From 989c7f83208b89d85eaaff27f2cd6c4af6f2cf6d Mon Sep 17 00:00:00 2001
From: ss <shishi.dong@deltaww.com>
Date: Tue, 5 Nov 2024 13:36:57 +0800
Subject: [PATCH] Site updated: 2024-11-05 13:36:48

---
 .../index.html"                               |   6 +-
 .../index.html"                               |   4 +-
 .../index.html"                               |   9 +-
 .../index.html"                               |  11 +-
 .../index.html"                               |   9 +-
 .../index.html"                               |   9 +-
 .../index.html"                               |   6 +-
 .../index.html"                               |  12 +-
 .../index.html"                               |   4 +-
 .../index.html"                               |   9 +-
 .../index.html"                               |   4 +-
 .../index.html"                               |   4 +-
 .../index.html"                               |   7 +-
 .../index.html"                               |   8 +-
 .../index.html"                               |   9 +-
 .../index.html"                               |   7 +-
 .../index.html"                               |  10 +-
 all-archives/index.html                       |   2 +-
 all-categories/index.html                     |   2 +-
 all-tags/index.html                           | 104 +-----
 archives/2024/07/index.html                   |   6 +-
 archives/2024/index.html                      |   6 +-
 archives/index.html                           |   6 +-
 baidusitemap.xml                              |  36 +-
 .../\345\256\211\345\205\250/index.html"      |   6 +-
 .../index.html"                               |   6 +-
 index.html                                    |   6 +-
 sitemap.xml                                   | 102 +++---
 tags/AFL/index.html                           |  43 +++
 tags/Fuzz/index.html                          |   6 +-
 "tags/\345\256\211\345\205\250/index.html"    |   6 +-
 "tags/\345\267\245\345\205\267/index.html"    | 344 ------------------
 "tags/\346\272\220\347\240\201/index.html"    |   6 +-
 33 files changed, 217 insertions(+), 598 deletions(-)

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 c2b4827..6a016fb 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":"Fuzz, 安全, AFL, 工具"}</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="安全">
-<meta property="article:tag" content="工具">
 <meta property="article:tag" content="Fuzz">
+<meta property="article:tag" content="安全">
 <meta property="article:tag" content="AFL">
+<meta property="article:tag" content="工具">
 <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/CPP\344\270\216Python\347\232\204OOP\346\257\224\350\276\203/index.html" "b/2023/CPP\344\270\216Python\347\232\204OOP\346\257\224\350\276\203/index.html"
index 538d4bc..84e228e 100644
--- "a/2023/CPP\344\270\216Python\347\232\204OOP\346\257\224\350\276\203/index.html"
+++ "b/2023/CPP\344\270\216Python\347\232\204OOP\346\257\224\350\276\203/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. OOP 三特性  封装 ：将相关数据和操作数据的方法打包成一个类。不同的类相互隔离，也可以自由组合。 继承 ：从一个父类衍生出子类，子类可以自然地拥有与父类的相同的属性和行为。 多态 ：子类与父类或者兄弟类在某一种行为上有所区别，即同一函数不同实现。 个人理解，继承保持了类之间的共性，多态使得这些具有共性的类之间有各自的特性。\n2. 封装  类是一组数据以及操这组数据的函数（方法）的集合。类是对象的抽象模板，对象是类的具体实例，给类的数据取不同的值，同一个类就产成了不同的对象。\n数据  于是数据应该有两种：一种是与  类级别  的，同一个类取值都一样，与实例无关；另一种是  实例级别  的，同一个类的不同实例取值各不相同。\n\n\n\n数据类别\nC++\nPython\n\n\n\n类级别\n静态数据成员\n类变量\n\n\n实例级别\n非静态数据成员\n实例变量\n\n\n方法  既然数据有两种，方法至少也应该有两种，一种是类级别的，一种是实例级别的。类级别的数据在实例化之前就存在，在实例化之前操作类级别的数据，是一种方法。实例化之后产生了实例级别的数据，这时候的方法可以同时操作两类数据，是另一种方法。\n\n\n\n可操作数据\nC++\nPython\n\n\n\n类级别\n静态成员函数\n类方法\n\n\n类级别和实例级别\n非静态成员函数\n实例方法\n\n\nC++ 中还有一种重要方法是  虚函数，使用虚函数可以实现 C++ 中的多态。Python 中还有一种方法是静态方法。在 Python 中可以认为，实例方法传入了实例对象的指针，类方法传入了类的指针，而静态方法既不需要传入实例，也不需要传入类。\n3. 继承  子类继承父类，使子类拥有父类的数据和方法。\n单一继承  这种情况下，python 和 C++ 的最大区别应该在于继承方式。C++ 继承分为 public、private、protected 三种，Python 都是 public。\n多重继承  没有虚函数的情况下，区别主要有两点：(1) 假设函数名为 fun，当多个父类中定义方法 fun，而子类没有定义方法 fun，通过子类调用方法 fun，C++ 会  报错 ，Python 会使用MRO 来确定调用哪个父类的 fun。(2) 对菱形继承的情况，C++ 要使用  虚继承，Python 要使用super 结合 MRO。\n4. 多态  多态在代码上的表现为一个方法多个实现。C++ 的多态必须建立在继承基础上，现有继承，后有多态。Python 的多态没有继承关系的限制，只要实现了同名方法即可。\nC++ 多态  前文介绍了 C++ 对象的内存模型，这里只说最简单的单一继承情况。C++ 通过父类的指针或引用调用虚函数，在编译期间无法确定调用的是父类的实现还是子类的实现，只有在执行期间访问内存模型中的虚函数表才能确定。 假设 Derived 类继承 Base 类，Base 类中定义了虚函数 method，Derived 类重写了虚函数 method，此时 Base 类和 Derived 类的对象模型如图：\n\n\n执行如下代码：\n12Base *ptr = new Derived();ptr-&gt;method();\n\n编译器看到 ptr 是 Base 类型，如果 method 不是虚函数，那么执行的应该是 Base::method。现在 method 是虚函数，执行期调用 Base::method 还是 Derived::method，要看赋给 ptr 的是 Base 对象地址还是 Derived 对象地址。上面的代码是创建了一个 Derived 对象，并把地址传给 Base 类指针，但是内存模型中的 vptr 指向的仍然是 Derived 类实现的虚函数，所以最后调用的是 Derived::method。\nPython 多态  相比 C++ 复杂的内存模型，Python 的鸭子类型让多态更灵活（Python 内存模型跟多态的关系好像不大）。\n123456789101112class Cat:    @classmethod    def say(cls):        print(&quot;miao miao&quot;)class Dog:    @classmethod    def say(cls):        print(&quot;wang wang&quot;)def func(kls):    kls.say()\n\n这里 Cat 和 Dog 没有继承关系，say 也不是虚函数，调用 func(Cat)和 func(Dog)都能正确执行。要是再定义个 Person 类，只要定义了方法 say，就可以把 Person 传给 func 完成调用。\n5. 写在最后  虽然都是从 C 语言发展出来的 OOP 语言，C++ 和 Python 的区别还是挺大的，特别是多态的处理，所以对相同逻辑的多态执行结果也是有区别的：\nC++ 示例\n12345678910111213141516171819202122#include &lt;iostream&gt;class Base&#123;public:    int x = 1;    virtual void print() &#123; std::cout &lt;&lt; x &lt;&lt; std::endl; &#125;&#125;;class Derived : public Base&#123;public:    int x = 2;&#125;;int main() &#123;    Base *ptr = nullptr;    ptr = new Base();    ptr-&gt;print();  // 打印 1    ptr = new Derived();    ptr-&gt;print();  // 打印 1&#125;\n\nPython 示例\n12345678910111213141516class Base:    def __init__(self):        self.x = 1    def print(self):        print(self.x)class Derived(Base):    def __init__(self):        self.x = 2def func(Kls):    obj = Kls()    obj.print()func(Base)     // 打印1func(Derived)  // 打印2","dateCreated":"2023-05-10T13:08:21+08:00","dateModified":"2024-11-05T13:28:48+08:00","datePublished":"2023-05-10T13:08:21+08:00","description":"C++ 和 Python 都是从 C 语言演变出来的面向对象（OOP）的编程语言，本文基于 OOP 三特性，比较 C++ 和 Python 的异同点","headline":"C++ 与 Python 的 OOP 比较","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2023/CPP%E4%B8%8EPython%E7%9A%84OOP%E6%AF%94%E8%BE%83/"},"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/CPP%E4%B8%8EPython%E7%9A%84OOP%E6%AF%94%E8%BE%83/","keywords":"C++, 编程, 开发, 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\n1. OOP 三特性  封装 ：将相关数据和操作数据的方法打包成一个类。不同的类相互隔离，也可以自由组合。 继承 ：从一个父类衍生出子类，子类可以自然地拥有与父类的相同的属性和行为。 多态 ：子类与父类或者兄弟类在某一种行为上有所区别，即同一函数不同实现。 个人理解，继承保持了类之间的共性，多态使得这些具有共性的类之间有各自的特性。\n2. 封装  类是一组数据以及操这组数据的函数（方法）的集合。类是对象的抽象模板，对象是类的具体实例，给类的数据取不同的值，同一个类就产成了不同的对象。\n数据  于是数据应该有两种：一种是与  类级别  的，同一个类取值都一样，与实例无关；另一种是  实例级别  的，同一个类的不同实例取值各不相同。\n\n\n\n数据类别\nC++\nPython\n\n\n\n类级别\n静态数据成员\n类变量\n\n\n实例级别\n非静态数据成员\n实例变量\n\n\n方法  既然数据有两种，方法至少也应该有两种，一种是类级别的，一种是实例级别的。类级别的数据在实例化之前就存在，在实例化之前操作类级别的数据，是一种方法。实例化之后产生了实例级别的数据，这时候的方法可以同时操作两类数据，是另一种方法。\n\n\n\n可操作数据\nC++\nPython\n\n\n\n类级别\n静态成员函数\n类方法\n\n\n类级别和实例级别\n非静态成员函数\n实例方法\n\n\nC++ 中还有一种重要方法是  虚函数，使用虚函数可以实现 C++ 中的多态。Python 中还有一种方法是静态方法。在 Python 中可以认为，实例方法传入了实例对象的指针，类方法传入了类的指针，而静态方法既不需要传入实例，也不需要传入类。\n3. 继承  子类继承父类，使子类拥有父类的数据和方法。\n单一继承  这种情况下，python 和 C++ 的最大区别应该在于继承方式。C++ 继承分为 public、private、protected 三种，Python 都是 public。\n多重继承  没有虚函数的情况下，区别主要有两点：(1) 假设函数名为 fun，当多个父类中定义方法 fun，而子类没有定义方法 fun，通过子类调用方法 fun，C++ 会  报错 ，Python 会使用MRO 来确定调用哪个父类的 fun。(2) 对菱形继承的情况，C++ 要使用  虚继承，Python 要使用super 结合 MRO。\n4. 多态  多态在代码上的表现为一个方法多个实现。C++ 的多态必须建立在继承基础上，现有继承，后有多态。Python 的多态没有继承关系的限制，只要实现了同名方法即可。\nC++ 多态  前文介绍了 C++ 对象的内存模型，这里只说最简单的单一继承情况。C++ 通过父类的指针或引用调用虚函数，在编译期间无法确定调用的是父类的实现还是子类的实现，只有在执行期间访问内存模型中的虚函数表才能确定。 假设 Derived 类继承 Base 类，Base 类中定义了虚函数 method，Derived 类重写了虚函数 method，此时 Base 类和 Derived 类的对象模型如图：\n\n\n执行如下代码：\n12Base *ptr = new Derived();ptr-&gt;method();\n\n编译器看到 ptr 是 Base 类型，如果 method 不是虚函数，那么执行的应该是 Base::method。现在 method 是虚函数，执行期调用 Base::method 还是 Derived::method，要看赋给 ptr 的是 Base 对象地址还是 Derived 对象地址。上面的代码是创建了一个 Derived 对象，并把地址传给 Base 类指针，但是内存模型中的 vptr 指向的仍然是 Derived 类实现的虚函数，所以最后调用的是 Derived::method。\nPython 多态  相比 C++ 复杂的内存模型，Python 的鸭子类型让多态更灵活（Python 内存模型跟多态的关系好像不大）。\n123456789101112class Cat:    @classmethod    def say(cls):        print(&quot;miao miao&quot;)class Dog:    @classmethod    def say(cls):        print(&quot;wang wang&quot;)def func(kls):    kls.say()\n\n这里 Cat 和 Dog 没有继承关系，say 也不是虚函数，调用 func(Cat)和 func(Dog)都能正确执行。要是再定义个 Person 类，只要定义了方法 say，就可以把 Person 传给 func 完成调用。\n5. 写在最后  虽然都是从 C 语言发展出来的 OOP 语言，C++ 和 Python 的区别还是挺大的，特别是多态的处理，所以对相同逻辑的多态执行结果也是有区别的：\nC++ 示例\n12345678910111213141516171819202122#include &lt;iostream&gt;class Base&#123;public:    int x = 1;    virtual void print() &#123; std::cout &lt;&lt; x &lt;&lt; std::endl; &#125;&#125;;class Derived : public Base&#123;public:    int x = 2;&#125;;int main() &#123;    Base *ptr = nullptr;    ptr = new Base();    ptr-&gt;print();  // 打印 1    ptr = new Derived();    ptr-&gt;print();  // 打印 1&#125;\n\nPython 示例\n12345678910111213141516class Base:    def __init__(self):        self.x = 1    def print(self):        print(self.x)class Derived(Base):    def __init__(self):        self.x = 2def func(Kls):    obj = Kls()    obj.print()func(Base)     // 打印1func(Derived)  // 打印2","dateCreated":"2023-05-10T13:08:21+08:00","dateModified":"2024-11-05T13:28:48+08:00","datePublished":"2023-05-10T13:08:21+08:00","description":"C++ 和 Python 都是从 C 语言演变出来的面向对象（OOP）的编程语言，本文基于 OOP 三特性，比较 C++ 和 Python 的异同点","headline":"C++ 与 Python 的 OOP 比较","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2023/CPP%E4%B8%8EPython%E7%9A%84OOP%E6%AF%94%E8%BE%83/"},"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/CPP%E4%B8%8EPython%E7%9A%84OOP%E6%AF%94%E8%BE%83/","keywords":"C++, Python, 编程, 开发"}</script>
     <meta name="description" content="C++ 和 Python 都是从 C 语言演变出来的面向对象（OOP）的编程语言，本文基于 OOP 三特性，比较 C++ 和 Python 的异同点">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="C++ 与 Python 的 OOP 比较">
@@ -27,9 +27,9 @@
 <meta property="article:modified_time" content="2024-11-05T05:28:48.830Z">
 <meta property="article:author" content="一瓢清浅">
 <meta property="article:tag" content="C++">
+<meta property="article:tag" content="Python">
 <meta property="article:tag" content="编程">
 <meta property="article:tag" content="开发">
-<meta property="article:tag" content="Python">
 <meta name="twitter:card" content="summary">
 <meta name="twitter:image" content="https://www.stepbystep.asia/2023/CPP%E4%B8%8EPython%E7%9A%84OOP%E6%AF%94%E8%BE%83/CPP%E5%A4%9A%E6%80%81.png">
     
diff --git "a/2023/Docker\345\277\205\347\237\245\345\277\205\344\274\232/index.html" "b/2023/Docker\345\277\205\347\237\245\345\277\205\344\274\232/index.html"
index bb7c178..1ccf412 100644
--- "a/2023/Docker\345\277\205\347\237\245\345\277\205\344\274\232/index.html"
+++ "b/2023/Docker\345\277\205\347\237\245\345\277\205\344\274\232/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一、基本概念Docker 是一种轻量级的虚拟化技术，可以让开发者非常便捷地实现应用程序的打包、移植、启动等操作，在软件开发、交付和部署中，有非常广泛的应用。\nDocker 容器与传统虚拟机的架构对比如下：\n\n\n传统 VM 使用 Hypervisor 通过对物理主机的硬件资源进行协调和管理，为每个 GuestOS 分配独立的资源，让每个 GuestOS 成为一个虚拟主机，不同的 GuestOS 中的应用程序互不影响。Docker 容器直接运行在物理主机的 HostOS 上，共用物理主机的硬件资源，Container Engine 负责实现容器之间的资源隔离，让每个容器的应用独立地运行。\n可以看出，容器比虚拟机少了一层 GuestOS，容器占用资源更少，启动更快，但隔离程度不如虚拟机。容器和虚拟机简要对比如下：\n\n\n\n维度\n容器\n虚拟机\n\n\n\n隔离级别\n进程级\n操作系统级\n\n\n镜像大小\nK-M 级\nM-G 级\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\nDocker 中有三个常见的名词：镜像、容器和仓库。这里先简单介绍下概念，知道是什么就行，后面再详细说明。\n（一）镜像（Image）镜像是一个特殊的文件系统，提供容器运行时所需的环境和配置，例如程序、库、资源、配置等文件，以及环境变量、匿名卷、用户等配置参数。镜像是静态的，不包含任何动态数据，在镜像构建之后，其内容不会发生改变。\n（二）容器（Container）容器和镜像的关系，类似于面向对象编程中对象和类的关系，容器是运行镜像后得到的实例，运行镜像就相当于类的实例化，多次运行镜像，可以得到多个容器。容器是动态的，可以对容器进行创建、删除、启动、停止、暂停等操作。\n容器实质上是运行在宿主机上的进程，Docker 是用特殊的技术将容器与宿主机上的其他进程隔离开来，使得容器内的应用看起来是运行在一个独立的环境中。\n（三）仓库（Repository）仓库类似 github，对镜像进行存储和分发。在任一宿主机上，都可以从仓库拉取指定镜像，也可以把自己打包好的镜像上传到仓库，供他人访问。默认的是官方仓库 Docker Hub，拥有众多官方镜像，国内访问需要配加速器，如阿里云的镜像仓。也可以自行搭建本地私有镜像仓。\n二、基础原理  前面提到，容器是宿主机用特殊机制隔离出来的进程。为了实现容器进程的互不干扰，这个机制需要解决两个基本问题：\n\n容器内屏蔽容器外的情况，使用 Linux 的 Namespace 机制\n容器拥有独立的资源，使用 Linux 的 Cgroups 机制\n\n（一）Namespace顾名思义，Namespace 就是命名空间。C++ 使用命名空间解决了类型、变量和函数的冲突问题。Docker 容器也具有自己的命名空间，通过命名空间对资源对象进行隔离，使得不同的容器进程号、用户、文件目录等相互屏蔽。Linux 支持的命名空间有以下几种：\n\n\n\nNamespace\nFlag\nIsolates\n\n\n\nMount\nCLONE_NEWNS\n隔离文件系统挂载点\n\n\nIPC\nCLONE_NEWIPC\n隔离进程间通信\n\n\nNetwork\nCLONE_NEWNET\n隔离网络\n\n\nPID\nCLONE_NEWPID\n隔离进程 ID\n\n\nUSER\nCLONE_NEWUSER\n隔离用户和用户组\n\n\nUTS\nCLONE_NEWUTS\n隔离主机名和域名\n\n\nTime\nCLONE_NEWTIME\n隔离系统时间\n\n\n（二）CgroupsLinux Cgroups 的全称是 Linux Control Group，主要用于对共享资源进行隔离、限制、审计。通过 Cgroups 限制容器能够使用的资源上限，包括 cpu、内存、磁盘、网络带宽等，可以避免多个容器之间的资源竞争。Linux 一切皆文件，Cgroups 也是通过树状的文件系统来对资源进行限制。\n\n查看 cgroup 挂载的目录，可以看到 cgroup 挂在 sys&#x2F;fs&#x2F;cgroup 节点，该路径下还有很多子目录（又称子系统），如 cpu、memory 等，每个子系统对应一种可以被限制的资源类型。\n\n\n以 cpu 为例，查看 cpu 子系统。其中有两个参数 cfs_period_us 和 cfs_quota_us 通常组合使用，用于限制进程在长度为 cfs_period_us 的时间内，只能被分配到总量为 cfs_quota_us 的 cpu 时间。还有一个 tasks 文件，其中存放的是受限制的进程编号。\n\n  \n\ncpu 子系统中有个 docker 子目录，docker 目录中的文件与 cpu 目录中的文件一样。当我们拉起一个容器，比如运行 redis 镜像，可以看到 docker 目录中又多了一层以容器 id 为名称的子目录。\n\n\n\n综上两点，容器其实是一个启用了多种 Namespace 的进程，它能够使用的资源量收到 Cgroups 的限制。截至目前，我们使用 Namespace 和 Cgroups 为容器开辟了一个独立的运行环境，接下来我们再剖析一下容器里运行的镜像。\n前面提到，容器镜像是一个文件系统，我们运行 ubuntu 的镜像，可以通过命令行查看根目录内容，也可以创建并执行脚本文件：\n\n\n我们还可以把改动之后的文件系统打包成我们自己的镜像，下次直接执行：\n\n\n可以看到，我们以 ubuntu 文件系统为基础，加了一层我们自己的修改，打包了一个新的镜像。容器镜像实际上就是以 Linux 的联合文件系统机制（UnionFS）实现分层文件系统。\n（三）UnionFSUnionFS（联合文件系统），可以将不同目录挂载到同一个虚拟文件系统下。Docker 利用 UnionFS 的功能，在基础文件系统上以增量的方式，叠加一层又一层新的文件系统，通过联合挂载，最终得到一个完整的 Docker 镜像文件系统。\nDocker 分层镜像的示例图如下，除了最顶层（称为容器层）是可写的，其他层（称为镜像层）都是只读的。UnoinFS 将所有层都叠加起来，形成最后我们在容器中所看到的文件系统。\n\n\n由于镜像层都是只读的，所有对文件的修改操作都发生在容器层中，Docker 采用了 Copy-On-Write（写时复制） 的机制，具体来说：\n\n新增文件：在容器层中创建文件\n读取文件：自上而下在各层中查找文件，一旦找到，打开并读入内存\n修改文件：自上而下在各层中查找文件，找到后，将文件复制到容器层，在容器层中修改对应文件\n删除文件：自上而下在各层中查找文件，找到后，在容器层中记录删除操作\n\n通过这种分层且只读的设计，使得每一个镜像层都是唯一且不变的，同一个镜像层可以在不同 docker 镜像中共享，只需要下载一次，存储一份，从而节省了大量的资源消耗和占用。\n（四）Volumes由前所述，启动容器后，在容器内执行的所有文件的修改，都保存在容器层中，在删除容器时，对应的修改也会被删除。当我们需要保存修改的结果时，就需要用到数据卷（Data Volume），换句话说，数据卷提供了一种数据持久化的方式，使得在容器中产生的修改能永久的保留到宿主机上。数据卷的使用也很简单，在启动容器时，将宿主机的目录映射到容器中即可。\n三、使用方法 （一）命令行 与 Linux 一样，Docker 主要通过命令行操作，Docker 提供了非常多的命令，可以通过如下命令查看说明文档：\n1docker command --help\n\nDocker 命令主要涉及到镜像、容器、仓库的操作和使用，下图可以概览全貌：\n\n\n以下列举一些常用的 docker 命令，各命令详细用法可以通过 help 查看：\n1. 镜像相关\n搜索镜像：search\n1docker search python\n\n拉取镜像：pull，不指定标签时，默认拉取 lastest 版本\n1docker pull python\n\n推送镜像：push\n1docker push python\n\n构建镜像：build，根据 Dockerfile 构建镜像，Dockerfile 见下一节内容。以下这条命令是指在根据当前目录的 Dockerfile 文件，构建一个名为 my_python 的镜像\n1docker build -t my_python .\n\n列出镜像：images，等同于 image ls\n1docker images\n\n删除镜像：rmi，等同于 image rm\n1docker rmi python\n\n2. 容器相关\n运行容器：run，创建一个容器，运行镜像文件\n1docker run ubuntu\n\n查看容器：ps，默认只列出运行中的容器，加 -a 参数可以列出所有容器，显示结果中第一列为 CONTAINER ID，是容器的唯一标识\n1docker ps -a\n\n启动容器：start\n1docker start 369dde08ff20\n\n停止容器：stop\n1docker stop 369dde08ff20\n\n删除容器：rm\n1docker rm 369dde08ff20\n\n重启容器：restart\n1docker restart 369dde08ff20\n\n链接容器：attach，连接一个正在运行的容器\n1docker attach 369dde08ff20\n\n执行命令：exec，在正在运行的容器中执行命令。以下这条命令在 ID 为 369dde08ff20 的容器中，开启一个交互式命令行终端\n1docker exec -it 369dde08ff20 /bin/bash\n\n查看信息：inspect，查看镜像或容器的具体配置信息\n1docker inspect 369dde08ff20\n\n提交镜像：commit，将当前容器的修改保存为镜像\n1docker commit -m &quot;container to image&quot; 369dde08ff20 my_ubuntu\n\n查看变更：diff，将容器创建以来，文件系统中发生变更的文件和目录\n1docker diff 369dde08ff20\n\n拷贝文件：cp，用于在容器和宿主机之间拷贝数据。以下这条命令将容器中的 &#x2F;tmp 目录，拷贝到宿主机中的 &#x2F;tmp 目录\n1docker cp 369dde08ff20:/tmp/ /tmp/\n\n（二）镜像制作  制作 Docker 镜像有两种方法，一种是在容器中使用 commit 提交修改，另一种是使用 Dockfile 进行 build，后一种是主流做法。\nDockerfile 是由一行行指令组成的脚本文件，每一行命令都会生成一个镜像层，多行命令生成多个镜像层，叠加生成最终的镜像文件。Dockerfile 的常见指令及含义如图所示：\n\n\n最后看个 Dockerfile 的小例子：\n\n编写 Dockerfile 文件\n\n\n生成镜像文件\n\n\n查看并运行镜像文件\n\n\n四、参考资料\nDocker 原理（图解 + 秒懂 + 史上最全） \nDocker 命令行官方手册 \nDockerfile 文件详解\n","dateCreated":"2023-07-08T16:10:21+08:00","dateModified":"2024-11-05T13:26:53+08:00","datePublished":"2023-07-08T16:10:21+08:00","description":"Docker 基本原理以及常用命令","headline":"Docker 必知必会","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2023/Docker%E5%BF%85%E7%9F%A5%E5%BF%85%E4%BC%9A/"},"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/Docker%E5%BF%85%E7%9F%A5%E5%BF%85%E4%BC%9A/","keywords":"工具, Linux, Docker"}</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一、基本概念Docker 是一种轻量级的虚拟化技术，可以让开发者非常便捷地实现应用程序的打包、移植、启动等操作，在软件开发、交付和部署中，有非常广泛的应用。\nDocker 容器与传统虚拟机的架构对比如下：\n\n\n传统 VM 使用 Hypervisor 通过对物理主机的硬件资源进行协调和管理，为每个 GuestOS 分配独立的资源，让每个 GuestOS 成为一个虚拟主机，不同的 GuestOS 中的应用程序互不影响。Docker 容器直接运行在物理主机的 HostOS 上，共用物理主机的硬件资源，Container Engine 负责实现容器之间的资源隔离，让每个容器的应用独立地运行。\n可以看出，容器比虚拟机少了一层 GuestOS，容器占用资源更少，启动更快，但隔离程度不如虚拟机。容器和虚拟机简要对比如下：\n\n\n\n维度\n容器\n虚拟机\n\n\n\n隔离级别\n进程级\n操作系统级\n\n\n镜像大小\nK-M 级\nM-G 级\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\nDocker 中有三个常见的名词：镜像、容器和仓库。这里先简单介绍下概念，知道是什么就行，后面再详细说明。\n（一）镜像（Image）镜像是一个特殊的文件系统，提供容器运行时所需的环境和配置，例如程序、库、资源、配置等文件，以及环境变量、匿名卷、用户等配置参数。镜像是静态的，不包含任何动态数据，在镜像构建之后，其内容不会发生改变。\n（二）容器（Container）容器和镜像的关系，类似于面向对象编程中对象和类的关系，容器是运行镜像后得到的实例，运行镜像就相当于类的实例化，多次运行镜像，可以得到多个容器。容器是动态的，可以对容器进行创建、删除、启动、停止、暂停等操作。\n容器实质上是运行在宿主机上的进程，Docker 是用特殊的技术将容器与宿主机上的其他进程隔离开来，使得容器内的应用看起来是运行在一个独立的环境中。\n（三）仓库（Repository）仓库类似 github，对镜像进行存储和分发。在任一宿主机上，都可以从仓库拉取指定镜像，也可以把自己打包好的镜像上传到仓库，供他人访问。默认的是官方仓库 Docker Hub，拥有众多官方镜像，国内访问需要配加速器，如阿里云的镜像仓。也可以自行搭建本地私有镜像仓。\n二、基础原理  前面提到，容器是宿主机用特殊机制隔离出来的进程。为了实现容器进程的互不干扰，这个机制需要解决两个基本问题：\n\n容器内屏蔽容器外的情况，使用 Linux 的 Namespace 机制\n容器拥有独立的资源，使用 Linux 的 Cgroups 机制\n\n（一）Namespace顾名思义，Namespace 就是命名空间。C++ 使用命名空间解决了类型、变量和函数的冲突问题。Docker 容器也具有自己的命名空间，通过命名空间对资源对象进行隔离，使得不同的容器进程号、用户、文件目录等相互屏蔽。Linux 支持的命名空间有以下几种：\n\n\n\nNamespace\nFlag\nIsolates\n\n\n\nMount\nCLONE_NEWNS\n隔离文件系统挂载点\n\n\nIPC\nCLONE_NEWIPC\n隔离进程间通信\n\n\nNetwork\nCLONE_NEWNET\n隔离网络\n\n\nPID\nCLONE_NEWPID\n隔离进程 ID\n\n\nUSER\nCLONE_NEWUSER\n隔离用户和用户组\n\n\nUTS\nCLONE_NEWUTS\n隔离主机名和域名\n\n\nTime\nCLONE_NEWTIME\n隔离系统时间\n\n\n（二）CgroupsLinux Cgroups 的全称是 Linux Control Group，主要用于对共享资源进行隔离、限制、审计。通过 Cgroups 限制容器能够使用的资源上限，包括 cpu、内存、磁盘、网络带宽等，可以避免多个容器之间的资源竞争。Linux 一切皆文件，Cgroups 也是通过树状的文件系统来对资源进行限制。\n\n查看 cgroup 挂载的目录，可以看到 cgroup 挂在 sys&#x2F;fs&#x2F;cgroup 节点，该路径下还有很多子目录（又称子系统），如 cpu、memory 等，每个子系统对应一种可以被限制的资源类型。\n\n\n以 cpu 为例，查看 cpu 子系统。其中有两个参数 cfs_period_us 和 cfs_quota_us 通常组合使用，用于限制进程在长度为 cfs_period_us 的时间内，只能被分配到总量为 cfs_quota_us 的 cpu 时间。还有一个 tasks 文件，其中存放的是受限制的进程编号。\n\n  \n\ncpu 子系统中有个 docker 子目录，docker 目录中的文件与 cpu 目录中的文件一样。当我们拉起一个容器，比如运行 redis 镜像，可以看到 docker 目录中又多了一层以容器 id 为名称的子目录。\n\n\n\n综上两点，容器其实是一个启用了多种 Namespace 的进程，它能够使用的资源量收到 Cgroups 的限制。截至目前，我们使用 Namespace 和 Cgroups 为容器开辟了一个独立的运行环境，接下来我们再剖析一下容器里运行的镜像。\n前面提到，容器镜像是一个文件系统，我们运行 ubuntu 的镜像，可以通过命令行查看根目录内容，也可以创建并执行脚本文件：\n\n\n我们还可以把改动之后的文件系统打包成我们自己的镜像，下次直接执行：\n\n\n可以看到，我们以 ubuntu 文件系统为基础，加了一层我们自己的修改，打包了一个新的镜像。容器镜像实际上就是以 Linux 的联合文件系统机制（UnionFS）实现分层文件系统。\n（三）UnionFSUnionFS（联合文件系统），可以将不同目录挂载到同一个虚拟文件系统下。Docker 利用 UnionFS 的功能，在基础文件系统上以增量的方式，叠加一层又一层新的文件系统，通过联合挂载，最终得到一个完整的 Docker 镜像文件系统。\nDocker 分层镜像的示例图如下，除了最顶层（称为容器层）是可写的，其他层（称为镜像层）都是只读的。UnoinFS 将所有层都叠加起来，形成最后我们在容器中所看到的文件系统。\n\n\n由于镜像层都是只读的，所有对文件的修改操作都发生在容器层中，Docker 采用了 Copy-On-Write（写时复制） 的机制，具体来说：\n\n新增文件：在容器层中创建文件\n读取文件：自上而下在各层中查找文件，一旦找到，打开并读入内存\n修改文件：自上而下在各层中查找文件，找到后，将文件复制到容器层，在容器层中修改对应文件\n删除文件：自上而下在各层中查找文件，找到后，在容器层中记录删除操作\n\n通过这种分层且只读的设计，使得每一个镜像层都是唯一且不变的，同一个镜像层可以在不同 docker 镜像中共享，只需要下载一次，存储一份，从而节省了大量的资源消耗和占用。\n（四）Volumes由前所述，启动容器后，在容器内执行的所有文件的修改，都保存在容器层中，在删除容器时，对应的修改也会被删除。当我们需要保存修改的结果时，就需要用到数据卷（Data Volume），换句话说，数据卷提供了一种数据持久化的方式，使得在容器中产生的修改能永久的保留到宿主机上。数据卷的使用也很简单，在启动容器时，将宿主机的目录映射到容器中即可。\n三、使用方法 （一）命令行 与 Linux 一样，Docker 主要通过命令行操作，Docker 提供了非常多的命令，可以通过如下命令查看说明文档：\n1docker command --help\n\nDocker 命令主要涉及到镜像、容器、仓库的操作和使用，下图可以概览全貌：\n\n\n以下列举一些常用的 docker 命令，各命令详细用法可以通过 help 查看：\n1. 镜像相关\n搜索镜像：search\n1docker search python\n\n拉取镜像：pull，不指定标签时，默认拉取 lastest 版本\n1docker pull python\n\n推送镜像：push\n1docker push python\n\n构建镜像：build，根据 Dockerfile 构建镜像，Dockerfile 见下一节内容。以下这条命令是指在根据当前目录的 Dockerfile 文件，构建一个名为 my_python 的镜像\n1docker build -t my_python .\n\n列出镜像：images，等同于 image ls\n1docker images\n\n删除镜像：rmi，等同于 image rm\n1docker rmi python\n\n2. 容器相关\n运行容器：run，创建一个容器，运行镜像文件\n1docker run ubuntu\n\n查看容器：ps，默认只列出运行中的容器，加 -a 参数可以列出所有容器，显示结果中第一列为 CONTAINER ID，是容器的唯一标识\n1docker ps -a\n\n启动容器：start\n1docker start 369dde08ff20\n\n停止容器：stop\n1docker stop 369dde08ff20\n\n删除容器：rm\n1docker rm 369dde08ff20\n\n重启容器：restart\n1docker restart 369dde08ff20\n\n链接容器：attach，连接一个正在运行的容器\n1docker attach 369dde08ff20\n\n执行命令：exec，在正在运行的容器中执行命令。以下这条命令在 ID 为 369dde08ff20 的容器中，开启一个交互式命令行终端\n1docker exec -it 369dde08ff20 /bin/bash\n\n查看信息：inspect，查看镜像或容器的具体配置信息\n1docker inspect 369dde08ff20\n\n提交镜像：commit，将当前容器的修改保存为镜像\n1docker commit -m &quot;container to image&quot; 369dde08ff20 my_ubuntu\n\n查看变更：diff，将容器创建以来，文件系统中发生变更的文件和目录\n1docker diff 369dde08ff20\n\n拷贝文件：cp，用于在容器和宿主机之间拷贝数据。以下这条命令将容器中的 &#x2F;tmp 目录，拷贝到宿主机中的 &#x2F;tmp 目录\n1docker cp 369dde08ff20:/tmp/ /tmp/\n\n（二）镜像制作  制作 Docker 镜像有两种方法，一种是在容器中使用 commit 提交修改，另一种是使用 Dockfile 进行 build，后一种是主流做法。\nDockerfile 是由一行行指令组成的脚本文件，每一行命令都会生成一个镜像层，多行命令生成多个镜像层，叠加生成最终的镜像文件。Dockerfile 的常见指令及含义如图所示：\n\n\n最后看个 Dockerfile 的小例子：\n\n编写 Dockerfile 文件\n\n\n生成镜像文件\n\n\n查看并运行镜像文件\n\n\n四、参考资料\nDocker 原理（图解 + 秒懂 + 史上最全） \nDocker 命令行官方手册 \nDockerfile 文件详解\n","dateCreated":"2023-07-08T16:10:21+08:00","dateModified":"2024-11-05T13:36:12+08:00","datePublished":"2023-07-08T16:10:21+08:00","description":"Docker 基本原理以及常用命令","headline":"Docker 必知必会","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2023/Docker%E5%BF%85%E7%9F%A5%E5%BF%85%E4%BC%9A/"},"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/Docker%E5%BF%85%E7%9F%A5%E5%BF%85%E4%BC%9A/","keywords":"Docker, Linux"}</script>
     <meta name="description" content="Docker 基本原理以及常用命令">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="Docker 必知必会">
@@ -37,11 +37,10 @@
 <meta property="og:image" content="https://www.stepbystep.asia/2023/Docker%E5%BF%85%E7%9F%A5%E5%BF%85%E4%BC%9A/%E7%94%9F%E6%88%90docker%E9%95%9C%E5%83%8F.png">
 <meta property="og:image" content="https://www.stepbystep.asia/2023/Docker%E5%BF%85%E7%9F%A5%E5%BF%85%E4%BC%9A/%E6%9F%A5%E7%9C%8B%E5%B9%B6%E8%BF%90%E8%A1%8Cdocker%E9%95%9C%E5%83%8F.png">
 <meta property="article:published_time" content="2023-07-08T08:10:21.000Z">
-<meta property="article:modified_time" content="2024-11-05T05:26:53.230Z">
+<meta property="article:modified_time" content="2024-11-05T05:36:12.109Z">
 <meta property="article:author" content="一瓢清浅">
-<meta property="article:tag" content="工具">
-<meta property="article:tag" content="Linux">
 <meta property="article:tag" content="Docker">
+<meta property="article:tag" content="Linux">
 <meta name="twitter:card" content="summary">
 <meta name="twitter:image" content="https://www.stepbystep.asia/2023/Docker%E5%BF%85%E7%9F%A5%E5%BF%85%E4%BC%9A/vm-vs-docker.jpg">
     
@@ -498,7 +497,7 @@ <h2 id="四、参考资料"><a href="# 四、参考资料" class="headerlink" ti
             <div class="post-footer-tags">
                 <span class="text-color-light text-small">标签</span><br>
                 
-    <a class="tag tag--primary tag--small t-none-link" href="/tags/Docker/" rel="tag">Docker</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/Linux/" rel="tag">Linux</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E5%B7%A5%E5%85%B7/" rel="tag">工具</a>
+    <a class="tag tag--primary tag--small t-none-link" href="/tags/Docker/" rel="tag">Docker</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/Linux/" rel="tag">Linux</a>
 
             </div>
         
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 83492fa..d1d8800 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-11-05T13:27:51+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>
+    <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-11-05T13:36:12+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>
     <meta name="description" content="LibAFL 是用 Rust 开发的一款模糊测试库，支持 Fuzz 各模块的灵活定制">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="LibAFL 简介">
@@ -24,12 +24,11 @@
 <meta property="og:locale" content="zh_CN">
 <meta property="og: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">
 <meta property="article:published_time" content="2023-11-18T02:38:08.000Z">
-<meta property="article:modified_time" content="2024-11-05T05:27:51.014Z">
+<meta property="article:modified_time" content="2024-11-05T05:36:12.352Z">
 <meta property="article:author" content="一瓢清浅">
-<meta property="article:tag" content="安全">
-<meta property="article:tag" content="工具">
-<meta property="article:tag" content="AFL++">
 <meta property="article:tag" content="Fuzz">
+<meta property="article:tag" content="安全">
+<meta property="article:tag" content="AFL">
 <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">
     
@@ -308,7 +307,7 @@ <h2 id="5- 参考资料"><a href="#5- 参考资料" class="headerlink" title="5.
             <div class="post-footer-tags">
                 <span class="text-color-light text-small">标签</span><br>
                 
-    <a class="tag tag--primary tag--small t-none-link" href="/tags/AFL/" rel="tag">AFL++</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/Fuzz/" rel="tag">Fuzz</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E5%AE%89%E5%85%A8/" rel="tag">安全</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E5%B7%A5%E5%85%B7/" rel="tag">工具</a>
+    <a class="tag tag--primary tag--small t-none-link" href="/tags/AFL/" rel="tag">AFL</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/Fuzz/" rel="tag">Fuzz</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E5%AE%89%E5%85%A8/" rel="tag">安全</a>
 
             </div>
         
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 dd0e07e..7532dd3 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-11-05T13:36:11+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 使用说明">
@@ -23,11 +23,10 @@
 <meta property="og:description" content="模糊测试工具 LibFuzzer 从 0 到 1，原理 + 安装 + 使用 + 优化，一篇讲完">
 <meta property="og:locale" content="zh_CN">
 <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:modified_time" content="2024-11-05T05:36:11.976Z">
 <meta property="article:author" content="一瓢清浅">
-<meta property="article:tag" content="安全">
-<meta property="article:tag" content="工具">
 <meta property="article:tag" content="Fuzz">
+<meta property="article:tag" content="安全">
 <meta property="article:tag" content="LibFuzzer">
 <meta name="twitter:card" content="summary">
     
@@ -695,7 +694,7 @@ <h2 id="四、- 参考资料"><a href="# 四、- 参考资料" class="headerlink
             <div class="post-footer-tags">
                 <span class="text-color-light text-small">标签</span><br>
                 
-    <a class="tag tag--primary tag--small t-none-link" href="/tags/Fuzz/" rel="tag">Fuzz</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/LibFuzzer/" rel="tag">LibFuzzer</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E5%AE%89%E5%85%A8/" rel="tag">安全</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E5%B7%A5%E5%85%B7/" rel="tag">工具</a>
+    <a class="tag tag--primary tag--small t-none-link" href="/tags/Fuzz/" rel="tag">Fuzz</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/LibFuzzer/" rel="tag">LibFuzzer</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E5%AE%89%E5%85%A8/" rel="tag">安全</a>
 
             </div>
         
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 c010822..5baa5bb 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-11-05T13:36:12+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 编译指南">
@@ -25,11 +25,10 @@
 <meta property="og: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">
 <meta property="og: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%E5%8A%A8%E6%80%81%E5%BA%93.png">
 <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:modified_time" content="2024-11-05T05:36:12.178Z">
 <meta property="article:author" content="一瓢清浅">
-<meta property="article:tag" content="安全">
-<meta property="article:tag" content="工具">
 <meta property="article:tag" content="Fuzz">
+<meta property="article:tag" content="安全">
 <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">
@@ -447,7 +446,7 @@ <h3 id="2- 静态库 or 动态库"><a href="#2- 静态库 or 动态库" class="h
             <div class="post-footer-tags">
                 <span class="text-color-light text-small">标签</span><br>
                 
-    <a class="tag tag--primary tag--small t-none-link" href="/tags/Fuzz/" rel="tag">Fuzz</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/LibFuzzer/" rel="tag">LibFuzzer</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E5%AE%89%E5%85%A8/" rel="tag">安全</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E5%B7%A5%E5%85%B7/" rel="tag">工具</a>
+    <a class="tag tag--primary tag--small t-none-link" href="/tags/Fuzz/" rel="tag">Fuzz</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/LibFuzzer/" rel="tag">LibFuzzer</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E5%AE%89%E5%85%A8/" rel="tag">安全</a>
 
             </div>
         
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 1553afc..8b8deff 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="符号执行">
-<meta property="article:tag" content="安全">
 <meta property="article:tag" content="Fuzz">
+<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/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 8d3b5ed..e874575 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"
@@ -7,28 +7,28 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <meta name="generator" content="千里之行，始于足下">
-    <title>AFLplusplus 源码分析——同步机制 - 千里之行，始于足下</title>
+    <title>AFL++ 源码分析——同步机制 - 千里之行，始于足下</title>
     <meta name="author" content="一瓢清浅">
     
         <meta name="keywords" content="python,AI,安全,算法,编程,">
     
     
     
-    <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-11-05T13:29:09+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-11-05T13:31:39+08:00","datePublished":"2024-07-16T09:02:06+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%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>
     <meta name="description" content="分析 AFL++ 同步机制的相关源码">
 <meta property="og:type" content="blog">
-<meta property="og:title" content="AFLplusplus 源码分析——同步机制">
+<meta property="og:title" content="AFL++ 源码分析——同步机制">
 <meta property="og:url" 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/index.html">
 <meta property="og:site_name" content="千里之行，始于足下">
 <meta property="og:description" content="分析 AFL++ 同步机制的相关源码">
 <meta property="og:locale" content="zh_CN">
 <meta property="og: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">
 <meta property="article:published_time" content="2024-07-16T01:02:06.000Z">
-<meta property="article:modified_time" content="2024-11-05T05:29:09.949Z">
+<meta property="article:modified_time" content="2024-11-05T05:31:39.424Z">
 <meta property="article:author" content="一瓢清浅">
-<meta property="article:tag" content="安全">
 <meta property="article:tag" content="AFL++">
 <meta property="article:tag" content="Fuzz">
+<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/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">
@@ -226,7 +226,7 @@ <h5 class="sidebar-profile-bio"><p>个人技术博客<br>涉猎开发、测试
         <div class="post-header main-content-wrap text-left">
     
         <h1 class="post-title">
-            AFLplusplus 源码分析——同步机制
+            AFL++ 源码分析——同步机制
         </h1>
     
     
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 e46f7c6..116e576 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-11-05T13:29:09+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-11-05T13:29:09+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>
     <meta name="description" content="分析 AFL++ 度量覆盖率的相关代码">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="AFL++ 源码分析——覆盖率">
@@ -25,9 +25,9 @@
 <meta property="article:published_time" content="2024-08-15T09:28:52.000Z">
 <meta property="article:modified_time" content="2024-11-05T05:29:09.893Z">
 <meta property="article:author" content="一瓢清浅">
-<meta property="article:tag" content="安全">
 <meta property="article:tag" content="AFL++">
 <meta property="article:tag" content="Fuzz">
+<meta property="article:tag" content="安全">
 <meta property="article:tag" content="源码">
 <meta name="twitter:card" content="summary">
     
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 ff94dd0..18e9f9c 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-11-05T13:28:48+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":"符号执行, Angr, 安全, 工具"}</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-11-05T13:36:12+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":"安全, 符号执行, Angr"}</script>
     <meta name="description" content="Angr 是一款二进制分析和符号执行工具，常用于 CTF 和安全测试领域">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="符号执行工具——Angr 零基础入门">
@@ -27,12 +27,11 @@
 <meta property="og:image" content="https://www.stepbystep.asia/2024/Angr%E9%9B%B6%E5%9F%BA%E7%A1%80%E5%85%A5%E9%97%A8/%E6%89%A7%E8%A1%8Cblock.png">
 <meta property="og:image" content="https://www.stepbystep.asia/2024/Angr%E9%9B%B6%E5%9F%BA%E7%A1%80%E5%85%A5%E9%97%A8/AssertError%E8%8A%82%E7%82%B9.png">
 <meta property="article:published_time" content="2024-01-23T05:45:08.000Z">
-<meta property="article:modified_time" content="2024-11-05T05:28:48.978Z">
+<meta property="article:modified_time" content="2024-11-05T05:36:12.239Z">
 <meta property="article:author" content="一瓢清浅">
+<meta property="article:tag" content="安全">
 <meta property="article:tag" content="符号执行">
 <meta property="article:tag" content="Angr">
-<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">
     
@@ -544,7 +543,7 @@ <h2 id="六、参考资料"><a href="# 六、参考资料" class="headerlink" ti
             <div class="post-footer-tags">
                 <span class="text-color-light text-small">标签</span><br>
                 
-    <a class="tag tag--primary tag--small t-none-link" href="/tags/Angr/" rel="tag">Angr</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E5%AE%89%E5%85%A8/" rel="tag">安全</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E5%B7%A5%E5%85%B7/" rel="tag">工具</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E7%AC%A6%E5%8F%B7%E6%89%A7%E8%A1%8C/" rel="tag">符号执行</a>
+    <a class="tag tag--primary tag--small t-none-link" href="/tags/Angr/" rel="tag">Angr</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E5%AE%89%E5%85%A8/" rel="tag">安全</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E7%AC%A6%E5%8F%B7%E6%89%A7%E8%A1%8C/" rel="tag">符号执行</a>
 
             </div>
         
diff --git "a/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" "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"
index 4949454..0e07eef 100644
--- "a/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"
+++ "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,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\nClusterFuzz是 Google 开源的一个模糊测试平台，它集成了多种 Fuzz 引擎，如 Libfuzzer、AFL、Honggfuzz 等，支持跨平台，且具有高度可扩展性。\n一、简介ClusterFuzz 官网的运作流程图如下：\n\n\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：分词工具\nweb_server：在 bot 上启动一个 server，处理 testcase 相关请求\n\n\nbuild_management：根据用户上传的文件，创建 fuzz 任务\nconfig：读取配置文件，获取配置项\ncrash_analysis：crash 的分析、比较和分级\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 平台 bot 进行配置\n\n\npython\nbot：启动 bot\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-09-30T10:51:56+08:00","dateModified":"2024-11-05T13:28:48+08:00","datePublished":"2024-09-30T10:51:56+08:00","description":"Clusterfuzz 源码概览","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>
+    <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 官网的运作流程图如下：\n\n\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：分词工具\nweb_server：在 bot 上启动一个 server，处理 testcase 相关请求\n\n\nbuild_management：根据用户上传的文件，创建 fuzz 任务\nconfig：读取配置文件，获取配置项\ncrash_analysis：crash 的分析、比较和分级\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 平台 bot 进行配置\n\n\npython\nbot：启动 bot\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-09-30T10:51:56+08:00","dateModified":"2024-11-05T13:28:48+08:00","datePublished":"2024-09-30T10:51:56+08:00","description":"Clusterfuzz 源码概览","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 源码概览">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="ClusterFuzz 源码分析（一）">
@@ -27,8 +27,8 @@
 <meta property="article:published_time" content="2024-09-30T02:51:56.000Z">
 <meta property="article:modified_time" content="2024-11-05T05:28:48.875Z">
 <meta property="article:author" content="一瓢清浅">
-<meta property="article:tag" content="安全">
 <meta property="article:tag" content="Fuzz">
+<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/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89/overview.png">
diff --git "a/2024/ClusterFuzz\346\272\220\347\240\201\345\210\206\346\236\220\357\274\210\344\272\214\357\274\211/index.html" "b/2024/ClusterFuzz\346\272\220\347\240\201\345\210\206\346\236\220\357\274\210\344\272\214\357\274\211/index.html"
index 70e0b8c..2b3e368 100644
--- "a/2024/ClusterFuzz\346\272\220\347\240\201\345\210\206\346\236\220\357\274\210\344\272\214\357\274\211/index.html"
+++ "b/2024/ClusterFuzz\346\272\220\347\240\201\345\210\206\346\236\220\357\274\210\344\272\214\357\274\211/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一、ClusterFuzz 使用简介  根据 ClusterFuzz官方说明，可以在本地执行以下命令启动 ClusterFuzz 平台：\n12345# If you run the server for the first time or want to reset all data.python butler.py run_server --bootstrap# In all the other cases, do not use &quot;--bootstrap&quot; flag.python butler.py run_server\n启动 ClusterFuzz 后，通过访问http://localhost:9000，即可打开 web 页面。\n执行 fuzz 任务，需要启动 bot，命令如下：\n1python butler.py run_bot --name my-bot /path/to/my-bot  # rename my-bot to anything\n当 bot 启动后，ClusterFuzz 的各项任务才能执行。\n二、run_server 源码分析  当我们执行 python butler.py run_server --skip-install-deps --bootstrap 时，发生了什么？\nsequenceDiagram\n    participant A as bulter.py\n    box local/bulter\n        participant B as run_server.py\n        participant C as common.py\n    end\n    box appengine\n        participant D as main.py\n        participant E as server.py\n    end\n    box clusterfuzz/_internal\n        participant F as test_utils.py\n    end\n    participant G as gcs.go\n\n    A ->> A: call _setup\n    A ->> B: call execute\n    B ->> B: call bootstrap_gcs\n    B ->> F: call start_cloud_emulator\n    F -->> B: start pubsub emulator and datastore emulator\n    B ->> G: go run gcs.go\n    alt bootstrap\n        B ->> B: call bootstrap_db\n    end\n    B ->> B: call start_cron_threads\n    B ->> C: call execute_async\n    C ->> D: gunicorn start app for cron service\n    D ->> E: register_routes\n    E -->> D: return cron service app\n    B ->> C: call execute\n    C ->> D: gunicorn start app for dev service\n    D ->> E: register_routes\n    E -->> D: return dev service app\n\n_setup：设置工程的模块搜索路径\nrun_server.execute：依次启动各项服务\nbootstrap_gcs：创建 gcs 相关路径，默认保存在 local/storage/local_gcs 之下\ntest_utils.start_cloud_emulator：启动 pubsub emulator 和 datastore emulator\ncommon.execute_async(&#39;go run emulators/gcs.go&#39;)：启动 gcs emulator\nbootstrap_db：执行 src/local/butler/scripts/setup.py 中的execute，初始化数据库\nstart_cron_threads：启动定时任务，各项任务通过 route 转到相应 handler 执行\ncommon.execute_async(&#39;gunicorn -b :&#123;port&#125; main:app)：gunicorn 指定 port 启动 src/appengine/main.py 中的 app 应用\nsrc/appengine/main.py：调用 server.py 中的 app\nsrc/appengine/server.py：定义 web app，注册 web route 信息\n\n\n\n三、run_bot 源码分析  当我们执行 python butler.py run_bot --name fuzz-bot fuzz-bot/ 时，发生了什么？\nsequenceDiagram\n    participant A as bulter.py\n    box local/bulter\n        participant B as run_bot.py\n        participant C as common.py\n    end\n    box python/bot\n        participant D as startup/run_bot.py\n    end\n    box local/_internal\n        participant E as metrics/monitor.py\n        participant F as bot/fuzzers/init.py\n        participant G as bot/tasks/update_task.py\n        participant H as base/tasks.py\n        participant I as bot/tasks/commands.py\n    end\n    \n    A ->> A: call _setup\n    A ->> B: call execute\n    B ->> B: call _setup_bot_directory\n    B ->> B: call _setup_environment_and_configs\n    B ->> C: call execute_async\n    C ->> D: start bot\n    D ->> E: initialize monitor\n    E -->> D: \n    D ->> F: initialize fuzzer engine\n    F --> D: \n    loop task_loop\n        D ->> G: call run to update task\n        G --> D: \n        D ->> H: call get_task\n        H --> D: \n        D --> I: call process_commands to execute task\n    end\n\n_setup：设置工程的模块搜索路径\nrun_bot.execute：启动 bot\n_setup_bot_directory：创建 bot 相关路径\n_setup_environment_and_configs：设置运行环境，如环境变量等\nexecute_async(&#39;python src/python/bot/startup/run_bot.py&#39;)：启动 bot\nmonitor.initialize：初始化监控器\nfuzzers_init.run：初始化 fuzz 引擎，通过 import clusterfuzz._internal.bot.fuzzers.&#123;engine_name&#125;.engine 导入各 fuzzer 模块\ntask_loop：循环执行任务\nupdate_task.run：更新任务信息和 bot 心跳\ntasks.get_task：获取任务，有多种任务，fuzz 只是其中一种任务\ncommands.process_command：通过命令行执行任务\n\n\n\n\n\n\n","dateCreated":"2024-10-10T13:25:07+08:00","dateModified":"2024-11-05T13:28:48+08:00","datePublished":"2024-10-10T13:25:07+08:00","description":"ClusterFuzz 启动 server 和 bot 的源码分析","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%BA%8C%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%BA%8C%EF%BC%89/","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一、ClusterFuzz 使用简介  根据 ClusterFuzz官方说明，可以在本地执行以下命令启动 ClusterFuzz 平台：\n12345# If you run the server for the first time or want to reset all data.python butler.py run_server --bootstrap# In all the other cases, do not use &quot;--bootstrap&quot; flag.python butler.py run_server\n启动 ClusterFuzz 后，通过访问http://localhost:9000，即可打开 web 页面。\n执行 fuzz 任务，需要启动 bot，命令如下：\n1python butler.py run_bot --name my-bot /path/to/my-bot  # rename my-bot to anything\n当 bot 启动后，ClusterFuzz 的各项任务才能执行。\n二、run_server 源码分析  当我们执行 python butler.py run_server --skip-install-deps --bootstrap 时，发生了什么？\nsequenceDiagram\n    participant A as bulter.py\n    box local/bulter\n        participant B as run_server.py\n        participant C as common.py\n    end\n    box appengine\n        participant D as main.py\n        participant E as server.py\n    end\n    box clusterfuzz/_internal\n        participant F as test_utils.py\n    end\n    participant G as gcs.go\n\n    A ->> A: call _setup\n    A ->> B: call execute\n    B ->> B: call bootstrap_gcs\n    B ->> F: call start_cloud_emulator\n    F -->> B: start pubsub emulator and datastore emulator\n    B ->> G: go run gcs.go\n    alt bootstrap\n        B ->> B: call bootstrap_db\n    end\n    B ->> B: call start_cron_threads\n    B ->> C: call execute_async\n    C ->> D: gunicorn start app for cron service\n    D ->> E: register_routes\n    E -->> D: return cron service app\n    B ->> C: call execute\n    C ->> D: gunicorn start app for dev service\n    D ->> E: register_routes\n    E -->> D: return dev service app\n\n_setup：设置工程的模块搜索路径\nrun_server.execute：依次启动各项服务\nbootstrap_gcs：创建 gcs 相关路径，默认保存在 local/storage/local_gcs 之下\ntest_utils.start_cloud_emulator：启动 pubsub emulator 和 datastore emulator\ncommon.execute_async(&#39;go run emulators/gcs.go&#39;)：启动 gcs emulator\nbootstrap_db：执行 src/local/butler/scripts/setup.py 中的execute，初始化数据库\nstart_cron_threads：启动定时任务，各项任务通过 route 转到相应 handler 执行\ncommon.execute_async(&#39;gunicorn -b :&#123;port&#125; main:app)：gunicorn 指定 port 启动 src/appengine/main.py 中的 app 应用\nsrc/appengine/main.py：调用 server.py 中的 app\nsrc/appengine/server.py：定义 web app，注册 web route 信息\n\n\n\n三、run_bot 源码分析  当我们执行 python butler.py run_bot --name fuzz-bot fuzz-bot/ 时，发生了什么？\nsequenceDiagram\n    participant A as bulter.py\n    box local/bulter\n        participant B as run_bot.py\n        participant C as common.py\n    end\n    box python/bot\n        participant D as startup/run_bot.py\n    end\n    box local/_internal\n        participant E as metrics/monitor.py\n        participant F as bot/fuzzers/init.py\n        participant G as bot/tasks/update_task.py\n        participant H as base/tasks.py\n        participant I as bot/tasks/commands.py\n    end\n    \n    A ->> A: call _setup\n    A ->> B: call execute\n    B ->> B: call _setup_bot_directory\n    B ->> B: call _setup_environment_and_configs\n    B ->> C: call execute_async\n    C ->> D: start bot\n    D ->> E: initialize monitor\n    E -->> D: \n    D ->> F: initialize fuzzer engine\n    F --> D: \n    loop task_loop\n        D ->> G: call run to update task\n        G --> D: \n        D ->> H: call get_task\n        H --> D: \n        D --> I: call process_commands to execute task\n    end\n\n_setup：设置工程的模块搜索路径\nrun_bot.execute：启动 bot\n_setup_bot_directory：创建 bot 相关路径\n_setup_environment_and_configs：设置运行环境，如环境变量等\nexecute_async(&#39;python src/python/bot/startup/run_bot.py&#39;)：启动 bot\nmonitor.initialize：初始化监控器\nfuzzers_init.run：初始化 fuzz 引擎，通过 import clusterfuzz._internal.bot.fuzzers.&#123;engine_name&#125;.engine 导入各 fuzzer 模块\ntask_loop：循环执行任务\nupdate_task.run：更新任务信息和 bot 心跳\ntasks.get_task：获取任务，有多种任务，fuzz 只是其中一种任务\ncommands.process_command：通过命令行执行任务\n\n\n\n\n\n\n","dateCreated":"2024-10-10T13:25:07+08:00","dateModified":"2024-11-05T13:28:48+08:00","datePublished":"2024-10-10T13:25:07+08:00","description":"ClusterFuzz 启动 server 和 bot 的源码分析","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%BA%8C%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%BA%8C%EF%BC%89/","keywords":"Fuzz, 安全, 源码"}</script>
     <meta name="description" content="ClusterFuzz 启动 server 和 bot 的源码分析">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="ClusterFuzz 源码分析（二）">
@@ -25,8 +25,8 @@
 <meta property="article:published_time" content="2024-10-10T05:25:07.000Z">
 <meta property="article:modified_time" content="2024-11-05T05:28:48.920Z">
 <meta property="article:author" content="一瓢清浅">
-<meta property="article:tag" content="安全">
 <meta property="article:tag" content="Fuzz">
+<meta property="article:tag" content="安全">
 <meta property="article:tag" content="源码">
 <meta name="twitter:card" content="summary">
     
diff --git "a/2024/Hexo\346\215\243\351\274\223\346\234\255\350\256\260/index.html" "b/2024/Hexo\346\215\243\351\274\223\346\234\255\350\256\260/index.html"
index a73f011..1f31a15 100644
--- "a/2024/Hexo\346\215\243\351\274\223\346\234\255\350\256\260/index.html"
+++ "b/2024/Hexo\346\215\243\351\274\223\346\234\255\350\256\260/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\nHexo 简介 Hexo 是一个快速、简洁且强大的静态博客框架，基于 Node.js 开发，允许用户使用 Markdown 语法 编写文章，并将其转换为 HTML 页面，部署后呈现为个人或企业的 web 站点。\n建站\n安装 Node.js：访问 Node.js 官网，下载并安装\n安装 Hexo：在命令行中，通过 npm 命令安装 hexo1npm install -g hexo-cli\n初始化 Hexo 站点：在命令行中，使用 hexo 命令创建一个博客123hexo init blogcd blognpm install\n启动 Hexo 站点：使用 hexo 命令启动本地预览，通过 http://localhost:4000 即可访问1hexo server\n新建文章：使用 hexo 命令创建一篇名为 article.md 的文章1hexo new post article\n生成静态文件：使用 hexo 命令生成静态 html 文件1hexo generate\n部署网站：1hexo deploy\n\nHexo 支持的各条指令和使用方法，请参考 Hexo 官网的  命令说明。\n配置  当初始化站点执行成功后，进入站点目录，可以看到如下内容：\n\n.├── _config.yml&emsp;# 网站配置信息 ├── package.json&emsp;# 程序使用的工具和库文件信息 ├── scaffolds&emsp;# 存放网站使用的模版文件 ├── source&emsp;# 存放用户资源，如文章、图片等 |   ├── _drafts&emsp;# 存放未发布的草稿 |   └── _posts&emsp;# 存放正式发布的博文 └── themes&emsp;# 博客使用的主题 \n\n网站配置项都包含在_config.yml 文件中，各配置项的含义，请参考 Hexo 官网的  配置说明。\n常见的个性化定义的配置项包括：\n\n\n\n参数\n含义\n默认值\n\n\n\ntitle\n网站标题\n\n\n\ndescription\n网站描述。主要用于 SEO\n\n\n\nkeywords\n网站关键词\n\n\n\nauthor\n网站作者\n\n\n\nlanguage\n网站语言。中国大陆使用zh-CN\n\n\n\ntimezone\n网站时区。中国大陆使用Asia/Shanghai\n\n\n\npermalink\n文章永久链接格式。为了优化 SEO，建议缩短长度\n:year&#x2F;:month&#x2F;:day&#x2F;:title&#x2F;\n\n\ntheme\n使用的主题名称。为 false 表示禁用主题\n\n\n\ndeploy\n部署环境配置。常见的有 Github\n\n\n\nHexo 主题  对于前端零基础、审美也堪忧的人来说，从空白雕出一个漂亮的网页 UI，那是不可能的，好在 Hexo 提供了丰富的  主题。\n通过预览找到心仪的主题，记住主题的名称，然后到 github 上用 hexo-theme-$name 搜索，即可找到主题对应的代码仓。为什么 Hexo 主题预览页不直接提供对应的 github 仓库的链接呢，令人费解 o(╯□╰)o。\n关于主题挑选，从审美上来说，萝卜青菜，各有所爱；从可用性来说，建议选使用者还算多的，代码仓还有人维护的。不同的主题切换，还是需要一些适配成本的。\n我选的tranquilpeak，用的人不算少，但是作者好像已经不怎么维护和更新了。导致有一些功能需要自己开发和改造，过程中免不了踩一些坑，这也是本篇博文诞生的主要原因。\n后续改动都是基于 tranquilpeak 主题，其他主题不一定能拿去即用，解决方案仅供参考。\n安装  根据 tranquilpeak仓库说明，tranquilpeak 的安装和启用包括以下步骤：\n\n下载  最新版的 tranquilpeak\n解压后，放到 Hexo 博客主目录下 themes 文件夹中\n修改 Hexo 博客主目录下 _config.yml 文件中 theme 参数，设置为tranquilpeak\n进入 Hexo 博客主目录下 themes\\tranquilpeak 文件夹中，执行命令：1npm install &amp;&amp; npm run prod\n\n配置  在themes\\tranquilpeak文件夹中也有一个 _config.yml，这个文件中的配置项会覆盖 Hexo 博客主目录下_config.yml 的同名配置项。\ntranquilpeak 主题的配置方法参考  仓库说明。\n本博客站点设置的一些 tranquilpeak 主题配置如下：\n\n\n\n配置项\n含义\n取值\n说明\n\n\n\nlocation\n位置信息\n中国\n中国\n\n\npicture\n个人头像\nphoto.jpg\n位于source\\assets\\images\n\n\ngithub\ngithub 用户名\n\n\n\n\nsidebar_behavior\n侧边栏的呈现\n2\n有 1-6 种方式可以选\n\n\ncover_image\n主题的背景图\ncover.png\n位于source\\assets\\images\n\n\n改造1. 添加 mermaid 支持mermaid 是一款使用文本来绘制图表的工具，可以与 markdown 集成，使用标记语言完成流程图、序列图、甘特图等图表绘制。\ntranquilpeak 主题不支持 mermaid 渲染，需要自己改造。\n\n安装插件1npm install hexo-filter-mermaid-diagrams\n修改配置文件：在 themes/tranquilpeak/_config.yml 中添加如下内容，表示启用 mermaid123456# Mermaid (markdwon to flow chart, seq chart, class chart ...)mermaid:  enable: true  version: 9.0.0  # Available themes: default | dark | forest | neutral  theme: default\n修改 script.ejs 文件：在 themes/tranquilpeak/layout/_partial/script.ejs 末尾添加如下内容，完成 mermaid 初始化123456789101112&lt;% if (theme.mermaid.enable) &#123; %&gt;  &lt;script src=&#x27;https://unpkg.com/mermaid@&lt;%= theme.mermaid.version %&gt;/dist/mermaid.min.js&#x27;&gt;&lt;/script&gt;   &lt;script type=&quot;text/javascript&quot;&gt;      $(document).ready(function() &#123;          var mermaid_config = &#123;              startOnLoad: true,              theme: &#x27;&lt;%- theme.mermaid.theme %&gt;&#x27;          &#125;          mermaid.initialize(mermaid_config);      &#125;);  &lt;/script&gt; &lt;% &#125; %&gt;\n修改_base.scss 文件：在 themes/tranquilpeak/source/_css/base/_base.scss 中，添加如下内容，设置 mermaid 图片样式，避免图片前后出现大片空白的情况。注意设置完后需要执行 npm run prod 重新构建主题，才能使得修改生效。1234pre.mermaid &gt; svg &#123;    width: 100%;    height: 100%;&#125;\n\n2. 添加目录导航侧边栏  对于长文浏览来说，目录导航能有效提高阅读体验。tranquilpeak 主题自带的 toc 不好用，生成的目录默认都位于文章最开头，对于长文不够友好。\ntranquilpeak 主题支持多种屏幕大小，以及自定义的窗口样式。tocbot 作为外来者，适配窗口样式有点麻烦。我这个前端小白折腾了好久，终于让 tranquilpeak 勉强兼容了 tocbot，大致步骤如下：\n\n安装 tocbot 插件：tocbot是一款自动根据标题构建目录的工具1npm install tocbot --save\n修改配置文件：在 themes/tranquilpeak/_config.yml 中添加如下内容，表示启用 tocbot12345678# add toc in posttocbot:  enable: true  tocSelector: &#x27;#post-toc&#x27;  contentSelector: &#x27;.post-content&#x27;  headings:     - &#x27;h2&#x27;     - &#x27;h3&#x27;\n修改 script.ejs 文件：在 themes/tranquilpeak/layout/_partial/script.ejs 末尾添加如下内容，完成 tocbot 初始化1234567891011121314&lt;% if (theme.tocbot.enable) &#123; %&gt;  &lt;script src=&quot;https://cdn.jsdelivr.net/npm/tocbot@4.25.0/dist/tocbot.min.js&quot;&gt;&lt;/script&gt;   &lt;script type=&quot;text/javascript&quot;&gt;      tocbot.init(&#123;        tocSelector: &#x27;&lt;%- theme.tocbot.tocSelector %&gt;&#x27;, // 目录容器的 ID 或 class        contentSelector: &#x27;&lt;%- theme.tocbot.contentSelector %&gt;&#x27;, // 内容容器的 ID 或 class        headingSelector: &#x27;&lt;%- theme.tocbot.headings %&gt;&#x27;, // 包含在目录中的标题级别        collapseDepth: 3,        scrollSmooth: true,         activeClass: &#x27;active&#x27;,         orderedList: false    &#125;);  &lt;/script&gt; &lt;% &#125; %&gt;\n修改 layout.ejs 文件：在 themes/tranquilpeak/layout/layout.ejs 中&lt;%- body %&gt;之前添加如下内容，在页面上添加 toc 空间1&lt;%- partial(&#x27;_partial/toc&#x27;, &#123;post: page&#125;) %&gt;\n增加 toc.ejs 文件：在 themes/tranquilpeak/layout/_partial/ 目录下新建 toc.ejs 文件，实现对 toc 的样式控制123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051&lt;% if (theme.tocbot.enable) &#123; %&gt;    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdnjs.cloudflare.com/ajax/libs/tocbot/4.25.0/tocbot.css&quot;&gt;    &lt;style&gt;        #post-toc &#123;            position: fixed !important;            top: 80px;            padding: 10px;            z-index: 100;            background-color: rgba(255,255,255,0);            transform: translateX(0);            right: 3%;            width: 220px;            height: auto;            padding-top: 10px;            padding-bottom: 10px;        &#125;    &lt;/style&gt;    &lt;script&gt;        var tocWidth = 220; // TOC 的固定宽度        var tocPadding = 10; // TOC 的内边距，这里假设是两边各 10px，总和为 20px        var tocRight = 0.03; // TOC 的右边框距离屏幕右边的距离相对屏幕宽度的占比        // 检查窗口宽度并调整 TOC 显示        function adjustToc() &#123;            var toc = document.getElementById(&#x27;post-toc&#x27;);            var screenWidth = window.innerWidth || document.documentElement.clientWidth;            var contentWrap = document.querySelector(&#x27;div.post-content.markdown div.main-content-wrap&#x27;);            if (contentWrap) &#123;                var contentWidth = contentWrap.offsetWidth;                // 计算 contentWrap 的宽度加上 TOC 的宽度和内边距                var totalWidth = Math.round((contentWidth + tocWidth * 2 + tocPadding * 4) / (1 - tocRight * 2));                if (totalWidth &gt;= screenWidth) &#123;                    toc.style.display = &#x27;none&#x27;; // 如果总宽度大于或等于屏幕宽度，不显示 TOC                &#125; else &#123;                    toc.style.display = &#x27;block&#x27;; // 否则，显示 TOC                &#125;            &#125; else &#123;                toc.style.display = &#x27;none&#x27;; // 如果无法获取 contentWrap 的宽度，不显示 TOC            &#125;        &#125;        // 监听窗口大小变化事件        window.addEventListener(&#x27;resize&#x27;, adjustToc);        // 页面加载完毕时调用 adjustToc        document.addEventListener(&#x27;DOMContentLoaded&#x27;, adjustToc);    &lt;/script&gt;    &lt;div id=&quot;post-toc&quot; class=&quot;toc&quot; style=&quot;display: none;&quot;&gt;&lt;/div&gt; &lt;!-- 初始化时隐藏 --&gt;&lt;% &#125; %&gt;\n","dateCreated":"2024-04-03T14:48:16+08:00","dateModified":"2024-11-05T13:28:04+08:00","datePublished":"2024-04-03T14:48:16+08:00","description":"记录用 Hexo 搭建此个人博客遇到的相关问题","headline":"Hexo 捣鼓札记","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2024/Hexo%E6%8D%A3%E9%BC%93%E6%9C%AD%E8%AE%B0/"},"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/Hexo%E6%8D%A3%E9%BC%93%E6%9C%AD%E8%AE%B0/","keywords":"工具, Web, Hexo"}</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\nHexo 简介 Hexo 是一个快速、简洁且强大的静态博客框架，基于 Node.js 开发，允许用户使用 Markdown 语法 编写文章，并将其转换为 HTML 页面，部署后呈现为个人或企业的 web 站点。\n建站\n安装 Node.js：访问 Node.js 官网，下载并安装\n安装 Hexo：在命令行中，通过 npm 命令安装 hexo1npm install -g hexo-cli\n初始化 Hexo 站点：在命令行中，使用 hexo 命令创建一个博客123hexo init blogcd blognpm install\n启动 Hexo 站点：使用 hexo 命令启动本地预览，通过 http://localhost:4000 即可访问1hexo server\n新建文章：使用 hexo 命令创建一篇名为 article.md 的文章1hexo new post article\n生成静态文件：使用 hexo 命令生成静态 html 文件1hexo generate\n部署网站：1hexo deploy\n\nHexo 支持的各条指令和使用方法，请参考 Hexo 官网的  命令说明。\n配置  当初始化站点执行成功后，进入站点目录，可以看到如下内容：\n\n.├── _config.yml&emsp;# 网站配置信息 ├── package.json&emsp;# 程序使用的工具和库文件信息 ├── scaffolds&emsp;# 存放网站使用的模版文件 ├── source&emsp;# 存放用户资源，如文章、图片等 |   ├── _drafts&emsp;# 存放未发布的草稿 |   └── _posts&emsp;# 存放正式发布的博文 └── themes&emsp;# 博客使用的主题 \n\n网站配置项都包含在_config.yml 文件中，各配置项的含义，请参考 Hexo 官网的  配置说明。\n常见的个性化定义的配置项包括：\n\n\n\n参数\n含义\n默认值\n\n\n\ntitle\n网站标题\n\n\n\ndescription\n网站描述。主要用于 SEO\n\n\n\nkeywords\n网站关键词\n\n\n\nauthor\n网站作者\n\n\n\nlanguage\n网站语言。中国大陆使用zh-CN\n\n\n\ntimezone\n网站时区。中国大陆使用Asia/Shanghai\n\n\n\npermalink\n文章永久链接格式。为了优化 SEO，建议缩短长度\n:year&#x2F;:month&#x2F;:day&#x2F;:title&#x2F;\n\n\ntheme\n使用的主题名称。为 false 表示禁用主题\n\n\n\ndeploy\n部署环境配置。常见的有 Github\n\n\n\nHexo 主题  对于前端零基础、审美也堪忧的人来说，从空白雕出一个漂亮的网页 UI，那是不可能的，好在 Hexo 提供了丰富的  主题。\n通过预览找到心仪的主题，记住主题的名称，然后到 github 上用 hexo-theme-$name 搜索，即可找到主题对应的代码仓。为什么 Hexo 主题预览页不直接提供对应的 github 仓库的链接呢，令人费解 o(╯□╰)o。\n关于主题挑选，从审美上来说，萝卜青菜，各有所爱；从可用性来说，建议选使用者还算多的，代码仓还有人维护的。不同的主题切换，还是需要一些适配成本的。\n我选的tranquilpeak，用的人不算少，但是作者好像已经不怎么维护和更新了。导致有一些功能需要自己开发和改造，过程中免不了踩一些坑，这也是本篇博文诞生的主要原因。\n后续改动都是基于 tranquilpeak 主题，其他主题不一定能拿去即用，解决方案仅供参考。\n安装  根据 tranquilpeak仓库说明，tranquilpeak 的安装和启用包括以下步骤：\n\n下载  最新版的 tranquilpeak\n解压后，放到 Hexo 博客主目录下 themes 文件夹中\n修改 Hexo 博客主目录下 _config.yml 文件中 theme 参数，设置为tranquilpeak\n进入 Hexo 博客主目录下 themes\\tranquilpeak 文件夹中，执行命令：1npm install &amp;&amp; npm run prod\n\n配置  在themes\\tranquilpeak文件夹中也有一个 _config.yml，这个文件中的配置项会覆盖 Hexo 博客主目录下_config.yml 的同名配置项。\ntranquilpeak 主题的配置方法参考  仓库说明。\n本博客站点设置的一些 tranquilpeak 主题配置如下：\n\n\n\n配置项\n含义\n取值\n说明\n\n\n\nlocation\n位置信息\n中国\n中国\n\n\npicture\n个人头像\nphoto.jpg\n位于source\\assets\\images\n\n\ngithub\ngithub 用户名\n\n\n\n\nsidebar_behavior\n侧边栏的呈现\n2\n有 1-6 种方式可以选\n\n\ncover_image\n主题的背景图\ncover.png\n位于source\\assets\\images\n\n\n改造1. 添加 mermaid 支持mermaid 是一款使用文本来绘制图表的工具，可以与 markdown 集成，使用标记语言完成流程图、序列图、甘特图等图表绘制。\ntranquilpeak 主题不支持 mermaid 渲染，需要自己改造。\n\n安装插件1npm install hexo-filter-mermaid-diagrams\n修改配置文件：在 themes/tranquilpeak/_config.yml 中添加如下内容，表示启用 mermaid123456# Mermaid (markdwon to flow chart, seq chart, class chart ...)mermaid:  enable: true  version: 9.0.0  # Available themes: default | dark | forest | neutral  theme: default\n修改 script.ejs 文件：在 themes/tranquilpeak/layout/_partial/script.ejs 末尾添加如下内容，完成 mermaid 初始化123456789101112&lt;% if (theme.mermaid.enable) &#123; %&gt;  &lt;script src=&#x27;https://unpkg.com/mermaid@&lt;%= theme.mermaid.version %&gt;/dist/mermaid.min.js&#x27;&gt;&lt;/script&gt;   &lt;script type=&quot;text/javascript&quot;&gt;      $(document).ready(function() &#123;          var mermaid_config = &#123;              startOnLoad: true,              theme: &#x27;&lt;%- theme.mermaid.theme %&gt;&#x27;          &#125;          mermaid.initialize(mermaid_config);      &#125;);  &lt;/script&gt; &lt;% &#125; %&gt;\n修改_base.scss 文件：在 themes/tranquilpeak/source/_css/base/_base.scss 中，添加如下内容，设置 mermaid 图片样式，避免图片前后出现大片空白的情况。注意设置完后需要执行 npm run prod 重新构建主题，才能使得修改生效。1234pre.mermaid &gt; svg &#123;    width: 100%;    height: 100%;&#125;\n\n2. 添加目录导航侧边栏  对于长文浏览来说，目录导航能有效提高阅读体验。tranquilpeak 主题自带的 toc 不好用，生成的目录默认都位于文章最开头，对于长文不够友好。\ntranquilpeak 主题支持多种屏幕大小，以及自定义的窗口样式。tocbot 作为外来者，适配窗口样式有点麻烦。我这个前端小白折腾了好久，终于让 tranquilpeak 勉强兼容了 tocbot，大致步骤如下：\n\n安装 tocbot 插件：tocbot是一款自动根据标题构建目录的工具1npm install tocbot --save\n修改配置文件：在 themes/tranquilpeak/_config.yml 中添加如下内容，表示启用 tocbot12345678# add toc in posttocbot:  enable: true  tocSelector: &#x27;#post-toc&#x27;  contentSelector: &#x27;.post-content&#x27;  headings:     - &#x27;h2&#x27;     - &#x27;h3&#x27;\n修改 script.ejs 文件：在 themes/tranquilpeak/layout/_partial/script.ejs 末尾添加如下内容，完成 tocbot 初始化1234567891011121314&lt;% if (theme.tocbot.enable) &#123; %&gt;  &lt;script src=&quot;https://cdn.jsdelivr.net/npm/tocbot@4.25.0/dist/tocbot.min.js&quot;&gt;&lt;/script&gt;   &lt;script type=&quot;text/javascript&quot;&gt;      tocbot.init(&#123;        tocSelector: &#x27;&lt;%- theme.tocbot.tocSelector %&gt;&#x27;, // 目录容器的 ID 或 class        contentSelector: &#x27;&lt;%- theme.tocbot.contentSelector %&gt;&#x27;, // 内容容器的 ID 或 class        headingSelector: &#x27;&lt;%- theme.tocbot.headings %&gt;&#x27;, // 包含在目录中的标题级别        collapseDepth: 3,        scrollSmooth: true,         activeClass: &#x27;active&#x27;,         orderedList: false    &#125;);  &lt;/script&gt; &lt;% &#125; %&gt;\n修改 layout.ejs 文件：在 themes/tranquilpeak/layout/layout.ejs 中&lt;%- body %&gt;之前添加如下内容，在页面上添加 toc 空间1&lt;%- partial(&#x27;_partial/toc&#x27;, &#123;post: page&#125;) %&gt;\n增加 toc.ejs 文件：在 themes/tranquilpeak/layout/_partial/ 目录下新建 toc.ejs 文件，实现对 toc 的样式控制123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051&lt;% if (theme.tocbot.enable) &#123; %&gt;    &lt;link rel=&quot;stylesheet&quot; href=&quot;https://cdnjs.cloudflare.com/ajax/libs/tocbot/4.25.0/tocbot.css&quot;&gt;    &lt;style&gt;        #post-toc &#123;            position: fixed !important;            top: 80px;            padding: 10px;            z-index: 100;            background-color: rgba(255,255,255,0);            transform: translateX(0);            right: 3%;            width: 220px;            height: auto;            padding-top: 10px;            padding-bottom: 10px;        &#125;    &lt;/style&gt;    &lt;script&gt;        var tocWidth = 220; // TOC 的固定宽度        var tocPadding = 10; // TOC 的内边距，这里假设是两边各 10px，总和为 20px        var tocRight = 0.03; // TOC 的右边框距离屏幕右边的距离相对屏幕宽度的占比        // 检查窗口宽度并调整 TOC 显示        function adjustToc() &#123;            var toc = document.getElementById(&#x27;post-toc&#x27;);            var screenWidth = window.innerWidth || document.documentElement.clientWidth;            var contentWrap = document.querySelector(&#x27;div.post-content.markdown div.main-content-wrap&#x27;);            if (contentWrap) &#123;                var contentWidth = contentWrap.offsetWidth;                // 计算 contentWrap 的宽度加上 TOC 的宽度和内边距                var totalWidth = Math.round((contentWidth + tocWidth * 2 + tocPadding * 4) / (1 - tocRight * 2));                if (totalWidth &gt;= screenWidth) &#123;                    toc.style.display = &#x27;none&#x27;; // 如果总宽度大于或等于屏幕宽度，不显示 TOC                &#125; else &#123;                    toc.style.display = &#x27;block&#x27;; // 否则，显示 TOC                &#125;            &#125; else &#123;                toc.style.display = &#x27;none&#x27;; // 如果无法获取 contentWrap 的宽度，不显示 TOC            &#125;        &#125;        // 监听窗口大小变化事件        window.addEventListener(&#x27;resize&#x27;, adjustToc);        // 页面加载完毕时调用 adjustToc        document.addEventListener(&#x27;DOMContentLoaded&#x27;, adjustToc);    &lt;/script&gt;    &lt;div id=&quot;post-toc&quot; class=&quot;toc&quot; style=&quot;display: none;&quot;&gt;&lt;/div&gt; &lt;!-- 初始化时隐藏 --&gt;&lt;% &#125; %&gt;\n","dateCreated":"2024-04-03T14:48:16+08:00","dateModified":"2024-11-05T13:36:12+08:00","datePublished":"2024-04-03T14:48:16+08:00","description":"记录用 Hexo 搭建此个人博客遇到的相关问题","headline":"Hexo 捣鼓札记","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/2024/Hexo%E6%8D%A3%E9%BC%93%E6%9C%AD%E8%AE%B0/"},"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/Hexo%E6%8D%A3%E9%BC%93%E6%9C%AD%E8%AE%B0/","keywords":"Web, Hexo"}</script>
     <meta name="description" content="记录用 Hexo 搭建此个人博客遇到的相关问题">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="Hexo 捣鼓札记">
@@ -23,9 +23,8 @@
 <meta property="og:description" content="记录用 Hexo 搭建此个人博客遇到的相关问题">
 <meta property="og:locale" content="zh_CN">
 <meta property="article:published_time" content="2024-04-03T06:48:16.000Z">
-<meta property="article:modified_time" content="2024-11-05T05:28:04.204Z">
+<meta property="article:modified_time" content="2024-11-05T05:36:12.282Z">
 <meta property="article:author" content="一瓢清浅">
-<meta property="article:tag" content="工具">
 <meta property="article:tag" content="Web">
 <meta property="article:tag" content="Hexo">
 <meta name="twitter:card" content="summary">
@@ -404,7 +403,7 @@ <h4 id="2- 添加目录导航侧边栏"><a href="#2- 添加目录导航侧边栏
             <div class="post-footer-tags">
                 <span class="text-color-light text-small">标签</span><br>
                 
-    <a class="tag tag--primary tag--small t-none-link" href="/tags/Hexo/" rel="tag">Hexo</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/Web/" rel="tag">Web</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E5%B7%A5%E5%85%B7/" rel="tag">工具</a>
+    <a class="tag tag--primary tag--small t-none-link" href="/tags/Hexo/" rel="tag">Hexo</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/Web/" rel="tag">Web</a>
 
             </div>
         
diff --git "a/2024/Python\350\277\233\351\230\266\342\200\224\342\200\224\345\271\266\345\217\221\347\274\226\347\250\213/index.html" "b/2024/Python\350\277\233\351\230\266\342\200\224\342\200\224\345\271\266\345\217\221\347\274\226\347\250\213/index.html"
index ea3ba07..58f207d 100644
--- "a/2024/Python\350\277\233\351\230\266\342\200\224\342\200\224\345\271\266\345\217\221\347\274\226\347\250\213/index.html"
+++ "b/2024/Python\350\277\233\351\230\266\342\200\224\342\200\224\345\271\266\345\217\221\347\274\226\347\250\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\n一、基本概念1. 进程、线程与协程\n进程：进程是操作系统分配资源的基本单位，它包含了一个程序的执行实例及其用到的系统资源（如内存、文件、设备等）。每个进程有自己独立的内存空间，不同的进程通过进程间通信来交换信息。\n线程：线程是 CPU 调度和执行的基本单位，是包含在进程中（比进程更小）的能独立运行的最小单位，线程又称为轻量级进程。每个进程可以有一个或多个线程，进程中的各个线程共享该进程的内存空间。线程没有独立的内存空间，只拥有运行时必不可少的资源，如程序计数器、寄存器和栈。\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较高，涉及 CPU 的上下文切换\n较低，涉及内核线程的上下文切换\n最低，通常由程序控制，不需要 CPU 和内核上下文切换\n\n\n通信方式\n通过进程间通信(IPC)，如管道、消息队列、共享内存等\n通过共享内存\n通过参数传递，或共享数据结构\n\n\n应用场景\n不同的程序或服务\n多个子任务并发执行\n异步编程，提高性能\n\n\n竞态条件\n使用锁、信号量等同步机制\n使用锁、信号量等同步机制\n通常不用加锁，协程之间没有竞争关系\n\n\n举个通俗点的例子来理解下这些干巴巴的概念：\n比如我们要准备一顿晚饭，做饭这项活动就可以视为一个进程，炉灶和食材是这个进程可以利用的资源。\n炒菜和煮饭可以视为两个子线程，它们共用炉灶和食材资源，当资源紧缺（比如只有一个炉灶）时，会存在竞争关系。\n晚饭计划一菜一汤，当炖汤时，我们可以一边等，一边准备下一道菜的工序，比如摘菜、洗菜、切菜。每项工序完成，我们还要去看看炖汤的进展。这个切换操作就是协程。\n2. 并发和并行\n并发：指在同一时间段内宏观上有多个程序在同时运行，但在单核 CPU 中，这些程序是交替执行的，同一时刻，只有一条指令在执行。\n并行：指在同一时刻，有多条指令在多个处理器上同时执行，需要有硬件支持，比如多核 CPU、GPU 等，是真正意义上的同时运行。\n\n举个例子，在一个便利店有两队（红队和蓝队）顾客排队买单。\n如果只有一个收银员，那这个收银员只能交替给两队顾客结账，在同一时刻，只能有一个顾客在买单，要么来自红队，要么来自蓝队。\n如果有两个收银员，那么每个收银员可以对接一队顾客。在同一时刻，蓝队和红队可能同时有顾客在买单。\n3. 同步和异步\n同步：在同步模式下，当程序执行一个操作 A，必须等这个 A 操作返回结果后，才能执行下一个操作 B。当操作 A 需要执行很长时间才能完成时，操作 B 需要陷入长久的等待，程序出现阻塞。\n异步：在异步模式下，当程序执行一个操作 A，不会等 A 操作完成，而是立即执行下一个操作 B。当 A 操作执行完后，程序通过某种机制（例如回调函数、事件等）接收 A 操作的结果，再进行后续处理。异步使得在等待操作 A 运行期间，程序可以执行其他操作，提高了运行效率。\n\n举个例子，肚子饿了去搞吃的，有两种餐馆：\n一种是没有服务员上菜的，只能在窗口排队等着，现点现做，拿到餐品才能去找座位。这种就是同步模式，等取餐了才能去找座位。\n另一种是有服务员负责传餐的，点完餐品，可以先去找个位子坐下，等服务员上菜就行。这种就是异步模式，等餐的过程中可以去找座位。\n异步和协程的想法很相似，当某一项任务需要花费很长时间时，可以先转去做别的任务，避免干等。\n协程可以作为实现异步的一种技术，它提供了一种简洁好用的异步模型，避免了多层嵌套的回调函数（回调地狱）导致代码变得极其复杂，难以理解和维护。\n二、python 并发实践 1. 多进程与进程池2. 多线程与线程池3. 协程4. 异步 三、参考资料\n一文读懂什么是进程、线程、协程\n一篇文章搞懂 Python 中的进程和线程\npython3-cookbook 并发编程\n2w 字 + 40 张图带你参透并发编程\n","dateCreated":"2024-06-26T10:56:20+08:00","dateModified":"2024-08-21T15:24:18+08:00","datePublished":"2024-06-26T10:56:20+08:00","description":"进程、线程、协程，并发编程绕不过的三座大山","headline":"Python 进阶——并发编程","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/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/"},"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/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/","keywords":"编程, 开发, 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一、基本概念1. 进程、线程与协程\n进程：进程是操作系统分配资源的基本单位，它包含了一个程序的执行实例及其用到的系统资源（如内存、文件、设备等）。每个进程有自己独立的内存空间，不同的进程通过进程间通信来交换信息。\n线程：线程是 CPU 调度和执行的基本单位，是包含在进程中（比进程更小）的能独立运行的最小单位，线程又称为轻量级进程。每个进程可以有一个或多个线程，进程中的各个线程共享该进程的内存空间。线程没有独立的内存空间，只拥有运行时必不可少的资源，如程序计数器、寄存器和栈。\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较高，涉及 CPU 的上下文切换\n较低，涉及内核线程的上下文切换\n最低，通常由程序控制，不需要 CPU 和内核上下文切换\n\n\n通信方式\n通过进程间通信(IPC)，如管道、消息队列、共享内存等\n通过共享内存\n通过参数传递，或共享数据结构\n\n\n应用场景\n不同的程序或服务\n多个子任务并发执行\n异步编程，提高性能\n\n\n竞态条件\n使用锁、信号量等同步机制\n使用锁、信号量等同步机制\n通常不用加锁，协程之间没有竞争关系\n\n\n举个通俗点的例子来理解下这些干巴巴的概念：\n比如我们要准备一顿晚饭，做饭这项活动就可以视为一个进程，炉灶和食材是这个进程可以利用的资源。\n炒菜和煮饭可以视为两个子线程，它们共用炉灶和食材资源，当资源紧缺（比如只有一个炉灶）时，会存在竞争关系。\n晚饭计划一菜一汤，当炖汤时，我们可以一边等，一边准备下一道菜的工序，比如摘菜、洗菜、切菜。每项工序完成，我们还要去看看炖汤的进展。这个切换操作就是协程。\n2. 并发和并行\n并发：指在同一时间段内宏观上有多个程序在同时运行，但在单核 CPU 中，这些程序是交替执行的，同一时刻，只有一条指令在执行。\n并行：指在同一时刻，有多条指令在多个处理器上同时执行，需要有硬件支持，比如多核 CPU、GPU 等，是真正意义上的同时运行。\n\n举个例子，在一个便利店有两队（红队和蓝队）顾客排队买单。\n如果只有一个收银员，那这个收银员只能交替给两队顾客结账，在同一时刻，只能有一个顾客在买单，要么来自红队，要么来自蓝队。\n如果有两个收银员，那么每个收银员可以对接一队顾客。在同一时刻，蓝队和红队可能同时有顾客在买单。\n3. 同步和异步\n同步：在同步模式下，当程序执行一个操作 A，必须等这个 A 操作返回结果后，才能执行下一个操作 B。当操作 A 需要执行很长时间才能完成时，操作 B 需要陷入长久的等待，程序出现阻塞。\n异步：在异步模式下，当程序执行一个操作 A，不会等 A 操作完成，而是立即执行下一个操作 B。当 A 操作执行完后，程序通过某种机制（例如回调函数、事件等）接收 A 操作的结果，再进行后续处理。异步使得在等待操作 A 运行期间，程序可以执行其他操作，提高了运行效率。\n\n举个例子，肚子饿了去搞吃的，有两种餐馆：\n一种是没有服务员上菜的，只能在窗口排队等着，现点现做，拿到餐品才能去找座位。这种就是同步模式，等取餐了才能去找座位。\n另一种是有服务员负责传餐的，点完餐品，可以先去找个位子坐下，等服务员上菜就行。这种就是异步模式，等餐的过程中可以去找座位。\n异步和协程的想法很相似，当某一项任务需要花费很长时间时，可以先转去做别的任务，避免干等。\n协程可以作为实现异步的一种技术，它提供了一种简洁好用的异步模型，避免了多层嵌套的回调函数（回调地狱）导致代码变得极其复杂，难以理解和维护。\n二、python 并发实践 1. 多进程与进程池2. 多线程与线程池3. 协程4. 异步 三、参考资料\n一文读懂什么是进程、线程、协程\n一篇文章搞懂 Python 中的进程和线程\npython3-cookbook 并发编程\n2w 字 + 40 张图带你参透并发编程\n","dateCreated":"2024-06-26T10:56:20+08:00","dateModified":"2024-08-21T15:24:18+08:00","datePublished":"2024-06-26T10:56:20+08:00","description":"进程、线程、协程，并发编程绕不过的三座大山","headline":"Python 进阶——并发编程","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/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/"},"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/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/","keywords":"Python, 编程, 开发"}</script>
     <meta name="description" content="进程、线程、协程，并发编程绕不过的三座大山">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="Python 进阶——并发编程">
@@ -25,9 +25,9 @@
 <meta property="article:published_time" content="2024-06-26T02:56:20.000Z">
 <meta property="article:modified_time" content="2024-08-21T07:24:18.017Z">
 <meta property="article:author" content="一瓢清浅">
+<meta property="article:tag" content="Python">
 <meta property="article:tag" content="编程">
 <meta property="article:tag" content="开发">
-<meta property="article:tag" content="Python">
 <meta name="twitter:card" content="summary">
     
     
@@ -349,7 +349,7 @@ <h2 id="二、python 并发实践"><a href="# 二、python 并发实践" class="
             <li class="post-action">
                 
                     
-                <a class="post-action-btn btn btn--default tooltip--top" 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/" data-tooltip="AFLplusplus 源码分析——同步机制" aria-label="上一篇: AFLplusplus 源码分析——同步机制">
+                <a class="post-action-btn btn btn--default tooltip--top" 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/" data-tooltip="AFL++ 源码分析——同步机制" aria-label="上一篇: AFL++ 源码分析——同步机制">
                     
                         <i class="fa fa-angle-left" aria-hidden="true"></i>
                         <span class="hide-xs hide-sm text-small icon-ml">上一篇</span>
@@ -412,7 +412,7 @@ <h2 id="二、python 并发实践"><a href="# 二、python 并发实践" class="
             <li class="post-action">
                 
                     
-                <a class="post-action-btn btn btn--default tooltip--top" 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/" data-tooltip="AFLplusplus 源码分析——同步机制" aria-label="上一篇: AFLplusplus 源码分析——同步机制">
+                <a class="post-action-btn btn btn--default tooltip--top" 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/" data-tooltip="AFL++ 源码分析——同步机制" aria-label="上一篇: AFL++ 源码分析——同步机制">
                     
                         <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/Symbion\345\210\235\346\216\242/index.html" "b/2024/Symbion\345\210\235\346\216\242/index.html"
index 16cd24d..91cbfbc 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-11-05T13:27:14+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":"符号执行, Angr, 安全, 工具"}</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-11-05T13:36:12+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":"安全, 符号执行, Angr"}</script>
     <meta name="description" content="Symbion 是 Angr 的一款插件，可以实现具体执行与符号执行交替运行">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="交替符号执行工具——Symbion 初探">
@@ -30,12 +30,11 @@
 <meta property="og:image" content="https://www.stepbystep.asia/2024/Symbion%E5%88%9D%E6%8E%A2/not_packed_elf64%E6%8C%87%E5%AE%9A%E8%B7%AF%E5%BE%84.png">
 <meta property="og:image" content="https://www.stepbystep.asia/2024/Symbion%E5%88%9D%E6%8E%A2/not_packed_elf64%E7%A4%BA%E4%BE%8B%E4%BB%A3%E7%A0%81%E5%88%86%E6%9E%90.png">
 <meta property="article:published_time" content="2024-02-27T08:33:24.000Z">
-<meta property="article:modified_time" content="2024-11-05T05:27:14.313Z">
+<meta property="article:modified_time" content="2024-11-05T05:36:12.321Z">
 <meta property="article:author" content="一瓢清浅">
+<meta property="article:tag" content="安全">
 <meta property="article:tag" content="符号执行">
 <meta property="article:tag" content="Angr">
-<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">
     
@@ -379,7 +378,7 @@ <h2 id="二、示例分析"><a href="# 二、示例分析" class="headerlink" ti
             <div class="post-footer-tags">
                 <span class="text-color-light text-small">标签</span><br>
                 
-    <a class="tag tag--primary tag--small t-none-link" href="/tags/Angr/" rel="tag">Angr</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E5%AE%89%E5%85%A8/" rel="tag">安全</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E5%B7%A5%E5%85%B7/" rel="tag">工具</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E7%AC%A6%E5%8F%B7%E6%89%A7%E8%A1%8C/" rel="tag">符号执行</a>
+    <a class="tag tag--primary tag--small t-none-link" href="/tags/Angr/" rel="tag">Angr</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E5%AE%89%E5%85%A8/" rel="tag">安全</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E7%AC%A6%E5%8F%B7%E6%89%A7%E8%A1%8C/" rel="tag">符号执行</a>
 
             </div>
         
