Review · November 20, 2026
"One-Time Refresh Proofs: Replacing Refresh Token Rotation with a Signed Counter"
The problem it's solving
Refresh token rotation logs users out when a token response gets lost.
The AS invalidates the old refresh token when it issues the new one. If the response never arrives, the client retries with the old token. The AS sees a superseded token, treats it as theft, and revokes the grant. The user sees a login screen for no reason.
Grace periods make this rarer. They don't fix it, because the next secret still travels from the AS to the client in a response that may not arrive.
This draft removes the server-to-client secret. The refresh token never changes. The client proves possession of a key on every refresh, and signs a counter that does the theft detection rotation used to do.
How it fits in the working group
This fits the charter. It's a token endpoint extension to RFC 6749: one new parameter on the code exchange, three on the refresh request, and one new error code.
The context is the Security BCP, which requires refresh tokens for public clients to be either sender-constrained or rotated. Sender-constrained means DPoP or mTLS today. This draft is a third option, aimed at clients "unable or unwilling to implement DPoP."
Normative dependencies are light: RFC 6749 and RFC 4648, plus FIPS 186-5 and SEC1 for the key format. DPoP, mTLS, and RFC 9700 are informative.
No new roles and no new relationships. Resource servers are not involved, and access tokens stay bearer tokens.
What the mechanism actually does
Key registration. The client generates a P-256 key pair per authorization. It sends the public key as refresh_pub with the authorization code. The AS stores it with the grant and sets a counter to zero.
Refresh. Each refresh request carries refresh_counter, refresh_nonce, and refresh_proof. The proof is an ECDSA signature over refresh_token.counter.nonce. There is no JWT.
AS processing. After verifying the signature, the AS takes one of three branches:
- The counter is exactly one more than the last accepted value. Issue an access token.
- The (counter, nonce) pair is one the AS already accepted. Return
duplicate_request. Nothing is issued and nothing is revoked. - Anything else. Revoke the grant.
Retry. A client that gets no response resends the same counter and nonce. If the first request never arrived, the retry succeeds. If it did arrive, the client gets duplicate_request, knows that counter was consumed, and moves to the next one. It costs one extra round trip.
Theft detection. Two parties holding the same key will eventually present the same counter with different nonces. The second one triggers revocation. This is the same signal rotation gives, with the same blind spot when the legitimate client is idle.
So how is this different from DPoP?
Less than the draft suggests.
A DPoP-bound refresh token already survives a lost response, because it doesn't need to rotate. The draft's own comparison table says so.
The draft lists "no involvement of resource servers" as an advantage. RFC 9449 Section 5 already lets the AS issue Bearer access tokens to a DPoP client, which binds the refresh token alone. So that is not a difference.
What's left is two things. The proof format is simpler: three concatenated strings instead of a JWS with htu, htm, and a server nonce. And the counter detects a copied key, which plain DPoP does not.
The first is a weak argument. A client that can generate a P-256 key, sign with it, persist state durably, and coordinate a lock across tabs can also build a DPoP proof.
The second is the real contribution. The draft's Open Issue 6 asks whether the counter should be a DPoP extension instead. That is the question the working group should answer first.
Significant interoperability concerns
The signature encoding is not specified. The draft says "an ECDSA signature... base64url encoded." The examples are 64 bytes, so raw r || s. WebCrypto produces that format. OpenSSL, Java, and Apple's Secure Enclave APIs produce DER by default. Two implementations will disagree on day one. This needs one sentence.
No discovery and no confirmation. Nothing tells the client the AS supports this. An AS that ignores refresh_pub returns an ordinary bearer refresh token, and the client can't tell. The protection is silently absent. This needs an AS metadata parameter and an indicator in the token response. The draft lists this as an open issue.
The fragility moves, it doesn't go away. Rotation fails on a lost response. This fails on concurrent refresh. Section 5.4 says two tabs that both read the same counter will get the grant revoked. That is one of the most common ways rotation fails in browser apps today. The same goes for a client restored from a backup with an old counter.
The client's retry rules are too aggressive. Every error other than invalid_grant, invalid_client, and duplicate_request is treated as a lost response and retried. That includes invalid_request and invalid_scope. A client with a malformed request retries forever with a pending attempt it can never clear.
AS consistency is unaddressed. The counter check must be atomic per grant. In a multi-region AS with replication lag, an honest client's next counter can land on a node that hasn't seen the previous one. The "otherwise" branch revokes the grant. The draft explains that branch only as a counter the AS "has already moved past," and doesn't discuss a counter that is ahead. The section on this is listed as not yet written.
"Detected" overstates the in-client attacker case. The comparison table says an attacker executing in the client is detected. An attacker running in the client can sign with the key and also rewrite the client's stored counter, so no conflict ever appears. The browser-based apps BCP makes this point about rotation, and it applies here unchanged.
Smaller items:
- The signature covers only the refresh token, counter, and nonce.
scopeandresourceare not signed. An attacker who captures and withholds a request can change them before delivering it. - The draft never says it satisfies the RFC 9700 sender-constraining requirement. It should say so, or say it updates RFC 9700.
- Confidential clients are not mentioned.
- Only the authorization code grant is covered.
- P-256 only, with no agility. That's a reasonable choice for an experiment, but it needs a stated position.
- IANA registrations for four parameters and one error code are missing.
Mechanisms that could be removed
Very little. The spec is already minimal.
The 65-octet SEC1 public key encoding is a custom format where a JWK or JWK thumbprint would match the rest of OAuth. It saves a few lines of client code and costs a new encoding for AS implementers to validate.
The larger question is whether the whole proof format should exist. Defining the counter and nonce as claims in a DPoP proof at the token endpoint would drop refresh_pub, refresh_proof, and the signing input definition. It would keep the one new idea.
Worth keeping: the rule that a failed signature must not revoke the grant, the rule that a duplicate must not be answered with a new access token, and the detailed client state machine in Section 5. Those are what make the retry behavior safe.
Writing quality
Very good. This is one of the clearer -00 drafts in the queue.
The body is about nine pages. Sentences are short and each requirement comes with its reason. BCP 14 language is used correctly. The framing of rotation as "an exactly-once operation carried over a transport that offers at-most-once delivery" explains the whole problem in one line.
The security considerations are honest about limits. The capture-and-withhold attack and the one-refresh delay in detection are both stated plainly.
It is also openly unfinished. Appendix B lists eight open issues, including missing sections on key storage, denial of service, AS consistency, metadata, and IANA. All parameter names are marked as placeholders. That's fine for a -00, and the list is a useful agenda for discussion.
I did not verify the example signatures. The draft says they are real.
Background of the author
Maxwell Gerber (Twilio). No published RFCs. His Datatracker profile lists two active individual drafts, this one and Client Metadata Lookup, both submitted this month. No expired drafts.
He is also listed as a co-author of Deferred Token Response, which the working group adopted this year.
So he's a new IETF author who is writing actively and has already taken one draft through adoption.
Questions for the working group
So what should the working group decide?
- Is the counter better specified as a DPoP extension? That would give DPoP clients clone detection and avoid a second proof format.
- Is "DPoP is too hard" a real barrier for clients that can already manage keys, durable state, and cross-tab locking?
- Does trading lost-response failures for concurrent-refresh failures actually reduce unexpected logouts in practice? Deployment data from Twilio or others would help.
- Does a proof-bound, non-rotating refresh token satisfy RFC 9700 as written, or does that need an update?