Join our Newsletter — 33% off our NHI Course
Home› Guides› OAuth Attestation-Based Client Authentication Guide: Authenticating Wallets and…
Guide Identity & Access Management (IAM)

OAuth Attestation-Based Client Authentication Guide: Authenticating Wallets and Native App Instances

PDF for newsletter subscribers · free to read online

← All guides
By NHI Mgmt Group, edited by Lalit Choda Updated 27 October 2026 13 min read
On this page

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 unique jti.
  • 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_jwt lacks 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_jwt the 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

ElementClient Attestation JWTClient Attestation PoP JWT
Signed byClient Attester (signature, or MAC in tightly coupled deployments)Client instance, asymmetric signature with the cnf key
typ headeroauth-client-attestation+jwt (profiles may override)oauth-client-attestation-pop+jwt
Required claimssub (the client_id), exp, iat, cnf with a jwkaud (AS issuer identifier or RS resource identifier), jti, iat
OptionalAdditional claims about the instance (ignored if not understood)challenge from the server
HTTP headerOAuth-Client-AttestationOAuth-Client-Attestation-PoP
LifetimeReusable across requests until exp; validity period controls reuseOne 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_auth and attest_jwt_client_auth_dpop. If the request contains client_id, the server must check it equals the attestation sub.
  • As an additional security signal: alongside another client authentication method, advertised through client_attestation_pop_methods_supported with values attestation_pop_jwt, dpop_combined and none (attestation optional).
  • At resource servers: the PoP aud becomes 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

  1. Exactly one attestation header containing a JWT with all required header parameters and claims.
  2. Algorithm check: alg is registered, not none, supported and acceptable by local policy.
  3. Attester trust: the signature verifies with the key of a known and trusted Client Attester, resolved through an x5c chain to a trust anchor, kid with jku, or kid with pre-shared client metadata.
  4. Key sanity: the cnf key is a public key, not a private key.
  5. Freshness: iat or exp acceptable under local policy; otherwise return use_fresh_attestation.
  6. Client match: client_id, if present, equals sub unless a profile redefines this.
  7. PoP: exactly one PoP header, signed by the cnf key, aud equal to this server, iat or server challenge within the acceptable window, and the expected challenge if you issue them (otherwise use_attestation_challenge with a new challenge in OAuth-Client-Attestation-Challenge).
  8. Replay: reject repeated jti or challenge values within a sliding window; the draft suggests trie or radix tree structures at high volume.
  9. Errors: invalid_client_attestation (alongside invalid_client) for verification failures, normally with HTTP 400, optionally 401.

Comparing client authentication options

MethodSuited toInstance-level identityPrivacy from attesterKey custodyMain weakness
client_secret_basic or _postServer-side appsNoNot applicableShared secretSecret theft and sprawl
private_key_jwt (RFC 7523)Server-side confidential clientsNo, per clientBackend contacts every serverBackend keyUnsuitable for millions of devices
mTLS (RFC 8705)Server-side, regulated APIsPer certificateBackend contacts every serverCertificate keyPKI operations, poor fit for mobile
Public client with PKCE onlyLow-assurance mobile and SPANoYesNoneNo proof the app is genuine
Attestation-basedWallets, high-assurance native appsYes, via cnf keyYes, front channelDevice 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_jwt or 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_link and status claims. Wallets send it with the Pushed Authorization Request and the Token Request, and for privacy the sub is 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, with key_storage and user_authentication values such as iso_18045_high) describes the keys credentials will be bound to. Issuers usually need both.
  • Status of attestations: both attestation types can carry a status claim 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

  1. 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).
  2. 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 sub set to the wallet's client_id, the instance public key in cnf, and an expiry of a few hours. The backend never learns which issuer the wallet will contact.
  3. Challenge: the wallet calls the issuer's challenge_endpoint and receives an attestation_challenge and, if DPoP nonces are used, a DPoP-Nonce.
  4. PAR: the wallet pushes its authorisation request with the OAuth-Client-Attestation header and either a PoP JWT (aud = issuer's authorisation server, fresh jti, 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.
  5. 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.
  6. 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

  1. Define the trust framework: which attesters you accept, how their keys are distributed (trust list, x5c anchors or registered metadata), and what an attester must check before issuing (platform integrity verdict, app version, key in secure hardware).
  2. Build the attester: verify platform evidence, issue short-lived attestations with cnf bound to a device key, round or randomise iat and exp as the draft recommends to reduce correlation, and issue different attestations and keys per authorisation server.
  3. Enable server support in signal mode: advertise client_attestation_pop_methods_supported including none, accept and log attestations without enforcing.
  4. Add replay protection: implement jti tracking or a challenge endpoint (challenge_endpoint returning attestation_challenge with Cache-Control: no-store).
  5. Bind artefacts: bind authorisation codes via PAR and refresh tokens to the instance key, and require the same key on refresh.
  6. Enforce: register attest_jwt_client_auth or attest_jwt_client_auth_dpop as the required method for the client, removing none.
  7. 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, sub mismatch, replayed jti. 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).
MetricTarget
Token requests from native clients carrying a valid attestation100% for enforced clients
Refresh tokens bound to an instance key100% where attestation is used
Replay rejections investigatedAll spikes triaged within one working day
Maximum attestation lifetime issued by the attesterWithin policy (for example hours, not months)
Time to revoke attestations for a vulnerable app versionWithin your incident SLA

Framework mapping

FrameworkReferenceRelevance
NIST SP 800-53 Rev. 5IA-3 Device Identification and Authentication; IA-9 Service Identification and AuthenticationAuthenticating app instances and their devices
NIST SP 800-53 Rev. 5IA-5 Authenticator Management; SC-12 Cryptographic Key Establishment and ManagementInstance keys, attester keys, rotation
NIST SP 800-53 Rev. 5SI-7(15) Code AuthenticationPlatform integrity evidence behind the attestation
NIST CSF 2.0PR.AA-01, PR.AA-03Managing and authenticating service and hardware identities
OWASP ASVS 5.0V10.4.10Confidential client authentication on back-channel requests including PAR
IETF RFC 9334RATS Passport modelThe 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 cnf key 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 iat lets 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 iat and exp.
  • Issue distinct attestations and keys per authorisation server.
  • Enforce PoP audience, jti replay 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

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

PDF for subscribers

Take this guide with you

Every section, table and checklist in one PDF, with links to the sources and related guides. Subscribe to our weekly NHI & AI Identity Journal and we’ll email you a download link.

Free weekly newsletter

Subscribe to the NHI & AI Identity Journal

The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.

Bonus 33% off our NHI Course when you subscribe.

NHIMG Editorial Note
Researched and written by the NHI Mgmt Group editorial team using AI tools, under the editorial direction of Lalit Choda. Facts are drawn from the sources listed on this page and checked by our automated quality process. Last updated 27 October 2026. Spotted an error? Use our contact page.
NHI Mgmt Group, the independent authority on Non-Human Identity, IAM and Agentic AI security. nhimg.org

PDF Downloads for Newsletter Subscribers

Get the guide

Enter your details and we’ll email you a download link.

The full guide is free to read online. The PDF is a thank you for subscribing.

Fill in all fields marked * and tick the PDF box to continue.