diff --git a/src/afl-analyze.c b/src/afl-analyze.c index bcb429b..633f468 100644 --- a/src/afl-analyze.c +++ b/src/afl-analyze.c @@ -1,133 +1,133 @@ /* - Copyright 2016 Google LLC All rights reserved. + 版权所有 2016 Google LLC 保留所有权利。 - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at: + 根据 Apache 许可证 2.0 版（"许可证"）授权； + 除非符合许可证的规定，否则您不得使用此文件。 + 您可以从以下网址获取许可证的副本： http://www.apache.org/licenses/LICENSE-2.0 - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. + 除非适用法律要求或书面同意，软件 + 根据许可证分发是一种"按现状"的基础， + 不提供任何形式的保证或条件，无论是明确的还是隐含的。 + 请参阅许可证以了解管理权限和 + 限制的具体语言。 */ /* - american fuzzy lop - file format analyzer + American Fuzzy Lop - 文件格式分析器 ----------------------------------------- - Written and maintained by Michal Zalewski + 作者和维护者：Michal Zalewski - A nifty utility that grabs an input file and takes a stab at explaining - its structure by observing how changes to it affect the execution path. - - If the output scrolls past the edge of the screen, pipe it to 'less -r'. + 一个很酷的工具，它获取输入文件并尝试解释 + 其结构，通过观察对其进行更改如何影响执行路径。 + 如果输出超出了屏幕边缘，请将其管道到 'less -r'。 */ -#define AFL_MAIN // 定义主程序宏 -#include "android-ashmem.h" // 包含Android共享内存支持 +#define AFL_MAIN // 定义 AFL_MAIN，表示这是 AFL 的主程序 +#include "android-ashmem.h" // 包含 Android 共享内存的头文件 #include "config.h" // 包含配置文件 -#include "types.h" // 包含类型定义 -#include "debug.h" // 包含调试工具 -#include "alloc-inl.h" // 包含内存分配工具 -#include "hash.h" // 包含哈希函数 - -#include // 标准输入输出 -#include // POSIX标准库 -#include // 标准库 -#include // 字符串处理 -#include // 时间处理 -#include // 错误处理 -#include // 信号处理 -#include // 目录操作 -#include // 文件控制 -#include // 字符处理 - -#include // 进程等待 -#include // 时间处理 -#include // 共享内存 -#include // 文件状态 -#include // 类型定义 -#include // 资源限制 - -static s32 child_pid; // 测试程序的PID - -static u8* trace_bits; // 共享内存中的插桩位图 - -static u8 *in_file, // 分析器输入测试用例 - *prog_in, // 目标程序的输入文件 - *target_path, // 目标二进制文件的路径 - *doc_path; // 文档路径 - -static u8 *in_data; // 用于分析的输入数据 - -static u32 in_len, // 输入数据长度 - orig_cksum, // 原始校验和 - total_execs, // 总执行次数 - exec_hangs, // 总挂起次数 - exec_tmout = EXEC_TIMEOUT; // 执行超时时间（毫秒） - -static u64 mem_limit = MEM_LIMIT; // 内存限制（MB） - -static s32 shm_id, // 共享内存区域的ID - dev_null_fd = -1; // /dev/null的文件描述符 - -static u8 edges_only, // 是否忽略命中计数 - use_hex_offsets, // 是否显示十六进制偏移量 - use_stdin = 1; // 是否使用stdin作为程序输入 +#include "types.h" // 包含自定义类型定义 +#include "debug.h" // 包含调试工具的头文件 +#include "alloc-inl.h" // 包含内存分配工具的头文件 +#include "hash.h" // 包含哈希函数的头文件 + +#include // 包含标准输入输出函数 +#include // 包含 Unix 标准函数 +#include // 包含标准库函数 +#include // 包含字符串处理函数 +#include // 包含时间相关函数 +#include // 包含错误处理相关函数 +#include // 包含信号处理相关函数 +#include // 包含目录操作相关函数 +#include // 包含文件控制函数 +#include // 包含字符处理函数 + +#include // 包含进程管理相关函数 +#include // 包含时间和计时器相关函数 +#include // 包含共享内存相关函数 +#include // 包含文件状态相关函数 +#include // 包含数据类型相关函数 +#include // 包含资源管理相关函数 + +static s32 child_pid; // 被测试程序的进程 ID + +static u8* trace_bits; // 用于存储仪器化位图的共享内存 + +static u8* in_file, // 分析输入测试用例的文件 + *prog_in, // 目标程序输入文件 + *target_path, // 目标二进制文件路径 + *doc_path; // 文档路径 + +static u8* in_data; // 用于分析的输入数据 + +static u32 in_len, // 输入数据长度 + orig_cksum, // 原始校验和 + total_execs, // 总执行次数 + exec_hangs, // 总挂起次数 + exec_tmout = EXEC_TIMEOUT; // 执行超时（毫秒） + +static u64 mem_limit = MEM_LIMIT; // 内存限制（MB） + +static s32 shm_id, // 共享内存区域的 ID + dev_null_fd = -1; // /dev/null 的文件描述符 + +static u8 edges_only, // 是否忽略命中计数 + use_hex_offsets, // 是否显示十六进制偏移 + use_stdin = 1; // 是否使用标准输入作为程序输入 static volatile u8 - stop_soon, // 是否按下Ctrl-C - child_timed_out; // 子进程是否超时 - + stop_soon, // 是否按下 Ctrl-C + child_timed_out; // 子进程是否超时 -/* Constants used for describing byte behavior. */ +/* 用于描述字节行为的常量. */ -#define RESP_NONE 0x00 // 改变字节无影响 -#define RESP_MINOR 0x01 // 某些改变无影响 -#define RESP_VARIABLE 0x02 // 改变产生可变路径 -#define RESP_FIXED 0x03 // 改变产生固定模式 +#define RESP_NONE 0x00 // 改变字节是无操作。 +#define RESP_MINOR 0x01 // 一些更改没有影响。 +#define RESP_VARIABLE 0x02 // 更改产生可变路径。 +#define RESP_FIXED 0x03 // 更改产生固定模式。 -#define RESP_LEN 0x04 // 可能是长度字段 -#define RESP_CKSUM 0x05 // 可能是校验和 -#define RESP_SUSPECT 0x06 // 可能是“可疑”块 +#define RESP_LEN 0x04 // 潜在的长度字段 +#define RESP_CKSUM 0x05 // 潜在的校验和 +#define RESP_SUSPECT 0x06 // 潜在的“可疑”数据块 -/* Classify tuple counts. This is a slow & naive version, but good enough here. */ +/* 分类元组计数。这是一个慢而天真的版本，但足够好了。 */ -static u8 count_class_lookup[256] = { // 计数分类查找表 +static u8 count_class_lookup[256] = { - [0] = 0, - [1] = 1, - [2] = 2, - [3] = 4, - [4 ... 7] = 8, - [8 ... 15] = 16, - [16 ... 31] = 32, - [32 ... 127] = 64, - [128 ... 255] = 128 + [0] = 0, // 0个元组 + [1] = 1, // 1个元组 + [2] = 2, // 2个元组 + [3] = 4, // 3个元组 + [4 ... 7] = 8, // 4到7个元组 + [8 ... 15] = 16, // 8到15个元组 + [16 ... 31] = 32, // 16到31个元组 + [32 ... 127] = 64, // 32到127个元组 + [128 ... 255] = 128 // 128到255个元组 }; -static void classify_counts(u8* mem) { // 分类计数 +/* 分类计数 */ - u32 i = MAP_SIZE; +static void classify_counts(u8* mem) { - if (edges_only) { // 如果只关注边缘 + u32 i = MAP_SIZE; // 初始化索引为映射大小 + + if (edges_only) { // 如果只计算边缘覆盖 while (i--) { - if (*mem) *mem = 1; // 如果有计数，设置为1 + if (*mem) *mem = 1; // 将非零值标记为1 mem++; } - } else { // 否则 + } else { // 如果不只计算边缘覆盖 while (i--) { - *mem = count_class_lookup[*mem]; // 使用查找表分类 + *mem = count_class_lookup[*mem]; // 使用查找表分类计数 mem++; } @@ -136,318 +136,310 @@ static void classify_counts(u8* mem) { // 分类计数 } -/* See if any bytes are set in the bitmap. */ +/* 检查位图中是否有任何字节被设置。 */ -static inline u8 anything_set(void) { // 检查位图中是否有任何字节被设置 +static inline u8 anything_set(void) { - u32* ptr = (u32*)trace_bits; - u32 i = (MAP_SIZE >> 2); + u32* ptr = (u32*)trace_bits; // 将位图指针转换为32位无符号整型指针 + u32 i = (MAP_SIZE >> 2); // 计算32位整型的数量 - while (i--) if (*(ptr++)) return 1; // 如果有设置，返回1 + while (i--) if (*(ptr++)) return 1; // 如果有非零值，返回1 return 0; // 否则返回0 } -/* Get rid of shared memory and temp files (atexit handler). */ +/* 删除共享内存和临时文件（atexit处理程序）。 */ -static void remove_shm(void) { // 删除共享内存和临时文件 +static void remove_shm(void) { - unlink(prog_in); // 忽略错误 + unlink(prog_in); /* 忽略错误 */ shmctl(shm_id, IPC_RMID, NULL); // 删除共享内存 } -/* Configure shared memory. */ +/* 配置共享内存。 */ -static void setup_shm(void) { // 配置共享内存 +static void setup_shm(void) { u8* shm_str; shm_id = shmget(IPC_PRIVATE, MAP_SIZE, IPC_CREAT | IPC_EXCL | 0600); // 创建共享内存 - if (shm_id < 0) PFATAL("shmget() failed"); // 如果失败，报错 + if (shm_id < 0) PFATAL("shmget() failed"); // 检查共享内存创建是否成功 - atexit(remove_shm); // 注册退出处理函数 + atexit(remove_shm); // 注册退出时调用的处理函数 - shm_str = alloc_printf("%d", shm_id); // 分配并格式化共享内存ID + shm_str = alloc_printf("%d", shm_id); // 将共享内存 ID 转换为字符串 - setenv(SHM_ENV_VAR, shm_str, 1); // 设置环境变量 + setenv(SHM_ENV_VAR, shm_str, 1); // 设置共享内存环境变量 - ck_free(shm_str); // 释放内存 + ck_free(shm_str); // 释放分配的字符串内存 - trace_bits = shmat(shm_id, NULL, 0); // 附加共享内存 + trace_bits = shmat(shm_id, NULL, 0); // 将共享内存附加到进程的地址空间 - if (trace_bits == (void *)-1) PFATAL("shmat() failed"); // 如果失败，报错 + if (trace_bits == (void *)-1) PFATAL("shmat() failed"); // 检查共享内存附加是否成功 } -/* Read initial file. */ +/* 读取初始文件。 */ -static void read_initial_file(void) { // 读取初始文件 +static void read_initial_file(void) { - struct stat st; - s32 fd = open(in_file, O_RDONLY); // 打开文件 + struct stat st; // 文件状态结构 + s32 fd = open(in_file, O_RDONLY); // 打开输入文件 - if (fd < 0) PFATAL("Unable to open '%s'", in_file); // 如果失败，报错 + if (fd < 0) PFATAL("Unable to open '%s'", in_file); // 检查文件是否成功打开 if (fstat(fd, &st) || !st.st_size) // 获取文件状态 - FATAL("Zero-sized input file."); // 如果文件大小为0，报错 + FATAL("Zero-sized input file."); // 检查文件大小是否为零 - if (st.st_size >= TMIN_MAX_FILE) // 如果文件过大 - FATAL("Input file is too large (%u MB max)", TMIN_MAX_FILE / 1024 / 1024); // 报错 + if (st.st_size >= TMIN_MAX_FILE) // 检查文件大小是否超过最大值 + FATAL("Input file is too large (%u MB max)", TMIN_MAX_FILE / 1024 / 1024); in_len = st.st_size; // 设置输入数据长度 - in_data = ck_alloc_nozero(in_len); // 分配内存 - - ck_read(fd, in_data, in_len, in_file); // 读取文件内容 + in_data = ck_alloc_nozero(in_len); // 分配内存以存储输入数据 - close(fd); // 关闭文件 + ck_read(fd, in_data, in_len, in_file); // 读取输入文件数据 - OKF("Read %u byte%s from '%s'.", in_len, in_len == 1 ? "" : "s", in_file); // 输出读取成功信息 + close(fd); // 关闭文件描述符 + OKF("Read %u byte%s from '%s'.", in_len, in_len == 1 ? "" : "s", in_file); // 输出读取的字节数 } -/* Write output file. */ +/* 写入输出文件。 */ -static s32 write_to_file(u8* path, u8* mem, u32 len) { // 写入输出文件 +static s32 write_to_file(u8* path, u8* mem, u32 len) { s32 ret; - unlink(path); // 忽略错误 + unlink(path); /* 忽略错误 */ // 删除旧文件（如果存在） - ret = open(path, O_RDWR | O_CREAT | O_EXCL, 0600); // 创建文件 + ret = open(path, O_RDWR | O_CREAT | O_EXCL, 0600); // 创建新文件 - if (ret < 0) PFATAL("Unable to create '%s'", path); // 如果失败，报错 + if (ret < 0) PFATAL("Unable to create '%s'", path); // 检查文件创建是否成功 - ck_write(ret, mem, len, path); // 写入数据 + ck_write(ret, mem, len, path); // 写入数据到新文件 - lseek(ret, 0, SEEK_SET); // 重置文件指针 + lseek(ret, 0, SEEK_SET); // 将文件指针移动到文件开头 return ret; // 返回文件描述符 - } -/* Handle timeout signal. */ +/* 处理超时信号。 */ -static void handle_timeout(int sig) { // 处理超时信号 +static void handle_timeout(int sig) { - child_timed_out = 1; // 设置超时标志 + child_timed_out = 1; // 设置标志表示子进程超时 if (child_pid > 0) kill(child_pid, SIGKILL); // 杀死子进程 } -/* Execute target application. Returns exec checksum, or 0 if program - times out. */ +/* 执行目标应用程序。返回执行校验和，如果程序超时则返回 0。 */ -static u32 run_target(char** argv, u8* mem, u32 len, u8 first_run) { // 执行目标程序 +static u32 run_target(char** argv, u8* mem, u32 len, u8 first_run) { - static struct itimerval it; - int status = 0; + static struct itimerval it; // 定义计时器 + int status = 0; // 定义状态码 - s32 prog_in_fd; - u32 cksum; + s32 prog_in_fd; // 程序输入文件描述符 + u32 cksum; // 校验和 - memset(trace_bits, 0, MAP_SIZE); // 清空位图 - MEM_BARRIER(); // 内存屏障 + memset(trace_bits, 0, MAP_SIZE); // 清空轨迹位图 + MEM_BARRIER(); // 保证内存操作的顺序 - prog_in_fd = write_to_file(prog_in, mem, len); // 写入输入文件 + prog_in_fd = write_to_file(prog_in, mem, len); // 写入输入数据到临时文件 child_pid = fork(); // 创建子进程 - if (child_pid < 0) PFATAL("fork() failed"); // 如果失败，报错 + if (child_pid < 0) PFATAL("fork() failed"); // 检查是否成功创建子进程 - if (!child_pid) { // 子进程 + if (!child_pid) { // 如果是子进程 - struct rlimit r; + struct rlimit r; // 定义资源限制结构 - if (dup2(use_stdin ? prog_in_fd : dev_null_fd, 0) < 0 || // 重定向stdin - dup2(dev_null_fd, 1) < 0 || // 重定向stdout - dup2(dev_null_fd, 2) < 0) { // 重定向stderr + if (dup2(use_stdin ? prog_in_fd : dev_null_fd, 0) < 0 || // 重定向标准输入 + dup2(dev_null_fd, 1) < 0 || // 重定向标准输出 + dup2(dev_null_fd, 2) < 0) { // 重定向标准错误 - *(u32*)trace_bits = EXEC_FAIL_SIG; // 设置失败标志 - PFATAL("dup2() failed"); // 如果失败，报错 + *(u32*)trace_bits = EXEC_FAIL_SIG; // 设置执行失败信号 + PFATAL("dup2() failed"); // 检查重定向是否成功 } - close(dev_null_fd); // 关闭/dev/null - close(prog_in_fd); // 关闭输入文件 + close(dev_null_fd); // 关闭 /dev/null 文件描述符 + close(prog_in_fd); // 关闭程序输入文件描述符 if (mem_limit) { // 如果设置了内存限制 - r.rlim_max = r.rlim_cur = ((rlim_t)mem_limit) << 20; // 设置内存限制 + r.rlim_max = r.rlim_cur = ((rlim_t)mem_limit) << 20; // 设置资源限制 #ifdef RLIMIT_AS - - setrlimit(RLIMIT_AS, &r); // 忽略错误 - + setrlimit(RLIMIT_AS, &r); /* 忽略错误 */ #else - - setrlimit(RLIMIT_DATA, &r); // 忽略错误 - + setrlimit(RLIMIT_DATA, &r); /* 忽略错误 */ #endif /* ^RLIMIT_AS */ } - r.rlim_max = r.rlim_cur = 0; - setrlimit(RLIMIT_CORE, &r); // 忽略错误 + r.rlim_max = r.rlim_cur = 0; // 禁止核心转储 + setrlimit(RLIMIT_CORE, &r); /* 忽略错误 */ execv(target_path, argv); // 执行目标程序 - *(u32*)trace_bits = EXEC_FAIL_SIG; // 设置失败标志 - exit(0); // 退出 + *(u32*)trace_bits = EXEC_FAIL_SIG; // 设置执行失败信号 + exit(0); // 退出子进程 } - close(prog_in_fd); // 关闭输入文件 + close(prog_in_fd); // 关闭程序输入文件描述符 - /* Configure timeout, wait for child, cancel timeout. */ + /* 配置超时，等待子进程，取消超时。 */ child_timed_out = 0; // 重置超时标志 - it.it_value.tv_sec = (exec_tmout / 1000); // 设置超时时间 - it.it_value.tv_usec = (exec_tmout % 1000) * 1000; + it.it_value.tv_sec = (exec_tmout / 1000); // 设置秒数 + it.it_value.tv_usec = (exec_tmout % 1000) * 1000; // 设置微秒数 - setitimer(ITIMER_REAL, &it, NULL); // 设置定时器 + setitimer(ITIMER_REAL, &it, NULL); // 设置计时器 - if (waitpid(child_pid, &status, 0) <= 0) FATAL("waitpid() failed"); // 等待子进程 + if (waitpid(child_pid, &status, 0) <= 0) FATAL("waitpid() failed"); // 等待子进程执行完毕 - child_pid = 0; // 重置子进程PID - it.it_value.tv_sec = 0; // 重置定时器 - it.it_value.tv_usec = 0; + child_pid = 0; // 重置子进程 ID + it.it_value.tv_sec = 0; // 重置计时器秒数 + it.it_value.tv_usec = 0; // 重置计时器微秒数 - setitimer(ITIMER_REAL, &it, NULL); // 取消定时器 + setitimer(ITIMER_REAL, &it, NULL); // 取消计时器 - MEM_BARRIER(); // 内存屏障 + MEM_BARRIER(); // 保证内存操作的顺序 - /* Clean up bitmap, analyze exit condition, etc. */ + /* 清理位图，分析退出情况等。 */ - if (*(u32*)trace_bits == EXEC_FAIL_SIG) // 如果执行失败 - FATAL("Unable to execute '%s'", argv[0]); // 报错 + if (*(u32*)trace_bits == EXEC_FAIL_SIG) // 如果执行失败信号被设置 + FATAL("无法执行 '%s'", argv[0]); // 输出错误信息 - classify_counts(trace_bits); // 分类计数 - total_execs++; // 增加执行次数 + classify_counts(trace_bits); // 分类轨迹位图中的计数 + total_execs++; // 总执行次数加一 - if (stop_soon) { // 如果用户中止 - SAYF(cRST cLRD "\n+++ Analysis aborted by user +++\n" cRST); // 输出中止信息 - exit(1); // 退出 + if (stop_soon) { + SAYF(cRST cLRD "\n+++ 用户中止分析 +++\n" cRST); // 输出分析中止提示 + exit(1); // 退出程序 } - /* Always discard inputs that time out. */ + /* 始终丢弃超时的输入。 */ - if (child_timed_out) { // 如果超时 + if (child_timed_out) { // 如果子进程超时 - exec_hangs++; // 增加挂起次数 - return 0; // 返回0 + exec_hangs++; // 挂起次数加一 + return 0; // 返回0表示超时 } - cksum = hash32(trace_bits, MAP_SIZE, HASH_CONST); // 计算校验和 + cksum = hash32(trace_bits, MAP_SIZE, HASH_CONST); // 计算轨迹位图的哈希值 - /* We don't actually care if the target is crashing or not, - except that when it does, the checksum should be different. */ + /* 我们实际上并不在乎目标程序是否崩溃， + 除非它崩溃，校验和应该是不同的。 */ - if (WIFSIGNALED(status) || // 如果子进程被信号终止 - (WIFEXITED(status) && WEXITSTATUS(status) == MSAN_ERROR) || // 如果MSAN错误 - (WIFEXITED(status) && WEXITSTATUS(status))) { // 如果非正常退出 + if (WIFSIGNALED(status) || // 如果进程被信号终止 + (WIFEXITED(status) && WEXITSTATUS(status) == MSAN_ERROR) || // 如果进程以错误状态退出 + (WIFEXITED(status) && WEXITSTATUS(status))) { // 如果进程以非零状态退出 - cksum ^= 0xffffffff; // 反转校验和 + cksum ^= 0xffffffff; // 取反校验和 } - if (first_run) orig_cksum = cksum; // 如果是第一次运行，保存原始校验和 + if (first_run) orig_cksum = cksum; // 如果是第一次运行，更新原始校验和 return cksum; // 返回校验和 - } -#ifdef USE_COLOR +/* 帮助函数，显示可读的字符。 */ -/* Helper function to display a human-readable character. */ +#ifdef USE_COLOR -static void show_char(u8 val) { // 显示可读字符 +static void show_char(u8 val) { switch (val) { - case 0 ... 32: - case 127 ... 255: SAYF("#%02x", val); break; // 显示十六进制值 + case 0 ... 32: // 控制字符 + case 127 ... 255: SAYF("#%02x", val); break; // 显示字符的十六进制值 - default: SAYF(" %c ", val); // 显示字符 + default: SAYF(" %c ", val); // 显示可读字符 } } -/* Show the legend */ +/* 显示图例 */ -static void show_legend(void) { // 显示图例 +static void show_legend(void) { - SAYF(" " cLGR bgGRA " 01 " cRST " - no-op block " - cBLK bgLGN " 01 " cRST " - suspected length field\n" - " " cBRI bgGRA " 01 " cRST " - superficial content " - cBLK bgYEL " 01 " cRST " - suspected cksum or magic int\n" - " " cBLK bgCYA " 01 " cRST " - critical stream " - cBLK bgLRD " 01 " cRST " - suspected checksummed block\n" - " " cBLK bgMGN " 01 " cRST " - \"magic value\" section\n\n"); + SAYF(" " cLGR bgGRA " 01 " cRST " - 无操作块 " + cBLK bgLGN " 01 " cRST " - 可疑长度字段\n" + " " cBRI bgGRA " 01 " cRST " - 表面内容 " + cBLK bgYEL " 01 " cRST " - 可疑的校验和或魔法整数\n" + " " cBLK bgCYA " 01 " cRST " - 关键流 " + cBLK bgLRD " 01 " cRST " - 可疑的校验和块\n" + " " cBLK bgMGN " 01 " cRST " - “魔法值”部分\n\n"); // 显示不同类型的说明 } #endif /* USE_COLOR */ -/* Interpret and report a pattern in the input file. */ +/* 解释并报告输入文件中的模式。 */ -static void dump_hex(u8* buf, u32 len, u8* b_data) { // 解释并报告输入文件中的模式 +static void dump_hex(u8* buf, u32 len, u8* b_data) { u32 i; for (i = 0; i < len; i++) { #ifdef USE_COLOR - u32 rlen = 1, off; + u32 rlen = 1, off; // 当前运行长度和偏移量 #else - u32 rlen = 1; + u32 rlen = 1; // 当前运行长度 #endif /* ^USE_COLOR */ - u8 rtype = b_data[i] & 0x0f; + u8 rtype = b_data[i] & 0x0f; // 获取当前类型 - /* Look ahead to determine the length of run. */ + /* 向前查看以确定运行长度。 */ - while (i + rlen < len && (b_data[i] >> 7) == (b_data[i + rlen] >> 7)) { // 查找连续相同类型 + while (i + rlen < len && (b_data[i] >> 7) == (b_data[i + rlen] >> 7)) { // 检查相同类型的连续性 - if (rtype < (b_data[i + rlen] & 0x0f)) rtype = b_data[i + rlen] & 0x0f; - rlen++; + if (rtype < (b_data[i + rlen] & 0x0f)) rtype = b_data[i + rlen] & 0x0f; // 更新类型 + rlen++; // 增加长度 } - /* Try to do some further classification based on length & value. */ + /* 根据长度和数值进行进一步分类。 */ - if (rtype == RESP_FIXED) { // 如果是固定模式 + if (rtype == RESP_FIXED) { // 如果是固定类型 - switch (rlen) { + switch (rlen) { // 根据长度分类 - case 2: { // 2字节 + case 2: { // 长度为2 - u16 val = *(u16*)(in_data + i); + u16 val = *(u16*)(in_data + i); // 获取16位值 - /* Small integers may be length fields. */ + /* 小整数可能是长度字段。 */ - if (val && (val <= in_len || SWAP16(val) <= in_len)) { // 可能是长度字段 - rtype = RESP_LEN; + if (val && (val <= in_len || SWAP16(val) <= in_len)) { + rtype = RESP_LEN; // 更新为长度字段 break; } - /* Uniform integers may be checksums. */ + /* 均匀整数可能是校验和。 */ - if (val && abs(in_data[i] - in_data[i + 1]) > 32) { // 可能是校验和 - rtype = RESP_CKSUM; + if (val && abs(in_data[i] - in_data[i + 1]) > 32) { + rtype = RESP_CKSUM; // 更新为校验和 break; } @@ -455,23 +447,23 @@ static void dump_hex(u8* buf, u32 len, u8* b_data) { // 解释并报告输入 } - case 4: { // 4字节 + case 4: { // 长度为4 - u32 val = *(u32*)(in_data + i); + u32 val = *(u32*)(in_data + i); // 获取32位值 - /* Small integers may be length fields. */ + /* 小整数可能是长度字段。 */ - if (val && (val <= in_len || SWAP32(val) <= in_len)) { // 可能是长度字段 - rtype = RESP_LEN; + if (val && (val <= in_len || SWAP32(val) <= in_len)) { + rtype = RESP_LEN; // 更新为长度字段 break; } - /* Uniform integers may be checksums. */ + /* 均匀整数可能是校验和。 */ if (val && (in_data[i] >> 7 != in_data[i + 1] >> 7 || in_data[i] >> 7 != in_data[i + 2] >> 7 || - in_data[i] >> 7 != in_data[i + 3] >> 7)) { // 可能是校验和 - rtype = RESP_CKSUM; + in_data[i] >> 7 != in_data[i + 3] >> 7)) { + rtype = RESP_CKSUM; // 更新为校验和 break; } @@ -479,73 +471,73 @@ static void dump_hex(u8* buf, u32 len, u8* b_data) { // 解释并报告输入 } - case 1: case 3: case 5 ... MAX_AUTO_EXTRA - 1: break; + case 1: case 3: case 5 ... MAX_AUTO_EXTRA - 1: break; // 处理其他长度 - default: rtype = RESP_SUSPECT; // 可能是可疑块 + default: rtype = RESP_SUSPECT; // 标记为可疑 } } - /* Print out the entire run. */ + /* 打印整个运行。 */ #ifdef USE_COLOR - for (off = 0; off < rlen; off++) { // 打印整个连续块 + for (off = 0; off < rlen; off++) { // 逐个输出每个字符 - /* Every 16 digits, display offset. */ + /* 每16个数字显示一次偏移。 */ - if (!((i + off) % 16)) { // 每16字节显示偏移量 + if (!((i + off) % 16)) { // 检查是否需要显示偏移 - if (off) SAYF(cRST cLCY ">"); + if (off) SAYF(cRST cLCY ">"); // 显示分隔符 - if (use_hex_offsets) // 如果使用十六进制偏移量 - SAYF(cRST cGRA "%s[%06x] " cRST, (i + off) ? "\n" : "", i + off); + if (use_hex_offsets) + SAYF(cRST cGRA "%s[%06x] " cRST, (i + off) ? "\n" : "", i + off); // 显示偏移 else - SAYF(cRST cGRA "%s[%06u] " cRST, (i + off) ? "\n" : "", i + off); + SAYF(cRST cGRA "%s[%06u] " cRST, (i + off) ? "\n" : "", i + off); // 显示偏移 } switch (rtype) { // 根据类型设置颜色 - case RESP_NONE: SAYF(cLGR bgGRA); break; - case RESP_MINOR: SAYF(cBRI bgGRA); break; - case RESP_VARIABLE: SAYF(cBLK bgCYA); break; - case RESP_FIXED: SAYF(cBLK bgMGN); break; - case RESP_LEN: SAYF(cBLK bgLGN); break; - case RESP_CKSUM: SAYF(cBLK bgYEL); break; - case RESP_SUSPECT: SAYF(cBLK bgLRD); break; + case RESP_NONE: SAYF(cLGR bgGRA); break; // 无操作 + case RESP_MINOR: SAYF(cBRI bgGRA); break; // 小改动 + case RESP_VARIABLE: SAYF(cBLK bgCYA); break; // 可变 + case RESP_FIXED: SAYF(cBLK bgMGN); break; // 固定 + case RESP_LEN: SAYF(cBLK bgLGN); break; // 长度字段 + case RESP_CKSUM: SAYF(cBLK bgYEL); break; // 校验和 + case RESP_SUSPECT: SAYF(cBLK bgLRD); break; // 可疑 } - show_char(in_data[i + off]); // 显示字符 + show_char(in_data[i + off]); // 输出字符 - if (off != rlen - 1 && (i + off + 1) % 16) SAYF(" "); else SAYF(cRST " "); // 处理空格 + if (off != rlen - 1 && (i + off + 1) % 16) SAYF(" "); else SAYF(cRST " "); // 控制输出格式 } #else - if (use_hex_offsets) // 如果使用十六进制偏移量 - SAYF(" Offset %x, length %u: ", i, rlen); + if (use_hex_offsets) + SAYF(" 偏移 %x, 长度 %u: ", i, rlen); // 输出偏移和长度 else - SAYF(" Offset %u, length %u: ", i, rlen); + SAYF(" 偏移 %u, 长度 %u: ", i, rlen); // 输出偏移和长度 - switch (rtype) { // 根据类型输出描述 + switch (rtype) { // 根据类型输出对应信息 - case RESP_NONE: SAYF("no-op block\n"); break; - case RESP_MINOR: SAYF("superficial content\n"); break; - case RESP_VARIABLE: SAYF("critical stream\n"); break; - case RESP_FIXED: SAYF("\"magic value\" section\n"); break; - case RESP_LEN: SAYF("suspected length field\n"); break; - case RESP_CKSUM: SAYF("suspected cksum or magic int\n"); break; - case RESP_SUSPECT: SAYF("suspected checksummed block\n"); break; + case RESP_NONE: SAYF("无操作块\n"); break; // 无操作 + case RESP_MINOR: SAYF("表面内容\n"); break; // 小改动 + case RESP_VARIABLE: SAYF("关键流\n"); break; // 关键流 + case RESP_FIXED: SAYF("\"魔法值\"部分\n"); break; // 固定部分 + case RESP_LEN: SAYF("可疑长度字段\n"); break; // 可疑长度字段 + case RESP_CKSUM: SAYF("可疑的校验和\n"); break; // 可疑校验和 + case RESP_SUSPECT: SAYF("可疑的校验块\n"); break; // 可疑校验块 } #endif /* ^USE_COLOR */ - i += rlen - 1; // 跳过已处理的字节 + i += rlen - 1; // 更新索引 } @@ -556,102 +548,98 @@ static void dump_hex(u8* buf, u32 len, u8* b_data) { // 解释并报告输入 } -/* Actually analyze! */ +/* 实际分析！ */ -static void analyze(char** argv) { // 实际分析函数 +static void analyze(char** argv) { u32 i; - u32 boring_len = 0, prev_xff = 0, prev_x01 = 0, prev_s10 = 0, prev_a10 = 0; + u32 boring_len = 0, prev_xff = 0, prev_x01 = 0, prev_s10 = 0, prev_a10 = 0; // 初始化之前的统计 - u8* b_data = ck_alloc(in_len + 1); // 分配行为数据数组 - u8 seq_byte = 0; + u8* b_data = ck_alloc(in_len + 1); // 分配存储分析结果的内存 + u8 seq_byte = 0; // 初始化序列字节 - b_data[in_len] = 0xff; /* Intentional terminator. */ // 设置终止符 + b_data[in_len] = 0xff; /* 设置结尾标识符. */ - ACTF("Analyzing input file (this may take a while)...\n"); // 输出分析提示 + ACTF("分析输入文件（这可能需要一段时间）...\n"); // 开始分析 #ifdef USE_COLOR show_legend(); // 显示图例 #endif /* USE_COLOR */ - for (i = 0; i < in_len; i++) { // 遍历输入文件的每个字节 + for (i = 0; i < in_len; i++) { // 遍历输入数据的每一个字节 - u32 xor_ff, xor_01, sub_10, add_10; - u8 xff_orig, x01_orig, s10_orig, a10_orig; + u32 xor_ff, xor_01, sub_10, add_10; // 初始化不同操作的校验和 + u8 xff_orig, x01_orig, s10_orig, a10_orig; // 原始校验和 - /* Perform walking byte adjustments across the file. We perform four - operations designed to elicit some response from the underlying - code. */ + /* 对文件执行字节调整以获得响应。 */ - in_data[i] ^= 0xff; // 对当前字节进行异或操作 + in_data[i] ^= 0xff; // 执行 XFF 操作（按位取反） xor_ff = run_target(argv, in_data, in_len, 0); // 运行目标程序并获取校验和 - in_data[i] ^= 0xfe; // 再次异或操作 + in_data[i] ^= 0xfe; // 执行 X01 操作 xor_01 = run_target(argv, in_data, in_len, 0); // 运行目标程序并获取校验和 - in_data[i] = (in_data[i] ^ 0x01) - 0x10; // 对当前字节进行减操作 + in_data[i] = (in_data[i] ^ 0x01) - 0x10; // 执行减操作 sub_10 = run_target(argv, in_data, in_len, 0); // 运行目标程序并获取校验和 - in_data[i] += 0x20; // 对当前字节进行加操作 + in_data[i] += 0x20; // 执行加操作 add_10 = run_target(argv, in_data, in_len, 0); // 运行目标程序并获取校验和 - in_data[i] -= 0x10; // 恢复原始值 - - /* Classify current behavior. */ + in_data[i] -= 0x10; // 恢复原始数据 - xff_orig = (xor_ff == orig_cksum); // 检查异或操作后的校验和是否与原始校验和相同 - x01_orig = (xor_01 == orig_cksum); // 检查异或操作后的校验和是否与原始校验和相同 - s10_orig = (sub_10 == orig_cksum); // 检查减操作后的校验和是否与原始校验和相同 - a10_orig = (add_10 == orig_cksum); // 检查加操作后的校验和是否与原始校验和相同 + /* 当前行为的分类。 */ - if (xff_orig && x01_orig && s10_orig && a10_orig) { // 如果所有操作后的校验和都与原始校验和相同 + xff_orig = (xor_ff == orig_cksum); // 检查是否与原始校验和相同 + x01_orig = (xor_01 == orig_cksum); + s10_orig = (sub_10 == orig_cksum); + a10_orig = (add_10 == orig_cksum); - b_data[i] = RESP_NONE; // 标记为无影响 - boring_len++; // 增加无影响字节计数 + if (xff_orig && x01_orig && s10_orig && a10_orig) { // 所有操作都没有影响 + b_data[i] = RESP_NONE; // 标记为无操作 + boring_len++; // 无操作计数加一 - } else if (xff_orig || x01_orig || s10_orig || a10_orig) { // 如果部分操作后的校验和与原始校验和相同 + } else if (xff_orig || x01_orig || s10_orig || a10_orig) { // 某些操作有影响 + b_data[i] = RESP_MINOR; // 标记为小改动 + boring_len++; // 无操作计数加一 - b_data[i] = RESP_MINOR; // 标记为轻微影响 - boring_len++; // 增加无影响字节计数 - - } else if (xor_ff == xor_01 && xor_ff == sub_10 && xor_ff == add_10) { // 如果所有操作后的校验和相同 - - b_data[i] = RESP_FIXED; // 标记为固定模式 - - } else b_data[i] = RESP_VARIABLE; // 否则标记为可变模式 - - /* When all checksums change, flip most significant bit of b_data. */ + } else if (xor_ff == xor_01 && xor_ff == sub_10 && xor_ff == add_10) { // 所有结果相同 + b_data[i] = RESP_FIXED; // 标记为固定 + } else { + b_data[i] = RESP_VARIABLE; // 标记为变量 + } - if (prev_xff != xor_ff && prev_x01 != xor_01 && // 如果所有操作后的校验和都发生变化 - prev_s10 != sub_10 && prev_a10 != add_10) seq_byte ^= 0x80; // 翻转最高位 + /* 当所有校验和都改变时，翻转 b_data 的最高有效位。 */ - b_data[i] |= seq_byte; // 更新行为数据 + if (prev_xff != xor_ff && prev_x01 != xor_01 && + prev_s10 != sub_10 && prev_a10 != add_10) { + seq_byte ^= 0x80; // 翻转序列字节的最高位 + } - prev_xff = xor_ff; // 更新前一个异或操作后的校验和 - prev_x01 = xor_01; // 更新前一个异或操作后的校验和 - prev_s10 = sub_10; // 更新前一个减操作后的校验和 - prev_a10 = add_10; // 更新前一个加操作后的校验和 + b_data[i] |= seq_byte; // 更新 b_data 对应字节 + prev_xff = xor_ff; // 更新之前的校验和 + prev_x01 = xor_01; + prev_s10 = sub_10; + prev_a10 = add_10; } - dump_hex(in_data, in_len, b_data); // 输出分析结果 + dump_hex(in_data, in_len, b_data); // 输出十六进制字节信息 - SAYF("\n"); + SAYF("\n"); // 换行 - OKF("Analysis complete. Interesting bits: %0.02f%% of the input file.", // 输出分析完成信息 - 100.0 - ((double)boring_len * 100) / in_len); + OKF("分析完成。 有趣的部分: %0.02f%% 的输入文件。", + 100.0 - ((double)boring_len * 100) / in_len); // 输出分析结果 - if (exec_hangs) // 如果有超时 - WARNF(cLRD "Encountered %u timeouts - results may be skewed." cRST, // 输出警告 - exec_hangs); + if (exec_hangs) // 检查是否有挂起 + WARNF(cLRD "遇到 %u 个超时 - 结果可能会失真。" cRST, exec_hangs); - ck_free(b_data); // 释放行为数据数组 + ck_free(b_data); // 释放 b_data 占用的内存 } -/* Handle Ctrl-C and the like. */ +/* 处理 Ctrl-C 等信号。 */ -static void handle_stop_sig(int sig) { // 处理停止信号 +static void handle_stop_sig(int sig) { stop_soon = 1; // 设置停止标志 @@ -660,433 +648,411 @@ static void handle_stop_sig(int sig) { // 处理停止信号 } -/* Do basic preparations - persistent fds, filenames, etc. */ +/* 进行基本准备 - 持久文件描述符、文件名等。 */ -static void set_up_environment(void) { // 设置环境 +static void set_up_environment(void) { u8* x; - dev_null_fd = open("/dev/null", O_RDWR); // 打开/dev/null - if (dev_null_fd < 0) PFATAL("Unable to open /dev/null"); // 如果失败，报错 + dev_null_fd = open("/dev/null", O_RDWR); // 打开 /dev/null + if (dev_null_fd < 0) PFATAL("无法打开 /dev/null"); // 检查打开是否成功 - if (!prog_in) { // 如果没有指定输入文件 + if (!prog_in) { // 如果程序输入未指定 - u8* use_dir = "."; + u8* use_dir = "."; // 默认使用当前目录 - if (access(use_dir, R_OK | W_OK | X_OK)) { // 检查当前目录是否可访问 + if (access(use_dir, R_OK | W_OK | X_OK)) { // 检查权限 - use_dir = getenv("TMPDIR"); // 获取临时目录 - if (!use_dir) use_dir = "/tmp"; // 如果没有设置，使用/tmp + use_dir = getenv("TMPDIR"); // 获取 TMPDIR 环境变量 + if (!use_dir) use_dir = "/tmp"; // 如果不存在，则使用/tmp } - prog_in = alloc_printf("%s/.afl-analyze-temp-%u", use_dir, getpid()); // 生成临时文件路径 + prog_in = alloc_printf("%s/.afl-analyze-temp-%u", use_dir, getpid()); // 创建临时程序输入文件名 } - /* Set sane defaults... */ + /* 设置合理的默认值... */ - x = getenv("ASAN_OPTIONS"); // 获取ASAN选项 + x = getenv("ASAN_OPTIONS"); // 获取 ASAN_OPTIONS 环境变量 - if (x) { // 如果设置了ASAN选项 + if (x) { // 如果环境变量存在 - if (!strstr(x, "abort_on_error=1")) // 检查是否设置了abort_on_error - FATAL("Custom ASAN_OPTIONS set without abort_on_error=1 - please fix!"); + if (!strstr(x, "abort_on_error=1")) + FATAL("自定义 ASAN_OPTIONS 设置时未包含 abort_on_error=1 - 请修复！"); - if (!strstr(x, "symbolize=0")) // 检查是否设置了symbolize - FATAL("Custom ASAN_OPTIONS set without symbolize=0 - please fix!"); + if (!strstr(x, "symbolize=0")) + FATAL("自定义 ASAN_OPTIONS 设置时未包含 symbolize=0 - 请修复！"); } - x = getenv("MSAN_OPTIONS"); // 获取MSAN选项 + x = getenv("MSAN_OPTIONS"); // 获取 MSAN_OPTIONS 环境变量 - if (x) { // 如果设置了MSAN选项 + if (x) { // 如果环境变量存在 - if (!strstr(x, "exit_code=" STRINGIFY(MSAN_ERROR))) // 检查是否设置了exit_code - FATAL("Custom MSAN_OPTIONS set without exit_code=" - STRINGIFY(MSAN_ERROR) " - please fix!"); + if (!strstr(x, "exit_code=" STRINGIFY(MSAN_ERROR))) + FATAL("自定义 MSAN_OPTIONS 设置时未包含 exit_code=" + STRINGIFY(MSAN_ERROR) " - 请修复！"); - if (!strstr(x, "symbolize=0")) // 检查是否设置了symbolize - FATAL("Custom MSAN_OPTIONS set without symbolize=0 - please fix!"); + if (!strstr(x, "symbolize=0")) + FATAL("自定义 MSAN_OPTIONS 设置时未包含 symbolize=0 - 请修复！"); } - setenv("ASAN_OPTIONS", "abort_on_error=1:" // 设置ASAN选项 + // 设置默认的环境变量 + setenv("ASAN_OPTIONS", "abort_on_error=1:" "detect_leaks=0:" "symbolize=0:" "allocator_may_return_null=1", 0); - setenv("MSAN_OPTIONS", "exit_code=" STRINGIFY(MSAN_ERROR) ":" // 设置MSAN选项 + setenv("MSAN_OPTIONS", "exit_code=" STRINGIFY(MSAN_ERROR) ":" "symbolize=0:" "abort_on_error=1:" "allocator_may_return_null=1:" "msan_track_origins=0", 0); - if (getenv("AFL_PRELOAD")) { // 如果设置了AFL_PRELOAD - setenv("LD_PRELOAD", getenv("AFL_PRELOAD"), 1); // 设置LD_PRELOAD - setenv("DYLD_INSERT_LIBRARIES", getenv("AFL_PRELOAD"), 1); // 设置DYLD_INSERT_LIBRARIES + if (getenv("AFL_PRELOAD")) { // 检查 AFL_PRELOAD 环境变量 + setenv("LD_PRELOAD", getenv("AFL_PRELOAD"), 1); // 设置预加载库 + setenv("DYLD_INSERT_LIBRARIES", getenv("AFL_PRELOAD"), 1); // 设置动态链接库 } } -/* Setup signal handlers, duh. */ +/* 设置信号处理程序。 */ -static void setup_signal_handlers(void) { // 设置信号处理函数 +static void setup_signal_handlers(void) { - struct sigaction sa; + struct sigaction sa; // 定义信号行为结构 - sa.sa_handler = NULL; - sa.sa_flags = SA_RESTART; - sa.sa_sigaction = NULL; + sa.sa_handler = NULL; // 初始化处理程序 + sa.sa_flags = SA_RESTART; // 设置重启标志 + sa.sa_sigaction = NULL; // 初始化信号动作 - sigemptyset(&sa.sa_mask); + sigemptyset(&sa.sa_mask); // 初始化信号集 - /* Various ways of saying "stop". */ + /* 多种“停止”的方式。 */ - sa.sa_handler = handle_stop_sig; // 设置停止信号处理函数 - sigaction(SIGHUP, &sa, NULL); - sigaction(SIGINT, &sa, NULL); - sigaction(SIGTERM, &sa, NULL); + sa.sa_handler = handle_stop_sig; // 设置处理Ctrl-C等信号的行为 + sigaction(SIGHUP, &sa, NULL); // 捕捉挂起信号 + sigaction(SIGINT, &sa, NULL); // 捕捉中断信号 + sigaction(SIGTERM, &sa, NULL); // 捕捉终止信号 - /* Exec timeout notifications. */ + /* 执行超时通知。 */ - sa.sa_handler = handle_timeout; // 设置超时信号处理函数 - sigaction(SIGALRM, &sa, NULL); + sa.sa_handler = handle_timeout; // 设置处理超时的行为 + sigaction(SIGALRM, &sa, NULL); // 捕捉超时信号 } -/* Detect @@ in args. */ +/* 检测命令行参数中是否有 @@。 */ -static void detect_file_args(char** argv) { // 检测参数中的@@ +static void detect_file_args(char** argv) { - u32 i = 0; + u32 i = 0; // 初始化循环索引 u8* cwd = getcwd(NULL, 0); // 获取当前工作目录 - if (!cwd) PFATAL("getcwd() failed"); // 如果失败，报错 + if (!cwd) PFATAL("getcwd() failed"); // 检查获取工作目录是否成功 while (argv[i]) { // 遍历参数 - u8* aa_loc = strstr(argv[i], "@@"); // 查找@@ + u8* aa_loc = strstr(argv[i], "@@"); // 查找 @@ 字符串 - if (aa_loc) { // 如果找到@@ + if (aa_loc) { // 如果找到 @@ u8 *aa_subst, *n_arg; - /* Be sure that we're always using fully-qualified paths. */ + /* 确保我们总是使用完全合格的路径。 */ - if (prog_in[0] == '/') aa_subst = prog_in; // 如果输入文件是绝对路径，直接使用 - else aa_subst = alloc_printf("%s/%s", cwd, prog_in); // 否则拼接当前目录 + if (prog_in[0] == '/') aa_subst = prog_in; // 直接使用绝对路径 + else aa_subst = alloc_printf("%s/%s", cwd, prog_in); // 拼接当前工作目录和输入文件 - /* Construct a replacement argv value. */ + /* 构造替换的参数值。 */ - *aa_loc = 0; // 截断字符串 - n_arg = alloc_printf("%s%s%s", argv[i], aa_subst, aa_loc + 2); // 构造新参数 - argv[i] = n_arg; // 替换参数 - *aa_loc = '@'; // 恢复@@ + *aa_loc = 0; // 将 @@ 替换为字符串结束符 + n_arg = alloc_printf("%s%s%s", argv[i], aa_subst, aa_loc + 2); // 创建新的参数值 + argv[i] = n_arg; // 更新参数 + *aa_loc = '@'; // 还原 @@ - if (prog_in[0] != '/') ck_free(aa_subst); // 释放内存 + if (prog_in[0] != '/') ck_free(aa_subst); // 释放临时分配的路径内存 } - i++; + i++; // 移动到下一个参数 } - free(cwd); /* not tracked */ // 释放当前工作目录 + free(cwd); // 释放获取的工作目录内存 } -/* Display usage hints. */ +/* 显示用法提示。 */ -static void usage(u8* argv0) { // 显示用法提示 +static void usage(u8* argv0) { SAYF("\n%s [ options ] -- /path/to/target_app [ ... ]\n\n" - "Required parameters:\n\n" - - " -i file - input test case to be analyzed by the tool\n" + "所需参数：\n\n" - "Execution control settings:\n\n" + " -i file - 输入测试用例，由工具分析\n" - " -f file - input file read by the tested program (stdin)\n" - " -t msec - timeout for each run (%u ms)\n" - " -m megs - memory limit for child process (%u MB)\n" - " -Q - use binary-only instrumentation (QEMU mode)\n\n" + "执行控制设置：\n\n" - "Analysis settings:\n\n" + " -f file - 由被测程序读取的输入文件（stdin）\n" + " -t msec - 每次运行的超时时间（%u 毫秒）\n" + " -m megs - 子进程的内存限制（%u MB)\n" + " -Q - 使用仅二进制的仪器（QEMU 模式）\n\n" - " -e - look for edge coverage only, ignore hit counts\n\n" + "分析设置：\n\n" - "Other stuff:\n\n" + " -e - 仅查找边缘覆盖，忽略命中计数\n\n" - " -V - show version number and exit\n\n" + "其他信息：\n\n" - "For additional tips, please consult %s/README.\n\n", + " -V - 显示版本号并退出\n\n" - argv0, EXEC_TIMEOUT, MEM_LIMIT, doc_path); + "有关其他提示，请参阅 %s/README。\n\n", - exit(1); + argv0, EXEC_TIMEOUT, MEM_LIMIT, doc_path); // 输出程序使用说明和文档路径 + exit(1); // 退出程序 } -/* Find binary. */ +/* 查找二进制文件。 */ -static void find_binary(u8* fname) { // 查找目标二进制文件 +static void find_binary(u8* fname) { - u8* env_path = 0; - struct stat st; + u8* env_path = 0; // 环境路径 + struct stat st; // 文件状态结构 - if (strchr(fname, '/') || !(env_path = getenv("PATH"))) { // 如果文件名包含路径或没有PATH环境变量 + if (strchr(fname, '/') || !(env_path = getenv("PATH"))) { // 如果是绝对路径或没有 PATH 环境变量 target_path = ck_strdup(fname); // 直接使用文件名 - if (stat(target_path, &st) || !S_ISREG(st.st_mode) || // 检查文件状态 + if (stat(target_path, &st) || !S_ISREG(st.st_mode) || // 检查文件是否存在且可执行 !(st.st_mode & 0111) || st.st_size < 4) - FATAL("Program '%s' not found or not executable", fname); // 如果文件不存在或不可执行，报错 + FATAL("程序 '%s' 未找到或不可执行", fname); // 输出错误信息 - } else { // 否则在PATH中查找 + } else { // 如果是相对路径 - while (env_path) { // 遍历PATH + while (env_path) { // 遍历环境变量 PATH - u8 *cur_elem, *delim = strchr(env_path, ':'); // 查找分隔符 + u8 *cur_elem, *delim = strchr(env_path, ':'); // 查找下一个路径分隔符 if (delim) { // 如果找到分隔符 - cur_elem = ck_alloc(delim - env_path + 1); // 分配内存 - memcpy(cur_elem, env_path, delim - env_path); // 复制路径 - delim++; + cur_elem = ck_alloc(delim - env_path + 1); // 获取当前路径 + memcpy(cur_elem, env_path, delim - env_path); // 拷贝当前路径 + delim++; // 移动到下一个路径 - } else cur_elem = ck_strdup(env_path); // 否则直接复制路径 + } else cur_elem = ck_strdup(env_path); // 如果没有找到，则直接拷贝 - env_path = delim; + env_path = delim; // 更新环境路径为下一个路径 - if (cur_elem[0]) // 如果路径不为空 - target_path = alloc_printf("%s/%s", cur_elem, fname); // 拼接路径 + if (cur_elem[0]) // 如果当前路径非空 + target_path = alloc_printf("%s/%s", cur_elem, fname); // 拼接路径和文件名 else - target_path = ck_strdup(fname); // 否则直接使用文件名 + target_path = ck_strdup(fname); // 如果当前路径为空，直接使用文件名 - ck_free(cur_elem); // 释放内存 + ck_free(cur_elem); // 释放当前路径内存 - if (!stat(target_path, &st) && S_ISREG(st.st_mode) && // 检查文件状态 - (st.st_mode & 0111) && st.st_size >= 4) break; // 如果文件存在且可执行，退出循环 + if (!stat(target_path, &st) && S_ISREG(st.st_mode) && // 检查路径是否有效 + (st.st_mode & 0111) && st.st_size >= 4) break; // 如果有效则退出循环 - ck_free(target_path); // 释放内存 - target_path = 0; + ck_free(target_path); // 释放目标路径内存 + target_path = 0; // 重置目标路径 } - if (!target_path) FATAL("Program '%s' not found or not executable", fname); // 如果未找到文件，报错 + if (!target_path) FATAL("程序 '%s' 未找到或不可执行", fname); // 输出错误信息 } } -/* Fix up argv for QEMU. */ +/* 修复 argv 以供 QEMU 使用。 */ -static char** get_qemu_argv(u8* own_loc, char** argv, int argc) { // 为QEMU模式修复argv +static char** get_qemu_argv(u8* own_loc, char** argv, int argc) { - char** new_argv = ck_alloc(sizeof(char*) * (argc + 4)); // 分配内存 - u8 *tmp, *cp, *rsl, *own_copy; + char** new_argv = ck_alloc(sizeof(char*) * (argc + 4)); // 分配新的参数数组 + u8 *tmp, *cp, *rsl, *own_copy; // 定义临时变量 - /* Workaround for a QEMU stability glitch. */ + /* QEMU 稳定性解决方法。 */ - setenv("QEMU_LOG", "nochain", 1); // 设置QEMU日志 + setenv("QEMU_LOG", "nochain", 1); // 设置环境变量 - memcpy(new_argv + 3, argv + 1, sizeof(char*) * argc); // 复制参数 + memcpy(new_argv + 3, argv + 1, sizeof(char*) * argc); // 拷贝原始参数 - /* Now we need to actually find qemu for argv[0]. */ + /* 现在我们需要实际查找 qemu 作为argv[0]。 */ - new_argv[2] = target_path; // 设置目标路径 - new_argv[1] = "--"; // 设置分隔符 + new_argv[2] = target_path; // 设置目标路径为新参数 + new_argv[1] = "--"; // 添加参数分隔符 - tmp = getenv("AFL_PATH"); // 获取AFL路径 + tmp = getenv("AFL_PATH"); // 获取 AFL_PATH 环境变量 - if (tmp) { // 如果设置了AFL路径 + if (tmp) { // 如果存在 AFL_PATH - cp = alloc_printf("%s/afl-qemu-trace", tmp); // 拼接路径 + cp = alloc_printf("%s/afl-qemu-trace", tmp); // 构造新的 qemu 路径 - if (access(cp, X_OK)) // 检查文件是否可执行 - FATAL("Unable to find '%s'", tmp); // 如果不可执行，报错 + if (access(cp, X_OK)) // 检查是否可执行 + FATAL("无法找到 '%s'", tmp); // 输出错误信息 - target_path = new_argv[0] = cp; // 设置目标路径 - return new_argv; // 返回新参数 + target_path = new_argv[0] = cp; // 更新目标路径 + return new_argv; // 返回新的参数数组 } own_copy = ck_strdup(own_loc); // 复制当前路径 - rsl = strrchr(own_copy, '/'); // 查找最后一个斜杠 + rsl = strrchr(own_copy, '/'); // 查找最后一个路径分隔符 - if (rsl) { // 如果找到斜杠 + if (rsl) { // 如果找到了路径分隔符 - *rsl = 0; // 截断路径 + *rsl = 0; // 设置为字符串结束符 - cp = alloc_printf("%s/afl-qemu-trace", own_copy); // 拼接路径 - ck_free(own_copy); // 释放内存 + cp = alloc_printf("%s/afl-qemu-trace", own_copy); // 构造新的 qemu 路径 + ck_free(own_copy); // 释放当前路径的内存 - if (!access(cp, X_OK)) { // 检查文件是否可执行 + if (!access(cp, X_OK)) { // 如果可执行 - target_path = new_argv[0] = cp; // 设置目标路径 - return new_argv; // 返回新参数 + target_path = new_argv[0] = cp; // 更新目标路径 + return new_argv; // 返回新的参数数组 } - } else ck_free(own_copy); // 释放内存 - - if (!access(BIN_PATH "/afl-qemu-trace", X_OK)) { // 检查默认路径 - - target_path = new_argv[0] = BIN_PATH "/afl-qemu-trace"; // 设置目标路径 - return new_argv; // 返回新参数 + } else ck_free(own_copy); // 如果没有找到路径分隔符，释放内存 + if (!access(BIN_PATH "/afl-qemu-trace", X_OK)) { // 检查预定义的 qemu 路径 + target_path = new_argv[0] = BIN_PATH "/afl-qemu-trace"; // 更新目标路径 + return new_argv; // 返回新的参数数组 } - FATAL("Unable to find 'afl-qemu-trace'."); // 如果未找到，报错 + FATAL("无法找到 'afl-qemu-trace'。"); // 输出错误信息 } -/* Main entry point */ +/* 主程序入口 */ -int main(int argc, char** argv) { // 主函数 +int main(int argc, char** argv) { - s32 opt; - u8 mem_limit_given = 0, timeout_given = 0, qemu_mode = 0; - char** use_argv; + s32 opt; // 定义选项变量 + u8 mem_limit_given = 0, timeout_given = 0, qemu_mode = 0; // 初始化标志 + char** use_argv; // 用来存储使用的参数 doc_path = access(DOC_PATH, F_OK) ? "docs" : DOC_PATH; // 设置文档路径 SAYF(cCYA "afl-analyze " cBRI VERSION cRST " by \n"); // 输出版本信息 - while ((opt = getopt(argc,argv,"+i:f:m:t:eQV")) > 0) // 解析命令行参数 + // 解析命令行参数 + while ((opt = getopt(argc, argv, "+i:f:m:t:eQV")) > 0) switch (opt) { - case 'i': // 输入文件 - - if (in_file) FATAL("Multiple -i options not supported"); // 如果多次指定，报错 + case 'i': // 处理 -i 选项 + if (in_file) FATAL("不支持多个 -i 选项"); in_file = optarg; // 设置输入文件 break; - case 'f': // 目标程序输入文件 - - if (prog_in) FATAL("Multiple -f options not supported"); // 如果多次指定，报错 - use_stdin = 0; // 不使用stdin - prog_in = optarg; // 设置输入文件 + case 'f': // 处理 -f 选项 + if (prog_in) FATAL("不支持多个 -f 选项"); + use_stdin = 0; // 使用文件而非标准输入 + prog_in = optarg; // 设置程序输入 break; - case 'e': // 只关注边缘覆盖率 - - if (edges_only) FATAL("Multiple -e options not supported"); // 如果多次指定，报错 - edges_only = 1; // 设置只关注边缘覆盖率 + case 'e': // 处理 -e 选项 + if (edges_only) FATAL("不支持多个 -e 选项"); + edges_only = 1; // 设置为仅查找边缘覆盖 break; - case 'm': { // 内存限制 - - u8 suffix = 'M'; - - if (mem_limit_given) FATAL("Multiple -m options not supported"); // 如果多次指定，报错 - mem_limit_given = 1; - - if (!strcmp(optarg, "none")) { // 如果设置为none + case 'm': { // 处理 -m 选项 + u8 suffix = 'M'; // 后缀初始化为 MB - mem_limit = 0; // 不限制内存 - break; - - } - - if (sscanf(optarg, "%llu%c", &mem_limit, &suffix) < 1 || // 解析内存限制 - optarg[0] == '-') FATAL("Bad syntax used for -m"); // 如果语法错误，报错 - - switch (suffix) { // 根据后缀调整内存限制 - - case 'T': mem_limit *= 1024 * 1024; break; // TB - case 'G': mem_limit *= 1024; break; // GB - case 'k': mem_limit /= 1024; break; // KB - case 'M': break; // MB - - default: FATAL("Unsupported suffix or bad syntax for -m"); // 不支持的后缀，报错 - - } - - if (mem_limit < 5) FATAL("Dangerously low value of -m"); // 如果内存限制过低，报错 - - if (sizeof(rlim_t) == 4 && mem_limit > 2000) // 如果是32位系统且内存限制过大 - FATAL("Value of -m out of range on 32-bit systems"); // 报错 + if (mem_limit_given) FATAL("不支持多个 -m 选项"); + mem_limit_given = 1; // 标记已给定内存限制 + if (!strcmp(optarg, "none")) { // 如果参数为 "none" + mem_limit = 0; // 设置内存限制为 0 + break; } - break; + if (sscanf(optarg, "%llu%c", &mem_limit, &suffix) < 1 || // 解析内存限制 + optarg[0] == '-') FATAL("不正确的 -m 语法"); - case 't': // 超时时间 + switch (suffix) { // 根据后缀设置内存限制 + case 'T': mem_limit *= 1024 * 1024; break; // 转换为字节 + case 'G': mem_limit *= 1024; break; // 转换为 MB + case 'k': mem_limit /= 1024; break; // 转换为 KB + case 'M': break; // MB，不需转换 + default: FATAL("不支持的后缀或不正确的 -m 语法"); + } - if (timeout_given) FATAL("Multiple -t options not supported"); // 如果多次指定，报错 - timeout_given = 1; + if (mem_limit < 5) FATAL("危险的低的 -m 值"); // 检查内存限制是否安全 - exec_tmout = atoi(optarg); // 设置超时时间 + if (sizeof(rlim_t) == 4 && mem_limit > 2000) // 检查32位系统的限制 + FATAL("在32位系统上，-m 值超出范围"); + } + break; - if (exec_tmout < 10 || optarg[0] == '-') // 如果超时时间过小 - FATAL("Dangerously low value of -t"); // 报错 + case 't': // 处理 -t 选项 + if (timeout_given) FATAL("不支持多个 -t 选项"); + timeout_given = 1; // 标记超时已给定 + exec_tmout = atoi(optarg); // 设置执行超时时间 + if (exec_tmout < 10 || optarg[0] == '-') // 检查时间值 + FATAL("危险的低的 -t 值"); break; - case 'Q': // QEMU模式 - - if (qemu_mode) FATAL("Multiple -Q options not supported"); // 如果多次指定，报错 - if (!mem_limit_given) mem_limit = MEM_LIMIT_QEMU; // 如果没有设置内存限制，使用默认值 - - qemu_mode = 1; // 设置QEMU模式 + case 'Q': // 处理 -Q 选项 + if (qemu_mode) FATAL("不支持多个 -Q 选项"); + if (!mem_limit_given) mem_limit = MEM_LIMIT_QEMU; // 如果未给定内存限制，使用 QEMU 的默认值 + qemu_mode = 1; // 设置为 QEMU 模式 break; - case 'V': /* Show version number */ // 显示版本号 - - /* Version number has been printed already, just quit. */ // 版本号已输出，退出 - exit(0); + case 'V': // 显示版本号选项 + exit(0); // 直接退出 default: - - usage(argv[0]); // 显示用法提示 - + usage(argv[0]); // 显示用法信息 } - if (optind == argc || !in_file) usage(argv[0]); // 如果没有目标程序或输入文件，显示用法提示 + if (optind == argc || !in_file) usage(argv[0]); // 检查必要参数 - use_hex_offsets = !!getenv("AFL_ANALYZE_HEX"); // 设置是否使用十六进制偏移量 + use_hex_offsets = !!getenv("AFL_ANALYZE_HEX"); // 检查环境变量是否设置 setup_shm(); // 设置共享内存 - setup_signal_handlers(); // 设置信号处理函数 + setup_signal_handlers(); // 设置信号处理程序 - set_up_environment(); // 设置环境 + set_up_environment(); // 设置环境变量 find_binary(argv[optind]); // 查找目标二进制文件 - detect_file_args(argv + optind); // 检测参数中的@@ + detect_file_args(argv + optind); // 检测命令行参数中的文件输入 - if (qemu_mode) // 如果是QEMU模式 - use_argv = get_qemu_argv(argv[0], argv + optind, argc - optind); // 获取QEMU参数 + if (qemu_mode) // 如果是 QEMU 模式 + use_argv = get_qemu_argv(argv[0], argv + optind, argc - optind); // 获取 QEMU 兼容的参数数组 else - use_argv = argv + optind; // 否则直接使用参数 + use_argv = argv + optind; // 直接使用传入的参数 SAYF("\n"); read_initial_file(); // 读取初始文件 - ACTF("Performing dry run (mem limit = %llu MB, timeout = %u ms%s)...", // 输出预运行信息 - mem_limit, exec_tmout, edges_only ? ", edges only" : ""); - - run_target(use_argv, in_data, in_len, 1); // 运行目标程序 + ACTF("进行干运行（内存限制 = %llu MB，超时 = %u ms%s）...", + mem_limit, exec_tmout, edges_only ? ", 仅查找边缘" : ""); // 输出干运行信息 - if (child_timed_out) // 如果超时 - FATAL("Target binary times out (adjusting -t may help)."); // 报错 + run_target(use_argv, in_data, in_len, 1); // 运行目标程序进行第一次测试 - if (!anything_set()) FATAL("No instrumentation detected."); // 如果没有插桩，报错 + if (child_timed_out) // 检查子进程是否超时 + FATAL("目标二进制程序超时（调整 -t 可能会有所帮助）。"); - analyze(use_argv); // 分析输入文件 + if (!anything_set()) FATAL("未检测到任何仪器。"); // 输出未检测到仪器的错误信息 - OKF("We're done here. Have a nice day!\n"); // 输出完成信息 + analyze(use_argv); // 开始分析输入文件 - exit(0); // 退出 + OKF("我们结束了。祝你有美好的一天！\n"); // 输出结束信息 -} \ No newline at end of file + exit(0); // 正常退出程序 +}