Skip to main content

vm2 CVE-2026-92952

| EUVDEUVD-2026-81601 HIGH
Incorrect Resource Transfer Between Spheres (CWE-669)
8.9
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Run untrusted JS in vm2 sandbox
  2. Delivery
    Enumerate host WebStream prototype symbols
  3. Exploit
    Recover nodejs.stream.disturbed/errored symbols
  4. Execution
    Write symbols onto host stream objects
  5. Persist
    Corrupt host-visible stream state
  6. Impact
    Bypass one-shot body-consumption enforcement

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Incorrect resource transfer between spheres
Exploitation Conditions

Requires all of: (1) the vm2 threat model - the application runs untrusted/attacker-controlled JavaScript inside the sandbox; (2) the embedder explicitly exposes a host WebStream object AND the host stream/web module to the sandbox (not a default configuration); (3) a newer Node.js runtime where nodejs.stream.disturbed and nodejs.stream.errored are exposed on WebStream prototypes (validated on Node.js v25.8.0). Limiting factors: elevated attack complexity, dependence on non-default host-object exposure, dependence on a specific Node.js version, and integrity-only impact (no confidentiality/availability loss and no host code execution per the reported proof).

Impact

This is a moderate-to-high integrity issue, not a critical one, despite the 8.9 vendor score. The CVSS 4.0 vector (AV:N/AC:H/AT:P/PR:N/UI:N/VC:N/VI:H/VA:N/SI:H) is internally consistent with the description: integrity-only impact (VI:H/SI:H) with no confidentiality or availability loss, and elevated attack complexity (AC:H) plus an attack requirement (AT:P) reflecting the need for a specific newer Node.js runtime (validated on v25.8.0) and an embedder that exposes a host WebStream object plus the host stream/web module. The description explicitly states this is NOT a host code-execution primitive in the reported proof of vulnerability, which correctly downgrades it from the RCE-class members of the vm2 escape lineage. Exploitation status: no public exploit identified at time of analysis - there is no KEV listing and no POC signal in the provided data (only a mention of a 'reported proof of vulnerability' in the advisory, which is a demonstration, not weaponized exploit code). EPSS is not provided. The 'Authentication Bypass' tag conflicts with the actual impact - this corrupts host stream-state bookkeeping (e.g., forcing isDisturbed() to return false), it does not bypass authentication; treat that tag as mislabeled. Bottom line: real but conditional priority, gated on both a non-trivial embedder configuration and a modern Node.js version, so realistic exposure is narrower than the raw 8.9 suggests.

Exploit ScenarioDerived

An application embeds vm2 (3.11.4-3.11.6) on a newer Node.js release and hands sandboxed untrusted code a host WebStream object plus the host stream/web module. The sandboxed code calls Object.getOwnPropertySymbols on the host ReadableStream prototype to recover the unfiltered nodejs.stream.disturbed / nodejs.stream.errored symbols, then writes them onto host stream objects to falsify state - making an already-consumed stream appear un-consumed and defeating host one-shot body-consumption or errored-stream-rejection logic. A proof of vulnerability was reported in the advisory, but no weaponized public exploit is identified.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
1 public PoC Patch available 0.4% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Sep 17, 2026

vm2 versions 3.11.4 through 3.11.6 allow untrusted JavaScript running inside the sandbox to bypass cross-realm registered-symbol filtering and write Node.js internal stream symbols onto host WebStream objects, corrupting host-visible stream state - for example making stream.Readable.isDisturbed() return false for an already-consumed stream, which can defeat host logic that enforces one-shot body consumption or rejects errored streams. Exploitation is unauthenticated per the CVSS vector (PR:N) but requires a non-default setup: the embedder must expose both a host WebStream object and the host stream/web module to sandboxed code, and the host must run a Node.js release that exposes nodejs.stream.disturbed and nodejs.stream.errored on WebStream prototypes (validated on Node.js v25.8.0). Impact is integrity-only, with no host code execution, confidentiality, or availability loss in the reported proof; no public exploit code has been identified at time of analysis, and the flaw is fixed in vm2 3.11.7.

RemediationAI

