使用AFL++-QEMU和libprotobuf进行高级二进制模糊测试——语法感知+内存持久模糊测试的实例

发表于 |

Binary-only fuzzing 的一些常见问题

QEMU是AFL++支持的后端之一，用于Binary-only的模糊测试，这是通过patch QEMU来执行原始二进制文件，以收集覆盖率信息。

此外，针对QEMU模式，可以配置不同的环境比那里来优化模糊测试的性能和覆盖率。

插桩相关：

  • AFL_INST_LIBS：设置 AFL_INST_LIBS 会导致qemu翻译器对任何动态链接库中的代码进行插桩（特别是包括glibc在内的库）。比如设置AFL_INST_LIBS=1即可。
  • AFL_QEMU_INST_RANGES：您可以使用 AFL_QEMU_INST_RANGES=0xaaaa-0xbbbb,0xcccc-0xdddd 来仅插桩特定的内存位置，或者是特定的库 ，值得注意的是排除范围优先于包含范围的变量的。

变异相关：

  • AFL_CUSTOM_MUTATOR_LIBRARY，这个设置自定义的共享库路径，一般里面实现了afl_custom_fuzz()去生成样本
  • AFL_CUSTOM_MUTATOR_ONLY，假如这个设置了，就只是用上面的库进行变异，其他默认的变异策略都不使用

执行相关：

  • AFL_ENTRYPOINT：允许您指定二进制文件的特定入口点（这对性能非常有好处！）。入口点以十六进制地址的形式指定，例如， 0x4004110 。请注意，地址必须是基本块的地址。
  • AFL_QEMU_PERSISTENT_ADDR：当目标为i386/x86_64时，可以使用 AFL_QEMU_PERSISTENT_ADDR=start addr 指定需要执行persistent loop的函数地址。
  • AFL_QEMU_PERSISTENT_HOOK：（persistent hook）会在每次持久迭代（在START处开始）执行一个在共享对象中定义的函数，您可以通过指定AFL_QEMU_PERSISTENT_HOOK=/path/to/hook.so来指定共享对象的路径。
  • AFL_DISABLE_TRIM ：设置 AFL_DISABLE_TRIM 告诉 afl-fuzz 不要修剪测试用例。这通常是一个坏主意！
  • AFL_DEBUG：会将二进制文件的入口点打印到stderr。如果您不确定入口点是否正确，请使用此选项。但直接使用，例如 afl-qemu-trace ./program 。
  • AFL_DEBUG_CHILD ：设置 AFL_DEBUG_CHILD 这样可以看到子进程的所有输出，从而更好地发现问题。

从理论到实践有时看起来很乏味，经常会引发一些反复出现的问题，比如：

  • 我们希望插桩到哪些代码
  • 模糊测试的入口点的最佳选择是什么
  • 移动入口点对于测试用例的格式产生什么影响
  • 如何利用afl++提供的环境变量，提高fuzzing的性能

学习示例

一个简单的X509解析器

这是一个二进制文件，它接收一个文件名作为输入，并尝试解析相应文件的内容作为X509证书。

学习示例源码：https://github.com/airbus-seclab/AFLplusplus-blogpost/tree/main/src

main函数：调用init初始化，之后将文件作为参数传递给parse_cert函数
parse_cert函数：调用read_file函数读取文件，之后调用base64_decode进行文件解码，最后调用parse_cert_buf
parse_cert_buf函数：使用openssl库的d2i_X509进行解析，尝试获取CN并打印。

注：在证书中，”CN” 代表 “Common Name”，即 “通用名称”。它是用于标识证书（如SSL证书）所关联的实体（例如网站、服务器等）的一个字段。通常情况下，CN字段会包含一个域名（或者IP地址），用于指示证书所属的主体实体的名称。在SSL证书中，CN字段通常用于验证证书是否与访问的域名匹配，以确保通信的安全性。

原作者故意在函数中留了一个缓冲区溢出漏洞：strcpy(cn, subj); // Oops

1
2
3
4
5
6
7
8
9
10
11
int parse_cert_buf(const unsigned char *buf, size_t len) {
    X509 *cert;
    char cn[MAX_CN_SIZE];

    cert = d2i_X509(NULL, &buf, len);
    ...
    char *subj = X509_NAME_oneline(X509_get_subject_name(cert), NULL, 0);
    strcpy(cn, subj);  // Oops
    printf("Got CN='%s' from certificate\n", cn);
    ...
}

而且作者在主函数的开头故意添加了一个虚拟的 init 函数，以模拟一个初始化阶段，这会花费一些时间并使目标变得缓慢启动，不过才usleep50毫秒。

探索目标

在现实生活中，目标显然不像我们上面的X509解析器那样简单。事实上，对于一个只有二进制文件没有源码的目标进行有效的模糊测试，总是要先进行逆向工程，一般有以下阶段：

  1. 了解目标，它的工作原理，以及它与环境的交互等
  2. 找到有趣的特征进行研究
  3. 寻找可能成为模糊测试目标的函数
  4. 分析上下文、结构体、用户可控的参数等
  5. 构建一个harness，以适当的参数和模糊输入调用目标函数
  6. 生成或者收集一个初始语料库，以启动模糊测试

由于上面的示例比较简单，所以不需要花太长时间来找到易受攻击的代码、调用追踪并确定感兴趣的函数就是parse_cert_buf

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
int __cdecl main(int argc, const char **argv, const char **envp)
{
  if ( argc == 2 )
  {
    init((__int64)argv[1]);
    return parse_cert((__int64)argv[1]);
  }
  else
  {
    puts("Usage: ./target <file path>");
    return 1;
  }
}
__int64 __fastcall parse_cert(__int64 a1)
{
  __int64 result; // rax
  int v2; // eax

  result = read_file(a1, &state[1], &state[513]);
  if ( !(_DWORD)result )
  {
    v2 = base64_decode(&state[1], LODWORD(state[513]));
    LODWORD(state[513]) = v2;
    if ( v2 < 0 )
    {
      puts("Failed to decode base64 data");
      return 1LL;
    }
    else
    {
      return parse_cert_buf((__int64)&state[1], v2);
    }
  }
  return result;
}

Corpus 语料库

需要收集目标程序期望的输入格式的文件，由于示例是一个证书解析器，那就可以用openssl生成一个证书：

1
$ openssl req -nodes -new -x509 -keyout key.pem -out cert.pem
1
2
3
4
5
6
7
8
9
10
11
12
这个命令是使用OpenSSL工具生成自签名的RSA密钥对和X.509数字证书文件的命令。下面是对每个选项的解释：

openssl: OpenSSL工具的命令。
req: 指定要执行证书请求相关操作。
-nodes: 不使用加密对私钥进行保护，也就是不使用密码短语对私钥文件进行加密。
-new: 创建新的证书请求。
-x509: 创建自签名的X.509数字证书。
-keyout key.pem: 指定将生成的私钥保存到key.pem文件中。
-out cert.pem: 指定将生成的证书保存到cert.pem文件中。
执行此命令后，OpenSSL将生成一个新的RSA密钥对，并使用该密钥对生成一个自签名的X.509证书。私钥将保存在key.pem文件中，证书将保存在cert.pem文件中。这对密钥和证书可以用于各种加密和身份验证场景，如HTTPS通信或客户端身份验证等。

请注意，在实际使用中，生成的自签名证书由于没有经过受信任的第三方机构的签名，可能会在某些情况下被一些应用程序或服务器拒绝。因此，在生产环境中，通常会使用由受信任的证书颁发机构（CA）签署的证书。

作者把—–BEGIN CERTIFICATE—–和—–END CERTIFICATE—–以及前后空格给去掉当作

预处理语料库

在使用这个语料库之前，我们可以进行预处理

  1. 只保留不同执行路径的输入样本（使用 afl-cmin ）
  2. 尽量减小每个输入样本的大小，以保留其独特的执行路径，同时使其尺寸尽可能小（使用 afl-tmin ）。这将使变异更加有效，因为文件样本小了。

作者将其写成了脚本build_corpus.sh：先进行cmin，再缩减样本大小tmin

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
#!/bin/bash
FUZZ_DIR=`dirname $(realpath -s $0)`
source "$FUZZ_DIR/afl_config.sh"

in_path="$FUZZ_DIR/corpus"
out_path="$corpus_path"

if [ -d "$out_path" ]
then
  echo "$out_path alread exists, aborting"
  exit 1
fi

"$afl_path"/afl-cmin -Q -i "$in_path" -o "$out_path" -- "$target_path" @@

if [ -d "$out_path" ]
then
  cd "$out_path"
  for i in *; do
    "$afl_path"/afl-tmin -Q -i "$i" -o "$i".min -- "$target_path" @@
    rm "$i"
  done
else
  echo "afl-cmin failed, aborting"
fi

其中afl_config.sh 文件如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
$ cat afl_config.sh 
FUZZ_DIR=`dirname $(realpath -s $0)`

## Paths

export BASEPATH=`dirname $FUZZ_DIR`
export afl_path="$BASEPATH/AFLplusplus"
export corpus_path="$FUZZ_DIR/corpus_unique"
export output_path="$FUZZ_DIR/output"
export target_path="$BASEPATH/src/target"

## Debug

#export AFL_NO_UI=1
#export AFL_DEBUG=1
#export AFL_DEBUG_CHILD=1

export AFL_SKIP_CPUFREQ=1
export AFL_I_DONT_CARE_ABOUT_MISSING_CRASHES=1

#export AFL_BENCH_UNTIL_CRASH=1

插桩

默认设置（step 0）

通过默认的形式启动AFL++的QEMU模式，目标的所有基本块都被插桩，共享库不包含在插桩中。

1
2
3
4
5
#!/bin/bash
FUZZ_DIR=`dirname $(realpath -s $0)`
source "$FUZZ_DIR/afl_config.sh"

"$afl_path"/afl-fuzz -Q -i "$corpus_path" -o "$output_path" -- "$target_path" @@

我们可以在下面的不断优化中查看执行速度的变化

在我的机器上，这个默认模式，速度大概是18每秒

插桩调优（step 1）

对于插桩的调优，可能有以下原因：

  • 对于导入库的覆盖路径情况感兴趣
  • 要排除已经进行过安全测试的库的特定部分
  • 对整个库的二进制文件进行插桩可能会降低执行速度

如果需要调优，可有下面变量可用

  • AFL_INST_LIBS
  • AFL_QEMU_INST_RANGES
  • AFL_CODE_START
  • AFL_CODE_END

在上面证书解析的例子中，parse_cert_buf 的插桩很重要，但是对于main的插桩就不那么相关了，还有共享库libssl.so

我们可以通过AFL_QEMU_INST_RANGES来将插桩限制在想要关注的函数上，即parse_cert_buf的第一条指令到最后一条指令

注意：可以使用 AFL_CODE_START 和 AFL_CODE_END 来完成这个操作。然而， AFL_QEMU_INST_RANGES 更加灵活，因为它允许指定多个范围进行插桩。

作者写好了脚本来设置

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
# The base address at which QEMU loads our binary depends on the target
# See https://github.com/AFLplusplus/AFLplusplus/blob/stable/qemu_mode/README.persistent.md#21-the-start-address
case $(file "$target_path") in
  *"statically linked"*)
    QEMU_BASE_ADDRESS=0
    ;;
  *"32-bit"*)
    QEMU_BASE_ADDRESS=0x40000000
    ;;
  *"64-bit"*)
    QEMU_BASE_ADDRESS=0x4000000000
    ;;
  *) echo "Failed to guess QEMU_BASE_ADDRESS"; exit 1
esac

# We use objdump to parse our target binary and obtain the address and size of a given function
function find_func() {
    objdump -t "$target_path" | awk -n /"$1"'$/{print "0x"$1, "0x"$5}'
}

# Some environment variables for AFL++ must be hex encoded
function hex_encode() {
    printf "0x%x" "$1"
}

read fuzz_func_addr fuzz_func_size < <(find_func "parse_cert_buf")
inst_start=$(hex_encode $(("$QEMU_BASE_ADDRESS" + "$fuzz_func_addr")))
inst_end=$(hex_encode $(("$inst_start" + "$fuzz_func_size")))
export AFL_QEMU_INST_RANGES="$inst_start-$inst_end"

inst_start就是QEMU_BASE_ADDRESS+函数文件内偏移
inst_end就是函数文件内偏移+函数大小

作者给的find_func函数有点难理解，下面的其实更好理解，双引号是正则匹配，后面是输出规则

1
2
3
function find_func() {
    objdump -t "$target_path" | awk -n "/$1$/"'{print "0x"$1, "0x"$5}'
}

可以使用下面的更简单

1
objdump -t "$target_path" | grep $1 | awk '{print "0x"$1, "0x"$5}'

上面脚本可添加echo $fuzz_func_addr $fuzz_func_size可以输出获取的值，看看是否正确

1
2
$ ./find_func.sh parse_cert_buf
0x0000000000001550 0x000000000000010c

之后启动afl的时候，通过启用AFL++-QEMU的调试模式（ AFL_DEBUG ），我们可以检查插桩范围是否与我们设置的一样

