Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend small crafted input to parse()
-
ExploitBypass typed-array allocation check via malformed ArrayBuffer reviver
-
ExecutionAllocate oversized ArrayBuffer
-
ImpactExhaust process memory, denial of service
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Memory allocation limits
|
| Exploitation Conditions | Exploitation requires the integrating application to use devalue's parse() with a custom ArrayBuffer reviver that is malformed; per the GHSA advisory this happens only 'under very specific circumstances.' That custom-reviver configuration is the concrete prerequisite and is non-default - applications relying on devalue's built-in parsing without a custom ArrayBuffer reviver are not exposed. The limiting factor is therefore this specific, application-supplied configuration rather than attacker-controlled input alone; where present, no authentication (PR:N) or user interaction (UI:N) is needed and the untrusted input reaches parse() over the network. Impact is confined to availability (memory-exhaustion DoS); no confidentiality or integrity effect. |
| Impact | The input signals are genuinely mixed, and the raw CVSS 4.0 base score of 8.7 (HIGH) overstates everyday risk for most deployments. The vector CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H is network-reachable, unauthenticated, no user interaction, with availability-only impact (VA:H; confidentiality and integrity untouched) - consistent with a memory-exhaustion denial of service (CWE-789, plus CWE-843 type confusion per the GHSA). However, the authoritative GHSA advisory states this occurs only 'under very specific circumstances' and 'required a malformed ArrayBuffer custom reviver,' which means the condition is supplied by the integrating application, not the attacker - so the CVSS AT:N (no attack requirements) understates a real precondition that most apps will not meet. No EPSS score was provided, there is no CISA KEV listing, and no PoC or exploit code is referenced - only the GHSA and VulnCheck advisories. The vuln.today decision label is 'this_week,' a patch-promptly tier rather than act_now/emergency. Net: this is a patch-this-week availability bug whose practical exploitability is gated by a non-default custom-reviver configuration, not a high-CVSS issue that translates to broad, immediate real-world risk. Note the discrepancy explicitly: CVSS marks AT:N/AC:L while the advisory describes 'very specific circumstances' requiring a malformed custom reviver - treat the base score as an upper bound and verify your own reviver usage. |
| Exploit ScenarioDerived | An application uses devalue's parse() with a custom, malformed ArrayBuffer reviver to deserialize untrusted input over the network. An attacker sends a very small crafted payload that bypasses the typed-array allocation validation, causing the process to allocate a massive ArrayBuffer and exhaust memory, crashing or hanging the service. No public exploit identified at time of analysis; exploitation requires no authentication (PR:N) but hinges on the vulnerable custom-reviver configuration being present. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 08, 2026
Memory-exhaustion denial of service in the npm library devalue (all versions up to and including 5.9.2) lets a malformed custom ArrayBuffer reviver bypass typed-array allocation validation inside parse(), so a very small crafted payload can cause allocation of massive ArrayBuffers. The flaw is not reachable by default: the integrating application must pass that malformed ArrayBuffer reviver to parse(), a configuration the GHSA describes as occurring only 'under very specific circumstances', and no public exploit code has been identified at time of analysis. Impact is confined to availability (VC:N/VI:N/VA:H, unauthenticated and without user interaction per the assessed vector), and the vendor shipped a fix in devalue 5.9.3.
RemediationAI
Upgrade devalue to 5.9.3 or later; that is the version that closes the bypass, implemented in commit 8f8d78e173f8a00023d009c7677ccc600dee0b99 and documented in GHSA-r9w8-h9r3-54w4 (https://github.com/sveltejs/devalue/security/advisories/GHSA-r9w8-h9r3-54w4), with the VulnCheck advisory at https://www.vulncheck.com/advisories/devalue-before-5.9.3-typed-array-allocation-validation-bypass-via-parse as a secondary reference. If the upgrade cannot be shipped immediately, the configuration-level mitigation supported by the advisory is to remove or correct the custom ArrayBuffer reviver passed to parse(), which eliminates the vulnerable path entirely; the trade-off is that any application feature relying on that custom reviver must be reimplemented or temporarily disabled. Audit dependency trees for transitive copies of devalue so nested installs are pinned to 5.9.3 as well. Applications that use devalue's built-in parsing without a custom ArrayBuffer reviver sit outside the exploitation conditions and carry only routine upgrade urgency.
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 a JavaScript value serialization/deserialization library maintained under the sveltejs organization, used as a richer alternative to JSON that can round-trip types such as Map, Set, Date, RegExp, typed arrays and ArrayBuffer. Deserialization runs through parse(), which rehydrates encoded values and can accept caller-supplied revivers; those revivers are application code that constructs the final objects, including ArrayBuffers. The advisory (CWE-789, memory allocation with an excessive size value, with CWE-843 type confusion also cited) frames the bug as a validation bypass: the typed-array allocation checks are skipped when a custom ArrayBuffer reviver is used, so a small amount of crafted input can drive an allocation of disproportionate size. The CPE cpe:2.3:a:sveltejs:devalue:*:*:*:*:*:*:*:* identifies the npm package as the affected component, with the GHSA narrowing the vulnerable range to versions <= 5.9.2. The precise code path that a reviver must expose to reach the unchecked allocation is documented in the referenced fix commit rather than in the advisory text, so the exact trigger beyond 'a malformed custom ArrayBuffer reviver' is not described in the available sources.
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 and unauthenticated (AV:N/PR:N), but the advisory's 'very specific circumstances' requiring a malformed custom reviver makes reliable triggering conditional, so AC:H; availability-only impact (A:H).
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
2DescriptionCVE.org
Devalue before 5.9.3 contains a validation bypass vulnerability that allows custom ArrayBuffer revivers to skip typed-array allocation checks in the parse function. Attackers can supply very small crafted input processed by a malformed ArrayBuffer reviver to allocate massive ArrayBuffers, causing memory exhaustion and denial of service.
Technical POC Analysis
CWE-789: Memory Allocation with Excessive Size Value (the advisory also tags CWE-843, incompatible-type access).
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
A high-severity vulnerability in the widely used npm library devalue (through version 5.9.2) can enable a denial-of-service attack that exhausts server memory, potentially disrupting any application that accepts untrusted data and uses a custom ArrayBuffer reviver. While exploitation requires a specific, non-default configuration and no public exploit code exists yet, the broad dependency footprint of devalue means teams should prioritize remediation to prevent availability outages if conditions align.
Apply vendor patch (upgrade to devalue 5.9.3). If patching is delayed, avoid passing custom ArrayBuffer revivers to parse() and implement strict input validation and size limits on incoming payloads to mitigate memory exhaustion.
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-119448
GHSA-6cvq-7mp2-2cxc
NVD
CVE.org
EPSS
Exploit-DB