Review · October 26, 2026
Selective Disclosure for JWT Access Tokens, Without Changing the Token
The problem it's solving
JWT access tokens often carry user attributes like email and name. Once they're in the token, they show up everywhere the token goes: token stores, gateway logs, and every resource server the token reaches. Encrypting the token hides the values, but then nobody without the key can validate it.
This draft applies SD-JWT (RFC 9901) to RFC 9068 JWT access tokens. The token carries only digests of the sensitive claims. The client decides on each request which values to reveal to which resource server. Existing infrastructure keeps validating the token exactly as it does today.
How it fits in the working group
In charter. It's a profile that combines three finished OAuth WG documents: RFC 9068, RFC 9901, and DPoP (RFC 9449). It doesn't add new endpoints or flows.
It does add new things on the wire:
- A
disclosuresparameter in the token response. - Two new HTTP fields,
SD-JWT-DisclosuresandSD-JWT-Key-Binding.
It also gives the client a new job. Today the client treats the access token as opaque. Under this profile the client acts as an SD-JWT holder. It picks which of the user's attributes each resource server gets to see. That's a real change to how the client relates to the user's data and to the RS.
The normative dependencies are RFC 6749, 9068, 9449, 9901, 7638, 9110, and 9651. All of them are published, so nothing here is blocked waiting on another draft.
What the mechanism actually does
- The AS issues a normal RFC 9068 token with
typ: at+jwt. Some top-level claims are swapped for_sddigests. Nesting, array-element disclosures, and recursive disclosures are prohibited. - A fixed set of claims always stays in the clear:
iss,exp,aud,sub,client_id,iat,jti,cnf, plusscopeandnbfwhen present. The same goes for any claim whose absence would widen what the token permits, such asact. - The token response includes a
disclosuresarray next toaccess_token. The client doesn't parse the token. It picks Disclosures by the claim name each one carries. - On each request, the client sends the token in the
Authorization: DPoPheader as usual. It sends whichever Disclosures it chooses inSD-JWT-Disclosures, and optionally a Key Binding JWT inSD-JWT-Key-Binding. - The RS validates the token and DPoP proof first, with no changes to that step. It then reassembles the SD-JWT and verifies it per RFC 9901.
DPoP binding is mandatory. The KB-JWT is signed with the same key as the DPoP proof and uses the DPoP nonce.
An RS that doesn't implement the profile ignores the new headers and sees only the cleartext claims. So does any RS that uses token introspection, because the AS is told never to put disclosable values in introspection responses.
Significant interoperability concerns
Discovery is completely unspecified, in both directions. The AS "issues a selectively disclosable Token only to a client it knows to implement this profile." The client sends Disclosures only to "a resource server it does not know to implement it." Which claims a given RS needs is "something the client knows." All three are out of scope. There's no error code for "valid token, but you didn't disclose the claim I need." The author lists this as an open issue. Until it's solved, every deployment will be a bilateral, hand-configured arrangement. In practice the client just ends up sending everything to every RS.
The PII moves from one header to another. The draft's main pitch is that tokens can be logged and stored as less sensitive. But the values now travel in SD-JWT-Disclosures on every request. Section 6 requires that header to be redacted like Authorization, and then admits that infrastructure unaware of the profile won't do that. A gateway that logs all headers except Authorization now logs the user's email in plaintext. Before this profile, that same gateway logged nothing sensitive. The draft tries to contain this with a SHOULD NOT about sending Disclosures to unknown resource servers. That pushes the real problem back onto the discovery gap above.
The client is told not to inspect the token, but it has to understand the claims. RFC 9068 Section 6 says clients MUST NOT inspect access tokens. This draft keeps that rule and then has the client pick Disclosures by claim name. That ties the client to the AS's claim vocabulary in a way OAuth has deliberately avoided. Today Okta or Auth0 can change what's in an access token without breaking clients. Under this profile, they can't.
The value only shows up when one token goes to several resource servers. The intro describes an agent calling several RSes with one token and disclosing different attributes to each. That requires a multi-audience token. The draft dismisses Resource Indicators (RFC 8707) as "multiplying tokens." But per-RS tokens already give each RS only what it needs, with no client-side selection, no new headers, and no new redaction rules. The draft should make the case for why one shared token plus per-request Disclosures beats that.
Keeping typ: at+jwt goes against RFC 9901's recommendation. RFC 9901 Section 9.11 recommends a distinct typ for SD-JWT profiles. The draft argues that falling back to an ordinary access token is the intended behavior, which is reasonable. Still, the WG should settle it explicitly, and the author lists it as an open issue.
Mechanisms that could be removed
The KB-JWT. The author already asks whether it's redundant beside DPoP. It's close to fully redundant. Section 3 requires every claim whose absence would widen permissions to stay in the clear. It also says an RS MUST NOT treat an undisclosed claim as permission. That means stripping Disclosures can only reduce what the RS learns. It can't escalate anything. The KB-JWT's only remaining job is to detect that stripping. It does that by adding a second signature with the same key on every request, plus a mandatory DPoP nonce round trip. The open issue's alternative is cheaper: put a hash of the Disclosures in the DPoP proof. Better still, drop the integrity check and let the RS treat missing Disclosures as missing.
The zero-Disclosure KB-JWT case. Section 5.3 itself says it "adds nothing beyond the DPoP proof." It should be prohibited or left out entirely.
The JWE-per-Disclosure aside. It's described in Security Considerations and then deferred to future work. Cut it, or move it to the open issues.
Writing quality
Precise and very compact. The main text is about six pages. It reads like someone who has read RFC 9901 closely. The open issues section is honest and names the draft's real weak spots.
It's dense to the point of being hard to review. Long sentences are chained with semicolons, and almost every paragraph cites a specific section of RFC 9901, so you need that RFC open alongside. Some phrasing is awkward. One example: "The token itself then carries no selectively disclosable value, and the holder chooses per request which values to reveal." Justifications are mixed into normative sections, like the typ argument in Section 3.
The mandatory DPoP requirement only appears in Security Considerations. It's a core part of the profile and belongs in Section 3 or 5.
Author background
I couldn't reach Datatracker from this session, so this is based on the local draft corpus.
Su-hyeon Forten Lee is the sole author, writing with a personal email address and no listed affiliation. Their name doesn't appear on any RFC in the local corpus, so they look like a new IETF author. They're writing actively, with three OAuth individual drafts in October 2026 alone:
- This draft.
- draft-forten-oauth-scope-metadata-document, about dereferencing URI scopes.
- draft-lee-oauth-dpop-credential-presentation, already at -03, which makes the same JWT access token double as a W3C Verifiable Credential.
Two of the three follow the same pattern: overload the RFC 9068 token with a second purpose while claiming the RS needs no changes.
Questions worth raising
- Who is the threat model protecting against? If it's log and token-store leakage, the new header recreates that leak. If it's resource servers seeing too much, per-RS tokens via RFC 8707 already solve it. The draft needs a concrete deployment where neither alternative works.
- Can the KB-JWT go? Given the Section 3 rule that undisclosed claims never grant permission, what attack does it actually stop?
- How does a client learn what to disclose? Without RS metadata and an error code, this isn't interoperable. Both should be in -01, not deferred.
- Is the WG comfortable with clients selecting claims by name from an access token? That's a departure from "access tokens are opaque to clients" that deserves its own discussion.
- Why not leave PII out of the access token entirely? The RS can get user attributes from the AS when it actually needs them. The draft should explain why that pattern isn't enough.
For the underlying mechanism, read RFC 9901. For the token format being profiled, read RFC 9068.