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

Review · September 2, 2026

The X.509 Assertion the Authorization Server Isn't Allowed to Trust

draft-kemp-oauth-x509-bearer -00View on Datatracker →

The problem it's solving

Workloads already have certificates. SPIFFE/SPIRE and Athenz hand every service a short-lived X.509 cert with a spiffe:// URI SAN, rotate it automatically, and use it for mutual TLS between services. That infrastructure exists and is in production.

So why should a workload stand up a separate JWT issuer just to get an OAuth access token?

That's the pitch. RFC 7521 has a JWT profile and a SAML profile. There's no X.509 profile. This draft fills that slot: two new URNs, one grant type and one client authentication method, both carrying a certificate as the assertion value.

The draft is clear-eyed about the obvious trap. A certificate is not a secret. It goes over the wire in the clear during every TLS handshake, gets logged by intermediaries, and for public CAs ends up in Certificate Transparency logs. So Section 3 item 7 requires that possession of the private key be corroborated on every single request, either through mutual TLS to the token endpoint or through an attestation from a trusted TLS-terminating proxy.

That requirement is the right call. It's also what unravels the rest of the document.

How it fits in the working group

The OAuth working group already adopted a draft for this. draft-ietf-oauth-spiffe-client-auth is at -02, and its Section 3.2 covers X.509-SVID client authentication: establish mutual TLS with the AS, validate the chain, confirm exactly one URI SAN with a valid SPIFFE ID, confirm it's a leaf with digitalSignature set, match the SPIFFE ID to a registered client. Same certificates, same SPIFFE deployments, same URI SAN extraction.

It does all of that by reusing RFC 8705 as-is. No new grant type. No new client_assertion_type. No new IANA registration. And it goes further than this draft does, specifying SPIFFE bundle endpoints for trust anchor distribution and spiffe_id / spiffe_bundle_endpoint client registration metadata.

This draft doesn't cite it. It also doesn't cite draft-ietf-wimse-mutual-tls, which profiles workload identity certificates for mTLS in the WIMSE working group, or attestation-based client authentication, which the SPIFFE draft builds on for WIT-SVIDs.

The subject matter is squarely in charter. The WG demonstrated that by adopting the SPIFFE draft. The problem is that half of this document duplicates adopted work using a more complicated mechanism, and the other half doesn't do anything.

Dependency count is modest: RFC 6749, RFC 7521, and RFC 5280 normatively, plus RFC 8705, RFC 9846, RFC 6960, and RFC 6755 in practice.

What the mechanism actually does

Two parameter bindings, both straightforward.

For grants: grant_type=urn:ietf:params:oauth:grant-type:x509-bearer and assertion set to the unpadded base64url of the certificate's DER encoding. For client authentication: client_assertion_type=urn:ietf:params:oauth:client-assertion-type:x509-bearer with the same encoding in client_assertion. Exactly one certificate, no chain.

Section 3 then maps certificate fields onto JWT claims. Issuer plays iss. Subject or subjectAltName plays sub, and for workload certs the AS SHOULD prefer the URI SAN because the Subject is usually empty. notBefore and notAfter play nbf and exp. The pair (Issuer, serialNumber) plays jti. There's no aud equivalent in RFC 5280, so audience restriction moves entirely out of band.

Section 2.3 adds a shorthand. If the client already presented the cert over mutual TLS, it can send x5t#S256: followed by the base64url SHA-256 digest instead of the whole certificate, computed the same way as RFC 8705's confirmation method.

Section 3.3 recommends binding the issued access token to the same certificate using RFC 8705's certificate-bound token mechanism. That part is sensible and carries the possession property through to the resource server.

The assertion parameter carries nothing

Read item 7 next to Section 2.3 and Section 6.

Item 7 gives the AS exactly two ways to corroborate possession. Mechanism A: the certificate in the assertion is the same one the client presented in the TLS handshake. Mechanism B: a trusted intermediary forwarded the certificate along with an attestation that it authenticated the TLS client.

Then Section 2.3 says the AS "MUST NOT accept a thumbprint reference together with a certificate supplied elsewhere in the client's request as if the two were mutually corroborating; the certificate the thumbprint is checked against MUST come from the TLS layer or a trusted intermediary, never from the request itself." Section 6 repeats it for emphasis.

In both corroboration paths the AS obtains the authoritative certificate from outside the request body. The copy in assertion is compared against it. It can agree or disagree. It can never be the thing the AS relies on.

So the assertion parameter is a consistency check that can only fail. It supplies no identity, no authority, and no information the AS is permitted to act on. Section 2.3's thumbprint form makes this visible, because a digest of a certificate the server already holds is self-evidently zero new bits. The full-certificate form has exactly the same property, just less obviously.

The grant type has no work to do

The client authentication half is redundant with RFC 8705. That's arguable, since the draft could claim it's a cleaner spelling. The grant half is the genuinely novel piece, and it's where the design contradicts itself.

Item 3(A) says that for the authorization grant, "the subject typically identifies an authorized accessor for which the access token is being requested (i.e., the resource owner or an authorized delegate)."

Item 7 says the party presenting the certificate MUST prove possession of the certificate's private key.

Those two can't both hold for a delegate. If the presenter must hold the subject's private key, the presenter is the subject. There is no delegation case, because a delegate doesn't have the subject's key.

That leaves one scenario: a workload proves it holds its own key and receives a token for itself. That is client_credentials with mTLS client authentication, which RFC 8705 has covered since 2020 and which the SPIFFE draft profiles for exactly these certificates.

Compare RFC 7523, where the grant type earns its keep. There the assertion is signed by a third party, says something about a subject the client is not, and is scoped by aud. The client presenting it doesn't hold the subject's key. That's the whole point of bearer semantics, and it's what makes the JWT grant genuinely different from client credentials. Mandatory proof-of-possession removes precisely that capability, and with it the reason for a new grant type to exist.

There's a naming problem sitting on top of this. RFC 7521 Section 3 explicitly distinguishes bearer assertions from holder-of-key assertions. This document defines a holder-of-key assertion and calls it a bearer profile, in the title and in both URNs it wants IANA to register. That should be settled before anything gets registered.

The stated gap isn't a client-facing gap

The introduction gives a second justification: this "accommodates deployments in which TLS is terminated in front of the authorization server's application logic (for example, by a load balancer or reverse proxy)."

RFC 8705 is deployed behind TLS-terminating proxies constantly. The proxy passes the verified client certificate to the AS in a header. That plumbing lives entirely between the proxy and the AS, inside one administrative domain, and nothing about the client's request changes.

Mechanism 7(B) is that same plumbing. The draft requires "an attestation from that intermediary that the certificate was successfully used to authenticate a TLS client," and then defines no format, no header, no attestation syntax, and no way for the AS to distinguish a trusted forwarder from a spoofed header. So the document names a gap and doesn't fill it, while the gap it names doesn't require a client-visible protocol change in the first place.

Significant interoperability concerns

Section 5 is honest, which makes it damning. Seven things require agreement between the AS and the certificate issuer, and the exchange of all of them is "explicitly out of scope":

  • the set of trust anchors and Issuing CAs
  • the rule for mapping Subject or subjectAltName to a resource owner or client_id, configured per CA
  • which Issuing CAs the AS considers itself an intended relying party for, standing in for the missing aud
  • the revocation-checking mechanism
  • which corroboration mechanism is in use, direct mTLS or a forwarding intermediary
  • whether the AS accepts thumbprint references at all
  • any maximum certificate lifetime the AS will accept

Two authorization servers can each claim conformance and share none of it. The SPIFFE draft specifies the bundle endpoint and the client registration metadata, so it actually produces interoperable deployments. This draft leaves the equivalent surface as a bullet list of things someone else should figure out.

There's a real bug in the replay guidance. Item 6 maps (Issuer, serialNumber) to jti and lets the AS "track (Issuer, serialNumber) pairs it has already processed, within a configured window, to detect and reject replayed requests." Section 6 upgrades that from MAY to SHOULD, with the window "derived from the certificate's validity period."

A jti is unique per assertion, and RFC 7523 assertions are minted per request. A certificate serial is unique per certificate, and the certificate is reused for its entire lifetime by design. A workload holding a one-hour SVID will hit the token endpoint many times in that hour with the same (Issuer, serialNumber). An AS following Section 6 rejects everything after the first request. The mechanism breaks the draft's own primary use case.

Smaller items worth fixing:

  • RFC 8705 and RFC 9846 are informative references, but Section 2.3 requires computing the thumbprint identically to RFC 8705 and item 7 requires mutual TLS per RFC 9846. Both are MUST-level dependencies and belong in the normative list, along with RFC 6960 for revocation and RFC 6755 for the IANA registrations.
  • Section 2.1 attributes base64url to RFC 7521. That's RFC 4648.
  • assertion carries exactly one certificate with no chain, so every intermediate has to be pre-configured at the AS. TLS handshakes carry chains, so mechanism 7(A) works fine, but the encoded form can't.
  • The MAY in item 6 and the SHOULD in Section 6 disagree about the same requirement.

Mechanisms that could be removed

Section 2.3 should go entirely. A digest of a certificate the AS is required to already hold, checked against that same certificate, is pure ceremony. Removing it also removes two of the document's normative footguns and one of the seven out-of-band agreement items.

The replay tracking in item 6 and Section 6 should go, for the reasons above. If it stays, it needs to track something that varies per request, and a certificate doesn't.

The privacy considerations read as though carried over from human identity work. Correlating a billing service across relying parties by its stable spiffe:// identifier is the intended behavior of a workload identity system, not a privacy harm in the RFC 6973 sense. Two sentences about not sending certificates over cleartext would cover the real concern.

One thing worth keeping: the observation that a missing aud matters much less here than it would for a bearer JWT, because a third party who copies the certificate still can't complete the handshake. Mandatory proof-of-possession does that work. It's also the strongest argument that RFC 8705 was already sufficient.

Writing quality

Genuinely good. This reads like someone who has written specs before. BCP 14 keywords are used correctly and consistently, the error codes match RFC 6749 (invalid_grant for the grant, invalid_client for client authentication), the examples are complete and correctly percent-encoded, and both security and privacy sections are substantive rather than placeholders.

Section 6 is the best part of the document. "A certificate is therefore not a secret, and a copy of one proves nothing about who is presenting it" is exactly right, and the explicit MUST NOT against authenticating on a syntactically valid certificate alone is the kind of thing that saves an implementer from a bad afternoon.

The prose gets too dense in places. Item 4 is a single sentence covering the missing aud claim, out-of-band agreement, SPIFFE trust domains as a coarse signal, and a possible future certificate extension. Section 5's first paragraph runs past 150 words with seven embedded list items. Both should be broken up. The eight-item structure in Section 3 works well and the rest of the document would benefit from the same treatment.

The submission boilerplate wasn't cleaned up. The affiliation is still "Your Organization Here" and the acknowledgments still say "TODO acknowledge reviewers and contributors."

Background of the author

Sole author, John Kemp. His Datatracker profile shows zero published RFCs, one active Internet-Draft (this one), and no expired drafts. By that record, a first-time IETF author.

The technical content suggests otherwise about operational experience. The SPIFFE and Athenz framing is accurate, the empty-Subject observation for workload certs is the kind of thing you notice from running the software, and the security considerations show real understanding of why the naive version of this idea fails.

No co-authors is the thing I'd flag. A document that overlaps an adopted working group draft usually reflects someone who hasn't seen it yet, and most of what's wrong here would come out of one conversation with the SPIFFE client auth authors. The right next step is probably not a -01. It's a mailing list thread asking whether the grant-type case survives mandatory proof-of-possession, and if it doesn't, whether anything is left that RFC 8705 and the SPIFFE draft don't already cover.