Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessVictim app requests data from attacker-controlled server
-
DeliveryServer returns tiny highly-compressed body
-
ExploitDecoder inflates chunk past requested bound
-
ExecutionUncapped decompression exhausts memory
-
ImpactClient process/service crashes (DoS)
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 the victim application to (1) use Zapros <0.14.0 and (2) stream a compressed response - via iter_bytes(chunk_size=...) or the default - from a server the attacker controls or can MITM, while relying on the chunk-size bound to cap memory. The specific defect is that the built-in decompression decoder ignores the caller's chunk_size limit, so one compressed chunk can inflate arbitrarily. Limiting factors: the attacker must serve the malicious compressed body (client-initiated connection to a hostile/compromised origin), and the impact is confined to availability (process/host memory exhaustion) with no data disclosure or modification. Mitigations that remove the condition: reading with Response.iter_raw()/async_iter_raw() and decompressing manually with an explicit output-size bound (e.g. zlib max_length), or sending Accept-Encoding: identity to disable server-side compression. |
| Impact | The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H, base 8.7 High) correctly isolates the impact to availability only (VA:H) with no confidentiality or integrity loss, consistent with a CWE-770 memory-exhaustion/decompression-bomb flaw. There is no EPSS score, no CISA KEV listing, and no public exploit code provided, so the signal is: no public exploit identified at time of analysis and no evidence of active exploitation. The scored network vector and no-privilege/no-interaction rating are technically defensible because a caller-side HTTP client is compromised simply by streaming a compressed response, but exploitation is directionally inverted from a typical server flaw - the ATTACKER must control (or MITM) the HTTP server the victim's application chooses to contact, which is a meaningful real-world gate the base score does not surface. Net: this is a legitimate availability bug worth patching for any service that fetches compressed data from untrusted origins, but it is not a drop-everything internet-wide threat - the affected product's tiny footprint and the requirement to talk to a hostile server keep realistic priority moderate rather than critical. |
| Exploit ScenarioDerived | An application uses the Zapros HTTP client (<0.14.0) to stream responses from a remote endpoint and relies on iter_bytes(chunk_size=...) or the default chunk size to cap memory usage. An attacker who controls or intercepts that endpoint returns a small, highly compressed (e.g. gzip/deflate) response that the client-side decoder inflates far beyond the requested chunk bound, exhausting process memory and crashing the client or its host service. No public proof-of-concept is referenced in the available data. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 21, 2026
Denial of service via memory exhaustion affects Zapros, the Python HTTP client, in all releases prior to 0.14.0. An unauthenticated remote attacker who controls, or can man-in-the-middle, the origin server can return a small compressed response that the built-in decompression decoder inflates far beyond the caller-supplied bound, because iter_bytes(chunk_size=...) and its default are ignored during decoding - a single chunk can therefore exhaust process or host memory (CVSS 4.0 8.7 High, availability-only: VA:H, VC:N, VI:N, PR:N, UI:N). The vendor released a fix in 0.14.0, and no public exploit code or confirmed active exploitation was identified at time of analysis.
RemediationAI
Upgrade Zapros to 0.14.0 or later, which is the vendor-released patch and makes the decompression decoder respect the caller's chunk_size bound; see GHSA-6cp7-3m3c-5x5c. Where an immediate upgrade is not possible, use the vendor-documented workarounds: read the still-compressed body with Response.iter_raw()/Response.async_iter_raw() and decompress it yourself under an explicit output-size limit (for example zlib's max_length), aborting once a configured cap is exceeded - the trade-off is that you now own decompression correctness and buffering, and a poorly chosen limit can truncate legitimate large responses. Alternatively, send Accept-Encoding: identity so servers return uncompressed bodies that are never decompressed client-side; this costs bandwidth, can be ignored or overridden by some servers/CDNs, and may not apply to already-negotiated streams. As a general hardening step, avoid decoding response bodies from untrusted or unauthenticated origins, and monitor for anomalous memory growth in processes streaming responses from third-party hosts.
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
The root cause is CWE-770 (Allocation of Resources Without Limits or Throttling) in Zapros' response-streaming decompression path. Zaporos, like other HTTP clients, exposes streamed body iteration with a caller-controlled chunk size (Response.iter_bytes(chunk_size=...) or a library default) intended to bound how much data is held in memory at once. Its built-in decoders for compressed transfer encodings (e.g. gzip/deflate-style content) apply that bound to the compressed input but not to the inflated output, so a compressed payload can expand by orders of magnitude before any limit is enforced - the classic decompression-bomb pattern. Streaming a response from a hostile or compromised origin is therefore sufficient to drive unbounded decoder allocations, and the flaw is only reachable by callers that stream and let Zapros decompress. The CPE cpe:2.3:a:kap-sh:zapros:*:*:*:*:*:*:*:* confirms every pre-0.14.0 release of the package is in scope; the fix in 0.14.0 makes the decoder honor the caller's chunk-size bound.
Know when Zapros 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:H/SC:N/SI:N/SA:N
Client crashes merely by streaming a compressed response from a hostile server (AV:N/AC:L/PR:N/UI:N); impact is availability-only memory exhaustion (A:H, C:N/I:N), same process so S:U.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
Zapros, a Python HTTP client, prior to version 0.14.0 is vulnerable to denial of service via memory exhaustion. The issue affects all callers who streamed compressed responses relying on the chunk size - explicit (iter_bytes(chunk_size=...)) or the default - to bound memory. The decoder ignored that bound, so a chunk could be far larger than requested and a single compressed response could overflow memory. Version 0.14.0 contains a patch. Some workarounds are available. Read the still-compressed body with Response.iter_raw() / Response.async_iter_raw(), which bypass the built-in decoders, and decompress it yourself with an explicit output-size bound (e.g. zlib's max_length), aborting once a configured limit is exceeded. Where feasible, send Accept-Encoding: identity to disable response compression so bodies are not decompressed client-side. Avoid decoding response bodies from untrusted servers.
Technical POC Analysis
CWE-770, Allocation of Resources Without Limits or Throttling - a classic decompression-bomb primitive.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
A high-severity denial-of-service flaw in Zapros, the Python HTTP client library, lets an unauthenticated attacker who controls or intercepts the server connection force a small compressed response to expand into unbounded memory use, crashing or exhausting any application built on releases prior to 0.14.0. Because Zapros is typically embedded inside internal services, data pipelines, and API integrations, the exposure sits with engineering-owned components rather than the network perimeter, and a single crafted response can take dependent business processes offline. No public exploit has been identified at time of analysis, so leadership has a near-term window to drive library upgrades before opportunistic scanning and exploitation begin.
Apply vendor patch (upgrade to Zapros 0.14.0 or later). Until then, enforce per-process and per-container memory limits, restrict or sandbox fetches of untrusted origins, and enforce strict outbound TLS validation to reduce man-in-the-middle risk.
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
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
EUVD-2026-84175
GHSA-6cp7-3m3c-5x5c
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB