# forkserver 的目的

参见 lcamtuf.blogspot
如果每次由 fuzzer 来进行 fork-execve 那么每次目标程序都得进装载器链接器和动态加载库打一套 十分浪费时间。
但是 如果我们劫持了目标程序的_start 让目标程序一开始执行我们写入的 forkserver 代码,这样就能在装载之后通过 COW 实现低成本的 fork。
也就是 forkserver 本身就注入到目标程序里面去了,作为目标程序的起始点不断的进行 fork。

# trampoline

这个被插桩到每个基本块之前

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
static const u8* trampoline_fmt_64 =

"\n"
"/* --- AFL TRAMPOLINE (64-BIT) --- */\n"
"\n"
".align 4\n"
"\n"
"leaq -(128+24)(%%rsp), %%rsp\n"
"movq %%rdx, 0(%%rsp)\n"
"movq %%rcx, 8(%%rsp)\n"
"movq %%rax, 16(%%rsp)\n"
"movq $0x%08x, %%rcx\n"
"call __afl_maybe_log\n"
"movq 16(%%rsp), %%rax\n"
"movq 8(%%rsp), %%rcx\n"
"movq 0(%%rsp), %%rdx\n"
"leaq (128+24)(%%rsp), %%rsp\n"
"\n"
"/* --- END --- */\n"
"\n";
  1. 将当前 rsp 下降 (128+24)
  2. rdx rcx rax 分别保存在 rsp 上面一丢丢
  3. R(MAP_SIZE) 这个随机数 (0-65535) 给到 rcx 调用__afl_maybe_log (这个随机数是基本块标号,编译时确定)

# main_payload_64

这个主要是注入大量函数逻辑

# __afl_maybe_log

1
2
3
4
5
6
7
8
"__afl_maybe_log:\n"
" lahf\n"
" seto %al\n"

" movq __afl_area_ptr(%rip), %rdx\n"
" testq %rdx, %rdx\n"
" je __afl_setup\n"
"__afl_store:\n"
  • lahf : load to ah from eflags
  • seto : set to 1 if target byte overflow
  • 如果 __afl_area_ptr 里没有东西 就跳转到 __afl_setup (setup 属于共享内存没被初始化的情况,第一次 if 才会走到里面去)
  • 否则就进行 __afl_store
    其中 __afl_area_ptr 是共享内存的指针 attach 上 fuzzer 创建的。

# __afl_store

1
2
3
4
5
6
7
8
9
10
"__afl_store:\n"
" xorq __afl_prev_loc(%rip), %rcx\n"
" xorq %rcx, __afl_prev_loc(%rip)\n"
" shrq $1, __afl_prev_loc(%rip)\n"
" incb (%rdx, %rcx, 1)\n"

"__afl_return:\n"
" addb $127, %al\n"
" sahf\n"
" ret\n"

为了验证这个原理,上 gdb 调试一下,随便编译一个函数 打断点在 log 那 然后由于通信建立不起来 需要改 prev loc 的内存

1
2
3
4
gef➤  set {int}&__afl_area_ptr=1
gef➤ x/4gx &__afl_area_ptr
0x4040a0 <__afl_area_ptr>: 0x0000000000000001 0x0000000000000001
0x4040b0 <__afl_fork_pid>: 0x0000000000000000 0x0000000000000001

然后

1
2
3
4
→   0x4017a0 <__afl_store+0>  xor    rcx, QWORD PTR [rip+0x2901]        # 0x4040a8 <__afl_prev_loc>
0x4017a7 <__afl_store+7> xor QWORD PTR [rip+0x28fa], rcx # 0x4040a8 <__afl_prev_loc>
0x4017ae <__afl_store+14> shr QWORD PTR [rip+0x28f3], 1 # 0x4040a8 <__afl_prev_loc>
0x4017b5 <__afl_store+21> inc BYTE PTR [rdx+rcx*1]

