Skip to main content

vm2 CVE-2026-92954

| EUVDEUVD-2026-81603 CRITICAL
Uncaught Exception (CWE-248)
9.2
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Submit malicious JS to vm2 sandbox
  2. Delivery
    Call host Promise-returning API (events.once)
  3. Exploit
    Host returns rejected Promise
  4. Execution
    Discard return value, leaving rejection unhandled
  5. Impact
    Node 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.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
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 – 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

vm2 3.10.0 <3.11.8

Affected Packages

npm vm2 fix: 3.11.8

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

Vendor (VulnCheck) PRIMARY 9.2 CRITICAL
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
vuln.today AI 8.6 HIGH

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.

3.1 AV:N/AC:L/PR:N/UI:N/S:C/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:H
Red Hat 8.6 HIGH

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
High

Lifecycle Timeline

2
Patch available
Sep 17, 2026 - 15:17 EUVD
CVE Published
Sep 17, 2026 - 13:46 cve.org
CRITICAL 9.2

DescriptionCVE.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
† from your stack dependencies † transitive graph · vuln.today resolves 4-path depth
  • 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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.3%
Top 72% exploitable
Prevalence
Medium
popular but deprecated Node.js sandbox library, embedded in many tools
Threat Intel
1
1 source
Data Quality
5 sources
Confidence: Medium
EUVD NVD CVE.org EPSS GHSA Vendor GitHub VulDB

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 CRITICAL
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
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

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

More in Vm2

View all
CVE-2023-37466 CRITICAL POC
10.0 Jul 14

vm2 is an advanced vm/sandbox for Node.js. Rated critical severity (CVSS 10.0), this vulnerability is remotely exploitab

CVE-2023-32314 CRITICAL POC
10.0 May 15

vm2 is a sandbox that can run untrusted code with Node's built-in modules. Rated critical severity (CVSS 10.0), this vul

CVE-2023-30547 CRITICAL POC
10.0 Apr 17

vm2 is a sandbox that can run untrusted code with whitelisted Node's built-in modules. Rated critical severity (CVSS 10.

CVE-2023-29199 CRITICAL POC
10.0 Apr 14

There exists a vulnerability in source code transformer (exception sanitization logic) of vm2 for versions up to 3.9.15,

CVE-2022-36067 CRITICAL POC
10.0 Sep 06

vm2 is a sandbox that can run untrusted code with whitelisted Node's built-in modules. Rated critical severity (CVSS 10.

CVE-2021-23449 CRITICAL POC
10.0 Oct 18

This affects the package vm2 before 3.9.4 via a Prototype Pollution attack vector, which can lead to execution of arbitr

CVE-2026-26956 CRITICAL POC
9.8 May 04

Full sandbox escape with arbitrary code execution allows remote attackers to break out of vm2's Node.js sandbox environm

CVE-2026-24120 CRITICAL POC
9.8 May 04

Sandbox escape in vm2 for Node.js allows remote unauthenticated attackers to execute arbitrary commands on the host syst

CVE-2026-45411 CRITICAL POC
9.8 May 13

Sandbox escape in vm2 (patriksimek/vm2) versions prior to 3.11.3 enables remote code execution on the host Node.js proce

CVE-2026-22709 CRITICAL POC
9.8 Jan 26

Sandbox escape in vm2 Node.js sandbox before 3.10.2 via Promise.prototype.then/catch callback sanitization bypass. PoC a

CVE-2023-29017 CRITICAL POC
9.8 Apr 06

vm2 is a sandbox that can run untrusted code with whitelisted Node's built-in modules. Rated critical severity (CVSS 9.8

CVE-2022-25893 CRITICAL POC
9.8 Dec 21

The package vm2 before 3.9.10 are vulnerable to Arbitrary Code Execution due to the usage of prototype lookup for the We

Vendor StatusVendor

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