Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessRegister/control OAuth client permitted id_token response
-
DeliverySend authorization request adding openid scope
-
ExploitRaw payload.scope check passes at implicit.py:72
-
ExecutionVictim logs in and consents
-
ImpactReceive 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
Affected Packages
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
AV:N/AC:L/PR:L/UI:R/S:U/C:L/I:L/A:N
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.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
1DescriptionCVE.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
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
Authlib 0.15 through 1.9.0 can let a party holding any valid RFC 7592 registration access token read, modify, or delete
Token forgery in the Authlib Python library before 1.9.1 lets a remote, unauthenticated attacker mint HS256, HS384 or HS
EUVD-2026-108521
GHSA-q686-2qmg-hqc7
NVD
CVE.org
EPSS
VulDB
Exploit-DB