sakuraのAFL源码全注释(二)

阅读量    108344 | 评论 1

分享到: QQ空间 新浪微博 微信 QQ facebook twitter

 

afl-fast-clang中叙

afl-llvm-rt

AFL LLVM_Mode中存在着三个特殊的功能。这三个功能的源码位于afl-llvm-rt.o.c中。

deferred instrumentation

AFL会尝试通过仅执行一次目标二进制文件来优化性能。它会暂停控制流,然后复制该“主”进程以持续提供fuzzer的目标。该功能在某些情况下可以减少操作系统、链接与libc内部执行程序的成本。
选好位置后,将下述代码添加到该位置上,之后使用afl-clang-fast重新编译代码即可

#ifdef __AFL_HAVE_MANUAL_CONTROL
  __AFL_INIT();
#endif

__AFL_INIT()内部调用__afl_manual_init函数。该函数的源代码如下

void __afl_manual_init(void) {
  static u8 init_done;

  if (!init_done) {

    __afl_map_shm();
    __afl_start_forkserver();
    init_done = 1;

  }

}

如果还没有被初始化,就初始化共享内存,然后开始执行forkserver,然后设置init_done为1。

__afl_map_shm就是简单的通过读取环境变量SHM_ENV_VAR来获取共享内存,然后将地址赋值给__afl_area_ptr。否则,默认的__afl_area_ptr指向的是一个数组。

__afl_start_forkserver的逻辑稍微复杂,分条叙述

  • 首先设置child_stopped为0,然后通过FORKSRV_FD + 1向状态管道写入4个字节,告知AFL fuzz已经准备好了。
  • 然后进入fuzz loop循环
    • 通过read从控制管道FORKSRV_FD读取4个字节,如果当前管道中没有内容,就会堵塞在这里,如果读到了,就代表AFL命令我们fork server去执行一次fuzz
    • 如果child_stopped为0,则直接fork出一个子进程去进行fuzz
      • 然后此时对于子进程就会关闭和控制管道和状态管道相关的fd,然后return跳出fuzz loop,恢复正常执行。
    • 如果child_stopped为1,这是对于persistent mode的特殊处理,此时子进程还活着,只是被暂停了,所以可以通过kill(child_pid, SIGCONT)来简单的重启,然后设置child_stopped为0。
    • 然后fork server向状态管道FORKSRV_FD + 1写入子进程的pid,然后等待子进程结束,注意这里对于persistent mode,我们会设置waitpid的第三个参数为WUNTRACED,代表若子进程进入暂停状态,则马上返回。
    • WIFSTOPPED(status)宏确定返回值是否对应于一个暂停子进程,因为在persistent mode里子进程会通过SIGSTOP信号来暂停自己,并以此指示运行成功,所以在这种情况下,我们需要再进行一次fuzz,就只需要和上面一样,通过SIGCONT信号来唤醒子进程继续执行即可,不需要再进行一次fuzz。
      • 设置child_stopped为1。
    • 当子进程结束以后,向状态管道FORKSRV_FD + 1写入4个字节,通知AFL这次target执行结束了。

persistent mode

上面我们其实已经介绍过persistent mode的一些特点了,那就是它并不是通过fork出子进程去进行fuzz的,而是认为当前我们正在fuzz的API是无状态的,当API重置后,一个长期活跃的进程就可以被重复使用,这样可以消除重复执行fork函数以及OS相关所需要的开销。
所以的使用方法如下:

while (__AFL_LOOP(1000)) {
  /* Read input data. */
  /* Call library code to be fuzzed. */
  /* Reset state. */
}
/* Exit normally */

循环次数不能设置过大,因为较小的循环次数可以将内存泄漏和类似故障的影响降到最低。所以循环次数设置成1000是个不错的选择。

接下来我们来解读一下源码,首先介绍一个__attribute__ constructor,demo如下,代表被此修饰的函数将在main执行之前自动运行

__attribute__((constructor(1))) void before_main1(){
    printf("before_main1\n");
}
__attribute__((constructor(2))) void before_main2(){
    printf("before_main2\n");
}
__attribute__((destructor(1))) void after_main1(){
    printf("after_main1\n");
}
__attribute__((destructor(2))) void after_main2(){
    printf("after_main2\n");
}
int main(){
    printf("main\n");
}
...
...
before_main1
before_main2
main
after_main2
after_main1

llvm mode里有一个函数__attribute__((constructor(CONST_PRIO))) void __afl_auto_init(void),其逻辑如下

  • 读取环境变量PERSIST_ENV_VAR的值,设置给is_persistent
  • 读取环境变量DEFER_ENV_VAR的值,如果为1,就直接返回,这代表__afl_auto_init和deferred instrumentation不通用,这其实道理也很简单,因为deferred instrumentation会自己选择合适的时机,手动init,不需要用这个函数来init,所以这个函数只在没有手动init的时候会自动init。
  • 执行__afl_manual_init函数,其含义见上文。

宏定义__AFL_LOOP内部调用__afl_persistent_loop函数。
__afl_persistent_loop(unsigned int max_cnt)的逻辑如下

  • 如果是第一次执行loop
    • 如果is_persistent为1
      • 清空__afl_area_ptr,设置__afl_area_ptr[0]为1,__afl_prev_loc为0
    • 设置cycle_cnt的值为传入的max_cnt参数,然后直接返回1
  • 如果不是第一次执行loop
    • 如果cycle_cnt减一(代表需要执行的循环次数减一)后大于0
      • 发出信号SIGSTOP来让当前进程暂停
      • 设置__afl_area_ptr[0]为1,__afl_prev_loc为0,然后直接返回1
    • 如果cycle_cnt为0
      • 设置__afl_area_ptr指向一个无关数组__afl_area_initial

我们将这些联系在一起,重新梳理一遍
假设我们是这么使用的:

while (__AFL_LOOP(1000)) {
    fuzzAPI();
}
  • 首先在main函数之前读取共享内容,然后以当前进程为fork server,去和AFL fuzz通信。
  • 当AFL fuzz通知进行一次fuzz,由于此时child_stopped为0,则fork server先fork出一个子进程。
  • 这个子进程会很快执行到__AFL_LOOP包围的代码,因为是第一次执行loop,所以会先清空__afl_area_ptr和设置__afl_prev_loc为0,并向共享内存的第一个元素写一个值,然后设置循环次数1000,随后返回1,此时while(__AFL_LOOP)满足条件,于是执行一次fuzzAPI。
  • 然后因为是while循环,会再次进入__AFL_LOOP里,此时将循环次数减一,变成999,然后发出信号SIGSTOP来让当前进程暂停,因为我们设置了WUNTRACED,所以waitpid函数就会返回,fork server将继续执行。
  • fork server在收到SIGSTOP信号后就知道fuzzAPI已经被成功执行结束了,就设置child_stopped为1,并告知AFL fuzz
  • 然后当AFL fuzz通知再进行一次fuzz的时候,fork server将不再需要去fork出一个新的子进程去进行fuzz,只需要恢复之前的子进程继续执行,并设置child_stopped为0
  • 因为我们是相当于重新执行一次程序,所以将__afl_prev_loc设置为0,并向共享内存的第一个元素写一个值,随后直接返回1,此时while(__AFL_LOOP)满足条件,于是执行一次fuzzAPI,然后因为是while循环,会再次进入__AFL_LOOP里,再次减少一次循环次数变成998,并发出信号暂停。
  • 上述过程重复执行,直到第1000次执行时,先恢复执行,然后返回1,然后执行一次fuzzAPI,然后因为是while循环,会再次进入__AFL_LOOP里,再次减少一次循环次数变成0,此时循环次数cnt已经被减到0,就不会再发出信号暂停子进程,而是设置__afl_area_ptr指向一个无关数组__afl_area_initial,随后将子进程执行到结束。
    • 这是因为程序依然会向后执行并触发到instrument,这会向__afl_area_ptr里写值,但是此时我们其实并没有执行fuzzAPI,我们并不想向共享内存里写值,于是将其指向一个无关数组,随意写值。同理,在deferred instrumentation模式里,在执行__afl_manual_init之前,也是向无关数组里写值,因为我们将fork点手动设置,就代表在这个fork点之前的path我们并不关心。
    • 重新整理一下上面的逻辑
      • loop第一次执行的时候,会初始化,然后返回1,执行一次fuzzAPI,然后cnt会减到999,然后抛出信号暂停子进程。
      • loop第二次执行的时候,恢复执行,清空一些值,然后返回1,执行一次fuzzAPI,然后cnt会减到998,然后抛出信号暂停子进程。
      • loop第1000次执行的时候,恢复执行,清空一些值,然后返回1,执行一次fuzzAPI,然后cnt会减到0,然后就设置指向无关数组,返回0,while循环结束,程序也将执行结束。
  • 此时fork server将不再收到SIGSTOP信号,于是child_stopped仍为0。
  • 所以当AFL fuzz通知fork server再进行一次fuzz的时候,由于此时child_stopped为0,则fork server会先fork出一个子进程,然后后续过程和之前一样了。
  • 有点绕,可以结合代码再读一下
    int __afl_persistent_loop(unsigned int max_cnt) {
    static u8  first_pass = 1;
    static u32 cycle_cnt;
    if (first_pass) {
      if (is_persistent) {
        memset(__afl_area_ptr, 0, MAP_SIZE);
        __afl_area_ptr[0] = 1;
        __afl_prev_loc = 0;
      }
      cycle_cnt  = max_cnt;
      first_pass = 0;
      return 1;
    }
    if (is_persistent) {
      if (--cycle_cnt) {
        raise(SIGSTOP);
        __afl_area_ptr[0] = 1;
        __afl_prev_loc = 0;
        return 1;
      } else {
        __afl_area_ptr = __afl_area_initial;
      }
    }
    return 0;
    }
    

trace-pc-guard mode

要使用这个功能,需要先通过AFL_TRACE_PC=1来定义DUSE_TRACE_PC宏,从而在执行afl-clang-fast的时候传入-fsanitize-coverage=trace-pc-guard参数,来开启这个功能,和之前我们的插桩不同,开启了这个功能之后,我们不再是仅仅只对每个基本块插桩,而是对每条edge都进行了插桩。

ifdef AFL_TRACE_PC
  CFLAGS    += -DUSE_TRACE_PC=1
endif

__sanitizer_cov_trace_pc_guard这个函数将在每个edge调用,该函数利用函数参数guard指针所指向的uint32值来确定共享内存上所对应的地址。
每个edge上都有应该有其不同(但其实可能相同,原因下述)的guard值

void __sanitizer_cov_trace_pc_guard(uint32_t* guard) {
  __afl_area_ptr[*guard]++;
}

而这个guard指针的初始化在__sanitizer_cov_trace_pc_guard_init函数里,llvm会设置guard其首末分别为start和stop。
它会从第一个guard开始向后遍历,设置guard指向的值,这个值是通过R(MAP_SIZE)设置的,定义如下,所以如果我们的edge足够多,而MAP_SIZE不够大,就有可能重复,而这个加一是因为我们会把0当成一个特殊的值,其代表对这个edge不进行插桩。
这个init其实很有趣,我们可以打印输出一下stop-start的值,就代表了llvm发现的程序里总计的edge数。

#  define R(x) (random() % (x))
...
...
  *(start++) = R(MAP_SIZE - 1) + 1;

  while (start < stop) {

    if (R(100) < inst_ratio) *start = R(MAP_SIZE - 1) + 1;
    else *start = 0;

    start++;

  }

 

afl-fuzz长叙

初始配置

setup_signal_handlers

注册必要的信号处理函数

  • Linux进程间通信(一):信号 signal()、sigaction()
  • SIGHUP/SIGINT/SIGTERM
    • hangup/interrupt/software termination signal from kill
    • 主要是”stop”的处理函数
    • handle_stop_sig
      • 设置stop_soon为1
      • 如果child_pid存在,向其发送SIGKILL终止信号,从而被系统杀死。
      • 如果forksrv_pid存在,向其发送SIGKILL终止信号
  • SIGALRM
    • alarm clock
    • 处理超时的情况
    • handle_timeout
      • 如果child_pid>0,则设置child_timed_out为1,并kill掉child_pid
      • 如果child_pid==-1,且forksrv_pid>0,则设置child_timed_out为1,并kill掉forksrv_pid
  • SIGWINCH
    • Window resize
    • 处理窗口大小的变化信号
    • handle_resize
      • 设置clear_screen=1
  • SIGUSR1
    • user defined signal 1,这个是留给用户自定义的信号
    • 这里定义成skip request (SIGUSR1)
    • handle_skipreq
      • 设置skip_requested=1
  • SIGTSTP/SIGPIPE
    • stop signal from tty/write on a pipe with no one to read it
    • 不关心的一些信号
    • SIG_IGN

check_asan_opts

check asan选项

  • 读取环境变量ASAN_OPTIONS和MSAN_OPTIONS,做一些检查

fix_up_sync

如果通过-M或者-S指定了sync_id,则更新out_dir和sync_dir的值

  • 设置sync_dir的值为out_dir
  • 设置out_dir的值为out_dir/sync_id

save_cmdline

拷贝当前的命令行参数

   00 ff 00 ff   55 00 00 00   buf-> 2f 55 73 65   72 73 2f 73   │ ····U···/Users/s │
   61 6b 75 72   61 2f 67 69   74 73 6f 75   72 63 65 2f   │ akura/gitsource/ │
   41 46 4c 2f   63 6d 61 6b   65 2d 62 75   69 6c 64 2d   │ AFL/cmake-build- │
   64 65 62 75   67 2f 61 66   6c 2d 66 75   7a 7a 20 2d   │ debug/afl-fuzz - │
   69 20 69 6e   70 75 74 20   2d 6f 20 6f   75 74 70 75   │ i input -o outpu │
   74 20 2d 2d   20 2e 2f 74   65 73 74 00   00 f0 00 00   │ t -- ./test·····

fix_up_banner

修剪并且创建一个运行横幅

check_if_tty

检查是否在tty终端上面运行。

  • 读取环境变量AFL_NO_UI的值,如果为真,则设置not_on_tty为1,并返回
  • ioctl(1, TIOCGWINSZ, &ws)通过ioctl来读取window size,如果报错为ENOTTY,则代表当前不在一个tty终端运行,设置not_on_tty

get_core_count

计数logical CPU cores

check_crash_handling

check_cpu_governor

setup_post

setup_shm

配置共享内存和virgin_bits

  • Linux进程间通信(六):共享内存 shmget()、shmat()、shmdt()、shmctl()
  • 如果in_bitmap为空,则通过memset初始化数组virgin_bits[MAP_SIZE]的每个元素的值为’255’(\xff)
  • 通过memset设置virgin_tmout[MAP_SIZE]和virgin_crash[MAP_SIZE]的每个元素的值为’255’(\xff)
  • 调用shmget分配一块共享内存,shmget(IPC_PRIVATE, MAP_SIZE, IPC_CREAT | IPC_EXCL | 0600);,将返回的共享内存标识符保存到shm_id里。
    • int shmget(key_t key, size_t size, int shmflg);
    • 第一个参数,程序需要提供一个参数key(非0整数),它有效地为共享内存段命名,shmget()函数成功时返回一个与key相关的共享内存标识符(非负整数),用于后续的共享内存函数。调用失败返回-1.
      • 这里shm_id取值是IPC_PRIVATE,所以函数shmget()将创建一块新的共享内存
    • 第二个参数,size以字节为单位指定需要共享的内存容量
      • 这里取值为MAP_SIZE
    • 第三个参数,shmflg是权限标志
      • IPC_CREAT 如果共享内存不存在,则创建一个共享内存,否则打开操作。
      • IPC_EXCL 只有在共享内存不存在的时候,新的共享内存才建立,否则就产生错误。
      • 421分别表示,读写执行3种权限。 比如,上面的6=4+2,表示读+写。
      • 0600 每一位表示一种类型的权限,比如,第一位是表示八进制,第二位表示拥有者的权限为读写,第三位表示同组无权限,第四位表示他人无权限。
  • 注册atexit handler为remove_shm
    • remove_shm
      • shmctl(shm_id, IPC_RMID, NULL);
        • 第一个参数,shm_id是shmget()函数返回的共享内存标识符。
        • 第二个参数,command是要采取的操作,它可以取下面的三个值
          • IPC_RMID:删除共享内存段
        • 第三个参数,buf是一个结构指针
  • 使用alloc_printf(“%d”, shm_id)来创建一个字符串shm_str
     00 ff 00 ff   06 00 00 00  shm_str->36 35 35 33   38 00 f0 f0   │ ········65538··· │
    
  • 如果不是dumb_mode,则设置环境变量SHM_ENV_VAR的值为shm_str
  • trace_bits = shmat(shm_id, NULL, 0);
    • trace_bits是用做SHM with instrumentation bitmap
    • 第一次创建完共享内存时,它还不能被任何进程访问,所以通过shmat来启动对该共享内存的访问,并把共享内存连接到当前进程的地址空间。
    • void *shmat(int shm_id, const void *shm_addr, int shmflg)
      • 第一个参数,shm_id是由shmget()函数返回的共享内存标识。
      • 第二个参数,shm_addr指定共享内存连接到当前进程中的地址位置,通常为空,表示让系统来选择共享内存的地址。
      • 第三个参数,shm_flg是一组标志位,通常为0。
      • 调用成功时返回一个指向共享内存第一个字节的指针,如果调用失败返回-1.

init_count_class16

这其实是因为trace_bits是用一个字节来记录是否到达这个路径,和这个路径被命中了多少次的,而这个次数在0-255之间,但比如一个循环,它循环5次和循环6次可能是完全一样的效果,为了避免被当成不同的路径,或者说尽可能减少因为命中次数导致的区别。
在每次去计算是否发现了新路径之前,先把这个路径命中数进行规整,比如把命中5次和6次都统一认为是命中了8次,见下面这个。

static const u8 count_class_lookup8[256] = {
        [0]           = 0,
        [1]           = 1,
        [2]           = 2,
        [3]           = 4,
        [4 ... 7]     = 8,
        [8 ... 15]    = 16,
        [16 ... 31]   = 32,
        [32 ... 127]  = 64,
        [128 ... 255] = 128
};

而为什么又需要用一个count_class_lookup16呢,是因为AFL在后面实际进行规整的时候,是一次读两个字节去处理的,为了提高效率,这只是出于效率的考量,实际效果还是上面这种效果。
初始化u16 count_class_lookup16[65536]

EXP_ST void init_count_class16(void) {

    u32 b1, b2;

    for (b1 = 0; b1 < 256; b1++)
        for (b2 = 0; b2 < 256; b2++)
            count_class_lookup16[(b1 << 8) + b2] =
                    (count_class_lookup8[b1] << 8) |
                    count_class_lookup8[b2];
}

setup_dirs_fds

准备输出文件夹和fd

  • 如果sync_id存在,且创建sync_dir文件夹,设置权限为0700(读写执行)
    • 如果报错,且errno不是EEXIST,则抛出异常。
  • 创建out_dir,设置权限为0700(读写执行)
    • 如果报错,且errno不是EEXIST,则抛出异常。
      • maybe_delete_out_dir
    • 如果创建成功
      • 如果设置了in_place_resume,就抛出异常”Resume attempted but old output directory not found”
      • out_dir_fd = open(out_dir, O_RDONLY)以只读模式打开这个文件,并返回文件句柄out_dir_fd
      • 如果没有定义宏__sun
        • 如果打开out_dir失败,或者为out_dir通过flock建立互斥锁定失败,就抛出异常”Unable to flock() output directory.”
  • 建立queue文件夹
    • 创建out_dir/queue文件夹,设置权限为0700
      • 创建out_dir/queue/.state/,设置权限为0700,该文件夹主要保存用于session resume和related tasks的queue metadata
        • 创建out_dir/queue/.state/deterministic_done/,设置权限为0700,该文件夹标记过去经历过deterministic fuzzing的queue entries
        • 创建out_dir/queue/.state/auto_extras/,设置权限为0700,Directory with the auto-selected dictionary entries.
        • 创建out_dir/queue/.state/redundant_edges/,设置权限为0700,保存当前被认为是多余的路径集合
        • 创建out_dir/queue/.state/variable_behavior/,设置权限为0700,The set of paths showing variable behavior.
  • 如果sync_id存在
    • 创建out_dir/.synced/,设置权限为0700,同步文件夹,用于跟踪cooperating fuzzers.
  • 建立crashes文件夹
    • 创建out_dir/crashes文件夹,设置权限为0700,用于记录crashes
  • 建立hangs文件夹
    • 创建out_dir/hangs文件夹,设置权限为0700,用于记录hangs
  • 通常有用的文件描述符
    • dev_null_fd = open("/dev/null", O_RDWR);以读写模式打开/dev/null
    • dev_urandom_fd = open("/dev/urandom", O_RDONLY);,以只读模式打开/dev/urandom
  • 建立Gnuplot输出文件夹
    • fd = open(tmp, O_WRONLY | O_CREAT | O_EXCL, 0600);以只写方式打开out_dir/plot_data文件,如果文件不存在,就创建,并获取句柄
    • plot_file = fdopen(fd, "w");根据句柄得到FILE* plot_file
    • 向其中写入# unix_time, cycles_done, cur_path, paths_total, pending_total, pending_favs, map_size, unique_crashes, unique_hangs, max_depth, execs_per_sec\n

read_testcases

从输入文件夹中读取所有文件,然后将它们排队进行测试。

  • 尝试访问in_dir/queue文件夹,如果存在就重新设置in_dir为in_dir/queue
    • Auto-detect non-in-place resumption attempts.
  • 扫描in_dir,并将结果保存在struct dirent **nl
    • 不使用readdir,因为测试用例的顺序将随机地有些变化,并且将难以控制。
  • 遍历nl,nl[i]->d_name的值为input文件夹下的文件名字符串
    • u8 *fn = alloc_printf("%s/%s", in_dir, nl[i]->d_name);
    • u8 *dfn = alloc_printf("%s/.state/deterministic_done/%s", in_dir, nl[i]->d_name);
    • 如果shuffle_queue的值为真,且nl_cnt大于1,则shuffle_ptrs((void **) nl, nl_cnt),字面意思上就是重排nl里的指针的位置。
    • 通过文件属性过滤掉...这样的regular文件,并检查文件大小,如果文件大小大于MAX_FILE,默认是1024*1024字节,即1M
    • 通过access检查in_dir/.state/deterministic_done/nl[i]->d_name是否存在,这应该是为了用在resume恢复扫描使用
      • 如果存在就设置passed_det为1
      • 这个检查是用来判断是否这个entry已完成deterministic fuzzing。在恢复异常终止的扫描时,我们不想重复deterministic fuzzing,因为这将毫无意义,而且可能非常耗时
    • add_to_queue(fn, st.st_size, passed_det);
    • 如果queued_paths为0,则代表输入文件夹为0,抛出异常
    • 设置last_path_time为0
    • queued_at_start的值设置为queued_paths
      • Total number of initial inputs

add_to_queue(u8 *fname, u32 len, u8 passed_det)

  • queue_entry是一个链表数据结构
  • 先通过calloc动态分配一个queue_entry结构体,并初始化其fname为文件名fn,len为文件大小,depth为cur_depth + 1,passed_det为传递进来的passed_det
    q->fname = fname;
    q->len = len;
    q->depth = cur_depth + 1;
    q->passed_det = passed_det;
    
  • 如果q->depth > max_depth,则设置max_depth为q->depth
  • 如果queue_top不为空,则设置queue_top->next为q,queue_top = q;,否则q_prev100 = queue = queue_top = q;
    static struct queue_entry *queue,     /* Fuzzing queue (linked list)      */
    *queue_top, /* Top of the list                  */
    *q_prev100; /* Previous 100 marker              */
    
  • queue计数器queued_paths和待fuzz的样例计数器pending_not_fuzzed加一
  • cycles_wo_finds设置为0
    • Cycles without any new paths
  • 如果queued_paths % 100得到0,则设置q_prev100->next_100 = q; q_prev100 = q;
  • 设置last_path_time为当前时间。

load_auto

load自动生成的提取出来的词典token

  • 遍历循环从i等于0到USE_AUTO_EXTRAS,默认50
    • 以只读模式尝试打开文件名为alloc_printf("%s/.state/auto_extras/auto_%06u", in_dir, i)的文件
    • 如果打开失败,则结束
    • 如果打开成功,则从fd读取最多MAX_AUTO_EXTRA+1个字节到tmp数组里,默认MAX_AUTO_EXTRA为32,这是单个auto extra文件的最大大小,读取出的长度保存到len里。
    • maybe_add_auto(tmp, len);
      };

maybe_add_auto(u8 *mem, u32 len)

  • 如果用户设置了MAX_AUTO_EXTRAS或者USE_AUTO_EXTRAS为0,则直接返回。
  • 循环遍历i从1到len,将tmp[0]和mem[i]异或,如果相同,则结束循环。
  • 如果结束时i=0,即tmp[0]和tmp[1]就相同,就直接返回。这里我推断tmp应该是从小到大排序的字节流。
  • 如果len的长度为2,就和interesting_16数组里的元素比较,如果和其中某一个相同,就直接return。
  • 如果len的长度为4,就和interesting_32数组里的元素比较,如果和其中某一个相同,就直接return。
  • 将tmp和现有的extras数组里的元素比较,利用extras数组里保存的元素是按照size大小,从小到大排序这个特性,来优化代码。
    • 遍历extras数组,比较memcmp_nocase(extras[i].data, mem, len),如果有一个相同,就直接return。
    • static struct extra_data extras; / Extra tokens to fuzz with */
  • 设置auto_changed为1
  • 遍历a_extras数组,比较memcmp_nocase(a_extras[i].data, mem, len),如果相同,就将其hit_cnt值加一,这是代表在语料中被use的次数,然后跳转到sort_a_extras
    • static struct extra_data a_extras; / Automatically selected extras */
      struct extra_data {
      u8 *data;                           /* Dictionary token data            */
      u32 len;                            /* Dictionary token length          */
      u32 hit_cnt;                        /* Use count in the corpus          */
      
  • 此时我们可能在处理一个不在之前的任何a_extras或者extras数组里的新entry了,处理逻辑是
    • 先比较a_extras_cnt和MAX_AUTO_EXTRAS,如果小于就代表a_extras数组没有填满,直接拷贝tmp和len,来构造出一个新项,加入到a_extras数组里
    • 否则的话,就从a_extras数组的后半部分里,随机替换掉一个元素的a_extras[i].data为ck_memdup(mem, len),并将len设置为len,hit_cnt设置为0。

pivot_inputs

逻辑上说这个函数就是为inputdir里的testcase,在output dir里创建hard link

  • 初始化id=0
  • 依次遍历queue里的queue_entry
    • 在q->fname里找到最后一个’/‘所在的位置,如果找不到,则rsl = q->fname,否则rsl指向’/‘后的第一个字符,其实也就是最后一个/后面的字符串
    • 将rsl的前三个字节和id_进行比较
      • 如果相等,则设置resuming_fuzz为1,然后做一些恢复操作,不叙述。
      • 如果不相等
        • 在rsl里寻找,orig:子串,如果找到了,将use_name指向该子串的冒号后的名字;如果没找到,就另use_name = rsl
        • nfn = alloc_printf("%s/queue/id:%06u,orig:%s", out_dir, id, use_name);
        • 尝试创建从input file到alloc_printf("%s/queue/id:%06u,orig:%s", out_dir, id, use_name)的硬链接
    • 修改q的fname指向这个硬链接
    • 如果q的passed_det为1,则mark_as_det_done(q),这主要是对应上面的resuming_fuzz的情况。
      • mark_as_det_done简单的说就是打开out_dir/queue/.state/deterministic_done/use_name这个文件,如果不存在就创建这个文件,然后设置q的passed_det为1。
      • 这里的use_name就是orig:后面的字符串
  • 如果设置了in_place_resume为1,则nuke_resume_dir()
    • nuke_resume_dir()
      • 删除out_dir/_resume/.state/deterministic_done文件夹下所有id:前缀的文件
      • 删除out_dir/_resume/.state/auto_extras文件夹下所有auto_前缀的文件
      • 删除out_dir/_resume/.state/redundant_edges文件夹下所有id:前缀的文件
      • 删除out_dir/_resume/.state/variable_behavior文件夹下所有id:前缀的文件
      • 删除文件夹out_dir/_resume/.state
      • 删除out_dir/_resume文件夹下所有id:前缀的文件
      • 如果全部删除成功就正常返回,如果有某一个删除失败就抛出异常。

load_extras

如果定义了extras_dir,则从extras_dir读取extras到extras数组里,并按size排序。

find_timeout

如果timeout_given没有被设置,则进入find_timeout
这个想法是,在不指定-t的情况下resuming sessions时,我们不希望一遍又一遍地自动调整超时时间,以防止超时值因随机波动而增长

  • 如果resuming_fuzz为0,则直接return
  • 如果in_place_resume为1,则fn = alloc_printf("%s/fuzzer_stats", out_dir);,否则fn = alloc_printf("%s/../fuzzer_stats", in_dir);
  • 以只读方式打开fd,读取内容到tmp[4096]里,并在里面搜索”exec_timeout : “,如果搜索不到就直接返回,如果搜索到了,就读取这个timeout的数值,如果大于4就设置为exec_tmout的值。
    • EXP_ST u32 exec_tmout = EXEC_TIMEOUT; / Configurable exec timeout (ms) /
  • timeout_given = 3;
    • timeout_given, / Specific timeout given? /

detect_file_args

这个函数其实就是识别参数里面有没有@@,如果有就替换为out_dir/.cur_input,如果没有就返回

setup_stdio_file

如果out_file为NULL,如果没有使用-f,就删除原本的out_dir/.cur_input,创建一个新的out_dir/.cur_input,保存其文件描述符在out_fd中

check_binary

check指定路径处要执行的程序是否存在,且它不能是一个shell script

perform_dry_run

执行所有的测试用例,以检查是否按预期工作

  • 读取环境变量AFL_SKIP_CRASHES到skip_crashes,设置cal_failures为0
  • 遍历queue
    • 打开q->fname,并读取到分配的内存use_mem里
    • res = calibrate_case(argv, q, use_mem, 0, 1);
      • 校准测试用例,见下文
    • 如果stop_soon被置为1,就直接return
    • 如果res的结果为crash_mode或者FAULT_NOBITS
      • 打印SAYF("len = %u, map size = %u, exec speed = %llu us\n", q->len, q->bitmap_size, q->exec_us);
    • 依据res的结果查看是哪种错误并进行判断。一共有以下几种错误类型
      • FAULT_NONE
        • 如果q是头结点,即第一个测试用例,则check_map_coverage,用以评估map coverage
          • 计数trace_bits发现的路径数,如果小于100,就直接返回
          • 在trace_bits的数组后半段,如果有值就直接返回。
          • 抛出警告WARNF("Recompile binary with newer version of afl to improve coverage!")
        • 如果是crash_mode,则抛出异常,FATAL("Test case '%s' does *NOT* crash", fn);,该文件不崩溃
      • FAULT_TMOUT
        • 如果指定了-t参数,则timeout_given值为2
          • 抛出警告WARNF("Test case results in a timeout (skipping)");,并设置q的cal_failed为CAL_CHANCES,cal_failures计数器加一。
      • FAULT_CRASH
        • 如果没有指定mem_limit,则可能抛出建议增加内存的建议
        • 但不管指定了还是没有,都会抛出异常FATAL("Test case '%s' results in a crash", fn);
      • FAULT_ERROR
        • 抛出异常Unable to execute target application
      • FAULT_NOINST
        • 这个样例运行没有出现任何路径信息,抛出异常No instrumentation detected
      • FAULT_NOBITS
        • 如果这个样例有出现路径信息,但是没有任何新路径,抛出警告WARNF("No new instrumentation output, test case may be useless."),认为这是无用路径。useless_at_start计数器加一
    • 如果这个样例q的var_behavior为真,则代表它多次运行,同样的输入条件下,却出现不同的覆盖信息。
      • 抛出警告WARNF("Instrumentation output varies across runs.");,代表这个样例的路径输出可变
    • 然后读取下一个queue,继续测试,直到结束。
      enum {
      /* 00 */ FAULT_NONE,
      /* 01 */ FAULT_TMOUT,
      /* 02 */ FAULT_CRASH,
      /* 03 */ FAULT_ERROR,
      /* 04 */ FAULT_NOINST,
      /* 05 */ FAULT_NOBITS };
      

u8 calibrate_case(char *argv, struct queue_entry q, u8 *use_mem, u32 handicap, u8 from_queue)

这个函数评估input文件夹下的case,来发现这些testcase的行为是否异常;以及在发现新的路径时,用以评估这个新发现的testcase的行为是否是可变(这里的可变是指多次执行这个case,发现的路径不同)等等

  • 这个函数的参数为char **argv, struct queue_entry *q, u8 *use_mem, u32 handicap, u8 from_queue
  • 创建first_trace[MAP_SIZE]
  • 如果q->exec_cksum为0,代表这是这个case第一次运行,即来自input文件夹下,所以将first_run置为1。
  • 保存原有的stage_cur、stage_max、stage_name
  • 设置use_tmout为exec_tmout,如果from_queue是0或者resuming_fuzz被置为1,即代表不来自于queue中或者在resuming sessions的时候,则use_tmout的值被设置的更大。
  • q->cal_failed++
  • 设置stage_name为”calibration”,以及根据是否fast_cal为1,来设置stage_max的值为3还是CAL_CYCLES(默认为8),含义是每个新测试用例(以及显示出可变行为的测试用例)的校准周期数,也就是说这个stage要执行几次的意思。
  • 如果当前不是以dumb mode运行,且no_forkserver(禁用forkserver)为0,且forksrv_pid为0,则init_forkserver(argv)启动fork server,见后文。
  • 如果这个queue不是来自input文件夹,而是评估新case,则此时q->exec_cksum不为空,拷贝trace_bits到first_trace里,然后计算has_new_bits的值,赋值给new_bits。
  • 开始执行calibration stage,共执行stage_max轮
    • 如果这个queue不是来自input文件夹,而是评估新case,且第一轮calibration stage执行结束时,刷新一次展示界面show_stats,用来展示这次执行的结果,此后不再展示。
    • write_to_testcase(use_mem, q->len)
      • 将从q->fname中读取的内容写入到.cur_input
    • u8 run_target(argv, use_tmout),结果保存在fault中
    • 如果这是calibration stage第一次运行,且不在dumb_mode,且共享内存里没有任何路径(即没有任何byte被置位),设置fault为FAULT_NOINST,然后goto abort_calibration。
      • 计算共享内存里有多少字节被置位了,通过count_bytes函数
        • u32 count_bytes(u8 *mem)
    • 计算hash32(trace_bits, MAP_SIZE, HASH_CONST)的结果,其值为一个32位uint值,保存到cksum中
    • 如果q->exec_cksum不等于cksum,即代表这是第一次运行,或者在相同的参数下,每次执行,cksum却不同,是一个路径可变的queue
      • hnb = has_new_bits(virgin_bits)
      • 如果hnb大于new_bits,设置new_bits的值为hnb
      • 如果q->exec_cksum不等于0,即代表这是判断是否是可变queue
        • i从0到MAP_SIZE遍历,如果first_trace[i]不等于trace_bits[i],代表发现了可变queue,且var_bytes为空,则将该字节设置为1,并将stage_max设置为CAL_CYCLES_LONG,即需要执行40次。
        • 将var_detected设置为1
      • 否则,即q->exec_cksum等于0,即代表这是第一次执行这个queue
        • 设置q->exec_cksum的值为之前计算出来的本次执行的cksum
        • 拷贝trace_bits到first_trace中。
  • 保存所有轮次总的执行时间,加到total_cal_us里,总的执行轮次,加到total_cal_cycles里
  • 计算出一些统计信息,包括
    • 计算出单次执行时间的平均值保存到q->exec_us里
    • 将最后一次执行所覆盖到的路径数保存到q->bitmap_size里
    • q->handicap = handicap;
    • q->cal_failed = 0;
    • total_bitmap_size里加上这个queue所覆盖到的路径数
    • total_bitmap_entries++
    • update_bitmap_score(struct queue_entry *q)
  • 如果fault为FAULT_NONE,且该queue是第一次执行,且不属于dumb_mode,而且new_bits为0,代表在这个样例所有轮次的执行里,都没有发现任何新路径和出现异常,设置fault为FAULT_NOBITS
  • 如果new_bits为2,且q->has_new_cov为0,设置其值为1,并将queued_with_cov加一,代表有一个queue发现了新路径。
  • 如果这个queue是可变路径,即var_detected为1,则计算var_bytes里被置位的tuple个数,保存到var_byte_count里,代表这些tuple具有可变的行为。
  • 将这个queue标记为一个variable
    • mark_as_variable(struct queue_entry *q)
      • 创建符号链接out_dir/queue/.state/variable_behavior/fname
      • 设置queue的var_behavior为1
    • 计数variable behavior的计数器queued_variable的值加一
  • 恢复之前的stage值
  • 如果不是第一次运行这个queue,展示show_stats
  • 返回fault的值

init_forkserver

  • 建立管道st_pipe和ctl_pipe,在父子进程之间,是通过管道进行通信,一个用于传递状态,另一个用于传递命令。
  • fork出一个子进程,fork函数执行完毕后,如果创建新进程成功,则出现两个进程,一个是子进程,一个是父进程。在子进程中,fork函数返回0,在父进程中,fork返回新创建子进程的进程ID。我们可以通过fork返回的值来判断当前进程是子进程还是父进程。
    • forksrv_pid = fork()
  • 子进程和父进程都会向下执行,我们通过pid来使它们执行不同的代码if(!forksrv_pid)
    • 以下都是子进程要执行的代码
      • 在继续向下读之前,需要仔细阅读这篇文章
      • 重定向文件描述符1和2到dev_null_fd,如果指定了out_file,则文件描述符0重定向到dev_null_fd,否则重定向到out_fd。
        • dup2(dev_null_fd, 1);
        • dup2(dev_null_fd, 2);
      • 重定向FORKSRV_FD到ctl_pipe[0],重定向FORKSRV_FD + 1到st_pipe[1]
        • 子进程只能读取命令
        • 子进程只能发送(“写出”)状态
      • 关闭子进程里的一些文件描述符
        close(ctl_pipe[0]);
        close(ctl_pipe[1]);
        close(st_pipe[0]);
        close(st_pipe[1]);
        
        close(out_dir_fd);
        close(dev_null_fd);
        close(dev_urandom_fd);
        close(fileno(plot_file));
        
      • 读取环境变量LD_BIND_LAZY,如果没有设置,则设置环境变量LD_BIND_NOW为1
      • 设置环境变量ASAN_OPTIONS为"abort_on_error=1:" "detect_leaks=0:" "symbolize=0:" "allocator_may_return_null=1",同理设置MSAN_OPTIONS
      • execv(target_path, argv)带参数执行target,这个函数除非出错不然不会返回。
        • execv会替换掉原有的进程空间为target_path代表的程序,所以相当于后续就是去执行target_path,这个程序结束的话,子进程就结束。
        • 而在这里非常特殊,第一个target会进入__afl_maybe_log里的__afl_fork_wait_loop,并充当fork server,在整个Fuzz的过程中,它都不会结束,每次要Fuzz一次target,都会从这个fork server fork出来一个子进程去fuzz。
      • 使用一个独特的bitmaps EXEC_FAIL_SIG(0xfee1dead)写入trace_bits,来告诉父进程执行失败,并结束子进程。
  • 以下都是父进程要执行的代码
    • 关闭不需要的endpoints
        // 关闭不是需要的endpoints
        close(ctl_pipe[0]);
        close(st_pipe[1]);
      
        fsrv_ctl_fd = ctl_pipe[1];//父进程只能发送("写出")命令
        fsrv_st_fd = st_pipe[0];//父进程只能读取状态
      
    • 等待fork server启动,但是不能等太久。(所以在调试时要注意这个…)
      • 从管道里读取4个字节到status里,如果读取成功,则代表fork server成功启动,就结束这个函数并返回。
      • 如果超时,就抛出异常。
  • 后续是一些子进程启动失败的异常处理逻辑,暂时不叙。

has_new_bits(u8 *virgin_map)

  • 检查有没有新路径或者某个路径的执行次数有所不同。
  • 初始化current和virgin为trace_bits和virgin_map的u64首元素地址,设置ret的值为0
  • 8个字节一组,每次从trace_bits,也就是共享内存里取出8个字节
    • 如果current不为0,且current & virgin不为0,即代表current发现了新路径或者某条路径的执行次数和之前有所不同
      • 如果ret当前小于2
        • 取current的首字节地址为cur,virgin的首字节地址为vir
        • i的范围是0-7,比较cur[i] && vir[i] == 0xff,如果有一个为真,则设置ret为2
          • 这代表发现了之前没有出现过的tuple
          • 注意==的优先级比&&要高,所以先判断vir[i]是否是0xff,即之前从未被覆盖到,然后再和cur[i]进行逻辑与
        • 否则设置ret为1
          • 这代表仅仅只是改变了某个tuple的hit-count
      • *virgin &= ~*current
    • current和virgin移动到下一组8个字节,直到MAPSIZE全被遍历完。
  • 如果传入给has_new_bits的参数virgin_mapvirgin_bits,且ret不为0,就设置bitmap_changed为1
    • virgin_bits保存还没有被Fuzz覆盖到的byte,其初始值每位全被置位1,然后每次按字节置位。
  • 返回ret的值。

u32 count_bytes(u8 *mem)

  • 初始化计数器ret的值为0,循环读取mem里的值,每次读取4个字节到u32变量v中
  • 如果v为0,则代表这四个字节都是0,直接跳过,进入下一次循环
  • 如果v不为0,则依次计算v & FF(0),v & FF(1),v & FF(2),v&FF(3)的结果,如果不为0,则计数器ret加一。
    • #define FF(_b) (0xff << ((_b) << 3))
      • (_b) << 3)_b * 8
      • 0x000000ff左移(_b * 8)
      • 最终结果可以是0x000000ff,0x0000ff00,0x00ff0000,0xff000000其中之一

u8 run_target(char **argv, u32 timeout)

  • 先清空trace_bits[MAP_SIZE],将其全置为0,也就是清空共享内存。
  • 如果dumb_mode等于1,且no_forkserver,则直接fork出一个子进程,然后让子进程execv去执行target,如果execv执行失败,则向trace_bits写入EXEC_FAIL_SIG
  • 否则,就向控制管道写入prev_timed_out的值,命令Fork server开始fork出一个子进程进行fuzz,然后从状态管道读取fork server返回的fork出的子进程的ID到child_pid
  • 无论实际执行的是上面两种的哪一种,在执行target期间,都设置计数器为timeout,如果超时,就杀死正在执行的子进程,并设置child_timed_out为1;
  • 计算target执行时间exec_ms,并将total_execs这个执行次数计数器加一。
  • 等待target执行结束,如果是dumb_mode,target执行结束的状态码将直接保存到status中,如果不是dumb_mode,则从状态管道中读取target执行结束的状态码。
  • classify_counts((u64 *) trace_bits)
    • 具体地,target是将每个分支的执行次数用1个byte来储存,而fuzzer则进一步把这个执行次数归入到buckets中,举个例子,如果某分支执行了1次,那么落入第2个bucket,其计数byte仍为1;如果某分支执行了4次,那么落入第5个bucket,其计数byte将变为8,等等。
    • 这样处理之后,对分支执行次数就会有一个简单的归类。例如,如果对某个测试用例处理时,分支A执行了32次;对另外一个测试用例,分支A执行了33次,那么AFL就会认为这两次的代码覆盖是相同的。当然,这样的简单分类肯定不能区分所有的情况,不过在某种程度上,处理了一些因为循环次数的微小区别,而误判为不同执行结果的情况.
  • 设置prev_timed_out的值为child_timed_out。
  • 接着依据status的值,向调用者返回结果。
    • WIFSIGNALED(status)若为异常结束子进程返回的状态,则为真
      • WTERMSIG(status)取得子进程因信号而中止的信号代码
        • 如果child_timed_out为1,且状态码为SIGKILL,则返回FAULT_TMOUT
        • 否则返回FAULT_CRASH
    • 如果是dumb_mode,且trace_bits为EXEC_FAIL_SIG,就返回FAULT_ERROR
    • 如果timeout小于等于exec_tmout,且slowest_exec_ms小于exec_ms,设置slowest_exec_ms等于exec_ms
    • 返回FAULT_NONE

classify_counts(u64 *mem)

  • 8个字节一组去循环读入,直到遍历完整个mem
    • 每次取两个字节u16 *mem16 = (u16 *) mem
    • i从0到3,计算mem16[i]的值,在count_class_lookup16[mem16[i]]里找到对应的取值,并赋值给mem16[i]

update_bitmap_score(struct queue_entry *q)

每当我们发现一个新的路径,都会调用这个函数来判断其是不是更加地favorable,这个favorable的意思是说是否包含最小的路径集合来遍历到所有bitmap中的位,我们专注于这些集合而忽略其他的。

  • 首先计算出这个case的fav_factor,计算方法是q->exec_us * q->len即执行时间和样例大小的乘积,以这两个指标来衡量权重。
  • 遍历trace_bits数组,如果该字节的值不为0,则代表这是已经被覆盖到的path
    • 然后检查对应于这个path的top_rated是否存在
      • static struct queue_entry *top_rated[MAP_SIZE]; /* Top entries for bitmap bytes */
      • 如果存在,就比较fav_factor > top_rated[i]->exec_us * top_rated[i]->len,即比较执行时间和样例大小的乘积,哪个更小。
        • 如果top_rated[i]的更小,则代表top_rated[i]的更优,不做任何处理,继续遍历下一个path。
        • 如果q更小,就将top_rated[i]原先对应的queue entry的tc_ref字段减一,并将其trace_mini字段置为空。
        • u8 *trace_mini; /* Trace bytes, if kept */
        • u32 tc_ref; /* Trace bytes ref count */
      • 然后设置top_rated[i]为q,即当前case,然后将其tc_ref的值加一
      • 如果q->trace_mini为空,则将trace_bits经过minimize_bits压缩,然后存到trace_mini字段里
      • 设置score_changed为1.

void minimize_bits(u8 dst, u8 src)

将trace_bits压缩为较小的位图。
简单的理解就是把原本是包括了是否覆盖到和覆盖了多少次的byte,压缩成是否覆盖到的bit。
在看这个函数和下一个函数cull_queue之前,建议把经典算法系列之(一) – BitMap [数据的压缩存储]读完。

static void minimize_bits(u8 *dst, u8 *src) {

    u32 i = 0;

    while (i < MAP_SIZE) {

        if (*(src++)) dst[i >> 3] |= 1 << (i & 7);
        i++;

    }

}

虽然dst是一个bitmap,但是实际上在这里我们还是用一个byte数组来操作它,所以就首先得做byte->bit的映射,比如说将src的前0-7个字节映射到dst的第一个字节(0-7位)

>>> 0>>3
0
>>> 1>>3
0
>>> 2>>3
0
...
>>> 7>>3
0
>>> 8>>3
1

然后如果src里该字节的值不为0,i此时就代表这个字节的index索引,其与0000 0111相与,最终的结果都只在0-7之间,这样我们就可以知道这个index在0-7之间对应的具体的bit是哪一个,最后通过或运算将该位置位。

>>> 0&7
0
>>> 1&7
1
>>> 2&7
2
>>> 3&7
3
>>> 4&7
4
>>> 5&7
5
>>> 6&7
6
>>> 7&7
7
>>> 8&7
0
>>> 9&7
1

cull_queue

