gr1ffon/quic-go
1
0
Fork 0
forked from quic-go/quic-go
Code Pull Requests Activity

don't pass the client's version to the header parser

Browse Source
This commit is contained in:
Marten Seemann
2018-05-21 11:27:15 +08:00
parent 797dfa57a1
commit 372463db49
6 changed files with 18 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
client.go
View File

@@ -304,7 +304,7 @@ func (c *client) handlePacket(remoteAddr net.Addr, packet []byte) error {
rcvTime := time.Now()
r := bytes.NewReader(packet)
hdr, err := wire.ParseHeaderSentByServer(r, c.version)
hdr, err := wire.ParseHeaderSentByServer(r)
// drop the packet if we can't parse the header
if err != nil {
return fmt.Errorf("error parsing packet from %s: %s", remoteAddr.String(), err.Error())

9
internal/wire/header.go
View File

@@ -39,7 +39,7 @@ type Header struct {
}
// ParseHeaderSentByServer parses the header for a packet that was sent by the server.
func ParseHeaderSentByServer(b *bytes.Reader, version protocol.VersionNumber) (*Header, error) {
func ParseHeaderSentByServer(b *bytes.Reader) (*Header, error) {
typeByte, err := b.ReadByte()
if err != nil {
return nil, err
@@ -49,13 +49,10 @@ func ParseHeaderSentByServer(b *bytes.Reader, version protocol.VersionNumber) (*
var isPublicHeader bool
if typeByte&0x80 > 0 { // gQUIC always has 0x80 unset. IETF Long Header or Version Negotiation
isPublicHeader = false
} else if typeByte&0xcf == 0x9 { // gQUIC Version Negotiation Packet
isPublicHeader = true
} else {
// the client knows the version that this packet was sent with
isPublicHeader = !version.UsesTLS()
// gQUIC never uses 6 byte packet numbers, so the third and fourth bit will never be 11
isPublicHeader = typeByte&0x30 != 0x30
}
return parsePacketHeader(b, protocol.PerspectiveServer, isPublicHeader)
}

14
internal/wire/header_test.go
View File

@@ -68,7 +68,7 @@ var _ = Describe("Header", func() {
PacketNumber: 0x42,
}).writeHeader(buf)
Expect(err).ToNot(HaveOccurred())
hdr, err := ParseHeaderSentByServer(bytes.NewReader(buf.Bytes()), versionIETFHeader)
hdr, err := ParseHeaderSentByServer(bytes.NewReader(buf.Bytes()))
Expect(err).ToNot(HaveOccurred())
Expect(hdr.IsPublicHeader).To(BeFalse())
})
@@ -94,7 +94,7 @@ var _ = Describe("Header", func() {
Expect(hdr.IsPublicHeader).To(BeTrue())
})
It("parses a gQUIC Public Header, when the version is known", func() {
It("parses a gQUIC Public Header", func() {
connID := protocol.ConnectionID{8, 7, 6, 5, 4, 3, 2, 1}
buf := &bytes.Buffer{}
err := (&Header{
@@ -105,7 +105,7 @@ var _ = Describe("Header", func() {
DiversificationNonce: bytes.Repeat([]byte{'f'}, 32),
}).writePublicHeader(buf, protocol.PerspectiveServer, versionPublicHeader)
Expect(err).ToNot(HaveOccurred())
hdr, err := ParseHeaderSentByServer(bytes.NewReader(buf.Bytes()), versionPublicHeader)
hdr, err := ParseHeaderSentByServer(bytes.NewReader(buf.Bytes()))
Expect(err).ToNot(HaveOccurred())
Expect(hdr.DestConnectionID).To(Equal(connID))
Expect(hdr.SrcConnectionID).To(Equal(connID))
@@ -130,7 +130,7 @@ var _ = Describe("Header", func() {
})
It("errors when given no data", func() {
_, err := ParseHeaderSentByServer(bytes.NewReader([]byte{}), protocol.VersionUnknown)
_, err := ParseHeaderSentByServer(bytes.NewReader([]byte{}))
Expect(err).To(MatchError(io.EOF))
_, err = ParseHeaderSentByClient(bytes.NewReader([]byte{}))
Expect(err).To(MatchError(io.EOF))
@@ -140,7 +140,7 @@ var _ = Describe("Header", func() {
connID := protocol.ConnectionID{0xde, 0xca, 0xfb, 0xad, 0xde, 0xca, 0xfb, 0xad}
versions := []protocol.VersionNumber{0x13, 0x37}
data := ComposeGQUICVersionNegotiation(connID, versions)
hdr, err := ParseHeaderSentByServer(bytes.NewReader(data), protocol.VersionUnknown)
hdr, err := ParseHeaderSentByServer(bytes.NewReader(data))
Expect(err).ToNot(HaveOccurred())
Expect(hdr.IsPublicHeader).To(BeTrue())
Expect(hdr.DestConnectionID).To(Equal(connID))
@@ -157,7 +157,7 @@ var _ = Describe("Header", func() {
versions := []protocol.VersionNumber{0x13, 0x37}
data, err := ComposeVersionNegotiation(destConnID, srcConnID, versions)
Expect(err).ToNot(HaveOccurred())
hdr, err := ParseHeaderSentByServer(bytes.NewReader(data), protocol.VersionUnknown)
hdr, err := ParseHeaderSentByServer(bytes.NewReader(data))
Expect(err).ToNot(HaveOccurred())
Expect(hdr.IsPublicHeader).To(BeFalse())
Expect(hdr.IsVersionNegotiation).To(BeTrue())
@@ -199,7 +199,7 @@ var _ = Describe("Header", func() {
}
err := hdr.Write(buf, protocol.PerspectiveServer, versionIETFHeader)
Expect(err).ToNot(HaveOccurred())
_, err = ParseHeaderSentByServer(bytes.NewReader(buf.Bytes()), versionIETFFrames)
_, err = ParseHeaderSentByServer(bytes.NewReader(buf.Bytes()))
Expect(err).ToNot(HaveOccurred())
Expect(hdr.IsPublicHeader).To(BeFalse())
})

4
packet_packer_test.go
View File

@@ -265,7 +265,7 @@ var _ = Describe("Packet packer", func() {
Expect(err).ToNot(HaveOccurred())
// parse the packet
r := bytes.NewReader(p.raw)
hdr, err := wire.ParseHeaderSentByServer(r, packer.version)
hdr, err := wire.ParseHeaderSentByServer(r)
Expect(err).ToNot(HaveOccurred())
Expect(hdr.PayloadLen).To(BeEquivalentTo(r.Len()))
})
@@ -614,7 +614,7 @@ var _ = Describe("Packet packer", func() {
Expect(p.header.IsLongHeader).To(BeTrue())
// parse the packet
r := bytes.NewReader(p.raw)
hdr, err := wire.ParseHeaderSentByServer(r, packer.version)
hdr, err := wire.ParseHeaderSentByServer(r)
Expect(err).ToNot(HaveOccurred())
Expect(hdr.PayloadLen).To(BeEquivalentTo(r.Len()))
})

4
server_test.go
View File

@@ -571,7 +571,7 @@ var _ = Describe("Server", func() {
Eventually(func() int { return conn.dataWritten.Len() }).ShouldNot(BeZero())
Expect(conn.dataWrittenTo).To(Equal(udpAddr))
r := bytes.NewReader(conn.dataWritten.Bytes())
packet, err := wire.ParseHeaderSentByServer(r, protocol.VersionUnknown)
packet, err := wire.ParseHeaderSentByServer(r)
Expect(err).ToNot(HaveOccurred())
Expect(packet.VersionFlag).To(BeTrue())
Expect(packet.DestConnectionID).To(Equal(connID))
@@ -614,7 +614,7 @@ var _ = Describe("Server", func() {
Eventually(func() int { return conn.dataWritten.Len() }).ShouldNot(BeZero())
Expect(conn.dataWrittenTo).To(Equal(udpAddr))
r := bytes.NewReader(conn.dataWritten.Bytes())
packet, err := wire.ParseHeaderSentByServer(r, protocol.VersionUnknown)
packet, err := wire.ParseHeaderSentByServer(r)
Expect(err).ToNot(HaveOccurred())
Expect(packet.IsVersionNegotiation).To(BeTrue())
Expect(packet.DestConnectionID).To(Equal(connID))

6
server_tls_test.go
View File

@@ -71,7 +71,7 @@ var _ = Describe("Stateless TLS handling", func() {
unpackPacket := func(data []byte) (*wire.Header, []byte) {
r := bytes.NewReader(conn.dataWritten.Bytes())
hdr, err := wire.ParseHeaderSentByServer(r, protocol.VersionTLS)
hdr, err := wire.ParseHeaderSentByServer(r)
Expect(err).ToNot(HaveOccurred())
hdr.Raw = data[:len(data)-r.Len()]
aead, err := crypto.NewNullAEAD(protocol.PerspectiveClient, hdr.SrcConnectionID, protocol.VersionTLS)
@@ -89,7 +89,7 @@ var _ = Describe("Stateless TLS handling", func() {
}
server.HandleInitial(nil, hdr, bytes.Repeat([]byte{0}, protocol.MinInitialPacketSize))
Expect(conn.dataWritten.Len()).ToNot(BeZero())
hdr, err := wire.ParseHeaderSentByServer(bytes.NewReader(conn.dataWritten.Bytes()), protocol.VersionUnknown)
hdr, err := wire.ParseHeaderSentByServer(bytes.NewReader(conn.dataWritten.Bytes()))
Expect(err).ToNot(HaveOccurred())
Expect(hdr.IsVersionNegotiation).To(BeTrue())
Expect(sessionChan).ToNot(Receive())
@@ -118,7 +118,7 @@ var _ = Describe("Stateless TLS handling", func() {
server.HandleInitial(nil, hdr, data)
Expect(conn.dataWritten.Len()).ToNot(BeZero())
r := bytes.NewReader(conn.dataWritten.Bytes())
replyHdr, err := wire.ParseHeaderSentByServer(r, protocol.VersionTLS)
replyHdr, err := wire.ParseHeaderSentByServer(r)
Expect(err).ToNot(HaveOccurred())
Expect(replyHdr.Type).To(Equal(protocol.PacketTypeRetry))
Expect(replyHdr.SrcConnectionID).To(Equal(hdr.DestConnectionID))