Review · September 2, 2026
AuthZEN Profile for OAuth 2.0 Token Issuance
Every OAuth spec that defines a moment where the AS decides whether to mint a token describes the inputs carefully and then stops. RFC 8693 says the decision is governed by policy it doesn't define. Identity chaining, the identity assertion grant, and transaction tokens all inherit that and say "administrator-defined policy" without saying how such a policy gets expressed.
The draft's observation: that's the most security-relevant step in issuance, and today it lives in vendor-specific rules engines and inline hooks that don't port anywhere.
The proposal is to make the authorization server a Policy Enforcement Point and ask an OpenID AuthZEN PDP. The draft specifies how a token request maps onto AuthZEN's five mandatory fields, how the PDP's response can narrow the token, and how a PDP advertises that it speaks this profile.
The mapping is worth understanding because it's the interesting part. Issuance gets split into two questions that are usually conflated. Can this subject get a token of this kind for this target? That's the "gate tuple," with an action name like issue:access_token:authorization_code. Can this subject exercise this scope at this target? That's a "scope tuple," one per requested scope, with the scope string carried verbatim as the action name. The draft grounds the split in RFC 8693's may_act: the authority to mint a delegated grant aimed at an API is not the authority to call it. That's a good insight and it's the strongest idea in the document.
RAR gets a third tuple shape. Since RFC 9396 §2.2 says an entry means the product of its actions, locations, and datatypes, the AS decomposes each entry into one evaluation per cell, then reassembles the entry from the cells the PDP permitted. A 2x2 entry across two targets becomes six evaluations.
How this fits with the working group's existing work
Nothing changes on the OAuth wire. No new request parameters, no new response fields, no new client behavior, no new AS metadata. Every error the profile can produce is an error code that already exists.
That's the same threshold question the companion claims draft raises, and it's sharper here. This document specifies how an authorization server talks to a policy engine. The two parties that need to interoperate are an AS and a PDP, neither of which is a role the OAuth WG defines. The normative dependency runs to the OpenID Foundation's Authorization API 1.0. Conformance is, by the draft's own words in Section 4.1, "a property of the messages exchanged and not of the topology that carries them," and Section 4.1 expects the strictest deployments to evaluate in-process. So nobody outside the operator can tell whether an AS conforms.
There's a second venue problem. Section 10.1 acknowledges that the AuthZEN WG's own Access Request OAuth Profile "governs the same moment as this document," divides the territory by the value of decision (that profile owns deny, this one owns allow), notes the two must both build an evaluation request from a token request, and concludes that "aligning the two is expected work." Two bodies are currently specifying how a PDP sits behind an OAuth token endpoint. The working group should figure out where that alignment happens before adopting anything.
Dependency count is moderate. Normative on RFC 6749, 7519, 8693, and 9396 plus AuthZEN. Informative on 7515, 7643, 8126, 8176, 8707, 9068, 9126, 9470, and 9700, most of them doing real work in the reasoning.
The failure modes are inconsistent
Section 6.4.2 handles token_lifetime correctly. It's a ceiling, and the AS uses the lesser of the PDP's value and its own. A PDP that doesn't know the AS's policy can't break anything.
Section 6.4.1 handles granted_scope the opposite way. It MUST be a subset of what the AS would otherwise have granted, and the AS MUST reject the decision otherwise. Rejecting means failing closed, which means no token.
Consider the case the key is actually for: a gate-only evaluation where the client requested no scopes, so the PDP is answering "permit, and grant this set." The PDP has no way to know the AS's default set for that client and target. If it names a scope the AS wouldn't have issued, the whole request fails, where the obviously right answer is to issue the intersection. Same situation as the lifetime ceiling, opposite outcome. Fix this by intersecting, the way token_lifetime already does.
The audience key duplicates a denial
Section 6.4.3 defines audience as an array of strings narrowing the set of targets. Then it says every value MUST be the resource.id of the evaluation it came from, so the array is either that one target or empty, and an empty array has "the same effect as the denied gate of Section 5.5.4."
That's a boolean wearing an array's clothes, and it expresses something decision: false already expresses. Section 5.2.2 justifies the multi-target machinery partly on the grounds that it's "what makes the audience constraining key of Section 6 reachable," but that doesn't hold: because each evaluation can only speak for its own target, the key does exactly the same thing whether the request named one target or five.
Multi-target support arrived in -01, and it's worth asking whether it should stay. Section 5.2.1 already says a request SHOULD name a single target and an AS MAY reject a multi-target request. Section 5.5.4 then also lets an AS fail the whole request when any single gate is denied. So a client sending the same multi-target request to two conforming ASes can get a full token, a partial token, or an error, and can't predict which. Dropping multi-target would delete Section 5.2.2, most of 5.5.4, the intersection rule in 5.5.5, the audience key, and a good chunk of Section 6.6.
The RAR action name encoding is ambiguous
Section 5.3.4 joins an action and a datatype with a colon, datatype last, and says "the datatype is recovered as the segment following the final colon." It guards the case where the datatype contains a colon by declining to compound. It doesn't guard the action.
RAR actions values are arbitrary strings defined per authorization details type. An entry with actions: ["read:contacts"] and no datatypes produces the action name read:contacts. So does an entry with actions: ["read"] and datatypes: ["contacts"]. Two different requests, one action name, and a PDP applying the recovery rule reads the first one as a datatype request that was never made. Either the encoding needs a delimiter that can't appear in either value, or the datatype needs its own field in properties with the caveat that the design rule in Section 1.1 pushes against that.
The batch is unbounded in principle and unspecified in practice
One token request becomes many evaluations, and the client controls the count. Scopes times targets, plus the full product of every RAR entry. Section 11.2 is honest about this: an authenticated but unprivileged client can impose disproportionate work on the PDP and through it on every other tenant.
Section 5.5.3 requires an AS to bound the number of evaluations and deliberately names no value, citing RFC 9126 §2.3 as precedent. The precedent isn't quite the same. An oversized pushed request is one parameter the client can shorten; here the bound is on a number the client never sees and has to infer from a product it may not know it's forming. A floor would help, something like a statement that an AS supporting this profile handles at least N evaluations, so a client has some request size it can rely on everywhere.
The refusal to lean on AuthZEN's own load-shedding is the right call and well argued: a shed request is a fail-closed request, so relying on the PDP's protections turns an amplification attack into an outage.
Mechanisms that could come out
Section 6.6's aggregation table exists because AuthZEN batch responses have no top-level context, so shaping arrives spread across items. The draft handles it with a per-key composition rule (minimum for lifetime, union for scope and crit, merge for claims, reject on conflicting claim values) and then a SHOULD asking the PDP to put token-level shaping on a single item anyway. Make that a MUST on the gate item and the whole subsection becomes two sentences.
granted_scope and scope tuples are two mechanisms for the same downscoping, reconciled by a SHOULD NOT and an aggregation rule. Restricting granted_scope to the gate-only shape, which Section 6.4.1 already calls its principal use, would remove the overlap.
Section 4.3, "The Seam Inside the Authorization Server," says outright that its consequence is "practical rather than normative." It's a good observation about where implementation effort actually goes, and it's commentary.
Section 7's discovery requirement is one URN and a rule that a PDP advertising it must render a decision rather than an error for any registered gate action. "Denying is a decision; a protocol error is not" is exactly right and takes one line. The three paragraphs after it explain why granularity isn't finer, and then describe an optional deployment-time check using the Action Search API that "nothing in this profile requires."
Section 8's error table restates conditions already stated normatively in Sections 5.5, 6.3, and 6.4. If it stays, mark it non-normative so the two can't drift.
Section 12.1 writes an open question into the IANA section. AuthZEN asked IANA for a urn:ietf:params:authzen sub-namespace and a capabilities registry, neither of which exists yet, and the sub-namespace registry's IETF Review policy can't be satisfied from outside the IETF stream. The draft lays out three options and hands the choice to the working group. That's the correct thing to raise and the wrong place to raise it, because both parties have to compute the same capability string and right now the draft doesn't tell them what it is.
The step-up gap is worth extracting
Buried at the end of Section 8: a PDP can deny and name the acr and amr values that would have permitted. The AS should surface that to the client. Neither end of that is specified. AuthZEN shows the pattern only in a non-normative example, and RFC 9470's insufficient_user_authentication is defined for resource servers, so there's no equivalent signal at the token endpoint.
That's a real hole in OAuth, independent of whether any of this profile gets adopted, and it's the finding most likely to be useful to the working group on its own.
Writing quality
Unusually good prose, same as the other two drafts in this series. Careful reasoning, objections anticipated, derivations rather than assertions. The design rule in Section 1.1 (decision-critical input goes in the five-tuple, properties and context are advisory, a conforming mapping must work for a PDP that reads only the five-tuple) is stated once and then applied consistently for forty pages, which is harder than it looks. The reserved claims table in Section 6.5.1 is well constructed, and "re-subjecting a token is a fresh issuance, not an attenuation of an existing one" is the kind of sentence that settles an argument.
The problem is the same one: 49 pages for a mechanism whose entire wire surface is filling in five fields and reading one JSON object. Maybe twelve pages are normative. The rest is design rationale, related work, and argument, and it reads as an essay about a specification. There's an Editor's note in the IANA section. Section 5.3.2 spends most of a page on Zanzibar-style relation identifier grammars to justify a regex and a length limit that would stand on their own.
Section 4.1 is a case where the rationale is load for the reader rather than the implementer. The latency argument concludes that the profile adds no round trip because AuthZEN doesn't specify topology, which is true, and which means the section's real content is one sentence: the PDP may be in-process.
Author background
Omri Gazitt, listed as Independent. Zero published RFCs, three active Internet-Drafts, all three of them this AuthZEN series. New to IETF authorship.
The implementation experience is visible. Someone who hadn't tried this wouldn't know that open banking consent objects carry their multiplicity in type-specific members rather than in the RAR common data fields, or that pre-allocating a jti for correlation means spending identifiers on denied requests.
What changed in -01
Multi-target requests, discussed above. Requested authorization_details now reach the PDP through the cell decomposition, which is the largest addition. The AS's own reductions are now ordered before the PDP call, so the batch carries only what the AS would otherwise grant. The batch bound and the amplification section are new. crit became unilateral, and the request-leg context.issuance envelope and the enforcement point capability declaration that gated it are gone, so the profile no longer puts anything on the request leg. The structural check in Section 6.4.4 now tests a returned entry against a single covering request entry rather than the union of same-type entries, which closes a real hole.
Where feedback would be most useful
The venue question comes first, and it has two halves. Is a profile of how an AS talks to its policy engine OAuth WG work, given nothing on the OAuth wire changes and the normative dependency runs to the OIDF? And if it is, how does it get reconciled with the AuthZEN WG's own OAuth profile that Section 10.1 says governs the same moment?
Beyond that, four specific things:
Make
granted_scopeintersect rather than reject, matchingtoken_lifetime. As written, a PDP that doesn't know the AS's defaults can fail the request outright.Reconsider multi-target. It arrived in -01, it makes client-visible behavior unpredictable across ASes, and removing it takes the
audiencekey and most of the aggregation rules with it.Fix the RAR action name encoding.
read:contactscurrently has two possible readings.Cut the document roughly in half, and pin down the capability URN before the IANA section asks the reader to choose.
The gate-versus-scope split is worth keeping whatever happens to the rest, and so is the observation that RFC 8693 and everything built on top of it leave the same seam. For the rest of the series, see the claims profile, which populates RFC 9068 group and role claims from AuthZEN searches, and the token exchange binding.