模糊测试实战：覆盖率引导的自动化漏洞挖掘与 CI 落地

统计事实：
  · 大多数安全漏洞集中在"解析外部输入"的代码里
    （HTTP 报文、图片/视频解码、压缩包、序列化、协议解析）
  · 手写测试覆盖不到畸形输入的组合空间
  · 攻击者专门构造畸形输入 → 越界、溢出、死循环、panic

模糊测试的目标：
  在攻击者之前，自动找到"会让代码崩溃/出错的输入"
  而且它一旦跑起来，是 7x24 的——比你手写用例勤快得多

覆盖率引导模糊器的工作循环：
  1. 种子输入（seed corpus）→ 送入目标函数
  2. 插桩代码记录"本次覆盖了哪些边"（edge coverage）
  3. 变异种子（bit 翻转/字节增删/拼接/字典 token）
  4. 若新输入产生了"之前未覆盖的边" → 保留进语料库
  5. 循环 → 语料库不断生长，覆盖率不断逼近全边界

关键点：
  · 不是"随机碰运气"，而是"朝着新路径持续前进"
  · 语料库（corpus）是探索的"记忆"，可持久化、可复用
  · 多进程并行：每个进程独立探索，共享 corpus 提升效率

// 插桩示意：每个基本块前后记录 (prev, cur) 哈希到比特表
// 一次比较被插桩后：
//   if (len > MAX) → 覆盖 "len>MAX" 边
//   下轮变异就会"往这个方向"进化
// 这就是 libFuzzer 的 __sanitizer_cov_trace_pc_guard 机制

// fuzz_target.cc — 解析 JSON 的目标函数
#include <cstdint>
#include <cstddef>
#include <string>
#include "json_parser.h"

extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
    std::string input(reinterpret_cast<const char*>(data), size);
    JsonParser parser;
    parser.parse(input);      // 只做解析，不做断言
    return 0;                 // 崩溃即发现（由 Sanitizer 捕获）
}

# 用 ASan + fuzzer 插桩编译
clang++ -g -fsanitize=fuzzer,address \
    fuzz_target.cc json_parser.cc -o fuzz_json

# 带语料库启动（多进程并行）
./fuzz_json -jobs=8 -workers=8 \
    -max_len=4096 -artifact_prefix=crash_ ./corpus

# 发现崩溃：
#   artifact_prefix 目录下出现 crash-xxxx（最小崩溃输入）
# 用它复现：./fuzz_json crash-xxxx

-max_len=4096        输入最大长度（防资源耗尽）
-runs=1000000        跑够次数自动停
-timeout=5           单个输入超时判定（防死循环）
-print_final_stats=1 结束输出覆盖统计
-artifact_prefix=    崩溃/超时产物目录
-dict=json.dict      字典（关键 token：{ } " , \n 等）
merge=corpus_new     合并两个语料库（去重）

// fuzz_test.go
package parser

import "testing"

func FuzzParseJSON(f *testing.F) {
    // 1. 种子语料：合法样例让 fuzzer 起步
    f.Add(`{"a": 1}`)
    f.Add(`[]`)
    f.Add(`{"nested": {"x": [1,2,3]}}`)

    // 2. 目标：任意输入下不崩溃、不 panic、不卡死
    f.Fuzz(func(t *testing.T, input string) {
        if _, err := ParseJSON(input); err != nil {
            return // 解析失败是合法的，不 assert
        }
        // 解析成功 → 结果必须可序列化回环
        out := MarshalJSON(parsed)
        if !validJSON(out) {
            t.Fatalf("roundtrip produced invalid JSON: %q", out)
        }
    })
}

# 跑模糊（默认 1 个 worker，无限期直到失败或 -fuzztime 到点）
go test -fuzz=FuzzParseJSON -fuzztime=60s ./parser

# 发现失败：生成 testdata/fuzz/FuzzParseJSON/<hash> 崩溃样本
# 复现：go test -run=FuzzParseJSON/xxxx ./parser
# 回归：普通 go test 会重放 testdata/fuzz 下所有样本

# atheris 需要配合 libFuzzer 驱动
import atheris
import sys

def TestOneInput(data):
    try:
        parse_json(data)         # 崩溃/异常即发现
    except (ValueError, KeyError):
        pass                     # 预期异常不算

atheris.Setup(sys.argv, TestOneInput)
atheris.Fuzz()

// jazzer 驱动一个 @FuzzTest
@FuzzTest
void jsonParserFuzz(FuzzedDataProvider data) {
    String input = data.consumeRemainingAsString();
    try {
        JsonParser.parse(input);
    } catch (JsonSyntaxException expected) { }
}
// 运行：jazzer --cp=... JsonParserFuzzTest
// 配合 jacoco 覆盖率引导；崩溃产出最小样本

// fuzz_targets/parse.rs
#![no_main]
use libfuzzer_sys::fuzz_target;
use json_lib::parse;

fuzz_target!(|data: &[u8]| {
    if let Ok(s) = std::str::from_utf8(data) {
        let _ = parse(s);       // 崩溃即发现
    }
});
// cargo fuzz run parse   → 覆盖率引导 + 崩溃最小化

很多内存错误不会立刻崩溃：
  越界写 → 悄悄污染邻域 → 几小时后才在别处爆炸
  未定义行为 → 优化器乱编 → 偶发错误
  → 不插桩就测不到

Sanitizer 在编译期插入检查，运行期捕获第一现场：
  · ASan（Address）：越界、UAF、double-free、泄漏
  · UBSan（Undefined）：整数溢出、非法移位、空指针
  · MSan（Memory）：使用未初始化内存
  · TSan（Thread）：数据竞争（并发模糊）

# 多 Sanitizer 组合（部分互斥，需分开跑）
clang++ -fsanitize=fuzzer,address,undefined fuzz_target.cc -o fuzz
clang++ -fsanitize=fuzzer,memory ...       # MSan 单独
clang++ -fsanitize=fuzzer,thread ...       # TSan 单独

# 运行后崩溃输出示例：
#   ERROR: AddressSanitizer: heap-buffer-overflow
#   WRITE of size 4 at 0x... thread T0
#   #0 ... in JsonParser::parse  json_parser.cc:42
#   → 直接定位到源码行，附最小崩溃输入

好种子 = 覆盖常见结构的合法输入：
  · JSON：{"a":1}、嵌套对象、数组、空串、Unicode
  · 图片：几张小尺寸合法图（PNG/JPEG 头结构）
  · 协议：几个合法握手报文

种子太少 → 从零探索慢
种子太杂 → 浪费语料空间
原则：宁精勿多，覆盖结构多样性，而非海量重复

字典 = 语义 token 提示：
  JSON 字典：{ } [ ] , : " \n true false null
  协议字典：GET, POST, \r\n, Content-Type, 0x00 0xff

fuzzer 会把字典 token 掺进变异，显著提升协议/格式类 fuzz 效率：
  -dict=json.dict

· 语料库应提交到仓库（testdata/corpus），随 CI 演进
· 持续模糊的新发现会自动"回填"语料库（保留新路径）
· 定期 merge 清理冗余样本（--merge_control / corpus sync）
· 崩溃样本一律入库作为回归测试

OSS-Fuzz（Google）为开源项目提供 7x24 持续模糊：
  流程：
    1. 提交 project 配置（build.sh + Dockerfile）
    2. Google 每天跑数万亿次执行
    3. 崩溃自动生成 issue 通知维护者（90 天修复窗口）
    4. 修复验证 → 回归 corpus 收录

收益：
  · 无需自建 fuzz 集群
  · 覆盖 C/C++/Go/Rust/Java/Python 等主流语言
  · 世界级 fuzz 基础设施（ClusterFuzz）

# project.yaml 示例
homepage: "https://github.com/example/jsonlib"
language: c++
primary_contact: "maintainer@example.com"
sanitizers:
  - address
  - undefined

# GitHub Actions：每次提交跑 60s 模糊回归
- name: Fuzz regression
  run: |
    go test -fuzz=FuzzParseJSON -fuzztime=60s ./parser
    # 崩溃样本已在 testdata/fuzz，普通 go test 会重放
- name: ClusterFuzzLite
  uses: google/clusterfuzzlite/actions@...
  # 或自建：GitLab CI 定时任务跑 libFuzzer -runs=100000

· 每个崩溃样本 = 永久回归用例（重放验证已修复）
· 语料库差分：新版本覆盖率不得低于旧版本（防性能/结构回退）
· 定期评估覆盖率增量：若长期无新边 → 增加字典/调整 target
· fuzz 结果与安全响应流程联动：崩溃 → 漏洞库 → CVE

□ 优先给"解析外部输入"的代码写 fuzz target
□ 配 Sanitizer（至少 ASan+UBSan），否则测不到静默内存错误
□ 提供多样化的种子语料 + 语义字典
□ 设置合理 max_len / timeout（防资源耗尽与死循环）
□ 崩溃样本入库作为回归用例
□ 本地小规模（1 分钟）+ CI 定时大规模（小时级）
□ 开源项目接入 OSS-Fuzz
□ 定期评估覆盖率增量，维护语料库
□ 结果与漏洞管理流程打通

模糊测试不是"找麻烦"，而是"在攻击者之前把麻烦找完"。