Also add Gossip headers to resent group messages

[missytake]

• Operating System (Linux/Mac/Windows/iOS/Android): Linux
• Delta Chat Version: 1.40.4

Expected behavior

If I get added to a group through a resent message (which is properly encrypted), I can reply to it.

Actual behavior

My reply is not sent out, because I don't have the public keys of all group members.

Steps to reproduce the problem

1. alice@c1.testrun.org sends a message to bob@c1.testrun.org
2. bob@c1.testrun.org creates a group with alice@c1.testrun.org and asdf@systemli.org and sends a message
   - this message is unencrypted because bob doesn't have asdf's key, and it can't be delivered to asdf@systemli.org, because c1.testrun.org prevents unencrypted messages to systemli.org
3. asdf@systemli.org writes a message to bob@c1.testrun.org
4. bob@c1.testrun.org re-sends the group creation message to asdf@systemli.org
   - this message is now displayed to bob as encrypted, even though it was sent unencrypted initially (to alice)
5. asdf@systemli.org tries to quote-reply to the group creation message
   - it can't be encrypted because asdf@systemli.org doesn't have alice@c1.testrun.org's key, as the resent group creation message didn't have gossip headers
   - it can't be sent out as quote replies to encrypted messages always have to be encrypted

Screenshots

bob's view of the group creation message, after it was resent to asdf@systemli.org (note that it suddenly is shown as encrypted, even though it was sent to alice unencrypted)

asdf's view of the failed outgoing message from step 5

alice's view of the group creation message as she received it

Decrypted plaintext of bob's resent group creation message, as it arrived at asdf (note that the Autocrypt-Gossip headers are missing):

gpg: encrypted with ECDH key, ID 433C5A79284BD372
gpg: encrypted with ECDH key, ID F919D5690759780F
gpg: encrypted with 2048-bit RSA key, ID 17893D443E5A660B, created 2019-08-15
      "<asdf@systemli.org>"
Content-Type: text/plain; charset=utf-8; format=flowed; delsp=no;
	protected-headers="v1";
Subject: grouptry
Chat-Disposition-Notification-To: bob@c1.testrun.org
Chat-Group-ID: OB52UY7PwM0
Chat-Group-Name: =?utf-8?q?grouptry?=
From: <bob@c1.testrun.org>

Who receives this?
gpg: Signature made So 15 Okt 2023 14:03:27 CEST
gpg:                using EDDSA key 1A2277293043413A91715AE4CDC8AF7EBCCBB371
gpg: Can't check signature: No public key

Suggested Solution

Right now, resent messages don't contain Autocrypt-Gossip headers. I suggest to add them.

[link2xt]

Resent message in this case should contain Autocrypt-Gossip header already. However, resent messages have the same Message-ID, so asdf@systemli.org ignores "duplicate" message and will not even download it.

I started writing a test, but it fails on the next to last line because charlie.recv_msg complains that the message went to trash as it is a duplicate:

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn test_resend_gossip() -> Result<()> {
    let mut tcm = TestContextManager::new();
    let alice = &tcm.alice().await;
    let bob = &tcm.bob().await;
    let charlie = &tcm.charlie().await;

    tcm.section("Bob creates a group chat with Alice and Charlie");
    let bob_chat_id = create_group_chat(bob, ProtectionStatus::Unprotected, "Chat").await?;

    // Bob gets a key of Alice, but not Charlie,
    // so can only send unencrypted messages to the group.
    let bob_alice_contact_id = bob.add_or_lookup_contact_id(alice).await;
    let bob_charlie_contact_id = bob.add_or_lookup_email_contact_id(charlie).await;
    add_contact_to_chat(bob, bob_chat_id, bob_alice_contact_id).await?;
    add_contact_to_chat(bob, bob_chat_id, bob_charlie_contact_id).await?;

    tcm.section("Bob sends unencrypted message to promote the group");
    let bob_sent_msg = bob.send_text(bob_chat_id, "Hi! I created a group.").await;
    let alice_received_msg = alice.recv_msg(&bob_sent_msg).await;
    let charlie_received_msg = charlie.recv_msg(&bob_sent_msg).await;
    assert_eq!(alice_received_msg.get_showpadlock(), false);
    assert_eq!(charlie_received_msg.get_showpadlock(), false);

    tcm.section("Bob imports the key for Charlie");
    bob.add_or_lookup_contact_id(charlie).await;

    tcm.section("Bob resends welcome message as encrypted");
    resend_msgs(bob, &[bob_sent_msg.sender_msg_id]).await?;
    let bob_resent_msg = bob.pop_sent_msg().await;
    let charlie_received_resent_msg = charlie.recv_msg(&bob_resent_msg).await;
    assert_eq!(charlie_received_resent_msg.id, charlie_received_msg.id);

    Ok(())
}

The problem will be "solved" with PGP-contacts branch by not allowing the groups to change between unencrypted and encrypted.