漏洞来源

一个评分十分的严重漏洞

漏洞描述

SandboxJS 是一个 JavaScript 沙箱库。在 0.8.34 版本之前,可以获取包含 Function 数组,从而导致沙箱逃逸。如果拥有包含 Function 的数组和 Object.fromEntries,就可以构造 {[p]: Function},其中 p 是任何可构造的属。此漏洞已在 0.8.34 版本中修复

漏洞原理

CVE-2026-26954 的本质是 SandboxJS 污点追踪机制在复杂数据流转换中的结构性断裂:当攻击者利用 Object.values 等内置方法将带有“危险标记”的宿主函数封装进新数组时,沙箱引擎未能将污点标记递归传播至数组元素,导致宿主 Function 构造器在经历“数组存取”与 Object.fromEntries 重组后被意外加白;这种标记的静默丢失使得沙箱误判其为安全对象,进而允许攻击者通过 Promise 链调用该构造器在宿主全局作用域执行任意代码,深刻揭示了纯 JavaScript 沙箱在面对语言自身丰富的反射与数据变换能力时,仅靠局部路径封堵难以维持标记完整性的根本困境。

漏洞分析

漏洞入口点:SandboxExec.ts

// 第 138 行:SAFE_PROTOTYPES 定义
map.set(
  Object,
  new Set([
    'constructor', 'name', 'entries', 'fromEntries', 
    // ...
    'values', // <--- 允许 Object.values
    // ...
  ]),
);

当攻击者在沙箱代码中写下 Object.values(...) 时,沙箱的权限检查机制(在 executor.ts 的 GetProp 或 Call 前置检查中)会判定此操作合法,允许执行继续。

接下来执行原生调用

// LispType.Call 的处理逻辑
addOps<unknown, Lisp[], any>(LispType.Call, ({ done, a, b, obj, context }) => {
  // ... (参数解析逻辑省略)
  
  // 【步骤 2.1】直接调用宿主环境的原生方法
  // obj.context 是宿主对象 (如 globalThis 或 sandbox 全局域)
  // obj.prop 是 "values"
  let ret = obj.context[obj.prop](...vals) as unknown; 
  // 此时 ret = [Function, Object, Array, ...] (包含真实的宿主构造函数)

  // 【步骤 2.2】尝试进行安全检查(但存在缺陷)
  ret = getGlobalProp(ret, context) || ret;
  
  // 【步骤 2.3】返回结果
  done(undefined, ret);
});

漏洞逻辑分析:

  1. 原生执行:obj.context[obj.prop](...vals) 直接调用了 JavaScript 引擎原生的 Object.values。由于传入的对象包含了沙箱对宿主全局对象的引用(通常沙箱为了兼容性,会将 Function, Object 等映射到宿主原生构造函数),返回的 ret 是一个真实的 JavaScript 数组,其内部元素直接指向宿主的 Function 构造器等危险对象。
  2. 清洗失效:代码执行了 getGlobalProp(ret, context)。
  • getGlobalProp 的逻辑通常是:“如果 ret 本身是某个全局对象(如 globalThis),则返回对应的沙箱代理;否则返回 undefined”。
  • 关键点:ret 是一个新创建的数组实例,它本身不是全局对象。因此 getGlobalProp 返回 undefined。
  • 逻辑回退:ret = undefined || ret,导致 ret 保持原样。

最终一个包含宿主危险引用的脏数组被成功返回给了沙箱变量 arr。这是第一次污染,因为代码没有递归遍历数组内部去清洗每个元素。

接下来就是数组元素的解包与传递

// LispType.CreateArray 的处理逻辑
addOps<unknown, Lisp[]>(LispType.CreateArray, ({ done, b, context }) => {
  const items = b
    .map((item) => {
      if (item instanceof SpreadArray) {
        return [...item.item]; // 展开操作
      } else {
        return [item];
      }
    })
    .flat()
    .map((item) => valueOrProp(item, context)); // 关键步骤
  
  done(undefined, items);
});

漏洞逻辑分析:

  1. 当攻击者执行 [...arr] 或类似操作时,触发 LispType.CreateArray。
  2. 代码遍历源数组的元素,并调用 valueOrProp(item, context)。
  3. valueOrProp 的缺陷:该函数的作用是将沙箱内部的包装器(Wrapper/Prop)解包为原始值。
  • 如果 item 是来自上一阶段的那个脏数组中的宿主 Function,valueOrProp 会直接返回这个原始的宿主函数引用。
  • 缺失的逻辑:这里没有再次调用类似 sanitizeValue 的检查来判断“这个解包后的值是否是禁止访问的宿主全局对象?”。

最终危险的宿主函数被放入了一个新的沙箱数组结构中,或者被赋值给了一个变量。此时,该引用在沙箱内部已经加白,被视为普通值,最终实现逃逸

后续执行逻辑(隐含在 LispType.Call 的再次触发中):

  • 当攻击者执行 MaliciousFunc("return this")() 时:
  • 再次进入 LispType.Call 逻辑。
  • obj.context 现在是那个真实的宿主 Function。
  • obj.context(...) 被执行。
  • 由于 Function 构造器具有最高权限,它可以执行任意字符串代码,并且其内部的 this 指向真正的宿主全局对象(globalThis),从而完全突破沙箱隔离。

漏洞过程

POC:

