Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAttacker controls or compromises HTTP/1 origin server
-
DeliveryServe chunked response with signed chunk-size header (+0 or -0)
-
ExploitStrict RFC intermediary applies different message boundary than Mint client
-
ExecutionMint misidentifies response end; attributes injected bytes to next queued request
-
PersistResponse queue poisoned for co-tenant in-flight requests
-
ImpactAttacker reads or corrupts unrelated application responses
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 | Exploitation requires all three of the following conditions simultaneously: (1) The Mint client must be using HTTP/1.1 with a keep-alive pooled connection where multiple in-flight requests share the same TCP connection - without connection pooling, there are no co-tenant requests to poison. (2) A strict RFC 7230-compliant intermediary (reverse proxy, CDN, API gateway) must be present in the response path between the origin server and the Mint client - without the intermediary, there is no desynchronization and no injection surface. (3) An attacker must control or be able to influence the origin server's HTTP responses to include RFC-forbidden signed chunk-size headers ( |
| Impact | The CVSS 4.0 score of 6.3 (Medium) with vector AV:N/AC:L/AT:P/PR:N/UI:N/VC:L/VI:L/VA:N/SC:N/SI:N/SA:N accurately reflects conditional, moderate-impact exploitation. The critical limiting factor is AT:P (Attack Preconditions required in CVSS 4.0 terminology), meaning three specific conditions must align: the Mint client must be using HTTP/1.1 connection pooling, the response path must include a strict RFC-compliant intermediary, and the attacker must be able to influence origin server responses. This is not a broad spray-and-pray attack surface. The impact is limited to response confidentiality (VC:L) and integrity (VI:L) - an attacker can read or corrupt responses destined for other in-flight requests sharing the same connection pool, which is sufficient for session data theft or response injection but does not enable arbitrary code execution. No EPSS data was provided in the intelligence feed; given the niche attack topology and library-specific footprint, real-world mass exploitation risk is low. No CISA KEV listing and no public POC exist, making this a patch-now but not panic-now finding. The vendor's CVSS 4.0 vector and the CVE description are fully consistent - no contradictory signals observed. |
| Exploit ScenarioDerived | An attacker who controls or has compromised an HTTP/1 origin server behind a strict RFC-compliant proxy crafts a chunked HTTP response containing a |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jul 16, 2026
Response-queue poisoning in the elixir-mint Mint HTTP/1.1 client library (versions 0.1.0 through before 1.9.3) allows a malicious or attacker-influenced HTTP/1 origin server to desynchronize a strict RFC-compliant intermediary from the Mint client on shared keep-alive pooled connections. The root cause is Mint.HTTP1.decode_body/5 using Elixir's Integer.parse/2 for chunked transfer-encoding chunk-size parsing, which accepts RFC-forbidden leading + or - sign prefixes, causing both parties to disagree on where one HTTP response ends and the next begins. No public exploit has been identified at time of analysis, but a vendor-released patch is available in Mint 1.9.3.
RemediationAI
Upgrade elixir-mint Mint to version 1.9.3 or later, which replaces the vulnerable Integer.parse/2 chunk-size parser with a custom RFC-strict hex-only parser (Mint.HTTP1.Parse.chunk_size/1) that explicitly rejects signed integers. The patch commit is at https://github.com/elixir-mint/mint/commit/fc7d16538db7e40b56ed489f08683225cb0197fa and the advisory at https://github.com/elixir-mint/mint/security/advisories/GHSA-x3x7-96vm-6h2w. Note: the CHANGELOG in the patch commit marks the fix as 'Unreleased,' so confirm version 1.9.3 availability in the Hex.pm package registry before deploying. If immediate upgrade is not feasible, disabling HTTP/1.1 connection pooling and forcing a new TCP connection per request eliminates the response-queue poisoning risk by removing shared connection state; this carries a significant performance penalty (new TLS handshake per request). An alternative architectural control is removing any strict RFC-compliant intermediary from the Mint client's response path, though this requires careful topology review and may reduce other security properties.
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 affected library is elixir-mint Mint (CPE: cpe:2.3:a:elixir-mint:mint), an HTTP client written in Elixir for the BEAM virtual machine. CWE-444 (Inconsistent Interpretation of HTTP Requests - HTTP Request/Response Smuggling) describes the root cause class: two HTTP-processing entities disagree on message boundaries, enabling injection attacks. Specifically, Mint.HTTP1.decode_body/5 in lib/mint/http1.ex called Integer.parse(data, 16) to parse HTTP/1.1 chunked transfer-encoding chunk-size values in hex. Elixir's Integer.parse/2 implements Elixir integer parsing semantics that tolerate an optional leading + or -, but RFC 7230 defines chunk-size = 1*HEXDIG - strictly unsigned hex digits only. This means +5 is parsed as a five-byte chunk, while +0 and -0 are each accepted as a terminating zero-length chunk, ending the message body prematurely. A strict RFC 7230-compliant intermediary in the response path (proxy, CDN, API gateway) rejects these forms and applies different message boundaries than Mint, enabling the desynchronization. The fix (commit fc7d165) replaces Integer.parse/2 with a new Mint.HTTP1.Parse.chunk_size/1 function that validates each character individually as a valid hex digit (0-9, a-f, A-F), explicitly rejecting any sign prefix.
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 attack vector (AV:N), high complexity (AC:H) for required topology; no privileges or UI needed; scope changed (S:C) as response poisoning corrupts data for other users on the same connection pool; limited C and I impact only.
Primary rating from Vendor (EEF).
CVSS VectorVendor: EEF
DescriptionCVE.org
Inconsistent interpretation of HTTP requests (HTTP response smuggling) vulnerability in elixir-mint mint allows a malicious HTTP/1 server to desynchronize a strict intermediary and the Mint client on the same pooled connection, enabling response-queue poisoning against subsequent requests that share the connection.
The Mint.HTTP1.decode_body/5 function in lib/mint/http1.ex parses the chunk-size line of a Transfer-Encoding: chunked response with Integer.parse(data, 16). RFC 7230 defines chunk-size = 1*HEXDIG and forbids any sign prefix, but Integer.parse/2 accepts an optional leading + or -. A chunk-size line of +5 is accepted as a five-byte chunk; lines of +0 and -0 are accepted as the terminating zero-length chunk and end the message body early.
An RFC-strict intermediary in the response path rejects these forms, so the intermediary and the Mint client disagree on where one response ends and the next begins. On a pooled keep-alive connection, an attacker-influenced origin can inject bytes that the client attributes to the next legitimate response on the same connection, poisoning the response queue and corrupting the responses returned to unrelated in-flight requests.
This issue affects mint: from 0.1.0 before 1.9.3.
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.
Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.
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
Chunked-response smuggling in the Elixir Mint HTTP client (0.1.0 through 1.10.0) allows a malicious or compromised HTTP/
EUVD-2026-44909
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB