treat the connection ID as a big endian value

internal/crypto/key_derivation_quic_crypto.go

@@ -42,7 +42,7 @@ func deriveKeys(forwardSecure bool, sharedSecret, nonces []byte, connID protocol
 	} else {
 		info.Write([]byte("QUIC key expansion\x00"))
 	}
-	utils.LittleEndian.WriteUint64(&info, uint64(connID))
+	utils.BigEndian.WriteUint64(&info, uint64(connID))
 	info.Write(chlo)
 	info.Write(scfg)
 	info.Write(cert)

internal/crypto/key_derivation_quic_crypto_test.go

@@ -92,7 +92,7 @@ var _ = Describe("QUIC Crypto Key Derivation", func() {
 				false,
 				[]byte("0123456789012345678901"),
 				[]byte("nonce"),
-				protocol.ConnectionID(42),
+				protocol.ConnectionID(0x2a00000000000000), // this was 42 before the connection ID was changed to big endian
 				[]byte("chlo"),
 				[]byte("scfg"),
 				[]byte("cert"),
@@ -142,7 +142,7 @@ var _ = Describe("QUIC Crypto Key Derivation", func() {
 				false,
 				[]byte("0123456789012345678901"),
 				[]byte("nonce"),
-				protocol.ConnectionID(42),
+				protocol.ConnectionID(0x2a00000000000000), // this was 42 before the connection ID was changed to big endian
 				[]byte("chlo"),
 				[]byte("scfg"),
 				[]byte("cert"),
@@ -161,7 +161,7 @@ var _ = Describe("QUIC Crypto Key Derivation", func() {
 				true,
 				[]byte("0123456789012345678901"),
 				[]byte("nonce"),
-				protocol.ConnectionID(42),
+				protocol.ConnectionID(0x2a00000000000000), // this was 42 before the connection ID was changed to big endian
 				[]byte("chlo"),
 				[]byte("scfg"),
 				[]byte("cert"),
@@ -180,7 +180,7 @@ var _ = Describe("QUIC Crypto Key Derivation", func() {
 				true,
 				[]byte("0123456789012345678901"),
 				[]byte("nonce"),
-				protocol.ConnectionID(42),
+				protocol.ConnectionID(0x2a00000000000000), // this was 42 before the connection ID was changed to big endian
 				[]byte("chlo"),
 				[]byte("scfg"),
 				[]byte("cert"),

internal/wire/public_header.go

@@ -76,8 +76,7 @@ func (h *PublicHeader) Write(b *bytes.Buffer, version protocol.VersionNumber, pe
 	b.WriteByte(publicFlagByte)
 
 	if !h.OmitConnectionID {
-		// always read the connection ID in little endian
+		utils.BigEndian.WriteUint64(b, uint64(h.ConnectionID))
-		utils.LittleEndian.WriteUint64(b, uint64(h.ConnectionID))
 	}
 
 	if h.VersionFlag && pers == protocol.PerspectiveClient {
@@ -125,7 +124,7 @@ func PeekConnectionID(b *bytes.Reader, packetSentBy protocol.Perspective) (proto
 		return 0, errReceivedOmittedConnectionID
 	}
 	if !omitConnectionID {
-		connID, err := utils.LittleEndian.ReadUint64(b)
+		connID, err := utils.BigEndian.ReadUint64(b)
 		if err != nil {
 			return 0, err
 		}
@@ -182,8 +181,7 @@ func ParsePublicHeader(b *bytes.Reader, packetSentBy protocol.Perspective, versi
 	// Connection ID
 	if !header.OmitConnectionID {
 		var connID uint64
-		// always write the connection ID in little endian
+		connID, err = utils.BigEndian.ReadUint64(b)
-		connID, err = utils.LittleEndian.ReadUint64(b)
 		if err != nil {
 			return nil, err
 		}

internal/wire/public_header_test.go

@@ -20,7 +20,7 @@ var _ = Describe("Public Header", func() {
 		})
 
 		It("gets the connection ID", func() {
-			b := bytes.NewReader([]byte{0x09, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0x51, 0x30, 0x33, 0x34, 0x01})
+			b := bytes.NewReader([]byte{0x09, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6, 0x51, 0x30, 0x33, 0x34, 0x01})
 			len := b.Len()
 			connID, err := PeekConnectionID(b, protocol.PerspectiveClient)
 			Expect(err).ToNot(HaveOccurred())
@@ -52,7 +52,7 @@ var _ = Describe("Public Header", func() {
 
 	Context("when parsing", func() {
 		It("accepts a sample client header", func() {
-			b := bytes.NewReader([]byte{0x09, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0x51, 0x30, 0x33, 0x34, 0x01})
+			b := bytes.NewReader([]byte{0x09, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6, 0x51, 0x30, 0x33, 0x34, 0x01})
 			hdr, err := ParsePublicHeader(b, protocol.PerspectiveClient, protocol.VersionUnknown)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(hdr.VersionFlag).To(BeTrue())
@@ -99,7 +99,7 @@ var _ = Describe("Public Header", func() {
 			Expect(err).ToNot(HaveOccurred())
 			Expect(hdr.ResetFlag).To(BeTrue())
 			Expect(hdr.VersionFlag).To(BeFalse())
-			Expect(hdr.ConnectionID).To(Equal(protocol.ConnectionID(0x0807060504030201)))
+			Expect(hdr.ConnectionID).To(Equal(protocol.ConnectionID(0x0102030405060708)))
 		})
 
 		It("reads a diversification nonce sent by the server", func() {
@@ -120,7 +120,7 @@ var _ = Describe("Public Header", func() {
 		})
 
 		PIt("rejects diversification nonces sent by the client", func() {
-			b := bytes.NewReader([]byte{0x0c, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c,
+			b := bytes.NewReader([]byte{0x0c, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6,
 				0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1,
 				0x01,
 			})
@@ -186,7 +186,7 @@ var _ = Describe("Public Header", func() {
 				})
 
 				It("accepts 1-byte packet numbers", func() {
-					b := bytes.NewReader([]byte{0x08, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0xde})
+					b := bytes.NewReader([]byte{0x08, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6, 0xde})
 					hdr, err := ParsePublicHeader(b, protocol.PerspectiveClient, version)
 					Expect(err).ToNot(HaveOccurred())
 					Expect(hdr.PacketNumber).To(Equal(protocol.PacketNumber(0xde)))
@@ -195,7 +195,7 @@ var _ = Describe("Public Header", func() {
 				})
 
 				It("accepts 2-byte packet numbers", func() {
-					b := bytes.NewReader([]byte{0x18, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0xde, 0xca})
+					b := bytes.NewReader([]byte{0x18, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6, 0xde, 0xca})
 					hdr, err := ParsePublicHeader(b, protocol.PerspectiveClient, version)
 					Expect(err).ToNot(HaveOccurred())
 					Expect(hdr.PacketNumber).To(Equal(protocol.PacketNumber(0xcade)))
@@ -204,7 +204,7 @@ var _ = Describe("Public Header", func() {
 				})
 
 				It("accepts 4-byte packet numbers", func() {
-					b := bytes.NewReader([]byte{0x28, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0xad, 0xfb, 0xca, 0xde})
+					b := bytes.NewReader([]byte{0x28, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6, 0xad, 0xfb, 0xca, 0xde})
 					hdr, err := ParsePublicHeader(b, protocol.PerspectiveClient, version)
 					Expect(err).ToNot(HaveOccurred())
 					Expect(hdr.PacketNumber).To(Equal(protocol.PacketNumber(0xdecafbad)))
@@ -213,7 +213,7 @@ var _ = Describe("Public Header", func() {
 				})
 
 				It("accepts 6-byte packet numbers", func() {
-					b := bytes.NewReader([]byte{0x38, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0x23, 0x42, 0xad, 0xfb, 0xca, 0xde})
+					b := bytes.NewReader([]byte{0x38, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6, 0x23, 0x42, 0xad, 0xfb, 0xca, 0xde})
 					hdr, err := ParsePublicHeader(b, protocol.PerspectiveClient, version)
 					Expect(err).ToNot(HaveOccurred())
 					Expect(hdr.PacketNumber).To(Equal(protocol.PacketNumber(0xdecafbad4223)))
@@ -230,7 +230,7 @@ var _ = Describe("Public Header", func() {
 				})
 
 				It("accepts 1-byte packet numbers", func() {
-					b := bytes.NewReader([]byte{0x08, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0xde})
+					b := bytes.NewReader([]byte{0x08, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6, 0xde})
 					hdr, err := ParsePublicHeader(b, protocol.PerspectiveClient, version)
 					Expect(err).ToNot(HaveOccurred())
 					Expect(hdr.PacketNumber).To(Equal(protocol.PacketNumber(0xde)))
@@ -239,7 +239,7 @@ var _ = Describe("Public Header", func() {
 				})
 
 				It("accepts 2-byte packet numbers", func() {
-					b := bytes.NewReader([]byte{0x18, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0xde, 0xca})
+					b := bytes.NewReader([]byte{0x18, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6, 0xde, 0xca})
 					hdr, err := ParsePublicHeader(b, protocol.PerspectiveClient, version)
 					Expect(err).ToNot(HaveOccurred())
 					Expect(hdr.PacketNumber).To(Equal(protocol.PacketNumber(0xdeca)))
@@ -248,7 +248,7 @@ var _ = Describe("Public Header", func() {
 				})
 
 				It("accepts 4-byte packet numbers", func() {
-					b := bytes.NewReader([]byte{0x28, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0xad, 0xfb, 0xca, 0xde})
+					b := bytes.NewReader([]byte{0x28, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6, 0xad, 0xfb, 0xca, 0xde})
 					hdr, err := ParsePublicHeader(b, protocol.PerspectiveClient, version)
 					Expect(err).ToNot(HaveOccurred())
 					Expect(hdr.PacketNumber).To(Equal(protocol.PacketNumber(0xadfbcade)))
@@ -257,7 +257,7 @@ var _ = Describe("Public Header", func() {
 				})
 
 				It("accepts 6-byte packet numbers", func() {
-					b := bytes.NewReader([]byte{0x38, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0x23, 0x42, 0xad, 0xfb, 0xca, 0xde})
+					b := bytes.NewReader([]byte{0x38, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6, 0x23, 0x42, 0xad, 0xfb, 0xca, 0xde})
 					hdr, err := ParsePublicHeader(b, protocol.PerspectiveClient, version)
 					Expect(err).ToNot(HaveOccurred())
 					Expect(hdr.PacketNumber).To(Equal(protocol.PacketNumber(0x2342adfbcade)))
@@ -278,7 +278,7 @@ var _ = Describe("Public Header", func() {
 			}
 			err := hdr.Write(b, versionLittleEndian, protocol.PerspectiveServer)
 			Expect(err).ToNot(HaveOccurred())
-			Expect(b.Bytes()).To(Equal([]byte{0x38, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 2, 0, 0, 0, 0, 0}))
+			Expect(b.Bytes()).To(Equal([]byte{0x38, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6, 2, 0, 0, 0, 0, 0}))
 		})
 
 		It("writes a sample header as a client", func() {
@@ -290,7 +290,7 @@ var _ = Describe("Public Header", func() {
 			}
 			err := hdr.Write(b, versionLittleEndian, protocol.PerspectiveClient)
 			Expect(err).ToNot(HaveOccurred())
-			Expect(b.Bytes()).To(Equal([]byte{0x38, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0x37, 0x13, 0, 0, 0, 0}))
+			Expect(b.Bytes()).To(Equal([]byte{0x38, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6, 0x37, 0x13, 0, 0, 0, 0}))
 		})
 
 		It("refuses to write a Public Header if the PacketNumberLen is not set", func() {
@@ -327,7 +327,7 @@ var _ = Describe("Public Header", func() {
 			err := hdr.Write(b, versionLittleEndian, protocol.PerspectiveServer)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(b.Bytes()).To(Equal([]byte{
-				0x0c, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c,
+				0x0c, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6,
 				1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 				0x01,
 			}))
@@ -533,7 +533,7 @@ var _ = Describe("Public Header", func() {
 					}
 					err := hdr.Write(b, version, protocol.PerspectiveServer)
 					Expect(err).ToNot(HaveOccurred())
-					Expect(b.Bytes()).To(Equal([]byte{0x08, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0xAD}))
+					Expect(b.Bytes()).To(Equal([]byte{0x08, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6, 0xAD}))
 				})
 
 				It("writes a header with a 2-byte packet number", func() {
@@ -545,7 +545,7 @@ var _ = Describe("Public Header", func() {
 					}
 					err := hdr.Write(b, version, protocol.PerspectiveServer)
 					Expect(err).ToNot(HaveOccurred())
-					Expect(b.Bytes()).To(Equal([]byte{0x18, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0xad, 0xfb}))
+					Expect(b.Bytes()).To(Equal([]byte{0x18, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6, 0xad, 0xfb}))
 				})
 
 				It("writes a header with a 4-byte packet number", func() {
@@ -557,7 +557,7 @@ var _ = Describe("Public Header", func() {
 					}
 					err := hdr.Write(b, version, protocol.PerspectiveServer)
 					Expect(err).ToNot(HaveOccurred())
-					Expect(b.Bytes()).To(Equal([]byte{0x28, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0xAD, 0xfb, 0xca, 0xde}))
+					Expect(b.Bytes()).To(Equal([]byte{0x28, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6, 0xAD, 0xfb, 0xca, 0xde}))
 				})
 
 				It("writes a header with a 6-byte packet number", func() {
@@ -569,7 +569,7 @@ var _ = Describe("Public Header", func() {
 					}
 					err := hdr.Write(b, version, protocol.PerspectiveServer)
 					Expect(err).ToNot(HaveOccurred())
-					Expect(b.Bytes()).To(Equal([]byte{0x38, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0xad, 0xfb, 0xca, 0xde, 0x37, 0x13}))
+					Expect(b.Bytes()).To(Equal([]byte{0x38, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6, 0xad, 0xfb, 0xca, 0xde, 0x37, 0x13}))
 				})
 			})
 
@@ -589,7 +589,7 @@ var _ = Describe("Public Header", func() {
 					}
 					err := hdr.Write(b, version, protocol.PerspectiveServer)
 					Expect(err).ToNot(HaveOccurred())
-					Expect(b.Bytes()).To(Equal([]byte{0x08, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0xad}))
+					Expect(b.Bytes()).To(Equal([]byte{0x08, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6, 0xad}))
 				})
 
 				It("writes a header with a 2-byte packet number", func() {
@@ -601,7 +601,7 @@ var _ = Describe("Public Header", func() {
 					}
 					err := hdr.Write(b, version, protocol.PerspectiveServer)
 					Expect(err).ToNot(HaveOccurred())
-					Expect(b.Bytes()).To(Equal([]byte{0x18, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0xfb, 0xad}))
+					Expect(b.Bytes()).To(Equal([]byte{0x18, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6, 0xfb, 0xad}))
 				})
 
 				It("writes a header with a 4-byte packet number", func() {
@@ -613,7 +613,7 @@ var _ = Describe("Public Header", func() {
 					}
 					err := hdr.Write(b, version, protocol.PerspectiveServer)
 					Expect(err).ToNot(HaveOccurred())
-					Expect(b.Bytes()).To(Equal([]byte{0x28, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0xde, 0xca, 0xfb, 0xad}))
+					Expect(b.Bytes()).To(Equal([]byte{0x28, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6, 0xde, 0xca, 0xfb, 0xad}))
 				})
 
 				It("writes a header with a 6-byte packet number", func() {
@@ -625,7 +625,7 @@ var _ = Describe("Public Header", func() {
 					}
 					err := hdr.Write(b, version, protocol.PerspectiveServer)
 					Expect(err).ToNot(HaveOccurred())
-					Expect(b.Bytes()).To(Equal([]byte{0x38, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0x13, 0x37, 0xde, 0xca, 0xfb, 0xad}))
+					Expect(b.Bytes()).To(Equal([]byte{0x38, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6, 0x13, 0x37, 0xde, 0xca, 0xfb, 0xad}))
 				})
 			})
 		})

internal/wire/public_reset.go

@@ -20,7 +20,7 @@ type PublicReset struct {
 func WritePublicReset(connectionID protocol.ConnectionID, rejectedPacketNumber protocol.PacketNumber, nonceProof uint64) []byte {
 	b := &bytes.Buffer{}
 	b.WriteByte(0x0a)
-	utils.LittleEndian.WriteUint64(b, uint64(connectionID))
+	utils.BigEndian.WriteUint64(b, uint64(connectionID))
 	utils.LittleEndian.WriteUint32(b, uint32(handshake.TagPRST))
 	utils.LittleEndian.WriteUint32(b, 2)
 	utils.LittleEndian.WriteUint32(b, uint32(handshake.TagRNON))

internal/wire/public_reset_test.go

@@ -15,7 +15,7 @@ var _ = Describe("public reset", func() {
 		It("writes public reset packets", func() {
 			Expect(WritePublicReset(0xdeadbeef, 0x8badf00d, 0xdecafbad)).To(Equal([]byte{
 				0x0a,
-				0xef, 0xbe, 0xad, 0xde, 0x00, 0x00, 0x00, 0x00,
+				0x0, 0x0, 0x0, 0x0, 0xde, 0xad, 0xbe, 0xef,
 				'P', 'R', 'S', 'T',
 				0x02, 0x00, 0x00, 0x00,
 				'R', 'N', 'O', 'N',

internal/wire/version_negotiation_test.go

@@ -9,7 +9,7 @@ import (
 var _ = Describe("Version Negotiation Packet", func() {
 	It("composes version negotiation packets", func() {
 		expected := append(
-			[]byte{0x01 | 0x08, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
+			[]byte{0x01 | 0x08, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1},
 			[]byte{'Q', '0', '9', '9'}...,
 		)
 		Expect(ComposeVersionNegotiation(1, []protocol.VersionNumber{99})).To(Equal(expected))

server_test.go

@@ -117,7 +117,7 @@ var _ = Describe("Server", func() {
 			}
 			b := &bytes.Buffer{}
 			utils.LittleEndian.WriteUint32(b, protocol.VersionNumberToTag(protocol.SupportedVersions[0]))
-			firstPacket = []byte{0x09, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c}
+			firstPacket = []byte{0x09, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6}
 			firstPacket = append(append(firstPacket, b.Bytes()...), 0x01)
 		})
 
@@ -176,7 +176,7 @@ var _ = Describe("Server", func() {
 		It("assigns packets to existing sessions", func() {
 			err := serv.handlePacket(nil, nil, firstPacket)
 			Expect(err).ToNot(HaveOccurred())
-			err = serv.handlePacket(nil, nil, []byte{0x08, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0x01})
+			err = serv.handlePacket(nil, nil, []byte{0x08, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6, 0x01})
 			Expect(err).ToNot(HaveOccurred())
 			Expect(serv.sessions).To(HaveLen(1))
 			Expect(serv.sessions[connID].(*mockSession).connectionID).To(Equal(connID))
@@ -225,7 +225,7 @@ var _ = Describe("Server", func() {
 
 		It("ignores packets for closed sessions", func() {
 			serv.sessions[connID] = nil
-			err := serv.handlePacket(nil, nil, []byte{0x08, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0x01})
+			err := serv.handlePacket(nil, nil, []byte{0x08, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6, 0x01})
 			Expect(err).ToNot(HaveOccurred())
 			Expect(serv.sessions).To(HaveLen(1))
 			Expect(serv.sessions[connID]).To(BeNil())
@@ -283,7 +283,7 @@ var _ = Describe("Server", func() {
 			b := &bytes.Buffer{}
 			// add an unsupported version
 			utils.LittleEndian.WriteUint32(b, protocol.VersionNumberToTag(protocol.SupportedVersions[0]+1))
-			data := []byte{0x09, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c}
+			data := []byte{0x09, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6}
 			data = append(append(data, b.Bytes()...), 0x01)
 			err = serv.handlePacket(nil, nil, data)
 			Expect(err).ToNot(HaveOccurred())
@@ -422,7 +422,7 @@ var _ = Describe("Server", func() {
 		b = &bytes.Buffer{}
 		utils.LittleEndian.WriteUint32(b, protocol.VersionNumberToTag(99))
 		expected := append(
-			[]byte{0x9, 0x37, 0x13, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
+			[]byte{0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x13, 0x37},
 			b.Bytes()...,
 		)
 		Expect(conn.dataWritten.Bytes()).To(Equal(expected))
@@ -431,7 +431,7 @@ var _ = Describe("Server", func() {
 
 	It("sends a PublicReset for new connections that don't have the VersionFlag set", func() {
 		conn.dataReadFrom = udpAddr
-		conn.dataToRead = []byte{0x08, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0x01}
+		conn.dataToRead = []byte{0x08, 0x4c, 0xfa, 0x9f, 0x9b, 0x66, 0x86, 0x19, 0xf6, 0x01}
 		ln, err := Listen(conn, nil, config)
 		Expect(err).ToNot(HaveOccurred())
 		go func() {