Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach HTTP/2 endpoint unauthenticated
-
DeliveryCraft HPACK integer with many continuation octets
-
ExploitSend small header block to decoder
-
ExecutionTrigger O(N²) bignum accumulation
-
PersistExhaust server CPU and memory
-
ImpactDeny service to legitimate users
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V2 - Validation and Business Logic Algorithmic complexity limits
|
| Exploitation Conditions | Exploitation requires only that the target parses attacker-supplied HTTP/2 header blocks through hpax's 'Elixir.HPAX':decode/2 path using a version between 0.1.1 and 1.0.3 - i.e. any Elixir service (or client processing attacker-influenced responses) that speaks HTTP/2 via a vulnerable hpax. The crafted input is a valid HPACK variable-length integer with an extended sequence of continuation octets and no terminating size limit. Per CVSS 4.0 (AV:N/AC:L/AT:N/PR:N/UI:N) there is no authentication, no user interaction, and no special attack requirement; it works against default configurations. The primary limiting factors are that the service must actually expose an HTTP/2 endpoint and be running an unpatched hpax version, and that impact is confined to availability (CPU/memory exhaustion) - no code execution or data access is possible. |
| Impact | The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H, score 8.7) is internally consistent with the description: network-reachable, low complexity, no authentication, no user interaction, and impact limited to availability - there is no confidentiality or integrity exposure. Despite the input's 'RCE' tag, this is unambiguously a denial-of-service issue, not remote code execution; the tag is misleading and should be disregarded. No EPSS score, KEV listing, SSVC decision, or POC was provided, so exploitation likelihood must be inferred: the attack is trivial to construct (a hand-crafted HPACK integer, no valid session state or credentials needed) and highly automatable, which argues for real, near-term risk once details are public. The main factors bounding severity are that impact is confined to resource exhaustion (recoverable, no data loss) and that reach depends on the affected service actually terminating HTTP/2 and using a vulnerable hpax version. Overall this is a genuine patch-soon priority for exposed Elixir HTTP/2 endpoints rather than a high-CVSS-but-theoretical issue, but not a drop-everything emergency absent evidence of active exploitation. |
| Exploit ScenarioDerived | An attacker points a script at a public HTTPS service that terminates HTTP/2 on a vulnerable hpax version and opens a connection, requiring no credentials or user interaction. They send a single small header block whose HPACK integer carries a long run of continuation octets, forcing the decoder into ~O(N²) bignum arithmetic; repeating this across connections pins server CPU and starves legitimate requests. No public POC is identified at time of analysis, but the amplification is straightforward to reproduce from the advisory. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jul 06, 2026
Unauthenticated denial-of-service in elixir-mint's hpax (the HPACK header-compression library for Elixir HTTP/2, versions 0.1.1 through 1.0.3) allows a remote attacker to force superlinear (~O(N²)) CPU consumption by sending a small header block containing an HPACK integer with a long run of continuation octets. Because BEAM integers are arbitrary-precision, the decoder builds an ever-growing bignum with no upper bound, turning a few crafted bytes into a large, attacker-controlled amount of CPU and transient memory - a classic decompression/amplification DoS. No public exploit is identified at time of analysis and it is not in CISA KEV, but a vendor patch (version 1.0.4) is available.
RemediationAI
Vendor-released patch: upgrade hpax to 1.0.4 or later, which bounds HPACK integer decoding; the fix is in commit 1ba4bb2dc91e80089cf89c73970ac3ded76f17eb (https://github.com/elixir-mint/hpax/commit/1ba4bb2dc91e80089cf89c73970ac3ded76f17eb) and described in advisory GHSA-jj2p-32j7-whj2. In mix.exs, update the hpax dependency constraint to ~> 1.0.4 and run mix deps.update hpax; note that hpax is usually a transitive dependency, so also confirm the resolved version in mix.lock and rebuild, since a pinned parent library may otherwise hold back an old hpax. If immediate patching is not possible, place the HTTP/2 endpoint behind a proxy or WAF that can cap request header size and reject oversized/abnormal HPACK header blocks, and/or constrain per-connection CPU/time and concurrent HTTP/2 streams to limit amplification - with the trade-off that aggressive header-size limits can break legitimate clients sending large cookies or auth tokens. Where HTTP/2 is not required, disabling HTTP/2 (falling back to HTTP/1.1) removes the reachable decode path at the cost of losing HTTP/2's multiplexing benefits.
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
hpax implements HPACK (RFC 7541), the header-compression format used by HTTP/2, and is a foundational dependency in the Elixir networking stack (notably Mint and Finch-based clients/servers). The flaw sits in the variable-length integer decoder: 'Elixir.HPAX.Types':decode_remaining_integer/3 accumulates the value as int + (value <<< m), advancing the shift by 7 bits per continuation octet, and terminates only on a terminating octet or truncated input - never on a size threshold. Each continuation octet enlarges the running bignum, so re-adding into an O(N)-bit integer N times yields roughly O(N²) work. This is the textbook manifestation of CWE-407 (Inefficient Algorithmic Complexity), aggravated here by BEAM's arbitrary-precision integers which remove the natural 64-bit ceiling that would cap the cost in most languages. The reachable entry point is 'Elixir.HPAX':decode/2, invoked whenever a server or client parses an inbound HTTP/2 header block.
Know when Hpax 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, no auth or interaction, and low complexity to craft the HPACK integer; impact is availability-only (CPU/memory exhaustion) with no confidentiality or integrity effect, scope unchanged.
Primary rating from Vendor (EEF).
CVSS VectorVendor: EEF
DescriptionCVE.org
Inefficient Algorithmic Complexity vulnerability in elixir-mint hpax allows unauthenticated denial-of-service via unbounded HPACK integer decoding.
hpax decodes HPACK variable-length integers with no upper bound on the decoded value or the number of continuation octets. 'Elixir.HPAX.Types':decode_remaining_integer/3 accumulates the integer as int + (value <<< m), shifting by 7 more bits for each continuation octet and stopping only on a terminating octet or truncated input, never because the integer grew too large. Because BEAM integers are arbitrary precision, a run of N continuation octets builds an O(N)-bit bignum and re-adds into an ever-larger bignum on each step, so the total decoding cost is superlinear (about O(N^2)). An unauthenticated attacker who can send an HTTP/2 header block to a server using this decoder (reached through the 'Elixir.HPAX':decode/2 entry point) can supply a small header block that forces a large, attacker-controlled amount of CPU (and transient memory), a denial-of-service amplification.
This issue affects hpax from 0.1.1 before 1.0.4.
Executive ViewAI
Elixir applications using the hpax HTTP/2 library (versions 0.1.1-1.0.3) face remote denial-of-service vulnerability that allows unauthenticated attackers to disable services with minimal network traffic. Affected systems include any Elixir microservices or web applications relying on HTTP/2 functionality. An available patch (version 1.0.4) must be deployed to mitigate the risk of service unavailability.
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
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
EUVD-2026-41861
NVD
CVE.org
EPSS
Vulnrichment
GitHub
VulDB
Exploit-DB