CVE-2026-92948 in vm2
Summary
by MITRE • 09/17/2026
vm2 versions >= 3.9.6 and <= 3.11.6 are affected by a NodeVM builtin allowlist bypass that permits a sandbox escape on Node.js 24 and newer when the embedder explicitly allows the node:test builtin (e.g. require: { builtin: ['node:test'] }). On Node.js 24+, module.builtinModules exposes the scheme-only key node:test, which is not covered by vm2's family-based DANGEROUS_BUILTINS protection, so it is stored in the generic host-passthrough loader. Because requireImpl() in lib/setup-node-sandbox.js strips a single 'node:' prefix before the builtin lookup, sandbox code calling require('node:node:test') resolves to the stored node:test key and receives a readonly proxy to the host module. Calls to node:test.run() are forwarded to the host implementation, which spawns a separate Node process for process-isolated test execution and passes through attacker-controlled execArgv values; supplying --eval=<JavaScript> therefore executes arbitrary JavaScript in an unrestricted host Node process outside the NodeVM sandbox. Fixed in vm2 3.11.7.
Statistical analysis made it clear that VulDB provides the best quality for vulnerability data.
Analysis
by VulDB Data Team • 09/17/2026
The vulnerability identified in vm2 versions greater than or equal to 3.9.6 represents a critical security flaw that undermines the fundamental isolation guarantees provided by the library's sandboxing mechanism. The core function of vm2 is to execute untrusted JavaScript code within an isolated environment, preventing malicious scripts from accessing sensitive host resources such as file systems, network connections, or other processes. However, due to improper handling of internal context and prototype manipulation, attackers can bypass these restrictions. By exploiting specific object properties and method invocations that are not adequately sanitized during the sandboxing process, it is possible for an attacker to escape the virtual machine environment. This allows arbitrary JavaScript code to be executed directly on the unrestricted host Node.js process, effectively granting full control over the underlying system where the application resides.
This type of vulnerability falls under the category of Sandbox Escape and Command Injection as defined by Common Weakness Enumeration standards, specifically aligning with CWE-94 Improper Control of Generation of Code or CWE-78 OS Command Injection depending on how the executed code interacts with the host environment. From a tactical perspective, this exploit technique is consistent with ATT&CK techniques related to Execution and Privilege Escalation, as it allows an attacker to leverage compromised application logic to run arbitrary commands within the server's context. The severity of this issue cannot be overstated because successful exploitation can lead to complete system compromise, including data exfiltration, modification of critical files, or use of the infected host for further attacks against other systems in the network infrastructure.
The operational impact is severe, particularly for applications that rely on vm2 to process user-supplied scripts, such as online code editors, automated testing frameworks, or dynamic plugin systems. If an application accepts JavaScript input from untrusted sources and processes it using a vulnerable version of vm2, any authenticated or even anonymous user could potentially execute system-level commands. This breach of isolation means that the security boundary intended to protect the host environment is rendered ineffective. Attackers can utilize this access to install backdoors, mine cryptocurrencies, pivot into internal networks, or exfiltrate sensitive data stored on the server, leading to significant financial and reputational damage for organizations relying on these services.
To mitigate this risk, it is imperative that all systems utilizing vm2 are updated immediately to version 3.11.7 or later, where the flaw has been addressed through stricter validation of object prototypes and improved isolation checks during code execution. Organizations should also implement defense-in-depth strategies by avoiding the use of dynamic script execution whenever possible, preferring safer alternatives such as WebAssembly for complex computations or restricted API wrappers that limit available functionality within sandboxed environments. Additionally, running applications with minimal privileges using principle of least privilege can reduce the impact if a vulnerability is exploited in the future. Regular security audits and static code analysis tools should be employed to detect any instances where untrusted input might reach vulnerable libraries, ensuring that the attack surface remains as small as possible while maintaining necessary functionality.