Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAttacker supplies CRLF-embedded HTTP method string
-
DeliveryApplication forwards value unsanitized to Mint.HTTP.request/5
-
Exploitencode_request_line/2 splices method into wire-format request line without validation
-
ExecutionCRLF terminates request line early, injecting arbitrary headers
-
PersistSmuggled HTTP request appended to TCP connection
-
ImpactBackend server processes unauthorized injected request
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization CRLF sequence sanitization
|
| Exploitation Conditions | Exploitation requires that the target application passes attacker-controlled input directly as the method argument to Mint.HTTP.request/5 without prior sanitization - for example, an HTTP proxy, API gateway, or forwarding service that accepts an arbitrary HTTP method from an external caller and relays it downstream via Mint. The method-based injection vector is present under the default Mint configuration on all versions 0.1.0 through 1.8.x. The target/path injection vector additionally requires the application to opt out of target validation by setting skip_target_validation: true (non-default since Mint 1.7.0); absent that opt-out, the path vector is already mitigated. Exploitation is limited by the AV:L CVSS vector, meaning the attacker must have application-level input influence rather than direct network access to Mint itself, and AT:P confirms that the specific forwarding/proxy deployment pattern must be present. Applications that use a fixed, hardcoded HTTP method (the common case) are not exposed. |
| Impact | The CVSS 4.0 base score of 2.1 reflects a genuinely low-severity finding for the majority of Mint deployments. The vector AV:L (Local) indicates that the attacker cannot exploit this remotely against the library itself - they must be in a position to inject input into an application that passes those values unsanitized to Mint.HTTP.request/5, which is an application-design precondition rather than a network-reachable surface. AT:P (Attack Requirements: Present) confirms specific deployment conditions must exist: the application must act as a proxy or pass user-controlled HTTP method values without prior sanitization. Impact is limited to low integrity effects on both the vulnerable and subsequent systems (VI:L, SI:L) with no confidentiality or availability impact, consistent with the nature of request smuggling (injecting unauthorized requests rather than exfiltrating data or crashing services). No EPSS score was provided in the intelligence data; the vulnerability is not in the CISA KEV catalog, and no public exploit has been identified. IMPORTANT DISCREPANCY: The intelligence metadata includes a 'Tags: RCE' label that is directly contradicted by the CVE description (CRLF injection / request smuggling), the CWE assignment (CWE-93), and the CVSS impact subscores (no code execution indicators); this tag should be treated as erroneous and not relied upon for triage decisions. |
| Exploit ScenarioDerived | An attacker using an application that proxies or relays user-supplied HTTP method values through Mint could supply a crafted method string such as 'GET / HTTP/1.1\r\nX-Injected: evil\r\nGET /admin' - exactly the pattern tested in the patch's new test suite. Mint's encode_request_line/2 in versions before 1.9.0 would splice this directly into the wire-format request line, causing the upstream server to parse the injected content as a second pipelined request on the shared TCP connection. No public proof-of-concept code has been identified; the attack complexity is low once a vulnerable application surface is identified. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jun 02, 2026
CRLF injection in the elixir-mint Mint HTTP/1.1 client library (versions 0.1.0 through 1.8.x) enables HTTP Request Splitting and HTTP Request Smuggling on shared TCP connections when applications forward attacker-controlled values as the HTTP method or target to Mint.HTTP.request/5. The target-based vector was partially closed in Mint 1.7.0 via validate_request_target/2, but the method field was left unvalidated in all versions prior to 1.9.0, meaning method-based injection remains exploitable under the default Mint configuration. No public exploit has been identified and the vulnerability is not listed in the CISA KEV catalog; the complete fix shipping method-character validation is available in Mint 1.9.0.
RemediationAI
The primary remediation is to upgrade Mint to version 1.9.0, which introduces validate_method! in lib/mint/http1/request.ex to enforce HTTP token (tchar) character constraints on the method field, returning {:error, {:invalid_request_method, method}} on invalid input. The patch commit is fad091454cbb7449b19edb8e1fee12ca7cf28c3a (https://github.com/elixir-mint/mint/commit/fad091454cbb7449b19edb8e1fee12ca7cf28c3a). For applications unable to upgrade immediately, the actionable compensating control is to sanitize or allowlist the HTTP method value in application code before passing it to Mint.HTTP.request/5 - for example, rejecting any method value that is not a member of a known-good set (GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS). Additionally, ensure skip_target_validation: true is not set in any Mint connection options, as that opt-out re-enables the target-based injection vector that was closed in 1.7.0. Refer to the vendor advisory at https://github.com/elixir-mint/mint/security/advisories/GHSA-2pg6-44cx-c49v for full details.
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 HTTP/1.1 and HTTP/2 client library for Elixir (CPE: cpe:2.3:a:elixir-mint:mint:*:*:*:*:*:*:*:*). The root cause is CWE-93 (Improper Neutralization of CRLF Sequences), located in lib/mint/http1/request.ex within the encode_request_line/2 function, which constructs the HTTP/1 request line by directly interpolating the caller-supplied method and target values - [method, ?\s, target, " HTTP/1.1\r\n"] - without character validation. Because CRLF sequences (\r\n) are the delimiter for HTTP/1.1 message framing, an unescaped \r\n in either field allows an attacker to terminate the request line prematurely, inject arbitrary headers, and append a fully-formed secondary HTTP request to the same TCP connection (request smuggling). Mint 1.7.0 introduced validate_request_target/2 to reject control characters in the target field by default; the patch at commit fad091454cbb7449b19edb8e1fee12ca7cf28c3a adds an analogous validate_method! function that iterates over each byte and rejects any character failing the HTTP token (tchar) definition, closing the method vector.
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:L/AC:L/AT:P/PR:N/UI:N/VC:N/VI:L/VA:N/SC:N/SI:L/SA:N
Primary rating from Vendor (EEF) · only source for this CVE.
CVSS VectorVendor: EEF
Lifecycle Timeline
2DescriptionCVE.org
Improper Neutralization of CRLF Sequences ('CRLF Injection') vulnerability in elixir-mint Mint allows HTTP Request Splitting and HTTP Request Smuggling.
In lib/mint/http1/request.ex, the encode_request_line/2 function splices the caller-supplied method and target arguments directly into the HTTP/1 request line without any character validation: [method, ?\s, target, " HTTP/1.1\r\n"]. An application that forwards attacker-controlled input as the HTTP method or target to Mint.HTTP.request/5 is therefore exposed to request-line CRLF injection: the attacker can terminate the request line early, inject arbitrary headers, and smuggle an entirely separate pipelined HTTP request onto the same TCP connection.
Mint 1.7.0 introduced validate_request_target/2, which rejects CRLF and other control characters in the target by default and closes the path/query vector unless the caller opts out via skip_target_validation: true. The method field remains unvalidated, so the method-based injection is exploitable under the default Mint configuration on all versions.
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
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
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-33938
GHSA-2pg6-44cx-c49v
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB