Internet-Draft Actor-Bound Token Exchange November 2026
Nandakumar & Jennings Expires 20 May 2027 [Page]
Workgroup:
Web Authorization Protocol
Internet-Draft:
draft-nandakumar-oauth-actor-bound-token-exchange-00
Published:
Intended Status:
Standards Track
Expires:
Authors:
S. Nandakumar
Cisco
C. Jennings
Cisco Systems

OAuth 2.0 Token Exchange with Actor-Bound Tokens

Abstract

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.

About This Document

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/.

Status of This Memo

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.

▲

Table of Contents

1. Introduction

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:

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.

1.1. Requirements Language

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.

1.2. Terminology

Requesting client:

The OAuth client that sends the token exchange request.

Actor:

The party named by the actor token, to whose key the issued token is bound.

Actor proof:

A JWT signed by the actor that proves possession of its key and authorizes binding a token to it (Section 2.2).

2. Protocol

2.1. Token Exchange Request

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...

2.2. Actor Proof

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:

typ:

REQUIRED. actor-proof+jwt.

alg:

REQUIRED. An asymmetric digital signature algorithm. It MUST NOT be none or a MAC algorithm.

jwk or x5c:

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:

aud:

REQUIRED. The authorization server's issuer identifier [RFC8414].

iat, exp, jti:

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.

ath:

REQUIRED. The base64url-encoded SHA-256 hash [RFC6234] of the ASCII encoding of the actor token's value, binding the proof to it.

azh:

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.

nonce:

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).

2.3. Authorization Server Processing

The authorization server:

  1. processes the request as [RFC8693] requires, including its policy on whether the subject may be acted for by the actor;

  2. validates the actor token and extracts its cnf, rejecting the request with invalid_request if the actor token has none;

  3. validates the actor proof: typ and alg; the signature, under the key that the actor token's cnf confirms, taken from cnf or from the proof's jwk or x5c after checking it against the thumbprint in cnf; aud; exp; ath; nonce, if it requires one; and that it has not accepted the same jti before. It keeps each accepted jti until that proof's exp passes;

  4. if azh is present, takes the details the actor asked for from actor_authorization_details when present, and from the request's authorization_details otherwise, and checks that the hash of their JCS form equals azh. The details it issues MUST be equal to, or narrower than, those details. It determines "narrower" by the rules of each authorization details type, which a type can declare as [RAR-NARROWING] defines. For a type whose rules it does not know, or where it cannot determine that the details only narrow, it MUST reject the request with invalid_authorization_details ([RFC9396]); and

  5. issues a token whose cnf confirms the actor's key, as the actor token's cnf does, and whose act claim (Section 4.1 of [RFC8693]) identifies the actor by the sub, and iss where needed, of the actor token. A deployment can use the richer act claim of [ACTOR-PROFILE].

When requested_token_type identifies an access token, the token response has token_type DPoP for a key confirmed by jwk or jkt, or Bearer for a certificate-bound key ([RFC8705]). When it identifies an assertion that the actor will itself present as an authorization grant, such as an Identity Assertion JWT Authorization Grant [ID-JAG], the cnf and act claims are placed in that assertion, token_type is the one the assertion's specification defines (N_A for ID-JAG), and the party that accepts the grant requires proof of possession of the key confirmed by cnf. In either case the response includes:

actor_bound:

true, telling the requesting client that it cannot use the token and must give it to the actor.

If the actor proof is invalid, or the hash checked in step 4 does not equal azh, the authorization server returns the error invalid_actor_proof in a token error response (Section 3.2.4 of [OAUTH-2.1]).

2.4. Authorization Server Metadata

actor_bound_token_exchange_supported:

OPTIONAL. Boolean. Whether the authorization server supports this document. Absent means false.

When the authorization server requires DPoP-bound tokens [DPOP-REQUIRED], actor-bound tokens satisfy that requirement through the actor's key.

3. Using the Token

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.

4. Relationship to Other Work

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.

5. Security Considerations

Token theft by the requesting client:

The requesting client receives the token but cannot use it, because it does not hold the actor's key.

Binding without consent:

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.

Replay of actor proofs:

Mitigated by aud, exp, jti, and nonce. An authorization server MUST NOT accept an actor proof twice.

Reuse of a proof by the requesting client:

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.

Disclosure of the actor token:

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.

Inflated originals:

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.

Scope:

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.

6. Privacy Considerations

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.

7. IANA Considerations

7.1. OAuth Parameters

  • 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.

7.2. OAuth Extensions Error

  • Name: invalid_actor_proof; Usage Location: token error response; Protocol Extension: this document; Change Controller: IETF; Reference: this document.

7.3. OAuth Authorization Server Metadata

  • Metadata Name: actor_bound_token_exchange_supported; Metadata Description: Whether the authorization server supports actor-bound token exchange; Change Controller: IETF; Reference: this document.

7.4. JSON Web Token Claims

  • 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.

7.5. Media Type

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

  • Security considerations: Section 5 of this document

  • 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

8. References

8.1. Normative References

[OAUTH-2.1]
Hardt, D., Parecki, A., and T. Lodderstedt, "The OAuth 2.1 Authorization Framework", Work in Progress, Internet-Draft, draft-ietf-oauth-v2-1-17, , <https://datatracker.ietf.org/doc/html/draft-ietf-oauth-v2-1-17>.
[RFC2119]
Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, , <https://www.rfc-editor.org/rfc/rfc2119>.
[RFC6234]
Eastlake 3rd, D. and T. Hansen, "US Secure Hash Algorithms (SHA and SHA-based HMAC and HKDF)", RFC 6234, DOI 10.17487/RFC6234, , <https://www.rfc-editor.org/rfc/rfc6234>.
[RFC7515]
Jones, M., Bradley, J., and N. Sakimura, "JSON Web Signature (JWS)", RFC 7515, DOI 10.17487/RFC7515, , <https://www.rfc-editor.org/rfc/rfc7515>.
[RFC7519]
Jones, M., Bradley, J., and N. Sakimura, "JSON Web Token (JWT)", RFC 7519, DOI 10.17487/RFC7519, , <https://www.rfc-editor.org/rfc/rfc7519>.
[RFC7800]
Jones, M., Bradley, J., and H. Tschofenig, "Proof-of-Possession Key Semantics for JSON Web Tokens (JWTs)", RFC 7800, DOI 10.17487/RFC7800, , <https://www.rfc-editor.org/rfc/rfc7800>.
[RFC8174]
Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, , <https://www.rfc-editor.org/rfc/rfc8174>.
[RFC8414]
Jones, M., Sakimura, N., and J. Bradley, "OAuth 2.0 Authorization Server Metadata", RFC 8414, DOI 10.17487/RFC8414, , <https://www.rfc-editor.org/rfc/rfc8414>.
[RFC8693]
Jones, M., Nadalin, A., Campbell, B., Ed., Bradley, J., and C. Mortimore, "OAuth 2.0 Token Exchange", RFC 8693, DOI 10.17487/RFC8693, , <https://www.rfc-editor.org/rfc/rfc8693>.
[RFC8705]
Campbell, B., Bradley, J., Sakimura, N., and T. Lodderstedt, "OAuth 2.0 Mutual-TLS Client Authentication and Certificate-Bound Access Tokens", RFC 8705, DOI 10.17487/RFC8705, , <https://www.rfc-editor.org/rfc/rfc8705>.
[RFC8785]
Rundgren, A., Jordan, B., and S. Erdtman, "JSON Canonicalization Scheme (JCS)", RFC 8785, DOI 10.17487/RFC8785, , <https://www.rfc-editor.org/rfc/rfc8785>.
[RFC9396]
Lodderstedt, T., Richer, J., and B. Campbell, "OAuth 2.0 Rich Authorization Requests", RFC 9396, DOI 10.17487/RFC9396, , <https://www.rfc-editor.org/rfc/rfc9396>.
[RFC9449]
Fett, D., Campbell, B., Bradley, J., Lodderstedt, T., Jones, M., and D. Waite, "OAuth 2.0 Demonstrating Proof of Possession (DPoP)", RFC 9449, DOI 10.17487/RFC9449, , <https://www.rfc-editor.org/rfc/rfc9449>.

8.2. Informative References

[ACTOR-PROFILE]
McGuinness, K., "OAuth Actor Profile for Delegation", Work in Progress, Internet-Draft, draft-mcguinness-oauth-actor-profile-01, , <https://datatracker.ietf.org/doc/html/draft-mcguinness-oauth-actor-profile-01>.
[CIBA]
OpenID Foundation, "OpenID Connect Client-Initiated Backchannel Authentication Flow - Core 1.0", n.d., <https://openid.net/specs/openid-client-initiated-backchannel-authentication-core-1_0.html>.
[CLIENT-INSTANCE]
McGuinness, K., "OAuth 2.0 Client Instance Identifiers", Work in Progress, Internet-Draft, draft-mcguinness-oauth-client-instance-id-01, , <https://datatracker.ietf.org/doc/html/draft-mcguinness-oauth-client-instance-id-01>.
[DPOP-REQUIRED]
Smith, E., "OAuth Authorization Server Metadata Parameter for Requiring DPoP", Work in Progress, Internet-Draft, draft-emelia-oauth-as-metadata-dpop-required-00, , <https://datatracker.ietf.org/doc/html/draft-emelia-oauth-as-metadata-dpop-required-00>.
[ID-CHAINING]
Schwenkschuster, A., Kasselman, P., Burgin, K., Jenkins, M. J., Campbell, B., and A. Parecki, "OAuth Identity and Authorization Chaining Across Domains", Work in Progress, Internet-Draft, draft-ietf-oauth-identity-chaining-17, , <https://datatracker.ietf.org/doc/html/draft-ietf-oauth-identity-chaining-17>.
[ID-JAG]
Parecki, A., McGuinness, K., and B. Campbell, "Identity Assertion JWT Authorization Grant", Work in Progress, Internet-Draft, draft-ietf-oauth-identity-assertion-authz-grant-06, , <https://datatracker.ietf.org/doc/html/draft-ietf-oauth-identity-assertion-authz-grant-06>.
[RAR-NARROWING]
Nandakumar, S., "Comparing OAuth Authorization Details", Work in Progress, Internet-Draft, draft-nandakumar-oauth-rar-narrowing-00, , <https://datatracker.ietf.org/doc/draft-nandakumar-oauth-rar-narrowing/>.
[TXN-AT]
Tulshibagwale, A., "Transactional Access Tokens", Work in Progress, Internet-Draft, draft-tulshi-oauth-transactional-access-tokens-00, , <https://datatracker.ietf.org/doc/html/draft-tulshi-oauth-transactional-access-tokens-00>.
[TXN-CHALLENGE]
Rosomakho, Y., Campbell, B., McGuinness, K., and P. Kasselman, "OAuth Transaction Authorization Challenge", Work in Progress, Internet-Draft, draft-rosomakho-oauth-txn-challenge-01, , <https://datatracker.ietf.org/doc/html/draft-rosomakho-oauth-txn-challenge-01>.
[WIMSE-CREDS]
Campbell, B., Salowey, J. A., Schwenkschuster, A., Sheffer, Y., and Y. Rosomakho, "WIMSE Workload Credentials", Work in Progress, Internet-Draft, draft-ietf-wimse-workload-creds-03, , <https://datatracker.ietf.org/doc/html/draft-ietf-wimse-workload-creds-03>.

Acknowledgments

This document generalizes the requested_cnf approach of identity chaining to a single authorization server with proof from the actor.

Authors' Addresses

Suhas Nandakumar
Cisco
Cullen Jennings
Cisco Systems