diff --git "a/2024/\346\261\241\347\202\271\345\210\206\346\236\220\345\267\245\345\205\267\342\200\224\342\200\224libdft64/index.html" "b/2024/\346\261\241\347\202\271\345\210\206\346\236\220\345\267\245\345\205\267\342\200\224\342\200\224libdft64/index.html"
index 2b75f90..ab3759b 100644
--- "a/2024/\346\261\241\347\202\271\345\210\206\346\236\220\345\267\245\345\205\267\342\200\224\342\200\224libdft64/index.html"
+++ "b/2024/\346\261\241\347\202\271\345\210\206\346\236\220\345\267\245\345\205\267\342\200\224\342\200\224libdft64/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\nlibdft64 简介libdft64 一款基于 Intel Pin 开发的动态污点分析工具。\n1. 污点分析  污点分析（Taint Analysis）是一种跟踪并分析污点信息（通常指程序接受的外部输入）在程序中流动的技术。污点分析过程通常包括三个步骤：\n\n识别并标记污点源（Source）\n跟踪污点在程序中的传播（propagation）\n在关键的程序点（Sink）检测是否受到污点的影响\n\n动态污点分析（Dynamic Taint Analysis, DTA）是一种用于确定在程序运行时，运行环境中哪些寄存器和内存区域，可以由外部输入来进行控制的技术。\n动态污点分析与静态污点分析的主要区别在于，静态污点分析是模拟程序运行，而动态污点分析需要实际运行程序。动态污点分析的优缺点为：\n\n优点：误报率较低，检测结果的可信度较高。\n缺点：\n漏报率较高：由程序动态运行时的代码覆盖率决定\n平台相关性较高：特定的动态污点分析工具只能够解决在特定平台上运行的程序\n资源消耗大：包括空间复杂度和时间复杂度\n\n\n\n2. Intel PinIntel Pin 是一个动态二进制插桩（Dynamic Binary Instrumentation, DBI）框架，由英特尔公司开发。它允许用户在程序运行时（即不需要源代码）对程序的二进制代码进行插桩和分析。\nIntel Pin 提供了丰富的 API 库，供开发者编写和构建自己的 Pintool，用来完成特定的分析任务。\nlibdft64 安装和使用1. 安装和构建libdft64 是一款开源工具，它依赖于 Intel Pin。使用时需要下载源码，安装依赖，执行构建：\n12345git clone https://github.com/AngoraFuzzer/libdft64.gitcd libdft64PREFIX=~/pin ./install_pin.shexport PIN_ROOT=~/pin/pin-3.20-98437-gf02b61307-gcc-linuxmake\n\n2. 示例解析(1) 使用演示libdft64 给出的示例用法如下：\n12cd toolsmake test_mini\n执行结果为：\n\n\n(2) 源码解读 libdft64 测试对象的源码为mini_test.cpp。在main 函数中，调用一些自定义的函数(__libdft_set_taint, __libdft_get_taint, __libdft_getval_taint)，来进行污点数据的设置和获取操作。\n1234567891011121314151617181920212223242526272829303132333435363738394041int main(int argc, char **argv) &#123;  if (argc &lt; 2)    return 0;  FILE *fp;  char buf[255];  size_t ret;  fp = fopen(argv[1], &quot;rb&quot;);  if (!fp) &#123;    printf(&quot;st err\\n&quot;);    return 0;  &#125;  int len = 20;  // dfsan_read_label(&amp;(len), sizeof *buf);  ret = fread(buf, sizeof *buf, len, fp);  fclose(fp);  // printf(&quot;len is :%d\\n&quot;, len);  if (ret &lt; len) &#123;    // printf(&quot;input fail \\n&quot;);    return 0;  &#125;  uint64_t m = 0;  __libdft_set_taint(&amp;m, 8);  __libdft_get_taint(&amp;m);  __libdft_getval_taint(m);  uint16_t x = 0;  __libdft_get_taint(&amp;x);  memcpy(&amp;x, buf + 5, 2); // x 1 - 2  __libdft_get_taint(&amp;x);  __libdft_getval_taint(x);  uint64_t y = x + 2;  __libdft_getval_taint(y);  return 0;&#125;\n\n使用 libdft64 进行污点追踪的代码为 track.cpp。通过 Intel Pin 的 API 函数RTN_FindByName 来定位 mini_test.cpp 中的函数 (__libdft_set_taint, __libdft_get_taint, __libdft_getval_taint)，并通过 Intel Pin 的 API 函数RTN_InsertCall 来对这些定位到的函数进行插桩。当运行到目标函数时，会调用相应的 handler 函数 (TestSetHandler, TestGetHandler, TestGetValHandler) 执行额外操作。\n123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475VOID TestGetHandler(void *p) &#123;  uint64_t v = *((uint64_t *)p);  tag_t t = tagmap_getn((ADDRINT)p, 8);  printf(&quot;[PIN][GET] addr: %p, v: %lu, lb: %d, taint: %s\\n&quot;, p, v, t,         tag_sprint(t).c_str());&#125;VOID TestGetValHandler(THREADID tid, uint64_t v) &#123;  tag_t t = tagmap_getn_reg(tid, X64_ARG0_REG, 8);  printf(&quot;[PIN][GETVAL] v: %lu, lb: %d, taint: %s\\n&quot;, v, t,         tag_sprint(t).c_str());&#125;VOID TestSetHandler(void *p, unsigned int v) &#123;  tag_t t = tag_alloc&lt;tag_t&gt;(v);  tagmap_setb((ADDRINT)p, t);  printf(&quot;[PIN][SET] addr: %p, lb: %d, taint: %d\\n&quot;, p, t, v);&#125;VOID EntryPoint(VOID *v) &#123;  for (IMG img = APP_ImgHead(); IMG_Valid(img); img = IMG_Next(img)) &#123;    RTN test_get_rtn = RTN_FindByName(img, &quot;__libdft_get_taint&quot;);    if (RTN_Valid(test_get_rtn)) &#123;      RTN_Open(test_get_rtn);      RTN_InsertCall(test_get_rtn, IPOINT_BEFORE, (AFUNPTR)TestGetHandler,                     IARG_FUNCARG_ENTRYPOINT_VALUE, 0, IARG_END);      RTN_Close(test_get_rtn);    &#125;    RTN test_set_rtn = RTN_FindByName(img, &quot;__libdft_set_taint&quot;);    if (RTN_Valid(test_set_rtn)) &#123;      RTN_Open(test_set_rtn);      RTN_InsertCall(test_set_rtn, IPOINT_BEFORE, (AFUNPTR)TestSetHandler,                     IARG_FUNCARG_ENTRYPOINT_VALUE, 0,                     IARG_FUNCARG_ENTRYPOINT_VALUE, 1, IARG_END);      RTN_Close(test_set_rtn);    &#125;    RTN test_getval_rtn = RTN_FindByName(img, &quot;__libdft_getval_taint&quot;);    if (RTN_Valid(test_getval_rtn)) &#123;      RTN_Open(test_getval_rtn);      RTN_InsertCall(test_getval_rtn, IPOINT_BEFORE, (AFUNPTR)TestGetValHandler,                     IARG_THREAD_ID, IARG_FUNCARG_ENTRYPOINT_VALUE, 0,                     IARG_END);      RTN_Close(test_getval_rtn);    &#125;  &#125;&#125;int main(int argc, char *argv[]) &#123;  PIN_InitSymbols();  if (unlikely(PIN_Init(argc, argv))) &#123;    std::cerr        &lt;&lt; &quot;Sth error in PIN_Init. Plz use the right command line options.&quot;        &lt;&lt; std::endl;    return -1;  &#125;  if (unlikely(libdft_init() != 0)) &#123;    std::cerr &lt;&lt; &quot;Sth error libdft_init.&quot; &lt;&lt; std::endl;    return -1;  &#125;  PIN_AddApplicationStartFunction(EntryPoint, 0);  hook_file_syscall();  PIN_StartProgram();  return 0;&#125;\n\n根据 Intel Pin 的 API 手册，RTN_InsertCall 原型为：\n123456789101112VOID RTN_InsertCall (    RTN \trtn,    IPOINT \taction,    AFUNPTR \tfunptr,    ... )Parameters    rtn: 需要插桩的目标函数    action: IPOINT_BEFORE 表示在目前函数执行之前插入, IPOINT_AFTER 表示在目标函数执行之后返回之前插入    funptr: 需要调用的 handler 函数    ...: 传递给 funptr 的可变参数\n\n根据官方示例，不难发现，使用 libdft64 的主要步骤为：定位目标函数 -&gt; 对目标函数进行插桩 -&gt; 在插桩的 handler 函数中实现分析需求。","dateCreated":"2024-05-17T14:35:03+08:00","dateModified":"2024-11-05T13:26:29+08:00","datePublished":"2024-05-17T14:35:03+08:00","description":"libdft64 是一种数据流追踪工具，可以实现高效并且透明的动态污点分析（DTA），通常用来检测二进制中的安全漏洞","headline":"污点分析工具——libdft64","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/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/"},"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/%E6%B1%A1%E7%82%B9%E5%88%86%E6%9E%90%E5%B7%A5%E5%85%B7%E2%80%94%E2%80%94libdft64/","keywords":"安全, 工具, IntelPin, 污点分析"}</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\nlibdft64 简介libdft64 一款基于 Intel Pin 开发的动态污点分析工具。\n1. 污点分析  污点分析（Taint Analysis）是一种跟踪并分析污点信息（通常指程序接受的外部输入）在程序中流动的技术。污点分析过程通常包括三个步骤：\n\n识别并标记污点源（Source）\n跟踪污点在程序中的传播（propagation）\n在关键的程序点（Sink）检测是否受到污点的影响\n\n动态污点分析（Dynamic Taint Analysis, DTA）是一种用于确定在程序运行时，运行环境中哪些寄存器和内存区域，可以由外部输入来进行控制的技术。\n动态污点分析与静态污点分析的主要区别在于，静态污点分析是模拟程序运行，而动态污点分析需要实际运行程序。动态污点分析的优缺点为：\n\n优点：误报率较低，检测结果的可信度较高。\n缺点：\n漏报率较高：由程序动态运行时的代码覆盖率决定\n平台相关性较高：特定的动态污点分析工具只能够解决在特定平台上运行的程序\n资源消耗大：包括空间复杂度和时间复杂度\n\n\n\n2. Intel PinIntel Pin 是一个动态二进制插桩（Dynamic Binary Instrumentation, DBI）框架，由英特尔公司开发。它允许用户在程序运行时（即不需要源代码）对程序的二进制代码进行插桩和分析。\nIntel Pin 提供了丰富的 API 库，供开发者编写和构建自己的 Pintool，用来完成特定的分析任务。\nlibdft64 安装和使用1. 安装和构建libdft64 是一款开源工具，它依赖于 Intel Pin。使用时需要下载源码，安装依赖，执行构建：\n12345git clone https://github.com/AngoraFuzzer/libdft64.gitcd libdft64PREFIX=~/pin ./install_pin.shexport PIN_ROOT=~/pin/pin-3.20-98437-gf02b61307-gcc-linuxmake\n\n2. 示例解析(1) 使用演示libdft64 给出的示例用法如下：\n12cd toolsmake test_mini\n执行结果为：\n\n\n(2) 源码解读 libdft64 测试对象的源码为mini_test.cpp。在main 函数中，调用一些自定义的函数(__libdft_set_taint, __libdft_get_taint, __libdft_getval_taint)，来进行污点数据的设置和获取操作。\n1234567891011121314151617181920212223242526272829303132333435363738394041int main(int argc, char **argv) &#123;  if (argc &lt; 2)    return 0;  FILE *fp;  char buf[255];  size_t ret;  fp = fopen(argv[1], &quot;rb&quot;);  if (!fp) &#123;    printf(&quot;st err\\n&quot;);    return 0;  &#125;  int len = 20;  // dfsan_read_label(&amp;(len), sizeof *buf);  ret = fread(buf, sizeof *buf, len, fp);  fclose(fp);  // printf(&quot;len is :%d\\n&quot;, len);  if (ret &lt; len) &#123;    // printf(&quot;input fail \\n&quot;);    return 0;  &#125;  uint64_t m = 0;  __libdft_set_taint(&amp;m, 8);  __libdft_get_taint(&amp;m);  __libdft_getval_taint(m);  uint16_t x = 0;  __libdft_get_taint(&amp;x);  memcpy(&amp;x, buf + 5, 2); // x 1 - 2  __libdft_get_taint(&amp;x);  __libdft_getval_taint(x);  uint64_t y = x + 2;  __libdft_getval_taint(y);  return 0;&#125;\n\n使用 libdft64 进行污点追踪的代码为 track.cpp。通过 Intel Pin 的 API 函数RTN_FindByName 来定位 mini_test.cpp 中的函数 (__libdft_set_taint, __libdft_get_taint, __libdft_getval_taint)，并通过 Intel Pin 的 API 函数RTN_InsertCall 来对这些定位到的函数进行插桩。当运行到目标函数时，会调用相应的 handler 函数 (TestSetHandler, TestGetHandler, TestGetValHandler) 执行额外操作。\n123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475VOID TestGetHandler(void *p) &#123;  uint64_t v = *((uint64_t *)p);  tag_t t = tagmap_getn((ADDRINT)p, 8);  printf(&quot;[PIN][GET] addr: %p, v: %lu, lb: %d, taint: %s\\n&quot;, p, v, t,         tag_sprint(t).c_str());&#125;VOID TestGetValHandler(THREADID tid, uint64_t v) &#123;  tag_t t = tagmap_getn_reg(tid, X64_ARG0_REG, 8);  printf(&quot;[PIN][GETVAL] v: %lu, lb: %d, taint: %s\\n&quot;, v, t,         tag_sprint(t).c_str());&#125;VOID TestSetHandler(void *p, unsigned int v) &#123;  tag_t t = tag_alloc&lt;tag_t&gt;(v);  tagmap_setb((ADDRINT)p, t);  printf(&quot;[PIN][SET] addr: %p, lb: %d, taint: %d\\n&quot;, p, t, v);&#125;VOID EntryPoint(VOID *v) &#123;  for (IMG img = APP_ImgHead(); IMG_Valid(img); img = IMG_Next(img)) &#123;    RTN test_get_rtn = RTN_FindByName(img, &quot;__libdft_get_taint&quot;);    if (RTN_Valid(test_get_rtn)) &#123;      RTN_Open(test_get_rtn);      RTN_InsertCall(test_get_rtn, IPOINT_BEFORE, (AFUNPTR)TestGetHandler,                     IARG_FUNCARG_ENTRYPOINT_VALUE, 0, IARG_END);      RTN_Close(test_get_rtn);    &#125;    RTN test_set_rtn = RTN_FindByName(img, &quot;__libdft_set_taint&quot;);    if (RTN_Valid(test_set_rtn)) &#123;      RTN_Open(test_set_rtn);      RTN_InsertCall(test_set_rtn, IPOINT_BEFORE, (AFUNPTR)TestSetHandler,                     IARG_FUNCARG_ENTRYPOINT_VALUE, 0,                     IARG_FUNCARG_ENTRYPOINT_VALUE, 1, IARG_END);      RTN_Close(test_set_rtn);    &#125;    RTN test_getval_rtn = RTN_FindByName(img, &quot;__libdft_getval_taint&quot;);    if (RTN_Valid(test_getval_rtn)) &#123;      RTN_Open(test_getval_rtn);      RTN_InsertCall(test_getval_rtn, IPOINT_BEFORE, (AFUNPTR)TestGetValHandler,                     IARG_THREAD_ID, IARG_FUNCARG_ENTRYPOINT_VALUE, 0,                     IARG_END);      RTN_Close(test_getval_rtn);    &#125;  &#125;&#125;int main(int argc, char *argv[]) &#123;  PIN_InitSymbols();  if (unlikely(PIN_Init(argc, argv))) &#123;    std::cerr        &lt;&lt; &quot;Sth error in PIN_Init. Plz use the right command line options.&quot;        &lt;&lt; std::endl;    return -1;  &#125;  if (unlikely(libdft_init() != 0)) &#123;    std::cerr &lt;&lt; &quot;Sth error libdft_init.&quot; &lt;&lt; std::endl;    return -1;  &#125;  PIN_AddApplicationStartFunction(EntryPoint, 0);  hook_file_syscall();  PIN_StartProgram();  return 0;&#125;\n\n根据 Intel Pin 的 API 手册，RTN_InsertCall 原型为：\n123456789101112VOID RTN_InsertCall (    RTN \trtn,    IPOINT \taction,    AFUNPTR \tfunptr,    ... )Parameters    rtn: 需要插桩的目标函数    action: IPOINT_BEFORE 表示在目前函数执行之前插入, IPOINT_AFTER 表示在目标函数执行之后返回之前插入    funptr: 需要调用的 handler 函数    ...: 传递给 funptr 的可变参数\n\n根据官方示例，不难发现，使用 libdft64 的主要步骤为：定位目标函数 -&gt; 对目标函数进行插桩 -&gt; 在插桩的 handler 函数中实现分析需求。","dateCreated":"2024-05-17T14:35:03+08:00","dateModified":"2024-11-05T13:36:12+08:00","datePublished":"2024-05-17T14:35:03+08:00","description":"libdft64 是一种数据流追踪工具，可以实现高效并且透明的动态污点分析（DTA），通常用来检测二进制中的安全漏洞","headline":"污点分析工具——libdft64","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.stepbystep.asia/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/"},"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/%E6%B1%A1%E7%82%B9%E5%88%86%E6%9E%90%E5%B7%A5%E5%85%B7%E2%80%94%E2%80%94libdft64/","keywords":"安全, IntelPin, 污点分析"}</script>
     <meta name="description" content="libdft64 是一种数据流追踪工具，可以实现高效并且透明的动态污点分析（DTA），通常用来检测二进制中的安全漏洞">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="污点分析工具——libdft64">
@@ -24,10 +24,9 @@
 <meta property="og:locale" content="zh_CN">
 <meta property="og:image" content="https://www.stepbystep.asia/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/test_mini%E8%BF%90%E8%A1%8C%E7%BB%93%E6%9E%9C.png">
 <meta property="article:published_time" content="2024-05-17T06:35:03.000Z">
-<meta property="article:modified_time" content="2024-11-05T05:26:29.565Z">
+<meta property="article:modified_time" content="2024-11-05T05:36:12.047Z">
 <meta property="article:author" content="一瓢清浅">
 <meta property="article:tag" content="安全">
-<meta property="article:tag" content="工具">
 <meta property="article:tag" content="IntelPin">
 <meta property="article:tag" content="污点分析">
 <meta name="twitter:card" content="summary">
@@ -302,7 +301,7 @@ <h4 id="2- 源码解读"><a href="#2- 源码解读" class="headerlink" title="(2
             <div class="post-footer-tags">
                 <span class="text-color-light text-small">标签</span><br>
                 
-    <a class="tag tag--primary tag--small t-none-link" href="/tags/IntelPin/" rel="tag">IntelPin</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E5%AE%89%E5%85%A8/" rel="tag">安全</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E5%B7%A5%E5%85%B7/" rel="tag">工具</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E6%B1%A1%E7%82%B9%E5%88%86%E6%9E%90/" rel="tag">污点分析</a>
+    <a class="tag tag--primary tag--small t-none-link" href="/tags/IntelPin/" rel="tag">IntelPin</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E5%AE%89%E5%85%A8/" rel="tag">安全</a> <a class="tag tag--primary tag--small t-none-link" href="/tags/%E6%B1%A1%E7%82%B9%E5%88%86%E6%9E%90/" rel="tag">污点分析</a>
 
             </div>
         
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 f0a3936..3008b67 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,10 +27,10 @@
 <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="安全">
 <meta property="article:tag" content="AFL++">
-<meta property="article:tag" content="开发">
+<meta property="article:tag" content="安全">
 <meta property="article:tag" content="Python">
+<meta property="article:tag" content="开发">
 <meta name="twitter:card" content="summary">
 <meta name="twitter:image" content="https://www.stepbystep.asia/2024/%E7%94%B1subprocess-PIPE%E5%BC%95%E5%8F%91%E7%9A%84%E8%A1%80%E6%A1%88/gdb%E8%B0%83%E8%AF%95afl.png">
     
@@ -327,7 +327,7 @@ <h2 id="三、罪魁祸首"><a href="# 三、罪魁祸首" class="headerlink" ti
             <li class="post-action">
                 
                     
-                <a class="post-action-btn btn btn--default tooltip--top" 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/" data-tooltip="AFLplusplus 源码分析——同步机制" aria-label="下一篇: AFLplusplus 源码分析——同步机制">
+                <a class="post-action-btn btn btn--default tooltip--top" 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/" data-tooltip="AFL++ 源码分析——同步机制" aria-label="下一篇: AFL++ 源码分析——同步机制">
                     
                         <span class="hide-xs hide-sm text-small icon-mr">下一篇</span>
                         <i class="fa fa-angle-right" aria-hidden="true"></i>
@@ -390,7 +390,7 @@ <h2 id="三、罪魁祸首"><a href="# 三、罪魁祸首" class="headerlink" ti
             <li class="post-action">
                 
                     
-                <a class="post-action-btn btn btn--default tooltip--top" 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/" data-tooltip="AFLplusplus 源码分析——同步机制" aria-label="下一篇: AFLplusplus 源码分析——同步机制">
+                <a class="post-action-btn btn btn--default tooltip--top" 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/" data-tooltip="AFL++ 源码分析——同步机制" aria-label="下一篇: AFL++ 源码分析——同步机制">
                     
                         <span class="hide-xs hide-sm text-small icon-mr">下一篇</span>
                         <i class="fa fa-angle-right" aria-hidden="true"></i>
diff --git a/all-archives/index.html b/all-archives/index.html
index c7e6e3a..0843c33 100644
--- a/all-archives/index.html
+++ b/all-archives/index.html
@@ -356,7 +356,7 @@ <h5 class="archive-title">
             
             
             <li class="archive-post archive-day" data-date="20240716">
-                <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>
+                <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/">AFL++ 源码分析——同步机制</a>
                 <span class="archive-post-date"> - 2024 年 7 月 16 日</span>
             </li>
         
diff --git a/all-categories/index.html b/all-categories/index.html
index b045da6..1a1f986 100644
--- a/all-categories/index.html
+++ b/all-categories/index.html
@@ -275,7 +275,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/">安全 (12)</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%BA%8C%EF%BC%89/">ClusterFuzz 源码分析（二）</a><span class="archive-post-date"> - 2024 年 10 月 10 日</span></li><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 年 9 月 30 日</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/">模糊测试 (8)</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%BA%8C%EF%BC%89/">ClusterFuzz 源码分析（二）</a><span class="archive-post-date"> - 2024 年 10 月 10 日</span></li><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 年 9 月 30 日</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/">安全 (12)</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%BA%8C%EF%BC%89/">ClusterFuzz 源码分析（二）</a><span class="archive-post-date"> - 2024 年 10 月 10 日</span></li><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 年 9 月 30 日</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/">AFL++ 源码分析——同步机制</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/">模糊测试 (8)</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%BA%8C%EF%BC%89/">ClusterFuzz 源码分析（二）</a><span class="archive-post-date"> - 2024 年 10 月 10 日</span></li><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 年 9 月 30 日</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/">AFL++ 源码分析——同步机制</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 9487eb5..76f3704 100644
--- a/all-tags/index.html
+++ b/all-tags/index.html
@@ -338,11 +338,20 @@ <h4 class="archive-result text-color-base text-xlarge" data-message-zero="没有
             <div id="AFL-list" class="archive box" data-tag="afl">
                 <h4 class="archive-title">
                     <a class="link-unstyled" href="/tags/AFL">
-                        AFL (1)
+                        AFL (2)
                     </a>
                 </h4>
                 <ul class="archive-posts">
                     
+                        <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 原理与实践
@@ -358,7 +367,7 @@ <h4 class="archive-title">
             <div id="AFL++-list" class="archive box" data-tag="afl++">
                 <h4 class="archive-title">
                     <a class="link-unstyled" href="/tags/AFL">
-                        AFL++ (4)
+                        AFL++ (3)
                     </a>
                 </h4>
                 <ul class="archive-posts">
@@ -383,22 +392,13 @@ <h4 class="archive-title">
                     
                         <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 源码分析——同步机制
+                                AFL++ 源码分析——同步机制
                             </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>
-                    
                 </ul>
             </div>
         
@@ -535,7 +535,7 @@ <h4 class="archive-title">
                     
                         <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 源码分析——同步机制
+                                AFL++ 源码分析——同步机制
                             </a>
                             <span class="archive-post-date">
                                  - 2024 年 7 月 16 日
@@ -850,7 +850,7 @@ <h4 class="archive-title">
                     
                         <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 源码分析——同步机制
+                                AFL++ 源码分析——同步机制
                             </a>
                             <span class="archive-post-date">
                                  - 2024 年 7 月 16 日
@@ -935,56 +935,11 @@ <h4 class="archive-title">
             <div id="工具-list" class="archive box" data-tag="工具">
                 <h4 class="archive-title">
                     <a class="link-unstyled" href="/tags/%E5%B7%A5%E5%85%B7">
-                        工具 (9)
+                        工具 (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>
-                    
-                        <li class="archive-post">
-                            <a class="archive-post-title" href="/2024/Hexo%E6%8D%A3%E9%BC%93%E6%9C%AD%E8%AE%B0/">
-                                Hexo 捣鼓札记
-                            </a>
-                            <span class="archive-post-date">
-                                 - 2024 年 4 月 3 日
-                            </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/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 原理与实践
@@ -994,33 +949,6 @@ <h4 class="archive-title">
                             </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>
-                    
-                        <li class="archive-post">
-                            <a class="archive-post-title" href="/2023/Docker%E5%BF%85%E7%9F%A5%E5%BF%85%E4%BC%9A/">
-                                Docker 必知必会
-                            </a>
-                            <span class="archive-post-date">
-                                 - 2023 年 7 月 8 日
-                            </span>
-                        </li>
-                    
                 </ul>
             </div>
         
@@ -1224,7 +1152,7 @@ <h4 class="archive-title">
                     
                         <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 源码分析——同步机制
+                                AFL++ 源码分析——同步机制
                             </a>
                             <span class="archive-post-date">
                                  - 2024 年 7 月 16 日
diff --git a/archives/2024/07/index.html b/archives/2024/07/index.html
index edfecac..61fd512 100644
--- a/archives/2024/07/index.html
+++ b/archives/2024/07/index.html
@@ -263,8 +263,8 @@ <h1 class="postShorten-title">
             <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 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=": AFL++ 源码分析——同步机制">
+                            AFL++ 源码分析——同步机制
                         </a>
                     
                 </h1>
@@ -288,7 +288,7 @@ <h1 class="postShorten-title">
                 <div class="postShorten-excerpt">
                     <p>分析 AFL++ 同步机制的相关源码</p>
                     
-                        <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 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=": AFL++ 源码分析——同步机制">
                             阅读全文
                         </a>
                         
diff --git a/archives/2024/index.html b/archives/2024/index.html
index 82e0137..bbdfd59 100644
--- a/archives/2024/index.html
+++ b/archives/2024/index.html
@@ -607,8 +607,8 @@ <h1 class="postShorten-title">
             <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 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=": AFL++ 源码分析——同步机制">
+                            AFL++ 源码分析——同步机制
                         </a>
                     
                 </h1>
@@ -632,7 +632,7 @@ <h1 class="postShorten-title">
                 <div class="postShorten-excerpt">
                     <p>分析 AFL++ 同步机制的相关源码</p>
                     
-                        <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 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=": AFL++ 源码分析——同步机制">
                             阅读全文
                         </a>
                         
diff --git a/archives/index.html b/archives/index.html
index 3cf4a1b..d1e2f5d 100644
--- a/archives/index.html
+++ b/archives/index.html
@@ -607,8 +607,8 @@ <h1 class="postShorten-title">
             <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 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=": AFL++ 源码分析——同步机制">
+                            AFL++ 源码分析——同步机制
                         </a>
                     
                 </h1>
@@ -632,7 +632,7 @@ <h1 class="postShorten-title">
                 <div class="postShorten-excerpt">
                     <p>分析 AFL++ 同步机制的相关源码</p>
                     
-                        <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 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=": AFL++ 源码分析——同步机制">
                             阅读全文
                         </a>
                         
diff --git a/baidusitemap.xml b/baidusitemap.xml
index ea981c0..fb58b61 100644
--- a/baidusitemap.xml
+++ b/baidusitemap.xml
@@ -1,11 +1,15 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
   <url>
-    <loc>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/</loc>
+    <loc>https://www.stepbystep.asia/2023/LibAFL%E7%AE%80%E4%BB%8B/</loc>
     <lastmod>2024-11-05</lastmod>
   </url>
   <url>
-    <loc>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/</loc>
+    <loc>https://www.stepbystep.asia/2024/Symbion%E5%88%9D%E6%8E%A2/</loc>
+    <lastmod>2024-11-05</lastmod>
+  </url>
+  <url>
+    <loc>https://www.stepbystep.asia/2024/Hexo%E6%8D%A3%E9%BC%93%E6%9C%AD%E8%AE%B0/</loc>
     <lastmod>2024-11-05</lastmod>
   </url>
   <url>
@@ -13,35 +17,39 @@
     <lastmod>2024-11-05</lastmod>
   </url>
   <url>
-    <loc>https://www.stepbystep.asia/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%BA%8C%EF%BC%89/</loc>
+    <loc>https://www.stepbystep.asia/2023/LibFuzzer%E7%BC%96%E8%AF%91%E6%8C%87%E5%8D%97/</loc>
     <lastmod>2024-11-05</lastmod>
   </url>
   <url>
-    <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>
+    <loc>https://www.stepbystep.asia/2023/Docker%E5%BF%85%E7%9F%A5%E5%BF%85%E4%BC%9A/</loc>
     <lastmod>2024-11-05</lastmod>
   </url>
   <url>
-    <loc>https://www.stepbystep.asia/2023/CPP%E4%B8%8EPython%E7%9A%84OOP%E6%AF%94%E8%BE%83/</loc>
+    <loc>https://www.stepbystep.asia/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/</loc>
     <lastmod>2024-11-05</lastmod>
   </url>
   <url>
-    <loc>https://www.stepbystep.asia/2024/Hexo%E6%8D%A3%E9%BC%93%E6%9C%AD%E8%AE%B0/</loc>
+    <loc>https://www.stepbystep.asia/2023/LibFuzzer%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E/</loc>
     <lastmod>2024-11-05</lastmod>
   </url>
   <url>
-    <loc>https://www.stepbystep.asia/2023/LibAFL%E7%AE%80%E4%BB%8B/</loc>
+    <loc>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/</loc>
     <lastmod>2024-11-05</lastmod>
   </url>
   <url>
-    <loc>https://www.stepbystep.asia/2024/Symbion%E5%88%9D%E6%8E%A2/</loc>
+    <loc>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/</loc>
     <lastmod>2024-11-05</lastmod>
   </url>
   <url>
-    <loc>https://www.stepbystep.asia/2023/Docker%E5%BF%85%E7%9F%A5%E5%BF%85%E4%BC%9A/</loc>
+    <loc>https://www.stepbystep.asia/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%BA%8C%EF%BC%89/</loc>
     <lastmod>2024-11-05</lastmod>
   </url>
   <url>
-    <loc>https://www.stepbystep.asia/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/</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-11-05</lastmod>
+  </url>
+  <url>
+    <loc>https://www.stepbystep.asia/2023/CPP%E4%B8%8EPython%E7%9A%84OOP%E6%AF%94%E8%BE%83/</loc>
     <lastmod>2024-11-05</lastmod>
   </url>
   <url>
@@ -84,14 +92,6 @@
     <loc>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/</loc>
     <lastmod>2024-06-27</lastmod>
   </url>
-  <url>
-    <loc>https://www.stepbystep.asia/2023/LibFuzzer%E7%BC%96%E8%AF%91%E6%8C%87%E5%8D%97/</loc>
-    <lastmod>2024-06-26</lastmod>
-  </url>
-  <url>
-    <loc>https://www.stepbystep.asia/2023/LibFuzzer%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E/</loc>
-    <lastmod>2024-06-26</lastmod>
-  </url>
   <url>
     <loc>https://www.stepbystep.asia/2023/AFL%E5%8E%9F%E7%90%86%E4%B8%8E%E5%AE%9E%E8%B7%B5/</loc>
     <lastmod>2024-05-30</lastmod>
diff --git "a/categories/\345\256\211\345\205\250/index.html" "b/categories/\345\256\211\345\205\250/index.html"
index ef83dd4..1b89349 100644
--- "a/categories/\345\256\211\345\205\250/index.html"
+++ "b/categories/\345\256\211\345\205\250/index.html"
@@ -349,8 +349,8 @@ <h1 class="postShorten-title">
             <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 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=": AFL++ 源码分析——同步机制">
+                            AFL++ 源码分析——同步机制
                         </a>
                     
                 </h1>
@@ -374,7 +374,7 @@ <h1 class="postShorten-title">
                 <div class="postShorten-excerpt">
                     <p>分析 AFL++ 同步机制的相关源码</p>
                     
-                        <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 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=": AFL++ 源码分析——同步机制">
                             阅读全文
                         </a>
                         
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 ae40d83..336383a 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"
@@ -349,8 +349,8 @@ <h1 class="postShorten-title">
             <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 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=": AFL++ 源码分析——同步机制">
+                            AFL++ 源码分析——同步机制
                         </a>
                     
                 </h1>
@@ -374,7 +374,7 @@ <h1 class="postShorten-title">
                 <div class="postShorten-excerpt">
                     <p>分析 AFL++ 同步机制的相关源码</p>
                     
-                        <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 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=": AFL++ 源码分析——同步机制">
                             阅读全文
                         </a>
                         
diff --git a/index.html b/index.html
index 5270bb8..4cf1340 100644
--- a/index.html
+++ b/index.html
@@ -606,8 +606,8 @@ <h1 class="postShorten-title">
             <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 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=": AFL++ 源码分析——同步机制">
+                            AFL++ 源码分析——同步机制
                         </a>
                     
                 </h1>
@@ -631,7 +631,7 @@ <h1 class="postShorten-title">
                 <div class="postShorten-excerpt">
                     <p>分析 AFL++ 同步机制的相关源码</p>
                     
-                        <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 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=": AFL++ 源码分析——同步机制">
                             阅读全文
                         </a>
                         
diff --git a/sitemap.xml b/sitemap.xml
index 7624fc2..2bc42ca 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/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/</loc>
+    <loc>https://www.stepbystep.asia/2023/LibAFL%E7%AE%80%E4%BB%8B/</loc>
     
     <lastmod>2024-11-05</lastmod>
     
@@ -11,7 +11,7 @@
   </url>
   
   <url>
-    <loc>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/</loc>
+    <loc>https://www.stepbystep.asia/2024/Symbion%E5%88%9D%E6%8E%A2/</loc>
     
     <lastmod>2024-11-05</lastmod>
     
@@ -20,7 +20,7 @@
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/2024/Angr%E9%9B%B6%E5%9F%BA%E7%A1%80%E5%85%A5%E9%97%A8/</loc>
+    <loc>https://www.stepbystep.asia/2024/Hexo%E6%8D%A3%E9%BC%93%E6%9C%AD%E8%AE%B0/</loc>
     
     <lastmod>2024-11-05</lastmod>
     
@@ -29,7 +29,7 @@
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%BA%8C%EF%BC%89/</loc>
+    <loc>https://www.stepbystep.asia/2024/Angr%E9%9B%B6%E5%9F%BA%E7%A1%80%E5%85%A5%E9%97%A8/</loc>
     
     <lastmod>2024-11-05</lastmod>
     
@@ -38,7 +38,7 @@
   </url>
   
   <url>
-    <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>
+    <loc>https://www.stepbystep.asia/2023/LibFuzzer%E7%BC%96%E8%AF%91%E6%8C%87%E5%8D%97/</loc>
     
     <lastmod>2024-11-05</lastmod>
     
@@ -47,7 +47,7 @@
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/2023/CPP%E4%B8%8EPython%E7%9A%84OOP%E6%AF%94%E8%BE%83/</loc>
+    <loc>https://www.stepbystep.asia/2023/Docker%E5%BF%85%E7%9F%A5%E5%BF%85%E4%BC%9A/</loc>
     
     <lastmod>2024-11-05</lastmod>
     
@@ -56,7 +56,7 @@
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/2024/Hexo%E6%8D%A3%E9%BC%93%E6%9C%AD%E8%AE%B0/</loc>
+    <loc>https://www.stepbystep.asia/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/</loc>
     
     <lastmod>2024-11-05</lastmod>
     
@@ -65,7 +65,7 @@
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/2023/LibAFL%E7%AE%80%E4%BB%8B/</loc>
+    <loc>https://www.stepbystep.asia/2023/LibFuzzer%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E/</loc>
     
     <lastmod>2024-11-05</lastmod>
     
@@ -74,7 +74,7 @@
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/2024/Symbion%E5%88%9D%E6%8E%A2/</loc>
+    <loc>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/</loc>
     
     <lastmod>2024-11-05</lastmod>
     
@@ -83,7 +83,7 @@
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/2023/Docker%E5%BF%85%E7%9F%A5%E5%BF%85%E4%BC%9A/</loc>
+    <loc>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/</loc>
     
     <lastmod>2024-11-05</lastmod>
     
@@ -92,7 +92,7 @@
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/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/</loc>
+    <loc>https://www.stepbystep.asia/2024/ClusterFuzz%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%EF%BC%88%E4%BA%8C%EF%BC%89/</loc>
     
     <lastmod>2024-11-05</lastmod>
     
@@ -101,7 +101,7 @@
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/2023/Linux%E4%BB%8E%E5%85%A5%E9%97%A8%E5%88%B0%E7%86%9F%E7%BB%83/</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-11-05</lastmod>
     
@@ -110,7 +110,7 @@
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/2023/%E9%9B%B6%E5%9F%BA%E7%A1%80%E7%88%AC%E8%99%AB%E5%85%A5%E9%97%A8/</loc>
+    <loc>https://www.stepbystep.asia/2023/CPP%E4%B8%8EPython%E7%9A%84OOP%E6%AF%94%E8%BE%83/</loc>
     
     <lastmod>2024-11-05</lastmod>
     
@@ -119,7 +119,7 @@
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/2024/%E8%BD%AF%E8%80%83%E6%9E%B6%E6%9E%84%E2%80%94%E2%80%94%E7%B3%BB%E7%BB%9F%E5%88%86%E6%9E%90%E4%B8%8E%E8%AE%BE%E8%AE%A1%EF%BC%9A%E7%BB%93%E6%9E%84%E5%8C%96%E4%B8%8E%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/</loc>
+    <loc>https://www.stepbystep.asia/2023/Linux%E4%BB%8E%E5%85%A5%E9%97%A8%E5%88%B0%E7%86%9F%E7%BB%83/</loc>
     
     <lastmod>2024-11-05</lastmod>
     
@@ -128,7 +128,7 @@
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/2024/%E8%BD%AF%E8%80%83%E6%9E%B6%E6%9E%84%E2%80%94%E2%80%94NoSQL%E6%95%B0%E6%8D%AE%E5%BA%93/</loc>
+    <loc>https://www.stepbystep.asia/2023/%E9%9B%B6%E5%9F%BA%E7%A1%80%E7%88%AC%E8%99%AB%E5%85%A5%E9%97%A8/</loc>
     
     <lastmod>2024-11-05</lastmod>
     
@@ -137,7 +137,7 @@
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/2024/%E8%BD%AF%E8%80%83%E6%9E%B6%E6%9E%84%E2%80%94%E2%80%94%E6%95%B0%E6%8D%AE%E5%BA%93%E7%9A%84%E6%8E%A7%E5%88%B6%E5%8A%9F%E8%83%BD/</loc>
+    <loc>https://www.stepbystep.asia/2024/%E8%BD%AF%E8%80%83%E6%9E%B6%E6%9E%84%E2%80%94%E2%80%94%E7%B3%BB%E7%BB%9F%E5%88%86%E6%9E%90%E4%B8%8E%E8%AE%BE%E8%AE%A1%EF%BC%9A%E7%BB%93%E6%9E%84%E5%8C%96%E4%B8%8E%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/</loc>
     
     <lastmod>2024-11-05</lastmod>
     
@@ -146,7 +146,7 @@
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/2024/%E8%BD%AF%E8%80%83%E6%9E%B6%E6%9E%84%E2%80%94%E2%80%94%E6%95%B0%E6%8D%AE%E5%BA%93%E8%AE%BE%E8%AE%A1%E4%B8%8E%E5%BB%BA%E6%A8%A1/</loc>
+    <loc>https://www.stepbystep.asia/2024/%E8%BD%AF%E8%80%83%E6%9E%B6%E6%9E%84%E2%80%94%E2%80%94NoSQL%E6%95%B0%E6%8D%AE%E5%BA%93/</loc>
     
     <lastmod>2024-11-05</lastmod>
     
@@ -155,7 +155,7 @@
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/2024/%E8%BD%AF%E8%80%83%E6%9E%B6%E6%9E%84%E2%80%94%E2%80%94%E9%9D%A2%E5%90%91%E6%9C%8D%E5%8A%A1%E6%9E%B6%E6%9E%84%E4%B8%8E%E5%BE%AE%E6%9C%8D%E5%8A%A1%E6%9E%B6%E6%9E%84/</loc>
+    <loc>https://www.stepbystep.asia/2024/%E8%BD%AF%E8%80%83%E6%9E%B6%E6%9E%84%E2%80%94%E2%80%94%E6%95%B0%E6%8D%AE%E5%BA%93%E7%9A%84%E6%8E%A7%E5%88%B6%E5%8A%9F%E8%83%BD/</loc>
     
     <lastmod>2024-11-05</lastmod>
     
@@ -164,45 +164,45 @@
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/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/</loc>
+    <loc>https://www.stepbystep.asia/2024/%E8%BD%AF%E8%80%83%E6%9E%B6%E6%9E%84%E2%80%94%E2%80%94%E6%95%B0%E6%8D%AE%E5%BA%93%E8%AE%BE%E8%AE%A1%E4%B8%8E%E5%BB%BA%E6%A8%A1/</loc>
     
-    <lastmod>2024-08-21</lastmod>
+    <lastmod>2024-11-05</lastmod>
     
     <changefreq>monthly</changefreq>
     <priority>0.6</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/2024/%E7%94%B1subprocess-PIPE%E5%BC%95%E5%8F%91%E7%9A%84%E8%A1%80%E6%A1%88/</loc>
+    <loc>https://www.stepbystep.asia/2024/%E8%BD%AF%E8%80%83%E6%9E%B6%E6%9E%84%E2%80%94%E2%80%94%E9%9D%A2%E5%90%91%E6%9C%8D%E5%8A%A1%E6%9E%B6%E6%9E%84%E4%B8%8E%E5%BE%AE%E6%9C%8D%E5%8A%A1%E6%9E%B6%E6%9E%84/</loc>
     
-    <lastmod>2024-08-16</lastmod>
+    <lastmod>2024-11-05</lastmod>
     
     <changefreq>monthly</changefreq>
     <priority>0.6</priority>
   </url>
   
   <url>
-    <loc>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/</loc>
+    <loc>https://www.stepbystep.asia/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/</loc>
     
-    <lastmod>2024-06-27</lastmod>
+    <lastmod>2024-08-21</lastmod>
     
     <changefreq>monthly</changefreq>
     <priority>0.6</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/2023/LibFuzzer%E7%BC%96%E8%AF%91%E6%8C%87%E5%8D%97/</loc>
+    <loc>https://www.stepbystep.asia/2024/%E7%94%B1subprocess-PIPE%E5%BC%95%E5%8F%91%E7%9A%84%E8%A1%80%E6%A1%88/</loc>
     
-    <lastmod>2024-06-26</lastmod>
+    <lastmod>2024-08-16</lastmod>
     
     <changefreq>monthly</changefreq>
     <priority>0.6</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/2023/LibFuzzer%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E/</loc>
+    <loc>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/</loc>
     
-    <lastmod>2024-06-26</lastmod>
+    <lastmod>2024-06-27</lastmod>
     
     <changefreq>monthly</changefreq>
     <priority>0.6</priority>
@@ -290,14 +290,14 @@
 
   
   <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/AFL/</loc>
     <lastmod>2024-11-05</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/Angr/</loc>
+    <loc>https://www.stepbystep.asia/tags/Fuzz/</loc>
     <lastmod>2024-11-05</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
@@ -311,7 +311,7 @@
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/%E5%B7%A5%E5%85%B7/</loc>
+    <loc>https://www.stepbystep.asia/tags/%E6%BA%90%E7%A0%81/</loc>
     <lastmod>2024-11-05</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
@@ -325,49 +325,49 @@
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/Fuzz/</loc>
+    <loc>https://www.stepbystep.asia/tags/%E5%B7%A5%E5%85%B7/</loc>
     <lastmod>2024-11-05</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/%E6%BA%90%E7%A0%81/</loc>
+    <loc>https://www.stepbystep.asia/tags/%E7%AC%A6%E5%8F%B7%E6%89%A7%E8%A1%8C/</loc>
     <lastmod>2024-11-05</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/C/</loc>
+    <loc>https://www.stepbystep.asia/tags/Angr/</loc>
     <lastmod>2024-11-05</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/%E7%BC%96%E7%A8%8B/</loc>
+    <loc>https://www.stepbystep.asia/tags/C/</loc>
     <lastmod>2024-11-05</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/%E5%BC%80%E5%8F%91/</loc>
+    <loc>https://www.stepbystep.asia/tags/Python/</loc>
     <lastmod>2024-11-05</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/Python/</loc>
+    <loc>https://www.stepbystep.asia/tags/%E7%BC%96%E7%A8%8B/</loc>
     <lastmod>2024-11-05</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/AFL/</loc>
+    <loc>https://www.stepbystep.asia/tags/%E5%BC%80%E5%8F%91/</loc>
     <lastmod>2024-11-05</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
@@ -388,21 +388,21 @@
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/Linux/</loc>
+    <loc>https://www.stepbystep.asia/tags/Docker/</loc>
     <lastmod>2024-11-05</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-11-05</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/Docker/</loc>
+    <loc>https://www.stepbystep.asia/tags/LibFuzzer/</loc>
     <lastmod>2024-11-05</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
@@ -423,7 +423,7 @@
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/LibFuzzer/</loc>
+    <loc>https://www.stepbystep.asia/tags/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/</loc>
     <lastmod>2024-11-05</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
@@ -465,21 +465,21 @@
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/SOA/</loc>
+    <loc>https://www.stepbystep.asia/tags/%E7%88%AC%E8%99%AB/</loc>
     <lastmod>2024-11-05</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/tags/%E5%BE%AE%E6%9C%8D%E5%8A%A1/</loc>
+    <loc>https://www.stepbystep.asia/tags/SOA/</loc>
     <lastmod>2024-11-05</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/%E5%BE%AE%E6%9C%8D%E5%8A%A1/</loc>
     <lastmod>2024-11-05</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
@@ -495,14 +495,14 @@
   </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/%E5%AE%89%E5%85%A8/%E6%A8%A1%E7%B3%8A%E6%B5%8B%E8%AF%95/</loc>
     <lastmod>2024-11-05</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </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-11-05</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
@@ -537,21 +537,21 @@
   </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%AE%89%E5%85%A8/%E6%B1%A1%E7%82%B9%E5%88%86%E6%9E%90/</loc>
     <lastmod>2024-11-05</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/Docker/</loc>
     <lastmod>2024-11-05</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/categories/%E8%BD%AF%E8%80%83/</loc>
+    <loc>https://www.stepbystep.asia/categories/%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8%80/Python/</loc>
     <lastmod>2024-11-05</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
@@ -565,7 +565,7 @@
   </url>
   
   <url>
-    <loc>https://www.stepbystep.asia/categories/%E5%BC%80%E5%8F%91/Docker/</loc>
+    <loc>https://www.stepbystep.asia/categories/%E8%BD%AF%E8%80%83/</loc>
     <lastmod>2024-11-05</lastmod>
     <changefreq>weekly</changefreq>
     <priority>0.2</priority>
diff --git a/tags/AFL/index.html b/tags/AFL/index.html
index dce4d95..14adc6c 100644
--- a/tags/AFL/index.html
+++ b/tags/AFL/index.html
@@ -214,6 +214,49 @@ <h5 class="sidebar-profile-bio"><p>个人技术博客<br>涉猎开发、测试
     <section class="postShorten-group main-content-wrap">
     
     
+    <article class="postShorten postShorten--thumbnailimg-right">
+        <div class="postShorten-wrap">
+            
+            <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>
+                    
+                </h1>
+                <div class="postShorten-meta">
+    <time datetime="2023-11-18T10:38:08+08:00">
+	
+		    2023 年 11 月 18 日
+    	
+    </time>
+    
+        <span>发布在 </span>
+        
+    <a class="category-link" href="/categories/%E5%AE%89%E5%85%A8/">安全</a>, <a class="category-link" href="/categories/%E5%AE%89%E5%85%A8/%E6%A8%A1%E7%B3%8A%E6%B5%8B%E8%AF%95/">模糊测试</a>
+
+
+    
+</div>
+
+            </div>
+            
+                <div class="postShorten-excerpt">
+                    <p>LibAFL 是用 Rust 开发的一款模糊测试库，支持 Fuzz 各模块的灵活定制 </p>
+                    
+                        <a href="/2023/LibAFL%E7%AE%80%E4%BB%8B/" class="postShorten-excerpt_link link" aria-label=": LibAFL 简介">
+                            阅读全文
+                        </a>
+                        
+                    
+                </div>
+            
+        </div>
+        
+    </article>
+    
+    
     <article class="postShorten postShorten--thumbnailimg-right">
         <div class="postShorten-wrap">
             
diff --git a/tags/Fuzz/index.html b/tags/Fuzz/index.html
index 43c6396..98503d2 100644
--- a/tags/Fuzz/index.html
+++ b/tags/Fuzz/index.html
@@ -349,8 +349,8 @@ <h1 class="postShorten-title">
             <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 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=": AFL++ 源码分析——同步机制">
+                            AFL++ 源码分析——同步机制
                         </a>
                     
                 </h1>
@@ -374,7 +374,7 @@ <h1 class="postShorten-title">
                 <div class="postShorten-excerpt">
                     <p>分析 AFL++ 同步机制的相关源码</p>
                     
-                        <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 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=": AFL++ 源码分析——同步机制">
                             阅读全文
                         </a>
                         
diff --git "a/tags/\345\256\211\345\205\250/index.html" "b/tags/\345\256\211\345\205\250/index.html"
index 1bdde57..7b0dcf1 100644
--- "a/tags/\345\256\211\345\205\250/index.html"
+++ "b/tags/\345\256\211\345\205\250/index.html"
@@ -392,8 +392,8 @@ <h1 class="postShorten-title">
             <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 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=": AFL++ 源码分析——同步机制">
+                            AFL++ 源码分析——同步机制
                         </a>
                     
                 </h1>
@@ -417,7 +417,7 @@ <h1 class="postShorten-title">
                 <div class="postShorten-excerpt">
                     <p>分析 AFL++ 同步机制的相关源码</p>
                     
-                        <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 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=": AFL++ 源码分析——同步机制">
                             阅读全文
                         </a>
                         
diff --git "a/tags/\345\267\245\345\205\267/index.html" "b/tags/\345\267\245\345\205\267/index.html"
index 8695b70..1cadc6a 100644
--- "a/tags/\345\267\245\345\205\267/index.html"
+++ "b/tags/\345\267\245\345\205\267/index.html"
@@ -214,221 +214,6 @@ <h5 class="sidebar-profile-bio"><p>个人技术博客<br>涉猎开发、测试
     <section class="postShorten-group main-content-wrap">
     
     
-    <article class="postShorten postShorten--thumbnailimg-right">
-        <div class="postShorten-wrap">
-            
-            <div class="postShorten-header">
-                <h1 class="postShorten-title">
-                    
-                        <a class="link-unstyled" 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/" aria-label=": 污点分析工具——libdft64">
-                            污点分析工具——libdft64
-                        </a>
-                    
-                </h1>
-                <div class="postShorten-meta">
-    <time datetime="2024-05-17T14:35:03+08:00">
-	
-		    2024 年 5 月 17 日
-    	
-    </time>
-    
-        <span>发布在 </span>
-        
-    <a class="category-link" href="/categories/%E5%AE%89%E5%85%A8/">安全</a>, <a class="category-link" href="/categories/%E5%AE%89%E5%85%A8/%E6%B1%A1%E7%82%B9%E5%88%86%E6%9E%90/">污点分析</a>
-
-
-    
-</div>
-
-            </div>
-            
-                <div class="postShorten-excerpt">
-                    <p>libdft64 是一种数据流追踪工具，可以实现高效并且透明的动态污点分析（DTA），通常用来检测二进制中的安全漏洞</p>
-                    
-                        <a 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/" class="postShorten-excerpt_link link" aria-label=": 污点分析工具——libdft64">
-                            阅读全文
-                        </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/Hexo%E6%8D%A3%E9%BC%93%E6%9C%AD%E8%AE%B0/" aria-label=": Hexo 捣鼓札记">
-                            Hexo 捣鼓札记
-                        </a>
-                    
-                </h1>
-                <div class="postShorten-meta">
-    <time datetime="2024-04-03T14:48:16+08:00">
-	
-		    2024 年 4 月 3 日
-    	
-    </time>
-    
-        <span>发布在 </span>
-        
-    <a class="category-link" href="/categories/Web/">Web</a>
-
-
-    
-</div>
-
-            </div>
-            
-                <div class="postShorten-excerpt">
-                    <p>记录用 Hexo 搭建此个人博客遇到的相关问题</p>
-                    
-                        <a href="/2024/Hexo%E6%8D%A3%E9%BC%93%E6%9C%AD%E8%AE%B0/" class="postShorten-excerpt_link link" aria-label=": Hexo 捣鼓札记">
-                            阅读全文
-                        </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/Symbion%E5%88%9D%E6%8E%A2/" aria-label=": 交替符号执行工具——Symbion 初探">
-                            交替符号执行工具——Symbion 初探
-                        </a>
-                    
-                </h1>
-                <div class="postShorten-meta">
-    <time datetime="2024-02-27T16:33:24+08:00">
-	
-		    2024 年 2 月 27 日
-    	
-    </time>
-    
-        <span>发布在 </span>
-        
-    <a class="category-link" href="/categories/%E5%AE%89%E5%85%A8/">安全</a>, <a class="category-link" href="/categories/%E5%AE%89%E5%85%A8/%E7%AC%A6%E5%8F%B7%E6%89%A7%E8%A1%8C/">符号执行</a>
-
-
-    
-</div>
-
-            </div>
-            
-                <div class="postShorten-excerpt">
-                    <p>Symbion 是 Angr 的一款插件，可以实现具体执行与符号执行交替运行</p>
-                    
-                        <a href="/2024/Symbion%E5%88%9D%E6%8E%A2/" class="postShorten-excerpt_link link" aria-label=": 交替符号执行工具——Symbion 初探">
-                            阅读全文
-                        </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/Angr%E9%9B%B6%E5%9F%BA%E7%A1%80%E5%85%A5%E9%97%A8/" aria-label=": 符号执行工具——Angr 零基础入门">
-                            符号执行工具——Angr 零基础入门
-                        </a>
-                    
-                </h1>
-                <div class="postShorten-meta">
-    <time datetime="2024-01-23T13:45:08+08:00">
-	
-		    2024 年 1 月 23 日
-    	
-    </time>
-    
-        <span>发布在 </span>
-        
-    <a class="category-link" href="/categories/%E5%AE%89%E5%85%A8/">安全</a>, <a class="category-link" href="/categories/%E5%AE%89%E5%85%A8/%E7%AC%A6%E5%8F%B7%E6%89%A7%E8%A1%8C/">符号执行</a>
-
-
-    
-</div>
-
-            </div>
-            
-                <div class="postShorten-excerpt">
-                    <p>Angr 是一款二进制分析和符号执行工具，常用于 CTF 和安全测试领域</p>
-                    
-                        <a href="/2024/Angr%E9%9B%B6%E5%9F%BA%E7%A1%80%E5%85%A5%E9%97%A8/" class="postShorten-excerpt_link link" aria-label=": 符号执行工具——Angr 零基础入门">
-                            阅读全文
-                        </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="/2023/LibAFL%E7%AE%80%E4%BB%8B/" aria-label=": LibAFL 简介">
-                            LibAFL 简介
-                        </a>
-                    
-                </h1>
-                <div class="postShorten-meta">
-    <time datetime="2023-11-18T10:38:08+08:00">
-	
-		    2023 年 11 月 18 日
-    	
-    </time>
-    
-        <span>发布在 </span>
-        
-    <a class="category-link" href="/categories/%E5%AE%89%E5%85%A8/">安全</a>, <a class="category-link" href="/categories/%E5%AE%89%E5%85%A8/%E6%A8%A1%E7%B3%8A%E6%B5%8B%E8%AF%95/">模糊测试</a>
-
-
-    
-</div>
-
-            </div>
-            
-                <div class="postShorten-excerpt">
-                    <p>LibAFL 是用 Rust 开发的一款模糊测试库，支持 Fuzz 各模块的灵活定制 </p>
-                    
-                        <a href="/2023/LibAFL%E7%AE%80%E4%BB%8B/" class="postShorten-excerpt_link link" aria-label=": LibAFL 简介">
-                            阅读全文
-                        </a>
-                        
-                    
-                </div>
-            
-        </div>
-        
-    </article>
-    
-    
     <article class="postShorten postShorten--thumbnailimg-right">
         <div class="postShorten-wrap">
             
@@ -471,135 +256,6 @@ <h1 class="postShorten-title">
         
     </article>
     
-    
-    <article class="postShorten postShorten--thumbnailimg-right">
-        <div class="postShorten-wrap">
-            
-            <div class="postShorten-header">
-                <h1 class="postShorten-title">
-                    
-                        <a class="link-unstyled" href="/2023/LibFuzzer%E7%BC%96%E8%AF%91%E6%8C%87%E5%8D%97/" aria-label=": LibFuzzer 编译指南">
-                            LibFuzzer 编译指南
-                        </a>
-                    
-                </h1>
-                <div class="postShorten-meta">
-    <time datetime="2023-09-26T14:32:22+08:00">
-	
-		    2023 年 9 月 26 日
-    	
-    </time>
-    
-        <span>发布在 </span>
-        
-    <a class="category-link" href="/categories/%E5%AE%89%E5%85%A8/">安全</a>, <a class="category-link" href="/categories/%E5%AE%89%E5%85%A8/%E6%A8%A1%E7%B3%8A%E6%B5%8B%E8%AF%95/">模糊测试</a>
-
-
-    
-</div>
-
-            </div>
-            
-                <div class="postShorten-excerpt">
-                    <p>怎样编出 LibFuzzer 的 target</p>
-                    
-                        <a href="/2023/LibFuzzer%E7%BC%96%E8%AF%91%E6%8C%87%E5%8D%97/" class="postShorten-excerpt_link link" aria-label=": LibFuzzer 编译指南">
-                            阅读全文
-                        </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="/2023/LibFuzzer%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E/" aria-label=": LibFuzzer 使用说明">
-                            LibFuzzer 使用说明
-                        </a>
-                    
-                </h1>
-                <div class="postShorten-meta">
-    <time datetime="2023-09-17T18:30:15+08:00">
-	
-		    2023 年 9 月 17 日
-    	
-    </time>
-    
-        <span>发布在 </span>
-        
-    <a class="category-link" href="/categories/%E5%AE%89%E5%85%A8/">安全</a>, <a class="category-link" href="/categories/%E5%AE%89%E5%85%A8/%E6%A8%A1%E7%B3%8A%E6%B5%8B%E8%AF%95/">模糊测试</a>
-
-
-    
-</div>
-
-            </div>
-            
-                <div class="postShorten-excerpt">
-                    <p>模糊测试工具 LibFuzzer 从 0 到 1，原理 + 安装 + 使用 + 优化，一篇讲完</p>
-                    
-                        <a href="/2023/LibFuzzer%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E/" class="postShorten-excerpt_link link" aria-label=": LibFuzzer 使用说明">
-                            阅读全文
-                        </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="/2023/Docker%E5%BF%85%E7%9F%A5%E5%BF%85%E4%BC%9A/" aria-label=": Docker 必知必会">
-                            Docker 必知必会
-                        </a>
-                    
-                </h1>
-                <div class="postShorten-meta">
-    <time datetime="2023-07-08T16:10:21+08:00">
-	
-		    2023 年 7 月 8 日
-    	
-    </time>
-    
-        <span>发布在 </span>
-        
-    <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/Docker/">Docker</a>
-
-
-    
-</div>
-
-            </div>
-            
-                <div class="postShorten-excerpt">
-                    <p>Docker 基本原理以及常用命令</p>
-                    
-                        <a href="/2023/Docker%E5%BF%85%E7%9F%A5%E5%BF%85%E4%BC%9A/" class="postShorten-excerpt_link link" aria-label=": Docker 必知必会">
-                            阅读全文
-                        </a>
-                        
-                    
-                </div>
-            
-        </div>
-        
-    </article>
-    
     <div class="pagination-bar">
     <ul class="pagination">
         
diff --git "a/tags/\346\272\220\347\240\201/index.html" "b/tags/\346\272\220\347\240\201/index.html"
index 35cd8f8..8fe43bb 100644
--- "a/tags/\346\272\220\347\240\201/index.html"
+++ "b/tags/\346\272\220\347\240\201/index.html"
@@ -349,8 +349,8 @@ <h1 class="postShorten-title">
             <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 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=": AFL++ 源码分析——同步机制">
+                            AFL++ 源码分析——同步机制
                         </a>
                     
                 </h1>
@@ -374,7 +374,7 @@ <h1 class="postShorten-title">
                 <div class="postShorten-excerpt">
                     <p>分析 AFL++ 同步机制的相关源码</p>
                     
-                        <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 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=": AFL++ 源码分析——同步机制">
                             阅读全文
                         </a>