CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-92937

CVE-2026-92937: Sandbox Escape leading to Remote Code Execution via Promise Indirection in vm2

Amit Schendel
Amit Schendel
Senior Security Researcher

Oct 2, 2026·6 min read·50 visits

Executive Summary (TL;DR)

A critical bypass in the vm2 sandbox proxy lets untrusted code use Function call/apply indirection to bypass Promise rejection sanitizers, leading to remote code execution.

CVE-2026-92937 is a critical sandbox escape vulnerability in the `vm2` Node.js library. Due to a logical failure in checking direct invocation targets inside the Proxy bridge, an attacker can register Promise callbacks using `Function.prototype.call` or `Function.prototype.apply` indirection. This bypasses the error sanitization wrappers, delivering raw host error objects directly to sandboxed callbacks and allowing the attacker to escape the sandbox and execute arbitrary shell commands on the host.

Vulnerability Overview

The component vm2 is a widely utilized Node.js library designed to run untrusted code in an isolated environment. It attempts to create a secure context boundary by intercepting operations between the host and sandboxed environments through a custom Proxy-based bridge mechanism.

The vulnerability tracked as CVE-2026-92937 represents a critical boundary-crossing flaw where sandboxed code bypasses safety wrapper logic designed to sanitize rejection errors. The vulnerability allows an attacker to leak a raw host-realm error object, bypassing the sandbox isolation guarantees.

Once an attacker obtains a direct reference to a host object from the leaked error, they can abuse standard Node.js API paths to achieve arbitrary remote code execution on the host machine. The vulnerability occurs due to a logical mismatch in how the proxy's apply trap evaluates target execution contexts.

Root Cause Analysis

The root cause of this vulnerability lies in the sanitization logic implemented in lib/bridge.js to address the prior advisory GHSA-m283-3h24-438v. The library used an identity verification gate inside the Proxy bridge apply trap to determine if a call was targeting Promise.prototype.then or Promise.prototype.catch on a host Promise.

When these methods were called directly, the proxy wrapped the registered callbacks in a sanitizer function, which stripped raw host properties from any rejection error. However, the check only inspected the direct target of the invocation represented by the object variable in the apply trap.

By invoking the target methods indirectly using Function.prototype.call or Function.prototype.apply, sandboxed code causes the proxy trap to receive the helper function (e.g., call) as the direct target instead of the underlying then or catch method. Because the target identity does not match the expected Promise prototype methods, the sanitization wrapper bypasses the callbacks entirely, allowing direct access to the raw error object on rejection.

Code Analysis

Prior to the fix, the vulnerability gate inside lib/bridge.js evaluated only the direct target function. The logic was vulnerable to indirect call chains that obscured the identity of the underlying Promise method:

if (!isHost && hostPromiseSanitizeReject !== null) {
    if (isHostPromiseThen(object)) {
        args = wrapHostPromiseThenArgs(args);
    } else if (isHostPromiseCatch(object)) {
        args = wrapHostPromiseCatchArgs(args);
    }
}

The patch addresses this by implementing a structured normalizer function named normalizeHostPromiseCallbacks that executes recursively when the trap fires. The normalizer checks for Function.prototype.call and Function.prototype.apply indirection and unwinds the call stack up to 64 layers to find the true destination function:

function normalizeHostPromiseCallbacks(object, context, args) {
    if (isHost || hostPromiseSanitizeReject === null) return args;
    let curFn = object;
    let curThis = context;
    let container = args;
    let base = 0;
    let guard = 0;
    while (true) {
        if (guard++ >= MAX_PROMISE_PEEL) {
            throw new VMError(OPNA);
        }
        if (isHostPromiseThen(curFn)) {
            wrapPromiseSlot(container, base, false);
            wrapPromiseSlot(container, base + 1, true);
            return args;
        }
        // ... logic continues to peel and sanitize args in place
    }
}

This normalization prevents sandbox code from hiding the identity of the target behind execution helpers, neutralizing variant bypass methods while protecting against time-of-check to time-of-use (TOCTOU) attacks by snapshotting arguments.

Exploitation Methodology

Exploitation requires an async host-realm function exposed to the sandbox that returns a Promise and rejects with an Error containing a custom reference to a host-realm capability. When the sandbox invokes this function, it receives a proxy representation of the Promise.

Instead of registering rejection handlers directly, the exploit invokes the .then or .catch function using Function.prototype.call or Function.prototype.apply. This sequence prevents the proxy from intercepting the callback registration, causing Node's Promise reaction mechanism to invoke the callback with the raw, unsanitized host rejection error:

const p = hostFunction();
p.then.call(p, undefined, (err) => {
    // err contains the unsanitized host error object
    const hostProcess = err.detail;
    hostProcess.mainModule.require('child_process').execSync('id');
});

Because the callback operates with direct reference to the raw host error, the attacker accesses the unmitigated host object properties. By navigating properties such as .detail or .cause, the execution context obtains the native process module, resulting in arbitrary execution of system commands.

Impact Assessment

The security impact of CVE-2026-92937 is critical, achieving the maximum CVSS score of 10.0. A successful exploit breaks all isolation guarantees of the sandbox environment, allowing a remote or local attacker to execute arbitrary shell commands inside the underlying operating system context.

The vulnerability is classified under CWE-94 (Improper Control of Generation of Code) and CWE-693 (Protection Mechanism Failure). Because the sandbox's purpose is to isolate untrusted code, a complete escape represents a total compromise of confidentiality, integrity, and availability on the hosting server.

While there are no current reports of weaponized, active exploits in the wild, public proof-of-concept scripts exist and run reliably. This high severity means any system relying on vm2 to execute untrusted user input is exposed to immediate, full-system takeover if host-provided asynchronous methods return error objects with reference properties.

Mitigation and Remediation

The primary remediation path is updating the vm2 dependency to version 3.11.7 or later. The patch implements complete callback normalization and argument snapshotting, closing the delivery gap and preventing unmitigated error reference leaks.

However, because the vm2 library is officially deprecated and is no longer maintained, continuing to rely on it poses significant long-term security risks. Organizations must transition away from vm2 to alternative isolation techniques.

Recommended alternatives include WebAssembly sandboxing, running code in dedicated short-lived container environments, or using virtualization hypervisors like gVisor or Firecracker. These solutions provide physical boundary separation at the OS or kernel level, making runtime-level sandbox escapes significantly harder to achieve.

Fix Analysis (1)

Technical Appendix

CVSS Score
10.0/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
EPSS Probability
1.03%
Top 37% most exploited

Affected Systems

Node.js applications running vm2 <= 3.11.6

Affected Versions Detail

Product
Affected Versions
Fixed Version
vm2
patriksimek
<= 3.11.63.11.7
AttributeDetail
CWE IDCWE-94, CWE-693
Attack VectorNetwork
CVSS v3.1 Score10.0 (Critical)
EPSS Score0.01033 (1.03%)
Exploit StatusProof of Concept (PoC) available
Patch Version3.11.7

MITRE ATT&CK Mapping

T1059Command and Scripting Interpreter
Execution
T1203Exploitation for Client Execution
Execution
CWE-94
Improper Control of Generation of Code ('Code Injection')

References & Sources

  • [1]Official GitHub Advisory
  • [2]NVD Official CVE Page
  • [3]CVE.org Record
  • [4]Fix Commit
  • [5]Official Version Release (v3.11.7)

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•1 day ago•CVE-2026-128087
3.7

CVE-2026-128087: Premature Key Exchange Callback Invocation Prior to Host Key Verification in russh

CVE-2026-128087 (GHSA-9264-jvgf-6w2f) is an incorrect behavior order (CWE-696) and improper authorization (CWE-863) vulnerability in the russh Rust SSH library, affecting versions 0.55.0 through 0.65.0. During the initial SSH key exchange (KEX) handshake, the client state machine invokes the client::Handler::kex_done() callback—providing the negotiated raw shared secret bytes—prior to validating the remote server's host key or certificate via check_server_key(). Consequently, an untrusted or rogue SSH server can complete cryptographic key agreement and force a connecting client to execute side-effecting application logic inside kex_done() before the server's identity is checked and rejected.

