Skip to main content

Elixir Mint CVE-2026-82729

| EUVDEUVD-2026-71219 MEDIUM
Inefficient Algorithmic Complexity (CWE-407)
2026-09-04 EEF
6.3
CVSS 4.0 · Vendor: EEF
View

Attack ChainAIDerived

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

  1. Recon
    Attacker operates or compromises HTTP server
  2. Delivery
    Victim application sends HTTP/1.1 request to attacker server
  3. Exploit
    Server returns valid 200 status and headers (bypass intermediary inspection)
  4. Install
    Server streams chunked body with oversized hex chunk-size field byte-by-byte
  5. C2
    Each TCP segment triggers O(N²) re-parse of accumulated buffer
  6. Execute
    CPU exhausted on client host
  7. Impact
    Application 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.

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

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

Alert me

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

Mint 1.9.3 <1.10.0
Mint fc7d16538db7e40b56ed489f08683225cb0197fa <bd2a4e7513594997c140cfef9fe0e968712fb588

Affected Packages

euvd mint fix: 1.10.0

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

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

Network vector but AC:H because attacker must control the server the client connects to; availability impact is Low per bounded CPU exhaustion.

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:L
4.0 AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:L/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
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
Low
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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

EPSS Score
0.5%
Top 60% exploitable
Prevalence
Low
niche Elixir HTTP client library, limited ecosystem footprint
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.5%
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

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

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-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-82672 MEDIUM
6.3 Sep 19

Chunked-response smuggling in the Elixir Mint HTTP client (0.1.0 through 1.10.0) allows a malicious or compromised HTTP/

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