feat!: QR codes and symmetric encryption for broadcast channels

benches/decrypting.rs

@@ -110,6 +110,7 @@ fn criterion_benchmark(c: &mut Criterion) {
                 vec![black_box(key_pair.public.clone())],
                 Some(key_pair.secret.clone()),
                 true,
+                true,
             )
             .await
             .unwrap()

deltachat-rpc-client/tests/test_securejoin.py

@@ -243,6 +243,8 @@ def check_account(ac, contact, inviter_side, please_wait_info_msg=False):
 
     check_account(fiona, fiona.create_contact(alice), inviter_side=False, please_wait_info_msg=True)
 
+    # For Bob, the channel must not have changed:
+    check_account(bob, bob.create_contact(alice), inviter_side=False, please_wait_info_msg=True)
 
 def test_qr_securejoin_contact_request(acfactory) -> None:
     """Alice invites Bob to a group when Bob's chat with Alice is in a contact request mode."""

src/chat/chat_tests.rs

@@ -2627,6 +2627,121 @@ async fn test_can_send_group() -> Result<()> {
     Ok(())
 }
 
+/// Tests that in a broadcast channel,
+/// the recipients can't see the identity of their fellow recipients.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn test_broadcast_members_cant_see_each_other() -> Result<()> {
+    fn contains(parsed: &MimeMessage, s: &str) -> bool {
+        assert_eq!(parsed.decrypting_failed, false);
+        let decoded_str = str::from_utf8(&parsed.decoded_data).unwrap();
+        decoded_str.contains(s)
+    }
+
+    let mut tcm = TestContextManager::new();
+    let alice = &tcm.alice().await;
+    let bob = &tcm.bob().await;
+    let charlie = &tcm.charlie().await;
+
+    tcm.section("Alice creates a channel, Bob joins.");
+    let alice_broadcast_id = create_broadcast(alice, "Channel".to_string()).await?;
+    let qr = get_securejoin_qr(alice, Some(alice_broadcast_id))
+        .await
+        .unwrap();
+    tcm.exec_securejoin_qr(bob, alice, &qr).await;
+
+    tcm.section("Charlie scans the QR code and sends request.");
+    {
+        join_securejoin(charlie, &qr).await.unwrap();
+
+        let request = charlie.pop_sent_msg().await;
+        assert_eq!(request.recipients, "[email protected] [email protected]");
+
+        alice.recv_msg_trash(&request).await;
+    }
+
+    tcm.section("Alice sends auth-required");
+    {
+        let auth_required = alice.pop_sent_msg().await;
+        assert_eq!(
+            auth_required.recipients,
+            "[email protected] [email protected]"
+        );
+        let parsed = charlie.parse_msg(&auth_required).await;
+        assert!(parsed.header_exists(HeaderDef::AutocryptGossip));
+        assert!(contains(&parsed, "[email protected]"));
+        assert_eq!(contains(&parsed, "[email protected]"), false);
+
+        let parsed_by_bob = bob.parse_msg(&auth_required).await;
+        assert!(parsed_by_bob.decrypting_failed);
+
+        charlie.recv_msg_trash(&auth_required).await;
+    }
+
+    tcm.section("Charlie sends request-with-auth");
+    {
+        let request_with_auth = charlie.pop_sent_msg().await;
+        assert_eq!(
+            request_with_auth.recipients,
+            "[email protected] [email protected]"
+        );
+
+        alice.recv_msg_trash(&request_with_auth).await;
+    }
+
+    tcm.section("Alice adds member");
+    {
+        let member_added = alice.pop_sent_msg().await;
+        assert_eq!(
+            member_added.recipients,
+            "[email protected] [email protected]"
+        );
+        let parsed = charlie.parse_msg(&member_added).await;
+        assert!(parsed.header_exists(HeaderDef::AutocryptGossip));
+        assert!(contains(&parsed, "[email protected]"));
+        assert_eq!(contains(&parsed, "[email protected]"), false);
+
+        let parsed_by_bob = bob.parse_msg(&member_added).await;
+        assert!(parsed_by_bob.decrypting_failed);
+
+        let rcvd = charlie.recv_msg(&member_added).await;
+        assert_eq!(rcvd.param.get_cmd(), SystemMessage::MemberAddedToGroup);
+    }
+
+    tcm.section("Alice sends into the channel.");
+    {
+        let hi_msg = alice.send_text(alice_broadcast_id, "hi").await;
+        let parsed = charlie.parse_msg(&hi_msg).await;
+        assert_eq!(parsed.header_exists(HeaderDef::AutocryptGossip), false);
+        assert_eq!(contains(&parsed, "[email protected]"), false);
+        assert_eq!(contains(&parsed, "[email protected]"), false);
+
+        let parsed_by_bob = bob.parse_msg(&hi_msg).await;
+        assert_eq!(parsed_by_bob.decrypting_failed, false);
+    }
+
+    tcm.section("Alice removes Charlie. Bob must not see it.");
+    {
+        let alice_charlie_contact = alice.add_or_lookup_contact_id(charlie).await;
+        remove_contact_from_chat(alice, alice_broadcast_id, alice_charlie_contact).await?;
+        let member_removed = alice.pop_sent_msg().await;
+        assert_eq!(
+            member_removed.recipients,
+            "[email protected] [email protected]"
+        );
+        let parsed = charlie.parse_msg(&member_removed).await;
+        assert!(contains(&parsed, "[email protected]"));
+        assert_eq!(contains(&parsed, "[email protected]"), false);
+
+        let parsed_by_bob = bob.parse_msg(&member_removed).await;
+        assert!(parsed_by_bob.decrypting_failed);
+
+        let rcvd = charlie.recv_msg(&member_removed).await;
+        assert_eq!(rcvd.param.get_cmd(), SystemMessage::MemberRemovedFromGroup);
+    }
+
+    Ok(())
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_broadcast_change_name() -> Result<()> {
     let mut tcm = TestContextManager::new();
@@ -3174,10 +3289,7 @@ async fn test_leave_broadcast_multidevice() -> Result<()> {
 
     alice.recv_msg_trash(&request_with_auth).await;
     let member_added = alice.pop_sent_msg().await;
-    assert_eq!(
-        request_with_auth.recipients,
-        "[email protected] [email protected]"
-    );
+    assert_eq!(member_added.recipients, "[email protected] [email protected]");
 
     tcm.section("Bob receives the member-added message answer, and processes it");
     let rcvd = bob0.recv_msg(&member_added).await;

src/mimefactory.rs

@@ -3,7 +3,7 @@
 use std::collections::{BTreeSet, HashSet};
 use std::io::Cursor;
 
-use anyhow::{Context as _, Result, bail};
+use anyhow::{Context as _, Result, bail, format_err};
 use base64::Engine as _;
 use data_encoding::BASE32_NOPAD;
 use deltachat_contact_tools::sanitize_bidi_characters;
@@ -290,6 +290,14 @@ impl MimeFactory {
                         for row in rows {
                             let (authname, addr, fingerprint, id, add_timestamp, remove_timestamp, public_key_bytes_opt) = row?;
 
+                            // In a broadcast channel, only send member-added/removed messages
+                            // to the affected member:
+                            if let Some(fp) = should_only_send_to_one_recipient(&msg, &chat){
+                                if fp? != fingerprint {
+                                    continue;
+                                }
+                            }
+
                             let public_key_opt = if let Some(public_key_bytes) = &public_key_bytes_opt {
                                 Some(SignedPublicKey::from_slice(public_key_bytes)?)
                             } else {
@@ -415,20 +423,6 @@ impl MimeFactory {
                 req_mdn = true;
             }
 
-            // If undisclosed_recipients, and this is a member-added/removed message,
-            // only send to the added/removed member
-            if undisclosed_recipients
-                && matches!(
-                    msg.param.get_cmd(),
-                    SystemMessage::MemberRemovedFromGroup | SystemMessage::MemberAddedToGroup
-                )
-            {
-                let Some(member) = msg.param.get(Param::Arg) else {
-                    bail!("Missing removed/added member");
-                };
-                recipients.retain(|addr| addr == member);
-            }
-
             encryption_pubkeys = if !is_encrypted {
                 None
             } else if should_encrypt_symmetrically(&msg, &chat) {
@@ -1975,12 +1969,7 @@ fn hidden_recipients() -> Address<'static> {
 }
 
 fn should_encrypt_with_broadcast_secret(msg: &Message, chat: &Chat) -> bool {
-    chat.typ == Chattype::OutBroadcast
-        // We encrypt securejoin messages asymmetrically
-        && msg.param.get_cmd() != SystemMessage::SecurejoinMessage
-        // The member-added message in a broadcast must be asymmetrically encrypted,
-        // because the newly-added member doesn't know the broadcast shared secret yet:
-        && msg.param.get_cmd() != SystemMessage::MemberAddedToGroup
+    chat.typ == Chattype::OutBroadcast && should_only_send_to_one_recipient(msg, chat).is_none()
 }
 
 fn should_hide_recipients(msg: &Message, chat: &Chat) -> bool {
@@ -1991,6 +1980,25 @@ fn should_encrypt_symmetrically(msg: &Message, chat: &Chat) -> bool {
     should_encrypt_with_broadcast_secret(msg, chat)
 }
 
+/// Some messages sent into outgoing broadcast channels (member-added/member-removed)
+/// should only go to a single recipient,
+/// rather than all recipients.
+/// This function returns the fingerprint of the recipient the message should be sent to.
+fn should_only_send_to_one_recipient<'a>(msg: &'a Message, chat: &Chat) -> Option<Result<&'a str>> {
+    if chat.typ == Chattype::OutBroadcast
+        && matches!(
+            msg.param.get_cmd(),
+            SystemMessage::MemberRemovedFromGroup | SystemMessage::MemberAddedToGroup
+        )
+    {
+        let Some(fp) = msg.param.get(Param::Arg4) else {
+            return Some(Err(format_err!("Missing removed/added member")));
+        };
+        return Some(Ok(fp));
+    }
+    None
+}
+
 async fn build_body_file(context: &Context, msg: &Message) -> Result<MimePart<'static>> {
     let file_name = msg.get_filename().context("msg has no file")?;
     let blob = msg