From 21b9ef03beb51db37a26119e319c96d03a7829d4 Mon Sep 17 00:00:00 2001 From: Marten Seemann Date: Sun, 28 Aug 2022 13:28:11 +0300 Subject: [PATCH] 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 | 13 ++++++++ internal/protocol/connection_id_test.go | 15 +++++++++ internal/wire/header.go | 38 +++++++++++++++++++++ internal/wire/header_test.go | 44 +++++++++++++++++++++++++ 4 files changed, 110 insertions(+) diff --git a/internal/protocol/connection_id.go b/internal/protocol/connection_id.go index 7ae7d9dc..7dce4c5c 100644 --- a/internal/protocol/connection_id.go +++ b/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 diff --git a/internal/protocol/connection_id_test.go b/internal/protocol/connection_id_test.go index 345e656c..e62506c4 100644 --- a/internal/protocol/connection_id_test.go +++ b/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)) + }) + }) }) diff --git a/internal/wire/header.go b/internal/wire/header.go index d08df0f7..4c7eb926 100644 --- a/internal/wire/header.go +++ b/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 diff --git a/internal/wire/header_test.go b/internal/wire/header_test.go index 12a3a211..b0149f28 100644 --- a/internal/wire/header_test.go +++ b/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())