WIP: feat: add option to process unencrypted messages

Author: link2xt

src/chat/chat_tests.rs

@@ -1049,6 +1049,7 @@ async fn chatlist_len(ctx: &Context, listflags: usize) -> usize {
 async fn test_archive() {
     // create two chats
     let t = TestContext::new_alice().await;
+
     let mut msg = Message::new_text("foo".to_string());
     let msg_id = add_device_msg(&t, None, Some(&mut msg)).await.unwrap();
     let chat_id1 = message::Message::load_from_db(&t, msg_id)
@@ -1381,6 +1382,9 @@ async fn test_markfresh_chat() -> Result<()> {
 async fn test_archive_fresh_msgs() -> Result<()> {
     let t = TestContext::new_alice().await;
 
+    // FIXME: use encrypted messages
+    t.set_config(Config::ProcessUnencrypted, Some("1")).await?;
+
     async fn msg_from(t: &TestContext, name: &str, num: u32) -> Result<()> {
         receive_imf(
             t,
@@ -1873,52 +1877,46 @@ async fn test_lookup_self_by_contact_id() {
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_marknoticed_chat() -> Result<()> {
-    let t = TestContext::new_alice().await;
-    let chat = t.create_chat_with_contact("bob", "bob@example.org").await;
+    let mut tcm = TestContextManager::new();
+    let alice = &tcm.alice().await;
+    let bob = &tcm.bob().await;
+    let chat = alice.create_chat(bob).await;
 
-    receive_imf(
-        &t,
-        b"From: bob@example.org\n\
-                 To: alice@example.org\n\
-                 Message-ID: <1@example.org>\n\
-                 Chat-Version: 1.0\n\
-                 Date: Fri, 23 Apr 2021 10:00:57 +0000\n\
-                 \n\
-                 hello\n",
-        false,
-    )
-    .await?;
+    let bob_chat_id = bob.create_chat_id(alice).await;
+    let sent = bob.send_text(bob_chat_id, "hello").await;
+    alice.recv_msg(&sent).await;
 
-    let chats = Chatlist::try_load(&t, 0, None, None).await?;
+    let chats = Chatlist::try_load(alice, 0, None, None).await?;
     assert_eq!(chats.len(), 1);
     assert_eq!(chats.get_chat_id(0)?, chat.id);
-    assert_eq!(chat.id.get_fresh_msg_cnt(&t).await?, 1);
-    assert_eq!(t.get_fresh_msgs().await?.len(), 1);
+    assert_eq!(chat.id.get_fresh_msg_cnt(alice).await?, 1);
+    assert_eq!(alice.get_fresh_msgs().await?.len(), 1);
 
-    let msgs = get_chat_msgs(&t, chat.id).await?;
-    assert_eq!(msgs.len(), 1);
-    let msg_id = match msgs.first().unwrap() {
+    let msgs = get_chat_msgs(alice, chat.id).await?;
+    assert_eq!(msgs.len(), 2);
+    let msg_id = match msgs.last().unwrap() {
         ChatItem::Message { msg_id } => *msg_id,
         _ => MsgId::new_unset(),
     };
-    let msg = message::Message::load_from_db(&t, msg_id).await?;
+    let msg = message::Message::load_from_db(alice, msg_id).await?;
     assert_eq!(msg.state, MessageState::InFresh);
 
-    marknoticed_chat(&t, chat.id).await?;
+    marknoticed_chat(alice, chat.id).await?;
 
-    let chats = Chatlist::try_load(&t, 0, None, None).await?;
+    let chats = Chatlist::try_load(alice, 0, None, None).await?;
     assert_eq!(chats.len(), 1);
-    let msg = message::Message::load_from_db(&t, msg_id).await?;
+    let msg = message::Message::load_from_db(alice, msg_id).await?;
     assert_eq!(msg.state, MessageState::InNoticed);
-    assert_eq!(chat.id.get_fresh_msg_cnt(&t).await?, 0);
-    assert_eq!(t.get_fresh_msgs().await?.len(), 0);
+    assert_eq!(chat.id.get_fresh_msg_cnt(alice).await?, 0);
+    assert_eq!(alice.get_fresh_msgs().await?.len(), 0);
 
     Ok(())
 }
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_contact_request_fresh_messages() -> Result<()> {
     let t = TestContext::new_alice().await;
+    t.set_config(Config::ProcessUnencrypted, Some("1")).await?;
 
     let chats = Chatlist::try_load(&t, 0, None, None).await?;
     assert_eq!(chats.len(), 0);
@@ -1970,47 +1968,53 @@ async fn test_contact_request_fresh_messages() -> Result<()> {
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_contact_request_archive() -> Result<()> {
-    let t = TestContext::new_alice().await;
+    let mut tcm = TestContextManager::new();
+    let alice = &tcm.alice().await;
+    let bob = &tcm.bob().await;
 
-    receive_imf(
-        &t,
-        b"From: bob@example.org\n\
-                 To: alice@example.org\n\
-                 Message-ID: <2@example.org>\n\
-                 Chat-Version: 1.0\n\
-                 Date: Sun, 22 Mar 2021 19:37:57 +0000\n\
-                 \n\
-                 hello\n",
-        false,
-    )
-    .await?;
+    let bob_chat_id = bob.create_chat_id(alice).await;
+    let bob_sent_text = bob.send_text(bob_chat_id, "hello").await;
+    alice.recv_msg(&bob_sent_text).await;
 
-    let chats = Chatlist::try_load(&t, 0, None, None).await?;
+    let chats = Chatlist::try_load(alice, 0, None, None).await?;
     assert_eq!(chats.len(), 1);
     let chat_id = chats.get_chat_id(0)?;
-    assert!(Chat::load_from_db(&t, chat_id).await?.is_contact_request());
-    assert_eq!(get_archived_cnt(&t).await?, 0);
+    assert!(
+        Chat::load_from_db(alice, chat_id)
+            .await?
+            .is_contact_request()
+    );
+    assert_eq!(get_archived_cnt(alice).await?, 0);
 
     // archive request without accepting or blocking
-    chat_id.set_visibility(&t, ChatVisibility::Archived).await?;
+    chat_id
+        .set_visibility(alice, ChatVisibility::Archived)
+        .await?;
 
-    let chats = Chatlist::try_load(&t, 0, None, None).await?;
+    let chats = Chatlist::try_load(alice, 0, None, None).await?;
     assert_eq!(chats.len(), 1);
     let chat_id = chats.get_chat_id(0)?;
     assert!(chat_id.is_archived_link());
-    assert_eq!(get_archived_cnt(&t).await?, 1);
+    assert_eq!(get_archived_cnt(alice).await?, 1);
 
-    let chats = Chatlist::try_load(&t, DC_GCL_ARCHIVED_ONLY, None, None).await?;
+    let chats = Chatlist::try_load(alice, DC_GCL_ARCHIVED_ONLY, None, None).await?;
     assert_eq!(chats.len(), 1);
     let chat_id = chats.get_chat_id(0)?;
-    assert!(Chat::load_from_db(&t, chat_id).await?.is_contact_request());
+    assert!(
+        Chat::load_from_db(alice, chat_id)
+            .await?
+            .is_contact_request()
+    );
 
     Ok(())
 }
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_classic_email_chat() -> Result<()> {
     let alice = TestContext::new_alice().await;
+    alice
+        .set_config(Config::ProcessUnencrypted, Some("1"))
+        .await?;
 
     // Alice receives a classic (non-chat) message from Bob.
     receive_imf(

src/chatlist.rs

@@ -473,6 +473,7 @@ mod tests {
         add_contact_to_chat, create_broadcast, create_group, get_chat_contacts,
         remove_contact_from_chat, send_text_msg, set_chat_name,
     };
+    use crate::config::Config;
     use crate::receive_imf::receive_imf;
     use crate::securejoin::get_securejoin_qr;
     use crate::stock_str::StockMessage;
@@ -665,6 +666,7 @@ mod tests {
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_search_single_chat() -> anyhow::Result<()> {
         let t = TestContext::new_alice().await;
+        t.set_config(Config::ProcessUnencrypted, Some("1")).await?;
 
         // receive a one-to-one-message
         receive_imf(
@@ -725,6 +727,7 @@ mod tests {
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_search_single_chat_without_authname() -> anyhow::Result<()> {
         let t = TestContext::new_alice().await;
+        t.set_config(Config::ProcessUnencrypted, Some("1")).await?;
 
         // receive a one-to-one-message without authname set
         receive_imf(

src/config.rs

@@ -486,6 +486,11 @@ pub enum Config {
     /// Experimental option denoting that the current profile is shared between multiple team members.
     /// For now, the only effect of this option is that seen flags are not synchronized.
     TeamProfile,
+
+    /// Process unencrypted messages.
+    ///
+    /// Unencrypted messages are fetched and processed only if this setting is explicitly enabled.
+    ProcessUnencrypted,
 }
 
 impl Config {

src/context.rs

@@ -1056,6 +1056,12 @@ impl Context {
             "team_profile",
             self.get_config_bool(Config::TeamProfile).await?.to_string(),
         );
+        res.insert(
+            "process_unencrypted",
+            self.get_config_bool(Config::ProcessUnencrypted)
+                .await?
+                .to_string(),
+        );
 
         let elapsed = time_elapsed(&self.creation_time);
         res.insert("uptime", duration_to_str(elapsed));

src/decrypt.rs

@@ -370,6 +370,7 @@ mod tests {
     use super::*;
     use crate::receive_imf::receive_imf;
     use crate::test_utils::TestContext;
+    use crate::config::Config;
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_mixed_up_mime() -> Result<()> {
@@ -402,6 +403,7 @@ mod tests {
         assert!(get_attachment_mime(&mail).is_some());
 
         let bob = TestContext::new_bob().await;
+        bob.set_config(Config::ProcessUnencrypted, Some("1")).await?;
         receive_imf(&bob, attachment_mime, false).await?;
         let msg = bob.get_last_msg().await;
         // Subject should be prepended because the attachment doesn't have "Chat-Version".
@@ -416,6 +418,7 @@ mod tests {
         // Desktop via MS Exchange (actually made with TB though).
         let mixed_up_mime = include_bytes!("../test-data/message/mixed-up-long.eml");
         let bob = TestContext::new_bob().await;
+        bob.set_config(Config::ProcessUnencrypted, Some("1")).await?;
         receive_imf(&bob, mixed_up_mime, false).await?;
         let msg = bob.get_last_msg().await;
         assert!(!msg.get_text().is_empty());

src/e2ee.rs

@@ -160,6 +160,8 @@ Sent with my Delta Chat Messenger: https://delta.chat";
         let mut tcm = TestContextManager::new();
         let bob = &tcm.bob().await;
         bob.set_config_bool(Config::IsChatmail, true).await?;
+        bob.set_config_bool(Config::ProcessUnencrypted, true)
+            .await?;
         let bob_chat_id = receive_imf(
             bob,
             b"From: alice@example.org\n\

src/html.rs

@@ -287,6 +287,7 @@ impl MsgId {
 mod tests {
     use super::*;
     use crate::chat::{self, Chat, forward_msgs, save_msgs};
+    use crate::config::Config;
     use crate::constants;
     use crate::contact::ContactId;
     use crate::message::{MessengerMessage, Viewtype};
@@ -450,6 +451,9 @@ test some special html-characters as < > and & but also " and &#x
         // alice receives a non-delta html-message
         let mut tcm = TestContextManager::new();
         let alice = &tcm.alice().await;
+        alice
+            .set_config(Config::ProcessUnencrypted, Some("1"))
+            .await?;
         let chat = alice
             .create_chat_with_contact("", "sender@testrun.org")
             .await;
@@ -483,6 +487,8 @@ test some special html-characters as < > and & but also " and &#x
 
         // bob: check that bob also got the html-part of the forwarded message
         let bob = &tcm.bob().await;
+        bob.set_config(Config::ProcessUnencrypted, Some("1"))
+            .await?;
         let chat_bob = bob.create_chat_with_contact("", "alice@example.org").await;
         async fn check_receiver(ctx: &TestContext, chat: &Chat, sender: &TestContext) {
             let msg = ctx.recv_msg(&sender.pop_sent_msg().await).await;
@@ -520,8 +526,12 @@ test some special html-characters as < > and & but also " and &#x
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_html_save_msg() -> Result<()> {
+        let mut tcm = TestContextManager::new();
+        let alice = &tcm.alice().await;
+        alice
+            .set_config(Config::ProcessUnencrypted, Some("1"))
+            .await?;
         // Alice receives a non-delta html-message
-        let alice = TestContext::new_alice().await;
         let chat = alice
             .create_chat_with_contact("", "sender@testrun.org")
             .await;
@@ -555,6 +565,10 @@ test some special html-characters as &lt; &gt; and &amp; but also &quot; and &#x
         let mut tcm = TestContextManager::new();
         // Alice receives a non-delta html-message
         let alice = &tcm.alice().await;
+        alice
+            .set_config(Config::ProcessUnencrypted, Some("1"))
+            .await
+            .unwrap();
         let chat = alice
             .create_chat_with_contact("", "sender@testrun.org")
             .await;
@@ -618,18 +632,22 @@ test some special html-characters as &lt; &gt; and &amp; but also &quot; and &#x
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_cp1252_html() -> Result<()> {
-        let t = TestContext::new_alice().await;
+        let mut tcm = TestContextManager::new();
+        let alice = &tcm.alice().await;
+        alice
+            .set_config(Config::ProcessUnencrypted, Some("1"))
+            .await?;
         receive_imf(
-            &t,
+            alice,
             include_bytes!("../test-data/message/cp1252-html.eml"),
             false,
         )
         .await?;
-        let msg = t.get_last_msg().await;
+        let msg = alice.get_last_msg().await;
         assert_eq!(msg.viewtype, Viewtype::Text);
         assert!(msg.text.contains("foo bar ä ö ü ß"));
         assert!(msg.has_html());
-        let html = msg.get_id().get_html(&t).await?.unwrap();
+        let html = msg.get_id().get_html(alice).await?.unwrap();
         println!("{html}");
         assert!(html.contains("foo bar ä ö ü ß"));
         Ok(())

src/imap.rs

@@ -1996,12 +1996,21 @@ pub(crate) async fn prefetch_should_download(
     // prevent_rename=true as this might be a mailing list message and in this case it would be bad if we rename the contact.
     // (prevent_rename is the last argument of from_field_to_contact_id())
 
+    let is_encrypted = if let Some(content_type) = headers.get_header_value(HeaderDef::ContentType)
+    {
+        mailparse::parse_content_type(&content_type).mimetype == "multipart/encrypted"
+    } else {
+        false
+    };
+
     if flags.any(|f| f == Flag::Draft) {
         info!(context, "Ignoring draft message");
         return Ok(false);
     }
 
-    let should_download = !blocked_contact || maybe_ndn;
+    let should_download = maybe_ndn
+        || (!blocked_contact
+            && (is_encrypted || context.get_config_bool(Config::ProcessUnencrypted).await?));
     Ok(should_download)
 }
 

src/imap/session.rs

@@ -21,6 +21,7 @@ const PREFETCH_FLAGS: &str = "(UID RFC822.SIZE BODY.PEEK[HEADER.FIELDS (\
                               DATE \
                               X-MICROSOFT-ORIGINAL-MESSAGE-ID \
                               FROM \
+                              CONTENT-TYPE \
                               CHAT-VERSION \
                               CHAT-IS-POST-MESSAGE \
                               AUTOCRYPT-SETUP-MESSAGE\