fuzz实战之afl
安全脉搏SecPulse.Com独家发文，如需转载，请先联系授权。
像 libFuzzer, afl 这类 fuzz 对于 从文件 或者 标准输入 获取输入的程序都能进行很好的 fuzz, 但是对于基于网络的程序来说就不是那么方便了。
这篇文章介绍用 afl 来 fuzz 网络应用程序。
afl 是一个非常厉害的 fuzz，最近几年炒的火热。它是基于代码插桩来生成测试用例，这样生成的样本就比较的好，而且针对 linux 做了许多性能优化使得速度也非常快。
使用 afl 的常规步骤
如果有源码，用 afl-gcc 或者 afl-clang-fast 编译源码，afl 会利用这些工具在编译期间对代码进行插桩，为后面的测试提供代码覆盖率，测试样本的变异则会基于代码覆盖率进行。无源码的话可以使用 qemu 进行插桩
搜集好 初始样本集，如果必要的话使用 afl-cmin 把样本集进行精简。
然后用 afl-fuzz 开始 fuzz.
下面对一些常见的命令给个示例
精简样本集
afl-cmin -i in/ -o out/ /path/to/program
in/是初始样本集目录
out/是 精简后的样本集存放的目录
开启 fuzz
afl-fuzz -i in/ -o out/ /path/to/program
in/是初始样本集目录
out/用于保存fuzz过程中的一些文件
afl-fuzz 默认是往 stdin 中写测试数据，它同时支持从文件喂 测试数据给目标程序，只要把设置文件的参数修改为 @@ ， fuzz 过程中 afl-fuzz会把它替换成 文件名。
比如 ./a 这个程序的 第二个参数是要处理的文件的名称， 那么相应的 afl-fuzz 的命令就是
afl-fuzz -i in/ -o out/ ./a arg1 @@
更多内容请看
http://lcamtuf.coredump.cx/afl/QuickStartGuide.txt http://lcamtuf.coredump.cx/afl/README.txt
这里以 libmodbus 这个库为目标进行 fuzz 。
库的官网地址如下
http://libmodbus.org/documentation/
这是一个用于 modbus 通讯的库， 通过这个库可以很方便的实现 modbus 服务器 和 客户端。 这里以 modbus tcp 的服务端作为 fuzz 的对象。
首先在官网下载好源码
http://libmodbus.org/releases/libmodbus-3.1.4.tar.gz
源码目录下的 tests 目录里面有一些示例程序， 其中 tests/bandwidth-server-one.c 就实现了一个 modbus tcp server ， 把它做一些精简得到
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <modbus.h>
int main(int argc, char *argv[])
{
int s = -1;
modbus_t *ctx = NULL;
modbus_mapping_t *mb_mapping = NULL;
int rc;
int use_backend;
ctx = modbus_new_tcp("127.0.0.1", 1502);
s = modbus_tcp_listen(ctx, 1);
modbus_tcp_accept(ctx, &s);
mb_mapping = modbus_mapping_new(MODBUS_MAX_READ_BITS, 0,
MODBUS_MAX_READ_REGISTERS, 0);
if (mb_mapping == NULL) {
modbus_free(ctx);
return -1;
}
uint8_t query[MODBUS_TCP_MAX_ADU_LENGTH];
memset(query, 0, MODBUS_TCP_MAX_ADU_LENGTH);
rc = modbus_receive(ctx, query); // 获取客户端的请求数据
if (rc > 0) {
modbus_reply(ctx, query, rc, mb_mapping); // 处理并响应之
}
modbus_mapping_free(mb_mapping);
if (s != -1) {
close(s);
}
/* For RTU, skipped by TCP (no TCP connect) */
modbus_close(ctx);
modbus_free(ctx);
return 0;
}
代码逻辑简单理一下
modbus_new_tcp 初始化 modbus_t 结构体
modbus_tcp_accept 和 modbus_tcp_listen 就是调用 socket 监听端口
modbus_mapping_new 初始化一个缓冲区，用于模拟寄存器信息
然后 modbus_receive 接收客户端的请求和输入
获取输入后就 通过 modbus_reply 处理 请求，以及构造响应数据包， 同时返回响应
然后就是释放掉分配的一些内存
afl 默认只能 fuzz 通过 stdin 和 文件 获取输入的程序， 要 fuzz 网络相关的程序，需要使用一个库
https://github.com/zardus/preeny
这个库利用 LD_PRELOAD 机制，重写了 很多库函数， 其中 desock.c 这个文件负责重写 socket 相关的函数，其实现的功能就是当应用从 socket获取输入时，其实是从 stdin 获取输入。 （具体实现以后再看~_~)
首先下载编译下
git clone https://github.com/zardus/preeny.git cd preeny/ make
然后会在 x86_64-linux-gnu 目录下生成编译好的 lib 。
写个测试脚本，测试一下 (根据 tests 目录里面的 sock.c 改造)
#include <sys/socket.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
int main()
{
int s = socket(AF_INET, SOCK_STREAM, 0);
char buf[1024]={0};
char send_msg[] = "hello, send by send() :\n";
send(s, send_msg, strlen(send_msg), 0);
recv(s, buf, 1024, 0);
printf("recv from recv() : %s\n", buf);
}
编译运行
gcc sock_test.c -o sock_test LD_PRELOAD="/home/haclh/vmdk_kernel/preeny/x86_64-linux-gnu/desock.so" ./sock_test
往 socket 调用 send , 成功往 stdout 输出了 字符串。
从 stdin 输入 I am Tester ，可以看到成功写入 buf 里面
所以我们就可以利用 preeny 来 fuzz modbus tcp server 了
首先使用 afl-gcc 编译 libmodbus ，对 libmodbus 插桩。
unzip libmodbus-master.zip cd libmodbus-master/ ./autogen.sh CC=afl-gcc CXX=afl-g++ ./configure --enable-static make -j4
--enable-static： 用于生成静态库
然后在 src/.libs 下就可以看到编译好的库
03:45 haclh@ubuntu:libmodbus-master $ ls src/.libs/ libmodbus.a libmodbus.la libmodbus.lai libmodbus.so libmodbus.so.5 libmodbus.so.5.1.0 modbus-data.o modbus.o modbus-rtu.o modbus-tcp.o
libmodbus.a 就是编译好的静态库
然后使用我们修改过的 bandwidth-server-one.c 编译 和 fuzz
cd tests/ vim bandwidth-server-one.c afl-gcc bandwidth-server-one.c -I../src ../src/.libs/libmodbus.a -o server mkdir in echo 11111 > in/1 LD_PRELOAD="/home/haclh/vmdk_kernel/preeny/x86_64-linux-gnu/desock.so" afl-fuzz -i in -o out ./server
这里 直接用 echo 生成了一个 测试文件，如果直接用这个去测的话会发现速度非常的慢。
一组好的样本数据对 fuzzer 的影响还是非常大的，一般我们可以去网上搜索样本，比如图片，视频文件等。对于我们这次的目标 libmodbus ， 它自带了很多的测试程序，我们可以利用这些测试程序测试，然后用 tcpdump 抓包， 最后在把其中的请求数据保存下来，作为测试样本集。
首先使用 random-test-server 在 127.0.0.1:1502 起一个 modbus tcp 服务
04:09 haclh@ubuntu:libmodbus-master $ cd tests/ 04:09 haclh@ubuntu:tests $ ./random-test-server
然后开启 tcpdump ， 保存数据包到 ~/modbus.pcap
04:09 haclh@ubuntu:~ $ sudo tcpdump -i lo -w ~/modbus.pcap [sudo] password for haclh: tcpdump: listening on lo, link-type EN10MB (Ethernet), capture size 262144 bytes
最后使用 random-test-client 随机发送各种 modbus 请求到 127.0.0.1:1502
cd tests/ ./random-test-client
然后写一个脚本把 ~/modbus.pcap 中 由客户端发送的数据包 （也就是目的地为 127.0.0.1:1502的数据包） 的内容提取出来，每个数据包内容保存为一个单独的文件。
from scapy.all import *
save_path = "/tmp/seeds/"
uuid = 0
if not os.path.exists(save_path):
os.system("mkdir %s" %(save_path))
def save_to_file(data):
global uuid
with open("{}{}".format(save_path, uuid), "w") as fp:
fp.write(str(data))
uuid += 1
print "write test file: {}".format(uuid)
modbus_session = ''
pg = rdpcap("modbus.pcap")
session = pg.sessions()
for k in session.keys():
if k.endswith("127.0.0.1:1502"):
modbus_session = session[k]
for s in modbus_session:
payload = s[TCP].payload
if len(payload) > 4:
save_to_file(payload)
print "Total: %d tests" %(uuid)
然后以生成的样本集作为初始样本集进行 fuzz
LD_PRELOAD="/home/haclh/vmdk_kernel/preeny/x86_64-linux-gnu/desock.so" afl-fuzz -i /tmp/seeds/ -o out ./server
速度有一定的提升，而且 总路径数 直接 1000+
最后 fuzz 了两个多小时
那个唯一的 crash 还是误报 (~_~)
afl + preeny 来 fuzz 网络应用 速度还行， 关键的还是要找到好的样本，从程序自带的测试用例中抓取也是一个不错的思路。
参考
Fuzzing nginx - Hunting vulnerabilities with afl-fuzz
在介绍一个 在 fuzz 一些网络程序时可能用到的特性， AFL 的 persistent 模式。
persistent 模式就是在程序的某个代码位置不断喂生成的变异数据 进行 fuzz , 而不用每次喂数据都得重新 fork 一个程序。
要使用这个特性，首先得编译 llvm_mode
cd afl-2.52b/ cd llvm_mode/ make cd .. sudo make install
此时就会有 afl-clang-fast 和 afl-clang-fast++ 两个命令， 要使用这个模式，就要用这两个命令来编译目标应用。
afl 的 作者有一篇 文章 介绍这个特性。
下面还是用 afl 自带的 测试文件 experimental/persistent_demo/persistent_demo.c 来看看。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
int main(int argc, char** argv) {
char buf[100];
while (__AFL_LOOP(1000)) {
memset(buf, 0, 100);
read(0, buf, 100);
if (buf[0] == 'f') {
printf("one\n");
if (buf[1] == 'o') {
printf("two\n");
if (buf[2] == 'o') {
printf("three\n");
if (buf[3] == '!') {
printf("four\n");
abort();
}
}
}
}
} // end of while (__AFL_LOOP(1000))
return 0;
}
最关键的 就是 AFL_LOOP(1000) 这个宏, 其中的参数指定循环的次数。
每一次循环 afl 都会生成 测试数据，然后喂到 stdin , 这样 fuzzer 就可以在 AFL_LOOP 宏 包围的内部，通过 read(0,buf, size) 来获取测试数据，然后喂给目标程序的数据处理的代码，这样可以减少 fork 等操作的开销。
对应到上面的程序，就是 afl 会在
while (__AFL_LOOP(1000)) {
........
........
}
里面 fuzz 1000 次，即生成 1000 次测试数据， 然后会 return 0 . 程序结束，然后 afl 会重新起一个程序。继续这样的 fuzz .
被 while (__AFL_LOOP(1000)) 包围的代码，就是不断的 从 stdin 获取测试数据，然后进入下面的 if 判断逻辑。
编译 然后用 afl-fuzz 它
afl-clang-fast persistent_demo.c -o persistent_demo afl-fuzz -i in/ -o out/ ./persistent_demo
一会就能拿到 crash 了。（ abort 会被 afl 检测为 crash) 。
对于 libmodbus ， 不会用这种方式进行 fuzz。（如果有人成功，望悉知，感激不尽）
不过网上还是有一些案例
https://www.fastly.com/blog/how-fuzz-server-american-fuzzy-lop https://sensepost.com/blog/2017/fuzzing-apache-httpd-server-with-american-fuzzy-lop-%2B-persistent-mode/
如果使用 afl 来 fuzz 网络应用，有两种方式
利用 preeny 把从 socket 获取数据，转变为 从 stdin 获取数据
利用 afl 的 persistent 模式
其实还有第三种，网上有个修改版的 afl 可以用来 fuzz 网络应用，不过版本比较老，貌似也没啥人使用（:~
https://github.com/jdbirdwell/afl
此外 ， afl 还有各种扩展模式，比如 利用 qemu 可以无源码 fuzz。 17 年 还有一个 afl-unicorn ，貌似可以 fuzz 任意架构的代码（:没来得及看~。
https://hackernoon.com/afl-unicorn-fuzzing-arbitrary-binary-code-563ca28936bf https://hackernoon.com/afl-unicorn-part-2-fuzzing-the-unfuzzable-bea8de3540a5
fuzz实战之afl
安全脉搏SecPulse.Com独家发文，如需转载，请先联系授权。
本文作者：hackedbylh
本文为安全脉搏专栏作者发布，转载请注明：https://www.secpulse.com/archives/71903.html
必填 您当前尚未登录。 登录？ 注册
必填（保密）