Skip to main content

Authlib EUVDEUVD-2026-108521

| CVE-2026-114619 MEDIUM
Incorrect Authorization (CWE-863)
2026-10-22 GitHub_M GHSA-q686-2qmg-hqc7
4.6
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Register/control OAuth client permitted id_token response
  2. Delivery
    Send authorization request adding openid scope
  3. Exploit
    Raw payload.scope check passes at implicit.py:72
  4. Execution
    Victim logs in and consents
  5. Impact
    Receive signed ID token with user sub and profile claims

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V8 - Authorization Authorization logic validation
MITRE ATT&CK

1 technique across 1 tactic: Privilege Escalation

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires all of the following, drawn directly from the advisory's preconditions: the authorization server must register OpenIDImplicitGrant (or a subclass); the attacker must control a registered OAuth client whose metadata permits an OIDC implicit response type (id_token or id_token token); that client's allowed scopes must exclude openid but include a claim-bearing scope such as profile; the client sends an authorization request adding openid (e.g. scope=openid profile) with a nonce; and a user must log in and approve the request. The limiting factors are significant: attacker must already be a registered/permitted client (PR:L), the flaw is gated by user login and active consent (UI:R), the issued ID token's audience is the attacking client, and deployments are NOT affected if they use only the OIDC authorization-code flow or if every client permitted an id_token response type is also allowed the openid scope.

Impact

This is a genuine but constrained authorization flaw, best treated as a measured-priority fix rather than an emergency, consistent with the input's 'this_month' decision label. The supplied CVSS:3.1 vector (AV:N/AC:L/PR:L/UI:R/S:U/C:L/I:L/A:N, base 4.6, Medium) aligns well with the mechanism: network-reachable, low attack complexity, but requiring an already-registered OAuth client (PR:L) and active user login plus consent (UI:R). No EPSS score was provided and the CVE is not in CISA KEV, so there is no signal of widespread or automated exploitation. The GitHub advisory describes a reporter-verified reproduction (a pytest PoC and a standalone Flask provider driven by curl), so a public PoC reference exists; it is not verified as published, distributable working exploit code. The reporter and CWE-863 (Incorrect Authorization) both frame this as an authorization/scope-restriction bypass, not an authentication bypass as the input Tags suggest. The practical ceiling on risk is real: the attacker must operate a registered client that the operator deliberately permitted an id_token response type while withholding the openid scope, the victim user must log in and approve, and the resulting ID token's audience is the attacking client itself. Deployments using only the OIDC authorization-code flow, or that grant openid to every client allowed an id_token response, are explicitly not affected. Net: a legitimate confidentiality/authorization concern for OIDC implicit-grant deployments, worth patching on a normal maintenance cadence, but not a high-urgency internet-wide threat.

Exploit ScenarioDerived

An operator registers an OAuth client with Authlib's OpenIDImplicitGrant, permitting it an id_token (or id_token token) response type and the profile scope but deliberately not the openid scope. The malicious client sends an authorization request adding openid to its scopes with a nonce; a legitimate user logs in and approves what the consent page shows only as 'profile', and the server returns a signed ID token carrying the user's sub and profile claims. A reporter-verified PoC (pytest and a curl-driven Flask provider) exists in the GitHub advisory, but exploitation still requires attacker control of a registered client plus victim login and consent.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 22, 2026

Authlib's OpenID Connect implicit grant (OpenIDImplicitGrant) before 1.9.0 validates the openid scope against the raw, client-supplied request.payload.scope instead of the client-filtered request.scope, so a registered client that is permitted an id_token response type but is explicitly denied the openid scope can still obtain a signed ID token. The attacker must already be a registered client (PR:L) and a user must log in and consent (UI:R); the resulting token carries the user's subject and allowed profile claims but its audience is the attacking client, giving limited confidentiality impact. Deployments using only the OIDC authorization-code flow, or where every client permitted an id_token response type is also allowed openid, are unaffected. No public exploit code and no confirmed active exploitation were identified at time of analysis, and the priority signal is a measured this-month fix rather than an emergency.

RemediationAI

Vendor-released patch: upgrade to Authlib 1.9.0 (or later), which is the fixed version published at https://github.com/authlib/authlib/releases/tag/v1.9.0; the code change is in https://github.com/authlib/authlib/pull/945 (commit e3bd41cb29dcfee434453b135ffb487884baeedf) and replaces the raw request.payload.scope check with the filtered request.scope in both the implicit and hybrid grants, so any local subclass or copied save_authorization_code example that reads request.payload.scope should be updated the same way. If upgrading cannot happen immediately, the only reliable compensating control is a configuration change: remove openid from no client that is permitted an id_token or id_token token response type (i.e. grant openid to every implicit-capable client), since the bypass requires the client's allowed scopes to exclude openid; the trade-off is that it grants identity-token capability to clients the operator had deliberately restricted. Alternatively, stop registering OpenIDImplicitGrant and serve OIDC only through the authorization-code flow, which was verified as unaffected but removes implicit-flow support for existing clients. Adding an explicit check that request.scope contains openid before issuing an ID token is a viable local patch but must be re-validated after each upstream update. See the advisory at https://github.com/authlib/authlib/security/advisories/GHSA-q686-2qmg-hqc7 for the vendor's guidance.

Affected VersionsENISA

authlib < 1.9.0

Affected Packages

pypi authlib fix: 1.9.0

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in pypi

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

CWE-863 (Incorrect Authorization): the flaw is a policy-check mismatch between two representations of the same OAuth 2.0 authorization request. In authlib/oidc/core/grants/implicit.py, OpenIDImplicitGrant.validate_authorization_request() first calls the parent ImplicitGrant, which runs client.get_allowed_scope() and stores the filtered result in request.scope; the OpenID subclass then calls is_openid_scope() on request.payload.scope, the unfiltered value the client sent. A client whose registered scopes are 'profile' only can therefore send scope=openid profile, satisfy the openid check with the raw value, and reach create_granted_params()/process_implicit_token() to receive an RS256-signed ID token with iss, aud (the requesting client), nonce, auth_time, at_hash, sub and name. Sibling paths behave correctly and confirm this is a bug rather than intent: the base implicit grant filters scope, the UserInfoEndpoint rejects the same client's access token with 403 insufficient_scope when the built-in scope-filtering BearerTokenGenerator is used, and the authorization-code flow issues no ID token. The upstream fix in PR 945 replaces request.payload.scope with request.scope in the implicit and hybrid grants (and in the documented save_authorization_code examples), and also hardens unrelated JOSE/JWT-bearer checks. OIDC implicit flow is the legacy, implicit-consent-heavy path of OpenID Connect; the ticket-gating role of the openid scope is exactly what this bypass defeats.

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 4.6 MEDIUM
AV:N/AC:L/PR:L/UI:R/S:U/C:L/I:L/A:N
vuln.today AI 3.5 LOW

Attacker is a registered client so PR:L; victim must log in and consent so UI:R; impact is disclosure of a limited set of user identity claims (C:L) with no data modification or availability loss.

3.1 AV:N/AC:L/PR:L/UI:R/S:U/C:L/I:N/A:N
4.0 AV:N/AC:L/AT:N/PR:L/UI:A/VC:L/VI:N/VA:N/SC:N/SI:N/SA:N
Red Hat 4.6 MEDIUM

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

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

Lifecycle Timeline

1
Patch available
Oct 22, 2026 - 22:03 EUVD

DescriptionCVE.org

Authlib is a Python library which builds OAuth and OpenID Connect servers. Prior to 1.9.0, OpenIDImplicitGrant.validate_authorization_request() checks the client-controlled raw request.payload.scope for openid after the parent grant has filtered allowed scopes into request.scope. A registered client permitted an ID token response type but not the openid scope can add openid to the request, obtain user consent, and receive a signed ID token containing the user's subject and allowed profile claims. Authorization code flow and deployments that allow openid for every client permitted an ID token response are not affected. In authlib/oidc/core/grants/implicit.py, OpenIDImplicitGrant.validate_authorization_request() checks request.payload.scope instead of the filtered request.scope. This issue is fixed in version 1.9.0.

Threat Intelligence Overview

EPSS Score
0.2%
Top 96% exploitable
Prevalence
Medium
popular Python OAuth/OIDC library, but implicit-grant deployments less common
Threat Intel
1
1 source
Social Media
1
Sightings
Data Quality
5 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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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· derived
Medium

Priority Score

23
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +23
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-116672 HIGH
8.8 Oct 27

Authlib 0.15 through 1.9.0 can let a party holding any valid RFC 7592 registration access token read, modify, or delete

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

Vendor StatusVendor

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