Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessControl or influence an HTTP/1 origin server
-
DeliverySend chunked response with malformed chunk-size line (5ZZZZZ / 0ZZZZ)
-
ExploitMint and strict intermediary disagree on chunk boundaries
-
ExecutionDesynchronize the shared pooled connection
-
ImpactPoison response queue for subsequent co-tenant requests
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V4 - API and Web Service HTTP request consistency
|
| Exploitation Conditions | Requires all of the following to align: (1) the target application uses Mint (0.1.0 up to but not including 1.10.1) for HTTP/1 over a pooled/shared connection; (2) an RFC-9112-strict intermediary (proxy, CDN, or load balancer) sits between Mint and the origin so the two parsers can disagree on chunk boundaries; and (3) the attacker controls or can influence an HTTP/1 server's chunked responses to inject a malformed chunk-size line (hex digits followed by arbitrary non-';' bytes, e.g. '5ZZZZZ', '5 9', or '0ZZZZ'). Limiting factors: exploitation is unauthenticated (PR:N) but non-trivial (AT:P) because it depends on this specific desync topology; a connection not shared/pooled, or the absence of a strict intermediary, largely neutralizes the impact. Impact is confined to confidentiality/integrity of responses on the poisoned connection (VC:L/VI:L), with no availability or code-execution effect. |
| Impact | This is a moderate-severity HTTP/1 response-smuggling flaw (CWE-444) that is a real but conditional priority rather than a drop-everything issue. The vendor CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:N/UI:N/VC:L/VI:L/VA:N/SC:N) scores 6.3: network-reachable and unauthenticated, but critically gated by AT:P (Attack Requirements: Present), which correctly captures that exploitation is not fire-and-forget - it needs a specific topology (a malicious/attacker-influenced HTTP/1 server, a strict RFC-9112 intermediary in the path, and a pooled/shared connection). Impact is limited to Low confidentiality and Low integrity with no availability or subsequent-system impact, consistent with response-queue poisoning that can misattribute or corrupt responses to co-tenant requests rather than granting code execution. No EPSS score, no CISA KEV listing, and no public POC are present in the provided intelligence, so there is no evidence of active or automated exploitation; the risk is opportunistic/targeted at best. Note a clear data conflict: the input Tags include 'RCE', but nothing in the description, CWE-444, or the patch supports remote code execution - this is request/response smuggling only, and the 'RCE' tag should be disregarded. A patch (mint 1.10.1) is available and remediation is straightforward, which lowers residual risk for maintained deployments. |
| Exploit ScenarioDerived | An Elixir application using Mint (directly or via Finch/Req/Tesla) makes HTTP/1 requests through a strict intermediary (proxy/CDN/load balancer) over a pooled connection to a server the attacker controls or can influence. The attacker returns a chunked response whose chunk-size line contains trailing non-hex bytes (e.g. '5ZZZZZ' or '0ZZZZ'); the strict intermediary and Mint disagree on where the response ends, letting attacker-planted bytes be dequeued as the response to a different, legitimate request sharing that connection. No public exploit code is identified at time of analysis, and the AT:P attack requirement means the specific intermediary/pooling topology must exist. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 19, 2026
Chunked-response smuggling in the Elixir Mint HTTP client (0.1.0 through 1.10.0) allows a malicious or compromised HTTP/1 origin to desynchronize an RFC-9112-strict intermediary from Mint on a shared, pooled connection, poisoning the response queue so that later requests reusing that socket receive another request's or attacker-chosen response content. Mint's chunk-size parser accepts trailing junk after the hex size (for example '5ZZZZZ', '5 9', or '0ZZZZ') while strict proxies reject it, so the two disagree on chunk boundaries and on where the message ends. Exploitation is unauthenticated (PR:N) but conditional and non-trivial: it requires a pooled connection to an attacker-influenced origin plus a strict intermediary in the path; impact is limited to confidentiality and integrity of responses on the poisoned connection (VC:L/VI:L), with no availability or code-execution effect, and no public exploit code has been identified at time of analysis. Note that upstream tag metadata for this CVE includes 'RCE'; that label is not supported by the assessed vector or impact and should not be used for prioritization.
RemediationAI
Upgrade Mint to 1.10.1 or later: the vendor-released patch fixes the chunk-size grammar, with the upstream fix in commit c82377838dc6e275ef40bafa664fbcdf50270c60 (linked as the patch reference) and the related decoder rework in commit 60089586ec7adc9fddb09f69a2f5919ba9ac7f33; the advisory at https://github.com/elixir-mint/mint/security/advisories/GHSA-rj5m-69wp-cxq9 should be the source of record for the exact published version. If an immediate upgrade is not possible, compensating controls target the preconditions rather than the parser: disable HTTP/1 keep-alive or connection pooling for Mint clients that talk to untrusted or third-party origins, forcing a fresh connection per request at the cost of higher latency and TLS handshake overhead; avoid sending requests to attacker-influenced origins through the same pooled connection as sensitive ones, accepting the operational cost of separate connection pools or client instances; and, where feasible, terminate or normalize chunked responses at a trusted gateway that enforces RFC 9112 strictness before they reach Mint, though this does not help if the strict intermediary is exactly the component the attacker is desynchronizing from. Monitor for anomalous mixed response content or unexpected body truncation on pooled connections as a detection signal, and note that no public exploit code has been identified, so these are precautionary measures rather than responses to observed attacks.
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
The flaw is CWE-444 (Inconsistent Interpretation of HTTP Requests, i.e. HTTP request/response smuggling) rooted in divergent parsing of HTTP/1.1 chunked transfer encoding (RFC 9112 Section 7.1). RFC 9112 permits a chunk-size line of hex digits optionally followed by a ';'-introduced chunk extension, terminated by CRLF; any other trailing byte is a protocol error. Mint.HTTP1.Parse.chunk_size/1 in lib/mint/http1/parse.ex parses only the leading hex run and returns the remaining bytes unexamined, and Mint.HTTP1.decode_body/5 in lib/mint/http1.ex then discards everything up to the next CRLF via Parse.ignore_until_crlf/1. The effective accepted grammar therefore becomes hex-digits-plus-arbitrary-bytes, so a size line like '5ZZZZZ' or '5 9' is read as length 5 and '0ZZZZ' is treated as the terminating zero-length chunk, prematurely ending the body. When a strict intermediary normalizes or rejects that same line, the two parsers compute different message boundaries on the same byte stream: the intermediary may forward remaining bytes (including a following response) that Mint instead treats as the current body, or vice versa, producing response-queue poisoning on the pooled connection. Affected components map to CPE cpe:2.3:a:elixir-mint:mint (0.1.0 up to but not including 1.10.1). The upstream fix (commit 60089586ec7adc9fddb09f69a2f5919ba9ac7f33 in the xhttp conn decoder) replaces the loose Integer.parse-then-skip approach with an explicit chunked state machine ({:chunked, nil} -> size parsing with strict rejection of leftover bytes, :metadata CRLF enforcement, :trailer decoding) and returns {:error, :invalid_response} where the grammar is violated.
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:L/VI:L/VA:N/SC:N/SI:N/SA:N
Network-reachable and unauthenticated (AV:N/PR:N) but AC:H because it needs a strict intermediary plus a malicious server on a pooled connection; low confidentiality/integrity, no availability or code execution.
Primary rating from Vendor (EEF).
CVSS VectorVendor: EEF
DescriptionCVE.org
Inconsistent Interpretation of HTTP Requests ('HTTP Request/Response Smuggling') vulnerability in elixir-mint mint allows a malicious HTTP/1 server to desynchronize a strict intermediary and the Mint client on a pooled connection, enabling response-queue poisoning against subsequent requests that share the connection.
Mint.HTTP1.Parse.chunk_size/1 in lib/mint/http1/parse.ex stops at the first non-hexadecimal byte of a chunked response's chunk-size line and returns the remainder unexamined. Mint.HTTP1.decode_body/5 in lib/mint/http1.ex then discards every byte up to the CRLF with Parse.ignore_until_crlf/1, so the accepted grammar is a run of hex digits followed by arbitrary bytes, where RFC 9112 permits only a ;-introduced chunk extension. Lines such as 5ZZZZZ and 5 9 are accepted as chunk size 5, and 0ZZZZ is accepted as the terminating chunk that ends the message body. An RFC-strict intermediary rejects such a line while Mint accepts it, so the two disagree on chunk boundaries and on where the response ends.
This issue affects mint: from 0.1.0 before 1.10.1.
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
HTTP request smuggling exploits inconsistencies in how front-end and back-end servers parse HTTP message boundaries.
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
CPU exhaustion via crafted chunked HTTP responses affects the Elixir Mint HTTP client library (versions 1.9.3 through be
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
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-83608
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB