Review · October 26, 2026
Signed Delegation Chains for Brokered Authorization Requests
Brokered OAuth is everywhere. A client sends the user to broker A. Broker A is a client of broker B, which is a client of the authorization server that actually asks for consent and issues tokens. The upstream AS only ever sees the last broker.
That causes the shared consent problem that the Security BCP update describes. The user approves "Broker C" once. From then on, every downstream client that comes through Broker C rides on that consent. The user never sees which app actually ends up with access.
This draft gives each broker in the redirect path a way to sign a statement saying "this is the client I'm forwarding for." The upstream AS gets the full path and can bind consent to the real originating client.
How it fits in the working group
The scope is narrow on purpose. It adds no new grant type, endpoint, token format or error code. It defines two things:
- A Rich Authorization Requests
authorization_detailstype,oauth_request_delegation_chain, which carries the chain. - A
client_rolesclient metadata value,oauth_broker, which lets a client declare that it's a broker.
It depends on RFC 6749, RAR, AS Metadata, JWS, Dynamic Client Registration and, optionally, CIMD. It plainly fits the charter, since it addresses a threat the WG's own BCP update names.
The new relationship is between the upstream AS and brokers it has never dealt with. The AS now has to trust signatures from every AS in the path, not just the one it has a client registration with.
The draft has five "Relation to" sections, covering OpenID Federation, CIMD, Token Exchange act, the Actor Profile and Actor-Signed Hop Proofs. They all say the same thing: those are token-time and this is request-time. That's a fair distinction. A deployment could validate this chain at the authorization endpoint and then express the result as act claims in the issued token.
What the mechanism actually does
Each broker adds a node to a JSON array. A node contains:
iss: the broker signing the nodeaud: the next AS in the pathclient_nsandclient_id: the client this broker is vouching for, either an AS-local ID or a CIMD URLnandp_hash: position in the chain, and a hash of the previous node- An optional
resource,subandclient_name proof.jws: a detached JWS over a custom line-based serialization of the node
The receiving AS checks that the last node is addressed to it and was issued by the broker it's talking to. It then walks backward, verifying every signature (keys come from each iss's AS metadata jwks_uri) along with hash links, sequence numbers, and that each aud matches the next iss. Then it applies local policy, including whether chain[0] is allowed to be the first node.
Consent is then bound to user + AS + immediate broker + originating client + broker path + resource + chain hash.
Brokers discover upstream support through authorization_details_types_supported. A broker that can't forward the chain must reject the request, unless every node set omit_chain: allowed.
The front channel problem
This is the biggest issue. The chain travels in a redirect authorization request, through the user's browser, with no client authentication.
Section 8.3 requires the AS to bind the last node's iss to "the authenticated OAuth client submitting the request." Section 11.8 says the AS "MUST still authenticate the immediate OAuth client." Neither is possible at a plain authorization endpoint. The only way to make these checks real is PAR, and PAR is never mentioned.
Size is a problem too. Three nodes, each carrying an ES256 JWS plus URLs, all JSON-encoded and then URL-encoded inside authorization_details, can easily blow past browser and proxy URL limits. PAR fixes that as well. It should be required.
Nothing ties the chain to this request
Nodes have no exp, iat, nonce or binding to state or PKCE. Section 11.3 explicitly leaves replay protection to deployment-specific extensions.
So a node is a portable, permanent statement: "broker-a vouches for client-123." It doesn't prove that broker-a vouched for client-123 in this particular authorization request. Anyone who has seen a valid chain can attach it to any other request through the same final broker. The final broker's own redirect handling limits the damage. Still, a provenance mechanism whose evidence is replayable forever doesn't add much. The minimum fix is an expiry, plus binding the first node to something per-request.
Consent binding won't work as written
Section 9 includes the "delegation chain hash" in the consent binding. ECDSA signatures are randomized, so every fresh chain has a different hash even when the path is identical. Consent bound to the chain hash never matches a prior grant. The user gets prompted every time.
What the consent binding actually needs is the originating client plus the ordered broker path. Drop the chain hash from the list.
The custom serialization is risky
Section 7.2 defines its own canonicalization: name=value lines joined by \n. Nothing is escaped. client_name is display text, often taken from client metadata, which for a CIMD client is fully attacker-controlled. A client_name containing \nresource=https://evil.example serializes to the same bytes as a node with no such name and a resource member. One signature then validates two different nodes.
Other problems:
- Array elements are "JSON string serialization," which implies quotes, but the example has none.
- It's not specified how
p_hash: nullserializes. - Numbers have no defined format.
The stated reason for avoiding a normal JWS payload is that it keeps the wire format as JSON that can be validated against a schema before cryptographic verification. That doesn't justify the risk. Make each node a regular compact JWS with a JSON payload, or use JCS (RFC 8785). Either removes the whole section.
Is RAR the right carrier?
authorization_details describes permissions the user is consenting to. RAR expects the AS to show it to the user and echo it in the token response. A delegation chain is provenance, not a permission. Putting it there means every client and resource server that processes authorization_details has to learn to skip it.
There's one real benefit: an AS that doesn't support the type will reject the request, so the request fails closed. A dedicated request parameter inside a PAR request would be cleaner. The draft should make the case either way.
Section 12.2 talks about a future IANA registration for the type. RFC 9396 doesn't create a registry for authorization details types, so there's nothing to register.
Significant interoperability concerns
- The serialization is underspecified. Two implementations will produce different bytes for nulls, numbers and array values. Their signatures won't verify against each other.
- Contradictory extension handling. Section 6.2 says receivers MUST reject unknown members unless local policy allows ignoring them. Section 8.1 says receivers MAY reject them. Section 7.4.5 says attesters MAY add claims "as parties see fit."
- Binding the final
issto the client is "deployment-specific." No registered client metadata says "my broker issuer is X." Two ASes will do this differently, or not at all. resourceduplicates RFC 8707. The chain'sresourceisn't required to match the request'sresourceparameter. Section 8.6 makes consistency a SHOULD, and it allows "resource transformation" without defining what that means.- Trust in every node's
issis pure local policy. That's realistic. In practice, though, the upstream AS needs an allowlist of every broker in every path, which is the federation problem this draft says it's leaving to OpenID Federation.
Mechanisms that could be removed
omit_chain. This is a per-node opt-out of the draft's own protection, andforbiddenis already the default. Brokers that can't forward the chain should apply local policy, and the AS that requires the chain will reject the request anyway.client_roles/oauth_broker. Section 11.6 says it can't be trusted unless it comes from a trusted source, and Section 10 lists six other ways to decide a client is a broker. An AS that knows a client is a broker learned that at registration. This adds a registry entry without improving interop.n. The hash chain andaud/isscontinuity already fix the order. The draft admits JSON arrays are ordered.- Most of the "Relation to" text. A single paragraph contrasting request-time and token-time would cover all five sections.
Writing quality
The writing uses normal IETF conventions and is mostly clear. The validation algorithm is step-by-step and easy to follow. The security considerations on head, middle and tail truncation are well thought out, and they're honest that re-origination can only be handled by policy.
There are rough edges. The intro bullet list ends with "and" followed by nothing. "authrization" is misspelled. Several lists mix commas and periods. Normative requirements are repeated in two or three places with different strength (MUST vs SHOULD vs MAY), which is how the contradictions above crept in. RFC 7517, 7518 and 7519 are listed as normative but barely used, and 7519 doesn't apply since nodes are explicitly not JWTs.
At 43 pages it's long for a single RAR type. Cutting the relation sections, omit_chain, client_roles and the custom serialization would roughly halve it.
Background of the author
Yaron Zehavi, Raiffeisen Bank International. As of our review two weeks ago, Yaron's Datatracker profile showed zero published RFCs and four active drafts: this one, audience-bound token exchange, authority metadata, and RAR metadata and remediation. The working group has already adopted RAR metadata.
That's not a new author. Yaron is one of the most active individual contributors in the WG right now. The drafts share a theme of making intermediaries visible in multi-AS deployments. This one covers brokers on the front channel. The token exchange draft covers resource servers on the back channel.
So what should happen next?
The problem is real, and the WG already acknowledges it in the Security BCP update. The shape of the solution is reasonable. A chain of per-hop attestations walked backward from the trusted hop is the right model.
Before adoption, the draft needs three changes: require PAR, replace the custom serialization with standard JWS payloads, and add expiry and per-request binding. Alongside those, it's worth a list discussion on whether RAR is the right carrier. Further reading is the shared consent text in the Security BCP update, which this draft should cite by section.