The Scope Creep Automated reviews of new AI-related working group submissions

Review · August 19, 2026

Identity Continuation Assertion for OAuth 2.0 Token Exchange

draft-mcguinness-oauth-id-continuation-assertion -00View on Datatracker →

Problem Statement

The spec solves a narrow but real problem: how to continue a user's delegated identity across a chain of services when each service uses pairwise (audience-local) subject identifiers that only the IdP can resolve. When a user's request passes through multiple services after the user has left (e.g., expense → travel → booking APIs), downstream workloads can't directly name the user for the next audience — only the IdP holds that mapping. This makes each cross-service hop a fresh IdP mint rather than a simple pass-through or offline token attenuation.

How the Spec Fits In

This is a profile/extension of Token Exchange (RFC8693) and ID-JAG (draft-ietf-oauth-identity-assertion-authz-grant) specifically for pairwise-subject chaining. It layers heavily on top of several OAuth specs:

Depends on:

  • RFC8693 (Token Exchange) — the core exchange mechanism
  • RFC9449 (DPoP) — mandatory proof-of-possession method
  • RFC8707 (Resource Indicators)
  • RFC9396 (RAR)
  • I-D.ietf-oauth-identity-assertion-authz-grant (ID-JAG) — the draft being profiled
  • I-D.ietf-oauth-transaction-tokens — for intra-domain context propagation
  • RFC7519 (JWT), RFC7638 (JWK Thumbprint), RFC7800 (PoP Key Semantics), RFC8725 (JWT BCP)

New concepts introduced:

  • Identity Continuation Assertion — a new short-lived, sender-constrained JWT token type used as the subject_token in a Token Exchange request
  • identity_continuation_handle — a new JWT claim embedded in ID-JAGs to enable subsequent continuation
  • Chain Authority (CA) — a new trusted role that attests the accepted hop, current actor, and key before the IdP will mint the next ID-JAG
  • Hop state machine (PENDING → ACCEPTED → CONTINUABLE) — a new lifecycle model for tracking chain progress
  • invalid_continuation — new OAuth error code
  • identity_continuation_supported — new AS metadata field
  • New grant profile URI — urn:ietf:params:oauth:grant-profile:id-jag-continuation

This is a significant new behavior addition. The Chain Authority role in particular creates a new trust relationship and deployment component. The spec explicitly separates concerns: IdP owns the root envelope and hop tree, RAS binds accepted hops, TTS propagates intra-domain context, and the Chain Authority attests actor-to-hop binding. The security model is well-reasoned with explicit blast-radius analysis for various compromise scenarios.

Key design choice: DPoP is the single mandatory confirmation method. mTLS is listed as an open question for WG discussion.