精简队列

  • 如果score_changed为0,即top_rated没有变化,或者dumb_mode,就直接返回
  • 设置score_changed的值为0
  • 创建u8 temp_v数组,大小为MAP_SIZE除8,并将其初始值设置为0xff,其每位如果为1就代表还没有被覆盖到,如果为0就代表以及被覆盖到了。
  • 设置queued_favored为0,pending_favored为0
  • 开始遍历queue队列,设置其favored的值都为0
  • 将i从0到MAP_SIZE迭代,这个迭代其实就是筛选出一组queue entry,它们就能够覆盖到所有现在已经覆盖到的路径,而且这个case集合里的case要更小更快,这并不是最优算法,只能算是贪婪算法。
    • 这又是个不好懂的位运算,temp_v[i >> 3] & (1 << (i & 7))与上面的差不多,中间的或运算改成了与,是为了检查该位是不是0,即判断该path对应的bit有没有被置位。
      for (i = 0; i < MAP_SIZE; i++)
        if (top_rated[i] && (temp_v[i >> 3] & (1 << (i & 7)))) {
      ...
      
    • 如果top_rated[i]有值,且该path在temp_v里被置位
      • 就从temp_v中清除掉所有top_rated[i]覆盖到的path,将对应的bit置为0
      • 设置top_rated[i]->favored为1,queued_favored计数器加一
      • 如果top_rated[i]的was_fuzzed字段是0,代表其还没有fuzz过,则将pending_favored计数器加一
    • 遍历queue队列
      • mark_as_redundant(q, !q->favored)
        • 也就是说,如果不是favored的case,就被标记成redundant_edges

mark_as_redundant(struct queue_entry *q, u8 state)

  • 如果state和q->fs_redundant相等,就直接返回
  • 设置q->fs_redundant的值为state,
  • 如果state为1
    • 尝试创建out_dir/queue/.state/redundant_edges/fname
  • 如果state为0
    • 尝试删除out_dir/queue/.state/redundant_edges/fname

show_init_stats

在处理输入目录的末尾显示统计信息,以及一堆警告,以及几个硬编码的常量。

  • 依据之前从calibrate_case里得到的total_cal_us和total_cal_cycles,计算出单轮执行的时间avg_us,如果大于10000,就警告"The target binary is pretty slow! See %s/perf_tips.txt."
    • 如果avg_us大于50000,设置havoc_div为10 / 0-19 execs/sec /
    • 大于20000,设置havoc_div为5 / 20-49 execs/sec /
    • 如果大于10000,设置havoc_div为2 / 50-100 execs/sec /
  • 如果不是resuming session,则对queue的大小和个数超限提出警告,且如果useless_at_start不为0,就警告有可以精简的样本。
  • 如果timeout_given为0,则根据avg_us来计算出exec_tmout,注意这里avg_us的单位是微秒,而exec_tmout单位是毫秒,所以需要除以1000
    • avg_us > 50000
      • exec_tmout = avg_us * 2 / 1000
    • avg_us > 10000
      • exec_tmout = avg_us * 3 / 1000
    • exec_tmout = avg_us * 5 / 1000
    • 然后在上面计算出来的exec_tmout和所有样例中执行时间最长的样例进行比较,取最大值赋给exec_tmout
    • 如果exec_tmout大于EXEC_TIMEOUT,就设置exec_tmout = EXEC_TIMEOUT
      • EXEC_TIMEOUT的值为1秒,即最大超时时间是1秒
    • 打印出"No -t option specified, so I'll use exec timeout of %u ms.", exec_tmout
    • 设置timeout_given为1
  • 如果timeout_give不为0,且为3,代表这是resuming session,直接打印"Applying timeout settings from resumed session (%u ms).", exec_tmout,此时的timeout_give是我们从历史记录里读取出的。
  • 如果是dumb_mode且没有设置环境变量AFL_HANG_TMOUT
    • 设置hang_tmout为EXEC_TIMEOUT和exec_tmout * 2 + 100中的最小值
  • All set and ready to roll!

find_start_position

resume时,请尝试查找要从其开始的队列位置,这仅在resume时以及当我们可以找到原始的fuzzer_stats时才有意义.

  • 如果不是resuming_fuzz,就直接返回
  • 如果是in_place_resume,就打开out_dir/fuzzer_stats文件,否则打开in_dir/../fuzzer_stats文件
  • 读这个文件的内容到tmp[4096]中,找到cur_path,并设置为ret的值,如果大于queued_paths就设置ret为0,返回ret。

void write_stats_file(double bitmap_cvg, double stability, double eps)

更新统计信息文件以进行无人值守的监视

  • 创建文件out_dir/fuzzer_stats
  • 写入统计信息
  • start_time
    • fuzz运行的开始时间,start_time / 1000
  • last_update
    • 当前时间
  • fuzzer_pid
    • 获取当前pid
  • cycles_done
    • queue_cyclequeue_cur为空,即执行到当前队列尾的时候才增加1,所以这代表queue队列被完全变异一次的次数。
  • execs_done
    • total_execs,target的总的执行次数,每次run_target的时候会增加1
  • execs_per_sec
    • 每秒执行的次数
  • paths_total
    • queued_paths在每次add_to_queue的时候会增加1,代表queue里的样例总数
  • paths_favored
    • queued_favored,有价值的路径总数
  • paths_found
    • queued_discovered在每次common_fuzz_stuff去执行一次fuzz时,发现新的interesting case的时候会增加1,代表在fuzz运行期间发现的新queue entry。
  • paths_imported
    • queued_imported是master-slave模式下,如果sync过来的case是interesting的,就增加1
  • max_depth
    • 最大路径深度
  • cur_path
    • current_entry一般情况下代表的是正在执行的queue entry的整数ID,queue首节点的ID是0
  • pending_favs
    • pending_favored 等待fuzz的favored paths数
  • pending_total
    • pending_not_fuzzed 在queue中等待fuzz的case数
  • variable_paths
    • queued_variable在calibrate_case去评估一个新的test case的时候,如果发现这个case的路径是可变的,则将这个计数器加一,代表发现了一个可变case
  • stability
  • bitmap_cvg
  • unique_crashes
    • unique_crashes这是在save_if_interesting时,如果fault是FAULT_CRASH,就将unique_crashes计数器加一
  • unique_hangs
    • unique_hangs这是在save_if_interesting时,如果fault是FAULT_TMOUT,且exec_tmout小于hang_tmout,就以hang_tmout为超时时间再执行一次,如果还超时,就让hang计数器加一。
  • last_path
    • add_to_queue里将一个新case加入queue时,就设置一次last_path_time为当前时间,last_path_time / 1000
  • last_crash
    • 同上,在unique_crashes加一的时候,last_crash也更新时间,last_crash_time / 1000
  • last_hang
    • 同上,在unique_hangs加一的时候,last_hang也更新时间,last_hang_time / 1000
  • execs_since_crash
    • total_execs – last_crash_execs,这里last_crash_execs是在上一次crash的时候的总计执行了多少次
  • exec_tmout
    • 配置好的超时时间,有三种可能的配置方式,见上文
    fprintf(f, "start_time        : %llu\n"
               "last_update       : %llu\n"
               "fuzzer_pid        : %u\n"
               "cycles_done       : %llu\n"
               "execs_done        : %llu\n"
               "execs_per_sec     : %0.02f\n"
               "paths_total       : %u\n"
               "paths_favored     : %u\n"
               "paths_found       : %u\n"
               "paths_imported    : %u\n"
               "max_depth         : %u\n"
               "cur_path          : %u\n" /* Must match find_start_position() */
               "pending_favs      : %u\n"
               "pending_total     : %u\n"
               "variable_paths    : %u\n"
               "stability         : %0.02f%%\n"
               "bitmap_cvg        : %0.02f%%\n"
               "unique_crashes    : %llu\n"
               "unique_hangs      : %llu\n"
               "last_path         : %llu\n"
               "last_crash        : %llu\n"
               "last_hang         : %llu\n"
               "execs_since_crash : %llu\n"
               "exec_timeout      : %u\n" /* Must match find_timeout() */
               "afl_banner        : %s\n"
               "afl_version       : " VERSION "\n"
               "target_mode       : %s%s%s%s%s%s%s\n"
               "command_line      : %s\n"
               "slowest_exec_ms   : %llu\n",
            start_time / 1000, get_cur_time() / 1000, getpid(),
            queue_cycle ? (queue_cycle - 1) : 0, total_execs, eps,
            queued_paths, queued_favored, queued_discovered, queued_imported,
            max_depth, current_entry, pending_favored, pending_not_fuzzed,
            queued_variable, stability, bitmap_cvg, unique_crashes,
            unique_hangs, last_path_time / 1000, last_crash_time / 1000,
            last_hang_time / 1000, total_execs - last_crash_execs,
            exec_tmout, use_banner,
            qemu_mode ? "qemu " : "", dumb_mode ? " dumb " : "",
            no_forkserver ? "no_forksrv " : "", crash_mode ? "crash " : "",
            persistent_mode ? "persistent " : "", deferred_mode ? "deferred " : "",
            (qemu_mode || dumb_mode || no_forkserver || crash_mode ||
             persistent_mode || deferred_mode) ? "" : "default",
            orig_cmdline, slowest_exec_ms);
  • 统计子进程的资源用量并写入。

save_auto

保存自动生成的extras

  • 如果auto_changed为0,则直接返回
  • 如果不为0,就设置为0,然后创建名为alloc_printf("%s/queue/.state/auto_extras/auto_%06u", out_dir, i);的文件,并写入a_extras的内容。

通信管道基础知识

            假设进程A拥有一个已打开的文件描述符fd3,它的状态如下
            进程A的文件描述符表(before dup2)
            ------------
            fd0 0   | p0
            ------------
            fd1 1   | p1 -------------> 文件表1 ---------> vnode1
            ------------
            fd2 2   | p2
            ------------
            fd3 3   | p3 -------------> 文件表2 ---------> vnode2
            ------------
            ... ...
            ... ...
            ------------

            经下面调用:
            n_fd = dup2(fd3, STDOUT_FILENO);后进程状态如下:

            进程A的文件描述符表(after dup2)
            ------------
            fd0 0   | p0
            ------------
            n_fd 1  | p1 ------------
            ------------               \
            fd2 2   | p2                  \
            ------------                 _\|
            fd3 3   | p3 -------------> 文件表2 ---------> vnode2

            在学习dup2时总是碰到“重定向”一词,上图完成的就是一个“从标准输出到文件的重定向”,经过dup2后进程A的任何目标为STDOUT_FILENO的I/O操作如printf等,其数据都将流入fd3所对应的文件中。下面是一个例子程序:
            #define TESTSTR "Hello dup2\n"
            int main() {
                    int     fd3;

                    fd3 = open("testdup2.dat", 0666);
                    if (fd < 0) {
                            printf("open error\n");
                            exit(-1);
                    }

                    if (dup2(fd3, STDOUT_FILENO) < 0) {       
                            printf("err in dup2\n");
                    }
                    printf(TESTSTR);
                    return 0;
            }
            其结果就是你在testdup2.dat中看到"Hello dup2"。
分享到: QQ空间 新浪微博 微信 QQ facebook twitter
|推荐阅读
|发表评论
|评论列表
加载更多