Join our Newsletter — 33% off our NHI Course
Home› Guides› OpenID Federation and Trust Chains Guide: Building Multilateral…
Guide Authorisation

OpenID Federation and Trust Chains Guide: Building Multilateral OAuth and OIDC Trust Safely

PDF for newsletter subscribers · free to read online

← All guides
By NHI Mgmt Group, edited by Lalit Choda Updated 27 October 2026 15 min read
On this page

Bilateral OAuth and OpenID Connect registration does not scale when thousands of identity providers, relying parties and services need to trust each other, and the usual workarounds (shared metadata files, open dynamic registration) either go stale or trust too much. OpenID Federation 1.0 addresses this with signed, chained statements that let any participant verify another back to a Trust Anchor it already trusts, and apply the federation's policy to the other party's metadata. This guide explains how trust chains, metadata policy, constraints and Trust Marks work, where the specification is used today in education and national eID, how it relates to the EUDI Wallet trust model, and how to operate a federation or join one securely. It is for identity architects, federation operators and engineers building OpenID Providers, relying parties and OAuth clients. It assumes you know the basics in the OAuth 2.0 and OpenID Connect Guide.

Key takeaways

  • It is now a Final specification. The OpenID Foundation published OpenID Federation 1.0 as Final on 17 February 2026, so implementations can target a stable text (status checked 27 October 2026).
  • Trust is rooted only in the Trust Anchor. A participant should directly trust no party except the Trust Anchor; everything else is proved by a chain of signed Entity Statements.
  • Policy flows down and can only tighten. Superiors can constrain a subordinate's metadata and the shape of the chain, and a conflicting policy makes the chain invalid.
  • Expiry replaces revocation. The specification defines no revocation process, so short statement lifetimes and frequent chain refresh are your removal mechanism.
  • The federation keys are crown jewels. Whoever holds a Trust Anchor or Intermediate signing key can enrol entities and rewrite their metadata, so treat these as high-value non-human credentials.

Core concepts

OpenID Federation defines a trust layer that sits beside OpenID Connect and OAuth 2.0. The building blocks are signed JWTs:

TermWhat it isWho publishes it
EntityAny participant, identified by an Entity Identifier (an HTTPS URL)n/a
Entity ConfigurationAn Entity Statement an entity issues about itself, with its federation signing keys, metadata and authority_hints pointing to its Immediate Superiors. Published at /.well-known/openid-federationEvery entity, including the Trust Anchor
Subordinate StatementAn Entity Statement a superior issues about an Immediate Subordinate, carrying the subordinate's keys and optionally metadata, metadata_policy and constraintsTrust Anchor or Intermediate, via its fetch endpoint
Trust AnchorThe trusted third party at the root of a federationFederation operator
Intermediate EntityAn entity between the Trust Anchor and the subject, such as a national federation inside an interfederation, or an aggregatorDelegated operator
Leaf EntityAn entity with no subordinates, usually an OpenID Provider, relying party, OAuth client, authorisation server or protected resourceService owner
Trust ChainAn ordered set of statements from the subject's Entity Configuration to the Trust Anchor; each issuer is the next statement's subject and signs with a key published in the next statementAssembled by the verifier or a resolver
Trust MarkA signed statement from an accreditation authority that an entity conforms to a defined set of requirements, identified by a Trust Mark typeTrust Mark issuer listed by the Trust Anchor

All Entity Statements must carry the JOSE header typ value entity-statement+jwt, and statements without it must be rejected. Trust Marks use trust-mark+jwt and signed JWK Sets use jwk-set+jwt. Explicit typing is there to prevent one kind of JWT being accepted as another. See the JWT Security Guide.

How a trust chain is resolved and validated

  1. Fetch the subject's Entity Configuration from its Entity Identifier plus /.well-known/openid-federation, and read its authority_hints.
  2. Walk upwards: fetch each superior's Entity Configuration, then call the superior's fetch endpoint for the Subordinate Statement about the entity below. Repeat until you reach a Trust Anchor you already hold keys for.
  3. Verify every link: each statement's signature must verify with a key published in the statement above it, ending in the Trust Anchor key you configured out of band. Check iat and exp on every statement, with limited clock skew.
  4. Apply constraints: check max_path_length, naming_constraints and allowed_entity_types from each Subordinate Statement. Any failed constraint invalidates the chain.
  5. Apply metadata policy: combine the policies from every superior, top down, then apply them to the subject's metadata to get the resolved metadata you will actually use.
  6. Evaluate Trust Marks if your federation requires them, checking that each issuer is listed in the Trust Anchor's trust_mark_issuers.
  7. Cache until expiry: the chain's expiry is the minimum exp of all statements in it. Participants must support refreshing a chain when it expires.

If several valid chains exist, the specification suggests preferring the shorter one, subject to local policy. Instead of resolving chains itself, an entity can call another entity's resolve endpoint, but it is then trusting that resolver to validate correctly.

Metadata policy and constraints

Metadata policy is what makes a federation enforceable rather than a directory. Policies are bound to an Entity Type (for example openid_relying_party) and expressed per metadata parameter using operators:

OperatorEffectTypical federation use
valueForces the parameter to a fixed valueSet a required token endpoint authentication method
addAdds values to an array parameterAdd a mandatory contact or scope
defaultSupplies a value if the parameter is absentDefault signing algorithm
one_ofValue must be one of a setRestrict id_token_signed_response_alg to approved algorithms
subset_ofArray values are reduced to those in the setLimit grant types or response types
superset_ofArray must contain at least these valuesRequire support for a mandatory feature
essentialParameter must be presentRequire jwks or a logo for user interfaces

All superiors in a chain contribute policy on an equal basis, but the combined policy must be logically sound: an Intermediate can further restrict what its superiors specified, and an Intermediate that introduces a conflict causes the chain to be invalid. A superior may also state metadata directly in a Subordinate Statement, which overrides identically named values in the subject's own configuration for that subject only. Federations that add their own operators list them in metadata_policy_crit, which an implementation must understand or reject.

Constraints shape the chain itself:

  • max_path_length: the maximum number of Intermediates allowed between the entity setting the constraint and the subject. Zero means no Intermediates.
  • naming_constraints: permitted and excluded URI namespaces for subordinate Entity Identifiers, using the RFC 5280 domain name constraint syntax. Excluded always wins.
  • allowed_entity_types: which Entity Types subordinates may have. Types not listed are removed from the subject's metadata during resolution; federation_entity is always allowed.

Use constraints to stop an Intermediate from enrolling entities outside its remit, for example a university federation that should only enrol hosts under its own domains, or an aggregator that should only onboard relying parties and never OpenID Providers.

Client registration in a federation

AspectAutomatic registrationExplicit registration
Prior stepNone: the RP sends an authentication request directlyRP registers at the OP's federation registration endpoint first
Client IDThe RP's Entity IdentifierAssigned by the OP
Client authenticationAsymmetric cryptography is mandatory; no client secret is issuedAs agreed; the OP returns a signed registration response
Trust evaluationOP resolves the RP's chain at request time (or uses a chain the RP supplies)OP resolves the chain at registration and stores the result
Good fitLarge open ecosystems, many RPs, little coordinationOPs that need a registration record, quotas or manual approval

In both cases the RP must resolve the OP's chain before sending a request and must stop if resolution fails. The same methods work for plain OAuth 2.0 using the oauth_client and oauth_authorization_server Entity Types. Compared with open RFC 7591 dynamic registration, federation registration ties every client to an accountable superior and policy. See the OAuth Dynamic Client Registration Security Guide.

Where it is used: education, national eID and wallets

  • Italian SPID and CIE id: Italy's public digital identity systems adopt OpenID Connect Core, the iGov profile and OpenID Connect Federation. In the published technical rules, the Trust Anchors are AgID for SPID and the Ministry of the Interior for CIE id, Intermediates (soggetti aggregatori) onboard service providers, and Trust Marks issued by the Trust Anchor, Intermediates or attribute authorities are required for an entity to be recognised as a member.
  • Research and education: GÉANT reported in June 2026 that eduGAIN connects more than 10,000 identity and service providers across 84 member federations, and is running a pilot under the GN5-2 project to test OpenID Federation as the future trust technology for eduGAIN, in parallel with the current SAML setup. The specification's own examples model a university, a national federation and eduGAIN as a three-level chain.
  • EUDI Wallets: the EUDI Architecture and Reference Framework trust model rests on Registrars, access certificates, registration certificates and Trusted Lists, with an X.509 PKI (RFC 5280) for PIDs, qualified attestations and public body attestations; it notes non-qualified attestations may adopt alternative trust models. OpenID Federation is therefore not the ARF baseline trust mechanism for wallets (checked against the ARF main branch on 27 October 2026), although it is being explored for adjacent ecosystems. See the EUDI Wallet Architecture and Reference Framework Guide.
Trust approachHow trust is distributedPolicy enforcementRemoval
Bilateral OIDC registrationConfigured per pairManual, per OPDelete the client
SAML metadata aggregateOperator signs a file listing all entitiesRegistration practice, metadata filteringDrop from next aggregate; consumers must refresh
Open dynamic registration (RFC 7591)Anyone can registerOP side onlyOP deletes the client
OpenID FederationSigned hierarchical chains to a Trust AnchorMetadata policy, constraints, Trust MarksStop issuing statements; chain expires
X.509 trusted lists (EUDI ARF)Trusted list of CAs and providers, certificates per entityRegistration and certificate profilesCertificate revocation, list updates

Operating a federation securely

The Trust Anchor and Intermediate signing keys can enrol new entities and rewrite metadata, including redirect URIs and keys, for any subordinate. That makes them the highest-value secrets in the system and a target comparable to a SAML or token signing key (MITRE ATT&CK T1552.004 Private Keys; T1606 Forge Web Credentials).

  • Protect federation keys in hardware: HSM-backed signing for Trust Anchor and Intermediate keys, separate from protocol keys (for example ID Token signing keys), with dual control for key ceremonies. See the JSON Web Key Sets (JWKS) and Signing Key Rotation Guide.
  • Roll keys as the specification describes: publish the new key in the Entity Configuration, keep signing with the old key long enough for subordinates to pick up the new one, switch, then remove the old key. The historical keys endpoint lets verifiers check statements signed with retired keys.
  • Distribute Trust Anchor keys independently: the specification recommends federation operators offer a way to retrieve Trust Anchor public keys that does not depend on the Trust Anchor's Entity Configuration, as protection against a Web PKI compromise, and that participants compare the two.
  • Set lifetimes deliberately: because there is no revocation process, the exp on Subordinate Statements is how quickly a removed or compromised entity stops being trusted. Short lifetimes mean faster removal but more load on fetch endpoints.
  • Use constraints on every Intermediate: naming_constraints and allowed_entity_types limit the damage a compromised or careless Intermediate can do.
  • Harden federation endpoints against propagation attacks: the specification warns that resolve, automatic registration and explicit registration can be abused to make a server issue many outbound requests, for example through hundreds of fake authority_hints. Limit how many hints you follow, prefer static trust chains supplied in requests, and have the resolve endpoint answer unauthenticated clients only from cache.
  • Mind privacy: fetch and Trust Mark status calls can reveal who is evaluating whom. Short-lived Trust Marks and static, short-lived chains reduce real-time lookups. Keep Entity Statements to organisational information; the specification says they are not a substitute for KYC or AML platforms.

Implementation roadmap

  1. Define governance first: who runs the Trust Anchor, onboarding criteria, Trust Mark types and their issuers, statement lifetimes, incident and removal procedures.
  2. Design the hierarchy: the minimum number of levels, with constraints for each Intermediate. Model the interfederation case if a national federation will also sit under a larger one.
  3. Write the metadata policy: approved algorithms, mandatory client authentication methods, required contacts and logos, allowed grant and response types.
  4. Pilot alongside existing trust: run federation resolution in parallel with existing SAML metadata or bilateral registration, as eduGAIN is doing, and compare resolved metadata against what each party has configured today.
  5. Test failure paths: expired statements, conflicting policies, a broken intermediate, key rollover, fetch endpoint outage and a removed entity. Each must fail closed.
  6. Go live by cohort, with rollback to the previous registration method for each cohort until chain refresh and monitoring are proven.

Decision guidance: a small group of known partners rarely needs a federation; bilateral registration with private key JWT client authentication is simpler. Federation pays off when there are many parties, several administrative domains, delegated onboarding or a need for verifiable accreditation. Automatic registration suits very large RP populations; explicit registration suits OPs that want a record and approval. For workload and CI/CD token exchange, a different pattern applies. See the GitHub Actions OIDC Federation Hardening Guide.

