offensive-fuzzing

漏洞利用型模糊测试

模糊测试器类型

类型	覆盖率	速度	工具
黑盒	差	快	Peach、Boofuzz
灰盒	良好	快	AFL++、Honggfuzz、libFuzzer、WinAFL
快照	良好	最快	Nyx、wtf、Snapchange
白盒	最佳	慢	KLEE、QSYM、SymSan
集成	最佳	快	AFL++ + Honggfuzz + libFuzzer

灰盒子类型： 定向（AFLGo、UAFuzz）、语法（AFLSmart、Tlspuffin）、合谋（QSYM、Driller）、内核（syzkaller、kAFL、wtf）。

核心工作流

Research target → Choose analyses → Build harness → Seed corpus → Instrument → Fuzz → Triage crashes → Report

1. 调研目标

• 梳理所有输入面（文件、网络、IPC、系统调用、IOCTL）
• 找出高价值区域：之前修补过的代码、复杂解析器、新增代码、输入接收点
• 对于内核模块：不要只关注 copy_from_user，还要检查 DMA-BUF 操作、页故障处理程序、VM 操作结构体、分配回调

2. 插桩和构建

# AFL++ (preferred for GreyBox)
CC=afl-clang-fast CXX=afl-clang-fast++ cmake -DCMAKE_BUILD_TYPE=Release .. && make -j

# libFuzzer + ASan/UBSan (C/C++)
cmake -DCMAKE_CXX_FLAGS="-fsanitize=fuzzer,address,undefined -O1 -g" ..

# CmpLog build for hard compares
AFL_LLVM_CMPLOG=1 CC=afl-clang-fast CXX=afl-clang-fast++ make clean all

Windows（MSVC）： Project Properties → C/C++ → Address Sanitizer: Yes (/fsanitize=address)

3. 编写 Harness

libFuzzer（C++）：

#include <cstdint>
#include <cstddef>
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
    parse_or_process(data, size);
    return 0;
}

Honggfuzz HF_ITER（持久模式——大型目标的首选）：

#include "honggfuzz.h"
int main(int argc, char** argv) {
    initialize_target(); // runs once
    for (;;) {
        size_t len; uint8_t *buf;
        HF_ITER(&buf, &len);
        FILE* s = fmemopen(buf, len, "r");
        target_function(s);
        fclose(s);
        reset_target_state();
    }
}

AFL++ 持久模式（__AFL_LOOP）：

while (__AFL_LOOP(10000)) {
    // re-read input and process
}

macOS IPC（Mach 消息模糊测试）：

void *lib_handle = dlopen("libexample.dylib", RTLD_LAZY);
pFunction = dlsym(lib_handle, "DesiredFunction");

4. 构建种子语料库

• 从目标的测试套件、缺陷报告和真实样本中提取
• 对文件格式进行网络爬取（Common Crawl）；按 MIME 类型筛选
• 最小化：afl-cmin -i raw_corpus -o seeds -- ./target @@
• 裁剪输入：afl-tmin -i crash -o crash.min -- ./target @@

5. 启动模糊测试

AFL++ 并行运行（主实例 + 使用 cmplog 的次要实例）：

afl-fuzz -M f1 -i seeds -o findings -x dict.txt -- ./target @@
afl-fuzz -S s1 -i seeds -o findings -c 0 -- ./target @@

libFuzzer：

./target_libfuzzer corpus/ -max_total_time=3600 -workers=4

仅二进制（QEMU）：

afl-fuzz -Q -i seeds -o findings -- target.exe @@

快照（AFL++ Nyx）：

NYX_MODE=1 AFL_MAP_SIZE=1048576 afl-fuzz -i seeds -o findings -- ./target_nyx @@

集成（AFL++ + Honggfuzz 共享语料库）：

# Terminal 1
afl-fuzz -M fuzzer1 -i seeds -o sync_dir -- ./target @@
# Terminal 2
../honggfuzz/honggfuzz -i sync_dir/fuzzer1/queue -W sync_dir/hfuzz \
  --linux_perf_ipt_block -t 10 -- ./target ___FILE___

6. 监控并解除停滞

如果进度停滞：

• 启用 CmpLog：在 AFL++ 次要实例上使用 -c 0
• 添加字典：使用 -x dict.txt 或 AFL_TOKEN_FILE
• 切换到定向模糊测试（AFLGo），针对特定 BB/函数
• 在难以覆盖的分支上使用合谋辅助（QSYM、Driller）
• 对目标创建快照以提高 exec/s
• MOpt 调度器使用 AFL_MAP_SIZE=1048576、-L 0

7. 分析崩溃

# 1. Minimize
afl-tmin -i crash -o crash.min -- ./target @@
# 2. Symbolize
ASAN_OPTIONS=abort_on_error=1:symbolize=1 ./target crash.min 2>asan.log
# 3. Hash + bucket
./cov-tool --bbids ./target crash.min > cov.hash
./bucket.py --key "$(cat cov.hash)" --log asan.log --out triage/

Sanitizer 环境变量速查：

ASAN_OPTIONS=abort_on_error=1:symbolize=1:detect_stack_use_after_return=1
UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1
TSAN_OPTIONS=halt_on_error=1:history_size=7
MSAN_OPTIONS=poison_in_dtor=1:track_origins=2

Oracle 选择

缺陷类别	Oracle
内存安全	ASan、HWASan（AArch64，开销较低）
未初始化读取	MSan
并发	TSan
未定义行为	UBSan
类型安全	TypeSan
堆加固	Scudo Hardened Allocator
逻辑缺陷	差分 / 幂等性 Oracle
内核内存	KASAN、KMSAN、KCSAN
内核 UB	KUBSan（CONFIG_UBSAN_TRAP=y）
CFI	KCFI（-fsanitize=kcfi，Clang 18）
仅二进制	QASAN（QEMU+ASan）、DynamoRIO

属性 Oracle 模式：

• 幂等性：f(x) == f(f(x))
• 差分：比较两个实现，按输出不匹配进行分类
• 不变量：长度单调递增、校验和相等、解析后进行架构验证

专用目标

内核（Linux）—— syzkaller

{
  "target": "linux/arm64",
  "http": ":56700",
  "workdir": "/path/to/workdir",
  "kernel_obj": "/path/to/kernel",
  "image": "/path/to/rootfs.ext3",
  "sshkey": "/path/to/id_rsa",
  "procs": 8,
  "enable_syscalls": ["openat$module_name", "ioctl$IOCTL_CMD", "mmap"],
  "type": "qemu",
  "vm": { "count": 4, "cpu": 2, "mem": 2048 }
}

• 限制 enable_syscalls，以加深对特定子系统的覆盖
• 使用 syz-extract 提取自定义模块所需的常量
• 启用 CONFIG_KASAN=y、CONFIG_KCFI=y、CONFIG_DEBUG_INFO_BTF=y
• 使用 kcov 过滤器和 syz_cover_filter 引导覆盖
• 网络模糊测试：通过 TUN/TAP + 伪系统调用（syz_emit_ethernet）注入
• 崩溃解码：./scripts/decode_stacktrace.sh vmlinux ... < dmesg.log

syzkaller 重现：

syz-execprog -repeat=0 -procs=1 -cover=0 -debug target.repro

EDR / Windows 扫描引擎

WTF 快照 Harness 骨架（mpengine.dll / mini-filter）：

g_Backend->SetBreakpoint("nt!KeBugCheck2", [](Backend_t *Backend) {
    const uint64_t BCode = Backend->GetArg(0);
    Backend->Stop(Crash_t(fmt::format("crash-{:#x}", BCode)));
});

FilterConnectionPort 模糊测试：

HANDLE hPort;
FilterConnectCommunicationPort(L"\\PortName", 0, NULL, 0, NULL, &hPort);
FilterSendMessage(hPort, fuzzData, sizeof(fuzzData), NULL, 0, &bytesReturned);

IOCTL 模糊测试模式：

HANDLE hDev = CreateFile(L"\\\\.\\DeviceName", GENERIC_READ|GENERIC_WRITE, ...);
DeviceIoControl(hDev, ioctlCode, inputBuf, inputLen, outBuf, outLen, &ret, NULL);

• 在初始化后、解析/分派循环开始前创建快照
• 使用 IDA Lighthouse 可视化覆盖情况
• 监控：DRIVER_VERIFIER_DETECTED_VIOLATION (0xc4)、IRQL_NOT_LESS_OR_EQUAL (0xa)
• WinDbg：.symfix; !analyze -v; k; !heap -p -a @rax

在 Linux 上跨平台运行 mpengine.dll（loadlibrary + HF_ITER + Intel PT）：

