Go的简单入门：开始使用模糊测试

最新推荐文章于 2024-08-29 21:49:34 发布
原创 最新推荐文章于 2024-08-29 21:49:34 发布 · 192 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#golang #go

本文详细介绍了如何在Go中进行模糊测试，包括创建测试目录、编写代码、添加单元测试和模糊测试，以及如何诊断和修复由于字符串处理错误导致的问题。通过模糊测试，可以发现代码中的漏洞和崩溃输入，确保程序的健壮性。

开始使用模糊测试

文章目录

一、介绍

这篇指导介绍Go中基础的模糊测试。通过模糊测试，随机数据会针对您的测试运行，以尝试找出漏洞或导致崩溃的输入。例如，通过模糊测试能够发现SQL注入的漏洞，缓冲区溢出，拒绝服务或者跨域攻击。

在这篇指导中，你将为一个简单的函数写一个模糊测试，运行Go命令行，调试并修复代码中的问题。

你将通过下面的部分：

  1. 为你的代码创建一个目录；
  2. 添加代码用于测试；
  3. 添加单元测试；
  4. 添加模糊测试；
  5. 修复两个bug；
  6. 探索更多的资源；

二、准备

  • 安装Go1.18 或以上版本；
  • 一个用于编写代码的工具；
  • 命令行工具；
  • 一个支持模糊测试的环境。目前仅在 AMD64 和 ARM64 架构上使用覆盖检测进行模糊测试。

三、实践

3.1 为你的代码创建一个目录

  1. 打开命令行，进入到工作目录

    从为你将要写的代码创建目录开始。

    $ cd 
$

  2. 通过命令行，创建一个名称为fuzz的目录

    $ mkdir fuzz
$ cd fuzz/
$

  3. 为你的代码创建一个模块

    运行go mod init命令，并给它一个新的代码模块路径

    $ go mod init example/fuzz
go: creating new go.mod: module example/fuzz
$

接下来，你将添加一些简单代码去反转字符串，它将用于模糊。

3.2 添加代码用于测试

在这一步，将添加函数用于反转字符串。

写代码

  1. 使用文本编辑器，在fuzz目录中，创建一个叫main.go的文件。

  2. 进入main.go文件，在文件的顶部，粘贴下面的代码声明。

    package main

    一个独立的程序（和标准库相反），总是在main包中。

  3. 在包声明的下面，粘贴下面的函数声明

    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)
}

    函数接受一个字符串，同时循环byte，最后返回反转的字符串。

    注意：这个代码基于golang.org/x/example的stringUtils.Reverse函数。

  4. 在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 agained: %q\n", doubleRev)
}

这个函数将运行Reverse 操作，然后打印命令行的输出。这个是有用的，在实践中查看代码，也是有用的对于发现潜在的debug。

  1. 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 agained: "The quick brown fox jumped over the lazy dog"
$

你能看到原始数据，反转的结果数据，然后对结果再次旋转。它和原始数据相等。

现在代码正在运行，是时间去测试它了。

3.3 添加单元测试

在这一步，你将为Reverse函数写基础的单元测试。

写代码

  1. 使用你的文本编辑器，在fuzz目录中，创建一个文件叫做reverse_test.go

  2. 粘贴下面的代码到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.325s
$ go test -v
=== RUN   TestReverse
--- PASS: TestReverse (0.00s)
PASS
ok  	example/fuzz	0.253s
$

接下来，你将改变单元测试变成模糊测试。

3.4 添加模糊测试

单元测试拥有局限性，即每次输入必须被开发者添加到测试。一个模糊测试的好处是它能为你的代码创建输入，并且能确认边缘化的用例，那些你没有想象出来的用例。

在这一部分你将转换单元测试变成模糊测试，以便于你能通过少量的工作产生更多输入。

注意，你将保留单元测试、基准测试和模糊测试在相同的*_test.go文件下面。但是对于这个案例，你将转换单元测试成为模糊测试。

写代码

在你的文本编译器中，使用下面的模糊测试替换单元测试。

func FuzzReverse(f *testing.F) {
	testcase := []string{"Hello World", " ", "!12345"}
	for _, tc := range testcase {
		f.Add(tc)
	}
	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)
		}
	})
}

Fuzzing也有一些局限性。在你的单元测试中，你能预测Reverse函数期待的输出，并且验证实际的输出满足预期。

例如，在测试用例Reverse("Hello, world")单元测试明确返回dlrow ,olleH。

使用模糊查询，你不能预测期待的输出，因为你不能控制输入。

可是，这里有一些Reverse函数的属性，你能在fuzz测试中进行验证。其中两个能在模糊测试中验证的是：

  1. 反转字符串两次，保留原始值；
  2. 反转的字符串将其状态保留在UTF-8；

注意在单元测试和模糊测试中的语法不同。

  • 函数以FuzzXxx开头代替TestXxx，并且获取*testing.F代替*testing.T；
  • 在你期待看到t.Run执行的地方，你替换成f.Fuzz，在那儿你获取一个模糊测试的函数，它的参数是*testing.T和一个用于模糊执行的类型。单元测试的输入使用 f.Add 作为种子语料库输入提供。

确保新的包unicode/utf8是被导入。

package main

import (
  "testing"
  "unicode/utf8"
)

使用模糊测试覆盖单元测试，同时，再次运行测试。

运行代码

  1. 运行模糊测试，不带模糊属性，确保种子输入能够通过

    $ go test
PASS
ok  	example/fuzz	1.089s
$

  2. 带上模糊，运行FuzzReverse，去看是否任意的随机产生的字符串输入将产生错误。这次执行使用go test带上一个新的标识，-fuzz。

    $ 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: elapsed: 0s, execs: 780 (19533/sec), new interesting: 5 (total: 8)
--- FAIL: FuzzReverse (0.04s)
    --- FAIL: FuzzReverse (0.00s)
        reverse_test.go:20: Reverse produced invalid UTF-8 string "0\x86\xcb"

    Failing input written to testdata/fuzz/FuzzReverse/51fd8412ffb50aa7caa0c705c8d9b9f44bd34af7973d0f5940d60a7b24e6ff34
    To re-run:
    go test -run=FuzzReverse/51fd8412ffb50aa7caa0c705c8d9b9f44bd34af7973d0f5940d60a7b24e6ff34
FAIL
exit status 1
FAIL	example/fuzz	1.106s
$

    使用模糊测试的时候一个错误产生了，并且引起问题的输入是被写到了一个种子语料库文件。它将在下次go test被调用的时候运行，即便不带-fuzz标识。为了展示引起错误的输入，在编译器中打开被写到testdata/fuzz/FuzzReverse 目录下的语料库文件。你的语料库文件可能包含不同的字符串，但是格式是相同的。

    $ cat testdata/fuzz/FuzzReverse/51fd8412ffb50aa7caa0c705c8d9b9f44bd34af7973d0f5940d60a7b24e6ff34
go test fuzz v1
string("ˆ0")
$

    语料库文件第一行包含了编码版本。以下每一行代表构成语料库条目的每种类型的值。因为模糊测试的目标仅获取一个值，在版本后面仅仅有一个值。

  3. 再次不带-fuzz运行go test，将使用新的失败种子语料库条目。

    $ go test
--- FAIL: FuzzReverse (0.00s)
    --- FAIL: FuzzReverse/51fd8412ffb50aa7caa0c705c8d9b9f44bd34af7973d0f5940d60a7b24e6ff34 (0.00s)
        reverse_test.go:20: Reverse produced invalid UTF-8 string "0\x86\xcb"
FAIL
exit status 1
FAIL	example/fuzz	1.076s
$

因为我们的测试失败了，是时候进行调试了。

3.5 修复无效的字符串错误

在这一部分，你将调试错误，并修复错误。

在继续之前，请随意花一些时间思考这个问题并尝试自己解决问题。

诊断错误

这儿有一些不同的方法用来调试错误。如果你使用VS Code作为你的编译器，你能设置断点进行调试。

在这个教程中，你将打印有用的调试信息到你的控制台。

首先，思考对于utf8.ValidString的文档。

ValidString 报告 s 是否完全由有效的 UTF-8 编码符文组成。

当前的Reverse函数，一个字节一个字节的反转字符串，这就是我们的问题。为了保留原始字符串的 UTF-8 编码符文，我们必须逐个符文反转字符串。

为了检查当反转的时候为什么那个输入（在这种情况下，字符串ˆ0）造成了Reverse 产生了一个无效的字符串，你能检查反转字符串符文的数量。

写代码

在文本编译器中，使用下面的代码替换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)
	}
})

这个t.Logf行将打印到命令行，如果一个错误发生。获取如果执行测试带上-v，它能帮助你调试特定的议题。

运行代码

使用go test运行测试

$ go test
--- FAIL: FuzzReverse (0.00s)
    --- FAIL: FuzzReverse/51fd8412ffb50aa7caa0c705c8d9b9f44bd34af7973d0f5940d60a7b24e6ff34 (0.00s)
        reverse_test.go:16: Number of runes: orig=2, rev=3, doubleRev=2
        reverse_test.go:21: Reverse produced invalid UTF-8 string "0\x86\xcb"
FAIL
exit status 1
FAIL	example/fuzz	1.098s
$

整个种子语料库使用字符串，其中每个字符都是一个字节。可是，字符像^需要若干个字节。因此，一个字节一个字节的反转字符串是无效的对于多字节字符。

注意，如果你好奇关于Go处理字符串，阅读博客Strings, bytes, runes and characters in Go进行更深度的理解。

为了更好的理解错误，更正反向功能的错误。

修复错误

为了修复Reverse函数，让我们按照符文遍历字符，代替通过字节。

写代码

在文本编译器中，使用下面的代码替换存在的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现在是遍历字符串中的每个符文，而不是每一个字符。

运行代码

  1. 使用go test运行测试

    $ go test
PASS
ok  	example/fuzz	1.207s
$

  2. 再次使用go test -fuzz=Fuzz进行模糊测试，去看现在是否有新的问题。

    $ go test -fuzz=Fuzz
fuzz: elapsed: 0s, gathering baseline coverage: 0/9 completed
fuzz: minimizing 31-byte failing input file
fuzz: elapsed: 0s, gathering baseline coverage: 4/9 completed
--- FAIL: FuzzReverse (0.03s)
    --- FAIL: FuzzReverse (0.00s)
        reverse_test.go:16: Number of runes: orig=1, rev=1, doubleRev=1
        reverse_test.go:18: Before: "\xa0", after: "�"

    Failing input written to testdata/fuzz/FuzzReverse/1d81da97512e2e81bf08cdb8b161334d7d9639f5c5b18255c920ad25370ff2aa
    To re-run:
    go test -run=FuzzReverse/1d81da97512e2e81bf08cdb8b161334d7d9639f5c5b18255c920ad25370ff2aa
FAIL
exit status 1
FAIL	example/fuzz	1.081s
$

    我们能够看到，经过两次反转的结果是不同于原始结果。这次输入是一个无效的字符串。如果我们使用字符串进行模糊测试，这怎么可能？

    让我们再次调试。

3.6 修复两次反转的错误

在这一部分，我们将调试两次反转的错误，并修复这个错误。

在继续之前，自由的好一些时间去思考这个问题，并修复这个问题。

诊断错误

就像之前，有若干个方法调试错误，在这种场景下，使用断点是一个好的方法。

在这个教程中，我们将在Reverse函数中打印有用的调试信息。

仔细查看反转的字符串以发现错误。在Go中，一个字符串实际上是一个字符切片。并且能够包含非有效的UTF-8字节。原始字符串是一个字节切片，有一个字节，‘\x91’。 当输入字符串设置为 []rune 时，Go 将字节切片编码为 UTF-8，并将字节替换为 UTF-8 字符 �。 当我们将替换的 UTF-8 字符与输入字节切片进行比较时，它们显然不相等。

写代码

  1. 在文本编辑器中，使用下面的代码替换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)-1; i, j = i+1, j-1 {
    r[i], r[j] = r[j], r[i]
  }
  return string(r)
}

    这将帮助我们理解发生了什么错误，当字符串转化成符文切片。

运行代码

这个时候，我们仅仅想运行失败的测试为了检查日志。为了做这个，我们将使用go test -run。

$ go test -run FuzzReverse/1d81da97512e2e81bf08cdb8b161334d7d9639f5c5b18255c920ad25370ff2aa
input: "\xa0"
runes: ['�']
input: "�"
runes: ['�']
--- FAIL: FuzzReverse (0.00s)
    --- FAIL: FuzzReverse/1d81da97512e2e81bf08cdb8b161334d7d9639f5c5b18255c920ad25370ff2aa (0.00s)
        reverse_test.go:16: Number of runes: orig=1, rev=1, doubleRev=1
        reverse_test.go:18: Before: "\xa0", after: "�"
FAIL
exit status 1
FAIL	example/fuzz	0.435s
$

为了运行包含在FuzzXxx/testdata中特定语料库，你能提供{FuzzTestName}/filename 到-run。这是有用的在调试的时候。

知道了输入是无效的unicode，让我们修复在Reverse函数的错误。

修复错误

为了修复这个问题，如果Reverse输入不是一个有效的的UTF-8，让我们返回一个错误。

写代码

  1. 在你的编译器中，使用下面的函数替换存在的Reverse函数

    func Reverse(s string) (string, error) {
	if !utf8.ValidString(s) {
		return s, errors.New("输入是一个无效的UTF-8")
	}
	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)-1; i, j = i+1, j-1 {
		r[i], r[j] = r[j], r[i]
	}
	return string(r), nil
}

    这次改变，当输入的字符串是一个无效的UTF-8时，将返回一个错误。

  2. 因为Reverse 函数现在返回了一个错误，修复main函数去丢弃额外的错误值。使用下面的代码替换已经存在的main函数。

    func main() {
	input := "The quick brown fox jumped over the lazy dog"
	rev, revErr := Reverse(input)
	doubleRev, doubleErr := Reverse(rev)
	fmt.Printf("original: %q\n", input)
  fmt.Printf("reversed: %q, err: %v\n", rev, revErr)
  fmt.Printf("reversed agained: %q, err: %v\n", doubleRev, doubleErr)
}

    这些调用将会返回一个nil 错误，因为输入是有效的UTF-8。

  3. 你需要导入errors和unicode/utf8包。在main.go 中的导入语句看起来像这样：

    import (
  "errors"
  "fmt"
  "unicode/utf8"
)

  4. 修改reverse_test.go 文件，检查错误并跳过测试，如果错误是被返回值产生。

    func FuzzReverse(f *testing.F) {
	testcase := []string{"Hello World", " ", "!12345"}
	for _, tc := range testcase {
		f.Add(tc) // 使用 f.Add 提供种子语料库
	}
	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() 来停止执行该模糊输入。

运行代码

  1. 使用 go test 运行测试

    $ go test
PASS
ok  	example/fuzz	0.491s
$

  2. 使用带有go test -fuzz=Fuzz进行模糊化，然后若干秒后通过，使用ctrl-C停止模糊测试

    $ go test -fuzz=Fuzz
fuzz: elapsed: 0s, gathering baseline coverage: 0/9 completed
fuzz: elapsed: 0s, gathering baseline coverage: 9/9 completed, now fuzzing with 8 workers
fuzz: elapsed: 3s, execs: 306930 (102280/sec), new interesting: 32 (total: 41)
fuzz: elapsed: 6s, execs: 870767 (187915/sec), new interesting: 33 (total: 42)
fuzz: elapsed: 9s, execs: 1293839 (141029/sec), new interesting: 34 (total: 43)
......
fuzz: elapsed: 1m18s, execs: 10520829 (142569/sec), new interesting: 36 (total: 45)
fuzz: elapsed: 1m21s, execs: 10909615 (129590/sec), new interesting: 37 (total: 46)
fuzz: elapsed: 1m24s, execs: 11289776 (126692/sec), new interesting: 37 (total: 46)
fuzz: elapsed: 1m27s, execs: 11689172 (133198/sec), new interesting: 37 (total: 46)
fuzz: elapsed: 1m30s, execs: 12068776 (126454/sec), new interesting: 37 (total: 46)
fuzz: elapsed: 1m33s, execs: 12461830 (131088/sec), new interesting: 37 (total: 46)
fuzz: elapsed: 1m36s, execs: 12843006 (127040/sec), new interesting: 37 (total: 46)
^Cfuzz: elapsed: 1m38s, execs: 13067321 (134596/sec), new interesting: 37 (total: 46)
PASS
ok  	example/fuzz	98.729s
lifeideMacBook-Pro:fuzz lifei$

    除非您通过 -fuzztime 标志，否则模糊测试将一直运行，直到遇到失败的输入。如果没有发生故障，默认是永远运行，并且可以使用 ctrl-C 中断该过程。

  3. 使用go test -fuzz=Fuzz -fuzztime 30s进行模糊化，如果没有发现失败，它将在退出之前模糊 30 秒。

    $ go test -fuzz=Fuzz -fuzztime 30s
fuzz: elapsed: 0s, gathering baseline coverage: 0/46 completed
fuzz: elapsed: 0s, gathering baseline coverage: 46/46 completed, now fuzzing with 8 workers
fuzz: elapsed: 3s, execs: 432881 (144195/sec), new interesting: 3 (total: 49)
fuzz: elapsed: 6s, execs: 881372 (149498/sec), new interesting: 3 (total: 49)
fuzz: elapsed: 9s, execs: 1320812 (146554/sec), new interesting: 3 (total: 49)
fuzz: elapsed: 12s, execs: 1735749 (138323/sec), new interesting: 3 (total: 49)
fuzz: elapsed: 15s, execs: 2140404 (134860/sec), new interesting: 3 (total: 49)
fuzz: elapsed: 18s, execs: 2553033 (137558/sec), new interesting: 3 (total: 49)
fuzz: elapsed: 21s, execs: 2934209 (127072/sec), new interesting: 3 (total: 49)
fuzz: elapsed: 24s, execs: 3289376 (118391/sec), new interesting: 3 (total: 49)
fuzz: elapsed: 27s, execs: 3670350 (126988/sec), new interesting: 4 (total: 50)
fuzz: elapsed: 30s, execs: 4071006 (133510/sec), new interesting: 4 (total: 50)
fuzz: elapsed: 30s, execs: 4071006 (0/sec), new interesting: 4 (total: 50)
PASS
ok  	example/fuzz	30.994s
$

    模糊化测试通过。

除了添加-fuzz标识，若干个新的标识能够添加到go test上，在文档中能够看到：custom-settings 。

点击文档，go.dev/doc/fuzz 进一步阅读。

Golang 模糊测试的使用
飞越蓝天的专栏
02-12 854
其本质上是一种自动化测试技术，更具体一点，它是一种基于随机输入的自动化测试技术，常被用于发现处理用户输入的代码中存在的bug和问题。模糊测试和常规的功能测试的最主要区别是：模糊测试时候，因为输入不可控，所以不能精准预测输出。举个例子说明，一般流程如下：我们有个方法，用来翻转一个字符串；通过运行结果，可以看到，我们的方法通过了测试用例，说明我们这个方法没问题。如果不带上这个参数，模糊测试会一直执行下去，直到遇到报错；带上这个参数，带上时间，执行完这个时间，模糊测试就自动终止了。在我的环境里面，运行。
【GoCN酷Go推荐】 ​强大的模糊测试工具 go-fuzz
Go中国
05-17 851
推荐go-fuzz 的背景我们在日常开发中经常会编写测试和对应的测试用例，大家是否常常会有以下疑惑：现有的测试用例是否完全覆盖了各种边界场景？会不会有意料之外的 case？代码测试覆盖率...
【Go语言成长之路】 模糊测试
最新发布
pzslongyutianxia的博客
08-29 1342
本教程介绍了 Go 中模糊测试的基础知识。通过模糊测试，随机数据会针对您的测试运行，以尝试找到漏洞或导致崩溃的输入。可以通过模糊测试发现的漏洞示例包括 SQL 注入、缓冲区溢出、拒绝服务和跨站点脚本攻击
进行模糊测试。-Golang开发
05-26
gofuzz gofuzz是一个用于使用随机值填充go对象的库。 这对于测试很有用：在所有情况下，您项目的对象是否真的正确地对序列化/反序列化？ 是否存在格式错误的objec gofuzz gofuzz是用于使用随机值填充go对象的库。 这对于测试很有用：在所有情况下，您项目的对象是否真的正确地对序列化/反序列化？ 是否存在格式错误的对象，这会导致您的项目出现紧急情况？ 使用导入“ github.com/google/gofuzz”导入您可以在单个变量上使用它：f：= fuzz.New（）var myInt int f.Fuzz（＆myInt）// myInt获得随机值。 您可以在地图上使用它：f：= fuzz.New（）。NilChance（0）.NumElements（1，1）var m
Go-yFuzz是一个与Kubernetes一起大规模运行模糊测试工作的项目
08-13
yFuzz是一个与Kubernetes一起大规模运行模糊测试工作的项目
『每周译Go』Go 模糊测试
Go中国
01-11 600
从 Go 1.18 版本开始，标准工具集开始支持模糊测试。1概述模糊测试（Fuzzing）是一种自动化测试方法，通过不断地控制程序输入来发现程序错误。Go 中模糊测试使用覆盖率引导来智能浏...
官方教程：Go fuzzing模糊测试
perfume
02-27 2275
Go 1.18在go工具链里引入了fuzzing模糊测试，可以发现Go代码里的漏洞或者bug，非常强大，学习起来
知识普及：关于Fuzzing模糊测试入门原理及实践的讨论
热门推荐
「鸿渐之翼」的博客
09-19 1万+
欢迎点赞收藏加关注。 你的鼓励不仅能让更多的人看到Fuzzing,更是作者原创的动力。 ????：博主是一个伪装成程序员的hacker。研究领域包括操作系统安全，二进制安全，Linux系统，运维，渗透测试，人工智能，信息计算科学等领域。懂些C和汇编，了解Linux，懂点Web皮毛，业余Golang选手 ????：博客经常更新二进制安全，Linux系统，运维，渗透测试，人工智能，信息计算科学等方面知识。 前言： 漏洞挖掘是否是真正的安全呢？ "The best alternative to defen
入门指南：如何使用AFL模糊测试工具
AFL模糊测试工具简介 ## 1.1 什么是AFL模糊测试工具？ AFL（American fuzzy lop）是一款由Lcamtuf开发的模糊测试（fuzz testing）工具。它通过对输入数据进行变异和覆盖率分析，来发现程序中潜在的漏洞和异常行为...
Golang初步实践：gotest项目入门
标题“gotest: Golang的初步工作”以及描述“gotest Golang的初步工作”表明该文件内容聚焦于使用Go语言进行基础测试实践，尤其是围绕`go test`命令和标准库中的`testing`包展开的初步探索。结合标签“Golang, go...
新功能！Go 模糊测试
slphahaha的博客
11-22 818
我们曾探讨过如何有效地测试 Go 代码，完善的测试方案能让程序更加健壮与安全。将于 2022 年 2 月发布的 Go 1.18 是一个大版本：除了备受关注的泛型之外，还有一个非常大的特性将...
Go-知识测试-模糊测试
a18792721831的博客
07-11 1395
模糊测试(Fuzzing)是一种通过构造随机数据对代码进行测试的测试方法，相比于单元测试，它能提供更为全面的测试覆盖，从而找出代码中的潜在漏洞。从1.18开始，Go开始正式支持模糊测试。模糊测试要保证测试文件以_test.go结尾。测试方法必须以FuzzXxx开头。模糊测试方法必须以*testing.F作为参数。Go 1.18 的 Fuzz 测试使用了一种称为 “coverage-guided fuzzing” 的技术来生成随机输入。
一文掌握 Golang 模糊测试（Fuzz Testing）
路多辛的所思所想
06-03 1667
Golang 的模糊测试允许开发者提供初始语料，初始语料可以通过 f.Add 方法添加，也可以将语料按照要求的格式写入 testdata/fuzz/FuzzXXX/ 中的语料文件中。a, b int}{{10, 2},{5, 3},{-6, 3},{-6, -3},// 根据提供的语料，反射获得参数类型并穷举可能的值Div(a, b)})
Go1.18升级功能 - 模糊测试Fuzz 从零开始Go语言
m0_67400972的博客
07-31 340
学习笔记，写到哪是哪。模糊测试也是Go1.18更新的功能点之一。自己测试了一下，初步感觉挺好用的。可以通过模糊测试来进行全自动的测试，不依赖提供的数据集。写法入参使用*testing.F，使用Fuzz方法对入参方法进行模糊测试。使用gotest来执行，执行命令如下后面的时间可以自己设置。看一下执行结果。可以看到测试通过了，中间还有一些测试细节。我们换一个有问题的代码，来试试看。和刚才一样，执行一下看看结果。可以看到很快就发现问题了，在文件同级目录下有个测试数据文件。...
Go模糊测试的现状与未来 | Gopher Daily (2020.08.26) ʕ◔ϖ◔ʔ
TonyBai
08-26 306
每日一谚：If you feel comments are unclear or hard to write concisely, reconsider your API design....
亲测体验Go语言模糊测试
Go中国
01-19 155
何为 模糊测试 (Fuzz Testing)?模糊测试是一种自动化的软件测试技术，它通过向程序提供无效、意外或随机的数据作为输入来检测软件中的错误、漏洞或失败。这种测试方法的目的是找到程序处理意外或异常输入时可能会崩溃或表现出异常行为的地方。模糊测试已成为软件开发和安全领域的一个重要组成部分。对很多基础软件，金融类软件，安全圈子的各位"师傅"们，可能在跑着若干Fuzz Testing以寻找漏洞。作...
Go 语言新提案：添加模糊测试支持
weixin_41888295的博客
02-25 254
Go 语言增加了支持模糊测试 (Fuzz Test) 的新提案。 据介绍，此项提案会为 Go 添加新的testing.F类型，在_test.go文件中支持FuzzFoo函数，并增加新的go命令行为。该提案的 Draft Design 已发布，并根据 Go 社区的反馈进行了迭代。下一步要做的工作是将提案实现为语言特性。 此项特性在 Go 1.17 中会被视为实验性功能，且其 API 也不一定会与 Go 1 兼容。当然，这项功能本身也会存在错误并缺少某些功能，但即便如此也会将其作为概念验证，Go 开发者可以对
Go Fuzz Corpus - 探索Go语言模糊测试新维度
gitblog_00019的博客
06-02 383
Go Fuzz Corpus - 探索Go语言模糊测试新维度 去发现同类优质开源项目:https://gitcode.com/ 项目介绍 go-fuzz-corpus 是一个针对 github.com/dvyukov/go-fuzz 开源项目的示例语料库。这个项目旨在提供一组用于模糊测试（Fuzz Testing）的输入数据集合，帮助开发者更好地理解和应用Go Fuzz工具进行代码漏洞挖掘和软件质...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值