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

     1  package main
     2  
     3  import (
     4  	"crypto/tls"
     5  	"log"
     6  
     7  	fuzzhandshake "github.com/mikelsr/quic-go/fuzzing/handshake"
     8  	"github.com/mikelsr/quic-go/fuzzing/internal/helper"
     9  	"github.com/mikelsr/quic-go/internal/handshake"
    10  	"github.com/mikelsr/quic-go/internal/protocol"
    11  	"github.com/mikelsr/quic-go/internal/testdata"
    12  	"github.com/mikelsr/quic-go/internal/utils"
    13  	"github.com/mikelsr/quic-go/internal/wire"
    14  )
    15  
    16  type chunk struct {
    17  	data     []byte
    18  	encLevel protocol.EncryptionLevel
    19  }
    20  
    21  type stream struct {
    22  	chunkChan chan<- chunk
    23  	encLevel  protocol.EncryptionLevel
    24  }
    25  
    26  func (s *stream) Write(b []byte) (int, error) {
    27  	data := append([]byte{}, b...)
    28  	select {
    29  	case s.chunkChan <- chunk{data: data, encLevel: s.encLevel}:
    30  	default:
    31  		panic("chunkChan too small")
    32  	}
    33  	return len(b), nil
    34  }
    35  
    36  func initStreams() (chan chunk, *stream /* initial */, *stream /* handshake */) {
    37  	chunkChan := make(chan chunk, 10)
    38  	initialStream := &stream{chunkChan: chunkChan, encLevel: protocol.EncryptionInitial}
    39  	handshakeStream := &stream{chunkChan: chunkChan, encLevel: protocol.EncryptionHandshake}
    40  	return chunkChan, initialStream, handshakeStream
    41  }
    42  
    43  type handshakeRunner interface {
    44  	OnReceivedParams(*wire.TransportParameters)
    45  	OnHandshakeComplete()
    46  	OnReceivedReadKeys()
    47  	DropKeys(protocol.EncryptionLevel)
    48  }
    49  
    50  type runner struct {
    51  	handshakeComplete chan<- struct{}
    52  }
    53  
    54  var _ handshakeRunner = &runner{}
    55  
    56  func newRunner(handshakeComplete chan<- struct{}) *runner {
    57  	return &runner{handshakeComplete: handshakeComplete}
    58  }
    59  
    60  func (r *runner) OnReceivedParams(*wire.TransportParameters) {}
    61  func (r *runner) OnReceivedReadKeys()                        {}
    62  func (r *runner) OnHandshakeComplete() {
    63  	close(r.handshakeComplete)
    64  }
    65  func (r *runner) DropKeys(protocol.EncryptionLevel) {}
    66  
    67  const alpn = "fuzz"
    68  
    69  func main() {
    70  	cChunkChan, cInitialStream, cHandshakeStream := initStreams()
    71  	var client, server handshake.CryptoSetup
    72  	clientHandshakeCompleted := make(chan struct{})
    73  	client, _ = handshake.NewCryptoSetupClient(
    74  		cInitialStream,
    75  		cHandshakeStream,
    76  		nil,
    77  		protocol.ConnectionID{},
    78  		&wire.TransportParameters{ActiveConnectionIDLimit: 2},
    79  		newRunner(clientHandshakeCompleted),
    80  		&tls.Config{
    81  			MinVersion:         tls.VersionTLS13,
    82  			ServerName:         "localhost",
    83  			NextProtos:         []string{alpn},
    84  			RootCAs:            testdata.GetRootCA(),
    85  			ClientSessionCache: tls.NewLRUClientSessionCache(1),
    86  		},
    87  		false,
    88  		utils.NewRTTStats(),
    89  		nil,
    90  		utils.DefaultLogger.WithPrefix("client"),
    91  		protocol.Version1,
    92  	)
    93  
    94  	sChunkChan, sInitialStream, sHandshakeStream := initStreams()
    95  	config := testdata.GetTLSConfig()
    96  	config.NextProtos = []string{alpn}
    97  	serverHandshakeCompleted := make(chan struct{})
    98  	server = handshake.NewCryptoSetupServer(
    99  		sInitialStream,
   100  		sHandshakeStream,
   101  		nil,
   102  		protocol.ConnectionID{},
   103  		&wire.TransportParameters{ActiveConnectionIDLimit: 2},
   104  		newRunner(serverHandshakeCompleted),
   105  		config,
   106  		false,
   107  		utils.NewRTTStats(),
   108  		nil,
   109  		utils.DefaultLogger.WithPrefix("server"),
   110  		protocol.Version1,
   111  	)
   112  
   113  	if err := client.StartHandshake(); err != nil {
   114  		log.Fatal(err)
   115  	}
   116  
   117  	if err := server.StartHandshake(); err != nil {
   118  		log.Fatal(err)
   119  	}
   120  
   121  	done := make(chan struct{})
   122  	go func() {
   123  		<-serverHandshakeCompleted
   124  		<-clientHandshakeCompleted
   125  		close(done)
   126  	}()
   127  
   128  	var messages [][]byte
   129  messageLoop:
   130  	for {
   131  		select {
   132  		case c := <-cChunkChan:
   133  			messages = append(messages, c.data)
   134  			if err := server.HandleMessage(c.data, c.encLevel); err != nil {
   135  				log.Fatal(err)
   136  			}
   137  		case c := <-sChunkChan:
   138  			messages = append(messages, c.data)
   139  			if err := client.HandleMessage(c.data, c.encLevel); err != nil {
   140  				log.Fatal(err)
   141  			}
   142  		case <-done:
   143  			break messageLoop
   144  		}
   145  	}
   146  
   147  	ticket, err := server.GetSessionTicket()
   148  	if err != nil {
   149  		log.Fatal(err)
   150  	}
   151  	if ticket == nil {
   152  		log.Fatal("expected a session ticket")
   153  	}
   154  	messages = append(messages, ticket)
   155  
   156  	for _, m := range messages {
   157  		if err := helper.WriteCorpusFileWithPrefix("corpus", m, fuzzhandshake.PrefixLen); err != nil {
   158  			log.Fatal(err)
   159  		}
   160  	}
   161  }