Skip to main content

Elixir Mint CVE-2026-82672

| EUVDEUVD-2026-83608 MEDIUM
HTTP Request/Response Smuggling (CWE-444)
2026-09-19 EEF
6.3
CVSS 4.0 · Vendor: EEF
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Control or influence an HTTP/1 origin server
  2. Delivery
    Send chunked response with malformed chunk-size line (5ZZZZZ / 0ZZZZ)
  3. Exploit
    Mint and strict intermediary disagree on chunk boundaries
  4. Execution
    Desynchronize the shared pooled connection
  5. Impact
    Poison 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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

Mint 0.1.0 <1.10.1
Mint 60089586ec7adc9fddb09f69a2f5919ba9ac7f33 <c82377838dc6e275ef40bafa664fbcdf50270c60

Affected Packages

euvd mint fix: 1.10.1

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

Vendor (EEF) PRIMARY 6.3 MEDIUM
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
vuln.today AI 4.8 MEDIUM

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.

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:N
4.0 AV:N/AC:L/AT:P/PR:N/UI:N/VC:L/VI:L/VA:N/SC:N/SI:N/SA:N

Primary rating from Vendor (EEF).

CVSS VectorVendor: EEF

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
Present
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
Low
Vulnerable system: Integrity
Low
Vulnerable system: Availability
None
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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

EPSS Score
0.3%
Top 77% exploitable
Prevalence
Medium
Widely-used low-level HTTP client underpinning Finch/Req/Tesla in the Elixir ecosystem
Data Quality
6 sources
Confidence: High

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.

SignalValue
Severity MEDIUM
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

32
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +32
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

HTTP request smuggling exploits inconsistencies in how front-end and back-end servers parse HTTP message boundaries.

More in Mint

View all
CVE-2026-49754 HIGH POC
8.2 Jun 02

Memory exhaustion in the Elixir Mint HTTP/2 client (versions 0.1.0 through 1.8.x) allows a malicious or compromised HTTP

CVE-2026-48862 HIGH POC
8.2 Jun 02

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

CVE-2026-49753 MEDIUM POC
6.3 Jun 02

HTTP response smuggling in the Elixir Mint HTTP client library (versions 0.1.0 through before 1.9.0) allows attacker-con

CVE-2026-56810 HIGH
8.7 Jul 06

Uncontrolled memory allocation in the Elixir Mint HTTP client (Mint.HTTP1 module, versions 0.5.0 through 1.9.0) lets a m

CVE-2026-82728 HIGH
8.2 Sep 04

Unbounded memory accumulation in the elixir-mint Mint HTTP client library (versions 0.1.0 through <1.10.0) enables a rem

CVE-2026-58229 HIGH
8.2 Jul 14

Unbounded memory consumption in the Elixir Mint HTTP client (versions 0.1.0 through 1.9.1) lets a malicious or attacker-

CVE-2026-91043 HIGH
8.2 Sep 28

Memory exhaustion denial-of-service in Elixir Mint affects versions 1.1.0 through 1.10.x and allows a malicious or compr

CVE-2026-82729 MEDIUM
6.3 Sep 04

CPU exhaustion via crafted chunked HTTP responses affects the Elixir Mint HTTP client library (versions 1.9.3 through be

CVE-2026-59246 MEDIUM
6.3 Jul 14

Memory exhaustion in elixir-mint's HTTP/2 client library (mint) allows a malicious or attacker-controlled HTTP/2 server

CVE-2026-94194 MEDIUM
6.3 Sep 28

HTTP/1 response smuggling in the Elixir Mint client (0.1.0 through 1.10.x) allows a malicious or attacker-influenced ori

CVE-2026-92103 MEDIUM
6.3 Sep 28

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

CVE-2026-59249 MEDIUM
6.3 Jul 16

Response-queue poisoning in the elixir-mint Mint HTTP/1.1 client library (versions 0.1.0 through before 1.9.3) allows a

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy