IoT 固件的协议 Fuzzing：对私有协议做覆盖率引导测试

IoT 固件的协议 Fuzzing：对私有协议做覆盖率引导测试

一、私有协议是 IoT 安全的黑洞

IoT 设备的安全问题大多集中在通信协议上。和 Web 应用不同，IoT 协议大多是私有的、二进制的、文档不全的。智能摄像头可能用自定义 TCP 协议传控制指令，工业网关可能用私有 UDP 协议上报状态。这类协议没有公开规范，传统 Fuzzing 工具拿不到协议模型，只能盲目变异，效率很低。

盲目 Fuzzing 的问题就一个：输入空间太大。一个 64 字节的协议包，可能的取值空间是 256 的 64 次方，远超任何 Fuzzer 的探索能力。没有协议结构引导，Fuzzer 会把大量算力浪费在"根本不可能通过解析"的输入上------把包头改乱，包体再怎么变异也进不了业务逻辑。覆盖率上不去，漏洞就发现不了。

覆盖率引导是解决这个问题的关键。Fuzzer 实时监控被测程序的代码覆盖率，优先保留能触发新代码路径的输入，再基于这些输入做变异。探索效率大幅提升，能从随机变异走向"沿着协议解析路径深入"。但覆盖率引导的前提是 Fuzzer 能拿到执行反馈，这对 IoT 固件来说不容易------固件往往跑在 ARM/MIPS 嵌入式内核上，主流 Fuzzer 默认支持的是 x86 Linux。

私有协议 Fuzzing 绕不开两件事：建立协议模型让变异不盲目，搭建执行环境让覆盖率反馈可用。前者靠抓包逆向与协议建模，后者靠 QEMU 用户态模拟或硬件在环。两件事都不简单，缺一不可。

本文目标很明确：不追求"全协议覆盖"，而是给出一套可复用的覆盖率引导 Fuzzing 落地路径------从抓包到变异、从执行到崩溃复现，让私有协议测试有章可循。

二、覆盖率引导 Fuzzing 的链路与协议模型位置

把一次私有协议 Fuzzing 拆开看，从抓包建模到崩溃复现，是一条完整的反馈闭环。

协议模型是整条链路的起点。它把"无结构的字节流"拆成"有语义的字段序列"------包头魔数、版本号、长度域、命令字、载荷、校验。变异引擎基于这个模型做"结构感知变异"：只改载荷字段，不动包头魔数，保证输入能通过解析器进入业务逻辑。没有协议模型，变异就是瞎改；有了协议模型，变异才能触达深层代码。

执行环境是覆盖率反馈的来源。QEMU 用户态模拟可以跑 ARM/MIPS 固件的单个二进制，不用完整系统，开销低；硬件在环更接近真实，但成本高、并发难。两种方式都能通过插桩拿到覆盖率，前者用 AFL 的 QEMU 模式，后者需要硬件 JTAG 或专用 Fuzzer 支持。

崩溃复现是最后一环。Fuzzer 发现崩溃后，要把崩溃样本去重、最小化，再独立复现确认不是偶发。这一步常被忽视，但很关键。我见过太多团队 Fuzzer 跑了一周，崩溃样本堆了几百个，最后发现 90% 是同一根因，有价值的漏洞只有几个。

三、生产级协议模型变异 Fuzzer 实现

下面是一段基于协议模型的变异 Fuzzer 实现。它包含结构化变异、覆盖率反馈、崩溃归档与最小化：

import os
import json
import time
import struct
import random
import hashlib
import subprocess
from dataclasses import dataclass, field
from typing import Callable

@dataclass
class ProtoField:
    name: str
    fmt: str           # struct 格式符，如 ">H" 表示大端 2 字节
    value: bytes
    mutable: bool = True  # 是否参与变异，魔数等不可变字段标 False

@dataclass
class CrashRecord:
    payload: bytes
    trace_hash: str
    coverage_tag: str
    ts: float = field(default_factory=time.time)

# 协议模型：定义一个简化的 IoT 控制协议字段序列
def build_proto_model() -> list[ProtoField]:
    return [
        ProtoField("magic",   ">I", struct.pack(">I", 0xDEADBEEF), mutable=False),
        ProtoField("version", ">B", struct.pack(">B", 0x01),       mutable=False),
        ProtoField("length",  ">H", struct.pack(">H", 0x0010),     mutable=True),
        ProtoField("cmd",     ">B", struct.pack(">B", 0x03),       mutable=True),
        ProtoField("payload", ">16s", b"\x00" * 16,                mutable=True),
        ProtoField("crc",     ">H", struct.pack(">H", 0x0000),     mutable=True),
    ]

class StructuredMutator:
    """结构感知变异：只改可变字段，保留协议骨架"""
    def __init__(self, max_iterations: int = 10000):
        self._max_iter = max_iterations
        self._count = 0

    def mutate(self, model: list[ProtoField]) -> bytes:
        if self._count >= self._max_iter:
            raise StopIteration("max iterations reached")
        self._count += 1
        out = bytearray()
        for f in model:
            if f.mutable and random.random() < 0.5:
                # 命中变异：按字段格式生成新值
                new_val = self._mutate_field(f)
                out.extend(new_val)
            else:
                out.extend(f.value)
        return bytes(out)

    def _mutate_field(self, f: ProtoField) -> bytes:
        size = struct.calcsize(f.fmt)
        # 几种变异策略：边界值、全 0xFF、随机字节、bit flip
        strategy = random.choice(["boundary", "fill", "random", "flip"])
        if strategy == "boundary":
            return random.choice([b"\x00" * size, b"\xff" * size,
                                  b"\x7f" + b"\x00" * (size - 1),
                                  b"\x80" + b"\x00" * (size - 1)])
        if strategy == "fill":
            return bytes([random.randint(0, 255)]) * size
        if strategy == "flip":
            arr = bytearray(f.value)
            if arr:
                idx = random.randint(0, len(arr) - 1)
                arr[idx] ^= (1 << random.randint(0, 7))
            return bytes(arr)
        return bytes(random.randint(0, 255) for _ in range(size))

class CoverageTracker:
    """覆盖率跟踪：记录已覆盖的代码路径，识别新路径"""
    def __init__(self):
        self._seen: set[str] = set()

    def is_new(self, trace: str) -> bool:
        if trace in self._seen:
            return False
        self._seen.add(trace)
        return True

class ProtocolFuzzer:
    def __init__(self, target_cmd: list[str], workdir: str,
                 timeout: float = 2.0):
        # target_cmd: 把输入文件路径作为参数的被测命令
        self._cmd = target_cmd
        self._workdir = workdir
        os.makedirs(workdir, exist_ok=True)
        self._timeout = timeout
        self._mutator = StructuredMutator()
        self._cov = CoverageTracker()
        self._crashes: list[CrashRecord] = []

    def _execute(self, payload: bytes, idx: int) -> tuple[int, str]:
        in_path = os.path.join(self._workdir, f"input_{idx}.bin")
        with open(in_path, "wb") as f:
            f.write(payload)
        try:
            # 用 subprocess 跑被测程序，带超时防卡死
            r = subprocess.run(self._cmd + [in_path],
                               capture_output=True, timeout=self._timeout)
            # 真实环境从 stderr 或专用插桩接口拿覆盖率，这里用返回码近似
            trace = hashlib.md5(r.stderr).hexdigest()[:8]
            return r.returncode, trace
        except subprocess.TimeoutExpired:
            return -1, "timeout"
        except Exception as e:
            return -2, f"err:{e}"

    def run(self, model: list[ProtoField], rounds: int = 200):
        for i in range(rounds):
            try:
                payload = self._mutator.mutate(model)
            except StopIteration:
                break
            rc, trace = self._execute(payload, i)
            # 新覆盖率或崩溃都保留样本
            is_new_cov = self._cov.is_new(trace)
            if rc < 0 or is_new_cov:
                rec = CrashRecord(payload=payload, trace_hash=trace,
                                  coverage_tag="crash" if rc < 0 else "new_cov")
                self._crashes.append(rec)
        return self._crashes

    def minimize(self) -> list[CrashRecord]:
        """崩溃去重：按 trace_hash 聚合，每个 hash 只留一个代表样本"""
        seen = {}
        for c in self._crashes:
            if c.trace_hash not in seen:
                seen[c.trace_hash] = c
        return list(seen.values())

# 使用示例（被测程序用 /bin/cat 模拟，真实环境替换为目标二进制）
def demo():
    workdir = "/tmp/iot_fuzz"
    fuzzer = ProtocolFuzzer(target_cmd=["/bin/cat"], workdir=workdir, timeout=1.0)
    model = build_proto_model()
    crashes = fuzzer.run(model, rounds=50)
    print(f"raw findings: {len(crashes)}")
    unique = fuzzer.minimize()
    print(f"unique traces: {len(unique)}")
    for u in unique[:3]:
        print(f"  trace={u.trace_hash} tag={u.coverage_tag} len={len(u.payload)}")

if __name__ == "__main__":
    demo()

协议模型把字节流拆成可变与不可变字段，变异只改可变字段保留协议骨架；覆盖率跟踪用 trace hash 识别新路径，新路径样本优先保留；崩溃归档按 trace 去重，避免同一根因被反复记录。这套实现用 subprocess 跑被测程序并捕获 stderr 做近似覆盖率，真实环境可换成 AFL 的 QEMU 模式或专用插桩接口，结构不变。

四、Fuzzing 落地的现实问题

私有协议 Fuzzing 不是装上工具就能跑通。落地要面对几类现实问题，每个都能卡住人。

协议模型决定了 Fuzzing 上限。模型越精确，变异越能触达深层逻辑；模型粗糙，Fuzzer 还在解析器入口打转。建立精确模型需要抓包与逆向结合------抓大量真实流量做字段对齐，逆向二进制验证字段语义。这一步很耗时，不能省。有些团队跳过建模直接用 AFL 盲跑，跑了一周覆盖率不到 5%。不奇怪。

执行环境影响反馈精度。QEMU 用户态模拟速度快，但只能跑单个二进制，覆盖不了内核交互与多进程协作；硬件在环更真实，但并发受限、调试困难。有些漏洞只在特定内核版本或特定硬件外设下触发，纯模拟环境永远发现不了。务实做法是分层：先在 QEMU 上跑大规模 Fuzzing 找代码层漏洞，再在硬件在环上跑小规模 Fuzzing 找环境相关漏洞。

崩溃复现与定位是真正的瓶颈。Fuzzer 跑一周产出几百个崩溃样本，其中 80% 是同一根因的不同表现。去重要靠调用栈哈希，但嵌入式环境往往没有完整栈回溯，只能靠寄存器状态与内存映射近似。复现要在相同硬件、相同固件版本、相同输入下重放，环境差异会导致"开发机能复现、产线不能复现"。把崩溃样本与最小化输入版本化归档，是后续定位的前提。

Fuzzing 不能替代人工审计。覆盖率引导能发现内存破坏、解析器越界这类"代码模式"漏洞，但发现不了业务逻辑漏洞、权限绕过、协议层重放。这个坑我踩过：跑了两周 Fuzzer 找到十几个 crash，审计一看全是同一类越界，真正有危害的业务逻辑漏洞一个都没碰到。Fuzzing 和人工逆向是互补的，不是替代关系。

五、总结

IoT 固件的私有协议 Fuzzing，难在两头：协议建模靠人，执行环境靠工具。跳过建模直接盲跑，属于浪费电。覆盖率反馈让 Fuzzing 从随机变异变成可度量的事，但前提是你能把执行环境搭起来。

崩溃样本必须去重，不然你会被几百个同一根因的 crash 淹死。分层做------QEMU 上大规模跑代码层，硬件上小规模跑环境层------比单押一种方式靠谱。最后记住：Fuzzer 是工具，不是答案。它找不到逻辑漏洞，别迷信。