Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend request with attacker-influenced async values
-
DeliveryTrigger stringifyAsync serializing multiple promises
-
ExploitLater promise rejects before earlier settles
-
ExecutionInternal rejection left unhandled
-
ImpactNode default handler terminates process
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A10:2025 - Mishandling of Exceptional Conditions
ASVS 5.0
V16 - Security Logging and Error Handling Exception handling completeness
|
| Exploitation Conditions | Exploitation requires that the application (1) calls devalue's stringifyAsync to serialize MULTIPLE promises simultaneously, and (2) allows attacker influence over the timing or failure (rejection) of those asynchronous values so that a later promise can reject before an earlier one settles. The limiting factors are significant: the vendor states exploitation is 'essentially impossible' and that the issue is far more likely to appear as a developer-introduced bug; it also relies on Node.js's default unhandled-rejection-terminates-process behavior (configurable via --unhandled-rejections). Applications that do not serialize multiple promises, or that do not expose promise timing/failure to untrusted input, are not realistically exposed. Only devalue versions >= 5.8.0 and <= 5.9.2 are affected. |
| Impact | The CVSS 4.0 vector (AV:N/AC:L/PR:N/UI:N) scores 8.7 (High) driven entirely by availability impact (VA:H), with no confidentiality or integrity impact - this is a pure denial-of-service (process-termination) issue, not data exposure despite the misleading 'Information Disclosure' tag. The decision label is 'this_week' rather than act_now/emergency, consistent with a serious-but-not-urgent DoS. Critically, the vendor's own GHSA advisory states this is 'essentially impossible to exploit, and is much more likely to surface as a developer-introduced bug,' which directly contradicts the AC:L rating in the supplied vector: real exploitation requires an attacker to influence the relative timing and failure ordering of multiple serialized promises, a non-trivial precondition. No CISA KEV listing and no EPSS score were provided, and there is no confirmed working exploit code - only advisory references. Net assessment: a legitimate availability bug worth patching on a normal cadence, but the real-world weaponizability is low and the raw 8.7 overstates practical priority. If an application never passes attacker-influenced async values/timing into stringifyAsync, exposure is effectively nil. |
| Exploit ScenarioDerived | An application uses devalue's stringifyAsync to serialize multiple promises whose resolution timing or failure is derived from untrusted request input. An attacker crafts input causing a later promise to reject before an earlier one settles, producing an internal unhandled rejection that, under Node's default behavior, crashes the process - even though the application correctly awaits and catches the returned promise. No public working exploit code was identified, and the vendor characterizes practical exploitation as 'essentially impossible.' |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 08, 2026
Denial of service in the npm package devalue 5.8.0 through 5.9.2 lets a rejected internal promise from stringifyAsync go unhandled, so Node.js can terminate the process even when the caller catches the returned promise. Unauthenticated remote attackers can only trigger this if the application serializes multiple promises at once and lets untrusted input influence the timing or failure of those asynchronous values; the vendor describes exploitation as essentially impossible and far more likely to appear as a developer-introduced bug. There is no confidentiality or integrity impact - the only outcome is availability loss - and no public exploit has been identified at time of analysis.
RemediationAI
Vendor-released patch: devalue 5.9.3 (upstream commit https://github.com/sveltejs/devalue/commit/dae8153e9d7541b975cc4018138d6cebec6c1199). Upgrade every dependency path that resolves devalue into the 5.8.0-5.9.2 range to 5.9.3 or later and regenerate lockfiles, since transitive dependency pins commonly keep the vulnerable copy in place. Where the upgrade cannot be shipped immediately, the compensating options traceable to the advisory are narrow: avoid calling stringifyAsync on multiple promises whose settlement order or failure is influenced by request data, or, if that is not feasible, change Node's default unhandled-rejection policy via the --unhandled-rejections flag so an unhandled rejection does not terminate the process - the trade-off is that this masks all unhandled rejections application-wide, including genuine defects, and is a runtime-wide setting rather than a scoped fix. Updating to 5.9.3 is the complete fix; advisory details are at https://github.com/sveltejs/devalue/security/advisories/GHSA-x5rw-q4pp-hg5g
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 small Svelte-adjacent serialization library used to turn JavaScript values, including promises, into strings that can be revived later. Its stringifyAsync API accepts values that may resolve or reject asynchronously; when several promises are serialized together, the implementation attaches internal handlers that assume earlier entries settle before later ones. If a later promise rejects while an earlier one is still pending, an internal rejected promise is left without a handler, which is classified as CWE-248 (uncaught exception) and CWE-755 (improper handling of exceptional conditions). Under Node's default unhandled-rejection policy the runtime aborts the process, so the impact is purely availability. The public tags label this 'Information Disclosure', but nothing in the advisory supports data exposure. The CPE cpe:2.3:a:sveltejs:devalue covers the npm package; only the >= 5.8.0, <= 5.9.2 range is affected.
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
Remote with no auth or interaction, but requires attacker control of promise timing/failure ordering across multiple serialized values, so AC:H; impact is process termination only, hence A:H and C/I:N.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
2DescriptionCVE.org
devalue (sveltejs/devalue) 5.8.0 before 5.9.3 contains an unhandled promise rejection in stringifyAsync: when serializing multiple promises, a later promise rejecting before an earlier one settles leaves an internal rejection unhandled, even if the caller catches the returned promise. An attacker able to influence the timing or failure of serialized asynchronous values can terminate the Node.js process.
Technical POC Analysis
Bug class: uncaught exception / unhandled promise rejection (CWE-248, per the advisory; the advisory also tags CWE-755, improper handling of exceptional conditions).
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
The npm package devalue, used for serializing application state in JavaScript/Node.js environments, contains a high-severity availability flaw (CVE-2026-123562) affecting versions 5.8.0 through 5.9.2. If triggered, it can force the Node.js process to terminate even when application code catches the returned promise, potentially causing service outages for any product relying on affected versions. Leadership should care primarily about uptime and operational disruption, as there is no confidentiality or integrity impact and the vendor considers external exploitation essentially impossible.
No vendor-released patch identified at time of analysis. Interim mitigations: avoid serializing multiple promises concurrently when untrusted input can influence their timing or failure; validate and restrict untrusted input reaching asynchronous serialization paths; and ensure process supervision, health checks, and automatic restart to limit availability loss from process termination.
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
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-119447
GHSA-6jpw-759r-8m52
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB