Skip to main content

Svelte devalue CVE-2026-81176

| EUVDEUVD-2026-80943 MEDIUM
Allocation of Resources Without Limits or Throttling (CWE-770)
2026-09-16 GitHub_M GHSA-9rgm-9g3h-6x36
5.3
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Identify endpoint parsing untrusted devalue data
  2. Delivery
    Craft payload with out-of-bounds indices
  3. Exploit
    Submit payload to devalue.parse
  4. Execution
    Parser alternates array representations doing quadratic work
  5. Impact
    CPU/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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.5% exploitation probability (EPSS)

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

Alert me

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

devalue < 5.9.2

Affected Packages

npm devalue fix: 5.9.2

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

Vendor (GitHub_M) PRIMARY 5.3 MEDIUM
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
vuln.today AI 5.3 MEDIUM

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.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
Low

Lifecycle Timeline

1
Patch available
Sep 16, 2026 - 19:19 EUVD

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

EPSS Score
0.5%
Top 59% exploitable
Prevalence
Medium
popular JS serialization library, SvelteKit dependency, but untrusted-parsing path is a subset
Threat Intel
1
1 source
Data Quality
6 sources
Confidence: High

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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.5%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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· derived
Medium

Priority Score

26
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +26
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.

CVE-2026-123563 HIGH
8.7 Nov 08

Memory-exhaustion denial of service in the npm library devalue (all versions up to and including 5.9.2) lets a malformed

CVE-2026-123569 HIGH
8.7 Nov 08

The npm package devalue (all versions through 5.6.2) can exhaust CPU and memory when it serializes a true sparse array t

CVE-2026-123566 HIGH
8.7 Nov 08

Denial of service in Svelte devalue through 5.9.2 can let remote, unauthenticated attackers block the Node.js event loop

CVE-2026-123565 HIGH
8.7 Nov 08

Memory and CPU exhaustion in Svelte devalue through 5.9.2 can occur when an application parses attacker-controlled data

CVE-2026-123564 HIGH
8.7 Nov 08

Memory exhaustion in Svelte devalue 1.0.0 through 5.9.2 occurs when an application uses uneval to serialize an attacker-

CVE-2026-123562 HIGH
8.7 Nov 08

Denial of service in the npm package devalue 5.8.0 through 5.9.2 lets a rejected internal promise from stringifyAsync go

CVE-2026-92708 HIGH
7.5 Sep 18

Serialization of Node.js Buffer objects in the JavaScript library devalue 5.1.0 through 5.9.2 leaks unrelated process me

CVE-2026-30226 HIGH
7.5 Mar 11

In devalue v5.6.3, `devalue.parse` and `devalue.unflatten` were susceptible to prototype pollution via maliciously craft

CVE-2026-22775 HIGH
7.5 Jan 15

Denial of service in Svelte devalue library versions 5.1.0 through 5.6.1 allows remote attackers to exhaust CPU and memo

CVE-2026-22774 HIGH
7.5 Jan 15

Denial of service in Svelte devalue versions 5.3.0 through 5.6.1 allows remote attackers to exhaust CPU and memory resou

CVE-2026-123561 MEDIUM
6.3 Nov 08

The npm package devalue (sveltejs) through 5.9.2 can be induced by crafted serialized payloads to produce objects carryi

CVE-2026-123567 MEDIUM
6.3 Nov 08

Prototype injection in the sveltejs devalue npm package (4.0.0 through 5.6.3) allows unauthenticated remote attackers to

Vendor StatusVendor

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