fix: Make pre-messages w/o text want MDNs (#8004 )

This fixes failing `test_pre_msg_mdn_before_sending_full`. Maybe it's even good that MDNs will be sent for pre-messages only having placeholder text with the viewtype and size, at least this way we notify the contact that we've noticed the message. Anyway, with adding message previews the problem will be solved for the corresponding viewtypes.
test: MDN on pre-message has effect if received before sending full message (#8004 )
2026-05-02 04:46:29 +03:00 · 2026-04-27 03:14:28 -03:00 · 2026-04-27 03:14:28 -03:00 · 2026-04-27 03:14:12 -03:00
37 changed files with 599 additions and 279 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -23,7 +23,7 @@ env:
  RUST_VERSION: 1.95.0

  # Minimum Supported Rust Version
-  MSRV: 1.89.0
+  MSRV: 1.88.0

 jobs:
  lint_rust:
@@ -137,7 +137,7 @@ jobs:
        uses: swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4

      - name: Install nextest
-        uses: taiki-e/install-action@5f57d6cb7cd20b14a8a27f522884c4bc8a187458
+        uses: taiki-e/install-action@85b24a67ef0c632dfefad70b9d5ce8fddb040754
        with:
          tool: nextest

--- a/.github/workflows/deltachat-rpc-server.yml
+++ b/.github/workflows/deltachat-rpc-server.yml
@@ -34,7 +34,7 @@ jobs:
        with:
          show-progress: false
          persist-credentials: false
-      - uses: cachix/install-nix-action@ab739621df7a23f52766f9ccc97f38da6b7af14f # v31.10.5
+      - uses: cachix/install-nix-action@2126ae7fc54c9df00dd18f7f18754393182c73cd # v31.9.1

      - name: Build deltachat-rpc-server binaries
        run: nix build .#deltachat-rpc-server-${{ matrix.arch }}-linux
@@ -58,7 +58,7 @@ jobs:
        with:
          show-progress: false
          persist-credentials: false
-      - uses: cachix/install-nix-action@ab739621df7a23f52766f9ccc97f38da6b7af14f # v31.10.5
+      - uses: cachix/install-nix-action@2126ae7fc54c9df00dd18f7f18754393182c73cd # v31.9.1

      - name: Build deltachat-rpc-server wheels
        run: nix build .#deltachat-rpc-server-${{ matrix.arch }}-linux-wheel
@@ -82,7 +82,7 @@ jobs:
        with:
          show-progress: false
          persist-credentials: false
-      - uses: cachix/install-nix-action@ab739621df7a23f52766f9ccc97f38da6b7af14f # v31.10.5
+      - uses: cachix/install-nix-action@2126ae7fc54c9df00dd18f7f18754393182c73cd # v31.9.1

      - name: Build deltachat-rpc-server binaries
        run: nix build .#deltachat-rpc-server-${{ matrix.arch }}
@@ -106,7 +106,7 @@ jobs:
        with:
          show-progress: false
          persist-credentials: false
-      - uses: cachix/install-nix-action@ab739621df7a23f52766f9ccc97f38da6b7af14f # v31.10.5
+      - uses: cachix/install-nix-action@2126ae7fc54c9df00dd18f7f18754393182c73cd # v31.9.1

      - name: Build deltachat-rpc-server wheels
        run: nix build .#deltachat-rpc-server-${{ matrix.arch }}-wheel
@@ -157,7 +157,7 @@ jobs:
        with:
          show-progress: false
          persist-credentials: false
-      - uses: cachix/install-nix-action@ab739621df7a23f52766f9ccc97f38da6b7af14f # v31.10.5
+      - uses: cachix/install-nix-action@2126ae7fc54c9df00dd18f7f18754393182c73cd # v31.9.1

      - name: Build deltachat-rpc-server binaries
        run: nix build .#deltachat-rpc-server-${{ matrix.arch }}-android
@@ -181,7 +181,7 @@ jobs:
        with:
          show-progress: false
          persist-credentials: false
-      - uses: cachix/install-nix-action@ab739621df7a23f52766f9ccc97f38da6b7af14f # v31.10.5
+      - uses: cachix/install-nix-action@2126ae7fc54c9df00dd18f7f18754393182c73cd # v31.9.1

      - name: Build deltachat-rpc-server wheels
        run: nix build .#deltachat-rpc-server-${{ matrix.arch }}-android-wheel
@@ -208,7 +208,7 @@ jobs:
        with:
          show-progress: false
          persist-credentials: false
-      - uses: cachix/install-nix-action@ab739621df7a23f52766f9ccc97f38da6b7af14f # v31.10.5
+      - uses: cachix/install-nix-action@2126ae7fc54c9df00dd18f7f18754393182c73cd # v31.9.1

      - name: Download Linux aarch64 binary
        uses: actions/download-artifact@v7
--- a/.github/workflows/nix.yml
+++ b/.github/workflows/nix.yml
@@ -25,7 +25,7 @@ jobs:
        with:
          show-progress: false
          persist-credentials: false
-      - uses: cachix/install-nix-action@ab739621df7a23f52766f9ccc97f38da6b7af14f # v31.10.5
+      - uses: cachix/install-nix-action@2126ae7fc54c9df00dd18f7f18754393182c73cd # v31.9.1
      - run: nix fmt flake.nix -- --check

  build:
@@ -84,7 +84,7 @@ jobs:
        with:
          show-progress: false
          persist-credentials: false
-      - uses: cachix/install-nix-action@ab739621df7a23f52766f9ccc97f38da6b7af14f # v31.10.5
+      - uses: cachix/install-nix-action@2126ae7fc54c9df00dd18f7f18754393182c73cd # v31.9.1
      - run: nix build .#${{ matrix.installable }}

  build-macos:
@@ -105,5 +105,5 @@ jobs:
        with:
          show-progress: false
          persist-credentials: false
-      - uses: cachix/install-nix-action@ab739621df7a23f52766f9ccc97f38da6b7af14f # v31.10.5
+      - uses: cachix/install-nix-action@2126ae7fc54c9df00dd18f7f18754393182c73cd # v31.9.1
      - run: nix build .#${{ matrix.installable }}
--- a/.github/workflows/repl.yml
+++ b/.github/workflows/repl.yml
@@ -18,7 +18,7 @@ jobs:
        with:
          show-progress: false
          persist-credentials: false
-      - uses: cachix/install-nix-action@ab739621df7a23f52766f9ccc97f38da6b7af14f # v31.10.5
+      - uses: cachix/install-nix-action@2126ae7fc54c9df00dd18f7f18754393182c73cd # v31.9.1
      - name: Build
        run: nix build .#deltachat-repl-win64
      - name: Upload binary
--- a/.github/workflows/upload-docs.yml
+++ b/.github/workflows/upload-docs.yml
@@ -41,7 +41,7 @@ jobs:
          show-progress: false
          persist-credentials: false
          fetch-depth: 0 # Fetch history to calculate VCS version number.
-      - uses: cachix/install-nix-action@ab739621df7a23f52766f9ccc97f38da6b7af14f # v31.10.5
+      - uses: cachix/install-nix-action@2126ae7fc54c9df00dd18f7f18754393182c73cd # v31.9.1
      - name: Build Python documentation
        run: nix build .#python-docs
      - name: Upload to py.delta.chat
@@ -63,7 +63,7 @@ jobs:
          show-progress: false
          persist-credentials: false
          fetch-depth: 0 # Fetch history to calculate VCS version number.
-      - uses: cachix/install-nix-action@ab739621df7a23f52766f9ccc97f38da6b7af14f # v31.10.5
+      - uses: cachix/install-nix-action@2126ae7fc54c9df00dd18f7f18754393182c73cd # v31.9.1
      - name: Build C documentation
        run: nix build .#docs
      - name: Upload to c.delta.chat
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -194,9 +194,9 @@ dependencies = [

 [[package]]
 name = "astral-tokio-tar"
-version = "0.6.1"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ce73b17c62717c4b6a9af10b43e87c578b0cac27e00666d48304d3b7d2c0693"
+checksum = "3c23f3af104b40a3430ccb90ed5f7bd877a8dc5c26fc92fde51a22b40890dcf9"
 dependencies = [
 "filetime",
 "futures-core",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3,7 +3,7 @@ name = "deltachat"
 version = "2.50.0-dev"
 edition = "2024"
 license = "MPL-2.0"
-rust-version = "1.89"
+rust-version = "1.88"
 repository = "https://github.com/chatmail/core"

 [profile.dev]
@@ -103,7 +103,7 @@ thiserror = { workspace = true }
 tokio-io-timeout = "1.2.1"
 tokio-rustls = { version = "0.26.2", default-features = false }
 tokio-stream = { version = "0.1.17", features = ["fs"] }
-astral-tokio-tar = { version = "0.6.1", default-features = false }
+astral-tokio-tar = { version = "0.6", default-features = false }
 tokio-util = { workspace = true }
 tokio = { workspace = true, features = ["fs", "rt-multi-thread", "macros"] }
 toml = "0.9"
--- a/STYLE.md
+++ b/STYLE.md
@@ -161,16 +161,3 @@ are documented.

 Follow Rust guidelines for the documentation comments:
 <https://rust-lang.github.io/rfcs/1574-more-api-documentation-conventions.html#summary-sentence>
-
-## Do not use `into()`, `try_into()` or `parse()`
-
-For internal types, implementing `From`, `TryFrom` or `FromStr` is discouraged.
-Instead, a `new()` function is recommended.
-
-For external types, prefer using `Type::from()`, `Type::try_from()` or `Type::from_str()`
-over `into()`, `try_into()` or `parse()`.
-
-Calling `into()`, `try_into()` or `parse()`
-creates an indirection,
-which is hard to follow for people who are not familiar with Rust,
-or who are not using rust-analyzer.
--- a/deltachat-jsonrpc/src/api.rs
+++ b/deltachat-jsonrpc/src/api.rs
@@ -1882,6 +1882,20 @@ impl CommandApi {
        deltachat::contact::make_vcard(&ctx, &contacts).await
    }

+    /// Sets vCard containing the given contacts to the message draft.
+    async fn set_draft_vcard(
+        &self,
+        account_id: u32,
+        msg_id: u32,
+        contacts: Vec<u32>,
+    ) -> Result<()> {
+        let ctx = self.get_context(account_id).await?;
+        let contacts: Vec<_> = contacts.iter().map(|&c| ContactId::new(c)).collect();
+        let mut msg = Message::load_from_db(&ctx, MsgId::new(msg_id)).await?;
+        msg.make_vcard(&ctx, &contacts).await?;
+        msg.get_chat_id().set_draft(&ctx, Some(&mut msg)).await
+    }
+
    // ---------------------------------------------
    //                   chat
    // ---------------------------------------------
@@ -2407,7 +2421,6 @@ impl CommandApi {
        chat::resend_msgs(&ctx, &message_ids).await
    }

-    /// @deprecated as of 2026-04; use `send_msg` with `Viewtype::Sticker` instead.
    async fn send_sticker(
        &self,
        account_id: u32,
--- a/deltachat-jsonrpc/src/api/types/qr.rs
+++ b/deltachat-jsonrpc/src/api/types/qr.rs
@@ -238,7 +238,7 @@ impl From<Qr> for QrObject {
                is_v3,
            } => {
                let contact_id = contact_id.to_u32();
-                let fingerprint = fingerprint.human_readable();
+                let fingerprint = fingerprint.to_string();
                QrObject::AskVerifyContact {
                    contact_id,
                    fingerprint,
@@ -257,7 +257,7 @@ impl From<Qr> for QrObject {
                is_v3,
            } => {
                let contact_id = contact_id.to_u32();
-                let fingerprint = fingerprint.human_readable();
+                let fingerprint = fingerprint.to_string();
                QrObject::AskVerifyGroup {
                    grpname,
                    grpid,
@@ -278,7 +278,7 @@ impl From<Qr> for QrObject {
                is_v3,
            } => {
                let contact_id = contact_id.to_u32();
-                let fingerprint = fingerprint.human_readable();
+                let fingerprint = fingerprint.to_string();
                QrObject::AskJoinBroadcast {
                    name,
                    grpid,
@@ -321,7 +321,7 @@ impl From<Qr> for QrObject {
                authcode,
            } => {
                let contact_id = contact_id.to_u32();
-                let fingerprint = fingerprint.human_readable();
+                let fingerprint = fingerprint.to_string();
                QrObject::WithdrawVerifyContact {
                    contact_id,
                    fingerprint,
@@ -338,7 +338,7 @@ impl From<Qr> for QrObject {
                authcode,
            } => {
                let contact_id = contact_id.to_u32();
-                let fingerprint = fingerprint.human_readable();
+                let fingerprint = fingerprint.to_string();
                QrObject::WithdrawVerifyGroup {
                    grpname,
                    grpid,
@@ -357,7 +357,7 @@ impl From<Qr> for QrObject {
                authcode,
            } => {
                let contact_id = contact_id.to_u32();
-                let fingerprint = fingerprint.human_readable();
+                let fingerprint = fingerprint.to_string();
                QrObject::WithdrawJoinBroadcast {
                    name,
                    grpid,
@@ -374,7 +374,7 @@ impl From<Qr> for QrObject {
                authcode,
            } => {
                let contact_id = contact_id.to_u32();
-                let fingerprint = fingerprint.human_readable();
+                let fingerprint = fingerprint.to_string();
                QrObject::ReviveVerifyContact {
                    contact_id,
                    fingerprint,
@@ -391,7 +391,7 @@ impl From<Qr> for QrObject {
                authcode,
            } => {
                let contact_id = contact_id.to_u32();
-                let fingerprint = fingerprint.human_readable();
+                let fingerprint = fingerprint.to_string();
                QrObject::ReviveVerifyGroup {
                    grpname,
                    grpid,
@@ -410,7 +410,7 @@ impl From<Qr> for QrObject {
                authcode,
            } => {
                let contact_id = contact_id.to_u32();
-                let fingerprint = fingerprint.human_readable();
+                let fingerprint = fingerprint.to_string();
                QrObject::ReviveJoinBroadcast {
                    name,
                    grpid,
--- a/deltachat-rpc-client/examples/echobot_no_hooks.py
+++ b/deltachat-rpc-client/examples/echobot_no_hooks.py
@@ -13,7 +13,7 @@ def main():
    with Rpc() as rpc:
        deltachat = DeltaChat(rpc)
        system_info = deltachat.get_system_info()
-        logging.info(f"Running deltachat core {system_info['deltachat_core_version']}")
+        logging.info("Running deltachat core %s", system_info["deltachat_core_version"])

        accounts = deltachat.get_all_accounts()
        account = accounts[0] if accounts else deltachat.add_account()
@@ -21,30 +21,36 @@ def main():
        account.set_config("bot", "1")
        if not account.is_configured():
            logging.info("Account is not configured, configuring")
-            account.add_or_update_transport({"addr": sys.argv[1], "password": sys.argv[2]})
+            account.set_config("addr", sys.argv[1])
+            account.set_config("mail_pw", sys.argv[2])
+            account.configure()
            logging.info("Configured")
        else:
            logging.info("Account is already configured")
            deltachat.start_io()

-        qr = account.get_qr_code()
-        logging.info(f"Invite link: {qr}")
-        while True:
-            event = account.wait_for_event()
-            if event.kind == EventType.INFO:
-                logging.info(event["msg"])
-            elif event.kind == EventType.WARNING:
-                logging.warning(event["msg"])
-            elif event.kind == EventType.ERROR:
-                logging.error(event["msg"])
-            elif event.kind == EventType.INCOMING_MSG:
-                logging.info("Got an incoming message")
-                message = account.get_message_by_id(event.msg_id)
+        def process_messages():
+            for message in account.get_next_messages():
                snapshot = message.get_snapshot()
                if snapshot.from_id != SpecialContactId.SELF and not snapshot.is_bot and not snapshot.is_info:
                    snapshot.chat.send_text(snapshot.text)
                snapshot.message.mark_seen()

+        # Process old messages.
+        process_messages()
+
+        while True:
+            event = account.wait_for_event()
+            if event["kind"] == EventType.INFO:
+                logging.info("%s", event["msg"])
+            elif event["kind"] == EventType.WARNING:
+                logging.warning("%s", event["msg"])
+            elif event["kind"] == EventType.ERROR:
+                logging.error("%s", event["msg"])
+            elif event["kind"] == EventType.INCOMING_MSG:
+                logging.info("Got an incoming message")
+                process_messages()
+

 if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO)
--- a/deltachat-rpc-client/src/deltachat_rpc_client/account.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/account.py
@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Optional, Union
+from warnings import warn

 from ._utils import AttrDict, futuremethod
 from .chat import Chat
@@ -391,7 +392,8 @@ class Account:
        """Return the list of fresh messages, newest messages first.

        This call is intended for displaying notifications.
-        If you are writing a bot, process "incoming message" events instead.
+        If you are writing a bot, use `get_fresh_messages_in_arrival_order()` instead,
+        to process oldest messages first.
        """
        fresh_msg_ids = self._rpc.get_fresh_msgs(self.id)
        return [Message(self, msg_id) for msg_id in fresh_msg_ids]
@@ -461,6 +463,16 @@ class Account:
        """Wait for reaction change event."""
        return self.wait_for_event(EventType.REACTIONS_CHANGED)

+    def get_fresh_messages_in_arrival_order(self) -> list[Message]:
+        """Return fresh messages list sorted in the order of their arrival, with ascending IDs."""
+        warn(
+            "get_fresh_messages_in_arrival_order is deprecated, use get_next_messages instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        fresh_msg_ids = sorted(self._rpc.get_fresh_msgs(self.id))
+        return [Message(self, msg_id) for msg_id in fresh_msg_ids]
+
    def export_backup(self, path, passphrase: str = "") -> None:
        """Export backup."""
        self._rpc.export_backup(self.id, str(path), passphrase)
--- a/deltachat-rpc-client/src/deltachat_rpc_client/chat.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/chat.py
@@ -164,7 +164,7 @@ class Chat:
        return Message(self.account, msg_id)

    def send_sticker(self, path: str) -> Message:
-        """Deprecated as of 2026-04; use `send_message` with `Viewtype.STICKER` instead."""
+        """Send an sticker and return the resulting Message instance."""
        msg_id = self._rpc.send_sticker(self.account.id, self.id, path)
        return Message(self.account, msg_id)

--- a/src/aheader.rs
+++ b/src/aheader.rs
@@ -4,8 +4,9 @@

 use std::collections::BTreeMap;
 use std::fmt;
+use std::str::FromStr;

-use anyhow::{Context as _, Result, bail};
+use anyhow::{Context as _, Error, Result, bail};

 use crate::key::{DcKey, SignedPublicKey};

@@ -27,8 +28,10 @@ impl fmt::Display for EncryptPreference {
    }
 }

-impl EncryptPreference {
-    fn new(s: &str) -> Result<Self> {
+impl FromStr for EncryptPreference {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self> {
        match s {
            "mutual" => Ok(EncryptPreference::Mutual),
            "nopreference" => Ok(EncryptPreference::NoPreference),
@@ -82,8 +85,10 @@ impl fmt::Display for Aheader {
    }
 }

-impl Aheader {
-    pub(crate) fn from_str(s: &str) -> Result<Self> {
+impl FromStr for Aheader {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self> {
        let mut attributes: BTreeMap<String, String> = s
            .split(';')
            .filter_map(|a| {
@@ -111,7 +116,7 @@ impl Aheader {

        let prefer_encrypt = attributes
            .remove("prefer-encrypt")
-            .and_then(|raw| EncryptPreference::new(&raw).ok())
+            .and_then(|raw| raw.parse().ok())
            .unwrap_or_default();

        let verified = attributes.remove("_verified").is_some();
@@ -139,9 +144,8 @@ mod tests {

    #[test]
    fn test_from_str() -> Result<()> {
-        let h = Aheader::from_str(&format!(
-            "addr=me@mail.com; prefer-encrypt=mutual; keydata={RAWKEY}"
-        ))?;
+        let h: Aheader =
+            format!("addr=me@mail.com; prefer-encrypt=mutual; keydata={RAWKEY}").parse()?;

        assert_eq!(h.addr, "me@mail.com");
        assert_eq!(h.prefer_encrypt, EncryptPreference::Mutual);
@@ -153,7 +157,7 @@ mod tests {
    #[test]
    fn test_from_str_reset() -> Result<()> {
        let raw = format!("addr=reset@example.com; prefer-encrypt=reset; keydata={RAWKEY}");
-        let h = Aheader::from_str(&raw)?;
+        let h: Aheader = raw.parse()?;

        assert_eq!(h.addr, "reset@example.com");
        assert_eq!(h.prefer_encrypt, EncryptPreference::NoPreference);
@@ -163,7 +167,7 @@ mod tests {
    #[test]
    fn test_from_str_non_critical() -> Result<()> {
        let raw = format!("addr=me@mail.com; _foo=one; _bar=two; keydata={RAWKEY}");
-        let h = Aheader::from_str(&raw)?;
+        let h: Aheader = raw.parse()?;

        assert_eq!(h.addr, "me@mail.com");
        assert_eq!(h.prefer_encrypt, EncryptPreference::NoPreference);
@@ -173,7 +177,7 @@ mod tests {
    #[test]
    fn test_from_str_superflous_critical() {
        let raw = format!("addr=me@mail.com; _foo=one; _bar=two; other=me; keydata={RAWKEY}");
-        assert!(Aheader::from_str(&raw).is_err());
+        assert!(raw.parse::<Aheader>().is_err());
    }

    #[test]
--- a/src/chat.rs
+++ b/src/chat.rs
@@ -1210,8 +1210,7 @@ SELECT id, rfc724_mid, pre_rfc724_mid, timestamp, ?, 1 FROM msgs WHERE chat_id=?
            );
            let fingerprint = contact
                .fingerprint()
-                .context("Contact does not have a fingerprint in encrypted chat")?
-                .human_readable();
+                .context("Contact does not have a fingerprint in encrypted chat")?;
            if let Some(public_key) = contact.public_key(context).await? {
                if let Some(relay_addrs) = addresses_from_public_key(&public_key) {
                    let relays = relay_addrs.join(",");
--- a/src/config.rs
+++ b/src/config.rs
@@ -407,6 +407,9 @@ pub enum Config {
    #[strum(props(default = "1"))]
    SyncMsgs,

+    /// Make all outgoing messages with Autocrypt header "multipart/signed".
+    SignUnencrypted,
+
    /// Let the core save all events to the database.
    /// This value is used internally to remember the MsgId of the logging xdc
    #[strum(props(default = "0"))]
@@ -463,6 +466,10 @@ pub enum Config {
    /// storing the same token multiple times on the server.
    EncryptedDeviceToken,

+    /// Make `TestContext::pop_sent_msg_opt()` and related functions pop messages from the `smtp`
+    /// head, i.e. make it a queue. For historical reasons the default is a stack.
+    PopSentMsgFromHead,
+
    /// Enables running test hooks, e.g. see `InnerContext::pre_encrypt_mime_hook`.
    /// This way is better than conditional compilation, i.e. `#[cfg(test)]`, because tests not
    /// using this still run unmodified code.
@@ -707,6 +714,7 @@ impl Context {
            | Config::Bot
            | Config::NotifyAboutWrongPw
            | Config::SyncMsgs
+            | Config::SignUnencrypted
            | Config::DisableIdle => {
                ensure!(
                    matches!(value, None | Some("0") | Some("1")),
@@ -940,18 +948,6 @@ impl Context {
    /// Determine whether the specified addr maps to the/a self addr.
    /// Returns `false` if no addresses are configured.
    pub(crate) async fn is_self_addr(&self, addr: &str) -> Result<bool> {
-        // Employ the config cache to optimize for `ConfiguredAddr` passed.
-        if !addr.is_empty()
-            && addr_cmp(
-                addr,
-                &self
-                    .get_config(Config::ConfiguredAddr)
-                    .await?
-                    .unwrap_or_default(),
-            )
-        {
-            return Ok(true);
-        }
        Ok(self
            .get_all_self_addrs()
            .await?
--- a/src/contact.rs
+++ b/src/contact.rs
@@ -1396,7 +1396,7 @@ WHERE addr=?
        let Some(fingerprint_other) = contact.fingerprint() else {
            return Ok(stock_str::encr_none(context));
        };
-        let fingerprint_other = fingerprint_other.human_readable();
+        let fingerprint_other = fingerprint_other.to_string();

        let stock_message = if contact.public_key(context).await?.is_some() {
            stock_str::messages_are_e2ee(context)
@@ -1410,7 +1410,7 @@ WHERE addr=?
        let fingerprint_self = load_self_public_key(context)
            .await?
            .dc_fingerprint()
-            .human_readable();
+            .to_string();
        if addr < contact.addr {
            cat_fingerprint(
                &mut ret,
--- a/src/context.rs
+++ b/src/context.rs
@@ -991,6 +991,12 @@ impl Context {
                .await?
                .to_string(),
        );
+        res.insert(
+            "sign_unencrypted",
+            self.get_config_int(Config::SignUnencrypted)
+                .await?
+                .to_string(),
+        );
        res.insert(
            "debug_logging",
            self.get_config_int(Config::DebugLogging).await?.to_string(),
@@ -1038,6 +1044,13 @@ impl Context {
                .await?
                .to_string(),
        );
+        res.insert(
+            "pop_sent_msg_from_head",
+            self.sql
+                .get_raw_config("pop_sent_msg_from_head")
+                .await?
+                .unwrap_or_default(),
+        );
        res.insert(
            "test_hooks",
            self.sql
--- a/src/decrypt.rs
+++ b/src/decrypt.rs
@@ -1,6 +1,7 @@
 //! Helper functions for decryption.
 //! The actual decryption is done in the [`crate::pgp`] module.

+use std::collections::HashSet;
 use std::io::Cursor;

 use anyhow::{Context as _, Result, bail};
@@ -18,8 +19,8 @@ use crate::chat::ChatId;
 use crate::constants::Chattype;
 use crate::contact::ContactId;
 use crate::context::Context;
-use crate::key::load_self_secret_keyring;
 use crate::key::self_fingerprint;
+use crate::key::{Fingerprint, SignedPublicKey, load_self_secret_keyring};
 use crate::token::Namespace;

 /// Tries to decrypt the message,
@@ -334,6 +335,36 @@ fn get_autocrypt_mime<'a, 'b>(mail: &'a ParsedMail<'b>) -> Option<&'a ParsedMail
    }
 }

+/// Validates signatures of Multipart/Signed message part, as defined in RFC 1847.
+///
+/// Returns the signed part and the set of key
+/// fingerprints for which there is a valid signature.
+///
+/// Returns None if the message is not Multipart/Signed or doesn't contain necessary parts.
+pub(crate) fn validate_detached_signature<'a, 'b>(
+    mail: &'a ParsedMail<'b>,
+    public_keyring_for_validate: &[SignedPublicKey],
+) -> Option<(&'a ParsedMail<'b>, HashSet<Fingerprint>)> {
+    if mail.ctype.mimetype != "multipart/signed" {
+        return None;
+    }
+
+    if let [first_part, second_part] = &mail.subparts[..] {
+        // First part is the content, second part is the signature.
+        let content = first_part.raw_bytes;
+        let ret_valid_signatures = match second_part.get_body_raw() {
+            Ok(signature) => {
+                crate::pgp::pk_validate(content, &signature, public_keyring_for_validate)
+                    .unwrap_or_default()
+            }
+            Err(_) => Default::default(),
+        };
+        Some((first_part, ret_valid_signatures))
+    } else {
+        None
+    }
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;
--- a/src/e2ee.rs
+++ b/src/e2ee.rs
@@ -79,6 +79,16 @@ impl EncryptHelper {

        Ok(ctext)
    }
+
+    /// Signs the passed-in `mail` using the private key from `context`.
+    /// Returns the payload and the signature.
+    pub async fn sign(self, context: &Context, mail: &MimePart<'static>) -> Result<String> {
+        let sign_key = load_self_secret_key(context).await?;
+        let mut buffer = Vec::new();
+        mail.clone().write_part(&mut buffer)?;
+        let signature = pgp::pk_calc_signature(buffer, &sign_key)?;
+        Ok(signature)
+    }
 }

 /// Ensures a private key exists for the configured user.
--- a/src/key.rs
+++ b/src/key.rs
@@ -1,7 +1,7 @@
 //! Cryptographic key module.

 use std::collections::BTreeMap;
-use std::fmt::{self, Write as _};
+use std::fmt;
 use std::io::Cursor;

 use anyhow::{Context as _, Result, bail, ensure};
@@ -583,21 +583,6 @@ impl Fingerprint {
    pub fn hex(&self) -> String {
        hex::encode_upper(&self.0)
    }
-
-    /// Make a human-readable fingerprint.
-    pub fn human_readable(&self) -> String {
-        let mut f = String::new();
-        // Split key into chunks of 4 with space and newline at 20 chars
-        for (i, c) in self.hex().chars().enumerate() {
-            if i > 0 && i % 20 == 0 {
-                writeln!(&mut f).ok();
-            } else if i > 0 && i % 4 == 0 {
-                write!(&mut f, " ").ok();
-            }
-            write!(&mut f, "{c}").ok();
-        }
-        f
-    }
 }

 impl From<pgp::types::Fingerprint> for Fingerprint {
@@ -614,6 +599,22 @@ impl fmt::Debug for Fingerprint {
    }
 }

+/// Make a human-readable fingerprint.
+impl fmt::Display for Fingerprint {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // Split key into chunks of 4 with space and newline at 20 chars
+        for (i, c) in self.hex().chars().enumerate() {
+            if i > 0 && i % 20 == 0 {
+                writeln!(f)?;
+            } else if i > 0 && i % 4 == 0 {
+                write!(f, " ")?;
+            }
+            write!(f, "{c}")?;
+        }
+        Ok(())
+    }
+}
+
 /// Parse a human-readable or otherwise formatted fingerprint.
 impl std::str::FromStr for Fingerprint {
    type Err = anyhow::Error;
@@ -889,7 +890,7 @@ i8pcjGO+IZffvyZJVRWfVooBJmWWbPB1pueo3tx8w3+fcuzpxz+RLFKaPyqXO+dD
            1, 2, 4, 8, 16, 32, 64, 128, 255, 1, 2, 4, 8, 16, 32, 64, 128, 255, 19, 20,
        ]);
        assert_eq!(
-            fp.human_readable(),
+            fp.to_string(),
            "0102 0408 1020 4080 FF01\n0204 0810 2040 80FF 1314"
        );
    }
--- a/src/login_param.rs
+++ b/src/login_param.rs
@@ -70,7 +70,6 @@ pub struct EnteredImapLoginParam {
    /// Folder to watch.
    ///
    /// If empty, user has not entered anything and it shuold expand to "INBOX" later.
-    #[serde(default)]
    pub folder: String,

    /// Socket security.
--- a/src/message.rs
+++ b/src/message.rs
@@ -1901,9 +1901,10 @@ pub async fn markseen_msgs(context: &Context, msg_ids: Vec<MsgId>) -> Result<()>
            //
            // We also don't send read receipts for contact requests.
            // Read receipts will not be sent even after accepting the chat.
+            let wants_mdn = curr_param.get_bool(Param::WantsMdn).unwrap_or_default();
            let to_id = if curr_blocked == Blocked::Not
                && !curr_hidden
-                && curr_param.get_bool(Param::WantsMdn).unwrap_or_default()
+                && wants_mdn
                && curr_param.get_cmd() == SystemMessage::Unknown
                && context.should_send_mdns().await?
            {
@@ -1925,6 +1926,11 @@ pub async fn markseen_msgs(context: &Context, msg_ids: Vec<MsgId>) -> Result<()>
                None
            };
            if let Some(to_id) = to_id {
+                info!(
+                    context,
+                    "Queuing MDN to {to_id} for {id} from {curr_from_id}, wants_mdn={wants_mdn}, cmd={}.",
+                    curr_param.get_cmd()
+                );
                context
                    .sql
                    .execute(
--- a/src/mimefactory.rs
+++ b/src/mimefactory.rs
@@ -1227,18 +1227,53 @@ impl MimeFactory {
                    message.header(header, value)
                });
            let message = MimePart::new("multipart/mixed", vec![message]);
-            let message = protected_headers
+            let mut message = protected_headers
                .iter()
                .fold(message, |message, (header, value)| {
                    message.header(*header, value.clone())
                });

-            // Deduplicate unprotected headers that also are in the protected headers:
-            let protected: HashSet<&str> =
-                HashSet::from_iter(protected_headers.iter().map(|(header, _value)| *header));
-            unprotected_headers.retain(|(header, _value)| !protected.contains(header));
+            if skip_autocrypt || !context.get_config_bool(Config::SignUnencrypted).await? {
+                // Deduplicate unprotected headers that also are in the protected headers:
+                let protected: HashSet<&str> =
+                    HashSet::from_iter(protected_headers.iter().map(|(header, _value)| *header));
+                unprotected_headers.retain(|(header, _value)| !protected.contains(header));

-            message
+                message
+            } else {
+                for (h, v) in &mut message.headers {
+                    if h == "Content-Type"
+                        && let mail_builder::headers::HeaderType::ContentType(ct) = v
+                    {
+                        let mut ct_new = ct.clone();
+                        ct_new = ct_new.attribute("protected-headers", "v1");
+                        if use_std_header_protection {
+                            ct_new = ct_new.attribute("hp", "clear");
+                        }
+                        *ct = ct_new;
+                        break;
+                    }
+                }
+
+                let signature = encrypt_helper.sign(context, &message).await?;
+                MimePart::new(
+                    "multipart/signed; protocol=\"application/pgp-signature\"; protected",
+                    vec![
+                        message,
+                        MimePart::new(
+                            "application/pgp-signature; name=\"signature.asc\"",
+                            signature,
+                        )
+                        .header(
+                            "Content-Description",
+                            mail_builder::headers::raw::Raw::<'static>::new(
+                                "OpenPGP digital signature",
+                            ),
+                        )
+                        .attachment("signature"),
+                    ],
+                )
+            }
        };

        let MimeFactory {
@@ -2157,6 +2192,10 @@ fn group_headers_by_confidentiality(
                }
            }
        } else {
+            // Copy the header to the protected headers
+            // in case of signed-only message.
+            // If the message is not signed, this value will not be used.
+            protected_headers.push(header.clone());
            unprotected_headers.push(header.clone())
        }
    }
--- a/src/mimefactory/mimefactory_tests.rs
+++ b/src/mimefactory/mimefactory_tests.rs
@@ -601,6 +601,70 @@ async fn test_selfavatar_unencrypted() -> anyhow::Result<()> {
    Ok(())
 }

+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn test_selfavatar_unencrypted_signed() {
+    // create chat with bob, set selfavatar
+    let t = TestContext::new_alice().await;
+    t.set_config(Config::SignUnencrypted, Some("1"))
+        .await
+        .unwrap();
+    let chat = t.create_chat_with_contact("bob", "bob@example.org").await;
+
+    let file = t.dir.path().join("avatar.png");
+    let bytes = include_bytes!("../../test-data/image/avatar64x64.png");
+    tokio::fs::write(&file, bytes).await.unwrap();
+    t.set_config(Config::Selfavatar, Some(file.to_str().unwrap()))
+        .await
+        .unwrap();
+
+    // send message to bob: that should get multipart/signed.
+    // `Subject:` is protected by copying it.
+    // make sure, `Subject:` stays in the outer header (imf header)
+    let mut msg = Message::new_text("this is the text!".to_string());
+
+    let sent_msg = t.send_msg(chat.id, &mut msg).await;
+    let mut payload = sent_msg.payload().splitn(4, "\r\n\r\n");
+
+    let part = payload.next().unwrap();
+    assert_eq!(part.match_indices("multipart/signed").count(), 1);
+    assert_eq!(part.match_indices("From:").count(), 1);
+    assert_eq!(part.match_indices("Message-ID:").count(), 1);
+    assert_eq!(part.match_indices("Subject:").count(), 1);
+    assert_eq!(part.match_indices("Autocrypt:").count(), 1);
+    assert_eq!(part.match_indices("Chat-User-Avatar:").count(), 0);
+
+    let part = payload.next().unwrap();
+    assert_eq!(
+        part.match_indices("multipart/mixed; protected-headers=\"v1\"")
+            .count(),
+        1
+    );
+    assert_eq!(part.match_indices("From:").count(), 1);
+    assert_eq!(part.match_indices("Message-ID:").count(), 0);
+    assert_eq!(part.match_indices("Subject:").count(), 1);
+    assert_eq!(part.match_indices("Autocrypt:").count(), 1);
+    assert_eq!(part.match_indices("Chat-User-Avatar:").count(), 0);
+
+    let part = payload.next().unwrap();
+    assert_eq!(part.match_indices("text/plain").count(), 1);
+    assert_eq!(part.match_indices("From:").count(), 0);
+    assert_eq!(part.match_indices("Message-ID:").count(), 1);
+    assert_eq!(part.match_indices("Chat-User-Avatar:").count(), 0);
+    assert_eq!(part.match_indices("Subject:").count(), 0);
+
+    let body = payload.next().unwrap();
+    assert_eq!(body.match_indices("this is the text!").count(), 1);
+
+    let bob = TestContext::new_bob().await;
+    bob.recv_msg(&sent_msg).await;
+    let alice_id = Contact::lookup_id_by_addr(&bob.ctx, "alice@example.org", Origin::Unknown)
+        .await
+        .unwrap()
+        .unwrap();
+    let alice_contact = Contact::get_by_id(&bob.ctx, alice_id).await.unwrap();
+    assert_eq!(alice_contact.is_key_contact(), false);
+}
+
 /// Test that removed member address does not go into the `To:` field.
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_remove_member_bcc() -> Result<()> {
--- a/src/mimeparser.rs
+++ b/src/mimeparser.rs
@@ -20,7 +20,7 @@ use crate::config::Config;
 use crate::constants;
 use crate::contact::{ContactId, import_public_key};
 use crate::context::Context;
-use crate::decrypt::{self};
+use crate::decrypt::{self, validate_detached_signature};
 use crate::dehtml::dehtml;
 use crate::download::PostMsgMetadata;
 use crate::events::EventType;
@@ -304,9 +304,37 @@ impl MimeMessage {

        // Parse hidden headers.
        let mimetype = mail.ctype.mimetype.parse::<Mime>()?;
+        let (part, mimetype) =
+            if mimetype.type_() == mime::MULTIPART && mimetype.subtype().as_str() == "signed" {
+                if let Some(part) = mail.subparts.first() {
+                    // We don't remove "subject" from `headers` because currently just signed
+                    // messages are shown as unencrypted anyway.
+
+                    timestamp_sent =
+                        Self::get_timestamp_sent(&part.headers, timestamp_sent, timestamp_rcvd);
+                    MimeMessage::merge_headers(
+                        context,
+                        &mut headers,
+                        &mut headers_removed,
+                        &mut recipients,
+                        &mut past_members,
+                        &mut from,
+                        &mut list_post,
+                        &mut chat_disposition_notification_to,
+                        part,
+                    );
+                    (part, part.ctype.mimetype.parse::<Mime>()?)
+                } else {
+                    // Not a valid signed message, handle it as plaintext.
+                    (&mail, mimetype)
+                }
+            } else {
+                // Currently we do not sign unencrypted messages by default.
+                (&mail, mimetype)
+            };
        if mimetype.type_() == mime::MULTIPART
            && mimetype.subtype().as_str() == "mixed"
-            && let Some(part) = mail.subparts.first()
+            && let Some(part) = part.subparts.first()
        {
            for field in &part.headers {
                let key = field.get_key().to_lowercase();
@@ -330,7 +358,8 @@ impl MimeMessage {
            );
        }

-        // Remove headers that are allowed _only_ in the encrypted+signed part
+        // Remove headers that are allowed _only_ in the encrypted+signed part. It's ok to leave
+        // them in signed-only emails, but has no value currently.
        let encrypted = false;
        Self::remove_secured_headers(&mut headers, &mut headers_removed, encrypted);

@@ -487,6 +516,17 @@ impl MimeMessage {
            HashMap::new()
        };

+        let mail = mail.as_ref().map(|mail| {
+            let (content, signatures_detached) = validate_detached_signature(mail, &public_keyring)
+                .unwrap_or((mail, Default::default()));
+            let signatures_detached = signatures_detached
+                .into_iter()
+                .map(|fp| (fp, Vec::new()))
+                .collect::<HashMap<_, _>>();
+            signatures.extend(signatures_detached);
+            content
+        });
+
        if let Some(expected_sender_fingerprint) = expected_sender_fingerprint {
            ensure!(
                !signatures.is_empty(),
@@ -502,7 +542,7 @@ impl MimeMessage {
            );
        }

-        if let (Ok(mail), true) = (&mail, is_encrypted) {
+        if let (Ok(mail), true) = (mail, is_encrypted) {
            if !signatures.is_empty() {
                // Unsigned "Subject" mustn't be prepended to messages shown as encrypted
                // (<https://github.com/deltachat/deltachat-core-rust/issues/1790>).
@@ -527,7 +567,7 @@ impl MimeMessage {
                &mut inner_from,
                &mut list_post,
                &mut chat_disposition_notification_to,
-                &mail,
+                mail,
            );

            if !signatures.is_empty() {
@@ -571,7 +611,7 @@ impl MimeMessage {
            signatures.clear();
        }

-        if let (Ok(mail), true) = (&mail, is_encrypted)
+        if let (Ok(mail), true) = (mail, is_encrypted)
            && let Some(post_msg_rfc724_mid) =
                mail.headers.get_header_value(HeaderDef::ChatPostMessageId)
        {
@@ -629,7 +669,7 @@ impl MimeMessage {
            from,
            incoming,
            chat_disposition_notification_to,
-            decryption_error: mail.as_ref().err().map(|err| format!("{err:#}")),
+            decryption_error: mail.err().map(|err| format!("{err:#}")),

            // only non-empty if it was a valid autocrypt message
            signature,
@@ -655,9 +695,9 @@ impl MimeMessage {
            pre_message,
        };

-        match &mail {
+        match mail {
            Ok(mail) => {
-                parser.parse_mime_recursive(context, &mail, false).await?;
+                parser.parse_mime_recursive(context, mail, false).await?;
            }
            Err(err) => {
                let txt = "[This message cannot be decrypted.\n\n• It might already help to simply reply to this message and ask the sender to send the message again.\n\n• If you just re-installed Delta Chat then it is best if you re-setup Delta Chat now and choose \"Add as second device\" or import a backup.]";
@@ -911,14 +951,16 @@ impl MimeMessage {
        self.parse_attachments();

        // See if an MDN is requested from the other side
+        let mut wants_mdn = false;
        if self.decryption_error.is_none()
-            && !self.parts.is_empty()
+            && (!self.parts.is_empty() || matches!(&self.pre_message, PreMessageMode::Pre { .. }))
            && let Some(ref dn_to) = self.chat_disposition_notification_to
        {
            // Check that the message is not outgoing.
            let from = &self.from.addr;
            if !context.is_self_addr(from).await? {
                if from.to_lowercase() == dn_to.addr.to_lowercase() {
+                    wants_mdn = true;
                    if let Some(part) = self.parts.last_mut() {
                        part.param.set_int(Param::WantsMdn, 1);
                    }
@@ -940,7 +982,9 @@ impl MimeMessage {
                typ: Viewtype::Text,
                ..Default::default()
            };
-
+            if wants_mdn {
+                part.param.set_int(Param::WantsMdn, 1);
+            }
            if let Some(ref subject) = self.get_subject()
                && !self.has_chat_version()
                && self.webxdc_status_update.is_none()
@@ -2087,7 +2131,7 @@ async fn parse_gossip_headers(
    let mut gossiped_keys: BTreeMap<String, GossipedKey> = Default::default();

    for value in &gossip_headers {
-        let header = match Aheader::from_str(value) {
+        let header = match value.parse::<Aheader>() {
            Ok(header) => header,
            Err(err) => {
                warn!(context, "Failed parsing Autocrypt-Gossip header: {}", err);
@@ -2177,6 +2221,9 @@ pub(crate) fn parse_message_id(ids: &str) -> Result<String> {
 /// Returns whether the outer header value must be ignored if the message contains a signed (and
 /// optionally encrypted) part. This is independent from the modern Header Protection defined in
 /// <https://www.rfc-editor.org/rfc/rfc9788.html>.
+///
+/// NB: There are known cases when Subject and List-ID only appear in the outer headers of
+/// signed-only messages. Such messages are shown as unencrypted anyway.
 fn is_protected(key: &str) -> bool {
    key.starts_with("chat-")
        || matches!(
@@ -2449,6 +2496,8 @@ async fn handle_mdn(
    let Some((msg_id, chat_id, has_mdns, is_dup)) = context
        .sql
        .query_row_optional(
+            // MDN on a pre-message references the post-message, see `receive_imf`. So we can't tell
+            // which one was seen, but this is on purpose.
            "SELECT
                m.id AS msg_id,
                c.id AS chat_id,
--- a/src/mimeparser/mimeparser_tests.rs
+++ b/src/mimeparser/mimeparser_tests.rs
@@ -7,7 +7,6 @@ use crate::{
    chat,
    chatlist::Chatlist,
    constants::{self, Blocked, DC_DESIRED_TEXT_LEN, DC_ELLIPSIS},
-    contact::Contact,
    key,
    message::{MessageState, MessengerMessage},
    receive_imf::receive_imf,
@@ -2042,24 +2041,32 @@ async fn test_multiple_autocrypt_hdrs() -> Result<()> {
    Ok(())
 }

-/// Tests receiving a simple signed-unencrypted message
-/// that was generated by an old version of Core that supported sending such messages.
+/// Tests that timestamp of signed but not encrypted message is protected.
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn test_receive_signed_only() -> Result<()> {
+async fn test_protected_date() -> Result<()> {
    let mut tcm = TestContextManager::new();
+    let alice = &tcm.alice().await;
    let bob = &tcm.bob().await;

-    let imf_raw = include_bytes!("../../test-data/message/unencrypted_signed_simple.eml");
-    let msg = receive_imf(bob, imf_raw, false).await?.unwrap();
-    assert_eq!(msg.msg_ids.len(), 1);
-    let msg = Message::load_from_db(bob, msg.msg_ids[0]).await?;
-    assert_eq!(msg.get_text(), "Hello!");
-    assert_eq!(msg.viewtype, Viewtype::Text);
-    assert_eq!(msg.get_timestamp(), 1615987853);
+    alice.set_config(Config::SignUnencrypted, Some("1")).await?;

-    let alice_contact = Contact::get_by_id(bob, msg.from_id).await.unwrap();
-    assert_eq!(alice_contact.is_key_contact(), false);
+    let alice_chat = alice.create_email_chat(bob).await;
+    let alice_msg_id = chat::send_text_msg(alice, alice_chat.id, "Hello!".to_string()).await?;
+    let alice_msg = Message::load_from_db(alice, alice_msg_id).await?;
+    assert_eq!(alice_msg.get_showpadlock(), false);

+    let mut sent_msg = alice.pop_sent_msg().await;
+    sent_msg.payload = sent_msg.payload.replacen(
+        "Date:",
+        "Date: Wed, 17 Mar 2021 14:30:53 +0100 (CET)\r\nX-Not-Date:",
+        1,
+    );
+    let bob_msg = bob.recv_msg(&sent_msg).await;
+    assert_eq!(alice_msg.get_text(), bob_msg.get_text());
+
+    // Timestamp that the sender has put into the message
+    // should always be displayed as is on the receiver.
+    assert_eq!(alice_msg.get_timestamp(), bob_msg.get_timestamp());
    Ok(())
 }

--- a/src/pgp.rs
+++ b/src/pgp.rs
@@ -6,15 +6,15 @@ use std::io::Cursor;
 use anyhow::{Context as _, Result, ensure};
 use deltachat_contact_tools::{EmailAddress, may_be_valid_addr};
 use pgp::composed::{
-    Deserializable, DetachedSignature, EncryptionCaps, KeyType as PgpKeyType, MessageBuilder,
-    SecretKeyParamsBuilder, SignedKeyDetails, SignedPublicKey, SignedPublicSubKey, SignedSecretKey,
-    SubkeyParamsBuilder, SubpacketConfig,
+    ArmorOptions, Deserializable, DetachedSignature, EncryptionCaps, KeyType as PgpKeyType,
+    MessageBuilder, SecretKeyParamsBuilder, SignedKeyDetails, SignedPublicKey, SignedPublicSubKey,
+    SignedSecretKey, SubkeyParamsBuilder, SubpacketConfig,
 };
 use pgp::crypto::aead::{AeadAlgorithm, ChunkSize};
 use pgp::crypto::ecc_curve::ECCCurve;
 use pgp::crypto::hash::HashAlgorithm;
 use pgp::crypto::sym::SymmetricKeyAlgorithm;
-use pgp::packet::{Signature, Subpacket, SubpacketData};
+use pgp::packet::{Signature, SignatureConfig, SignatureType, Subpacket, SubpacketData};
 use pgp::types::{
    CompressionAlgorithm, Imprint, KeyDetails, KeyVersion, Password, SignedUser, SigningKey as _,
    StringToKey,
@@ -202,6 +202,47 @@ pub async fn pk_encrypt(
        .await?
 }

+/// Produces a detached signature for `plain` text using `private_key_for_signing`.
+pub fn pk_calc_signature(
+    plain: Vec<u8>,
+    private_key_for_signing: &SignedSecretKey,
+) -> Result<String> {
+    let rng = thread_rng();
+
+    let mut config = SignatureConfig::from_key(
+        rng,
+        &private_key_for_signing.primary_key,
+        SignatureType::Binary,
+    )?;
+
+    config.hashed_subpackets = vec![
+        Subpacket::regular(SubpacketData::IssuerFingerprint(
+            private_key_for_signing.fingerprint(),
+        ))?,
+        Subpacket::critical(SubpacketData::SignatureCreationTime(
+            pgp::types::Timestamp::now(),
+        ))?,
+    ];
+    config.unhashed_subpackets = vec![];
+    if private_key_for_signing.version() <= KeyVersion::V4 {
+        config
+            .unhashed_subpackets
+            .push(Subpacket::regular(SubpacketData::IssuerKeyId(
+                private_key_for_signing.legacy_key_id(),
+            ))?);
+    }
+
+    let signature = config.sign(
+        &private_key_for_signing.primary_key,
+        &Password::empty(),
+        plain.as_slice(),
+    )?;
+
+    let sig = DetachedSignature::new(signature);
+
+    Ok(sig.to_armored_string(ArmorOptions::default())?)
+}
+
 /// Returns fingerprints
 /// of all keys from the `public_keys_for_validation` keyring that
 /// have valid signatures in `msg` and corresponding intended recipient fingerprints
--- a/src/qr.rs
+++ b/src/qr.rs
@@ -645,7 +645,7 @@ async fn decode_openpgp(context: &Context, qr: &str) -> Result<Qr> {
        }
    } else {
        Ok(Qr::FprWithoutAddr {
-            fingerprint: fingerprint.human_readable(),
+            fingerprint: fingerprint.to_string(),
        })
    }
 }
--- a/src/qr/qr_tests.rs
+++ b/src/qr/qr_tests.rs
@@ -388,7 +388,7 @@ async fn test_decode_openpgp_fingerprint() -> Result<()> {
        bob,
        &format!(
            "OPENPGP4FPR:{}#a=alice@example.org",
-            alice_contact.fingerprint().unwrap().hex()
+            alice_contact.fingerprint().unwrap()
        ),
    )
    .await?;
--- a/src/reaction.rs
+++ b/src/reaction.rs
@@ -36,7 +36,10 @@ pub struct Reaction {
    reaction: String,
 }

-impl Reaction {
+// We implement From<&str> instead of std::str::FromStr, because
+// FromStr requires error type and reaction parsing never returns an
+// error.
+impl From<&str> for Reaction {
    /// Convert a `&str` into a `Reaction`.
    /// Everything after the first whitespace is ignored.
    ///
@@ -48,7 +51,7 @@ impl Reaction {
    /// reactions is not different from other kinds of spam attacks
    /// such as sending large numbers of large messages, and should be
    /// dealt with the same way, e.g. by blocking the user.
-    pub fn new(reaction: &str) -> Self {
+    fn from(reaction: &str) -> Self {
        let reaction: &str = reaction
            .split_ascii_whitespace()
            .next()
@@ -58,7 +61,9 @@ impl Reaction {
            reaction: reaction.to_string(),
        }
    }
+}

+impl Reaction {
    /// Returns true if reaction contains no emoji.
    pub fn is_empty(&self) -> bool {
        self.reaction.is_empty()
@@ -207,7 +212,7 @@ pub async fn send_reaction(context: &Context, msg_id: MsgId, reaction: &str) ->
    let msg = Message::load_from_db(context, msg_id).await?;
    let chat_id = msg.chat_id;

-    let reaction = Reaction::new(reaction);
+    let reaction: Reaction = reaction.into();
    let mut reaction_msg = Message::new_text(reaction.as_str().to_string());
    reaction_msg.set_reaction();
    reaction_msg.in_reply_to = Some(msg.rfc724_mid);
@@ -277,7 +282,7 @@ pub async fn get_msg_reactions(context: &Context, msg_id: MsgId) -> Result<React
            |row| {
                let contact_id: ContactId = row.get(0)?;
                let reaction: String = row.get(1)?;
-                Ok((contact_id, Reaction::new(reaction.as_str())))
+                Ok((contact_id, Reaction::from(reaction.as_str())))
            },
        )
        .await?;
@@ -356,32 +361,32 @@ mod tests {
    #[test]
    fn test_parse_reaction() {
        // Check that basic set of emojis from RFC 9078 is supported.
-        assert_eq!(Reaction::new("👍").as_str(), "👍");
-        assert_eq!(Reaction::new("👎").as_str(), "👎");
-        assert_eq!(Reaction::new("😀").as_str(), "😀");
-        assert_eq!(Reaction::new("☹").as_str(), "☹");
-        assert_eq!(Reaction::new("😢").as_str(), "😢");
+        assert_eq!(Reaction::from("👍").as_str(), "👍");
+        assert_eq!(Reaction::from("👎").as_str(), "👎");
+        assert_eq!(Reaction::from("😀").as_str(), "😀");
+        assert_eq!(Reaction::from("☹").as_str(), "☹");
+        assert_eq!(Reaction::from("😢").as_str(), "😢");

        // Empty string can be used to remove all reactions.
-        assert!(Reaction::new("").is_empty());
+        assert!(Reaction::from("").is_empty());

        // Short strings can be used as emojis, could be used to add
        // support for custom emojis via emoji shortcodes.
-        assert_eq!(Reaction::new(":deltacat:").as_str(), ":deltacat:");
+        assert_eq!(Reaction::from(":deltacat:").as_str(), ":deltacat:");

        // Check that long strings are not valid emojis.
        assert!(
-            Reaction::new(":foobarbazquuxaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:").is_empty()
+            Reaction::from(":foobarbazquuxaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:").is_empty()
        );

        // Multiple reactions separated by spaces or tabs are not supported.
-        assert_eq!(Reaction::new("👍 ❤").as_str(), "👍");
-        assert_eq!(Reaction::new("👍\t❤").as_str(), "👍");
+        assert_eq!(Reaction::from("👍 ❤").as_str(), "👍");
+        assert_eq!(Reaction::from("👍\t❤").as_str(), "👍");

-        assert_eq!(Reaction::new("👍\t:foo: ❤").as_str(), "👍");
-        assert_eq!(Reaction::new("👍\t:foo: ❤").as_str(), "👍");
+        assert_eq!(Reaction::from("👍\t:foo: ❤").as_str(), "👍");
+        assert_eq!(Reaction::from("👍\t:foo: ❤").as_str(), "👍");

-        assert_eq!(Reaction::new("👍 👍").as_str(), "👍");
+        assert_eq!(Reaction::from("👍 👍").as_str(), "👍");
    }

    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
@@ -577,7 +582,7 @@ Content-Disposition: reaction\n\
                assert_eq!(chat_id, expected_chat_id);
                assert_eq!(msg_id, expected_msg_id);
                assert_eq!(contact_id, expected_contact_id);
-                assert_eq!(reaction, Reaction::new(expected_reaction));
+                assert_eq!(reaction, Reaction::from(expected_reaction));
            }
            _ => panic!("Unexpected event {event:?}."),
        }
--- a/src/receive_imf.rs
+++ b/src/receive_imf.rs
@@ -3,7 +3,6 @@
 use std::cmp;
 use std::collections::{BTreeMap, BTreeSet};
 use std::iter;
-use std::str::FromStr as _;
 use std::sync::LazyLock;

 use anyhow::{Context as _, Result, ensure};
@@ -1829,7 +1828,7 @@ async fn add_parts(
    // Extract ephemeral timer from the message
    let mut ephemeral_timer = if let Some(value) = mime_parser.get_header(HeaderDef::EphemeralTimer)
    {
-        match EphemeralTimer::from_str(value) {
+        match value.parse::<EphemeralTimer>() {
            Ok(timer) => timer,
            Err(err) => {
                warn!(context, "Can't parse ephemeral timer \"{value}\": {err:#}.");
@@ -2107,7 +2106,7 @@ async fn add_parts(
                chat_id,
                from_id,
                sort_timestamp,
-                Reaction::new(reaction_str.as_str()),
+                Reaction::from(reaction_str.as_str()),
                is_incoming_fresh,
            )
            .await?;
--- a/src/securejoin.rs
+++ b/src/securejoin.rs
@@ -861,8 +861,7 @@ fn encrypted_and_signed(
        } else {
            warn!(
                context,
-                "Message does not match expected fingerprint {}.",
-                expected_fingerprint.human_readable()
+                "Message does not match expected fingerprint {expected_fingerprint}.",
            );
            false
        }
--- a/src/smtp.rs
+++ b/src/smtp.rs
@@ -13,7 +13,7 @@ use crate::config::Config;
 use crate::contact::{Contact, ContactId};
 use crate::context::Context;
 use crate::events::EventType;
-use crate::log::{LogExt, warn};
+use crate::log::warn;
 use crate::message::Message;
 use crate::message::{self, MsgId};
 use crate::mimefactory::MimeFactory;
@@ -590,44 +590,77 @@ async fn send_mdn_rfc724_mid(
    if context.get_config_bool(Config::BccSelf).await? {
        add_self_recipients(context, &mut recipients, encrypted).await?;
    }
-    let recipients: Vec<_> = recipients
-        .into_iter()
-        .filter_map(|addr| {
-            async_smtp::EmailAddress::new(addr.clone())
-                .with_context(|| format!("Invalid recipient: {addr}"))
-                .log_err(context)
-                .ok()
-        })
-        .collect();
+    #[cfg(not(test))]
+    {
+        use crate::log::LogExt;

-    match smtp_send(context, &recipients, &body, smtp, None).await {
-        SendResult::Success => {
-            if !recipients.is_empty() {
-                info!(context, "Successfully sent MDN for {rfc724_mid}.");
+        let recipients: Vec<_> = recipients
+            .into_iter()
+            .filter_map(|addr| {
+                async_smtp::EmailAddress::new(addr.clone())
+                    .with_context(|| format!("Invalid recipient: {addr}"))
+                    .log_err(context)
+                    .ok()
+            })
+            .collect();
+
+        match smtp_send(context, &recipients, &body, smtp, None).await {
+            SendResult::Success => {
+                if !recipients.is_empty() {
+                    info!(context, "Successfully sent MDN for {rfc724_mid}.");
+                }
+                context
+                    .sql
+                    .transaction(|transaction| {
+                        let mut stmt =
+                            transaction.prepare("DELETE FROM smtp_mdns WHERE rfc724_mid = ?")?;
+                        stmt.execute((rfc724_mid,))?;
+                        for additional_rfc724_mid in additional_rfc724_mids {
+                            stmt.execute((additional_rfc724_mid,))?;
+                        }
+                        Ok(())
+                    })
+                    .await?;
+                Ok(true)
            }
-            context
-                .sql
-                .transaction(|transaction| {
-                    let mut stmt =
-                        transaction.prepare("DELETE FROM smtp_mdns WHERE rfc724_mid = ?")?;
-                    stmt.execute((rfc724_mid,))?;
-                    for additional_rfc724_mid in additional_rfc724_mids {
-                        stmt.execute((additional_rfc724_mid,))?;
-                    }
-                    Ok(())
-                })
-                .await?;
-            Ok(true)
+            SendResult::Retry => {
+                info!(
+                    context,
+                    "Temporary SMTP failure while sending an MDN for {rfc724_mid}."
+                );
+                Ok(false)
+            }
+            SendResult::Failure(err) => Err(err),
        }
-        SendResult::Retry => {
-            info!(
-                context,
-                "Temporary SMTP failure while sending an MDN for {rfc724_mid}."
-            );
-            Ok(false)
-        }
-        SendResult::Failure(err) => Err(err),
    }
+    #[cfg(test)]
+    {
+        let _ = smtp;
+        context
+            .sql
+            .transaction(|t| {
+                t.execute(
+                    "INSERT INTO smtp (rfc724_mid, recipients, mime, msg_id)
+                    VALUES (?, ?, ?, ?)",
+                    (rfc724_mid, recipients.join(" "), body, u32::MAX),
+                )?;
+                let mut stmt = t.prepare("DELETE FROM smtp_mdns WHERE rfc724_mid = ?")?;
+                stmt.execute((rfc724_mid,))?;
+                for additional_rfc724_mid in additional_rfc724_mids {
+                    stmt.execute((additional_rfc724_mid,))?;
+                }
+                Ok(())
+            })
+            .await?;
+        Ok(true)
+    }
+}
+
+#[cfg(test)]
+pub(crate) async fn queue_mdn(context: &Context) -> Result<()> {
+    let queued = send_mdn(context, &mut Smtp::new()).await?;
+    assert!(queued);
+    Ok(())
 }

 /// Tries to send a single MDN. Returns true if more MDNs should be sent.
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -624,7 +624,10 @@ impl TestContext {
    }

    pub async fn pop_sent_msg_opt(&self, timeout: Duration) -> Option<SentMessage<'_>> {
-        let rev_order = true;
+        let rev_order = !self
+            .get_config_bool(Config::PopSentMsgFromHead)
+            .await
+            .unwrap();
        self.pop_sent_msg_ex(rev_order, timeout).await
    }

--- a/src/tests/pre_messages/receiving.rs
+++ b/src/tests/pre_messages/receiving.rs
@@ -1,23 +1,26 @@
 //! Tests about receiving Pre-Messages and Post-Message
+use std::time::Duration;
+
 use anyhow::{Context as _, Result};
 use pretty_assertions::assert_eq;

 use crate::EventType;
 use crate::chat;
-use crate::chat::send_msg;
 use crate::config::Config;
 use crate::contact;
 use crate::download::{DownloadState, PRE_MSG_ATTACHMENT_SIZE_THRESHOLD, PostMsgMetadata};
-use crate::message::{Message, MessageState, Viewtype, delete_msgs, markseen_msgs};
+use crate::message::{self, Message, MessageState, Viewtype, delete_msgs, markseen_msgs};
 use crate::mimeparser::MimeMessage;
 use crate::param::Param;
 use crate::reaction::{get_msg_reactions, send_reaction};
 use crate::receive_imf::receive_imf;
+use crate::smtp;
 use crate::summary::assert_summary_texts;
 use crate::test_utils::TestContextManager;
 use crate::tests::pre_messages::util::{
    big_webxdc_app, send_large_file_message, send_large_image_message, send_large_webxdc_message,
 };
+use crate::tools::{SystemTime, time};
 use crate::webxdc::StatusUpdateSerial;

 /// Test that mimeparser can correctly detect and parse pre-messages and Post-Messages
@@ -261,6 +264,64 @@ async fn test_lost_pre_msg() -> Result<()> {
    Ok(())
 }

+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn test_pre_msg_mdn_before_sending_full() -> Result<()> {
+    pre_msg_mdn_before_sending_full("").await
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn test_pre_msg_mdn_before_sending_full_with_text() -> Result<()> {
+    pre_msg_mdn_before_sending_full("text").await
+}
+
+async fn pre_msg_mdn_before_sending_full(text: &str) -> Result<()> {
+    let mut tcm = TestContextManager::new();
+    let alice = &tcm.alice().await;
+    alice
+        .set_config_bool(Config::PopSentMsgFromHead, true)
+        .await?;
+    let bob = &tcm.bob().await;
+    let alice_chat_id = alice.create_group_with_members("", &[bob]).await;
+
+    let file_bytes = include_bytes!("../../../test-data/image/screenshot.gif");
+    let mut msg = Message::new(Viewtype::Image);
+    msg.set_file_from_bytes(alice, "a.jpg", file_bytes, None)?;
+    msg.set_text(text.to_string());
+    let pre_msg = alice.send_msg(alice_chat_id, &mut msg).await;
+    let alice_msg_id = msg.id;
+
+    let msg = bob.recv_msg(&pre_msg).await;
+    assert_eq!(msg.download_state, DownloadState::Available);
+    assert_eq!(msg.id.get_state(bob).await?, MessageState::InFresh);
+    assert_eq!(msg.text, text);
+    assert!(msg.param.get_bool(Param::WantsMdn).unwrap_or_default());
+    msg.chat_id.accept(bob).await?;
+    markseen_msgs(bob, vec![msg.id]).await?;
+    assert_eq!(msg.id.get_state(bob).await?, MessageState::InSeen);
+    assert_eq!(
+        bob.sql
+            .count(
+                "SELECT COUNT(*) FROM smtp_mdns WHERE from_id=?",
+                (msg.from_id,)
+            )
+            .await?,
+        1
+    );
+    smtp::queue_mdn(bob).await?;
+    alice.recv_msg_trash(&bob.pop_sent_msg().await).await;
+    assert_eq!(
+        alice_msg_id.get_state(alice).await?,
+        MessageState::OutPending
+    );
+
+    let _full_msg = alice.pop_sent_msg().await;
+    assert_eq!(
+        alice_msg_id.get_state(alice).await?,
+        MessageState::OutMdnRcvd
+    );
+    Ok(())
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_post_msg_bad_sender() -> Result<()> {
    let mut tcm = TestContextManager::new();
@@ -546,7 +607,7 @@ async fn test_webxdc_updates_in_post_message_after_pre_message() -> Result<()> {
        .send_webxdc_status_update(alice_instance.id, r#"{"payload":42, "info":"i"}"#)
        .await?;

-    send_msg(alice, alice_chat_id, &mut alice_instance).await?;
+    chat::send_msg(alice, alice_chat_id, &mut alice_instance).await?;
    let post_message = alice.pop_sent_msg().await;
    let pre_message = alice.pop_sent_msg().await;

@@ -587,7 +648,7 @@ async fn test_webxdc_updates_in_post_message_without_pre_message() -> Result<()>
        .send_webxdc_status_update(alice_instance.id, r#"{"payload":42, "info":"i"}"#)
        .await?;

-    send_msg(alice, alice_chat_id, &mut alice_instance).await?;
+    chat::send_msg(alice, alice_chat_id, &mut alice_instance).await?;
    let post_message = alice.pop_sent_msg().await;
    let pre_message = alice.pop_sent_msg().await;

@@ -625,7 +686,7 @@ async fn test_markseen_pre_msg() -> Result<()> {
    alice.create_chat(bob).await; // Make sure the chat is accepted.

    tcm.section("Bob sends a large message to Alice");
-    let (pre_message, post_message, _bob_msg_id) =
+    let (pre_message, post_message, bob_msg_id) =
        send_large_file_message(bob, bob_chat_id, Viewtype::File, &vec![0u8; 1_000_000]).await?;

    tcm.section("Alice receives a pre-message message from Bob");
@@ -640,10 +701,23 @@ async fn test_markseen_pre_msg() -> Result<()> {
    assert_eq!(
        alice
            .sql
-            .count("SELECT COUNT(*) FROM smtp_mdns", ())
+            .count(
+                "SELECT COUNT(*) FROM smtp_mdns WHERE from_id=?",
+                (msg.from_id,)
+            )
            .await?,
        1
    );
+    smtp::queue_mdn(alice).await?;
+    SystemTime::shift(Duration::from_secs(3600));
+    bob.recv_msg_trash(&alice.pop_sent_msg().await).await;
+    let bob_msg = Message::load_from_db(bob, bob_msg_id).await?;
+    assert_eq!(bob_msg.get_state(), MessageState::OutMdnRcvd);
+    let read_receipts = message::get_msg_read_receipts(bob, bob_msg_id).await?;
+    assert_eq!(read_receipts.len(), 1);
+    let (contact_id, ts) = read_receipts[0];
+    assert_eq!(contact_id, bob.add_or_lookup_contact_id(alice).await);
+    assert!(ts + 3600 - 60 < time());

    tcm.section("Alice downloads message");
    alice.recv_msg_trash(&post_message).await;
--- a/test-data/message/unencrypted_signed_simple.eml
+++ b/test-data/message/unencrypted_signed_simple.eml
@@ -1,70 +0,0 @@
-Content-Type: multipart/signed; protocol="application/pgp-signature"; protected; 
-	boundary="18aa9ed356ff9321_81d052095421b935_6b26de88a99ef0a0"
-MIME-Version: 1.0
-From: <alice@example.org>
-To: <bob@example.net>
-Subject: Message from alice@example.org
-Date: Wed, 17 Mar 2021 14:30:53 +0100 (CET)
-X-Not-Date: Tue, 28 Apr 2026 20:20:34 +0000
-Message-ID: <13140637-3c00-4553-8b76-fdbbbe3cc117@localhost>
-References: <13140637-3c00-4553-8b76-fdbbbe3cc117@localhost>
-Chat-Version: 1.0
-Chat-Disposition-Notification-To: alice@example.org
-Autocrypt: addr=alice@example.org; prefer-encrypt=mutual; keydata=mDMEXlh13RYJKwYBBAHaRw8BAQdAzfVIAleCXMJrq8VeLlEVof6ITCviMktKjmcBKAu4m5
-	 DCtAQfFggAZgUCAAAAABYhBC5vossjtTLXKGNLWGSwj2Gp7ZRDAhsDAh4JBAsJCAcFFQgJCgsDFgIB
-	 AycJAgIZASwUgAAAAAASABFyZWxheXNAY2hhdG1haWwuYXRhbGljZUBleGFtcGxlLm9yZwAA57ABAL
-	 DeNEB8l86SrqNKbUhDl5e7Q46VN+k/jxPEbIAs506MAQDXxgFEO2xAE19ykJI4JqU8+Zj+dwld9rXM
-	 Bh98UTnEBs0TPGFsaWNlQGV4YW1wbGUub3JnPsKRBBMWCAA5BQIAAAAAFiEELm+iyyO1MtcoY0tYZL
-	 CPYantlEMCGwMCHgkECwkIBwUVCAkKCwMWAgEDJwkCAhkBAAoJEGSwj2Gp7ZRD4e8BAKrOvjAu/Zd+
-	 +XeYCfN00mA7Vb6FtLlvVb0gT0hzv/rBAP0dYE736fa81MseX1PdUeN2Lf9SyNOVw3eW8W0nKXEbDr
-	 g4BF5Ydd0SCisGAQQBl1UBBQEBB0AG7cjWy2SFAU8KnltlubVW67rFiyfp01JrRe6Xqy22HQMBCAeI
-	 eAQYFggAIBYhBC5vossjtTLXKGNLWGSwj2Gp7ZRDBQJeWHXdAhsMAAoJEGSwj2Gp7ZRDLo8BAObE8G
-	 nsGVwKzNqCvHeWgJsqhjS3C6gvSlV3tEm9XmF6AQDXucIyVfoBwoyMh2h6cSn/ATn5QJb35pgo+ivp
-	 3jsMAg==
-
-
--18aa9ed356ff9321_81d052095421b935_6b26de88a99ef0a0
-Content-Type: multipart/mixed; protected-headers="v1"; hp="clear"; 
-	boundary="18aa9ed357004185_2007cbc2d36c354a_6b26de88a99ef0a0"
-From: <alice@example.org>
-To: <bob@example.net>
-Subject: Message from alice@example.org
-Date: Tue, 28 Apr 2026 20:20:34 +0000
-References: <13140637-3c00-4553-8b76-fdbbbe3cc117@localhost>
-Chat-Version: 1.0
-Chat-Disposition-Notification-To: alice@example.org
-Autocrypt: addr=alice@example.org; prefer-encrypt=mutual; keydata=mDMEXlh13RYJKwYBBAHaRw8BAQdAzfVIAleCXMJrq8VeLlEVof6ITCviMktKjmcBKAu4m5
-	 DCtAQfFggAZgUCAAAAABYhBC5vossjtTLXKGNLWGSwj2Gp7ZRDAhsDAh4JBAsJCAcFFQgJCgsDFgIB
-	 AycJAgIZASwUgAAAAAASABFyZWxheXNAY2hhdG1haWwuYXRhbGljZUBleGFtcGxlLm9yZwAA57ABAL
-	 DeNEB8l86SrqNKbUhDl5e7Q46VN+k/jxPEbIAs506MAQDXxgFEO2xAE19ykJI4JqU8+Zj+dwld9rXM
-	 Bh98UTnEBs0TPGFsaWNlQGV4YW1wbGUub3JnPsKRBBMWCAA5BQIAAAAAFiEELm+iyyO1MtcoY0tYZL
-	 CPYantlEMCGwMCHgkECwkIBwUVCAkKCwMWAgEDJwkCAhkBAAoJEGSwj2Gp7ZRD4e8BAKrOvjAu/Zd+
-	 +XeYCfN00mA7Vb6FtLlvVb0gT0hzv/rBAP0dYE736fa81MseX1PdUeN2Lf9SyNOVw3eW8W0nKXEbDr
-	 g4BF5Ydd0SCisGAQQBl1UBBQEBB0AG7cjWy2SFAU8KnltlubVW67rFiyfp01JrRe6Xqy22HQMBCAeI
-	 eAQYFggAIBYhBC5vossjtTLXKGNLWGSwj2Gp7ZRDBQJeWHXdAhsMAAoJEGSwj2Gp7ZRDLo8BAObE8G
-	 nsGVwKzNqCvHeWgJsqhjS3C6gvSlV3tEm9XmF6AQDXucIyVfoBwoyMh2h6cSn/ATn5QJb35pgo+ivp
-	 3jsMAg==
-
-
--18aa9ed357004185_2007cbc2d36c354a_6b26de88a99ef0a0
-Content-Type: text/plain; charset="utf-8"
-Message-ID: <13140637-3c00-4553-8b76-fdbbbe3cc117@localhost>
-Content-Transfer-Encoding: 7bit
-
-Hello!
--18aa9ed357004185_2007cbc2d36c354a_6b26de88a99ef0a0--
-
--18aa9ed356ff9321_81d052095421b935_6b26de88a99ef0a0
-Content-Type: application/pgp-signature; name="signature.asc"; 
-	charset="utf-8"
-Content-Description: OpenPGP digital signature
-Content-Disposition: attachment; filename="signature"
-Content-Transfer-Encoding: quoted-printable
-
-----BEGIN PGP SIGNATURE-----=0A=0AwnUEABYIAB0WIQQub6LLI7Uy1yhjS1hksI9hqe2UQ=
-wWCafEWkQAKCRBksI9hqe2U=0AQ4qaAQCFSLVDANIjaXswP8V5zIwUSvGnUwsMD+ruozO0mG2AqA=
-D9EqpWeD6cc+is=0Av9/nvp6uHi35pUmDX0s1XKu3xbSTWg8=3D=0A=3Dr9hO=0A-----END PGP=
- SIGNATURE-----=0A
--18aa9ed356ff9321_81d052095421b935_6b26de88a99ef0a0--
-
-