Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconAttacker operates or compromises HTTP server
-
DeliveryVictim application sends HTTP/1.1 request to attacker server
-
ExploitServer returns valid 200 status and headers (bypass intermediary inspection)
-
InstallServer streams chunked body with oversized hex chunk-size field byte-by-byte
-
C2Each TCP segment triggers O(N²) re-parse of accumulated buffer
-
ExecuteCPU exhausted on client host
-
ImpactApplication denial of service
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V2 - Validation and Business Logic Algorithmic complexity limits
|
| Exploitation Conditions | The victim application must initiate an outgoing HTTP/1.1 connection to a server controlled or influenced by the attacker. The server must respond with HTTP/1.1 chunked transfer encoding (Transfer-Encoding: chunked) and stream an oversized chunk-size hex field. Applications that accept user-supplied URLs, act as HTTP proxy clients, or consume third-party APIs over HTTP/1.1 are most exposed. The CVSS 4.0 AT:P metric confirms the attack requirement: the attacker cannot initiate the connection - the client must reach out. Exploitation is limited to: (1) outbound HTTP/1.1 connections (HTTP/2 and HTTPS to pinned certificates are unaffected unless the server itself is compromised), (2) Mint versions 1.9.3 through pre-1.10.0, and (3) scenarios where the attacker controls or can intercept responses from the upstream server. Applications making requests exclusively to known-good, operator-controlled servers over TLS with certificate validation are not realistically at risk. |
| Impact | The CVSS 4.0 score of 6.3 reflects a moderate, client-side DoS with AT:P (attack requirements present), meaning exploitation is contingent on the victim application connecting to an attacker-controlled server - a non-trivial precondition that reduces real-world risk relative to a straightforward inbound server vulnerability. VA:L (low availability impact on the vulnerable system) is conservatively scored; in practice, the CPU exhaustion described (10+ seconds per large payload, compoundable) could fully starve a single-threaded Elixir process or degrade a pool under load, suggesting the real availability impact may be higher than the score implies. Applications most at risk are those that make outbound HTTP/1.1 requests to user-supplied URLs, act as reverse-proxy clients, or connect to third-party services that could themselves be compromised. Applications with a fixed set of known-good upstream HTTPS servers face negligible risk unless those servers are compromised. No KEV listing and no POC code have been identified; EPSS was not provided in the source data. The risk-to-patch ratio strongly favors upgrading, given the fix is a one-line digit-count guard with no behavioral impact on valid responses. |
| Exploit ScenarioDerived | An attacker operates a malicious HTTP server (or compromises a legitimate one) that victim Elixir applications connect to via Mint. When the victim requests a resource, the server responds with a valid 200 status and headers - indistinguishable from a legitimate response to any inspection layer - then streams a chunk-size field containing hundreds of thousands of hex digits one byte per TCP packet. Each arriving byte triggers a full re-parse of the accumulated buffer, compounding O(N²) bignum multiplications until the client's CPU is exhausted. No POC code has been publicly identified, but the advisory provides sufficient technical detail to reproduce the condition. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 04, 2026
CPU exhaustion via crafted chunked HTTP responses affects the Elixir Mint HTTP client library (versions 1.9.3 through before 1.10.0). The chunk-size hex parser in lib/mint/http1/parse.ex accumulates digits into an arbitrary-precision integer using acc * 16 + digit with no upper bound on digit count, producing O(N²) cost per parse pass; compounded by a re-parse-from-start design on each socket message, a server that trickles digits forces the client to pay this cost repeatedly. Benchmark data in the advisory confirms ~512,000 hex digits produces over ten seconds of CPU in a single pass, and an intermediary inspecting only headers sees a normal 200 response. No public exploit identified at time of analysis; patch is available in version 1.10.0.
RemediationAI
Upgrade Elixir Mint to version 1.10.0 or later, which includes the fix from commit bd2a4e7513594997c140cfef9fe0e968712fb588 (https://github.com/elixir-mint/mint/commit/bd2a4e7513594997c140cfef9fe0e968712fb588). Update your mix.exs dependency to {:mint, "~> 1.10"} and run mix deps.update mint. If an immediate upgrade is not possible, a compensating control is to restrict the application from connecting to untrusted or user-controlled HTTP endpoints at the network or application layer; however, this is highly application-specific and may not be feasible. Disabling HTTP/1.1 chunked transfer encoding is not an option within Mint itself - the protocol requires it. The full advisory is at https://github.com/elixir-mint/mint/security/advisories/GHSA-7p8w-j234-7qc8.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Mint is an Elixir HTTP/1.1 and HTTP/2 client library (CPE: cpe:2.3:a:elixir-mint:mint). HTTP/1.1 chunked transfer encoding requires parsing a hex integer chunk-size field before each body chunk. The affected parse_hex_prefix/2 function in lib/mint/http1/parse.ex performs digit accumulation using Elixir's native arbitrary-precision integers (bignums). Because bignum multiplication cost scales with the number's width, processing N hex digits costs O(N²) overall - a classic CWE-407 (Inefficient Algorithmic Complexity) pattern. The secondary amplifier is handle_data/2, which prepends conn.buffer and restarts parsing from the first byte on every new TCP segment, meaning a server that deliberately dribbles chunk-size bytes one at a time multiplies the O(N²) cost by the number of segments. The fix, applied in commit bd2a4e7513594997c140cfef9fe0e968712fb588, caps digit count at 16 (@max_chunk_size_digits 16), limiting the chunk size to the maximum uint64 value (0xFFFFFFFFFFFFFFFF ≈ 18 EiB), which is compatible with all practical HTTP payloads while making the parse O(1) per segment.
Know when Mint 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:P/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N
Network vector but AC:H because attacker must control the server the client connects to; availability impact is Low per bounded CPU exhaustion.
Primary rating from Vendor (EEF).
CVSS VectorVendor: EEF
DescriptionCVE.org
Inefficient Algorithmic Complexity vulnerability in elixir-mint mint allows a remote HTTP server to exhaust CPU on the client host and cause a denial of service.
parse_hex_prefix/2 in lib/mint/http1/parse.ex folds each hex digit of a chunked response's chunk-size field into an arbitrary-precision accumulator with acc * 16 + digit and imposes no limit on the digit count. Because the accumulator grows without bound, the multiplication is not constant time and one pass over N digits costs O(N squared). handle_data/2 prepends conn.buffer and re-parses from the start on every socket message, so a server that dribbles the digits out in small packets makes the client pay that cost repeatedly. A run of roughly 512,000 hex digits costs over ten seconds of CPU in a single pass, measured on stock defaults. The parser reaches this state after a valid status line and a complete, valid header section, so an intermediary inspecting only headers sees an ordinary 200 response.
This issue affects mint: from 1.9.3 before 1.10.0.
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.
Memory exhaustion in the Elixir Mint HTTP/2 client (versions 0.1.0 through 1.8.x) allows a malicious or compromised HTTP
Memory exhaustion in elixir-mint Mint HTTP/2 client (versions 0.2.0 through 1.8.x) allows a malicious HTTP/2 server to c
HTTP response smuggling in the Elixir Mint HTTP client library (versions 0.1.0 through before 1.9.0) allows attacker-con
Uncontrolled memory allocation in the Elixir Mint HTTP client (Mint.HTTP1 module, versions 0.5.0 through 1.9.0) lets a m
Unbounded memory accumulation in the elixir-mint Mint HTTP client library (versions 0.1.0 through <1.10.0) enables a rem
Unbounded memory consumption in the Elixir Mint HTTP client (versions 0.1.0 through 1.9.1) lets a malicious or attacker-
Memory exhaustion denial-of-service in Elixir Mint affects versions 1.1.0 through 1.10.x and allows a malicious or compr
Memory exhaustion in elixir-mint's HTTP/2 client library (mint) allows a malicious or attacker-controlled HTTP/2 server
HTTP/1 response smuggling in the Elixir Mint client (0.1.0 through 1.10.x) allows a malicious or attacker-influenced ori
Memory exhaustion in the Elixir Mint HTTP/2 client (mint 0.1.0 through 1.10.x) lets a malicious or man-in-the-middle HTT
Chunked-response smuggling in the Elixir Mint HTTP client (0.1.0 through 1.10.0) allows a malicious or compromised HTTP/
Response-queue poisoning in the elixir-mint Mint HTTP/1.1 client library (versions 0.1.0 through before 1.9.3) allows a
EUVD-2026-71219
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB