diff --git "a/2023/AFL\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265/index.html" "b/2023/AFL\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265/index.html"
index 9aa3ef4..82c42b0 100644
--- "a/2023/AFL\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265/index.html"
+++ "b/2023/AFL\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265/index.html"
@@ -14,7 +14,7 @@
     
     
     
-    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg"},"articleBody":"\n\n\n在软件开发的世界里，质量和安全性是评估产品成败的重要指标。模糊测试作为一种高效的自动化测试方法，专门用来发现程序中的错误和安全漏洞。本文旨在详细介绍 AFL（American Fuzzy Lop）的基本原理和使用方法。\n一、AFL 的原理介绍  模糊测试是一种通过向软件输入异常或随机数据的自动化技术，目的是发现程序在处理意外或边缘情况输入时的错误。AFL 是这一测试策略中的杰出代表，它通过不断学习程序反应来改进测试用例，提高测试的覆盖率和发现漏洞的概率。\nAFL 利用遗传算法，不断生成测试用例，并通过动态插桩技术监控程序的行为，特别是程序的代码覆盖情况。当新的输入能触发新的代码路径时，这个输入会被保存以供进一步的测试。该过程可以形成一个反馈循环，不断优化测试用例以探索更多程序状态。\n下面是 AFL 工作流程图，展示了从准备测试用例到监控程序行为的步骤：\ngraph TD\n    A[Compile with afl-gcc] --> B[Initialize seed corpus] --> C[Fuzzing loop] --> D[Select seed from corpus queue]\n    D[Select seed from corpus queue] --> E[Mutate selected seed] --> F[Execute with mutated testcase]\n    F[Execute with mutated testcase] --> G[Monitor for crashes and coverage update] --> H{Check for new coverage}\n    H{Check for new coverage} -- YES --> I[Save mutated testcase to queue] --> D\n    H{Check for new coverage} -- NO --> D\n\n流程图详细展示了 AFL 在模糊测试中的核心步骤：\n\n编译（Compile with afl-gcc） - 使用 AFL 提供的编译器 afl-gcc，对目标程序进行编译，实现程序的动态插桩。\n\n初始化种子库（Initialize seed corpus） - 创建初始测试用例集（种子库），这些测试用例将作为模糊测试的起点。\n\n模糊测试循环（Fuzzing loop） - 一个不断循环的过程，根据测试结果更新种子库，并反复执行下列子步骤：a. 选择种子（Select seed from corpus queue） - 从种子库中选择一个种子文件作为当前测试的输入。b. 突变种子（Mutate selected seed） - 对选中的种子文件应用突变算法，生成新的测试用例。c. 执行测试（Execute with mutated test case） - 将变异后的测试用例作为输入执行已插桩的目标程序。d. 监控结果（Monitor for crashes and coverage update） - 监控程序的执行情况，记录崩溃和代码覆盖率的变化。\n\n覆盖率检查（Check for new coverage） - 判断是否出现新的代码覆盖，如果有，则将其保存为新测试用例。\n\n保存新测试用例（Save new testcase to queue） - 将触发新代码覆盖的测试用例保存到队列中，用于后续的测试。\n\n\nAFL 采用了 fork 的运行模式，这使得当待测程序出现崩溃时，fuzz 进程不会终止，这一点相较于 LibFuzzer 更具优势。然而，频繁的 fork 操作也导致了 AFL 的效率不如 LibFuzzer。\n二、AFL 安装和运行1. 支持的系统和架构AFL 设计之初主要针对 UNIX-like 系统，其在 Linux 系统上有最好的支持。然而，在社区的努力下，也有 Windows 版本的 AFL，如 winafl，其可以在 Windows 进行模糊测试。\nAFL 还支持多种 CPU 架构，其中对 x86 和 x64 架构的支持最好。如果要支持 ARM 架构，则需要使用 AFL 的 QEMU 模式。\n2. 安装步骤AFL 可以通过源码进行安装：\n123apt install git make gccgit clone https://github.com/google/AFL.git cd AFL &amp;&amp; make\n\n3. 运行参数  在安装并编译完 AFL 之后，可以使用 afl-fuzz 命令来启动模糊测试。一个基本的 AFL fuzz 命令如下：\n1afl-fuzz -i input_dir -o output_dir -- /path/to/program [options] @@\n\n这里：\n\nafl-fuzz 是启动 AFL 模糊测试的程序。\n-i input_dir 指定包含初始化测试用例的目录。\n-o output_dir 指定存放的 fuzzing 结果的目录。\n\n-- 之后的部分是运行被测试程序的命令行，其中 /path/to/program 替换为需要进行模糊测试的程序的路径，[options] 是运行该程序的任何选项或参数。\n如果测试程序需要从文件中读取输入，可以在实际输入文件路径的位置使用 @@ 占位符。AFL 将替换 @@ 来插入它正在测试的输入文件。如果省略这个占位符，AFL 将会把模糊测试用例通过 stdin 传递给测试程序。\n三、AFL 的使用示例  本节使用一个简单的示例，演示 AFL 的操作步骤。\n这是待测源码，其功能是接受一行命令行输入，进行四则运算。其中使用了不安全的 gets 函数，可能导致缓冲区溢出：\n1234567891011121314151617181920212223242526272829303132#include &lt;stdio.h&gt;#include &lt;string.h&gt;int calculate(int a, int b, char op) &#123;    switch (op) &#123;        case &#x27;+&#x27;: return a + b;        case &#x27;-&#x27;: return a - b;        case &#x27;x&#x27;: return a * b;        case &#x27;/&#x27;: return b ? a / b : 0;        default: return 0;    &#125;&#125;int main() &#123;    char input[100];    // unsafe method that may cause buffer overflow    gets(input);    int a, b, result;    char op;    if (sscanf(input, &quot;%d %c %d&quot;, &amp;a, &amp;op, &amp;b) != 3)        return 1;    result = calculate(a, b, op);    printf(&quot;Result: %d\\n&quot;, result);    return 0;&#125;\n\n1. 编译源码  使用 AFL 的编译器 afl-gcc 或afl-clang对源文件 hello.c 进行编译，添加所需要的代码覆盖插桩。afl-gcc或 afl-clang 实际上是对常规的 gcc 或clang编译器进行了封装，通过在编译时进行插桩，来统计 fuzz 过程中的代码覆盖率：\n1afl-gcc -o hello hello.c\n\n2. 准备种子语料库  不论程序是从 file 还是从 stdin 获取数据，AFL 都需要一个初始语料库来启动模糊测试过程。输入（无论是来自 file 或 stdin）是 AFL 用来开始探索程序行为的基础。初始语料库（seed corpus）是一组文件，其中包含了各种有效的输入示例，这些输入会被 AFL 用作模糊测试的起始点。\n从 stdin 读取输入时，AFL 会将语料库中的每个文件内容作为输入在每次测试运行时送到程序的标准输入流中。使用 AFL 时，必须要有初始语料库。注意这一点 AFL 与 Libfuzzer 不同，Libfuzzer 只接受 stdin，不接受 file，初始语料库为可选项。\n12mkdir inecho &#x27;abc&#x27; &gt; in/seed\n\n3. 执行测试  在运行 AFL 之前，需要执行下面的系统设置命令，将字符串”core”写入到文件 /proc/sys/kernel/core_pattern 中。\n在 Linux 系统中，/proc/sys/kernel/core_pattern 文件用于指定当程序崩溃时，内核转储文件（core dump）的文件名模式。通过修改这个文件，可以控制内核生成 core 文件的行为。\n通过执行这个命令，生成的核心转储文件将以”core”命名，这使得 AFL 更容易检测和处理目标程序的崩溃情况，从而更好地进行模糊测试。\n1echo core | tee /proc/sys/kernel/core_pattern\n\n在 hello 中使用 gets 函数从 stdin 中读取数据，因此在运行 AFL 时，不需要添加 @@。是否使用@@ 取决于待测程序接受的输入来自 file 还是 stdin。\n1afl-fuzz -i in -o out -- ./hello\n\n4. 结果解读AFL 开始运行后，将会看到如下的界面显示：\n\n\n从这个界面上可以看到 AFL 找到了多少 crash，但还不能直观地显示覆盖率。pythia是一款 AFL 的扩展工具，可以查看代码覆盖率的情况。\nAFL 在运行过程中，会不断地产生输出。输出目录结构如下：\n123456789101112131415161718192021222324out|-- crashes|   |-- README.txt|   |-- id:000000,sig:06,src:000000,op:havoc,rep:64|   |-- id:000001,sig:06,src:000002+000003,op:splice,rep:128|   |-- id:000002,sig:06,src:000003,op:havoc,rep:32|   |-- id:000003,sig:06,src:000002+000003,op:splice,rep:16|   |-- id:000004,sig:06,src:000004,op:havoc,rep:32|   |-- id:000005,sig:11,src:000003+000002,op:splice,rep:64|   `-- id:000006,sig:06,src:000004+000005,op:splice,rep:2|-- fuzz_bitmap|-- fuzzer_stats|-- hangs|-- plot_data`-- queue    |-- id:000000,orig:seed    |-- id:000001,src:000000,op:havoc,rep:16,+cov    |-- id:000002,src:000000+000001,op:splice,rep:4,+cov    |-- id:000003,src:000001,op:arith8,pos:1,val:-5,+cov    |-- id:000004,src:000001,op:arith8,pos:1,val:-9,+cov    `-- id:000005,src:000002+000003,op:splice,rep:4,+cov3 directories, 17 files\n\n\nqueue&#x2F; - 存放 AFL 生成的触发新代码路径的测试样本\n\ncrashes&#x2F; - 存放能触发待测程序崩溃的测试样本\n\nhangs&#x2F; - 存发导致待测程序超时的测试样本\n\nfuzzer_stats - 文本文件，包含了 fuzzer 的实时统计信息，如执行速度、路径覆盖等度量指标。这个文件不断更新以反映当前的 fuzzing 状态。\n\nplot_data - 文本文件，包含了 AFL 执行过程中的统计数据。使用 AFL 的 afl-plot 工具处理 plot_data 文件，可以生成 fuzz 过程的可视化图像。\n\nfuzz_bitmap - 这是用来记录路径覆盖率的位图（coverage bitmap），非人类可读。AFL 使用这个位图来跟踪程序在处理不同输入时执行的不同分支，用来帮助 AFL 识别新的、唯一的代码路径，以便后续生成更具有探索性的测试样本。\n\n\n四、AFL 的 QEMU 模式  前面的例子中，AFL 在对待测程序的源码进行编译时插桩。实际中，我们不一定能拿到待测源码，我们要测的可能是一个已经编译好的二进制文件。这种情况下 Libfuzzer 就无能为力了，但 AFL 还能用，这依赖于 AFL 的 QEMU 模式。\nAFL 的 QEMU 模式，也称为 AFL-QEMU，允许你在二进制模糊测试中使用 AFL，即使源代码不可用。这在对闭源应用进行模糊测试时非常有用。这种模式使用 QEMU 的用户模式仿真，来运行并分析非原生的二进制文件。以下是安装 AFL 的 QEMU 模式和使用步骤的指南：\n1. 编译 QEMU 支持  在 AFL 主目录下有一个专门的 QEMU 模式目录。进入该目录并编译 QEMU 模式，过程中可能缺少依赖项，根据提示进行安装即可：\n12cd qemu_mode./build_qemu_support.sh\n\n2. AFL-QEMU 使用步骤  用法很简单，在 AFL 运行命令中添加 -Q 参数即可：\n1afl-fuzz -i input -o output -Q -- /path/to/binary @@\n\n\n五、AFL 的升级版——AFL++AFL++ 可以看作是原始 AFL 的”增强版”，对 AFL 的调度策略和变异算法进行了很多改进，同时还引入了很多新特性，如 CMPLOG 和持久化这样的特性。\n1. CMPLOGCMPLOG 是 AFL++ 引入的一个新功能，类似于 Libfuzzer 中的 trace-cmp，它可以极大地提高代码覆盖率。CMPLOG 的主要作用是对程序中的所有比较操作进行记录，包括等于、不等于、小于等逻辑比较。当 fuzzer 执行时，CMPLOG 能够捕获比较操作的参数，并将对应的值添加到 fuzzer 的输入测试用例中。这个过程实际上帮助 fuzzer 更好地理解代码中期待的输入，特别是那些用于逻辑分支的字面值和魔法数字。这种理解能够导向更深入的路径覆盖，进而揭露隐藏更深的潜在缺陷。\n2. 持久化模式AFL 的持久化（persistent）模式允许目标程序在单个进程周期内重复执行多次模糊测试用例。这对性能产生了显著的提升，因为它减少了程序启动和终止的开销，特别是当测试的目标程序需要很大的初始化成本时。在 AFL++ 中，持久化模式的执行更为高效，它允许模糊器在目标程序中一次性执行多个测试用例，而非每次执行一个用例都重启目标程序。有了持久化模式，AFL++ 能够在相同的时间内执行更多的测试迭代，从而提高漏洞检测的速度。\n六、小结AFL 是一款强大的模糊测试工具，实践中 AFL++ 的应用非常广泛。相比 Libfuzzer，AFL++ 不局限于源码，并且支持多种 cpu 架构，还有丰富的插件生态可以使用。\n但模糊测试本身存在覆盖率瓶颈的问题，难以探索复杂的程序路径，这时候可以结合其他的技术，如符号执行来突破。","dateCreated":"2023-10-15T11:23:55+08:00","dateModified":"2024-05-30T16:11:03+08:00","datePublished":"2023-10-15T11:23:55+08:00","description":"模糊测试工具 AFL（American Fuzzy Lop）的原理介绍与实践应用","headline":"AFL 原理与实践","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2023/AFL%E5%8E%9F%E7%90%86%E4%B8%8E%E5%AE%9E%E8%B7%B5/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://www.stepbystep.asia/2023/AFL%E5%8E%9F%E7%90%86%E4%B8%8E%E5%AE%9E%E8%B7%B5/","keywords":"Fuzz, 安全, 工具, AFL"}</script>
+    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg"},"articleBody":"\n\n\n在软件开发的世界里，质量和安全性是评估产品成败的重要指标。模糊测试作为一种高效的自动化测试方法，专门用来发现程序中的错误和安全漏洞。本文旨在详细介绍 AFL（American Fuzzy Lop）的基本原理和使用方法。\n一、AFL 的原理介绍  模糊测试是一种通过向软件输入异常或随机数据的自动化技术，目的是发现程序在处理意外或边缘情况输入时的错误。AFL 是这一测试策略中的杰出代表，它通过不断学习程序反应来改进测试用例，提高测试的覆盖率和发现漏洞的概率。\nAFL 利用遗传算法，不断生成测试用例，并通过动态插桩技术监控程序的行为，特别是程序的代码覆盖情况。当新的输入能触发新的代码路径时，这个输入会被保存以供进一步的测试。该过程可以形成一个反馈循环，不断优化测试用例以探索更多程序状态。\n下面是 AFL 工作流程图，展示了从准备测试用例到监控程序行为的步骤：\ngraph TD\n    A[Compile with afl-gcc] --> B[Initialize seed corpus] --> C[Fuzzing loop] --> D[Select seed from corpus queue]\n    D[Select seed from corpus queue] --> E[Mutate selected seed] --> F[Execute with mutated testcase]\n    F[Execute with mutated testcase] --> G[Monitor for crashes and coverage update] --> H{Check for new coverage}\n    H{Check for new coverage} -- YES --> I[Save mutated testcase to queue] --> D\n    H{Check for new coverage} -- NO --> D\n\n流程图详细展示了 AFL 在模糊测试中的核心步骤：\n\n编译（Compile with afl-gcc） - 使用 AFL 提供的编译器 afl-gcc，对目标程序进行编译，实现程序的动态插桩。\n\n初始化种子库（Initialize seed corpus） - 创建初始测试用例集（种子库），这些测试用例将作为模糊测试的起点。\n\n模糊测试循环（Fuzzing loop） - 一个不断循环的过程，根据测试结果更新种子库，并反复执行下列子步骤：a. 选择种子（Select seed from corpus queue） - 从种子库中选择一个种子文件作为当前测试的输入。b. 突变种子（Mutate selected seed） - 对选中的种子文件应用突变算法，生成新的测试用例。c. 执行测试（Execute with mutated test case） - 将变异后的测试用例作为输入执行已插桩的目标程序。d. 监控结果（Monitor for crashes and coverage update） - 监控程序的执行情况，记录崩溃和代码覆盖率的变化。\n\n覆盖率检查（Check for new coverage） - 判断是否出现新的代码覆盖，如果有，则将其保存为新测试用例。\n\n保存新测试用例（Save new testcase to queue） - 将触发新代码覆盖的测试用例保存到队列中，用于后续的测试。\n\n\nAFL 采用了 fork 的运行模式，这使得当待测程序出现崩溃时，fuzz 进程不会终止，这一点相较于 LibFuzzer 更具优势。然而，频繁的 fork 操作也导致了 AFL 的效率不如 LibFuzzer。\n二、AFL 安装和运行1. 支持的系统和架构AFL 设计之初主要针对 UNIX-like 系统，其在 Linux 系统上有最好的支持。然而，在社区的努力下，也有 Windows 版本的 AFL，如 winafl，其可以在 Windows 进行模糊测试。\nAFL 还支持多种 CPU 架构，其中对 x86 和 x64 架构的支持最好。如果要支持 ARM 架构，则需要使用 AFL 的 QEMU 模式。\n2. 安装步骤AFL 可以通过源码进行安装：\n123apt install git make gccgit clone https://github.com/google/AFL.git cd AFL &amp;&amp; make\n\n3. 运行参数  在安装并编译完 AFL 之后，可以使用 afl-fuzz 命令来启动模糊测试。一个基本的 AFL fuzz 命令如下：\n1afl-fuzz -i input_dir -o output_dir -- /path/to/program [options] @@\n\n这里：\n\nafl-fuzz 是启动 AFL 模糊测试的程序。\n-i input_dir 指定包含初始化测试用例的目录。\n-o output_dir 指定存放的 fuzzing 结果的目录。\n\n-- 之后的部分是运行被测试程序的命令行，其中 /path/to/program 替换为需要进行模糊测试的程序的路径，[options] 是运行该程序的任何选项或参数。\n如果测试程序需要从文件中读取输入，可以在实际输入文件路径的位置使用 @@ 占位符。AFL 将替换 @@ 来插入它正在测试的输入文件。如果省略这个占位符，AFL 将会把模糊测试用例通过 stdin 传递给测试程序。\n三、AFL 的使用示例  本节使用一个简单的示例，演示 AFL 的操作步骤。\n这是待测源码，其功能是接受一行命令行输入，进行四则运算。其中使用了不安全的 gets 函数，可能导致缓冲区溢出：\n1234567891011121314151617181920212223242526272829303132#include &lt;stdio.h&gt;#include &lt;string.h&gt;int calculate(int a, int b, char op) &#123;    switch (op) &#123;        case &#x27;+&#x27;: return a + b;        case &#x27;-&#x27;: return a - b;        case &#x27;x&#x27;: return a * b;        case &#x27;/&#x27;: return b ? a / b : 0;        default: return 0;    &#125;&#125;int main() &#123;    char input[100];    // unsafe method that may cause buffer overflow    gets(input);    int a, b, result;    char op;    if (sscanf(input, &quot;%d %c %d&quot;, &amp;a, &amp;op, &amp;b) != 3)        return 1;    result = calculate(a, b, op);    printf(&quot;Result: %d\\n&quot;, result);    return 0;&#125;\n\n1. 编译源码  使用 AFL 的编译器 afl-gcc 或afl-clang对源文件 hello.c 进行编译，添加所需要的代码覆盖插桩。afl-gcc或 afl-clang 实际上是对常规的 gcc 或clang编译器进行了封装，通过在编译时进行插桩，来统计 fuzz 过程中的代码覆盖率：\n1afl-gcc -o hello hello.c\n\n2. 准备种子语料库  不论程序是从 file 还是从 stdin 获取数据，AFL 都需要一个初始语料库来启动模糊测试过程。输入（无论是来自 file 或 stdin）是 AFL 用来开始探索程序行为的基础。初始语料库（seed corpus）是一组文件，其中包含了各种有效的输入示例，这些输入会被 AFL 用作模糊测试的起始点。\n从 stdin 读取输入时，AFL 会将语料库中的每个文件内容作为输入在每次测试运行时送到程序的标准输入流中。使用 AFL 时，必须要有初始语料库。注意这一点 AFL 与 Libfuzzer 不同，Libfuzzer 只接受 stdin，不接受 file，初始语料库为可选项。\n12mkdir inecho &#x27;abc&#x27; &gt; in/seed\n\n3. 执行测试  在运行 AFL 之前，需要执行下面的系统设置命令，将字符串”core”写入到文件 /proc/sys/kernel/core_pattern 中。\n在 Linux 系统中，/proc/sys/kernel/core_pattern 文件用于指定当程序崩溃时，内核转储文件（core dump）的文件名模式。通过修改这个文件，可以控制内核生成 core 文件的行为。\n通过执行这个命令，生成的核心转储文件将以”core”命名，这使得 AFL 更容易检测和处理目标程序的崩溃情况，从而更好地进行模糊测试。\n1echo core | tee /proc/sys/kernel/core_pattern\n\n在 hello 中使用 gets 函数从 stdin 中读取数据，因此在运行 AFL 时，不需要添加 @@。是否使用@@ 取决于待测程序接受的输入来自 file 还是 stdin。\n1afl-fuzz -i in -o out -- ./hello\n\n4. 结果解读AFL 开始运行后，将会看到如下的界面显示：\n\n\n从这个界面上可以看到 AFL 找到了多少 crash，但还不能直观地显示覆盖率。pythia是一款 AFL 的扩展工具，可以查看代码覆盖率的情况。\nAFL 在运行过程中，会不断地产生输出。输出目录结构如下：\n123456789101112131415161718192021222324out|-- crashes|   |-- README.txt|   |-- id:000000,sig:06,src:000000,op:havoc,rep:64|   |-- id:000001,sig:06,src:000002+000003,op:splice,rep:128|   |-- id:000002,sig:06,src:000003,op:havoc,rep:32|   |-- id:000003,sig:06,src:000002+000003,op:splice,rep:16|   |-- id:000004,sig:06,src:000004,op:havoc,rep:32|   |-- id:000005,sig:11,src:000003+000002,op:splice,rep:64|   `-- id:000006,sig:06,src:000004+000005,op:splice,rep:2|-- fuzz_bitmap|-- fuzzer_stats|-- hangs|-- plot_data`-- queue    |-- id:000000,orig:seed    |-- id:000001,src:000000,op:havoc,rep:16,+cov    |-- id:000002,src:000000+000001,op:splice,rep:4,+cov    |-- id:000003,src:000001,op:arith8,pos:1,val:-5,+cov    |-- id:000004,src:000001,op:arith8,pos:1,val:-9,+cov    `-- id:000005,src:000002+000003,op:splice,rep:4,+cov3 directories, 17 files\n\n\nqueue&#x2F; - 存放 AFL 生成的触发新代码路径的测试样本\n\ncrashes&#x2F; - 存放能触发待测程序崩溃的测试样本\n\nhangs&#x2F; - 存发导致待测程序超时的测试样本\n\nfuzzer_stats - 文本文件，包含了 fuzzer 的实时统计信息，如执行速度、路径覆盖等度量指标。这个文件不断更新以反映当前的 fuzzing 状态。\n\nplot_data - 文本文件，包含了 AFL 执行过程中的统计数据。使用 AFL 的 afl-plot 工具处理 plot_data 文件，可以生成 fuzz 过程的可视化图像。\n\nfuzz_bitmap - 这是用来记录路径覆盖率的位图（coverage bitmap），非人类可读。AFL 使用这个位图来跟踪程序在处理不同输入时执行的不同分支，用来帮助 AFL 识别新的、唯一的代码路径，以便后续生成更具有探索性的测试样本。\n\n\n四、AFL 的 QEMU 模式  前面的例子中，AFL 在对待测程序的源码进行编译时插桩。实际中，我们不一定能拿到待测源码，我们要测的可能是一个已经编译好的二进制文件。这种情况下 Libfuzzer 就无能为力了，但 AFL 还能用，这依赖于 AFL 的 QEMU 模式。\nAFL 的 QEMU 模式，也称为 AFL-QEMU，允许你在二进制模糊测试中使用 AFL，即使源代码不可用。这在对闭源应用进行模糊测试时非常有用。这种模式使用 QEMU 的用户模式仿真，来运行并分析非原生的二进制文件。以下是安装 AFL 的 QEMU 模式和使用步骤的指南：\n1. 编译 QEMU 支持  在 AFL 主目录下有一个专门的 QEMU 模式目录。进入该目录并编译 QEMU 模式，过程中可能缺少依赖项，根据提示进行安装即可：\n12cd qemu_mode./build_qemu_support.sh\n\n2. AFL-QEMU 使用步骤  用法很简单，在 AFL 运行命令中添加 -Q 参数即可：\n1afl-fuzz -i input -o output -Q -- /path/to/binary @@\n\n\n五、AFL 的升级版——AFL++AFL++ 可以看作是原始 AFL 的”增强版”，对 AFL 的调度策略和变异算法进行了很多改进，同时还引入了很多新特性，如 CMPLOG 和持久化这样的特性。\n1. CMPLOGCMPLOG 是 AFL++ 引入的一个新功能，类似于 Libfuzzer 中的 trace-cmp，它可以极大地提高代码覆盖率。CMPLOG 的主要作用是对程序中的所有比较操作进行记录，包括等于、不等于、小于等逻辑比较。当 fuzzer 执行时，CMPLOG 能够捕获比较操作的参数，并将对应的值添加到 fuzzer 的输入测试用例中。这个过程实际上帮助 fuzzer 更好地理解代码中期待的输入，特别是那些用于逻辑分支的字面值和魔法数字。这种理解能够导向更深入的路径覆盖，进而揭露隐藏更深的潜在缺陷。\n2. 持久化模式AFL 的持久化（persistent）模式允许目标程序在单个进程周期内重复执行多次模糊测试用例。这对性能产生了显著的提升，因为它减少了程序启动和终止的开销，特别是当测试的目标程序需要很大的初始化成本时。在 AFL++ 中，持久化模式的执行更为高效，它允许模糊器在目标程序中一次性执行多个测试用例，而非每次执行一个用例都重启目标程序。有了持久化模式，AFL++ 能够在相同的时间内执行更多的测试迭代，从而提高漏洞检测的速度。\n六、小结AFL 是一款强大的模糊测试工具，实践中 AFL++ 的应用非常广泛。相比 Libfuzzer，AFL++ 不局限于源码，并且支持多种 cpu 架构，还有丰富的插件生态可以使用。\n但模糊测试本身存在覆盖率瓶颈的问题，难以探索复杂的程序路径，这时候可以结合其他的技术，如符号执行来突破。","dateCreated":"2023-10-15T11:23:55+08:00","dateModified":"2024-05-30T16:11:03+08:00","datePublished":"2023-10-15T11:23:55+08:00","description":"模糊测试工具 AFL（American Fuzzy Lop）的原理介绍与实践应用","headline":"AFL 原理与实践","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2023/AFL%E5%8E%9F%E7%90%86%E4%B8%8E%E5%AE%9E%E8%B7%B5/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://www.stepbystep.asia/2023/AFL%E5%8E%9F%E7%90%86%E4%B8%8E%E5%AE%9E%E8%B7%B5/","keywords":"安全, 工具, AFL, Fuzz"}</script>
     <meta name="description" content="模糊测试工具 AFL（American Fuzzy Lop）的原理介绍与实践应用">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="AFL 原理与实践">
@@ -26,10 +26,10 @@
 <meta property="article:published_time" content="2023-10-15T03:23:55.000Z">
 <meta property="article:modified_time" content="2024-05-30T08:11:03.608Z">
 <meta property="article:author" content="一瓢清浅">
-<meta property="article:tag" content="Fuzz">
 <meta property="article:tag" content="安全">
 <meta property="article:tag" content="工具">
 <meta property="article:tag" content="AFL">
+<meta property="article:tag" content="Fuzz">
 <meta name="twitter:card" content="summary">
 <meta name="twitter:image" content="https://www.stepbystep.asia/2023/AFL%E5%8E%9F%E7%90%86%E4%B8%8E%E5%AE%9E%E8%B7%B5/AFL%E8%BF%90%E8%A1%8C%E7%95%8C%E9%9D%A2.png">
     
diff --git "a/2023/LibAFL\347\256\200\344\273\213/index.html" "b/2023/LibAFL\347\256\200\344\273\213/index.html"
index 5f649f6..0f32093 100644
--- "a/2023/LibAFL\347\256\200\344\273\213/index.html"
+++ "b/2023/LibAFL\347\256\200\344\273\213/index.html"
@@ -14,7 +14,7 @@
     
     
     
-    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg"},"articleBody":"\n\n1. 什么是 LibAFLLibAFL 是一款用 Rust 语言开发的开源模糊测试框架，它将模糊测试的组件划分成一组模块文件，用户可以基于这组模块，快速实现自定义的 fuzz 引擎。\n2. 为什么要设计 LibAFL 现有的 Fuzz 引擎很多是基于 AFL 进行改造的，不同的改造之间存在不兼容的情况，比如 Fairfuzz 是基于 AFL 改造的，但是 AFL++ 不支持 Fairfuzz。如果希望把多种 Fuzz 优化技术集合在一起，工程难度很大。\nAFL++ 是 AFL 的进化版，它在 AFL 的基础上集成了很多 Fuzz 优化技术，并支持以插件的方式进行功能扩展，例如可以自定义 mutator。但 AFL++ 还是受限于 AFL 本身的程序设计，与 mutator 无关的优化技术，与 AFL++ 的集成也比较困难。\n3. LibAFL 整体架构 （1）Fuzz 引擎的相关组件 \nInput 指 fuzz 过程中，传递给 target 的输入数据。Libfuzzer 和 AFL 默认的输入格式，都是字节数组。fuzz 的入口函数在以这个字节数组作为入参，然后对字节数组进行切片和类型变换，转换为 target 中待测函数所要求的参数形式，再对待测函数进行调用。\n\nCorpus 指 fuzz 过程中，用来存放有效 input 的语料库。AFL 必须要有初始语料库，Libfuzzer 可以不提供初始语料库。语料库可以存放在磁盘中通过 io 读写，也可以全部加载进内存中。前者效率低，后者内存消耗大。\n\nScheduler 指 fuzz 引擎从语料库中选择 input 的调度机制。语料库中包含大量的 input，fuzz 每轮执行需要挑选一个 input。调度机制决定了 input 的挑选方法，简单的实现包括先入先出、随机挑选等。对调度机制进行优化，也是改进 fuzz 的一个方向。\n\nStagefuzz 的每一轮执行实际上都包含多个步骤，每个步骤都可以理解为一个阶段。比如变异阶段是对 input 进行随机变异操作，分析阶段可以使用污点分析等技术搜集更多信息，语料库精简阶段是对语料库进行筛选操作。一连串的阶段性操作构成了一次完整的 fuzz 执行过程。\n\nObserver 观察器用来收集 fuzz 单词运行过程中的信息。在覆盖率引导的 fuzz 引擎中，观察器会看这次执行过程中，input 所经过的代码路径。AFL 中的 bitmap 就是一个观察器，AFL 将代码路径转化为 branch 或 edge 的集合，并记录在 bitmap 中。\n\nExecutor 执行器负责将 input 喂给 target 开启一次 fuzz 执行。不同的 fuzz 工具，可能有不同的执行方式。Libfuzzer 是一个单进程的执行模式，在一个进程中生成 input 运行 target，并不断循环这个过程；AFL 则通过 fork 模式，每次 input 都会 fork 出一个子进程，在子进程中运行 target。\n\nFeedback 反馈通常是基于观察器收集到的执行结果，来判断这次 fuzz 执行过程中，使用的 input 是不是一个有效的输入，如果是有效输入才会保存到语料库中。在覆盖率引导的 fuzz 引擎中，当一个 input 能命中此前都没有到达的代码区块时，才会被认为是有效的。\n\nMutator 变异器接受一个 input 作为输入，通过修改、插入、删除等变异操作，衍生出一个新的 input。在 AFL 和 Libfuzzer 中，input 为字节数组，变异器通过对字节位和字节块进行改变，进而得到新的 input。在 target 输入需要满足指定格式时，自定义变异器是一条可行的途径。\n\nGenerator 生成器是指从头生成一个 input 作为输入，它不是基于已有的 input 进行修改。常用于基于生成的 fuzz 引擎中，例如 peach 中通过定义 input 的数据模型来指导 input 的生成。\n\n\n（2）LibAFL 的架构设计 LibAFL 的核心架构设计如下图：\n\n\n 其中的一些实体名词含义参见前一部分介绍。在这个架构图中，有三个比较大的组件：\n\nState：负责记录和维护 fuzzer 运行过程中的需要持久化的信息。它包括了各类统计数据、测试用例数据、已发现的漏洞、程序执行的路径等。这些信息用于帮助 fuzzer 做出智能决策，优化测试过程。\n\nFuzzer：负责实际执行模糊测试。它使用各种算法和策略来生成或者变异输入数据，然后将这些数据用于测试目标程序，以期发现潜在的安全漏洞。Fuzzer 需要与状态组件紧密协作，以使用状态信息引导自己的测试过程。\n\nEvent Manager：事件管理器作为 LibAFL 架构中的通信枢纽，它负责协调不同组件间的交互工作。事件管理器处理各种事件，如新发现的错误、状态更新信号等，并确保这些信息及时、正确地在组件间传递。\n\n\n4. LibAFL 使用方法 \n 简单的模糊器实例 - LibAFL 模糊测试库 \nfuzzing-101-with-libafl\n\n5. 参考资料 \nLibAFL: A Framework to Build Modular and Reusable Fuzzers\nLibAFL 学习笔记 \nLibAFL 中文文档 \n","dateCreated":"2023-11-18T10:38:08+08:00","dateModified":"2024-06-27T16:30:08+08:00","datePublished":"2023-11-18T10:38:08+08:00","description":"LibAFL 是用 Rust 开发的一款模糊测试库，支持 Fuzz 各模块的灵活定制 ","headline":"LibAFL 简介","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2023/LibAFL%E7%AE%80%E4%BB%8B/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://www.stepbystep.asia/2023/LibAFL%E7%AE%80%E4%BB%8B/","keywords":"Fuzz, 安全, 工具, AFL"}</script>
+    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg"},"articleBody":"\n\n1. 什么是 LibAFLLibAFL 是一款用 Rust 语言开发的开源模糊测试框架，它将模糊测试的组件划分成一组模块文件，用户可以基于这组模块，快速实现自定义的 fuzz 引擎。\n2. 为什么要设计 LibAFL 现有的 Fuzz 引擎很多是基于 AFL 进行改造的，不同的改造之间存在不兼容的情况，比如 Fairfuzz 是基于 AFL 改造的，但是 AFL++ 不支持 Fairfuzz。如果希望把多种 Fuzz 优化技术集合在一起，工程难度很大。\nAFL++ 是 AFL 的进化版，它在 AFL 的基础上集成了很多 Fuzz 优化技术，并支持以插件的方式进行功能扩展，例如可以自定义 mutator。但 AFL++ 还是受限于 AFL 本身的程序设计，与 mutator 无关的优化技术，与 AFL++ 的集成也比较困难。\n3. LibAFL 整体架构 （1）Fuzz 引擎的相关组件 \nInput 指 fuzz 过程中，传递给 target 的输入数据。Libfuzzer 和 AFL 默认的输入格式，都是字节数组。fuzz 的入口函数在以这个字节数组作为入参，然后对字节数组进行切片和类型变换，转换为 target 中待测函数所要求的参数形式，再对待测函数进行调用。\n\nCorpus 指 fuzz 过程中，用来存放有效 input 的语料库。AFL 必须要有初始语料库，Libfuzzer 可以不提供初始语料库。语料库可以存放在磁盘中通过 io 读写，也可以全部加载进内存中。前者效率低，后者内存消耗大。\n\nScheduler 指 fuzz 引擎从语料库中选择 input 的调度机制。语料库中包含大量的 input，fuzz 每轮执行需要挑选一个 input。调度机制决定了 input 的挑选方法，简单的实现包括先入先出、随机挑选等。对调度机制进行优化，也是改进 fuzz 的一个方向。\n\nStagefuzz 的每一轮执行实际上都包含多个步骤，每个步骤都可以理解为一个阶段。比如变异阶段是对 input 进行随机变异操作，分析阶段可以使用污点分析等技术搜集更多信息，语料库精简阶段是对语料库进行筛选操作。一连串的阶段性操作构成了一次完整的 fuzz 执行过程。\n\nObserver 观察器用来收集 fuzz 单词运行过程中的信息。在覆盖率引导的 fuzz 引擎中，观察器会看这次执行过程中，input 所经过的代码路径。AFL 中的 bitmap 就是一个观察器，AFL 将代码路径转化为 branch 或 edge 的集合，并记录在 bitmap 中。\n\nExecutor 执行器负责将 input 喂给 target 开启一次 fuzz 执行。不同的 fuzz 工具，可能有不同的执行方式。Libfuzzer 是一个单进程的执行模式，在一个进程中生成 input 运行 target，并不断循环这个过程；AFL 则通过 fork 模式，每次 input 都会 fork 出一个子进程，在子进程中运行 target。\n\nFeedback 反馈通常是基于观察器收集到的执行结果，来判断这次 fuzz 执行过程中，使用的 input 是不是一个有效的输入，如果是有效输入才会保存到语料库中。在覆盖率引导的 fuzz 引擎中，当一个 input 能命中此前都没有到达的代码区块时，才会被认为是有效的。\n\nMutator 变异器接受一个 input 作为输入，通过修改、插入、删除等变异操作，衍生出一个新的 input。在 AFL 和 Libfuzzer 中，input 为字节数组，变异器通过对字节位和字节块进行改变，进而得到新的 input。在 target 输入需要满足指定格式时，自定义变异器是一条可行的途径。\n\nGenerator 生成器是指从头生成一个 input 作为输入，它不是基于已有的 input 进行修改。常用于基于生成的 fuzz 引擎中，例如 peach 中通过定义 input 的数据模型来指导 input 的生成。\n\n\n（2）LibAFL 的架构设计 LibAFL 的核心架构设计如下图：\n\n\n 其中的一些实体名词含义参见前一部分介绍。在这个架构图中，有三个比较大的组件：\n\nState：负责记录和维护 fuzzer 运行过程中的需要持久化的信息。它包括了各类统计数据、测试用例数据、已发现的漏洞、程序执行的路径等。这些信息用于帮助 fuzzer 做出智能决策，优化测试过程。\n\nFuzzer：负责实际执行模糊测试。它使用各种算法和策略来生成或者变异输入数据，然后将这些数据用于测试目标程序，以期发现潜在的安全漏洞。Fuzzer 需要与状态组件紧密协作，以使用状态信息引导自己的测试过程。\n\nEvent Manager：事件管理器作为 LibAFL 架构中的通信枢纽，它负责协调不同组件间的交互工作。事件管理器处理各种事件，如新发现的错误、状态更新信号等，并确保这些信息及时、正确地在组件间传递。\n\n\n4. LibAFL 使用方法 \n 简单的模糊器实例 - LibAFL 模糊测试库 \nfuzzing-101-with-libafl\n\n5. 参考资料 \nLibAFL: A Framework to Build Modular and Reusable Fuzzers\nLibAFL 学习笔记 \nLibAFL 中文文档 \n","dateCreated":"2023-11-18T10:38:08+08:00","dateModified":"2024-06-27T16:30:08+08:00","datePublished":"2023-11-18T10:38:08+08:00","description":"LibAFL 是用 Rust 开发的一款模糊测试库，支持 Fuzz 各模块的灵活定制 ","headline":"LibAFL 简介","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2023/LibAFL%E7%AE%80%E4%BB%8B/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://www.stepbystep.asia/2023/LibAFL%E7%AE%80%E4%BB%8B/","keywords":"安全, 工具, AFL, Fuzz"}</script>
     <meta name="description" content="LibAFL 是用 Rust 开发的一款模糊测试库，支持 Fuzz 各模块的灵活定制">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="LibAFL 简介">
@@ -26,10 +26,10 @@
 <meta property="article:published_time" content="2023-11-18T02:38:08.000Z">
 <meta property="article:modified_time" content="2024-06-27T08:30:08.593Z">
 <meta property="article:author" content="一瓢清浅">
-<meta property="article:tag" content="Fuzz">
 <meta property="article:tag" content="安全">
 <meta property="article:tag" content="工具">
 <meta property="article:tag" content="AFL">
+<meta property="article:tag" content="Fuzz">
 <meta name="twitter:card" content="summary">
 <meta name="twitter:image" content="https://www.stepbystep.asia/2023/LibAFL%E7%AE%80%E4%BB%8B/LibAFL%E6%9E%B6%E6%9E%84%E8%AE%BE%E8%AE%A1.png">
     
diff --git "a/2023/LibFuzzer\344\275\277\347\224\250\350\257\264\346\230\216/index.html" "b/2023/LibFuzzer\344\275\277\347\224\250\350\257\264\346\230\216/index.html"
index b02c42c..fec8f81 100644
--- "a/2023/LibFuzzer\344\275\277\347\224\250\350\257\264\346\230\216/index.html"
+++ "b/2023/LibFuzzer\344\275\277\347\224\250\350\257\264\346\230\216/index.html"
@@ -14,7 +14,7 @@
     
     
     
-    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg"},"articleBody":"\n\n按照  官方定义，LibFuzzer 是一个in-process（进程内的），coverage-guided（以覆盖率为引导的），evolutionary（进化的） 的 fuzz 引擎，是 LLVM 项目的一部分，主要用于对 C&#x2F;C++ 程序进行 Fuzz 测试。LibFuzzer 三个特性的具体含义为：\n\nin-process：不会为每个测试用例启动一个进程，而是将所有的测试数据投放在同一个进程的内存空间中\n\ncoverage-guided：对每一个测试输入都进行代码覆盖率计算，不断累积测试用例使得代码覆盖率最大化\n\nevolutionary：结合了变异和生成两种形势的 Fuzz 引擎\n\n变异：基于已有的数据样本，通过一些变异规则，产生新的测试用例\n\n生成：通过对目标协议或接口规范进行建模，从零开始产生测试用例\n\n\n\n\nLibFuzzer 与待测的 library 进行链接，通过向指定的 fuzzing 入口（即target 函数）发送测试数据，并跟踪被触达的代码区域，然后对输入的数据进行变异，以达到代码覆盖率最大的目的，其中代码覆盖率的信息由 LLVM 的 SanitizerCoverage 工具提供。\n一、使用方法 1. 安装环境Clang 是一个类似 GCC 的 C&#x2F;C++ 语言编译工具，此处 简介。LibFuzzer 现在已被集成到 Clang 6.0 之后的版本中，在 Linux 环境下，只需直接安装 Clang 即可：\n1apt install clang\n\n安装完毕之后，可以通过如下命令查看 clang 版本：\n1clang --version\n\n2. 构建 target使用 LibFuzzer 时，第一步就是要实现 target 函数——LLVMFuzzerTestOneInput，该函数以 bytes 数组作为输入，函数体内使用待测 API 对这个 bytes 数组进行处理：\n12345// fuzz_target.ccextern &quot;C&quot; int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) &#123;  DoSomethingInterestingWithMyAPI(Data, Size);  return 0;  // Values other than 0 and -1 are reserved for future use.&#125;\n\ntarget 函数的名称、参数类型、返回值类型都不能改变。此外，官方文档中还有如下说明：\n\ntarget 函数在同一个进程中被多次执行，被不同的输入循环调用；\n\ntarget 函数需要容忍任何形势的输入，比如空数据、很长的数据、格式错误的数据等；\n\ntarget 函数不允许调用 exit 函数，否则将导致 Fuzz 终止执行；\n\ntarget 函数中可以使用线程，但是子线程要在函数体结束前 join，即进入下一次循环前，结束上一次循环的子线程；\n\ntarget 函数的结果必须是确定性的，即两次的 Data 如果一致，两次的执行结果也必须一致；\n\ntarget 函数执行速度必须快，避免三阶及以上的复杂度、日志记录和过多的内存消耗；\n\ntarget 函数应尽量避免修改全局状态，因为在同一个进程中修改全局变量，会导致下一次运行与上一次运行的上下文不同，可能影响程序确定性；\n\ntarget 函数的处理范围越窄越好，如果函数要处理多种数据格式，那最好拆分成多个子函数，每个子函数处理一种格式。\n\n\ntarget 函数编写完成后，通过以下命令编译成可执行文件：\n1234clang -g -O1 -fsanitize=fuzzer                         fuzz_target.cc # Builds the fuzz target w/o sanitizersclang -g -O1 -fsanitize=fuzzer,address                 fuzz_target.cc # Builds the fuzz target with ASANclang -g -O1 -fsanitize=fuzzer,signed-integer-overflow fuzz_target.cc # Builds the fuzz target with a part of UBSANclang -g -O1 -fsanitize=fuzzer,memory                  fuzz_target.cc # Builds the fuzz target with MSAN\n\nClang 支持的编译选项可以  参考文档  或者通过–help 查看，构建 LibFuzzer target 时常用的  编译选项  如下：\n\n-g：生成调试信息\n\n-O：设置编译器优化等级，可以是 1&#x2F;2&#x2F;3，默认为 1，数字越大，优化越多，注意2 和 3 有可能导致 Fuzz 找不到 crash\n\n-o：指定输出文件名\n\n-I：uppercase i，添加头文件搜索路径\n\n-L：添加库文件搜索路径\n\n-l：lowercase L，指定库文件名称，动态库和静态库同时存在时，动态库优先\n\n-fsanitize：启用 LibFuzzer，对源码进行插桩，并添加各种  消毒器 sanitizer，对程序进行运行时检查。\n\n-fsanitize&#x3D;fuzzer  编译时对源码插桩，链接 libFuzzer 库文件（使用 libFuzzer 的 main 函数）\n\n-fsanitize&#x3D;fuzzer-no-link  编译时对源码插桩，不链接 libFuzzer，适用于拥有 main 函数的源码。对大型项目来说，构建效率更高\n\n-fsanitize&#x3D;address  地址消毒器（AddressSanitizer），用于检测缓冲区溢出、UAF、Double Free、内存泄漏等内存问题\n\n-fsanitize&#x3D;memory  内存消毒器（MemorySanitizer），用于检测未初始化的内存访问\n\n-fsanitize&#x3D;undefined  未定义行为消毒器（UndefinedBehaviorSanitizer），用于检测程序运行中未定义行为，如越界访问、整数溢出、空指针解引用等\n\n\n\n-fsanitize-coverage：启用代码覆盖率的统计，包括 function 级别，basic block 级别和 edge 级别，详情可  参考文档 。但需要注意的是， 高版本的 clang 中，已经取消了对 -fsanitize-coverage&#x3D;trace-pc-guard 的支持，建议改用 -fsanitize&#x3D;fuzzer 替代，否则会出现报错，参见第二章节使用示例。\n\n-fsanitize-coverage&#x3D;trace-pc-guard,edge  使用 edge 级别代码覆盖率，edge 为默认级别，可省略\n\n-fsanitize-coverage&#x3D;trace-pc-guard,func  使用 function 级别代码覆盖率\n\n-fsanitize-coverage&#x3D;trace-pc-guard,bb  使用 basic block 级别代码覆盖率\n\n\n\n\n关于添加 LibFuzzer 相关选项后的详细构建过程，有兴趣可以参考libFuzzer 编译链接。\n关于 LibFuzzer 通过插桩统计代码覆盖率的具体实现，有兴趣可以参考Coverage Control in libFuzzer。\n3. 执行 fuzz在 target 函数构建成功后，会生成一个可执行的 fuzz 二进制文件，该文件通过命令行方式执行，可以接受指定的参数选项。执行格式为：\n1./fuzz-target -flag1=val1 -flag2=val2 ... path1 path2 ...\n\n在不限制运行时长的情况下，Fuzz 将会一直执行下去，直到出现 crash（通常是因为触发 sanitizer 异常）才会终止。导致 crash 的输入将会作为能触发 bug 的 testcase 保存到磁盘上，并根据 crash 的类型，用不同的文件名前缀进行区分，比如 crash-XXX，leak-XXX，timeout-XXX 等。\n(1) 参数说明  常见的 flag 选项及作用列举如下，使用 flag 时必须以 -flag&#x3D;val 的格式：\n\n\n\nflag\n默认值\n作用\n\n\n\nverbosity\n1\n运行时输出详细日志\n\n\nseed\n0\n随机种子。如果为 0，则自动生成随机种子\n\n\nruns\n-1\n测试运行的次数（-1 表示无限）\n\n\nmax_len\n0\n测试输入的最大长度。若为 0，libFuzzer 会自行猜测\n\n\nshuffle\n1\n为 1 表示启动时打乱初始语料库\n\n\nprefer_small\n1\n为 1 表示打乱语料库时，较小输入更优先\n\n\ntimeout\n1200\n超时时长，单位为秒。如果单次运行超过时长，Fuzz 将被终止\n\n\nmax_total_time\n0\n最大运行时长，单位为秒。若为正，表示 Fuzz 最长运行时间\n\n\nhelp\n0\n为 1 表示打印帮助信息\n\n\nmerge\n0\n为 1 表示在不损失代码覆盖率的情况下，进行语料库合并\n\n\nmerge_control_file\n0\n指定合并进程的控制文件，用于恢复合并状态\n\n\nminimize_crash\n0\n为 1 表示将提供的崩溃输入进行最小化。与 -runs &#x3D; N 或 -max_total_time &#x3D; N 一起使用以限制尝试次数\n\n\njobs\n0\njob 的数量，多个 job 将被分配到 workers 上执行，每个 job 的 stdout&#x2F;stderr 被重定向到 fuzz-&lt;JOB&gt;.log\n\n\nworkers\n0\nworker 的数量，为 0 将使用 min(jobs, number_of_cpu_cores&#x2F;2)\n\n\nreload\n1\n设置重新加载主语料库的间隔秒数。在并行模式下，在多个 job 中同步语料集。为 0 表示禁止\n\n\nreduce_inputs\n1\n为 1 表示尝试减少输入数据的大小，同时保留其完整的特征集\n\n\nrss_limit_mb\n2048\nRSS 内存用量限制，单位为 Mb。为 0 表示无限制\n\n\npurge_allocator_interval\n1\n清理缓存的建个时长，单位为秒。当指定 rss_limit_mb 且 rss 使用率超过 50% 时，开始清理。为 -1 表示禁止\n\n\nmalloc_limit_mb\n0\n单次 malloc 申请内存的大小限制，单位为 Mb。为 0 则采用 rss_limit_mb 进行限制\n\n\ndetect_leaks\n1\n为 1，且启用 LeakSanitizer 消毒器时，将在 Fuzz 过程中检测内存泄漏，而不仅是在 Fuzz 结束时才检测\n\n\nprint_coverage\n0\n退出时打印覆盖率信息\n\n\nprint_corpus_stats\n0\n退出时打印语料信息\n\n\nprint_final_stats\n0\n退出时打印统计信息\n\n\nonly_ascii\n0\n为 1 表示只生成 ASCII（isprint + isspace）字符作为输入\n\n\nartifact_prefix\n0\n将 fuzzing artifacts（crash、timeout 等 file）保存为文件时所使用的前缀，即文件将保存为 $(artifact_prefix)file\n\n\nexact_artifact_path\n0\n将单个 fuzz artfifact 保存为文件时所使用的前缀。将覆盖 -artifact_prefix，并行任务中不要使用相同取值\n\n\n(2) 语料使用  模糊测试通过随机的方式变异或生成测试用例。提供种子语料库作为随机变异的基础用例，避免从头开始生完全随机地生成用例，在待测函数接受复杂或结构化输入的情况下，能显著提升 Fuzz 测试的效率和覆盖率。\nLibFuzzer 是以覆盖率为引导的，当提供种子语料库时，LibFuzzer 从语料库中读取语料，通过随机变异产生新的测试数据，输入到 Fuzz Target。由于在构建 Fuzz Target 时，通过编译参数进行了代码插桩，因此可以跟踪 Fuzz Target 在接收到输入后，具体执行了哪些代码。如果某个测试输入能执行到之前从未执行的代码，那么这个测试输入就是一个有效变异，将被纳入到语料库，作为后续变异的基础。整体流程大致如下，仅做原理示意，不等于具体实现。\ngraph LR\n    A[从语料库中读取样本] --> B[随机变异生成新样本]\n    B --> C[新样本输入 Fuzz Target]\n    C --> D[跟踪代码执行路径]\n    D --> E{是否覆盖新的代码}\n    E -->| 是 | F[测试数据加入语料库]\n    E -->| 否 | B\n    F --> A\n\n使用 corpus 时，需要提供一个或多个存放种子语料的路径，命令为：\n1./fuzz_target -max_len=1000 -jobs=20 corpus_dir  # 种子语料存放在 corpus_dir 目录下\n\n当语料库很大时，可以在保持代码覆盖率的情况下进行精简操作，这时需要用 -merge 参数，命令为：\n1./fuzz_target -merge=1 mini_corpus_dir corpus_dir  # 原始语料集存放在 corpus_dir 目录下，精简后的语料集存放在 mini_corpus_dir 目录下\n\n利用 -merge 参数，还可以实现有效语料的提取，即从一批候选语料中，找到能够触发新代码路径的语料，命令为：\n1./fuzz_target -merge=1 interesting_corpus_dir candidate_corpus_dir  # 候选语料放在 candidate_corpus_dir，有效语料放在 interesting_corpus_dir\n\n总的来说，语料集的路径可以有一个、两个或更多，当使用 -merge 参数时，这些语料集中发现的有效语料，都会被保存到第一个路径下。需要注意的是，合并语料是一个非常耗时的过程，通过使用 -merge_control_file 参数，可以实现无缝恢复的多阶段合并，即通过 killall -SIGUSR1 /path/to/fuzzer/binary 中断合并操作后，下次还能继续上一次的合并进度，继续开始合并操作。示例如下：\n123456789101112131415% rm -f SomeLocalPath% ./my_fuzzer CORPUS1 CORPUS2 -merge=1 -merge_control_file=SomeLocalPath...MERGE-INNER: using the control file &#x27;SomeLocalPath&#x27;...# While this is running, do `killall -SIGUSR1 my_fuzzer` in another console==9015== INFO: libFuzzer: exiting as requested# This will leave the file SomeLocalPath with the partial state of the merge.# Now, you can continue the merge by executing the same command. The merge will continue from where it has been interrupted.% ./my_fuzzer CORPUS1 CORPUS2 -merge=1 -merge_control_file=SomeLocalPath...MERGE-OUTER: non-empty control file provided: &#x27;SomeLocalPath&#x27;MERGE-OUTER: control file ok, 32 files total, first not processed file 20...\n\n语料库除了用于提高 Fuzz 效率，还可用于回归测试。在回归测试和复现 crash 时，还可以具体指定某一个 testcase，命令为：\n1./fuzz_target testcase_path  # testcase_path 就是 fuzz crash 时保存的 testcase file 的文件路径\n\n4. 输出解读  在 Fuzz 执行过程中，标准错误流 stderr 中，通常会输出以下格式的内容：\n12345678910111213INFO: Seed: 1523017872INFO: Loaded 1 modules (16 guards): [0x744e60, 0x744ea0),INFO: -max_len is not provided, using 64INFO: A corpus is not provided, starting from an empty corpus#0    READ units: 1#1    INITED cov: 3 ft: 2 corp: 1/1b exec/s: 0 rss: 24Mb#3811 NEW    cov: 4 ft: 3 corp: 2/2b exec/s: 0 rss: 25Mb L: 1 MS: 5 ChangeBit-ChangeByte-ChangeBit-ShuffleBytes-ChangeByte-#3827 NEW    cov: 5 ft: 4 corp: 3/4b exec/s: 0 rss: 25Mb L: 2 MS: 1 CopyPart-#3963 NEW    cov: 6 ft: 5 corp: 4/6b exec/s: 0 rss: 25Mb L: 2 MS: 2 ShuffleBytes-ChangeBit-#4167 NEW    cov: 7 ft: 6 corp: 5/9b exec/s: 0 rss: 25Mb L: 3 MS: 1 InsertByte-==31511== ERROR: libFuzzer: deadly signal...artifact_prefix=&#x27;./&#x27;; Test unit written to ./crash-b13e8756b13a00cf168300179061fb4b91fefbed\n\n第一行显示 Fuzz 测试使用的随机种子，可以通过 -seed 参数来设置。\n第二行显示插桩后的 PC guards 数量（PC 指 Program Counter），可理解为 Fuzz 识别出来的 edge 总数，参考  此处脚注说明。\n第三行显示输入数据的长度限制，示例中 -max_len 参数没有设置，Fuzz 程序将 -max_len 定为 64，即最大数据长度不超过 64kb。\n第四行显示语料库信息，示例中没有提供 corpus，Fuzz 程序从头开始生成语料。\n第五行到第十行，每行开头的 #N 表示 Fuzz 已执行了 N 次测试输入，后面的内容为测试过程中的事件代码和统计信息：\n\n\n\n事件代码\n含义\n\n\n\nREAD\nFuzz 已从语料库中读取所有初始输入样本\n\n\nINITED\nFuzz 已完成初始化，包括通过被测代码运行每个初始输入样本\n\n\nNEW\nFuzz 生成了一个测试输入样本，它能触发被测代码的新路径，将被保存到主语料库目录\n\n\nREDUCE\nFuzz 找到了一个更好的输入样本，它能保持原有样本的特征集（参考下表 ft 含义），但是 size 更小\n\n\npulse\nFuzz 已生成 2 的 n 次方个输入（定期生成以使用户确信 Fuzz 仍在工作）\n\n\nDONE\nFuzz 已完成操作，因为它已达到指定的迭代限制（-runs）或时间限制（-max_total_time）\n\n\nRELOAD\nFuzz 正在定期重新加载语料库目录中的输入样本，这使它能够发现其他 Fuzz 进程发现的任何输入\n\n\n\n\n\n统计指标\n含义\n\n\n\ncov\n执行当前语料库所覆盖的 block 或 edge 的总数\n\n\nft\nLibFuzzer 使用不同的信号来评估代码覆盖率：边缘覆盖率、边缘计数器、间接调用者 &#x2F; 被调用者对等。这些信号组合起来称为特征\n\n\ncorp\n当前内存测试语料库中的条目数及其大小（单位为 byte）\n\n\nlim\n当前语料库中新样本的长度限制。 随着时间的推移而增加，直到达到最大长度 (-max_len)\n\n\nexec&#x2F;s\n每秒 Fuzz 执行次数\n\n\nrss\n当前内存消耗（单位为 Mb）\n\n\nL\n新样本的大小（单位为 byte）。只用于 NEW 和 REDUCE 事件\n\n\nMS: &lt;n&gt; &lt;operations&gt;\n生成新样本时的变异次数和变异方法。只用于 NEW 和 REDUCE 事件\n\n\n第十一行开始，显示 Fuzz 遇到 crash 并终止执行，导致 crash 的用例被保存为.&#x2F;crash-&lt;sha1&gt; 文件，保存路径和名称可以通过 -artifact_prefix 参数修改。\n二、使用示例  以CVE-2016-5180为例，演示 LibFuzzer 的使用过程。CVE-2016-5180是在 c-ares 中出现的堆溢出问题，是使得 ChromeOS 被攻击（重启后以访客模式执行代码）的漏洞之一。\n1. 下载源码  最新的 c-ares 代码已修复漏洞，为了复现漏洞，clone 代码后，需要恢复到漏洞修复之前。\n123git clone https://github.com/c-ares/c-ares.gitcd c-ares/git reset --hard 51fbb479f7948fca2ace3ff34a15ff27e796afdd\n\n2. 编写 Fuzz 主函数  实现 LLVMFuzzerTestOneInput 函数，将 LibFuzzer 输入的字节流进行转换，调用 ares_create_query 函数，并将代码保存为 target.cc 文件。\n1234567891011121314151617// Copyright 2016 Google Inc. All Rights Reserved.// Licensed under the Apache License, Version 2.0 (the &quot;License&quot;);#include &lt;stdint.h&gt;#include &lt;stdlib.h&gt;#include &lt;string&gt;#include &lt;arpa/nameser.h&gt;#include &lt;ares.h&gt;extern &quot;C&quot; int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) &#123;  unsigned char *buf;  int buflen;  std::string s(reinterpret_cast&lt;const char *&gt;(Data), Size);  ares_create_query(s.c_str(), ns_c_in, ns_t_a, 0x1234, 0, &amp;buf, &amp;buflen, 0);  free(buf);  return 0;&#125;\n\n3. 编译 Fuzz target使用 fuzzer-test-suite 提供的编译脚本，执行 build.sh 脚本，会自动调用 custom-build.sh 和 common.sh 进行编译。三个 shell 脚本和 Fuzz 函数的存放路径如下，脚本中会自动使用 git 拉取代码，这里将第 1 步手动拉取的代码删掉了：\n123456789root@server:~/fuzz$ tree.├── cares│   ├── build.sh│   └── target.cc├── common.sh└── custom-build.sh1 directory, 4 files\n\n注意需要将原始脚本中的 -fsanitize-coverage&#x3D;trace-pc-guard 替换为 -fsanitize&#x3D;fuzzer，否则执行 Fuzz 时会出现错误：-fsanitize-coverage&#x3D;trace-pc-guard is no longer supported by libFuzzer。\n1234root@server:~/fuzz$ ./cares-fsanitize_fuzzer-fsanitize-coverage=trace-pc-guard is no longer supported by libFuzzer.Please either migrate to a compiler that supports -fsanitize=fuzzeror use an older version of libFuzzer\n\n执行脚本进行编译（也可以自己编写命令进行编译，编译相关的内容之后会单独写文章进行说明）：\n1root@server:~/fuzz$ ./cares/build.sh\n\n编译完后，可以看到目录下多了一个二进制文件 cares-fsanitize_fuzzer，两个目录 BUILD 和 SRC。cares-fsanitize_fuzzer 是可执行的 Fuzz 程序，SRC 目录存放 c-ares 含漏洞的源码，BUILD 目录用于存放编译产生的中间文件和最终文件：\n12345678910root@server:~/fuzz$ tree -L 1.├── BUILD├── cares├── cares-fsanitize_fuzzer├── common.sh├── custom-build.sh└── SRC3 directories, 3 files\n\n4. 执行 Fuzz 测试  直接运行编译得到的二进制文件，如需附带参数，可参考第一章节执行 fuzz 的参数说明。\n123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778root@server:~/fuzz$ ./cares-fsanitize_fuzzerINFO: Seed: 817252946INFO: Loaded 1 modules   (10 inline 8-bit counters): 10 [0x5a90e0, 0x5a90ea),INFO: Loaded 1 PC tables (10 PCs): 10 [0x56c278,0x56c318),INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 4096 bytesINFO: A corpus is not provided, starting from an empty corpus#2      INITED cov: 3 ft: 3 corp: 1/1b exec/s: 0 rss: 27Mb#3      NEW    cov: 4 ft: 4 corp: 2/5b lim: 4 exec/s: 0 rss: 27Mb L: 4/4 MS: 1 CrossOver-#10     REDUCE cov: 4 ft: 4 corp: 2/4b lim: 4 exec/s: 0 rss: 27Mb L: 3/3 MS: 2 ChangeByte-CrossOver-#11     REDUCE cov: 4 ft: 4 corp: 2/3b lim: 4 exec/s: 0 rss: 27Mb L: 2/2 MS: 1 EraseBytes-#1368   REDUCE cov: 6 ft: 6 corp: 3/20b lim: 17 exec/s: 0 rss: 27Mb L: 17/17 MS: 2 InsertByte-InsertRepeatedBytes-#1524   REDUCE cov: 6 ft: 6 corp: 3/19b lim: 17 exec/s: 0 rss: 27Mb L: 16/16 MS: 1 EraseBytes-===================================================================3049145==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x6030012599c2 at pc 0x000000550e1c bp 0x7fffbad826d0 sp 0x7fffbad826c8WRITE of size 1 at 0x6030012599c2 thread T0    #0 0x550e1b in ares_create_query (/home/fuzz/cares-fsanitize_fuzzer+0x550e1b)    #1 0x55053c in LLVMFuzzerTestOneInput /home/fuzz/cares/target.cc:14:3    #2 0x4586a1 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) (/home/fuzz/cares-fsanitize_fuzzer+0x4586a1)    #3 0x457de5 in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool*) (/home/fuzz/cares-fsanitize_fuzzer+0x457de5)    #4 0x45a087 in fuzzer::Fuzzer::MutateAndTestOne() (/home/fuzz/cares-fsanitize_fuzzer+0x45a087)    #5 0x45ad85 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector&lt;fuzzer::SizedFile, fuzzer::fuzzer_allocator&lt;fuzzer::SizedFile&gt; &gt;&amp;) (/home/fuzz/cares-fsanitize_fuzzer+0x45ad85)    #6 0x44973e in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (/home/fuzz/cares-fsanitize_fuzzer+0x44973e)    #7 0x472582 in main (/home/fuzz/cares-fsanitize_fuzzer+0x472582)    #8 0x7fd31481c082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082)    #9 0x41e4dd in _start (/home/fuzz/cares-fsanitize_fuzzer+0x41e4dd)0x6030012599c2 is located 0 bytes to the right of 18-byte region [0x6030012599b0,0x6030012599c2)allocated by thread T0 here:    #0 0x51e20d in malloc (/home/fuzz/cares-fsanitize_fuzzer+0x51e20d)    #1 0x5508f6 in ares_create_query (/home/fuzz/cares-fsanitize_fuzzer+0x5508f6)    #2 0x55053c in LLVMFuzzerTestOneInput /home/fuzz/cares/target.cc:14:3    #3 0x4586a1 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) (/home/fuzz/cares-fsanitize_fuzzer+0x4586a1)    #4 0x457de5 in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool*) (/home/fuzz/cares-fsanitize_fuzzer+0x457de5)    #5 0x45a087 in fuzzer::Fuzzer::MutateAndTestOne() (/home/fuzz/cares-fsanitize_fuzzer+0x45a087)    #6 0x45ad85 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector&lt;fuzzer::SizedFile, fuzzer::fuzzer_allocator&lt;fuzzer::SizedFile&gt; &gt;&amp;) (/home/fuzz/cares-fsanitize_fuzzer+0x45ad85)    #7 0x44973e in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (/home/fuzz/cares-fsanitize_fuzzer+0x44973e)    #8 0x472582 in main (/home/fuzz/cares-fsanitize_fuzzer+0x472582)    #9 0x7fd31481c082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082)SUMMARY: AddressSanitizer: heap-buffer-overflow (/home/fuzz/cares-fsanitize_fuzzer+0x550e1b) in ares_create_queryShadow bytes around the buggy address:  0x0c06802432e0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa  0x0c06802432f0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa  0x0c0680243300: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa  0x0c0680243310: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa  0x0c0680243320: fa fa fa fa fa fa fa fa fa fa fd fd fd fa fa fa=&gt;0x0c0680243330: fd fd fd fa fa fa 00 00[02]fa fa fa fd fd fd fa  0x0c0680243340: fa fa fd fd fd fa fa fa fd fd fd fa fa fa fd fd  0x0c0680243350: fd fa fa fa fd fd fd fa fa fa fd fd fd fa fa fa  0x0c0680243360: fd fd fd fa fa fa fd fd fd fa fa fa fd fd fd fa  0x0c0680243370: fa fa fd fd fd fa fa fa fd fd fd fa fa fa fd fd  0x0c0680243380: fd fa fa fa fd fd fd fa fa fa fd fd fd fa fa faShadow byte legend (one shadow byte represents 8 application bytes):  Addressable:           00  Partially addressable: 01 02 03 04 05 06 07  Heap left redzone:       fa  Freed heap region:       fd  Stack left redzone:      f1  Stack mid redzone:       f2  Stack right redzone:     f3  Stack after return:      f5  Stack use after scope:   f8  Global redzone:          f9  Global init order:       f6  Poisoned by user:        f7  Container overflow:      fc  Array cookie:            ac  Intra object redzone:    bb  ASan internal:           fe  Left alloca redzone:     ca  Right alloca redzone:    cb  Shadow gap:              cc==3049145==ABORTINGMS: 4 ChangeByte-InsertByte-CopyPart-ChangeByte-; base unit: 00b28ff06b788b9b67c6b259800f404f9f3761fd0x5c,0x2e,0x0,0x6b,0x0,\\\\.\\x00k\\x00artifact_prefix=&#x27;./&#x27;; Test unit written to ./crash-edef708d314ed627eba0ef2b042e47aa96a9b899Base64: XC4AawA=\n\n可以看到，LibFuzzer 发现了 c-ares 中的 heap-buffer-overflow 漏洞，触发 crash 的用例保存为 crash-edef708d314ed627eba0ef2b042e47aa96a9b899 文件，该用例包含 5 个字节，字节码分别为：0x5c,0x2e,0x0,0x6b,0x0，其中 0x0 为空字符 NULL，属于不可见字符。\n5. 提取语料  执行 Fuzz 时，传入一个空文件夹作为 copus 路径，执行完后，可以在文件夹中看到 LibFuzzer 执行过程中，生成的有效语料。\n123456789101112131415161718192021222324252627282930313233343536373839404142root@server:~/fuzz/cares$ mkdir corpusroot@server:~/fuzz/cares$ lsBUILD  build.sh  cares_fuzzer  corpus  target.ccroot@server:~/fuzz/cares$ ./cares_fuzzer corpus/INFO: Seed: 4140748905INFO: Loaded 1 modules   (57 inline 8-bit counters): 57 [0x5a9100, 0x5a9139),INFO: Loaded 1 PC tables (57 PCs): 57 [0x5a9140,0x5a94d0),INFO:        0 files found in corpus/INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 4096 bytesINFO: A corpus is not provided, starting from an empty corpus#2      INITED cov: 13 ft: 14 corp: 1/1b exec/s: 0 rss: 27Mb#4      NEW    cov: 16 ft: 20 corp: 2/3b lim: 4 exec/s: 0 rss: 27Mb L: 2/2 MS: 2 ChangeByte-InsertByte-#9      NEW    cov: 16 ft: 26 corp: 3/6b lim: 4 exec/s: 0 rss: 27Mb L: 3/3 MS: 5 ChangeBit-ChangeByte-ChangeByte-CopyPart-InsertByte-#10     NEW    cov: 16 ft: 32 corp: 4/10b lim: 4 exec/s: 0 rss: 27Mb L: 4/4 MS: 1 CrossOver-#25     NEW    cov: 18 ft: 34 corp: 5/11b lim: 4 exec/s: 0 rss: 27Mb L: 1/4 MS: 5 ChangeBit-ChangeASCIIInt-CMP-CrossOver-EraseBytes- DE: &quot;\\x01\\x00&quot;-#94     NEW    cov: 19 ft: 35 corp: 6/15b lim: 4 exec/s: 0 rss: 27Mb L: 4/4 MS: 4 CrossOver-ShuffleBytes-ChangeByte-ChangeBit-#108    NEW    cov: 21 ft: 37 corp: 7/16b lim: 4 exec/s: 0 rss: 27Mb L: 1/4 MS: 4 ChangeByte-ShuffleBytes-ChangeBit-ChangeByte-#125    NEW    cov: 22 ft: 38 corp: 8/18b lim: 4 exec/s: 0 rss: 27Mb L: 2/4 MS: 2 ShuffleBytes-InsertByte-...==3237059==ABORTINGMS: 2 InsertRepeatedBytes-ChangeByte-; base unit: 1bef8aac927d18852642a96c20e50efba80fdfae0x5c,0x5,0x98,0x98,0x98,0x98,0x98,0x98,0x98,0x98,0x98,0x98,0x98,0x5c,0x2e,\\\\\\x05\\x98\\x98\\x98\\x98\\x98\\x98\\x98\\x98\\x98\\x98\\x98\\\\.artifact_prefix=&#x27;./&#x27;; Test unit written to ./crash-157768d6f06d94325fe0e6bcf66cbd2d27dd8db7Base64: XAWYmJiYmJiYmJiYmFwuroot@server:~/fuzz/cares$ ls -altotal 2244drwxrwxr-x 4 root root    4096 Sep 26 17:47 .drwxrwxr-x 5 root root    4096 Sep 26 15:25 ..drwxrwxr-x 9 root root   20480 Sep 26 17:18 BUILD-rw-rw-r-- 1 root root     722 Sep 26 17:13 build.sh-rwxrwxr-x 1 root root 2250720 Sep 26 17:18 cares_fuzzerdrwxrwxr-x 2 root root    4096 Sep 26 17:47 corpus-rw-rw-r-- 1 root root      15 Sep 26 17:47 crash-157768d6f06d94325fe0e6bcf66cbd2d27dd8db7-rw-rw-r-- 1 root root     499 Sep 26 17:14 target.ccroot@server:~/fuzz/cares$ ls corpus/08534f33c201a45017b502e90a800f1b708ebcb3  5175b74bd75b8d90a01f77709deba3982fbbdcb2  78bdce51613f555049a9937095bf469bcb77e94f  be566cb17d3bce0b2a8e5e710b3779df720db1f50f1c5448bf80343eeac759f8adcbdc2720533d15  5318c4ac20dac95a702bee2e27834d39ea6bc2b6  8e54ed049741d7cf6fb8ef7f4288ef0be3b54f17  be5c29e07560abcf094c3419712a01590bbe85940fe509b10d833be6eb3d5ed4947cbe0fbb64ed84  5ba93c9db0cff93f52b521d7420e43f6eda2784f  8ea51a3719d7cbfc3e2dcd3edf6109918d5aad55  caea31b9ef76b9be352ad1054956efbb86d4451a1bef8aac927d18852642a96c20e50efba80fdfae  60321f72401b49b895535045eb8d3b9ca7db7c7c  91a3f7c503955600f5dac12c1c1a3c5b674a4d98  dea712be0e801f4502a21e04dfbec5bd0cbc677c24792aa3923c4cd185519d3d445ecfd0801db1c1  6380a9a2d2701df0cb53d880842747cbefef8a5d  9f64357cb30f24cf567513e140e9fb0cbf1a2be5  e716589d09e16cf4a48d2c7f1d357bb481aaf3bc3a52ce780950d4d969792a2559cd519d7ee8c727  6414bd7955e39106721edf7cc29efdb82f7007ac  b534844fd943d8b338025ad82d68283f1bcdb5c0\n\n6. 合并语料  当 Fuzz 执行很久之后，会产生大量语料。为了减少语料数量，可以使用 merge 参数进行合并。创建一个 min_corpus 目录，执行 Fuzz 时，启动 merge 参数，传入 min_corpus 目录和 corpus 目录，合并完后，可以在 min_corpus 目录下看到缩减之后的语料。以下示例显示预料数据从 31 个减少到 29 个：\n1234567891011121314151617181920212223root@server:~/fuzz/cares$ mkdir min_corpusroot@server:~/fuzz/cares$ ./cares_fuzzer -merge=1 min_corpus/ corpus/INFO: Seed: 1671146211INFO: Loaded 1 modules   (57 inline 8-bit counters): 57 [0x5a9100, 0x5a9139),INFO: Loaded 1 PC tables (57 PCs): 57 [0x5a9140,0x5a94d0),MERGE-OUTER: 31 files, 0 in the initial corpus, 0 processed earlierMERGE-OUTER: attempt 1INFO: Seed: 1671165588INFO: Loaded 1 modules   (57 inline 8-bit counters): 57 [0x5a9100, 0x5a9139),INFO: Loaded 1 PC tables (57 PCs): 57 [0x5a9140,0x5a94d0),INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 1048576 bytesMERGE-INNER: using the control file &#x27;/tmp/libFuzzerTemp.3327149.txt&#x27;MERGE-INNER: 31 total files; 0 processed earlier; will process 31 files now#1      pulse  cov: 9 ft: 10 exec/s: 0 rss: 27Mb#2      pulse  cov: 13 ft: 14 exec/s: 0 rss: 27Mb#4      pulse  cov: 20 ft: 22 exec/s: 0 rss: 27Mb#8      pulse  cov: 28 ft: 38 exec/s: 0 rss: 27Mb#16     pulse  cov: 29 ft: 56 exec/s: 0 rss: 27Mb#31     DONE   cov: 29 ft: 82 exec/s: 0 rss: 28MbMERGE-OUTER: succesfull in 1 attempt(s)MERGE-OUTER: the control file has 2691 bytesMERGE-OUTER: consumed 0Mb (27Mb rss) to parse the control fileMERGE-OUTER: 29 new files with 82 new features added; 29 new coverage edges\n\n三、优化技巧  整体优化思路分两种：\n\n找到 crash 更快 –&gt; 并行化，多个实例一起运行\n覆盖 edge 更多 –&gt; 加强语料，让输入能走到更深的分支\n\n（一）并行化1、LibFuzzer(1) jobs 和 workers\n\njobs：指定 fuzz 实例的数量。在不设置运行时长的情况下，每个 fuzz 实例找到 crash 才会停止。理论上有多少 jobs，最后会产生多少个 crash 文件。但实际上，不同的 job 可能找到同样的 crash，最后 crash 文件个数少于 job 个数。\nworks：执行 fuzz 进程的数量。在多个 jobs 的情况下，平均每个 woker 执行 #jobs&#x2F;#workers 个 job。\n\n简单来说，使用 workers 能提升 fuzz 运行速度，使用 jobs 能增加 crash 数量（仅根据输入去重，没有对调用栈去重）。 只使用 jobs 的情况下，默认开启 min(#jobs, #cores) &#x2F;&#x2F; 2 个 workers。\n(2) fork\n目前 fork 是实验阶段的参数，计划最终使用 fork 代替 jobs 和 workers 来实现 LibFuzzer 的并行化。\n\nfork：父进程不直接执行 fuzz，而是开启 N 个子进程，每个子进程使用语料库的随机子集进行 fuzz，当子进程退出后，该子进程的语料将被合并到主语料库中。子进程可以通过设置参数，来实现对指定错误的容错能力：\n\n-ignore_ooms：默认为 True。子进程发生内存溢出时，保存输入用于重现，但 fuzz 继续执行。\n\n-ignore_timeouts：默认为 True。子进程发生超时时，保留输入用于重现，但 fuzz 继续执行。\n\n-ignore_crashes：默认为 False。子进程发生其他类型 crash 时，保留输入用于重现，但 fuzz 继续执行。\n\n\n2、LibFuzzer 结合 AFLAFL 可以支持 LibFuzzer 的 target，编译方法参考  此处说明。\n12afl-fuzz -i testcase_dir -o findings_dir ./fuzz-target @@ ./fuzz-target testcase_dir findings_dir # Will write new tests to testcase_dir\n\n需要定期重启 AFL 和 LibFuzzer，以完成语料同步。\n（二）加强语料 1、字典 运行时使用 -dict 参数指定字典（Dictionary）文件的路径，字典用于指定和控制模糊测试中输入数据的一部分，从而提高模糊测试的效果。\n字典文件：\n12345678910# Lines starting with &#x27;#&#x27; and empty lines are ignored.# Adds &quot;blah&quot; (w/o quotes) to the dictionary.kw1=&quot;blah&quot;# Use \\\\ for backslash and \\&quot; for quotes.kw2=&quot;\\&quot;ac\\\\dc\\&quot;&quot;# Use \\xAB for hex valueskw3=&quot;\\xF7\\xF8&quot;# the name of the keyword followed by &#x27;=&#x27; may be omitted:&quot;foo\\x0Abar&quot;\n\n使用方法（运行时）：\n1./fuzz-target -dict=dict_file\n\n2、CMP编译时使用 -fsanitize-coverage&#x3D;trace-cmp 参数，让 fuzz 拦截 CMP 指令（例如 if 语句中的 compare 条件）并根据拦截到的 CMP 指令的参数来引导变异。这可能会减慢模糊测试的速度，但很可能会改善测试结果。\n使用方法（编译时）：\n1clang++ buggy.cc -fsanitize=fuzzer,address -fsanitize-coverage=trace-cmp -g -o buggy-fuzzer\n\n3、Value Profile需要与 -fsanitize-coverage=trace-cmp 一起使用，让 fuzz 收集 CMP 指令的参数值进行分析，用于发现更多的有效输入。但是有两个缺点：首先可能会导致速度降低 2 倍。 其次语料库可能增长数倍。\n使用方法（运行时）：\n1./fuzz-target -use_value_profile=1\n\n4、Fuzzer-friendly build mode程序中可能存在某些对 fuzz 不友好的特性，例如：\n\n随机化：同一个输入，可能走不同的路径\n校验和：拦截无效输入\n\n此时可以用构建宏 FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 来编译一个对 fuzz 友好的版本，使用时需要对源码进行修改。例如：\n12345678void MyInitPRNG() &#123;#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION  // In fuzzing mode the behavior of the code should be deterministic.  srand(0);#else  srand(time(0));#endif&#125;\n\n四、 参考资料\nlibFuzzer – a library for coverage-guided fuzz testing\nlibFuzzer 使用总结教程\nEfficient Fuzzing Guide\nThe art of fuzzing-A Step-by-Step Guide to Coverage-Guided Fuzzing with LibFuzzer\nAn introduction to LLVM libFuzzer\nAn informative guide on using AFL and libFuzzer\nlibfuzzer-workshop\nSanitizers\nThe Magic Behind Feedback-Based Fuzzing\n","dateCreated":"2023-09-17T18:30:15+08:00","dateModified":"2024-06-26T14:24:54+08:00","datePublished":"2023-09-17T18:30:15+08:00","description":"模糊测试工具 LibFuzzer 从 0 到 1，原理 + 安装 + 使用 + 优化，一篇讲完","headline":"LibFuzzer 使用说明","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2023/LibFuzzer%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://www.stepbystep.asia/2023/LibFuzzer%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E/","keywords":"Fuzz, 安全, 工具, LibFuzzer"}</script>
+    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg"},"articleBody":"\n\n按照  官方定义，LibFuzzer 是一个in-process（进程内的），coverage-guided（以覆盖率为引导的），evolutionary（进化的） 的 fuzz 引擎，是 LLVM 项目的一部分，主要用于对 C&#x2F;C++ 程序进行 Fuzz 测试。LibFuzzer 三个特性的具体含义为：\n\nin-process：不会为每个测试用例启动一个进程，而是将所有的测试数据投放在同一个进程的内存空间中\n\ncoverage-guided：对每一个测试输入都进行代码覆盖率计算，不断累积测试用例使得代码覆盖率最大化\n\nevolutionary：结合了变异和生成两种形势的 Fuzz 引擎\n\n变异：基于已有的数据样本，通过一些变异规则，产生新的测试用例\n\n生成：通过对目标协议或接口规范进行建模，从零开始产生测试用例\n\n\n\n\nLibFuzzer 与待测的 library 进行链接，通过向指定的 fuzzing 入口（即target 函数）发送测试数据，并跟踪被触达的代码区域，然后对输入的数据进行变异，以达到代码覆盖率最大的目的，其中代码覆盖率的信息由 LLVM 的 SanitizerCoverage 工具提供。\n一、使用方法 1. 安装环境Clang 是一个类似 GCC 的 C&#x2F;C++ 语言编译工具，此处 简介。LibFuzzer 现在已被集成到 Clang 6.0 之后的版本中，在 Linux 环境下，只需直接安装 Clang 即可：\n1apt install clang\n\n安装完毕之后，可以通过如下命令查看 clang 版本：\n1clang --version\n\n2. 构建 target使用 LibFuzzer 时，第一步就是要实现 target 函数——LLVMFuzzerTestOneInput，该函数以 bytes 数组作为输入，函数体内使用待测 API 对这个 bytes 数组进行处理：\n12345// fuzz_target.ccextern &quot;C&quot; int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) &#123;  DoSomethingInterestingWithMyAPI(Data, Size);  return 0;  // Values other than 0 and -1 are reserved for future use.&#125;\n\ntarget 函数的名称、参数类型、返回值类型都不能改变。此外，官方文档中还有如下说明：\n\ntarget 函数在同一个进程中被多次执行，被不同的输入循环调用；\n\ntarget 函数需要容忍任何形势的输入，比如空数据、很长的数据、格式错误的数据等；\n\ntarget 函数不允许调用 exit 函数，否则将导致 Fuzz 终止执行；\n\ntarget 函数中可以使用线程，但是子线程要在函数体结束前 join，即进入下一次循环前，结束上一次循环的子线程；\n\ntarget 函数的结果必须是确定性的，即两次的 Data 如果一致，两次的执行结果也必须一致；\n\ntarget 函数执行速度必须快，避免三阶及以上的复杂度、日志记录和过多的内存消耗；\n\ntarget 函数应尽量避免修改全局状态，因为在同一个进程中修改全局变量，会导致下一次运行与上一次运行的上下文不同，可能影响程序确定性；\n\ntarget 函数的处理范围越窄越好，如果函数要处理多种数据格式，那最好拆分成多个子函数，每个子函数处理一种格式。\n\n\ntarget 函数编写完成后，通过以下命令编译成可执行文件：\n1234clang -g -O1 -fsanitize=fuzzer                         fuzz_target.cc # Builds the fuzz target w/o sanitizersclang -g -O1 -fsanitize=fuzzer,address                 fuzz_target.cc # Builds the fuzz target with ASANclang -g -O1 -fsanitize=fuzzer,signed-integer-overflow fuzz_target.cc # Builds the fuzz target with a part of UBSANclang -g -O1 -fsanitize=fuzzer,memory                  fuzz_target.cc # Builds the fuzz target with MSAN\n\nClang 支持的编译选项可以  参考文档  或者通过–help 查看，构建 LibFuzzer target 时常用的  编译选项  如下：\n\n-g：生成调试信息\n\n-O：设置编译器优化等级，可以是 1&#x2F;2&#x2F;3，默认为 1，数字越大，优化越多，注意2 和 3 有可能导致 Fuzz 找不到 crash\n\n-o：指定输出文件名\n\n-I：uppercase i，添加头文件搜索路径\n\n-L：添加库文件搜索路径\n\n-l：lowercase L，指定库文件名称，动态库和静态库同时存在时，动态库优先\n\n-fsanitize：启用 LibFuzzer，对源码进行插桩，并添加各种  消毒器 sanitizer，对程序进行运行时检查。\n\n-fsanitize&#x3D;fuzzer  编译时对源码插桩，链接 libFuzzer 库文件（使用 libFuzzer 的 main 函数）\n\n-fsanitize&#x3D;fuzzer-no-link  编译时对源码插桩，不链接 libFuzzer，适用于拥有 main 函数的源码。对大型项目来说，构建效率更高\n\n-fsanitize&#x3D;address  地址消毒器（AddressSanitizer），用于检测缓冲区溢出、UAF、Double Free、内存泄漏等内存问题\n\n-fsanitize&#x3D;memory  内存消毒器（MemorySanitizer），用于检测未初始化的内存访问\n\n-fsanitize&#x3D;undefined  未定义行为消毒器（UndefinedBehaviorSanitizer），用于检测程序运行中未定义行为，如越界访问、整数溢出、空指针解引用等\n\n\n\n-fsanitize-coverage：启用代码覆盖率的统计，包括 function 级别，basic block 级别和 edge 级别，详情可  参考文档 。但需要注意的是， 高版本的 clang 中，已经取消了对 -fsanitize-coverage&#x3D;trace-pc-guard 的支持，建议改用 -fsanitize&#x3D;fuzzer 替代，否则会出现报错，参见第二章节使用示例。\n\n-fsanitize-coverage&#x3D;trace-pc-guard,edge  使用 edge 级别代码覆盖率，edge 为默认级别，可省略\n\n-fsanitize-coverage&#x3D;trace-pc-guard,func  使用 function 级别代码覆盖率\n\n-fsanitize-coverage&#x3D;trace-pc-guard,bb  使用 basic block 级别代码覆盖率\n\n\n\n\n关于添加 LibFuzzer 相关选项后的详细构建过程，有兴趣可以参考libFuzzer 编译链接。\n关于 LibFuzzer 通过插桩统计代码覆盖率的具体实现，有兴趣可以参考Coverage Control in libFuzzer。\n3. 执行 fuzz在 target 函数构建成功后，会生成一个可执行的 fuzz 二进制文件，该文件通过命令行方式执行，可以接受指定的参数选项。执行格式为：\n1./fuzz-target -flag1=val1 -flag2=val2 ... path1 path2 ...\n\n在不限制运行时长的情况下，Fuzz 将会一直执行下去，直到出现 crash（通常是因为触发 sanitizer 异常）才会终止。导致 crash 的输入将会作为能触发 bug 的 testcase 保存到磁盘上，并根据 crash 的类型，用不同的文件名前缀进行区分，比如 crash-XXX，leak-XXX，timeout-XXX 等。\n(1) 参数说明  常见的 flag 选项及作用列举如下，使用 flag 时必须以 -flag&#x3D;val 的格式：\n\n\n\nflag\n默认值\n作用\n\n\n\nverbosity\n1\n运行时输出详细日志\n\n\nseed\n0\n随机种子。如果为 0，则自动生成随机种子\n\n\nruns\n-1\n测试运行的次数（-1 表示无限）\n\n\nmax_len\n0\n测试输入的最大长度。若为 0，libFuzzer 会自行猜测\n\n\nshuffle\n1\n为 1 表示启动时打乱初始语料库\n\n\nprefer_small\n1\n为 1 表示打乱语料库时，较小输入更优先\n\n\ntimeout\n1200\n超时时长，单位为秒。如果单次运行超过时长，Fuzz 将被终止\n\n\nmax_total_time\n0\n最大运行时长，单位为秒。若为正，表示 Fuzz 最长运行时间\n\n\nhelp\n0\n为 1 表示打印帮助信息\n\n\nmerge\n0\n为 1 表示在不损失代码覆盖率的情况下，进行语料库合并\n\n\nmerge_control_file\n0\n指定合并进程的控制文件，用于恢复合并状态\n\n\nminimize_crash\n0\n为 1 表示将提供的崩溃输入进行最小化。与 -runs &#x3D; N 或 -max_total_time &#x3D; N 一起使用以限制尝试次数\n\n\njobs\n0\njob 的数量，多个 job 将被分配到 workers 上执行，每个 job 的 stdout&#x2F;stderr 被重定向到 fuzz-&lt;JOB&gt;.log\n\n\nworkers\n0\nworker 的数量，为 0 将使用 min(jobs, number_of_cpu_cores&#x2F;2)\n\n\nreload\n1\n设置重新加载主语料库的间隔秒数。在并行模式下，在多个 job 中同步语料集。为 0 表示禁止\n\n\nreduce_inputs\n1\n为 1 表示尝试减少输入数据的大小，同时保留其完整的特征集\n\n\nrss_limit_mb\n2048\nRSS 内存用量限制，单位为 Mb。为 0 表示无限制\n\n\npurge_allocator_interval\n1\n清理缓存的建个时长，单位为秒。当指定 rss_limit_mb 且 rss 使用率超过 50% 时，开始清理。为 -1 表示禁止\n\n\nmalloc_limit_mb\n0\n单次 malloc 申请内存的大小限制，单位为 Mb。为 0 则采用 rss_limit_mb 进行限制\n\n\ndetect_leaks\n1\n为 1，且启用 LeakSanitizer 消毒器时，将在 Fuzz 过程中检测内存泄漏，而不仅是在 Fuzz 结束时才检测\n\n\nprint_coverage\n0\n退出时打印覆盖率信息\n\n\nprint_corpus_stats\n0\n退出时打印语料信息\n\n\nprint_final_stats\n0\n退出时打印统计信息\n\n\nonly_ascii\n0\n为 1 表示只生成 ASCII（isprint + isspace）字符作为输入\n\n\nartifact_prefix\n0\n将 fuzzing artifacts（crash、timeout 等 file）保存为文件时所使用的前缀，即文件将保存为 $(artifact_prefix)file\n\n\nexact_artifact_path\n0\n将单个 fuzz artfifact 保存为文件时所使用的前缀。将覆盖 -artifact_prefix，并行任务中不要使用相同取值\n\n\n(2) 语料使用  模糊测试通过随机的方式变异或生成测试用例。提供种子语料库作为随机变异的基础用例，避免从头开始生完全随机地生成用例，在待测函数接受复杂或结构化输入的情况下，能显著提升 Fuzz 测试的效率和覆盖率。\nLibFuzzer 是以覆盖率为引导的，当提供种子语料库时，LibFuzzer 从语料库中读取语料，通过随机变异产生新的测试数据，输入到 Fuzz Target。由于在构建 Fuzz Target 时，通过编译参数进行了代码插桩，因此可以跟踪 Fuzz Target 在接收到输入后，具体执行了哪些代码。如果某个测试输入能执行到之前从未执行的代码，那么这个测试输入就是一个有效变异，将被纳入到语料库，作为后续变异的基础。整体流程大致如下，仅做原理示意，不等于具体实现。\ngraph LR\n    A[从语料库中读取样本] --> B[随机变异生成新样本]\n    B --> C[新样本输入 Fuzz Target]\n    C --> D[跟踪代码执行路径]\n    D --> E{是否覆盖新的代码}\n    E -->| 是 | F[测试数据加入语料库]\n    E -->| 否 | B\n    F --> A\n\n使用 corpus 时，需要提供一个或多个存放种子语料的路径，命令为：\n1./fuzz_target -max_len=1000 -jobs=20 corpus_dir  # 种子语料存放在 corpus_dir 目录下\n\n当语料库很大时，可以在保持代码覆盖率的情况下进行精简操作，这时需要用 -merge 参数，命令为：\n1./fuzz_target -merge=1 mini_corpus_dir corpus_dir  # 原始语料集存放在 corpus_dir 目录下，精简后的语料集存放在 mini_corpus_dir 目录下\n\n利用 -merge 参数，还可以实现有效语料的提取，即从一批候选语料中，找到能够触发新代码路径的语料，命令为：\n1./fuzz_target -merge=1 interesting_corpus_dir candidate_corpus_dir  # 候选语料放在 candidate_corpus_dir，有效语料放在 interesting_corpus_dir\n\n总的来说，语料集的路径可以有一个、两个或更多，当使用 -merge 参数时，这些语料集中发现的有效语料，都会被保存到第一个路径下。需要注意的是，合并语料是一个非常耗时的过程，通过使用 -merge_control_file 参数，可以实现无缝恢复的多阶段合并，即通过 killall -SIGUSR1 /path/to/fuzzer/binary 中断合并操作后，下次还能继续上一次的合并进度，继续开始合并操作。示例如下：\n123456789101112131415% rm -f SomeLocalPath% ./my_fuzzer CORPUS1 CORPUS2 -merge=1 -merge_control_file=SomeLocalPath...MERGE-INNER: using the control file &#x27;SomeLocalPath&#x27;...# While this is running, do `killall -SIGUSR1 my_fuzzer` in another console==9015== INFO: libFuzzer: exiting as requested# This will leave the file SomeLocalPath with the partial state of the merge.# Now, you can continue the merge by executing the same command. The merge will continue from where it has been interrupted.% ./my_fuzzer CORPUS1 CORPUS2 -merge=1 -merge_control_file=SomeLocalPath...MERGE-OUTER: non-empty control file provided: &#x27;SomeLocalPath&#x27;MERGE-OUTER: control file ok, 32 files total, first not processed file 20...\n\n语料库除了用于提高 Fuzz 效率，还可用于回归测试。在回归测试和复现 crash 时，还可以具体指定某一个 testcase，命令为：\n1./fuzz_target testcase_path  # testcase_path 就是 fuzz crash 时保存的 testcase file 的文件路径\n\n4. 输出解读  在 Fuzz 执行过程中，标准错误流 stderr 中，通常会输出以下格式的内容：\n12345678910111213INFO: Seed: 1523017872INFO: Loaded 1 modules (16 guards): [0x744e60, 0x744ea0),INFO: -max_len is not provided, using 64INFO: A corpus is not provided, starting from an empty corpus#0    READ units: 1#1    INITED cov: 3 ft: 2 corp: 1/1b exec/s: 0 rss: 24Mb#3811 NEW    cov: 4 ft: 3 corp: 2/2b exec/s: 0 rss: 25Mb L: 1 MS: 5 ChangeBit-ChangeByte-ChangeBit-ShuffleBytes-ChangeByte-#3827 NEW    cov: 5 ft: 4 corp: 3/4b exec/s: 0 rss: 25Mb L: 2 MS: 1 CopyPart-#3963 NEW    cov: 6 ft: 5 corp: 4/6b exec/s: 0 rss: 25Mb L: 2 MS: 2 ShuffleBytes-ChangeBit-#4167 NEW    cov: 7 ft: 6 corp: 5/9b exec/s: 0 rss: 25Mb L: 3 MS: 1 InsertByte-==31511== ERROR: libFuzzer: deadly signal...artifact_prefix=&#x27;./&#x27;; Test unit written to ./crash-b13e8756b13a00cf168300179061fb4b91fefbed\n\n第一行显示 Fuzz 测试使用的随机种子，可以通过 -seed 参数来设置。\n第二行显示插桩后的 PC guards 数量（PC 指 Program Counter），可理解为 Fuzz 识别出来的 edge 总数，参考  此处脚注说明。\n第三行显示输入数据的长度限制，示例中 -max_len 参数没有设置，Fuzz 程序将 -max_len 定为 64，即最大数据长度不超过 64kb。\n第四行显示语料库信息，示例中没有提供 corpus，Fuzz 程序从头开始生成语料。\n第五行到第十行，每行开头的 #N 表示 Fuzz 已执行了 N 次测试输入，后面的内容为测试过程中的事件代码和统计信息：\n\n\n\n事件代码\n含义\n\n\n\nREAD\nFuzz 已从语料库中读取所有初始输入样本\n\n\nINITED\nFuzz 已完成初始化，包括通过被测代码运行每个初始输入样本\n\n\nNEW\nFuzz 生成了一个测试输入样本，它能触发被测代码的新路径，将被保存到主语料库目录\n\n\nREDUCE\nFuzz 找到了一个更好的输入样本，它能保持原有样本的特征集（参考下表 ft 含义），但是 size 更小\n\n\npulse\nFuzz 已生成 2 的 n 次方个输入（定期生成以使用户确信 Fuzz 仍在工作）\n\n\nDONE\nFuzz 已完成操作，因为它已达到指定的迭代限制（-runs）或时间限制（-max_total_time）\n\n\nRELOAD\nFuzz 正在定期重新加载语料库目录中的输入样本，这使它能够发现其他 Fuzz 进程发现的任何输入\n\n\n\n\n\n统计指标\n含义\n\n\n\ncov\n执行当前语料库所覆盖的 block 或 edge 的总数\n\n\nft\nLibFuzzer 使用不同的信号来评估代码覆盖率：边缘覆盖率、边缘计数器、间接调用者 &#x2F; 被调用者对等。这些信号组合起来称为特征\n\n\ncorp\n当前内存测试语料库中的条目数及其大小（单位为 byte）\n\n\nlim\n当前语料库中新样本的长度限制。 随着时间的推移而增加，直到达到最大长度 (-max_len)\n\n\nexec&#x2F;s\n每秒 Fuzz 执行次数\n\n\nrss\n当前内存消耗（单位为 Mb）\n\n\nL\n新样本的大小（单位为 byte）。只用于 NEW 和 REDUCE 事件\n\n\nMS: &lt;n&gt; &lt;operations&gt;\n生成新样本时的变异次数和变异方法。只用于 NEW 和 REDUCE 事件\n\n\n第十一行开始，显示 Fuzz 遇到 crash 并终止执行，导致 crash 的用例被保存为.&#x2F;crash-&lt;sha1&gt; 文件，保存路径和名称可以通过 -artifact_prefix 参数修改。\n二、使用示例  以CVE-2016-5180为例，演示 LibFuzzer 的使用过程。CVE-2016-5180是在 c-ares 中出现的堆溢出问题，是使得 ChromeOS 被攻击（重启后以访客模式执行代码）的漏洞之一。\n1. 下载源码  最新的 c-ares 代码已修复漏洞，为了复现漏洞，clone 代码后，需要恢复到漏洞修复之前。\n123git clone https://github.com/c-ares/c-ares.gitcd c-ares/git reset --hard 51fbb479f7948fca2ace3ff34a15ff27e796afdd\n\n2. 编写 Fuzz 主函数  实现 LLVMFuzzerTestOneInput 函数，将 LibFuzzer 输入的字节流进行转换，调用 ares_create_query 函数，并将代码保存为 target.cc 文件。\n1234567891011121314151617// Copyright 2016 Google Inc. All Rights Reserved.// Licensed under the Apache License, Version 2.0 (the &quot;License&quot;);#include &lt;stdint.h&gt;#include &lt;stdlib.h&gt;#include &lt;string&gt;#include &lt;arpa/nameser.h&gt;#include &lt;ares.h&gt;extern &quot;C&quot; int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) &#123;  unsigned char *buf;  int buflen;  std::string s(reinterpret_cast&lt;const char *&gt;(Data), Size);  ares_create_query(s.c_str(), ns_c_in, ns_t_a, 0x1234, 0, &amp;buf, &amp;buflen, 0);  free(buf);  return 0;&#125;\n\n3. 编译 Fuzz target使用 fuzzer-test-suite 提供的编译脚本，执行 build.sh 脚本，会自动调用 custom-build.sh 和 common.sh 进行编译。三个 shell 脚本和 Fuzz 函数的存放路径如下，脚本中会自动使用 git 拉取代码，这里将第 1 步手动拉取的代码删掉了：\n123456789root@server:~/fuzz$ tree.├── cares│   ├── build.sh│   └── target.cc├── common.sh└── custom-build.sh1 directory, 4 files\n\n注意需要将原始脚本中的 -fsanitize-coverage&#x3D;trace-pc-guard 替换为 -fsanitize&#x3D;fuzzer，否则执行 Fuzz 时会出现错误：-fsanitize-coverage&#x3D;trace-pc-guard is no longer supported by libFuzzer。\n1234root@server:~/fuzz$ ./cares-fsanitize_fuzzer-fsanitize-coverage=trace-pc-guard is no longer supported by libFuzzer.Please either migrate to a compiler that supports -fsanitize=fuzzeror use an older version of libFuzzer\n\n执行脚本进行编译（也可以自己编写命令进行编译，编译相关的内容之后会单独写文章进行说明）：\n1root@server:~/fuzz$ ./cares/build.sh\n\n编译完后，可以看到目录下多了一个二进制文件 cares-fsanitize_fuzzer，两个目录 BUILD 和 SRC。cares-fsanitize_fuzzer 是可执行的 Fuzz 程序，SRC 目录存放 c-ares 含漏洞的源码，BUILD 目录用于存放编译产生的中间文件和最终文件：\n12345678910root@server:~/fuzz$ tree -L 1.├── BUILD├── cares├── cares-fsanitize_fuzzer├── common.sh├── custom-build.sh└── SRC3 directories, 3 files\n\n4. 执行 Fuzz 测试  直接运行编译得到的二进制文件，如需附带参数，可参考第一章节执行 fuzz 的参数说明。\n123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778root@server:~/fuzz$ ./cares-fsanitize_fuzzerINFO: Seed: 817252946INFO: Loaded 1 modules   (10 inline 8-bit counters): 10 [0x5a90e0, 0x5a90ea),INFO: Loaded 1 PC tables (10 PCs): 10 [0x56c278,0x56c318),INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 4096 bytesINFO: A corpus is not provided, starting from an empty corpus#2      INITED cov: 3 ft: 3 corp: 1/1b exec/s: 0 rss: 27Mb#3      NEW    cov: 4 ft: 4 corp: 2/5b lim: 4 exec/s: 0 rss: 27Mb L: 4/4 MS: 1 CrossOver-#10     REDUCE cov: 4 ft: 4 corp: 2/4b lim: 4 exec/s: 0 rss: 27Mb L: 3/3 MS: 2 ChangeByte-CrossOver-#11     REDUCE cov: 4 ft: 4 corp: 2/3b lim: 4 exec/s: 0 rss: 27Mb L: 2/2 MS: 1 EraseBytes-#1368   REDUCE cov: 6 ft: 6 corp: 3/20b lim: 17 exec/s: 0 rss: 27Mb L: 17/17 MS: 2 InsertByte-InsertRepeatedBytes-#1524   REDUCE cov: 6 ft: 6 corp: 3/19b lim: 17 exec/s: 0 rss: 27Mb L: 16/16 MS: 1 EraseBytes-===================================================================3049145==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x6030012599c2 at pc 0x000000550e1c bp 0x7fffbad826d0 sp 0x7fffbad826c8WRITE of size 1 at 0x6030012599c2 thread T0    #0 0x550e1b in ares_create_query (/home/fuzz/cares-fsanitize_fuzzer+0x550e1b)    #1 0x55053c in LLVMFuzzerTestOneInput /home/fuzz/cares/target.cc:14:3    #2 0x4586a1 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) (/home/fuzz/cares-fsanitize_fuzzer+0x4586a1)    #3 0x457de5 in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool*) (/home/fuzz/cares-fsanitize_fuzzer+0x457de5)    #4 0x45a087 in fuzzer::Fuzzer::MutateAndTestOne() (/home/fuzz/cares-fsanitize_fuzzer+0x45a087)    #5 0x45ad85 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector&lt;fuzzer::SizedFile, fuzzer::fuzzer_allocator&lt;fuzzer::SizedFile&gt; &gt;&amp;) (/home/fuzz/cares-fsanitize_fuzzer+0x45ad85)    #6 0x44973e in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (/home/fuzz/cares-fsanitize_fuzzer+0x44973e)    #7 0x472582 in main (/home/fuzz/cares-fsanitize_fuzzer+0x472582)    #8 0x7fd31481c082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082)    #9 0x41e4dd in _start (/home/fuzz/cares-fsanitize_fuzzer+0x41e4dd)0x6030012599c2 is located 0 bytes to the right of 18-byte region [0x6030012599b0,0x6030012599c2)allocated by thread T0 here:    #0 0x51e20d in malloc (/home/fuzz/cares-fsanitize_fuzzer+0x51e20d)    #1 0x5508f6 in ares_create_query (/home/fuzz/cares-fsanitize_fuzzer+0x5508f6)    #2 0x55053c in LLVMFuzzerTestOneInput /home/fuzz/cares/target.cc:14:3    #3 0x4586a1 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) (/home/fuzz/cares-fsanitize_fuzzer+0x4586a1)    #4 0x457de5 in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool*) (/home/fuzz/cares-fsanitize_fuzzer+0x457de5)    #5 0x45a087 in fuzzer::Fuzzer::MutateAndTestOne() (/home/fuzz/cares-fsanitize_fuzzer+0x45a087)    #6 0x45ad85 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector&lt;fuzzer::SizedFile, fuzzer::fuzzer_allocator&lt;fuzzer::SizedFile&gt; &gt;&amp;) (/home/fuzz/cares-fsanitize_fuzzer+0x45ad85)    #7 0x44973e in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (/home/fuzz/cares-fsanitize_fuzzer+0x44973e)    #8 0x472582 in main (/home/fuzz/cares-fsanitize_fuzzer+0x472582)    #9 0x7fd31481c082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082)SUMMARY: AddressSanitizer: heap-buffer-overflow (/home/fuzz/cares-fsanitize_fuzzer+0x550e1b) in ares_create_queryShadow bytes around the buggy address:  0x0c06802432e0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa  0x0c06802432f0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa  0x0c0680243300: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa  0x0c0680243310: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa  0x0c0680243320: fa fa fa fa fa fa fa fa fa fa fd fd fd fa fa fa=&gt;0x0c0680243330: fd fd fd fa fa fa 00 00[02]fa fa fa fd fd fd fa  0x0c0680243340: fa fa fd fd fd fa fa fa fd fd fd fa fa fa fd fd  0x0c0680243350: fd fa fa fa fd fd fd fa fa fa fd fd fd fa fa fa  0x0c0680243360: fd fd fd fa fa fa fd fd fd fa fa fa fd fd fd fa  0x0c0680243370: fa fa fd fd fd fa fa fa fd fd fd fa fa fa fd fd  0x0c0680243380: fd fa fa fa fd fd fd fa fa fa fd fd fd fa fa faShadow byte legend (one shadow byte represents 8 application bytes):  Addressable:           00  Partially addressable: 01 02 03 04 05 06 07  Heap left redzone:       fa  Freed heap region:       fd  Stack left redzone:      f1  Stack mid redzone:       f2  Stack right redzone:     f3  Stack after return:      f5  Stack use after scope:   f8  Global redzone:          f9  Global init order:       f6  Poisoned by user:        f7  Container overflow:      fc  Array cookie:            ac  Intra object redzone:    bb  ASan internal:           fe  Left alloca redzone:     ca  Right alloca redzone:    cb  Shadow gap:              cc==3049145==ABORTINGMS: 4 ChangeByte-InsertByte-CopyPart-ChangeByte-; base unit: 00b28ff06b788b9b67c6b259800f404f9f3761fd0x5c,0x2e,0x0,0x6b,0x0,\\\\.\\x00k\\x00artifact_prefix=&#x27;./&#x27;; Test unit written to ./crash-edef708d314ed627eba0ef2b042e47aa96a9b899Base64: XC4AawA=\n\n可以看到，LibFuzzer 发现了 c-ares 中的 heap-buffer-overflow 漏洞，触发 crash 的用例保存为 crash-edef708d314ed627eba0ef2b042e47aa96a9b899 文件，该用例包含 5 个字节，字节码分别为：0x5c,0x2e,0x0,0x6b,0x0，其中 0x0 为空字符 NULL，属于不可见字符。\n5. 提取语料  执行 Fuzz 时，传入一个空文件夹作为 copus 路径，执行完后，可以在文件夹中看到 LibFuzzer 执行过程中，生成的有效语料。\n123456789101112131415161718192021222324252627282930313233343536373839404142root@server:~/fuzz/cares$ mkdir corpusroot@server:~/fuzz/cares$ lsBUILD  build.sh  cares_fuzzer  corpus  target.ccroot@server:~/fuzz/cares$ ./cares_fuzzer corpus/INFO: Seed: 4140748905INFO: Loaded 1 modules   (57 inline 8-bit counters): 57 [0x5a9100, 0x5a9139),INFO: Loaded 1 PC tables (57 PCs): 57 [0x5a9140,0x5a94d0),INFO:        0 files found in corpus/INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 4096 bytesINFO: A corpus is not provided, starting from an empty corpus#2      INITED cov: 13 ft: 14 corp: 1/1b exec/s: 0 rss: 27Mb#4      NEW    cov: 16 ft: 20 corp: 2/3b lim: 4 exec/s: 0 rss: 27Mb L: 2/2 MS: 2 ChangeByte-InsertByte-#9      NEW    cov: 16 ft: 26 corp: 3/6b lim: 4 exec/s: 0 rss: 27Mb L: 3/3 MS: 5 ChangeBit-ChangeByte-ChangeByte-CopyPart-InsertByte-#10     NEW    cov: 16 ft: 32 corp: 4/10b lim: 4 exec/s: 0 rss: 27Mb L: 4/4 MS: 1 CrossOver-#25     NEW    cov: 18 ft: 34 corp: 5/11b lim: 4 exec/s: 0 rss: 27Mb L: 1/4 MS: 5 ChangeBit-ChangeASCIIInt-CMP-CrossOver-EraseBytes- DE: &quot;\\x01\\x00&quot;-#94     NEW    cov: 19 ft: 35 corp: 6/15b lim: 4 exec/s: 0 rss: 27Mb L: 4/4 MS: 4 CrossOver-ShuffleBytes-ChangeByte-ChangeBit-#108    NEW    cov: 21 ft: 37 corp: 7/16b lim: 4 exec/s: 0 rss: 27Mb L: 1/4 MS: 4 ChangeByte-ShuffleBytes-ChangeBit-ChangeByte-#125    NEW    cov: 22 ft: 38 corp: 8/18b lim: 4 exec/s: 0 rss: 27Mb L: 2/4 MS: 2 ShuffleBytes-InsertByte-...==3237059==ABORTINGMS: 2 InsertRepeatedBytes-ChangeByte-; base unit: 1bef8aac927d18852642a96c20e50efba80fdfae0x5c,0x5,0x98,0x98,0x98,0x98,0x98,0x98,0x98,0x98,0x98,0x98,0x98,0x5c,0x2e,\\\\\\x05\\x98\\x98\\x98\\x98\\x98\\x98\\x98\\x98\\x98\\x98\\x98\\\\.artifact_prefix=&#x27;./&#x27;; Test unit written to ./crash-157768d6f06d94325fe0e6bcf66cbd2d27dd8db7Base64: XAWYmJiYmJiYmJiYmFwuroot@server:~/fuzz/cares$ ls -altotal 2244drwxrwxr-x 4 root root    4096 Sep 26 17:47 .drwxrwxr-x 5 root root    4096 Sep 26 15:25 ..drwxrwxr-x 9 root root   20480 Sep 26 17:18 BUILD-rw-rw-r-- 1 root root     722 Sep 26 17:13 build.sh-rwxrwxr-x 1 root root 2250720 Sep 26 17:18 cares_fuzzerdrwxrwxr-x 2 root root    4096 Sep 26 17:47 corpus-rw-rw-r-- 1 root root      15 Sep 26 17:47 crash-157768d6f06d94325fe0e6bcf66cbd2d27dd8db7-rw-rw-r-- 1 root root     499 Sep 26 17:14 target.ccroot@server:~/fuzz/cares$ ls corpus/08534f33c201a45017b502e90a800f1b708ebcb3  5175b74bd75b8d90a01f77709deba3982fbbdcb2  78bdce51613f555049a9937095bf469bcb77e94f  be566cb17d3bce0b2a8e5e710b3779df720db1f50f1c5448bf80343eeac759f8adcbdc2720533d15  5318c4ac20dac95a702bee2e27834d39ea6bc2b6  8e54ed049741d7cf6fb8ef7f4288ef0be3b54f17  be5c29e07560abcf094c3419712a01590bbe85940fe509b10d833be6eb3d5ed4947cbe0fbb64ed84  5ba93c9db0cff93f52b521d7420e43f6eda2784f  8ea51a3719d7cbfc3e2dcd3edf6109918d5aad55  caea31b9ef76b9be352ad1054956efbb86d4451a1bef8aac927d18852642a96c20e50efba80fdfae  60321f72401b49b895535045eb8d3b9ca7db7c7c  91a3f7c503955600f5dac12c1c1a3c5b674a4d98  dea712be0e801f4502a21e04dfbec5bd0cbc677c24792aa3923c4cd185519d3d445ecfd0801db1c1  6380a9a2d2701df0cb53d880842747cbefef8a5d  9f64357cb30f24cf567513e140e9fb0cbf1a2be5  e716589d09e16cf4a48d2c7f1d357bb481aaf3bc3a52ce780950d4d969792a2559cd519d7ee8c727  6414bd7955e39106721edf7cc29efdb82f7007ac  b534844fd943d8b338025ad82d68283f1bcdb5c0\n\n6. 合并语料  当 Fuzz 执行很久之后，会产生大量语料。为了减少语料数量，可以使用 merge 参数进行合并。创建一个 min_corpus 目录，执行 Fuzz 时，启动 merge 参数，传入 min_corpus 目录和 corpus 目录，合并完后，可以在 min_corpus 目录下看到缩减之后的语料。以下示例显示预料数据从 31 个减少到 29 个：\n1234567891011121314151617181920212223root@server:~/fuzz/cares$ mkdir min_corpusroot@server:~/fuzz/cares$ ./cares_fuzzer -merge=1 min_corpus/ corpus/INFO: Seed: 1671146211INFO: Loaded 1 modules   (57 inline 8-bit counters): 57 [0x5a9100, 0x5a9139),INFO: Loaded 1 PC tables (57 PCs): 57 [0x5a9140,0x5a94d0),MERGE-OUTER: 31 files, 0 in the initial corpus, 0 processed earlierMERGE-OUTER: attempt 1INFO: Seed: 1671165588INFO: Loaded 1 modules   (57 inline 8-bit counters): 57 [0x5a9100, 0x5a9139),INFO: Loaded 1 PC tables (57 PCs): 57 [0x5a9140,0x5a94d0),INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 1048576 bytesMERGE-INNER: using the control file &#x27;/tmp/libFuzzerTemp.3327149.txt&#x27;MERGE-INNER: 31 total files; 0 processed earlier; will process 31 files now#1      pulse  cov: 9 ft: 10 exec/s: 0 rss: 27Mb#2      pulse  cov: 13 ft: 14 exec/s: 0 rss: 27Mb#4      pulse  cov: 20 ft: 22 exec/s: 0 rss: 27Mb#8      pulse  cov: 28 ft: 38 exec/s: 0 rss: 27Mb#16     pulse  cov: 29 ft: 56 exec/s: 0 rss: 27Mb#31     DONE   cov: 29 ft: 82 exec/s: 0 rss: 28MbMERGE-OUTER: succesfull in 1 attempt(s)MERGE-OUTER: the control file has 2691 bytesMERGE-OUTER: consumed 0Mb (27Mb rss) to parse the control fileMERGE-OUTER: 29 new files with 82 new features added; 29 new coverage edges\n\n三、优化技巧  整体优化思路分两种：\n\n找到 crash 更快 –&gt; 并行化，多个实例一起运行\n覆盖 edge 更多 –&gt; 加强语料，让输入能走到更深的分支\n\n（一）并行化1、LibFuzzer(1) jobs 和 workers\n\njobs：指定 fuzz 实例的数量。在不设置运行时长的情况下，每个 fuzz 实例找到 crash 才会停止。理论上有多少 jobs，最后会产生多少个 crash 文件。但实际上，不同的 job 可能找到同样的 crash，最后 crash 文件个数少于 job 个数。\nworks：执行 fuzz 进程的数量。在多个 jobs 的情况下，平均每个 woker 执行 #jobs&#x2F;#workers 个 job。\n\n简单来说，使用 workers 能提升 fuzz 运行速度，使用 jobs 能增加 crash 数量（仅根据输入去重，没有对调用栈去重）。 只使用 jobs 的情况下，默认开启 min(#jobs, #cores) &#x2F;&#x2F; 2 个 workers。\n(2) fork\n目前 fork 是实验阶段的参数，计划最终使用 fork 代替 jobs 和 workers 来实现 LibFuzzer 的并行化。\n\nfork：父进程不直接执行 fuzz，而是开启 N 个子进程，每个子进程使用语料库的随机子集进行 fuzz，当子进程退出后，该子进程的语料将被合并到主语料库中。子进程可以通过设置参数，来实现对指定错误的容错能力：\n\n-ignore_ooms：默认为 True。子进程发生内存溢出时，保存输入用于重现，但 fuzz 继续执行。\n\n-ignore_timeouts：默认为 True。子进程发生超时时，保留输入用于重现，但 fuzz 继续执行。\n\n-ignore_crashes：默认为 False。子进程发生其他类型 crash 时，保留输入用于重现，但 fuzz 继续执行。\n\n\n2、LibFuzzer 结合 AFLAFL 可以支持 LibFuzzer 的 target，编译方法参考  此处说明。\n12afl-fuzz -i testcase_dir -o findings_dir ./fuzz-target @@ ./fuzz-target testcase_dir findings_dir # Will write new tests to testcase_dir\n\n需要定期重启 AFL 和 LibFuzzer，以完成语料同步。\n（二）加强语料 1、字典 运行时使用 -dict 参数指定字典（Dictionary）文件的路径，字典用于指定和控制模糊测试中输入数据的一部分，从而提高模糊测试的效果。\n字典文件：\n12345678910# Lines starting with &#x27;#&#x27; and empty lines are ignored.# Adds &quot;blah&quot; (w/o quotes) to the dictionary.kw1=&quot;blah&quot;# Use \\\\ for backslash and \\&quot; for quotes.kw2=&quot;\\&quot;ac\\\\dc\\&quot;&quot;# Use \\xAB for hex valueskw3=&quot;\\xF7\\xF8&quot;# the name of the keyword followed by &#x27;=&#x27; may be omitted:&quot;foo\\x0Abar&quot;\n\n使用方法（运行时）：\n1./fuzz-target -dict=dict_file\n\n2、CMP编译时使用 -fsanitize-coverage&#x3D;trace-cmp 参数，让 fuzz 拦截 CMP 指令（例如 if 语句中的 compare 条件）并根据拦截到的 CMP 指令的参数来引导变异。这可能会减慢模糊测试的速度，但很可能会改善测试结果。\n使用方法（编译时）：\n1clang++ buggy.cc -fsanitize=fuzzer,address -fsanitize-coverage=trace-cmp -g -o buggy-fuzzer\n\n3、Value Profile需要与 -fsanitize-coverage=trace-cmp 一起使用，让 fuzz 收集 CMP 指令的参数值进行分析，用于发现更多的有效输入。但是有两个缺点：首先可能会导致速度降低 2 倍。 其次语料库可能增长数倍。\n使用方法（运行时）：\n1./fuzz-target -use_value_profile=1\n\n4、Fuzzer-friendly build mode程序中可能存在某些对 fuzz 不友好的特性，例如：\n\n随机化：同一个输入，可能走不同的路径\n校验和：拦截无效输入\n\n此时可以用构建宏 FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 来编译一个对 fuzz 友好的版本，使用时需要对源码进行修改。例如：\n12345678void MyInitPRNG() &#123;#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION  // In fuzzing mode the behavior of the code should be deterministic.  srand(0);#else  srand(time(0));#endif&#125;\n\n四、 参考资料\nlibFuzzer – a library for coverage-guided fuzz testing\nlibFuzzer 使用总结教程\nEfficient Fuzzing Guide\nThe art of fuzzing-A Step-by-Step Guide to Coverage-Guided Fuzzing with LibFuzzer\nAn introduction to LLVM libFuzzer\nAn informative guide on using AFL and libFuzzer\nlibfuzzer-workshop\nSanitizers\nThe Magic Behind Feedback-Based Fuzzing\n","dateCreated":"2023-09-17T18:30:15+08:00","dateModified":"2024-06-26T14:24:54+08:00","datePublished":"2023-09-17T18:30:15+08:00","description":"模糊测试工具 LibFuzzer 从 0 到 1，原理 + 安装 + 使用 + 优化，一篇讲完","headline":"LibFuzzer 使用说明","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2023/LibFuzzer%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://www.stepbystep.asia/2023/LibFuzzer%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E/","keywords":"安全, 工具, Fuzz, LibFuzzer"}</script>
     <meta name="description" content="模糊测试工具 LibFuzzer 从 0 到 1，原理 + 安装 + 使用 + 优化，一篇讲完">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="LibFuzzer 使用说明">
@@ -25,9 +25,9 @@
 <meta property="article:published_time" content="2023-09-17T10:30:15.000Z">
 <meta property="article:modified_time" content="2024-06-26T06:24:54.052Z">
 <meta property="article:author" content="一瓢清浅">
-<meta property="article:tag" content="Fuzz">
 <meta property="article:tag" content="安全">
 <meta property="article:tag" content="工具">
+<meta property="article:tag" content="Fuzz">
 <meta property="article:tag" content="LibFuzzer">
 <meta name="twitter:card" content="summary">
     
diff --git "a/2023/LibFuzzer\347\274\226\350\257\221\346\214\207\345\215\227/index.html" "b/2023/LibFuzzer\347\274\226\350\257\221\346\214\207\345\215\227/index.html"
index 6229803..b53c631 100644
--- "a/2023/LibFuzzer\347\274\226\350\257\221\346\214\207\345\215\227/index.html"
+++ "b/2023/LibFuzzer\347\274\226\350\257\221\346\214\207\345\215\227/index.html"
@@ -14,7 +14,7 @@
     
     
     
-    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg"},"articleBody":"\n\n使用 LibFuzzer 时，编译 fuzz target 是需要使用者自己执行的重要步骤。在编译时，通过编译选项添加消毒器，链接 LibFuzzer 静态库，得到可执行的 fuzz target。\n本文针对 LibFuzzer Target 编译进行说明。\n一、使用开源脚本 fuzzer-test-suite 是 Google 开源的一个 Fuzz 基准测试集，包含 Fuzz（LibFuzzer 和 AFL）测试的多个 benchmark。这些 benchmark 都来自真实案例，涉及到图像处理、SQL 注入、JSON 解析等多个领域。\n以 c-ares-CVE 为例，编译主要用到以下三个 sh 脚本，以及实现了 LLVMFuzzerTestOneInput 的 cc 源码文件：\n123456fuzzer-test-suite│  common.sh│  custom-build.sh├─c-ares-CVE-2016-5180│      build.sh│      target.cc\n\n1. 编译过程  编译入口为 build.sh 文件，其代码如下：\n1234567891011121314151617181920#!/bin/bash# Copyright 2016 Google Inc. All Rights Reserved.# Licensed under the Apache License, Version 2.0 (the &quot;License&quot;);. $(dirname $0)/../custom-build.sh $1 $2. $(dirname $0)/../common.shbuild_lib() &#123;  rm -rf BUILD  cp -rf SRC BUILD  (cd BUILD &amp;&amp; ./buildconf &amp;&amp; ./configure --disable-shared &amp;&amp; make -j $JOBS)&#125;get_git_revision https://github.com/c-ares/c-ares.git 51fbb479f7948fca2ace3ff34a15ff27e796afdd SRCbuild_libbuild_fuzzerif [[$FUZZING_ENGINE == &quot;hooks&quot;]]; then  # Link ASan runtime so we can hook memcmp et al.  LIB_FUZZING_ENGINE=&quot;$LIB_FUZZING_ENGINE -fsanitize=address&quot;fi$CXX $CXXFLAGS $SCRIPT_DIR/target.cc -I BUILD BUILD/.libs/libcares.a $LIB_FUZZING_ENGINE -o $EXECUTABLE_NAME_BASE\n\n执行 build.sh 时，首先依次调用外层的 custom-build.sh 和common.sh，然后执行如下步骤：\n\nget_git_revision：定义在 common.sh 中，拉取有漏洞的代码\n\nbuild_lib：将拉取的代码编译成静态库文件 libcares.a，注意--disable-shared 参数指定编译静态库文件，否则编译动态库文件\n\nbuild_fuzzer：定义在 common.sh 中，编译 Fuzz 引擎源码（如果使用 LibFuzzer，则编译 LibFuzzer 源码，得到libFuzzer.a）\n\n\\$CXX \\$CXXFLAGS \\$SCRIPT_DIR/target.cc：编译 target.cc 文件，链接 libcares.a 和libFuzzer.a，得到可执行的 fuzz target\n\n\n在整个编译过程中，需要重点关注的是  编译选项的设置  和静态库的链接。\n2. 编译选项  在build_lib中编译待测源码时，使用的是 configure-make 工具，该工具广泛用于 Linux 环境中编写的 C&#x2F;C++ 程序的编译（近年来开始使用 cmake 工具），主要包含两个步骤：\n\nconfigure对编译过程进行配置，通过参数和环境变量控制编译，生成 makefile\nmake从 makefile 中读取命令并执行编译，生成二进制文件\n\n通过 ./configure -h 可以查看编译参数和环境变量的含义，脚本中用到的参数和环境变量列举如下：\n\n\n\n参数\n含义\n\n\n\n–enable-shared\n编译动态库文件（默认 yes）\n\n\n–enable-static\n编译静态库文件（默认 yes）\n\n\n–disable-shared\n不编译动态库文件\n\n\n–disable-static\n不编译静态库文件\n\n\n\n\n\n环境变量\n含义\n\n\n\nCC\nC 编译程序\n\n\nCXX\nC++ 编译程序\n\n\nCFLAGS\nC 编译程序的命令行参数\n\n\nCXXFLAGS\nC++ 编译程序的命令行参数\n\n\n在执行 build_lib 时，设置了 --disable-shared 参数，指定将待测源码编译成静态库文件。在 custom-build.sh 和common.sh中，设置了如下环境变量：\n\ncustom-build.sh\n\nasan 模式\n123export FUZZING_ENGINE=libfuzzerexport CFLAGS=&quot;-O2 -fno-omit-frame-pointer -gline-tables-only -fsanitize=address -fsanitize-address-use-after-scope -fsanitize-coverage=trace-pc-guard,trace-cmp,trace-gep,trace-div&quot;export CXXFLAGS=&quot;$&#123;CFLAGS&#125;&quot;\n\nubsan 模式\n123export FUZZING_ENGINE=libfuzzerexport CFLAGS=&quot;-O2 -fno-omit-frame-pointer -gline-tables-only -fsanitize=undefined -fsanitize-coverage=trace-pc-guard,trace-cmp,trace-gep,trace-div&quot;export CXXFLAGS=&quot;$&#123;CFLAGS&#125;&quot;\n\n默认模式\n12FUZZING_ENGINE=$&#123;FUZZING_ENGINE:-&quot;fsanitize_fuzzer&quot;&#125;FUZZ_CXXFLAGS=&quot;-O2 -fno-omit-frame-pointer -gline-tables-only -fsanitize=address -fsanitize-address-use-after-scope -fsanitize-coverage=trace-pc-guard,trace-cmp,trace-gep,trace-div&quot;\n\n\ncommon.sh\n1234567891011121314151617FUZZ_CXXFLAGS=&quot;-O2 -fno-omit-frame-pointer -gline-tables-only -fsanitize=address -fsanitize-address-use-after-scope -fsanitize-coverage=trace-pc-guard,trace-cmp,trace-gep,trace-div&quot;......export CC=$&#123;CC:-&quot;clang&quot;&#125;export CXX=$&#123;CXX:-&quot;clang++&quot;&#125;export CPPFLAGS=$&#123;CPPFLAGS:-&quot;-DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION&quot;&#125;export LIB_FUZZING_ENGINE=&quot;libFuzzingEngine-$&#123;FUZZING_ENGINE&#125;.a&quot;if [[$FUZZING_ENGINE == &quot;fsanitize_fuzzer&quot;]]; then  FSANITIZE_FUZZER_FLAGS=&quot;-O2 -fno-omit-frame-pointer -gline-tables-only -fsanitize=address,fuzzer-no-link -fsanitize-address-use-after-scope&quot;  export CFLAGS=$&#123;CFLAGS:-$FSANITIZE_FUZZER_FLAGS&#125;  export CXXFLAGS=$&#123;CXXFLAGS:-$FSANITIZE_FUZZER_FLAGS&#125;elif......else  export CFLAGS=$&#123;CFLAGS:-&quot;$FUZZ_CXXFLAGS&quot;&#125;  export CXXFLAGS=$&#123;CXXFLAGS:-&quot;$FUZZ_CXXFLAGS&quot;&#125;fi\n\n可以看到脚本指定了 CC 和CXX编译工具为 clang 和clang++，在 CFLAGS 和CXXFLAGS中设置了 clang 的编译选项：\n\n\n\n选项\n含义\n\n\n\n-O2\n指定编译器优化等级为 2\n\n\n-fno-omit-frame-pointer\n将 frame pointer 保存在寄存器中。frame pointer 即栈帧基地址（指向栈底），在编译器优化时或某些平台上，fp 会被忽略，通过此选项可强制开启\n\n\n-gline-tables-only\n函数调用栈中包含函数名、文件名和行号等信息，但不包括局部变量和函数参数。要包括全部信息应使用 -g 选项\n\n\n-fsanitize&#x3D;fuzzer\n编译时对源码插桩，链接 libFuzzer 库文件\n\n\n-fsanitize&#x3D;fuzzer-no-link\n编译时对源码插桩，不链接 libFuzzer 库文件。编译待测源码时不链接，编译 fuzz target 时再链接，对大型项目可以提升编译效率\n\n\n-fsanitize&#x3D;address\n启用 AddressSanitizer，检测缓冲区溢出、UAF、Double Free、内存泄漏等内存问题\n\n\n-fsanitize-address-use-after-scope\n启用局部变量的 sanitization 以检测 use-after-scope 错误（作用域外访问）\n\n\n-fsanitize&#x3D;undefined\n启用 UndefinedSanitizer，检测程序运行中越界访问、整数溢出、空指针解引用等未定义行为\n\n\n-fsanitize-coverage&#x3D;trace-pc-guard,trace-cmp,trace-gep,trace-div\n开启代码覆盖率统计。在高版本 clang 中 -fsanitize-coverage&#x3D;trace-pc-guard 已弃用，默认开启代码覆盖率统计，使用此选项会报错\n\n\n3. 链接库文件  编译 fuzz target 时，执行了如下命令：\n1$CXX $CXXFLAGS $SCRIPT_DIR/target.cc -I BUILD BUILD/.libs/libcares.a $LIB_FUZZING_ENGINE -o $EXECUTABLE_NAME_BASE\n\n环境变量 CXX 和CXXFLAGS沿用之前定义，通过-I（uppercase i）选项，指定了.h 头文件目录和.a 静态库路径：\n\nBUILD：存放待测源码的头文件\n\nBUILD/.libs/libcares.a：编译待测源码生成的静态库文件libcares.a\n\n$LIB_FUZZING_ENGINE：编译 LibFuzzer 源码生成的libFuzzer.a\n\n\n链接库文件时，-I（uppercase i）可以用 -L 和-l（lowercase L）替换：\n1-I BUILD/.libs/libcares.a  等价于  -L BUILD/.libs -l cares\n\n特别地，链接 libFuzzer.a 库文件时，可以用过 -fsanitize=fuzzer 实现：\n1-I libFuzzer.a 等价于 -fsanitize=fuzzer\n\n二、自己编写命令  开源的编译脚本为了适配多个 benchmark 和多种 Fuzz 类型，做了较多逻辑处理，适配新的 benchmark 时不够灵活。通过对编译脚本的流程分析，很容易自己编写命令完成编译。\n在 Linux 环境下安装 clang，以 c-ares-CVE 为例，编写命令生成 fuzz target：\n0. 准备源码   123git clone https://github.com/c-ares/c-ares.gitcd c-ares/git reset --hard 51fbb479f7948fca2ace3ff34a15ff27e796afdd\n   此时查看目录内容如下：\n   123456root@server:~/fuzz/cares$ tree -L 1.├── c-ares└── target.cc1 directory, 1 file\n\n1. 设置环境变量   设置CC、CXX、CFLAGS、CXXFLAGS\n   1234export CC=clangexport CXX=clang++export CFLAGS=&quot;-O2 -fno-omit-frame-pointer -gline-tables-only -fsanitize=address,fuzzer-no-link -fsanitize-address-use-after-scope&quot;export CXXFLAGS=$CFLAGS\n\n2. 编译待测库    进入源码目录，执行configure 脚本，设置禁止编译动态库文件，执行 make 编译libcares.a\n   1234cd c-ares./buildconf./configure --disable-sharedmake -j4\n   编译成功后，会在源码目录下生成.lib 目录，存放生成的 libcares.a 文件\n   123root@server:~/fuzz/cares/c-ares$ cd .libs/root@server:~/fuzz/cares/c-ares/.libs$ lslibcares.a  libcares.la  libcares.lai\n\n3. 编译 fuzz target   由于安装 clang 时已经自带 LibFuzzer.a，因此不用再编译LibFuzzer.a，回到target.cc 目录，直接编译 targe.cc 链接 libFuzzer 即可\n   12cd ~/fuzz/cares$CXX $CXXFLAGS target.cc -fsanitize=fuzzer -g -I c-ares c-ares/.libs/libcares.a -o cares-fuzzer\n   编译成功后，会在当前目录下生成可执行文件 cares-fuzzer，执行cares-fuzzer 开始 fuzz 测试，可以看到触发了 crash\n   1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980root@server:~/fuzz/cares$ lsc-ares  cares-fuzzer  target.ccroot@server:~/fuzz/cares$ ./cares-fuzzerINFO: Seed: 3031255060INFO: Loaded 1 modules   (10 inline 8-bit counters): 10 [0x5a90e0, 0x5a90ea),INFO: Loaded 1 PC tables (10 PCs): 10 [0x56c278,0x56c318),INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 4096 bytesINFO: A corpus is not provided, starting from an empty corpus#2      INITED cov: 3 ft: 3 corp: 1/1b exec/s: 0 rss: 27Mb#4      NEW    cov: 4 ft: 4 corp: 2/3b lim: 4 exec/s: 0 rss: 27Mb L: 2/2 MS: 2 ChangeBit-InsertByte-#1331   NEW    cov: 6 ft: 6 corp: 3/20b lim: 17 exec/s: 0 rss: 27Mb L: 17/17 MS: 2 InsertByte-CrossOver-#1368   REDUCE cov: 6 ft: 6 corp: 3/19b lim: 17 exec/s: 0 rss: 27Mb L: 16/16 MS: 2 CrossOver-EraseBytes-#1048576        pulse  cov: 6 ft: 6 corp: 3/19b lim: 4096 exec/s: 524288 rss: 773Mb#2097152        pulse  cov: 6 ft: 6 corp: 3/19b lim: 4096 exec/s: 419430 rss: 773Mb===================================================================664326==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x603000d2c052 at pc 0x000000550e1c bp 0x7ffd914ddd30 sp 0x7ffd914ddd28WRITE of size 1 at 0x603000d2c052 thread T0    #0 0x550e1b in ares_create_query (/home/rootfuzz/cares/cares-fuzzer+0x550e1b)    #1 0x55053c in LLVMFuzzerTestOneInput /home/rootfuzz/cares/target.cc:14:3    #2 0x4586a1 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) (/home/rootfuzz/cares/cares-fuzzer+0x4586a1)    #3 0x457de5 in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool*) (/home/rootfuzz/cares/cares-fuzzer+0x457de5)    #4 0x45a087 in fuzzer::Fuzzer::MutateAndTestOne() (/home/rootfuzz/cares/cares-fuzzer+0x45a087)    #5 0x45ad85 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector&lt;fuzzer::SizedFile, fuzzer::fuzzer_allocator&lt;fuzzer::SizedFile&gt; &gt;&amp;) (/home/rootfuzz/cares/cares-fuzzer+0x45ad85)    #6 0x44973e in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (/home/rootfuzz/cares/cares-fuzzer+0x44973e)    #7 0x472582 in main (/home/rootfuzz/cares/cares-fuzzer+0x472582)    #8 0x7f4b400f8082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082)    #9 0x41e4dd in _start (/home/rootfuzz/cares/cares-fuzzer+0x41e4dd)0x603000d2c052 is located 0 bytes to the right of 18-byte region [0x603000d2c040,0x603000d2c052)allocated by thread T0 here:    #0 0x51e20d in malloc (/home/rootfuzz/cares/cares-fuzzer+0x51e20d)    #1 0x5508f6 in ares_create_query (/home/rootfuzz/cares/cares-fuzzer+0x5508f6)    #2 0x55053c in LLVMFuzzerTestOneInput /home/rootfuzz/cares/target.cc:14:3    #3 0x4586a1 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) (/home/rootfuzz/cares/cares-fuzzer+0x4586a1)    #4 0x457de5 in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool*) (/home/rootfuzz/cares/cares-fuzzer+0x457de5)    #5 0x45a087 in fuzzer::Fuzzer::MutateAndTestOne() (/home/rootfuzz/cares/cares-fuzzer+0x45a087)    #6 0x45ad85 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector&lt;fuzzer::SizedFile, fuzzer::fuzzer_allocator&lt;fuzzer::SizedFile&gt; &gt;&amp;) (/home/rootfuzz/cares/cares-fuzzer+0x45ad85)    #7 0x44973e in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (/home/rootfuzz/cares/cares-fuzzer+0x44973e)    #8 0x472582 in main (/home/rootfuzz/cares/cares-fuzzer+0x472582)    #9 0x7f4b400f8082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082)SUMMARY: AddressSanitizer: heap-buffer-overflow (/home/rootfuzz/cares/cares-fuzzer+0x550e1b) in ares_create_queryShadow bytes around the buggy address:  0x0c068019d7b0: fd fa fa fa fd fd fd fa fa fa fd fd fd fa fa fa  0x0c068019d7c0: fd fd fd fa fa fa fd fd fd fa fa fa fd fd fd fa  0x0c068019d7d0: fa fa fa fa fa fa fa fa fd fd fd fa fa fa fd fd  0x0c068019d7e0: fd fa fa fa fd fd fd fa fa fa fd fd fd fa fa fa  0x0c068019d7f0: fa fa fa fa fa fa fa fa fa fa fa fa fd fd fd fa=&gt;0x0c068019d800: fa fa fa fa fa fa fa fa 00 00[02]fa fa fa fa fa  0x0c068019d810: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa  0x0c068019d820: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa  0x0c068019d830: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa  0x0c068019d840: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa  0x0c068019d850: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa faShadow byte legend (one shadow byte represents 8 application bytes):  Addressable:           00  Partially addressable: 01 02 03 04 05 06 07  Heap left redzone:       fa  Freed heap region:       fd  Stack left redzone:      f1  Stack mid redzone:       f2  Stack right redzone:     f3  Stack after return:      f5  Stack use after scope:   f8  Global redzone:          f9  Global init order:       f6  Poisoned by user:        f7  Container overflow:      fc  Array cookie:            ac  Intra object redzone:    bb  ASan internal:           fe  Left alloca redzone:     ca  Right alloca redzone:    cb  Shadow gap:              cc==664326==ABORTINGMS: 4 ChangeBit-InsertByte-EraseBytes-ChangeByte-; base unit: 7c9981f8ba526a6e0b8c1bbb846c08e2d6026e3a0x5c,0x2e,\\\\.artifact_prefix=&#x27;./&#x27;; Test unit written to ./crash-c9257f8fd31ea852baf734ef06d37348bf6e8cb2Base64: XC4=\n\n三、补充说明 1. 脚本执行 带mode参数执行 build.sh 脚本时，需要编译 LibFuzzer 源码，这时候会出现找不到 LibFuzzer 源码的错误。需要自己下载源码，并放到指定路径，调试脚本解决问题，比较麻烦。\n建议不带参数执行build.sh，这时采用默认模式，编译时会采用 address 消毒器，这也是应用的最多的一种消毒器。\n2. 静态库 or 动态库  编译待测库的源码时，一定要编译成静态库文件 ，在congfigure 时使用 --disable-shared 参数。\n如果是编成动态库文件，或静态库动态库同时都有的情况下，fuzz target 会优先链接动态库文件。而动态库会导致 fuzz 测试失效。\n\n\n第一个图中使用静态库，fuzz 很快能发现 crash，第二个图中是用动态库，fuzz 运行很慢，找不到 crash。\n使用静态库得到 57 PCs，使用动态库得到 5 PCs，二者有明显区别，推测使用动态库可能会导致插桩失效，影响 fuzz 运行效率。","dateCreated":"2023-09-26T14:32:22+08:00","dateModified":"2024-06-26T15:04:11+08:00","datePublished":"2023-09-26T14:32:22+08:00","description":"怎样编出 LibFuzzer 的 target","headline":"LibFuzzer 编译指南","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2023/LibFuzzer%E7%BC%96%E8%AF%91%E6%8C%87%E5%8D%97/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://www.stepbystep.asia/2023/LibFuzzer%E7%BC%96%E8%AF%91%E6%8C%87%E5%8D%97/","keywords":"Fuzz, 安全, 工具, LibFuzzer"}</script>
+    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg"},"articleBody":"\n\n使用 LibFuzzer 时，编译 fuzz target 是需要使用者自己执行的重要步骤。在编译时，通过编译选项添加消毒器，链接 LibFuzzer 静态库，得到可执行的 fuzz target。\n本文针对 LibFuzzer Target 编译进行说明。\n一、使用开源脚本 fuzzer-test-suite 是 Google 开源的一个 Fuzz 基准测试集，包含 Fuzz（LibFuzzer 和 AFL）测试的多个 benchmark。这些 benchmark 都来自真实案例，涉及到图像处理、SQL 注入、JSON 解析等多个领域。\n以 c-ares-CVE 为例，编译主要用到以下三个 sh 脚本，以及实现了 LLVMFuzzerTestOneInput 的 cc 源码文件：\n123456fuzzer-test-suite│  common.sh│  custom-build.sh├─c-ares-CVE-2016-5180│      build.sh│      target.cc\n\n1. 编译过程  编译入口为 build.sh 文件，其代码如下：\n1234567891011121314151617181920#!/bin/bash# Copyright 2016 Google Inc. All Rights Reserved.# Licensed under the Apache License, Version 2.0 (the &quot;License&quot;);. $(dirname $0)/../custom-build.sh $1 $2. $(dirname $0)/../common.shbuild_lib() &#123;  rm -rf BUILD  cp -rf SRC BUILD  (cd BUILD &amp;&amp; ./buildconf &amp;&amp; ./configure --disable-shared &amp;&amp; make -j $JOBS)&#125;get_git_revision https://github.com/c-ares/c-ares.git 51fbb479f7948fca2ace3ff34a15ff27e796afdd SRCbuild_libbuild_fuzzerif [[$FUZZING_ENGINE == &quot;hooks&quot;]]; then  # Link ASan runtime so we can hook memcmp et al.  LIB_FUZZING_ENGINE=&quot;$LIB_FUZZING_ENGINE -fsanitize=address&quot;fi$CXX $CXXFLAGS $SCRIPT_DIR/target.cc -I BUILD BUILD/.libs/libcares.a $LIB_FUZZING_ENGINE -o $EXECUTABLE_NAME_BASE\n\n执行 build.sh 时，首先依次调用外层的 custom-build.sh 和common.sh，然后执行如下步骤：\n\nget_git_revision：定义在 common.sh 中，拉取有漏洞的代码\n\nbuild_lib：将拉取的代码编译成静态库文件 libcares.a，注意--disable-shared 参数指定编译静态库文件，否则编译动态库文件\n\nbuild_fuzzer：定义在 common.sh 中，编译 Fuzz 引擎源码（如果使用 LibFuzzer，则编译 LibFuzzer 源码，得到libFuzzer.a）\n\n\\$CXX \\$CXXFLAGS \\$SCRIPT_DIR/target.cc：编译 target.cc 文件，链接 libcares.a 和libFuzzer.a，得到可执行的 fuzz target\n\n\n在整个编译过程中，需要重点关注的是  编译选项的设置  和静态库的链接。\n2. 编译选项  在build_lib中编译待测源码时，使用的是 configure-make 工具，该工具广泛用于 Linux 环境中编写的 C&#x2F;C++ 程序的编译（近年来开始使用 cmake 工具），主要包含两个步骤：\n\nconfigure对编译过程进行配置，通过参数和环境变量控制编译，生成 makefile\nmake从 makefile 中读取命令并执行编译，生成二进制文件\n\n通过 ./configure -h 可以查看编译参数和环境变量的含义，脚本中用到的参数和环境变量列举如下：\n\n\n\n参数\n含义\n\n\n\n–enable-shared\n编译动态库文件（默认 yes）\n\n\n–enable-static\n编译静态库文件（默认 yes）\n\n\n–disable-shared\n不编译动态库文件\n\n\n–disable-static\n不编译静态库文件\n\n\n\n\n\n环境变量\n含义\n\n\n\nCC\nC 编译程序\n\n\nCXX\nC++ 编译程序\n\n\nCFLAGS\nC 编译程序的命令行参数\n\n\nCXXFLAGS\nC++ 编译程序的命令行参数\n\n\n在执行 build_lib 时，设置了 --disable-shared 参数，指定将待测源码编译成静态库文件。在 custom-build.sh 和common.sh中，设置了如下环境变量：\n\ncustom-build.sh\n\nasan 模式\n123export FUZZING_ENGINE=libfuzzerexport CFLAGS=&quot;-O2 -fno-omit-frame-pointer -gline-tables-only -fsanitize=address -fsanitize-address-use-after-scope -fsanitize-coverage=trace-pc-guard,trace-cmp,trace-gep,trace-div&quot;export CXXFLAGS=&quot;$&#123;CFLAGS&#125;&quot;\n\nubsan 模式\n123export FUZZING_ENGINE=libfuzzerexport CFLAGS=&quot;-O2 -fno-omit-frame-pointer -gline-tables-only -fsanitize=undefined -fsanitize-coverage=trace-pc-guard,trace-cmp,trace-gep,trace-div&quot;export CXXFLAGS=&quot;$&#123;CFLAGS&#125;&quot;\n\n默认模式\n12FUZZING_ENGINE=$&#123;FUZZING_ENGINE:-&quot;fsanitize_fuzzer&quot;&#125;FUZZ_CXXFLAGS=&quot;-O2 -fno-omit-frame-pointer -gline-tables-only -fsanitize=address -fsanitize-address-use-after-scope -fsanitize-coverage=trace-pc-guard,trace-cmp,trace-gep,trace-div&quot;\n\n\ncommon.sh\n1234567891011121314151617FUZZ_CXXFLAGS=&quot;-O2 -fno-omit-frame-pointer -gline-tables-only -fsanitize=address -fsanitize-address-use-after-scope -fsanitize-coverage=trace-pc-guard,trace-cmp,trace-gep,trace-div&quot;......export CC=$&#123;CC:-&quot;clang&quot;&#125;export CXX=$&#123;CXX:-&quot;clang++&quot;&#125;export CPPFLAGS=$&#123;CPPFLAGS:-&quot;-DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION&quot;&#125;export LIB_FUZZING_ENGINE=&quot;libFuzzingEngine-$&#123;FUZZING_ENGINE&#125;.a&quot;if [[$FUZZING_ENGINE == &quot;fsanitize_fuzzer&quot;]]; then  FSANITIZE_FUZZER_FLAGS=&quot;-O2 -fno-omit-frame-pointer -gline-tables-only -fsanitize=address,fuzzer-no-link -fsanitize-address-use-after-scope&quot;  export CFLAGS=$&#123;CFLAGS:-$FSANITIZE_FUZZER_FLAGS&#125;  export CXXFLAGS=$&#123;CXXFLAGS:-$FSANITIZE_FUZZER_FLAGS&#125;elif......else  export CFLAGS=$&#123;CFLAGS:-&quot;$FUZZ_CXXFLAGS&quot;&#125;  export CXXFLAGS=$&#123;CXXFLAGS:-&quot;$FUZZ_CXXFLAGS&quot;&#125;fi\n\n可以看到脚本指定了 CC 和CXX编译工具为 clang 和clang++，在 CFLAGS 和CXXFLAGS中设置了 clang 的编译选项：\n\n\n\n选项\n含义\n\n\n\n-O2\n指定编译器优化等级为 2\n\n\n-fno-omit-frame-pointer\n将 frame pointer 保存在寄存器中。frame pointer 即栈帧基地址（指向栈底），在编译器优化时或某些平台上，fp 会被忽略，通过此选项可强制开启\n\n\n-gline-tables-only\n函数调用栈中包含函数名、文件名和行号等信息，但不包括局部变量和函数参数。要包括全部信息应使用 -g 选项\n\n\n-fsanitize&#x3D;fuzzer\n编译时对源码插桩，链接 libFuzzer 库文件\n\n\n-fsanitize&#x3D;fuzzer-no-link\n编译时对源码插桩，不链接 libFuzzer 库文件。编译待测源码时不链接，编译 fuzz target 时再链接，对大型项目可以提升编译效率\n\n\n-fsanitize&#x3D;address\n启用 AddressSanitizer，检测缓冲区溢出、UAF、Double Free、内存泄漏等内存问题\n\n\n-fsanitize-address-use-after-scope\n启用局部变量的 sanitization 以检测 use-after-scope 错误（作用域外访问）\n\n\n-fsanitize&#x3D;undefined\n启用 UndefinedSanitizer，检测程序运行中越界访问、整数溢出、空指针解引用等未定义行为\n\n\n-fsanitize-coverage&#x3D;trace-pc-guard,trace-cmp,trace-gep,trace-div\n开启代码覆盖率统计。在高版本 clang 中 -fsanitize-coverage&#x3D;trace-pc-guard 已弃用，默认开启代码覆盖率统计，使用此选项会报错\n\n\n3. 链接库文件  编译 fuzz target 时，执行了如下命令：\n1$CXX $CXXFLAGS $SCRIPT_DIR/target.cc -I BUILD BUILD/.libs/libcares.a $LIB_FUZZING_ENGINE -o $EXECUTABLE_NAME_BASE\n\n环境变量 CXX 和CXXFLAGS沿用之前定义，通过-I（uppercase i）选项，指定了.h 头文件目录和.a 静态库路径：\n\nBUILD：存放待测源码的头文件\n\nBUILD/.libs/libcares.a：编译待测源码生成的静态库文件libcares.a\n\n$LIB_FUZZING_ENGINE：编译 LibFuzzer 源码生成的libFuzzer.a\n\n\n链接库文件时，-I（uppercase i）可以用 -L 和-l（lowercase L）替换：\n1-I BUILD/.libs/libcares.a  等价于  -L BUILD/.libs -l cares\n\n特别地，链接 libFuzzer.a 库文件时，可以用过 -fsanitize=fuzzer 实现：\n1-I libFuzzer.a 等价于 -fsanitize=fuzzer\n\n二、自己编写命令  开源的编译脚本为了适配多个 benchmark 和多种 Fuzz 类型，做了较多逻辑处理，适配新的 benchmark 时不够灵活。通过对编译脚本的流程分析，很容易自己编写命令完成编译。\n在 Linux 环境下安装 clang，以 c-ares-CVE 为例，编写命令生成 fuzz target：\n0. 准备源码   123git clone https://github.com/c-ares/c-ares.gitcd c-ares/git reset --hard 51fbb479f7948fca2ace3ff34a15ff27e796afdd\n   此时查看目录内容如下：\n   123456root@server:~/fuzz/cares$ tree -L 1.├── c-ares└── target.cc1 directory, 1 file\n\n1. 设置环境变量   设置CC、CXX、CFLAGS、CXXFLAGS\n   1234export CC=clangexport CXX=clang++export CFLAGS=&quot;-O2 -fno-omit-frame-pointer -gline-tables-only -fsanitize=address,fuzzer-no-link -fsanitize-address-use-after-scope&quot;export CXXFLAGS=$CFLAGS\n\n2. 编译待测库    进入源码目录，执行configure 脚本，设置禁止编译动态库文件，执行 make 编译libcares.a\n   1234cd c-ares./buildconf./configure --disable-sharedmake -j4\n   编译成功后，会在源码目录下生成.lib 目录，存放生成的 libcares.a 文件\n   123root@server:~/fuzz/cares/c-ares$ cd .libs/root@server:~/fuzz/cares/c-ares/.libs$ lslibcares.a  libcares.la  libcares.lai\n\n3. 编译 fuzz target   由于安装 clang 时已经自带 LibFuzzer.a，因此不用再编译LibFuzzer.a，回到target.cc 目录，直接编译 targe.cc 链接 libFuzzer 即可\n   12cd ~/fuzz/cares$CXX $CXXFLAGS target.cc -fsanitize=fuzzer -g -I c-ares c-ares/.libs/libcares.a -o cares-fuzzer\n   编译成功后，会在当前目录下生成可执行文件 cares-fuzzer，执行cares-fuzzer 开始 fuzz 测试，可以看到触发了 crash\n   1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980root@server:~/fuzz/cares$ lsc-ares  cares-fuzzer  target.ccroot@server:~/fuzz/cares$ ./cares-fuzzerINFO: Seed: 3031255060INFO: Loaded 1 modules   (10 inline 8-bit counters): 10 [0x5a90e0, 0x5a90ea),INFO: Loaded 1 PC tables (10 PCs): 10 [0x56c278,0x56c318),INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 4096 bytesINFO: A corpus is not provided, starting from an empty corpus#2      INITED cov: 3 ft: 3 corp: 1/1b exec/s: 0 rss: 27Mb#4      NEW    cov: 4 ft: 4 corp: 2/3b lim: 4 exec/s: 0 rss: 27Mb L: 2/2 MS: 2 ChangeBit-InsertByte-#1331   NEW    cov: 6 ft: 6 corp: 3/20b lim: 17 exec/s: 0 rss: 27Mb L: 17/17 MS: 2 InsertByte-CrossOver-#1368   REDUCE cov: 6 ft: 6 corp: 3/19b lim: 17 exec/s: 0 rss: 27Mb L: 16/16 MS: 2 CrossOver-EraseBytes-#1048576        pulse  cov: 6 ft: 6 corp: 3/19b lim: 4096 exec/s: 524288 rss: 773Mb#2097152        pulse  cov: 6 ft: 6 corp: 3/19b lim: 4096 exec/s: 419430 rss: 773Mb===================================================================664326==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x603000d2c052 at pc 0x000000550e1c bp 0x7ffd914ddd30 sp 0x7ffd914ddd28WRITE of size 1 at 0x603000d2c052 thread T0    #0 0x550e1b in ares_create_query (/home/rootfuzz/cares/cares-fuzzer+0x550e1b)    #1 0x55053c in LLVMFuzzerTestOneInput /home/rootfuzz/cares/target.cc:14:3    #2 0x4586a1 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) (/home/rootfuzz/cares/cares-fuzzer+0x4586a1)    #3 0x457de5 in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool*) (/home/rootfuzz/cares/cares-fuzzer+0x457de5)    #4 0x45a087 in fuzzer::Fuzzer::MutateAndTestOne() (/home/rootfuzz/cares/cares-fuzzer+0x45a087)    #5 0x45ad85 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector&lt;fuzzer::SizedFile, fuzzer::fuzzer_allocator&lt;fuzzer::SizedFile&gt; &gt;&amp;) (/home/rootfuzz/cares/cares-fuzzer+0x45ad85)    #6 0x44973e in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (/home/rootfuzz/cares/cares-fuzzer+0x44973e)    #7 0x472582 in main (/home/rootfuzz/cares/cares-fuzzer+0x472582)    #8 0x7f4b400f8082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082)    #9 0x41e4dd in _start (/home/rootfuzz/cares/cares-fuzzer+0x41e4dd)0x603000d2c052 is located 0 bytes to the right of 18-byte region [0x603000d2c040,0x603000d2c052)allocated by thread T0 here:    #0 0x51e20d in malloc (/home/rootfuzz/cares/cares-fuzzer+0x51e20d)    #1 0x5508f6 in ares_create_query (/home/rootfuzz/cares/cares-fuzzer+0x5508f6)    #2 0x55053c in LLVMFuzzerTestOneInput /home/rootfuzz/cares/target.cc:14:3    #3 0x4586a1 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) (/home/rootfuzz/cares/cares-fuzzer+0x4586a1)    #4 0x457de5 in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool*) (/home/rootfuzz/cares/cares-fuzzer+0x457de5)    #5 0x45a087 in fuzzer::Fuzzer::MutateAndTestOne() (/home/rootfuzz/cares/cares-fuzzer+0x45a087)    #6 0x45ad85 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector&lt;fuzzer::SizedFile, fuzzer::fuzzer_allocator&lt;fuzzer::SizedFile&gt; &gt;&amp;) (/home/rootfuzz/cares/cares-fuzzer+0x45ad85)    #7 0x44973e in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (/home/rootfuzz/cares/cares-fuzzer+0x44973e)    #8 0x472582 in main (/home/rootfuzz/cares/cares-fuzzer+0x472582)    #9 0x7f4b400f8082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082)SUMMARY: AddressSanitizer: heap-buffer-overflow (/home/rootfuzz/cares/cares-fuzzer+0x550e1b) in ares_create_queryShadow bytes around the buggy address:  0x0c068019d7b0: fd fa fa fa fd fd fd fa fa fa fd fd fd fa fa fa  0x0c068019d7c0: fd fd fd fa fa fa fd fd fd fa fa fa fd fd fd fa  0x0c068019d7d0: fa fa fa fa fa fa fa fa fd fd fd fa fa fa fd fd  0x0c068019d7e0: fd fa fa fa fd fd fd fa fa fa fd fd fd fa fa fa  0x0c068019d7f0: fa fa fa fa fa fa fa fa fa fa fa fa fd fd fd fa=&gt;0x0c068019d800: fa fa fa fa fa fa fa fa 00 00[02]fa fa fa fa fa  0x0c068019d810: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa  0x0c068019d820: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa  0x0c068019d830: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa  0x0c068019d840: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa  0x0c068019d850: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa faShadow byte legend (one shadow byte represents 8 application bytes):  Addressable:           00  Partially addressable: 01 02 03 04 05 06 07  Heap left redzone:       fa  Freed heap region:       fd  Stack left redzone:      f1  Stack mid redzone:       f2  Stack right redzone:     f3  Stack after return:      f5  Stack use after scope:   f8  Global redzone:          f9  Global init order:       f6  Poisoned by user:        f7  Container overflow:      fc  Array cookie:            ac  Intra object redzone:    bb  ASan internal:           fe  Left alloca redzone:     ca  Right alloca redzone:    cb  Shadow gap:              cc==664326==ABORTINGMS: 4 ChangeBit-InsertByte-EraseBytes-ChangeByte-; base unit: 7c9981f8ba526a6e0b8c1bbb846c08e2d6026e3a0x5c,0x2e,\\\\.artifact_prefix=&#x27;./&#x27;; Test unit written to ./crash-c9257f8fd31ea852baf734ef06d37348bf6e8cb2Base64: XC4=\n\n三、补充说明 1. 脚本执行 带mode参数执行 build.sh 脚本时，需要编译 LibFuzzer 源码，这时候会出现找不到 LibFuzzer 源码的错误。需要自己下载源码，并放到指定路径，调试脚本解决问题，比较麻烦。\n建议不带参数执行build.sh，这时采用默认模式，编译时会采用 address 消毒器，这也是应用的最多的一种消毒器。\n2. 静态库 or 动态库  编译待测库的源码时，一定要编译成静态库文件 ，在congfigure 时使用 --disable-shared 参数。\n如果是编成动态库文件，或静态库动态库同时都有的情况下，fuzz target 会优先链接动态库文件。而动态库会导致 fuzz 测试失效。\n\n\n第一个图中使用静态库，fuzz 很快能发现 crash，第二个图中是用动态库，fuzz 运行很慢，找不到 crash。\n使用静态库得到 57 PCs，使用动态库得到 5 PCs，二者有明显区别，推测使用动态库可能会导致插桩失效，影响 fuzz 运行效率。","dateCreated":"2023-09-26T14:32:22+08:00","dateModified":"2024-06-26T15:04:11+08:00","datePublished":"2023-09-26T14:32:22+08:00","description":"怎样编出 LibFuzzer 的 target","headline":"LibFuzzer 编译指南","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2023/LibFuzzer%E7%BC%96%E8%AF%91%E6%8C%87%E5%8D%97/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://www.stepbystep.asia/2023/LibFuzzer%E7%BC%96%E8%AF%91%E6%8C%87%E5%8D%97/","keywords":"安全, 工具, Fuzz, LibFuzzer"}</script>
     <meta name="description" content="怎样编出 LibFuzzer 的 target">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="LibFuzzer 编译指南">
@@ -27,9 +27,9 @@
 <meta property="article:published_time" content="2023-09-26T06:32:22.000Z">
 <meta property="article:modified_time" content="2024-06-26T07:04:11.486Z">
 <meta property="article:author" content="一瓢清浅">
-<meta property="article:tag" content="Fuzz">
 <meta property="article:tag" content="安全">
 <meta property="article:tag" content="工具">
+<meta property="article:tag" content="Fuzz">
 <meta property="article:tag" content="LibFuzzer">
 <meta name="twitter:card" content="summary">
 <meta name="twitter:image" content="https://www.stepbystep.asia/2023/LibFuzzer%E7%BC%96%E8%AF%91%E6%8C%87%E5%8D%97/%E4%BD%BF%E7%94%A8%E9%9D%99%E6%80%81%E5%BA%93.png">
diff --git "a/2023/\347\254\246\345\217\267\346\211\247\350\241\214\344\270\216\346\267\267\345\220\210\346\250\241\347\263\212\346\265\213\350\257\225/index.html" "b/2023/\347\254\246\345\217\267\346\211\247\350\241\214\344\270\216\346\267\267\345\220\210\346\250\241\347\263\212\346\265\213\350\257\225/index.html"
index 76469ec..be64999 100644
--- "a/2023/\347\254\246\345\217\267\346\211\247\350\241\214\344\270\216\346\267\267\345\220\210\346\250\241\347\263\212\346\265\213\350\257\225/index.html"
+++ "b/2023/\347\254\246\345\217\267\346\211\247\350\241\214\344\270\216\346\267\267\345\220\210\346\250\241\347\263\212\346\265\213\350\257\225/index.html"
@@ -14,7 +14,7 @@
     
     
     
-    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg"},"articleBody":"\n\n一、符号执行 1. 静态符号执行 定义  符号执行是一种程序分析技术，它通过使用符号代替实际的运行时值来探索程序的所有可能执行路径。这种技术不仅可以帮助生成覆盖率高的测试用例，还能有效地发现潜在的程序错误。\n\n\n具体地，符号执行采用抽象的符号代替具体值作为程序输入变量，得出每个路径抽象的输出结果和需要满足的约束条件。通过约束求解器，可以反推出指定程序路径时，程序输入应该设置的具体值。\n这种传统的符号执行不需要运行程序，所以也称为静态符号执行，它与 fuzz 测试相比各有优劣。举例来说，当我要求如下程序触发 AssertionError 时：\n12345def f():    x = int(input())    y = x * 2    if y == 12:        assert False\n如果使用 fuzz 测试，由于 x 是随机输入，为了满足y==12，fuzz 需要进行大量的尝试。\n如果使用符号执行，要触发 AssertionError 只需要满足约束条件 2*x==12 即可，求解可得x==6，一次分析即可搞定。\n原理  符号执行包括三个核心组件：\n\n状态信息存储器\nσ：程序变量的符号表达式\nπ：路径约束，即走到特定语句所经过的条件组合\nstmt：指向需要处理的下一条程序语句\n\n\n语句执行器：执行 stmt 指向的语句，更新 σ 或π的状态\n约束求解器：根据路径约束 π 和符号表达式σ，求出可行解\n\n下图演示了符号执行过程中，各组件的变化情况：\n\n\n缺陷  只需一次分析，即可获得所有路径的可行解，这个理想很美好，但现实很骨感。 静态符号执行在实际应用中，面临两大挑战：\n1. 路径爆炸\n程序中的分支和循环，都会使得程序路径爆炸式增长，导致分析过程变得不可行：\n\n每增加一次条件判断，程序会产生两个分支，极端情况下，路径数量呈指数增长\n无限循环和递归调用，可能导致无穷长的路径1234567def func():    s = 0    x = int(input())    while x &gt; 0:        s += x        print(f&#x27;total sum: &#123;s&#125;&#x27;)        x = int(input())\n\n处理路径爆炸问题的思路主要是限制分析的搜索空间，例如设置超时机制、搜索次数，使用启发式搜索等策略。\n2. 约束不可解\n符号执行中的关键环节在于约束求解器求解约束条件。学过数学的都知道，解不出来的方程可太多了。在程序中会面临更复杂的情况：\n\n程序调用无源码函数\n1234def func(x, y):    z = do_something(x)    if y + z &lt; 0:        print(&#x27;error&#x27;)\n\n不可解的非线程约束条件\n\n\n为了处理不可解的场景，动态符号执行诞生了，它将具体值与符号值结合，在符号值解不了的场景，用具体值代替，达到化简约束、降低求解难度的目的。\n2. 动态符号执行  静态符号执行不需要运行程序，动态符号执行则是要设置输入，启动程序，让程序跑起来。在程序运行过程中，程序的变量在理论上都有两种取值，一种是符号值，一种是具体值。\n在实现上，根据两种取值的配合方式，动态符号执行可分为两种路线：\nConcolic Testing在这种测试方法中，每个变量同时保留了符号值和具体值。在求解约束条件时，如果用符号值表达的约束条件解不了，那就将具体值代入对应的符号变量，化简条件再求解。\n此外，这种测试方法在一条路径探索结束后，会通过对条件约束进行取反操作，切换到其他的执行路径，再继续进行探索。\n\n\nExecution-Generated Testing在这种测试方法中，每个变量值保留符号值和具体值中的一个状态。程序中的任何一个运算，如果所有相关变量都是具体值，那就使用具体执行；如果有任何一个变量是符号值，那就使用符号执行。\n\n\n缺陷  没有完美的方案，动态符号执行虽然能缓解约束不可解的问题，但是使用具体值简化，也可能导致部分可执行路径无法被探索到。\n1234def func(x):    y = do_something(x)    if y &gt; 0:        print(&#x27;error&#x27;)\n\n由于 do_something 的源码未知，使用静态符号执行无法求解，动态符号执行会用 x 的具体值来计算 y。假设算出来y==-1，那么if 的判断条件由于矛盾而终止，导致 error 不可达。\n为了解决这个问题，需要不断地更换 x 的具体值。从这个角度来看，将 Fuzz 和动态符号执行结合起来，是一件自然而然的事情，于是就有了混合模糊测试技术（Hybrid Fuzzing)。\n3. 参考资料\n符号执行入门\nSymbolic Execution for Software Testing  Three Decades Later\nA Survey of Symbolic Execution Techniques\n北京大学 - 软件分析技术 - 第 19 课\nUsing Klee and Angr\n\n二、混合模糊测试1. 原理与架构Fuzz 测试与符号执行互有优劣，在一定程度上是互补关系。\n\n\n\n技术\n优点\n缺点\n\n\n\nFuzz 测试\n随机变异，运行速度快\n难以深入复杂的执行路径，代码覆盖率有限\n\n\n符号执行\n对程序进行分析和推理，可以突破复杂的路径约束\n运行速度慢，资源消耗大\n\n\n混合模糊测试结合二者的长处，通过 Fuzz 测试随机生成大量输入来测试程序的浅层代码，再结合动态符号执行来探索程序的深层路径，提升整体的代码覆盖率。\n混合模糊测试的常见架构设计如下：\n\n\n在 Fuzz 引擎和符号执行引擎之外，还有一个关键组件 Coordinator，其作用主要为协调 Fuzz 与符号执行的相互配合。 \nFuzz 测试与符号执行在执行速度与资源消耗方面都有很大区别，这个差异还会随着 target 而各有不同。如何设计一个好的 Coordinator，让运行时的性能最优，是混合模糊测试需要考虑的一个关键因素。\n2. SymCCSymCC是一款开源的动态符号执行工具，通过在编译时插桩，为每个变量构建符号表达，在运行时，缩短符号推理计算的时间，相比此前的符号执行工具（如 KLEE 和 QSYM）性能有明显提升。\nSymCC 由于出色表现，已被 LibAFL 官方集成。SymCC 本身提供了一个 symcc_fuzzing_helper 工具，简单快速的支持混合模糊测试功能，其核心代码为：\n\n\n这段代码的主要逻辑为：每隔 5 秒检查 AFL 的corpus目录，如果 AFL 有产生新的测试用例，那么就将这个测试用例发给 symcc，symcc 基于这个测试用例开始动态符号执行。\n使用 SymCC 进行混合模糊测试的步骤请见参考资料。能顺利跑起来的开源项目不多，SymCC 必须给个好评。\n3. 参考资料\nExploratory Review of Hybrid Fuzzing for Automated Vulnerability Detection\nSymbolic execution with SymCC: Don’t interpret, compile!\n符号执行 Symcc 与模糊测试 AFL 结合实践\n","dateCreated":"2023-12-24T16:22:08+08:00","dateModified":"2024-06-27T16:12:14+08:00","datePublished":"2023-12-24T16:22:08+08:00","description":"介绍符号执行技术，以及符号执行与 Fuzz 相结合的混合模糊测试技术","headline":"符号执行与混合模糊测试","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2023/%E7%AC%A6%E5%8F%B7%E6%89%A7%E8%A1%8C%E4%B8%8E%E6%B7%B7%E5%90%88%E6%A8%A1%E7%B3%8A%E6%B5%8B%E8%AF%95/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://www.stepbystep.asia/2023/%E7%AC%A6%E5%8F%B7%E6%89%A7%E8%A1%8C%E4%B8%8E%E6%B7%B7%E5%90%88%E6%A8%A1%E7%B3%8A%E6%B5%8B%E8%AF%95/","keywords":"Fuzz, 安全, 符号执行"}</script>
+    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg"},"articleBody":"\n\n一、符号执行 1. 静态符号执行 定义  符号执行是一种程序分析技术，它通过使用符号代替实际的运行时值来探索程序的所有可能执行路径。这种技术不仅可以帮助生成覆盖率高的测试用例，还能有效地发现潜在的程序错误。\n\n\n具体地，符号执行采用抽象的符号代替具体值作为程序输入变量，得出每个路径抽象的输出结果和需要满足的约束条件。通过约束求解器，可以反推出指定程序路径时，程序输入应该设置的具体值。\n这种传统的符号执行不需要运行程序，所以也称为静态符号执行，它与 fuzz 测试相比各有优劣。举例来说，当我要求如下程序触发 AssertionError 时：\n12345def f():    x = int(input())    y = x * 2    if y == 12:        assert False\n如果使用 fuzz 测试，由于 x 是随机输入，为了满足y==12，fuzz 需要进行大量的尝试。\n如果使用符号执行，要触发 AssertionError 只需要满足约束条件 2*x==12 即可，求解可得x==6，一次分析即可搞定。\n原理  符号执行包括三个核心组件：\n\n状态信息存储器\nσ：程序变量的符号表达式\nπ：路径约束，即走到特定语句所经过的条件组合\nstmt：指向需要处理的下一条程序语句\n\n\n语句执行器：执行 stmt 指向的语句，更新 σ 或π的状态\n约束求解器：根据路径约束 π 和符号表达式σ，求出可行解\n\n下图演示了符号执行过程中，各组件的变化情况：\n\n\n缺陷  只需一次分析，即可获得所有路径的可行解，这个理想很美好，但现实很骨感。 静态符号执行在实际应用中，面临两大挑战：\n1. 路径爆炸\n程序中的分支和循环，都会使得程序路径爆炸式增长，导致分析过程变得不可行：\n\n每增加一次条件判断，程序会产生两个分支，极端情况下，路径数量呈指数增长\n无限循环和递归调用，可能导致无穷长的路径1234567def func():    s = 0    x = int(input())    while x &gt; 0:        s += x        print(f&#x27;total sum: &#123;s&#125;&#x27;)        x = int(input())\n\n处理路径爆炸问题的思路主要是限制分析的搜索空间，例如设置超时机制、搜索次数，使用启发式搜索等策略。\n2. 约束不可解\n符号执行中的关键环节在于约束求解器求解约束条件。学过数学的都知道，解不出来的方程可太多了。在程序中会面临更复杂的情况：\n\n程序调用无源码函数\n1234def func(x, y):    z = do_something(x)    if y + z &lt; 0:        print(&#x27;error&#x27;)\n\n不可解的非线程约束条件\n\n\n为了处理不可解的场景，动态符号执行诞生了，它将具体值与符号值结合，在符号值解不了的场景，用具体值代替，达到化简约束、降低求解难度的目的。\n2. 动态符号执行  静态符号执行不需要运行程序，动态符号执行则是要设置输入，启动程序，让程序跑起来。在程序运行过程中，程序的变量在理论上都有两种取值，一种是符号值，一种是具体值。\n在实现上，根据两种取值的配合方式，动态符号执行可分为两种路线：\nConcolic Testing在这种测试方法中，每个变量同时保留了符号值和具体值。在求解约束条件时，如果用符号值表达的约束条件解不了，那就将具体值代入对应的符号变量，化简条件再求解。\n此外，这种测试方法在一条路径探索结束后，会通过对条件约束进行取反操作，切换到其他的执行路径，再继续进行探索。\n\n\nExecution-Generated Testing在这种测试方法中，每个变量值保留符号值和具体值中的一个状态。程序中的任何一个运算，如果所有相关变量都是具体值，那就使用具体执行；如果有任何一个变量是符号值，那就使用符号执行。\n\n\n缺陷  没有完美的方案，动态符号执行虽然能缓解约束不可解的问题，但是使用具体值简化，也可能导致部分可执行路径无法被探索到。\n1234def func(x):    y = do_something(x)    if y &gt; 0:        print(&#x27;error&#x27;)\n\n由于 do_something 的源码未知，使用静态符号执行无法求解，动态符号执行会用 x 的具体值来计算 y。假设算出来y==-1，那么if 的判断条件由于矛盾而终止，导致 error 不可达。\n为了解决这个问题，需要不断地更换 x 的具体值。从这个角度来看，将 Fuzz 和动态符号执行结合起来，是一件自然而然的事情，于是就有了混合模糊测试技术（Hybrid Fuzzing)。\n3. 参考资料\n符号执行入门\nSymbolic Execution for Software Testing  Three Decades Later\nA Survey of Symbolic Execution Techniques\n北京大学 - 软件分析技术 - 第 19 课\nUsing Klee and Angr\n\n二、混合模糊测试1. 原理与架构Fuzz 测试与符号执行互有优劣，在一定程度上是互补关系。\n\n\n\n技术\n优点\n缺点\n\n\n\nFuzz 测试\n随机变异，运行速度快\n难以深入复杂的执行路径，代码覆盖率有限\n\n\n符号执行\n对程序进行分析和推理，可以突破复杂的路径约束\n运行速度慢，资源消耗大\n\n\n混合模糊测试结合二者的长处，通过 Fuzz 测试随机生成大量输入来测试程序的浅层代码，再结合动态符号执行来探索程序的深层路径，提升整体的代码覆盖率。\n混合模糊测试的常见架构设计如下：\n\n\n在 Fuzz 引擎和符号执行引擎之外，还有一个关键组件 Coordinator，其作用主要为协调 Fuzz 与符号执行的相互配合。 \nFuzz 测试与符号执行在执行速度与资源消耗方面都有很大区别，这个差异还会随着 target 而各有不同。如何设计一个好的 Coordinator，让运行时的性能最优，是混合模糊测试需要考虑的一个关键因素。\n2. SymCCSymCC是一款开源的动态符号执行工具，通过在编译时插桩，为每个变量构建符号表达，在运行时，缩短符号推理计算的时间，相比此前的符号执行工具（如 KLEE 和 QSYM）性能有明显提升。\nSymCC 由于出色表现，已被 LibAFL 官方集成。SymCC 本身提供了一个 symcc_fuzzing_helper 工具，简单快速的支持混合模糊测试功能，其核心代码为：\n\n\n这段代码的主要逻辑为：每隔 5 秒检查 AFL 的corpus目录，如果 AFL 有产生新的测试用例，那么就将这个测试用例发给 symcc，symcc 基于这个测试用例开始动态符号执行。\n使用 SymCC 进行混合模糊测试的步骤请见参考资料。能顺利跑起来的开源项目不多，SymCC 必须给个好评。\n3. 参考资料\nExploratory Review of Hybrid Fuzzing for Automated Vulnerability Detection\nSymbolic execution with SymCC: Don’t interpret, compile!\n符号执行 Symcc 与模糊测试 AFL 结合实践\n","dateCreated":"2023-12-24T16:22:08+08:00","dateModified":"2024-06-27T16:12:14+08:00","datePublished":"2023-12-24T16:22:08+08:00","description":"介绍符号执行技术，以及符号执行与 Fuzz 相结合的混合模糊测试技术","headline":"符号执行与混合模糊测试","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2023/%E7%AC%A6%E5%8F%B7%E6%89%A7%E8%A1%8C%E4%B8%8E%E6%B7%B7%E5%90%88%E6%A8%A1%E7%B3%8A%E6%B5%8B%E8%AF%95/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://www.stepbystep.asia/2023/%E7%AC%A6%E5%8F%B7%E6%89%A7%E8%A1%8C%E4%B8%8E%E6%B7%B7%E5%90%88%E6%A8%A1%E7%B3%8A%E6%B5%8B%E8%AF%95/","keywords":"符号执行, 安全, Fuzz"}</script>
     <meta name="description" content="介绍符号执行技术，以及符号执行与 Fuzz 相结合的混合模糊测试技术">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="符号执行与混合模糊测试">
@@ -29,9 +29,9 @@
 <meta property="article:published_time" content="2023-12-24T08:22:08.000Z">
 <meta property="article:modified_time" content="2024-06-27T08:12:14.674Z">
 <meta property="article:author" content="一瓢清浅">
-<meta property="article:tag" content="Fuzz">
-<meta property="article:tag" content="安全">
 <meta property="article:tag" content="符号执行">
+<meta property="article:tag" content="安全">
+<meta property="article:tag" content="Fuzz">
 <meta name="twitter:card" content="summary">
 <meta name="twitter:image" content="https://www.stepbystep.asia/2023/%E7%AC%A6%E5%8F%B7%E6%89%A7%E8%A1%8C%E4%B8%8E%E6%B7%B7%E5%90%88%E6%A8%A1%E7%B3%8A%E6%B5%8B%E8%AF%95/%E7%AC%A6%E5%8F%B7%E6%89%A7%E8%A1%8C%E5%AE%9A%E4%B9%89.png">
     
diff --git "a/2024/AFLplusplus\346\272\220\347\240\201\345\210\206\346\236\220\342\200\224\342\200\224\345\220\214\346\255\245\346\234\272\345\210\266/index.html" "b/2024/AFLplusplus\346\272\220\347\240\201\345\210\206\346\236\220\342\200\224\342\200\224\345\220\214\346\255\245\346\234\272\345\210\266/index.html"
index 28a6c71..48062fa 100644
--- "a/2024/AFLplusplus\346\272\220\347\240\201\345\210\206\346\236\220\342\200\224\342\200\224\345\220\214\346\255\245\346\234\272\345\210\266/index.html"
+++ "b/2024/AFLplusplus\346\272\220\347\240\201\345\210\206\346\236\220\342\200\224\342\200\224\345\220\214\346\255\245\346\234\272\345\210\266/index.html"
@@ -14,7 +14,7 @@
     
     
     
-    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg"},"articleBody":"\n\n最近遇到 AFL++ 同步 interesting corpus 失败的问题，不得不嗑一嗑 AFL++ 的源码了，该来的躲不掉，虽然 C 代码让我有点头大。\n一、同步机制  常规情况下 AFL++ 是以单实例运行的。三个臭皮匠顶个诸葛亮，多开几个 AFL++ 实例一起跑是可行的，AFL++ 和其他的 Fuzz 工具（LibFuzzer、HonggFuzz）一起跑也是可以的。\n通过 afl-fuzz -h 可以看到 AFL++ 提供了相关的命令参数：\n\nOther stuff:&emsp;-M&#x2F;-S id&emsp;- distributed mode (-M sets -Z and disables trimming)&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;see docs&#x2F;fuzzing_in_depth.md#c-using-multiple-cores&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;for effective recommendations for parallel fuzzing.&emsp;-F path&emsp;- sync to a foreign fuzzer queue directory (requires -M, can&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;be specified up to 32 times)\n\n简而言之，AFL++ 同步相关的几个参数如下：\n\n-M：指定 AFL++ 主实例。主实例会从 -S 指定的从实例、-F 指定的其他 Fuzz 中同步有趣的测试用例。主实例只有一个，负责管理所有的测试用例。\n-S：指定 AFL++ 从实例。从实例产生的有趣测试用例将被同步到 -M 指定的主实例中，从实例也会从 -M 指定的主实例中同步有趣的测试用例。\n-F：指定其他 Fuzz 实例的 corpus 目录。由其他 Fuzz 产生的有趣的测试用例，将会被同步到 -M 指定的主实例中。\n\n可以看到  主实例位于多实例运行模式的核心地位，它负责汇总和分发 AFL++ 的测试用例。\n123456789101112131415  +---------+       +---------+  | Fuzzer 1|       | Fuzzer 2|  |   (F)   |       |   (F)   |  +----+----+       +----+----+       |                 |       v                 v+------+-----------------+------+|           Master (M)          |+-----+---------------+---------+      ^  |            ^  |      |  v            |  v  +---------+      +---------+  | Slave 1 |      | Slave 2 |  |   (S)   |      |   (S)   |  +---------+      +---------+\n\n实际使用时，执行命令参考如下：\n123afl-fuzz -i inputs -o outputs -M master -F /path/to/foreign_fuzzer1/queue -F /path/to/foreign_fuzzer2/queue -- ./targetafl-fuzz -i inputs -o outputs -S slave1 -- ./targetafl-fuzz -i inputs -o outputs -S slave2 -- ./target\n\n二、源码分析 AFL++ 的源码入口为afl_fuzz.c 的main函数。AFL++ 从其他 fuzzer 中同步 corpus，是通过 sync_fuzzers 函数来实现的。\n在 main 函数中，可以看到对 sync_fuzzers 函数的调用。一路跟踪下来，代码调用关系参考如下时序图：\nsequenceDiagram\n    participant main\n    participant sync_fuzzers\n    participant read_foreign_testcases\n    participant update_sync_time\n    participant scandir\n    participant fuzz_run_target\n    participant save_if_interesting\n    participant has_new_bits\n    participant describe_op\n    participant ck_write\n    participant add_to_queue\n\n    main->>sync_fuzzers: 开始同步\n    loop 遍历 AFL++ 的 out 目录中的子目录 d_name\n        sync_fuzzers->>update_sync_time: 更新同步时间\n        sync_fuzzers->>scandir: 读取 d_name/queue 目录中的 corpus 列表\n        loop 遍历新增的 corpus（通过 corpus 的 id 号来识别）\n            sync_fuzzers->>fuzz_run_target: 用 corpus 作为输入运行一次 target\n            fuzz_run_target-->>sync_fuzzers: 返回 target 运行结果\n            sync_fuzzers->>save_if_interesting: 检查并保存 corpus\n            save_if_interesting->>has_new_bits: 检查 corpus 是否为 interesting\n            has_new_bits-->>save_if_interesting: 返回检查结果\n            alt 如果 corpus 是 interesting\n                save_if_interesting->>describe_op: 为 corpus 创建文件名\n                describe_op-->>save_if_interesting: 返回文件名\n                save_if_interesting-->>ck_write: 将 interesting 的 corpus 保存到 AFL++ 的 queue 目录中\n                save_if_interesting->>add_to_queue: 将 interesting 的 corpus 添加到 AFL++ 的队列中\n            end\n        end\n    end\n    alt 如果指定了其他 Fuzz 的 corpus 目录\n        sync_fuzzers->>read_foreign_testcases: 开始同步其他 Fuzz 的 corpus\n        loop 遍历其他 Fuzz 的 corpus 目录\n            read_foreign_testcases->>scandir: 读取其他 Fuzz 的 corpus 列表\n            loop 遍历其他 Fuzz 的 corpus\n                read_foreign_testcases->>fuzz_run_target: 用 corpus 作为输入运行一次 target\n                fuzz_run_target-->>read_foreign_testcases: 返回 target 运行结果\n                read_foreign_testcases->>save_if_interesting: 检查 corpus 是否为 interesting\n                save_if_interesting->>has_new_bits: 检查 corpus 是否为 interesting\n                has_new_bits-->>save_if_interesting: 返回检查结果\n                alt 如果 corpus 是 interesting\n                    save_if_interesting->>describe_op: 为 corpus 创建文件名\n                    describe_op-->>save_if_interesting: 返回文件名\n                    save_if_interesting-->>ck_write: 将 interesting 的 corpus 保存到 AFL++ 的 queue 目录中\n                    save_if_interesting->>add_to_queue: 将 interesting 的 corpus 添加到 AFL++ 的队列中\n                end\n            end\n        end\n        read_foreign_testcases-->>sync_fuzzers: 同步其他 Fuzz 的 corpus 结束\n    end\n    sync_fuzzers-->>main: 同步完毕\n简而言之，主实例同步从实例过程是这样的：\n\nAFL++ 会检查 out 目录下的文件夹（排除 AFL++ 本身的 default 文件夹）\n如果文件夹中没有 queue 子目录，转 1\n如果文件夹中有 queue，则遍历 queue 下的 corpus\n如果 corpus 是处理过的（根据文件名 id 判断），转 4\n如果 corpus 是没有处理过的，那就用这个 corpus 作为输入，执行一次 target\n分析 target 执行结果，判断 corpus 是否为 interesting，如果不是 interesting，转 3\n如果 corpus 是 interesting，则将 corpus 保存为 out&#x2F;default&#x2F;queue 目录下的文件，并将 corpus 添加到 AFL++ 的内存队列中，再转 3\n\n主实例同步其他 Fuzz 的过程与之类似，只是每次同步时，并不会根据 corpus 文件名的 id 编号过滤已经分析过的 corpus，因此从外部 Fuzz 同步 corpus 的性能较差。\n三、实践应用  如果某一款工具能生成 corpus，但是希望以从示例的方式被主实例同步，需要保证这款工具产生的 corpus 的命名符合以下要求：\n\n以 id: 开头，然后是高位补 0 的六位数字\n第一个 corpus 的 id 从 0 开始，随后的 corpus 依次以 1 递增\n\n其原因读一遍 sync_fuzzers 的源码就明白了，源码面前，了无秘密。\n","dateCreated":"2024-07-16T09:02:06+08:00","dateModified":"2024-07-24T11:41:30+08:00","datePublished":"2024-07-16T09:02:06+08:00","description":"分析 AFL++ 同步机制的相关源码","headline":"AFLplusplus 源码分析——同步机制","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2024/AFLplusplus%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E2%80%94%E2%80%94%E5%90%8C%E6%AD%A5%E6%9C%BA%E5%88%B6/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://www.stepbystep.asia/2024/AFLplusplus%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E2%80%94%E2%80%94%E5%90%8C%E6%AD%A5%E6%9C%BA%E5%88%B6/","keywords":"AFL++, Fuzz, 安全, 工具"}</script>
+    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg"},"articleBody":"\n\n最近遇到 AFL++ 同步 interesting corpus 失败的问题，不得不嗑一嗑 AFL++ 的源码了，该来的躲不掉，虽然 C 代码让我有点头大。\n一、同步机制  常规情况下 AFL++ 是以单实例运行的。三个臭皮匠顶个诸葛亮，多开几个 AFL++ 实例一起跑是可行的，AFL++ 和其他的 Fuzz 工具（LibFuzzer、HonggFuzz）一起跑也是可以的。\n通过 afl-fuzz -h 可以看到 AFL++ 提供了相关的命令参数：\n\nOther stuff:&emsp;-M&#x2F;-S id&emsp;- distributed mode (-M sets -Z and disables trimming)&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;see docs&#x2F;fuzzing_in_depth.md#c-using-multiple-cores&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;for effective recommendations for parallel fuzzing.&emsp;-F path&emsp;- sync to a foreign fuzzer queue directory (requires -M, can&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;be specified up to 32 times)\n\n简而言之，AFL++ 同步相关的几个参数如下：\n\n-M：指定 AFL++ 主实例。主实例会从 -S 指定的从实例、-F 指定的其他 Fuzz 中同步有趣的测试用例。主实例只有一个，负责管理所有的测试用例。\n-S：指定 AFL++ 从实例。从实例产生的有趣测试用例将被同步到 -M 指定的主实例中，从实例也会从 -M 指定的主实例中同步有趣的测试用例。\n-F：指定其他 Fuzz 实例的 corpus 目录。由其他 Fuzz 产生的有趣的测试用例，将会被同步到 -M 指定的主实例中。\n\n可以看到  主实例位于多实例运行模式的核心地位，它负责汇总和分发 AFL++ 的测试用例。\n123456789101112131415  +---------+       +---------+  | Fuzzer 1|       | Fuzzer 2|  |   (F)   |       |   (F)   |  +----+----+       +----+----+       |                 |       v                 v+------+-----------------+------+|           Master (M)          |+-----+---------------+---------+      ^  |            ^  |      |  v            |  v  +---------+      +---------+  | Slave 1 |      | Slave 2 |  |   (S)   |      |   (S)   |  +---------+      +---------+\n\n实际使用时，执行命令参考如下：\n123afl-fuzz -i inputs -o outputs -M master -F /path/to/foreign_fuzzer1/queue -F /path/to/foreign_fuzzer2/queue -- ./targetafl-fuzz -i inputs -o outputs -S slave1 -- ./targetafl-fuzz -i inputs -o outputs -S slave2 -- ./target\n\n二、源码分析 AFL++ 的源码入口为afl_fuzz.c 的main函数。AFL++ 从其他 fuzzer 中同步 corpus，是通过 sync_fuzzers 函数来实现的。\n在 main 函数中，可以看到对 sync_fuzzers 函数的调用。一路跟踪下来，代码调用关系参考如下时序图：\nsequenceDiagram\n    participant main\n    participant sync_fuzzers\n    participant read_foreign_testcases\n    participant update_sync_time\n    participant scandir\n    participant fuzz_run_target\n    participant save_if_interesting\n    participant has_new_bits\n    participant describe_op\n    participant ck_write\n    participant add_to_queue\n\n    main->>sync_fuzzers: 开始同步\n    loop 遍历 AFL++ 的 out 目录中的子目录 d_name\n        sync_fuzzers->>update_sync_time: 更新同步时间\n        sync_fuzzers->>scandir: 读取 d_name/queue 目录中的 corpus 列表\n        loop 遍历新增的 corpus（通过 corpus 的 id 号来识别）\n            sync_fuzzers->>fuzz_run_target: 用 corpus 作为输入运行一次 target\n            fuzz_run_target-->>sync_fuzzers: 返回 target 运行结果\n            sync_fuzzers->>save_if_interesting: 检查并保存 corpus\n            save_if_interesting->>has_new_bits: 检查 corpus 是否为 interesting\n            has_new_bits-->>save_if_interesting: 返回检查结果\n            alt 如果 corpus 是 interesting\n                save_if_interesting->>describe_op: 为 corpus 创建文件名\n                describe_op-->>save_if_interesting: 返回文件名\n                save_if_interesting-->>ck_write: 将 interesting 的 corpus 保存到 AFL++ 的 queue 目录中\n                save_if_interesting->>add_to_queue: 将 interesting 的 corpus 添加到 AFL++ 的队列中\n            end\n        end\n    end\n    alt 如果指定了其他 Fuzz 的 corpus 目录\n        sync_fuzzers->>read_foreign_testcases: 开始同步其他 Fuzz 的 corpus\n        loop 遍历其他 Fuzz 的 corpus 目录\n            read_foreign_testcases->>scandir: 读取其他 Fuzz 的 corpus 列表\n            loop 遍历其他 Fuzz 的 corpus\n                read_foreign_testcases->>fuzz_run_target: 用 corpus 作为输入运行一次 target\n                fuzz_run_target-->>read_foreign_testcases: 返回 target 运行结果\n                read_foreign_testcases->>save_if_interesting: 检查 corpus 是否为 interesting\n                save_if_interesting->>has_new_bits: 检查 corpus 是否为 interesting\n                has_new_bits-->>save_if_interesting: 返回检查结果\n                alt 如果 corpus 是 interesting\n                    save_if_interesting->>describe_op: 为 corpus 创建文件名\n                    describe_op-->>save_if_interesting: 返回文件名\n                    save_if_interesting-->>ck_write: 将 interesting 的 corpus 保存到 AFL++ 的 queue 目录中\n                    save_if_interesting->>add_to_queue: 将 interesting 的 corpus 添加到 AFL++ 的队列中\n                end\n            end\n        end\n        read_foreign_testcases-->>sync_fuzzers: 同步其他 Fuzz 的 corpus 结束\n    end\n    sync_fuzzers-->>main: 同步完毕\n简而言之，主实例同步从实例过程是这样的：\n\nAFL++ 会检查 out 目录下的文件夹（排除 AFL++ 本身的 default 文件夹）\n如果文件夹中没有 queue 子目录，转 1\n如果文件夹中有 queue，则遍历 queue 下的 corpus\n如果 corpus 是处理过的（根据文件名 id 判断），转 4\n如果 corpus 是没有处理过的，那就用这个 corpus 作为输入，执行一次 target\n分析 target 执行结果，判断 corpus 是否为 interesting，如果不是 interesting，转 3\n如果 corpus 是 interesting，则将 corpus 保存为 out&#x2F;default&#x2F;queue 目录下的文件，并将 corpus 添加到 AFL++ 的内存队列中，再转 3\n\n主实例同步其他 Fuzz 的过程与之类似，只是每次同步时，并不会根据 corpus 文件名的 id 编号过滤已经分析过的 corpus，因此从外部 Fuzz 同步 corpus 的性能较差。\n三、实践应用  如果某一款工具能生成 corpus，但是希望以从示例的方式被主实例同步，需要保证这款工具产生的 corpus 的命名符合以下要求：\n\n以 id: 开头，然后是高位补 0 的六位数字\n第一个 corpus 的 id 从 0 开始，随后的 corpus 依次以 1 递增\n\n其原因读一遍 sync_fuzzers 的源码就明白了，源码面前，了无秘密。\n","dateCreated":"2024-07-16T09:02:06+08:00","dateModified":"2024-07-24T11:41:30+08:00","datePublished":"2024-07-16T09:02:06+08:00","description":"分析 AFL++ 同步机制的相关源码","headline":"AFLplusplus 源码分析——同步机制","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2024/AFLplusplus%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E2%80%94%E2%80%94%E5%90%8C%E6%AD%A5%E6%9C%BA%E5%88%B6/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://www.stepbystep.asia/2024/AFLplusplus%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E2%80%94%E2%80%94%E5%90%8C%E6%AD%A5%E6%9C%BA%E5%88%B6/","keywords":"安全, 工具, Fuzz, AFL++"}</script>
     <meta name="description" content="分析 AFL++ 同步机制的相关源码">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="AFLplusplus 源码分析——同步机制">
@@ -26,10 +26,10 @@
 <meta property="article:published_time" content="2024-07-16T01:02:06.000Z">
 <meta property="article:modified_time" content="2024-07-24T03:41:30.618Z">
 <meta property="article:author" content="一瓢清浅">
-<meta property="article:tag" content="AFL++">
-<meta property="article:tag" content="Fuzz">
 <meta property="article:tag" content="安全">
 <meta property="article:tag" content="工具">
+<meta property="article:tag" content="Fuzz">
+<meta property="article:tag" content="AFL++">
 <meta name="twitter:card" content="summary">
 <meta name="twitter:image" content="https://www.stepbystep.asia/2024/AFLplusplus%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E2%80%94%E2%80%94%E5%90%8C%E6%AD%A5%E6%9C%BA%E5%88%B6/sync_fuzzers%E6%BA%90%E7%A0%81.png">
     
diff --git "a/2024/AFLplusplus\346\272\220\347\240\201\345\210\206\346\236\220\342\200\224\342\200\224\350\246\206\347\233\226\347\216\207/index.html" "b/2024/AFLplusplus\346\272\220\347\240\201\345\210\206\346\236\220\342\200\224\342\200\224\350\246\206\347\233\226\347\216\207/index.html"
index c0ab6fe..0f55347 100644
--- "a/2024/AFLplusplus\346\272\220\347\240\201\345\210\206\346\236\220\342\200\224\342\200\224\350\246\206\347\233\226\347\216\207/index.html"
+++ "b/2024/AFLplusplus\346\272\220\347\240\201\345\210\206\346\236\220\342\200\224\342\200\224\350\246\206\347\233\226\347\216\207/index.html"
@@ -14,7 +14,7 @@
     
     
     
-    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg"},"articleBody":"\n\n前文 AFL++ 同步机制 提到，执行同步函数 sync_fuzzers 会调用函数 save_if_interesting。顾名思义，这个save_if_interesting 函数是用来保存 interesting 的 corpus。\nAFL++ 认为 corpus 是否 interesting，是基于 corpus 对 binary 的代码覆盖率来判断。在分析 save_if_interesting 的源码之前，有必要了解一下 AFL++ 的覆盖率统计机制。\n一、原理简介  在AFL++ 白皮书  中，对覆盖率的计算有简要说明。\n首先，通过插桩，来跟踪 corpus 在 binary 中走过的路径，并将路径转换为一系列 (branch_src, branch_dst) 元组的集合。例如：\n12corpus 1: A -&gt; B -&gt; C -&gt; D -&gt; E  =&gt;  (AB, BC, CD, DE)corpus 2: A -&gt; B -&gt; D -&gt; C -&gt; E  =&gt;  (AB, BD, DC, CE)\n\n其次，通过一个共享数组 shared_mem 来记录 (branch_src, branch_dst) 元组（可以看作是 CFG 中的 edge 的表示）被命中的次数，伪代码为：\n123cur_location = &lt;COMPILE_TIME_RANDOM&gt;;shared_mem[cur_location ^ prev_location]++; prev_location = cur_location &gt;&gt; 1;\n当 corpus 从 branch_src 走到 branch_dst 时，将 branch_dst 与branch_src进行异或运算的结果作为 shared_mem 的索引，并给索引指向的元素进行加一操作，表示多命中一次(branch_src, branch_dst)。\n值得注意的是最后一行的右移操作。当从 branch_dst 开始找下一个 edge 时，并没有直接把 cur_location 赋值给 pre_location，而是先对cur_location 进行了一次右移操作，再赋值给pre_location。这样处理的好处有两个：\n\n区分 AB 和 BA。如果没有进行右移，那么 A^B 算出的索引，和 B^A 算出的索引，二者是相等的，也就是把 AB 和 BA 看做是同一个 edge。实际上 CFG 中 edge 都是有向边，方向性是一个很重要的信息。\n区分 AA 和 BB。在循环体中，如果 prev_location 与cur_location相等，那么 cur_location^prev_location 的结果将恒等于 0。导致循环体执行不同的 basic block 时，在 shared_mem 中无法得到有效区分。\n\n这种统计方式也是有一定局限性的，例如：\n123corpus 1: A -&gt; B -&gt; C -&gt; D -&gt; E  =&gt;  (AB, BC, CD, DE)corpus 2: A -&gt; B -&gt; C -&gt; A -&gt; E  =&gt;  (AB, BC, CA, AE)corpus 3: A -&gt; B -&gt; C -&gt; A -&gt; B -&gt; C -&gt; A -&gt; B -&gt; C -&gt; D -&gt; E  =&gt;  (AB, BC, CD, DE)\ncorpus 2 与 corpus 1 相比，增加了新的 edge 元组 CA 和 AE。因此 AFL++ 认为 corpus 2 找到一条新的路径。corpus 3 与 corpus 1 相比，没有增加新的 edge 元组。即使 corpus 3 的真实路径与 corpus 1 的真实路径有明显区别，但在 AFL++ 看来，corpus 3 并没有找到一条新路径。\nAFL++ 在判断一个 corpus 是否 interesting 时，除了考虑 corpus 有没有找到新路径（命中新 edge），也会考虑 edge 的命中次数。为了简化命中次数的比较，AFL++ 对次数进行分桶处理，将命中次数分为如下 8 个桶（以 2 的幂次来分割）。当 corpus 使得 edge 的命中次数从一个桶变到另一个桶时，它也会被认为是 interesting。\n11, 2, 3, 4-7, 8-15, 16-31, 32-127, 128+\n此处有个疑问：3 作为单独一个桶有点乱入的感觉，为什么不是 2-3 作为一个桶，且为什么没有 0 这个桶呢？\n总结一下，AFL++ 认为一个 corpus 是 interesting，当且仅当 corpus 至少满足以下条件之一：\n\ncorpus 找到了一个新的 edge。\ncorpus 使某个 edge 的命中次数从一个 bucket 转移到另一个 bucket。\n\n二、源码分析 1. save_if_interestingsave_if_interesting 函数位于afl-fuzz-bitmap.c，其签名为：\n1u8 save_if_interesting(afl_state_t *afl, void *mem, u32 len, u8 fault);\n\n在 sync_fuzzers 中调用 save_if_interesting 的代码如下：\n123456789101112131415161718192021222324if (st.st_size &amp;&amp; st.st_size &lt;= MAX_FILE) &#123;    u8  fault;    u8 *mem = mmap(0, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);        if (mem == MAP_FAILED) &#123; PFATAL(&quot;Unable to mmap &#x27;%s&#x27;&quot;, path); &#125;        /* See what happens. We rely on save_if_interesting() to catch major       errors and save the test case. */        u32 new_len = write_to_testcase(afl, (void **)&amp;mem, st.st_size, 1);        fault = fuzz_run_target(afl, &amp;afl-&gt;fsrv, afl-&gt;fsrv.exec_tmout);        if (afl-&gt;stop_soon) &#123; goto close_sync; &#125;        afl-&gt;syncing_party = sd_ent-&gt;d_name;    afl-&gt;queued_imported += save_if_interesting(afl, mem, new_len, fault);    show_stats(afl);    afl-&gt;syncing_party = 0;        munmap(mem, st.st_size);&#125;\n\n可以看到 save_if_interesting 函数的入参分别为：\n1234afl: AFL++ 的全局状态mem: corpus 的内容len: corpus 的长度fault: fuzz_run_target 的执行结果，0 表示正常结束，1 表示运行超时，2 表示出现 crash\n\n在 save_if_interesting 函数体内，主要执行了如下流程：\nsequenceDiagram\n    save_if_interesting ->> has_new_bits: 检查 corpus 是否能更新 bitmap\n    has_new_bits ->> discover_word: 检查 bitmap 是否有变化\n    discover_word -->> has_new_bits: 返回检查结果\n    has_new_bits -->> save_if_interesting: 返回 0 表示无变化，返回 1 表示命中次数的 bucket 有变化，返回 2 表示找到了一个新 edge\n    save_if_interesting ->> describe_op: 创建 corpus 文件名\n    describe_op -->> save_if_interesting: 返回 corpus 文件名\n    save_if_interesting ->> ck_write: 将 corpus 保存为文件\n    save_if_interesting ->> add_to_queue: 将 corpus 添加到 AFL++ 的队列中\n\n2. has_new_bits负责检查整个 bitmap 是否有变化的是 has_new_bits 函数，其代码为：\n123456789101112131415161718192021222324252627282930313233343536373839404142/* Check if the current execution path brings anything new to the table.   Update virgin bits to reflect the finds. Returns 1 if the only change is   the hit-count for a particular tuple; 2 if there are new tuples seen.   Updates the map, so subsequent calls will always return 0.   This function is called after every exec() on a fairly large buffer, so   it needs to be fast. We do this in 32-bit and 64-bit flavors. */inline u8 has_new_bits(afl_state_t *afl, u8 *virgin_map) &#123;#ifdef WORD_SIZE_64  u64 *current = (u64 *)afl-&gt;fsrv.trace_bits;  u64 *virgin = (u64 *)virgin_map;  u32 i = ((afl-&gt;fsrv.real_map_size + 7) &gt;&gt; 3);#else  u32 *current = (u32 *)afl-&gt;fsrv.trace_bits;  u32 *virgin = (u32 *)virgin_map;  u32 i = ((afl-&gt;fsrv.real_map_size + 3) &gt;&gt; 2);#endif                                                     /* ^WORD_SIZE_64 */  u8 ret = 0;  while (i--) &#123;    if (unlikely(*current)) discover_word(&amp;ret, current, virgin);    current++;    virgin++;  &#125;  if (unlikely(ret) &amp;&amp; likely(virgin_map == afl-&gt;virgin_bits))    afl-&gt;bitmap_changed = 1;  return ret;&#125;\n首先在宏定义中，计算整个 binary 的 bitmap 的长度i（可以理解为 edge 的个数）。\n然后在 while 循环中，依次循环每个 edge，调用 discover_word 函数来完成实际比对操作。\ncurrent和 virgin 分别表示当前 corpus 覆盖路径对应的 bitmap，以及整个 AFL++ 已走过的路径所对应的 bitmap。\n需要理解它们的数据结构，current和 virgin 是长度相等的一维数组，每个元素的有效数据是一个字节，即 8 个 bits 构成的 bit 数组，在 64 位和 32 位系统中，分别用 u64 指针和 u32 指针来指示。\n在第一部分介绍 AFL++ 统计覆盖率的原理时有讲，AFL++ 讲每个 edge 的命中频次进行分桶处理，分成了 8 个桶，每个桶实际上是以一个 bit 位来表示。\n在 AFL++ 初始化 virgin 时，将所有的 bit 位都设为 1，因此 1 表示没有落在这个桶，0 表示落在这个桶。但在 current 中，bit 为 1 表示落在这个桶，0 表示没有落在这个桶。需要注意 bit 为 1 的含义相反！\n以 virgin 为例，若virgin[12345]=0b10110110，表示 AFL++ 产生的所有 corpus 在 12345 这个 edge 上，有命中 2 次、8-15 次、128+ 次三种情况。\n3. discover_word具体完成某个 edge 的 bitmap 对比的是 discover_word 函数，其代码为：\n123456789101112131415161718192021222324252627282930313233/* Updates the virgin bits, then reflects whether a new count or a new tuple is * seen in ret. */inline void discover_word(u8 *ret, u64 *current, u64 *virgin) &#123;  /* Optimize for (*current &amp; *virgin) == 0 - i.e., no bits in current bitmap     that have not been already cleared from the virgin map - since this will     almost always be the case. */  if (*current &amp; *virgin) &#123;    if (likely(*ret &lt; 2)) &#123;      u8 *cur = (u8 *)current;      u8 *vir = (u8 *)virgin;      /* Looks like we have not found any new bytes yet; see if any non-zero         bytes in current[] are pristine in virgin[]. */      if ((cur[0] &amp;&amp; vir[0] == 0xff) || (cur[1] &amp;&amp; vir[1] == 0xff) ||          (cur[2] &amp;&amp; vir[2] == 0xff) || (cur[3] &amp;&amp; vir[3] == 0xff) ||          (cur[4] &amp;&amp; vir[4] == 0xff) || (cur[5] &amp;&amp; vir[5] == 0xff) ||          (cur[6] &amp;&amp; vir[6] == 0xff) || (cur[7] &amp;&amp; vir[7] == 0xff))        *ret = 2;      else        *ret = 1;    &#125;    *virgin &amp;= ~*current;  &#125;&#125;\n首先，计算 *current &amp; *virgin，即将current 指向的 8 个 bits 与 virgin 指向的 8 个 bits 进行按位与运算。\n前面说到 bit=1 在current与 virgin 中的含义是相反的，那么 current 与virgin按位与的结果为 1，说明至少有一个桶，virgin是没到过的，而 current 到了。\n接着，判断 likely(*ret &lt; 2)，在 AFL++ 看来*ret &lt; 2 是一个很可能出现的情况，current找到一个新的 edge，才会将设置*ret=2。\n判断 current 是否找到一个新的 edge，是通过依次比较 (cur[k] &amp;&amp; vir[k] == 0xff), k=0...7 来实现的。vir[k]==0xff表示所有桶的 bit 位为 1，即这个 edge 从来没到过。而 cur[k]==1 表示当前 corpus 到了这个 edge，从而认为 corpus 找到了新 edge。\n此处有个疑问：k 从 0 到 7 要怎么理解？从代码来看，current 和 virgin 的每个元素用 64 个 bit 来存储，分 8 次读取，某一次读取的 8 个 bit 是全为 1 就可以。那为什么不直接用 8 个 bit 来存储？\n4. describe_op在 AFL++ 获得一个 interesting 的 corpus 之后，会将其保存为文件。在保存之前，通过 describe_op 函数来生成文件名，在文件名中记录一些关键信息：\n1234567id: 记录 corpus 的 id 编号sync: 从哪个目录同步过来src: 从哪个 corpus 演化而来，记录来源 corpus 的 idtime: AFL++ 的运行时间execs: AFL++ 的运行次数+cov: 当前 corpus 找到了新 edge，即 has_new_bits 返回 2+tout: 当前 corpus 运行超时\n\n三、参考资料\nAFL 源码阅读（六）：队列、变异、同步\nAFL++ 白皮书和源码阅读\n","dateCreated":"2024-08-15T17:28:52+08:00","dateModified":"2024-09-13T15:11:29+08:00","datePublished":"2024-08-15T17:28:52+08:00","description":"分析 AFL++ 度量覆盖率的相关代码","headline":"AFL++ 源码分析——覆盖率","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2024/AFLplusplus%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E2%80%94%E2%80%94%E8%A6%86%E7%9B%96%E7%8E%87/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://www.stepbystep.asia/2024/AFLplusplus%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E2%80%94%E2%80%94%E8%A6%86%E7%9B%96%E7%8E%87/","keywords":"AFL++, Fuzz, 安全, 工具"}</script>
+    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg"},"articleBody":"\n\n前文 AFL++ 同步机制 提到，执行同步函数 sync_fuzzers 会调用函数 save_if_interesting。顾名思义，这个save_if_interesting 函数是用来保存 interesting 的 corpus。\nAFL++ 认为 corpus 是否 interesting，是基于 corpus 对 binary 的代码覆盖率来判断。在分析 save_if_interesting 的源码之前，有必要了解一下 AFL++ 的覆盖率统计机制。\n一、原理简介  在AFL++ 白皮书  中，对覆盖率的计算有简要说明。\n首先，通过插桩，来跟踪 corpus 在 binary 中走过的路径，并将路径转换为一系列 (branch_src, branch_dst) 元组的集合。例如：\n12corpus 1: A -&gt; B -&gt; C -&gt; D -&gt; E  =&gt;  (AB, BC, CD, DE)corpus 2: A -&gt; B -&gt; D -&gt; C -&gt; E  =&gt;  (AB, BD, DC, CE)\n\n其次，通过一个共享数组 shared_mem 来记录 (branch_src, branch_dst) 元组（可以看作是 CFG 中的 edge 的表示）被命中的次数，伪代码为：\n123cur_location = &lt;COMPILE_TIME_RANDOM&gt;;shared_mem[cur_location ^ prev_location]++; prev_location = cur_location &gt;&gt; 1;\n当 corpus 从 branch_src 走到 branch_dst 时，将 branch_dst 与branch_src进行异或运算的结果作为 shared_mem 的索引，并给索引指向的元素进行加一操作，表示多命中一次(branch_src, branch_dst)。\n值得注意的是最后一行的右移操作。当从 branch_dst 开始找下一个 edge 时，并没有直接把 cur_location 赋值给 pre_location，而是先对cur_location 进行了一次右移操作，再赋值给pre_location。这样处理的好处有两个：\n\n区分 AB 和 BA。如果没有进行右移，那么 A^B 算出的索引，和 B^A 算出的索引，二者是相等的，也就是把 AB 和 BA 看做是同一个 edge。实际上 CFG 中 edge 都是有向边，方向性是一个很重要的信息。\n区分 AA 和 BB。在循环体中，如果 prev_location 与cur_location相等，那么 cur_location^prev_location 的结果将恒等于 0。导致循环体执行不同的 basic block 时，在 shared_mem 中无法得到有效区分。\n\n这种统计方式也是有一定局限性的，例如：\n123corpus 1: A -&gt; B -&gt; C -&gt; D -&gt; E  =&gt;  (AB, BC, CD, DE)corpus 2: A -&gt; B -&gt; C -&gt; A -&gt; E  =&gt;  (AB, BC, CA, AE)corpus 3: A -&gt; B -&gt; C -&gt; A -&gt; B -&gt; C -&gt; A -&gt; B -&gt; C -&gt; D -&gt; E  =&gt;  (AB, BC, CD, DE)\ncorpus 2 与 corpus 1 相比，增加了新的 edge 元组 CA 和 AE。因此 AFL++ 认为 corpus 2 找到一条新的路径。corpus 3 与 corpus 1 相比，没有增加新的 edge 元组。即使 corpus 3 的真实路径与 corpus 1 的真实路径有明显区别，但在 AFL++ 看来，corpus 3 并没有找到一条新路径。\nAFL++ 在判断一个 corpus 是否 interesting 时，除了考虑 corpus 有没有找到新路径（命中新 edge），也会考虑 edge 的命中次数。为了简化命中次数的比较，AFL++ 对次数进行分桶处理，将命中次数分为如下 8 个桶（以 2 的幂次来分割）。当 corpus 使得 edge 的命中次数从一个桶变到另一个桶时，它也会被认为是 interesting。\n11, 2, 3, 4-7, 8-15, 16-31, 32-127, 128+\n此处有个疑问：3 作为单独一个桶有点乱入的感觉，为什么不是 2-3 作为一个桶，且为什么没有 0 这个桶呢？\n总结一下，AFL++ 认为一个 corpus 是 interesting，当且仅当 corpus 至少满足以下条件之一：\n\ncorpus 找到了一个新的 edge。\ncorpus 使某个 edge 的命中次数从一个 bucket 转移到另一个 bucket。\n\n二、源码分析 1. save_if_interestingsave_if_interesting 函数位于afl-fuzz-bitmap.c，其签名为：\n1u8 save_if_interesting(afl_state_t *afl, void *mem, u32 len, u8 fault);\n\n在 sync_fuzzers 中调用 save_if_interesting 的代码如下：\n123456789101112131415161718192021222324if (st.st_size &amp;&amp; st.st_size &lt;= MAX_FILE) &#123;    u8  fault;    u8 *mem = mmap(0, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);        if (mem == MAP_FAILED) &#123; PFATAL(&quot;Unable to mmap &#x27;%s&#x27;&quot;, path); &#125;        /* See what happens. We rely on save_if_interesting() to catch major       errors and save the test case. */        u32 new_len = write_to_testcase(afl, (void **)&amp;mem, st.st_size, 1);        fault = fuzz_run_target(afl, &amp;afl-&gt;fsrv, afl-&gt;fsrv.exec_tmout);        if (afl-&gt;stop_soon) &#123; goto close_sync; &#125;        afl-&gt;syncing_party = sd_ent-&gt;d_name;    afl-&gt;queued_imported += save_if_interesting(afl, mem, new_len, fault);    show_stats(afl);    afl-&gt;syncing_party = 0;        munmap(mem, st.st_size);&#125;\n\n可以看到 save_if_interesting 函数的入参分别为：\n1234afl: AFL++ 的全局状态mem: corpus 的内容len: corpus 的长度fault: fuzz_run_target 的执行结果，0 表示正常结束，1 表示运行超时，2 表示出现 crash\n\n在 save_if_interesting 函数体内，主要执行了如下流程：\nsequenceDiagram\n    save_if_interesting ->> has_new_bits: 检查 corpus 是否能更新 bitmap\n    has_new_bits ->> discover_word: 检查 bitmap 是否有变化\n    discover_word -->> has_new_bits: 返回检查结果\n    has_new_bits -->> save_if_interesting: 返回 0 表示无变化，返回 1 表示命中次数的 bucket 有变化，返回 2 表示找到了一个新 edge\n    save_if_interesting ->> describe_op: 创建 corpus 文件名\n    describe_op -->> save_if_interesting: 返回 corpus 文件名\n    save_if_interesting ->> ck_write: 将 corpus 保存为文件\n    save_if_interesting ->> add_to_queue: 将 corpus 添加到 AFL++ 的队列中\n\n2. has_new_bits负责检查整个 bitmap 是否有变化的是 has_new_bits 函数，其代码为：\n123456789101112131415161718192021222324252627282930313233343536373839404142/* Check if the current execution path brings anything new to the table.   Update virgin bits to reflect the finds. Returns 1 if the only change is   the hit-count for a particular tuple; 2 if there are new tuples seen.   Updates the map, so subsequent calls will always return 0.   This function is called after every exec() on a fairly large buffer, so   it needs to be fast. We do this in 32-bit and 64-bit flavors. */inline u8 has_new_bits(afl_state_t *afl, u8 *virgin_map) &#123;#ifdef WORD_SIZE_64  u64 *current = (u64 *)afl-&gt;fsrv.trace_bits;  u64 *virgin = (u64 *)virgin_map;  u32 i = ((afl-&gt;fsrv.real_map_size + 7) &gt;&gt; 3);#else  u32 *current = (u32 *)afl-&gt;fsrv.trace_bits;  u32 *virgin = (u32 *)virgin_map;  u32 i = ((afl-&gt;fsrv.real_map_size + 3) &gt;&gt; 2);#endif                                                     /* ^WORD_SIZE_64 */  u8 ret = 0;  while (i--) &#123;    if (unlikely(*current)) discover_word(&amp;ret, current, virgin);    current++;    virgin++;  &#125;  if (unlikely(ret) &amp;&amp; likely(virgin_map == afl-&gt;virgin_bits))    afl-&gt;bitmap_changed = 1;  return ret;&#125;\n首先在宏定义中，计算整个 binary 的 bitmap 的长度i（可以理解为 edge 的个数）。\n然后在 while 循环中，依次循环每个 edge，调用 discover_word 函数来完成实际比对操作。\ncurrent和 virgin 分别表示当前 corpus 覆盖路径对应的 bitmap，以及整个 AFL++ 已走过的路径所对应的 bitmap。\n需要理解它们的数据结构，current和 virgin 是长度相等的一维数组，每个元素的有效数据是一个字节，即 8 个 bits 构成的 bit 数组，在 64 位和 32 位系统中，分别用 u64 指针和 u32 指针来指示。\n在第一部分介绍 AFL++ 统计覆盖率的原理时有讲，AFL++ 讲每个 edge 的命中频次进行分桶处理，分成了 8 个桶，每个桶实际上是以一个 bit 位来表示。\n在 AFL++ 初始化 virgin 时，将所有的 bit 位都设为 1，因此 1 表示没有落在这个桶，0 表示落在这个桶。但在 current 中，bit 为 1 表示落在这个桶，0 表示没有落在这个桶。需要注意 bit 为 1 的含义相反！\n以 virgin 为例，若virgin[12345]=0b10110110，表示 AFL++ 产生的所有 corpus 在 12345 这个 edge 上，有命中 2 次、8-15 次、128+ 次三种情况。\n3. discover_word具体完成某个 edge 的 bitmap 对比的是 discover_word 函数，其代码为：\n123456789101112131415161718192021222324252627282930313233/* Updates the virgin bits, then reflects whether a new count or a new tuple is * seen in ret. */inline void discover_word(u8 *ret, u64 *current, u64 *virgin) &#123;  /* Optimize for (*current &amp; *virgin) == 0 - i.e., no bits in current bitmap     that have not been already cleared from the virgin map - since this will     almost always be the case. */  if (*current &amp; *virgin) &#123;    if (likely(*ret &lt; 2)) &#123;      u8 *cur = (u8 *)current;      u8 *vir = (u8 *)virgin;      /* Looks like we have not found any new bytes yet; see if any non-zero         bytes in current[] are pristine in virgin[]. */      if ((cur[0] &amp;&amp; vir[0] == 0xff) || (cur[1] &amp;&amp; vir[1] == 0xff) ||          (cur[2] &amp;&amp; vir[2] == 0xff) || (cur[3] &amp;&amp; vir[3] == 0xff) ||          (cur[4] &amp;&amp; vir[4] == 0xff) || (cur[5] &amp;&amp; vir[5] == 0xff) ||          (cur[6] &amp;&amp; vir[6] == 0xff) || (cur[7] &amp;&amp; vir[7] == 0xff))        *ret = 2;      else        *ret = 1;    &#125;    *virgin &amp;= ~*current;  &#125;&#125;\n首先，计算 *current &amp; *virgin，即将current 指向的 8 个 bits 与 virgin 指向的 8 个 bits 进行按位与运算。\n前面说到 bit=1 在current与 virgin 中的含义是相反的，那么 current 与virgin按位与的结果为 1，说明至少有一个桶，virgin是没到过的，而 current 到了。\n接着，判断 likely(*ret &lt; 2)，在 AFL++ 看来*ret &lt; 2 是一个很可能出现的情况，current找到一个新的 edge，才会将设置*ret=2。\n判断 current 是否找到一个新的 edge，是通过依次比较 (cur[k] &amp;&amp; vir[k] == 0xff), k=0...7 来实现的。vir[k]==0xff表示所有桶的 bit 位为 1，即这个 edge 从来没到过。而 cur[k]==1 表示当前 corpus 到了这个 edge，从而认为 corpus 找到了新 edge。\n此处有个疑问：k 从 0 到 7 要怎么理解？从代码来看，current 和 virgin 的每个元素用 64 个 bit 来存储，分 8 次读取，某一次读取的 8 个 bit 是全为 1 就可以。那为什么不直接用 8 个 bit 来存储？\n4. describe_op在 AFL++ 获得一个 interesting 的 corpus 之后，会将其保存为文件。在保存之前，通过 describe_op 函数来生成文件名，在文件名中记录一些关键信息：\n1234567id: 记录 corpus 的 id 编号sync: 从哪个目录同步过来src: 从哪个 corpus 演化而来，记录来源 corpus 的 idtime: AFL++ 的运行时间execs: AFL++ 的运行次数+cov: 当前 corpus 找到了新 edge，即 has_new_bits 返回 2+tout: 当前 corpus 运行超时\n\n三、参考资料\nAFL 源码阅读（六）：队列、变异、同步\nAFL++ 白皮书和源码阅读\n","dateCreated":"2024-08-15T17:28:52+08:00","dateModified":"2024-09-13T15:11:29+08:00","datePublished":"2024-08-15T17:28:52+08:00","description":"分析 AFL++ 度量覆盖率的相关代码","headline":"AFL++ 源码分析——覆盖率","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2024/AFLplusplus%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E2%80%94%E2%80%94%E8%A6%86%E7%9B%96%E7%8E%87/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://www.stepbystep.asia/2024/AFLplusplus%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E2%80%94%E2%80%94%E8%A6%86%E7%9B%96%E7%8E%87/","keywords":"安全, 工具, Fuzz, AFL++"}</script>
     <meta name="description" content="分析 AFL++ 度量覆盖率的相关代码">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="AFL++ 源码分析——覆盖率">
@@ -25,10 +25,10 @@
 <meta property="article:published_time" content="2024-08-15T09:28:52.000Z">
 <meta property="article:modified_time" content="2024-09-13T07:11:29.738Z">
 <meta property="article:author" content="一瓢清浅">
-<meta property="article:tag" content="AFL++">
-<meta property="article:tag" content="Fuzz">
 <meta property="article:tag" content="安全">
 <meta property="article:tag" content="工具">
+<meta property="article:tag" content="Fuzz">
+<meta property="article:tag" content="AFL++">
 <meta name="twitter:card" content="summary">
     
     
@@ -341,7 +341,7 @@ <h2 id="三、参考资料"><a href="# 三、参考资料" class="headerlink" ti
             <li class="post-action">
                 
                     
-                <a class="post-action-btn btn btn--default tooltip--top" href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/" data-tooltip="ClusterFuzz 源码分析（一）" aria-label="上一篇: ClusterFuzz 源码分析（一）">
+                <a class="post-action-btn btn btn--default tooltip--top" href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/" data-tooltip="ClusterFuzz 源码分析（一）" aria-label="上一篇: ClusterFuzz 源码分析（一）">
                     
                         <i class="fa fa-angle-left" aria-hidden="true"></i>
                         <span class="hide-xs hide-sm text-small icon-ml">上一篇</span>
@@ -404,7 +404,7 @@ <h2 id="三、参考资料"><a href="# 三、参考资料" class="headerlink" ti
             <li class="post-action">
                 
                     
-                <a class="post-action-btn btn btn--default tooltip--top" href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/" data-tooltip="ClusterFuzz 源码分析（一）" aria-label="上一篇: ClusterFuzz 源码分析（一）">
+                <a class="post-action-btn btn btn--default tooltip--top" href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/" data-tooltip="ClusterFuzz 源码分析（一）" aria-label="上一篇: ClusterFuzz 源码分析（一）">
                     
                         <i class="fa fa-angle-left" aria-hidden="true"></i>
                         <span class="hide-xs hide-sm text-small icon-ml">上一篇</span>
diff --git "a/2024/Angr\351\233\266\345\237\272\347\241\200\345\205\245\351\227\250/index.html" "b/2024/Angr\351\233\266\345\237\272\347\241\200\345\205\245\351\227\250/index.html"
index 613a02c..27014cc 100644
--- "a/2024/Angr\351\233\266\345\237\272\347\241\200\345\205\245\351\227\250/index.html"
+++ "b/2024/Angr\351\233\266\345\237\272\347\241\200\345\205\245\351\227\250/index.html"
@@ -14,7 +14,7 @@
     
     
     
-    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg"},"articleBody":"\n\n一、Angr 简介Angr 是一个由 Python 语言编写的开源二进制分析框架，它主要用于静态分析、符号执行、逆向工程等安全研究领域。Angr 支持多种操作系统和硬件架构，包括 Windows、Linux、macOS 以及 x86、ARM 等。\n二、Angr 整体架构1、核心组件Angr 是一个复杂的二进制分析框架，其初始的整体架构设计如下图：\n\n\nAngr 的核心组件自下而上依次为：\n\nCLE：加载可执行文件和库文件\n\narchinfo：获取架构信息\n\nPyVEX：将指令转换成 VEX 这种中间语言（IR）\n\nSimuVEX：模拟执行引擎，负责在虚拟环境中执行 VEX\n\nClaripy：用于创建和管理符号变量及条件约束，传递给 Z3 求解器进行求解\n\nAngr：将各个组件集成起来，提供一套整体的二进制分析和符号执行框架\n\nanalysis：提供一套分析工具，通过 CFG、DDG 等对程序进行分析\n\nsurveyors：用于记录和跟踪程序的可执行路径\n\n\n随着 Angr 的发展，部分组件有更新和迭代：\n\nSimuVEX 被移除，其组件已集成到 Angr 中\n\nsurveyors 被移除，被 SimulationManager 所取代\n\n\n2、运作流程Angr 的整体运作流程如图：\n\n\n使用 Angr 进行二进制分析时，各组件的运行步骤为：\n\nCLE 加载二进制，获取机器指令\n\nArchinfo 分析二进制的架构类型\n\nPyVEX 根据架构类型，将机器指令转换为 VEX 中间表达\n\nSimEngine 基于 VEX 来模拟程序执行\n\nClarify 创建和管理执行过程中的符号变量和约束条件，转化为 SMT 表达式，传递给 Z3 求解\n\nSimOS（SimProcedures） 模拟程序与系统的交互，如标准 io 流、文件读写、系统调用等操作\n\n\n三、Angr 使用说明1. 安装Angr 需要 python 3.8 以上的运行环境，需要先装 3.8 版本以上的 python。\n安装 Angr 有两种推荐方式：\n\npip 安装\n1pip install Angr\n\n源码安装\n123git clone https://github.com/Angr/Angr-dev.gitcd Angr-dev./setup.sh -i -e Angr\n\n2. 运行  建议在虚拟环境中运行 Angr。源码安装的方式可以自动创建名为 Angr 的虚拟环境。手动创建虚拟环境的命令为：\n1python3 -m venv Angr\n\n启动虚拟环境：\n1source Angr/bin/active\n\n3. 使用Angr 作为 python 的三方库，通过 import 进行调用：\n1import Angr\n\nAngr 的顶层 API 围绕着 Angr 的核心组件来设计，包含一组常用的 Python 类和对象，它们提供了二进制分析、符号执行和其他功能。\n以下是 Angr 的一些常用 API 组件：\n\nProject（项目）：\n\nProject是 Angr 的中心组件，它代表了用户所要处理的二进制文件。\n创建一个 Project 实例是使用 Angr 进行分析的第一步，Project对象提供了对二进制文件的操作和分析的接口。\n\n\nFactory（工厂）：\n\nFactory对象通过 Project 的factory属性来访问，它提供了快速访问 Angr 的各种分析技术的接口，避免复杂的实例化操作。\n\n\nSimState（模拟状态）：\n\nSimState代表程序的一个瞬时状态，它包含寄存器、内存、堆栈、文件系统等运行时的上下文环境状态，可用于执行符号执行和具体执行。\nSimState对象通过 Project 的factory属性的方法来访问，这些方法包括 entry_state、blank_state、full_init_state 等。\n\n\nSimulationManager（模拟管理器）：\n\nSimulationManager用来跟踪程序执行过程中的路径探索和 SimState 演化，并对这些路径和 SimState 进行管理。\nSimulationManager对象通过 Project 的factory属性的 simulation_manager 方法实例化。\n\n\nLoader（加载器）：\n\nLoader负责将二进制文件载入内存，并处理符号以及它们的地址空间，为后续分析提供详细信息，如入口点、可执行段、符号表等。\nLoader对象通过 Project 的loader属性的方法来访问。\n\n\nBlock（块）：\n\nBlock表示程序基本块，是 Angr 分析的基本单位。每个 Block 是一组顺序执行代码片段，具有原子性，以分支或跳转结尾。\nBlock对象通过 Project 的factory属性的 block 方法实例化。\n\n\n\n四、Angr 实践应用example.c 源码：\n12345678910111213141516171819202122232425262728293031323334#include &lt;stdio.h&gt;#include &lt;string.h&gt;#include &lt;stdint.h&gt;#include &lt;assert.h&gt;#define MAX_LEN 100int calculate(int number)&#123;    return number * number;&#125;int main()&#123;    char input[MAX_LEN];    printf(&quot;Enter the string: &quot;);    fgets(input, MAX_LEN, stdin);    int len = strlen(input);    int num = 0;    for(int i = 0; i &lt; len; i++) &#123;        if(input[i] &gt;= &#x27;0&#x27; &amp;&amp; input[i] &lt;= &#x27;9&#x27;)&#123;            num = num * 10 + (input[i] - &#x27;0&#x27;);        &#125;    &#125;    int res = calculate(num);    assert(res != 65536);    return 0;&#125;\n\n将 example.c 编译为 example_binary ：\n1gcc example.c -o example_binary\n\n以 example_binary 为例，演示 Angr 用法。\n1. 静态程序分析  首先用 Angr 定位程序入口：\n12345678910111213&gt;&gt;&gt; import angr&gt;&gt;&gt; project = angr.Project(&#x27;example_binary&#x27;, load_options=&#123;&#x27;auto_load_libs&#x27;: False&#125;)&gt;&gt;&gt; project.filename&#x27;example_binary&#x27;&gt;&gt;&gt; project.arch&lt;Arch AMD64 (LE)&gt;&gt;&gt;&gt; project.entry4198624&gt;&gt;&gt; bb = project.factory.block(4198624)&gt;&gt;&gt; bb.instructions12&gt;&gt;&gt; hex(bb.addr)&#x27;0x4010e0&#x27;\n\n这个 0x4010e0 地址对应的是程序的入口 block ，包括 12 条指令，在 CFG 中表示为如下节点，可以看到 block 的名字并不是 main，而是 _start ：\n\n\n接着从 _start 开始执行，执行一次后到达 ___libc_start_main ，然而再执行一次后并没有到达 main ：\n123456789101112&gt;&gt;&gt; st_0 = project.factory.entry_state()&gt;&gt;&gt; hex(st_0.addr)&#x27;0x4010e0&#x27;&gt;&gt;&gt; nx  = st_0.step()&gt;&gt;&gt; nx.successors[&lt;SimState @ 0x500000&gt;]&gt;&gt;&gt; st_1 = nx.successors[0]&gt;&gt;&gt; hex(st_1.addr)&#x27;0x500000&#x27;&gt;&gt;&gt; nx = st_1.step()&gt;&gt;&gt; nx.successors[&lt;SimState @ 0x4012e0&gt;]\n\n为了获取 main 这个 block 的状态，可以使用 SimulationManager 来执行：\n12345678&gt;&gt;&gt; simgr = project.factory.simulation_manager(st_0)&gt;&gt;&gt; main_obj = project.loader.main_object.get_symbol(&#x27;main&#x27;)&gt;&gt;&gt; hex(main_obj.rebased_addr)&#x27;0x4011dc&#x27;&gt;&gt;&gt; simgr.explore(find=main_obj.rebased_addr)&lt;SimulationManager with 1 found&gt;&gt;&gt;&gt; simgr.found[&lt;SimState @ 0x4011dc&gt;]\n\n\n\n2. 静态符号执行example_binary 接受一个最长为 100 位的字符串作为输入，提取字符串中的数字，转换成数值，然后进行平方运算，结果等于 65536 时出现断言错误。反推回来，当输入字符串中包含 2、5、6 这三个数字时，就能导致AssertionError。\n要让程序自动找到触发 example_binary 中 AssertionError 的 input，可以用 Angr 符号执行来求解。\n首先引入claripy，创建符号变量：\n1234&gt;&gt;&gt; import claripy&gt;&gt;&gt; input_size = 100&gt;&gt;&gt; symbolic_buffer = claripy.BVS(&#x27;input&#x27;, 8 * (input_size - 1))&gt;&gt;&gt; entry_state = project.factory.entry_state(stdin=claripy.Concat(symbolic_buffer, claripy.BVV(b&#x27;\\n&#x27;)))\n\n通过 CFG 可以找到 AssertionError 的 block 地址为0x4010c0：\n\n\n然后用 SimulationManager 控制程序朝 AssertionError 开始探索：\n1234567891011121314151617181920212223&gt;&gt;&gt; simgr = project.factory.simulation_manager(entry_state)&gt;&gt;&gt; simgr.explore(find=0x4010c0)WARNING  | 2024-03-11 17:27:02,034 | angr.storage.memory_mixins.default_filler_mixin | The program is accessing memory with an unspecified value. This could indicate unwanted behavior.WARNING  | 2024-03-11 17:27:03,808 | angr.storage.memory_mixins.default_filler_mixin | angr will cope with this by generating an unconstrained symbolic variable and continuing. You can resolve this by:WARNING  | 2024-03-11 17:27:03,808 | angr.storage.memory_mixins.default_filler_mixin | 1) setting a value to the initial stateWARNING  | 2024-03-11 17:27:03,808 | angr.storage.memory_mixins.default_filler_mixin | 2) adding the state option ZERO_FILL_UNCONSTRAINED_&#123;MEMORY,REGISTERS&#125;, to make unknown regions hold nullWARNING  | 2024-03-11 17:27:03,808 | angr.storage.memory_mixins.default_filler_mixin | 3) adding the state option SYMBOL_FILL_UNCONSTRAINED_&#123;MEMORY,REGISTERS&#125;, to suppress these messages.WARNING  | 2024-03-11 17:27:03,994 | angr.storage.memory_mixins.default_filler_mixin | Filling memory at 0x7fffffffffeff70 with 1 unconstrained bytes referenced from 0x500010 (strlen+0x0 in extern-address space (0x10))&lt;SimulationManager with 829 active, 20 deadended, 1 found&gt;&gt;&gt;&gt;&gt;&gt;&gt; simgr.found[&lt;SimState @ 0x4010c0&gt;]&gt;&gt;&gt; found_state = simgr.found[0]&gt;&gt;&gt; found_state&lt;SimState @ 0x4010c0&gt;&gt;&gt;&gt; found_state.solver.eval(symbolic_buffer, cast_to=bytes)b&#x27;256\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x80\\x01\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00@ \\x08\\x08\\x00\\x02\\x00 \\x00\\x00\\x80\\x00\\x00\\x00@\\x00\\x01 \\x02\\x10\\x00\\x01 \\x10\\x00@\\x04\\x80\\x80\\x01\\x80\\x01@\\x02\\x08\\x08\\x04\\x80\\x01@\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00&#x27;&gt;&gt;&gt; len(found_state.solver.eval(symbolic_buffer, cast_to=bytes))99&gt;&gt;&gt; found_state.solver.constraints[&lt;Bool !(input_3_792[791:784] == 10)&gt;, &lt;Bool !(input_3_792[783:776] == 10)&gt;, &lt;Bool !(input_3_792[775:768] == 10)&gt;, &lt;Bool !(input_3_792[767:760] == 10)&gt;, &lt;Bool !(input_3_792[759:752] == 10)&gt;, &lt;Bool !(input_3_792[751:744] == 10)&gt;, &lt;Bool !(input_3_792[743:736] == 10)&gt;, &lt;Bool !(input_3_792[735:728] == 10)&gt;, &lt;Bool !(input_3_792[727:720] == 10)&gt;, &lt;Bool !(input_3_792[719:712] == 10)&gt;, &lt;Bool !(input_3_792[711:704] == 10)&gt;, &lt;Bool !(input_3_792[703:696] == 10)&gt;, &lt;Bool !……\n\n可以看到虽然很慢，但是 Angr 成功地算出了一个可以触发 AssertionError 的输入。计算结果保存在 SimulationManager 的found属性中，每个结果是一个 SimState 实例，通过 SimState 的solver属性可以查看可行解与约束条件。\n五、同类工具\n\n\n特性 \\ 工具\nAngr\nBAP\nTriton\nBinary Ninja\nGhidra\n\n\n\n发布年份\n2015\n2011\n2015\n2016\n2019\n\n\n开发语言\nPython\nOCaml (接口: C&#x2F;Python)\nC++ (接口: Python)\nC++\nJava\n\n\n模块化\n✅\n✅\n❌\n✅\n✅\n\n\n插件系统\n✅\n✅\n❌\n✅\n✅\n\n\n符号执行\n✅\n✅\n✅\n❌\n✅\n\n\n污点分析\n✅\n部分支持\n✅\n✅\n✅\n\n\n动静态分析\n均支持\n主要是静态分析\n主要是动态分析\n主要静态分析\n均支持\n\n\n形式化验证\n有限支持\n✅\n❌\n❌\n通过插件\n\n\n中间表示\nVEX IR\nMicrocode\nTriton IR\nLLIL&#x2F;MLIL&#x2F;HLIL\nP-Code\n\n\n社区活跃度\n高\n中\n低\n高\n高\n\n\n专长领域\n全栈式分析\n可扩展性与形式化验证\n动态分析与污点追踪\n逆向工程\n逆向工程\n\n\n跨平台支持\n广泛\n广泛\n有限\n广泛\n广泛\n\n\n学习曲线\n中等\n较高\n中等\n中等\n中等\n\n\n应用场景\nCTF&#x2F; 漏洞研究 &#x2F; 二进制加固\n安全研究 &#x2F; 形式化验证\n精确污点追踪 &#x2F; 变量跟踪\n逆向工程\n逆向工程\n\n\n开源\n✅\n部分开源\n✅\n社区版开源\n✅\n\n\n六、参考资料\nangr 原理与实践（一）——原理\nangr 官方文档\nangr 系列教程(一）核心概念及模块解读\nAngr 初学笔记\nBinary 自动分析的那些事\n","dateCreated":"2024-01-23T13:45:08+08:00","dateModified":"2024-06-26T16:27:23+08:00","datePublished":"2024-01-23T13:45:08+08:00","description":"Angr 是一款二进制分析和符号执行工具，常用于 CTF 和安全测试领域","headline":"符号执行工具——Angr 零基础入门","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2024/Angr%E9%9B%B6%E5%9F%BA%E7%A1%80%E5%85%A5%E9%97%A8/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://www.stepbystep.asia/2024/Angr%E9%9B%B6%E5%9F%BA%E7%A1%80%E5%85%A5%E9%97%A8/","keywords":"安全, 工具, 符号执行"}</script>
+    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg"},"articleBody":"\n\n一、Angr 简介Angr 是一个由 Python 语言编写的开源二进制分析框架，它主要用于静态分析、符号执行、逆向工程等安全研究领域。Angr 支持多种操作系统和硬件架构，包括 Windows、Linux、macOS 以及 x86、ARM 等。\n二、Angr 整体架构1、核心组件Angr 是一个复杂的二进制分析框架，其初始的整体架构设计如下图：\n\n\nAngr 的核心组件自下而上依次为：\n\nCLE：加载可执行文件和库文件\n\narchinfo：获取架构信息\n\nPyVEX：将指令转换成 VEX 这种中间语言（IR）\n\nSimuVEX：模拟执行引擎，负责在虚拟环境中执行 VEX\n\nClaripy：用于创建和管理符号变量及条件约束，传递给 Z3 求解器进行求解\n\nAngr：将各个组件集成起来，提供一套整体的二进制分析和符号执行框架\n\nanalysis：提供一套分析工具，通过 CFG、DDG 等对程序进行分析\n\nsurveyors：用于记录和跟踪程序的可执行路径\n\n\n随着 Angr 的发展，部分组件有更新和迭代：\n\nSimuVEX 被移除，其组件已集成到 Angr 中\n\nsurveyors 被移除，被 SimulationManager 所取代\n\n\n2、运作流程Angr 的整体运作流程如图：\n\n\n使用 Angr 进行二进制分析时，各组件的运行步骤为：\n\nCLE 加载二进制，获取机器指令\n\nArchinfo 分析二进制的架构类型\n\nPyVEX 根据架构类型，将机器指令转换为 VEX 中间表达\n\nSimEngine 基于 VEX 来模拟程序执行\n\nClarify 创建和管理执行过程中的符号变量和约束条件，转化为 SMT 表达式，传递给 Z3 求解\n\nSimOS（SimProcedures） 模拟程序与系统的交互，如标准 io 流、文件读写、系统调用等操作\n\n\n三、Angr 使用说明1. 安装Angr 需要 python 3.8 以上的运行环境，需要先装 3.8 版本以上的 python。\n安装 Angr 有两种推荐方式：\n\npip 安装\n1pip install Angr\n\n源码安装\n123git clone https://github.com/Angr/Angr-dev.gitcd Angr-dev./setup.sh -i -e Angr\n\n2. 运行  建议在虚拟环境中运行 Angr。源码安装的方式可以自动创建名为 Angr 的虚拟环境。手动创建虚拟环境的命令为：\n1python3 -m venv Angr\n\n启动虚拟环境：\n1source Angr/bin/active\n\n3. 使用Angr 作为 python 的三方库，通过 import 进行调用：\n1import Angr\n\nAngr 的顶层 API 围绕着 Angr 的核心组件来设计，包含一组常用的 Python 类和对象，它们提供了二进制分析、符号执行和其他功能。\n以下是 Angr 的一些常用 API 组件：\n\nProject（项目）：\n\nProject是 Angr 的中心组件，它代表了用户所要处理的二进制文件。\n创建一个 Project 实例是使用 Angr 进行分析的第一步，Project对象提供了对二进制文件的操作和分析的接口。\n\n\nFactory（工厂）：\n\nFactory对象通过 Project 的factory属性来访问，它提供了快速访问 Angr 的各种分析技术的接口，避免复杂的实例化操作。\n\n\nSimState（模拟状态）：\n\nSimState代表程序的一个瞬时状态，它包含寄存器、内存、堆栈、文件系统等运行时的上下文环境状态，可用于执行符号执行和具体执行。\nSimState对象通过 Project 的factory属性的方法来访问，这些方法包括 entry_state、blank_state、full_init_state 等。\n\n\nSimulationManager（模拟管理器）：\n\nSimulationManager用来跟踪程序执行过程中的路径探索和 SimState 演化，并对这些路径和 SimState 进行管理。\nSimulationManager对象通过 Project 的factory属性的 simulation_manager 方法实例化。\n\n\nLoader（加载器）：\n\nLoader负责将二进制文件载入内存，并处理符号以及它们的地址空间，为后续分析提供详细信息，如入口点、可执行段、符号表等。\nLoader对象通过 Project 的loader属性的方法来访问。\n\n\nBlock（块）：\n\nBlock表示程序基本块，是 Angr 分析的基本单位。每个 Block 是一组顺序执行代码片段，具有原子性，以分支或跳转结尾。\nBlock对象通过 Project 的factory属性的 block 方法实例化。\n\n\n\n四、Angr 实践应用example.c 源码：\n12345678910111213141516171819202122232425262728293031323334#include &lt;stdio.h&gt;#include &lt;string.h&gt;#include &lt;stdint.h&gt;#include &lt;assert.h&gt;#define MAX_LEN 100int calculate(int number)&#123;    return number * number;&#125;int main()&#123;    char input[MAX_LEN];    printf(&quot;Enter the string: &quot;);    fgets(input, MAX_LEN, stdin);    int len = strlen(input);    int num = 0;    for(int i = 0; i &lt; len; i++) &#123;        if(input[i] &gt;= &#x27;0&#x27; &amp;&amp; input[i] &lt;= &#x27;9&#x27;)&#123;            num = num * 10 + (input[i] - &#x27;0&#x27;);        &#125;    &#125;    int res = calculate(num);    assert(res != 65536);    return 0;&#125;\n\n将 example.c 编译为 example_binary ：\n1gcc example.c -o example_binary\n\n以 example_binary 为例，演示 Angr 用法。\n1. 静态程序分析  首先用 Angr 定位程序入口：\n12345678910111213&gt;&gt;&gt; import angr&gt;&gt;&gt; project = angr.Project(&#x27;example_binary&#x27;, load_options=&#123;&#x27;auto_load_libs&#x27;: False&#125;)&gt;&gt;&gt; project.filename&#x27;example_binary&#x27;&gt;&gt;&gt; project.arch&lt;Arch AMD64 (LE)&gt;&gt;&gt;&gt; project.entry4198624&gt;&gt;&gt; bb = project.factory.block(4198624)&gt;&gt;&gt; bb.instructions12&gt;&gt;&gt; hex(bb.addr)&#x27;0x4010e0&#x27;\n\n这个 0x4010e0 地址对应的是程序的入口 block ，包括 12 条指令，在 CFG 中表示为如下节点，可以看到 block 的名字并不是 main，而是 _start ：\n\n\n接着从 _start 开始执行，执行一次后到达 ___libc_start_main ，然而再执行一次后并没有到达 main ：\n123456789101112&gt;&gt;&gt; st_0 = project.factory.entry_state()&gt;&gt;&gt; hex(st_0.addr)&#x27;0x4010e0&#x27;&gt;&gt;&gt; nx  = st_0.step()&gt;&gt;&gt; nx.successors[&lt;SimState @ 0x500000&gt;]&gt;&gt;&gt; st_1 = nx.successors[0]&gt;&gt;&gt; hex(st_1.addr)&#x27;0x500000&#x27;&gt;&gt;&gt; nx = st_1.step()&gt;&gt;&gt; nx.successors[&lt;SimState @ 0x4012e0&gt;]\n\n为了获取 main 这个 block 的状态，可以使用 SimulationManager 来执行：\n12345678&gt;&gt;&gt; simgr = project.factory.simulation_manager(st_0)&gt;&gt;&gt; main_obj = project.loader.main_object.get_symbol(&#x27;main&#x27;)&gt;&gt;&gt; hex(main_obj.rebased_addr)&#x27;0x4011dc&#x27;&gt;&gt;&gt; simgr.explore(find=main_obj.rebased_addr)&lt;SimulationManager with 1 found&gt;&gt;&gt;&gt; simgr.found[&lt;SimState @ 0x4011dc&gt;]\n\n\n\n2. 静态符号执行example_binary 接受一个最长为 100 位的字符串作为输入，提取字符串中的数字，转换成数值，然后进行平方运算，结果等于 65536 时出现断言错误。反推回来，当输入字符串中包含 2、5、6 这三个数字时，就能导致AssertionError。\n要让程序自动找到触发 example_binary 中 AssertionError 的 input，可以用 Angr 符号执行来求解。\n首先引入claripy，创建符号变量：\n1234&gt;&gt;&gt; import claripy&gt;&gt;&gt; input_size = 100&gt;&gt;&gt; symbolic_buffer = claripy.BVS(&#x27;input&#x27;, 8 * (input_size - 1))&gt;&gt;&gt; entry_state = project.factory.entry_state(stdin=claripy.Concat(symbolic_buffer, claripy.BVV(b&#x27;\\n&#x27;)))\n\n通过 CFG 可以找到 AssertionError 的 block 地址为0x4010c0：\n\n\n然后用 SimulationManager 控制程序朝 AssertionError 开始探索：\n1234567891011121314151617181920212223&gt;&gt;&gt; simgr = project.factory.simulation_manager(entry_state)&gt;&gt;&gt; simgr.explore(find=0x4010c0)WARNING  | 2024-03-11 17:27:02,034 | angr.storage.memory_mixins.default_filler_mixin | The program is accessing memory with an unspecified value. This could indicate unwanted behavior.WARNING  | 2024-03-11 17:27:03,808 | angr.storage.memory_mixins.default_filler_mixin | angr will cope with this by generating an unconstrained symbolic variable and continuing. You can resolve this by:WARNING  | 2024-03-11 17:27:03,808 | angr.storage.memory_mixins.default_filler_mixin | 1) setting a value to the initial stateWARNING  | 2024-03-11 17:27:03,808 | angr.storage.memory_mixins.default_filler_mixin | 2) adding the state option ZERO_FILL_UNCONSTRAINED_&#123;MEMORY,REGISTERS&#125;, to make unknown regions hold nullWARNING  | 2024-03-11 17:27:03,808 | angr.storage.memory_mixins.default_filler_mixin | 3) adding the state option SYMBOL_FILL_UNCONSTRAINED_&#123;MEMORY,REGISTERS&#125;, to suppress these messages.WARNING  | 2024-03-11 17:27:03,994 | angr.storage.memory_mixins.default_filler_mixin | Filling memory at 0x7fffffffffeff70 with 1 unconstrained bytes referenced from 0x500010 (strlen+0x0 in extern-address space (0x10))&lt;SimulationManager with 829 active, 20 deadended, 1 found&gt;&gt;&gt;&gt;&gt;&gt;&gt; simgr.found[&lt;SimState @ 0x4010c0&gt;]&gt;&gt;&gt; found_state = simgr.found[0]&gt;&gt;&gt; found_state&lt;SimState @ 0x4010c0&gt;&gt;&gt;&gt; found_state.solver.eval(symbolic_buffer, cast_to=bytes)b&#x27;256\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x80\\x01\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00@ \\x08\\x08\\x00\\x02\\x00 \\x00\\x00\\x80\\x00\\x00\\x00@\\x00\\x01 \\x02\\x10\\x00\\x01 \\x10\\x00@\\x04\\x80\\x80\\x01\\x80\\x01@\\x02\\x08\\x08\\x04\\x80\\x01@\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00&#x27;&gt;&gt;&gt; len(found_state.solver.eval(symbolic_buffer, cast_to=bytes))99&gt;&gt;&gt; found_state.solver.constraints[&lt;Bool !(input_3_792[791:784] == 10)&gt;, &lt;Bool !(input_3_792[783:776] == 10)&gt;, &lt;Bool !(input_3_792[775:768] == 10)&gt;, &lt;Bool !(input_3_792[767:760] == 10)&gt;, &lt;Bool !(input_3_792[759:752] == 10)&gt;, &lt;Bool !(input_3_792[751:744] == 10)&gt;, &lt;Bool !(input_3_792[743:736] == 10)&gt;, &lt;Bool !(input_3_792[735:728] == 10)&gt;, &lt;Bool !(input_3_792[727:720] == 10)&gt;, &lt;Bool !(input_3_792[719:712] == 10)&gt;, &lt;Bool !(input_3_792[711:704] == 10)&gt;, &lt;Bool !(input_3_792[703:696] == 10)&gt;, &lt;Bool !……\n\n可以看到虽然很慢，但是 Angr 成功地算出了一个可以触发 AssertionError 的输入。计算结果保存在 SimulationManager 的found属性中，每个结果是一个 SimState 实例，通过 SimState 的solver属性可以查看可行解与约束条件。\n五、同类工具\n\n\n特性 \\ 工具\nAngr\nBAP\nTriton\nBinary Ninja\nGhidra\n\n\n\n发布年份\n2015\n2011\n2015\n2016\n2019\n\n\n开发语言\nPython\nOCaml (接口: C&#x2F;Python)\nC++ (接口: Python)\nC++\nJava\n\n\n模块化\n✅\n✅\n❌\n✅\n✅\n\n\n插件系统\n✅\n✅\n❌\n✅\n✅\n\n\n符号执行\n✅\n✅\n✅\n❌\n✅\n\n\n污点分析\n✅\n部分支持\n✅\n✅\n✅\n\n\n动静态分析\n均支持\n主要是静态分析\n主要是动态分析\n主要静态分析\n均支持\n\n\n形式化验证\n有限支持\n✅\n❌\n❌\n通过插件\n\n\n中间表示\nVEX IR\nMicrocode\nTriton IR\nLLIL&#x2F;MLIL&#x2F;HLIL\nP-Code\n\n\n社区活跃度\n高\n中\n低\n高\n高\n\n\n专长领域\n全栈式分析\n可扩展性与形式化验证\n动态分析与污点追踪\n逆向工程\n逆向工程\n\n\n跨平台支持\n广泛\n广泛\n有限\n广泛\n广泛\n\n\n学习曲线\n中等\n较高\n中等\n中等\n中等\n\n\n应用场景\nCTF&#x2F; 漏洞研究 &#x2F; 二进制加固\n安全研究 &#x2F; 形式化验证\n精确污点追踪 &#x2F; 变量跟踪\n逆向工程\n逆向工程\n\n\n开源\n✅\n部分开源\n✅\n社区版开源\n✅\n\n\n六、参考资料\nangr 原理与实践（一）——原理\nangr 官方文档\nangr 系列教程(一）核心概念及模块解读\nAngr 初学笔记\nBinary 自动分析的那些事\n","dateCreated":"2024-01-23T13:45:08+08:00","dateModified":"2024-06-26T16:27:23+08:00","datePublished":"2024-01-23T13:45:08+08:00","description":"Angr 是一款二进制分析和符号执行工具，常用于 CTF 和安全测试领域","headline":"符号执行工具——Angr 零基础入门","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2024/Angr%E9%9B%B6%E5%9F%BA%E7%A1%80%E5%85%A5%E9%97%A8/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://www.stepbystep.asia/2024/Angr%E9%9B%B6%E5%9F%BA%E7%A1%80%E5%85%A5%E9%97%A8/","keywords":"符号执行, 安全, 工具"}</script>
     <meta name="description" content="Angr 是一款二进制分析和符号执行工具，常用于 CTF 和安全测试领域">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="符号执行工具——Angr 零基础入门">
@@ -29,9 +29,9 @@
 <meta property="article:published_time" content="2024-01-23T05:45:08.000Z">
 <meta property="article:modified_time" content="2024-06-26T08:27:23.656Z">
 <meta property="article:author" content="一瓢清浅">
+<meta property="article:tag" content="符号执行">
 <meta property="article:tag" content="安全">
 <meta property="article:tag" content="工具">
-<meta property="article:tag" content="符号执行">
 <meta name="twitter:card" content="summary">
 <meta name="twitter:image" content="https://www.stepbystep.asia/2024/Angr%E9%9B%B6%E5%9F%BA%E7%A1%80%E5%85%A5%E9%97%A8/Angr%E6%A0%B8%E5%BF%83%E7%BB%84%E4%BB%B6.png">
     
diff --git "a/2024/ClusterFuzz\346\236\266\346\236\204\345\210\206\346\236\220/overview.png" "b/2024/ClusterFuzz\346\236\266\346\236\204\345\210\206\346\236\220/overview.png"
deleted file mode 100644
index 8d1b109..0000000
Binary files "a/2024/ClusterFuzz\346\236\266\346\236\204\345\210\206\346\236\220/overview.png" and /dev/null differ
diff --git "a/2024/ClusterFuzz\346\236\266\346\236\204\345\210\206\346\236\220/task.png" "b/2024/ClusterFuzz\346\236\266\346\236\204\345\210\206\346\236\220/task.png"
deleted file mode 100644
index d23cf1f..0000000
Binary files "a/2024/ClusterFuzz\346\236\266\346\236\204\345\210\206\346\236\220/task.png" and /dev/null differ
diff --git "a/2024/ClusterFuzz\346\236\266\346\236\204\345\210\206\346\236\220/index.html" "b/2024/ClusterFuzz\346\272\220\347\240\201\345\210\206\346\236\220\357\274\210\344\270\200\357\274\211/index.html"
similarity index 96%
rename from "2024/ClusterFuzz\346\236\266\346\236\204\345\210\206\346\236\220/index.html"
rename to "2024/ClusterFuzz\346\272\220\347\240\201\345\210\206\346\236\220\357\274\210\344\270\200\357\274\211/index.html"
index 417eac4..aff4743 100644
--- "a/2024/ClusterFuzz\346\236\266\346\236\204\345\210\206\346\236\220/index.html"
+++ "b/2024/ClusterFuzz\346\272\220\347\240\201\345\210\206\346\236\220\357\274\210\344\270\200\357\274\211/index.html"
@@ -14,24 +14,24 @@
     
     
     
-    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg"},"articleBody":"\n\nClusterFuzz是 Google 开源的一个模糊测试平台，它集成了多种 Fuzz 引擎，如 Libfuzzer、AFL、Honggfuzz 等，支持跨平台，且具有高度可扩展性。\n简介ClusterFuzz 官网的运作流程图如下：\nFuzz 测试中，编写 fuzzer 和修复 bug 需要人工操作，ClusterFuzz 将这两个环节之外的部分都给自动化了，包括 Fuzz 执行、crash 去重、testcase 精简等。\nClusterFuzz 有两个核心组件：\n\nApp Engine instance：App 引擎，提供一个 web 界面，供用户提交任务、查看结果、展示统计数据等，此外这个 App 引擎还负责调度定时任务。\nFuzz Bots pool：实际执行 Fuzz 的一组 Bot，每个 Bot 从任务队列中挑出任务并执行，这些任务包括但不限于：\nfuzz：执行一次 fuzz 测试 session\nprogression：检查一个 testcase 是否可复现，或者已修复\nregression：查找 crash 被引入的版本范围\nminimize：最小化 testcase\ncorpus_pruning：精简 corpus 语料库（仅限 Libfuzzer）\nanalyze：检查手动上传的 testcase 是否引发 crash\n\n\n\nClusterFuzz 定义的 Fuzz Bot 有两种类型：\n\n可抢占的：机器可以随时关闭，且只能运行 fuzz 任务\n不可抢占的：机器不会关闭，能不间断运行各种类型的任务\n\n代码概要 Google 开源了 ClusterFuzz 的 代码仓，项目 python 为主，读起来相对容易。\n代码结构大致为：\n\nbot：bot 相关文件\nconfigs：配置文件\ndocker：docker 镜像文件\ndocs：官方说明文档\nlocal：本地运行时需要的文件\nresources：bot 依赖的外部资源文件\nsrc：源码根目录\nappengine：App Engine 组件\nhandlers：处理 web 请求\nlibs：web 后端的公共库文件\nprivate：web 前端模板代码\nresources：web 前端使用的资源\n\n\nclusterfuzz\n_internal：核心代码\nbase：通用基础模块\nbot：\nfuzzers：封装各种 fuzzer 引擎，如 Libfuzzer、AFL、Honggfuzz\ninit_scripts：各 os 平台的初始化脚本\nminimizer：最小化 testcase\ntasks：定义各项任务\ntokenizer：分词工具\n\n\nbuild_management：根据用户上传的文件，创建 fuzz 任务\nconfig：读取配置文件，获取配置项\ncrash_analysis：crash 的分析、比较和分级\ndatabase：数据表定义和数据库操作\ndatastore：基于 ndb 定义数据结构和处理操作\nfuzzer_utils：提供 fuzz 基础操作，如 mutator 算子和 testcase 处理\nfuzzing：提供 fuzz 高级操作，如管理 fuzz 产生的 corpus、设置 fuzz 策略、挑选 fuzz 任务等\ngoogle_cloud_utils：基于 gcs 二次开发，封装 clusterfuzz 与存储相关的接口\nmetrics：监控运行数据，提供统计报表\nplatforms：封装各 os 平台的键鼠操作\nprotos：gRPC 的 proto 文件\nscripts：脚本\nsystem：封装各 os 平台的系统操作\ntests：测试\n\n\nenvironment：初始化 fuzz 相关的环境变量\nfuzz：启动 fuzz 任务，实际由 bot 中定义的 fuzzer 执行\nprune：启动 corpus 精简任务\nreproduce：启动 testcase 复现任务\nstracktraces：分析 crash 调用栈\ntests：测试\n\n\nlocal\nbulter：接受外层 bulter 的调用，实际执行具体的任务\nremote：提供不同 os 平台的 handler 给 bulter 使用，对不同的 os 平台 bot 进行配置\n\n\npython\nbot\nother-bots\n\n\nplatform_requirements.txt：python 依赖的三方库\n\n\nbower.json：web 前端依赖的组件\nbutler.py：命令行模式启动 clusterfuzz 的 server、bot、web_server、cron_server、remote 等任务，具体任务的启动脚本在 scr/local/bulter 中\n","dateCreated":"2024-10-09T10:51:56+08:00","dateModified":"2024-10-10T13:08:02+08:00","datePublished":"2024-10-09T10:51:56+08:00","description":"","headline":"ClusterFuzz 源码分析（一）","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://www.stepbystep.asia/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/","keywords":"Fuzz, 安全, 工具"}</script>
+    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg"},"articleBody":"\n\nClusterFuzz是 Google 开源的一个模糊测试平台，它集成了多种 Fuzz 引擎，如 Libfuzzer、AFL、Honggfuzz 等，支持跨平台，且具有高度可扩展性。\n简介ClusterFuzz 官网的运作流程图如下：\nFuzz 测试中，编写 fuzzer 和修复 bug 需要人工操作，ClusterFuzz 将这两个环节之外的部分都给自动化了，包括 Fuzz 执行、crash 去重、testcase 精简等。\nClusterFuzz 有两个核心组件：\n\nApp Engine instance：App 引擎，提供一个 web 界面，供用户提交任务、查看结果、展示统计数据等，此外这个 App 引擎还负责调度定时任务。\nFuzz Bots pool：实际执行 Fuzz 的一组 Bot，每个 Bot 从任务队列中挑出任务并执行，这些任务包括但不限于：\nfuzz：执行一次 fuzz 测试 session\nprogression：检查一个 testcase 是否可复现，或者已修复\nregression：查找 crash 被引入的版本范围\nminimize：最小化 testcase\ncorpus_pruning：精简 corpus 语料库（仅限 Libfuzzer）\nanalyze：检查手动上传的 testcase 是否引发 crash\n\n\n\nClusterFuzz 定义的 Fuzz Bot 有两种类型：\n\n可抢占的：机器可以随时关闭，且只能运行 fuzz 任务\n不可抢占的：机器不会关闭，能不间断运行各种类型的任务\n\n代码概要 Google 开源了 ClusterFuzz 的 代码仓，项目 python 为主，读起来相对容易。\n代码结构大致为：\n\nbot：bot 相关文件\nconfigs：配置文件\ndocker：docker 镜像文件\ndocs：官方说明文档\nlocal：本地运行时需要的文件\nresources：bot 依赖的外部资源文件\nsrc：源码根目录\nappengine：App Engine 组件\nhandlers：处理 web 请求\nlibs：web 后端的公共库文件\nprivate：web 前端模板代码\nresources：web 前端使用的资源\n\n\nclusterfuzz\n_internal：核心代码\nbase：通用基础模块\nbot：\nfuzzers：封装各种 fuzzer 引擎，如 Libfuzzer、AFL、Honggfuzz\ninit_scripts：各 os 平台的初始化脚本\nminimizer：最小化 testcase\ntasks：定义各项任务\ntokenizer：分词工具\n\n\nbuild_management：根据用户上传的文件，创建 fuzz 任务\nconfig：读取配置文件，获取配置项\ncrash_analysis：crash 的分析、比较和分级\ndatabase：数据表定义和数据库操作\ndatastore：基于 ndb 定义数据结构和处理操作\nfuzzer_utils：提供 fuzz 基础操作，如 mutator 算子和 testcase 处理\nfuzzing：提供 fuzz 高级操作，如管理 fuzz 产生的 corpus、设置 fuzz 策略、挑选 fuzz 任务等\ngoogle_cloud_utils：基于 gcs 二次开发，封装 clusterfuzz 与存储相关的接口\nmetrics：监控运行数据，提供统计报表\nplatforms：封装各 os 平台的键鼠操作\nprotos：gRPC 的 proto 文件\nscripts：脚本\nsystem：封装各 os 平台的系统操作\ntests：测试\n\n\nenvironment：初始化 fuzz 相关的环境变量\nfuzz：启动 fuzz 任务，实际由 bot 中定义的 fuzzer 执行\nprune：启动 corpus 精简任务\nreproduce：启动 testcase 复现任务\nstracktraces：分析 crash 调用栈\ntests：测试\n\n\nlocal\nbulter：接受外层 bulter 的调用，实际执行具体的任务\nremote：提供不同 os 平台的 handler 给 bulter 使用，对不同的 os 平台 bot 进行配置\n\n\npython\nbot\nother-bots\n\n\nplatform_requirements.txt：python 依赖的三方库\n\n\nbower.json：web 前端依赖的组件\nbutler.py：命令行模式启动 clusterfuzz 的 server、bot、web_server、cron_server、remote 等任务，具体任务的启动脚本在 scr/local/bulter 中\n","dateCreated":"2024-10-09T10:51:56+08:00","dateModified":"2024-10-10T13:09:32+08:00","datePublished":"2024-10-09T10:51:56+08:00","description":"","headline":"ClusterFuzz 源码分析（一）","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://www.stepbystep.asia/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/","keywords":"安全, 工具, Fuzz"}</script>
     <meta name="description" content="ClusterFuzz是 Google 开源的一个模糊测试平台，它集成了多种 Fuzz 引擎，如 Libfuzzer、AFL、Honggfuzz 等，支持跨平台，且具有高度可扩展性。 简介ClusterFuzz 官网的运作流程图如下： Fuzz 测试中，编写 fuzzer 和修复 bug 需要人工操作，ClusterFuzz 将这两个环节之外的部分都给自动化了，包括 Fuzz 执行、crash">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="ClusterFuzz 源码分析（一）">
-<meta property="og:url" content="https://www.stepbystep.asia/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/index.html">
+<meta property="og:url" content="https://www.stepbystep.asia/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/index.html">
 <meta property="og:site_name" content="千里之行，始于足下">
 <meta property="og:description" content="ClusterFuzz是 Google 开源的一个模糊测试平台，它集成了多种 Fuzz 引擎，如 Libfuzzer、AFL、Honggfuzz 等，支持跨平台，且具有高度可扩展性。 简介ClusterFuzz 官网的运作流程图如下： Fuzz 测试中，编写 fuzzer 和修复 bug 需要人工操作，ClusterFuzz 将这两个环节之外的部分都给自动化了，包括 Fuzz 执行、crash">
 <meta property="og:locale" content="zh_CN">
-<meta property="og:image" content="https://www.stepbystep.asia/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/overview.png">
-<meta property="og:image" content="https://www.stepbystep.asia/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/task.png">
+<meta property="og:image" content="https://www.stepbystep.asia/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/overview.png">
+<meta property="og:image" content="https://www.stepbystep.asia/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/task.png">
 <meta property="article:published_time" content="2024-10-09T02:51:56.000Z">
-<meta property="article:modified_time" content="2024-10-10T05:08:02.796Z">
+<meta property="article:modified_time" content="2024-10-10T05:09:32.325Z">
 <meta property="article:author" content="一瓢清浅">
-<meta property="article:tag" content="Fuzz">
 <meta property="article:tag" content="安全">
 <meta property="article:tag" content="工具">
+<meta property="article:tag" content="Fuzz">
 <meta name="twitter:card" content="summary">
-<meta name="twitter:image" content="https://www.stepbystep.asia/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/overview.png">
+<meta name="twitter:image" content="https://www.stepbystep.asia/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/overview.png">
     
     
         
@@ -254,7 +254,7 @@ <h1 class="post-title">
             <!--excerpt-->
 
 <p><a target="_blank" rel="external nofollow noopener noreferrer" href="https://google.github.io/clusterfuzz/">ClusterFuzz</a>是 Google 开源的一个模糊测试平台，它集成了多种 Fuzz 引擎，如 Libfuzzer、AFL、Honggfuzz 等，支持跨平台，且具有高度可扩展性。</p>
-<h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介</h2><p>ClusterFuzz 官网的运作流程图如下：<br><img src="/./ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/overview.png" alt="ClusterFuzz 流程"></p>
+<h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介</h2><p>ClusterFuzz 官网的运作流程图如下：<br><img src="/./ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/overview.png" alt="ClusterFuzz 流程"></p>
 <p>Fuzz 测试中，编写 fuzzer 和修复 bug 需要人工操作，ClusterFuzz 将这两个环节之外的部分都给自动化了，包括 Fuzz 执行、crash 去重、testcase 精简等。</p>
 <p>ClusterFuzz 有两个核心组件：</p>
 <ul>
@@ -272,7 +272,7 @@ <h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介<
 <p>ClusterFuzz 定义的 Fuzz Bot 有两种类型：</p>
 <ul>
 <li>可抢占的：机器可以随时关闭，且只能运行 fuzz 任务</li>
-<li>不可抢占的：机器不会关闭，能不间断运行各种类型的任务<br><img src="/./ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/task.png" alt="Fuzz Bot"></li>
+<li>不可抢占的：机器不会关闭，能不间断运行各种类型的任务<br><img src="/./ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/task.png" alt="Fuzz Bot"></li>
 </ul>
 <h2 id="代码概要"><a href="# 代码概要" class="headerlink" title="代码概要"></a>代码概要 </h2><p>Google 开源了 ClusterFuzz 的<a target="_blank" rel="external nofollow noopener noreferrer" href="https://github.com/google/clusterfuzz"> 代码仓</a>，项目 python 为主，读起来相对容易。</p>
 <p>代码结构大致为：</p>
@@ -526,7 +526,7 @@ <h4 id="about-card-name">一瓢清浅</h4>
               repo: 'comment',
               owner: 'jiliguluss',
               admin: ['jiliguluss'],
-              id: '2024/ClusterFuzz架构分析/',
+              id: '2024/ClusterFuzz源码分析（一）/',
               ...{"language":"zh-CN","perPage":10,"distractionFreeMode":false,"enableHotKey":true,"pagerDirection":"first"}
             }).render('gitalk')
           })()
diff --git "a/2024/Symbion\345\210\235\346\216\242/index.html" "b/2024/Symbion\345\210\235\346\216\242/index.html"
index 63f5beb..e0c5267 100644
--- "a/2024/Symbion\345\210\235\346\216\242/index.html"
+++ "b/2024/Symbion\345\210\235\346\216\242/index.html"
@@ -14,7 +14,7 @@
     
     
     
-    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg"},"articleBody":"\n\n一、原理介绍  原始论文：SYMBION: Interleaving Symbolic with Concrete Execution\n官方博客：symbion: fusing concrete and symbolic execution\n1. 背景  符号执行可以用来获取走到指定程序区块的可行输入，但是符号执行在实际应用中面临很多挑战：\n\n路径爆炸问题：符号执行从程序入口开始探索，当程序中出现分支和循环时，会导致路径状态呈指数增长。\n\n环境交互问题：当程序与系统或三方库进行交互时，由于缺失源码或交互复杂等原因，会阻碍符号执行的状态更新。\n\n\n2. 方案Symbion 通过具体执行环境与符号执行环境的同步与切换，实现具体值和符号值交替执行。通过这种交替执行机制，减少符号执行探索的路径状态，并解决程序对外部环境的依赖问题。\n图中演示了具体执行环境与符号执行环境相互切换的过程：\n\n\n目标是对从 PoI 到TP的路径进行符号推理，CSP节点是程序入口。从 CSP 到PoI要经过复杂的运算和交互，这导致直接从 CSP 开始符号推理，将无法向后演进到PoI。\n使用 Symbion 时，首先将具体值输入给 CSP，在具体执行后到达PoI。然后在PoI 切换到符号执行环境，算出到达 TP 所需的变量取值。再将算出来的结果同步给具体执行环境，在 PoI 恢复具体执行，即可到达TP。\n3. 实现Symbion 的架构设计如下：\n\n\nSymbion 在 Angr 的基础上，增加了如下组件：\n\nConcrete Target：定义了与具体执行环境交互的方法，通过实现这些方法可以让 Symbion 支持特定的交互环境。例如 Symbion 实现的GDBConcreteTarget，它通过 gdbsever 控制远程目标程序的交互。\n\nread_memory(address, nbytes)：从具体进程内存中 address 开始读取 nbytes 字节。\nwrite_memory(address, value)：在具体进程内存中 address 处写入value。\nread_register(register)：返回具体进程中指定 register 的内容。\nwrite_register(register, value)：在具体进程的 register 中写入value。\nset_breakpoint(address)：在具体进程中的 address 处设置断点。\nremove_breakpoint(address)：移除之前在 address 处设置的断点。\nrun()：恢复具体进程的执行。\n\n\nSimEngineConcrete：利用 Concrete Target 的方法执行以下步骤，实现 Symbolic 环境到 Concrete 环境的切换。\n\n用用户提供的值修改具体进程的内存。\n用用户提供的值修改具体进程的寄存器。\n通过断点来设置新的PoI。\n恢复程序的具体执行，直到到达新的PoI，并将控制权交还给 Angr。\n\n\nConcrete SimPlugin：当具体执行到达 PoI，这个插件实现Concrete 环境到 Symbolic 环境的切换，它将具体状态导入 Angr 来创建SimState。\n\n将 SimState 的内存后端重定向到具体进程的内存，即在符号执行过程中，SimState的内存读取都是从具体进程中来操作。\n\n将具体进程中的寄存器值复制到 SimState 中。\n\n将具体进程的内存映射与 Angr 在启动期间加载的内存映射同步。\n\n\n\nSYMBION Exploration Technique：提供用户使用 Symbion 的 API ，通过这些 API ，用户指定 PoI 的地址，在具体执行到达 PoI 后，Symbion 切换为符号执行。\n\n\n简而言之，在 Symbion 的工作流程中，各组件的作用为：\n\n用户通过 SYMBION Exploration Technique 指定PoI。\n\n程序经过具体执行到达到 PoI 后暂停， Concrete SimPlugin 根据具体执行环境来创建一个SimState。\n\nAngr 通过符号执行，计算到达下一个 PoI 的可行解。\n\nSimEngineConcrete 用 Angr 算出来的结果修改具体进程中的变量，恢复具体执行直到下一个PoI。\n\n\n二、示例分析Symbion 官方示例：test_concrete_not_packed_elf64\n示例使用的二进制：not_packed_elf64\n二进制没有给源码，通过 IDA 逆向源码，并用 AI 改写，得到 C 源码如下，源码中取 dest 变量中的一串数值做判断，不同的分支触发不同的print。\n\n\n在 Symbion 的示例代码中，首先通过具体执行到达 BINARY_DECISION_ADDRESS，然后用符号执行探索从BINARY_DECISION_ADDRESS 到DROP_STAGE2_V2的路径。\n\n\n在符号执行求解成功后，再将求解结果传递给具体执行环境，并启动具体执行，即可到达DROP_STAGE2_V2：\n\n\n结合 CFG 和源码可以看到，符号执行的起点 BINARY_DECISION_ADDRESS 对应源码图右侧 55 行，符号执行的终点 DROP_STAGE2_V2 对应源码图右侧 77 行。通过 Symbion，实现了对二进制按指定路径的进行分析的目的。\n\n\nSymbion 的示例代码中，涉及到很多内存地址操作，需要结合 IDA 的反编译源码来看：\n\n\n\nline 2：启动具体执行，到 BINARY_DECISION_ADDRESS 停下，即 IDA 反编译源码第 67 行代码\n\nline 3：从具体执行环境的获取寄存器中的栈指针sp，指向栈顶（即栈开始的位置）\n\nline 4：从栈顶 sp 开始读取 20 个字节的内存，这块内存包括反编译源码中的变量 i 和v5\n\nline 5：判断是否为符号变量，此时为具体执行环境，所以不是符号变量\n\nline 7：定义符号变量，变量名为arg0，大小为 32 字节\n\nline 8：用 symbolic_buffer_memory 指向具体执行环境中 rbp-0xc0 的内存地址，它对应 IDA 反编译源码中的数组 s 的起始地址。\n\nline 10：从 symbolic_buffer_memory 开始加载 36 个字节的内存\n\nline 11：判断是否为符号变量，此时为具体执行环境，所以不是符号变量\n\nline 12：将 angr0 存储到symbolic_buffer_memory，将符号变量与具体执行环境的内存地址关联起来\n\nline 15：从 symbolic_buffer_memory 开始加载 36 个字节的内存\n\nline 16：判断是否为符号变量，因为 把 angr0 保存到这块内存，所以是符号变量\n\nline 19：符号执行状态初始化\n\nline 37：启动符号执行\n\n\n可以看到，Symbion 在切换具体执行环境和符号执行环境时，是通过内存地址把变量的具体值和符号值对应起来。需要结合 IDA 反编译的源码中给出的变量地址和内存大小，人工设置符号执行中所需要的符号变量，难以实现自动化。","dateCreated":"2024-02-27T16:33:24+08:00","dateModified":"2024-06-26T16:27:23+08:00","datePublished":"2024-02-27T16:33:24+08:00","description":"Symbion 是 Angr 的一款插件，可以实现具体执行与符号执行交替运行","headline":"交替符号执行工具——Symbion 初探","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2024/Symbion%E5%88%9D%E6%8E%A2/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://www.stepbystep.asia/2024/Symbion%E5%88%9D%E6%8E%A2/","keywords":"安全, 工具, 符号执行"}</script>
+    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg"},"articleBody":"\n\n一、原理介绍  原始论文：SYMBION: Interleaving Symbolic with Concrete Execution\n官方博客：symbion: fusing concrete and symbolic execution\n1. 背景  符号执行可以用来获取走到指定程序区块的可行输入，但是符号执行在实际应用中面临很多挑战：\n\n路径爆炸问题：符号执行从程序入口开始探索，当程序中出现分支和循环时，会导致路径状态呈指数增长。\n\n环境交互问题：当程序与系统或三方库进行交互时，由于缺失源码或交互复杂等原因，会阻碍符号执行的状态更新。\n\n\n2. 方案Symbion 通过具体执行环境与符号执行环境的同步与切换，实现具体值和符号值交替执行。通过这种交替执行机制，减少符号执行探索的路径状态，并解决程序对外部环境的依赖问题。\n图中演示了具体执行环境与符号执行环境相互切换的过程：\n\n\n目标是对从 PoI 到TP的路径进行符号推理，CSP节点是程序入口。从 CSP 到PoI要经过复杂的运算和交互，这导致直接从 CSP 开始符号推理，将无法向后演进到PoI。\n使用 Symbion 时，首先将具体值输入给 CSP，在具体执行后到达PoI。然后在PoI 切换到符号执行环境，算出到达 TP 所需的变量取值。再将算出来的结果同步给具体执行环境，在 PoI 恢复具体执行，即可到达TP。\n3. 实现Symbion 的架构设计如下：\n\n\nSymbion 在 Angr 的基础上，增加了如下组件：\n\nConcrete Target：定义了与具体执行环境交互的方法，通过实现这些方法可以让 Symbion 支持特定的交互环境。例如 Symbion 实现的GDBConcreteTarget，它通过 gdbsever 控制远程目标程序的交互。\n\nread_memory(address, nbytes)：从具体进程内存中 address 开始读取 nbytes 字节。\nwrite_memory(address, value)：在具体进程内存中 address 处写入value。\nread_register(register)：返回具体进程中指定 register 的内容。\nwrite_register(register, value)：在具体进程的 register 中写入value。\nset_breakpoint(address)：在具体进程中的 address 处设置断点。\nremove_breakpoint(address)：移除之前在 address 处设置的断点。\nrun()：恢复具体进程的执行。\n\n\nSimEngineConcrete：利用 Concrete Target 的方法执行以下步骤，实现 Symbolic 环境到 Concrete 环境的切换。\n\n用用户提供的值修改具体进程的内存。\n用用户提供的值修改具体进程的寄存器。\n通过断点来设置新的PoI。\n恢复程序的具体执行，直到到达新的PoI，并将控制权交还给 Angr。\n\n\nConcrete SimPlugin：当具体执行到达 PoI，这个插件实现Concrete 环境到 Symbolic 环境的切换，它将具体状态导入 Angr 来创建SimState。\n\n将 SimState 的内存后端重定向到具体进程的内存，即在符号执行过程中，SimState的内存读取都是从具体进程中来操作。\n\n将具体进程中的寄存器值复制到 SimState 中。\n\n将具体进程的内存映射与 Angr 在启动期间加载的内存映射同步。\n\n\n\nSYMBION Exploration Technique：提供用户使用 Symbion 的 API ，通过这些 API ，用户指定 PoI 的地址，在具体执行到达 PoI 后，Symbion 切换为符号执行。\n\n\n简而言之，在 Symbion 的工作流程中，各组件的作用为：\n\n用户通过 SYMBION Exploration Technique 指定PoI。\n\n程序经过具体执行到达到 PoI 后暂停， Concrete SimPlugin 根据具体执行环境来创建一个SimState。\n\nAngr 通过符号执行，计算到达下一个 PoI 的可行解。\n\nSimEngineConcrete 用 Angr 算出来的结果修改具体进程中的变量，恢复具体执行直到下一个PoI。\n\n\n二、示例分析Symbion 官方示例：test_concrete_not_packed_elf64\n示例使用的二进制：not_packed_elf64\n二进制没有给源码，通过 IDA 逆向源码，并用 AI 改写，得到 C 源码如下，源码中取 dest 变量中的一串数值做判断，不同的分支触发不同的print。\n\n\n在 Symbion 的示例代码中，首先通过具体执行到达 BINARY_DECISION_ADDRESS，然后用符号执行探索从BINARY_DECISION_ADDRESS 到DROP_STAGE2_V2的路径。\n\n\n在符号执行求解成功后，再将求解结果传递给具体执行环境，并启动具体执行，即可到达DROP_STAGE2_V2：\n\n\n结合 CFG 和源码可以看到，符号执行的起点 BINARY_DECISION_ADDRESS 对应源码图右侧 55 行，符号执行的终点 DROP_STAGE2_V2 对应源码图右侧 77 行。通过 Symbion，实现了对二进制按指定路径的进行分析的目的。\n\n\nSymbion 的示例代码中，涉及到很多内存地址操作，需要结合 IDA 的反编译源码来看：\n\n\n\nline 2：启动具体执行，到 BINARY_DECISION_ADDRESS 停下，即 IDA 反编译源码第 67 行代码\n\nline 3：从具体执行环境的获取寄存器中的栈指针sp，指向栈顶（即栈开始的位置）\n\nline 4：从栈顶 sp 开始读取 20 个字节的内存，这块内存包括反编译源码中的变量 i 和v5\n\nline 5：判断是否为符号变量，此时为具体执行环境，所以不是符号变量\n\nline 7：定义符号变量，变量名为arg0，大小为 32 字节\n\nline 8：用 symbolic_buffer_memory 指向具体执行环境中 rbp-0xc0 的内存地址，它对应 IDA 反编译源码中的数组 s 的起始地址。\n\nline 10：从 symbolic_buffer_memory 开始加载 36 个字节的内存\n\nline 11：判断是否为符号变量，此时为具体执行环境，所以不是符号变量\n\nline 12：将 angr0 存储到symbolic_buffer_memory，将符号变量与具体执行环境的内存地址关联起来\n\nline 15：从 symbolic_buffer_memory 开始加载 36 个字节的内存\n\nline 16：判断是否为符号变量，因为 把 angr0 保存到这块内存，所以是符号变量\n\nline 19：符号执行状态初始化\n\nline 37：启动符号执行\n\n\n可以看到，Symbion 在切换具体执行环境和符号执行环境时，是通过内存地址把变量的具体值和符号值对应起来。需要结合 IDA 反编译的源码中给出的变量地址和内存大小，人工设置符号执行中所需要的符号变量，难以实现自动化。","dateCreated":"2024-02-27T16:33:24+08:00","dateModified":"2024-06-26T16:27:23+08:00","datePublished":"2024-02-27T16:33:24+08:00","description":"Symbion 是 Angr 的一款插件，可以实现具体执行与符号执行交替运行","headline":"交替符号执行工具——Symbion 初探","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2024/Symbion%E5%88%9D%E6%8E%A2/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://www.stepbystep.asia/2024/Symbion%E5%88%9D%E6%8E%A2/","keywords":"符号执行, 安全, 工具"}</script>
     <meta name="description" content="Symbion 是 Angr 的一款插件，可以实现具体执行与符号执行交替运行">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="交替符号执行工具——Symbion 初探">
@@ -32,9 +32,9 @@
 <meta property="article:published_time" content="2024-02-27T08:33:24.000Z">
 <meta property="article:modified_time" content="2024-06-26T08:27:23.616Z">
 <meta property="article:author" content="一瓢清浅">
+<meta property="article:tag" content="符号执行">
 <meta property="article:tag" content="安全">
 <meta property="article:tag" content="工具">
-<meta property="article:tag" content="符号执行">
 <meta name="twitter:card" content="summary">
 <meta name="twitter:image" content="https://www.stepbystep.asia/2024/Symbion%E5%88%9D%E6%8E%A2/symbion%E4%B8%8A%E4%B8%8B%E6%96%87%E5%88%87%E6%8D%A2.png">
     
diff --git "a/2024/\347\224\261subprocess-PIPE\345\274\225\345\217\221\347\232\204\350\241\200\346\241\210/index.html" "b/2024/\347\224\261subprocess-PIPE\345\274\225\345\217\221\347\232\204\350\241\200\346\241\210/index.html"
index 1211a99..3c0b75f 100644
--- "a/2024/\347\224\261subprocess-PIPE\345\274\225\345\217\221\347\232\204\350\241\200\346\241\210/index.html"
+++ "b/2024/\347\224\261subprocess-PIPE\345\274\225\345\217\221\347\232\204\350\241\200\346\241\210/index.html"
@@ -14,7 +14,7 @@
     
     
     
-    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg"},"articleBody":"\n\n一、案发现场  事情是酱滴：\n我写了个 python 脚本，在脚本中通过 subprocess 启动了 AFL++ 的子进程，对 binary 进行测试。\n然后我还在这个 python 脚本中，使用其他的工具生成针对 binary 有效的 corpus。\n参考前文AFL++ 同步机制，正常情况下 AFL++ 会将其他工具生成的 corpus（已确认能覆盖新的代码分支），同步到 AFL++ 的 queue 目录下。\n但是诡异的事情出现了：AFL++ 没有同步！\n二、破案过程 1. 还原现场 这个 AFL++ 不同步的情况不是必现的，非必现的问题真 TM 难调。\n我换了好几个机器，在 host 和 docker 上分别进行了多轮实验，前前后后跑了一两周的时间，排除了环境问题。虽然有的环境概率高，有的环境概率低，但只要跑的次数够多，都会出现 AFL++ 不同步的问题。\n2. 埋 log在反复跑实验的过程中，也有在 AFL++ 源码中埋 log。\n我在 sync_fuzzers 函数体内，以及调用之处加了很多 log。sync_fuzzers在 afl-fuzz.c 的main函数中有四处调用，编号 1~4 表示在代码中的先后顺序，实际调用流程大概如下：\nflowchart TD\n    A[main] --> B[stop_fuzzing]\n    B --> C[sync_fuzzers 4]\n    A --> D[while loop]\n    D --> E[sync_fuzzers 1]\n    E --> F[do-while loop]\n    F --> G[sync_fuzzers 2]\n    F --> H[sync_fuzzers 3]\n    H --> D\n    G --> D\n通过 log 发现，AFL++ 在同步 corpus 时，主要使用过 sync_fuzzers 1 来完成的。而在未同步的场景中，log 会在 do-while loop 里面中断，后续再也没有打印出sync_fuzzers 1。\n3. gdb 追踪  当 log 也印不出来的时候，gdb 看起来是唯一能用的工具了。\n于是我找了个复现概率高的机器，在启动 python 脚本后，用 gdb attach 脚本所启动的 AFL++ 子进程，并在 sync_fuzzers 的 1~4 处调用都打了断点，接着让 AFL++ 继续跑。\n神奇的事情出现了，AFL++ 正常同步的时候，sync_fuzzers 1总是会命中。然而当跑一阵后，sync_fuzzers 1就再也到不了了。此时 ctrl+c 暂停程序，查看调用栈如下：\n\n\n其中 afl-fuzz-one.c 的 420 行的代码如下，只是调用了 flush 库函数而已：\n\n\n我将此行注释掉，重新 gdb 一次，结果发现会在另一个 flush 处卡住。\n在库函数面前，我们要质疑的是自己的代码。\n三、罪魁祸首  我回头检查了自己的 Python 脚本，启动 AFL++ 的代码如下：\n12345678910111213self.fuzzer_popen = sp.Popen(    cmd,    shell=False,    stdout=sp.PIPE,    stderr=sp.PIPE,    env=env,    preexec_fn=os.setsid,)time.sleep(5)if self.fuzzer_popen.poll() is not None:    raise Exception(f&#x27;start fuzz process failed with error: &#123;self.fuzzer_popen.stderr.read().decode(&quot;utf-8&quot;)&#125;&#x27;)else:    logger.info(f&#x27;start fuzz process whose pid is &#123;self.fuzzer_popen.pid&#125;&#x27;)\n\n我又去查了一下 subprocess 的官方文档，赫然写着 注意事项：\n\nNote This will deadlock when using stdout&#x3D;PIPE or stderr&#x3D;PIPE and the child process generates enough output to a pipe such that it blocks waiting for the OS pipe buffer to accept more data. Use Popen.communicate() when using pipes to avoid that.\n\n破案了破案了，我用了 PIPE 来接受 AFL++ 的 stdout 和 stderr，但是我没有通过 communicate 来读取 PIPE，导致PIPE 中积压了大量的数据，阻碍了 AFL++ 继续flush。\n我被自己蠢哭了，也被 subprocess 坑惨了，修改后的代码如下：\n12345678self.fuzzer_popen = sp.Popen(    cmd,    shell=False,    stdout=sp.DEVNULL,    stderr=sp.DEVNULL,    env=env,    preexec_fn=os.setsid,)\n\n去他娘的 stdout 和 stderr，改完后 AFL++ 同步都正常了~~","dateCreated":"2024-07-30T16:19:00+08:00","dateModified":"2024-08-16T17:30:58+08:00","datePublished":"2024-07-30T16:19:00+08:00","description":"找了大半个月 AFL++ 不同步的原因，到头来都是 subprocess 的锅","headline":"由 subprocess.PIPE 引发的血案","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2024/%E7%94%B1subprocess-PIPE%E5%BC%95%E5%8F%91%E7%9A%84%E8%A1%80%E6%A1%88/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://www.stepbystep.asia/2024/%E7%94%B1subprocess-PIPE%E5%BC%95%E5%8F%91%E7%9A%84%E8%A1%80%E6%A1%88/","keywords":"AFL++, 安全, 开发, Python"}</script>
+    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg"},"articleBody":"\n\n一、案发现场  事情是酱滴：\n我写了个 python 脚本，在脚本中通过 subprocess 启动了 AFL++ 的子进程，对 binary 进行测试。\n然后我还在这个 python 脚本中，使用其他的工具生成针对 binary 有效的 corpus。\n参考前文AFL++ 同步机制，正常情况下 AFL++ 会将其他工具生成的 corpus（已确认能覆盖新的代码分支），同步到 AFL++ 的 queue 目录下。\n但是诡异的事情出现了：AFL++ 没有同步！\n二、破案过程 1. 还原现场 这个 AFL++ 不同步的情况不是必现的，非必现的问题真 TM 难调。\n我换了好几个机器，在 host 和 docker 上分别进行了多轮实验，前前后后跑了一两周的时间，排除了环境问题。虽然有的环境概率高，有的环境概率低，但只要跑的次数够多，都会出现 AFL++ 不同步的问题。\n2. 埋 log在反复跑实验的过程中，也有在 AFL++ 源码中埋 log。\n我在 sync_fuzzers 函数体内，以及调用之处加了很多 log。sync_fuzzers在 afl-fuzz.c 的main函数中有四处调用，编号 1~4 表示在代码中的先后顺序，实际调用流程大概如下：\nflowchart TD\n    A[main] --> B[stop_fuzzing]\n    B --> C[sync_fuzzers 4]\n    A --> D[while loop]\n    D --> E[sync_fuzzers 1]\n    E --> F[do-while loop]\n    F --> G[sync_fuzzers 2]\n    F --> H[sync_fuzzers 3]\n    H --> D\n    G --> D\n通过 log 发现，AFL++ 在同步 corpus 时，主要使用过 sync_fuzzers 1 来完成的。而在未同步的场景中，log 会在 do-while loop 里面中断，后续再也没有打印出sync_fuzzers 1。\n3. gdb 追踪  当 log 也印不出来的时候，gdb 看起来是唯一能用的工具了。\n于是我找了个复现概率高的机器，在启动 python 脚本后，用 gdb attach 脚本所启动的 AFL++ 子进程，并在 sync_fuzzers 的 1~4 处调用都打了断点，接着让 AFL++ 继续跑。\n神奇的事情出现了，AFL++ 正常同步的时候，sync_fuzzers 1总是会命中。然而当跑一阵后，sync_fuzzers 1就再也到不了了。此时 ctrl+c 暂停程序，查看调用栈如下：\n\n\n其中 afl-fuzz-one.c 的 420 行的代码如下，只是调用了 flush 库函数而已：\n\n\n我将此行注释掉，重新 gdb 一次，结果发现会在另一个 flush 处卡住。\n在库函数面前，我们要质疑的是自己的代码。\n三、罪魁祸首  我回头检查了自己的 Python 脚本，启动 AFL++ 的代码如下：\n12345678910111213self.fuzzer_popen = sp.Popen(    cmd,    shell=False,    stdout=sp.PIPE,    stderr=sp.PIPE,    env=env,    preexec_fn=os.setsid,)time.sleep(5)if self.fuzzer_popen.poll() is not None:    raise Exception(f&#x27;start fuzz process failed with error: &#123;self.fuzzer_popen.stderr.read().decode(&quot;utf-8&quot;)&#125;&#x27;)else:    logger.info(f&#x27;start fuzz process whose pid is &#123;self.fuzzer_popen.pid&#125;&#x27;)\n\n我又去查了一下 subprocess 的官方文档，赫然写着 注意事项：\n\nNote This will deadlock when using stdout&#x3D;PIPE or stderr&#x3D;PIPE and the child process generates enough output to a pipe such that it blocks waiting for the OS pipe buffer to accept more data. Use Popen.communicate() when using pipes to avoid that.\n\n破案了破案了，我用了 PIPE 来接受 AFL++ 的 stdout 和 stderr，但是我没有通过 communicate 来读取 PIPE，导致PIPE 中积压了大量的数据，阻碍了 AFL++ 继续flush。\n我被自己蠢哭了，也被 subprocess 坑惨了，修改后的代码如下：\n12345678self.fuzzer_popen = sp.Popen(    cmd,    shell=False,    stdout=sp.DEVNULL,    stderr=sp.DEVNULL,    env=env,    preexec_fn=os.setsid,)\n\n去他娘的 stdout 和 stderr，改完后 AFL++ 同步都正常了~~","dateCreated":"2024-07-30T16:19:00+08:00","dateModified":"2024-08-16T17:30:58+08:00","datePublished":"2024-07-30T16:19:00+08:00","description":"找了大半个月 AFL++ 不同步的原因，到头来都是 subprocess 的锅","headline":"由 subprocess.PIPE 引发的血案","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2024/%E7%94%B1subprocess-PIPE%E5%BC%95%E5%8F%91%E7%9A%84%E8%A1%80%E6%A1%88/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/jiliguluss"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://www.stepbystep.asia/2024/%E7%94%B1subprocess-PIPE%E5%BC%95%E5%8F%91%E7%9A%84%E8%A1%80%E6%A1%88/","keywords":"安全, AFL++, 开发, Python"}</script>
     <meta name="description" content="找了大半个月 AFL++ 不同步的原因，到头来都是 subprocess 的锅">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="由 subprocess.PIPE 引发的血案">
@@ -27,8 +27,8 @@
 <meta property="article:published_time" content="2024-07-30T08:19:00.000Z">
 <meta property="article:modified_time" content="2024-08-16T09:30:58.371Z">
 <meta property="article:author" content="一瓢清浅">
-<meta property="article:tag" content="AFL++">
 <meta property="article:tag" content="安全">
+<meta property="article:tag" content="AFL++">
 <meta property="article:tag" content="开发">
 <meta property="article:tag" content="Python">
 <meta name="twitter:card" content="summary">
diff --git a/all-archives/index.html b/all-archives/index.html
index f0b75f3..7e5c65b 100644
--- a/all-archives/index.html
+++ b/all-archives/index.html
@@ -239,7 +239,7 @@ <h5 class="archive-title">
                 
             
             <li class="archive-post archive-day" data-date="20241009">
-                <a class="archive-post-title" href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/">ClusterFuzz 源码分析（一）</a>
+                <a class="archive-post-title" href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/">ClusterFuzz 源码分析（一）</a>
                 <span class="archive-post-date"> - 2024 年 10 月 9 日</span>
             </li>
         
diff --git a/all-categories/index.html b/all-categories/index.html
index 8a8f869..e0b4629 100644
--- a/all-categories/index.html
+++ b/all-categories/index.html
@@ -273,7 +273,7 @@ <h5 class="archive-result text-color-base text-xlarge" data-message-zero="没有
             
         
             
-                    <div id="posts-list-安全" class="archive box" data-category="安全" data-parent-categories><h4 class="archive-title text-xlarge"><a class="link-unstyled" href="/categories/%E5%AE%89%E5%85%A8/">安全 (11)</a></h4><ul class="archive-posts"><li class="archive-post"><a class="archive-post-title" href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/">ClusterFuzz 源码分析（一）</a><span class="archive-post-date"> - 2024 年 10 月 9 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2024/AFLplusplus%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E2%80%94%E2%80%94%E8%A6%86%E7%9B%96%E7%8E%87/">AFL++ 源码分析——覆盖率</a><span class="archive-post-date"> - 2024 年 8 月 15 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2024/AFLplusplus%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E2%80%94%E2%80%94%E5%90%8C%E6%AD%A5%E6%9C%BA%E5%88%B6/">AFLplusplus 源码分析——同步机制</a><span class="archive-post-date"> - 2024 年 7 月 16 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2024/%E6%B1%A1%E7%82%B9%E5%88%86%E6%9E%90%E5%B7%A5%E5%85%B7%E2%80%94%E2%80%94libdft64/">污点分析工具——libdft64</a><span class="archive-post-date"> - 2024 年 5 月 17 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2024/Symbion%E5%88%9D%E6%8E%A2/">交替符号执行工具——Symbion 初探</a><span class="archive-post-date"> - 2024 年 2 月 27 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2024/Angr%E9%9B%B6%E5%9F%BA%E7%A1%80%E5%85%A5%E9%97%A8/">符号执行工具——Angr 零基础入门</a><span class="archive-post-date"> - 2024 年 1 月 23 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2023/%E7%AC%A6%E5%8F%B7%E6%89%A7%E8%A1%8C%E4%B8%8E%E6%B7%B7%E5%90%88%E6%A8%A1%E7%B3%8A%E6%B5%8B%E8%AF%95/">符号执行与混合模糊测试</a><span class="archive-post-date"> - 2023 年 12 月 24 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2023/LibAFL%E7%AE%80%E4%BB%8B/">LibAFL 简介</a><span class="archive-post-date"> - 2023 年 11 月 18 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2023/AFL%E5%8E%9F%E7%90%86%E4%B8%8E%E5%AE%9E%E8%B7%B5/">AFL 原理与实践</a><span class="archive-post-date"> - 2023 年 10 月 15 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2023/LibFuzzer%E7%BC%96%E8%AF%91%E6%8C%87%E5%8D%97/">LibFuzzer 编译指南</a><span class="archive-post-date"> - 2023 年 9 月 26 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2023/LibFuzzer%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E/">LibFuzzer 使用说明</a><span class="archive-post-date"> - 2023 年 9 月 17 日</span></li><div id="posts-list-模糊测试" class="archive " data-category="模糊测试" data-parent-categories="安全"><h4 class="archive-title text-xlarge"><a class="link-unstyled" href="/categories/%E5%AE%89%E5%85%A8/%E6%A8%A1%E7%B3%8A%E6%B5%8B%E8%AF%95/">模糊测试 (7)</a></h4><ul class="archive-posts"><li class="archive-post"><a class="archive-post-title" href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/">ClusterFuzz 源码分析（一）</a><span class="archive-post-date"> - 2024 年 10 月 9 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2024/AFLplusplus%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E2%80%94%E2%80%94%E8%A6%86%E7%9B%96%E7%8E%87/">AFL++ 源码分析——覆盖率</a><span class="archive-post-date"> - 2024 年 8 月 15 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2024/AFLplusplus%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E2%80%94%E2%80%94%E5%90%8C%E6%AD%A5%E6%9C%BA%E5%88%B6/">AFLplusplus 源码分析——同步机制</a><span class="archive-post-date"> - 2024 年 7 月 16 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2023/LibAFL%E7%AE%80%E4%BB%8B/">LibAFL 简介</a><span class="archive-post-date"> - 2023 年 11 月 18 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2023/AFL%E5%8E%9F%E7%90%86%E4%B8%8E%E5%AE%9E%E8%B7%B5/">AFL 原理与实践</a><span class="archive-post-date"> - 2023 年 10 月 15 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2023/LibFuzzer%E7%BC%96%E8%AF%91%E6%8C%87%E5%8D%97/">LibFuzzer 编译指南</a><span class="archive-post-date"> - 2023 年 9 月 26 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2023/LibFuzzer%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E/">LibFuzzer 使用说明</a><span class="archive-post-date"> - 2023 年 9 月 17 日</span></li></ul></div><div id="posts-list-污点分析" class="archive " data-category="污点分析" data-parent-categories="安全"><h4 class="archive-title text-xlarge"><a class="link-unstyled" href="/categories/%E5%AE%89%E5%85%A8/%E6%B1%A1%E7%82%B9%E5%88%86%E6%9E%90/">污点分析 (1)</a></h4><ul class="archive-posts"><li class="archive-post"><a class="archive-post-title" href="/2024/%E6%B1%A1%E7%82%B9%E5%88%86%E6%9E%90%E5%B7%A5%E5%85%B7%E2%80%94%E2%80%94libdft64/">污点分析工具——libdft64</a><span class="archive-post-date"> - 2024 年 5 月 17 日</span></li></ul></div><div id="posts-list-符号执行" class="archive " data-category="符号执行" data-parent-categories="安全"><h4 class="archive-title text-xlarge"><a class="link-unstyled" href="/categories/%E5%AE%89%E5%85%A8/%E7%AC%A6%E5%8F%B7%E6%89%A7%E8%A1%8C/">符号执行 (3)</a></h4><ul class="archive-posts"><li class="archive-post"><a class="archive-post-title" href="/2024/Symbion%E5%88%9D%E6%8E%A2/">交替符号执行工具——Symbion 初探</a><span class="archive-post-date"> - 2024 年 2 月 27 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2024/Angr%E9%9B%B6%E5%9F%BA%E7%A1%80%E5%85%A5%E9%97%A8/">符号执行工具——Angr 零基础入门</a><span class="archive-post-date"> - 2024 年 1 月 23 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2023/%E7%AC%A6%E5%8F%B7%E6%89%A7%E8%A1%8C%E4%B8%8E%E6%B7%B7%E5%90%88%E6%A8%A1%E7%B3%8A%E6%B5%8B%E8%AF%95/">符号执行与混合模糊测试</a><span class="archive-post-date"> - 2023 年 12 月 24 日</span></li></ul></div></ul></div>
+                    <div id="posts-list-安全" class="archive box" data-category="安全" data-parent-categories><h4 class="archive-title text-xlarge"><a class="link-unstyled" href="/categories/%E5%AE%89%E5%85%A8/">安全 (11)</a></h4><ul class="archive-posts"><li class="archive-post"><a class="archive-post-title" href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/">ClusterFuzz 源码分析（一）</a><span class="archive-post-date"> - 2024 年 10 月 9 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2024/AFLplusplus%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E2%80%94%E2%80%94%E8%A6%86%E7%9B%96%E7%8E%87/">AFL++ 源码分析——覆盖率</a><span class="archive-post-date"> - 2024 年 8 月 15 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2024/AFLplusplus%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E2%80%94%E2%80%94%E5%90%8C%E6%AD%A5%E6%9C%BA%E5%88%B6/">AFLplusplus 源码分析——同步机制</a><span class="archive-post-date"> - 2024 年 7 月 16 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2024/%E6%B1%A1%E7%82%B9%E5%88%86%E6%9E%90%E5%B7%A5%E5%85%B7%E2%80%94%E2%80%94libdft64/">污点分析工具——libdft64</a><span class="archive-post-date"> - 2024 年 5 月 17 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2024/Symbion%E5%88%9D%E6%8E%A2/">交替符号执行工具——Symbion 初探</a><span class="archive-post-date"> - 2024 年 2 月 27 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2024/Angr%E9%9B%B6%E5%9F%BA%E7%A1%80%E5%85%A5%E9%97%A8/">符号执行工具——Angr 零基础入门</a><span class="archive-post-date"> - 2024 年 1 月 23 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2023/%E7%AC%A6%E5%8F%B7%E6%89%A7%E8%A1%8C%E4%B8%8E%E6%B7%B7%E5%90%88%E6%A8%A1%E7%B3%8A%E6%B5%8B%E8%AF%95/">符号执行与混合模糊测试</a><span class="archive-post-date"> - 2023 年 12 月 24 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2023/LibAFL%E7%AE%80%E4%BB%8B/">LibAFL 简介</a><span class="archive-post-date"> - 2023 年 11 月 18 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2023/AFL%E5%8E%9F%E7%90%86%E4%B8%8E%E5%AE%9E%E8%B7%B5/">AFL 原理与实践</a><span class="archive-post-date"> - 2023 年 10 月 15 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2023/LibFuzzer%E7%BC%96%E8%AF%91%E6%8C%87%E5%8D%97/">LibFuzzer 编译指南</a><span class="archive-post-date"> - 2023 年 9 月 26 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2023/LibFuzzer%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E/">LibFuzzer 使用说明</a><span class="archive-post-date"> - 2023 年 9 月 17 日</span></li><div id="posts-list-模糊测试" class="archive " data-category="模糊测试" data-parent-categories="安全"><h4 class="archive-title text-xlarge"><a class="link-unstyled" href="/categories/%E5%AE%89%E5%85%A8/%E6%A8%A1%E7%B3%8A%E6%B5%8B%E8%AF%95/">模糊测试 (7)</a></h4><ul class="archive-posts"><li class="archive-post"><a class="archive-post-title" href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/">ClusterFuzz 源码分析（一）</a><span class="archive-post-date"> - 2024 年 10 月 9 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2024/AFLplusplus%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E2%80%94%E2%80%94%E8%A6%86%E7%9B%96%E7%8E%87/">AFL++ 源码分析——覆盖率</a><span class="archive-post-date"> - 2024 年 8 月 15 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2024/AFLplusplus%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E2%80%94%E2%80%94%E5%90%8C%E6%AD%A5%E6%9C%BA%E5%88%B6/">AFLplusplus 源码分析——同步机制</a><span class="archive-post-date"> - 2024 年 7 月 16 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2023/LibAFL%E7%AE%80%E4%BB%8B/">LibAFL 简介</a><span class="archive-post-date"> - 2023 年 11 月 18 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2023/AFL%E5%8E%9F%E7%90%86%E4%B8%8E%E5%AE%9E%E8%B7%B5/">AFL 原理与实践</a><span class="archive-post-date"> - 2023 年 10 月 15 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2023/LibFuzzer%E7%BC%96%E8%AF%91%E6%8C%87%E5%8D%97/">LibFuzzer 编译指南</a><span class="archive-post-date"> - 2023 年 9 月 26 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2023/LibFuzzer%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E/">LibFuzzer 使用说明</a><span class="archive-post-date"> - 2023 年 9 月 17 日</span></li></ul></div><div id="posts-list-污点分析" class="archive " data-category="污点分析" data-parent-categories="安全"><h4 class="archive-title text-xlarge"><a class="link-unstyled" href="/categories/%E5%AE%89%E5%85%A8/%E6%B1%A1%E7%82%B9%E5%88%86%E6%9E%90/">污点分析 (1)</a></h4><ul class="archive-posts"><li class="archive-post"><a class="archive-post-title" href="/2024/%E6%B1%A1%E7%82%B9%E5%88%86%E6%9E%90%E5%B7%A5%E5%85%B7%E2%80%94%E2%80%94libdft64/">污点分析工具——libdft64</a><span class="archive-post-date"> - 2024 年 5 月 17 日</span></li></ul></div><div id="posts-list-符号执行" class="archive " data-category="符号执行" data-parent-categories="安全"><h4 class="archive-title text-xlarge"><a class="link-unstyled" href="/categories/%E5%AE%89%E5%85%A8/%E7%AC%A6%E5%8F%B7%E6%89%A7%E8%A1%8C/">符号执行 (3)</a></h4><ul class="archive-posts"><li class="archive-post"><a class="archive-post-title" href="/2024/Symbion%E5%88%9D%E6%8E%A2/">交替符号执行工具——Symbion 初探</a><span class="archive-post-date"> - 2024 年 2 月 27 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2024/Angr%E9%9B%B6%E5%9F%BA%E7%A1%80%E5%85%A5%E9%97%A8/">符号执行工具——Angr 零基础入门</a><span class="archive-post-date"> - 2024 年 1 月 23 日</span></li><li class="archive-post"><a class="archive-post-title" href="/2023/%E7%AC%A6%E5%8F%B7%E6%89%A7%E8%A1%8C%E4%B8%8E%E6%B7%B7%E5%90%88%E6%A8%A1%E7%B3%8A%E6%B5%8B%E8%AF%95/">符号执行与混合模糊测试</a><span class="archive-post-date"> - 2023 年 12 月 24 日</span></li></ul></div></ul></div>
             
         
             
diff --git a/all-tags/index.html b/all-tags/index.html
index 310e145..d0a4b92 100644
--- a/all-tags/index.html
+++ b/all-tags/index.html
@@ -466,7 +466,7 @@ <h4 class="archive-title">
                 <ul class="archive-posts">
                     
                         <li class="archive-post">
-                            <a class="archive-post-title" href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/">
+                            <a class="archive-post-title" href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/">
                                 ClusterFuzz 源码分析（一）
                             </a>
                             <span class="archive-post-date">
@@ -767,7 +767,7 @@ <h4 class="archive-title">
                 <ul class="archive-posts">
                     
                         <li class="archive-post">
-                            <a class="archive-post-title" href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/">
+                            <a class="archive-post-title" href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/">
                                 ClusterFuzz 源码分析（一）
                             </a>
                             <span class="archive-post-date">
@@ -897,7 +897,7 @@ <h4 class="archive-title">
                 <ul class="archive-posts">
                     
                         <li class="archive-post">
-                            <a class="archive-post-title" href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/">
+                            <a class="archive-post-title" href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/">
                                 ClusterFuzz 源码分析（一）
                             </a>
                             <span class="archive-post-date">
diff --git a/archives/2024/10/index.html b/archives/2024/10/index.html
index 9f64ffb..b208986 100644
--- a/archives/2024/10/index.html
+++ b/archives/2024/10/index.html
@@ -220,7 +220,7 @@ <h5 class="sidebar-profile-bio"><p>个人技术博客<br>涉猎开发、测试
             <div class="postShorten-header">
                 <h1 class="postShorten-title">
                     
-                        <a class="link-unstyled" href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/" aria-label=": ClusterFuzz 源码分析（一）">
+                        <a class="link-unstyled" href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/" aria-label=": ClusterFuzz 源码分析（一）">
                             ClusterFuzz 源码分析（一）
                         </a>
                     
@@ -246,7 +246,7 @@ <h1 class="postShorten-title">
                     <!--excerpt-->
 
 <p><a target="_blank" rel="external nofollow noopener noreferrer" href="https://google.github.io/clusterfuzz/">ClusterFuzz</a>是 Google 开源的一个模糊测试平台，它集成了多种 Fuzz 引擎，如 Libfuzzer、AFL、Honggfuzz 等，支持跨平台，且具有高度可扩展性。</p>
-<h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介</h2><p>ClusterFuzz 官网的运作流程图如下：<br><img src="/./ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/overview.png" alt="ClusterFuzz 流程"></p>
+<h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介</h2><p>ClusterFuzz 官网的运作流程图如下：<br><img src="/./ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/overview.png" alt="ClusterFuzz 流程"></p>
 <p>Fuzz 测试中，编写 fuzzer 和修复 bug 需要人工操作，ClusterFuzz 将这两个环节之外的部分都给自动化了，包括 Fuzz 执行、crash 去重、testcase 精简等。</p>
 <p>ClusterFuzz 有两个核心组件：</p>
 <ul>
@@ -264,7 +264,7 @@ <h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介<
 <p>ClusterFuzz 定义的 Fuzz Bot 有两种类型：</p>
 <ul>
 <li>可抢占的：机器可以随时关闭，且只能运行 fuzz 任务</li>
-<li>不可抢占的：机器不会关闭，能不间断运行各种类型的任务<br><img src="/./ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/task.png" alt="Fuzz Bot"></li>
+<li>不可抢占的：机器不会关闭，能不间断运行各种类型的任务<br><img src="/./ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/task.png" alt="Fuzz Bot"></li>
 </ul>
 <h2 id="代码概要"><a href="# 代码概要" class="headerlink" title="代码概要"></a>代码概要 </h2><p>Google 开源了 ClusterFuzz 的<a target="_blank" rel="external nofollow noopener noreferrer" href="https://github.com/google/clusterfuzz"> 代码仓</a>，项目 python 为主，读起来相对容易。</p>
 <p>代码结构大致为：</p>
@@ -341,7 +341,7 @@ <h2 id="代码概要"><a href="# 代码概要" class="headerlink" title="代码
                     
                     
                         <p>
-                            <a href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/#post-footer" class="postShorten-excerpt_link link" aria-label>
+                            <a href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/#post-footer" class="postShorten-excerpt_link link" aria-label>
                                 评论和共享
                             </a>
                         </p>
diff --git a/archives/2024/index.html b/archives/2024/index.html
index 81e3e74..170f2f5 100644
--- a/archives/2024/index.html
+++ b/archives/2024/index.html
@@ -220,7 +220,7 @@ <h5 class="sidebar-profile-bio"><p>个人技术博客<br>涉猎开发、测试
             <div class="postShorten-header">
                 <h1 class="postShorten-title">
                     
-                        <a class="link-unstyled" href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/" aria-label=": ClusterFuzz 源码分析（一）">
+                        <a class="link-unstyled" href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/" aria-label=": ClusterFuzz 源码分析（一）">
                             ClusterFuzz 源码分析（一）
                         </a>
                     
@@ -246,7 +246,7 @@ <h1 class="postShorten-title">
                     <!--excerpt-->
 
 <p><a target="_blank" rel="external nofollow noopener noreferrer" href="https://google.github.io/clusterfuzz/">ClusterFuzz</a>是 Google 开源的一个模糊测试平台，它集成了多种 Fuzz 引擎，如 Libfuzzer、AFL、Honggfuzz 等，支持跨平台，且具有高度可扩展性。</p>
-<h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介</h2><p>ClusterFuzz 官网的运作流程图如下：<br><img src="/./ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/overview.png" alt="ClusterFuzz 流程"></p>
+<h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介</h2><p>ClusterFuzz 官网的运作流程图如下：<br><img src="/./ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/overview.png" alt="ClusterFuzz 流程"></p>
 <p>Fuzz 测试中，编写 fuzzer 和修复 bug 需要人工操作，ClusterFuzz 将这两个环节之外的部分都给自动化了，包括 Fuzz 执行、crash 去重、testcase 精简等。</p>
 <p>ClusterFuzz 有两个核心组件：</p>
 <ul>
@@ -264,7 +264,7 @@ <h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介<
 <p>ClusterFuzz 定义的 Fuzz Bot 有两种类型：</p>
 <ul>
 <li>可抢占的：机器可以随时关闭，且只能运行 fuzz 任务</li>
-<li>不可抢占的：机器不会关闭，能不间断运行各种类型的任务<br><img src="/./ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/task.png" alt="Fuzz Bot"></li>
+<li>不可抢占的：机器不会关闭，能不间断运行各种类型的任务<br><img src="/./ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/task.png" alt="Fuzz Bot"></li>
 </ul>
 <h2 id="代码概要"><a href="# 代码概要" class="headerlink" title="代码概要"></a>代码概要 </h2><p>Google 开源了 ClusterFuzz 的<a target="_blank" rel="external nofollow noopener noreferrer" href="https://github.com/google/clusterfuzz"> 代码仓</a>，项目 python 为主，读起来相对容易。</p>
 <p>代码结构大致为：</p>
@@ -341,7 +341,7 @@ <h2 id="代码概要"><a href="# 代码概要" class="headerlink" title="代码
                     
                     
                         <p>
-                            <a href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/#post-footer" class="postShorten-excerpt_link link" aria-label>
+                            <a href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/#post-footer" class="postShorten-excerpt_link link" aria-label>
                                 评论和共享
                             </a>
                         </p>
diff --git a/archives/index.html b/archives/index.html
index e1bf062..aaeca38 100644
--- a/archives/index.html
+++ b/archives/index.html
@@ -220,7 +220,7 @@ <h5 class="sidebar-profile-bio"><p>个人技术博客<br>涉猎开发、测试
             <div class="postShorten-header">
                 <h1 class="postShorten-title">
                     
-                        <a class="link-unstyled" href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/" aria-label=": ClusterFuzz 源码分析（一）">
+                        <a class="link-unstyled" href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/" aria-label=": ClusterFuzz 源码分析（一）">
                             ClusterFuzz 源码分析（一）
                         </a>
                     
@@ -246,7 +246,7 @@ <h1 class="postShorten-title">
                     <!--excerpt-->
 
 <p><a target="_blank" rel="external nofollow noopener noreferrer" href="https://google.github.io/clusterfuzz/">ClusterFuzz</a>是 Google 开源的一个模糊测试平台，它集成了多种 Fuzz 引擎，如 Libfuzzer、AFL、Honggfuzz 等，支持跨平台，且具有高度可扩展性。</p>
-<h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介</h2><p>ClusterFuzz 官网的运作流程图如下：<br><img src="/./ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/overview.png" alt="ClusterFuzz 流程"></p>
+<h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介</h2><p>ClusterFuzz 官网的运作流程图如下：<br><img src="/./ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/overview.png" alt="ClusterFuzz 流程"></p>
 <p>Fuzz 测试中，编写 fuzzer 和修复 bug 需要人工操作，ClusterFuzz 将这两个环节之外的部分都给自动化了，包括 Fuzz 执行、crash 去重、testcase 精简等。</p>
 <p>ClusterFuzz 有两个核心组件：</p>
 <ul>
@@ -264,7 +264,7 @@ <h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介<
 <p>ClusterFuzz 定义的 Fuzz Bot 有两种类型：</p>
 <ul>
 <li>可抢占的：机器可以随时关闭，且只能运行 fuzz 任务</li>
-<li>不可抢占的：机器不会关闭，能不间断运行各种类型的任务<br><img src="/./ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/task.png" alt="Fuzz Bot"></li>
+<li>不可抢占的：机器不会关闭，能不间断运行各种类型的任务<br><img src="/./ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/task.png" alt="Fuzz Bot"></li>
 </ul>
 <h2 id="代码概要"><a href="# 代码概要" class="headerlink" title="代码概要"></a>代码概要 </h2><p>Google 开源了 ClusterFuzz 的<a target="_blank" rel="external nofollow noopener noreferrer" href="https://github.com/google/clusterfuzz"> 代码仓</a>，项目 python 为主，读起来相对容易。</p>
 <p>代码结构大致为：</p>
@@ -341,7 +341,7 @@ <h2 id="代码概要"><a href="# 代码概要" class="headerlink" title="代码
                     
                     
                         <p>
-                            <a href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/#post-footer" class="postShorten-excerpt_link link" aria-label>
+                            <a href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/#post-footer" class="postShorten-excerpt_link link" aria-label>
                                 评论和共享
                             </a>
                         </p>
diff --git a/baidusitemap.xml b/baidusitemap.xml
index 8115967..c7cf690 100644
--- a/baidusitemap.xml
+++ b/baidusitemap.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
   <url>
-    <loc>https://www.stepbystep.asia/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/</loc>
+    <loc>https://www.stepbystep.asia/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/</loc>
     <lastmod>2024-10-10</lastmod>
   </url>
   <url>
diff --git "a/categories/\345\256\211\345\205\250/index.html" "b/categories/\345\256\211\345\205\250/index.html"
index 48719c5..b335033 100644
--- "a/categories/\345\256\211\345\205\250/index.html"
+++ "b/categories/\345\256\211\345\205\250/index.html"
@@ -220,7 +220,7 @@ <h5 class="sidebar-profile-bio"><p>个人技术博客<br>涉猎开发、测试
             <div class="postShorten-header">
                 <h1 class="postShorten-title">
                     
-                        <a class="link-unstyled" href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/" aria-label=": ClusterFuzz 源码分析（一）">
+                        <a class="link-unstyled" href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/" aria-label=": ClusterFuzz 源码分析（一）">
                             ClusterFuzz 源码分析（一）
                         </a>
                     
@@ -246,7 +246,7 @@ <h1 class="postShorten-title">
                     <!--excerpt-->
 
 <p><a target="_blank" rel="external nofollow noopener noreferrer" href="https://google.github.io/clusterfuzz/">ClusterFuzz</a>是 Google 开源的一个模糊测试平台，它集成了多种 Fuzz 引擎，如 Libfuzzer、AFL、Honggfuzz 等，支持跨平台，且具有高度可扩展性。</p>
-<h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介</h2><p>ClusterFuzz 官网的运作流程图如下：<br><img src="/./ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/overview.png" alt="ClusterFuzz 流程"></p>
+<h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介</h2><p>ClusterFuzz 官网的运作流程图如下：<br><img src="/./ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/overview.png" alt="ClusterFuzz 流程"></p>
 <p>Fuzz 测试中，编写 fuzzer 和修复 bug 需要人工操作，ClusterFuzz 将这两个环节之外的部分都给自动化了，包括 Fuzz 执行、crash 去重、testcase 精简等。</p>
 <p>ClusterFuzz 有两个核心组件：</p>
 <ul>
@@ -264,7 +264,7 @@ <h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介<
 <p>ClusterFuzz 定义的 Fuzz Bot 有两种类型：</p>
 <ul>
 <li>可抢占的：机器可以随时关闭，且只能运行 fuzz 任务</li>
-<li>不可抢占的：机器不会关闭，能不间断运行各种类型的任务<br><img src="/./ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/task.png" alt="Fuzz Bot"></li>
+<li>不可抢占的：机器不会关闭，能不间断运行各种类型的任务<br><img src="/./ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/task.png" alt="Fuzz Bot"></li>
 </ul>
 <h2 id="代码概要"><a href="# 代码概要" class="headerlink" title="代码概要"></a>代码概要 </h2><p>Google 开源了 ClusterFuzz 的<a target="_blank" rel="external nofollow noopener noreferrer" href="https://github.com/google/clusterfuzz"> 代码仓</a>，项目 python 为主，读起来相对容易。</p>
 <p>代码结构大致为：</p>
@@ -341,7 +341,7 @@ <h2 id="代码概要"><a href="# 代码概要" class="headerlink" title="代码
                     
                     
                         <p>
-                            <a href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/#post-footer" class="postShorten-excerpt_link link" aria-label>
+                            <a href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/#post-footer" class="postShorten-excerpt_link link" aria-label>
                                 评论和共享
                             </a>
                         </p>
diff --git "a/categories/\345\256\211\345\205\250/\346\250\241\347\263\212\346\265\213\350\257\225/index.html" "b/categories/\345\256\211\345\205\250/\346\250\241\347\263\212\346\265\213\350\257\225/index.html"
index 0be3fe9..4799ad0 100644
--- "a/categories/\345\256\211\345\205\250/\346\250\241\347\263\212\346\265\213\350\257\225/index.html"
+++ "b/categories/\345\256\211\345\205\250/\346\250\241\347\263\212\346\265\213\350\257\225/index.html"
@@ -220,7 +220,7 @@ <h5 class="sidebar-profile-bio"><p>个人技术博客<br>涉猎开发、测试
             <div class="postShorten-header">
                 <h1 class="postShorten-title">
                     
-                        <a class="link-unstyled" href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/" aria-label=": ClusterFuzz 源码分析（一）">
+                        <a class="link-unstyled" href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/" aria-label=": ClusterFuzz 源码分析（一）">
                             ClusterFuzz 源码分析（一）
                         </a>
                     
@@ -246,7 +246,7 @@ <h1 class="postShorten-title">
                     <!--excerpt-->
 
 <p><a target="_blank" rel="external nofollow noopener noreferrer" href="https://google.github.io/clusterfuzz/">ClusterFuzz</a>是 Google 开源的一个模糊测试平台，它集成了多种 Fuzz 引擎，如 Libfuzzer、AFL、Honggfuzz 等，支持跨平台，且具有高度可扩展性。</p>
-<h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介</h2><p>ClusterFuzz 官网的运作流程图如下：<br><img src="/./ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/overview.png" alt="ClusterFuzz 流程"></p>
+<h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介</h2><p>ClusterFuzz 官网的运作流程图如下：<br><img src="/./ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/overview.png" alt="ClusterFuzz 流程"></p>
 <p>Fuzz 测试中，编写 fuzzer 和修复 bug 需要人工操作，ClusterFuzz 将这两个环节之外的部分都给自动化了，包括 Fuzz 执行、crash 去重、testcase 精简等。</p>
 <p>ClusterFuzz 有两个核心组件：</p>
 <ul>
@@ -264,7 +264,7 @@ <h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介<
 <p>ClusterFuzz 定义的 Fuzz Bot 有两种类型：</p>
 <ul>
 <li>可抢占的：机器可以随时关闭，且只能运行 fuzz 任务</li>
-<li>不可抢占的：机器不会关闭，能不间断运行各种类型的任务<br><img src="/./ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/task.png" alt="Fuzz Bot"></li>
+<li>不可抢占的：机器不会关闭，能不间断运行各种类型的任务<br><img src="/./ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/task.png" alt="Fuzz Bot"></li>
 </ul>
 <h2 id="代码概要"><a href="# 代码概要" class="headerlink" title="代码概要"></a>代码概要 </h2><p>Google 开源了 ClusterFuzz 的<a target="_blank" rel="external nofollow noopener noreferrer" href="https://github.com/google/clusterfuzz"> 代码仓</a>，项目 python 为主，读起来相对容易。</p>
 <p>代码结构大致为：</p>
@@ -341,7 +341,7 @@ <h2 id="代码概要"><a href="# 代码概要" class="headerlink" title="代码
                     
                     
                         <p>
-                            <a href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/#post-footer" class="postShorten-excerpt_link link" aria-label>
+                            <a href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/#post-footer" class="postShorten-excerpt_link link" aria-label>
                                 评论和共享
                             </a>
                         </p>
diff --git a/index.html b/index.html
index 50a15a1..54ccb6a 100644
--- a/index.html
+++ b/index.html
@@ -219,7 +219,7 @@ <h5 class="sidebar-profile-bio"><p>个人技术博客<br>涉猎开发、测试
             <div class="postShorten-header">
                 <h1 class="postShorten-title">
                     
-                        <a class="link-unstyled" href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/" aria-label=": ClusterFuzz 源码分析（一）">
+                        <a class="link-unstyled" href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/" aria-label=": ClusterFuzz 源码分析（一）">
                             ClusterFuzz 源码分析（一）
                         </a>
                     
@@ -245,7 +245,7 @@ <h1 class="postShorten-title">
                     <!--excerpt-->
 
 <p><a target="_blank" rel="external nofollow noopener noreferrer" href="https://google.github.io/clusterfuzz/">ClusterFuzz</a>是 Google 开源的一个模糊测试平台，它集成了多种 Fuzz 引擎，如 Libfuzzer、AFL、Honggfuzz 等，支持跨平台，且具有高度可扩展性。</p>
-<h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介</h2><p>ClusterFuzz 官网的运作流程图如下：<br><img src="/./ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/overview.png" alt="ClusterFuzz 流程"></p>
+<h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介</h2><p>ClusterFuzz 官网的运作流程图如下：<br><img src="/./ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/overview.png" alt="ClusterFuzz 流程"></p>
 <p>Fuzz 测试中，编写 fuzzer 和修复 bug 需要人工操作，ClusterFuzz 将这两个环节之外的部分都给自动化了，包括 Fuzz 执行、crash 去重、testcase 精简等。</p>
 <p>ClusterFuzz 有两个核心组件：</p>
 <ul>
@@ -263,7 +263,7 @@ <h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介<
 <p>ClusterFuzz 定义的 Fuzz Bot 有两种类型：</p>
 <ul>
 <li>可抢占的：机器可以随时关闭，且只能运行 fuzz 任务</li>
-<li>不可抢占的：机器不会关闭，能不间断运行各种类型的任务<br><img src="/./ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/task.png" alt="Fuzz Bot"></li>
+<li>不可抢占的：机器不会关闭，能不间断运行各种类型的任务<br><img src="/./ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/task.png" alt="Fuzz Bot"></li>
 </ul>
 <h2 id="代码概要"><a href="# 代码概要" class="headerlink" title="代码概要"></a>代码概要 </h2><p>Google 开源了 ClusterFuzz 的<a target="_blank" rel="external nofollow noopener noreferrer" href="https://github.com/google/clusterfuzz"> 代码仓</a>，项目 python 为主，读起来相对容易。</p>
 <p>代码结构大致为：</p>
@@ -340,7 +340,7 @@ <h2 id="代码概要"><a href="# 代码概要" class="headerlink" title="代码
                     
                     
                         <p>
-                            <a href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/#post-footer" class="postShorten-excerpt_link link" aria-label>
+                            <a href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/#post-footer" class="postShorten-excerpt_link link" aria-label>
                                 评论和共享
                             </a>
                         </p>
diff --git a/sitemap.xml b/sitemap.xml
index 2a7f266..c582882 100644
--- a/sitemap.xml
+++ b/sitemap.xml
@@ -2,7 +2,7 @@
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
   
   <url>
-    <loc>https://www.stepbystep.asia/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/</loc>
+    <loc>https://www.stepbystep.asia/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/</loc>
     
     <lastmod>2024-10-10</lastmod>
     
@@ -236,35 +236,35 @@
 
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/AFL/</loc>
+    <loc>https://www.stepbystep.asia/tags/%E7%AC%A6%E5%8F%B7%E6%89%A7%E8%A1%8C/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/Fuzz/</loc>
+    <loc>https://www.stepbystep.asia/tags/%E5%AE%89%E5%85%A8/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/%E5%AE%89%E5%85%A8/</loc>
+    <loc>https://www.stepbystep.asia/tags/%E5%B7%A5%E5%85%B7/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/%E5%B7%A5%E5%85%B7/</loc>
+    <loc>https://www.stepbystep.asia/tags/AFL/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/%E7%AC%A6%E5%8F%B7%E6%89%A7%E8%A1%8C/</loc>
+    <loc>https://www.stepbystep.asia/tags/Fuzz/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
@@ -341,70 +341,70 @@
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/Linux/</loc>
+    <loc>https://www.stepbystep.asia/tags/LibFuzzer/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/</loc>
+    <loc>https://www.stepbystep.asia/tags/Linux/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/%E5%91%BD%E4%BB%A4/</loc>
+    <loc>https://www.stepbystep.asia/tags/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/LibFuzzer/</loc>
+    <loc>https://www.stepbystep.asia/tags/%E5%91%BD%E4%BB%A4/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/Web/</loc>
+    <loc>https://www.stepbystep.asia/tags/Python/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/%E7%88%AC%E8%99%AB/</loc>
+    <loc>https://www.stepbystep.asia/tags/IntelPin/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/python/</loc>
+    <loc>https://www.stepbystep.asia/tags/%E6%B1%A1%E7%82%B9%E5%88%86%E6%9E%90/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/Python/</loc>
+    <loc>https://www.stepbystep.asia/tags/Web/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/IntelPin/</loc>
+    <loc>https://www.stepbystep.asia/tags/%E7%88%AC%E8%99%AB/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/%E6%B1%A1%E7%82%B9%E5%88%86%E6%9E%90/</loc>
+    <loc>https://www.stepbystep.asia/tags/python/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
@@ -420,84 +420,84 @@
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/categories/%E5%AE%89%E5%85%A8/%E6%A8%A1%E7%B3%8A%E6%B5%8B%E8%AF%95/</loc>
+    <loc>https://www.stepbystep.asia/categories/%E5%AE%89%E5%85%A8/%E7%AC%A6%E5%8F%B7%E6%89%A7%E8%A1%8C/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/categories/%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8%80/</loc>
+    <loc>https://www.stepbystep.asia/categories/%E5%AE%89%E5%85%A8/%E6%A8%A1%E7%B3%8A%E6%B5%8B%E8%AF%95/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/categories/%E5%AE%89%E5%85%A8/%E7%AC%A6%E5%8F%B7%E6%89%A7%E8%A1%8C/</loc>
+    <loc>https://www.stepbystep.asia/categories/%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8%80/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/categories/%E5%BC%80%E5%8F%91/</loc>
+    <loc>https://www.stepbystep.asia/categories/%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8%80/C/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/categories/%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8%80/C/</loc>
+    <loc>https://www.stepbystep.asia/categories/%E5%BC%80%E5%8F%91/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/categories/%E5%BC%80%E5%8F%91/Docker/</loc>
+    <loc>https://www.stepbystep.asia/categories/web/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/categories/web/</loc>
+    <loc>https://www.stepbystep.asia/categories/%E5%BC%80%E5%8F%91/Docker/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/categories/%E5%BC%80%E5%8F%91/Linux/</loc>
+    <loc>https://www.stepbystep.asia/categories/%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8%80/Python/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/categories/web/%E4%B8%AA%E4%BA%BA%E5%8D%9A%E5%AE%A2/</loc>
+    <loc>https://www.stepbystep.asia/categories/%E5%AE%89%E5%85%A8/%E6%B1%A1%E7%82%B9%E5%88%86%E6%9E%90/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/categories/%E5%BC%80%E5%8F%91/%E7%88%AC%E8%99%AB/</loc>
+    <loc>https://www.stepbystep.asia/categories/web/%E4%B8%AA%E4%BA%BA%E5%8D%9A%E5%AE%A2/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/categories/%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8%80/Python/</loc>
+    <loc>https://www.stepbystep.asia/categories/%E5%BC%80%E5%8F%91/Linux/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/categories/%E5%AE%89%E5%85%A8/%E6%B1%A1%E7%82%B9%E5%88%86%E6%9E%90/</loc>
+    <loc>https://www.stepbystep.asia/categories/%E5%BC%80%E5%8F%91/%E7%88%AC%E8%99%AB/</loc>
     <lastmod>2024-10-10</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
diff --git a/tags/AFL/index.html b/tags/AFL/index.html
index 9ec261d..0f4c584 100644
--- a/tags/AFL/index.html
+++ b/tags/AFL/index.html
@@ -7,7 +7,7 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <meta name="generator" content="千里之行，始于足下">
-    <title>标签: AFL - 千里之行，始于足下</title>
+    <title>标签: AFL++ - 千里之行，始于足下</title>
     <meta name="author" content="一瓢清浅">
     
         <meta name="keywords" content="python,AI,安全,算法,编程,">
@@ -220,15 +220,15 @@ <h5 class="sidebar-profile-bio"><p>个人技术博客<br>涉猎开发、测试
             <div class="postShorten-header">
                 <h1 class="postShorten-title">
                     
-                        <a class="link-unstyled" href="/2023/LibAFL%E7%AE%80%E4%BB%8B/" aria-label=": LibAFL 简介">
-                            LibAFL 简介
+                        <a class="link-unstyled" href="/2024/AFLplusplus%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E2%80%94%E2%80%94%E8%A6%86%E7%9B%96%E7%8E%87/" aria-label=": AFL++ 源码分析——覆盖率">
+                            AFL++ 源码分析——覆盖率
                         </a>
                     
                 </h1>
                 <div class="postShorten-meta">
-    <time datetime="2023-11-18T10:38:08+08:00">
+    <time datetime="2024-08-15T17:28:52+08:00">
 	
-		    2023 年 11 月 18 日
+		    2024 年 8 月 15 日
     	
     </time>
     
@@ -243,9 +243,9 @@ <h1 class="postShorten-title">
             </div>
             
                 <div class="postShorten-excerpt">
-                    <p>LibAFL 是用 Rust 开发的一款模糊测试库，支持 Fuzz 各模块的灵活定制 </p>
+                    <p>分析 AFL++ 度量覆盖率的相关代码</p>
                     
-                        <a href="/2023/LibAFL%E7%AE%80%E4%BB%8B/" class="postShorten-excerpt_link link" aria-label=": LibAFL 简介">
+                        <a href="/2024/AFLplusplus%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E2%80%94%E2%80%94%E8%A6%86%E7%9B%96%E7%8E%87/" class="postShorten-excerpt_link link" aria-label=": AFL++ 源码分析——覆盖率">
                             阅读全文
                         </a>
                         
@@ -263,15 +263,58 @@ <h1 class="postShorten-title">
             <div class="postShorten-header">
                 <h1 class="postShorten-title">
                     
-                        <a class="link-unstyled" href="/2023/AFL%E5%8E%9F%E7%90%86%E4%B8%8E%E5%AE%9E%E8%B7%B5/" aria-label=": AFL 原理与实践">
-                            AFL 原理与实践
+                        <a class="link-unstyled" href="/2024/%E7%94%B1subprocess-PIPE%E5%BC%95%E5%8F%91%E7%9A%84%E8%A1%80%E6%A1%88/" aria-label=": 由 subprocess.PIPE 引发的血案">
+                            由 subprocess.PIPE 引发的血案
                         </a>
                     
                 </h1>
                 <div class="postShorten-meta">
-    <time datetime="2023-10-15T11:23:55+08:00">
+    <time datetime="2024-07-30T16:19:00+08:00">
 	
-		    2023 年 10 月 15 日
+		    2024 年 7 月 30 日
+    	
+    </time>
+    
+        <span>发布在 </span>
+        
+    <a class="category-link" href="/categories/%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8%80/">编程语言</a>, <a class="category-link" href="/categories/%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8%80/Python/">Python</a>
+
+
+    
+</div>
+
+            </div>
+            
+                <div class="postShorten-excerpt">
+                    <p>找了大半个月 AFL++ 不同步的原因，到头来都是 subprocess 的锅</p>
+                    
+                        <a href="/2024/%E7%94%B1subprocess-PIPE%E5%BC%95%E5%8F%91%E7%9A%84%E8%A1%80%E6%A1%88/" class="postShorten-excerpt_link link" aria-label=": 由 subprocess.PIPE 引发的血案">
+                            阅读全文
+                        </a>
+                        
+                    
+                </div>
+            
+        </div>
+        
+    </article>
+    
+    
+    <article class="postShorten postShorten--thumbnailimg-right">
+        <div class="postShorten-wrap">
+            
+            <div class="postShorten-header">
+                <h1 class="postShorten-title">
+                    
+                        <a class="link-unstyled" href="/2024/AFLplusplus%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E2%80%94%E2%80%94%E5%90%8C%E6%AD%A5%E6%9C%BA%E5%88%B6/" aria-label=": AFLplusplus 源码分析——同步机制">
+                            AFLplusplus 源码分析——同步机制
+                        </a>
+                    
+                </h1>
+                <div class="postShorten-meta">
+    <time datetime="2024-07-16T09:02:06+08:00">
+	
+		    2024 年 7 月 16 日
     	
     </time>
     
@@ -286,9 +329,9 @@ <h1 class="postShorten-title">
             </div>
             
                 <div class="postShorten-excerpt">
-                    <p>模糊测试工具 AFL（American Fuzzy Lop）的原理介绍与实践应用</p>
+                    <p>分析 AFL++ 同步机制的相关源码</p>
                     
-                        <a href="/2023/AFL%E5%8E%9F%E7%90%86%E4%B8%8E%E5%AE%9E%E8%B7%B5/" class="postShorten-excerpt_link link" aria-label=": AFL 原理与实践">
+                        <a href="/2024/AFLplusplus%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E2%80%94%E2%80%94%E5%90%8C%E6%AD%A5%E6%9C%BA%E5%88%B6/" class="postShorten-excerpt_link link" aria-label=": AFLplusplus 源码分析——同步机制">
                             阅读全文
                         </a>
                         
diff --git a/tags/Fuzz/index.html b/tags/Fuzz/index.html
index 3f2790f..d280388 100644
--- a/tags/Fuzz/index.html
+++ b/tags/Fuzz/index.html
@@ -220,7 +220,7 @@ <h5 class="sidebar-profile-bio"><p>个人技术博客<br>涉猎开发、测试
             <div class="postShorten-header">
                 <h1 class="postShorten-title">
                     
-                        <a class="link-unstyled" href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/" aria-label=": ClusterFuzz 源码分析（一）">
+                        <a class="link-unstyled" href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/" aria-label=": ClusterFuzz 源码分析（一）">
                             ClusterFuzz 源码分析（一）
                         </a>
                     
@@ -246,7 +246,7 @@ <h1 class="postShorten-title">
                     <!--excerpt-->
 
 <p><a target="_blank" rel="external nofollow noopener noreferrer" href="https://google.github.io/clusterfuzz/">ClusterFuzz</a>是 Google 开源的一个模糊测试平台，它集成了多种 Fuzz 引擎，如 Libfuzzer、AFL、Honggfuzz 等，支持跨平台，且具有高度可扩展性。</p>
-<h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介</h2><p>ClusterFuzz 官网的运作流程图如下：<br><img src="/./ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/overview.png" alt="ClusterFuzz 流程"></p>
+<h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介</h2><p>ClusterFuzz 官网的运作流程图如下：<br><img src="/./ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/overview.png" alt="ClusterFuzz 流程"></p>
 <p>Fuzz 测试中，编写 fuzzer 和修复 bug 需要人工操作，ClusterFuzz 将这两个环节之外的部分都给自动化了，包括 Fuzz 执行、crash 去重、testcase 精简等。</p>
 <p>ClusterFuzz 有两个核心组件：</p>
 <ul>
@@ -264,7 +264,7 @@ <h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介<
 <p>ClusterFuzz 定义的 Fuzz Bot 有两种类型：</p>
 <ul>
 <li>可抢占的：机器可以随时关闭，且只能运行 fuzz 任务</li>
-<li>不可抢占的：机器不会关闭，能不间断运行各种类型的任务<br><img src="/./ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/task.png" alt="Fuzz Bot"></li>
+<li>不可抢占的：机器不会关闭，能不间断运行各种类型的任务<br><img src="/./ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/task.png" alt="Fuzz Bot"></li>
 </ul>
 <h2 id="代码概要"><a href="# 代码概要" class="headerlink" title="代码概要"></a>代码概要 </h2><p>Google 开源了 ClusterFuzz 的<a target="_blank" rel="external nofollow noopener noreferrer" href="https://github.com/google/clusterfuzz"> 代码仓</a>，项目 python 为主，读起来相对容易。</p>
 <p>代码结构大致为：</p>
@@ -341,7 +341,7 @@ <h2 id="代码概要"><a href="# 代码概要" class="headerlink" title="代码
                     
                     
                         <p>
-                            <a href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/#post-footer" class="postShorten-excerpt_link link" aria-label>
+                            <a href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/#post-footer" class="postShorten-excerpt_link link" aria-label>
                                 评论和共享
                             </a>
                         </p>
diff --git a/tags/python/index.html b/tags/python/index.html
index 7d4e609..95c2411 100644
--- a/tags/python/index.html
+++ b/tags/python/index.html
@@ -7,7 +7,7 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <meta name="generator" content="千里之行，始于足下">
-    <title>标签: Python - 千里之行，始于足下</title>
+    <title>标签: python - 千里之行，始于足下</title>
     <meta name="author" content="一瓢清浅">
     
         <meta name="keywords" content="python,AI,安全,算法,编程,">
@@ -18,7 +18,7 @@
     <meta name="description" content="个人技术博客，涉及编程(python，c++)、安全测试、Web开发、AI算法等IT领域">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="千里之行，始于足下">
-<meta property="og:url" content="https://www.stepbystep.asia/tags/Python/index.html">
+<meta property="og:url" content="https://www.stepbystep.asia/tags/python/index.html">
 <meta property="og:site_name" content="千里之行，始于足下">
 <meta property="og:description" content="个人技术博客，涉及编程(python，c++)、安全测试、Web开发、AI算法等IT领域">
 <meta property="og:locale" content="zh_CN">
@@ -220,21 +220,21 @@ <h5 class="sidebar-profile-bio"><p>个人技术博客<br>涉猎开发、测试
             <div class="postShorten-header">
                 <h1 class="postShorten-title">
                     
-                        <a class="link-unstyled" href="/2024/%E7%94%B1subprocess-PIPE%E5%BC%95%E5%8F%91%E7%9A%84%E8%A1%80%E6%A1%88/" aria-label=": 由 subprocess.PIPE 引发的血案">
-                            由 subprocess.PIPE 引发的血案
+                        <a class="link-unstyled" href="/2023/%E9%9B%B6%E5%9F%BA%E7%A1%80%E7%88%AC%E8%99%AB%E5%85%A5%E9%97%A8/" aria-label=": 零基础爬虫入门">
+                            零基础爬虫入门
                         </a>
                     
                 </h1>
                 <div class="postShorten-meta">
-    <time datetime="2024-07-30T16:19:00+08:00">
+    <time datetime="2023-01-08T14:05:37+08:00">
 	
-		    2024 年 7 月 30 日
+		    2023 年 1 月 8 日
     	
     </time>
     
         <span>发布在 </span>
         
-    <a class="category-link" href="/categories/%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8%80/">编程语言</a>, <a class="category-link" href="/categories/%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8%80/Python/">Python</a>
+    <a class="category-link" href="/categories/%E5%BC%80%E5%8F%91/">开发</a>, <a class="category-link" href="/categories/%E5%BC%80%E5%8F%91/%E7%88%AC%E8%99%AB/">爬虫</a>
 
 
     
@@ -243,52 +243,9 @@ <h1 class="postShorten-title">
             </div>
             
                 <div class="postShorten-excerpt">
-                    <p>找了大半个月 AFL++ 不同步的原因，到头来都是 subprocess 的锅</p>
+                    <p>从零开始学爬虫</p>
                     
-                        <a href="/2024/%E7%94%B1subprocess-PIPE%E5%BC%95%E5%8F%91%E7%9A%84%E8%A1%80%E6%A1%88/" class="postShorten-excerpt_link link" aria-label=": 由 subprocess.PIPE 引发的血案">
-                            阅读全文
-                        </a>
-                        
-                    
-                </div>
-            
-        </div>
-        
-    </article>
-    
-    
-    <article class="postShorten postShorten--thumbnailimg-right">
-        <div class="postShorten-wrap">
-            
-            <div class="postShorten-header">
-                <h1 class="postShorten-title">
-                    
-                        <a class="link-unstyled" href="/2024/Python%E8%BF%9B%E9%98%B6%E2%80%94%E2%80%94%E5%B9%B6%E5%8F%91%E7%BC%96%E7%A8%8B/" aria-label=": Python 进阶——并发编程">
-                            Python 进阶——并发编程
-                        </a>
-                    
-                </h1>
-                <div class="postShorten-meta">
-    <time datetime="2024-06-26T10:56:20+08:00">
-	
-		    2024 年 6 月 26 日
-    	
-    </time>
-    
-        <span>发布在 </span>
-        
-    <a class="category-link" href="/categories/%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8%80/">编程语言</a>, <a class="category-link" href="/categories/%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8%80/Python/">Python</a>
-
-
-    
-</div>
-
-            </div>
-            
-                <div class="postShorten-excerpt">
-                    <p>进程、线程、协程，并发编程绕不过的三座大山</p>
-                    
-                        <a href="/2024/Python%E8%BF%9B%E9%98%B6%E2%80%94%E2%80%94%E5%B9%B6%E5%8F%91%E7%BC%96%E7%A8%8B/" class="postShorten-excerpt_link link" aria-label=": Python 进阶——并发编程">
+                        <a href="/2023/%E9%9B%B6%E5%9F%BA%E7%A1%80%E7%88%AC%E8%99%AB%E5%85%A5%E9%97%A8/" class="postShorten-excerpt_link link" aria-label=": 零基础爬虫入门">
                             阅读全文
                         </a>
                         
diff --git "a/tags/\345\256\211\345\205\250/index.html" "b/tags/\345\256\211\345\205\250/index.html"
index 8ccba45..b04460a 100644
--- "a/tags/\345\256\211\345\205\250/index.html"
+++ "b/tags/\345\256\211\345\205\250/index.html"
@@ -220,7 +220,7 @@ <h5 class="sidebar-profile-bio"><p>个人技术博客<br>涉猎开发、测试
             <div class="postShorten-header">
                 <h1 class="postShorten-title">
                     
-                        <a class="link-unstyled" href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/" aria-label=": ClusterFuzz 源码分析（一）">
+                        <a class="link-unstyled" href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/" aria-label=": ClusterFuzz 源码分析（一）">
                             ClusterFuzz 源码分析（一）
                         </a>
                     
@@ -246,7 +246,7 @@ <h1 class="postShorten-title">
                     <!--excerpt-->
 
 <p><a target="_blank" rel="external nofollow noopener noreferrer" href="https://google.github.io/clusterfuzz/">ClusterFuzz</a>是 Google 开源的一个模糊测试平台，它集成了多种 Fuzz 引擎，如 Libfuzzer、AFL、Honggfuzz 等，支持跨平台，且具有高度可扩展性。</p>
-<h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介</h2><p>ClusterFuzz 官网的运作流程图如下：<br><img src="/./ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/overview.png" alt="ClusterFuzz 流程"></p>
+<h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介</h2><p>ClusterFuzz 官网的运作流程图如下：<br><img src="/./ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/overview.png" alt="ClusterFuzz 流程"></p>
 <p>Fuzz 测试中，编写 fuzzer 和修复 bug 需要人工操作，ClusterFuzz 将这两个环节之外的部分都给自动化了，包括 Fuzz 执行、crash 去重、testcase 精简等。</p>
 <p>ClusterFuzz 有两个核心组件：</p>
 <ul>
@@ -264,7 +264,7 @@ <h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介<
 <p>ClusterFuzz 定义的 Fuzz Bot 有两种类型：</p>
 <ul>
 <li>可抢占的：机器可以随时关闭，且只能运行 fuzz 任务</li>
-<li>不可抢占的：机器不会关闭，能不间断运行各种类型的任务<br><img src="/./ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/task.png" alt="Fuzz Bot"></li>
+<li>不可抢占的：机器不会关闭，能不间断运行各种类型的任务<br><img src="/./ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/task.png" alt="Fuzz Bot"></li>
 </ul>
 <h2 id="代码概要"><a href="# 代码概要" class="headerlink" title="代码概要"></a>代码概要 </h2><p>Google 开源了 ClusterFuzz 的<a target="_blank" rel="external nofollow noopener noreferrer" href="https://github.com/google/clusterfuzz"> 代码仓</a>，项目 python 为主，读起来相对容易。</p>
 <p>代码结构大致为：</p>
@@ -341,7 +341,7 @@ <h2 id="代码概要"><a href="# 代码概要" class="headerlink" title="代码
                     
                     
                         <p>
-                            <a href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/#post-footer" class="postShorten-excerpt_link link" aria-label>
+                            <a href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/#post-footer" class="postShorten-excerpt_link link" aria-label>
                                 评论和共享
                             </a>
                         </p>
diff --git "a/tags/\345\267\245\345\205\267/index.html" "b/tags/\345\267\245\345\205\267/index.html"
index b467fae..d5ef6ee 100644
--- "a/tags/\345\267\245\345\205\267/index.html"
+++ "b/tags/\345\267\245\345\205\267/index.html"
@@ -220,7 +220,7 @@ <h5 class="sidebar-profile-bio"><p>个人技术博客<br>涉猎开发、测试
             <div class="postShorten-header">
                 <h1 class="postShorten-title">
                     
-                        <a class="link-unstyled" href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/" aria-label=": ClusterFuzz 源码分析（一）">
+                        <a class="link-unstyled" href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/" aria-label=": ClusterFuzz 源码分析（一）">
                             ClusterFuzz 源码分析（一）
                         </a>
                     
@@ -246,7 +246,7 @@ <h1 class="postShorten-title">
                     <!--excerpt-->
 
 <p><a target="_blank" rel="external nofollow noopener noreferrer" href="https://google.github.io/clusterfuzz/">ClusterFuzz</a>是 Google 开源的一个模糊测试平台，它集成了多种 Fuzz 引擎，如 Libfuzzer、AFL、Honggfuzz 等，支持跨平台，且具有高度可扩展性。</p>
-<h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介</h2><p>ClusterFuzz 官网的运作流程图如下：<br><img src="/./ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/overview.png" alt="ClusterFuzz 流程"></p>
+<h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介</h2><p>ClusterFuzz 官网的运作流程图如下：<br><img src="/./ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/overview.png" alt="ClusterFuzz 流程"></p>
 <p>Fuzz 测试中，编写 fuzzer 和修复 bug 需要人工操作，ClusterFuzz 将这两个环节之外的部分都给自动化了，包括 Fuzz 执行、crash 去重、testcase 精简等。</p>
 <p>ClusterFuzz 有两个核心组件：</p>
 <ul>
@@ -264,7 +264,7 @@ <h2 id="简介"><a href="# 简介" class="headerlink" title="简介"></a>简介<
 <p>ClusterFuzz 定义的 Fuzz Bot 有两种类型：</p>
 <ul>
 <li>可抢占的：机器可以随时关闭，且只能运行 fuzz 任务</li>
-<li>不可抢占的：机器不会关闭，能不间断运行各种类型的任务<br><img src="/./ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/task.png" alt="Fuzz Bot"></li>
+<li>不可抢占的：机器不会关闭，能不间断运行各种类型的任务<br><img src="/./ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90/task.png" alt="Fuzz Bot"></li>
 </ul>
 <h2 id="代码概要"><a href="# 代码概要" class="headerlink" title="代码概要"></a>代码概要 </h2><p>Google 开源了 ClusterFuzz 的<a target="_blank" rel="external nofollow noopener noreferrer" href="https://github.com/google/clusterfuzz"> 代码仓</a>，项目 python 为主，读起来相对容易。</p>
 <p>代码结构大致为：</p>
@@ -341,7 +341,7 @@ <h2 id="代码概要"><a href="# 代码概要" class="headerlink" title="代码
                     
                     
                         <p>
-                            <a href="/2024/ClusterFuzz%E6%9E%B6%E6%9E%84%E5%88%86%E6%9E%90/#post-footer" class="postShorten-excerpt_link link" aria-label>
+                            <a href="/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/#post-footer" class="postShorten-excerpt_link link" aria-label>
                                 评论和共享
                             </a>
                         </p>