Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSubmit malicious JS to vm2 sandbox
-
DeliveryCall host Promise-returning API (events.once)
-
ExploitHost returns rejected Promise
-
ExecutionDiscard return value, leaving rejection unhandled
-
ImpactNode terminates host process (DoS)
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 | Requires that the target application embeds vm2 (3.10.0 through 3.11.7) to execute untrusted/attacker-controlled JavaScript inside a NodeVM sandbox AND exposes at least one host-realm Promise-returning API to that sandbox - the advisory cites events.once() via the NodeVM events builtin, or any embedder-provided Promise-returning function. Exploitation is trivial once inside the sandbox (call the API, ignore the rejected Promise), with no authentication or user interaction beyond code submission, but it is fully gated by this sandbox-with-untrusted-code deployment model: applications that do not run untrusted JS, or that do not surface a host Promise API into the sandbox, are not exposed. Limiting factors: the host process must be running Node.js with default unhandled-rejection-terminates behavior, and the fix (3.11.8) neutralizes it. |
| Impact | This is a genuine but conditional availability threat, not a broad-internet emergency. The vendor CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:H, base 9.2) is availability-only and correctly reflects that there is NO confidentiality or integrity impact - the sole outcome is a host-process crash (CWE-248 uncaught exception / unhandled Promise rejection). The high score is driven entirely by VA:H plus SA:H (the subsequent host system), which is why it lands 'critical' despite being 'just' a denial of service. The critical caveat the raw score hides: exploitation presupposes the vm2 threat model - the embedding application must already be executing attacker-controlled JavaScript inside a vm2 NodeVM sandbox that exposes a host Promise-returning API (e.g. the events builtin's events.once()). That is vm2's entire purpose, so PR:N/AC:L are defensible for products that use vm2 as designed, but it is emphatically NOT 'any remote attacker against any host.' On exploitation signals: no CISA KEV entry, no EPSS score provided, and no explicit public POC in the input (the advisory describes the mechanism in enough detail to reproduce, but no weaponized code is confirmed) - so this is 'no public exploit identified at time of analysis.' Contrast with the higher-value RCE members of this same vm2 wave (e.g. CVE-2026-92956 default-config escape, CVE-2026-92955): those grant code execution; this one only kills the process. Net: a real, patch-worthy DoS for anyone running vm2 3.10.0-3.11.7 with untrusted code, but lower operational priority than the RCE siblings and lower than the CVSS 9.2 alone would suggest. |
| Exploit ScenarioDerived | An application uses vm2 (3.10.0-3.11.7) to run untrusted user-supplied JavaScript and exposes a host Promise-returning API such as events.once() through the NodeVM events builtin. The attacker submits sandbox code that calls that host function, receives a Promise that will reject, and simply discards the return value; because the bridge never marked the host Promise as handled, Node.js's default unhandled-rejection behavior terminates the entire host process, taking down the service. No weaponized POC is confirmed, though the advisory documents the mechanism precisely. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 17, 2026
A denial-of-service flaw in the vm2 Node.js sandbox library (versions 3.10.0 through 3.11.7) allows attacker-controlled JavaScript running inside a NodeVM sandbox to kill the host Node.js process by invoking a host-realm function that returns a rejected Promise and simply ignoring the return value. Because host-origin Promises crossing the bridge are not marked as handled, Node.js's default unhandled-rejection behavior terminates the process; the CVSS 4.0 score is 9.2, and the assessed vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:N/I:N/A:H) rates it unauthenticated and network-reachable but entirely gated on the target embedding vm2 to run untrusted code and exposing at least one host Promise-returning API (the advisory cites events.once() via the NodeVM events builtin). No public exploit code and no CISA KEV entry were identified at time of analysis, and this is an incomplete fix of GHSA-hw58-p9xv-2mjh that is resolved in vm2 3.11.8.
RemediationAI
Apply the vendor fix by upgrading vm2 to 3.11.8 or later, which is the exact patched version identified in the CVE description and the GitHub advisory (https://github.com/patriksimek/vm2/security/advisories/GHSA-gjq8-xm47-88rc); treat 3.10.0 through 3.11.7 as vulnerable, and note that VulnCheck's advisory (https://www.vulncheck.com/advisories/vm2-3.10.0-through-3.11.5-denial-of-service-via-host-promise) frames the range slightly differently, so upgrade to the newest release rather than attempting to bisect. If upgrading is not immediately possible, the most effective compensating control is architectural: do not expose host-realm Promise-returning APIs (including events.once() from the NodeVM events builtin) into the sandbox, since the flaw requires the sandbox to be able to obtain a rejected host Promise - disabling or stripping the events builtin and auditing every host function wired into the sandbox for Promise returns removes the trigger path, at the cost of reducing sandbox functionality. A second option is to wrap every host function you expose so it attaches a .catch (or .finally) handler to any Promise before returning it into the sandbox, which marks the rejection as handled before it crosses the bridge; this is effective but must be applied exhaustively, as a single un-wrapped API reopens the issue. Finally, running the host Node.js process with unhandled rejections configured not to terminate (for example --unhandled-rejections=warn or a process-level unhandledRejection handler) converts the crash into a logged warning, but this is a blunt global change that can mask genuine unhandled-rejection bugs elsewhere and should be considered only as a temporary stopgap. Note the earlier incomplete fix for GHSA-hw58-p9xv-2mjh, meaning partial or backported mitigations from that advisory should not be assumed sufficient.
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
vm2 is a widely used library for running untrusted JavaScript inside Node.js via its NodeVM and VM abstractions, which bridge objects between a host realm and a sandbox realm. The root cause maps to CWE-248 (Uncaught Exception): only Promises created inside the sandbox are wrapped with a rejection-swallowing handler in lib/setup-sandbox.js, and the bridge installs host-side rejection sanitizers only when sandbox code explicitly calls .then/.catch/.finally on a bridged Promise. A Promise returned from the host realm into the sandbox therefore crosses the bridge unmarked, so when sandbox code calls a host function returning a rejected Promise (for example events.once() surfaced through the NodeVM events builtin, or any embedder-supplied Promise-returning API) and discards the return value, the host Promise remains unhandled and Node.js's default unhandled-rejection behavior tears down the host process. The single CPE entry (cpe:2.3:a:patriksimek:vm2:*:*:*:*:*:*:*:*) is unspecific to any version range, so version targeting must rely on the description and advisory; note the VulnCheck advisory title references 3.10.0 through 3.11.5 while the CVE description and vendor advisory define the affected range as 3.10.0 through 3.11.7, and earlier prior-art issue GHSA-hw58-p9xv-2mjh covered the same class.
Know when Vm2 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:H
Sandboxed attacker code reaches out and crashes the host process (scope change, S:C); availability-only so C:N/I:N/A:H; PR:N/AC:L because supplying JS is the sandbox's designed input path.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
2DescriptionCVE.org
vm2 is a sandbox library for running untrusted JavaScript in Node.js. In versions >= 3.10.0 and <= 3.11.7, Promises returned from the host realm into the sandbox are not marked as handled at the bridge boundary; only Promises created inside the sandbox are wrapped with a rejection-swallowing handler (lib/setup-sandbox.js), and the bridge only installs host-side rejection sanitizers when sandbox code calls .then/.catch/.finally. As a result, code running in the sandbox can invoke a host function that returns a rejected Promise (for example events.once() exposed via the NodeVM events builtin, or any embedder-provided Promise-returning API) and simply ignore the return value, leaving the host Promise unhandled so that Node.js's default unhandled-rejection behavior terminates the host process. This is an incomplete fix of GHSA-hw58-p9xv-2mjh. The issue is fixed in version 3.11.8.
Blast Radius
ecosystem impact- 12 npm packages depend on vm2 (3 direct, 9 indirect)
Ecosystem-wide dependent count for version 3.10.0.
Technical POC Analysis
CWE-248 (Uncaught Exception), with CWE-703 as secondary.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
A critical denial-of-service flaw in the vm2 Node.js sandbox library (versions 3.10.0 through 3.11.7) allows untrusted JavaScript running inside a sandbox to terminate the entire host Node.js process, meaning a single crafted input can take a service offline. Exposure is limited to environments that embed vm2 to execute untrusted or third-party code while also exposing at least one host-realm API that returns a Promise (the advisory cites events.once() via the NodeVM events builtin) - a pattern common in plugin engines, rule evaluators, and multi-tenant code-execution platforms. Leadership should care because the business outcome is unplanned outage of customer-facing or revenue-critical services, reachable over the network without authentication, with no public exploit identified at time of analysis and no vendor-released patch identified in the vulnerability record - although the advisory states the issue is resolved in vm2 3.11.8.
No vendor-released patch identified at time of analysis, although the advisory states the issue is resolved in vm2 3.11.8, which should be treated as the primary remediation. Interim mitigations until that upgrade is deployed: register a process-level unhandledRejection handler so host-origin rejected Promises cannot terminate the Node.js process; run vm2 workloads under a supervisor or orchestrator with automatic restart, health checks, and per-instance resource limits so an outage is contained and self-healing; remove or disable the NodeVM events builtin and avoid exposing any host-realm Promise-returning APIs to sandboxed code; wrap any bridge calls that cannot be removed in rejection-swallowing handlers; isolate untrusted-code execution into dedicated worker processes or containers separate from customer-facing request path; and add monitoring and alerting on unexpected process exits to detect exploitation attempts.
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
vm2 is an advanced vm/sandbox for Node.js. Rated critical severity (CVSS 10.0), this vulnerability is remotely exploitab
vm2 is a sandbox that can run untrusted code with Node's built-in modules. Rated critical severity (CVSS 10.0), this vul
vm2 is a sandbox that can run untrusted code with whitelisted Node's built-in modules. Rated critical severity (CVSS 10.
There exists a vulnerability in source code transformer (exception sanitization logic) of vm2 for versions up to 3.9.15,
vm2 is a sandbox that can run untrusted code with whitelisted Node's built-in modules. Rated critical severity (CVSS 10.
This affects the package vm2 before 3.9.4 via a Prototype Pollution attack vector, which can lead to execution of arbitr
Full sandbox escape with arbitrary code execution allows remote attackers to break out of vm2's Node.js sandbox environm
Sandbox escape in vm2 for Node.js allows remote unauthenticated attackers to execute arbitrary commands on the host syst
Sandbox escape in vm2 (patriksimek/vm2) versions prior to 3.11.3 enables remote code execution on the host Node.js proce
Sandbox escape in vm2 Node.js sandbox before 3.10.2 via Promise.prototype.then/catch callback sanitization bypass. PoC a
vm2 is a sandbox that can run untrusted code with whitelisted Node's built-in modules. Rated critical severity (CVSS 9.8
The package vm2 before 3.9.10 are vulnerable to Arbitrary Code Execution due to the usage of prototype lookup for the We
EUVD-2026-81603
GHSA-mgj2-jqjq-q8gg
NVD
CVE.org
EPSS
VulDB
Exploit-DB