// Bypass Lua VM to avoid stability issues
insert_function_redirect((void*)luaV_execute_address, my_lua_exec, HOOK_REPLACE_FUNCTION);
for (;;) {
    HF_ITER(&buf, &len);
    ScanDescriptor.UserPtr = fmemopen(buf, len, "r");
    __rsignal(&KernelHandle, RSIG_SCAN_STREAMBUFFER, &ScanParams, sizeof ScanParams);
}

Rust

# Full Rust fuzzing pipeline
cargo test                                         # 1. property tests
cargo +nightly miri test                           # 2. UB via interpreter
cargo +nightly careful test                        # 3. runtime bounds checks
cargo fuzz run fuzz_target_1 -- -max_total_time=3600  # 4. libFuzzer crashes
RUSTFLAGS="--cfg loom" cargo test --release        # 5. concurrency (if needed)
cargo fuzz coverage fuzz_target_1                  # 6. coverage report

重点关注不安全代码块中的：Vec::from_raw_parts、未经检查的索引、transmute 大小不匹配、指针运算、FFI 整数截断。

嵌入式 / 仅二进制

• LibAFL：模块化 Rust 框架；Unicorn 引擎、快照模块、LBRFeedback（在 Intel 上无需插桩）、SAND 解耦式净化
• Retrowrite / QASAN：无需源代码即可通过二进制重写实现覆盖率检测和 ASan
• Nautilus：基于语法的结构化格式模糊测试

语言生态系统

• Go 1.18+：go test -fuzz=Fuzz -run=^$ ./...
• Python：Atheris（CPython 原生扩展模糊测试）
• Rust：cargo-fuzz 或 honggfuzz-rs
• JS 引擎：使用扩展插桩的 Fuzzilli（通过 __builtin_return_address(0) 跟踪 PC）
• Wasm 运行时：wasmtime-fuzz、wafl，用于在 V8/Wasmer/Wasmtime 之间进行差分模糊测试
• 智能合约：Echidna、Foundry-fuzz（Solidity）；Move-Fuzz（Aptos/Sui）

CI/CD 集成

- name: Build with afl-clang-fast
  run: CC=afl-clang-fast make -j
- name: Fuzz (smoke, 15 min)
  run: timeout 15m afl-fuzz -i seeds -o findings -- ./target @@ || true
- name: Upload crashes
  if: always()
  uses: actions/upload-artifact@v4
  with:
    path: findings/**/crashes/*

使用 ClusterFuzzLite 进行持续的长期模糊测试；在不同运行之间缓存语料库。

崩溃分析速查

Linux：

ulimit -c unlimited && sysctl -w kernel.core_pattern=core.%e.%p
gdb -q ./target core.* -ex 'bt' -ex 'info reg' -ex q
addr2line -e ./target 0xDEADBEEF

Windows：

# Enable local dumps
New-Item 'HKLM:\SOFTWARE\Microsoft\Windows\Windows Error Reporting\LocalDumps' -Force
# PageHeap
gflags /p /enable target.exe /full

内核 KASAN/KMSAN：

dmesg -T | egrep -i 'kasan|kmsan' -A 60
./scripts/decode_stacktrace.sh vmlinux /lib/modules/$(uname -r)/build < dmesg.log

**可复现性：**固定 CPU 调速器，仅在安全的情况下禁用 ASLR，固定 RNG 种子，在持久模式下保存输入序列，并在每次崩溃时记录二进制哈希和消毒器选项。

工具索引

工具	用途
AFL++	通用 GreyBox、CmpLog、MOpt、Nyx
Honggfuzz	Intel PT、崩溃检测、HF_ITER
libFuzzer	进程内模糊测试、提供源代码
syzkaller	Linux/Windows 内核系统调用模糊测试
wtf	快照模糊测试、Windows 目标
Nyx	AFL++ 快照模式（Intel PT）
Snapchange	AWS 快照模糊测试
LibAFL	自定义 Rust 模糊测试框架
AFLGo	针对目标 BB/函数的定向模糊测试
kAFL	内核和操作系统模糊测试
Jackalope	二进制覆盖率引导模糊测试（Windows/macOS）
cargo-fuzz	Rust libFuzzer 集成
Atheris	Python 模糊测试
Nautilus	基于语法的模糊测试
AFLTriage	自动化崩溃分诊
afl-cov	AFL++ 覆盖率分析
ClusterFuzz	分布式模糊测试基础设施