教程：模糊测试入门
本教程介绍了 Go 语言中模糊测试的基础知识。通过模糊测试，随机数据被用于您的测试，以试图发现漏洞或导致程序崩溃的输入。模糊测试可以发现的一些漏洞示例包括 SQL 注入、缓冲区溢出、拒绝服务和跨站脚本攻击。
在本教程中，您将为一个简单函数编写模糊测试，运行 go 命令，并调试和修复代码中的问题。
如需了解本教程中的术语，请参阅 Go 模糊测试术语表。
您将按以下章节进行
注意：有关其他教程，请参阅教程。
注意：Go 模糊测试目前支持一部分内置类型，具体列表请参见Go 模糊测试文档，未来将增加更多内置类型的支持。
先决条件
- 安装 Go 1.18 或更高版本。有关安装说明，请参阅安装 Go。
- 一个代码编辑器。您拥有的任何文本编辑器都可以正常工作。
- 一个命令行终端。Go 在 Linux 和 Mac 上的任何终端以及 Windows 上的 PowerShell 或 cmd 中都能很好地工作。
- 支持模糊测试的环境。目前，带有覆盖率检测的 Go 模糊测试仅在 AMD64 和 ARM64 架构上可用。
为您的代码创建一个文件夹
首先，为您将编写的代码创建一个文件夹。
-
打开命令行提示符并切换到您的主目录。
在 Linux 或 Mac 上
$ cd在 Windows 上
C:\> cd %HOMEPATH%本教程的其余部分将使用 $ 作为提示符。您使用的命令在 Windows 上也同样有效。
-
在命令行提示符下，为您的代码创建一个名为 fuzz 的目录。
$ mkdir fuzz $ cd fuzz -
创建一个模块来存放您的代码。
运行
go mod init命令，并指定新代码的模块路径。$ go mod init example/fuzz go: creating new go.mod: module example/fuzz注意：对于生产代码，您应该指定一个更符合您自身需求的模块路径。更多信息请参阅管理依赖项。
接下来，您将添加一些用于反转字符串的简单代码，我们稍后将对其进行模糊测试。
添加要测试的代码
在本步骤中，您将添加一个反转字符串的函数。
编写代码
-
使用您的文本编辑器，在 fuzz 目录中创建一个名为 main.go 的文件。
-
在 main.go 文件顶部，粘贴以下包声明。
package main一个独立的程序（与库相对）总是属于
main包。 -
在包声明下方，粘贴以下函数声明。
func Reverse(s string) string { b := []byte(s) for i, j := 0, len(b)-1; i < len(b)/2; i, j = i+1, j-1 { b[i], b[j] = b[j], b[i] } return string(b) }此函数将接受一个
string，每次循环处理一个byte，并在最后返回反转后的字符串。注意：此代码基于 golang.org/x/example 中的
stringutil.Reverse函数。 -
在 main.go 文件顶部，包声明下方，粘贴以下
main函数，用于初始化一个字符串，反转它，打印输出，并重复此过程。func main() { input := "The quick brown fox jumped over the lazy dog" rev := Reverse(input) doubleRev := Reverse(rev) fmt.Printf("original: %q\n", input) fmt.Printf("reversed: %q\n", rev) fmt.Printf("reversed again: %q\n", doubleRev) }此函数将运行几次
Reverse操作，然后将输出打印到命令行。这有助于查看代码的实际运行情况，并可能有助于调试。 -
main函数使用了 fmt 包，因此您需要导入它。代码的开头部分应如下所示
package main import "fmt"
运行代码
在包含 main.go 的目录的命令行中，运行代码。
$ go run .
original: "The quick brown fox jumped over the lazy dog"
reversed: "god yzal eht revo depmuj xof nworb kciuq ehT"
reversed again: "The quick brown fox jumped over the lazy dog"
您可以看到原始字符串、第一次反转的结果，然后是再次反转的结果，它与原始字符串相同。
代码运行后，现在该进行测试了。
添加单元测试
在本步骤中，您将为 Reverse 函数编写一个基本单元测试。
编写代码
-
使用您的文本编辑器，在 fuzz 目录中创建一个名为 reverse_test.go 的文件。
-
将以下代码粘贴到 reverse_test.go 中。
package main import ( "testing" ) func TestReverse(t *testing.T) { testcases := []struct { in, want string }{ {"Hello, world", "dlrow ,olleH"}, {" ", " "}, {"!12345", "54321!"}, } for _, tc := range testcases { rev := Reverse(tc.in) if rev != tc.want { t.Errorf("Reverse: %q, want %q", rev, tc.want) } } }这个简单的测试将断言列出的输入字符串将被正确反转。
运行代码
使用 go test 运行单元测试
$ go test
PASS
ok example/fuzz 0.013s
接下来，您将把单元测试转换为模糊测试。
添加模糊测试
单元测试存在局限性，即每个输入都必须由开发者添加到测试中。模糊测试的一个好处是它可以为您的代码生成输入，并可能发现您手动设计的测试用例未能触及的边缘情况。
在本节中，您将把单元测试转换为模糊测试，以便用更少的工作生成更多的输入！
请注意，您可以将单元测试、基准测试和模糊测试放在同一个 *_test.go 文件中，但在此示例中，您将把单元测试转换为模糊测试。
编写代码
在您的文本编辑器中，将 reverse_test.go 中的单元测试替换为以下模糊测试。
func FuzzReverse(f *testing.F) {
testcases := []string{"Hello, world", " ", "!12345"}
for _, tc := range testcases {
f.Add(tc) // Use f.Add to provide a seed corpus
}
f.Fuzz(func(t *testing.T, orig string) {
rev := Reverse(orig)
doubleRev := Reverse(rev)
if orig != doubleRev {
t.Errorf("Before: %q, after: %q", orig, doubleRev)
}
if utf8.ValidString(orig) && !utf8.ValidString(rev) {
t.Errorf("Reverse produced invalid UTF-8 string %q", rev)
}
})
}
模糊测试也有一些局限性。在您的单元测试中，您可以预测 Reverse 函数的预期输出，并验证实际输出是否符合这些预期。
例如，在测试用例 Reverse("Hello, world") 中，单元测试指定返回值为 "dlrow ,olleH"。
进行模糊测试时，您无法预测预期输出，因为您无法控制输入。
但是，在模糊测试中可以验证 Reverse 函数的几个属性。此模糊测试中检查的两个属性是
- 将字符串反转两次会保留原始值
- 反转后的字符串保持其有效的 UTF-8 状态。
请注意单元测试和模糊测试之间的语法差异
- 函数名称以 FuzzXxx 开头而不是 TestXxx，并且参数类型为
*testing.F而不是*testing.T - 在您期望看到
t.Run执行的地方，您会看到f.Fuzz，它接受一个模糊测试目标函数，该函数的参数是*testing.T和要进行模糊测试的类型。您的单元测试中的输入通过f.Add作为种子语料库输入提供。
确保新的包 unicode/utf8 已被导入。
package main
import (
"testing"
"unicode/utf8"
)
将单元测试转换为模糊测试后，是时候再次运行测试了。
运行代码
-
在不进行模糊测试的情况下运行模糊测试，以确保种子输入通过。
$ go test PASS ok example/fuzz 0.013s如果您在该文件中有其他测试，并且只希望运行模糊测试，也可以运行
go test -run=FuzzReverse。 -
运行带模糊测试的
FuzzReverse，以查看是否有任何随机生成的字符串输入会导致失败。这通过使用带有新标志-fuzz（设置为参数Fuzz）的go test执行。复制下面的命令。$ go test -fuzz=Fuzz另一个有用的标志是
-fuzztime，它限制了模糊测试的运行时间。例如，在下面的测试中指定-fuzztime 10s意味着，只要之前没有发生失败，测试将在经过 10 秒后默认退出。请参阅 cmd/go 文档的此部分，以查看其他测试标志。现在，运行您刚刚复制的命令。
$ go test -fuzz=Fuzz fuzz: elapsed: 0s, gathering baseline coverage: 0/3 completed fuzz: elapsed: 0s, gathering baseline coverage: 3/3 completed, now fuzzing with 8 workers fuzz: minimizing 38-byte failing input file... --- FAIL: FuzzReverse (0.01s) --- FAIL: FuzzReverse (0.00s) reverse_test.go:20: Reverse produced invalid UTF-8 string "\x9c\xdd" Failing input written to testdata/fuzz/FuzzReverse/af69258a12129d6cbba438df5d5f25ba0ec050461c116f777e77ea7c9a0d217a To re-run: go test -run=FuzzReverse/af69258a12129d6cbba438df5d5f25ba0ec050461c116f777e77ea7c9a0d217a FAIL exit status 1 FAIL example/fuzz 0.030s模糊测试时发生了失败，导致问题的输入被写入一个种子语料库文件，该文件将在下次调用
go test时运行，即使没有-fuzz标志。要查看导致失败的输入，请在文本编辑器中打开写入 testdata/fuzz/FuzzReverse 目录的语料库文件。您的种子语料库文件可能包含不同的字符串，但格式是相同的。go test fuzz v1 string("泃")语料库文件的第一行指示编码版本。后面的每一行表示构成语料库条目的每种类型的值。由于模糊测试目标只接受 1 个输入，因此版本之后只有 1 个值。
-
再次运行
go test，不带-fuzz标志；新的失败种子语料库条目将被使用$ go test --- FAIL: FuzzReverse (0.00s) --- FAIL: FuzzReverse/af69258a12129d6cbba438df5d5f25ba0ec050461c116f777e77ea7c9a0d217a (0.00s) reverse_test.go:20: Reverse produced invalid string FAIL exit status 1 FAIL example/fuzz 0.016s由于我们的测试失败了，是时候进行调试了。
修复无效字符串错误
在本节中，您将调试失败并修复 bug。
在继续之前，您可以花一些时间思考并尝试自己解决问题。
诊断错误
有几种不同的方法可以调试此错误。如果您使用 VS Code 作为文本编辑器，可以设置调试器进行调查。
在本教程中，我们将有用的调试信息记录到您的终端。
首先，考虑 utf8.ValidString 的文档。
ValidString reports whether s consists entirely of valid UTF-8-encoded runes.
当前的 Reverse 函数是按字节反转字符串的，问题就出在这里。为了保留原始字符串的 UTF-8 编码的 rune，我们必须改为按 rune 反转字符串。
要检查为什么输入（在本例中为汉字 泃）导致 Reverse 在反转时产生无效字符串，您可以检查反转字符串中的 rune 数量。
编写代码
在您的文本编辑器中，将 FuzzReverse 中的模糊测试目标替换为以下代码。
f.Fuzz(func(t *testing.T, orig string) {
rev := Reverse(orig)
doubleRev := Reverse(rev)
t.Logf("Number of runes: orig=%d, rev=%d, doubleRev=%d", utf8.RuneCountInString(orig), utf8.RuneCountInString(rev), utf8.RuneCountInString(doubleRev))
if orig != doubleRev {
t.Errorf("Before: %q, after: %q", orig, doubleRev)
}
if utf8.ValidString(orig) && !utf8.ValidString(rev) {
t.Errorf("Reverse produced invalid UTF-8 string %q", rev)
}
})
如果发生错误，或者使用 -v 执行测试时，此 t.Logf 行将打印到命令行，这有助于您调试此特定问题。
运行代码
使用 go test 运行测试
$ go test
--- FAIL: FuzzReverse (0.00s)
--- FAIL: FuzzReverse/28f36ef487f23e6c7a81ebdaa9feffe2f2b02b4cddaa6252e87f69863046a5e0 (0.00s)
reverse_test.go:16: Number of runes: orig=1, rev=3, doubleRev=1
reverse_test.go:21: Reverse produced invalid UTF-8 string "\x83\xb3\xe6"
FAIL
exit status 1
FAIL example/fuzz 0.598s
整个种子语料库使用的字符串中的每个字符都是单字节的。然而，像“泃”这样的字符可能需要多个字节。因此，按字节反转字符串会使多字节字符失效。
注意：如果您对 Go 如何处理字符串感到好奇，请阅读博客文章Go 中的字符串、字节、rune 和字符以获得更深入的了解。
更好地理解这个 bug 后，修正 Reverse 函数中的错误。
修复错误
为了修正 Reverse 函数，让我们按 rune（而不是按字节）遍历字符串。
编写代码
在您的文本编辑器中，将现有的 Reverse() 函数替换为以下代码。
func Reverse(s string) string {
r := []rune(s)
for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {
r[i], r[j] = r[j], r[i]
}
return string(r)
}
关键区别在于 Reverse 现在是遍历字符串中的每个 rune，而不是每个 byte。请注意，这只是一个示例，并且没有正确处理组合字符。
运行代码
-
使用
go test运行测试$ go test PASS ok example/fuzz 0.016s测试现在通过了！
-
再次使用
go test -fuzz进行模糊测试，看看是否有新的 bug。$ go test -fuzz=Fuzz fuzz: elapsed: 0s, gathering baseline coverage: 0/37 completed fuzz: minimizing 506-byte failing input file... fuzz: elapsed: 0s, gathering baseline coverage: 5/37 completed --- FAIL: FuzzReverse (0.02s) --- FAIL: FuzzReverse (0.00s) reverse_test.go:33: Before: "\x91", after: "�" Failing input written to testdata/fuzz/FuzzReverse/1ffc28f7538e29d79fce69fef20ce5ea72648529a9ca10bea392bcff28cd015c To re-run: go test -run=FuzzReverse/1ffc28f7538e29d79fce69fef20ce5ea72648529a9ca10bea392bcff28cd015c FAIL exit status 1 FAIL example/fuzz 0.032s我们可以看到，字符串在反转两次后与原始字符串不同。这次的输入本身是无效的 unicode。如果我们在用字符串进行模糊测试，这怎么可能呢？
让我们再次进行调试。
修复两次反转错误
在本节中，您将调试两次反转失败并修复 bug。
在继续之前，您可以花一些时间思考并尝试自己解决问题。
诊断错误
和之前一样，有几种方法可以调试此失败。在这种情况下，使用调试器将是一个很好的方法。
在本教程中，我们将在 Reverse 函数中记录有用的调试信息。
仔细查看反转后的字符串以发现错误。在 Go 中，字符串是一个只读的字节切片，可以包含不是有效 UTF-8 的字节。原始字符串是一个包含一个字节 '\x91' 的字节切片。当输入字符串被设置为 []rune 时，Go 会将字节切片编码为 UTF-8，并将该字节替换为 UTF-8 字符 �。当我们比较替换后的 UTF-8 字符与输入字节切片时，它们显然不相等。
编写代码
-
在您的文本编辑器中，将
Reverse函数替换为以下代码。func Reverse(s string) string { fmt.Printf("input: %q\n", s) r := []rune(s) fmt.Printf("runes: %q\n", r) for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 { r[i], r[j] = r[j], r[i] } return string(r) }这将帮助我们理解将字符串转换为 rune 切片时出了什么问题。
运行代码
这次，我们只希望运行失败的测试以检查日志。为此，我们将使用 go test -run。
要在 FuzzXxx/testdata 中运行特定的语料库条目，可以将 {FuzzTestName}/{filename} 提供给 -run。这在调试时会很有帮助。在此示例中，将 -run 标志设置为失败测试的精确哈希值。从您的终端复制并粘贴唯一的哈希值；它将与下方显示的哈希值不同。
$ go test -run=FuzzReverse/28f36ef487f23e6c7a81ebdaa9feffe2f2b02b4cddaa6252e87f69863046a5e0
input: "\x91"
runes: ['�']
input: "�"
runes: ['�']
--- FAIL: FuzzReverse (0.00s)
--- FAIL: FuzzReverse/28f36ef487f23e6c7a81ebdaa9feffe2f2b02b4cddaa6252e87f69863046a5e0 (0.00s)
reverse_test.go:16: Number of runes: orig=1, rev=1, doubleRev=1
reverse_test.go:18: Before: "\x91", after: "�"
FAIL
exit status 1
FAIL example/fuzz 0.145s
知道了输入是无效的 unicode，让我们修复 Reverse 函数中的错误。
修复错误
要解决此问题，如果 Reverse 的输入不是有效的 UTF-8，我们应该返回一个错误。
编写代码
-
在您的文本编辑器中，将现有的
Reverse函数替换为以下代码。func Reverse(s string) (string, error) { if !utf8.ValidString(s) { return s, errors.New("input is not valid UTF-8") } r := []rune(s) for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 { r[i], r[j] = r[j], r[i] } return string(r), nil }此更改将在输入字符串包含无效 UTF-8 字符时返回错误。
-
由于 Reverse 函数现在返回一个错误，修改
main函数以丢弃额外的错误值。将现有的main函数替换为以下代码。func main() { input := "The quick brown fox jumped over the lazy dog" rev, revErr := Reverse(input) doubleRev, doubleRevErr := Reverse(rev) fmt.Printf("original: %q\n", input) fmt.Printf("reversed: %q, err: %v\n", rev, revErr) fmt.Printf("reversed again: %q, err: %v\n", doubleRev, doubleRevErr) }这些对
Reverse的调用应该返回 nil 错误，因为输入字符串是有效的 UTF-8。 -
您需要导入 errors 和 unicode/utf8 包。main.go 中的 import 语句应如下所示。
import ( "errors" "fmt" "unicode/utf8" ) -
修改 reverse_test.go 文件以检查错误，并在生成错误时通过返回来跳过测试。
func FuzzReverse(f *testing.F) { testcases := []string {"Hello, world", " ", "!12345"} for _, tc := range testcases { f.Add(tc) // Use f.Add to provide a seed corpus } f.Fuzz(func(t *testing.T, orig string) { rev, err1 := Reverse(orig) if err1 != nil { return } doubleRev, err2 := Reverse(rev) if err2 != nil { return } if orig != doubleRev { t.Errorf("Before: %q, after: %q", orig, doubleRev) } if utf8.ValidString(orig) && !utf8.ValidString(rev) { t.Errorf("Reverse produced invalid UTF-8 string %q", rev) } }) }除了返回，您还可以调用
t.Skip()来停止该模糊输入的执行。
运行代码
-
使用 go test 运行测试
$ go test PASS ok example/fuzz 0.019s -
使用
go test -fuzz=Fuzz进行模糊测试，然后等待几秒钟后，按ctrl-C停止模糊测试。除非您传递-fuzztime标志，否则模糊测试将一直运行直到遇到失败输入。默认情况下，如果未发生失败，它将永远运行，可以通过ctrl-C中断进程。
$ go test -fuzz=Fuzz
fuzz: elapsed: 0s, gathering baseline coverage: 0/38 completed
fuzz: elapsed: 0s, gathering baseline coverage: 38/38 completed, now fuzzing with 4 workers
fuzz: elapsed: 3s, execs: 86342 (28778/sec), new interesting: 2 (total: 35)
fuzz: elapsed: 6s, execs: 193490 (35714/sec), new interesting: 4 (total: 37)
fuzz: elapsed: 9s, execs: 304390 (36961/sec), new interesting: 4 (total: 37)
...
fuzz: elapsed: 3m45s, execs: 7246222 (32357/sec), new interesting: 8 (total: 41)
^Cfuzz: elapsed: 3m48s, execs: 7335316 (31648/sec), new interesting: 8 (total: 41)
PASS
ok example/fuzz 228.000s
-
使用
go test -fuzz=Fuzz -fuzztime 30s进行模糊测试，如果在 30 秒内没有找到失败，则退出。$ go test -fuzz=Fuzz -fuzztime 30s fuzz: elapsed: 0s, gathering baseline coverage: 0/5 completed fuzz: elapsed: 0s, gathering baseline coverage: 5/5 completed, now fuzzing with 4 workers fuzz: elapsed: 3s, execs: 80290 (26763/sec), new interesting: 12 (total: 12) fuzz: elapsed: 6s, execs: 210803 (43501/sec), new interesting: 14 (total: 14) fuzz: elapsed: 9s, execs: 292882 (27360/sec), new interesting: 14 (total: 14) fuzz: elapsed: 12s, execs: 371872 (26329/sec), new interesting: 14 (total: 14) fuzz: elapsed: 15s, execs: 517169 (48433/sec), new interesting: 15 (total: 15) fuzz: elapsed: 18s, execs: 663276 (48699/sec), new interesting: 15 (total: 15) fuzz: elapsed: 21s, execs: 771698 (36143/sec), new interesting: 15 (total: 15) fuzz: elapsed: 24s, execs: 924768 (50990/sec), new interesting: 16 (total: 16) fuzz: elapsed: 27s, execs: 1082025 (52427/sec), new interesting: 17 (total: 17) fuzz: elapsed: 30s, execs: 1172817 (30281/sec), new interesting: 17 (total: 17) fuzz: elapsed: 31s, execs: 1172817 (0/sec), new interesting: 17 (total: 17) PASS ok example/fuzz 31.025s模糊测试通过！
除了
-fuzz标志之外，go test还添加了几个新标志，可以在文档中查看。有关模糊测试输出中使用的术语的更多信息，请参阅Go 模糊测试。例如，“new interesting” 指的是能够扩展现有模糊测试语料库代码覆盖率的输入。“new interesting” 输入的数量预计会在模糊测试开始时急剧增加，在发现新代码路径时出现几次高峰，然后随着时间的推移而逐渐减少。
结论
干得好！您刚刚入门了 Go 语言的模糊测试。
下一步是选择代码中您想进行模糊测试的函数，然后试试看！如果模糊测试在您的代码中发现了 bug，考虑将其添加到荣誉榜。
如果您遇到任何问题或有功能建议，请提交问题。
对于关于此功能的讨论和一般反馈，您也可以在 Gophers Slack 的#fuzzing 频道中参与。
请查阅go.dev/security/fuzz 上的文档以供进一步阅读。
完整代码
— main.go —
package main
import (
"errors"
"fmt"
"unicode/utf8"
)
func main() {
input := "The quick brown fox jumped over the lazy dog"
rev, revErr := Reverse(input)
doubleRev, doubleRevErr := Reverse(rev)
fmt.Printf("original: %q\n", input)
fmt.Printf("reversed: %q, err: %v\n", rev, revErr)
fmt.Printf("reversed again: %q, err: %v\n", doubleRev, doubleRevErr)
}
func Reverse(s string) (string, error) {
if !utf8.ValidString(s) {
return s, errors.New("input is not valid UTF-8")
}
r := []rune(s)
for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {
r[i], r[j] = r[j], r[i]
}
return string(r), nil
}
— reverse_test.go —
package main
import (
"testing"
"unicode/utf8"
)
func FuzzReverse(f *testing.F) {
testcases := []string{"Hello, world", " ", "!12345"}
for _, tc := range testcases {
f.Add(tc) // Use f.Add to provide a seed corpus
}
f.Fuzz(func(t *testing.T, orig string) {
rev, err1 := Reverse(orig)
if err1 != nil {
return
}
doubleRev, err2 := Reverse(rev)
if err2 != nil {
return
}
if orig != doubleRev {
t.Errorf("Before: %q, after: %q", orig, doubleRev)
}
if utf8.ValidString(orig) && !utf8.ValidString(rev) {
t.Errorf("Reverse produced invalid UTF-8 string %q", rev)
}
})
}