NewApp Monitoring is liveSign up free
AgentbeamBeta
Open-source package vulnerability · PyPI

CVE-2026-116672: Authlib RFC 7592 examples omit registration-access-token client binding

highCVSS 3.1 8.8GHSA-c73q-w75p-j82v

The documented example code for Authlib's RFC 7592 `ClientConfigurationEndpoint` never checks that the presented `registration_access_token` belongs to the target client. An app that copies the examples lets any registered client read, change or delete another client's registration. The Authlib header lists 1.9.1 as the patched version.

Published Oct 30, 2026 · Analysis Oct 31, 2026

What an attacker can do

In RFC 7592 dynamic client management, a registration access token should only let its own client manage its own registration. The example authenticate_client looks up the target by the client_id in the request payload. The example check_permission only tests a property of that target, such as editable. Neither reads request.credential, which holds the authenticated token the endpoint stores for this purpose (CWE-639).

If the server allows open dynamic registration, an attacker registers their own client, receives a valid token, and then presents it with a different client's ID. They can read that client's metadata, replace its redirect URIs to hijack authorization flows, or delete it. The advisory rates it High (CVSS 8.8).

The risk sits in applications that followed the documentation, not in a separate library function. Check your own implementation.

Who is affected

Authlib >= 0.15, <= 1.9.0 per the advisory header, in applications that implement ClientConfigurationEndpoint using the documented authenticate_client and check_permission examples. The page's own "affected products" section lists only 1.7.2 and says no patch exists, so it contradicts the header. Check the library, then read your own endpoint code:

pip show Authlib

Authlib

Ecosystem
PyPI
Affected
>= 0.15, <= 1.9.0
Fixed in
1.9.1
Check
pip show Authlib

How to fix it

Upgrade to 1.9.1 as the header states.

pip install --upgrade "Authlib>=1.9.1"

Because the flaw lives in example code you copied, also fix your implementation: compare the token's client to the target, for example request.credential.client_id == client.get_client_id(). The advisory suggests adding docstring warnings and a complete reference implementation in the integration modules.

How to tell if you were hit

Review your authenticate_client and check_permission for any use of request.credential. In logs, look for RFC 7592 configuration requests (GET, PUT, DELETE on the client configuration endpoint) where the token's client differs from the client_id being managed. Check registered clients for redirect URIs you did not set.

Original advisory

From the GitHub Advisory Database (CC BY 4.0).

Description

Summary

RFC 7592 (OAuth 2.0 Dynamic Client Registration Management Protocol) lets a previously registered client read, update, or delete its own registration, authenticated by a registration_access_token issued specifically to that client at registration time. The entire security model of this protocol depends on the server verifying that the token presented in the request actually belongs to the client identified in the request, not merely that the token is valid for some client.

Authlib's ClientConfigurationEndpoint implements the control flow correctly in structure, calling authenticate_token, then authenticate_client, then check_permission, and treats all three as abstract methods that "Developers MUST implement in subclass." The problem is that the documented example implementations for these methods, taken together exactly as written, never perform the one check that matters: binding the authenticated token to the specific client being accessed. A developer who implements these methods by following the provided examples ends up with a complete authorization bypass on this endpoint.

Details

authenticate_client's documented example (authlib/oauth2/rfc7592/endpoint.py):

def authenticate_client(self, request):
    """Read a client from the request payload.
    Developers MUST implement this method in subclass::

        def authenticate_client(self, request):
            client_id = request.payload.data.get("client_id")
            return Client.get(client_id=client_id)

    :return: client instance
    """
    raise NotImplementedError()

This looks the target client up purely by the client_id supplied in the request payload, with no reference to the token at all.

check_permission's documented example, in the same file:

def check_permission(self, client, request):
    """Checks whether the current client is allowed to be accessed, edited
    or deleted. Developers MUST implement it in subclass, e.g.::

        def check_permission(self, client, request):
            return client.editable

    :return: boolean
    """
    raise NotImplementedError()

This checks a property of the target client alone (whether it is generally "editable"), again with no reference to request.credential, the authenticated token object returned earlier by authenticate_token and stored on the request specifically so that later steps can check it:

def create_configuration_response(self, request):
    token = self.authenticate_token(request)
    if not token:
        raise AccessDeniedError()

    request.credential = token

    client = self.authenticate_client(request)
    ...
    if not self.check_permission(client, request):
        raise UnauthorizedClientError(...)

request.credential is set specifically so that a binding check can be performed downstream, but neither documented example ever reads it. Following both examples as written produces an implementation where the only requirements to access, modify, or delete a client's registration are: possessing any valid registration_access_token for any client, and knowing or guessing the target client_id.

This is meaningfully different from how the equivalent example is written for the token introspection endpoint (RFC 7662) elsewhere in the same codebase, which does correctly demonstrate checking the authenticated caller's own identity (authlib/oauth2/rfc7662/introspection.py):

def check_permission(self, token, client, request):
    """Check if the request has permission to introspect the token. Developers
    MUST implement this method::

        def check_permission(self, token, client, request):
            # only allow a special client to introspect the token
            return client.client_id == "introspection_client"
    """

In that endpoint, client represents the already-authenticated caller (verified through normal client credential authentication earlier in the flow), so checking a property of client is meaningful authorization logic. In the RFC 7592 endpoint, client instead represents the target being acted upon, not the caller, so the same style of example is actively misleading: it looks like a reasonable authorization check but performs none of the binding the protocol requires.

No file anywhere in the repository, including the Flask, Django, and SQLAlchemy integration modules, provides a complete, corrected reference implementation of ClientConfigurationEndpoint. The misleading docstring examples are the only guidance shipped for this endpoint.

Realistic exploitability

RFC 7591 dynamic client registration is commonly deployed without requiring an initial access token, since the specification explicitly anticipates open, self-service registration as a normal deployment model. Under that common configuration, an attacker can freely self-register their own throwaway client with no authentication at all, receive a valid registration_access_token scoped to that throwaway client, and then present that same token against /register/{target_client_id} for any other client, since neither documented example checks that the token corresponds to the target. If the target client's editable property (or whatever equivalent the developer implements based on the documented example) is true, an attacker can read the victim client's full registration including its metadata, update it (for example, changing redirect_uris to an attacker-controlled endpoint, enabling authorization code or token interception against that client's users), or delete it outright.

Reproduction

  1. Deploy an authorization server using ClientConfigurationEndpoint with authenticate_client and check_permission implemented exactly as documented in the class's own docstrings.
  2. As an attacker, register a new client via the RFC 7591 registration endpoint (commonly open/anonymous), obtaining client_id_A and registration_access_token_A.
  3. Identify or guess client_id_B, belonging to a different, unrelated client.
  4. Send GET /register/client_id_B (or PUT/DELETE) with Authorization: Bearer registration_access_token_A, and client_id set to client_id_B in the request body for the PUT case.
  5. authenticate_token succeeds because registration_access_token_A is a valid token. authenticate_client succeeds because it looks up client_id_B directly from the payload, ignoring which token was presented. check_permission succeeds because it only checks client_B.editable, not whether registration_access_token_A has any relationship to client_B. The request proceeds and returns, modifies, or deletes client B's registration.

Impact

Full read, modify, and delete access to any other client's registration record, for any party able to obtain a valid registration_access_token for any client of their own. In an open dynamic registration deployment this reduces to no meaningful barrier at all, since attackers can self-issue their own qualifying token for free. Impact includes disclosure of client metadata, redirect URI hijacking enabling authorization code or token interception, and denial of service via deletion of arbitrary client registrations.

Suggested fix

Update the documented example for check_permission (or authenticate_client) to explicitly demonstrate binding the authenticated token to the target client, for example:

def check_permission(self, client, request):
    return request.credential.client_id == client.get_client_id()

and add an explicit warning in both docstrings that omitting this comparison results in a complete authorization bypass on this endpoint. Consider also shipping a complete, correct reference implementation of ClientConfigurationEndpoint in the Flask/Django/SQLAlchemy integration modules, since none currently exists.

---

Affected products

Ecosystem: pip Package name: Authlib Affected versions: 1.7.2 Patched versions: 1.9.1

Severity

Privileges Required is Low, reflecting that the attacker needs some registration_access_token of their own, which under the common open dynamic registration deployment model is trivially self-issued. This is a documentation/reference-implementation issue rather than a bug the library enforces unconditionally on every deployment, since authenticate_client and check_permission are abstract methods a developer must implement; the finding is that the only guidance provided for implementing them correctly is, itself, exploitable if followed as written.

Credited to alham-rizvi.

Questions

Is Authlib itself vulnerable or only my code?

The documented example implementations are the problem. An application is exposed if it copied them without binding the token to the target client.

Does the attacker need an account?

They need a valid registration access token. Under open dynamic registration, they can obtain one by registering a client of their own.

Which version fixes it?

The advisory header lists 1.9.1. Its "affected products" section says no patch exists, so verify against the Authlib release notes and fix your endpoint code too.

References

How this page is made: the data panel comes from the GitHub Advisory Database, CISA’s KEV catalog, the NVD and FIRST EPSS, and updates twice a day. The analysis is written by an AI model from the sources listed above and checked by automated rules before it is published. Check versions against the vendor's advisory before you act. Methodology

More PyPI vulnerabilities

All PyPI entries