add a type for arbitrary length Connection IDs, and parsing function

RFC 8999 allows Connection IDs of up to 255 bytes. Current QUIC versions
only use up to 20 bytes.

internal/protocol/connection_id.go

@@ -7,6 +7,19 @@ import (
 	"io"
 )
 
+// An ArbitraryLenConnectionID is a QUIC Connection ID able to represent Connection IDs according to RFC 8999.
+// Future QUIC versions might allow connection ID lengths up to 255 bytes, while QUIC v1
+// restricts the length to 20 bytes.
+type ArbitraryLenConnectionID []byte
+
+func (c ArbitraryLenConnectionID) Len() int {
+	return len(c)
+}
+
+func (c ArbitraryLenConnectionID) Bytes() []byte {
+	return c
+}
+
 // A ConnectionID in QUIC
 type ConnectionID []byte
 

internal/protocol/connection_id_test.go

@@ -2,6 +2,7 @@ package protocol
 
 import (
 	"bytes"
+	"crypto/rand"
 	"io"
 
 	. "github.com/onsi/ginkgo"
@@ -105,4 +106,18 @@ var _ = Describe("Connection ID generation", func() {
 		var c ConnectionID
 		Expect(c.String()).To(Equal("(empty)"))
 	})
+
+	Context("arbitrary length connection IDs", func() {
+		It("returns the bytes", func() {
+			b := make([]byte, 30)
+			rand.Read(b)
+			c := ArbitraryLenConnectionID(b)
+			Expect(c.Bytes()).To(Equal(b))
+		})
+
+		It("returns the length", func() {
+			c := ArbitraryLenConnectionID(make([]byte, 156))
+			Expect(c.Len()).To(Equal(156))
+		})
+	})
 })

internal/wire/header.go

@@ -35,6 +35,44 @@ func ParseConnectionID(data []byte, shortHeaderConnIDLen int) (protocol.Connecti
 	return protocol.ConnectionID(data[6 : 6+destConnIDLen]), nil
 }
 
+// ParseArbitraryLenConnectionIDs parses the most general form of a Long Header packet,
+// using only the version-independent packet format as described in Section 5.1 of RFC 8999:
+// https://datatracker.ietf.org/doc/html/rfc8999#section-5.1.
+// This function should only be called on Long Header packets for which we don't support the version.
+func ParseArbitraryLenConnectionIDs(data []byte) (bytesParsed int, dest, src protocol.ArbitraryLenConnectionID, _ error) {
+	r := bytes.NewReader(data)
+	remaining := r.Len()
+	src, dest, err := parseArbitraryLenConnectionIDs(r)
+	return remaining - r.Len(), src, dest, err
+}
+
+func parseArbitraryLenConnectionIDs(r *bytes.Reader) (dest, src protocol.ArbitraryLenConnectionID, _ error) {
+	r.Seek(5, io.SeekStart) // skip first byte and version field
+	destConnIDLen, err := r.ReadByte()
+	if err != nil {
+		return nil, nil, err
+	}
+	destConnID := make(protocol.ArbitraryLenConnectionID, destConnIDLen)
+	if _, err := io.ReadFull(r, destConnID); err != nil {
+		if err == io.ErrUnexpectedEOF {
+			err = io.EOF
+		}
+		return nil, nil, err
+	}
+	srcConnIDLen, err := r.ReadByte()
+	if err != nil {
+		return nil, nil, err
+	}
+	srcConnID := make(protocol.ArbitraryLenConnectionID, srcConnIDLen)
+	if _, err := io.ReadFull(r, srcConnID); err != nil {
+		if err == io.ErrUnexpectedEOF {
+			err = io.EOF
+		}
+		return nil, nil, err
+	}
+	return destConnID, srcConnID, nil
+}
+
 // IsLongHeaderPacket says if this is a Long Header packet
 func IsLongHeaderPacket(firstByte byte) bool {
 	return firstByte&0x80 > 0

internal/wire/header_test.go

@@ -2,8 +2,10 @@ package wire
 
 import (
 	"bytes"
+	"crypto/rand"
 	"encoding/binary"
 	"io"
+	mrand "math/rand"
 
 	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
@@ -130,6 +132,48 @@ var _ = Describe("Header Parsing", func() {
 		})
 	})
 
+	Context("parsing arbitrary length connection IDs", func() {
+		generateConnID := func(l int) protocol.ArbitraryLenConnectionID {
+			c := make(protocol.ArbitraryLenConnectionID, l)
+			rand.Read(c)
+			return c
+		}
+
+		generatePacket := func(src, dest protocol.ArbitraryLenConnectionID) []byte {
+			b := []byte{0x80, 1, 2, 3, 4}
+			b = append(b, uint8(dest.Len()))
+			b = append(b, dest.Bytes()...)
+			b = append(b, uint8(src.Len()))
+			b = append(b, src.Bytes()...)
+			return b
+		}
+
+		It("parses arbitrary length connection IDs", func() {
+			src := generateConnID(mrand.Intn(255) + 1)
+			dest := generateConnID(mrand.Intn(255) + 1)
+			b := generatePacket(src, dest)
+			l := len(b)
+			b = append(b, []byte("foobar")...) // add some payload
+
+			parsed, d, s, err := ParseArbitraryLenConnectionIDs(b)
+			Expect(parsed).To(Equal(l))
+			Expect(err).ToNot(HaveOccurred())
+			Expect(s).To(Equal(src))
+			Expect(d).To(Equal(dest))
+		})
+
+		It("errors on EOF", func() {
+			b := generatePacket(generateConnID(mrand.Intn(255)+1), generateConnID(mrand.Intn(255)+1))
+			_, _, _, err := ParseArbitraryLenConnectionIDs(b)
+			Expect(err).ToNot(HaveOccurred())
+
+			for i := range b {
+				_, _, _, err := ParseArbitraryLenConnectionIDs(b[:i])
+				Expect(err).To(MatchError(io.EOF))
+			}
+		})
+	})
+
 	Context("Identifying Version Negotiation Packets", func() {
 		It("identifies version negotiation packets", func() {
 			Expect(IsVersionNegotiationPacket([]byte{0x80 | 0x56, 0, 0, 0, 0})).To(BeTrue())