Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify app serializing attacker-influenced data via uneval
-
ExploitSubmit tiny crafted very-large-length sparse array
-
ExecutionApplication evaluates generated uneval output
-
ImpactEager allocation exhausts browser/runtime memory
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 an application to use devalue's uneval to serialize data that an attacker can influence, where that serialized data can declare a very large sparse array, AND the generated code is subsequently evaluated in a browser or runtime - the vendor explicitly states this does NOT affect the default parse sparse-array construction path. Limiting factors: the application must both emit uneval output AND evaluate it on attacker-influenced sparse arrays, which is a non-default usage pattern; in the common uneval use case of sending data to a client, the worst outcome is a single client browser tab running out of memory rather than server-side impact. No authentication is indicated by the CVSS vector (PR:N), and no user interaction is required (UI:N). |
| Impact | The input CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) with availability-only impact (VA:H) describes a network-reachable, low-complexity, unauthenticated denial-of-service affecting the availability of the system that evaluates the generated code - there is no confidentiality or integrity impact (VC:N/VI:N). The score of 8.7 is driven almost entirely by that high availability impact under default-looking metrics. However, the vendor advisory sharply narrows real-world risk: exploitation only matters 'if you were serializing very large sparse arrays and then evaluating the results' with uneval, and the vendor notes the worst general-case outcome is a client browser tab running out of memory - a self-inflicted client-side crash rather than server-side compromise. No EPSS score, no CISA KEV listing, and no PoC/exploit reference were provided, so there is no evidence of active exploitation or public weaponization; the vuln.today Decision label is this_week, not act_now or emergency. Net assessment: this is a legitimate but bounded availability issue whose raw CVSS 4.0 score overstates practical danger, because the AC:L/PR:N metrics do not capture the non-default usage pattern (uneval output being eval'd on large sparse arrays) that is actually required. CWE labeling is inconsistent across sources (NVD CWE-770 vs. advisory CWE-400 and CWE-789), but all point to uncontrolled/eager resource allocation. |
| Exploit ScenarioDerived | An application uses devalue's uneval to serialize data that an attacker can influence, and the resulting generated code is later evaluated in a browser or runtime. The attacker supplies a tiny serialized value declaring a very large sparse array, which on evaluation triggers memory allocation proportional to the declared length, exhausting memory and crashing the evaluating tab or process. No public exploit code was identified at time of analysis, and because the attack vector is network with low complexity (AV:N/AC:L), delivery is straightforward wherever the vulnerable serialize-then-evaluate pattern exists. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 08, 2026
Memory exhaustion in Svelte devalue 1.0.0 through 5.9.2 occurs when an application uses uneval to serialize an attacker-influenced, very large sparse array and then evaluates the generated code, causing allocation proportional to the array's declared length. The supplied CVSS 4.0 vector rates this 8.7 with network reach, low complexity, no privileges, and no user interaction, but availability-only impact; the vendor states the default parse sparse-array path is unaffected and the common uneval-to-client use case would at worst exhaust a browser tab's memory. No public exploit was identified at time of analysis.
RemediationAI
Vendor-released patch: upgrade devalue to 5.9.3 or later, as identified in the GHSA and fixed by commit https://github.com/sveltejs/devalue/commit/6861dbbb7e548849e48bce718e88747a298f7250. Consult the vendor advisory at https://github.com/sveltejs/devalue/security/advisories/GHSA-wf3x-273g-mvxv for the official guidance. As a compensating measure, applications should avoid evaluating uneval output for attacker-influenced sparse arrays and should constrain or reject very large declared array lengths before serialization; the vendor states default parse sparse-array construction is not affected. These controls can break workflows that rely on evaluating uneval output or handling legitimate very large sparse datasets, so upgrading remains the complete fix.
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 an npm serialization package from SvelteJS, and the flaw is in uneval's generated code for sparse arrays. When that generated code is evaluated, an array with a very large declared length causes eager memory allocation proportional to that length, so a tiny serialized value can produce a large allocation in a consuming browser or runtime. This maps to CWE-770 (allocation without limits), with the GHSA also classifying it as CWE-400 and CWE-789. The vendor explicitly notes the issue occurs during evaluation of generated code, not in default parse sparse-array construction, so exposure is limited to applications that both emit uneval output and later evaluate it on attacker-influenced sparse arrays; in the common client-data use case the worst case is a browser tab running out of memory rather than server-side compromise.
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
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
Network-reachable, low-complexity, unauthenticated trigger with no user interaction once the app evaluates uneval output; impact is memory exhaustion so A:H and C/I:N, scope unchanged.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
2DescriptionCVE.org
Sveltejs devalue from 1.0.0 before 5.9.3 contains a memory exhaustion flaw in uneval, whose generated code for sparse arrays allocates memory proportional to the array's declared length when evaluated. Attackers who can influence a very large sparse array serialized by an application can exhaust memory in the browser or runtime evaluating the output.
Technical POC Analysis
Assigned CWE-770 (Allocation of Resources Without Limits or Throttling).
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-123564 is a high-severity memory exhaustion flaw in the devalue serialization library used by Svelte applications, which could allow an attacker to crash application processes by submitting crafted sparse arrays for serialization. This affects any web application that uses devalue's uneval function on untrusted input, potentially causing downtime and service disruption. Leadership should care because exploitation could lead to availability outages, impacting customers and business operations.
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
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Related Vulnerabilities in devalue Prototype Pollution and Resource Exhaustion
View all 9Serialization 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
Quadratic-complexity denial of service in the Svelte devalue JavaScript deserializer (all versions prior to 5.9.2) lets
EUVD-2026-119449
GHSA-97c7-3pc7-pw7r
NVD
CVE.org
EPSS
Exploit-DB