漏洞来源

一个满评分的沙箱逃逸漏洞

漏洞描述

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
  };
}
  1. 构造器映射(evals Map):将 Function → sandboxFunction
  2. 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 限制(防死循环),无法访问宿主全局作用域