Skip to main content

urllib3 EUVDEUVD-2026-89017

| CVE-2026-97689 HIGH
Allocation of Resources Without Limits or Throttling (CWE-770)
2026-09-29 GitHub_M GHSA-vxq7-64xx-v4gw
8.9
CVSS 4.0 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Induce client to request attacker/MITM server
  2. Delivery
    Server sends Transfer-Encoding: chunked
  3. Exploit
    Emit unterminated multi-megabyte chunk-size line
  4. Execution
    readline() buffers input without length bound
  5. Impact
    Client memory exhausted, process crashes

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource allocation 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 urllib3-based client (a) consumes a response using the streaming path - HTTPResponse.stream() or HTTPResponse.read_chunked() (not the non-streaming .read(), which was already bounded to http.client._MAXLINE), and (b) connects to a server the attacker controls or can machine-in-the-middle. The malicious server must respond with 'Transfer-Encoding: chunked' and then send a very long run of bytes with no newline in the chunk-size line. No authentication (PR:N) and no local access are needed against the client, and it works against default configurations of affected versions (1.10.3 through 2.7.x). The principal LIMITING factor is the trust boundary: applications that only contact fixed, trusted endpoints are largely unexposed, whereas SSRF-prone, proxy, crawler, or webhook-fetching services that reach arbitrary URLs are realistically exposed.

Impact

This is a genuine but bounded-impact denial-of-service issue, not an RCE. The vendor CVSS 4.0 vector (8.9 High) is availability-only: VC:N/VI:N/VA:H with subsequent-system SA:H and no confidentiality or integrity impact - the elevated numeric score reflects the DoS severity, not code execution. Critically, the attack direction is inverted: this is a SERVER→CLIENT attack (a malicious or MITM HTTP server exhausts the memory of the urllib3 CLIENT process), so it is only exploitable when the victim application makes an HTTP request to attacker-influenced infrastructure. That constraint is captured by AT:P (attack requirements present) in the 4.0 vector; note that CVSS 3.1 has no AT metric, so a naive 3.1 mapping of AV:N/AC:L/PR:N/UI:N/A:H = 7.5 actually OVERSTATES exploitability by omitting the malicious-server prerequisite. No EPSS score, no CISA KEV listing, and no public exploit are present in the supplied data, so there is no evidence of active exploitation. The fix commit and GitHub Security Advisory are confirmed, which raises fix-availability confidence. Net: real priority because urllib3 is everywhere and the fix should be adopted, but the practical risk is limited to environments where clients contact untrusted servers (SSRF-adjacent flows, proxies, crawlers, webhook/callback fetchers).

Exploit ScenarioDerived

A victim Python application (or any of the many libraries built on urllib3, e.g. requests) sends an HTTP request to a server the attacker controls - or an on-path attacker intercepts a response. The server replies with 'Transfer-Encoding: chunked' and then streams a very long, never-terminated chunk-size line; urllib3's streaming read path buffers the entire run without a length bound, driving memory allocation until the client process is exhausted or killed. No public exploit code is identified at time of analysis, though the fix's regression tests demonstrate the trigger.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.3% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Sep 29, 2026

Unbounded memory allocation in urllib3 (1.10.3 through 2.7.x) lets a malicious or machine-in-the-middle HTTP server exhaust the memory of a Python client process by streaming an unterminated chunk-size line in a 'Transfer-Encoding: chunked' response. Only clients that consume the response through the streaming path (HTTPResponse.stream() or HTTPResponse.read_chunked()) are affected; the non-streaming .read() path was already bounded to http.client._MAXLINE. Exploitation is unauthenticated (CVSS:4.0 vector PR:N, assessed CVSS:3.1 PR:N) but requires the client to reach an attacker-controlled or intercepted endpoint, so SSRF-prone, proxy, crawler, and webhook-fetching services are the realistic exposure; impact is denial of service only (C:N/I:N/A:H, no RCE), and no public exploit identified at time of analysis.

RemediationAI

Upgrade to urllib3 2.8.0 or later (vendor-released patch; fix commit cd770b059b543be29298ea5c52afb0b1b090f5ed, https://github.com/urllib3/urllib3/releases/tag/2.8.0, advisory https://github.com/urllib3/urllib3/security/advisories/GHSA-vxq7-64xx-v4gw), then pin the minimum version in requirements files and rebuild containers so the fix is not re-pulled from a stale layer. Where upgrading is not immediately possible, avoid the vulnerable code path by consuming responses non-streaming (preload_content=True / response.read() / response.data), which was already bounded to http.client._MAXLINE - the trade-off is that the whole body is buffered in the client's memory, which itself can be expensive for large or attacker-sized payloads. Because exploitation depends on the client talking to an attacker-controlled or intercepted server, restrict egress from services that fetch arbitrary URLs (SSRF hardening), validate and allow-list proxy, crawler and webhook destinations, and require TLS certificate verification so machine-in-the-middle servers cannot serve the malicious chunked response; these controls reduce exposure only and do not replace patching. No workaround was identified that preserves streaming semantics while removing the unbounded read other than patching.

Affected VersionsENISA

urllib3 1.10.3, < 2.8.0

Affected Packages

pypi urllib3 fix: 2.8.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

urllib3 is the widely used HTTP client library for Python. Under HTTP/1.1 chunked transfer-encoding, a response body is framed as a sequence of chunks, each introduced by a hexadecimal chunk-size line terminated by CRLF. urllib3's streaming reader in src/urllib3/response.py previously read that size line with an unbounded self._fp.fp.readline() call inside _update_chunk_length() (and similarly for chunk trailers in read_chunked()), so a server that never sends the terminating newline causes the library to buffer an arbitrarily long run of bytes in memory. This is CWE-770 (Allocation of Resources Without Limits or Throttling): the parser imposes no cap on input length. The fix (commit cd770b059b543be29298ea5c52afb0b1b090f5ed, released in 2.8.0) introduces _MAX_CHUNK_LINE_LENGTH = 2**16 (65536 bytes, matching http.client._MAXLINE), reads the size line and trailer line with a bounded readline(_MAX_CHUNK_LINE_LENGTH + 1), closes the connection, and raises urllib3.exceptions.ProtocolError if the limit is exceeded - making the streaming path consistent with the stdlib-derived non-streaming .read() path, which was already bounded. The CPE cpe:2.3:a:urllib3:urllib3 identifies the package; affected builds are those from 1.10.3 up to but not including 2.8.0.

Know when Urllib3 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 8.9 HIGH
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:H
vuln.today AI 7.5 HIGH

Remote availability-only DoS with no auth or user interaction (7.5); note 3.1 lacks an AT metric so it cannot represent the required malicious-server condition captured by 4.0's AT:P.

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:P/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:H
SUSE 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Red Hat 7.5 HIGH

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
Present
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
High

Lifecycle Timeline

2
Patch available
Sep 29, 2026 - 17:17 EUVD
CVE Published
Sep 29, 2026 - 15:36 cve.org
HIGH 8.9

DescriptionCVE.org

urllib3 is an HTTP client library for Python. From 1.10.3 until 2.8.0, the HTTPResponse.read_chunked and HTTPResponse.stream methods can allocate unbounded memory because the streaming chunk parser buffers the chunk-size field until newline or EOF without a length bound. The trigger is that a malicious server returns Transfer-Encoding: chunked followed by a very long run of bytes without a newline. The attack mechanism is that a malicious HTTP server sends a very long unterminated chunk-size line. The impact is that unbounded memory allocation can exhaust the client process. This issue is fixed in version 2.8.0.

Technical POC Analysis

CWE-770 (Allocation of Resources Without Limits or Throttling) in urllib3's chunked-transfer decoder, reachable via HTTPResponse.readchunked() and HTTPResponse.stream().

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

Executive ViewAI

Why It Matters

urllib3 versions 1.10.3 through 2.7.x expose Python services that stream HTTP responses to memory-exhaustion denial of service when contacting an attacker-controlled or intercepted endpoint, and no vendor-released patched version was identified at the time of this analysis. This affects organizations running SSRF-prone, proxy, crawler, or webhook-fetching workloads, where a single malicious endpoint response can crash or destabilize the client process and disrupt dependent business services. Although no public exploit identified at time of analysis and no remote code execution is involved, the availability impact is high and leadership should prioritize exposure reduction.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: enforce memory limits at the container or process level; restrict egress to trusted endpoints via allowlists; avoid HTTPResponse.stream() and HTTPResponse.read_chunked() or wrap them with strict maximum response and chunk-size limits; prefer the bounded .read() path where compatible; terminate or proxy outbound HTTP through a service that enforces response-size and timeout caps; require TLS verification to reduce man-in-the-middle exposure; and monitor memory usage and malformed chunked responses.

Threat Intelligence Overview

EPSS Score
0.3%
Top 80% exploitable
Prevalence
Ubiquitous
urllib3 is among the most-downloaded PyPI packages, underpinning requests and most Python HTTP clients
Threat Intel
1
1 sources
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA MSRC Vendor GitHub

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 No
EPSS 0.3%
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
None
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Partial

Priority Score

44
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: 0
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.

CVE-2024-37891 MEDIUM POC
6.5 Jun 17

urllib3 is a user-friendly HTTP client library for Python. Rated medium severity (CVSS 6.5), this vulnerability is remot

CVE-2019-11236 MEDIUM POC
6.1 Apr 15

In the urllib3 library through 1.24.1 for Python, CRLF injection is possible if the attacker controls the request parame

CVE-2018-20060 CRITICAL
9.8 Dec 11

urllib3 before version 1.23 does not remove the Authorization HTTP header when following a cross-origin redirect (i.e.,

CVE-2025-50181 MEDIUM POC
5.3 Jun 19

urllib3 is a user-friendly HTTP client library for Python. Prior to 2.5.0, it is possible to disable redirects for all r

CVE-2025-66418 HIGH
8.9 Dec 05

Resource-exhaustion denial of service in urllib3 1.24 through 2.5.x allows a malicious or attacker-controlled HTTP serve

CVE-2025-66471 HIGH
8.9 Dec 05

A decompression-bomb denial-of-service flaw in the urllib3 Python HTTP client library (versions 1.0 through 2.5.x, fixed

CVE-2026-21441 HIGH
8.9 Jan 07

Uncontrolled resource consumption in the Python urllib3 HTTP client library (versions 1.22 through 2.6.2) lets a malicio

CVE-2023-43804 HIGH
8.1 Oct 04

urllib3 is a user-friendly HTTP client library for Python. Rated high severity (CVSS 8.1), this vulnerability is remotel

CVE-2026-97687 HIGH
7.6 Sep 29

Certificate validation bypass in urllib3 1.26.0 through 2.7.x allows a man-in-the-middle attacker who can impersonate th

CVE-2021-33503 HIGH
7.5 Jun 29

An issue was discovered in urllib3 before 1.26.5. Rated high severity (CVSS 7.5), this vulnerability is remotely exploit

CVE-2020-7212 HIGH
7.5 Mar 06

The _encode_invalid_chars function in util/url.py in the urllib3 library 1.25.2 through 1.25.7 for Python allows a denia

CVE-2019-11324 HIGH
7.5 Apr 18

The urllib3 library before 1.24.2 for Python mishandles certain cases where the desired set of CA certificates is differ

Vendor StatusVendor

SUSE

Severity: Important
Product Status
openSUSE Tumbleweed Fixed
SUSE Linux Enterprise High Performance Computing 15 SP4-ESPOS Affected
SUSE Linux Enterprise High Performance Computing 15 SP4-LTSS Affected
SUSE Linux Enterprise High Performance Computing 15 SP5-ESPOS Affected
SUSE Linux Enterprise High Performance Computing 15 SP5-LTSS Affected

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