Detection and measurement

  • Log every resolution: subject, Trust Anchor used, chain length, resolved metadata hash, Trust Marks evaluated and outcome.
  • Alert on change: new Subordinate Statements, changed keys for an existing entity, changed redirect URIs in resolved metadata, and new Trust Mark issuers in the Trust Anchor configuration (ATT&CK T1484.002 Trust Modification is the analogous enterprise technique).
  • Watch endpoint load: spikes on resolve, fetch and registration endpoints, and requests with unusually many authority_hints.

Metrics:

  • Time from removal decision to the last valid chain expiring for that entity.
  • Percentage of chain resolutions that fail, by reason (expiry, signature, policy conflict, constraint).
  • Age of the oldest federation signing key in use against the rollover policy.
  • Percentage of Leaf Entities holding the Trust Marks the federation requires.
  • Resolution latency at the 95th percentile on the OP side.

Framework mapping

AreaNIST CSF 2.0NIST SP 800-53 Rev. 5ISO/IEC 27001:2022 Annex A
Entity identities and keysPR.AA-01, PR.AA-03IA-5, IA-8A.5.16, A.5.17
Federation signing key managementPR.DS-02SC-12, SC-17A.8.24
Agreements and onboarding of membersGV.SC-04CA-3, AC-20, SR-6A.5.14, A.5.19, A.5.20
Inventory of trust relationshipsID.AM-03CA-3A.5.9
Change control of policy and statementsPR.PS-01CM-3A.8.32
Endpoint abuse and input handlingDE.CM-06SC-5, SI-10A.8.20

Common failure patterns

  • Trusting a valid signature without checking scope: in the Microsoft Storm-0558 key breach, a stolen consumer signing key was accepted for enterprise mailboxes because issuer and key scope were not validated. In a federation, verify the full chain to your configured Trust Anchor and apply policy, never just the leaf signature.
  • Long statement lifetimes: Subordinate Statements valid for months mean a removed member keeps working for months, because there is no revocation to fall back on.
  • Unconstrained Intermediates: an aggregator that can enrol any Entity Type under any domain becomes a path to register a rogue OpenID Provider.
  • Federation keys handled like protocol keys: Trust Anchor keys on general web servers, without dual control or rehearsed rollover.
  • Open resolve endpoints: unauthenticated resolve or registration that performs live discovery for every request, which the specification identifies as a propagation and denial of service vector.
  • Using a third-party resolver blindly: relying on another entity's resolve endpoint transfers your validation to them; do it only with a resolver you trust and can audit.

Practitioner checklist

  • Target OpenID Federation 1.0 Final (17 February 2026) and record the version in your interoperability profile.
  • Configure Trust Anchor keys out of band and compare them with an independent source.
  • Reject any Entity Statement without typ entity-statement+jwt, and validate iat and exp on every link.
  • Apply constraints and combined metadata policy, and fail closed on any conflict.
  • Set Subordinate Statement lifetimes from your required removal time, and refresh chains on expiry.
  • Keep federation signing keys in HSMs with dual control and a rehearsed rollover.
  • Constrain every Intermediate by naming and Entity Type.
  • Limit authority_hints processing and serve unauthenticated resolve requests from cache.
  • Log resolutions and alert on new subordinates, key changes and redirect URI changes.

Standards and references

Related NHI Mgmt Group resources: OAuth 2.0 and OpenID Connect Guide · Federation and Trust Relationships Guide · NIST SP 800-63C-4 Federation Assurance Levels Guide · JSON Web Key Sets (JWKS) and Signing Key Rotation Guide · EUDI Wallet Architecture and Reference Framework Guide

PDF for subscribers

Take this guide with you

Every section, table and checklist in one PDF, with links to the sources and related guides. Subscribe to our weekly NHI & AI Identity Journal and we’ll email you a download link.

Free weekly newsletter

Subscribe to the NHI & AI Identity Journal

The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.

Bonus 33% off our NHI Course when you subscribe.

NHIMG Editorial Note
Researched and written by the NHI Mgmt Group editorial team using AI tools, under the editorial direction of Lalit Choda. Facts are drawn from the sources listed on this page and checked by our automated quality process. Last updated 27 October 2026. Spotted an error? Use our contact page.
NHI Mgmt Group, the independent authority on Non-Human Identity, IAM and Agentic AI security. nhimg.org

PDF Downloads for Newsletter Subscribers

Get the guide

Enter your details and we’ll email you a download link.

The full guide is free to read online. The PDF is a thank you for subscribing.

Fill in all fields marked * and tick the PDF box to continue.