Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessOpen HTTP/2 connection to server
-
DeliveryRequest large response and shrink send window
-
ExploitDrip small WINDOW_UPDATE frames before each deadline
-
ExecutionPin stream process and held resources alive
-
ImpactRepeat across streams and connections to exhaust processes/memory
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource consumption 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 only that the server accept HTTP/2 connections, which is a default protocol for Bandit; no authentication, user interaction, or non-default server configuration is needed (CVSS PR:N/UI:N/AC:L). The attacker-controlled prerequisites are self-establishing: the peer widens the connection-level window with a large WINDOW_UPDATE on stream 0 and shrinks the per-stream window via a small SETTINGS_INITIAL_WINDOW_SIZE to independently reach the stream-level block, then sustains the attack by sending periodic small WINDOW_UPDATE frames before each 15-second deadline expires. Limiting factors are minimal: it affects only bandit versions from 1.4.0 onward, and the server must be serving a response large enough to outrun the send window; because the two attack paths are independent, closing only the connection-level path does not remove exploitability. |
| Impact | Signals align consistently toward a genuine, easily-triggered availability risk rather than a CVSS-inflated non-issue. The vendor CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H) describes a network-reachable, low-complexity, unauthenticated flaw with no confidentiality or integrity impact and high availability impact, which matches the description precisely: a remote peer can pin HTTP/2 stream processes indefinitely with a trickle of WINDOW_UPDATE frames. No EPSS score, KEV listing, or public POC is provided in the input, so there is no public exploit identified at time of analysis and exploitation probability cannot be quantified from the data. The absence of KEV/EPSS does not contradict the CVSS reading - it simply means real-world weaponization is unconfirmed, consistent with a recently disclosed issue that already has a vendor patch. Practical priority is driven by how trivially the condition is reached (dripping a few bytes of window every few seconds, repeated across streams and connections) combined with the fact the two attack paths are independent, so partial mitigation that only closes the connection-level path leaves the stream-level path exploitable. The impact ceiling is availability only - no code execution or data exposure is described. |
| Exploit ScenarioDerived | An unauthenticated remote attacker opens HTTP/2 connections to a Bandit-backed server and requests responses large enough to exhaust the send window, then grants only a few bytes of flow-control window every few seconds via small WINDOW_UPDATE (or SETTINGS) frames, resetting the 15-second deadline on each partial advance. Each blocked stream keeps its process, Plug state, and any held resources alive indefinitely, and repeating this across many streams and connections exhausts server processes and memory. No public exploit is identified in the provided data, but the technique requires only a standard HTTP/2 client and no authentication (PR:N). |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 14, 2026
Uncontrolled HTTP/2 flow-control resource consumption in mtrudel/bandit 1.4.0 and later lets an unauthenticated remote peer hold server-side stream processes - together with their Plug conn state and any resource held mid-response - alive indefinitely by dripping small WINDOW_UPDATE frames just before each 15-second send deadline expires. Because both the connection-level (finish_data/5 re-queues the pending send with a fresh expires_at) and stream-level (send_data/3 recurses and re-arms read_timeout) deadline resets fire on partial progress, and the two paths are independent, an attacker can repeat the trickle across many streams and connections to exhaust processes and memory in a denial of service reachable with no authentication and no user interaction (CVSS 4.0 base 8.7; assessed CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H). No public exploit code or confirmed active exploitation was identified at time of analysis; an upstream fix commit is available and the issue is limited to bandit 1.4.0 and later.
RemediationAI
Apply the upstream fix, which is delivered by commit d88b21953c65061f21136ea76a89a4f95a2ac7a1 referenced from GHSA-69m6-wcv4-rwcf (https://github.com/mtrudel/bandit/security/advisories/GHSA-69m6-wcv4-rwcf); no exact patched release version is stated in the available data, so pin to the release that contains this commit rather than assuming a version number. Until you can upgrade, the most direct compensating control is to stop exposing the vulnerable transport: disable HTTP/2 in the Bandit options (the http_2 configuration key exposes an enabled flag) so traffic is served over HTTP/1.1, accepting the loss of multiplexing and the HTTP/2 performance benefit; this also affects clients that require h2. Reduce the blast radius of each connection by lowering max_requests and tightening default_local_settings (for example MAX_CONCURRENT_STREAMS) so an attacker cannot park as many stream processes per connection, with the trade-off of reduced legitimate concurrency. Front the server with a reverse proxy or load balancer that enforces per-connection idle and absolute timeouts, caps concurrent connections per source IP, and buffers responses, noting that buffering can break long-lived streaming or server-sent-event responses. Finally, monitor for the attack signature - large numbers of long-lived connections whose streams advance by only a few bytes at a time on a roughly sub-15-second cadence - and terminate those connections at the proxy.
Affected VersionsENISA
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The flaw is a CWE-400 uncontrolled resource consumption defect in Bandit's HTTP/2 implementation (RFC 9113), which since the 1.4.0 HTTP/2 refactor models each connection as a Bandit.HTTP2.Connection struct/process and each request as a Bandit.HTTP2.StreamProcess owning a Bandit.HTTP2.Stream struct and the Plug connection state. HTTP/2 applies send-side flow control through two independent windows: the connection window (signalled by WINDOW_UPDATE on stream 0) and the per-stream window (initialised by the peer's SETTINGS_INITIAL_WINDOW_SIZE). When a response body outruns the available window, Bandit blocks the send and attaches a 15-second deadline as a safety bound. The defect is that partial progress re-arms that bound: Bandit.HTTP2.Connection.finish_data/5 puts a partially advanced send back into pending_sends with a new expires_at, so any stream-0 WINDOW_UPDATE or SETTINGS frame restarts the connection-level clock, while Bandit.HTTP2.Stream.send_data/3 recurses on each stream WINDOW_UPDATE and installs a fresh read_timeout. A peer that widens the connection window while shrinking the per-stream window via a small SETTINGS_INITIAL_WINDOW_SIZE forces responses to block on the stream window, and since the stream-level block is reachable independently of the connection-level one, patching only the connection path would leave the attack viable. This is confirmed by the CPE data for cpe:2.3:a:mtrudel:bandit (wildcard version) and by the EUVD affected ranges bandit commit fff06efe3be962b484bd4d3eb339372fda5a231f to d88b21953c65061f21136ea76a89a4f95a2ac7a1 and bandit 1.4.0 onward.
Know when Bandit 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:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
Unauthenticated remote attacker (PR:N/UI:N) triggers the block with a trivial trickle of standard frames (AC:L); impact is availability-only resource exhaustion with no confidentiality or integrity effect.
Primary rating from Vendor (EEF).
CVSS VectorVendor: EEF
DescriptionCVE.org
Uncontrolled Resource Consumption vulnerability in mtrudel bandit allows an unauthenticated remote attacker to pin HTTP/2 stream processes indefinitely via a trickle of small WINDOW_UPDATE frames. A stream whose response outruns the connection or stream send window blocks until the peer grants more window, and each block carries a 15 second deadline. Both deadlines restart whenever the peer makes partial progress. Bandit.HTTP2.Connection.finish_data/5 re-queues a partially advanced send in pending_sends with a fresh expires_at, so every WINDOW_UPDATE on stream 0, and every SETTINGS frame, resets the clock. Bandit.HTTP2.Stream.send_data/3 recurses on each stream WINDOW_UPDATE and re-arms a fresh after read_timeout. A peer that grants a few bytes every few seconds keeps the blocked stream process, its Plug state and any resource it holds mid-response alive for as long as it keeps dripping, and repeats this across streams and connections to exhaust server processes and memory.
The two paths are independent. The stream-level block is reached on its own by widening the connection window with a large WINDOW_UPDATE on stream 0 and shrinking the per-stream window with a small SETTINGS_INITIAL_WINDOW_SIZE, so closing only the connection-level path leaves it exploitable.
This issue affects bandit: from 1.4.0 onward.
Technical POC Analysis
CWE-400 (Uncontrolled Resource Consumption), related to CWE-770, in mtrudel/bandit's HTTP/2 send-window handling.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
Bandit HTTP/2 server versions 1.4.0 and later contain a high-severity remote denial-of-service flaw that can be triggered without authentication or user interaction, allowing an attacker to tie up server processes and memory. Organizations running Bandit for internet-facing or shared HTTP/2 services face a credible availability risk, including degraded performance, resource exhaustion, and potential outages. Leadership should prioritize remediation because this issue affects service uptime rather than data confidentiality or integrity.
Apply vendor patch.
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 Bandit WebSocket server (versions 0.5.0 through 1.10.x) allows unauthenticated remote attackers to
Memory exhaustion in Bandit WebSocket server (versions 0.5.9 through 1.10.x) allows unauthenticated remote attackers to
Denial of service in mtrudel bandit via HTTP/2 frame deserialization allows unauthenticated remote attackers to exhaust
Transport-state spoofing in Bandit 1.0.0 through 1.10.x allows unauthenticated remote attackers to forge HTTPS connectio
HTTP request smuggling in mtrudel bandit before version 1.11.0 allows unauthenticated attackers to bypass edge security
Unauthenticated remote denial of service in mtrudel Bandit (Elixir HTTP server) versions 1.6.1 through 1.11.0 lets any c
CPU exhaustion in bandit 1.11.0 to 1.12.0 allows unauthenticated remote denial-of-service via WebSocket fragment reassem
Unauthenticated remote denial of service in Bandit (the Elixir HTTP/1 web server for Phoenix/Plug applications) versions
Bandit's HTTP/2 request body reader amplifies memory use, letting an unauthenticated remote client make a server hold ro
Unauthenticated remote CPU exhaustion in mtrudel Bandit's HTTP/2 server (versions before 1.14.0) is achievable by holdin
Unbounded per-connection memory and CPU growth in the Elixir Bandit HTTP/2 server (0.3.6 up to 1.14.0) lets an unauthent
Unauthenticated remote attackers can exhaust BEAM node memory on default-configured mtrudel Bandit HTTP/2 servers (0.3.3
EUVD-2026-101380
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB