【Node.js】VM模块深剖二：Script的编译与沙箱执行原理

1
#include <v8.h>
2
using namespace v8;
3

4
int main() {
5
  // 1. 初始化V8运行时（Isolate：JavaScript的“独立沙盒”）
6
  Isolate* isolate = Isolate::New();
7
  Isolate::Scope isolate_scope(isolate);
8
  HandleScope handle_scope(isolate);
9

10
  // 2. 定义要编译的JavaScript代码（“剧本”内容）
11
  Local<String> source = String::NewFromUtf8(isolate,
12
    "console.log(`Hello, ${name}!`)"  // 带变量的模板代码
13
  );
14

15
  // 3. 包裹源代码，准备编译
16
  ScriptCompiler::Source script_source(source);
17

18
  // 4. 编译为UnboundScript（生成“剧本模板”）
19
  Local<UnboundScript> unbound_script =
20
    ScriptCompiler::CompileUnboundScript(isolate, &script_source)
21
      .ToLocalChecked();  // 编译成功后返回UnboundScript
22

23
  // 后续：UnboundScript可绑定到任意Context执行（见1.2节）
24
  return 0;
25
}

1
// 延续1.1节的代码...
2

3
int main() {
4
  // ...（初始化Isolate、生成UnboundScript）
5

6
  // 1. 创建Context（“剧场”：定义变量环境）
7
  Local<Context> context = Context::New(isolate);
8
  Context::Scope context_scope(context);  // 进入该Context的作用域
9

10
  // 2. 给Context注入变量（“演员”：设置name的值）
11
  Local<String> name_key = String::NewFromUtf8(isolate, "name");
12
  Local<String> name_value = String::NewFromUtf8(isolate, "Alice");
13
  context->Global()->Set(context, name_key, name_value).Check();
14

15
  // 3. 将UnboundScript绑定到Context，生成Script（“具体演出”）
16
  Local<Script> script = unbound_script->BindToCurrentContext(context)
17
    .ToLocalChecked();
18

19
  // 4. 执行Script（“开始演出”）
20
  script->Run(context);  // 输出：Hello, Alice!
21

22
  // 5. 换一个Context执行（“另一个剧场”）
23
  Local<Context> another_context = Context::New(isolate);
24
  Context::Scope another_context_scope(another_context);
25
  another_context->Global()->Set(another_context, name_key,
26
    String::NewFromUtf8(isolate, "Bob")  // 不同的“演员”
27
  ).Check();
28
  Local<Script> another_script = unbound_script->BindToCurrentContext(another_context)
29
    .ToLocalChecked();
30
  another_script->Run(another_context);  // 输出：Hello, Bob!
31

32
  return 0;
33
}

1
class ContextifyScript {
2
private:
3
  v8::Local<v8::UnboundScript> unbound_script_; // 存储V8的UnboundScript
4
public:
5
  // 构造函数：编译源代码为UnboundScript
6
  ContextifyScript(v8::Isolate* isolate, const std::string& code) {
7
    v8::Local<v8::String> source = v8::String::NewFromUtf8(isolate, code.c_str());
8
    v8::ScriptCompiler::Source script_source(source);
9
    unbound_script_ = v8::ScriptCompiler::CompileUnboundScript(isolate, &script_source).ToLocalChecked();
10
  }
11

12
  // 绑定上下文并执行
13
  v8::Local<v8::Value> RunInContext(v8::Local<v8::Context> context) {
14
    v8::Context::Scope context_scope(context); // 切换上下文作用域
15
    v8::Local<v8::Script> script = unbound_script_->BindToCurrentContext(context).ToLocalChecked();
16
    return script->Run(context); // 执行Script
17
  }
18
};

1
const vm = require('vm')
2

3
// 1. 定义沙箱：仅暴露需要的变量（商品列表、优惠券规则）
4
const sandbox = {
5
  products: [
6
    { name: '手机', price: 5000 },
7
    { name: '耳机', price: 500 },
8
  ],
9
  coupon: { type: 'percentage', value: 10 }, // 10%折扣
10
  calculateTotal: (products) => products.reduce((sum, p) => sum + p.price, 0),
11
}
12

13
// 2. 创建上下文（沙箱），设置微任务模式为afterEvaluate（执行完脚本立即处理微任务）
14
const context = vm.createContext(sandbox, { microtaskMode: 'afterEvaluate' })
15

16
// 3. 用户提交的营销脚本（计算优惠后金额）
17
const marketingScript = `
18
const total = calculateTotal(products);
19
const discountedTotal = total * (1 - coupon.value / 100);
20
console.log(\`优惠后金额：\${discountedTotal}元\`);
21
`
22

23
// 4. 执行脚本
24
const script = new vm.Script(marketingScript)
25
script.runInContext(context) // 输出：优惠后金额：4950元

1
bool ContextifyScript::EvalMachine(v8::Local<v8::Context> context, int timeout) {
2
  // 1. 切换上下文作用域：后续操作都在context中执行
3
  v8::Context::Scope context_scope(context);
4
  // 2. 创建TryCatch：捕获未处理的异常
5
  v8::TryCatch try_catch(isolate_);
6
  // 3. 绑定UnboundScript到context，生成Script
7
  v8::Local<v8::Script> script = unbound_script_->BindToCurrentContext(context).ToLocalChecked();
8
  // 4. 执行Script
9
  v8::Local<v8::Value> result = script->Run(context);
10
  // 5. 处理微任务：若context有独立队列，立即执行（避免等待主事件循环）
11
  if (context->HasMicrotaskQueue()) {
12
    context->GetMicrotaskQueue()->PerformCheckpoint();
13
  }
14
  // 6. 处理错误：若有异常，向上抛出
15
  if (try_catch.HasCaught()) {
16
    try_catch.ReThrow();
17
    return false;
18
  }
19
  return true;
20
}

1
const vm = require('vm')
2
const sandbox = {
3
  products: [{ price: 100 }, { price: 200 }],
4
  console: console, // 允许输出日志
5
}
6
const context = vm.createContext(sandbox, { microtaskMode: 'afterEvaluate' })
7

8
// 主上下文的Promise：统计商品总数（微任务加入主队列）
9
new Promise((resolve) => {
10
  const totalProducts = sandbox.products.length
11
  resolve(`主程序：商品总数${totalProducts}`)
12
}).then((msg) => console.log(msg))
13

14
// 沙箱内的Promise：计算优惠后金额（微任务加入沙箱队列）
15
const marketingScript = `
16
new Promise(resolve => {
17
  const total = products.reduce((sum, p) => sum + p.price, 0);
18
  resolve(\`沙箱：优惠后金额\${total * 0.9}元\`);
19
}).then(msg => console.log(msg)); // 箭头函数：沙箱内的函数
20
`
21

22
// 执行脚本
23
vm.runInContext(marketingScript, context)
24

25
// 输出顺序：
26
// 主程序：商品总数2
27
// 沙箱：优惠后金额270元

1
const vm = require('vm')
2

3
// 用户提交的恶意代码：死循环输出
4
const maliciousCode = `
5
while (true) {
6
  console.log('正在占用CPU...');
7
}
8
`
9

10
// 创建Script，设置1秒超时
11
const script = new vm.Script(maliciousCode)
12

13
try {
14
  script.runInThisContext({ timeout: 1000 }) // 1秒后超时
15
} catch (err) {
16
  console.error('脚本执行超时：', err.message) // 输出：脚本执行超时：Script execution timed out after 1000ms
17
}

1
const moduleCode = `exports.foo = 'bar';`
2
const wrapper = `(function(exports, require, module) { ${moduleCode} })`
3
const script = new vm.Script(wrapper)
4
const moduleFn = script.runInThisContext()
5
moduleFn(module.exports, require, module)
6

7
// 若模块代码抛出错误，堆栈会指向Wrapper的第一行：
8
// Error: 模块错误
9
//   at Object.<anonymous> (wrapper:1:1)

1
const moduleCode = `exports.foo = 'bar';`
2
const moduleFn = vm.compileFunction(moduleCode, [
3
  'exports',
4
  'require',
5
  'module',
6
])
7
moduleFn(module.exports, require, module)
8

9
// 错误堆栈会准确指向模块代码的行号：
10
// Error: 模块错误
11
//   at Object.<anonymous> (mod.js:1:7)

1
const user = { name: 'Alice', balance: 1000 }
2
const sandbox = { user } // 直接传递引用
3
const context = vm.createContext(sandbox)
4
vm.runInContext(`user.balance = 0`, context) // 沙箱内修改balance
5
console.log(user.balance) // 输出：0（主程序的user被修改）

1
const _ = require('lodash')
2
const user = { name: 'Alice', balance: 1000 }
3
const sandbox = { user: _.cloneDeep(user) } // 深拷贝
4
const context = vm.createContext(sandbox)
5
vm.runInContext(`user.balance = 0`, context)
6
console.log(user.balance) // 输出：1000（主程序的user未被修改）

1
const maliciousCode = `while(true) {}`
2
const script = new vm.Script(maliciousCode)
3
script.runInThisContext() // 事件循环被阻塞，服务无法响应

1
const maliciousCode = `while(true) {}`
2
const script = new vm.Script(maliciousCode)
3
try {
4
  script.runInThisContext({ timeout: 1000 })
5
} catch (err) {
6
  console.error('超时：', err.message) // 输出：超时：Script execution timed out after 1000ms
7
}

1
const moduleCode = `throw new Error('模块错误');`
2
const wrapper = `(function() { ${moduleCode} })`
3
const script = new vm.Script(wrapper)
4
script.runInThisContext() // 错误堆栈指向Wrapper的第一行

1
const moduleCode = `throw new Error('模块错误');`
2
const moduleFn = vm.compileFunction(moduleCode)
3
moduleFn() // 错误堆栈指向moduleCode的第一行

1
// Node.js 20+（启用实验性flag）
2
const realm = new ShadowRealm()
3

4
// 1. 暴露有限API给插件（如获取用户信息）
5
realm.evaluate(`
6
  globalThis.getUserInfo = (userId) => ({
7
    id: userId,
8
    name: 'Alice',
9
    balance: 1000
10
  });
11
`)
12

13
// 2. 加载第三方插件（假设插件代码为字符串）
14
const pluginCode = `
15
  export function calculateDiscount(userId) {
16
    const user = getUserInfo(userId);
17
    return user.balance * 0.9; // 10%折扣
18
  }
19
`
20

21
// 3. 执行插件并获取结果
22
const calculateDiscount = await realm.importValue(
23
  pluginCode,
24
  'calculateDiscount'
25
)
26
const result = calculateDiscount(123)
27
console.log(result) // 输出：900