Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessOpen HTTP/2 connection to Bandit server
-
DeliverySend thousands of requests, withhold connection WINDOW_UPDATE
-
ExploitFlood cheap 9-byte SETTINGS frames
-
ExecutionTrigger O(n²) do_pending_sends queue walks
-
ImpactPin BEAM schedulers, deny service to all requests
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V2 - Validation and Business Logic Algorithmic complexity limits
|
| Exploitation Conditions | Requires only that the target run Bandit (versions in the affected range, below 1.14.0) with HTTP/2 enabled - the default handling of non-ACK SETTINGS and connection-level WINDOW_UPDATE frames is vulnerable, and max_concurrent_streams defaults to :infinity, so no non-default configuration is needed. The attacker must be able to establish HTTP/2 connections and must keep many response streams blocked on the connection send window (by issuing many requests with sizeable responses and withholding connection WINDOW_UPDATE frames); the quadratic cost scales with the number of blocked streams the attacker chooses. Limiting factors are minimal: exploitation is remote and unauthenticated (PR:N), needs no user interaction (UI:N), and works against default configurations; the only real prerequisite is that HTTP/2 is served and the server accepts enough concurrent streams, which is the default. |
| Impact | This is a genuine, well-substantiated availability risk rather than an inflated high-CVSS paper tiger. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) confirms remote, low-complexity, unauthenticated exploitation with no user interaction and no special attack requirement, and the impact is scoped purely to availability (VA:H; VC:N/VI:N) - consistent with the CWE-407 algorithmic-complexity DoS described: do_pending_sends/2 performs O(n²) List.delete/2 work per cheap SETTINGS or stream-0 WINDOW_UPDATE frame, and max_concurrent_streams defaults to :infinity so the attacker controls n. The vuln.today decision label is 'this_week' (not act_now/emergency), which fits a serious DoS that is not yet weaponized at scale. No EPSS score and no KEV listing were provided, so there is no evidence of active in-the-wild exploitation; however a complete, reporter-verified proof-of-concept is published in the GHSA advisory (133 ms to process one 9-byte frame at 3,000 blocked streams), which materially raises practical risk. The signals are consistent with each other: high severity for availability, easy to trigger, patch available, exploit code public, but no confirmed active exploitation - prioritize patching promptly (this_week) without treating it as an active-attack emergency. One data note: NVD-style affected range is stated as 'from 0.3.4', while the GHSA advisory text states 'from 0.3.6 onward' - verify the exact lower bound against the vendor advisory. |
| Exploit ScenarioDerived | An unauthenticated attacker opens a single HTTP/2 connection to a Bandit server, issues thousands of requests whose large responses block on the connection-level send window (never sending a connection WINDOW_UPDATE so every response stays queued in pending_sends), then repeatedly sends tiny 9-byte empty SETTINGS (or stream-0 WINDOW_UPDATE) frames. Each cheap frame forces quadratic list traversal over the blocked streams, pinning BEAM schedulers and starving all other requests on the node. A public, reporter-verified PoC exists demonstrating 133 ms of processing for a single frame at 3,000 blocked streams, and the low complexity (AC:L, PR:N, UI:N) makes this trivially repeatable from a few low-bandwidth connections. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 26, 2026
Unauthenticated remote CPU exhaustion in mtrudel Bandit's HTTP/2 server (versions before 1.14.0) is achievable by holding thousands of response streams blocked on the connection send window and then sending tiny SETTINGS or stream-0 WINDOW_UPDATE frames. Each such frame makes the server retry every blocked send via do_pending_sends/2, producing O(n²) list operations; the advisory's verified PoC measured 133 ms for a single 9-byte SETTINGS frame with 3,000 blocked streams. The issue is remotely exploitable without authentication or user interaction and is prioritized this_week; the supplied data does not confirm active exploitation, and a public proof-of-concept is included in the advisory.
RemediationAI
Vendor-released patch: upgrade Bandit to 1.14.0, which contains the fix; the advisory is at https://github.com/mtrudel/bandit/security/advisories/GHSA-j363-h72p-296m and the supplied patch commit is https://github.com/mtrudel/bandit/commit/220b9dfd27f9a21305be2afc75cbe585ddc24e7a. No complete workaround is documented in the supplied data. If immediate upgrade is not possible, setting max_concurrent_streams to a finite low value bounds n and reduces the per-frame quadratic cost, but it does not remove the O(n²) retry path and will reject legitimate concurrent streams; disabling HTTP/2 where it is not required removes exposure to the vulnerable HTTP/2 frame handling, at the cost of losing HTTP/2 multiplexing and related features.
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
This is a CWE-407 inefficient algorithmic complexity flaw in Bandit's HTTP/2 flow-control handling. In lib/bandit/http2/connection.ex, every non-ACK SETTINGS frame and every connection-level WINDOW_UPDATE calls do_pending_sends/2; for each of n queued sends, the code calls List.delete/2 over the whole pending_sends list and re-queues the entry if still blocked, so one cheap frame costs O(n²) list operations. SETTINGS handling also sends deliver_send_window_update to every stream even when delta is 0, allowing unread messages to accumulate in blocked streams' mailboxes. Because max_concurrent_streams defaults to :infinity, the attacker chooses n by opening thousands of streams and withholding connection WINDOW_UPDATE frames so responses remain blocked. The advisory's PoC against Bandit 1.12.5 opened 3,000 blocked streams and showed a single 9-byte SETTINGS frame delaying the next PING ACK by 133.09 ms; a few connections sending a few KB/s can keep BEAM schedulers busy. The supplied assessment is CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, consistent with remote unauthenticated availability impact only.
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
Remote, unauthenticated, low-complexity trigger via default HTTP/2 frame handling (AV:N/AC:L/PR:N/UI:N); impact is CPU-exhaustion DoS only, so A:H with C:N/I:N.
Primary rating from Vendor (EEF).
CVSS VectorVendor: EEF
DescriptionCVE.org
Inefficient Algorithmic Complexity vulnerability in the HTTP/2 implementation of mtrudel bandit allows an unauthenticated remote attacker to exhaust server CPU via small SETTINGS or connection-level WINDOW_UPDATE frames. The attacker opens thousands of streams whose responses block on the connection send window, then sends cheap frames that each make the server walk the whole queue of blocked sends. In the reporter's run, with 3,000 blocked streams a single 9-byte SETTINGS frame took 133 ms to process.
do_pending_sends/2 in lib/bandit/http2/connection.ex retries every queued send and, before each retry, removes that entry from the queue with List.delete/2, so one frame costs O(n²) list operations for n blocked streams. max_concurrent_streams defaults to :infinity, so the attacker chooses n.
This issue affects bandit: from 0.3.4 before 1.14.0.
Technical POC Analysis
CWE-407 (Inefficient Algorithmic Complexity), reachable from an unauthenticated HTTP/2 peer.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
CVE-2026-108529 is a high-severity CPU exhaustion vulnerability in the Bandit HTTP/2 server (versions before 1.14.0), which is widely used in Elixir applications. An unauthenticated remote attacker can hold thousands of response streams blocked and then send tiny frames, causing the server to consume excessive CPU and degrade or deny service to legitimate users. Leadership should care because this can lead to service outages affecting customers and operations, and a public proof-of-concept reference exists, though no active exploitation has been confirmed.
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
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
Uncontrolled HTTP/2 flow-control resource consumption in mtrudel/bandit 1.4.0 and later lets an unauthenticated remote p
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
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-109829
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB