Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSubmit oversized compact JWS to endpoint
-
Exploitbytes.split() copies segments pre-check
-
ExecutionTransient token-sized allocation before rejection
-
ImpactRepeat/enlarge to exhaust worker memory
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource consumption limits
MITRE ATT&CK
1 technique across 1 tactic: Impact The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires that the application actually feed attacker-controlled bytes into joserfc's compact JWS path - deserialize_compact() / extract_rfc7515_compact() - i.e. an endpoint that verifies untrusted JWS tokens using joserfc ≤ the vulnerable version. No authentication, user interaction, or non-default configuration is needed once that code path is reachable (PR:N/UI:N). The key LIMITING factor is the ~1.0× amplification measured by the vendor: because the induced allocation is roughly proportional (not multiplicative) to the supplied token, the attacker must send large tokens and/or sustain concurrent requests to drive a worker toward MemoryError, making this a bandwidth-bound availability failure rather than a single-packet crash. |
| Impact | This is a medium-severity availability-only issue, not an emergency. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) scoring 6.9 indicates a remote, low-complexity, unauthenticated trigger, but the only impact is availability (VA:L) - there is no confidentiality or integrity exposure (VC:N/VI:N). KEV status is not indicated in the input (treat as not listed), and no EPSS score was provided, so widespread-exploitation probability cannot be quantified from the data supplied. Critically, the vendor's own GHSA reproduction table shows amplification of roughly 1.0× (e.g. 64 MiB input → ~63.8 MiB peak RSS delta), meaning this is NOT a memory-amplification 'bomb': an attacker must transmit roughly as many bytes as the transient allocation they induce. That bandwidth-bound property materially lowers real-world DoS severity versus a classic resource-exhaustion amplifier. The vuln.today decision label is 'this_month' (not act_now/emergency), consistent with a genuine but non-urgent fix priority. Note a fixed-version conflict across sources that should be verified (see confidence_notes). |
| Exploit ScenarioDerived | An application exposes JWS verification on untrusted input and passes attacker-controlled compact serialization bytes to joserfc's deserialize_compact(). A remote unauthenticated attacker submits an oversized compact JWS token; before the aggregate size guard rejects it, Python's bytes.split(b'.') copies the header, payload, and signature segments, creating an additional token-sized allocation even though signature verification ultimately fails. A public reproduction/profiling script is referenced in the GHSA advisory but it is not verified as working weaponized exploit code. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 29, 2026
Memory exhaustion in joserfc before 1.7.6 allows remote unauthenticated attackers to force a roughly token-sized extra allocation inside the compact JWS deserialization path, because bytes.split() copies the header, payload, and signature segments before the existing aggregate size limits are enforced. Applications that pass attacker-controlled compact serialization bytes to deserialize_compact() or extract_rfc7515_compact() are affected; signature verification still fails, but large or concurrent tokens can drive a process toward MemoryError. This is a medium-severity, availability-only issue (CVSS 4.0 6.9; assessed CVSS 3.1 A:L) with bandwidth-bound rather than single-packet exploitation; no CISA KEV entry or confirmed working public exploit is available, though the advisory includes a reproduction harness.
RemediationAI
Vendor-released patch: upgrade joserfc to 1.7.6 or later; the advisory is at https://github.com/authlib/joserfc/security/advisories/GHSA-9pg5-8c7x-5hfx, the fix commit is https://github.com/authlib/joserfc/commit/397e04f4bbce0b94d86e31c1c003f4640af8fb39, and the release is https://github.com/authlib/joserfc/releases/tag/1.7.6. The fix adds a pre-split length check against the sum of the configured segment limits, so retain default or tighter max_header_length, max_payload_length, and max_signature_length settings. If upgrading immediately is not possible, enforce a hard maximum compact-token size before calling deserialize_compact(), such as a reverse-proxy request-body limit or an explicit len(token) check at the application boundary, and cap concurrent JWS verification work per worker; these reduce exposure to memory exhaustion but do not remove the pre-split allocation inside the library, and overly tight limits can reject legitimate large tokens. Do not rely on signature verification failure as a mitigation, because the allocation occurs before rejection, and the advisory's reproduction harness is not confirmed working exploit code.
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
joserfc implements JOSE compact serialization for RFC 7515 JWS, RFC 7516 JWE, and RFC 7797 unencoded-payload tokens, where a token is a dot-separated byte string. In vulnerable versions, the compact JWS path calls value.split(b'.') before checking max_header_length, max_payload_length, and max_signature_length; because Python bytes objects are immutable, split() creates new copies of all three segments even when the token is about to be rejected with ExceededSizeError. The root cause is CWE-400 uncontrolled resource consumption: the size guard runs after the allocation it is meant to prevent. The vendor's memory measurements show roughly 1.0x amplification (for example, a 64 MiB input produced a 63.80 MiB peak RSS delta), so the flaw does not multiply attacker input dramatically, but it does create an additional attacker-controlled, token-sized object and can exhaust worker memory under large or concurrent requests. The upstream commit adds validate_compact_value_size(), which compares len(value) against the sum of the configured segment limits before split(), and applies it to RFC 7515, RFC 7516, and RFC 7797 compact handling.
Know when Joserfc 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
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N
Remote unauthenticated bytes reach deserialize_compact() with no user interaction (AV:N/AC:L/PR:N/UI:N); only a transient availability impact and no confidentiality/integrity effect, so A:L and C:N/I:N.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
1DescriptionCVE.org
joserfc is a Python library that provides an implementation of several JSON Object Signing and Encryption (JOSE) standards. Prior to 1.7.6, joserfc compact JWS deserialization calls bytes.split() before enforcing the existing aggregate segment-size limits. When attacker-controlled compact serialization bytes reach deserialize_compact(), the split creates copies of the header, payload, and signature segments before ExceededSizeError rejects them, causing an additional allocation approximately proportional to the supplied token. Requests that exhaust available process memory can therefore cause an availability failure even though signature verification fails. This issue is fixed in version 1.7.6.
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
Insecure deserialization occurs when an application converts serialized data (a stream of bytes representing an object's state) back into a living object without proper validation.
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
joserfc is a Python library that provides an implementation of several JSON Object Signing and Encryption (JOSE) standar
Joserfc versions 1.6.2 and earlier fail to validate the PBES2 iteration count parameter in JWE tokens, allowing unauthen
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
CPU-exhaustion denial of service in joserfc prior to 1.7.5 affects any Python service that passes externally supplied JW
JWT malleability in joserfc versions 1.7.1 and prior allows a low-privileged user holding a valid token to craft alterna
EUVD-2026-113401
GHSA-9pg5-8c7x-5hfx
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB