Add final support for injecting messages. Also add support for error handling of malformed messages. Final part of coyim#29

Author: olabini

data_message_test.go

@@ -251,7 +251,7 @@ func Test_processDataMessage_signalsThatMessageIsUnreadableForAGPGConflictError(
 	}, MessageEventReceivedMessageUnreadable, nil, nil)
 }
 
-func Test_processDataMessage_returnsACustomErrorMessageIfOneIsAvailable(t *testing.T) {
+func Test_Receive_returnsACustomErrorMessageIfOneIsAvailable(t *testing.T) {
 	c := newConversation(otrV3{}, rand.Reader)
 	c.ourKey = bobPrivateKey
 
@@ -270,8 +270,9 @@ func Test_processDataMessage_returnsACustomErrorMessageIfOneIsAvailable(t *testi
 			return []byte("white hole happened")
 		}, nil, nil)
 
-	p, _, _ := c.receiveDecoded(msg)
-	assertDeepEquals(t, string(p), "?OTR Error: nova happened")
+	c.receiveDecoded(msg)
+	ts, _ := c.withInjections(nil, nil)
+	assertDeepEquals(t, string(ts[0]), "?OTR Error: nova happened")
 }
 
 func Test_processDataMessage_signalsThatMessageIsMalformedIfSomeOtherErrorHappens(t *testing.T) {
@@ -301,8 +302,9 @@ func Test_processDataMessage_callsErrorMessageHandlerAndReturnsTheResultAsAnOTRE
 			return []byte("dandelion happened")
 		}, nil, nil)
 
-	plain, _, _ := c.receiveDecoded(msg)
-	assertDeepEquals(t, string(plain), "?OTR Error: sunflower happened")
+	c.receiveDecoded(msg)
+	ts, _ := c.withInjections(nil, nil)
+	assertDeepEquals(t, string(ts[0]), "?OTR Error: sunflower happened")
 }
 
 func Test_processDataMessage_shouldNotRotateKeysWhenDecryptFails(t *testing.T) {

fragmentation_test.go

@@ -129,6 +129,27 @@ func Test_receiveFragment_signalsMessageEventIfInstanceTagsDoesNotMatch(t *testi
 	}, MessageEventReceivedMessageForOtherInstance, nil, nil)
 }
 
+func Test_receiveFragment_sendsAnErrorMessageAboutMalformedIfHandlerExists(t *testing.T) {
+	c := newConversation(otrV3{}, rand.Reader)
+	c.ourInstanceTag = 0x103
+	c.theirInstanceTag = 0x0A
+
+	existingContext := fragmentationContext{frag: []byte("shouldn't change")}
+
+	c.eventHandler = emptyEventHandlerWith(
+		func() bool { return true },
+		func(error ErrorCode) []byte {
+			if error == ErrorCodeMessageMalformed {
+				return []byte("black happened")
+			}
+			return []byte("white happened")
+		}, nil, nil)
+
+	c.receiveFragment(existingContext, []byte("?OTR|0000000A|00000103,00001,00004,one ,"))
+	ts, _ := c.withInjections(nil, nil)
+	assertDeepEquals(t, string(ts[0]), "?OTR Error: black happened")
+}
+
 func Test_receiveFragment_signalsMalformedMessageIfTheirInstanceTagIsBelowTheLimit(t *testing.T) {
 	c := newConversation(otrV3{}, rand.Reader)
 	c.ourInstanceTag = 0x103

inject_message.go

@@ -5,12 +5,22 @@ type injections struct {
 }
 
 // injectMessage will promise to send the messages now or later
+// The Injected Messages are promised to be well formed valid messages
+// including fragmentation and encoding
 func (c *Conversation) injectMessage(vm ValidMessage) {
 	c.injections.messages = append(c.injections.messages, vm)
 }
 
-func (c *Conversation) withInjections(vms []ValidMessage) []ValidMessage {
+func (c *Conversation) withInjects(vms []ValidMessage) []ValidMessage {
 	msgs := c.injections.messages
 	c.injections.messages = c.injections.messages[0:0]
 	return append(vms, msgs...)
 }
+
+func (c *Conversation) withInjectionsPlain(plain MessagePlaintext, vms []ValidMessage, err error) (MessagePlaintext, []ValidMessage, error) {
+	return plain, c.withInjects(vms), err
+}
+
+func (c *Conversation) withInjections(vms []ValidMessage, err error) ([]ValidMessage, error) {
+	return c.withInjects(vms), err
+}

otrv3.go

@@ -129,6 +129,7 @@ func (c *Conversation) generateInstanceTag() error {
 
 func malformedMessage(c *Conversation) {
 	messageEventReceivedMalformedMessage(c)
+	c.generatePotentialErrorMessage(ErrorCodeMessageMalformed)
 }
 
 func (v otrV3) parseMessageHeader(c *Conversation, msg []byte) ([]byte, []byte, error) {

receive.go

@@ -113,7 +113,7 @@ func (c *Conversation) receiveDecoded(message messageWithHeader) (plain MessageP
 				messageEventReceivedMalformedMessage(c)
 				e = ErrorCodeMessageMalformed
 			}
-			plain = MessagePlaintext(c.generatePotentialErrorMessage([]ValidMessage{ValidMessage(plain)}, e)[0])
+			c.generatePotentialErrorMessage(e)
 		}
 	} else {
 		toSend, err = c.potentialAuthError(c.receiveAKE(msgType, messageBody))
@@ -135,7 +135,7 @@ func (c *Conversation) Receive(m ValidMessage) (plain MessagePlaintext, toSend [
 	var messagesToSend []messageWithHeader
 	switch msgType {
 	case msgGuessError:
-		return c.receiveErrorMessage(message)
+		return c.withInjectionsPlain(c.receiveErrorMessage(message))
 	case msgGuessQuery:
 		messagesToSend, err = c.receiveQueryMessage(message)
 	case msgGuessTaggedPlaintext:
@@ -147,13 +147,13 @@ func (c *Conversation) Receive(m ValidMessage) (plain MessagePlaintext, toSend [
 	case msgGuessFragment:
 		c.fragmentationContext, err = c.receiveFragment(c.fragmentationContext, message)
 		if fragmentsFinished(c.fragmentationContext) {
-			return c.Receive(c.fragmentationContext.frag)
+			return c.withInjectionsPlain(c.Receive(c.fragmentationContext.frag))
 		}
 	case msgGuessUnknown:
 		messageEventReceivedUnrecognizedMessage(c)
 	case msgGuessDHCommit, msgGuessDHKey, msgGuessRevealSig, msgGuessSignature, msgGuessData:
 		plain, messagesToSend, err = c.receiveEncoded(encodedMessage(message))
 	}
 
-	return c.toSendEncoded(plain, messagesToSend, err)
+	return c.withInjectionsPlain(c.toSendEncoded(plain, messagesToSend, err))
 }

send.go

@@ -14,15 +14,15 @@ func (c *Conversation) Send(m ValidMessage) ([]ValidMessage, error) {
 
 	switch c.msgState {
 	case plainText:
-		return c.sendMessageOnPlaintext(message)
+		return c.withInjections(c.sendMessageOnPlaintext(message))
 	case encrypted:
-		return c.sendMessageOnEncrypted(message)
+		return c.withInjections(c.sendMessageOnEncrypted(message))
 	case finished:
 		messageEventConnectionEnded(c)
-		return nil, errors.New("otr: cannot send message because secure conversation has finished")
+		return c.withInjections(nil, errors.New("otr: cannot send message because secure conversation has finished"))
 	}
 
-	return nil, errors.New("otr: cannot send message in current state")
+	return c.withInjections(nil, errors.New("otr: cannot send message in current state"))
 }
 
 func (c *Conversation) sendMessageOnPlaintext(message ValidMessage) ([]ValidMessage, error) {
@@ -41,19 +41,18 @@ func (c *Conversation) sendMessageOnPlaintext(message ValidMessage) ([]ValidMess
 	return []ValidMessage{makeCopy(message)}, nil
 }
 
-func (c *Conversation) generatePotentialErrorMessage(before []ValidMessage, ec ErrorCode) []ValidMessage {
+func (c *Conversation) generatePotentialErrorMessage(ec ErrorCode) {
 	if c.getEventHandler().WishToHandleErrorMessage() {
 		msg := c.getEventHandler().HandleErrorMessage(ec)
-		return []ValidMessage{append(append(errorMarker, ' '), msg...)}
+		c.injectMessage(append(append(errorMarker, ' '), msg...))
 	}
-	return before
 }
 
 func (c *Conversation) sendMessageOnEncrypted(message ValidMessage) ([]ValidMessage, error) {
 	result, err := c.createSerializedDataMessage(message, messageFlagNormal, []tlv{})
 	if err != nil {
 		messageEventEncryptionError(c)
-		result = c.generatePotentialErrorMessage(result, ErrorCodeEncryptionError)
+		c.generatePotentialErrorMessage(ErrorCodeEncryptionError)
 	}
 
 	return result, err