Skip to main content

Svelte devalue EUVDEUVD-2026-119449

| CVE-2026-123564 HIGH
Allocation of Resources Without Limits or Throttling (CWE-770)
2026-11-08 VulnCheck GHSA-97c7-3pc7-pw7r
8.7
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Identify app serializing attacker-influenced data via uneval
  2. Exploit
    Submit tiny crafted very-large-length sparse array
  3. Execution
    Application evaluates generated uneval output
  4. Impact
    Eager 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

devalue 1.0.0 <5.9.3

Affected Packages

npm devalue fix: 5.9.3

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

Vendor (VulnCheck) PRIMARY 8.7 HIGH
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
vuln.today AI 7.5 HIGH

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.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

2
Patch available
Nov 08, 2026 - 03:01 EUVD
CVE Published
Nov 08, 2026 - 01:38 cve.org
HIGH 8.7

DescriptionCVE.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

Why It Matters

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.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.3%
Top 72% exploitable
Prevalence
Medium
popular JavaScript serialization library in the Svelte/SvelteKit ecosystem, not universal
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

Priority Score

44
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy