Review · September 2, 2026
AuthZEN Binding for OAuth 2.0 Token Exchange
RFC 8693 conditions a successful token exchange on the request meeting "all policy and other criteria of the authorization server." It defines neither. Identity chaining, the identity assertion grant, and transaction tokens all build on token exchange and inherit the same gap.
This is the third draft in a series. The issuance profile does the general work of turning a token request into an AuthZEN policy evaluation. This one handles the family of flows that profile can't, because token exchange has something no other grant has: a second party.
That's the whole idea, and it's a good one. An ordinary issuance decision asks what a subject may get. An exchange asks what a requesting party may get as, or on behalf of, a subject. The draft gives the second privilege its own evaluation tuple. Two gate tuples, both of which must be permitted:
- the subject gate asks whether a token of this kind may exist for this subject and target at all
- the requesting party gate asks whether this party may be the one to obtain it
Section 10.1 makes the case for why the second one matters. An impersonation exchange produces a token indistinguishable from one issued to the subject directly. No downstream resource server can tell that a gateway obtained it. If the AS doesn't evaluate the requesting party at exchange time, nobody ever does. "Client authentication establishes who is asking; it does not establish that they may ask for this."
Section 4.3.3 then refuses to let may_act stand in for that gate. may_act is an assertion the issuer made when the subject token was minted; the gate is a decision made at exchange time. Substituting one for the other reintroduces exactly the staleness that calling a PDP was supposed to fix. Also right.
How this fits with the working group's existing work
Same venue question as the issuance draft, and it's sharper here. Nothing on the OAuth wire changes. Every error the binding produces is an existing error code. The two parties that need to interoperate are an authorization server and its policy engine, and the normative dependency runs to the OpenID Foundation's Authorization API 1.0 plus draft-gazitt-oauth-authzen-issuance, which is itself an unadopted individual draft. You can't review this document on its own. Roughly half the normative content is by reference.
There's a sequencing problem on top of that. Of the four specifications it profiles, only RFC 8693 is finished. Identity chaining, ID-JAG, and transaction tokens are all in progress, and all three are cited informatively while the document specifies normative behavior for them. Section 11.1 asks IANA to register short names for id-jag and txn_token, then adds an Editor's note admitting those token type URIs don't exist yet because the documents requesting them are unfinished.
Dependency count is otherwise small. Normative on RFC 6749, 8693, and 8707 plus AuthZEN and the issuance profile.
The action name for ID-JAG redemption isn't defined
This is the sharpest interop problem in the document.
Section 3 puts two kinds of request in scope: token exchange, and "the assertion grants used to redeem an ID-JAG." Section 4.3 then says the action name is issue:<token-type>:token_exchange, and that "the grant segment is token_exchange throughout, since that is the grant this binding applies to."
ID-JAG redemption isn't token exchange. The ID-JAG draft redeems with grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer, or urn:ietf:params:oauth:grant-type:jwt-dpop when the client wants a DPoP-bound token back. The issuance profile registers a jwt_bearer grant short name in its own table. It registers nothing for jwt-dpop.
So an implementer reading Section 5.3's redemption paragraph has three candidate action names and the document commits to none: issue:access_token:token_exchange from Section 4.3's "throughout," issue:access_token:jwt_bearer from the registry, or something not yet registered for the DPoP variant. The action name is the one field that has to match between an AS and a PDP for policy to port anywhere. Two conforming implementations picking differently means the policy an operator wrote for one doesn't load into the other.
One other thing in that section: "The application's authorization server presents the ID-JAG as an assertion grant" has the roles reversed. The client presents the ID-JAG to that server.
Scope tuples at level 1 aren't explained
Section 4.4.1 is the other structural addition. Where an artifact's own audience differs from the audience of the access it describes, the AS evaluates at two levels. Level 1 sets resource.id to the consumer of the artifact, a peer authorization server. Level 2 sets it to each RFC 8707 resource. Gate tuples appear only at level 1. Authorization detail tuples only at level 2. Scope tuples at both.
Why both? Section 4.3.4 says a scope tuple asks whether the subject may exercise that scope at that target, and the level-1 target is an authorization server, not an API. "May Alice exercise files.read at as.app.example" doesn't obviously mean anything, and the document never says what a PDP should do with it. Every other rule here is derived from something. This one is asserted. Either it duplicates the level-2 tuples or it asks a different question, and the reader can't tell which.
The intersection rule sitting underneath it is well argued by comparison. A scope denied at any single level-2 resource is dropped everywhere, because an ID-JAG carries the resources in a resource claim and the scopes in a flat scope claim with no pairing between them. A per-resource denial would be invisible by the time the grant is redeemed, and the resource authorization server could grant it anyway. Deployments that need per-resource differences issue one ID-JAG per resource or use authorization_details, where the location is part of the cell. That's a good derivation and it replaced a weaker one.
audience and resource in a single-level exchange
Section 4.4 says the issuance target comes from the audience parameter, "or a resource parameter in the sense of RFC 8707." Two parameters feeding one field. Section 4.4.1 then splits them, with audience becoming level 1 and resource becoming level 2.
RFC 8693 lets a request carry both. For a plain access token exchange that does, the document has no answer. Two-level evaluation applies "where the two differ," which reads as a property of the token type in Section 5.3 and as a property of the request parameters in Section 4.4.1. An AS that treats audience plus resource on an ordinary access token exchange as two-level and one that treats it as single-level will send structurally different batches for identical client requests.
The context table is advisory and mostly could go
Six keys in Section 4.5, all SHOULD, all explicitly advisory, sitting under a MUST that a PDP be able to render a decision from the five-tuple alone. By the draft's own design rule they don't affect interoperability, so most of the table could come out.
Two things in it are worth keeping. The reason requested_token_type is excluded is one sentence and a good one: it's already the token type segment of the action name, and putting it in two places gives a PDP a way to disagree with itself. And the MUST NOT on placing raw token strings in context is a real requirement with the right justification, that the subject token may carry claims about a party who hasn't authorized their disclosure to the PDP.
The subject_token key needs work either way. It's defined as "selected validated claims of the subject token, such as iss, acr, amr, and auth_time." "Such as" isn't a definition, and the key overlaps act and may_act, which get their own rows while also being claims of the subject token. Enumerate the set or drop the key, since "advisory" already lets a deployment convey whatever it wants.
invalid_scope discloses what the gate mapping hides
Section 7 maps a subject gate denial and a requesting party gate denial both to invalid_request, and says why: the difference tells the requesting party whether its own authority or the subject's was lacking, and that's information about the subject the requesting party hasn't been authorized to learn. Section 10.4 restates it. Careful thinking.
The next row maps "all scope tuples denied" to invalid_scope, which tells the requesting party the same class of thing, that the subject can't do what was asked for. RFC 8693 defines invalid_scope, so there's a reason for the row. The draft should say why the privacy argument stops at the gates, otherwise it reads as selective.
The transaction token exception
Section 4.3.4 states a rule: the subject of every scope tuple MUST be the exchange subject, never the requesting party, because scope expresses access authority and the access being exercised is the subject's. Section 5.4 then requires the opposite for transaction tokens, adding a second full set of scope tuples for the requesting workload, with both sets required to permit.
The draft flags this as "the one place in this document where the requesting party is evaluated for access authority" and grounds it in the transaction tokens spec, which requires the TTS to decide whether the workload may obtain a token with the requested values. That's a fair reading. Two caveats: the rule and its exception both derive from a draft at -11 that can still move, and the exception doubles the batch size for the flow with the tightest latency budget in the family.
The rest of Section 5.4 is the strongest material in the token type bindings. For self_signed and unsigned_json subject tokens, the presented token isn't an authority on identity, so the AS MUST have an independent basis before accepting a user identity from one, and "the PDP cannot detect this error, because it sees only the identifier it is given." That's a sentence you write after building the thing.
Writing quality
Same series, same unusually good prose, and this one is appropriately sized. 26 pages against the issuance draft's 49, and it earns most of them. Objections get anticipated rather than ignored. The explanation for why a short-circuiting batch semantic isn't used gives three reasons and all three hold up.
Two places to trim. Section 9's two examples run five pages, and the second one adds a single new thing over the first, a scopeless request where the PDP supplies granted_scope. That could be a diff instead of a full payload. Sections 3 and 6 both restate the issuance framework, and Section 3 says so in the text.
Section 6's act and may_act argument is new and should stay: a PDP that could write act could fabricate a delegation history, and one that could write may_act would confer delegation authority no evaluation considered.
The italicized-sentence-as-heading style in Sections 5.4 and 6 isn't standard IETF form, but it reads fine.
Author background
Omri Gazitt, listed as Independent. No published RFCs, three active Internet-Drafts, all three of them this AuthZEN series. New to IETF authorship, with implementation experience that shows up in the specifics.
What changed in -01
Short list, and all of it downstream of the issuance draft's new authorization detail tuple. Details now narrow per cell rather than per scope tuple. Detail tuples sit at level 2, and an entry that omits locations gets the level-2 resources substituted. The scope intersection rule kept its conclusion and swapped its justification, moving from RFC 9068 to what an ID-JAG loses at redemption, which is a better argument. The enforcement point capability declaration came out of the examples because the issuance draft no longer defines it.
Where feedback would be most useful
The venue question comes first, and it belongs on the issuance draft, since this document can't stand without that one.
Assuming that clears, four specific things:
Define the action name for ID-JAG redemption. "The grant segment is
token_exchangethroughout" contradicts Section 3, and the ID-JAG draft redeems withjwt-bearerorjwt-dpop.Justify scope tuples at level 1 or remove them. Nothing in the document says what a scope means when the target is a peer authorization server.
Say what an AS does when a non-chained exchange names both
audienceand an RFC 8707resource.Cut Section 4.5 to the two rules that matter, the exclusion of
requested_token_typeand the prohibition on raw token strings.
The two-gate split is the contribution, and it holds up independent of everything else here. RFC 8693 Section 4.4 already names the party whose authority is in question, and in the impersonation case no downstream point can evaluate it. That's worth writing down whether or not a PDP call is what does the evaluating. For the rest of the series, see the issuance profile it depends on and the claims profile.