Skip to main content

bandit EUVDEUVD-2026-63661

| CVE-2026-75484 MEDIUM
Improper Neutralization of CRLF Sequences ('CRLF Injection') (CWE-93)
2026-08-20 6b3ad84c-e1a6-4bf7-a703-f496b71e49db GHSA-23xx-x3px-xxpj
6.9
CVSS 4.0 · Vendor: 6b3ad84c-e1a6-4bf7-a703-f496b71e49db
View

Attack ChainAIDerived

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

  1. Access
    Send HTTP/2 HEADERS frame with \r/\n/\0 in field values
  2. Delivery
    HPACK decodes frame without validation error
  3. Exploit
    Injected control chars land in conn.req_headers unchanged
  4. Execution
    Application code consumes raw header value verbatim
  5. Impact
    Log injection or HTTP/1.1 request smuggling achieved downstream

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization CRLF sequence sanitization
Exploitation Conditions

The vulnerability requires the target server to be running bandit version 1.4.0 through 1.12.4 with HTTP/2 enabled (the HTTP/1 code path already rejected the same characters). No authentication is required and no non-default configuration is needed for the injection itself to succeed - any HTTP/2 client can send a HEADERS frame with \r, \n, or \0 in a field value. However, the prerequisite for actual harm is that the downstream application code consumes raw header values in a way that is sensitive to these control characters: specifically, appending header values verbatim to plain-text logs (enabling log injection) or concatenating them into outbound HTTP/1.1 upstream request headers (enabling request smuggling). Applications that do not perform these operations are not materially harmed by the injection. The duplicate :authority condition additionally requires an attacker to send two :authority pseudo-headers in the same HEADERS frame, which is trivially constructable by any HTTP/2 client but requires the application to act on the second (non-winning) :authority value to cause harm.

Impact

The supplied CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:L/VA:N) scores 6.9 and accurately reflects the attack surface: fully network-reachable, no authentication or complexity barrier, but with impact limited to low integrity on the vulnerable system. EPSS data was not provided; absent KEV listing and with no publicly referenced POC, opportunistic mass exploitation is unlikely at time of analysis. The RCE tag attached to this CVE in the source data is not supported by the description - bandit itself is explicitly not a sink for the injected bytes, and the description rules out response splitting through bandit's own response-header path. The realistic risk lives entirely in how downstream application code consumes raw header values: a Phoenix application that appends an X- header verbatim to a structured log line or forwards it into an HTTP/1.1 upstream request is genuinely vulnerable to log injection or request smuggling respectively, but the severity of that outcome is application-dependent. Operators running bandit-backed services that proxy, log, or relay header values verbatim should treat this as a concrete integrity risk; those whose applications do not touch raw header values in those ways face negligible real-world exposure. The CVSS integrity impact of 'Low' (VI:L) and the absence of any confidentiality or availability metrics are consistent with the description. No conflict between CVSS signals and description is present, though the absence of EPSS data limits quantitative exploitation-probability assessment.

Exploit ScenarioDerived

An attacker sends an HTTP/2 HEADERS frame to a bandit server where one field value - for example, x-forwarded-for - contains an embedded LF followed by a fabricated header line such as x-injected: malicious. Because bandit does not validate field values in its HTTP/2 path, HPACK decodes the frame without error and the raw value (including the embedded LF) is placed into conn.req_headers. A downstream Phoenix controller that logs this header verbatim, or a reverse-proxy plug that forwards it in an HTTP/1.1 upstream request, receives the injected control characters and interprets the LF as a header delimiter, enabling log injection or request smuggling. No POC has been publicly identified at time of analysis.

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 – Aug 20, 2026

CRLF injection in the bandit Elixir HTTP server (versions 1.4.0 through 1.12.4) allows unauthenticated remote attackers to smuggle carriage-return, line-feed, or NUL characters into application-visible HTTP/2 request headers. Because HPACK carries arbitrary octets and bandit's HTTP/2 stream handler never validated field values for these control characters - unlike the HTTP/1 path which rejected them - a crafted HEADERS frame decodes cleanly and the malicious values reach downstream application logic unchanged. No public exploit or CISA KEV listing is identified; real-world impact is context-dependent and limited to how consuming application code handles raw header values (e.g., log injection, upstream request smuggling).

RemediationAI

