export seed corpus files using the SHA1 of the content as the filename

.gitignore

@@ -11,7 +11,3 @@ fuzzing/*/crashers
 fuzzing/*/sonarprofile
 fuzzing/*/suppressions
 fuzzing/*/corpus/
-fuzzing/*-fuzz.zip
-!fuzzing/frames/single-frame*
-!fuzzing/frames/multiple-frame*
-!fuzzing/header/header*

fuzzing/frames/cmd/corpus.go

@@ -2,12 +2,12 @@ package main
 
 import (
 	"bytes"
-	"fmt"
+	"log"
 	"math/rand"
-	"os"
 	"time"
 
 	"github.com/lucas-clemente/quic-go"
+	"github.com/lucas-clemente/quic-go/fuzzing/internal/helper"
 	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/qerr"
 	"github.com/lucas-clemente/quic-go/internal/wire"
@@ -246,19 +246,17 @@ func getFrames() []wire.Frame {
 }
 
 func main() {
-	rand.Seed(42)
-
-	for i, f := range getFrames() {
+	for _, f := range getFrames() {
 		b := &bytes.Buffer{}
 		if err := f.Write(b, version); err != nil {
-			panic(err)
+			log.Fatal(err)
 		}
-		if err := writeCorpusFile(fmt.Sprintf("single-frame-%d", i), b.Bytes()); err != nil {
-			panic(err)
+		if err := helper.WriteCorpusFileWithPrefix("corpus", b.Bytes(), 1); err != nil {
+			log.Fatal(err)
 		}
 	}
 
-	for i := 0; i < 25; i++ {
+	for i := 0; i < 30; i++ {
 		frames := getFrames()
 
 		b := &bytes.Buffer{}
@@ -268,26 +266,14 @@ func main() {
 			}
 			f := frames[rand.Intn(len(frames))]
 			if err := f.Write(b, version); err != nil {
-				panic(err)
+				log.Fatal(err)
 			}
 			if rand.Intn(10) == 0 { // write a PADDING frame
 				b.WriteByte(0x0)
 			}
 		}
-		if err := writeCorpusFile(fmt.Sprintf("multiple-frames-%d", i), b.Bytes()); err != nil {
-			panic(err)
+		if err := helper.WriteCorpusFileWithPrefix("corpus", b.Bytes(), 1); err != nil {
+			log.Fatal(err)
 		}
 	}
 }
-
-func writeCorpusFile(name string, data []byte) error {
-	file, err := os.Create("corpus/" + name)
-	if err != nil {
-		return err
-	}
-	data = append(getRandomData(1), data...)
-	if _, err := file.Write(data); err != nil {
-		return err
-	}
-	return file.Close()
-}

fuzzing/frames/fuzz.go

@@ -8,27 +8,34 @@ import (
 	"github.com/lucas-clemente/quic-go/internal/wire"
 )
 
+const version = protocol.VersionTLS
+
+// PrefixLen is the number of bytes used for configuration
+const PrefixLen = 1
+
+func toEncLevel(v uint8) protocol.EncryptionLevel {
+	switch v % 3 {
+	default:
+		return protocol.EncryptionInitial
+	case 1:
+		return protocol.EncryptionHandshake
+	case 2:
+		return protocol.Encryption1RTT
+	}
+}
+
+// Fuzz fuzzes the QUIC frames.
 //go:generate go run ./cmd/corpus.go
 func Fuzz(data []byte) int {
-	const version = protocol.VersionTLS
-
-	if len(data) < 1 {
+	if len(data) < PrefixLen {
 		return 0
 	}
+	encLevel := toEncLevel(data[0])
+	data = data[PrefixLen:]
+
 	parser := wire.NewFrameParser(version)
 	parser.SetAckDelayExponent(protocol.DefaultAckDelayExponent)
 
-	var encLevel protocol.EncryptionLevel
-	switch data[0] % 3 {
-	case 0:
-		encLevel = protocol.EncryptionInitial
-	case 1:
-		encLevel = protocol.EncryptionHandshake
-	case 2:
-		encLevel = protocol.Encryption1RTT
-	}
-
-	data = data[1:]
 	r := bytes.NewReader(data)
 	initialLen := r.Len()
 

fuzzing/header/cmd/corpus.go

@@ -2,10 +2,11 @@ package main
 
 import (
 	"bytes"
-	"fmt"
+	"log"
 	"math/rand"
-	"os"
 
+	"github.com/lucas-clemente/quic-go/fuzzing/header"
+	"github.com/lucas-clemente/quic-go/fuzzing/internal/helper"
 	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/wire"
 )
@@ -25,31 +26,29 @@ func getVNP(src, dest protocol.ConnectionID, numVersions int) []byte {
 	}
 	data, err := wire.ComposeVersionNegotiation(src, dest, versions)
 	if err != nil {
-		panic(err)
+		log.Fatal(err)
 	}
 	return data
 }
 
 func main() {
-	rand.Seed(1337)
-
 	headers := []wire.Header{
-		wire.Header{ // Initial without token
+		{ // Initial without token
 			IsLongHeader:     true,
 			SrcConnectionID:  protocol.ConnectionID(getRandomData(3)),
 			DestConnectionID: protocol.ConnectionID(getRandomData(8)),
 			Type:             protocol.PacketTypeInitial,
 			Length:           protocol.ByteCount(rand.Intn(1000)),
 			Version:          version,
 		},
-		wire.Header{ // Initial without token, with zero-length src conn id
+		{ // Initial without token, with zero-length src conn id
 			IsLongHeader:     true,
 			DestConnectionID: protocol.ConnectionID(getRandomData(8)),
 			Type:             protocol.PacketTypeInitial,
 			Length:           protocol.ByteCount(rand.Intn(1000)),
 			Version:          version,
 		},
-		wire.Header{ // Initial with Token
+		{ // Initial with Token
 			IsLongHeader:     true,
 			SrcConnectionID:  protocol.ConnectionID(getRandomData(10)),
 			DestConnectionID: protocol.ConnectionID(getRandomData(19)),
@@ -58,51 +57,51 @@ func main() {
 			Version:          version,
 			Token:            getRandomData(25),
 		},
-		wire.Header{ // Handshake packet
+		{ // Handshake packet
 			IsLongHeader:     true,
 			SrcConnectionID:  protocol.ConnectionID(getRandomData(5)),
 			DestConnectionID: protocol.ConnectionID(getRandomData(10)),
 			Type:             protocol.PacketTypeHandshake,
 			Length:           protocol.ByteCount(rand.Intn(1000)),
 			Version:          version,
 		},
-		wire.Header{ // Handshake packet, with zero-length src conn id
+		{ // Handshake packet, with zero-length src conn id
 			IsLongHeader:     true,
 			DestConnectionID: protocol.ConnectionID(getRandomData(12)),
 			Type:             protocol.PacketTypeHandshake,
 			Length:           protocol.ByteCount(rand.Intn(1000)),
 			Version:          version,
 		},
-		wire.Header{ // 0-RTT packet
+		{ // 0-RTT packet
 			IsLongHeader:     true,
 			SrcConnectionID:  protocol.ConnectionID(getRandomData(8)),
 			DestConnectionID: protocol.ConnectionID(getRandomData(9)),
 			Type:             protocol.PacketType0RTT,
 			Length:           protocol.ByteCount(rand.Intn(1000)),
 			Version:          version,
 		},
-		wire.Header{ // Retry Packet, with empty orig dest conn id
+		{ // Retry Packet, with empty orig dest conn id
 			IsLongHeader:     true,
 			SrcConnectionID:  protocol.ConnectionID(getRandomData(8)),
 			DestConnectionID: protocol.ConnectionID(getRandomData(9)),
 			Type:             protocol.PacketTypeRetry,
 			Token:            getRandomData(1000),
 			Version:          version,
 		},
-		wire.Header{ // Short-Header
+		{ // Short-Header
 			DestConnectionID: protocol.ConnectionID(getRandomData(8)),
 		},
 	}
 
-	for i, h := range headers {
+	for _, h := range headers {
 		extHdr := &wire.ExtendedHeader{
 			Header:          h,
 			PacketNumberLen: protocol.PacketNumberLen(rand.Intn(4) + 1),
 			PacketNumber:    protocol.PacketNumber(rand.Uint64()),
 		}
 		b := &bytes.Buffer{}
 		if err := extHdr.Write(b, version); err != nil {
-			panic(err)
+			log.Fatal(err)
 		}
 		if h.Type == protocol.PacketTypeRetry {
 			b.Write([]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16})
@@ -111,8 +110,8 @@ func main() {
 			b.Write(make([]byte, h.Length))
 		}
 
-		if err := writeCorpusFile(fmt.Sprintf("header-%d", i), b.Bytes()); err != nil {
-			panic(err)
+		if err := helper.WriteCorpusFileWithPrefix("corpus", b.Bytes(), header.PrefixLen); err != nil {
+			log.Fatal(err)
 		}
 	}
 
@@ -144,22 +143,9 @@ func main() {
 		),
 	}
 
-	for i, vnp := range vnps {
-		if err := writeCorpusFile(fmt.Sprintf("vnp-%d", i), vnp); err != nil {
-			panic(err)
+	for _, vnp := range vnps {
+		if err := helper.WriteCorpusFileWithPrefix("corpus", vnp, header.PrefixLen); err != nil {
+			log.Fatal(err)
 		}
 	}
-
-}
-
-func writeCorpusFile(name string, data []byte) error {
-	file, err := os.Create("corpus/" + name)
-	if err != nil {
-		return err
-	}
-	data = append(getRandomData(1), data...)
-	if _, err := file.Write(data); err != nil {
-		return err
-	}
-	return file.Close()
 }

fuzzing/header/fuzz.go

@@ -10,13 +10,17 @@ import (
 
 const version = protocol.VersionTLS
 
+// PrefixLen is the number of bytes used for configuration
+const PrefixLen = 1
+
+// Fuzz fuzzes the QUIC header.
 //go:generate go run ./cmd/corpus.go
 func Fuzz(data []byte) int {
-	if len(data) < 1 {
+	if len(data) < PrefixLen {
 		return 0
 	}
 	connIDLen := int(data[0] % 21)
-	data = data[1:]
+	data = data[PrefixLen:]
 
 	if wire.IsVersionNegotiationPacket(data) {
 		return fuzzVNP(data)