Skip to main content

Authlib CVE-2026-116672

| EUVDEUVD-2026-111112 HIGH
Authorization Bypass Through User-Controlled Key (CWE-639)
2026-10-27 GitHub_M
8.8
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Self-register client to obtain valid registration token
  2. Delivery
    Identify or guess victim client_id
  3. Exploit
    Send PUT/DELETE to /register/{victim_id} with own token
  4. Execution
    Server omits token-to-client binding check
  5. Impact
    Hijack 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

authlib 0.15, < 1.9.1

Affected Packages

euvd authlib fix: 1.9.1

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

Vendor (GitHub_M) PRIMARY 8.8 HIGH
AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 8.8 HIGH

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.

3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

2
Patch available
Oct 27, 2026 - 17:18 EUVD
CVE Published
Oct 27, 2026 - 16:31 cve.org
HIGH 8.8

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

Why It Matters

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.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.3%
Top 80% exploitable
Prevalence
Medium
popular Python OAuth/OIDC library, but not universal infrastructure
Data Quality
4 sources
Confidence: Medium

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
No
Human Impact
High

Priority Score

44
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.

CVE-2025-68158 HIGH POC
8.8 Jan 08

Authlib is a Python library which builds OAuth and OpenID Connect servers. [CVSS 5.7 MEDIUM]

CVE-2026-28802 HIGH POC
7.7 Mar 06

Authentication bypass in Authlib (Python OAuth/OpenID Connect library) versions 1.6.5 through 1.6.6 allows remote attack

CVE-2025-59420 HIGH POC
7.5 Sep 22

Authlib is a Python library which builds OAuth and OpenID Connect servers. Rated high severity (CVSS 7.5), this vulnerab

CVE-2025-61920 HIGH POC
7.5 Oct 10

Authlib's JOSE/JWS verification path (through 1.6.4, with 1.6.5 as the fix) decodes attacker-supplied JWT/JWS header and

CVE-2024-37568 HIGH POC
7.5 Jun 09

lepture Authlib before 1.3.1 has algorithm confusion with asymmetric public keys. Rated high severity (CVSS 7.5), this v

CVE-2025-62706 MEDIUM POC
6.5 Oct 22

Unbounded DEFLATE decompression in Authlib's JWE zip=DEF handling (authlib/jose/rfc7518/jwe_zips.py) lets a small, valid

CVE-2026-96760 CRITICAL
9.8 Sep 28

Signature verification bypass in Authlib 1.7.2 and earlier allows unauthenticated remote attackers to have crafted JWS J

CVE-2026-104056 CRITICAL
9.8 Oct 01

Poisoned OAuth/OIDC discovery metadata in Authlib 1.7.2 and earlier allows an attacker who controls or intercepts the me

CVE-2026-48990 MEDIUM POC
5.3 Jun 17

Resource exhaustion in joserfc (versions 1.3.4-1.6.5) is possible because the RFC7797 unencoded-payload (b64=false) JWS

CVE-2026-102946 CRITICAL
9.1 Oct 15

Authentication bypass in the joserfc Python library before 1.7.4 lets remote, unauthenticated attackers submit a JWS Gen

CVE-2026-114616 HIGH
7.4 Oct 22

Token forgery in the Authlib Python library before 1.9.1 lets a remote, unauthenticated attacker mint HS256, HS384 or HS

CVE-2026-114615 HIGH
7.4 Oct 22

Authentication bypass in Authlib's deprecated-but-still-shipped authlib.jose module (1.3.1 through 1.8.0, fixed in 1.9.0

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy