Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify endpoint parsing untrusted devalue data
-
DeliveryCraft payload with out-of-bounds indices
-
ExploitSubmit payload to devalue.parse
-
ExecutionParser alternates array representations doing quadratic work
-
ImpactCPU/event-loop exhaustion denies service
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource allocation 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 | Exploitation requires that the target application call devalue.parse (or unflatten) on untrusted, attacker-supplied input on a vulnerable version prior to 5.9.2 - this is the essential precondition and is not the library's default posture, since many consumers only serialize/deserialize trusted internal data. No authentication, user interaction, or special platform is required once such a parsing path is exposed (PR:N/UI:N). The limiting factor is deployment-specific: if the app never parses external devalue data, it is not exploitable regardless of version. Impact is confined to availability (CPU/event-loop starvation); there is no code execution or data exposure. |
| Impact | This is a low-to-moderate real-world risk best characterized as a genuine but bounded availability issue. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L, base 5.3) is internally consistent with the description: a network-reachable, unauthenticated attacker with no user interaction can send a crafted devalue payload, but the only impact is partial availability degradation (A:L) via CPU exhaustion from quadratic parsing work - no confidentiality or integrity impact, which matches CWE-770 (uncontrolled resource consumption). No EPSS score, KEV listing, or SSVC decision data was provided, so exploitation likelihood cannot be quantified from these signals. There is no public exploit identified beyond the fix commit's regression test, which itself demonstrates the trigger pattern ('[["Set",7]]'). The most important limiting factor is NOT captured in the CVSS 'AV:N/PR:N' metrics: exploitation is only possible in applications that actually call devalue.parse on attacker-controlled/untrusted input - a design decision, not the default use of the library. This makes the practical attack surface narrower than the 'unauthenticated network' vector suggests. Overall: a real, patch-worthy DoS but not a high-urgency emergency. |
| Exploit ScenarioDerived | An application exposes an endpoint that deserializes client-supplied data with devalue.parse (for example accepting devalue-encoded request bodies). An unauthenticated attacker submits a specially crafted payload containing out-of-bounds array indices that make the parser alternate between array representations, forcing quadratic work relative to payload size and consuming CPU/event-loop time. The fix commit includes a regression test proving the trigger, but no standalone weaponized exploit is published. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 16, 2026
Quadratic-complexity denial of service in the Svelte devalue JavaScript deserializer (all versions prior to 5.9.2) lets remote attackers stall Node/browser consuming processes by feeding a crafted serialized string to devalue.parse. Because the parser fails to reject indices greater than or equal to values.length in src/parse.js, a payload can alternate between array representations and force work that grows quadratically with payload size; the CVSS vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L) confirms this is unauthenticated and requires no user interaction, with impact limited to availability. Exploitation is deployment-conditional: the target application must actually call devalue.parse (or unflatten) on untrusted input - a library that only round-trips trusted internal data is not exposed regardless of version. No public exploit code or confirmed active exploitation (CISA KEV) was identified at time of analysis, and EPSS data was not provided; the issue is fixed by rejecting out-of-bounds indices in version 5.9.2.
RemediationAI
Upgrade to devalue 5.9.2, the exact vendor-released patch version, which adds the bounds check that throws Invalid input for any index >= values.length; the fix is documented in the GitHub Security Advisory https://github.com/sveltejs/devalue/security/advisories/GHSA-9rgm-9g3h-6x36, delivered by commit https://github.com/sveltejs/devalue/commit/8b2a4562c446d7c36d9d629778079a5fae4243e1 and tagged at https://github.com/sveltejs/devalue/releases/tag/v5.9.2. If an immediate upgrade is not possible, the most effective compensating control is architectural and lossless: ensure devalue.parse is never invoked on untrusted or externally supplied strings - restrict deserialization to payloads the application itself produced, and where user-controlled data must cross the boundary, validate or re-encode it with JSON.parse under a schema rather than devalue. For endpoints that must accept external serialized data, enforce a strict maximum request/payload body size at the proxy or framework layer before the string reaches parse; this bounds the quadratic blowup but does not eliminate it for payloads under the cap, and it carries the trade-off of rejecting legitimately large serialized state. Running parsing inside a worker thread or separate process with a hard CPU/wall-clock timeout and readiness/liveness restarts will contain event-loop starvation at the cost of added infrastructure complexity and abrupt request termination. Rate-limiting or temporarily disabling the affected endpoint reduces the frequency and impact of repeated triggering attempts without fixing the underlying algorithmic flaw, so it should be treated only as a stopgap until 5.9.2 is deployed.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in npm
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
devalue is the Svelte-ecosystem serialization library used when JSON.stringify cannot represent values such as Map, Set, Date, RegExp, BigInt, or cyclic references; it emits a flat array of values plus index-based references, and devalue.parse/unflatten reconstructs the original object graph by resolving those indices. The CPE cpe:2.3:a:sveltejs:devalue:*:*:*:*:*:*:*:* identifies the affected package across all unpatched releases, mapped to CWE-770 (Allocation of Resources Without Limits or Throttling). The root cause is an input-validation gap: in src/parse.js, the unflatten routine resolved indices without verifying that index < values.length, so a crafted payload containing forward or out-of-range references caused the parser to repeatedly re-walk or re-materialize array representations. Each additional element increased the amount of redundant resolution work, yielding quadratic (O(n^2)) CPU consumption and event-loop starvation in the parsing process. The upstream fix (commit 8b2a4562c446d7c36d9d629778079a5fae4243e1) inserts a guard that throws Invalid input when index >= values.length, plus a regression test asserting that parse('[['Set',7]]') throws - a strict bounds check that eliminates the pathological resolution path rather than merely capping runtime. The flaw is purely a parser-efficiency/validation issue: there is no memory-safety component, no type-confusion primitive, and no path to code execution or data disclosure, which is consistent with the assessed C:N/I:N/A:L vector.
Know when Devalue 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
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
Network-reachable unauthenticated parse of untrusted input (AV:N/PR:N/UI:N) with a low-complexity crafted payload (AC:L); impact is availability-only CPU exhaustion (A:L), no C/I.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
1DescriptionCVE.org
Svelte devalue is a JavaScript library that serializes values into strings when JSON.stringify isn't sufficient for the job. Prior to 5.9.2, devalue.parse does not reject out-of-bounds indices that are greater than or equal to values.length in src/parse.js. A specially crafted untrusted payload can make the parser alternate between array representations, producing quadratic work as the payload grows and causing denial of service in applications that parse untrusted devalue data. This issue is fixed in version 5.9.2.
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 denial of service in the npm library devalue (all versions up to and including 5.9.2) lets a malformed
The npm package devalue (all versions through 5.6.2) can exhaust CPU and memory when it serializes a true sparse array t
Denial of service in Svelte devalue through 5.9.2 can let remote, unauthenticated attackers block the Node.js event loop
Memory and CPU exhaustion in Svelte devalue through 5.9.2 can occur when an application parses attacker-controlled data
Memory exhaustion in Svelte devalue 1.0.0 through 5.9.2 occurs when an application uses uneval to serialize an attacker-
Denial of service in the npm package devalue 5.8.0 through 5.9.2 lets a rejected internal promise from stringifyAsync go
Serialization of Node.js Buffer objects in the JavaScript library devalue 5.1.0 through 5.9.2 leaks unrelated process me
In devalue v5.6.3, `devalue.parse` and `devalue.unflatten` were susceptible to prototype pollution via maliciously craft
Denial of service in Svelte devalue library versions 5.1.0 through 5.6.1 allows remote attackers to exhaust CPU and memo
Denial of service in Svelte devalue versions 5.3.0 through 5.6.1 allows remote attackers to exhaust CPU and memory resou
The npm package devalue (sveltejs) through 5.9.2 can be induced by crafted serialized payloads to produce objects carryi
Prototype injection in the sveltejs devalue npm package (4.0.0 through 5.6.3) allows unauthenticated remote attackers to
EUVD-2026-80943
GHSA-9rgm-9g3h-6x36
NVD
CVE.org
EPSS
Exploit-DB