Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconAttacker controls or compromises target HTTP server
-
DeliveryClient issues normal HTTP GET/POST to malicious server
-
ExploitServer returns compressed response with crafted decompression bomb payload
-
InstallHTTPX2 decoder calls decompress() without size bound
-
C2Single allocation expands 64 KiB input to ~64 MiB in heap
-
ExecuteRepeated per-chunk allocations exhaust system RAM
-
ImpactPython process OOM-terminated
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V2 - Validation and Business Logic Compression ratio limits
|
| Exploitation Conditions | Exploitation requires the HTTPX2 client to make an HTTP request to an attacker-controlled or compromised server that returns a response body encoded with gzip, deflate, brotli, or zstd (any encoding HTTPX2 decodes by default). The attacker must control the server endpoint, either by operating a malicious service, compromising a legitimate upstream, or positioning as a MITM on the network path. No authentication is required on the vulnerable client system. Applications that contact only a fixed, pre-vetted allowlist of internal servers face substantially lower exposure; applications that resolve and fetch user-supplied or third-party URLs are fully exposed under default HTTPX2 configuration. No non-default HTTPX2 setting is required to trigger the vulnerability - content decoding is enabled by default. |
| Impact | The CVSS 7.5 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) accurately reflects a trivially-reachable, unauthenticated availability attack with no confidentiality or integrity impact. EPSS data is absent from the input, and the vulnerability is not listed in CISA KEV, so active exploitation is not confirmed. The decompression-bomb technique is, however, well-documented and requires no reverse engineering - even a mid-sized municipal IT team in gdynia running HTTPX2-backed API aggregators should treat this as urgent, because any server in the client's request path (third-party APIs, user-supplied URLs, compromised upstreams) can trigger it without any cooperation from the application. The principal mitigating factor is deployment context: applications that restrict outbound HTTP to a fixed, fully-trusted allowlist of internal services face substantially reduced exposure, while those that fetch arbitrary or user-supplied URLs are fully exposed with no additional prerequisites. |
| Exploit ScenarioDerived | An attacker who operates or has compromised an HTTP server serves a response with |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 02, 2026
Memory exhaustion via unbounded decompression in HTTPX2 (all versions before 2.12.0) allows any HTTP server the client contacts to cause severe memory pressure or out-of-memory process termination by returning a crafted compressed response body. The content decoders in _decoders.py call decompress() without a size cap, so a single 64 KiB compressed chunk can inflate to approximately 64 MiB in one allocation across gzip, deflate, brotli, and zstd encodings - all enabled by default. No active exploitation is confirmed in CISA KEV, and no public proof-of-concept is referenced, but the decompression-bomb technique is well understood and trivially reproducible.
RemediationAI
Upgrade HTTPX2 to version 2.12.0 or later, as confirmed by the tagged release at https://github.com/pydantic/httpx2/releases/tag/v2.12.0 and security advisory GHSA-8xx6-hgc6-gc2m. The fix is implemented in PR #1126 (commit 4fd0c70a3f207c618b145934792f791bccfb39f8), which bounds all decompression calls to 1 MiB chunks. If an immediate upgrade is not feasible, applications can disable automatic content decoding in HTTPX2 and decompress responses manually using bounded reads - this requires code changes and sacrifices the library's convenience abstractions. A complementary compensating control is to configure downstream infrastructure (reverse proxy, WAF, or API gateway) to enforce a maximum response body size limit, which reduces but does not eliminate risk since the decompression amplification occurs client-side before any size check on the decompressed stream.
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
HTTPX2 (CPE: cpe:2.3:a:pydantic:httpx2:*:*:*:*:*:*:*:*) is pydantic's next-generation Python HTTP client, supporting gzip, deflate, brotli (br), and zstd response content encodings. CWE-409 (Improper Handling of Highly Compressed Data / Data Amplification) is the root cause class: the decode() and flush() methods on all content-decoder classes returned a single monolithic bytes object produced by an unbounded decompressor.decompress() call. Because HTTP chunked transfer encoding commonly segments bodies into 64 KiB chunks, a crafted server can trigger ~64 MiB heap allocations per chunk at a roughly 1000:1 expansion ratio, with only the OS OOM killer as a backstop. The fix in PR #1126 (commit 4fd0c70) introduces a MAX_DECODE_CHUNK_SIZE = 2**20 (1 MiB) constant and converts all decode()/flush() methods to generators that yield bounded slices, draining the decompressor iteratively via unconsumed_tail for zlib and an output_buffer_limit parameter for the brotli/zstd C backends.
Know when Httpx2 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:N/UI:N/S:U/C:N/I:N/A:H
Network-reachable via any HTTP server response; no credentials or user interaction required; impact is availability-only with no data exposure.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
HTTPX2 is a next generation HTTP client for Python. Prior to 2.12.0, the HTTPX2 content decoders in src/httpx2/httpx2/_decoders.py fully inflate each gzip, deflate, br, or zstd network chunk before iter_bytes() or aiter_bytes() yields bounded pieces to the application. A 64 KiB compressed chunk can expand to approximately 64 MiB in one intermediate allocation, so an attacker-controlled or compromised server can cause severe memory pressure or out-of-memory process termination even when the application streams the response. This issue is fixed in version 2.12.0.
Blast Radius
ecosystem impact- 18 pypi packages depend on httpx2 (18 direct, 0 indirect)
Ecosystem-wide dependent count for version 2.12.0.
Articles & Coverage 1
Technical POC Analysis
CVE-2026-84382 is an instance of CWE-409, Improper Handling of Highly Compressed Data (Data Amplification).
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
HTTPX2 HTTP client library in all current versions is vulnerable to denial-of-service attacks from any HTTP server it connects to, allowing attackers to crash the client application through memory exhaustion via crafted compressed responses. Any organization running services that use HTTPX2 faces immediate risk to application availability and system reliability.
No vendor-released patch identified at time of analysis. Interim mitigations: implement decompression size caps in application code before invoking HTTPX2 decoders, add memory watchdog alerts for affected processes, validate HTTP response sizes at the network level via proxies/gateways, and segment or rate-limit HTTP client workloads to contain blast radius of individual process crashes. Monitor vendor channels for HTTPX2 2.12.0 availability.
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
HTTPX2's SOCKS5 proxy implementation omits TLS negotiation for WebSocket Secure (wss://) origins, exposing the full WebS
Quadratic CPU exhaustion in HTTPX2's Server-Sent Events parser allows a malicious or compromised SSE endpoint to deny se
HTTP request smuggling in pydantic's HTTPX2 Python client library, all versions prior to 2.11.0, arises because Request.
CRLF injection in httpx2 (pydantic's next-generation Python HTTP client) before v2.11.0 allows manipulation of multipart
EUVD-2026-70251
GHSA-8xx6-hgc6-gc2m
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB