CVE-2026-23830:SandboxJS允许完全逃逸沙箱
漏洞来源一个满评分的沙箱逃逸漏洞漏洞描述SandboxJS 是一个 JavaScript 沙箱库。0.8.26 之前的版本存在沙箱逃逸漏洞,原因是 `AsyncFunction` 没有被隔离到 `SandboxFunction` 中。该库尝试通过将全局 `Function` 构造函数替换为安全的沙箱版本 `SandboxFunction` 来隔离代码执行。这在 `utils.ts` 中通过一个用于
漏洞来源
一个满评分的沙箱逃逸漏洞

漏洞描述
SandboxJS 是一个 JavaScript 沙箱库。0.8.26 之前的版本存在沙箱逃逸漏洞,原因是 `AsyncFunction` 没有被隔离到 `SandboxFunction` 中。该库尝试通过将全局 `Function` 构造函数替换为安全的沙箱版本 `SandboxFunction` 来隔离代码执行。这在 `utils.ts` 中通过一个用于查找的映射表将 `Function` 映射到 `sandboxFunction` 来实现。然而,在 0.8.26 之前的版本中,该库没有包含对 `AsyncFunction`、`GeneratorFunction` 和 `AsyncGeneratorFunction` 的映射。这些构造函数不是全局属性,但可以通过实例的 `.constructor` 属性访问(例如,`(async () => {}).constructor`)。属性访问在 `executor.ts` 中处理。当沙箱内运行的代码访问异步函数(沙箱允许创建异步函数)的 `.constructor` 属性时,`executor` 会检索该属性值。由于 `AsyncFunction` 不在安全替换映射中,`executor` 会返回实际的宿主原生 `AsyncFunction` 构造函数。JavaScript 中的函数构造函数(例如 `Function`、`AsyncFunction`)创建的函数会在全局作用域中执行。攻击者通过获取宿主 `AsyncFunction` 构造函数,可以创建一个完全在沙箱上下文之外执行的异步函数,从而绕过所有限制并获得对宿主环境的完全访问权限(远程代码执行)。0.8.26 版本修复了此漏洞。
漏洞原理
沙箱系统只对 Function 构造器进行了隔离,而忽略了功能完全等效的 AsyncFunction。攻击者可通过 (async () => {}).constructor 获取宿主 AsyncFunction,并用其创建在宿主全局作用域执行的函数,从而绕过所有沙箱限制。
漏洞分析
漏洞入口点:src/utils.ts
export function createExecContext(
sandbox: {
setSubscriptions: WeakMap<
SubscriptionSubject,
Map<string, Set<(modification: Change) => void>>
>;
changeSubscriptions: WeakMap<SubscriptionSubject, Set<(modification: Change) => void>>;
sandboxFunctions: WeakMap<(...args: any[]) => any, IExecContext>;
context: IContext;
},
executionTree: IExecutionTree,
evalContext?: IEvalContext
): IExecContext {
const evals = new Map();
const execContext: IExecContext = new ExecContext(
sandbox.context,
executionTree.constants,
executionTree.tree,
new Set<(obj: SubscriptionSubject, name: string) => void>(),
new WeakMap<SubscriptionSubject, Map<string, Set<(modification: Change) => void>>>(),
new WeakMap<SubscriptionSubject, Set<(modification: Change) => void>>(),
sandbox.setSubscriptions,
sandbox.changeSubscriptions,
evals,
(fn) => sandbox.sandboxFunctions.set(fn, execContext),
!!evalContext,
evalContext
);
if (evalContext) {
const func = evalContext.sandboxFunction(execContext);
evals.set(Function, func); // ← 仅注册了 Function!
evals.set(eval, evalContext.sandboxedEval(func));
evals.set(setTimeout, evalContext.sandboxedSetTimeout(func));
evals.set(setInterval, evalContext.sandboxedSetInterval(func));
}
return execContext;
}evals 是一个 Map,用于在属性访问时将危险构造器替换为沙箱安全版本。
- 此处只注册了 Function,但未处理:
- AsyncFunction = (async () => {}).constructor
- GeneratorFunction = (function* () {}).constructor
- AsyncGeneratorFunction = (async function* () {}).constructor
这些构造器虽然不是 globalThis 的属性,但可通过函数实例的 .constructor 获取,且其行为与 Function 完全等效,当沙箱代码执行 (async () => {}).constructor 时,Proxy 拦截器会得到一个对 AsyncFunction 的引用,并尝试在 evals 中查找。由于 evals.has(AsyncFunction) === false,拦截器直接返回原始的宿主 AsyncFunction 构造器
在 SandboxExec.ts 中,静态属性 SAFE_GLOBALS 定义了沙箱内允许访问的全局对象:
static get SAFE_GLOBALS(): IGlobals {
return {
Function, // ← 这里直接暴露了宿主的 Function 构造器!
// ... 其他安全 API
};
}- 构造器映射(evals Map):将 Function → sandboxFunction
- Proxy 拦截:当访问 (function(){}).constructor 时,返回映射后的值
Proxy 的 get 拦截器未处理未知构造器
// 推断逻辑
if (prop === 'constructor') {
const ctor = target.constructor;
return evals.has(ctor) ? evals.get(ctor) : ctor; // ← 返回原始 ctor!
}当 ctor 是 AsyncFunction 时,evals.has(ctor) === false,于是返回原始构造器
export interface IEvalContext {
sandboxFunction: typeof sandboxFunction;
sandboxedEval: typeof sandboxedEval;
sandboxedSetTimeout: typeof sandboxedSetTimeout;
sandboxedSetInterval: typeof sandboxedSetInterval;
lispifyFunction: typeof lispifyFunction;
}
export type SandboxFunction = (code: string, ...args: string[]) => () => unknown;
export type SandboxEval = (code: string) => unknown;
export type SandboxSetTimeout = (
handler: TimerHandler,
timeout?: number,
...args: unknown[]
) => any;
export type SandboxSetInterval = (
handler: TimerHandler,
timeout?: number,
...args: unknown[]
) => any;
export function createEvalContext(): IEvalContext {
return {
sandboxFunction,
sandboxedEval,
sandboxedSetTimeout,
sandboxedSetInterval,
lispifyFunction,
};
}sandboxFunction 是沙箱提供的安全函数构造器(如 createFunctionAsync)。
- 设计意图:所有动态代码创建必须通过此函数,以便:
- 检查 forbidFunctionCreation
- 验证 prototypeWhitelist
- 注册到 sandboxFunctions WeakMap
- 受限于 ticks 执行预算
- 漏洞关联:由于 evals 未覆盖所有构造器,可以完全绕过 sandboxFunction,直接使用宿主构造器,使上述所有安全检查失效。
export function createFunctionAsync(
argNames: string[],
parsed: Lisp[],
ticks: Ticks,
context: IExecContext,
scope?: Scope,
name?: string
) {
if (context.ctx.options.forbidFunctionCreation) {
throw new SandboxError('Function creation is forbidden');
}
if (!context.ctx.prototypeWhitelist?.has(Promise.prototype)) {
throw new SandboxError('Async/await not permitted');
}
let func;
if (name === undefined) {
func = async (...args: unknown[]) => {
const vars = generateArgs(argNames, args);
const res = await executeTreeAsync(
ticks,
context,
parsed,
scope === undefined ? [] : [new Scope(scope, vars)]
);
return res.result;
};
} else {
func = async function sandboxedObject(this: Unknown, ...args: unknown[]) {
const vars = generateArgs(argNames, args);
const res = await executeTreeAsync(
ticks,
context,
parsed,
scope === undefined ? [] : [new Scope(scope, vars, this)]
);
return res.result;
};
}
context.registerSandboxFunction(func);
sandboxedFunctions.add(func);
return func;
}此函数是沙箱内创建异步函数
- 包含关键安全检查:
- forbidFunctionCreation:禁止动态函数创建
- prototypeWhitelist:控制是否允许 async/await
攻击者使用宿主 AsyncFunction 时,完全跳过此函数,导致:
- 即使 forbidFunctionCreation=true,仍可创建函数
- 即使未授权 Promise.prototype,仍可使用 async/await
- 创建的函数不在 sandboxFunctions 中注册,无法被追踪或撤销
- 不受 ticks 限制,可无限执行
漏洞修复
官方修复:
src/utils.ts:注册 AsyncFunction 到沙箱映射表

新增代码:
export const AsyncFunction: Function = Object.getPrototypeOf(async function() {}).constructor;这行代码安全地获取宿主环境中的 AsyncFunction 构造器,async function() {} 是一个异步函数表达式,其原型是 AsyncFunction.prototype,再往上就是 AsyncFunction 构造器本身。
在 createExecContext 中注册映射
const func = evalContext.sandboxFunction(execContext);
const asyncFunc = evalContext.sandboxAsyncFunction(execContext);
evals.set(Function, func);
evals.set(AsyncFunction, asyncFunc); // ← 新增这一行现在,当沙箱内代码访问 (async () => {}).constructor 时,executor.ts 在解析 .constructor 属性后,会查到这个值等于 AsyncFunction。由于 evals 映射表中已将 AsyncFunction → asyncFunc(即 sandboxAsyncFunction),返回的是沙箱化的版本,而非原始构造器。阻止了攻击者获取原始 AsyncFunction
src/eval.ts:实现 sandboxAsyncFunction

export type SandboxAsyncFunction = (code: string, ...args: string[]) => () => Promise<unknown>;
export function sandboxAsyncFunction(context: IExecContext, ticks?: Ticks): SandboxAsyncFunction {
return SandboxAsyncFunction;
function SandboxAsyncFunction(...params: string[]) {
const code = params.pop() || ' ';
const parsed = parse(code);
return createFunctionAsync(
params,
parsed.tree,
ticks || currentTicks.current,
{
...context,
constants: parsed.constants,
tree: parsed.tree,
},
undefined,
'anonymous'
);
}
}这个函数模仿了 sandboxFunction 的行为,但调用的是 createFunctionAsync(异步版本的函数生成器)。它确保通过 new AsyncFunction(...)(在沙箱内被重定向为此函数)创建的函数:在沙箱上下文中执行,受 tick 限制(防死循环),无法访问宿主全局作用域
SandboxJS ≤0.8.25 因未沙箱化 AsyncFunction 等构造器,攻击者可通过 .constructor 获取原生构造器实现沙箱逃逸。
由 AI 根据全文自动生成,仅供参考,以原文为准