Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend multi-megabyte JSON body unauthenticated
-
ExploitUnbounded integer literal reaches JSON.decode in Plug.Parsers
-
Executionerlang:binary_to_integer burns CPU, allocates large bignums
-
ImpactSustained requests exhaust schedulers, denial of service
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V2 - Validation and Business Logic Input size validation
|
| Exploitation Conditions | Exploitation requires that the target application decode attacker-controlled JSON using Elixir's built-in JSON module (JSON.decode/1, JSON.decode!/1, or JSON.decode/3 with the default erlang:binary_to_integer integer decoder) on one of the affected versions (1.18.0-rc.0 through <1.18.6, 1.19.0-rc.0 through <1.19.7, or 1.20.0-rc.0 through <1.20.5). Applications generated by phx.new meet this condition by default, since phx.new sets JSON as the json_library and the generated endpoint passes it to Plug.Parsers, which decodes request bodies up to 8 MB before routing and authentication - so no authentication, user interaction, or non-default configuration is needed there. The limiting factors are: the app must actually parse untrusted JSON with this module (applications still using Jason are not affected, because Jason rejects integer literals longer than its default 1024-digit limit before conversion), impact is temporary CPU/memory exhaustion rather than crash or data loss, and a durable outage requires sustained request volume rather than a single request. |
| Impact | This is a genuine but moderate-priority availability issue, not an overblown high-CVSS entry. All signals point the same direction and are internally consistent: the supplied CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L) describes a network-reachable, low-complexity, unauthenticated flaw whose only impact is partial availability loss (VA:L) - no confidentiality or integrity exposure - which matches the description of CPU/memory exhaustion rather than code execution. The score of 6.9 and the vuln.today 'this_month' decision label both signal a real issue that warrants scheduled patching rather than emergency action. No EPSS score and no CISA KEV entry are present in the input, so there is no evidence of active exploitation; the vendor advisory does contain a concrete, reproducible proof-of-concept, which lowers the effort required to attack but is not the same as observed in-the-wild use. The main factors tempering urgency are that impact is temporary scheduler starvation requiring sustained request volume for a durable outage, and that exposure is limited to applications on the affected Elixir versions that actually decode untrusted JSON with the built-in JSON module (notably default phx.new Phoenix apps). No data is missing in a way that conflicts with the vector - the signals are coherent. |
| Exploit ScenarioDerived | An unauthenticated client sends a few-megabyte HTTP request body (default Plug.Parsers limit is 8 MB) containing JSON integer literals of roughly one million digits to a Phoenix application. Because Plug.Parsers decodes the body with the built-in JSON module before routing and authentication, the server spends about a second of CPU per request parsing each unbounded literal into a bignum, and sustained requests starve the BEAM schedulers. The vendor advisory publishes a working reproduction (a ~7 MB body of repeated '9' characters), so the barrier to reproducing the condition is low given the network vector and low attack complexity. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 30, 2026
Unauthenticated denial of service in Elixir's standard-library JSON module: JSON.decode/1, JSON.decode!/1 and JSON.decode/3 accept integer literals of unbounded length and pass them unchanged to erlang:binary_to_integer/1, so a single large numeric run consumes roughly 100 to 300 times the CPU of a string literal of the same size. Because phx.new-generated applications configure JSON as the Phoenix json_library and pass it to Plug.Parsers - which decodes bodies of up to 8 MB before routing and authentication - a multi-megabyte request body can tie up a scheduler for about a second per call and allocate large bignums; sustained traffic degrades availability. Note the assigned CVSS 4.0 score of 6.9 reflects low availability-only impact, and there is no indication of exploit code or active exploitation; the fix is shipped in 1.18.6, 1.19.7 and 1.20.5.
RemediationAI
Upgrade Elixir to 1.18.6, 1.19.7 or 1.20.5 depending on your release branch (vendor advisory GHSA-rp5q-xqhq-926h, with fix commits c81f122, 7154e87, cd158ef and ee5cc23); patch availability is confirmed by the vendor. Where an upgrade cannot be deployed immediately, the advisory's workaround is to decode untrusted input with a bounded integer decoder instead of the default: define a wrapper that calls JSON.decode/3 with integer: &safe_integer/1, where safe_integer/1 accepts at most 1024 bytes and raises otherwise, and in Phoenix pass that wrapper module to Plug.Parsers as json_decoder in place of Phoenix.json_library(). The trade-off is that legitimate JSON documents containing integers longer than 1024 digits will be rejected with a decode error, and any code path that bypasses the wrapper (direct JSON.decode/1 calls elsewhere in the app) remains exposed. Reducing the Plug.Parsers body length limit lowers the payload size available per request but does not remove the amplification, since a sub-megabyte digit run is still far costlier than the equivalent string.
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
Elixir 1.18 introduced a built-in JSON module (lib/elixir/lib/json.ex) alongside the vendored elixir_json encoder, and later versions delegate decoding to Erlang/OTP's :json.decode/3. Both paths default the :integer decoder to fun erlang:binary_to_integer/1, which will happily convert a digit run of arbitrary length; the scanner never caps the run before conversion. The cost of bignum conversion grows faster than linearly with digit count, hence the 100-300x CPU amplification relative to string decoding at one million digits, and above roughly 1.29 million digits the conversion raises SystemLimitError (which Plug.Parsers rescues into a 400 only after the CPU is already spent). This is CWE-1284 (Improper Validation of Specified Quantity in Input): a length/quantity field supplied by the attacker is consumed without a bound. The previously recommended library, Jason, is not exposed in the same way because it enforces a decoding_integer_digit_limit of 1024 by default before conversion. The fix adds an equivalent digit-length guard, and applications can replicate it by supplying a custom integer decoder.
Know when Elixir 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:L/SC:N/SI:N/SA:N
Remote unauthenticated request against default Phoenix config gives AV:N/AC:L/PR:N/UI:N; only transient availability impact so C:N/I:N/A:L and scope unchanged.
Primary rating from Vendor (EEF).
CVSS VectorVendor: EEF
DescriptionCVE.org
Improper Validation of Specified Quantity in Input vulnerability in the Elixir standard library's JSON module allows an unauthenticated attacker who supplies a JSON document to cause a denial of service through CPU and memory exhaustion.
JSON.decode/1 and JSON.decode!/1 convert each integer literal with erlang:binary_to_integer/1 and do not bound its length. A literal of one million digits decodes successfully but costs 100 to 300 times as much CPU as a string of the same length, so one request body of a few megabytes holds a scheduler for about a second. A literal of more than about 1.29 million digits raises SystemLimitError. Applications generated by phx.new decode request bodies with JSON in Plug.Parsers, before routing and authentication.
This issue affects elixir: from 1.18.0-rc.0 before 1.18.6, from 1.19.0-rc.0 before 1.19.7, and from 1.20.0-rc.0 before 1.20.5.
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.
Unbounded recursion in the Elixir `protobuf` Hex package (versions >= 0.8.0, < 0.16.1) lets unauthenticated remote attac
Improper JWT signature verification in Dashbit's nimble_zta (0.1.2 up to but not including 0.1.3) lets an unauthenticate
Session-swapping authentication bypass in the Elixir library AshAuthentication (versions 4.10.0 before 4.15.0 and 5.0.0-
Authentication bypass in the Elixir library ash_authentication lets an attacker who operates one federated identity-prov
Account takeover in AshAuthentication (Elixir/Ash) 4.14.0 through 4.14.x and 5.0.0-rc.10 through 5.0.0-rc.13 lets unauth
Server-Side Request Forgery protection bypass in the Elixir safeurl library (versions 0.1.0 and later) allows unauthenti
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 denial of service in the Elixir HTTP server Bandit (mtrudel/bandit) from 0.1.0 before 1.14.0 lets
Unauthenticated remote attackers can consume disproportionate server CPU on Bandit (mtrudel/bandit, Elixir/Erlang) by se
Memory-exhaustion denial of service in the elixir-protobuf library (protobuf) from 0.8.0 onward allows an unauthenticate
Atom table exhaustion in the Ash framework (Elixir) allows an unauthenticated remote attacker to crash a BEAM node by su
EUVD-2026-113758
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB