Suped

IETF email OAuth draft adds refresh keys to detect token replay

News
Published 18 Nov 2026
Updated 18 Nov 2026
7 min read
Summarize with
A mail envelope and refresh key above the article title.
The IETF's active MAILMAINT working group draft adds a refresh_key parameter to distinguish a native mail client's retry after a lost response from reuse of a stolen refresh token. Sections 6.3 and 6.4 of revision 07 describe how a qualifying retry recovers the same replacement refresh token without another rotation.
As of November 19, 2026 in Australia/Sydney (November 18 UTC), this is work in progress with intended status Informational. It is not a final RFC, is not approved, and is not current production guidance. There is no announced provider rollout or deployment deadline. Datatracker new-revision event 1247526 records publication at 23:21:47 UTC on November 16, which is November 17 in Sydney.

What changes against revision 06

Compared with revision 06, the main new mechanism is a request-specific refresh key. Token-destination checks and DPoP safeguards already existed, and Suped covered those in our September coverage. The November revision changes how clients recover an interrupted refresh without giving ordinary stolen-token reuse the same recovery path.
The audience is native mail client and authorization-server maintainers working with IMAP, SMTP, POP or JMAP. The profile also covers CalDAV and CardDAV. Browser-based and server-hosted web clients are outside its scope, even though a native application uses a browser during user authorization.
Revision 06
Recovery depends on a window before replacement-token use. Observed access-token use can close that window earlier. After that window closes, the server rejects the old refresh token and SHOULD revoke the authorization.
Revision 07
Recovery requires the recorded refresh key and an unused replacement refresh token. Superseded-token reuse outside that exception MUST trigger rejection and revocation of the entire authorization.

How the client preserves a refresh request

A refresh token obtains subsequent access tokens. The proposed refresh key is a separate, temporary secret identifying one refresh operation. It is a high-entropy cryptographically random string generated like a PKCE code verifier, rather than a DPoP private key or a permanent device identifier.
I treat the lost-response case as a storage problem first: a request that reached the server must remain recoverable after the application restarts. Under the proposal, the client retains durable state for that exact operation.
  1. Generate once. Create a fresh key for each new refresh operation. Never use one key with different refresh tokens.
  2. Persist before sending. Store the key with the refresh token being presented, protecting both as credentials, before making the network request.
  3. Repeat the operation. Retries use the same refresh token, exact key and other request parameters. A timeout does not justify generating another key.
  4. Keep pending state. Retain the key until a successful response is persisted, or invalid_grant or invalid_client is received. Network failures, server errors and malformed responses do not end the operation.
  5. Commit before use. Persist a rotated refresh token before using the access token returned beside it. Discard the pending key after completion or either terminal error.
A restart therefore resumes the outstanding request. It does not turn an uncertain result into a new refresh operation with new credentials.

When the server returns the same replacement

The recovery exception has strict conditions: the presented token must be the most recently superseded token, the request must carry its recorded refresh key, and the replacement refresh token must remain unused. A successful refresh is what counts as using that replacement.
When those conditions hold, the server must return the same replacement refresh token it issued originally. It must not rotate again. The access token can be newly issued, so the recovered response need not be identical in every field.
Illustrative lost-response recovery, not a production requesttext
Initial request: refresh token R0 + refresh key K0 Server records: R0 superseded; key K0; replacement R1 unused Lost response: client still holds R0 + K0 Matching retry: return R1 again, never issue R2
Returning the original access token has extra conditions. Resource parameters must match, DPoP must use the same key or be absent in both requests, and at least 10 minutes of the access token lifetime must remain. Its reported remaining lifetime must account for elapsed time.
Those 10 minutes are not a retry deadline. Recovery can happen much later after a lost response, provided the authorization remains valid and the replacement refresh token has not been used. A new access token handles an expired original one.

Which reuse requires revocation

Every other presentation of a superseded refresh token must fail with invalid_grant. Revision 07 also requires revocation of the entire authorization, including the current refresh token and all associated access tokens. That MUST replaces the earlier SHOULD. The rule applies even when the superseded token was sender-constrained.
A rotating-token request without a refresh key gets no recovery exception. The old token becomes invalid when its replacement is issued, and later reuse triggers rejection and revocation. The draft text therefore preserves strict replay handling for requests that omit the new parameter.

Condition

Refresh result

Authorization

Matching eligible retry
Same replacement
Retained
Wrong or absent key
invalid_grant
Revoked
Older superseded token
invalid_grant
Revoked
Replacement already used
invalid_grant
Revoked
Outcomes when a superseded refresh token is presented.
Consider a stolen token without its pending key. If the legitimate client refreshes first, a later request carrying the stolen old token fails the key check and revokes the authorization. If the attacker refreshes first, the legitimate client later presents the superseded token with a different key, triggering revocation then. Detection depends on conflicting reuse becoming visible; this is not a promise that a stolen token can never be used before detection.

Storage and concurrency are part of the mechanism

Servers must recognize every superseded refresh token while its authorization remains valid, although only the latest superseded token needs its recorded refresh key retained. The draft recommends storing a hash of that key and prohibits logging refresh keys. Servers also need a way to reproduce the replacement token for an eligible retry.
Processing for one authorization must be atomic. Otherwise simultaneous requests risk issuing competing replacements or accepting a retry after the replacement was used. Clients must serialize requests sharing a refresh token. Separate devices need separate authorizations rather than a shared refresh token.
The server checks superseded-token status before validating other request parameters. This ordering ensures that an old credential triggers the required replay handling rather than escaping that handling through an unrelated parameter error.
A refresh key is credential material
The mechanism distinguishes an eligible retry from possession of an old token alone. Theft of both the token and its pending refresh key still permits recovery of the replacement. It does not prevent credential theft or fix every phishing scenario. Subsequent conflicting reuse is what triggers revocation.
Rotation is not compulsory in every case. Sender-constrained refresh tokens, including tokens bound to a DPoP key, remain an allowed alternative. In that path the server can retain the same refresh token or omit a replacement. The new refresh key does not make those protection methods interchangeable.

Keep mailbox authorization separate from domain authentication

OAuth governs access to an account. SPF checks sending authorization, DKIM verifies message signatures, and DMARC checks authentication against the visible From domain. A message sent through a compromised authorized account can pass those checks. This draft creates no reason to change DNS records.
Suped, our DMARC and email authentication platform, covers that separate domain-authentication workflow. Its DMARC monitoring helps investigate sending sources and authentication failures. Suped's email tester checks a real message's authentication results. Neither result verifies an authorization server's refresh-key state machine or detects OAuth token replay.

Review isolated prototypes before changing deployed requests

I'd start an isolated prototype by dropping the response after the server commits its rotation, then restarting the client before it saves the replacement. The expected result is recovery of the same replacement token with the saved key. Tests should also exercise wrong keys and older superseded tokens, plus concurrent requests.
A second test should retry after the original access token expires. Recovery must still return the same unused replacement refresh token, alongside a new access token. Also verify that a timeout preserves the pending key and that an invalid_grant response ends the retry instead of starting another rotation attempt.
That is review and testing of a proposal, not a recommendation to add refresh_key to deployed OAuth requests now. There is no universal implementation support established by this publication. Maintainers need coordinated interoperability testing and further draft review before treating the proposed behavior as a production contract.

Frequency asked questions

No. It is an active MAILMAINT working group Internet-Draft with intended status Informational. It remains work in progress, without a provider rollout or deployment deadline.

No. A new operation needs a fresh key, but retries retain the original key, refresh token and other parameters until the response is persisted or a terminal error ends the operation.

No. It limits reuse of the original access token in a recovered response. The server can issue a new access token while returning the same eligible replacement refresh token.

No. The draft allows sender-constrained refresh tokens as an alternative. Rotation is required for refresh tokens that are not sender-constrained, with the defined exception for eligible retries.
DMARC monitoring

Start monitoring your DMARC reports today

Suped DMARC platform dashboard
What you'll get with Suped
Real-time DMARC report monitoring and analysis
Automated alerts for authentication failures
Clear recommendations to improve email deliverability
Protection against phishing and domain spoofing