關于 Golang 的模糊測試實踐
導言
在 Go 編程領域，有一個提升代碼安全性的秘密武器：模糊測試(fuzz testing)。想象一下，有個機器人不知疲倦的向你的 Go 程序扔出除了廚房水槽以外的所有東西，以確保它們堅如磐石。模糊測試不是常規、可預測的測試，而是測試意料之外的、離奇的場景，用隨機數據挑戰代碼，以發現隱藏 bug。
Go 的出現讓模糊測試變得輕而易舉。由于工具鏈內置了支持，Go 開發人員可以輕松的將這種強大的測試方法自動化。這就像為代碼配備了時刻保持警惕的守護者，不斷查找那些可能會漏掉的偷偷摸摸的 bug。
Go 模糊測試就是要將代碼推向極限，甚至超越極限，以確保代碼在現實世界中能夠抵御任何奇特而美妙的輸入。這證明了 Go 對可靠性和安全性的承諾，在一個軟件需要堅如磐石的世界里，它能讓人高枕無憂。
因此，如果你發現應用程序即使在最意想不到的情況下也能流暢運行時，請記住模糊測試所發揮的作用，它作為無名英雄在幕后為 Go 應用的順利運行而努力。
種子語料庫(Seed Corpus)：高效模糊測試的基礎
種子語料庫是提供給模糊測試流程的初始輸入集合，用于啟動生成測試用例，可以把它想象成鎖匠用來制作萬能鑰匙的初始鑰匙集。在模糊測試中，這些種子作為起點，模糊器從中衍生出多種變體，探索大量可能的輸入以發現錯誤。通過精心挑選一組具有代表性的多樣化種子，可以確保模糊器從一開始就能覆蓋更多領域，從而使測試過程更高效且有效。種子可以是典型用例數據，也可以是邊緣用例或以前發現的可誘發錯誤的輸入，從而為徹底測試軟件的可靠性奠定基礎。
示例：對 Go 字符串反轉函數進行模糊測試
我們用 Go 編寫一個簡單的字符串反轉函數，然后創建一個模糊測試。這個示例將有助于說明模糊測試如何在看似簡單的函數中發現意想不到的行為或錯誤。
Go 函數：反轉字符串
package main
// ReverseString takes a string as input and returns its reverse.
func ReverseString(s string) string {
// Convert the string to a rune slice to properly handle multi-byte characters.
runes := []rune(s)
for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
// Swap the runes.
runes[i], runes[j] = runes[j], runes[i]
}
// Convert the rune slice back to a string and return it.
return string(runes)
}解釋：
- ReverseString 函數：該函數接收一個字符串參數并返回其反轉值。它將字符串作為 rune 切片而不是字節來處理，這對于正確處理大小可能超過一個字節的 Unicode 字符至關重要。
- Rune 切片：通過將字符串轉換為 rune 切片，可以確保正確處理多字節字符，保持字符編碼的完整性。
- 交換：該函數迭代 rune 切片，從兩端開始交換元素，然后向中心移動，從而有效反轉切片。
ReverseString 函數的模糊測試
我們為這個函數編寫模糊測試：
package main
import (
"testing"
"unicode/utf8"
)
// FuzzReverseString tests the ReverseString function with fuzzing.
func FuzzReverseString(f *testing.F) {
// Seed corpus with examples, including a case with Unicode characters.
f.Add("hello")
f.Add("world")
f.Add("こんにちは") // "Hello" in Japanese
f.Fuzz(func(t *testing.T, original string) {
// Reverse the string twice should give us the original string back.
reversed := ReverseString(original)
doubleReversed := ReverseString(reversed)
if original != doubleReversed {
t.Errorf("Double reversing '%s' did not give original string, got '%s'", original, doubleReversed)
}
// The length of the original and the reversed string should be the same.
if utf8.RuneCountInString(original) != utf8.RuneCountInString(reversed) {
t.Errorf("The length of the original and reversed string does not match for '%s'", original)
}
})
}解釋：
- 種子語料庫：我們從一組種子輸入開始，包括簡單的 ASCII 字符串和一個 Unicode 字符串，以確保模糊測試涵蓋一系列字符編碼。
- 模糊函數：模糊函數反轉字符串，然后再反轉回來，期望得到原始字符串。這是一個簡單的不變量，如果反轉函數正確的話，就應該總是成立的。它還會檢查原始字符串和反轉字符串的長度是否相同，以檢查多字節字符可能出現的問題。
- 運行測試：要運行該模糊測試，請使用帶有 -fuzz 標志的 go test 命令，如：go test -fuzz=Fuzz。
構建用于數據持久化的 Go REST API 的模糊測試
要在 Go 中創建一個接受 POST 請求并將接收到的數據存儲到文件中的 REST API，可以使用 net/http 軟件包。我們將為處理 POST 請求數據的函數編寫模糊測試。請注意，由于模糊測試的性質及其適用性，此處的模糊測試將重點測試數據處理邏輯，而非 HTTP 服務器本身。
步驟 1：處理 POST 請求的 REST API 函數
首先需要設置一個簡單的 HTTP 服務器，保證其路由可以處理 POST 請求。該服務器將把 POST 請求正文保存到文件中。
package main
import (
"io/ioutil"
"log"
"net/http"
)
func main() {
http.HandleFunc("/save", saveDataHandler) // Set up the route
log.Println("Server starting on port 8080...")
log.Fatal(http.ListenAndServe(":8080", nil))
}
// saveDataHandler saves the POST request body into a file.
func saveDataHandler(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
http.Error(w, "Only POST method is allowed", http.StatusMethodNotAllowed)
return
}
// Read the body of the POST request
body, err := ioutil.ReadAll(r.Body)
if err != nil {
http.Error(w, "Error reading request body", http.StatusInternalServerError)
return
}
defer r.Body.Close()
// Save the data into a file
err = ioutil.WriteFile("data.txt", body, 0644)
if err != nil {
http.Error(w, "Error saving file", http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
w.Write([]byte("Data saved successfully"))
}這個簡單的服務監聽 8080 端口，并有一個接受 POST 請求的路由 /save。該路由的處理程序 saveDataHandler 會讀取請求正文并將其寫入名為 data.txt 的文件中。
步驟 2：編寫模糊測試
在模糊測試中，我們將重點關注將數據保存到文件中的功能。由于無法直接對 HTTP 服務器進行模糊測試，我們把處理數據的邏輯提取到單獨的函數中，并對其進行模糊測試。
package main
import (
"bytes"
"net/http"
"net/http/httptest"
"testing"
)
// FuzzSaveDataHandler uses f.Fuzz to fuzz the body of POST requests sent to saveDataHandler.
func FuzzSaveDataHandler(f *testing.F) {
// Seed corpus with examples, including different types and lengths of data.
f.Add([]byte("example data")) // Example seed
f.Add([]byte("")) // Empty seed
f.Fuzz(func(t *testing.T, data []byte) {
// Construct a new HTTP POST request with fuzzed data as the body.
req, err := http.NewRequest(http.MethodPost, "/save", bytes.NewReader(data))
if err != nil {
t.Fatalf("Failed to create request: %v", err)
}
// Create a ResponseRecorder to act as the target of the HTTP request.
rr := httptest.NewRecorder()
// Invoke the saveDataHandler with our request and recorder.
saveDataHandler(rr, req)
// Here, you can add assertions based on the expected behavior of your handler.
// For example, checking that the response status code is http.StatusOK.
if rr.Code != http.StatusOK {
t.Errorf("Expected status OK for input %v, got %v", data, rr.Code)
}
// Additional assertions can be added here, such as verifying the response body
// or the content of the "data.txt" file if necessary.
})
}解釋：
- FuzzSaveDataHandler 函數：該函數測試 saveDataHandler 如何處理不同 POST 請求體，基于模糊測試來嘗試各種輸入數據。
- 種子語料庫：測試從一些示例數據（"example data"和空字符串）開始，以指導模糊處理過程。
執行模糊測試：
- 對于每個模糊輸入，都會向處理程序發出 POST 請求。
- ResponseRecorder會捕捉處理程序對這些請求的響應。
- 測試將檢查處理程序是否對所有輸入都響應 http.StatusOK 狀態，從而判斷是否已成功處理這些輸入。
運行測試使用 go test -fuzz=FuzzSaveDataHandler 運行模糊測試。測試從種子數據中生成各種輸入，并檢查處理程序響應。
在 Go 中驗證和存儲 CSV 數據：模糊測試方法
要創建一個讀取 CSV 文件、驗證其值并將驗證后的數據存儲到文件中的函數，我們將按照以下步驟進行操作：
- 處理 CSV 的函數：該函數將讀取 CSV 數據，根據預定義規則驗證其內容（為簡單起見，假設我們期望兩列具有特定的數據類型），然后將驗證后的數據存儲到新文件中。
- 模糊測試：我們將為驗證 CSV 數據的函數部分編寫模糊測試。這是因為模糊測試非常適合測試代碼如何處理各種輸入，而我們將重點關注驗證邏輯。
步驟 1：處理和驗證 CSV 數據的功能
package main
import (
"encoding/csv"
"fmt"
"io"
"os"
"strconv"
)
// validateAndSaveData reads CSV data from an io.Reader, validates it, and saves valid rows to a file.
func validateAndSaveData(r io.Reader, outputFile string) error {
csvReader := csv.NewReader(r)
validData := [][]string{}
for {
record, err := csvReader.Read()
if err == io.EOF {
break
}
if err != nil {
return fmt.Errorf("error reading CSV data: %w", err)
}
if validateRecord(record) {
validData = append(validData, record)
}
}
return saveValidData(validData, outputFile)
}
// validateRecord checks if a CSV record is valid. For simplicity, let's assume the first column should be an integer and the second a non-empty string.
func validateRecord(record []string) bool {
if len(record) != 2 {
return false
}
if _, err := strconv.Atoi(record[0]); err != nil {
return false
}
if record[1] == "" {
return false
}
return true
}
// saveValidData writes the validated data to a file.
func saveValidData(data [][]string, outputFile string) error {
file, err := os.Create(outputFile)
if err != nil {
return fmt.Errorf("error creating output file: %w", err)
}
defer file.Close()
csvWriter := csv.NewWriter(file)
for _, record := range data {
if err := csvWriter.Write(record); err != nil {
return fmt.Errorf("error writing record to file: %w", err)
}
}
csvWriter.Flush()
return csvWriter.Error()
}步驟 2：驗證邏輯的模糊測試
在模糊測試中，我們將重點關注 validateRecord 函數，該函數負責驗證 CSV 數據的各個行。
package main
import (
"strings"
"testing"
)
// FuzzValidateRecord tests the validateRecord function with fuzzing.
func FuzzValidateRecord(f *testing.F) {
// Seed corpus with examples, joined as single strings
f.Add("123,validString") // valid record
f.Add("invalidInt,string") // invalid integer
f.Add("123,") // invalid string
f.Fuzz(func(t *testing.T, recordStr string) {
// Split the string back into a slice
record := strings.Split(recordStr, ",")
// Now you can call validateRecord with the slice
_ = validateRecord(record)
// Here you can add checks to verify the behavior of validateRecord
})
}運行模糊測試：
要運行這個模糊測試，需要使用帶有 -fuzz 標志的 go test 命令：
go test -fuzz=Fuzz該命令將啟動模糊處理過程，根據提供的種子自動生成和測試各種輸入。
說明：
- validateAndSaveData 函數從io.Reader讀取數據，從而可以處理來自任何實現此接口的數據源（如文件或內存緩沖區）的數據。該函數通過 csv.Reader 解析 CSV 數據，使用 validateRecord 驗證每條記錄，并存儲有效記錄。
- validateRecord 函數旨在根據簡單的規則驗證每條 CSV 記錄：第一列必須可轉換為整數，第二列必須是非空字符串。
- saveValidData 函數獲取經過驗證的數據，并以 CSV 格式將其寫入指定的輸出文件。
- validateRecord 的模糊測試使用種子輸入來啟動模糊處理過程，用大量生成的輸入值來測試驗證邏輯，以發現潛在的邊緣情況或意外行為。
測試似乎一直在進行
fuzz: elapsed: 45s, execs: 7257 (0/sec), new interesting: 0 (total: 2)
fuzz: elapsed: 48s, execs: 7257 (0/sec), new interesting: 0 (total: 2)
fuzz: elapsed: 51s, execs: 7257 (0/sec), new interesting: 0 (total: 2)
fuzz: elapsed: 54s, execs: 7257 (0/sec), new interesting: 0 (total: 2)
fuzz: elapsed: 57s, execs: 7257 (0/sec), new interesting: 0 (total: 2)
fuzz: elapsed: 1m0s, execs: 7257 (0/sec), new interesting: 0 (total: 2)
fuzz: elapsed: 1m3s, execs: 7848 (197/sec), new interesting: 4 (total: 6)
fuzz: elapsed: 1m6s, execs: 9301 (484/sec), new interesting: 4 (total: 6)
fuzz: elapsed: 1m9s, execs: 11457 (718/sec), new interesting: 4 (total: 6)
fuzz: elapsed: 1m12s, execs: 14485 (1009/sec), new interesting: 4 (total: 6)
fuzz: elapsed: 1m15s, execs: 16927 (814/sec), new interesting: 4 (total: 6)當模糊測試似乎無限期或長時間運行時，通常意味著它在不斷生成和測試新的輸入。模糊測試是一個密集的過程，會消耗大量時間和資源，尤其是當被測功能涉及復雜操作或模糊器發現許多"有趣"的輸入，從而探索出新的代碼路徑時。
以下是可以采取的幾個步驟，用于管理和減少長時間運行的模糊測試：
1.限制模糊測試時間
可以在運行模糊測試時使用 -fuzztime 標志來限制模糊測試的持續時間。例如，要使模糊測試最多運行 1 分鐘，可以使用：
go test -fuzz=FuzzSaveDataHandler -fuzztime=1m2.審查和優化測試代碼
如果代碼的某些部分特別慢或消耗資源，請考慮盡可能對其進行優化。由于模糊測試會產生大量請求，即使代碼效率稍微低一點，也會被放大。
3.調整種子語料庫
檢查提供給模糊器的種子語料庫，確保其多樣性足以探索各種代碼路徑，但又不會過于寬泛，導致模糊器陷入過多路徑。有時，過于通用的種子會導致模糊器在無益路徑上花費過多時間。
4.監控"有趣的"輸入
模糊器會報告覆蓋新代碼路徑或觸發獨特行為的"有趣"輸入。如果"有趣"輸入的數量大幅增加，則可能表明模糊器正在不斷發現新的探索場景。查看這些輸入可以深入了解代碼中的潛在邊緣情況或意外行為。
5.分析模糊器性能
輸出顯示了每秒執行次數，可以讓我們了解模糊器的運行效率。如果執行率很低，可能說明模糊器設置或被測代碼存在性能瓶頸。調查并解決這些瓶頸有助于提高模糊器的效率。
6.考慮手動中斷
如果模糊測試運行時間過長而沒有提供額外價值（例如，沒有發現新的有趣案例，或者已經從當前運行中獲得了足夠信息），可以手動停止該進程，然后查看迄今為止獲得的結果，以決定下一步行動（例如調整模糊參數或調查已發現的案例）。