payload = `
const p = (async function () {})();
({
  "finally": p.finally,
  ...Object.fromEntries([['then', ...Object.values(this).slice(1)]]),
}).finally('a=process.getBuiltinModule("child_process").execSync("ls", {stdio: "inherit"})')();
`;

接下来对poc的构造进行分析

const p = (async function () {})();

这里创建了一个 Promise,可以看到SandboxExec.ts的 SAFE_PROTOTYPES 配置如下:

map.set(Promise, new Set(['constructor', 'then', 'catch', 'finally']));

这里允许访问 Promise 及其 finally 方法,在 executor.ts的 GetProp 或 Call 逻辑中,如果对象是原生 Promise 实例,沙箱通常会直接透传原生的 Promise.prototype.finally,它是由宿主引擎原生执行的,而不是由沙箱解释器 (executor.ts) 逐行解释的。这意味着,一旦进入 finally 的内部逻辑,沙箱的检测就暂时失效了

Object.values(this).slice(1)

当执行 Object.values(this) 时,看 executor.ts中处理 LispType.Call 的代码

let ret = obj.context[obj.prop](...vals) as unknown; // 调用原生 Object.values
ret = getGlobalProp(ret, context) || ret;            // 尝试清洗
done(undefined, ret);

getGlobalProp(ret, context)它检查 ret本身(即那个新创建的数组)是否是全局对象,检查 ret内部的元素(即数组里的 Function 引用)是否是全局对象吗?

观察代码:代码中没有任何递归遍历。getGlobalProp 只看了一眼数组的外壳,发现它只是个普通数组,于是返回 undefined。
最终
ret = undefined || ret。那个包含宿主 Function 的脏数组,被原封不动地返回给了沙箱变量。

如果现在有一个脏数组 arr = [宿主Function, ...]。直接用它可能还会被某些检查拦截。那么PoC 中为什么要用 Object.fromEntries([['then', ...arr]])
这是为了改变数据的形态,从“数组元素”变为“对象属性”。
那在这个转换过程中,沙箱有机会拦截吗?
展开运算符 ...arr 会触发
executor.ts中的 LispType.CreateArray

.map((item) => valueOrProp(item, context))

valueOrProp解包沙箱内部的包装器。如果 item 已经是裸露的宿主引用(来自上一步的泄露),它就原样返回。

Object.fromEntries 的调用再次触发 LispType.Call。

let ret = obj.context[obj.prop](...vals); // 原生执行
ret = getGlobalProp(ret, context) || ret; // 再次浅层检查

这次 ret 是一个对象 { then: 宿主Function }。getGlobalProp 只检查对象本身。于是,一个包含危险 then 属性的普通对象被成功创建并返回。
这里数据在从数组到对象的形态转换中,从未经历过深度的污点清洗。宿主
Function 现在披着 obj.then 的外衣,在沙箱看来,它只是一个普通的函数引用。

({ finally: p.finally, ...obj }).finally('恶意代码')()
  1. 构建了一个新对象 target,它有两个属性:
  • finally: 指向原生宿主方法。
  • then: 指向宿主 Function 构造器。
  1. 调用 target.finally('恶意代码')。

当 target.finally 被调用时,p.finally 是原生的 Promise.prototype.finally。当你调用它时,JavaScript 引擎(V8/Node)直接在宿主层面执行该方法的逻辑。
宿主逻辑是这样的:

执行 finally 回调。根据 Promise 规范,调用这个 Promise 对象(即 target)的 then 方法。

宿主引擎在查找 target.then 时,由于target 是一个普通的 JS 对象,finally 是原生方法,它们之间的属性访问发生在沙箱边界之外的宿主内存空间中。宿主引擎直接读取了 target 对象内存中的 then 指针,发现它指向 Function 构造器。

最终过程:

  1. 宿主 finally 调用 target.then('恶意代码')。
  2. 这等价于直接执行 Function('恶意代码')。
  3. Function 构造器创建的函数,其作用域天然是全局宿主作用域。
  4. 于是,process.getBuiltinModule(...) 得以执行,沙箱彻底被绕过。

漏洞修复

官方修复

删除了 fallback 逻辑: ticks || currentTicks.current替换为固定来源:+ context.ctx.ticks

在旧版本代码中(红色部分),sandboxFunction 允许传入一个 ticks 对象。如果没传,就使用全局的 currentTicks.current。如果攻击者能够通过某种方式(例如利用原型污染、或者利用沙箱内部某些暴露的配置接口)修改 currentTicks.current 或者传入一个特制的 ticks 对象,他们就可以控制沙箱的执行预算。如果攻击者能禁用 Ticks 检查,他们就可以运行无限循环或复杂计算来辅助逃逸,或者在某些竞争条件下绕过检查。currentTicks 作为一个可变的全局/模块级状态,本身就是不安全的。它意味着沙箱的状态不是完全隔离的,而是依赖于外部传入的或全局共享的变量。

效果:移除 ticks 参数,意味着沙箱的执行限制现在完全由创建上下文时的 context 决定,且不可在函数创建阶段被外部篡改。

参考

https://github.com/nyariv/SandboxJS/commit/main#diff-96f3f99772d5025f1a54b1114d3d56bc6d5961f71fee89f163e5a8a7b0e45571

https://github.com/nyariv/SandboxJS/security/advisories/GHSA-6r9f-759j-hjgv