其实就是 __afl_prev_loc = __afl_prev_loc ^ rcx ^ __afl_prev_loc = rcx 就是一个赋值的 trick
rcx 是这一块地址的标号 在操作之后变成了 上一块地址标号 ^ 当前本块地址标号、
上一块地址标号变成了 本块地址标号 >> 1。
rdx __afl_area_ptr(%rip), %rdx 就是共享内存指针了。

1
2
3
cur_location = <COMPILE_TIME_RANDOM>;
shared_mem[cur_location ^ prev_location]++;
prev_location = cur_location >> 1;

右移是为了区分 A -> B or B -> A or X -> X.

# __afl_setup

最重要的部分就是这个 shmat 的调用,attach 到 fuzzer 里 setup 的 shm
共享内存指针保存在 __afl_area_ptr

1
2
3
4
5
6
7
8
9
10
11
12
13
"\n"
" xorq %rdx, %rdx /* shmat flags */\n"
" xorq %rsi, %rsi /* requested addr */\n"
" movq %rax, %rdi /* SHM ID */\n"
CALL_L64("shmat")
"\n"
" cmpq $-1, %rax\n"
" je __afl_setup_abort\n"
"\n"
" /* Store the address of the SHM region. */\n"
"\n"
" movq %rax, %rdx\n"
" movq %rax, __afl_area_ptr(%rip)\n"

# __afl_forkserver

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
"__afl_forkserver:\n"

" pushq %rdx\n"
" pushq %rdx\n"

" movq $4, %rdx /* length */\n"
" leaq __afl_temp(%rip), %rsi /* data */\n"
" movq $" STRINGIFY((FORKSRV_FD + 1)) ", %rdi /* file desc */\n"
CALL_L64("write")

" cmpq $4, %rax\n"
" jne __afl_fork_resume\n"

"__afl_fork_wait_loop:\n"

" movq $4, %rdx /* length */\n"
" leaq __afl_temp(%rip), %rsi /* data */\n"
" movq $" STRINGIFY(FORKSRV_FD) ", %rdi /* file desc */\n"
CALL_L64("read")

" cmpq $4, %rax\n"
" jne __afl_die\n"
"\n"
  1. 存入两次 __afl_area_ptr 的指针
  2. STRINGIFY ((FORKSRV_FD + 1)) 就是 # stringify
  3. 先写信息给 fuzzer 中去(写什么应该关系不大 就代表着来信息了)
  4. 然后从 forkserver 中读取 fuzzer 传输来的控制信息到 __afl_temp
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
CALL_L64("fork")
" cmpq $0, %rax\n"
" jl __afl_die\n"
" je __afl_fork_resume\n"

" movl %eax, __afl_fork_pid(%rip)\n"

" movq $4, %rdx /* length */\n"
" leaq __afl_fork_pid(%rip), %rsi /* data */\n"
" movq $" STRINGIFY((FORKSRV_FD + 1)) ", %rdi /* file desc */\n"
CALL_L64("write")

" movq $0, %rdx /* no flags */\n"
" leaq __afl_temp(%rip), %rsi /* status */\n"
" movq __afl_fork_pid(%rip), %rdi /* PID */\n"
CALL_L64("waitpid")

" cmpq $0, %rax\n"
" jle __afl_die\n"

" movq $4, %rdx /* length */\n"
" leaq __afl_temp(%rip), %rsi /* data */\n"
" movq $" STRINGIFY((FORKSRV_FD + 1)) ", %rdi /* file desc */\n"
CALL_L64("write")

" jmp __afl_fork_wait_loop\n"
  • fork 出目标程序的子进程 跳转到 __afl_fork_resume
  • 对于 forkserver 本 f,保存子进程 pid 到 __afl_fork_pid
  • 然后写给 fuzzer
  • waitpid 等待子进程结束
  • 结束后吧 status 写回给 fuzzer,跳转回 __afl_fork_wait_loop

# __afl_fork_resume

这里主要是 由 forkserver fork 出来的 child 是要执行目标进程的,就需要恢复由于执行 forkserver 而压入的上下文以及关掉两个通信的文件描述符。
所以这里就是简单的恢复上下文,关闭,执行正常逻辑代码。

# summary

个人画的总结图,还可以吧?