Relationship to Liu's chain delegation draft: Whereas Liu's draft (draft-liu-oauth-chain-delegation) focuses on general token chaining with propagation tokens, this draft specifically addresses the pairwise-subject boundary problem by routing all cross-boundary hops through the IdP. The two drafts are somewhat complementary — this spec acknowledges that offline attenuation (Liu's approach) is appropriate intra-domain, while IdP-routed continuation handles the cross-boundary pairwise-subject case.

High-Level Summary

When a user logs in and kicks off a business process — say, submitting an expense report — that request may need to travel through several backend services before it's done: expense service calls a travel service, which calls a booking service. Each service is protected by its own authorization server, and each uses a different internal identifier for the same user.

The problem today is that each service can't simply hand the user's identity to the next one, because the next service's authorization server (the IdP) uses a different, private identifier for that user — one only the IdP knows. Without a defined protocol, the chain breaks, or developers build ad-hoc workarounds.

What this spec defines: A formal handoff mechanism for exactly this scenario, built on top of existing OAuth standards. Here's how the players interact:

  1. IdP (Identity Provider): The central authority. It authenticates the user at the start, and every time the request crosses a service boundary, it issues a fresh authorization grant for the next service — using that service's private identifier for the user. The IdP is the only party that can do this translation.

  2. Resource Authorization Server (RAS): Each service has its own RAS that checks whether an incoming request is authorized. When it accepts an authorization grant, it records a "handle" — an opaque token that proves the hop happened and was accepted.

  3. Chain Authority: A new trusted component (can be co-located with the RAS) that vouches to the IdP: "yes, this service accepted the previous hop, and this specific workload is making the request with this specific key." This attestation is what the IdP requires before it will issue the next grant.

  4. Transaction Token Service (TTS): Within a single organization's services, a TTS can propagate the chain context so that multiple internal components can act on the user's behalf without each going back to the IdP separately.

The result is an auditable, revocable chain of delegations: the IdP can see the full hop graph, can revoke any branch, and enforces that no service in the chain can escalate the original user's permissions or forge the user's identity. If the user logs out or revokes access, the chain stops at the next hop.

The key constraint this solves: Services that use pairwise (audience-local) identifiers — where Service A's ID for a user is completely different from Service B's ID for the same user, and only the IdP knows both — can't do this delegation without going back to the IdP at each step. This spec standardizes how to do that in a secure, interoperable way.

Writing Quality

The spec is well-written by IETF standards, particularly for an individual draft at version -00. It uses proper RFC 2119 normative language (MUST, SHOULD, MAY) consistently and correctly throughout. The document structure follows standard IETF conventions: abstract, introduction, definitions, protocol overview, detailed sections, security considerations, privacy considerations, and IANA considerations.

Sentence and prose quality: High. The prose is technically dense but grammatically sound and precise. Ambiguity is rare — claims are stated with explicit carve-outs ("MUST NOT accept unless all hold," "exactly one audience and one resource"). The blast-radius analysis table in Section 11.8 is a standout example of clear security reasoning.

Length and conciseness: The spec is on the longer end for an individual draft. It introduces many new concepts (Chain Authority, hop state machine, root-chain envelope, governing authorization, etc.), and the thoroughness required to specify these correctly drives the length. The appendices with design rationale (why not a Transaction Token? why not a Cross-Domain Propagation Token?) are genuinely useful and not padding. The 16-rule validation section is verbose but arguably necessary given the security requirements. There is some repetition between the overview and the detailed sections, and the definitions section is extensive — a shorter glossary might improve accessibility without losing precision.

Overall: This reads like a mature, production-quality spec from an experienced technical writer who understands IETF conventions. The level of detail is appropriate for the complexity of the problem, though a future revision might benefit from a shorter introductory profile that builds up to the full machinery.

Author Background

Karl McGuinness ([email protected]), Independent

  • RFCs published: 0
  • New author? No — not a new IETF participant. He has 17 active Internet-Drafts, indicating very high writing activity. His draft draft-ietf-oauth-identity-assertion-authz-grant (the ID-JAG spec that this draft builds on) has been adopted as an official WG document, which is a significant signal of IETF engagement and credibility within the OAuth WG.
  • Active writing: Yes, extremely active — 17 active drafts across OAuth token exchange, AI agent identity, actor proofs, and resource authorization topics.

Notable: The same author is shepherding both ID-JAG (the base spec) and this continuation profile. This creates strong coherence between the two specs but also means both depend on one person's design vision advancing through the WG.

Assessment

General direction: Yes, this is a sound direction for enterprise and agentic AI use cases.

The problem is real and well-scoped. The spec is notably more rigorous than many individual drafts, with explicit security analysis, a formal state machine, and 16 detailed validation rules. The design rationale appendix honestly explains why alternative approaches (transaction tokens, pull-model introspection, cross-domain propagation tokens) were rejected or scoped differently.

Strengths:

  • Clear scoping: explicit about when to use this vs. offline attenuation
  • Strong security model with conjunctive trust (CA + actor issuer + DPoP + IdP envelope bounds every action)
  • Builds on already-WG-adopted ID-JAG spec from the same author
  • Replay protection is well-designed (atomic RESERVED/ISSUED state machine)

Questions worth raising:

  1. Is the Chain Authority really a separate role? (See extended discussion below.)
  2. ID-JAG dependency risk: This spec depends entirely on ID-JAG, which is still a WG draft (not an RFC). If ID-JAG changes significantly, this profile needs updates. Worth noting the ordering dependency.
  3. Complexity vs. adoption: The deployment model requires coordination among IdP, RAS, TTS, and Chain Authority — four distinct trust-domain components. Is there a simpler baseline profile that covers 80% of use cases?
  4. Pairwise subject assumption: The spec is clear this is for pairwise-subject deployments, but many enterprise deployments use stable global subjects (e.g., an enterprise email). The spec correctly defers those cases to offline attenuation, but the WG may want guidance on which approach to recommend when both apply.

Deep Dive: Should the Chain Authority Be In Scope?

The Chain Authority is the most architecturally novel concept in the spec — and arguably the one most worth questioning. The spec already acknowledges that "one operator MAY run the RAS, TTS, and Chain Authority," which raises the question: should the CA be a separate role in this spec at all, or should it be left as an optional future extension?

What the Chain Authority actually does: After the RAS accepts and binds a hop, the CA signs the Identity Continuation Assertion, attesting to the IdP that (a) the hop was accepted, (b) the current actor is who they claim to be, and (c) that actor controls the key in the cnf claim. This attestation is what the IdP requires before minting the next ID-JAG.

The extensibility hook is already in the token. The assertion's iss claim is already structurally separate from the RAS's issuer. The spec's own example uses https://ca.expenses.example/ as the CA issuer versus https://expenses.example/ as the RAS. This means the token format already supports a separate CA without any changes — the iss value is simply the signal the IdP uses to determine which trusted party signed the assertion.

A simpler baseline: The spec could instead define the default case as the RAS issuing the continuation assertion itself (iss = RAS issuer), with the IdP trusting that issuer for hops accepted by that RAS. Operators who want a dedicated CA for defense-in-depth could configure a separate trusted issuer — same token format, same IdP validation rules, just different trust configuration. This would:

  • Remove the Chain Authority as a distinct named role from the spec
  • Collapse Sections 5.4 (CA Issuance requirements) and 9 (RAS requirements) — the RAS simply does both
  • Simplify the CONTINUABLE hop state, which currently represents "a CA has freshly attested this accepted hop" as distinct from ACCEPTED
  • Reduce the IdP's trust configuration surface from "CA issuer mapped to RAS" to just "trusted issuers per RAS"

What would be given up: The explicit defense-in-depth separation. In the current model, a compromised RAS cannot unilaterally fabricate continuation assertions — those must also come from a separately trusted CA. That's a real security benefit for high-security deployments. However, the spec's own blast-radius analysis already shows that "RAS + TTS + Chain Authority" compromise is still bounded by the root-chain envelope, so the envelope — not the CA separation — is the ultimate security backstop.

The modularity argument: Leaving the CA out of scope (with the iss claim as the natural extension point) makes this spec a better building block. It lowers the barrier to adoption significantly — an implementer needs to build and operate two components (RAS and IdP support) rather than four (RAS, CA, TTS, IdP). The advanced CA separation becomes an interoperability profile that a future spec or deployment guide can define, rather than a normative requirement in the base spec.

This seems like a question worth raising directly with the author: was the CA modeled as a required distinct role intentionally (e.g., to enforce separation in high-security deployments), or could it be scoped out in favor of the simpler RAS-as-issuer baseline with an extension point?