github.com/mikelsr/quic-go@v0.36.1-0.20230701132136-1d9415b66898/fuzzing/header/cmd/corpus.go (about)

     1  package main
     2  
     3  import (
     4  	"log"
     5  	"math/rand"
     6  
     7  	"github.com/mikelsr/quic-go/fuzzing/header"
     8  	"github.com/mikelsr/quic-go/fuzzing/internal/helper"
     9  	"github.com/mikelsr/quic-go/internal/protocol"
    10  	"github.com/mikelsr/quic-go/internal/wire"
    11  )
    12  
    13  const version = protocol.Version1
    14  
    15  func getRandomData(l int) []byte {
    16  	b := make([]byte, l)
    17  	rand.Read(b)
    18  	return b
    19  }
    20  
    21  func getVNP(src, dest protocol.ArbitraryLenConnectionID, numVersions int) []byte {
    22  	versions := make([]protocol.VersionNumber, numVersions)
    23  	for i := 0; i < numVersions; i++ {
    24  		versions[i] = protocol.VersionNumber(rand.Uint32())
    25  	}
    26  	return wire.ComposeVersionNegotiation(src, dest, versions)
    27  }
    28  
    29  func main() {
    30  	headers := []wire.Header{
    31  		{ // Initial without token
    32  			SrcConnectionID:  protocol.ParseConnectionID(getRandomData(3)),
    33  			DestConnectionID: protocol.ParseConnectionID(getRandomData(8)),
    34  			Type:             protocol.PacketTypeInitial,
    35  			Length:           protocol.ByteCount(rand.Intn(1000)),
    36  			Version:          version,
    37  		},
    38  		{ // Initial without token, with zero-length src conn id
    39  			DestConnectionID: protocol.ParseConnectionID(getRandomData(8)),
    40  			Type:             protocol.PacketTypeInitial,
    41  			Length:           protocol.ByteCount(rand.Intn(1000)),
    42  			Version:          version,
    43  		},
    44  		{ // Initial with Token
    45  			SrcConnectionID:  protocol.ParseConnectionID(getRandomData(10)),
    46  			DestConnectionID: protocol.ParseConnectionID(getRandomData(19)),
    47  			Type:             protocol.PacketTypeInitial,
    48  			Length:           protocol.ByteCount(rand.Intn(1000)),
    49  			Version:          version,
    50  			Token:            getRandomData(25),
    51  		},
    52  		{ // Handshake packet
    53  			SrcConnectionID:  protocol.ParseConnectionID(getRandomData(5)),
    54  			DestConnectionID: protocol.ParseConnectionID(getRandomData(10)),
    55  			Type:             protocol.PacketTypeHandshake,
    56  			Length:           protocol.ByteCount(rand.Intn(1000)),
    57  			Version:          version,
    58  		},
    59  		{ // Handshake packet, with zero-length src conn id
    60  			DestConnectionID: protocol.ParseConnectionID(getRandomData(12)),
    61  			Type:             protocol.PacketTypeHandshake,
    62  			Length:           protocol.ByteCount(rand.Intn(1000)),
    63  			Version:          version,
    64  		},
    65  		{ // 0-RTT packet
    66  			SrcConnectionID:  protocol.ParseConnectionID(getRandomData(8)),
    67  			DestConnectionID: protocol.ParseConnectionID(getRandomData(9)),
    68  			Type:             protocol.PacketType0RTT,
    69  			Length:           protocol.ByteCount(rand.Intn(1000)),
    70  			Version:          version,
    71  		},
    72  		{ // Retry Packet, with empty orig dest conn id
    73  			SrcConnectionID:  protocol.ParseConnectionID(getRandomData(8)),
    74  			DestConnectionID: protocol.ParseConnectionID(getRandomData(9)),
    75  			Type:             protocol.PacketTypeRetry,
    76  			Token:            getRandomData(1000),
    77  			Version:          version,
    78  		},
    79  	}
    80  
    81  	for _, h := range headers {
    82  		extHdr := &wire.ExtendedHeader{
    83  			Header:          h,
    84  			PacketNumberLen: protocol.PacketNumberLen(rand.Intn(4) + 1),
    85  			PacketNumber:    protocol.PacketNumber(rand.Uint64()),
    86  		}
    87  		b, err := extHdr.Append(nil, version)
    88  		if err != nil {
    89  			log.Fatal(err)
    90  		}
    91  		if h.Type == protocol.PacketTypeRetry {
    92  			b = append(b, []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}...)
    93  		}
    94  		if h.Length > 0 {
    95  			b = append(b, make([]byte, h.Length)...)
    96  		}
    97  
    98  		if err := helper.WriteCorpusFileWithPrefix("corpus", b, header.PrefixLen); err != nil {
    99  			log.Fatal(err)
   100  		}
   101  	}
   102  
   103  	// short header
   104  	b, err := wire.AppendShortHeader(nil, protocol.ParseConnectionID(getRandomData(8)), 1337, protocol.PacketNumberLen2, protocol.KeyPhaseOne)
   105  	if err != nil {
   106  		log.Fatal(err)
   107  	}
   108  	if err := helper.WriteCorpusFileWithPrefix("corpus", b, header.PrefixLen); err != nil {
   109  		log.Fatal(err)
   110  	}
   111  
   112  	vnps := [][]byte{
   113  		getVNP(
   114  			protocol.ArbitraryLenConnectionID(getRandomData(8)),
   115  			protocol.ArbitraryLenConnectionID(getRandomData(10)),
   116  			4,
   117  		),
   118  		getVNP(
   119  			protocol.ArbitraryLenConnectionID(getRandomData(10)),
   120  			protocol.ArbitraryLenConnectionID(getRandomData(5)),
   121  			0,
   122  		),
   123  		getVNP(
   124  			protocol.ArbitraryLenConnectionID(getRandomData(3)),
   125  			protocol.ArbitraryLenConnectionID(getRandomData(19)),
   126  			100,
   127  		),
   128  		getVNP(
   129  			protocol.ArbitraryLenConnectionID(getRandomData(3)),
   130  			nil,
   131  			20,
   132  		),
   133  		getVNP(
   134  			nil,
   135  			protocol.ArbitraryLenConnectionID(getRandomData(10)),
   136  			5,
   137  		),
   138  	}
   139  
   140  	for _, vnp := range vnps {
   141  		if err := helper.WriteCorpusFileWithPrefix("corpus", vnp, header.PrefixLen); err != nil {
   142  			log.Fatal(err)
   143  		}
   144  	}
   145  }