Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLure client to connect to malicious HTTP/2 server
-
DeliveryServer declares near-max (16 MiB) frame length
-
ExploitWithhold final payload byte
-
ExecutionClient buffers all bytes as :more
-
PersistRepeat across many connections
-
ImpactClient memory exhaustion
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource allocation limits
MITRE ATT&CK
1 technique across 1 tactic: Impact The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires an Elixir application to use mint (0.1.0-1.10.x) as an HTTP/2 client and to establish a connection to an attacker-controlled or MITM-intercepted HTTP/2 server; no authentication or user interaction with the app itself is needed, but the attacker must control the server side of the connection (reflected as AT:P). Exploitation is strongly LIMITED: impact is memory-only with no amplification (the server must send every buffered byte), each connection is capped at ~16 MiB by the 24-bit frame-length field, and the malicious frames must be crafted to withhold the final byte to keep decode_next/2 returning :more; sustained denial of service therefore requires many concurrently held connections and matching attacker resources. |
| Impact | This is a genuine but low-severity availability issue, not a high-priority emergency. The CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:L, 6.3 Medium) correctly captures a network-reachable, unauthenticated, availability-only impact, with AT:P reflecting the key requirement that the victim client must connect to (or be MITM'd onto) an attacker-controlled HTTP/2 server. The impact is explicitly bounded: the description confirms there is NO amplification - the malicious server must transmit every byte the client buffers, and the buffer is capped by the 24-bit frame-length field at roughly 16 MiB per connection. Exploitation status: no public exploit identified at time of analysis (no POC referenced, no KEV listing, no EPSS provided). Because impact is memory pressure only (no confidentiality/integrity, no crash guaranteed) and is per-connection with no amplification, real-world risk is modest - meaningful DoS requires the attacker to open and hold many connections, spending equal server-side memory/bandwidth. Priority is LOW: patch is available (fixed in 1.11.0), but this is a hardening fix rather than an actively-exploited flaw. No signals conflict; the description and CVSS vector are mutually consistent. |
| Exploit ScenarioDerived | An Elixir application uses mint as its HTTP/2 client to reach an external endpoint that an attacker controls or can intercept (e.g., a webhook target, upstream API, or MITM position). The malicious server sends HTTP/2 frames each declaring a length near the 16,777,215-byte maximum but withholds the final byte, so decode_next/2 returns :more and Mint.HTTP2 retains all received bytes in the connection buffer (~16 MiB per connection). By holding many such connections open, the attacker drives the client's memory consumption up. No public exploit code was identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 28, 2026
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 HTTP/2 server pin roughly 16 MiB of client buffer memory per open connection by declaring an oversized frame and withholding its final byte. The weakness is an unbounded resource allocation issue (CWE-770) in Mint.HTTP2.Frame.decode_next/2, which only checks a frame against the client's 16,384-byte max_frame_size after the entire declared payload has arrived, causing the connection buffer to keep accumulating bytes up to the 24-bit frame-length ceiling of 16,777,215 bytes. Impact is availability-only and low severity per the independent assessment: there is no amplification because the attacker must transmit every byte the client buffers, sustained denial of service requires many concurrently held connections plus matching attacker resources, and no public exploit identified at time of analysis, with no CISA KEV listing and no EPSS signal supplied. Attacker control of the server side is required (unauthenticated from the client's perspective, reflected as AT:P), and vendor patches are available in mint 1.11.0.
RemediationAI
Vendor-released patch: upgrade mint to 1.11.0, the first version containing the fix for the affected 0.1.0-1.10.x range. The fix is also visible upstream in the patch commit https://github.com/elixir-mint/mint/commit/20252ca85065f4d1092aed9ee4ed21841a507dfe (remediation work alongside https://github.com/elixir-mint/mint/commit/596ca4304504be68939c4929e0831557097962b8); consult GHSA-q95c-ccq6-j5j6 for the vendor's guidance, and refresh Elixir dependency lockfiles so transitive consumers of mint pick up 1.11.0. Because exploitation requires the attacker to control the server side of the HTTP/2 connection, practical compensating controls center on that trust boundary: restrict outbound HTTP/2 traffic from Mint-based services to vetted, allow-listed endpoints and avoid fetching user-supplied URLs from processes that also hold sensitive state (trade-off: reduced functionality for proxy/fetch workloads), and terminate outbound HTTP/2 through a managed forward proxy that enforces its own frame and buffer limits (trade-off: added infrastructure latency and a new component to secure). Where those are not feasible, cap the blast radius per connection by running Mint-based clients in BEAM processes with bounded heap/memory limits and aggressive idle timeouts, and by limiting the number of concurrent outbound HTTP/2 connections a node may hold, accepting that a single connection can still absorb about 16 MiB. Note that the 24-bit frame-length ceiling and the absence of amplification mean these measures only reduce the number of connections an attacker must hold open; they do not eliminate the per-connection buffering behavior in unpatched versions, so upgrading to 1.11.0 remains the definitive fix.
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
Mint is an Elixir HTTP/1.x and HTTP/2 client library, and the affected code path is its HTTP/2 framing layer: Mint.HTTP2.Frame.decode_next/2 in lib/mint/http2/frame.ex, backed by the connection state machine that holds a buffer in Mint.HTTP2 (originally the XHTTP2.Conn struct, visible in the upstream commit history). HTTP/2 frame headers encode a 24-bit length field, so a single frame can declare up to 16,777,215 bytes of payload, while Mint advertises and enforces a default SETTINGS_MAX_FRAME_SIZE of 16,384 bytes (@default_max_frame_size in the connection struct, with a valid range of 16,384..16,777,215). The defect is that the max_frame_size comparison is performed only once the full declared payload has been received; until then decode_next/2 returns :more and every received byte is retained in the connection buffer. A hostile server can therefore declare a maximum-length frame and hold back the last byte indefinitely, keeping roughly 1,024 times the advertised frame limit resident per connection. This is a classic CWE-770 (Allocation of Resources Without Limits or Throttling) pattern with no amplification factor, since the server must send all buffered bytes, and the exposure is bounded by the 24-bit frame length field. The CPE records (cpe:2.3:a:elixir-mint:mint:*:*:*:*:*:*:*:*) confirm that all released versions of the elixir-mint mint package are treated as the affected product rather than a specific build.
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:N/VA:L/SC:N/SI:N/SA:N
Network-reachable client flaw triggered by a malicious server with no auth/UI; impact is bounded per-connection memory pressure only, so A:L and C:N/I:N.
Primary rating from Vendor (EEF).
CVSS VectorVendor: EEF
DescriptionCVE.org
Allocation of Resources Without Limits or Throttling vulnerability in elixir-mint mint allows a malicious HTTP/2 server to make the client hold up to about 16 MiB per connection in frames it should reject, consuming client memory.
Mint.HTTP2.Frame.decode_next/2 in lib/mint/http2/frame.ex compares a frame with the client's max_frame_size (16,384 bytes by default) only once the whole declared payload has arrived. Until then it returns :more, and Mint.HTTP2 keeps every received byte in the connection buffer. A server can declare a frame length of up to 16,777,215 bytes and withhold the last byte, keeping roughly 1,024 times the advertised limit buffered for as long as the connection stays open. The server has to send every byte the client buffers, so there is no amplification, and the buffer stops at the 24-bit frame length limit.
This issue affects mint: from 0.1.0 before 1.11.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
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
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
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-88219
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB