Native apps and digital identity wallets cannot keep a client secret, yet issuers and high-assurance APIs need to know that a request comes from a genuine, uncompromised instance of a known app. OAuth 2.0 Attestation-Based Client Authentication solves this by letting the app's own backend (the Client Attester) vouch for each app instance with a short-lived signed attestation bound to a key held by that instance, which the instance then proves possession of on every request. It is the client authentication method behind Wallet Attestations in OpenID for Verifiable Credential Issuance and is required by the OpenID4VC High Assurance Interoperability Profile (HAIP). This guide explains the artefacts, the verification rules, the DPoP combined mode, how it differs from private_key_jwt and mTLS, and how to deploy it as an authorisation server or app provider. It is written for identity architects, wallet and mobile security engineers and credential issuers.
Key takeaways
- It is still an Internet-Draft. The current version is draft-ietf-oauth-attestation-based-client-auth-12 (13 October 2026), in the IETF OAuth working group with consensus reached and waiting for write-up, intended for Standards Track (checked 27 October 2026). Details can still change.
- Two JWTs, two signers. The Client Attestation JWT is signed by the Client Attester and carries the instance key in
cnf; the Client Attestation PoP JWT is signed by the instance with that key, for one audience, with a uniquejti. - Front channel by design. The attester never talks to the authorisation server, so it cannot see which issuer a wallet uses, which is the privacy property that
private_key_jwtlacks in issuer, holder and verifier ecosystems. - The attestation is only as good as the attester. The draft states that claims in a Client Attestation are assertions by the attester; trust management and attester key resolution are out of scope and must come from your ecosystem.
- Bind everything to the instance key. Refresh tokens must be bound to the client instance key, and binding authorisation codes through PAR is recommended, so stolen tokens are useless without the device-held key.
Why a new client authentication method
- Public clients are weak: a mobile app distributed to millions of devices cannot hold a shared secret, so under RFC 6749 it is a public client and the server learns nothing about which app or device is calling.
- Platform attestations are not portable: Apple App Attest and Android Play Integrity prove app integrity, but each has its own format and trust chain. The draft's introduction describes transforming such platform mechanisms into a common format to reduce the work for authorisation servers.
- Backend-to-server authentication leaks behaviour: with
private_key_jwtthe app backend would authenticate directly to each issuer, letting the wallet provider correlate which holder talks to which issuer. Attestation-based authentication moves the authentication to the front channel. - Instance-level identity: the server can distinguish individual installations, bind tokens to them and refuse a compromised one, rather than treating every copy of an app as the same client.
Apple's App Attest documentation illustrates the platform layer underneath: the app generates a key in the Secure Enclave, Apple certifies that the key belongs to a valid instance of the app, the server issues a challenge of at least 16 bytes to prevent replay, and keys do not survive reinstallation, device migration or restore from backup. A wallet provider's backend typically verifies such platform evidence before it issues its own attestation; the OpenID4VCI specification names iOS DeviceCheck and Android Play Integrity as examples.
The artefacts in detail
| Element | Client Attestation JWT | Client Attestation PoP JWT |
|---|---|---|
| Signed by | Client Attester (signature, or MAC in tightly coupled deployments) | Client instance, asymmetric signature with the cnf key |
typ header | oauth-client-attestation+jwt (profiles may override) | oauth-client-attestation-pop+jwt |
| Required claims | sub (the client_id), exp, iat, cnf with a jwk | aud (AS issuer identifier or RS resource identifier), jti, iat |
| Optional | Additional claims about the instance (ignored if not understood) | challenge from the server |
| HTTP header | OAuth-Client-Attestation | OAuth-Client-Attestation-PoP |
| Lifetime | Reusable across requests until exp; validity period controls reuse | One per request and per audience |
Both headers are HTTP Structured Fields carrying the compact JWT. Because they travel in headers, the draft warns that default web server header size limits (commonly 8 kB or more) can reject requests; test proxies and gateways early.
Ways to use it
- As client authentication: token endpoint authentication methods
attest_jwt_client_authandattest_jwt_client_auth_dpop. If the request containsclient_id, the server must check it equals the attestationsub. - As an additional security signal: alongside another client authentication method, advertised through
client_attestation_pop_methods_supportedwith valuesattestation_pop_jwt,dpop_combinedandnone(attestation optional). - At resource servers: the PoP
audbecomes the RFC 9728 resource identifier, so APIs can also demand an attested client.
DPoP combined mode
When the client instance key and the DPoP key are the same key pair, one DPoP proof can serve as both the DPoP proof and the attestation proof of possession. Freshness then relies only on DPoP server nonces, and the server's challenge endpoint should return a fresh DPoP-Nonce. The draft notes that the dpop_jkt authorisation request parameter cannot replace an actual DPoP proof in combined mode. Combined mode halves the signing work on the device, which matters when each signature needs user verification on a secure element. See the DPoP Guide.
Verification rules for authorisation and resource servers
- Exactly one attestation header containing a JWT with all required header parameters and claims.
- Algorithm check:
algis registered, notnone, supported and acceptable by local policy. - Attester trust: the signature verifies with the key of a known and trusted Client Attester, resolved through an
x5cchain to a trust anchor,kidwithjku, orkidwith pre-shared client metadata. - Key sanity: the
cnfkey is a public key, not a private key. - Freshness:
iatorexpacceptable under local policy; otherwise returnuse_fresh_attestation. - Client match:
client_id, if present, equalssubunless a profile redefines this. - PoP: exactly one PoP header, signed by the
cnfkey,audequal to this server,iator server challenge within the acceptable window, and the expectedchallengeif you issue them (otherwiseuse_attestation_challengewith a new challenge inOAuth-Client-Attestation-Challenge). - Replay: reject repeated
jtiorchallengevalues within a sliding window; the draft suggests trie or radix tree structures at high volume. - Errors:
invalid_client_attestation(alongsideinvalid_client) for verification failures, normally with HTTP 400, optionally 401.
Comparing client authentication options
| Method | Suited to | Instance-level identity | Privacy from attester | Key custody | Main weakness |
|---|---|---|---|---|---|
client_secret_basic or _post | Server-side apps | No | Not applicable | Shared secret | Secret theft and sprawl |
private_key_jwt (RFC 7523) | Server-side confidential clients | No, per client | Backend contacts every server | Backend key | Unsuitable for millions of devices |
| mTLS (RFC 8705) | Server-side, regulated APIs | Per certificate | Backend contacts every server | Certificate key | PKI operations, poor fit for mobile |
| Public client with PKCE only | Low-assurance mobile and SPA | No | Yes | None | No proof the app is genuine |
| Attestation-based | Wallets, high-assurance native apps | Yes, via cnf key | Yes, front channel | Device key (ideally hardware-backed) | Depends on attester trust and platform integrity |
- Choose attestation-based authentication when you must authenticate a client that runs on end-user devices at a level above a public client, and especially in issuer, holder and verifier ecosystems where unlinkability matters.
- Stay with
private_key_jwtor mTLS for server-side clients; the draft offers nothing extra there. See the JWT Client Authentication (private_key_jwt) Guide. - Use it as an additional signal first if you already authenticate apps another way and want to add device integrity gradually.
Wallet ecosystems: OpenID4VCI and HAIP
- Wallet Attestation: OpenID4VCI 1.0 (OpenID Foundation Final, 16 September 2025) defines a Wallet Attestation that follows the draft's Client Attestation JWT and adds optional
wallet_name,wallet_linkandstatusclaims. Wallets send it with the Pushed Authorization Request and the Token Request, and for privacy thesubis the same across all instances from one wallet provider. - HAIP requirements: HAIP 1.0 (Final, December 2025) states that "Wallets MUST use, and Issuers MUST require, an OAuth2 Client authentication mechanism", that wallets authenticate at the PAR and token endpoints with a Wallet Attestation, and that "Wallet Attestations MUST NOT be reused across different Issuers". It also requires wallets to support key attestations, DPoP and PKCE with S256.
- Key attestation is different: the wallet attestation authenticates the app instance; a key attestation (OpenID4VCI
key-attestation+jwt, withkey_storageanduser_authenticationvalues such asiso_18045_high) describes the keys credentials will be bound to. Issuers usually need both. - Status of attestations: both attestation types can carry a
statusclaim pointing to a Token Status List, so a wallet provider can revoke attestations for compromised app versions. See the Token Status List and Credential Revocation Guide.
For the EU context, see the Wallet Unit Attestation and Device-Bound Keys Guide and the EUDI Wallet Architecture and Reference Framework Guide.
Worked example: a wallet obtaining a credential
- Instance key: on first launch the wallet app generates a key pair in secure hardware and obtains platform integrity evidence (for example an App Attest attestation bound to a server challenge).
- Attestation from the provider: the wallet provider's backend verifies that evidence, checks the app version is not blocked, and returns a Client Attestation JWT with
subset to the wallet'sclient_id, the instance public key incnf, and an expiry of a few hours. The backend never learns which issuer the wallet will contact. - Challenge: the wallet calls the issuer's
challenge_endpointand receives anattestation_challengeand, if DPoP nonces are used, aDPoP-Nonce. - PAR: the wallet pushes its authorisation request with the
OAuth-Client-Attestationheader and either a PoP JWT (aud= issuer's authorisation server, freshjti, the challenge) or a DPoP proof in combined mode. The server verifies attester trust, the PoP and the challenge, and binds the resulting authorisation code to the instance key. - Token request: after user authentication the wallet redeems the code with a new PoP (new
jti), receives a DPoP-bound access token and a refresh token bound to the instance key. - Credential request: the wallet sends key proofs or a key attestation for the keys the credential will be bound to; the issuer can now trust both the app instance and the key storage.
An attacker who copies the access token, refresh token and attestation from network logs still fails at step 5 or on refresh, because each request needs a fresh signature from the hardware-held instance key.
Implementation roadmap
- Define the trust framework: which attesters you accept, how their keys are distributed (trust list,
x5canchors or registered metadata), and what an attester must check before issuing (platform integrity verdict, app version, key in secure hardware). - Build the attester: verify platform evidence, issue short-lived attestations with
cnfbound to a device key, round or randomiseiatandexpas the draft recommends to reduce correlation, and issue different attestations and keys per authorisation server. - Enable server support in signal mode: advertise
client_attestation_pop_methods_supportedincludingnone, accept and log attestations without enforcing. - Add replay protection: implement
jtitracking or a challenge endpoint (challenge_endpointreturningattestation_challengewithCache-Control: no-store). - Bind artefacts: bind authorisation codes via PAR and refresh tokens to the instance key, and require the same key on refresh.
- Enforce: register
attest_jwt_client_authorattest_jwt_client_auth_dpopas the required method for the client, removingnone. - Plan key rotation and rollback: the draft has no rotation mechanism, so a new instance key requires a new attestation and existing bound refresh tokens are lost; keep enforcement per client so it can be relaxed to signal mode if an attester outage blocks users.
Detection and measurement
- Attestation failures by reason: expired, untrusted attester, signature failure,
submismatch, replayedjti. A rise in replays or mismatches can indicate token theft tooling. - Reuse patterns: the same attestation or instance key seen from many IP ranges or at several issuers in a HAIP ecosystem breaks the no-reuse rule and suggests cloning.
- Revocation: track how quickly a compromised app version's attestations are revoked through status lists.
- Threat mapping: attestation and instance binding raise the cost of using stolen tokens (MITRE ATT&CK T1528 Steal Application Access Token, T1550.001 Application Access Token) and of repackaged or impersonating apps (T1036 Masquerading).
| Metric | Target |
|---|---|
| Token requests from native clients carrying a valid attestation | 100% for enforced clients |
| Refresh tokens bound to an instance key | 100% where attestation is used |
| Replay rejections investigated | All spikes triaged within one working day |
| Maximum attestation lifetime issued by the attester | Within policy (for example hours, not months) |
| Time to revoke attestations for a vulnerable app version | Within your incident SLA |
Framework mapping
| Framework | Reference | Relevance |
|---|---|---|
| NIST SP 800-53 Rev. 5 | IA-3 Device Identification and Authentication; IA-9 Service Identification and Authentication | Authenticating app instances and their devices |
| NIST SP 800-53 Rev. 5 | IA-5 Authenticator Management; SC-12 Cryptographic Key Establishment and Management | Instance keys, attester keys, rotation |
| NIST SP 800-53 Rev. 5 | SI-7(15) Code Authentication | Platform integrity evidence behind the attestation |
| NIST CSF 2.0 | PR.AA-01, PR.AA-03 | Managing and authenticating service and hardware identities |
| OWASP ASVS 5.0 | V10.4.10 | Confidential client authentication on back-channel requests including PAR |
| IETF RFC 9334 | RATS Passport model | The draft describes its flow as related to the Passport model |
Common failure patterns
- Attesting without checking the platform: an attester that issues attestations to any caller with a valid app login turns the scheme into an expensive bearer token.
- Software-only instance keys: a
cnfkey that can be exported lets an attacker clone the instance; use hardware-backed keys and say so through key attestation. - Long-lived attestations: reuse is allowed until
exp, so month-long attestations outlive the integrity verdict they were based on. - Same attestation everywhere: reusing one attestation and key across issuers enables correlation and violates HAIP.
- No replay tracking: accepting any PoP with a recent
iatlets a captured request be replayed within the window. - Unbound refresh tokens: binding only to the client, not the instance key, lets a stolen refresh token work from anywhere. See the OAuth Refresh Token Rotation and Expiry Guide.
Practitioner checklist
- Record the draft version you implement and re-check the IETF Datatracker before each release.
- Publish a trust list or anchor set for accepted Client Attesters and how their keys are resolved.
- Require the attester to verify platform integrity and a hardware-backed instance key before issuing.
- Keep attestation lifetimes short and round or randomise
iatandexp. - Issue distinct attestations and keys per authorisation server.
- Enforce PoP audience,
jtireplay tracking or server challenges. - Bind authorisation codes via PAR and refresh tokens to the instance key.
- Roll out in signal mode, then enforce per client with a documented fallback.
Standards and references
- IETF: OAuth 2.0 Attestation-Based Client Authentication (Internet-Draft)
- OpenID Foundation: OpenID for Verifiable Credential Issuance 1.0
- OpenID Foundation: OpenID4VC High Assurance Interoperability Profile 1.0
- IETF: RFC 9334 Remote ATtestation procedureS (RATS) Architecture
- Apple Developer: Establishing your app's integrity
- OWASP: Application Security Verification Standard 5.0
Related NHI Mgmt Group resources: OAuth for Native and Mobile Apps Guide · Wallet Unit Attestation and Device-Bound Keys Guide · OpenID for Verifiable Credential Issuance Guide · OAuth Pushed Authorization Requests and JAR Guide