如何模糊测试 API 作为一个整体而不是文件输入？

Question

我正在学习模糊测试 C 应用程序的方法。 据我了解，大多数时候在进行模糊测试时，一个 C function 会获取/读取文件。 模糊器被赋予一个有效的样本文件，随机或使用覆盖启发式对其进行变异，并使用这个新输入执行 function。

但是现在我不想对接受文件输入的 function 进行模糊测试，而是对一些共同构成 API 的函数进行模糊测试。例如：

int setState(int state);
int run(void); // crashes when previous set state was == 123

这个想法是作为一个整体测试 API 并检测是否误用和以错误的顺序调用函数（这里：调用setState(123)后跟run() ）是否在某处崩溃了。

怎么能做出这样的事？ 我正在寻找模糊测试框架（不一定是 C）、一般概念和示例。

我尝试使用 LLVM 中的libFuzzer并逐字节“消耗”其模糊器数据。 我读取一个字节以确定调用什么 function，然后在需要时读取一个参数，最后调用 function。然后我重复直到没有更多的模糊器输入数据。 它看起来像这样：

int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
    while(/* not end of fuzzer data reached */)
        switch (fuzzerConsumeByte()) {
        case 0:
            setState(fuzzerConsumeInt());
            break;
        case 1:
            run();
            break;
        default:
            break;
        }
    }
    return 0;
}

提到我发现的这种模糊测试风格的来源是这样的：

[...] 从您的公共 API 中随机调用 select 函数，并使用随机参数以随机顺序调用它们。 代码智能

这似乎不是对基于输入文件的模糊器的良好或有效使用。 不过，使用libFuzzer进行模糊测试几秒钟后就发现了错误。 但我认为，如果我将 API 扩展为多个其他功能，则可能需要很长时间。

Answer 1

当以这种方式对有状态应用程序的 API 进行模糊测试时，还要记住的另一件事是，您应该确保在每次模糊测试之间重置您的应用程序，或者使用 AFL 而不是 libFuzzer 来分叉将测试的每个新输入。 否则，您发现的崩溃可能无法通过故障转储重现，因为崩溃取决于早期测试用例对目标应用程序所做的某些更改。

我还想提一下，我们正在使用“[...] 来自您的公共 API 的随机 select 函数，并使用随机参数以随机顺序调用它们。” 模糊测试方法也适用于更大的现实生活 API（多达几百个函数），并且正在实现良好的代码覆盖率并在合理的时间内找到结果。

关于崩溃转储不是人类可读的，你是对的，但是使用一些基于反馈的模糊测试工具，你不仅会得到崩溃输入的转储，还会得到额外的信息，比如堆栈跟踪，可以帮助你分析根本原因.

编辑：
下面是一个使用这种模糊测试方法并使用 FuzzedDataProvider 的模糊测试示例：

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

#include "FuzzedDataProvider.h"

#include "GPS_module_1.h"
#include "crypto_module_1.h"
#include "crypto_module_2.h"
#include "key_management_module_1.h"
#include "time_module_1.h"

// Wrapper function for FuzzedDataProvider.h
// Writes |num_bytes| of input data to the given destination pointer. If there
// is not enough data left, writes all remaining bytes and fills the rest with zeros.
// Return value is the number of bytes written.
void ConsumeDataAndFillRestWithZeros(void *destination, size_t num_bytes, FuzzedDataProvider *fuzz_data) {
  if (destination != nullptr) {
    size_t num_bytes_with_fuzz_data = fuzz_data->ConsumeData(destination, num_bytes);
    if (num_bytes > num_bytes_with_fuzz_data) {
      size_t num_bytes_with_zeros = num_bytes - num_bytes_with_fuzz_data;
      std::memset((char*)destination+num_bytes_with_fuzz_data, 0, num_bytes_with_zeros);
    }
  }
}

extern "C" int FUZZ(const uint8_t *Data, size_t Size) {
    // Ensure a minimum data length
    if(Size < 100) return 0;

    // Setup FuzzedDataProvider
    FuzzedDataProvider fuzz_data_provider(Data, Size);
    FuzzedDataProvider *fuzz_data = &fuzz_data_provider;

    // Reset the state of the target software
    // to ensure that crashes are reproducible
    crypto::init();

    int number_of_functions = fuzz_data->ConsumeIntegralInRange<int>(1,100);
    for (int i=0; i<number_of_functions; i++) {
      int func_id = fuzz_data->ConsumeIntegralInRange<int>(0, 15);
      switch(func_id) {
         case 0: {
            // Create a struct and fill it with fuzz data
            GPS::position struct_0 = {0};
            ConsumeDataAndFillRestWithZeros(&struct_0, sizeof(struct_0), fuzz_data);
            GPS::get_current_position(&struct_0);
            break;
          }
         case 1: {
            GPS::get_destination_position();
            break;
          }
         case 2: {
            GPS::init_crypto_module();
            break;
          }
         case 3: {
            GPS::position struct_0 = {0};
            ConsumeDataAndFillRestWithZeros(&struct_0, sizeof(struct_0), fuzz_data);
            GPS::set_destination_position(struct_0);
            break;
          }
         case 4: {
            // Create a vector of "random" size
            // and fill it with fuzz data
            std::vector<uint8_t> fuzz_data_0 = fuzz_data->ConsumeBytes<uint8_t>(fuzz_data->ConsumeIntegral<uint8_t>());
            size_t fuzz_size_0 = fuzz_data_0.size();
            crypto::hmac struct_0 = {0};
            ConsumeDataAndFillRestWithZeros(&struct_0, sizeof(struct_0), fuzz_data);
            crypto::calculate_hmac(fuzz_data_0.data(), fuzz_size_0, &struct_0);
            break;
          }
         case 5: {
            crypto::get_state();
            break;
          }
         case 6: {
            crypto::init();
            break;
          }
         case 7: {
            crypto::key struct_0 = {0};
            ConsumeDataAndFillRestWithZeros(&struct_0, sizeof(struct_0), fuzz_data);
            crypto::set_key(struct_0);
            break;
          }
         case 8: {
            crypto::nonce struct_0 = {0};
            ConsumeDataAndFillRestWithZeros(&struct_0, sizeof(struct_0), fuzz_data);
            crypto::set_nonce(struct_0);
            break;
          }
         case 9: {
            std::vector<uint8_t> fuzz_data_0 = fuzz_data->ConsumeBytes<uint8_t>(fuzz_data->ConsumeIntegral<uint8_t>());
            size_t fuzz_size_0 = fuzz_data_0.size();
            crypto::hmac struct_0 = {0};
            ConsumeDataAndFillRestWithZeros(&struct_0, sizeof(struct_0), fuzz_data);
            crypto::verify_hmac(fuzz_data_0.data(), fuzz_size_0, &struct_0);
            break;
          }
         case 10: {
            crypto::key struct_0 = {0};
            ConsumeDataAndFillRestWithZeros(&struct_0, sizeof(struct_0), fuzz_data);
            crypto::verify_key(struct_0);
            break;
          }
         case 11: {
            crypto::nonce struct_0 = {0};
            ConsumeDataAndFillRestWithZeros(&struct_0, sizeof(struct_0), fuzz_data);
            crypto::verify_nonce(&struct_0);
            break;
          }
         case 12: {
            std::vector<uint8_t> fuzz_data_0 = fuzz_data->ConsumeBytes<uint8_t>(fuzz_data->ConsumeIntegral<uint8_t>());
            size_t fuzz_size_0 = fuzz_data_0.size();
            key_management::create_key(fuzz_data_0.data(), fuzz_size_0);
            break;
          }
         case 13: {
            std::vector<uint8_t> fuzz_data_0 = fuzz_data->ConsumeBytes<uint8_t>(fuzz_data->ConsumeIntegral<uint8_t>());
            size_t fuzz_size_0 = fuzz_data_0.size();
            key_management::create_nonce(fuzz_data_0.data(), fuzz_size_0);
            break;
          }
         case 14: {
            std::vector<uint8_t> fuzz_data_0 = fuzz_data->ConsumeBytes<uint8_t>(fuzz_data->ConsumeIntegral<uint8_t>());
            size_t fuzz_size_0 = fuzz_data_0.size();
            key_management::generate_random_bytes(fuzz_data_0.data(), fuzz_size_0);
            break;
          }
         case 15: {
            time_management::current_time();
            break;
          }
      }
    }

    return 0;
}

Answer 2

回答我自己的问题：

是的，这就是 API 模糊测试的方法。 为了按字节消费数据，可以使用 libFuzzer #include <fuzzer/FuzzedDataProvider.h> (C++) 提供的函数。 这个问题：崩溃转储和模糊器语料库将无法被人类阅读。

对于更具可读性的模糊器，为 libFuzzer 实现结构感知自定义数据修改器是有益的。

我使用预制数据修改器libprotobuf-mutator (C++) 对示例 API 进行模糊测试。它根据协议缓冲区定义生成有效的输入数据，而不仅仅是（半）随机字节。 不过，它确实使模糊测试变慢了一点。 给定示例 API 中的错误是在 ~2 分钟后发现的，而基本字节消耗设置为 ~30 秒。 但我确实认为它对于更大的（真实的）API 会更好地扩展。