Merge pull request #313 from lucas-clemente/drop-32

Drop support for version 32
2016-09-01 12:53:14 +02:00
parent 69302be280 6a9364c20f
commit cb92d2f43b
15 changed files with 111 additions and 144 deletions
--- a/crypto/key_derivation.go
+++ b/crypto/key_derivation.go
@@ -21,15 +21,15 @@ import (
 // }

 // DeriveKeysAESGCM derives the client and server keys and creates a matching AES-GCM AEAD instance
-func DeriveKeysAESGCM(version protocol.VersionNumber, forwardSecure bool, sharedSecret, nonces []byte, connID protocol.ConnectionID, chlo []byte, scfg []byte, cert []byte, divNonce []byte) (AEAD, error) {
-	otherKey, myKey, otherIV, myIV, err := deriveKeys(version, forwardSecure, sharedSecret, nonces, connID, chlo, scfg, cert, divNonce, 16)
+func DeriveKeysAESGCM(forwardSecure bool, sharedSecret, nonces []byte, connID protocol.ConnectionID, chlo []byte, scfg []byte, cert []byte, divNonce []byte) (AEAD, error) {
+	otherKey, myKey, otherIV, myIV, err := deriveKeys(forwardSecure, sharedSecret, nonces, connID, chlo, scfg, cert, divNonce, 16)
 	if err != nil {
 		return nil, err
 	}
 	return NewAEADAESGCM(otherKey, myKey, otherIV, myIV)
 }

-func deriveKeys(version protocol.VersionNumber, forwardSecure bool, sharedSecret, nonces []byte, connID protocol.ConnectionID, chlo, scfg, cert, divNonce []byte, keyLen int) ([]byte, []byte, []byte, []byte, error) {
+func deriveKeys(forwardSecure bool, sharedSecret, nonces []byte, connID protocol.ConnectionID, chlo, scfg, cert, divNonce []byte, keyLen int) ([]byte, []byte, []byte, []byte, error) {
 	var info bytes.Buffer
 	if forwardSecure {
 		info.Write([]byte("QUIC forward secure key expansion\x00"))
@@ -52,7 +52,7 @@ func deriveKeys(version protocol.VersionNumber, forwardSecure bool, sharedSecret
 	otherIV := s[2*keyLen : 2*keyLen+4]
 	myIV := s[2*keyLen+4:]

-	if !forwardSecure && version >= protocol.Version33 {
+	if !forwardSecure {
 		if err := diversify(myKey, myIV, divNonce); err != nil {
 			return nil, nil, nil, nil, err
 		}
--- a/crypto/key_derivation_test.go
+++ b/crypto/key_derivation_test.go
@@ -89,64 +89,6 @@ var _ = Describe("KeyDerivation", func() {
 	Context("AES-GCM", func() {
 		It("derives non-fs keys", func() {
 			aead, err := DeriveKeysAESGCM(
-				protocol.Version32,
-				false,
-				[]byte("0123456789012345678901"),
-				[]byte("nonce"),
-				protocol.ConnectionID(42),
-				[]byte("chlo"),
-				[]byte("scfg"),
-				[]byte("cert"),
-				nil,
-			)
-			Expect(err).ToNot(HaveOccurred())
-			chacha := aead.(*aeadAESGCM)
-			// If the IVs match, the keys will match too, since the keys are read earlier
-			Expect(chacha.myIV).To(Equal([]byte{0x28, 0x71, 0x71, 0x16}))
-			Expect(chacha.otherIV).To(Equal([]byte{0x64, 0xef, 0x3c, 0x9}))
-		})
-
-		It("derives fs keys", func() {
-			aead, err := DeriveKeysAESGCM(
-				protocol.Version32,
-				true,
-				[]byte("0123456789012345678901"),
-				[]byte("nonce"),
-				protocol.ConnectionID(42),
-				[]byte("chlo"),
-				[]byte("scfg"),
-				[]byte("cert"),
-				nil,
-			)
-			Expect(err).ToNot(HaveOccurred())
-			chacha := aead.(*aeadAESGCM)
-			// If the IVs match, the keys will match too, since the keys are read earlier
-			Expect(chacha.myIV).To(Equal([]byte{0x7, 0xad, 0xab, 0xb8}))
-			Expect(chacha.otherIV).To(Equal([]byte{0xf2, 0x7a, 0xcc, 0x42}))
-		})
-
-		It("does not use diversification nonces in FS key derivation", func() {
-			aead, err := DeriveKeysAESGCM(
-				protocol.Version33,
-				true,
-				[]byte("0123456789012345678901"),
-				[]byte("nonce"),
-				protocol.ConnectionID(42),
-				[]byte("chlo"),
-				[]byte("scfg"),
-				[]byte("cert"),
-				[]byte("divnonce"),
-			)
-			Expect(err).ToNot(HaveOccurred())
-			chacha := aead.(*aeadAESGCM)
-			// If the IVs match, the keys will match too, since the keys are read earlier
-			Expect(chacha.myIV).To(Equal([]byte{0x7, 0xad, 0xab, 0xb8}))
-			Expect(chacha.otherIV).To(Equal([]byte{0xf2, 0x7a, 0xcc, 0x42}))
-		})
-
-		It("uses diversification nonces in initial key derivation", func() {
-			aead, err := DeriveKeysAESGCM(
-				protocol.Version33,
 				false,
 				[]byte("0123456789012345678901"),
 				[]byte("nonce"),
@@ -162,5 +104,41 @@ var _ = Describe("KeyDerivation", func() {
 			Expect(chacha.myIV).To(Equal([]byte{0x1c, 0xec, 0xac, 0x9b}))
 			Expect(chacha.otherIV).To(Equal([]byte{0x64, 0xef, 0x3c, 0x9}))
 		})
+
+		It("derives fs keys", func() {
+			aead, err := DeriveKeysAESGCM(
+				true,
+				[]byte("0123456789012345678901"),
+				[]byte("nonce"),
+				protocol.ConnectionID(42),
+				[]byte("chlo"),
+				[]byte("scfg"),
+				[]byte("cert"),
+				nil,
+			)
+			Expect(err).ToNot(HaveOccurred())
+			chacha := aead.(*aeadAESGCM)
+			// If the IVs match, the keys will match too, since the keys are read earlier
+			Expect(chacha.myIV).To(Equal([]byte{0x7, 0xad, 0xab, 0xb8}))
+			Expect(chacha.otherIV).To(Equal([]byte{0xf2, 0x7a, 0xcc, 0x42}))
+		})
+
+		It("does not use div-nonce for FS key derivation", func() {
+			aead, err := DeriveKeysAESGCM(
+				true,
+				[]byte("0123456789012345678901"),
+				[]byte("nonce"),
+				protocol.ConnectionID(42),
+				[]byte("chlo"),
+				[]byte("scfg"),
+				[]byte("cert"),
+				[]byte("divnonce"),
+			)
+			Expect(err).ToNot(HaveOccurred())
+			chacha := aead.(*aeadAESGCM)
+			// If the IVs match, the keys will match too, since the keys are read earlier
+			Expect(chacha.myIV).To(Equal([]byte{0x7, 0xad, 0xab, 0xb8}))
+			Expect(chacha.otherIV).To(Equal([]byte{0xf2, 0x7a, 0xcc, 0x42}))
+		})
 	})
 })
--- a/frames/ack_frame_legacy_test.go
+++ b/frames/ack_frame_legacy_test.go
@@ -14,7 +14,7 @@ var _ = Describe("AckFrame", func() {
 	Context("when parsing", func() {
 		It("accepts sample frame", func() {
 			b := bytes.NewReader([]byte{0x40, 0xA4, 0x03, 0x23, 0x45, 0x01, 0x02, 0xFF, 0xEE, 0xDD, 0xCC})
-			frame, err := ParseAckFrameLegacy(b, protocol.Version32)
+			frame, err := ParseAckFrameLegacy(b, protocol.VersionWhatever)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(frame.Entropy).To(Equal(byte(0xA4)))
 			Expect(frame.LargestObserved).To(Equal(protocol.PacketNumber(0x03)))
@@ -25,7 +25,7 @@ var _ = Describe("AckFrame", func() {

 		It("parses a frame with a 48 bit packet number", func() {
 			b := bytes.NewReader([]byte{0x4C, 0xA4, 0x37, 0x13, 0xAD, 0xFB, 0xCA, 0xDE, 0x23, 0x45, 0x01, 0x02, 0xFF, 0xEE, 0xDD, 0xCC})
-			frame, err := ParseAckFrameLegacy(b, protocol.Version32)
+			frame, err := ParseAckFrameLegacy(b, protocol.VersionWhatever)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(frame.LargestObserved).To(Equal(protocol.PacketNumber(0xDECAFBAD1337)))
 			Expect(b.Len()).To(Equal(0))
@@ -33,14 +33,14 @@ var _ = Describe("AckFrame", func() {

 		It("completely parses a frame with multiple timestamps", func() {
 			b := bytes.NewReader([]byte{0x40, 0xA4, 0x03, 0x23, 0x45, 0x03, 0x02, 0xFF, 0xEE, 0xDD, 0xCC, 0x12, 0x34, 0x56, 0x78, 0x90, 0xA0})
-			_, err := ParseAckFrameLegacy(b, protocol.Version32)
+			_, err := ParseAckFrameLegacy(b, protocol.VersionWhatever)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(b.Len()).To(Equal(0))
 		})

 		It("parses a frame containing one NACK range", func() {
 			b := bytes.NewReader([]byte{0x60, 0x8, 0x3, 0x72, 0x1, 0x1, 0x0, 0xc0, 0x15, 0x0, 0x0, 0x1, 0x1, 0x1})
-			frame, err := ParseAckFrameLegacy(b, protocol.Version32)
+			frame, err := ParseAckFrameLegacy(b, protocol.VersionWhatever)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(frame.HasNACK()).To(Equal(true))
 			Expect(frame.NackRanges).To(HaveLen(1))
@@ -52,7 +52,7 @@ var _ = Describe("AckFrame", func() {
 		It("parses a frame containing one NACK range with a 48 bit LargestObserved and missingPacketSequenceNumberDelta", func() {
 			var rangeLength uint64 = 3
 			b := bytes.NewReader([]byte{(0x4C | 0x20 | 0x03), 0x08, 0x37, 0x13, 0xAD, 0xFB, 0xCA, 0xDE, 0x72, 0x1, 0x1, 0x0, 0xc0, 0x15, 0x0, 0x0, 0x1, 0xFE, 0xCA, 0xEF, 0xBE, 0xAD, 0xDE, byte(rangeLength)})
-			frame, err := ParseAckFrameLegacy(b, protocol.Version32)
+			frame, err := ParseAckFrameLegacy(b, protocol.VersionWhatever)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(frame.LargestObserved).To(Equal(protocol.PacketNumber(0xDECAFBAD1337)))
 			Expect(frame.HasNACK()).To(Equal(true))
@@ -64,7 +64,7 @@ var _ = Describe("AckFrame", func() {
 		It("parses a frame containing multiple NACK ranges", func() {
 			// sent packets 1, 3, 7, 15
 			b := bytes.NewReader([]byte{0x60, 0x2, 0xf, 0xb8, 0x1, 0x1, 0x0, 0xe5, 0x58, 0x4, 0x0, 0x3, 0x1, 0x6, 0x1, 0x2, 0x1, 0x0})
-			frame, err := ParseAckFrameLegacy(b, protocol.Version32)
+			frame, err := ParseAckFrameLegacy(b, protocol.VersionWhatever)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(frame.HasNACK()).To(Equal(true))
 			Expect(frame.NackRanges).To(HaveLen(3))
@@ -77,13 +77,13 @@ var _ = Describe("AckFrame", func() {
 		It("rejects a packet with an invalid NACK range", func() {
 			// LargestObserved: 8, NackRange: (8-7-3) to (8-7)
 			b := bytes.NewReader([]byte{0x60, 0x8, 0x7, 0x72, 0x1, 0x1, 0x0, 0xc0, 0x15, 0x0, 0x0, 0x1, 0x7, 0x3})
-			_, err := ParseAckFrameLegacy(b, protocol.Version32)
+			_, err := ParseAckFrameLegacy(b, protocol.VersionWhatever)
 			Expect(err).To(MatchError(errInvalidNackRanges))
 		})

 		It("accepts truncated acks", func() {
 			b := bytes.NewReader([]byte{0x50, 0xA4, 0x03, 0x23, 0x45})
-			frame, err := ParseAckFrameLegacy(b, protocol.Version32)
+			frame, err := ParseAckFrameLegacy(b, protocol.VersionWhatever)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(frame.Truncated).To(BeTrue())
 			Expect(b.Len()).To(BeZero())
@@ -91,7 +91,7 @@ var _ = Describe("AckFrame", func() {

 		It("parses a frame with the largest observed missing", func() {
 			b := bytes.NewReader([]byte{0x60, 0x2, 0xf, 0xb8, 0x1, 0x1, 0x0, 0xe5, 0x58, 0x4, 0x0, 0x1, 0x0, 0x0})
-			frame, err := ParseAckFrameLegacy(b, protocol.Version32)
+			frame, err := ParseAckFrameLegacy(b, protocol.VersionWhatever)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(frame.HasNACK()).To(Equal(true))
 			Expect(frame.NackRanges).To(HaveLen(1))
@@ -102,7 +102,7 @@ var _ = Describe("AckFrame", func() {
 		Context("contiguous NACK ranges", func() {
 			It("parses a frame with a contiguous NACK range spanning two fields", func() {
 				b := bytes.NewReader([]byte{0x64, 0x8, 0x2E, 0x01, 0x72, 0x1, 0x1, 0x0, 0xc0, 0x15, 0x0, 0x0, 0x2, 0x1, 0x2b, 0x0, 0xff})
-				frame, err := ParseAckFrameLegacy(b, protocol.Version32)
+				frame, err := ParseAckFrameLegacy(b, protocol.VersionWhatever)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(frame.LargestObserved).To(Equal(protocol.PacketNumber(302)))
 				Expect(frame.NackRanges).To(HaveLen(1))
@@ -111,7 +111,7 @@ var _ = Describe("AckFrame", func() {

 			It("parses a frame with a contiguous NACK range spanning more than two fields", func() {
 				b := bytes.NewReader([]byte{0x64, 0x8, 0x16, 0x05, 0x72, 0x1, 0x1, 0x0, 0xc0, 0x15, 0x0, 0x0, 0x6, 0x1, 0x13, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff})
-				frame, err := ParseAckFrameLegacy(b, protocol.Version32)
+				frame, err := ParseAckFrameLegacy(b, protocol.VersionWhatever)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(frame.LargestObserved).To(Equal(protocol.PacketNumber(1302)))
 				Expect(frame.NackRanges).To(HaveLen(1))
@@ -120,7 +120,7 @@ var _ = Describe("AckFrame", func() {

 			It("parses a frame with two contiguous NACK ranges", func() {
 				b := bytes.NewReader([]byte{0x64, 0x8, 0x23, 0x03, 0x72, 0x1, 0x1, 0x0, 0xc0, 0x15, 0x0, 0x0, 0x4, 0x1, 0x8f, 0x0, 0xff, 0x1, 0x8f, 0x0, 0xff})
-				frame, err := ParseAckFrameLegacy(b, protocol.Version32)
+				frame, err := ParseAckFrameLegacy(b, protocol.VersionWhatever)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(frame.LargestObserved).To(Equal(protocol.PacketNumber(803)))
 				Expect(frame.NackRanges).To(HaveLen(2))
@@ -131,7 +131,7 @@ var _ = Describe("AckFrame", func() {
 			It("rejects a frame with an invalid NACK range", func() {
 				// LargestObserved: 280, but NACK range is 301 packets long
 				b := bytes.NewReader([]byte{0x64, 0x8, 0x18, 0x01, 0x72, 0x1, 0x1, 0x0, 0xc0, 0x15, 0x0, 0x0, 0x2, 0x1, 0x2b, 0x0, 0xff})
-				_, err := ParseAckFrameLegacy(b, protocol.Version32)
+				_, err := ParseAckFrameLegacy(b, protocol.VersionWhatever)
 				Expect(err).To(MatchError(errInvalidNackRanges))
 			})
 		})
@@ -266,7 +266,7 @@ var _ = Describe("AckFrame", func() {
 				Entropy:         2,
 				LargestObserved: 1,
 			}
-			err := frame.Write(b, protocol.Version32)
+			err := frame.Write(b, protocol.VersionWhatever)
 			Expect(err).ToNot(HaveOccurred())
 			// check all values except the DelayTime
 			Expect(b.Bytes()[0:3]).To(Equal([]byte{0x40, 0x02, 0x01}))
@@ -278,7 +278,7 @@ var _ = Describe("AckFrame", func() {
 				LargestObserved:    5,
 				PacketReceivedTime: time.Now().Add(-750 * time.Millisecond),
 			}
-			frame.Write(b, protocol.Version32)
+			frame.Write(b, protocol.VersionWhatever)
 			Expect(frame.DelayTime).To(BeNumerically("~", 750*time.Millisecond, 10*time.Millisecond))
 			delayTime := frame.DelayTime
 			var b2 bytes.Buffer
@@ -292,7 +292,7 @@ var _ = Describe("AckFrame", func() {
 				LargestObserved: 4,
 				NackRanges:      []NackRange{{FirstPacketNumber: 2, LastPacketNumber: 2}},
 			}
-			err := frame.Write(b, protocol.Version32)
+			err := frame.Write(b, protocol.VersionWhatever)
 			Expect(err).ToNot(HaveOccurred())
 			missingPacketBytes := b.Bytes()[b.Len()-8:]
 			Expect(missingPacketBytes[0]).To(Equal(uint8(1))) // numRanges
@@ -310,7 +310,7 @@ var _ = Describe("AckFrame", func() {
 				LargestObserved: 7,
 				NackRanges:      []NackRange{nackRange1, nackRange2},
 			}
-			err := frame.Write(b, protocol.Version32)
+			err := frame.Write(b, protocol.VersionWhatever)
 			Expect(err).ToNot(HaveOccurred())
 			missingPacketBytes := b.Bytes()[b.Len()-(1+2*7):]
 			Expect(missingPacketBytes[0]).To(Equal(uint8(2)))      // numRanges
@@ -331,7 +331,7 @@ var _ = Describe("AckFrame", func() {
 					LargestObserved: 258,
 					NackRanges:      []NackRange{{FirstPacketNumber: 2, LastPacketNumber: 257}},
 				}
-				err := frame.Write(b, protocol.Version32)
+				err := frame.Write(b, protocol.VersionWhatever)
 				Expect(err).ToNot(HaveOccurred())
 				missingPacketBytes := b.Bytes()[b.Len()-(1+7):]
 				Expect(missingPacketBytes[0]).To(Equal(uint8(1)))                   // numRanges
@@ -345,7 +345,7 @@ var _ = Describe("AckFrame", func() {
 					LargestObserved: 302,
 					NackRanges:      []NackRange{{FirstPacketNumber: 2, LastPacketNumber: 301}},
 				}
-				err := frame.Write(b, protocol.Version32)
+				err := frame.Write(b, protocol.VersionWhatever)
 				Expect(err).ToNot(HaveOccurred())
 				missingPacketBytes := b.Bytes()[b.Len()-(1+2*7):]
 				Expect(missingPacketBytes[0]).To(Equal(uint8(2)))                    // numRanges
@@ -361,7 +361,7 @@ var _ = Describe("AckFrame", func() {
 					LargestObserved: 259,
 					NackRanges:      []NackRange{{FirstPacketNumber: 2, LastPacketNumber: 258}},
 				}
-				err := frame.Write(b, protocol.Version32)
+				err := frame.Write(b, protocol.VersionWhatever)
 				Expect(err).ToNot(HaveOccurred())
 				missingPacketBytes := b.Bytes()[b.Len()-(1+2*7):]
 				Expect(missingPacketBytes[0]).To(Equal(uint8(2)))                    // numRanges
@@ -377,7 +377,7 @@ var _ = Describe("AckFrame", func() {
 					LargestObserved: 603,
 					NackRanges:      []NackRange{{FirstPacketNumber: 2, LastPacketNumber: 601}},
 				}
-				err := frame.Write(b, protocol.Version32)
+				err := frame.Write(b, protocol.VersionWhatever)
 				Expect(err).ToNot(HaveOccurred())
 				missingPacketBytes := b.Bytes()[b.Len()-(1+3*7):]
 				Expect(missingPacketBytes[0]).To(Equal(uint8(3)))                     // numRanges
@@ -397,7 +397,7 @@ var _ = Describe("AckFrame", func() {
 					LargestObserved: 655,
 					NackRanges:      []NackRange{nackRange2, nackRange1},
 				}
-				err := frame.Write(b, protocol.Version32)
+				err := frame.Write(b, protocol.VersionWhatever)
 				Expect(err).ToNot(HaveOccurred())
 				missingPacketBytes := b.Bytes()[b.Len()-(1+4*7):]
 				Expect(missingPacketBytes[0]).To(Equal(uint8(4)))                     // numRanges
@@ -416,7 +416,7 @@ var _ = Describe("AckFrame", func() {
 					frame := AckFrameLegacy{
 						LargestObserved: 7,
 					}
-					err := frame.Write(b, protocol.Version32)
+					err := frame.Write(b, protocol.VersionWhatever)
 					Expect(err).ToNot(HaveOccurred())
 					Expect(b.Bytes()[0] & 0x4C).To(Equal(uint8(0x40)))
 					Expect(b.Bytes()[2]).To(Equal(uint8(7)))
@@ -426,7 +426,7 @@ var _ = Describe("AckFrame", func() {
 					frame := AckFrameLegacy{
 						LargestObserved: 0x1337,
 					}
-					err := frame.Write(b, protocol.Version32)
+					err := frame.Write(b, protocol.VersionWhatever)
 					Expect(err).ToNot(HaveOccurred())
 					Expect(b.Bytes()[0] & 0x4C).To(Equal(uint8(0x44)))
 					Expect(b.Bytes()[2:4]).To(Equal([]byte{0x37, 0x13}))
@@ -436,7 +436,7 @@ var _ = Describe("AckFrame", func() {
 					frame := AckFrameLegacy{
 						LargestObserved: 0xDECAFBAD,
 					}
-					err := frame.Write(b, protocol.Version32)
+					err := frame.Write(b, protocol.VersionWhatever)
 					Expect(err).ToNot(HaveOccurred())
 					Expect(b.Bytes()[0] & 0x4C).To(Equal(uint8(0x48)))
 					Expect(b.Bytes()[2:6]).To(Equal([]byte{0xAD, 0xFB, 0xCA, 0xDE}))
@@ -446,7 +446,7 @@ var _ = Describe("AckFrame", func() {
 					frame := AckFrameLegacy{
 						LargestObserved: 0xDEADBEEFCAFE,
 					}
-					err := frame.Write(b, protocol.Version32)
+					err := frame.Write(b, protocol.VersionWhatever)
 					Expect(err).ToNot(HaveOccurred())
 					Expect(b.Bytes()[0] & 0x4C).To(Equal(uint8(0x4C)))
 					Expect(b.Bytes()[2:8]).To(Equal([]byte{0xFE, 0xCA, 0xEF, 0xBE, 0xAD, 0xDE}))
@@ -508,9 +508,9 @@ var _ = Describe("AckFrame", func() {
 				Entropy:         0xDE,
 				LargestObserved: 6789,
 			}
-			err := frameOrig.Write(b, protocol.Version32)
+			err := frameOrig.Write(b, protocol.VersionWhatever)
 			Expect(err).ToNot(HaveOccurred())
-			frame, err := ParseAckFrameLegacy(bytes.NewReader(b.Bytes()), protocol.Version32)
+			frame, err := ParseAckFrameLegacy(bytes.NewReader(b.Bytes()), protocol.VersionWhatever)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(frame.Entropy).To(Equal(frameOrig.Entropy))
 			Expect(frame.LargestObserved).To(Equal(frameOrig.LargestObserved))
@@ -526,10 +526,10 @@ var _ = Describe("AckFrame", func() {
 				LargestObserved: 15,
 				NackRanges:      nackRanges,
 			}
-			err := frameOrig.Write(b, protocol.Version32)
+			err := frameOrig.Write(b, protocol.VersionWhatever)
 			Expect(err).ToNot(HaveOccurred())
 			r := bytes.NewReader(b.Bytes())
-			frame, err := ParseAckFrameLegacy(r, protocol.Version32)
+			frame, err := ParseAckFrameLegacy(r, protocol.VersionWhatever)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(frame.LargestObserved).To(Equal(frameOrig.LargestObserved))
 			Expect(frame.NackRanges).To(HaveLen(len(frameOrig.NackRanges)))
@@ -546,10 +546,10 @@ var _ = Describe("AckFrame", func() {
 				LargestObserved: 1600,
 				NackRanges:      nackRanges,
 			}
-			err := frameOrig.Write(b, protocol.Version32)
+			err := frameOrig.Write(b, protocol.VersionWhatever)
 			Expect(err).ToNot(HaveOccurred())
 			r := bytes.NewReader(b.Bytes())
-			frame, err := ParseAckFrameLegacy(r, protocol.Version32)
+			frame, err := ParseAckFrameLegacy(r, protocol.VersionWhatever)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(frame.LargestObserved).To(Equal(frameOrig.LargestObserved))
 			Expect(frame.NackRanges).To(HaveLen(len(frameOrig.NackRanges)))
--- a/frames/ack_frame_test.go
+++ b/frames/ack_frame_test.go
@@ -883,7 +883,7 @@ var _ = Describe("AckFrame", func() {
 	Context("Legacy AckFrame wrapping", func() {
 		It("parses a ACK frame", func() {
 			b := bytes.NewReader([]byte{0x40, 0xA4, 0x03, 0x23, 0x45, 0x01, 0x02, 0xFF, 0xEE, 0xDD, 0xCC})
-			frame, err := ParseAckFrame(b, protocol.Version32)
+			frame, err := ParseAckFrame(b, protocol.Version33)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(frame.AckFrameLegacy).ToNot(BeNil())
 			Expect(frame.AckFrameLegacy.Entropy).To(Equal(byte(0xA4)))
@@ -903,9 +903,9 @@ var _ = Describe("AckFrame", func() {
 			frame := AckFrame{
 				AckFrameLegacy: ackLegacy,
 			}
-			err := frame.Write(b1, protocol.Version32)
+			err := frame.Write(b1, protocol.Version33)
 			Expect(err).ToNot(HaveOccurred())
-			err = ackLegacy.Write(b2, protocol.Version32)
+			err = ackLegacy.Write(b2, protocol.Version33)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(b1.Bytes()).To(Equal(b2.Bytes()))
 		})
--- a/h2quic/server_test.go
+++ b/h2quic/server_test.go
@@ -196,7 +196,7 @@ var _ = Describe("H2 server", func() {

 	Context("setting http headers", func() {
 		expected := http.Header{
-			"Alt-Svc":            {`quic=":443"; ma=2592000; v="35,34,33,32"`},
+			"Alt-Svc":            {`quic=":443"; ma=2592000; v="35,34,33"`},
 			"Alternate-Protocol": {`443:quic`},
 		}

--- a/handshake/crypto_setup.go
+++ b/handshake/crypto_setup.go
@@ -13,7 +13,7 @@ import (
 )

 // KeyDerivationFunction is used for key derivation
-type KeyDerivationFunction func(version protocol.VersionNumber, forwardSecure bool, sharedSecret, nonces []byte, connID protocol.ConnectionID, chlo []byte, scfg []byte, cert []byte, divNonce []byte) (crypto.AEAD, error)
+type KeyDerivationFunction func(forwardSecure bool, sharedSecret, nonces []byte, connID protocol.ConnectionID, chlo []byte, scfg []byte, cert []byte, divNonce []byte) (crypto.AEAD, error)

 // KeyExchangeFunction is used to make a new KEX
 type KeyExchangeFunction func() crypto.KeyExchange
@@ -248,7 +248,6 @@ func (h *CryptoSetup) handleCHLO(sni string, data []byte, cryptoData map[Tag][]b
 	}

 	h.secureAEAD, err = h.keyDerivation(
-		h.version,
 		false,
 		sharedSecret,
 		cryptoData[TagNONC],
@@ -271,7 +270,7 @@ func (h *CryptoSetup) handleCHLO(sni string, data []byte, cryptoData map[Tag][]b
 	if err != nil {
 		return nil, err
 	}
-	h.forwardSecureAEAD, err = h.keyDerivation(h.version,
+	h.forwardSecureAEAD, err = h.keyDerivation(
 		true,
 		ephermalSharedSecret,
 		fsNonce.Bytes(),
@@ -306,9 +305,6 @@ func (h *CryptoSetup) handleCHLO(sni string, data []byte, cryptoData map[Tag][]b

 // DiversificationNonce returns a diversification nonce if required in the next packet to be Seal'ed. See LockForSealing()!
 func (h *CryptoSetup) DiversificationNonce() []byte {
-	if h.version < protocol.Version33 {
-		return nil
-	}
 	if h.receivedForwardSecurePacket || h.secureAEAD == nil {
 		return nil
 	}
--- a/handshake/crypto_setup_test.go
+++ b/handshake/crypto_setup_test.go
@@ -81,7 +81,7 @@ func (mockAEAD) DiversificationNonce() []byte { return nil }
 var expectedInitialNonceLen int
 var expectedFSNonceLen int

-func mockKeyDerivation(v protocol.VersionNumber, forwardSecure bool, sharedSecret, nonces []byte, connID protocol.ConnectionID, chlo []byte, scfg []byte, cert []byte, divNonce []byte) (crypto.AEAD, error) {
+func mockKeyDerivation(forwardSecure bool, sharedSecret, nonces []byte, connID protocol.ConnectionID, chlo []byte, scfg []byte, cert []byte, divNonce []byte) (crypto.AEAD, error) {
 	if forwardSecure {
 		Expect(nonces).To(HaveLen(expectedFSNonceLen))
 	} else {
@@ -183,11 +183,6 @@ var _ = Describe("Crypto setup", func() {
 			Expect(cs.DiversificationNonce()).To(HaveLen(32))
 		})

-		It("does not return nonce for version < 33", func() {
-			cs.version = protocol.Version32
-			Expect(cs.DiversificationNonce()).To(BeEmpty())
-		})
-
 		It("does not return nonce for FS packets", func() {
 			cs.receivedForwardSecurePacket = true
 			Expect(cs.DiversificationNonce()).To(BeEmpty())
--- a/packet_packer_test.go
+++ b/packet_packer_test.go
@@ -160,7 +160,7 @@ var _ = Describe("Packet packer", func() {
 	It("packs many control frames into 1 packets", func() {
 		f := &frames.AckFrameLegacy{LargestObserved: 1}
 		b := &bytes.Buffer{}
-		f.Write(b, protocol.Version32)
+		f.Write(b, protocol.VersionWhatever)
 		maxFramesPerPacket := int(protocol.MaxFrameAndPublicHeaderSize-publicHeaderLen) / b.Len()
 		var controlFrames []frames.Frame
 		for i := 0; i < maxFramesPerPacket; i++ {
--- a/packet_unpacker_test.go
+++ b/packet_unpacker_test.go
@@ -87,10 +87,10 @@ var _ = Describe("Packet unpacker", func() {
 				Entropy:         0x37,
 			},
 		}
-		err := f.Write(buf, protocol.Version32)
+		err := f.Write(buf, protocol.Version33)
 		Expect(err).ToNot(HaveOccurred())
 		setData(buf.Bytes())
-		unpacker.version = protocol.Version32
+		unpacker.version = protocol.Version33
 		packet, err := unpacker.Unpack(hdrBin, hdr, data)
 		Expect(err).ToNot(HaveOccurred())
 		Expect(packet.frames).To(HaveLen(1))
--- a/protocol/version.go
+++ b/protocol/version.go
@@ -11,8 +11,7 @@ type VersionNumber int

 // The version numbers, making grepping easier
 const (
-	Version32 VersionNumber = 32 + iota
-	Version33
+	Version33 VersionNumber = 33 + iota
 	Version34
 	Version35
 	VersionWhatever = 0 // for when the version doesn't matter
@@ -20,7 +19,7 @@ const (

 // SupportedVersions lists the versions that the server supports
 var SupportedVersions = []VersionNumber{
-	Version32, Version33, Version34, Version35,
+	Version33, Version34, Version35,
 }

 // SupportedVersionsAsTags is needed for the SHLO crypto message
--- a/protocol/version_test.go
+++ b/protocol/version_test.go
@@ -17,11 +17,11 @@ var _ = Describe("Version", func() {
 	})

 	It("has proper tag list", func() {
-		Expect(SupportedVersionsAsTags).To(Equal([]byte("Q032Q033Q034Q035")))
+		Expect(SupportedVersionsAsTags).To(Equal([]byte("Q033Q034Q035")))
 	})

 	It("has proper version list", func() {
-		Expect(SupportedVersionsAsString).To(Equal("35,34,33,32"))
+		Expect(SupportedVersionsAsString).To(Equal("35,34,33"))
 	})

 	It("recognizes supported versions", func() {
--- a/public_header.go
+++ b/public_header.go
@@ -44,12 +44,9 @@ func (h *PublicHeader) WritePublicHeader(b *bytes.Buffer, version protocol.Versi
 		publicFlagByte |= 0x02
 	}
 	if !h.TruncateConnectionID {
-		if version < protocol.Version33 {
-			publicFlagByte |= 0x0c
-		} else {
-			publicFlagByte |= 0x08
-		}
+		publicFlagByte |= 0x08
 	}
+
 	if len(h.DiversificationNonce) > 0 {
 		if len(h.DiversificationNonce) != 32 {
 			return errors.New("invalid diversification nonce length")
@@ -110,7 +107,8 @@ func ParsePublicHeader(b io.ByteReader) (*PublicHeader, error) {
 	header.VersionFlag = publicFlagByte&0x01 > 0
 	header.ResetFlag = publicFlagByte&0x02 > 0

-	// TODO: Add this check when we drop support for <v33
+	// TODO: activate this check once Chrome sends the correct value
+	// see https://github.com/lucas-clemente/quic-go/issues/232
 	// if publicFlagByte&0x04 > 0 {
 	// 	return nil, errors.New("diversification nonces should only be sent by servers")
 	// }
--- a/public_header_test.go
+++ b/public_header_test.go
@@ -66,7 +66,7 @@ var _ = Describe("Public Header", func() {
 			Expect(b.Len()).To(BeZero())
 		})

-		PIt("rejects diversification nonces", func() {
+		PIt("rejects diversification nonces sent by the client", func() {
 			b := bytes.NewReader([]byte{0x0c, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c,
 				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,
@@ -84,8 +84,8 @@ var _ = Describe("Public Header", func() {
 				PacketNumber:    2,
 				PacketNumberLen: protocol.PacketNumberLen6,
 			}
-			hdr.WritePublicHeader(b, protocol.Version32)
-			Expect(b.Bytes()).To(Equal([]byte{0x38 | 0x04, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 2, 0, 0, 0, 0, 0}))
+			hdr.WritePublicHeader(b, protocol.Version33)
+			Expect(b.Bytes()).To(Equal([]byte{0x38, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 2, 0, 0, 0, 0, 0}))
 		})

 		It("sets the Version Flag", func() {
@@ -96,7 +96,7 @@ var _ = Describe("Public Header", func() {
 				PacketNumber:    2,
 				PacketNumberLen: protocol.PacketNumberLen6,
 			}
-			hdr.WritePublicHeader(b, protocol.Version32)
+			hdr.WritePublicHeader(b, protocol.VersionWhatever)
 			// must be the first assertion
 			Expect(b.Len()).To(Equal(1 + 8)) // 1 FlagByte + 8 ConnectionID
 			firstByte, _ := b.ReadByte()
@@ -111,7 +111,7 @@ var _ = Describe("Public Header", func() {
 				PacketNumber:    2,
 				PacketNumberLen: protocol.PacketNumberLen6,
 			}
-			hdr.WritePublicHeader(b, protocol.Version32)
+			hdr.WritePublicHeader(b, protocol.VersionWhatever)
 			// must be the first assertion
 			Expect(b.Len()).To(Equal(1 + 8)) // 1 FlagByte + 8 ConnectionID
 			firstByte, _ := b.ReadByte()
@@ -127,7 +127,7 @@ var _ = Describe("Public Header", func() {
 				PacketNumber:    2,
 				PacketNumberLen: protocol.PacketNumberLen6,
 			}
-			err := hdr.WritePublicHeader(b, protocol.Version32)
+			err := hdr.WritePublicHeader(b, protocol.VersionWhatever)
 			Expect(err).To(MatchError(errResetAndVersionFlagSet))
 		})

@@ -139,7 +139,7 @@ var _ = Describe("Public Header", func() {
 				PacketNumberLen:      protocol.PacketNumberLen6,
 				PacketNumber:         1,
 			}
-			err := hdr.WritePublicHeader(b, protocol.Version32)
+			err := hdr.WritePublicHeader(b, protocol.VersionWhatever)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(b.Bytes()).To(Equal([]byte{0x30, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0}))
 		})
@@ -247,7 +247,7 @@ var _ = Describe("Public Header", func() {
 					ConnectionID: 0x4cfa9f9b668619f6,
 					PacketNumber: 0xDECAFBAD,
 				}
-				err := hdr.WritePublicHeader(b, protocol.Version32)
+				err := hdr.WritePublicHeader(b, protocol.VersionWhatever)
 				Expect(err).To(MatchError(errPacketNumberLenNotSet))
 			})

@@ -258,9 +258,9 @@ var _ = Describe("Public Header", func() {
 					PacketNumber:    0xDECAFBAD,
 					PacketNumberLen: protocol.PacketNumberLen1,
 				}
-				err := hdr.WritePublicHeader(b, protocol.Version32)
+				err := hdr.WritePublicHeader(b, protocol.VersionWhatever)
 				Expect(err).ToNot(HaveOccurred())
-				Expect(b.Bytes()).To(Equal([]byte{0x08 | 0x04, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0xAD}))
+				Expect(b.Bytes()).To(Equal([]byte{0x08, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0xAD}))
 			})

 			It("writes a header with a 2-byte packet number", func() {
@@ -270,9 +270,9 @@ var _ = Describe("Public Header", func() {
 					PacketNumber:    0xDECAFBAD,
 					PacketNumberLen: protocol.PacketNumberLen2,
 				}
-				err := hdr.WritePublicHeader(b, protocol.Version32)
+				err := hdr.WritePublicHeader(b, protocol.VersionWhatever)
 				Expect(err).ToNot(HaveOccurred())
-				Expect(b.Bytes()).To(Equal([]byte{0x18 | 0x04, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0xAD, 0xFB}))
+				Expect(b.Bytes()).To(Equal([]byte{0x18, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0xAD, 0xFB}))
 			})

 			It("writes a header with a 4-byte packet number", func() {
@@ -282,9 +282,9 @@ var _ = Describe("Public Header", func() {
 					PacketNumber:    0x13DECAFBAD,
 					PacketNumberLen: protocol.PacketNumberLen4,
 				}
-				err := hdr.WritePublicHeader(b, protocol.Version32)
+				err := hdr.WritePublicHeader(b, protocol.VersionWhatever)
 				Expect(err).ToNot(HaveOccurred())
-				Expect(b.Bytes()).To(Equal([]byte{0x28 | 0x04, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0xAD, 0xFB, 0xCA, 0xDE}))
+				Expect(b.Bytes()).To(Equal([]byte{0x28, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0xAD, 0xFB, 0xCA, 0xDE}))
 			})

 			It("writes a header with a 6-byte packet number", func() {
@@ -294,9 +294,9 @@ var _ = Describe("Public Header", func() {
 					PacketNumber:    0xBE1337DECAFBAD,
 					PacketNumberLen: protocol.PacketNumberLen6,
 				}
-				err := hdr.WritePublicHeader(b, protocol.Version32)
+				err := hdr.WritePublicHeader(b, protocol.VersionWhatever)
 				Expect(err).ToNot(HaveOccurred())
-				Expect(b.Bytes()).To(Equal([]byte{0x38 | 0x04, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0xAD, 0xFB, 0xCA, 0xDE, 0x37, 0x13}))
+				Expect(b.Bytes()).To(Equal([]byte{0x38, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0xAD, 0xFB, 0xCA, 0xDE, 0x37, 0x13}))
 			})
 		})
 	})
--- a/server.go
+++ b/server.go
@@ -189,7 +189,7 @@ func composeVersionNegotiation(connectionID protocol.ConnectionID) []byte {
 		VersionFlag:  true,
 	}
 	// TODO: Update version number
-	err := responsePublicHeader.WritePublicHeader(fullReply, protocol.Version32)
+	err := responsePublicHeader.WritePublicHeader(fullReply, protocol.Version33)
 	if err != nil {
 		utils.Errorf("error composing version negotiation packet: %s", err.Error())
 	}
--- a/server_test.go
+++ b/server_test.go
@@ -48,7 +48,7 @@ var _ = Describe("Server", func() {

 		It("composes version negotiation packets", func() {
 			expected := append(
-				[]byte{0x01 | 0x08 | 0x04, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
+				[]byte{0x01 | 0x08, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
 				protocol.SupportedVersionsAsTags...,
 			)
 			Expect(composeVersionNegotiation(1)).To(Equal(expected))
@@ -73,7 +73,8 @@ var _ = Describe("Server", func() {
 		})

 		It("closes and deletes sessions", func() {
-			pheader := []byte{0x09, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0x51, 0x30, 0x33, 0x32, 0x01}
+			version := 0x34
+			pheader := []byte{0x09, 0xf6, 0x19, 0x86, 0x66, 0x9b, 0x9f, 0xfa, 0x4c, 0x51, 0x30, 0x33, byte(version), 0x01}
 			err := server.handlePacket(nil, nil, append(pheader, (&crypto.NullAEAD{}).Seal(nil, nil, 0, pheader)...))
 			Expect(err).ToNot(HaveOccurred())
 			Expect(server.sessions).To(HaveLen(1))
@@ -140,7 +141,7 @@ var _ = Describe("Server", func() {
 		Expect(err).NotTo(HaveOccurred())
 		data = data[:n]
 		expected := append(
-			[]byte{0xd, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
+			[]byte{0x9, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
 			protocol.SupportedVersionsAsTags...,
 		)
 		Expect(data).To(Equal(expected))