Simon/feat/decrypt targeted message

cc-book/src/unreleased/migration_guide.md

@@ -11,13 +11,14 @@
 
 ## DecryptedMessage
 
-`DecryptedMessage` is now an enum with `Text`, `Commit`, and `Proposal` variants. Data that was previously exposed
-through optional properties is now carried by the corresponding variant. Match on the variant before accessing its data:
+`DecryptedMessage` is now an enum with `ApplicationMessage`, `Commit`, and `Proposal` variants. Data that was previously
+exposed through optional properties is now carried by the corresponding variant. Match on the variant before accessing
+its data:
 
 <!-- langtabs-start -->
 
 ```typescript
-if (DecryptedMessage.Text.instanceOf(decryptedMessage)) {
+if (DecryptedMessage.ApplicationMessage.instanceOf(decryptedMessage)) {
     const { plaintext, senderClientId, identity } = decryptedMessage.inner;
     // Handle the application message.
 } else if (DecryptedMessage.Commit.instanceOf(decryptedMessage)) {
@@ -31,7 +32,7 @@ if (DecryptedMessage.Text.instanceOf(decryptedMessage)) {
 
 ```swift
 switch decryptedMessage {
-case let .text(plaintext, senderClientId, identity):
+case let .applicationMessage(plaintext, senderClientId, identity):
     // Handle the application message.
 case let .commit(isActive, bufferedMessages, identity):
     // Handle the commit.
@@ -42,7 +43,7 @@ case let .proposal(delay, identity):
 
 ```kotlin
 when (decryptedMessage) {
-    is DecryptedMessage.Text -> {
+    is DecryptedMessage.ApplicationMessage -> {
         val (plaintext, senderClientId, identity) = decryptedMessage
         // Handle the application message.
     }

crypto-ffi/bindings/js/shared/shared/utils.ts

@@ -423,10 +423,10 @@ async function setHelpers() {
                 );
 
                 if (
-                    ccModule.DecryptedMessage.Text.instanceOf(
+                    ccModule.DecryptedMessage.ApplicationMessage.instanceOf(
                         decryptedByClient1
                     ) &&
-                    ccModule.DecryptedMessage.Text.instanceOf(
+                    ccModule.DecryptedMessage.ApplicationMessage.instanceOf(
                         decryptedByClient2
                     )
                 ) {

crypto-ffi/bindings/js/shared/src/CoreCrypto.ts

@@ -85,5 +85,6 @@ export {
     HttpMethod,
     X509CredentialAcquisitionConfiguration,
     type Timestamp,
+    TargetedMessagePolicy,
     type MlsTransport,
 } from "#core-crypto-ffi";

crypto-ffi/bindings/js/shared/test/conversation.test.ts

@@ -45,4 +45,66 @@ describe("conversation", () => {
         expect(decryptedByAlice).to.equal(messageText);
         expect(decryptedByBob).to.equal(messageText);
     });
+
+    it("should allow decrypting targeted messages", async () => {
+        const results = await runOnPlatform(async () => {
+            const alice = await helpers.ccInit();
+            const bobId = helpers.newClientId();
+            const bob = await helpers.ccInit({ clientId: bobId });
+            const conversationId = await helpers.createConversation(alice);
+            await helpers.invite(alice, bob, conversationId);
+
+            const persistedMessage = new TextEncoder().encode(
+                "This persisted message targets Bob"
+            );
+            const persistedCiphertext = await alice.transaction((ctx) =>
+                ctx.encryptTargetedMessage(
+                    conversationId,
+                    bobId,
+                    ccModule.TargetedMessagePolicy.Persisted,
+                    persistedMessage
+                )
+            );
+            const persistedDecrypted = await bob.transaction((ctx) =>
+                ctx.decryptMessage(conversationId, persistedCiphertext)
+            );
+
+            const transientMessage = new TextEncoder().encode(
+                "This transient message targets Bob"
+            );
+            const transientCiphertext = await alice.transaction((ctx) =>
+                ctx.encryptTargetedMessage(
+                    conversationId,
+                    bobId,
+                    ccModule.TargetedMessagePolicy.Transient,
+                    transientMessage
+                )
+            );
+            const transientDecrypted = await bob.transaction((ctx) =>
+                ctx.decryptMessage(conversationId, transientCiphertext)
+            );
+
+            const decoder = new TextDecoder();
+
+            return {
+                persistedMessage: decoder.decode(persistedMessage),
+                persistedPlaintext:
+                    ccModule.DecryptedMessage.PersistedTargeted.instanceOf(
+                        persistedDecrypted
+                    )
+                        ? decoder.decode(persistedDecrypted.inner.plaintext)
+                        : "wrong decrypted variant",
+                transientMessage: decoder.decode(transientMessage),
+                transientPlaintext:
+                    ccModule.DecryptedMessage.TransientTargeted.instanceOf(
+                        transientDecrypted
+                    )
+                        ? decoder.decode(transientDecrypted.inner.plaintext)
+                        : "wrong decrypted variant",
+            };
+        });
+
+        expect(results.persistedPlaintext).to.equal(results.persistedMessage);
+        expect(results.transientPlaintext).to.equal(results.transientMessage);
+    });
 });

crypto-ffi/bindings/shared/src/commonTest/kotlin/com/wire/crypto/MLSTest.kt

@@ -222,7 +222,7 @@ class MLSTest {
 
         val plaintextMsg =
             bob.transaction { ctx ->
-                assertIs<DecryptedMessage.Text>(ctx.decryptMessage(groupId, ciphertextMsg)).plaintext
+                assertIs<DecryptedMessage.ApplicationMessage>(ctx.decryptMessage(groupId, ciphertextMsg)).plaintext
             }
         assertThat(plaintextMsg).isNotEmpty().isEqualTo(msg)
 
@@ -233,6 +233,52 @@ class MLSTest {
         assertIs<MlsException.DuplicateMessage>(expectedException.mlsError)
     }
 
+    @Test
+    fun encryptTargetedMessage_should_encrypt_then_receiver_should_decrypt() = runTest {
+        val alice = ccInit()
+        val bobId = genClientId()
+        val bob = ccInit(CcInitOptions(clientId = bobId))
+
+        val conversationId = createConversation(alice)
+        invite(alice, bob, conversationId)
+
+        val persistedMessage = "This persisted message targets Bob".toByteArray()
+        val persistedCiphertext = alice.transaction { ctx ->
+            ctx.encryptTargetedMessage(
+                conversationId,
+                bobId,
+                TargetedMessagePolicy.PERSISTED,
+                persistedMessage
+            )
+        }
+        assertThat(persistedCiphertext).isNotEqualTo(persistedMessage)
+
+        val persistedPlaintext = bob.transaction { ctx ->
+            assertIs<DecryptedMessage.PersistedTargeted>(
+                ctx.decryptMessage(conversationId, persistedCiphertext)
+            ).plaintext
+        }
+        assertThat(persistedPlaintext).isEqualTo(persistedMessage)
+
+        val transientMessage = "This transient message targets Bob".toByteArray()
+        val transientCiphertext = alice.transaction { ctx ->
+            ctx.encryptTargetedMessage(
+                conversationId,
+                bobId,
+                TargetedMessagePolicy.TRANSIENT,
+                transientMessage
+            )
+        }
+        assertThat(transientCiphertext).isNotEqualTo(transientMessage)
+
+        val transientPlaintext = bob.transaction { ctx ->
+            assertIs<DecryptedMessage.TransientTargeted>(
+                ctx.decryptMessage(conversationId, transientCiphertext)
+            ).plaintext
+        }
+        assertThat(transientPlaintext).isEqualTo(transientMessage)
+    }
+
     @Test
     fun addClientsToConversation_should_add_members_to_the_MLS_group() = runTest {
         val aliceId = genClientId()

crypto-ffi/bindings/swift/WireCoreCrypto/WireCoreCryptoTests/WireCoreCryptoTests.swift

@@ -597,7 +597,7 @@ final class WireCoreCryptoTests: XCTestCase {
         let decrypted = try await bob.transaction { ctx in
             try await ctx.decryptMessage(conversationId: conversationId, payload: ciphertext)
         }
-        guard case .text(let plaintext, _, _) = decrypted else {
+        guard case .applicationMessage(let plaintext, _, _) = decrypted else {
             XCTFail("Expected decrypted text")
             return
         }
@@ -612,6 +612,61 @@ final class WireCoreCryptoTests: XCTestCase {
         }
     }
 
+    func testTargetedMessagesCanBeDecryptedByReceiver() async throws {
+        let alice = try await ccInit()
+        let bobId = genClientId()
+        let bob = try await ccInit(options: CcInitOptions(clientId: bobId))
+
+        let conversationId = try await createConversation(coreCrypto: alice)
+        _ = try await invite(cc1: alice, cc2: bob, conversationId: conversationId)
+
+        let persistedMessage = Data("This persisted message targets Bob".utf8)
+        let persistedCiphertext = try await alice.transaction { ctx in
+            try await ctx.encryptTargetedMessage(
+                conversationId: conversationId,
+                recipient: bobId,
+                policy: .persisted,
+                message: persistedMessage
+            )
+        }
+        XCTAssertNotEqual(persistedCiphertext, persistedMessage)
+
+        let persistedDecrypted = try await bob.transaction { ctx in
+            try await ctx.decryptMessage(
+                conversationId: conversationId,
+                payload: persistedCiphertext
+            )
+        }
+        guard case .persistedTargeted(let plaintext, _, _) = persistedDecrypted else {
+            XCTFail("Expected a decrypted persisted targeted message")
+            return
+        }
+        XCTAssertEqual(plaintext, persistedMessage)
+
+        let transientMessage = Data("This transient message targets Bob".utf8)
+        let transientCiphertext = try await alice.transaction { ctx in
+            try await ctx.encryptTargetedMessage(
+                conversationId: conversationId,
+                recipient: bobId,
+                policy: .transient,
+                message: transientMessage
+            )
+        }
+        XCTAssertNotEqual(transientCiphertext, transientMessage)
+
+        let transientDecrypted = try await bob.transaction { ctx in
+            try await ctx.decryptMessage(
+                conversationId: conversationId,
+                payload: transientCiphertext
+            )
+        }
+        guard case .transientTargeted(let plaintext, _, _) = transientDecrypted else {
+            XCTFail("Expected a decrypted transient targeted message")
+            return
+        }
+        XCTAssertEqual(plaintext, transientMessage)
+    }
+
     func testRegisterEpochObserverShouldNotifyObserverOnNewEpoch() async throws {
         struct Epoch: Equatable {
             let conversationId: ConversationId

crypto-ffi/src/decrypted_message.rs

@@ -7,8 +7,8 @@ use crate::{ClientId, WireIdentity};
 /// Represents the items a consumer might require after decrypting a message.
 #[derive(Debug, uniffi::Enum)]
 pub enum DecryptedMessage {
-    /// The decrypted message is a text message.
-    Text {
+    /// The decrypted message is an MLS application message.
+    ApplicationMessage {
         /// Decrypted text message.
         plaintext: Vec<u8>,
         /// The sender's `ClientId`.
@@ -37,15 +37,33 @@ pub enum DecryptedMessage {
         /// Identity claims present in the sender credential.
         identity: WireIdentity,
     },
+    /// The decrypted message is a transient targeted message.
+    TransientTargeted {
+        /// Decrypted text message.
+        plaintext: Vec<u8>,
+        /// The sender's `ClientId`.
+        sender_client_id: Arc<ClientId>,
+        /// Identity claims present in the sender credential.
+        identity: WireIdentity,
+    },
+    /// The decrypted message is a persisted targeted message.
+    PersistedTargeted {
+        /// Decrypted text message.
+        plaintext: Vec<u8>,
+        /// The sender's `ClientId`.
+        sender_client_id: Arc<ClientId>,
+        /// Identity claims present in the sender credential.
+        identity: WireIdentity,
+    },
 }
 
 impl From<CcDecryptedMessage> for DecryptedMessage {
     fn from(from: CcDecryptedMessage) -> Self {
         match from {
-            CcDecryptedMessage::Text(text) => Self::Text {
-                plaintext: text.plaintext,
-                sender_client_id: Arc::new(text.sender_client_id.into()),
-                identity: text.identity.into(),
+            CcDecryptedMessage::ApplicationMessage(message) => Self::ApplicationMessage {
+                plaintext: message.plaintext,
+                sender_client_id: Arc::new(message.sender_client_id.into()),
+                identity: message.identity.into(),
             },
             CcDecryptedMessage::Commit(commit) => Self::Commit {
                 is_active: commit.is_active,
@@ -58,6 +76,16 @@ impl From<CcDecryptedMessage> for DecryptedMessage {
                 delay: proposal.delay,
                 identity: proposal.identity.into(),
             },
+            CcDecryptedMessage::TransientTargeted(message) => Self::TransientTargeted {
+                plaintext: message.plaintext,
+                sender_client_id: Arc::new(message.sender_client_id.into()),
+                identity: message.identity.into(),
+            },
+            CcDecryptedMessage::PersistedTargeted(message) => Self::PersistedTargeted {
+                plaintext: message.plaintext,
+                sender_client_id: Arc::new(message.sender_client_id.into()),
+                identity: message.identity.into(),
+            },
         }
     }
 }
@@ -66,8 +94,8 @@ impl From<CcDecryptedMessage> for DecryptedMessage {
 /// It represents messages for the new epoch that arrived before the commit that created it.
 #[derive(Debug, uniffi::Enum)]
 pub enum BufferedDecryptedMessage {
-    /// The decrypted message is a text message.
-    Text {
+    /// The decrypted message is an MLS application message.
+    ApplicationMessage {
         /// Decrypted text message.
         plaintext: Vec<u8>,
         /// The sender's `ClientId`.
@@ -93,15 +121,33 @@ pub enum BufferedDecryptedMessage {
         /// Identity claims present in the sender credential.
         identity: WireIdentity,
     },
+    /// The decrypted message is a transient targeted message.
+    TransientTargeted {
+        /// Decrypted text message.
+        plaintext: Vec<u8>,
+        /// The sender's `ClientId`.
+        sender_client_id: Arc<ClientId>,
+        /// Identity claims present in the sender credential.
+        identity: WireIdentity,
+    },
+    /// The decrypted message is a persisted targeted message.
+    PersistedTargeted {
+        /// Decrypted text message.
+        plaintext: Vec<u8>,
+        /// The sender's `ClientId`.
+        sender_client_id: Arc<ClientId>,
+        /// Identity claims present in the sender credential.
+        identity: WireIdentity,
+    },
 }
 
 impl From<CcBufferedDecryptedMessage> for BufferedDecryptedMessage {
     fn from(from: CcBufferedDecryptedMessage) -> Self {
         match from {
-            CcBufferedDecryptedMessage::Text(text) => Self::Text {
-                plaintext: text.plaintext,
-                sender_client_id: Arc::new(text.sender_client_id.into()),
-                identity: text.identity.into(),
+            CcBufferedDecryptedMessage::ApplicationMessage(message) => Self::ApplicationMessage {
+                plaintext: message.plaintext,
+                sender_client_id: Arc::new(message.sender_client_id.into()),
+                identity: message.identity.into(),
             },
             CcBufferedDecryptedMessage::Commit(commit) => Self::Commit {
                 is_active: commit.is_active,
@@ -111,6 +157,16 @@ impl From<CcBufferedDecryptedMessage> for BufferedDecryptedMessage {
                 delay: proposal.delay,
                 identity: proposal.identity.into(),
             },
+            CcBufferedDecryptedMessage::TransientTargeted(message) => Self::TransientTargeted {
+                plaintext: message.plaintext,
+                sender_client_id: Arc::new(message.sender_client_id.into()),
+                identity: message.identity.into(),
+            },
+            CcBufferedDecryptedMessage::PersistedTargeted(message) => Self::PersistedTargeted {
+                plaintext: message.plaintext,
+                sender_client_id: Arc::new(message.sender_client_id.into()),
+                identity: message.identity.into(),
+            },
         }
     }
 }

crypto/src/lib.rs

@@ -59,8 +59,8 @@ pub use crate::{
         cipher_suite::CipherSuite,
         conversation::{
             BufferedCommit, BufferedDecryptedMessage, Commit, CommitBundle, ConversationConfiguration, ConversationId,
-            CustomConfiguration, DecryptedMessage, GroupInfoBundle, GroupInfoEncryptionType, GroupInfoPayload,
-            Proposal, RatchetTreeType, Text, WirePolicy,
+            CustomConfiguration, DecryptedBytes, DecryptedMessage, GroupInfoBundle, GroupInfoEncryptionType,
+            GroupInfoPayload, Proposal, RatchetTreeType, WirePolicy,
         },
         credential::{
             Credential, CredentialRef, CredentialType, FindFilters as CredentialFindFilters, x509::CertificateBundle,