compose PublicHeader depending on perspective set in packetPacker

packet_packer.go

@@ -71,7 +71,16 @@ func (p *packetPacker) packPacket(stopWaitingFrame *frames.StopWaitingFrame, lea
 		PacketNumber:         currentPacketNumber,
 		PacketNumberLen:      packetNumberLen,
 		TruncateConnectionID: p.connectionParameters.TruncateConnectionID(),
-		DiversificationNonce: p.cryptoSetup.DiversificationNonce(),
+	}
+
+	if p.perspective == protocol.PerspectiveServer {
+		responsePublicHeader.DiversificationNonce = p.cryptoSetup.DiversificationNonce()
+	}
+
+	// TODO: stop sending version numbers once a version has been negotiated
+	if p.perspective == protocol.PerspectiveClient {
+		responsePublicHeader.VersionFlag = true
+		responsePublicHeader.VersionNumber = protocol.Version36
 	}
 
 	publicHeaderLength, err := responsePublicHeader.GetLength(p.perspective)

packet_packer_test.go

@@ -4,12 +4,29 @@ import (
 	"bytes"
 
 	"github.com/lucas-clemente/quic-go/frames"
-	"github.com/lucas-clemente/quic-go/handshake"
 	"github.com/lucas-clemente/quic-go/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
 
+type mockCryptoSetup struct {
+	diversificationNonce []byte
+}
+
+func (m *mockCryptoSetup) HandleCryptoStream() error { panic("not implemented") }
+
+func (m *mockCryptoSetup) Open(dst, src []byte, packetNumber protocol.PacketNumber, associatedData []byte) ([]byte, error) {
+	return nil, nil
+}
+func (m *mockCryptoSetup) Seal(dst, src []byte, packetNumber protocol.PacketNumber, associatedData []byte) []byte {
+	return append(src, bytes.Repeat([]byte{0}, 12)...)
+}
+func (m *mockCryptoSetup) LockForSealing()                      {}
+func (m *mockCryptoSetup) UnlockForSealing()                    {}
+func (m *mockCryptoSetup) HandshakeComplete() bool              { panic("not implemented") }
+func (m *mockCryptoSetup) DiversificationNonce() []byte         { return m.diversificationNonce }
+func (m *mockCryptoSetup) SetDiversificationNonce([]byte) error { panic("not implemented") }
+
 var _ = Describe("Packet packer", func() {
 	var (
 		packer          *packetPacker
@@ -25,15 +42,13 @@ var _ = Describe("Packet packer", func() {
 
 		cpm := &mockConnectionParametersManager{}
 		streamFramer = newStreamFramer(newStreamsMap(nil, cpm), fcm)
-		cs, err := handshake.NewCryptoSetup(0, nil, protocol.VersionWhatever, nil, nil, nil, nil)
-		Expect(err).ToNot(HaveOccurred())
 
 		packer = &packetPacker{
-			cryptoSetup:           cs,
+			cryptoSetup:           &mockCryptoSetup{},
 			connectionParameters:  cpm,
 			packetNumberGenerator: newPacketNumberGenerator(protocol.SkipPacketAveragePeriodLength),
 			streamFramer:          streamFramer,
-			perspective:                 protocol.PerspectiveServer,
+			perspective:           protocol.PerspectiveServer,
 		}
 		publicHeaderLen = 1 + 8 + 2 // 1 flag byte, 8 connection ID, 2 packet number
 		packer.version = protocol.Version34
@@ -60,6 +75,19 @@ var _ = Describe("Packet packer", func() {
 		Expect(p.raw).To(ContainSubstring(string(b.Bytes())))
 	})
 
+	It("includes a diversification nonce, when acting as a server", func() {
+		nonce := bytes.Repeat([]byte{'e'}, 32)
+		packer.cryptoSetup.(*mockCryptoSetup).diversificationNonce = nonce
+		f := &frames.StreamFrame{
+			StreamID: 5,
+			Data:     []byte{0xDE, 0xCA, 0xFB, 0xAD},
+		}
+		streamFramer.AddFrameForRetransmission(f)
+		p, err := packer.PackPacket(nil, []frames.Frame{}, 0)
+		Expect(err).ToNot(HaveOccurred())
+		Expect(p.raw).To(ContainSubstring(string(nonce)))
+	})
+
 	It("packs a ConnectionClose", func() {
 		ccf := frames.ConnectionCloseFrame{
 			ErrorCode:    0x1337,