Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconSubmit crafted JWTs with unique random kid values
-
DeliveryBypass unverified header parsing
-
ExploitTrigger uncached JWKS HTTP fetch per token
-
InstallSustain high-volume outbound requests to JWKS endpoint
-
C2Exhaust upstream provider rate limits or provoke transient errors
-
ExecuteDeny legitimate JWT verification
-
ImpactPartial service availability degradation
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A10:2025 - Mishandling of Exceptional Conditions
ASVS 5.0
V16 - Security Logging and Error Handling Exception cleanup procedures
|
| Exploitation Conditions | Exploitation requires that the target application uses PyJWT's PyJWKClient class and calls get_signing_key() with JWT input that includes attacker-controlled kid header values - meaning the application must accept externally-supplied JWTs for JWKS-backed verification without first validating or allowlisting the kid field. The CVSS vector PR:N confirms that no authentication to the target application is required; any party able to submit HTTP requests carrying JWT tokens is a potential attacker. Exploitation is constrained by AC:H: the actual availability impact depends on the upstream JWKS endpoint being susceptible to elevated request rates (rate limiting, transient errors), which is outside the attacker's direct control. Applications that enforce an explicit kid allowlist, apply per-source rate limiting on token verification, cache JWKS responses with sufficient TTL, or deploy the fixed version 2.13.0 are not practically exploitable via this path. |
| Impact | The CVSS score of 3.7 (Low) with vector AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:L accurately reflects constrained real-world risk. Network attack vector (AV:N) and no privileges required (PR:N) confirm that any unauthenticated actor capable of submitting JWTs to the target application can initiate the attack. However, high attack complexity (AC:H) is the decisive limiting factor: the attacker cannot independently cause JWKS fetch failures - they depend on the upstream identity provider's response to elevated request volume, which is outside the attacker's direct control. The impact ceiling is low availability degradation (A:L) with zero confidentiality or integrity risk. No EPSS data was provided, so probability-of-exploitation scoring cannot be assessed. The CVE is not listed in CISA KEV and no public exploit exists, consistent with the low CVSS score. This is a genuine low-priority finding for most deployments; it elevates to moderate concern only for high-throughput public-facing APIs that rely on PyJWKClient without application-layer rate limiting and whose JWKS providers lack robust upstream throttling. |
| Exploit ScenarioDerived | An attacker targeting a public REST API that uses PyJWKClient for JWT verification generates a high volume of JWT-shaped tokens, each with a unique random kid value that does not exist in the identity provider's JWKS. Each token causes the application to make a distinct outbound HTTP GET to the JWKS URI. If the identity provider begins rate-limiting these requests or experiences transient degradation, subsequent legitimate token verifications fail, resulting in authentication errors for real users. No public exploit code exists, and replicating the impact in practice requires the attacker to overwhelm or destabilize the upstream JWKS provider. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – May 28, 2026
Unconstrained outbound JWKS requests in PyJWT's PyJWKClient.get_signing_key() allow unauthenticated remote attackers to amplify HTTP traffic toward a downstream JWKS endpoint by submitting JWTs carrying arbitrary, unrecognized kid values. All PyJWT versions prior to 2.13.0 are affected when the PyJWKClient class is used for signature verification. The availability impact is low (CVSS A:L) and exploitation success is gated on the upstream JWKS provider exhibiting rate limiting or transient failures; no public exploit code exists and this CVE does not appear in CISA KEV.
RemediationAI
Upgrade PyJWT to version 2.13.0 or later, which is the vendor-confirmed fix as documented in GitHub Security Advisory GHSA-fhv5-28vv-h8m8 (https://github.com/jpadilla/pyjwt/security/advisories/GHSA-fhv5-28vv-h8m8). For environments that cannot immediately upgrade, implement application-layer rate limiting on JWT verification endpoints to cap the rate at which tokens with unknown kid values are processed per source IP or session - this directly limits the attacker's ability to generate sustained JWKS fetch volume. Alternatively, maintain an explicit allowlist of valid kid values and reject tokens presenting unrecognized kids before invoking get_signing_key(), eliminating the outbound request entirely for unknown keys; note that this requires operational overhead to update the allowlist when identity providers rotate keys. Aggressive local caching of JWKS responses with a short TTL (e.g., 60 seconds) can also reduce fetch frequency but does not eliminate the root cause for novel unknown kids.
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
PyJWT is a widely-deployed Python library for encoding and decoding JSON Web Tokens per RFC 7519. The PyJWKClient class provides JWKS-backed signature verification by fetching public keys from a remote JWKS URI. The vulnerable code path is get_signing_key(), which unconditionally issues a fresh outbound HTTP request to the JWKS endpoint whenever the kid (Key ID) claim in an incoming JWT header is not found in a local cache. The critical flaw is that the kid field is parsed from the unverified token header - base64-decoded but not yet cryptographically validated - meaning any caller can inject arbitrary kid values without needing a valid signature. The absence of rate limiting or negative-result caching for unknown kids means each such crafted token generates a distinct JWKS fetch. The assigned CWE-460 (Improper Cleanup on Thrown Exception) appears to be a mismatch; the root cause more closely aligns with CWE-770 (Allocation of Resources Without Limits or Throttling), and this discrepancy should be verified against the NVD record. The affected CPE is cpe:2.3:a:jpadilla:pyjwt:*:*:*:*:*:*:*:*, covering all versions without a stated lower bound.
Know when Pyjwt 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:H/PR:N/UI:N/S:U/C:N/I:N/A:L
Primary rating from Vendor (GitHub_M) · only source for this CVE.
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
1DescriptionCVE.org
PyJWT is a JSON Web Token implementation in Python. Prior to 2.13.0, PyJWKClient.get_signing_key() forces a fresh HTTP request to the JWKS endpoint for every JWT with an unknown kid value, with no rate limiting. Since kid comes from the unverified token header, an attacker can trigger unlimited outbound requests. The vulnerability surfaces only when a JWKS fetch fails; an attacker can attempt to provoke that with sustained unknown-kid traffic, but the outcome depends on upstream JWKS-endpoint behavior (rate limiting, transient errors) which is beyond the attacker's control. This vulnerability is fixed in 2.13.0.
Blast Radius
ecosystem impact- 195 pypi packages depend on pyjwt (132 direct, 64 indirect)
Ecosystem-wide dependent count for version 2.13.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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Forged HS256 JSON Web Tokens can be accepted as authentic by PyJWT (pip package PyJWT) versions 2.13.0 through 2.13.x wh
Improper validation in PyJWT 2.1.0 through 2.14.0 allows an attacker who already holds a stolen sender-constrained (DPoP
Denial of service in PyJWT 2.9.0 through 2.13.0: a single malformed RSA JWK embedded in a JWK Set aborts construction of
Unauthenticated denial of service in the PyJWT Python library (versions 2.0.0a1 through 2.14.0) allows a remote attacker
pyjwt is a JSON Web Token implementation in Python. Rated high severity (CVSS 7.5), this vulnerability is remotely explo
Authentication bypass in PyJWT versions prior to 2.13.0 allows remote attackers to forge valid JSON Web Tokens by exploi
Reuse of a caller-supplied options mapping in PyJWT 2.11.0 through 2.13.0 can silently leave registered-claim verificati
Malformed JSON Web Token headers can cause an uncaught RecursionError in PyJWT 2.13.0 through versions before 2.14.0, re
Uncontrolled resource consumption in PyJWT 2.8.0-2.12.1 exposes any service that verifies detached JWS tokens to unauthe
Signature forgery in PyJWT before 2.14.0 allows an attacker who knows a target's asymmetric public key to forge HMAC-aut
JWKS trust-boundary bypass in PyJWT's PyJWKClient allows a configured trusted JWKS endpoint that returns an HTTP 3xx red
Unauthenticated attackers can amplify outbound HTTP traffic from any application that validates JWTs with PyJWT's PyJWKC
EUVD-2026-32916
GHSA-fhv5-28vv-h8m8
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB