refactor: process conversation proteus/MLS message add event - WPB-10174

WireAPI/Sources/WireAPI/APIs/UpdateEventsAPI/Event decoding/Conversation/ConversationMLSMessageAddEventDecoder.swift

@@ -43,11 +43,17 @@ struct ConversationMLSMessageAddEventDecoder {
             forKey: .payload
         )
 
+        let timestamp = try container.decodeIfPresent(
+            UTCTimeMillis.self,
+            forKey: .timestamp
+        )
+
         return ConversationMLSMessageAddEvent(
             conversationID: conversationID,
             senderID: senderID,
             subconversation: subconversation,
-            message: payload.text
+            message: payload.text,
+            timestamp: timestamp?.date
         )
     }
 

WireAPI/Sources/WireAPI/APIs/UpdateEventsAPI/Event decoding/Conversation/ConversationProteusMessageAddEventDecoder.swift

@@ -47,8 +47,8 @@ struct ConversationProteusMessageAddEventDecoder {
             conversationID: conversationID,
             senderID: senderID,
             timestamp: timestamp.date,
-            message: .ciphertext(payload.text),
-            externalData: payload.data.map { .ciphertext($0) },
+            message: .init(encryptedMessage: payload.text),
+            externalData: payload.data.map { .init(encryptedMessage: $0) },
             messageSenderClientID: payload.sender,
             messageRecipientClientID: payload.recipient
         )

WireAPI/Sources/WireAPI/Models/Messaging/MessageContent.swift

@@ -21,14 +21,14 @@ import Foundation
 /// The contents of a message, typically as a base-64 encoded
 /// Protobuf string.
 
-public enum MessageContent: Equatable, Codable {
+public struct MessageContent: Equatable, Codable, Sendable {
 
     /// Encrypted message content.
 
-    case ciphertext(String)
+    public let encryptedMessage: String
 
     /// Unencrypted message content.
 
-    case plaintext(String)
+    public var decryptedMessage: String?
 
 }

WireAPI/Sources/WireAPI/Models/UpdateEvent/ConversationEvent/ConversationMLSMessageAddEvent.swift

@@ -20,7 +20,22 @@ import Foundation
 
 /// An event where an mls message was received in a conversation.
 
-public struct ConversationMLSMessageAddEvent: Equatable, Codable {
+public struct ConversationMLSMessageAddEvent: Equatable, Codable, Sendable {
+
+    public struct DecryptedMessage: Equatable, Codable, Sendable {
+
+        public let message: String
+
+        public let senderClientID: String?
+
+        public init(
+            message: String,
+            senderClientID: String?
+        ) {
+            self.message = message
+            self.senderClientID = senderClientID
+        }
+    }
 
     /// The id of the conversation.
 
@@ -42,4 +57,13 @@ public struct ConversationMLSMessageAddEvent: Equatable, Codable {
 
     public let message: String
 
+    /// The date the message was received.
+
+    public let timestamp: Date?
+
+    /// The decrypted current message + decrypted buffered messages
+    /// along with the related sender client ID for each message.
+
+    public var decryptedMessages: [DecryptedMessage] = []
+
 }

WireAPI/Sources/WireAPI/Models/UpdateEvent/ConversationEvent/ConversationProteusMessageAddEvent.swift

@@ -20,7 +20,7 @@ import Foundation
 
 /// An event where a proteus message was received in a conversation.
 
-public struct ConversationProteusMessageAddEvent: Equatable, Codable {
+public struct ConversationProteusMessageAddEvent: Equatable, Codable, Sendable {
 
     /// The id of the conversation.
 

WireAPI/Tests/WireAPITests/Network/PushChannel/PushChannelTests.swift

@@ -186,8 +186,8 @@ private enum Scaffolding {
         conversationID: conversationID,
         senderID: senderID,
         timestamp: timestamp,
-        message: .ciphertext("foo"),
-        externalData: .ciphertext("bar"),
+        message: .init(encryptedMessage: "foo"),
+        externalData: .init(encryptedMessage: "bar"),
         messageSenderClientID: "abc123",
         messageRecipientClientID: "def456"
     )

WireAPI/Tests/WireAPITests/UpdateEvent/ConversationEventDecodingTests.swift

@@ -458,7 +458,8 @@ final class ConversationEventDecodingTests: XCTestCase {
             conversationID: conversationID,
             senderID: senderID,
             subconversation: "subconversation",
-            message: "message"
+            message: "message",
+            timestamp: fractionalDate(from: "2024-06-04T15:03:07.598Z")
         )
 
         static let mlsWelcomeEvent = ConversationMLSWelcomeEvent(
@@ -471,8 +472,8 @@ final class ConversationEventDecodingTests: XCTestCase {
             conversationID: conversationID,
             senderID: senderID,
             timestamp: timestamp,
-            message: .ciphertext("foo"),
-            externalData: .ciphertext("bar"),
+            message: .init(encryptedMessage: "foo"),
+            externalData: .init(encryptedMessage: "bar"),
             messageSenderClientID: "abc123",
             messageRecipientClientID: "def456"
         )

WireAPI/Tests/WireAPITests/UpdateEvent/Resources/ConversationMLSMessageAdd.json

@@ -11,5 +11,6 @@
     "subconv": "subconversation",
     "data": {
         "text": "message"
-    }
+    },
+    "time": "2024-06-04T15:03:07.598Z"
 }

WireDomain/Sources/WireDomain/Event Decryption/MLSMessageDecryptor.swift

@@ -0,0 +1,168 @@
+//
+// Wire
+// Copyright (C) 2024 Wire Swiss GmbH
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see http://www.gnu.org/licenses/.
+//
+
+import Foundation
+import WireAPI
+import WireDataModel
+
+// sourcery: AutoMockable
+/// Decrypt MLS messages.
+protocol MLSMessageDecryptorProtocol {
+
+    /// Decrypt a MLS message.
+    ///
+    /// - Parameter eventData: A payload containing the encrypted message.
+    /// - Returns: The payload containing the decrypted message.
+
+    func decryptedEventData(
+        from eventData: ConversationMLSMessageAddEvent
+    ) async throws -> ConversationMLSMessageAddEvent
+
+}
+
+struct MLSMessageDecryptor: MLSMessageDecryptorProtocol {
+
+    let mlsDecryptionService: any MLSDecryptionServiceInterface
+    let mlsService: any MLSServiceInterface
+    let conversationLocalStore: any ConversationLocalStoreProtocol
+
+    func decryptedEventData(
+        from eventData: ConversationMLSMessageAddEvent
+    ) async throws -> ConversationMLSMessageAddEvent {
+        let conversationID = eventData.conversationID
+
+        guard let mlsConversation = await conversationLocalStore.fetchConversation(
+            id: conversationID.uuid,
+            domain: conversationID.domain
+        ) else {
+            WireLogger.mls.error(
+                "failed to add mls message: conversation not found in db"
+            )
+
+            throw MLSMessageDecryptorError.conversationNotFound
+        }
+
+        guard let mlsGroupID = await conversationLocalStore.mlsGroupID(
+            for: mlsConversation
+        ) else {
+            WireLogger.mls.error(
+                "failed to add mls message: missing MLS group ID"
+            )
+
+            throw MLSMessageDecryptorError.missingMLSGroupID
+        }
+
+        guard await conversationLocalStore.isConversationMLSReady(
+            mlsConversation
+        ) else {
+            WireLogger.mls.warn(
+                "failed to add mls message: conversation is not ready"
+            )
+
+            throw MLSMessageDecryptorError.mlsConversationNotReady
+        }
+
+        let decryptionResults = await decryptMLSMessage(
+            message: eventData.message,
+            mlsGroupID: mlsGroupID,
+            subconversation: eventData.subconversation
+        )
+
+        let decryptedMessages = await processMLSMessageDecryptionResults(
+            decryptionResults,
+            mlsConversation: mlsConversation,
+            senderID: eventData.senderID.uuid,
+            senderDomain: eventData.senderID.domain,
+            date: eventData.timestamp
+        )
+
+        var decryptedEvent = eventData
+        decryptedEvent.decryptedMessages = decryptedMessages
+
+        return decryptedEvent
+    }
+
+    private func decryptMLSMessage(
+        message: String,
+        mlsGroupID: MLSGroupID,
+        subconversation: String?
+    ) async -> [MLSDecryptResult] {
+        do {
+            let subconvType = subconversation != nil ? SubgroupType(rawValue: subconversation!) : nil
+
+            let results = try await mlsDecryptionService.decrypt(
+                message: message,
+                for: mlsGroupID,
+                subconversationType: subconvType
+            )
+
+            if results.isEmpty {
+                WireLogger.mls.info(
+                    "successfully decrypted mls message but no result was returned"
+                )
+
+                return []
+            }
+
+            return results
+
+        } catch {
+            WireLogger.mls.warn(
+                "failed to decrypt mls message: \(String(describing: error))"
+            )
+
+            return []
+        }
+    }
+
+    private func processMLSMessageDecryptionResults(
+        _ results: [MLSDecryptResult],
+        mlsConversation: ZMConversation,
+        senderID: UUID,
+        senderDomain: String,
+        date: Date?
+    ) async -> [ConversationMLSMessageAddEvent.DecryptedMessage] {
+        var decryptedMessages: [ConversationMLSMessageAddEvent.DecryptedMessage] = []
+
+        for result in results {
+            switch result {
+            case .message(let decryptedData, let senderClientID):
+                let mlsDecryptedMessage = decryptedData.base64EncodedString()
+                decryptedMessages.append(
+                    .init(
+                        message: mlsDecryptedMessage,
+                        senderClientID: senderClientID
+                    )
+                )
+
+            case .proposal(let commitDelay):
+                let scheduledDate = (date ?? Date.now) + TimeInterval(commitDelay)
+
+                await conversationLocalStore.storeConversation(
+                    commitPendingProposalDate: scheduledDate,
+                    conversation: mlsConversation
+                )
+
+                mlsService.commitPendingProposalsIfNeeded()
+            }
+        }
+
+        return decryptedMessages
+    }
+
+}

WireDomain/Sources/WireDomain/Event Decryption/MLSMessageDecryptorError.swift

@@ -0,0 +1,27 @@
+//
+// Wire
+// Copyright (C) 2024 Wire Swiss GmbH
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see http://www.gnu.org/licenses/.
+//
+
+enum MLSMessageDecryptorError: Error {
+
+    case conversationNotFound
+
+    case missingMLSGroupID
+
+    case mlsConversationNotReady
+
+}