Vendor-released patch: vm2 3.11.7 - upgrading from any 3.11.4/3.11.5/3.11.6 installation to 3.11.7 is the primary and recommended fix, and is documented in GHSA-jf8q-945g-9q4c (https://github.com/patriksimek/vm2/security/advisories/GHSA-jf8q-945g-9q4c) with corroborating detail at https://www.vulncheck.com/advisories/vm2-3.11.4-through-3.11.6-sandbox-symbol-filtering-bypass. Until the upgrade can be scheduled, the most effective compensating control is to stop exposing host stream primitives to the sandbox: remove host WebStream objects and the host stream/web module from the sandbox's injected context, and avoid passing host streams into sandboxed code entirely, since the vulnerability cannot be triggered without that exposure (the trade-off is that sandboxed scripts lose host stream APIs and must be rewritten to exchange plain buffers or strings through the bridge). If a host stream must be shared, do not use Readable.isDisturbed() or isErrored() as a security gate; instead track consumption and error state in host code using references the sandbox cannot reach (for example a host-side WeakSet of handed-out streams), accepting the extra bookkeeping. Keeping the Node.js runtime current may also remove the specific prototype-level symbols on which the bypass depends, but this is version-dependent and should not be treated as a substitute for patching vm2 or narrowing the sandbox's exposure surface.

Affected VersionsENISA

vm2 3.11.4 <3.11.7

Affected Packages

npm vm2 fix: 3.11.7

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

The root cause is CWE-669 (Incorrect Resource Transfer Between Spheres): vm2's isolation model tries to prevent sandbox code from reaching host-realm internals, but its cross-realm symbol handling is incomplete. Registered symbols created with Symbol.for are realm-agnostic - the same symbol identity is returned in every realm - so any registered symbol leaked onto a host prototype is effectively a shared write handle. vm2 attempts to defend this with fixed allow/deny lists: the extraction filters in lib/setup-sandbox.js and the cross-realm symbol checks plus write traps in lib/bridge.js enumerate known dangerous registered symbols such as the nodejs.* family. Those lists were not extended to cover nodejs.stream.disturbed and nodejs.stream.errored, which newer Node.js releases expose on host WebStream prototypes. Because the filters are list-based rather than derived from the live symbol registry, sandbox code that can reach the host stream/web module can call Object.getOwnPropertySymbols(streamWeb.ReadableStream.prototype), recover the real host symbol objects, and pass them through the bridge as write keys on host stream objects; the write traps do not recognize them as forbidden. The result is that the sandbox mutates genuine host stream state - e.g. flipping the disturbed/errored indicators consulted by Readable.isDisturbed() and Readable.isErrored() - rather than obtaining a host code-execution primitive. The advisory describes this as an incomplete fix for an earlier nodejs.* symbol-filtering issue, which reinforces that the underlying design (static symbol blocklists) is what fails, not a single missing string.

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 8.9 HIGH
CVSS:4.0/AV:N/AC:H/AT:P/PR:N/UI:N/VC:N/VI:H/VA:N/SC:N/SI:H/SA:N
vuln.today AI 6.8 MEDIUM

Untrusted JS runs in sandbox (PR:N) but AC:H reflects required newer Node.js plus non-default host WebStream exposure; sandbox-to-host corruption gives S:C with integrity-only I:H, C:N/A:N.

3.1 AV:N/AC:H/PR:N/UI:N/S:C/C:N/I:H/A:N
4.0 AV:N/AC:H/AT:P/PR:N/UI:N/VC:N/VI:H/VA:N/SC:N/SI:H/SA:N
Red Hat 6.8 MEDIUM

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
High
Attack Requirements
Present
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
High
Vulnerable system: Availability
None
Subsequent system: Confidentiality
None
Subsequent system: Integrity
High
Subsequent system: Availability
None

Lifecycle Timeline

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

DescriptionCVE.org

vm2 versions 3.11.4 through 3.11.6 incompletely filter Node.js registered internal symbols across the sandbox boundary. The extraction filters in lib/setup-sandbox.js and the cross-realm symbol checks and write traps in lib/bridge.js use a fixed list of known dangerous registered symbols that omits nodejs.stream.disturbed and nodejs.stream.errored, which are exposed on host WebStream prototypes on newer Node.js releases (validated on Node.js v25.8.0). When the embedder exposes a host WebStream object and the host stream/web module to the sandbox, sandbox code can obtain the real host symbols via Object.getOwnPropertySymbols(streamWeb.ReadableStream.prototype) and use them as write keys on host stream objects, corrupting host-visible stream state - for example making stream.Readable.isDisturbed() return false for an already-consumed stream. This can bypass host logic that relies on Node's public stream-state helpers to enforce one-shot body consumption, reject errored streams, or decide whether a stream is safe to hand to another component. It is not a host code-execution primitive in the reported proof of vulnerability. This is an incomplete fix for the earlier nodejs.* symbol filtering issue. Fixed in vm2 3.11.7.

Blast Radius

ecosystem impact
† from your stack dependencies † transitive graph · vuln.today resolves 4-path depth
  • 5 npm packages depend on vm2 (4 direct, 1 indirect)

Ecosystem-wide dependent count for version 3.11.4.

Technical POC Analysis

Metadata discrepancy to note up front: the supplied advisory rates this Moderate, CVSS 3.1 6.8 (AV:N/AC:H/PR:N/UI:N/S:C/C:N/I:H/A:N), lists no CVE, and states no patched version was known at publicat…

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Latest POC

1 public PoC link from github

Sign in to open the public PoC links collected for this CVE.

Executive ViewAI

Why It Matters

vm2, the JavaScript sandbox library many Node.js applications rely on to execute untrusted code, is affected in versions 3.11.4 through 3.11.6 by a high-severity integrity flaw that allows sandboxed code to falsify host-visible stream state. Applications that deliberately hand both a host WebStream object and the host stream/web module into the sandbox on newer Node.js releases could be misled by their own one-shot body consumption or errored-stream checks, weakening a control that often fronts authentication and data-integrity paths. Because vm2 is itself a trust boundary and no vendor patch is currently available, leadership should treat any service embedding it in that configuration as a priority remediation item rather than a routine dependency update.

Business Impact: Medium
Compensating Controls

No vendor patch identified; interim mitigations: remove the host stream/web module and host WebStream objects from the sandboxed code surface, reject vm2 3.11.4-3.11.6 in build pipelines, avoid relying on stream.Readable.isDisturbed()/errored checks by validating body consumption independently, run untrusted code in process or container isolation with a minimized host object surface, pin Node.js releases that do not expose nodejs.stream.disturbed and nodejs.stream.errored on WebStream prototypes, and monitor the vendor advisory for a fixed version.

Threat Intelligence Overview

EPSS Score
0.4%
Top 64% exploitable
Prevalence
Medium
popular but deprecated Node.js sandbox library, niche embedder-dependent feature
Threat Intel
1
1 sources
Data Quality
5 sources
Confidence: Medium
EUVD NVD CVE.org EPSS Vulnrichment GHSA Vendor GitHub

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 HIGH
CISA KEV No
Public POC Yes
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
No
Human Impact
Medium
Technical Impact
Partial

Priority Score

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

Attack Technique

Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.

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