Propoage SendE2e refactor across the stack

auth/utils_test.go

@@ -62,8 +62,8 @@ func (m mockE2eHandler) StartProcesses() (stoppable.Stoppable, error) {
 
 func (m mockE2eHandler) SendE2E(mt catalog.MessageType, recipient *id.ID,
 	payload []byte, params e2e.Params) ([]id.Round, cryptoE2e.MessageID,
-	time.Time, error) {
-	return nil, cryptoE2e.MessageID{}, time.Time{}, nil
+	time.Time, cryptoE2e.KeyResidue, error) {
+	return nil, cryptoE2e.MessageID{}, time.Time{}, cryptoE2e.KeyResidue{}, nil
 }
 
 func (m mockE2eHandler) RegisterListener(senderID *id.ID,

bindings/connect.go

@@ -85,7 +85,7 @@ func (c *Cmix) Connect(e2eId int, recipientContact, e2eParamsJSON []byte) (
 //  - []byte - the JSON marshalled bytes of the E2ESendReport object, which can
 //    be passed into Cmix.WaitForRoundResult to see if the send succeeded.
 func (c *Connection) SendE2E(mt int, payload []byte) ([]byte, error) {
-	rounds, mid, ts, err := c.connection.SendE2E(catalog.MessageType(mt), payload,
+	rounds, mid, ts, keyResidue, err := c.connection.SendE2E(catalog.MessageType(mt), payload,
 		c.params.Base)
 
 	if err != nil {
@@ -96,6 +96,7 @@ func (c *Connection) SendE2E(mt int, payload []byte) ([]byte, error) {
 		RoundsList: makeRoundsList(rounds...),
 		MessageID:  mid.Marshal(),
 		Timestamp:  ts.UnixNano(),
+		KeyResidue: keyResidue,
 	}
 
 	return json.Marshal(&sr)

bindings/e2eHandler.go

@@ -33,6 +33,8 @@ type E2ESendReport struct {
 	RoundsList
 	MessageID []byte
 	Timestamp int64
+	// todo: make marshal function
+	KeyResidue []byte
 }
 
 // GetReceptionID returns the marshalled default IDs.
@@ -133,7 +135,7 @@ func (e *E2e) SendE2E(messageType int, recipientId, payload,
 		return nil, err
 	}
 
-	roundIds, messageId, ts, err := e.api.GetE2E().SendE2E(
+	roundIds, messageId, ts, keyResidue, err := e.api.GetE2E().SendE2E(
 		catalog.MessageType(messageType), recipient, payload, params)
 	if err != nil {
 		return nil, err
@@ -143,6 +145,7 @@ func (e *E2e) SendE2E(messageType int, recipientId, payload,
 		RoundsList: makeRoundsList(roundIds...),
 		MessageID:  messageId.Marshal(),
 		Timestamp:  ts.UnixNano(),
+		KeyResidue: keyResidue,
 	}
 	return json.Marshal(result)
 }

cmd/connect.go

@@ -486,7 +486,7 @@ func miscConnectionFunctions(user *xxdk.E2e, conn connect.Connection) {
 			conn.GetPartner().PartnerId())
 		payload := []byte(msgBody)
 		for {
-			roundIDs, _, _, err := conn.SendE2E(catalog.XxMessage, payload,
+			roundIDs, _, _, _, err := conn.SendE2E(catalog.XxMessage, payload,
 				paramsE2E)
 			if err != nil {
 				jww.FATAL.Panicf("[CONN] Failed to send E2E message: %v", err)

cmd/root.go

@@ -288,7 +288,7 @@ var rootCmd = &cobra.Command{
 								e2eParams.Base)
 						} else {
 							e2eParams.Base.DebugTag = "cmd.E2E"
-							roundIDs, _, _, err = user.GetE2E().SendE2E(mt,
+							roundIDs, _, _, _, err = user.GetE2E().SendE2E(mt,
 								recipient, payload, e2eParams.Base)
 						}
 						if err != nil {

connect/authenticated.go

@@ -98,7 +98,7 @@ func connectWithAuthentication(conn Connection, timeStart time.Time,
 	}
 
 	// Send message to server
-	rids, _, _, err := conn.SendE2E(catalog.ConnectionAuthenticationRequest,
+	rids, _, _, _, err := conn.SendE2E(catalog.ConnectionAuthenticationRequest,
 		payload, clientE2e.GetDefaultParams())
 	if err != nil {
 		// Close connection on an error

connect/connect.go

@@ -43,7 +43,7 @@ type Connection interface {
 	// SendE2E is a wrapper for sending specifically to the Connection's
 	// partner.Manager
 	SendE2E(mt catalog.MessageType, payload []byte, params clientE2e.Params) (
-		[]id.Round, e2e.MessageID, time.Time, error)
+		[]id.Round, e2e.MessageID, time.Time, e2e.KeyResidue, error)
 
 	// RegisterListener is used for E2E reception
 	// and allows for reading data sent from the partner.Manager
@@ -221,9 +221,9 @@ func (h *handler) GetPartner() partner.Manager {
 // SendE2E is a wrapper for sending specifically to the Connection's
 // partner.Manager.
 func (h *handler) SendE2E(mt catalog.MessageType, payload []byte,
-	params clientE2e.Params) ([]id.Round, e2e.MessageID, time.Time, error) {
+	params clientE2e.Params) ([]id.Round, e2e.MessageID, time.Time, e2e.KeyResidue, error) {
 	if h.isClosed() {
-		return nil, e2e.MessageID{}, time.Time{}, alreadyClosedErr
+		return nil, e2e.MessageID{}, time.Time{}, e2e.KeyResidue{}, alreadyClosedErr
 	}
 
 	h.updateLastUse(netTime.Now())

connect/utils_test.go

@@ -116,7 +116,7 @@ func (m *mockConnection) GetPartner() partner.Manager { return m.partner }
 
 func (m *mockConnection) SendE2E(
 	mt catalog.MessageType, payload []byte, _ e2e.Params) (
-	[]id.Round, cryptoE2e.MessageID, time.Time, error) {
+	[]id.Round, cryptoE2e.MessageID, time.Time, cryptoE2e.KeyResidue, error) {
 	m.payloadChan <- payload
 	m.listener.Hear(receive.Message{
 		MessageType: mt,
@@ -124,7 +124,7 @@ func (m *mockConnection) SendE2E(
 		Sender:      m.partner.myID,
 		RecipientID: m.partner.partnerId,
 	})
-	return nil, cryptoE2e.MessageID{}, time.Time{}, nil
+	return nil, cryptoE2e.MessageID{}, time.Time{}, cryptoE2e.KeyResidue{}, nil
 }
 
 func (m *mockConnection) RegisterListener(

fileTransfer/connect/send.go

@@ -45,7 +45,7 @@ func sendNewFileTransferMessage(
 	params.LastServiceTag = catalog.Silent
 	params.DebugTag = initialMessageDebugTag
 
-	_, _, _, err := connectionHandler.SendE2E(
+	_, _, _, _, err := connectionHandler.SendE2E(
 		catalog.NewFileTransfer, transferInfo, params)
 	if err != nil {
 		return errors.Errorf(errNewFtSendE2e, err)
@@ -65,7 +65,7 @@ func sendEndFileTransferMessage(cmix ft.Cmix, connectionHandler connection) {
 				params.LastServiceTag = catalog.EndFT
 				params.DebugTag = lastMessageDebugTag
 
-				_, _, _, err := connectionHandler.SendE2E(
+				_, _, _, _, err := connectionHandler.SendE2E(
 					catalog.EndFileTransfer, nil, params)
 				if err != nil {
 					jww.ERROR.Printf(errEndFtSendE2e, err)

fileTransfer/connect/utils_test.go

@@ -268,7 +268,8 @@ func (m *mockConnection) GetPartner() partner.Manager {
 
 // SendE2E adds the message to the e2e handler map.
 func (m *mockConnection) SendE2E(mt catalog.MessageType, payload []byte,
-	_ e2e.Params) ([]id.Round, e2eCrypto.MessageID, time.Time, error) {
+	_ e2e.Params) ([]id.Round, e2eCrypto.MessageID, time.Time,
+	e2eCrypto.KeyResidue, error) {
 	m.handler.Lock()
 	defer m.handler.Unlock()
 
@@ -278,7 +279,8 @@ func (m *mockConnection) SendE2E(mt catalog.MessageType, payload []byte,
 		Sender:      m.myID,
 	})
 
-	return []id.Round{42}, e2eCrypto.MessageID{}, netTime.Now(), nil
+	return []id.Round{42}, e2eCrypto.MessageID{}, netTime.Now(),
+		e2eCrypto.KeyResidue{}, nil
 }
 
 func (m *mockConnection) RegisterListener(mt catalog.MessageType,

fileTransfer/connect/wrapper.go

@@ -41,7 +41,7 @@ type Wrapper struct {
 type connection interface {
 	GetPartner() partner.Manager
 	SendE2E(mt catalog.MessageType, payload []byte, params e2e.Params) (
-		[]id.Round, e2eCrypto.MessageID, time.Time, error)
+		[]id.Round, e2eCrypto.MessageID, time.Time, e2eCrypto.KeyResidue, error)
 	RegisterListener(messageType catalog.MessageType,
 		newListener receive.Listener) (receive.ListenerID, error)
 }

fileTransfer/e2e/send.go

@@ -46,7 +46,7 @@ func sendNewFileTransferMessage(
 	params.LastServiceTag = catalog.Silent
 	params.DebugTag = initialMessageDebugTag
 
-	_, _, _, err := e2eHandler.SendE2E(
+	_, _, _, _, err := e2eHandler.SendE2E(
 		catalog.NewFileTransfer, recipient, transferInfo, params)
 	if err != nil {
 		return errors.Errorf(errNewFtSendE2e, err)
@@ -66,7 +66,7 @@ func sendEndFileTransferMessage(recipient *id.ID, cmix ft.Cmix, e2eHandler e2eHa
 				params.LastServiceTag = catalog.EndFT
 				params.DebugTag = lastMessageDebugTag
 
-				_, _, _, err := e2eHandler.SendE2E(
+				_, _, _, _, err := e2eHandler.SendE2E(
 					catalog.EndFileTransfer, recipient, nil, params)
 				if err != nil {
 					jww.ERROR.Printf(errEndFtSendE2e, err)

fileTransfer/e2e/utils_test.go

@@ -259,7 +259,7 @@ func (m *mockE2e) StartProcesses() (stoppable.Stoppable, error) { panic("impleme
 
 // SendE2E adds the message to the e2e handler map.
 func (m *mockE2e) SendE2E(mt catalog.MessageType, recipient *id.ID,
-	payload []byte, _ e2e.Params) ([]id.Round, e.MessageID, time.Time, error) {
+	payload []byte, _ e2e.Params) ([]id.Round, e.MessageID, time.Time, e.KeyResidue, error) {
 
 	m.handler.listeners[mt].Hear(receive.Message{
 		MessageType: mt,
@@ -268,7 +268,7 @@ func (m *mockE2e) SendE2E(mt catalog.MessageType, recipient *id.ID,
 		RecipientID: recipient,
 	})
 
-	return []id.Round{42}, e.MessageID{}, netTime.Now(), nil
+	return []id.Round{42}, e.MessageID{}, netTime.Now(), e.KeyResidue{}, nil
 }
 
 func (m *mockE2e) RegisterListener(_ *id.ID, mt catalog.MessageType,

fileTransfer/e2e/wrapper.go

@@ -39,7 +39,8 @@ type Wrapper struct {
 // for easier testing.
 type e2eHandler interface {
 	SendE2E(mt catalog.MessageType, recipient *id.ID, payload []byte,
-		params e2e.Params) ([]id.Round, e2eCrypto.MessageID, time.Time, error)
+		params e2e.Params) ([]id.Round, e2eCrypto.MessageID, time.Time,
+		e2eCrypto.KeyResidue, error)
 	RegisterListener(senderID *id.ID, messageType catalog.MessageType,
 		newListener receive.Listener) receive.ListenerID
 }

groupChat/e2eManager_test.go

@@ -66,15 +66,15 @@ func (tnm *testE2eManager) GetE2eMsg(i int) testE2eMessage {
 
 func (tnm *testE2eManager) SendE2E(_ catalog.MessageType, recipient *id.ID,
 	payload []byte, _ clientE2E.Params) ([]id.Round, e2e.MessageID, time.Time,
-	error) {
+	e2e.KeyResidue, error) {
 	tnm.Lock()
 	defer tnm.Unlock()
 
 	tnm.errSkip++
 	if tnm.sendErr == 1 {
-		return nil, e2e.MessageID{}, time.Time{}, errors.New("SendE2E error")
+		return nil, e2e.MessageID{}, time.Time{}, e2e.KeyResidue{}, errors.New("SendE2E error")
 	} else if tnm.sendErr == 2 && tnm.errSkip%2 == 0 {
-		return nil, e2e.MessageID{}, time.Time{}, errors.New("SendE2E error")
+		return nil, e2e.MessageID{}, time.Time{}, e2e.KeyResidue{}, errors.New("SendE2E error")
 	}
 
 	tnm.e2eMessages = append(tnm.e2eMessages, testE2eMessage{
@@ -82,7 +82,7 @@ func (tnm *testE2eManager) SendE2E(_ catalog.MessageType, recipient *id.ID,
 		Payload:   payload,
 	})
 
-	return []id.Round{0, 1, 2, 3}, e2e.MessageID{}, time.Time{}, nil
+	return []id.Round{0, 1, 2, 3}, e2e.MessageID{}, time.Time{}, e2e.KeyResidue{}, nil
 }
 
 func (*testE2eManager) RegisterListener(*id.ID, catalog.MessageType, receive.Listener) receive.ListenerID {

groupChat/interface.go

@@ -126,7 +126,7 @@ type groupCmix interface {
 // needed by GroupChat
 type groupE2eHandler interface {
 	SendE2E(mt catalog.MessageType, recipient *id.ID, payload []byte,
-		params e2e.Params) ([]id.Round, crypto.MessageID, time.Time, error)
+		params e2e.Params) ([]id.Round, crypto.MessageID, time.Time, crypto.KeyResidue, error)
 	RegisterListener(senderID *id.ID, messageType catalog.MessageType,
 		newListener receive.Listener) receive.ListenerID
 	AddService(tag string, processor message.Processor) error

groupChat/sendRequests.go

@@ -120,7 +120,7 @@ func (m *manager) sendRequest(memberID *id.ID, request []byte) ([]id.Round, erro
 	p.LastServiceTag = catalog.GroupRq
 	p.DebugTag = "group.Request"
 
-	rounds, _, _, err := m.getE2eHandler().SendE2E(
+	rounds, _, _, _, err := m.getE2eHandler().SendE2E(
 		catalog.GroupCreationRequest, memberID, request, p)
 	if err != nil {
 		return nil, errors.Errorf(sendE2eErr, memberID, err)

restlike/connect/receiver.go

@@ -55,7 +55,7 @@ func respond(response *restlike.Message, conn connect.Connection) error {
 	}
 
 	// TODO: Parameterize params
-	_, _, _, err = conn.SendE2E(catalog.XxMessage, payload, e2e.GetDefaultParams())
+	_, _, _, _, err = conn.SendE2E(catalog.XxMessage, payload, e2e.GetDefaultParams())
 	if err != nil {
 		return errors.Errorf("unable to send restlike response message: %+v", err)
 	}

restlike/connect/request.go

@@ -49,7 +49,8 @@ func (s *Request) Request(method restlike.Method, path restlike.URI,
 	s.Net.RegisterListener(catalog.XxMessage, &response{responseCallback: cb})
 
 	// Transmit the Message
-	_, _, _, err = s.Net.SendE2E(catalog.XxMessage, msg, e2eParams)
+	// fixme: should this use the key residue?
+	_, _, _, _, err = s.Net.SendE2E(catalog.XxMessage, msg, e2eParams)
 	if err != nil {
 		return nil, err
 	}
@@ -84,6 +85,7 @@ func (s *Request) AsyncRequest(method restlike.Method, path restlike.URI,
 	s.Net.RegisterListener(catalog.XxMessage, &response{responseCallback: cb})
 
 	// Transmit the Message
-	_, _, _, err = s.Net.SendE2E(catalog.XxMessage, msg, e2eParams)
+	// fixme: should this use the key residue?
+	_, _, _, _, err = s.Net.SendE2E(catalog.XxMessage, msg, e2eParams)
 	return err
 }

ud/mockE2e_test.go

@@ -109,7 +109,7 @@ func (m mockE2eHandler) StartProcesses() (stoppable.Stoppable, error) {
 	panic("implement me")
 }
 
-func (m mockE2eHandler) SendE2E(mt catalog.MessageType, recipient *id.ID, payload []byte, params e2e.Params) ([]id.Round, cryptoE2e.MessageID, time.Time, error) {
+func (m mockE2eHandler) SendE2E(mt catalog.MessageType, recipient *id.ID, payload []byte, params e2e.Params) ([]id.Round, cryptoE2e.MessageID, time.Time, cryptoE2e.KeyResidue, error) {
 	//TODO implement me
 	panic("implement me")
 }