Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessControl or compromise upstream HTTP/1 server
-
DeliveryServe response with Content-Length: +0 (RFC-invalid sign prefix)
-
ExploitStrict proxy reframes body boundary at zero bytes; Mint parses +0 as valid zero
-
ExecutionParser disagreement desynchronizes response framing on shared connection
-
PersistSubsequent response bytes attributed to different pooled requester
-
ImpactLeak cross-requester HTTP response data
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 three concurrent conditions to be satisfied simultaneously. First, the Mint client must be operating in a connection-reuse mode - HTTP/1 keep-alive, pipelining, or a pooled connection shared across multiple requesters or application trust boundaries; single-request connections are not exploitable via this primitive. Second, an RFC-strict fronting proxy or load balancer must be present in the request path that enforces Content-Length grammar per RFC 7230 and interprets or reframes sign-prefixed values differently from Mint. Third, the attacker must control or have compromised an upstream HTTP/1 server capable of emitting responses with sign-prefixed Content-Length headers. Exploitation is further limited by PR:N meaning authentication at the Mint client layer is not required, but the attacker must influence the upstream server - not merely the network path. Standard deployments without connection pooling, direct Mint-to-server connections without an interposing proxy, or deployments behind proxies that normalize or strip malformed headers are not vulnerable to response desynchronization. |
| Impact | The CVSS 4.0 base score of 6.3 is derived from a vector of AV:N/AC:L/AT:P/PR:N/UI:N with impact values of VC:N/VI:L/VA:N/SC:L/SI:L/SA:N. The Attack Requirements of Partial (AT:P) is the critical risk-limiting factor: exploitation is not achievable against arbitrary Mint deployments but specifically requires a shared-connection topology (keep-alive, pipelining, or pooled connections across requesters) plus an interposing proxy with strict RFC enforcement and attacker control over an upstream server. The PR:N and UI:N values confirm no authentication or user interaction is required once the topology conditions are met, which is concerning for multi-tenant or SaaS architectures. Impact is bounded: no direct confidentiality loss on the vulnerable system (VC:N), only low integrity impact (VI:L), with low cross-system confidentiality and integrity impact (SC:L/SI:L), reflecting the response-stream leakage rather than arbitrary code execution. This vulnerability is not in CISA KEV and no public exploit code was identified in the provided data; EPSS was not provided. Real-world risk is low-to-moderate for typical single-tenant or direct-connection deployments, but material for multi-tenant applications, API gateways, or reverse-proxy architectures sharing Mint connection pools across users or services. |
| Exploit ScenarioDerived | An attacker who controls or has compromised an upstream HTTP/1 server behind a strict RFC-compliant proxy crafts responses containing a Content-Length header with a sign-prefixed value such as 'Content-Length: +0'. The interposing proxy, enforcing RFC 7230 strictly, interprets this as an invalid or zero-length body and reframes the boundary accordingly, while Mint's parser silently accepts '+0' as a valid zero length and advances its read cursor differently. In a connection pool shared across multiple application users or tenants, the resulting byte misalignment causes data from a subsequent response to be attributed to a different requester's stream, leaking potentially sensitive response content across trust boundaries. No public POC has been identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jun 02, 2026
HTTP response smuggling in the Elixir Mint HTTP client library (versions 0.1.0 through before 1.9.0) allows attacker-controlled upstream servers to desynchronize response framing on shared connections by exploiting a non-RFC-compliant Content-Length parser. Mint's parser accepts sign-prefixed integers such as '+0' or '+123' that RFC 7230 forbids, creating a disagreement with RFC-strict fronting proxies about where one HTTP response body ends and the next begins. When Mint reuses connections via keep-alive, pipelining, or pooling across trust boundaries, this parser mismatch can be weaponized to leak bytes from one requester's response into another's stream. No public exploit code has been identified at time of analysis, and no KEV listing exists; a vendor patch (v1.9.0) is available.
RemediationAI
Upgrade to Mint 1.9.0 or later, which incorporates the fix in commit 47e48027480228e4e32a0b4df39db497b4804921 and strictly enforces RFC 7230 Content-Length grammar by replacing Integer.parse/1 with a digit-only validator. The patch and advisory are available at https://github.com/elixir-mint/mint/commit/47e48027480228e4e32a0b4df39db497b4804921 and https://github.com/elixir-mint/mint/security/advisories/GHSA-mjqx-c6f6-7rc2. If an immediate upgrade is not feasible and your application shares Mint connection pools across trust boundaries, disable HTTP keep-alive and connection pooling to force per-request connections, eliminating the desynchronization primitive; note this increases latency and connection overhead. As an additional layer, configure your fronting proxy or load balancer to strictly validate and reject malformed Content-Length headers before forwarding - this hardens the proxy layer but does not fix the non-conformance in Mint itself and should not substitute for patching. Both workarounds have operational trade-offs and are not substitutes for upgrading.
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 vulnerability exists in Mint.HTTP1.Parse.content_length_header/1 located at lib/mint/http1/parse.ex within the elixir-mint/mint Elixir HTTP client library (CPE: cpe:2.3:a:elixir-mint:mint:*:*:*:*:*:*:*:*). The root cause, classified as CWE-444 (Inconsistent Interpretation of HTTP Requests), stems from Mint's use of Elixir's built-in Integer.parse/1 function to decode Content-Length header values. Integer.parse/1 accepts an optional leading '+' or '-' sign as valid integer notation per Elixir language semantics, but RFC 7230 strictly defines Content-Length as '1*DIGIT' - ASCII digits only, no sign characters permitted. A negative guard (length >= 0) blocked negative values but left '+'-prefixed inputs (e.g., '+0', '+123') silently accepted as valid lengths. Because Content-Length is the framing delimiter for HTTP/1 response bodies, any proxy or load balancer that enforces strict RFC grammar will parse the boundary differently from Mint, yielding a classical HTTP desynchronization condition. The fix (commit 47e48027480228e4e32a0b4df39db497b4804921) introduces a bespoke only_digits?/1 guard that explicitly rejects any non-digit character including '+', '0x' prefixes, embedded spaces, and leading whitespace, achieving strict RFC 7230 compliance.
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:L/VA:N/SC:L/SI:L/SA:N
Primary rating from Vendor (EEF) · only source for this CVE.
CVSS VectorVendor: EEF
Lifecycle Timeline
2DescriptionCVE.org
Inconsistent Interpretation of HTTP Requests ('HTTP Request/Response Smuggling') vulnerability in elixir-mint Mint allows attacker-controlled HTTP/1 servers to desynchronise response framing on shared connections.
Mint's HTTP/1 Content-Length parser, Mint.HTTP1.Parse.content_length_header/1 in lib/mint/http1/parse.ex, parses the header value with Integer.parse/1, which accepts an optional + or - sign prefix. The length >= 0 guard rejects negatives, but inputs such as +0 or +123 are returned as valid lengths. RFC 7230 specifies Content-Length = 1*DIGIT, with no sign character permitted.
A fronting proxy or load balancer that strictly enforces the grammar will reject or reframe a header like Content-Length: +0, while Mint silently treats it as zero. When Mint reuses the socket (keep-alive, pipelining, or any pooled connection shared across requesters), the parser disagreement is a response-smuggling primitive: the proxy delimits the body one way, Mint another, and bytes from one response get attributed to the next. Where the same Mint connection is shared across trust boundaries, an attacker-controlled upstream can leak bytes into a different consumer's response stream.
This issue affects mint: from 0.1.0 before 1.9.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
HTTP request smuggling exploits inconsistencies in how front-end and back-end servers parse HTTP message boundaries.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
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
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/
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-33941
GHSA-mjqx-c6f6-7rc2
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB