Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSelf-register client to obtain valid registration token
-
DeliveryIdentify or guess victim client_id
-
ExploitSend PUT/DELETE to /register/{victim_id} with own token
-
ExecutionServer omits token-to-client binding check
-
ImpactHijack redirect_uris or delete victim registration
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V8 - Authorization Object-level authorization, IDOR prevention
|
| Exploitation Conditions | Exploitation requires a deployment that (1) exposes Authlib's RFC 7592 ClientConfigurationEndpoint and (2) implemented authenticate_client and check_permission by following the vulnerable docstring examples - i.e. resolving the target client purely from the request-supplied client_id and checking only client.editable, never comparing request.credential to the target client. The attacker must present any valid registration_access_token (for any client) and know or guess the target client_id. The key limiting factor is correct implementation: servers that already bind the token to the target client are unaffected, so this does not hit every Authlib user. The major amplifying factor is the common open/anonymous RFC 7591 registration model, where an attacker can self-issue a qualifying token for free, reducing the practical barrier to near zero. Authentication is formally required (CVSS PR:L: a valid registration access token), but that token need not relate to the victim client. Fixed in 1.9.1. |
| Impact | Signals point to a genuine but conditional priority rather than a mass-exploitation emergency. The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N, C:H/I:H/A:H, base 8.8 High) describes network-reachable, low-complexity abuse requiring only low privilege and no user interaction, with full confidentiality, integrity and availability impact on the targeted client registration - consistent with the CWE-639 authorization-bypass mechanism. The vuln.today decision label is 'this_week', which matches a serious-but-not-emergency posture. Tempering that: there is no CISA KEV listing and no EPSS score in the input, so there is no evidence of active or widespread exploitation - treat exploitation likelihood as unquantified rather than low. The crucial caveat is that this is effectively a documentation-induced flaw: only deployments whose developers implemented authenticate_client and check_permission by copying the vulnerable docstring examples (lookup by request client_id plus a bare client.editable check, never binding request.credential to the target) are affected, so PR:L understates the gating condition. Conversely, PR:L arguably overstates the barrier in the common open RFC 7591 registration model, where any attacker can self-issue a qualifying token for free - in that configuration the effective privilege requirement collapses. No full SSVC decision (automatable / technical-impact) is supplied in the input, so those cells cannot be cross-referenced. |
| Exploit ScenarioDerived | In an authorization server using Authlib's RFC 7592 ClientConfigurationEndpoint implemented per the vulnerable docstring examples, and running the common open RFC 7591 dynamic-registration model, an attacker self-registers a throwaway client to obtain a valid registration_access_token, then sends PUT /register/{victim_client_id} with that token, rewriting the victim's redirect_uris to an attacker-controlled endpoint to intercept authorization codes or tokens (or DELETE to deny service). The GHSA-c73q-w75p-j82v advisory publishes full step-by-step reproduction, but the input confirms no packaged/weaponized exploit tool. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 28, 2026
Authlib 0.15 through 1.9.0 can let a party holding any valid RFC 7592 registration access token read, modify, or delete a different client's registration record, because the library's documented example implementations of ClientConfigurationEndpoint.authenticate_client and check_permission never bind the presented token to the target client. The exposure is conditional: it applies to deployments that expose the ClientConfigurationEndpoint and implemented those two methods by copying the shipped docstring examples, which resolve the target from the request-supplied client_id and check only client.editable. Exploitation is authenticated (CVSS PR:L - a valid registration_access_token is required) and also needs the victim's client_id, but under the common open/anonymous RFC 7591 self-registration model an attacker can self-issue a qualifying token for free, after which redirect_uri rewriting enables authorization code or token interception and deletion causes denial of service. Authlib 1.9.1 fixes the flaw; no public exploit was identified at time of analysis, and the overall signal is a conditional this-week remediation priority rather than a mass-exploitation emergency.
RemediationAI
Vendor-released patch: Authlib 1.9.1 - upgrade the pip package to 1.9.1 or later, which inserts token.check_client(client) into create_configuration_response and denies requests whose registration access token was issued to a different client (references: https://github.com/authlib/authlib/releases/tag/v1.9.1 and https://github.com/authlib/authlib/security/advisories/GHSA-c73q-w75p-j82v). If the upgrade cannot be applied immediately, patch the subclass directly: in check_permission compare request.credential's client identity against the target client (e.g. request.credential.client_id == client.get_client_id()) and return False otherwise, and derive the target client_id from the endpoint route/URL path rather than from request.payload.data, since GET and DELETE requests have no body - the trade-off is that this is bespoke code outside the vendor fix and must be maintained and tested per endpoint. Reducing exposure also means requiring an initial access token on the RFC 7591 registration endpoint so attackers cannot self-issue registration tokens for free; this closes the cheapest attack path but removes the open self-service onboarding model some deployments rely on. Finally, audit existing client registrations for unexpected redirect_uri or metadata changes and for deleted records, since the same missing binding permits both tampering and deletion.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The flaw sits in Authlib's implementation of RFC 7592 (OAuth 2.0 Dynamic Client Registration Management Protocol), which lets a previously registered client read, update, or delete its own registration using a registration_access_token issued specifically to it. Authlib's ClientConfigurationEndpoint runs authenticate_token, then authenticate_client, then check_permission, and stores the authenticated token on request.credential precisely so a downstream step can bind it to the client being acted upon. The docstrings for authenticate_client (look up Client.get(client_id=request.payload.data.get("client_id"))) and check_permission (return client.editable) demonstrate neither binding, and no complete corrected reference implementation ships in the Flask, Django, or SQLAlchemy integrations; the analogous RFC 7662 introspection example is not misleading because there the 'client' object is the already-authenticated caller, whereas in RFC 7592 it is the target. The root cause maps to CWE-639, authorization bypass through a user-controlled key: the key (client_id) comes from the request while the authorization decision ignores the credential identity. The upstream fix adds token.check_client(client) before proceeding, denies with access_denied on mismatch, and changes the documented guidance to derive client_id from the endpoint URL path rather than the request body, since GET and DELETE requests carry no body. Because the vulnerable code is documentation-driven example code rather than a single enforced code path, the practical trigger depends on how each integrator wrote their subclass - the trigger for any individual deployment is not described in the available sources beyond that implementation pattern.
Know when Authlib gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
Network endpoint, low complexity; PR:L because any valid registration access token suffices (trivially self-issued in open registration); read/modify/delete of client registration yields C:H/I:H/A:H.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
Authlib is a Python library which builds OAuth and OpenID Connect servers. From 0.15 until 1.9.1, the documented ClientConfigurationEndpoint.authenticate_client and ClientConfigurationEndpoint.check_permission reference implementations look up a target client from request-controlled client_id data and check only whether that target is editable, without verifying that request.credential belongs to the target client. Deployments following both examples can allow a client holding any valid registration access token to read, modify, or delete another client's registration. Changing redirect_uris can enable authorization code or token interception, while deleting registrations can deny service to affected clients. This issue is fixed in version 1.9.1.
Technical POC Analysis
Bug class: CWE-639, Authorization Bypass Through User-Controlled Key (the advisory also tags CWE-1188).
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
CVE-2026-116672 affects organizations using the Authlib OAuth/OIDC library (versions 0.15 to 1.9.0) that follow documented example implementations for client registration endpoints, allowing an attacker with any valid registration token to read, modify, or delete other clients' registration records. This can lead to interception of authorization codes or tokens and denial of service, potentially compromising user accounts and disrupting service availability for affected deployments.
Apply vendor patch.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
Authlib is a Python library which builds OAuth and OpenID Connect servers. [CVSS 5.7 MEDIUM]
Authentication bypass in Authlib (Python OAuth/OpenID Connect library) versions 1.6.5 through 1.6.6 allows remote attack
Authlib is a Python library which builds OAuth and OpenID Connect servers. Rated high severity (CVSS 7.5), this vulnerab
Authlib's JOSE/JWS verification path (through 1.6.4, with 1.6.5 as the fix) decodes attacker-supplied JWT/JWS header and
lepture Authlib before 1.3.1 has algorithm confusion with asymmetric public keys. Rated high severity (CVSS 7.5), this v
Unbounded DEFLATE decompression in Authlib's JWE zip=DEF handling (authlib/jose/rfc7518/jwe_zips.py) lets a small, valid
Signature verification bypass in Authlib 1.7.2 and earlier allows unauthenticated remote attackers to have crafted JWS J
Poisoned OAuth/OIDC discovery metadata in Authlib 1.7.2 and earlier allows an attacker who controls or intercepts the me
Resource exhaustion in joserfc (versions 1.3.4-1.6.5) is possible because the RFC7797 unencoded-payload (b64=false) JWS
Authentication bypass in the joserfc Python library before 1.7.4 lets remote, unauthenticated attackers submit a JWS Gen
Token forgery in the Authlib Python library before 1.9.1 lets a remote, unauthenticated attacker mint HS256, HS384 or HS
Authentication bypass in Authlib's deprecated-but-still-shipped authlib.jose module (1.3.1 through 1.8.0, fixed in 1.9.0
EUVD-2026-111112
NVD
CVE.org
EPSS
GitHub
Exploit-DB