Google 跟踪代码管理器(noscript) 结束 Google 跟踪代码管理器(noscript) HTML 用 Gemini 与约束求解器找出 fuzzing 漏掉的 Go bug 2026 年 11 月 12 日 Karl Weinmeister 开发者关系总监 title-image

我协助领导 Google 的 agent skills 项目,目前该项目有 175 个 agent skill,用于补充 go-skills等社区合集。为了让这么多 skill 文件保持一致,我编写了 skill-lint,这是一个独立的 Go CLI,用于检查 SKILL.md 文件,并在发布前应用 LLM 生成的逐行编辑。即便 skill-lint 自身有单元测试和 fuzz 测试套件,其 Markdown 解析器或编辑应用器中的一个小切片或行号错误仍可能潜伏下来,直到某个不寻常的文件或编辑范围在 linter 中触发运行时 panic。

在 Go 中,每一个可能在运行时 panic 的切片或索引操作,都会在编译器优化器剔除其已能排除的检查之后,被编译成机器码中一个显式的边界检查陷阱。为了寻找崩溃,我把代码中的关键函数编译出来,查看哪些 panic 陷阱在优化后仍然存在,然后由 Gemini 4 Argon 把通往每个陷阱的路径翻译成 Z3 约束求解器. 由 LLM 编写的求解器模型并不是可靠的证明系统,但它为 agent 提供了一种独立的方式来推理控制流并合成具体的 Go 复现程序,而且它发现的每一次崩溃都是真实的,因为 go test 会直接运行那些有问题的字节。这套工作流捕获了我在测试解析器中植入的全部三个 bug,并在 skill-lint 中发现了三个潜在 bug。

在本文中,我将介绍 Gemini 与 Z3 流水线的工作原理,为什么 go test -fuzz 漏掉了其中两次崩溃(以及修复它的一行改动),以及这种方法在日常 Go 工作流中的适用场景。

求解器流水线的工作原理

Anthropic 的 一篇近期文章 展示了形式化验证如何通过让前沿 AI 模型为 OSS-Fuzz 库编写经过机器校验的 Rocq 证明,来捕获 C 和 C++ 中的潜在 bug。与 fuzzer 随机采样输入不同,形式化工具从每个失败条件反向推导,求解出触发它的确切输入。完整的定理证明对大多数日常 Go 项目来说仍然过于沉重,所以我想看看 agent 能在每个函数约一分钟内,从 LLM 和约束求解器那里获得多少这种找 bug 的能力。

在 C 和 C++ 中,读写缓冲区末尾之外会破坏内存。Go 则在运行时捕获越界访问,把每一个它无法证明安全的切片或索引操作编译成一个显式分支,跳转到 runtime.panicBounds ,从而触发 panic,除非被恢复,否则会使进程崩溃。

在生成机器码之前,Go 的 SSA prove 遍已经通过跟踪切片长度和循环变量消除了大部分这类检查。该优化遍只留下编译器自身无法排除的 runtime.panicBounds 陷阱,从而给求解器一份简短的候选崩溃点清单。

我用 GOOS=linux GOARCH=riscv64 go build -gcflags="-S -d=ssa/check_bce/debug=1" (-S 编译每个目标(它会打印汇编清单,并 ssa/check_bce/debug=1 记录每一个存活的边界检查),然后把 Go 源码和反汇编都交给模型。仅看 Go 源码,你无法看出编译器已经移除了哪些边界检查,或者某个寄存器在哪里被截断为 8 位;而在反汇编中,两者都清晰可见。我选择 RISC-V 作为目标,因为它是 Anthropic 那篇文章为其 Rocq 证明所针对的指令集,而且 Go 开箱即可交叉编译到它。

接下来,Argon 读取 Go 源码和反汇编,返回一个 Z3 脚本,对通往每个存活陷阱的路径进行建模,并在标记出 bug 时附上修补后的函数。随后 Z3 检查这些约束是否可满足,每当它找到崩溃输入时, go test 就会把这些字节对真实函数重放。使用 LLM 让我免于手工把汇编翻译成求解器约束。Argon 的翻译占据了大部分运行时间,每个函数约一分钟,而 Z3 本身在毫秒内就完成了。

verification-harness Go 的 SSA 编译器首先剔除可证明安全的边界检查。随后 Gemini 4 Argon 对剩余陷阱建模,交由 Z3 检查。

何时信任求解器

Anthropic 的方法依赖于 交互式定理证明,即由专家对机器语义建模,Rocq 依据这些规则检查 LLM 生成的证明。相比之下,我的工作流使用基于 可满足性模理论(SMT)的约束求解器,依靠 Argon 把汇编直接翻译成 Z3 约束。虽然约束求解器在没有语义模型的情况下无法提供完整的正确性证明,但它在找 bug 方面非常有效。Z3 的 check-sat 命令在输入约束可满足时返回 sat,在不可满足时返回 unsat 。

sat 答案(“肯定有 bug”)会附带针对该陷阱的具体字节, go test 会把它们对真实函数运行。一旦 go test 发生 panic,无论 Argon 的模型是否可靠,你都得到了一个具体的 bug 复现程序。就像用于 bug 的布隆过滤器, unsat 答案只意味着“可能正确”。放弃正确性证明正是这种方法如此实用的原因:你以极小的代价获得了形式化方法的大部分找 bug 价值。

Anthropic 的设置在 64 MB 预算下证明了整个二进制文件的无崩溃性质;我则在全新的 64 字节切片上检查单个函数,其中 cap(buf) == len(buf),因此任何超过 len(buf) 的切片都会 panic。(如果你想要针对 Go 的整二进制 Rocq 设置, theorem-labs/oss-verify 包含一个 Go 1.27 运行时覆盖层,使运行时变为单线程且确定性。)

对于 fuzzing 基线,我在 Go 1.27.3 上对每个植入的 bug 运行了未设种子的 go test -fuzz :一次 3 秒运行和三次 60 秒运行,每次都使用全新的 fuzz 缓存,以免较短的时间预算成为漏掉的原因。

在汇编中发现植入的 bug

我先从三个安全的解析器开始,以确保流水线不会标记干净的代码。编译器的 prove 遍自行移除了 TOML 键解析器中的所有边界检查,Z3 返回了 unsat ,涉及一个 HTTP 头扫描器和 varint 解码器中剩余的陷阱。

然后我写了三个带有隐蔽 panic 的解析器。这是第一个, ParseTwoChunkFrame:

func ParseTwoChunkFrame(buf []byte) ([]byte, []byte) {
	if len(buf) < 4 || buf[0] != 0xA5 || buf[1] != 0x5A {
		return nil, nil
	}
	hdrLen, bodyLen := buf[2], buf[3]
	total := hdrLen + bodyLen
	if int(total)+4 > len(buf) {
		return nil, nil
	}
	endHdr := 4 + int(hdrLen)
	endBody := endHdr + int(bodyLen)
	return buf[4:endHdr], buf[endHdr:endBody]
}
Go 已复制

在 RISC-V 反汇编中,这个 bug 要容易看得多:

0x0060  ADD    X16, X9, X5                 ; X5 = hdrLen + bodyLen
0x0064  MOVBU  X5, X5                      ; TRUNCATE to uint8: X5 = X5 & 0xff
0x0068  ADDI   $4, X5, X5                  ; X5 = int(total) + 4
0x006a  BLT    X11, X5, 0x00bc             ; guard: if len(buf) < X5, return nil, nil
0x006e  MOV    X9, X11                     ; X11 = int(hdrLen)
0x0070  MOV    X16, X14                    ; X14 = int(bodyLen)
0x0072  ADD    X14, X11, X9                ; X9 = int(hdrLen) + int(bodyLen) (unmasked!)
0x0076  ADDI   $4, X11, X16                ; X16 = endHdr = 4 + int(hdrLen)
0x007a  BLTU   X12, X16, 0x00ec            ; if cap(buf) < endHdr -> runtime.panicBounds
...
0x0090  ADDI   $4, X9, X9                  ; X9 = endBody = 4 + int(hdrLen) + int(bodyLen)
0x0092  BLTU   X12, X9, 0x00e8             ; if cap(buf) < endBody -> runtime.panicBounds
纯文本 已复制

total := hdrLen + bodyLen 将两个 uint8 值相加,因此 MOVBU 在长度守卫检查之前就把和在 256 处回绕 ,而 endBody 则相加完整的 64 位整数。Argon 把这些指令转成一条 Z3 查询,询问一个不超过 64 字节的新切片能否通过守卫,却仍然在 endBody 处未通过 0x0092:

import z3

s = z3.Solver()
length, capacity = z3.BitVecs("length capacity", 64)
b0, b1, hdrLen8, bodyLen8 = z3.BitVecs("b0 b1 hdrLen8 bodyLen8", 8)

wrapped_sum64 = z3.ZeroExt(56, hdrLen8 + bodyLen8) + z3.BitVecVal(4, 64)
end_hdr64 = z3.BitVecVal(4, 64) + z3.ZeroExt(56, hdrLen8)
end_body64 = end_hdr64 + z3.ZeroExt(56, bodyLen8)

s.add(z3.UGE(length, 4), z3.ULE(length, 64), capacity == length)
s.add(b0 == 0xA5, b1 == 0x5A)
s.add(z3.UGE(length, wrapped_sum64), z3.ULE(end_hdr64, capacity))
s.add(z3.UGT(end_body64, capacity))  # panic at 0x0092
assert s.check() == z3.sat
print(s.model())
检查 Python 已复制

Z3 返回了一个 59 字节的反例,其中 hdrLen = 48 和 bodyLen = 236:它们的 uint8 和从 284 回绕到 28(因此 28 + 4 ≤ 59 通过守卫),随后 buf[endHdr:endBody] 切片到索引 288 并 panic。

为什么 Go 的 fuzzer 漏掉了一个五分之一概率的崩溃

在 59 字节时,所有可能的 (hdrLen, bodyLen) 对中有 19.4% 会触发这个崩溃。然而一次 3 秒的 fuzz 运行漏掉了它,三次 60 秒的运行也同样漏掉了。

Go 检查像 这样的 切片表达式 buf[endHdr:endBody] 时,依据的是切片的容量而非长度,而 Go 的 fuzzer 很少传入没有多余容量的切片。在一次对 386,741 次 fuzz 调用的 10 秒探测中,89% 的输入是指向一个共享的约 100 MB 缓冲区的视图,只有 0.07% 的输入满足 cap == len。在如此多的多余容量下,endBody(最多 514)永远不会超过 cap(buf),因此有 bug 的解析器会返回超出 buf 末尾的字节,而不是 panic。

第二个目标 ExtractQuotedToken在末尾反斜杠把索引推过 len(buf)一个字节时,也撞上了同一个盲区。Z3 立刻用 2 字节输入 []byte{'"', '\\'}抓住了它,而 fuzzer 则把越界吸收进了多余容量中。

用完整切片表达式把容量裁剪到长度,会让任何越过 len 的切片变成 panic:

f.Fuzz(func(t *testing.T, data []byte) {
	data = data[:len(data):len(data)] // cap == len: slicing past the end now panics
	ParseTwoChunkFrame(data)
})
Go 已复制

做出这一改动后,fuzzer 在三次运行中都让 ParseTwoChunkFrame 和 ExtractQuotedToken 崩溃了(中位数分别为 0.28 秒和 0.17 秒)。第三个目标 ParseMagicPacket是一个对照,因为它的有符号 int8 长度 bug 无论容量如何都会在负索引上 panic,而 fuzzer 每次运行都能找到它。Fuzzing 仍然无法在其余路径上给你一个 unsat 信号,我就是这样检查三个安全解析器和 Argon 的补丁的。

parser-benchmark-table 把切片容量裁剪到长度,修复了 fuzzer 在两个越界 bug 上的盲区,而 Argon 和 Z3 抓住了全部三个崩溃,并检查了每个打过补丁的解析器。

在 skill-lint 上运行它

接下来,我把流水线指向了 skill-lint 本身。整个 Go CLI 太大,无法直接交给求解器。即使是一个 10 行的解析器也会从 Go 运行时链接 1,559 个符号,而 28 MB 的 skill-lint 二进制文件总共有 32,321 个符号。遵循 函数式核心,命令式外壳,我把 CLI 标志、网络调用和文件 I/O 留给 go test -fuzz 和 go test -race,只对从文件读取代码中提取出的纯函数和切片辅助函数运行求解器。

verification-rings 把解析和切片运算提取成纯函数交给求解器,把文件 I/O、CLI 标志和网络调用留给标准 fuzzing 和竞态检测。

在我测试的五个函数中,两个扫描器返回了 unsat (包括一个带有六个存活边界检查的 CRLF 行拆分器),另外三个有 bug。最尖锐的一个在 ApplyReplacementChunks中,它根据初始行数验证 LLM 生成的 {StartLine, EndLine} 编辑,并从下到上排序,这样较早的编辑不会移动后面的行号:

for _, c := range chunks {
	if c.StartLine < 1 || c.EndLine > len(lines) || c.StartLine > c.EndLine {
		return nil
	}
}
sort.Slice(chunks, func(i, j int) bool {
	return chunks[i].StartLine > chunks[j].StartLine
})
for _, c := range chunks {
	lines = append(lines[:c.StartLine-1],
		append(c.Replacement, lines[c.EndLine:]...)...)
}
Go 已复制

Z3 立刻返回了 sat ,因为按 StartLine 排序并不能防止两个块重叠。在提取出的辅助函数中(它在一开始就检查一次边界),把 4 行文件的第 3 行和第 4 行替换为一行会使 lines 缩减为 3 个元素,因此第二个跨越第 2 到第 4 行的块会求值 lines[4:] 并以 slice bounds out of range [4:3]panic。在已发布的 ApplyChunks中,每次迭代的边界检查会把这种情况变成一个误导性的范围错误,而保持在 len(lines) 范围内的重叠块则会静默覆盖较早的编辑。在排序后拒绝重叠块可以同时修复两者。

另外两个 bug 是类似的记账错误。在本地修复器中,目标行号在内部块循环应用会缩减切片的删除之前,按每个违规检查一次(如果某个修复器在删除后返回第二个块,这是一个潜在的 panic,不过 DeleteLineFix 目前只返回一个)。在提示打包器中,一个截断检查为一个约 70 字节的包装器加文件路径预留了固定的 100 字节,当路径超过约 30 字节时,在已发布代码中会超出 2 MB 的上下文预算,并在提取出的辅助函数中 panic。

当你像这样模块化地检查一个函数时,目标必须包含它自己的入口守卫(比如 ApplyReplacementChunks中的边界检查和排序)。如果某个内部辅助函数假设了只有其调用者才强制或只在文档注释中声明的前置条件,Z3 会乐于编造违反这些条件的输入。因为每个提取出的辅助函数都包含了它的入口守卫,误报不是问题:在我测试的所有六个有 bug 的函数中,Z3 返回的第一个 sat 赋值都在 go test 中触发了真实的 panic,无需过滤掉不崩溃的候选或回到求解器。

一旦我把这些辅助函数从文件 I/O 中剥离出来,一次 3 秒的 fuzz 运行也抓住了全部三个 bug。为了确保 Argon 没有依赖我测试文件中的源码注释,我还在剥离所有注释后重新运行了 skill-lint 目标;Argon 和 Z3 仍然抓住了全部三个 bug,并在两个扫描器和全部三个补丁上返回了 unsat 。

这在 Go 工作流中的位置

完全停留在目标语言内部,会让一整类 bug 难以被 agent 看到。当 LLM 直接审查 Go 源码时,像 if int(total)+4 > len(buf) 这样的一行看起来就像教科书式的边界检查,而当它运行 go test -fuzz时,诸如多余切片容量或多步前置条件检查这类目标语言运行时细节,可能会无限期地掩盖崩溃。让 agent 把 Go 和汇编翻译成约束求解器,会强制进行一次表示转换,剥离表面语法,让每个位宽和切片边界都显式化,而 go test 则把任何求解器命中转回一个具体的 Go 复现程序。

对于大多数 Go 代码,将切片容量裁剪到长度后对纯辅助函数进行模糊测试,几秒钟内就能发现边界错误。对于同时逃过编译器范围证明器和快速模糊测试的陷阱,求解器值得多花一分钟,尤其是在根据多字段头部或行范围计算偏移量的解析器和编辑器中。

单线程求解器模型看不到数据竞争或死锁,因此并发代码仍应交给 竞态检测器, 确定性并发测试以及 Go 1.27 的 goroutine 泄漏剖析.

如果你正在 Go 上试验求解器或编码代理,欢迎在 X 或 LinkedIn.

上与我交流 发布于: 上一篇 下一篇 相关文章 A2UI 1.0: Build delightful, fast, reliable, agentic experiences 移动端 Web 教程 操作指南

A2UI 1.0:构建令人愉悦、快速、可靠的代理式体验

2026 年 11 月 11 日
Cost per task: Using cheap classifiers to route across Gemini models and thinking levels AI 云 操作指南 行业趋势

每任务成本:使用廉价分类器在 Gemini 模型和思考层级之间进行路由

2026 年 11 月 3 日
How Agent Anomaly Detection scores on benchmarks we didn't write AI 云 案例研究 影响力

代理异常检测在我们未编写的基准测试上的得分表现

2026 年 11 月 12 日