Upgrade bandit to version 1.12.5 or later, which contains the fix introduced in commit d38cf046c9a3cae4d0f88001c2ceb4143f86366b. The fix applies uniform field-value validation (rejecting \r, \n, and \0) to both HTTP/1 and HTTP/2 paths and enforces at-most-one :authority pseudo-header. Details are in the GitHub security advisory at https://github.com/mtrudel/bandit/security/advisories/GHSA-x3gh-xhj4-3vq8. If immediate upgrade is not possible, a targeted compensating control is to sanitize incoming HTTP header values in application-layer plugs before they are appended to logs or forwarded to upstream services - specifically, stripping or rejecting values containing \r, \n, or \0. This does not eliminate the underlying protocol-layer gap but breaks the exploitation chain for the most common downstream sinks. Note that this workaround adds application-layer overhead and may not cover all downstream consumers if headers are passed through third-party plugs or libraries without sanitization.

Affected VersionsENISA

bandit fff06efe3be962b484bd4d3eb339372fda5a231f <d38cf046c9a3cae4d0f88001c2ceb4143f86366b
bandit 1.4.0 <1.12.5

Affected Packages

euvd bandit fix: 1.12.5

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

Bandit is an Elixir-native HTTP server library (replacing Cowboy in the Phoenix ecosystem) implementing both HTTP/1 and HTTP/2. The HTTP/2 transport uses HPACK header compression (RFC 7541), which operates on raw binary octets with no restriction on field-value content - it is the server's responsibility to enforce RFC 9113 §8.2.1, which forbids CR (\r), LF (\n), and NUL (\0) in field values. CWE-93 (Improper Neutralization of CRLF Sequences) describes exactly this class: a validation gap where control characters that would be meaningful to a log system, proxy, or upstream HTTP/1.1 connection are not stripped or rejected. The affected module is Bandit.HTTP2.Stream.read_headers/1, which validated pseudo-header placement, uniqueness (partially - :authority was under-checked), casing, connection-specific headers, the te value, and content-length, but contained no call to check field values. A second, bundled defect allowed duplicate :authority pseudo-headers: only :method, :scheme, and :path were enforced to appear at most once; a duplicate :authority was silently accepted with the first value winning as conn.host while the second remained visible to the application, enabling host-header confusion attacks. The fix, in commit d38cf046, refactored the field-value check into a shared Bandit.Headers.field_value_valid?/1 function (backed by a lazily compiled :binary.compile_pattern cached in :persistent_term) and applied it uniformly to both HTTP/1 and HTTP/2 paths, and added at_most_one_instance_of!/3 for :authority.

Know when the next one hits your stack

  • 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 (6b3ad84c-e1a6-4bf7-a703-f496b71e49db) PRIMARY 6.9 MEDIUM
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:L/VA:N/SC:N/SI:N/SA:N
vuln.today AI 5.8 MEDIUM

Network-reachable, unauthenticated, no complexity barrier; scope changed because impact falls on downstream application logic consuming smuggled header values, not bandit itself.

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

Primary rating from Vendor (6b3ad84c-e1a6-4bf7-a703-f496b71e49db).

CVSS VectorVendor: 6b3ad84c-e1a6-4bf7-a703-f496b71e49db

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

Lifecycle Timeline

1
Patch available
Aug 20, 2026 - 22:04 EUVD

DescriptionCVE.org

Improper Neutralization of CRLF Sequences ('CRLF Injection') vulnerability in mtrudel bandit allows an unauthenticated remote attacker to smuggle CR, LF, or NUL characters into application-visible request headers via HTTP/2. Bandit.HTTP2.Stream.read_headers/1 validates pseudo-header placement and uniqueness, header-name casing, connection-specific headers, the te value, and content-length, but never checks field values. Because HPACK carries arbitrary octets, a HEADERS block whose field values contain \r, \n, or \0 decodes without error and the values land in conn.req_headers unchanged. The HTTP/1 path already rejects the same octets; HTTP/2 did not.

Bandit itself is not a sink for the injected bytes: its own logging uses fixed strings or inspect, and HTTP/2 response headers are HPACK-encoded and separately rejected by Plug's put_resp_header, so response splitting is not reachable through this path. The risk is entirely in how a downstream application consumes header values, such as appending one verbatim to a plain-text log or concatenating it into an upstream request. A related gap bundled in the same fix: only :method, :scheme, and :path were checked for at most one occurrence; a duplicate :authority pseudo-header was accepted, with the first instance silently winning as conn.host while a conflicting value remained visible to the application.

This issue affects bandit: from 1.4.0 before 1.12.5.

Threat Intelligence Overview

EPSS Score
0.5%
Top 56% exploitable
Prevalence
Low
Elixir/Phoenix-specific HTTP server, niche 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
Yes
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

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

Attack Technique

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

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