C++中的模糊测试（Fuzz Testing）：利用AFL/LibFuzzer工具链发现内存安全漏洞

好的，下面是一篇关于C++模糊测试，利用AFL/LibFuzzer工具链发现内存安全漏洞的技术文章，以讲座模式呈现。

C++模糊测试：利用AFL/LibFuzzer工具链发现内存安全漏洞

大家好，今天我们来聊聊C++模糊测试，特别是如何利用AFL和LibFuzzer这两个强大的工具链来发现程序中的内存安全漏洞。C++以其性能和底层控制能力而闻名，但也因此更容易出现内存相关的错误，例如缓冲区溢出、空指针解引用、格式化字符串漏洞等。模糊测试，也称为fuzzing，是一种通过向程序输入大量随机或半随机数据来检测这些漏洞的有效方法。

1. 什么是模糊测试（Fuzzing）？

模糊测试的核心思想是，通过构造大量非预期的输入，观察程序是否会崩溃、产生异常或表现出其他非预期行为。如果程序出现这些情况，很可能就存在漏洞，我们需要进一步分析和修复。

• 传统测试的局限性： 传统测试通常依赖于预定义的测试用例，只能覆盖到开发者预想到的情况。对于一些边界情况、异常情况或者程序未处理的输入，传统测试往往无法触及。
• 模糊测试的优势： 模糊测试则可以弥补这个缺陷，它通过自动生成大量的随机输入，可以覆盖到更多的代码路径，更容易发现隐藏的漏洞。

2. AFL (American Fuzzy Lop)：引导式模糊测试的先驱

AFL 是一个基于覆盖率引导的模糊测试工具。它通过插桩技术，在编译时向程序中插入额外的代码，用于记录程序执行过程中的覆盖率信息。AFL 会根据这些信息，不断调整和优化生成的输入，以尽可能地覆盖到更多的代码路径。

2.1 AFL 的工作原理

AFL 的工作流程大致如下：

1. 编译目标程序： 使用 AFL 提供的编译器（afl-gcc 或 afl-clang）编译目标程序，进行插桩。
2. 准备初始语料库： 提供一些有效的输入样本作为初始语料库，AFL 会基于这些样本进行变异。
3. 启动模糊测试： 运行 afl-fuzz 工具，指定输入目录、输出目录和目标程序。
4. AFL 变异输入： AFL 会不断从语料库中选择输入样本，对其进行变异（例如位翻转、字节插入、删除、算术运算等），生成新的输入。
5. 执行目标程序： 将生成的输入传递给目标程序执行。
6. 监控程序行为： AFL 会监控程序的执行情况，记录覆盖率信息。如果发现新的代码路径被覆盖，或者程序崩溃、挂起等，AFL 会将对应的输入保存到输出目录中。
7. 循环迭代： AFL 会不断重复步骤 4-6，直到达到预定的时间限制或发现足够的漏洞。

2.2 AFL 的插桩机制

AFL 使用两种主要的插桩技术：

• 基本块覆盖率： 在每个基本块的入口处插入代码，记录该基本块是否被执行过。
• 边缘覆盖率： 记录基本块之间的跳转关系，即程序执行的路径。

通过这些插桩信息，AFL 可以准确地了解哪些代码路径被覆盖了，哪些代码路径还没有被覆盖。

2.3 AFL 的使用示例

假设我们有一个简单的 C++ 程序 vulnerable.cpp，其中包含一个缓冲区溢出漏洞：

#include <iostream>
#include <cstring>

using namespace std;

int main(int argc, char *argv[]) {
  if (argc != 2) {
    cout << "Usage: vulnerable <input>" << endl;
    return 1;
  }

  char buffer[10];
  strcpy(buffer, argv[1]); // 缓冲区溢出

  cout << "Input: " << buffer << endl;

  return 0;
}

要使用 AFL 对这个程序进行模糊测试，可以按照以下步骤操作：

1. 编译目标程序：

   afl-clang++ vulnerable.cpp -o vulnerable

2. 创建输入和输出目录：

   mkdir input output
   echo "hello" > input/seed

3. 启动 AFL 模糊测试：

   afl-fuzz -i input -o output ./vulnerable

   afl-fuzz 的常用参数：

   • -i <input_dir>：指定输入目录，包含初始语料库。
   • -o <output_dir>：指定输出目录，用于保存发现的崩溃样本和新的语料库。
   • ./vulnerable：指定目标程序。

4. 监控 AFL 的运行状态：

   AFL 会在终端上显示当前的运行状态，包括执行速度、覆盖率、发现的崩溃数量等。

5. 分析崩溃样本：

   如果在 output/crashes 目录中发现了崩溃样本，可以使用 GDB 等调试器来分析崩溃原因。

3. LibFuzzer：进程内模糊测试的利器

LibFuzzer 是一个进程内模糊测试工具，它是 LLVM 项目的一部分。与 AFL 不同，LibFuzzer 直接在目标进程中运行模糊测试循环，避免了进程间通信的开销，因此具有更高的执行效率。

3.1 LibFuzzer 的工作原理

LibFuzzer 的工作流程如下：

1. 编写 Fuzz Target： 创建一个特殊的函数，称为 Fuzz Target，用于接收 LibFuzzer 生成的输入数据，并调用目标函数进行测试。
2. 编译 Fuzz Target： 使用 LLVM 提供的编译器（clang++）编译 Fuzz Target，并链接 LibFuzzer 库。
3. 启动模糊测试： 运行编译后的 Fuzz Target 程序，LibFuzzer 会自动生成输入数据，并传递给 Fuzz Target 函数。
4. 监控程序行为： LibFuzzer 会监控程序的执行情况，如果发现崩溃、挂起等，会保存对应的输入数据。

3.2 LibFuzzer 的优势

• 速度快： 进程内模糊测试，避免了进程间通信的开销。
• 易于集成： 可以方便地集成到现有的测试框架中。
• 代码覆盖率反馈： LibFuzzer 也会根据代码覆盖率信息，优化输入生成。

3.3 LibFuzzer 的使用示例

仍然以 vulnerable.cpp 为例，要使用 LibFuzzer 对其进行模糊测试，需要创建一个 Fuzz Target 函数：

#include <iostream>
#include <cstring>
#include <stddef.h>
#include <stdint.h>

using namespace std;

extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
  char buffer[10];
  if (size > 9) {
    return 0; // 避免提前崩溃，让 LibFuzzer 更好地探索
  }
  memcpy(buffer, data, size);
  buffer[size] = ''; // 保证字符串以 null 结尾

  cout << "Input: " << buffer << endl;

  return 0;
}

然后，将 Fuzz Target 函数编译成可执行文件：

clang++ -fsanitize=address,undefined -fno-omit-frame-pointer -g vulnerable.cpp -c -o vulnerable.o
clang++ -fsanitize=address,undefined -fno-omit-frame-pointer -g fuzzer.cpp vulnerable.o -o fuzzer -lFuzzer

其中，fuzzer.cpp 包含 LLVMFuzzerTestOneInput 函数，vulnerable.o 是编译后的目标程序。 -fsanitize=address,undefined 开启了 AddressSanitizer 和 UndefinedBehaviorSanitizer，用于检测内存错误和未定义行为。

最后，运行 Fuzz Target 程序：

./fuzzer

LibFuzzer 会自动生成输入数据，并传递给 LLVMFuzzerTestOneInput 函数。如果发现了崩溃，LibFuzzer 会在终端上显示错误信息，并将崩溃样本保存到磁盘上。

4. AFL 和 LibFuzzer 的比较

特性	AFL	LibFuzzer
运行模式	进程外	进程内
速度	较慢	较快
插桩方式	编译时插桩	编译时插桩
集成难度	较高，需要单独编译目标程序	较低，可以方便地集成到现有测试框架中
适用场景	需要测试整个程序或大型组件时	需要快速测试小型函数或库时
内存安全检测	需要结合 AddressSanitizer 等工具	内置 AddressSanitizer 和 UndefinedBehaviorSanitizer

5. 如何有效地进行模糊测试？

• 选择合适的模糊测试工具： 根据目标程序的特点和测试需求，选择合适的模糊测试工具。对于需要测试整个程序或大型组件的情况，可以选择 AFL。对于需要快速测试小型函数或库的情况，可以选择 LibFuzzer。
• 提供高质量的初始语料库： 初始语料库的质量直接影响模糊测试的效果。提供一些有效的、具有代表性的输入样本，可以帮助模糊测试工具更快地发现漏洞。
• 配置合适的模糊测试参数： 根据目标程序的特点，调整模糊测试的参数，例如执行时间、内存限制、线程数量等。
• 监控模糊测试的运行状态： 密切关注模糊测试的运行状态，例如执行速度、覆盖率、发现的崩溃数量等。如果发现异常情况，及时进行调整。
• 分析崩溃样本： 对于发现的崩溃样本，要认真分析崩溃原因，找到漏洞所在，并及时修复。
• 结合静态分析： 将模糊测试与静态分析结合起来，可以更有效地发现漏洞。静态分析可以帮助我们找到潜在的漏洞点，然后使用模糊测试来验证这些漏洞点。
• 持续集成： 将模糊测试集成到持续集成流程中，可以及早发现和修复漏洞，提高软件质量。

6. 模糊测试的局限性

尽管模糊测试是一种强大的漏洞发现技术，但它也存在一些局限性：

• 无法保证完全覆盖： 模糊测试只能覆盖到程序的部分代码路径，无法保证完全覆盖。
• 可能产生误报： 模糊测试可能会产生一些误报，需要人工进行分析和排除。
• 对输入格式有要求： 模糊测试需要目标程序能够处理大量的随机输入，如果目标程序对输入格式有严格的要求，模糊测试的效果可能会受到影响。
• 无法发现所有类型的漏洞： 模糊测试主要针对内存安全漏洞，对于一些逻辑漏洞或业务漏洞，模糊测试可能无法发现。

7. 代码示例：使用 LibFuzzer 测试图像处理库

假设我们有一个图像处理库 image_lib.cpp，其中包含一个图像缩放函数 resize_image：

// image_lib.cpp
#include <iostream>
#include <vector>

using namespace std;

struct Image {
  int width;
  int height;
  vector<unsigned char> data;
};

// 简单的图像缩放函数 (可能存在漏洞)
Image resize_image(const Image& input_image, int new_width, int new_height) {
  if (new_width <= 0 || new_height <= 0) {
    return {}; // 返回空图像
  }

  Image output_image;
  output_image.width = new_width;
  output_image.height = new_height;
  output_image.data.resize(new_width * new_height); // 可能的整数溢出

  // 简单的双线性插值 (省略实现)
  // ...

  return output_image;
}

// 一个用于测试resize_image的函数，方便后续进行fuzzing
Image create_test_image(int width, int height) {
    Image img;
    img.width = width;
    img.height = height;
    img.data.resize(width * height);
    for (size_t i = 0; i < img.data.size(); ++i) {
        img.data[i] = (unsigned char)(i % 256);
    }
    return img;
}

为了使用 LibFuzzer 对 resize_image 函数进行模糊测试，我们需要创建一个 Fuzz Target 函数：

// fuzzer.cpp
#include <iostream>
#include <stddef.h>
#include <stdint.h>
#include "image_lib.cpp" // 包含 image_lib.cpp

using namespace std;

extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
  if (size < 8) {
    return 0; // 需要至少 8 个字节的数据
  }

  int input_width = *reinterpret_cast<const int*>(data);
  int input_height = *reinterpret_cast<const int*>(data + 4);
  int new_width = *reinterpret_cast<const int*>(data);   //为了演示方便，直接使用data里的值
  int new_height = *reinterpret_cast<const int*>(data + 4); //实际应用中应该生成随机值

  Image input_image = create_test_image(input_width, input_height);

  // 调用目标函数
  resize_image(input_image, new_width, new_height);

  return 0;
}

然后，将 Fuzz Target 函数编译成可执行文件：

clang++ -fsanitize=address,undefined -fno-omit-frame-pointer -g fuzzer.cpp -o fuzzer -lFuzzer

最后，运行 Fuzz Target 程序：

./fuzzer

在这个例子中，resize_image 函数的 output_image.data.resize(new_width * new_height) 可能会发生整数溢出，导致分配的内存空间不足，从而引发内存安全漏洞。通过模糊测试，我们可以更容易地发现这种类型的漏洞。

8. 总结：利用Fuzzing技术提高软件的安全性

模糊测试是一种有效的漏洞发现技术，可以帮助我们发现程序中的内存安全漏洞和其他类型的漏洞。通过结合 AFL 和 LibFuzzer 等工具，我们可以更高效地进行模糊测试，提高软件的安全性。 持续集成Fuzzing是现代软件开发的重要一环。

更多IT精英技术系列讲座，到智猿学院