| Internet-Draft | Actor-Bound Token Exchange | November 2026 |
| Nandakumar & Jennings | Expires 20 May 2027 | [Page] |
In OAuth 2.0 Token Exchange, the client that sends the request receives the token, and with DPoP the token is bound to the key that signed the client's proof. Agent systems often need one party to obtain a token for another: an orchestrating agent that approves an action obtains a token for the agent that will perform it. This document lets a token exchange client request that the issued token be bound to the key of the actor named in the request, and requires the actor to prove possession of that key, so that the token is usable only by the actor and only with its consent.¶
This note is to be removed before publishing as an RFC.¶
Status information for this document may be found at https://datatracker.ietf.org/doc/draft-nandakumar-oauth-actor-bound-token-exchange/.¶
Discussion of this document takes place on the Web Authorization Protocol Working Group mailing list (mailto:oauth@ietf.org), which is archived at https://mailarchive.ietf.org/arch/browse/oauth/. Subscribe at https://www.ietf.org/mailman/listinfo/oauth/.¶
This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.¶
Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.¶
Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."¶
This Internet-Draft will expire on 20 May 2027.¶
Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved.¶
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Revised BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Revised BSD License.¶
OAuth 2.0 Token Exchange [RFC8693] lets a client present a subject
token, and optionally an actor token (Section 2.1 of [RFC8693]), and
receive a new token that can name the actor in its act claim
(Section 4.1 of [RFC8693]). With DPoP [RFC9449], the authorization
server binds the issued token to the public key in the DPoP proof of
the token request (Section 5 of [RFC9449]); with mutual TLS
[RFC8705], to the client's certificate. In both cases the token is
bound to the requesting client.¶
Some deployments need the token to be bound to the actor instead:¶
An agent that delegated a task approves one action that the performing agent asked for, and obtains a token for that action on the performing agent's behalf. The performing agent must be able to use the token; the approving agent should not.¶
An orchestrator provisions a token for a sub-agent that has no relationship with the authorization server.¶
The approving party could send its own token to the actor, but then
the actor holds a token bound to someone else's key, which it cannot
use, or a bearer token, which anyone can use. Identity chaining
[ID-CHAINING] binds a token to another client's key with a
requested_cnf claim inside a JWT authorization grant, between
authorization servers. This document provides the equivalent for a
client of one authorization server, with proof from the actor.¶
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.¶
The OAuth client that sends the token exchange request.¶
The party named by the actor token, to whose key the issued token is bound.¶
A JWT signed by the actor that proves possession of its key and authorizes binding a token to it (Section 2.2).¶
The requesting client sends a token exchange request (Section 2.1 of [RFC8693]) with:¶
actor_token and actor_token_type: a token that identifies the
actor and contains a cnf claim [RFC7800] confirming the actor's
key, such as a DPoP-bound access token or a WIMSE Workload Identity
Token [WIMSE-CREDS];¶
actor_proof: an actor proof (Section 2.2); and¶
actor_authorization_details: OPTIONAL. The authorization_details
[RFC9396] over which the actor computed azh, as a JSON array
serialized and encoded like authorization_details. The requesting
client MUST send it when the actor proof carries azh and the
request's authorization_details are not the ones the actor hashed,
for example because an approver narrowed them.¶
This document applies only to a request that carries actor_proof.
A token exchange request without it is processed as [RFC8693]
defines, even when it carries an actor token.¶
The requesting client authenticates as usual and MAY send its own DPoP
proof. When the request carries actor_proof, the issued token is not
bound to the key of that DPoP proof.¶
POST /token HTTP/1.1 Host: as.example.com Content-Type: application/x-www-form-urlencoded DPoP: eyJ...(requesting client's proof) grant_type=urn:ietf:params:oauth:grant-type:token-exchange &subject_token=eyJ...(approver's token) &subject_token_type=urn:ietf:params:oauth:token-type:access_token &actor_token=eyJ...(performing agent's credential, with cnf) &actor_token_type=urn:ietf:params:oauth:token-type:jwt &actor_proof=eyJ...(signed by the performing agent's key) &authorization_details=%5B%7B%22type%22...¶
An actor proof is a JWT [RFC7519], signed with JWS [RFC7515] by the
private key confirmed by the actor token's cnf.¶
Its JOSE header contains:¶
REQUIRED. actor-proof+jwt.¶
REQUIRED. An asymmetric digital signature algorithm. It MUST NOT be
none or a MAC algorithm.¶
The public key, as a JWK, when the actor token's cnf carries a
thumbprint (jkt) rather than the key itself; or the certificate
chain, when cnf carries a certificate thumbprint (x5t#S256)
[RFC8705]. Omitted when cnf carries the key (jwk).¶
Its claims are:¶
REQUIRED. The authorization server's issuer identifier [RFC8414].¶
REQUIRED. jti is a unique identifier for the proof. The actor sets
exp as soon after iat as the flow allows: a proof that waits for
a person's approval needs longer than one used at once. An
authorization server MAY reject a proof whose lifetime exceeds its
policy.¶
REQUIRED. The base64url-encoded SHA-256 hash [RFC6234] of the ASCII encoding of the actor token's value, binding the proof to it.¶
OPTIONAL. The base64url-encoded SHA-256 hash of the JSON
Canonicalization Scheme [RFC8785] form of the
authorization_details [RFC9396] the actor asks for. When present,
the issued token's authorization details MUST be equal to, or
narrower than, those hashed. A hash shows only equality; to issue
narrower details the authorization server needs the hashed details
themselves, which the requesting client sends in
actor_authorization_details.¶
OPTIONAL. A nonce the authorization server supplied, as for DPoP (Section 8 of [RFC9449]).¶
The actor creates the proof and gives it to the requesting client, for
example inside the message in which it asks for approval. The actor
need not contact the authorization server. An actor SHOULD include
azh: without it, the requesting client can use the proof to bind any
token it can obtain to the actor's key until the proof expires
(Section 5).¶
The requesting client gives the token to the actor. The actor presents it to the resource server with a DPoP proof made with its own key, or over mutual TLS with its own certificate. A resource server processes the token as any sender-constrained token; it needs no change.¶
Transaction-bound tokens, such as those issued after an OAuth Transaction Authorization Challenge [TXN-CHALLENGE] or Transactional Access Tokens [TXN-AT], can be issued actor-bound: the authorization server applies this document when the request carries an actor proof.¶
[TXN-CHALLENGE] binds the issued token to a cnf asserted by the
resource server in its challenge. This document instead binds to a key
the actor proves, which suits approvals that no resource challenged.¶
Client instance identifiers [CLIENT-INSTANCE] require authorization for any change of presenter or key during an exchange. An actor proof is that authorization from the new presenter.¶
In an agent approval flow, the agent that asks for approval of an
action includes an actor proof in its request, and the approving party
forwards the proof in its token exchange; the token it obtains is
usable only by the agent that asked. Because the actor creates the
proof without contacting the authorization server, such a proof
carries no server-supplied nonce, and the authorization server
relies on exp and jti against replay. How an authorization server
that requires a nonce delivers it to the actor is outside the scope of
this document.¶
The same parameters, actor_token, actor_token_type, and
actor_proof, can be carried in a Client-Initiated Backchannel
Authentication request [CIBA]. The OpenID Provider then validates the
proof when it receives the authentication request, with aud set to
its issuer identifier, and binds the token it issues after the person
approves to the actor's key. A token exchange that issues an ID-JAG
[ID-JAG] can likewise bind it to the agent that will redeem it.¶
The requesting client receives the token but cannot use it, because it does not hold the actor's key.¶
Without an actor proof, a requesting client could bind a token to a
key whose holder never asked for it, attributing actions to the
actor in act. The actor proof prevents this.¶
Mitigated by aud, exp, jti, and nonce. An authorization
server MUST NOT accept an actor proof twice.¶
An actor proof is not bound to the subject token or to the rest of
the request. Until the proof is used or expires, the requesting
client that holds it can choose the request it is used in. With
azh, the actor limits that request to the details it asked for;
without azh, the client can bind any token it can obtain to the
actor's key. Actors therefore SHOULD include azh, and SHOULD set
short lifetimes.¶
The requesting client learns the actor token. Because the actor token is itself bound to the actor's key, the client cannot present it as the actor.¶
The requesting client supplies actor_authorization_details, but
cannot inflate it: it must hash to the azh the actor signed. An
authorization server that compared issued details only with the
request's authorization_details, which the requesting client
chooses, would let that client widen the action.¶
The actor gains no authority of its own. The issued token's
authority comes from the subject token and the authorization
server's policy; azh lets the actor limit it further.¶
The requesting client learns the actor token. Deployments SHOULD use actor tokens that disclose only what the authorization server needs, for example a selectively disclosed credential.¶
Parameter Name: actor_proof; Parameter Usage Location: token
request; Change Controller: IETF; Reference: this document.¶
Parameter Name: actor_authorization_details; Parameter Usage
Location: token request; Change Controller: IETF; Reference: this
document.¶
Parameter Name: actor_bound; Parameter Usage Location: token
response; Change Controller: IETF; Reference: this document.¶
Name: invalid_actor_proof; Usage Location: token error response;
Protocol Extension: this document; Change Controller: IETF;
Reference: this document.¶
Claim Name: azh; Claim Description: Hash of requested authorization
details; Change Controller: IETF; Reference: Section 2.2.¶
The ath claim is already registered by [RFC9449], with the same
meaning: the hash of an associated token.¶
This document registers application/actor-proof+jwt in the "Media
Types" registry, for the typ header of actor proofs:¶
Type name: application¶
Subtype name: actor-proof+jwt¶
Required parameters: n/a¶
Optional parameters: n/a¶
Encoding considerations: binary; an actor proof is a JWT, a sequence of base64url-encoded values separated by period characters¶
Interoperability considerations: n/a¶
Published specification: this document¶
Applications that use this media type: OAuth 2.0 authorization servers and clients that implement this document¶
Fragment identifier considerations: n/a¶
Additional information: Magic number(s): n/a; File extension(s): n/a; Macintosh file type code(s): n/a¶
Person and email address to contact for further information: Suhas Nandakumar, snandaku@cisco.com¶
Intended usage: COMMON¶
Restrictions on usage: none¶
Author: Suhas Nandakumar, snandaku@cisco.com¶
Change controller: IETF¶
This document generalizes the requested_cnf approach of identity
chaining to a single authorization server with proof from the actor.¶