1
2
3
4
$ AFL_DEBUG=1 ./fuzz.sh | grep Instrument 
AFL forkserver entrypoint: 0x4000001320
AFL forkserver entrypoint: 0x4000001320
Instrument range: 0x4000001550-0x400000165c (<noname>)

Entrypoint 入口点（step 2）

在模糊测试时，AFL++会运行目标程序直到达到特定地址（AFL入口点），然后从该地址fork进行每一次迭代。默认情况下，AFL入口点被设置为目标程序的入口点（在我们的示例中， target 的 _start 函数）。

1
2
3
$ AFL_DEBUG=1 ./fuzz.sh | grep entrypoint
AFL forkserver entrypoint: 0x4000001320
AFL forkserver entrypoint: 0x4000001320

可以看到，确实是1320偏移

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
.text:0000000000001320                 public _start
.text:0000000000001320 _start          proc near               ; DATA XREF: LOAD:0000000000000018↑o
.text:0000000000001320 ; __unwind {
.text:0000000000001320                 endbr64
.text:0000000000001324                 xor     ebp, ebp
.text:0000000000001326                 mov     r9, rdx         ; rtld_fini
.text:0000000000001329                 pop     rsi             ; argc
.text:000000000000132A                 mov     rdx, rsp        ; ubp_av
.text:000000000000132D                 and     rsp, 0FFFFFFFFFFFFFFF0h
.text:0000000000001331                 push    rax
.text:0000000000001332                 push    rsp             ; stack_end
.text:0000000000001333                 lea     r8, __libc_csu_fini ; fini
.text:000000000000133A                 lea     rcx, __libc_csu_init ; init
.text:0000000000001341                 lea     rdi, main       ; main
.text:0000000000001348                 call    cs:__libc_start_main_ptr
.text:000000000000134E                 hlt
.text:000000000000134E ; } // starts at 1320
.text:000000000000134E _start          endp

在某些情况下（如我们的示例中），程序的初始化阶段可能需要一些时间。由于每次迭代都要进行初始化，这直接影响了模糊测试的速度。这正是 AFL_ENTRYPOINT 选项旨在解决的情况。

这样的话我们可以跳过初始化阶段，直达AFL_ENTRYPOINT 地址，停在AFL_ENTRYPOINT地址与fuzzer同步，让fuzzer对目标进行快照，之后便可有在AFL_ENTRYPOINT之后继续执行。

对于上面的例子，init函数是确定性的，也无需模糊测试，所以可以将AFL_ENTRYPOINT 设置为 parse_cert

parse_cert是1550偏移

1
2
$ ./find_func.sh parse_cert
0x0000000000001660 0x0000000000000063

通过AFL_ENTRYPOINT环境变量设置一下即可

1
2
read fuzz_func_addr fuzz_func_size < <(find_func "parse_cert")
export AFL_ENTRYPOINT=$(hex_encode $(("$QEMU_BASE_ADDRESS" + "$fuzz_func_addr")))

可以看到确实更改了入口点

查看现在的速度，已经提升到600+，原始作者更牛逼，直接1000+，估计他的cpu性能更好

Persistence

Persistent mode（step3）

“持久模式”是AFL++的一个功能，允许它在每次迭代时避免调用 fork 。相反，它会在子进程到达特定地址（ AFL_QEMU_PERSISTENT_ADDR ）时保存其状态，并在到达另一个地址（ AFL_QEMU_PERSISTENT_RET ）时恢复该状态。

注意：如果没有设置 AFL_QEMU_PERSISTENT_RET ，可以使用 AFL_QEMU_PERSISTENT_RETADDR_OFFSET 。如果没有设置这些值，AFL++将在到达第一个 ret 指令时停止（仅当 AFL_QEMU_PERSISTENT_ADDR 指向函数的起始位置时，否则必须手动设置该值）。

“恢复”状态可能意味着“恢复寄存器”（ AFL_QEMU_PERSISTENT_GPR ）和/或“恢复内存”（ AFL_QEMU_PERSISTENT_MEM ）。由于恢复内存状态的成本较高，只有在必要时才应该进行；在模糊测试时，要关注稳定性值，以确定是否需要启用此功能。

使用 AFL_QEMU_PERSISTENT_GPR=1，QEMU将保存通用寄存器的原始值，并在每个持久周期中恢复它们。

即使在使用持久模式时，AFL++ 仍会不时调用 fork （每 AFL_QEMU_PERSISTENT_CNT 次迭代，或默认为1000次）。如果稳定性足够高，增加此值可能会提高性能（最大值为10000）。

目标中循环越稳定，您可以运行的时间就越长；循环越不稳定，循环计数值就应该越低。一个较低的值可以是100，最大值应该为10000。默认值是1000。可以使用AFL_QEMU_PERSISTENT_CNT来设置此值。

以上面的例子为例

在上面的例子，以通过将 AFL_QEMU_PERSISTENT_ADDR 设置为与 AFL_ENTRYPOINT 相同的值（即 parse_cert 函数的地址）来开始。这样，AFL++将恢复进程到在读取输入文件内容之前的状态。

1
2
3
4
read fuzz_func_addr fuzz_func_size < <(find_func "parse_cert")
export AFL_QEMU_PERSISTENT_ADDR=$(hex_encode $(("$QEMU_BASE_ADDRESS" + "$fuzz_func_addr")))
export AFL_QEMU_PERSISTENT_GPR=1
export AFL_QEMU_PERSISTENT_CNT=10000

在这个例子中，稳定性保持在100%而无需恢复内存状态，因此我们只设置 AFL_QEMU_PERSISTENT_GPR 。我们还将 AFL_QEMU_PERSISTENT_CNT 增加到最大值，因为这不会对我们的稳定性产生负面影响。

下面可以看到Persistent也设置为1660偏移， gpr开启

1
2
3
4
5
6
$ AFL_DEBUG=1 ./fuzz.sh | grep Persistent
AFL forkserver entrypoint: 0x4000001660
AFL forkserver entrypoint: 0x4000001660
Instrument range: 0x4000001550-0x400000165c (<noname>)
Persistent: 0x4000001660 [0x0] gpr 
Debug: Sending status c201ffff

再看看此时的速度是接近6000，速度有了10倍增长

In-memory fuzzing（step 4）

尽管使用了持久模式，但在达到模糊函数之前，我们的目标仍然会执行一些不必要的操作，尤其是打开和读取由模糊器生成的文件的内容。

我们可以使用“内存模糊测试”来跳过这一步骤，直接从模糊测试器的内存中读取输入！

为了做到这一点，我们必须实施一个“hook’”。作者说这个源码比较简单，源码地址

定义了一个 afl_persistent_hook_init 函数，它声明了我们是否要使用内存模糊测试

1
2
3
4
5
int afl_persistent_hook_init(void) {
  // 1 for shared memory input (faster), 0 for normal input (you have to use
  // read(), input_buf will be NULL)
  return 1;
}

更有趣的是，我们定义了一个函数afl_persistent_hook，可以在每次迭代之前覆盖寄存器值和内存，就在达到 AFL_QEMU_PERSISTENT_ADDR 地址之前。我们所要做的就是覆盖包含要解析的缓冲区的内存，并在正确的寄存器中设置其长度。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define g2h(x) ((void *)((unsigned long)(x) + guest_base))
#define h2g(x) ((uint64_t)(x) - guest_base)

void afl_persistent_hook(struct x86_64_regs *regs, uint64_t guest_base, uint8_t *input_buf, uint32_t input_buf_len) {
  // Make sure we don't overflow the target buffer
  if (input_buf_len > 4096)
    input_buf_len = 4096;

  // Copy the fuzz data to the target's memory
  memcpy(g2h(regs->rdi), input_buf, input_buf_len);

  // Update the length
  regs->rsi = input_buf_len;
}

作者是受afl++的示例启发的： https://github.com/AFLplusplus/AFLplusplus/blob/stable/utils/qemu_persistent_hook/read_into_rdi.c

注意：您可以通过运行 gdb 并在目标函数的开始的地方中断，或直接查看反汇编代码来确定要使用的寄存器。

这个钩子应该被编译为一个共享库，AFL++将在运行时加载它。

要指示AFL++使用我们的hook，我们只需将 AFL_QEMU_PERSISTENT_HOOK 设置为我们 .so 文件的路径：

1
export AFL_QEMU_PERSISTENT_HOOK="$BASEPATH/src/hook/libhook.so"

要使用内存模糊测试，需要在迭代过程中跳过read_file的调用，需要修改 AFL_QEMU_PERSISTENT_ADDR ，这里有两个选项：

1、将AFL_QEMU_PERSISTENT_ADDR 设置为 base64_decode 的起始地址。在这种情况下，我们还要对 base64_decode 函数进行模糊测试；
2、或者我们将AFL_QEMU_PERSISTENT_ADDR 设置在 parse_cert_buf 。在这种情况下， base64_decode 将不会被测试。

由于 base64_decode 是由一个我们不想进行模糊测试的可信外部库实现的（在这种情况下是OpenSSL），我们将选择第二个选项。

因此，我们可以将 AFL_QEMU_PERSISTENT_ADDR 移动到 parse_cert_buf 的地址：

1
2
read fuzz_func_addr fuzz_func_size < <(find_func "parse_cert_buf")
export AFL_QEMU_PERSISTENT_ADDR=$(hex_encode $(("$QEMU_BASE_ADDRESS" + "$fuzz_func_addr")))

修改 AFL_QEMU_PERSISTENT_ADDR 对我们的语料库有影响。事实上，模糊测试器生成的缓冲区现在直接用于 parse_cert_buf （而不是传递给 base64_decode ）。这意味着我们需要重建我们的语料库。在我们的情况下，这很容易：我们只需要解码之前语料库中的base64文件，并将它们保存为原始二进制文件。

1
base64 -d test.cert.b64 > test.cert

这样我们不再从文件中读取数据，但是目标程序期望从一个文件中读取数据，否则它将立即退出。，所以我们需要创建一个空文件，传递给程序。

1
2
3
4
5
6
7
8
9
10
11
12
13
int __cdecl main(int argc, const char **argv, const char **envp)
{
  if ( argc == 2 )
  {
    init((__int64)argv[1]);
    return parse_cert((__int64)argv[1]);
  }
  else
  {
    puts("Usage: ./target <file path>");
    return 1;
  }
}

在Debug模式中也有successfully got fuzzing shared memory

1
2
3
4
5
6
7
8
$ AFL_DEBUG=1 ./fuzz.sh | grep  AFL
AFL forkserver entrypoint: 0x4000001660
AFL forkserver entrypoint: 0x4000001660
Instrument range: 0x4000001550-0x400000165c (<noname>)
Persistent: 0x4000001550 [0x0] gpr 
Debug: Sending status c301ffff
[D] DEBUG: calibration stage 1/7
[AFL] DEBUG: successfully got fuzzing shared memory

注意：由于执行速度并不是唯一重要的指标，当然你还应该关注其他指标，比如稳定性、新发现的路径、覆盖率等等。

语法感知的变异器（step 5）

动机

回顾一下我们迄今为止取得的成就：

  • 使用QEMU来设置AFL++来对一个仅有二进制文件的目标进行模糊测试
  • 配置了插桩范围，只覆盖相关的地址
  • 调整的AFL++的QEMU模式的入口点，并启用持久模式减少初始化时间，还改用了共享内存fuzzing

在大多数情况下，这样的配置足以运行成功模糊测试，尤其是与多处理器结合的时候。

然而，对于这个例子，我们还决定使用高度结构化的数据格式为输入进行模糊测试。

在这种情况下，引入新的方式来改变输入数据可能会很有趣。

确实，AFL++的另一个可调节的方面是生成和变异逻辑。AFL++内置了一组简单（但非常有效）的变异方法：

    • random bit flips; 随机位翻转；
  • random byte flips; 随机字节翻转；
  • arithmetics; 算术运算；
  • 等等

在大多数情况下，这些突变已足够用来探索代码进行模糊测试。但是某些数据格式具有内部约束，如果不满足这些约束，样本将被提前拒绝。

这就是ASN.1的情况，这是我们示例中使用的格式：如果在生成突变时不考虑这些约束，可能会导致大多数样本被目标系统立即丢弃为无效样本，从而无法实现任何增加的覆盖率。这意味着模糊测试活动需要一段时间才能收敛到相关的生成案例，影响fuzzing的效率或者直接导致毫无成果。

为了解决这种情况，AFL++允许用户提供自定义的变异器，以指导模糊测试工具生成更适合的输入。正如官方文档中所详细说明的那样，只要这个变异器实现了所需的API函数，就可以将其插入到AFL++中。

实施

有几种方法可以在AFL++中实现语法感知的变异器，其中之一是AFL++项目中的语法变异器。

然而，由于它不支持ASN.1，我们转而依赖于处理ASN.1的libprotobuf。

我们从官方文档和现有的框架中汲取灵感，构建了AFL++和我们自定义变异器之间的“粘合剂”。

最终实现为 custom_mutator.cpp

实现了以下来自AFL++ API的函数：

  • afl_custom_init ：初始化我们的自定义变异器；
  • afl_custom_fuzz ：使用我们的protobuf变异器来改变输入；
  • afl_custom_post_process ： 对突变数据进行后处理，以确保我们的目标接收到正确格式的输入；
  • afl_custom_deinit ： 清理一切。

输入格式

确实， afl_custom_post_process 函数发挥着重要的作用：我们的自定义变异器基于libprotobuf，因此需要protobuf数据作为输入。然而，我们的目标只能解析ASN.1数据，因此我们需要将数据从protobuf转换为ASN.1。幸运的是，protobuf变异器已经在 x509_certificate::X509CertificateToDER 中实现了这个功能。

以下是整个过程：

实际就是将输入通过afl_custom_fuzz进行变异，再通过afl_custom_post_process将数据从protobuf转换为ASN.1

和以前一样，我们需要调整我们语料库中文件的格式，以与我们的模糊测试工具相匹配。这一次，我们需要将我们的ASN.1 DER文件转换为protobuf格式。为此，我们实现了一个自定义脚本（asn1_to_protobuf.py）

应用于我们的例子

只需将 AFL_CUSTOM_MUTATOR_LIBRARY 设置为我们 .so 文件的路径

1
export AFL_CUSTOM_MUTATOR_LIBRARY="$BASEPATH/libmutator.so"

禁用了AFL++执行的所有默认变异和修剪操作

1
2
export AFL_DISABLE_TRIM=1
export AFL_CUSTOM_MUTATOR_ONLY=1

这一次，不是关于提高性能，而是关于深入探索更深层次的路径。在我们的例子中，这是一个非常小的目标，很难衡量这种影响。

然而，通常会通过比较覆盖范围并使用自定义变异器来检查是否达到了新的分支来完成此操作。

然而，您无需在使用自定义变异器和使用默认的AFL++变异器之间做出选择：通过运行多个模糊测试实例，您可以兼得两者的优点，我们将在下一步中讨论这个问题。

（from实践者：由于这个使用了谷歌的proto，编译出了点问题，暂时放弃这个的实践）

多进程（step 6）

这一步是我们将所有内容整合在一起来运行我们的实际模糊测试活动。实际上，在真实的活动中，你不会仅限于在一个核心/线程/机器上进行模糊测试。幸运的是，AFL++可以同时运行多个实例。

在同一台机器上，由于AFL++的设计方式，有一个最大的CPU核心/线程数量是有用的，使用更多的核心会导致整体性能下降。这个值取决于目标，限制在每台机器32到64个核心之间。

需要注意的是，即使在达到这个限制之前，性能的增加也不是成比例的（核心数量翻倍并不意味着每秒执行次数翻倍）：需要额外的开销来同步进程。

当运行多个模糊测试实例时，可以通过并行使用各种策略和配置来优化覆盖率。然而，由于该页面主要针对源代码可用的模糊目标，因此对于仅有二进制代码的模糊测试，需要进行一些调整。

Binary-only fuzzing的特殊性

当对源代码可用的目标进行模糊测试时，许多功能（例如ASAN、UBSAN、CFISAN、COMPCOV）需要使用特定选项重新编译目标。

尽管在处理二进制目标时重新编译不是一个选项，但是QEMU中仍然提供了一些这些功能

例如， AFL_USE_QASAN 可以使用 LD_PRELOAD 自动注入库来使用 ASAN 和 QEMU。同样， AFL_COMPCOV_LEVEL 可以在 QEMU 中使用 COMPCOV，无需重新编译目标。

下面的start_child用来启动子进程

1
2
3
4
5
6
7
children=()
function start_child() {
    eval "$@ > /dev/null 2>&1 &"
    child_pid="$!"
    echo "Started child with pid $child_pid and command line $@"
    children+=("$!")
}
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
# Run 1 afl-fuzz instance with CMPLOG (-c 0 + AFL_COMPCOV_LEVEL=2)
AFL_COMPCOV_LEVEL=2 start_child "'$afl_path/afl-fuzz' -Q -c 0 -S 'afl-compcov' -i '$corpus_path' -o '$output_path' -- '$target_path' /tmp/.afl_fake_input"

# Run 1 afl-fuzz instance with QASAN (AFL_USE_QASAN=1)
# We disable this for our example because it requires updating all addresses in
# afl_config.sh (and ensuring that ASLR is properly disabled on the host)
# If you want to use this, make sure to set QASAN_LOG=1 and QASAN_DEBUG=1, and
# change QEMU_BASE_ADDRESS in afl_config.sh to the value shown in the maps
AFL_USE_QASAN=1 start_child "'$afl_path/afl-fuzz' -Q -S 'afl-qasan' -i '$corpus_path' -o '$output_path' -- '$target_path' /tmp/.afl_fake_input"


# Run 1 afl-fuzz instance with LAF (AFL_PRELOAD=libcmpcov.so + AFL_COMPCOV_LEVEL=2)
AFL_COMPCOV_LEVEL=2 AFL_PRELOAD="$AFL_PRELOAD:$afl_path/libcompcov.so" start_child "'$afl_path/afl-fuzz' -Q -S 'afl-libcompcov' -i '$corpus_path' -o '$output_path' -- '$target_path' /tmp/.afl_fake_input"

# Run 1 afl-fuzz instance with the custom mutator
#AFL_DISABLE_TRIM="$_AFL_DISABLE_TRIM" AFL_CUSTOM_MUTATOR_ONLY="$_AFL_CUSTOM_MUTATOR_ONLY" AFL_CUSTOM_MUTATOR_LIBRARY="$_AFL_CUSTOM_MUTATOR_LIBRARY" start_child "'$afl_path/afl-fuzz' -Q -S 'afl-custom_mutator' -i '$protobuf_corpus_path' -o '$protobuf_output_path' -- '$target_path' /tmp/.afl_fake_input"

# Note: if you have enough cores left, you should run as many "regular"
# instances of afl-fuzz as possible here. For our example, it's not necessary
#for i in `seq 4 $(nproc)`; do  # Start at 4 since there are instances started separately
#    start_child "'$afl_path/afl-fuzz' -Q -S 'afl-$i' -i '$corpus_path' -o '$output_path' -- '$target_path' /tmp/.afl_fake_input"
#done

# Run main afl-fuzz instance
"$afl_path/afl-fuzz" -Q -M "afl-main" -i "$corpus_path" -o "$output_path" -- "$target_path" /tmp/.afl_fake_input

评估fuzzing

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
$ /AFLplusplus/afl-whatsup -s output/
/AFLplusplus/afl-whatsup status check tool for afl-fuzz by Michal Zalewski

Summary stats
=============

       Fuzzers alive : 3
      Total run time : 15 minutes, 0 seconds
         Total execs : 2 millions, 481 thousands
    Cumulative speed : 8269 execs/sec
       Average speed : 2756 execs/sec
       Pending items : 0 faves, 0 total
  Pending per fuzzer : 0 faves, 0 total (on average)
       Crashes saved : 3
Cycles without finds : 142/2938/554
  Time without finds : 5 minutes, 24 seconds

查看edges、crashes执行速度随实践变化的情况

1
2
3
4
5
6
7
8
$ /AFLplusplus/afl-plot output/afl-main /tmp/plot
progress plotting utility for afl-fuzz by Michal Zalewski

[*] Generating plots...
Warning: empty y range [23:23], adjusting to [22.77:23.23]
[?] You can also use -g flag to view the plots in an GUI window, and interact with the plots (if you have built afl-plot-ui). Run "afl-plot-h" to know more.
[*] Generating index.html...
[+] All done - enjoy your charts!

通过afl-showmap输出覆盖情况

1
2
3
"$afl_path/afl-showmap" -Q -C -i "$output_path"/afl-main/queue/ -o afl-main.cov -- "$target_path" /tmp/.afl_fake_input
"$afl_path/afl-showmap" -Q -C -i "$output_path"/afl-compcov/queue/ -o afl-compcov.cov -- "$target_path" /tmp/.afl_fake_input
"$afl_path/afl-showmap" -Q -C -i "$output_path"/afl-libcompcov/queue/ -o afl-libcompcov.cov -- "$target_path" /tmp/.afl_fake_input

对于崩溃的文件

一旦AFL++识别出崩溃或卡死，它将把触发它的输入保存在您的输出目录中的一个专用文件夹中，以便您可以重现它。

下面是一些有用的工具：

  • afl-tmin： 重现崩溃的最小测试用例
  • Lighthouse: 探索特定样本的覆盖范围
  • 使用Valgrind来调查内存问题；

From

https://airbus-seclab.github.io/AFLplusplus-blogpost/

打赏专区
paypal: https://www.paypal.me/giantbranch
假如你看不到评论，可能是你访问Disqus被墙了，请使用代理访问