use separate sealer interfaces for long and short header packets

internal/handshake/aead.go

@@ -19,9 +19,10 @@ type sealer struct {
 	is1RTT bool
 }
 
-var _ Sealer = &sealer{}
+var _ LongHeaderSealer = &sealer{}
+var _ ShortHeaderSealer = &sealer{}
 
-func newSealer(aead cipher.AEAD, hpEncrypter cipher.Block, is1RTT bool) Sealer {
+func newSealer(aead cipher.AEAD, hpEncrypter cipher.Block, is1RTT bool) ShortHeaderSealer {
 	return &sealer{
 		aead:        aead,
 		nonceBuf:    make([]byte, aead.NonceSize()),
@@ -57,6 +58,10 @@ func (s *sealer) Overhead() int {
 	return s.aead.Overhead()
 }
 
+func (s *sealer) KeyPhase() protocol.KeyPhase {
+	return protocol.KeyPhaseZero
+}
+
 type opener struct {
 	aead        cipher.AEAD
 	pnDecrypter cipher.Block

internal/handshake/aead_test.go

@@ -10,7 +10,7 @@ import (
 )
 
 var _ = Describe("AEAD", func() {
-	getSealerAndOpener := func(is1RTT bool) (Sealer, Opener) {
+	getSealerAndOpener := func(is1RTT bool) (ShortHeaderSealer, Opener) {
 		key := make([]byte, 16)
 		hpKey := make([]byte, 16)
 		rand.Read(key)
@@ -29,7 +29,7 @@ var _ = Describe("AEAD", func() {
 
 	Context("message encryption", func() {
 		var (
-			sealer Sealer
+			sealer ShortHeaderSealer
 			opener Opener
 		)
 

internal/handshake/crypto_setup.go

@@ -106,15 +106,15 @@ type cryptoSetup struct {
 
 	initialStream io.Writer
 	initialOpener Opener
-	initialSealer Sealer
+	initialSealer LongHeaderSealer
 
 	handshakeStream io.Writer
 	handshakeOpener Opener
-	handshakeSealer Sealer
+	handshakeSealer LongHeaderSealer
 
 	oneRTTStream io.Writer
 	opener       Opener
-	sealer       Sealer
+	sealer       ShortHeaderSealer
 }
 
 var _ qtls.RecordLayer = &cryptoSetup{}
@@ -564,14 +564,14 @@ func (h *cryptoSetup) SendAlert(alert uint8) {
 	h.alertChan <- alert
 }
 
-func (h *cryptoSetup) GetInitialSealer() (Sealer, error) {
+func (h *cryptoSetup) GetInitialSealer() (LongHeaderSealer, error) {
 	h.mutex.Lock()
 	defer h.mutex.Unlock()
 
 	return h.initialSealer, nil
 }
 
-func (h *cryptoSetup) GetHandshakeSealer() (Sealer, error) {
+func (h *cryptoSetup) GetHandshakeSealer() (LongHeaderSealer, error) {
 	h.mutex.Lock()
 	defer h.mutex.Unlock()
 
@@ -581,7 +581,7 @@ func (h *cryptoSetup) GetHandshakeSealer() (Sealer, error) {
 	return h.handshakeSealer, nil
 }
 
-func (h *cryptoSetup) Get1RTTSealer() (Sealer, error) {
+func (h *cryptoSetup) Get1RTTSealer() (ShortHeaderSealer, error) {
 	h.mutex.Lock()
 	defer h.mutex.Unlock()
 

internal/handshake/initial_aead.go

@@ -11,7 +11,7 @@ import (
 var quicVersion1Salt = []byte{0xef, 0x4f, 0xb0, 0xab, 0xb4, 0x74, 0x70, 0xc4, 0x1b, 0xef, 0xcf, 0x80, 0x31, 0x33, 0x4f, 0xae, 0x48, 0x5e, 0x09, 0xa0}
 
 // NewInitialAEAD creates a new AEAD for Initial encryption / decryption.
-func NewInitialAEAD(connID protocol.ConnectionID, pers protocol.Perspective) (Sealer, Opener, error) {
+func NewInitialAEAD(connID protocol.ConnectionID, pers protocol.Perspective) (LongHeaderSealer, Opener, error) {
 	clientSecret, serverSecret := computeSecrets(connID)
 	var mySecret, otherSecret []byte
 	if pers == protocol.PerspectiveClient {

internal/handshake/interface.go

@@ -14,13 +14,19 @@ type Opener interface {
 	DecryptHeader(sample []byte, firstByte *byte, pnBytes []byte)
 }
 
-// Sealer seals a packet
-type Sealer interface {
+// LongHeaderSealer seals a long header packet
+type LongHeaderSealer interface {
 	Seal(dst, src []byte, packetNumber protocol.PacketNumber, associatedData []byte) []byte
 	EncryptHeader(sample []byte, firstByte *byte, pnBytes []byte)
 	Overhead() int
 }
 
+// ShortHeaderSealer seals a short header packet
+type ShortHeaderSealer interface {
+	LongHeaderSealer
+	KeyPhase() protocol.KeyPhase
+}
+
 // A tlsExtensionHandler sends and received the QUIC TLS extension.
 type tlsExtensionHandler interface {
 	GetExtensions(msgType uint8) []qtls.Extension
@@ -49,7 +55,7 @@ type CryptoSetup interface {
 	GetHandshakeOpener() (Opener, error)
 	Get1RTTOpener() (Opener, error)
 
-	GetInitialSealer() (Sealer, error)
-	GetHandshakeSealer() (Sealer, error)
-	Get1RTTSealer() (Sealer, error)
+	GetInitialSealer() (LongHeaderSealer, error)
+	GetHandshakeSealer() (LongHeaderSealer, error)
+	Get1RTTSealer() (ShortHeaderSealer, error)
 }

internal/mocks/crypto_setup.go

@@ -94,10 +94,10 @@ func (mr *MockCryptoSetupMockRecorder) Get1RTTOpener() *gomock.Call {
 }
 
 // Get1RTTSealer mocks base method
-func (m *MockCryptoSetup) Get1RTTSealer() (handshake.Sealer, error) {
+func (m *MockCryptoSetup) Get1RTTSealer() (handshake.ShortHeaderSealer, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Get1RTTSealer")
-	ret0, _ := ret[0].(handshake.Sealer)
+	ret0, _ := ret[0].(handshake.ShortHeaderSealer)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -124,10 +124,10 @@ func (mr *MockCryptoSetupMockRecorder) GetHandshakeOpener() *gomock.Call {
 }
 
 // GetHandshakeSealer mocks base method
-func (m *MockCryptoSetup) GetHandshakeSealer() (handshake.Sealer, error) {
+func (m *MockCryptoSetup) GetHandshakeSealer() (handshake.LongHeaderSealer, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetHandshakeSealer")
-	ret0, _ := ret[0].(handshake.Sealer)
+	ret0, _ := ret[0].(handshake.LongHeaderSealer)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -154,10 +154,10 @@ func (mr *MockCryptoSetupMockRecorder) GetInitialOpener() *gomock.Call {
 }
 
 // GetInitialSealer mocks base method
-func (m *MockCryptoSetup) GetInitialSealer() (handshake.Sealer, error) {
+func (m *MockCryptoSetup) GetInitialSealer() (handshake.LongHeaderSealer, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetInitialSealer")
-	ret0, _ := ret[0].(handshake.Sealer)
+	ret0, _ := ret[0].(handshake.LongHeaderSealer)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }

internal/mocks/mockgen.go

@@ -2,7 +2,7 @@ package mocks
 
 //go:generate sh -c "mockgen -package mockquic -destination quic/stream.go github.com/lucas-clemente/quic-go Stream && goimports -w quic/stream.go"
 //go:generate sh -c "mockgen -package mockquic -destination quic/session.go github.com/lucas-clemente/quic-go Session && goimports -w quic/session.go"
-//go:generate sh -c "../mockgen_internal.sh mocks sealer.go github.com/lucas-clemente/quic-go/internal/handshake Sealer"
+//go:generate sh -c "../mockgen_internal.sh mocks short_header_sealer.go github.com/lucas-clemente/quic-go/internal/handshake ShortHeaderSealer"
 //go:generate sh -c "../mockgen_internal.sh mocks opener.go github.com/lucas-clemente/quic-go/internal/handshake Opener"
 //go:generate sh -c "../mockgen_internal.sh mocks crypto_setup.go github.com/lucas-clemente/quic-go/internal/handshake CryptoSetup"
 //go:generate sh -c "../mockgen_internal.sh mocks stream_flow_controller.go github.com/lucas-clemente/quic-go/internal/flowcontrol StreamFlowController"

internal/mocks/sealer.go

@@ -1,75 +0,0 @@
-// Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/lucas-clemente/quic-go/internal/handshake (interfaces: Sealer)
-
-// Package mocks is a generated GoMock package.
-package mocks
-
-import (
-	reflect "reflect"
-
-	gomock "github.com/golang/mock/gomock"
-	protocol "github.com/lucas-clemente/quic-go/internal/protocol"
-)
-
-// MockSealer is a mock of Sealer interface
-type MockSealer struct {
-	ctrl     *gomock.Controller
-	recorder *MockSealerMockRecorder
-}
-
-// MockSealerMockRecorder is the mock recorder for MockSealer
-type MockSealerMockRecorder struct {
-	mock *MockSealer
-}
-
-// NewMockSealer creates a new mock instance
-func NewMockSealer(ctrl *gomock.Controller) *MockSealer {
-	mock := &MockSealer{ctrl: ctrl}
-	mock.recorder = &MockSealerMockRecorder{mock}
-	return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use
-func (m *MockSealer) EXPECT() *MockSealerMockRecorder {
-	return m.recorder
-}
-
-// EncryptHeader mocks base method
-func (m *MockSealer) EncryptHeader(arg0 []byte, arg1 *byte, arg2 []byte) {
-	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "EncryptHeader", arg0, arg1, arg2)
-}
-
-// EncryptHeader indicates an expected call of EncryptHeader
-func (mr *MockSealerMockRecorder) EncryptHeader(arg0, arg1, arg2 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EncryptHeader", reflect.TypeOf((*MockSealer)(nil).EncryptHeader), arg0, arg1, arg2)
-}
-
-// Overhead mocks base method
-func (m *MockSealer) Overhead() int {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Overhead")
-	ret0, _ := ret[0].(int)
-	return ret0
-}
-
-// Overhead indicates an expected call of Overhead
-func (mr *MockSealerMockRecorder) Overhead() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Overhead", reflect.TypeOf((*MockSealer)(nil).Overhead))
-}
-
-// Seal mocks base method
-func (m *MockSealer) Seal(arg0, arg1 []byte, arg2 protocol.PacketNumber, arg3 []byte) []byte {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Seal", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].([]byte)
-	return ret0
-}
-
-// Seal indicates an expected call of Seal
-func (mr *MockSealerMockRecorder) Seal(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seal", reflect.TypeOf((*MockSealer)(nil).Seal), arg0, arg1, arg2, arg3)
-}

internal/mocks/short_header_sealer.go

@@ -0,0 +1,89 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/lucas-clemente/quic-go/internal/handshake (interfaces: ShortHeaderSealer)
+
+// Package mocks is a generated GoMock package.
+package mocks
+
+import (
+	reflect "reflect"
+
+	gomock "github.com/golang/mock/gomock"
+	protocol "github.com/lucas-clemente/quic-go/internal/protocol"
+)
+
+// MockShortHeaderSealer is a mock of ShortHeaderSealer interface
+type MockShortHeaderSealer struct {
+	ctrl     *gomock.Controller
+	recorder *MockShortHeaderSealerMockRecorder
+}
+
+// MockShortHeaderSealerMockRecorder is the mock recorder for MockShortHeaderSealer
+type MockShortHeaderSealerMockRecorder struct {
+	mock *MockShortHeaderSealer
+}
+
+// NewMockShortHeaderSealer creates a new mock instance
+func NewMockShortHeaderSealer(ctrl *gomock.Controller) *MockShortHeaderSealer {
+	mock := &MockShortHeaderSealer{ctrl: ctrl}
+	mock.recorder = &MockShortHeaderSealerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockShortHeaderSealer) EXPECT() *MockShortHeaderSealerMockRecorder {
+	return m.recorder
+}
+
+// EncryptHeader mocks base method
+func (m *MockShortHeaderSealer) EncryptHeader(arg0 []byte, arg1 *byte, arg2 []byte) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "EncryptHeader", arg0, arg1, arg2)
+}
+
+// EncryptHeader indicates an expected call of EncryptHeader
+func (mr *MockShortHeaderSealerMockRecorder) EncryptHeader(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EncryptHeader", reflect.TypeOf((*MockShortHeaderSealer)(nil).EncryptHeader), arg0, arg1, arg2)
+}
+
+// KeyPhase mocks base method
+func (m *MockShortHeaderSealer) KeyPhase() protocol.KeyPhase {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "KeyPhase")
+	ret0, _ := ret[0].(protocol.KeyPhase)
+	return ret0
+}
+
+// KeyPhase indicates an expected call of KeyPhase
+func (mr *MockShortHeaderSealerMockRecorder) KeyPhase() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KeyPhase", reflect.TypeOf((*MockShortHeaderSealer)(nil).KeyPhase))
+}
+
+// Overhead mocks base method
+func (m *MockShortHeaderSealer) Overhead() int {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Overhead")
+	ret0, _ := ret[0].(int)
+	return ret0
+}
+
+// Overhead indicates an expected call of Overhead
+func (mr *MockShortHeaderSealerMockRecorder) Overhead() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Overhead", reflect.TypeOf((*MockShortHeaderSealer)(nil).Overhead))
+}
+
+// Seal mocks base method
+func (m *MockShortHeaderSealer) Seal(arg0, arg1 []byte, arg2 protocol.PacketNumber, arg3 []byte) []byte {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Seal", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].([]byte)
+	return ret0
+}
+
+// Seal indicates an expected call of Seal
+func (mr *MockShortHeaderSealerMockRecorder) Seal(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seal", reflect.TypeOf((*MockShortHeaderSealer)(nil).Seal), arg0, arg1, arg2, arg3)
+}