Skip to main content

joserfc EUVDEUVD-2026-113392

| CVE-2026-119283 HIGH
Uncontrolled Resource Consumption (CWE-400)
2026-10-29 GitHub_M GHSA-jpxq-7h8p-2q76
7.5
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Reach endpoint accepting JWE General JSON
  2. Delivery
    Craft JWE with thousands of RSA recipients
  3. Exploit
    Submit small unauthenticated HTTP request
  4. Execution
    Server runs one RSA decrypt per recipient
  5. Persist
    Repeat requests exhaust CPU
  6. Impact
    Denial of service

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 target application call joserfc.jwe.decrypt_json() (the General JSON Serialization parser) on externally supplied JWE input and decrypt it with an RSA key-management algorithm such as RSA-OAEP or RSA1_5, in any version prior to 1.7.5. No authentication, no user interaction, and no non-default configuration are required against vulnerable versions - the vulnerable loop has no recipient-count cap and processes every recipient before consulting any option. The documented verify_all_recipients=False flag does NOT limit exploitation, as confirmed at runtime: it only affects exception behavior, not the number of RSA operations performed. Limiting factors that reduce real-world exposure: applications that do not use General JSON Serialization (e.g. only compact JWE), that do not decrypt attacker-controlled JWE, or that use non-RSA key-management algorithms are not meaningfully affected; the asymmetric cost derives specifically from expensive RSA private-key operations.

Impact

This is a genuine, well-evidenced availability risk but not a confidentiality/integrity emergency. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5 High) is internally consistent with the description and the source-code analysis: a remote, unauthenticated attacker over the network, with low complexity and no user interaction, can force unbounded RSA private-key decryption operations, with impact limited entirely to availability (C:N/I:N - the advisory explicitly states confidentiality and integrity are unaffected). The vuln.today decision label is 'this_week', consistent with a serious-but-not-critical DoS that should be patched promptly rather than as a fire drill. No EPSS score and no KEV listing were provided, so there is no signal of active in-the-wild exploitation; exploitation status is best characterized as a published, confirmed proof-of-concept rather than observed attacks. The one point to verify operationally is reachability: the 7.5 assumes an application actually exposes joserfc.jwe.decrypt_json() to untrusted JWE General JSON input using an RSA key-management algorithm - environments that only use compact serialization or non-RSA algorithms face materially lower real-world risk than the raw score implies. No conflicting signals were found; the CVSS, CWE-400, the GHSA advisory, and the fix commit all agree this is uncontrolled resource consumption.

Exploit ScenarioDerived

An application exposes an HTTP endpoint that accepts a JWE in General JSON Serialization and decrypts it with joserfc using an RSA-OAEP (or RSA1_5) private key. An unauthenticated attacker submits a single small request containing a 'recipients' array with thousands of entries, forcing one full RSA private-key decryption per recipient and consuming server CPU far out of proportion to the request size. A confirmed proof-of-concept in the GHSA advisory demonstrates near-linear scaling (e.g. ~1,500 recipients ≈ 1.9s CPU per request), and repeated requests can exhaust CPU and deny service.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
1 PoC candidate (unverified) 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 29, 2026

CPU-exhaustion denial of service in joserfc prior to 1.7.5 affects any Python service that passes externally supplied JWE General JSON Serialization documents to joserfc.jwe.decrypt_json() and decrypts them with an RSA key-management algorithm such as RSA-OAEP or RSA1_5. Because the recipients array has no count limit and the decrypt loop performs one full private-key RSA operation per entry, an unauthenticated remote attacker can choose how much CPU a single request consumes; the documented verify_all_recipients=False option does not reduce that work. Confidentiality and integrity are unaffected, and a public PoC reference exists that measures the linear cost growth (recipients 1500 produced roughly 594 KB of input and about 1.9 seconds of decrypt time in the advisory's run).

RemediationAI

Vendor-released patch: upgrade to joserfc 1.7.5 or later, which adds a JWERegistry.max_recipients limit (default 16) enforced by validate_recipient_count() during extract_general_json(), and also makes verify_all_recipients=False stop the decrypt loop after the first success; the fix is in commit d6dc8df6c7609277e741069d3733e43996c1cd17 and the release at https://github.com/authlib/joserfc/releases/tag/1.7.5. Because the vulnerable loop runs before any option is consulted, simply setting verify_all_recipients=False on a pre-1.7.5 version does not mitigate the CPU cost and should not be relied on. If upgrading is delayed, the practical compensating control is to reject or truncate JWE General JSON documents whose recipients array exceeds a small fixed count at the application or reverse-proxy layer before they reach decrypt_json(), and to prefer compact serialization or non-RSA key-management algorithms for attacker-facing endpoints; note that lowering the recipient cap can break legitimate multi-recipient JWE workflows, so verify the limit against expected traffic. The advisory's reproduction code can be used to confirm the fix by checking that an oversized recipients array now raises ExceededSizeError.

Affected VersionsENISA

joserfc < 1.7.5

Affected Packages

pypi joserfc fix: 1.7.5

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 is a Python implementation of the JOSE standards (JWS, JWE, JWK). JWE General JSON Serialization wraps a ciphertext with a "recipients" array, where each entry carries its own encrypted key and headers. In vulnerable versions, extract_general_json() in src/joserfc/_rfc7516/json.py appends a Recipient object for every array entry without any upper bound, and _perform_decrypt() in src/joserfc/_rfc7516/message.py then calls decrypt_recipient() for each one, dispatching to the RSA key-management algorithm's decrypt_cek() (src/joserfc/_rfc7518/jwe_algs.py), a genuine RSA private-key operation. The registry already enforces size caps for headers, encrypted keys, IVs, ciphertext and authentication tags, but had no max_recipients check, which is the CWE-400 (Uncontrolled Resource Consumption) root cause. Critically, the loop processes every recipient before registry.verify_all_recipients is consulted, so setting that flag to False changes only whether a failure raises an exception, not the number of RSA operations; runtime measurements in the advisory show identical decrypt times for both settings at the same recipient count. The cost is asymmetric because RSA private-key operations are expensive relative to the small incremental input size per recipient (about 396 bytes each).

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

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

Remote unauthenticated attacker (AV:N/PR:N/UI:N), low-complexity attacker-chosen recipient count (AC:L), impact is CPU exhaustion only (C:N/I:N/A:H), no scope change (S:U).

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/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
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
High

Lifecycle Timeline

2
Patch available
Oct 29, 2026 - 22:03 EUVD
CVE Published
Oct 29, 2026 - 21:10 cve.org
HIGH 7.5

DescriptionCVE.org

joserfc is a Python library that provides an implementation of several JSON Object Signing and Encryption (JOSE) standards. Prior to 1.7.5, joserfc.jwe.decrypt_json() accepts a JWE General JSON Serialization recipients array without a count limit and calls decrypt_cek() for every entry. An unauthenticated attacker who can submit a JWE to an endpoint using an RSA key-management algorithm can choose the number of private-key decryption operations performed by one request. The verify_all_recipients option does not reduce this work because the affected loop processes every recipient before consulting that setting, allowing repeated requests to exhaust service CPU without affecting confidentiality or integrity. This issue is fixed in version 1.7.5.

Blast Radius

ecosystem impact
† from your stack dependencies † transitive graph · vuln.today resolves 4-path depth
  • 6 pypi packages depend on joserfc (6 direct, 0 indirect)

Ecosystem-wide dependent count for version 1.7.5.

Technical POC Analysis

Uncontrolled resource consumption (CWE-400) caused by a missing length check on an attacker-controlled JSON array that drives a per-element expensive cryptographic operation.

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Latest POC

1 PoC candidate from github (unverified)

Sign in to open the public PoC links collected for this CVE.

Executive ViewAI

Why It Matters

CVE-2026-119283 is a high-severity CPU-exhaustion denial-of-service vulnerability in the joserfc Python library, affecting any service that decrypts externally supplied JWE General JSON Serialization documents using RSA key-management algorithms. Unauthenticated remote attackers can craft payloads with an unlimited number of recipients, forcing one full private-key RSA operation per entry and consuming substantial CPU per request, potentially degrading or halting service availability for legitimate users. Leadership should care because public proof-of-concept reference exists, exploitation is trivial, and the vulnerability can impact any internet-facing Python application relying on joserfc for token decryption, though confidentiality and integrity remain unaffected.

Business Impact: High
Compensating Controls

Until the vendor patch (joserfc 1.7.5) is applied, enforce strict input validation to reject JWE documents with excessive recipients (e.g., limit to a small maximum), apply rate limiting and request-size restrictions at the API gateway or reverse proxy, and monitor CPU usage for anomalies; note that the verify_all_recipients=False option does not mitigate the issue.

Threat Intelligence Overview

EPSS Score
0.2%
Top 86% exploitable
Prevalence
Low
niche Python JOSE library; RSA JWE General JSON decryption path rarely exposed
Threat Intel
1
1 source
Social Media
1
Sightings
Data Quality
5 sources
Confidence: Medium
EUVD NVD CVE.org EPSS Vulnrichment GHSA CIRCL GitHub VulDB

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 Yes
EPSS 0.2%
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
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

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

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

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