/

CVE-2026-92947

Severity:

CRITICAL RISK

(10.0)

Information Disclosure (CWE-200) in vm2 Buffer Pool

CVE-2026-92947

Deferred

Vulnerability type

Category:

Improper Information Exposure

CWE:

CWE-200

Impact:

Sensitive Memory Disclosure and Denial of Service

Severity:

CRITICAL RISK

(10.0)

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 critical memory-isolation flaw in vm2 exposes Node.js shared Buffer memory to sandboxed code. Under affected allocation patterns, sandboxed code may read sensitive host-memory contents or modify host-realm buffers, potentially causing data exposure or denial of service.

Affected context

The issue occurs in vm2 environments that expose Node.js Buffer-related allocation behavior to sandboxed code. It becomes risky when small Buffer or related allocations can obtain ArrayBuffers backed by Node's shared host Buffer pool, allowing sandboxed operations to cross the intended memory boundary.

Exploit preconditions

  • Attack surface: Code executed inside a vm2 sandbox
  • Required access: Ability to provide or execute JavaScript within the sandbox
  • Trigger point: Buffer.from, Buffer.concat, or related small-allocation paths
  • Why exploitation is possible: Shared host-realm Buffer memory can become reachable from sandboxed code, weakening isolation between the sandbox and host process

Why this happens

The vulnerability results from exposing Node.js's shared Buffer pool across the vm2 sandbox boundary without adequately isolating the underlying ArrayBuffer objects.

When sandboxed code can obtain references to host-backed memory, it may inspect or alter bytes outside its intended realm. This maps to CWE-200: Exposure of Sensitive Information to an Unauthorized Actor, with the related integrity and availability risks arising from unintended access to shared process memory.

Potential impact

  • Sandboxed code may read sensitive data held in host memory
  • Credentials, tokens, or application data may be exposed
  • Sandboxed code could modify host-realm buffer contents
  • Applications may experience corruption or denial of service
  • Confidentiality and isolation guarantees of the sandbox may be weakened

General mitigation guidance

Mitigation generally focuses on maintaining strict memory and object isolation between sandboxed code and the host process.

Common defensive patterns include:

  • Avoiding exposure of shared or host-backed Buffer pools to untrusted code
  • Using isolated allocation paths that do not reuse host-realm memory
  • Restricting or wrapping Buffer and ArrayBuffer capabilities at the sandbox boundary
  • Treating sandbox execution as untrusted and placing it in a separate process when strong isolation is required
  • Applying least privilege and limiting sensitive data available to the hosting process
  • Using defense-in-depth resource limits to reduce denial-of-service impact

How teams detect issues like this

Organizations can detect related risks through:

  • Static analysis of sandbox bridges that expose Buffer, ArrayBuffer, or typed-array objects
  • Code review checks for host-backed memory crossing trust boundaries
  • Tests that verify sandboxed objects cannot observe or mutate host allocations
  • Dependency and policy checks for sandbox components with known memory-isolation weaknesses
  • Runtime monitoring for abnormal allocation patterns, memory corruption symptoms, or unexpected sandbox process behavior

Automated review tools may help identify unsafe object exposure and missing isolation controls.

Sources

SourceLink
github.comgithub.com/patriksimek/vm2/security/advisories/GHSA-fcqc-726x-5wfc
vulncheck.comvulncheck.com/advisories/vm2-before-3.11.7-memory-disclosure-via-buffer-pool

Frequently asked

questions

Exploitation is generally dependent on an application executing attacker-controlled JavaScript inside a vulnerable vm2 sandbox. Remote reachability depends on how that application accepts and schedules sandboxed code.

An attacker typically needs the ability to influence code or inputs that are evaluated within the sandbox. Direct access to the host operating system is not necessarily required.

Preserve a strict boundary between sandboxed objects and host memory, avoid exposing shared Buffer pools, and use process-level isolation when sandbox guarantees must be strong.

Review all host-to-sandbox object bridges, test memory isolation explicitly, minimize sensitive data in the host process, and enforce dependency security policies for sandboxing components.

Find out what's already
exploitable in your codebase.