Review · November 10, 2026
Resource Parameter in the Access Token Response, Telling the Client Which Resource a Token Is Good For
The problem it's solving
Resource Indicators lets a client say which resource it wants a token for. The AS never says what it actually did with that request. It can honor it, narrow it, swap it for a default, or ignore it, and the token response looks the same in every case.
This matters most with dynamic discovery. A client finds an AS at runtime through Protected Resource Metadata, which is the MCP model. A malicious resource can point at a legitimate AS that ignores resource. The client gets a token that works at other APIs and hands it to the attacker.
The draft's fix is one parameter. The AS returns resource in the token response, and the client checks it against what it asked for.
How it fits in the working group
This is a small extension that fits the charter. It adds a "token response" usage location to the existing resource parameter registration. It adds no endpoints, roles, token formats, or metadata.
It depends on RFC 6749, RFC 8707, and RFC 9728. All 13 references are listed as normative, including introspection, DPoP, and the Security BCP, which the mechanism doesn't need.
It restates and tightens RFC 8707 AS behavior but does not declare "Updates: 8707." Filip Skokan's earlier competing draft did. The two efforts merged in -03, with Skokan joining as co-author.
-04 has no changes. It is a refresh to keep the draft from expiring.
What the mechanism actually does
The AS returns resource in a successful token response. The value is a string for one resource and an array for more than one.
If the client asked for resources, the response must include at least one of them. The AS can return a subset. It can add "server-assigned" resources on top, such as the UserInfo endpoint when openid is in the scope. If none of the requested resources are acceptable, the AS returns invalid_target.
If the client asked for nothing, the AS should still report any resource it assigned. If the token has no resource restriction, the AS omits the parameter.
Clients are split into two classes. A client that discovered the AS or the resource at runtime MUST reject a token response with no resource. A client statically configured with both can keep using the token as it did before.
Comparison uses RFC 3986 syntax-based normalization. Duplicates after normalization make the response invalid.
So does this stop the mix-up attack?
Partly. The check tells the client that the AS processed its resource request. An AS that does process it would already reject the attacker's unknown resource with invalid_target under RFC 8707.
The new protection comes from the absence rule. An AS that ignores resource won't return it, and a discovery-based client throws the token away.
The draft is upfront that this doesn't prevent token reuse by a malicious resource. It recommends DPoP for that.
Significant interoperability concerns
There is no way to discover support. The draft defines no AS metadata flag. A discovery-based client only learns the AS doesn't support this after the user has logged in and consented. The user completes the whole flow and then sees an error. Under the MUST, an MCP client adopting this fails against every AS that hasn't deployed it yet.
"Pre-configured knowledge" decides which rules apply, and nobody can test it. The same client software can be in either class depending on deployment. The class with weaker rules is self-declared.
Omission means two things. When no resource was requested, a missing parameter means "unbounded." It also means "this AS doesn't implement the spec." The client can't tell these apart.
The string-or-array rule contradicts itself. Section 3 says the AS SHOULD use a string for a single resource. Section 3.2 says it MUST.
The client rules and the examples disagree. AS rules trigger on resource in "the authorization request or token request." Client rules trigger only on "the token request." Every authorization code example puts resource in the authorization request and leaves it out of the token request. Read literally, those clients fall under "did not request a resource" and have nothing to validate.
URI comparison differs from RFC 9728. Protected Resource Metadata requires the resource value to be identical to the identifier the client used. This draft requires normalization first. A client doing both checks needs two comparison routines for the same identifier.
Only two grant types are covered. The rules "apply equally" to authorization code and refresh. Client credentials, Token Exchange, device flow, and JWT bearer are not mentioned.
Partial matches leave work for the client. A client that asks for A and B and gets back A and C has a valid response. It has to track per-resource which tokens it can use, and the draft doesn't say what to do about B.
Mechanisms that could be removed
- The restated RFC 8707 processing rules. Downscoping at the token endpoint, refresh token limits, and when to return
invalid_targetare already RFC 8707 topics. Changing them belongs in an explicit update to RFC 8707. - The duplicate check on the client. Rejecting a usable token because the AS listed a resource twice adds a failure mode with no security benefit.
- The two client classes. A single rule works: a client that sent
resourceand needs confirmation rejects a response without it. Pair it with a metadata flag. - The Resource vs Audience section. Two pages arguing why not
aud. One paragraph is enough. - Most of the examples. There are ten pages of near-identical authorization code and refresh exchanges.
- The DPoP recommendation. It is a general best practice already covered by the Security BCP.
Writing quality
The prose is clean and uses standard IETF style. The summary tables for AS and client processing are helpful.
It is too long for what it defines. This is 34 pages for one response parameter. Skokan's draft covered the same parameter in 7.
The repetition is where the inconsistencies come from. The string-or-array rule is stated three times with two different requirement levels. The invalid_target rule appears four times.
There are structural slips. Security Considerations is nested as Section 3.4 under the parameter definition. The introduction uses a normative "MAY" to describe what deployed servers do today. The acknowledgments thank Filip Skokan, who is now a co-author. There is no informative references section.
Background of the authors
Datatracker could not be reached for this review, so current profile counts are not verified.
Karl McGuinness (Independent, formerly Okta). As of the mid-October reviews: 0 published RFCs, 16 active Internet-Drafts, 2 expired. Co-author of ID-JAG, an adopted WG document. Not a new author, and writing at a very high rate.
Jared Hanson (Keycard Labs). Profile not checked. Known in the community as the author of Passport.js.
Filip Skokan (Okta). Profile not checked. Maintainer of widely used OAuth and JOSE libraries, and author of the resource response draft this one absorbed, plus the additional hashes draft.
Questions worth raising
- Should this be an update to RFC 8707? It changes what a conforming Resource Indicators AS does. Skokan's draft was framed that way.
- Where is the metadata flag? Without something like a
resource_response_supportedsignal, discovery-based clients fail after consent instead of before. - Is "at least one match" the right bar? A stricter rule, where the response must cover the resource the client is about to call, is easier to implement and explain.
- Which comparison rule wins? Aligning with RFC 9728's exact match avoids two answers for the same identifier.
- Can the draft drop to under ten pages? The mechanism is simple and has clear demand from MCP deployments. The current length is the main obstacle to a quick adoption call.
For the shorter take on the same parameter, read draft-skokan-oauth-resource-response.