Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach internet-facing Bandit HTTP/2 endpoint
-
DeliveryEncode 4,000-digit content-length via HPACK indexing
-
ExploitReplay stored value across thousands of streams
-
ExecutionTrigger quadratic bignum integer parsing
-
ImpactExhaust server CPU and deny service
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V2 - Validation and Business Logic Algorithmic complexity limits
|
| Exploitation Conditions | No special conditions - remote unauthenticated exploitation against default configurations of the Bandit web server (Elixir/Erlang). The flaw is reached on raw request input before any range check, via a content-length value or a Host/:authority port made of thousands of digits, on both HTTP/1 and HTTP/2. The only prerequisite is running a vulnerable version (1.0.0-pre.7 up to before 1.14.0) reachable by untrusted clients. Limiting factors: the severe amplification (one stored value replayed cheaply across many streams) specifically requires HTTP/2 with HPACK dynamic-table indexing enabled, though HTTP/1 is still vulnerable at lower leverage; and servers already upgraded to 1.14.0 are not affected. There is no authentication, user interaction, or non-default setting required to trigger the parser. |
| Impact | This is a genuine, actionable availability risk rather than an inflated high score. The vendor CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) scores 8.7 and is consistent with the mechanism: a remote, unauthenticated attacker over the network, no user interaction, no special configuration. Impact is availability-only (VA:H; VC:N/VI:N - no confidentiality or integrity exposure), so this is a denial-of-service, not a data-exposure or RCE issue. The strongest risk signal is the amplification demonstrated by the reporter: 124 KB of HTTP/2 traffic kept the server busy for 27.9 s because a single 4,000-digit value is stored once in the HPACK dynamic table and replayed across 5,000 streams, each costing quadratic parse time. CWE-407 and the source diff confirm the O(n²) bignum loop. KEV status is not listed (no confirmed active exploitation), and no EPSS score was provided, so widespread exploitation cannot be quantified from the input - the absence of EPSS/KEV data should be noted rather than read as low risk. A detailed PoC methodology is published in the GHSA advisory, but the input does not confirm a standalone working exploit. The vuln.today decision label is 'this_week' (not act_now/emergency), which aligns with a serious-but-non-emergency availability bug: prioritize patching this week for any internet-facing Bandit server. |
| Exploit ScenarioDerived | An attacker opens an HTTP/2 connection to any internet-facing Bandit server, sends a Content-Length (or Host/:authority port) value of several thousand digits stored once in the HPACK dynamic table, and re-references it across thousands of new streams. The server spends CPU time wildly out of proportion to the tiny traffic volume (27.9 s for ~124 KB in the reporter's test), degrading or denying service. A public PoC reference with step-by-step methodology exists in the GHSA advisory; it is not verified as working exploit code, and no authentication or special configuration is required. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 26, 2026
Unauthenticated remote attackers can consume disproportionate server CPU on Bandit (mtrudel/bandit, Elixir/Erlang) by sending a Content-Length value or a Host/:authority port composed of thousands of digits, which the header integer parser processes in quadratic time before any range check. Over HTTP/2 the cost is amplified because a 4,000-digit value can be stored once in the HPACK dynamic table and replayed cheaply across thousands of new streams; the advisory's proof-of-concept sent roughly 124 KB that kept the server busy for 27.9 seconds. Both HTTP/1 and HTTP/2 deployments are affected at default configuration, versions 1.0.0-pre.7 up to but not including 1.14.0. The advisory includes a public PoC reference that is not independently verified as working exploit code; there is no CISA KEV listing or other indication of active exploitation, and the vendor has released 1.14.0 as the fix.
RemediationAI
Vendor-released patch: upgrade Bandit to 1.14.0 or later; the advisory lists erlang/bandit as vulnerable from 1.0.0-pre.7 and fixed in 1.14.0 (GHSA-29cr-8477-rg6r, https://github.com/mtrudel/bandit/security/advisories/GHSA-29cr-8477-rg6r). The upstream fix is visible in commit 220b9dfd27f9a21305be2afc75cbe585ddc24e7a, and the introducing change is commit e0c8c0c30af9b0f57d8aafac37ddd9294363a8be; dependency manifests pinned to older versions should be bumped and redeployed, and operators using an umbrella release should rebuild the release rather than only updating the lockfile. The advisory does not document a configuration-level workaround, and because the parsing happens on raw request input before any range check, no in-application setting removes the exposure on its own. Deployments that cannot immediately upgrade should treat the affected listener as untrusted-input-exposed and plan the upgrade within the current patch cycle; disabling or terminating HTTP/2 at a front proxy removes the HPACK amplification leverage but leaves the HTTP/1 quadratic parse reachable, so it is at most a partial reduction and not a substitute for 1.14.0.
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
Bandit is an HTTP server written in Elixir. The root cause is CWE-407 (inefficient algorithmic complexity) in Bandit.Headers.parse_integer/2 in lib/bandit/headers.ex, which accumulates a value one digit at a time using total * 10 + digit without any cap on digit count, allocating a new bignum at every step so that parsing one value costs O(n²) in its length. The function is called from get_content_length/1 and parse_hostlike_header!/1 on raw request input over both HTTP/1 and HTTP/2, before any range check; an all-digit content-length is returned as {:ok, huge_int} and the is_port_number guard only runs after the whole number has been built. The advisory's measurements on OTP 28 put 10,000 digits at about 10 ms, 50,000 digits at about 250 ms and 80,000 digits at about 560 ms, versus 1 to 3 ms for String.to_integer/1 on the same inputs. The HTTP/2 amplification arises because HPACK dynamic-table indexing lets a 4,000-digit value be stored once and referenced by each subsequent stream for roughly one byte, so the attacker's bandwidth cost is decoupled from the server's parsing cost; HTTP/1 remains vulnerable at lower leverage. The flaw was introduced with the header-parsing code in commit e0c8c0c and is addressed by the 1.14.0 release (patch commit 220b9df).
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 with no user interaction or special config (AV:N/AC:L/PR:N/UI:N); impact is CPU-exhaustion denial of service only, so A:H and C:N/I:N.
Primary rating from Vendor (EEF).
CVSS VectorVendor: EEF
DescriptionCVE.org
Inefficient Algorithmic Complexity vulnerability in the header integer parser of mtrudel bandit allows an unauthenticated remote attacker to consume server CPU via a content-length value or a Host or :authority port made of thousands of digits.
Bandit.Headers.parse_integer/2 in lib/bandit/headers.ex builds the number one digit at a time with no limit on the digit count, allocating a new bignum at each step, so one value costs time quadratic in its length. It runs on raw request input over HTTP/1 and HTTP/2, before any range check. Over HTTP/2, a 4,000-digit value can be stored once in the HPACK dynamic table and re-sent on each new stream for about one byte: 124 KB of traffic kept the server busy for 27.9 s.
This issue affects bandit: from 1.0.0-pre.7 before 1.14.0.
Technical POC Analysis
CWE-407, Inefficient Algorithmic Complexity.
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-113436 is a high-severity (CVSS 8.7) denial-of-service vulnerability in the Bandit web server (Elixir/Erlang), affecting versions 1.0.0-pre.7 through 1.13.x. A single unauthenticated attacker can send a relatively small HTTP request (approx. 124 KB) that consumes server CPU for nearly 28 seconds, and over HTTP/2 this cost can be amplified across many streams, potentially causing extended service outages. Leadership should prioritize patching because any internet-facing Bandit deployment is at risk of disruption with minimal attacker effort.
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
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
EUVD-2026-109823
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB