The Scope Creep Automated reviews of new AI-related working group submissions

Review · August 26, 2026

OAuth 2.0 Policy-Based Anonymous Access Tokens

draft-li-oauth-policy-based-anonymous-tokens -00View on Datatracker →

draft-li-oauth-policy-based-anonymous-tokens-00 — Kretzler, Li, Wang, Fressancourt (all Huawei), submitted 26 August 2026.

The Problem Statement

The core idea, stripped down: one trip to the authorization server buys the client a credential from which it can locally mint up to N single-use access tokens that the resource server cannot correlate back to the issuance, and cannot correlate to each other.

The cap is enforced cryptographically rather than by counting. Token derivation is deterministic for a given (credential, tag) pair, so a client that tries to reuse a slot produces a byte-identical token that the RS rejects as a replay, and a client cannot manufacture a token for a slot the policy doesn't admit. The policy — currently just "counters 0 through N-1 within this epoch" — is public and the RS evaluates it offline with no introspection call.

The motivating case in the draft is agent quota: a user authorizes an agent to perform up to 20 reads in 30 minutes, and the agent gets neither a reusable bearer token covering all 20 nor 20 round trips to the AS.

The word "anonymous" is used narrowly and the draft is admirably explicit about it: the AS still knows who the client is at issuance, and the RS still sees the request, its timing, and its source. What's unlinkable is the cryptographic transcript.

How the Spec Fits In

This is not an extension of anything. It defines a new OAuth access token type and a new HTTP authentication scheme, making it a sibling of Bearer (RFC 6750) and DPoP (RFC 9449) rather than a modification of either. Concretely it adds:

  • A new access token type PBAT and HTTP auth scheme PBAT
  • Four new OAuth parameters, one new error code
  • Five new AS metadata members and four new protected-resource metadata members
  • A new RAR authorization-detail type (policy_based_anonymous_token)
  • A bespoke key-publication document at a new pbat_keys_uri endpoint
  • Two new IANA registries (ciphersuites, policy profiles)
  • A nine-operation abstract cryptographic interface
  • A mandatory new state requirement on resource servers (spent-token / replay storage, atomic, and shared across a replay domain)

Structural dependencies are moderate — RFC 6749/6750 for the base model, 9396 for the authorization vocabulary, 8414 and 9728 for discovery, 8785 (JCS) for canonicalization, 9110 for the auth framework, 7515 for base64url, 6234 for SHA-256. About 22 RFCs are cited in total.

On roles, the draft does something right: it maps cleanly onto the existing AS/client/RS triangle and introduces no new roles. But it does introduce two new artifacts that sit between the grant and the request — the PBAC (the credential the client holds and never shows anyone) and the policy (an AS-published object the client must reproduce byte-for-byte). The policy is the interesting one, because it's a new AS-published resource with no defined publication mechanism (more below).

The most important positioning question is Privacy Pass. RFC 9576/9577/9578 already cover privacy-preserving authorization tokens, including batched issuance, and the draft explicitly declines to reuse the PrivateToken scheme on the grounds that its syntax can't carry policy, tag, and OAuth metadata. That's a defensible argument, but it means this work is a second privacy-token architecture landing in a different working group. §21 proposes to resolve that by having the crypto reviewed by CFRG while OAuth owns the protocol bindings — a reasonable split, but one that needs buy-in from Privacy Pass and CFRG before OAuth adopts anything.

Against the current OAuth charter, the plausible hook is the "Complex Delegation" bullet — automated agents acting across multiple administrative domains. The agent-quota and cross-domain use cases land squarely there. There is no charter item for anonymous credentials or privacy-preserving tokens; the "Digital Credentials" bullet is about SD-JWT and selective disclosure, which is a different problem.

High-Level Summary

Today, when an application needs to make 20 API calls on a user's behalf, it either asks the authorization server 20 times, or it gets one token good for all 20 and hands the same reusable credential over on every call. The first is chatty; the second means a stolen token is worth the whole task, and the API operator can see that all 20 calls came from the same authorized session.

This proposal changes the shape of what the authorization server hands out. Instead of a token, the client receives a derivation key — a credential it never presents to anyone. From that credential, the client generates a distinct, single-use token for each of the 20 permitted slots. Three consequences follow:

For the resource server, the cap is self-enforcing. It doesn't call the authorization server, doesn't consult a quota service, and can't be talked into a 21st call — the math doesn't allow a 21st valid token to exist. It does have to remember which tokens it has already seen, which is real new infrastructure.

For the client, blast radius shrinks. A stolen presented token is worth exactly one API call and reveals nothing about the credential behind it. The derivation credential itself becomes the high-value asset and the draft correctly says it should live in non-exportable storage.

For privacy, the API operator can no longer tell that call #3 and call #17 came from the same authorization, or match either against the issuance record — even if the API operator and the authorization server compare notes. This is the genuinely novel property and it's the reason the underlying cryptography is nontrivial.

The catch worth understanding at leadership level: that last property is fragile in a way the draft acknowledges but doesn't fully resolve. Unlinkability holds only for the cryptography. Everything else about the request — the source IP, the timing, the requested resource, and critically the policy identifier and expiry time carried in the token — can re-identify the client. The draft says the authorization server should therefore use identical policies across large populations of clients, but then specifies a protocol in which the client chooses the policy identifier, epoch, and expiry, and forbids the authorization server from adjusting them. Those two requirements cannot both hold. A deployment that follows the wire protocol as written will produce per-client policies and get no privacy benefit at all.

Second catch: the cryptography does not exist yet as a specifiable thing. The one mandatory-to-implement algorithm suite is deferred to a "companion document" that has not been submitted to the IETF, based on two 2025 academic preprints (one co-authored by this draft's authors) that have had no CFRG review. Nobody can build an interoperable implementation of this document today.

Significant Interoperability Concerns

The mandatory ciphersuite is undefined. §8 requires every v1 implementation to support PBAT-EQS-BLS12381-SHA256, "specified by the companion PBAT ciphersuite document." No such document exists — a Datatracker search returns nothing, it does not appear in the reference list, and none of the four authors has it among their active drafts. §22.7 registers the initial entry with the reference "Companion PBAT EQS ciphersuite specification described in Section 21," which points at a section that describes a plan. The document is unimplementable as submitted, and this is the single blocking issue: everything downstream (test vectors, wire sizes, key encodings, whether public verification and private-bit recovery are actually achievable together) is unknowable until that document lands.

Step 1 of the protocol flow is unspecified. Figure 1 begins with "obtain policy and metadata" from the AS. There is no endpoint, no metadata member, and no format defined for how an AS advertises which policies it offers. Yet the client must construct the policy object byte-for-byte identically to the AS before it can even build the issuance request, because policy_hash is bound into public metadata. The client can only get there by guessing correctly, which works today only because §9's "non-enriching" rule forces the AS to accept exactly what was requested or reject.

Client-chosen policy identity contradicts the privacy goal. policy_id, epoch_id, not_before, expires_at, and maximum_uses are all REQUIRED members chosen by the client, and §9 forbids the AS from adding, removing, or changing any member. Meanwhile §11.3 and §19.2 require that these values be shared across large client populations or the anonymity set collapses. These are irreconcilable as written. The fix is probably to invert authority — the AS publishes a small set of policies with stable identifiers, the client references one by ID — but that is a substantial redesign of §9, not an editorial fix.

No downscoping path. §9 says the AS must reject with invalid_authorization_details if it won't authorize exactly what was asked, and separately says the AS must not issue a policy broader than the grant permits. If the resource owner consents to 5 uses when the client asked for 20, the AS's only legal move is a bare rejection with no way to signal what would be acceptable. This also deviates from RFC 9396, which permits the AS to return modified authorization details; the deviation needs justification.

access_token carries something that is not an access token. §10 puts the unfinalized ciphersuite issuance response in the access_token response parameter, then says it "MUST NOT be sent to an RS" and must be processed through Finalize first. Every existing OAuth client library, SDK, proxy, gateway, and log pipeline treats access_token as a credential to be stored and sent in an Authorization header. This is the most concrete and most easily fixed interoperability hazard in the document: it should be its own parameter (pbat_issuance_response), with access_token either absent or carrying nothing.

The replay domain is undefined for multi-valued audiences. locations and audience are arrays, so a policy can name several resource servers. §13 step 9 says to reject a token already accepted "in the same issuer, key, policy, and ciphersuite context" — RS identity is conspicuously absent from that list. Read literally, a token spent at RS A must be rejected at RS B, requiring synchronous shared replay state across resource servers that may be in different administrative domains. Read the other way (per-RS state), the effective quota becomes maximum_uses × |audience| and the cap isn't enforced. The draft needs to define the replay domain explicitly and probably restrict v1 to a single audience.

actions has no defined semantics. It's "an array of action identifiers understood by the AS and RS," and §13 step 5 asks the RS to verify "the approved authorization details permit the requested operation" with no mapping rules from actions to HTTP methods, paths, or operations. §12.1 then reports that failure as insufficient_scope even though scopes are not used anywhere in the protocol. Either define the mapping or drop actions from v1.

The challenge carries no negotiation information. §12.1's WWW-Authenticate: PBAT realm="example" conveys no ciphersuite, policy profile, version, or resource-metadata pointer. A client that guesses the wrong ciphersuite has no recovery path, and §15's requirement that the client "select a version, ciphersuite, policy profile, and verification mode supported by both the AS and RS" has no defined discovery trigger. RFC 9728's resource_metadata challenge parameter is the obvious precedent.

A bespoke key document instead of JWKS. §15 invents a keys array with kid, ciphersuite, public_key, not_before, expires_at, status. JWKS (RFC 7517) already has kid and extension points, and the OAuth ecosystem already has JWKS tooling everywhere. Inventing a parallel key format — with a revocation list bolted on via status: revoked entries that must remain published until every bound policy expires — is a gratuitous divergence that will need its own libraries.

Wire size. The presentation is base64url of a JCS-serialized JSON object that itself contains base64url of the policy, the tag, the public metadata, the token, and the witness — double base64 expansion (~1.78×) over a JSON structure that embeds the full authorization_details array plus two separate hashes of it, carried in an Authorization header, wrapping a pairing-based zero-knowledge proof. This plausibly lands in the multi-kilobyte range per request, against the 4–8 KB header limits common in proxies and web servers. The draft should state expected sizes once the ciphersuite exists, and should consider whether the policy needs to travel on every request at all.

Mechanisms That Could Be Removed

The document is 43 pages for a protocol whose actual cryptography lives elsewhere. I'd estimate 40% is removable without losing anything needed for interoperability.

Private verification mode (§14.2) — cut entirely. No private-verification ciphersuite is registered; §8 defers the algebraic-MAC construction to a later optional suite. So the draft defines an entire second verification mode with zero implementations, and §14.2 itself explains that it lets every verifier forge tokens and is NOT RECOMMENDED across domains. Removing it also removes: the verification_mode authorization-detail member, the verification_mode public-metadata member, the pbat_verification_modes_supported metadata member (in both the AS and RS registries), the VerifyPrivate operation, a branch in §13 step 7, and a registry column. That's a lot of surface for a mode nobody can use.

Private metadata bit (§11.4) — cut from v1. It's optional, and §5.4 concedes it's "not suitable when the verifier's observable response immediately discloses the bit" — which is essentially always, since §11.4's semantics are "zero means deny the request." §12.1 requires errors not to reveal the bit, but the client observes the denial. The feature defeats itself on its own terms. Removing it also removes the ReadBit operation, the private_metadata members in two objects, out-of-band recovery-key provisioning in §14.1, validation steps 8 and 10, and another registry column.

Redundant envelope members (§12). version, ciphersuite, issuer, and key_id in the presentation envelope must all exactly equal values already in the cryptographically bound public metadata. They add bytes and four consistency checks and carry no information. Public metadata is authoritative; drop them.

Redundant token-response parameters (§10). pbat_policy is deterministically derivable from the authorization details per §11.1, and pbat_public_metadata is the exact byte string the client just sent and must be echoed unchanged. Both are computable client-side. They're useful as debugging aids, not as protocol.

Version negotiation, three ways. version in the envelope, pbat_versions_supported in AS metadata, pbat_versions_supported in RS metadata, plus per-role conformance in §16 — for a protocol with exactly one version. Pick one.

§16 (Conformance) restates normative requirements already stated in the sections that define them, which creates two places to keep in sync.

§21 (Standards-Track Structure and Publication Path) must be deleted before adoption. Publication process does not belong in an RFC. It's also self-refuting: it asserts the document "does not defer the token representation, verification mode, initial policy profile, or protocol ownership to a future document" while deferring the sole mandatory-to-implement ciphersuite to a document that doesn't exist.

§17 (Relationship to Existing Work) is seven subsections where three paragraphs would do. The DPoP subsection (§17.5) is the one with real content — the observation that a stable DPoP key defeats unlinkability is worth keeping.

expires_in duplicates the authoritative nbf/exp in public metadata and can conflict with them.

Writing Quality

The sentence-level prose is genuinely good. BCP 14 keywords are used correctly and with discipline, sentences are well formed, terminology is defined before use, and several sections are better than typical for a -00. §19 (Privacy Considerations) is the strongest part of the document — the distinction between cryptographic unlinkability and end-to-end anonymity, the anonymity-set partitioning analysis, and the deliberate acknowledgment that tags are intentionally linkable, all reflect real understanding. §6.2 (Non-Goals) is honest and useful. §17 demonstrates that the authors have actually read the RFCs they're positioning against.

The document mechanics, however, are in poor shape, and the gap between the two is itself informative:

  • The front page contradicts §21. The header says "Intended status: Informational." §21 says "This document ... is intended for publication as a Proposed Standard. ... It is not an Informational framework."
  • Kramdown source artifacts leaked into the published text. The literal string — middle appears inside the abstract (visible on the Datatracker front page), — back appears before §23, {:numbered=false} appears under Acknowledgments, and roughly eleven {: artwork-align=... artwork-name=...} attribute blocks are scattered through the document after figures.
  • Every reference is degenerate. All 22 RFCs are cited as [RFC2119] IETF, "RFC2119", RFC 2119 — no title, no authors, no date. There is also no split between Normative and Informative references, which is a required element of RFC structure.
  • A document is cited that appears nowhere in the references. The "companion PBAT ciphersuite document" is referenced in the abstract, §8, §21, and §22.7, and is absent from §24.
  • §21 reads as a rebuttal to reviewer feedback, not as specification. Whatever prompted it, the right response was to fix the document rather than add a section arguing about its status.
  • PBAC collides with established usage. "Policy-Based Access Control" is widely used in the authorization space; introducing PBAC as "Policy-Based Authorization Credential" in an authorization WG will cause confusion. Worth renaming.

Taken together — clean prose, broken references, leaked source markup, an unproofread abstract, and a status contradiction on the front page — the pattern suggests text that was substantially generated or assembled and that no author read end to end before submission. That is worth naming directly in feedback, because it bears on how much reviewer time the working group should invest before the authors have done a proofreading pass.

On concision: the ideas here could be communicated in roughly 25 pages. Justification is uneven — the privacy analysis is well argued, but the two optional features (private verification, private metadata bit) consume significant normative surface with justification that amounts to "some deployment might want this," and both come with caveats in the draft that largely negate their stated value.

Background of the Authors

All four authors are at Huawei. None of the four has published an RFC.

David Kretzler (Huawei Heisenberg Research Center, Germany) — 0 RFCs, 1 active draft (this one), 0 expired. New to the IETF. Listed first, and is lead author of the underlying academic work ([PBAT], eprint 2025/2263) and the designated author of the nonexistent ciphersuite companion.

Yong Li (Huawei Heisenberg Research Center, Germany) — 0 RFCs, 3 active drafts, 12 expired. The draft carries Li's name, and Li is the experienced IETF hand here, with a document history stretching back through FORCES, RADEXT, SFC, ANIMA, ACE, NVO3, and CCAMP. Notably: twelve expired drafts and no RFCs, which is a long record of work that didn't converge. Currently active in directly adjacent territory — draft-guo-privacypass-token-binding and draft-guo-krb-spake-2fa — so the Privacy Pass overlap in this draft is not accidental.

Jian Wang (Huawei Technologies, Shenzhen) — 0 RFCs, 1 active draft (this one), 0 expired. New to the IETF.

Antoine Fressancourt (Huawei Technologies France) — 0 RFCs, 2 active drafts (this one and draft-iannone-dawn-privacy-considerations), 4 expired (DETNET, SPRING/SRv6 proof-of-transit, AI traffic). The only author with an IETF service role: reviewer for the Internet Area Directorate (intdir). Also engaged in the new DAWN work on agent discovery.

Reading the author list as a whole: this is output from a cryptography research lab (Heisenberg Research Center is Huawei's crypto research group) rather than an implementer-driven proposal, and the document's shape matches — strong on cryptographic framing and privacy analysis, weak on OAuth deployment realities and IETF document mechanics. Two of four authors are writing their first draft. There is no co-author from an OAuth implementation and no Privacy Pass or CFRG participant, despite §21's plan depending entirely on CFRG review. Adding both would materially improve this work's prospects.

Suggested Feedback

If you engage on the list, I'd lead with the two blocking items and hold the design critique for later:

  1. The mandatory ciphersuite document doesn't exist, so nothing here is implementable or reviewable. Ask when it will be submitted, and suggest the WG defer substantive review until it is. This is a fair, non-adversarial gate.
  2. Ask for a proofreading pass — Informational vs. Proposed Standard, the — middle in the abstract, the kramdown artifacts, and the reference section. Framing this as "reviewer time is expensive, please clean this up first" is reasonable and non-personal.
  3. Raise the client-chooses-policy-identity contradiction as the substantive design issue, since it's the one that makes the privacy claim not hold in a deployment following the wire protocol. It needs a redesign, not an edit, and the authors should hear it early.
  4. The access_token overload is a cheap, concrete fix worth stating plainly — it will break existing OAuth tooling.
  5. Point at Privacy Pass and CFRG. Whether OAuth is the right venue for a second privacy-token architecture is a chairs-and-AD question, and it's better asked before adoption than after. The §21 plan (OAuth owns bindings, CFRG owns crypto) is defensible but needs those groups to agree, and no one from either is on the author list.

On the merits: the underlying primitive is interesting and the agent-quota use case is real and charter-adjacent. If the crypto holds up under CFRG review and the policy-authority model gets inverted, there may be something worth pursuing here. But it is a long way from adoption-ready, and the cryptographic dependency means the working group would be adopting a protocol binding for an algorithm nobody has reviewed.