Description

vm2: NodeVM node:-prefixed negative builtin deny bypass exposes child_process

Summary

NodeVM normalizes node:-prefixed builtin specifiers during require() resolution, but it does not normalize user-provided negative builtin entries in wildcard policy.

As a result, this configuration:

new NodeVM({
  require: {
    builtin: ['*', '-node:child_process']
  }
});

does not deny the canonical child_process builtin. Sandboxed code can require both child_process and node:child_process, and receives the host module with process-spawning APIs such as execSync and spawn.

The safe proof below only checks module and function reachability. It does not execute any OS command.

Affected Mode

NodeVM.

Affected Configuration

new NodeVM({
  require: {
    builtin: ['*', '-node:child_process']
  }
});

This affects users who deny builtins using their node:-prefixed spelling, expecting -node:child_process to deny require('node:child_process') and require('child_process').

Affected Files / Functions

lib/builtin.js

makeBuiltinsFromLegacyOptions

wildcard builtin expansion

exact negative entry check: builtins.indexOf(\-${name}`)`

addDefaultBuiltin

lib/resolver.js

Resolver.resolve

lib/setup-node-sandbox.js

requireImpl

node: prefix stripping before builtin load

Root Cause

lib/setup-node-sandbox.js strips the node: prefix from resolved builtin filenames before loading the builtin:

if (localStringPrototypeStartsWith(filename, 'node:')) {
  id = localStringPrototypeSlice(filename, 5);
  let nmod = cacheBuiltins[id];
  if (!nmod) {
    nmod = loadBuiltinModule(id);
    if (!nmod) throw new VMError(`Cannot find module '${filename}'`, 'ENOTFOUND');
    cacheBuiltins[id] = nmod;
  }...
Show more

But lib/builtin.js checks wildcard negative entries by exact string match against the names in BUILTIN_MODULES:

if (builtins.indexOf(`-${name}`) === -1) {
  addDefaultBuiltin(res, name, hostRequire);
}

BUILTIN_MODULES contains the canonical name child_process, not node:child_process. Therefore -node:child_process does not exclude child_process, and addDefaultBuiltin() registers the host builtin.

Security Boundary Crossed

Sandboxed code reaches a host builtin that the embedder attempted to deny.

Boundary crossed:

sandbox -> host child_process builtin

sandbox -> host process-spawning function references

Impact

Confirmed impact:

require('child_process') succeeds inside the sandbox.

require('node:child_process') succeeds inside the sandbox.

The returned module exposes execSync and spawn as functions.

Worst confirmed impact is access to host process-spawning APIs. The proof does not execute any command.

The proof does not execute a command, but it confirms access to the host child_process module and its process-spawning APIs. For untrusted sandbox code, this is equivalent to command execution capability.

Safe Local Reproduction

Tested on Node.js v24.14.0.

This proof only checks whether the module and dangerous functions are reachable. It does not spawn a process and does not run OS commands.

'use strict';

const { NodeVM } = require('./');

function probe(builtin) {
  const vm = new NodeVM({
    require: {
      builtin...
Show more

Observed result:

{
  "nodeVersion": "v24.14.0",
  "denyNodePrefixed": {
    "child_process": {
      "loaded": true,
      "execSyncType": "function",
      "spawnType": "function",
      "moduleToStringTag": "[object Object]"...
Show more

Expected Secure Behavior

-node:child_process and -child_process should be equivalent.

If either spelling is denied, both of these should fail:

require('child_process')
require('node:child_process')

Suggested Fix

Canonicalize builtin names before allow/deny comparison:

Strip node: from user-provided builtin entries.

Preserve whether an entry is negative (-...) before canonicalizing.

Store and compare one canonical builtin key.

Apply the same normalization to:

wildcard negative entries

explicit allowlist entries

object-form builtin entries

mock/override keys if they are intended to support node: spelling

Add regression tests:

builtin: ['*', '-node:child_process'] blocks child_process.

builtin: ['*', '-node:child_process'] blocks node:child_process.

builtin: ['*', '-node:fs'] blocks fs and node:fs.

builtin: ['*', '-node:fs/promises'] and -fs/promises behave consistently.

Canonical dangerous builtins remain denied even if explicitly requested with node: spelling.

Mitigation

Aliases

References