| Internet-Draft | OAuth Client Challenge Protocol | May 2026 |
| Kahrer | Expires 20 November 2026 | [Page] |
This document extends the OAuth 2.0 token endpoint error response (RFC 6749) with a new error code that indicates to the client that it must provide additional input for the authorization server to authorize it and accept its request.¶
This mechanism enables just-in-time authorization flows in which the authorization server dynamically challenges the client during a request and the client tries to satisfy it. For example, the authorization server can ask the client mid-flow to provide an assertion, a verifiable presentation, or other proof-of-possession material.¶
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-kahrer-oauth-client-challenge-protocol/.¶
Source for this draft and an issue tracker can be found at https://github.com/curityio/ietf-draft-oauth-client-challenge-protocol.¶
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 November 2026.¶
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.¶
The OAuth 2.0 Authorization Framework [RFC6749] assumes that a single grant signaled through the grant_type parameter is sufficient for the authorization server to authorize the client. It does not define how the authorization server signals to the client to provide additional input for it to make a decision - like an additional grant from the Resource Owner or an attestation artifact to prove the client's provenance.¶
Real-world deployments increasingly require the authorization server to apply dynamic, contextual authorization policies — for example:¶
Demanding a freshly signed client attestation when risk signals indicate an elevated threat level.¶
Requiring the client to prove its mandate before a high-value token is issued.¶
This document introduces a way for the authorization server to start a challenge session where it defines requirements that it expects from the client. It extends the OAuth 2.0 Authorization Framework by introducing the following parameters:¶
A new error code insufficient_client_authorization for token error responses that the authorization server returns when it cannot proceed without additional client-supplied material.¶
A companion response parameter authorization_requirement — a typed JSON object
that describes what the authorization server requires.¶
Processing rules for both parties, including the requirement to return
unauthorized_client when subsequently provided input fails validation.¶
An authorization server may accept client authentication for low-assurance tokens but require an attestation for tokens granting elevated privileges (see ([I-D.ietf-oauth-attestation-based-client-auth])).
The insufficient_client_authorization mechanism allows the authorization server to escalate the authentication requirement without the client needing to speculatively include high-assurance credentials on every request. It allows, for example, public clients to increase their trust profile.¶
OAuth 2.0 First-Party Applications [I-D.ietf-oauth-first-party-apps] defines an API for user authentication where the authorization server challenges the OAuth 2.0 client to provide data from the user. The proposed API is similar to the mechanism defined in this document. However, there is a subtle difference: OAuth 2.0 First-Party Applications defines a new error code for the client to provide more data from the end-user (Resource Owner). Its main purpose is to enable clients to control the user experience. For that it makes two important assumptions:¶
The client can interact with an end-user.¶
The client is trusted to handle sensitive data like the end-user's credentials, i.e., the client is a first-party application.¶
The extension in this document is different because it assumes that the client can satisfy the challenge from the Authorization Requirement itself. It is applicable for both first- and third-party use cases where the authorization server challenges the client to provide additional input for the authorization grant. The client does not have to handle end-user credentials. What's more, it does not require an additional endpoint but extends the token response.¶
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.¶
This document uses the terms "access token", "authorization server", "client", "client authentication", "token response", "token request" and "token endpoint" as defined by the OAuth 2.0 Authorization Framework [RFC6749], unless otherwise specified by this document.¶
In addition, the document uses the following terms:¶
A token error response from the OAuth 2.0 token endpoint that indicates to the client that the authorization server requires additional input for it to authorize the client.¶
A typed JSON object returned by the authorization server in an Insufficient Client Authorization Response that specifies the additional material the client must supply.¶
A string managed by the authorization server that serves as the nonce in the challenge-response pattern. It associates an Insufficient Client Authorization Response with the subsequent request that satisfies it.¶
This document registers the error code insufficient_client_authorization for use in OAuth 2.0 token endpoint error responses as defined in Section 5.2 of [RFC6749].¶
The following content applies to the Insufficient Client Authorization Response.¶
error:REQUIRED. The error parameter MUST be insufficient_client_authorization.¶
authorization_requirement:REQUIRED. The authorization_requirement parameter is a typed JSON object as defined in Section 5.¶
challenge_session:REQUIRED. An opaque identifier generated by the authorization server that binds this authorization challenge to the follow-up request.¶
The client MUST include this value in the subsequent request to the authorization server if it receives one along with the insufficient_client_authorization error response.¶
expires_in:OPTIONAL. A JSON number that defines the number of seconds from the time of the Insufficient Client Authorization Response until the challenge_session expires.¶
The client MUST NOT submit a response after this time.¶
The authorization server MUST comply with Section 5.2 of [RFC6749]. The authorization server SHOULD respond with HTTP status code 403 (Forbidden). It MAY include other parameters in the response. The client MUST ignore any parameters it does not understand.¶
If the client does not understand or cannot satisfy the Authorization Requirement, it MUST treat the Insufficient Client Authorization Response as if the authorization server returned an unauthorized_client error.¶
The Insufficient Client Authorization Response indicates the following:¶
The authorization server has determined that it cannot yet authorize the client or issue an access token.¶
The condition is resolvable: the authorization server knows what additional input would allow it to proceed.¶
The authorization server wishes to challenge the client to supply that input.¶
The following represents a non-normative example of an Insufficient Client Authorization Response.¶
HTTP/1.1 403 Forbidden
Content-Type: application/json
Cache-Control: no-store
{
"error": "insufficient_client_authorization",
"authorization_requirement": {
"type": "verifiable_presentation",
"challenge_session": "7f3d9e2a-4c1b-4f8e-b5a0-1e6c8d2f0a9b",
"presentation_definition": { ... }
}
}
¶
Clients that communicate their client metadata, for example via dynamic client registration [RFC7591] or client ID metadata document [I-D.ietf-oauth-client-id-metadata-document] can signal support for this specification. To do so, they MUST include the following property in their client metadata:¶
insufficient_client_authorization_supported:OPTIONAL. JSON boolean value specifying whether the client supports this specification.¶
This enables authorization servers to apply this specification without breaking integrations.¶
The authorization server SHOULD issue sender-constrained tokens as a result of a successfully resolved client authorization challenge. In this way, the authorization server can mitigate the risk of token theft and replay. The idea is that the authorization server binds the token to a public key that the client controls. For the token to be valid, the client MUST provide a proof-of-possession that satisfies that key binding. The exact methods on how the authorization server binds the token to the client's key and how the client provides a proof-of-possession are out of scope of this document. Demonstrating Proof-of-Possession (DPoP) [RFC9449] and certificate-bound access tokens [RFC8705] are two examples, and there may be others.¶
The challenge_session parameter associates a Insufficient Client Authorization Response with follow-up resolution attempts. To mitigate session hijacking and replay, the authorization server SHOULD bind the challenge_session to the device requesting tokens, for example via DPoP. Similar to sender-constrained tokens, the binding prevents other devices from replaying a captured challenge_session and thus prevents other devices from taking over sessions (session hijacking).¶
This document defines the following values for the IANA "OAuth Parameters" registry of [IANA.oauth-parameters] established by [RFC6749].¶
Parameter Name: challenge_session¶
Parameter Usage Location: token response, token request¶
Change Controller: IETF¶
Specification Document: Section 4 of [draft-kahrer-oauth-client-challenge-protocol-00]¶
This document defines the following values for the IANA "OAuth Extensions Error" registry of [IANA.oauth-parameters].¶
Error Name: insufficient_client_authorization¶
Error Usage Location: token endpoint¶
Related Protocol Extension: n/a¶
Change Controller: IETF¶
Specification Document: Section 4 of [draft-kahrer-oauth-client-challenge-protocol-00]¶
This document defines the following values for the IANA "OAuth Dynamic Client Registration Metadata" registry of [IANA.oauth-parameters] established by [RFC7591].¶
Client Metadata Name: insufficient_client_authorization_supported¶
Client Metadata Description: JSON boolean value that specifies whether the OAuth client supports insufficient client authorization error in token error responses.¶
Change Controller: IESG¶
Specification Document: Section 7 of [draft-kahrer-oauth-client-challenge-protocol-00]¶
The author wants to thank the following people for their feedback, input and contributions to this document:¶
Jacob Ideskog, Michał Trojanowski¶
-00¶
Initial draft¶