Skip to content

feat(gateway): broker stable sandbox SPIFFE provider tokens - #4732

Open
drew wants to merge 19 commits into
mainfrom
feat/4731-stable-sandbox-spiffe/drew
Open

drew wants to merge 19 commits into
mainfrom
feat/4731-stable-sandbox-spiffe/drew

Conversation

@drew

@drew drew commented Oct 20, 2026 •

Copy link
Copy Markdown
Collaborator

Summary

Enable shared-supervisor Kubernetes sandboxes to obtain provider access tokens using stable sandbox SPIFFE identities. The gateway obtains sandbox JWT-SVIDs through SPIRE's experimental SPIFFE Broker API and performs provider-token exchanges. Supervisors authenticate with each sandbox generation's credentials and receive only final provider access tokens; workloads receive no SPIFFE socket or credentials.

Related Issue

Closes #4731

Changes

  • Add GetSandboxProviderAccessToken to the OpenShell service. Validate the signed session against persisted runtime generation, credential epoch, token lineage, and active state. Resolve provider attachment, credential key, endpoint, audience, and scopes from gateway configuration.
  • Derive <prefix>/gateway/<gateway-id>/sandbox/<sandbox-id> and request identity using the Sandbox resource's persisted Kubernetes UID. Callers cannot supply workload references or selectors.
  • Authenticate to the Broker over mTLS using fresh gateway X.509-SVID credentials from the CSI Workload API. Verify the Broker's certificate chain and exact configured SPIFFE identity through openshell-crypto, then verify returned JWT-SVID signatures, audience, expiry, and exact sandbox subject.
  • Perform RFC 7523 grants or both RFC 8693 exchange stages on the gateway. Bind cached access tokens to the sandbox generation, credential epoch, provider revision, configured grant, and resolved subject. Revalidate configuration and session authorization before serving cached or newly acquired tokens.
  • Reuse authenticated supervisor channels with bearer rotation and revocation checks. Bound identity acquisition at 10 seconds, each provider-token request at 30 seconds, the gateway operation at 120 seconds, and the supervisor operation at 135 seconds.
  • Separate shared SPIFFE types into openshell-spiffe and the Broker adapter into openshell-spire. Update published configuration docs, Helm guidance, troubleshooting, and integration fixtures.

Token flow

sequenceDiagram
    participant W as Sandbox workload
    participant S as Shared supervisor
    participant G as Gateway
    participant A as SPIRE Workload API
    participant B as SPIFFE Broker
    participant K as Kubernetes API
    participant T as Provider token service
    participant U as Upstream service

    W->>S: Request requiring provider credentials
    S->>G: Request token with sandbox session JWT
    G->>G: Verify session and active sandbox generation
    G->>G: Resolve attached provider and configured grant

    alt Valid cached token
        G->>G: Read token bound to sandbox, grant and subject
    else Cache miss
        G->>G: Derive stable SPIFFE ID and Sandbox UID
        G->>A: Fetch current gateway X.509-SVID and trust bundles
        A-->>G: Gateway credentials and bundles
        G->>B: Connect with mTLS and verify Broker identity
        G->>B: Request sandbox JWT-SVID using Sandbox UID
        B->>B: Check authorized broker identity
        B->>K: Attest Sandbox and check gateway authorization
        K-->>B: Attestation and authorization results
        B-->>G: Sandbox JWT-SVID
        G->>B: Fetch JWT verification bundles
        B-->>G: Bundles
        G->>G: Verify signature, audience, expiry and identity

        opt RFC 8693 token exchange
            G->>A: Fetch gateway JWT-SVID
            A-->>G: Gateway JWT-SVID
            G->>T: Exchange provider subject credential
            T-->>G: Intermediate token bound to sandbox identity
        end

        G->>T: Request provider token using sandbox JWT-SVID
        T-->>G: Provider access token
    end

    G->>G: Recheck configuration and session
    G-->>S: Final access token and remaining lifetime
    S->>U: Forward request with injected token
    U-->>S: Response
    S-->>W: Response
Loading

Configuration and scope