Amit Schendel
Amit Schendel
8 views•10 min read
•2 days ago•CVE-2026-128082
7.5

CVE-2026-128082: Uncontrolled Recursion and Denial of Service in AutoMapper via Constructor Parameter Mapping

CVE-2026-128082 (GHSA-6vhm-j9h7-f9gh) is an uncontrolled recursion vulnerability (CWE-674) in AutoMapper, a convention-based object-object mapper for .NET. When mapping nested or self-referential types into destination models that rely on parameterized constructors, C# positional records, or recursive ConstructUsing expressions, AutoMapper evaluates child constructor arguments prior to incrementing the parent's recursion depth counter. This ordering flaw bypasses both explicit MaxDepth limits and the default depth limit of 64. An unauthenticated remote attacker can supply deeply nested input payloads to affected endpoints, exhausting the thread call stack and triggering an uncatchable System.StackOverflowException that terminates the hosting .NET process.

Amit Schendel
Amit Schendel
8 views•11 min read
•2 days ago•CVE-2026-128080
5.8

CVE-2026-128080: Sensitive Query Parameter Disclosure on Incoming Server Spans in OpenTelemetry JavaScript (@opentelemetry/instrumentation-http)

An information exposure vulnerability in the @opentelemetry/instrumentation-http package for OpenTelemetry JavaScript versions 0.204.0 prior to 0.222.0 causes incoming HTTP server spans to record raw, unredacted query string parameters under the url.query attribute. While outgoing client spans applied built-in and user-configured query parameter redaction, incoming server spans bypassed this sanitization completely, resulting in the transmission of sensitive credentials such as pre-signed cloud URLs and API tokens to external observability backends.

Alon Barad
Alon Barad
7 views•10 min read
•2 days ago•CVE-2026-128089
7.5

CVE-2026-128089: Uncontrolled Resource Consumption in dnspython WKS Record Parser

CVE-2026-128089 is an uncontrolled resource consumption vulnerability in the dnspython toolkit for Python, affecting all versions prior to 2.9.2. When parsing Well-Known Service (WKS) records from text via dns.rdtypes.IN.WKS.WKS.from_text(), the parser fails to validate that numeric service port identifiers fall within the RFC 1035 valid range of 0 through 65535. An attacker capable of supplying untrusted zone files or RDATA text strings containing an arbitrarily large service port integer can force the parser to allocate an unbounded bitmap array using an inefficient linear append loop, resulting in severe CPU exhaustion, application hangs, or Out-Of-Memory (OOM) process termination.

Amit Schendel
Amit Schendel
8 views•10 min read
•2 days ago•CVE-2026-126347
3.1

CVE-2026-126347: Open Redirect via Triple-Slash Redirect Paths in Tornado RedirectHandler

CVE-2026-126347 (GHSA-5cjw-f85j-cv6r) is an open redirect vulnerability (CWE-601) in Tornado, an asynchronous Python networking library and web framework. The flaw resides in tornado.web.RedirectHandler when dynamic URL redirection templates incorporate unvalidated user input. Due to a parser differential between RFC 3986 (used by Python's urllib.parse.urlsplit) and the WHATWG URL Standard (used by modern web browsers), inputs containing three or more leading slashes bypass Tornado 6.6.0's validation logic, allowing unauthenticated attackers to redirect users to arbitrary external domains.

Alon Barad
Alon Barad
8 views•11 min read
•2 days ago•CVE-2026-128123
5.9

CVE-2026-128123: Uncaught Exception and Denial of Service in SvelteKit @sveltejs/adapter-node

A Denial of Service (DoS) vulnerability exists in @sveltejs/adapter-node versions 5.5.7 and 6.0.0-next.0 through 6.0.0. When a SvelteKit server route returns a direct response from a fetch() call with a Content-Type of text/event-stream, the Node.js adapter attempts to mutate the response headers to disable proxy buffering. Because headers returned directly by the WHATWG Fetch API carry an immutable guard, this mutation throws an unhandled TypeError, terminating the underlying Node.js process and denying service to all active and subsequent clients.

Alon Barad
Alon Barad
8 views•9 min read