/

CVE-2026-92957

Severity:

CRITICAL RISK

(9.9)

NodeVM Builtin Deny-List Bypass (CWE-269) in vm2 Sandbox

CVE-2026-92957

Deferred

Vulnerability type

Category:

Improper Privilege Management

CWE:

CWE-269

Impact:

Sandbox Escape and Host Command Execution

Severity:

CRITICAL RISK

(9.9)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A policy enforcement flaw in vm2's NodeVM can bypass a deny-list entry when the entry uses a node:-prefixed builtin name. Untrusted sandboxed code may then access child_process and invoke process-spawning APIs, potentially achieving command execution on the host.

Affected context

The vulnerability occurs in vm2 NodeVM configurations that allow builtins through a wildcard policy while attempting to deny specific modules using node:-prefixed entries. It becomes risky when untrusted code runs in the sandbox and the policy relies on exact-name matching without normalizing builtin module specifiers.

Exploit preconditions

  • Attack surface: NodeVM's builtin-module require policy
  • Required access: Ability to execute untrusted JavaScript within an affected NodeVM sandbox
  • Trigger point: Resolution of a builtin module requested through require()
  • Why exploitation is possible: The policy compares negative entries against canonical builtin names, while node:-prefixed deny entries are not normalized consistently, allowing a supposedly blocked module to remain available

Why this happens

The underlying bug is inconsistent canonicalization of module identifiers across authorization and resolution paths. NodeVM removes the node: prefix when resolving builtin modules, but its negative wildcard policy entries are compared using their original spelling. This maps to CWE-269: Improper Privilege Management, because a security policy fails to restrict access to a privileged capability that should have been denied.

Potential impact

  • Sandboxed code may access the host child_process builtin
  • An attacker could execute operating-system commands through process-spawning APIs
  • The NodeVM isolation boundary could be bypassed
  • Host files, credentials, or services may be exposed depending on process privileges
  • A compromised process could affect other workloads or systems reachable from the host

General mitigation guidance

Mitigation generally focuses on making module authorization use one canonical representation throughout policy evaluation and module resolution.

Common defensive patterns include:

  • Normalize builtin specifiers before applying allow or deny rules
  • Use explicit allowlists instead of wildcard permissions where practical
  • Deny high-risk capabilities such as process creation by default
  • Run sandboxed workloads with minimal operating-system privileges and isolated resources
  • Treat sandboxing as one layer and apply operating-system, container, and network restrictions around it
  • Keep dependency and security-policy review processes aligned with the supported security fixes

How teams detect issues like this

Organizations can detect this class of issue through:

  • Static analysis for mismatched normalization between authorization checks and resource resolution
  • Code review searches for wildcard module permissions combined with string-based deny rules
  • Tests covering equivalent module spellings, including canonical and node:-prefixed builtin names
  • Runtime policy monitoring for unexpected access to process-spawning modules
  • Dependency and configuration checks that flag broad builtin access in sandbox environments

Automated security review tools may help identify inconsistent canonicalization and overly broad capability policies.

Sources

SourceLink
github.comgithub.com/patriksimek/vm2/security/advisories/GHSA-8686-vhfx-7r3j
vulncheck.comvulncheck.com/advisories/vm2-before-3.11.7-authentication-bypass-via-node-prefix

Frequently asked

questions

It is not necessarily directly reachable over a network. Exploitation generally requires that an attacker can cause untrusted JavaScript to execute inside an affected NodeVM, after which the sandbox policy may expose a host process-execution capability.

The attacker needs access to a feature or service that evaluates attacker-controlled or otherwise untrusted code in the affected sandbox configuration. Direct filesystem or host access is not inherently required.

Apply consistent normalization before both policy evaluation and builtin resolution, and prefer explicit allowlists that exclude process-spawning capabilities unless they are essential.

Test authorization policies with equivalent resource names, minimize granted capabilities, run sandboxes with least privilege, and include dependency security reviews and regression tests in the development process.

Find out what's already
exploitable in your codebase.