The feature is disabled unless [openshell.gateway.spiffe_broker] is configured; there is no compile-time feature flag. Gateway session JWTs with a positive TTL are required.

Operators must enable SPIRE's experimental Broker endpoint, authorize the gateway identity, configure Kubernetes attestation with access_policy = "enforced", and provision registrations for sandbox identities. The agent needs Sandbox lookup and SubjectAccessReview permissions; the gateway identity needs narrowly scoped impersonate-via-spire authorization. The configured server SPIFFE ID must match the Broker endpoint's agent certificate exactly.

The gateway uses a CSI Workload API mount. Shared supervisors and sandbox workloads require no SPIFFE mounts. RFC 8693 profiles also require the gateway's existing Workload API configuration for its component JWT-SVID (server.providerTokenGrants.spiffe.enabled=true in Helm).

This change supports Kubernetes shared supervision. It does not automatically provision SPIRE registrations or enable other compute drivers. Already-issued provider bearer tokens retain their normal expiration. Kubernetes Restricted Pod Security admission was validated; OpenShift restricted-v2 SCC compatibility has not been validated.

The public RPC adds a method to generated Rust server traits and the full TypeScript client interface; downstream handwritten implementations and mocks may require updates.

Connection pooling, broader cache improvements, generated upstream Broker bindings, and inclusion of the SPIRE fixture in default CI remain follow-ups.

Testing

Validation of the implementation at 17c8b7b2c:

  • 36 Kubernetes conformance tests passed.
  • Eight SPIFFE Broker/provider tests passed on both a fresh cluster and the retained development cluster, including credential rotation, supervisor failover, and stale-session fencing.
  • Configuration-disabled shared-supervisor coverage passed.
  • Eight independent real-SPIRE protocol checks covered successful issuance and rejection of unauthorized references, stale UIDs, unauthorized callers, incorrect peer identities, and untrusted certificate chains.
  • 284 focused Rust tests, 473 Helm tests, and 206 TypeScript SDK tests passed.
  • Formatting, Clippy, Helm lint, crypto dependency policy, and lockfile checks passed.
  • Required GitHub CI passed: Branch Checks and E2E. The GPU gate passed with the GPU tests skipped.

The subsequent commit 4532524dc only corrects troubleshooting advice and a test description; git diff --check passed.

@copy-pr-bot

copy-pr-bot Bot commented Oct 20, 2026

Copy link
Copy Markdown

Auto-sync is disabled for draft pull requests in this repository. Workflows must be run manually.

Contributors can view more details about this message here.

@drew
drew added this pull request to stack #4698 October 20, 2026 02:05
@github-actions

Copy link
Copy Markdown

@drew
drew force-pushed the feat/4731-stable-sandbox-spiffe/drew branch from db063a9 to 8dfbd78 Compare October 20, 2026 16:24
@drew
drew force-pushed the feat/4731-stable-sandbox-spiffe/drew branch 2 times, most recently from a876a1a to 437619a Compare October 20, 2026 18:39
@drew drew changed the title feat(supervisor): delegate stable sandbox SPIFFE identities feat(gateway): broker stable sandbox SPIFFE provider tokens Oct 20, 2026
@drew
drew force-pushed the feat/4731-stable-sandbox-spiffe/drew branch from 3da8000 to 5fbece5 Compare October 20, 2026 22:10
@drew
drew force-pushed the feat/4731-stable-sandbox-spiffe/drew branch from 5fbece5 to 1899b5b Compare October 20, 2026 22:38
@drew
drew force-pushed the feat/4731-stable-sandbox-spiffe/drew branch 2 times, most recently from 96ba1b7 to e0b6cec Compare October 20, 2026 22:53
@drew
drew force-pushed the feat/4731-stable-sandbox-spiffe/drew branch 3 times, most recently from b4c1940 to b733887 Compare October 21, 2026 00:20
@drew
drew force-pushed the feat/4731-stable-sandbox-spiffe/drew branch from b733887 to 8e6786b Compare October 21, 2026 00:55
@drew
drew force-pushed the feat/4731-stable-sandbox-spiffe/drew branch from 8e6786b to 6dd2cbb Compare October 21, 2026 01:05
@drew
drew force-pushed the feat/4731-stable-sandbox-spiffe/drew branch from 6dd2cbb to 85cba03 Compare October 21, 2026 01:48
@drew
drew force-pushed the feat/4731-stable-sandbox-spiffe/drew branch from a78134c to 03c6d6e Compare October 22, 2026 00:58
@drew
drew force-pushed the feat/4731-stable-sandbox-spiffe/drew branch from 6b0466e to 16f61f5 Compare October 23, 2026 21:28
@github-actions

Copy link
Copy Markdown

Compatibility review (advisory)

New or updated breaking changes; see the full report for all findings.

1. rust-sdk — No explicit risk acceptance found

GetSandboxProviderAccessToken adds a required get_sandbox_provider_access_token method to openshell_sdk::raw::proto::open_shell_server::OpenShell without a default implementation.

  • Impact: Existing mock and custom gateway server implementations fail with a missing trait item, while existing generated client callers remain compatible.
  • Action: Provide a default UNIMPLEMENTED implementation for get_sandbox_provider_access_token so existing server implementations compile unchanged on v0.1.6.
  • PR: feat(gateway): broker stable sandbox SPIFFE provider tokens #4732

2. go-sdk — No explicit risk acceptance found

openshellv1.OpenShellClient now requires GetSandboxProviderAccessToken in addition to its baseline method set.

  • Impact: Existing handwritten client mocks and adapters no longer satisfy OpenShellClient, while generated client callers and servers embedding UnimplementedOpenShellServer remain compatible.
  • Action: Preserve OpenShellClient's baseline method set and expose GetSandboxProviderAccessToken through a separate opt-in service or extended interface for v0.1.6.
  • PR: feat(gateway): broker stable sandbox SPIFFE provider tokens #4732

3. typescript-sdk — No explicit risk acceptance found

Regeneration makes getSandboxProviderAccessToken mandatory on the injected Client<typeof OpenShell> accepted by SandboxClient and SandboxTemplateClient constructors.

  • Impact: Existing complete baseline client mocks passed as the constructors' second argument fail TypeScript assignability checks because they lack getSandboxProviderAccessToken.
  • Action: Keep the constructors' baseline injectable client shape compatible by making the new capability optional or exposing it through a separate service for v0.1.6.
  • PR: feat(gateway): broker stable sandbox SPIFFE provider tokens #4732
Review details
  • Execution: complete
  • Candidate: PR #4732 (f28af9eb4e11df30e67446b6c610058f2825aad7)
  • Baseline: 92434dcb2b6248ac827df05c00551fe7a1fedf17 (92434dcb2b6248ac827df05c00551fe7a1fedf17)
  • Reviewed: rust-sdk, python-sdk, go-sdk, typescript-sdk, api-behavior, cli, configuration, policy, helm, state

Advisory review; publication gates are unchanged.

Branch check run

@grs

grs commented Oct 26, 2026

Copy link
Copy Markdown
Contributor

Looks good to me!

@akram

akram commented Oct 27, 2026 •

Copy link
Copy Markdown
Contributor

Team,

I second @EmilienM's review by adding my personal feedback based on testing this PR on OpenShift. The biggest issue I am facing is the required hostPath mount for the SPIRE admin socket (openshell.gateway.spiffe_delegation).

On OpenShift, SPIRE is deployed via the SPIFFE/SPIRE operator (ZTWIM), which does not expose the admin socket outside the agent pod. Even if it did, mounting it via hostPath requires the gateway to run under the privileged SCC, which is a no-go on OpenShift where restricted-v2 is the default and cannot be relaxed in managed environments (ROSA, ARO).

@github-actions

Copy link
Copy Markdown

This pull request has had no activity for 14 days and is now marked stale.

@github-actions github-actions Bot added the state:stale Inactive item at risk of automatic closure. label Nov 10, 2026
Signed-off-by: Taylor Mutch <taylormutch@gmail.com>
Preserve the shared supervisor pool and recovery implementation from main while wiring gateway-brokered sandbox identities into shared hosts. Refresh the public schema inventory, authentication fixtures, and affected test-workspace lockfiles.

Signed-off-by: Taylor Mutch <taylormutch@gmail.com>
Signed-off-by: Taylor Mutch <taylormutch@gmail.com>
Signed-off-by: Taylor Mutch <taylormutch@gmail.com>
Signed-off-by: Taylor Mutch <taylormutch@gmail.com>
Signed-off-by: Taylor Mutch <taylormutch@gmail.com>
Signed-off-by: Taylor Mutch <taylormutch@gmail.com>
Signed-off-by: Taylor Mutch <taylormutch@gmail.com>
@TaylorMutch

Copy link
Copy Markdown
Collaborator

@akram Following up on the OpenShift deployment concern: commits 89aad0f and 17c8b7b switch this implementation to the SPIFFE Broker API over mTLS.

The gateway obtains its own X.509-SVID through the CSI Workload API socket. It no longer mounts a hostPath or requires a supplemental group for SPIRE access. For sandbox issuance, it supplies the Sandbox CR UID from its persisted compute-runtime identity. SPIRE resolves and attests that object, checks the broker identity allowlist, and enforces scoped Kubernetes authorization through SubjectAccessReview / impersonate-via-spire.

Local validation passed 36 Kubernetes conformance tests and all 8 Broker/provider-token tests, including credential renewal, abrupt supervisor takeover, and stale-session rejection. The Broker suite also passed against the retained Helm dev deployment. The gateway Pod specification passed server-side dry-run admission in a namespace enforcing Kubernetes Restricted Pod Security.

OpenShift restricted-v2 SCC and ZTWIM integration remain unvalidated. The next deployment check is whether the installed operator/SPIRE version supports exposing the experimental Broker endpoint and configuring its allowlist, Kubernetes attestor, and RBAC. The Kubernetes Restricted admission result alone does not establish ROSA/ARO compatibility.

@TaylorMutch

Copy link
Copy Markdown
Collaborator

Following up on the compatibility advisory for the current head, 17c8b7b:

We are keeping GetSandboxProviderAccessToken on OpenShell for review, consistent with the related provider methods already on that service. The Broker API migration changes identity acquisition behind the gateway; it does not resolve the advisory's source-compatibility concerns about the added RPC.

The Rust generated server-trait requirement and TypeScript injected-client/mock shape still need reviewer disposition: either mitigation or explicit acceptance of the source break. The current TypeScript SDK CI task passes all 206 tests, but that does not prove compatibility with downstream handwritten mocks or server implementations.

The Go finding should be reevaluated against ai-openshell/sdk-go, where that SDK now lives. This branch contains no Go binding changes, and the original advisory targets an older head and v0.1.6 baseline.

Please reevaluate these findings against the current API/SDK baseline. Keeping the RPC on this service is the proposed API placement; compatibility risk acceptance remains a separate review decision.

@github-actions github-actions Bot removed the state:stale Inactive item at risk of automatic closure. label Nov 14, 2026
@purp purp added area:runtime Sandbox execution, isolation, supervision, policy enforcement, networking, and provider lifecycle. topic:api Public APIs, gRPC/protobuf, SDK interfaces, versioning, compatibility, and API design standards. topic:architecture System design, component boundaries, data/control flow, architectural decisions, and RFCs. topic:authnz Authentication, authorization, identity, sessions, credential protection, and policy integrity. topic:documentation Architecture docs, READMEs, project website updates, and automated documentation generation. topic:kubernetes Kubernetes operators, CRDs, deployment controllers, and native Kubernetes API integration. topic:operability Installing/configuring deployments, upgrades, backup/restore, diagnostics, and maintenance. labels Nov 15, 2026
Signed-off-by: Taylor Mutch <taylormutch@gmail.com>
Signed-off-by: Taylor Mutch <taylormutch@gmail.com>
Preserve the SPIFFE RPC alongside service discovery and update the combined public schema inventory without changing durable fingerprints.

Signed-off-by: Taylor Mutch <taylormutch@gmail.com>

@EmilienM EmilienM left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Another iteration needed: 4 major, 19 minor (inline, 1 below)

The Broker API rework removed the hostPath and node-coupling problems from round 1, and the cache-binding fixes hold up. The main problem now is that the Broker connection pins one SPIRE agent's ID, so the documented Service setup only works on a single-node cluster. The other majors are per-request costs on the shared-supervisor path (catalog scans, the global gRPC rate limiter) and the wire format of the new RPC's credential_key.

Outside the diff:

  • Minor: docs/how-it-works/providers/profiles.mdx:705, still says token grants need the sandbox supervisor's own Workload API socket, as do docs/kubernetes/access-control.mdx:37 and deploy/helm/openshell/README.md.gotmpl:535; a short note linking to the new Broker section would cover shared supervisors.
How this was reviewed
  • Commit d7b0c95, round 2: a full pass, since the branch was rebased after round 1's 9b60d8d
  • Deep review, because it touches AGENTS.md, .agents/skills/helm-dev-environment/SKILL.md and crates/openshell-core/src/dynamic_credential_key.rs
  • Passes: architecture, performance, security, scalability, rust, kubernetes and supply-chain, then correctness, then an advanced defensive review
  • Independent skeptics checked each candidate finding (3 with a reproducer for blocking and major ones, 2 for architecture and scalability ones, 1 for minor ones); 19 of 23 held up
  • Repo rules read from main: AGENTS.md, CLAUDE.md, CONTRIBUTING.md, docs/CONTRIBUTING.mdx
  • Not covered: nothing skipped

.dangerous()
.with_custom_certificate_verifier(openshell_crypto::tls::spiffe::server_verifier(
roots,
config.server_spiffe_id.clone(),

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Major: the verifier accepts exactly one agent SPIFFE ID, but the documented endpoint (spire-broker.spire.svc) is a Service over the agent DaemonSet, and each k8s_psat agent ID carries its own node UID. On a multi-node cluster most new connections land on another agent and fail the handshake as unavailable, and gateway replicas or a rescheduled gateway can't share one value. The e2e passes because kind has one node (with-kube-gateway.sh:659 pins items[0]). Either accept agents by a trust-domain path prefix or a set, or document and test one supported topology (node-local agent with a per-node ID) and make configuration.mdx, NOTES.txt and the skill row agree.

.await
.map_err(|_| token_grant_store_status())?
.ok_or_else(invalid)?;
let catalog = state

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Major: snapshot_catalog lists, normalizes and hashes every platform and workspace profile, and obtain calls grant_configuration twice per request (here and at :319), cache hits included. The shared supervisor calls this RPC for every proxied request, so gateway DB and CPU cost now scales with request rate times profile count. A point lookup of the one profile, or a catalog cached by catalog.revision() with the closing re-check comparing revisions, keeps the fail-closed checks without the scans.

&'a self,
request: TokenGrantRequest<'a>,
) -> Pin<Box<dyn Future<Output = Result<String, TokenGrantFailure>> + Send + 'a>> {
Box::pin(async move {

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Major: with no supervisor cache, every proxied request becomes a GetSandboxProviderAccessToken call, and they all go through the single process-wide GrpcRateLimiter (multiplex.rs:350). With grpc_rate_limit_* set, one busy sandbox can drain the bucket and every other sandbox, supervisor control RPC and CLI call gets RESOURCE_EXHAUSTED. I'm not reopening the per-request authorization choice from round 1. Exempting this RPC from the global limiter and giving it a per-sandbox limit (or at least documenting the interaction) would contain it.

Comment thread proto/openshell.proto
// session JWT. No caller-selected identity, endpoint, audience, or scope.
message GetSandboxProviderAccessTokenRequest {
// Endpoint-bound dynamic credential key supplied by gateway configuration.
string credential_key = 1;

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Major: credential_key carries the supervisor's internal tab-separated scoped key, rev:N and installation:X included, and the gateway reverse-parses it with unscoped_owned_key. That ties a public message to an internal delimiter format and the supervisor's cache-scoping scheme, so changing either becomes a wire break. Modelling the selector as fields (as ExchangeProviderSubjectTokenRequest does with provider + credential_key), or sending the unscoped configured key and documenting its format here, keeps the contract explicit.


/// The reference is derived only from the driver's immutable identity retained
/// by the gateway, not mutable workload labels or caller-provided selectors.
fn reference(runtime: &str) -> Result<WorkloadReference, TokenGrantFailure> {

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Minor: reference() re-parses the Kubernetes driver's private kubernetes://ns/uid/component encoding and repeats its CRD group and plural, and SandboxIdentityProvider::fetch_jwt_svid doesn't document runtime_identity. It fails closed, but a driver change would break issuance with no compile-time signal. A typed reference exported next to parse_kubernetes_runtime_identity gives it one owner.

.min(svid.expires_at.saturating_mul(1000))
.min(subject_expiry.unwrap_or(i64::MAX));
let serve_until_ms =
serve_until_ms(&token, ttl_override, obtained_at_ms, identity_expires_at_ms).ok_or_else(

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Minor: authorize accepts a session up to the 30 s leeway past exp, so a miss in that window runs the Broker fetch and token exchanges, then serve_until_ms returns None and the request fails as unclassified at token_endpoint. Checking session.expires_at against now before acquiring fails fast with an identity rejection instead.

let session = authority
.verify_gateway_token(bearer)
.map_err(|error| error.status)?;
if session.expires_at == 0 {

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Minor: sandboxes launched before gateway_jwt.ttl_secs was set hold exp = 0 bearers that are never renewed, so once an operator enables spiffe_broker they fail here until relaunched, while their other RPCs keep working. Worth a line in the configuration docs or a startup warning.

/// DNS names are not used for SPIFFE authentication. Revocation checking is
/// not enabled; deployments rely on short-lived SVIDs.
#[must_use]
pub fn server_verifier(roots: RootCertStore, expected: String) -> Arc<dyn ServerCertVerifier> {

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Minor: this verifier gates the Broker connection but has no unit tests for its failure paths (wrong URI SAN, extra URI SANs, missing SAN, untrusted chain). CRYPTO.md asks for failure-handling tests, and the probe-based checks don't run in CI.

Comment thread e2e/with-kube-gateway.sh
cleanup_vault_fixture
fi

cleanup_spire_fixture

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Minor: this uninstalls SPIRE, and its CSI driver with it, before the OpenShell release whose gateway and supervisor Pods mount csi.spiffe.io is removed. On an existing cluster those Pods and the namespace stay Terminating, and the next run hits "namespace is being terminated". Moving the call after the release and namespace teardown fixes it.

tonic = { workspace = true, features = ["channel", "tls-native-roots"] }
tonic-reflection = { workspace = true }
prost = { workspace = true }
tonic-prost = { workspace = true }

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Minor: tonic-prost is added here, but nothing in openshell-server uses it.

Suggested change
tonic-prost = { workspace = true }

This branch has not been deployed

No deployments
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

area:runtime Sandbox execution, isolation, supervision, policy enforcement, networking, and provider lifecycle. test:e2e Requires end-to-end coverage test:e2e-kubernetes Requires Kubernetes end-to-end coverage topic:api Public APIs, gRPC/protobuf, SDK interfaces, versioning, compatibility, and API design standards. topic:architecture System design, component boundaries, data/control flow, architectural decisions, and RFCs. topic:authnz Authentication, authorization, identity, sessions, credential protection, and policy integrity. topic:documentation Architecture docs, READMEs, project website updates, and automated documentation generation. topic:kubernetes Kubernetes operators, CRDs, deployment controllers, and native Kubernetes API integration. topic:operability Installing/configuring deployments, upgrades, backup/restore, diagnostics, and maintenance.

Projects

None yet

Development

Successfully merging this pull request may close these issues.

feat: delegate stable sandbox SPIFFE identities from the shared supervisor

6 participants