5 files changed, 137 insertions, 19 deletions

diff --git a/framework/src/domain/composercontroller.cpp b/framework/src/domain/composercontroller.cpp
index 09d4c154..2286a71b 100644
--- a/framework/src/domain/composercontroller.cpp
+++ b/framework/src/domain/composercontroller.cpp
@@ -99,19 +99,19 @@ class AddresseeController : public Kube::ListPropertyController
 public:
 
     bool mFoundAllKeys = true;
+
     QSet<QByteArray> mMissingKeys;
-    AddresseeController()
-        : Kube::ListPropertyController{{"name", "keyFound", "key"}}
+    AddresseeController() : Kube::ListPropertyController{{"name", "keyFound", "key"}}
     {
-        QObject::connect(this, &Kube::ListPropertyController::added, this, [this] (const QByteArray &id, const QVariantMap &map) {
-            findKey(id, map.value("name").toString());
-        });
+        QObject::connect(
+            this, &Kube::ListPropertyController::added, this, [this](const QByteArray &id, const QVariantMap &map) {
+                findKey(id, map.value("name").toString());
+            });
+
         QObject::connect(this, &Kube::ListPropertyController::removed, this, [this] (const QByteArray &id) {
             mMissingKeys.remove(id);
             setFoundAllKeys(mMissingKeys.isEmpty());
         });
-
-
     }
 
     bool foundAllKeys()
@@ -133,12 +133,13 @@ public:
         mb.fromUnicodeString(addressee);
 
         SinkLog() << "Searching key for: " << mb.address();
-        asyncRun<std::vector<GpgME::Key>>(this, [mb] {
+        asyncRun<std::vector<GpgME::Key>>(this,
+            [mb] {
                 return MailCrypto::findKeys(QStringList{} << mb.address(), false, false, MailCrypto::OPENPGP);
             },
             [this, addressee, id](const std::vector<GpgME::Key> &keys) {
                 if (!keys.empty()) {
-                    if (keys.size() > 1 ) {
+                    if (keys.size() > 1) {
                         SinkWarning() << "Found more than one key, encrypting to all of them.";
                     }
                     SinkLog() << "Found key: " << keys.front().primaryFingerprint();
@@ -154,7 +155,7 @@ public:
 
     void set(const QStringList &list)
     {
-        for (const auto &email: list) {
+        for (const auto &email : list) {
             add({{"name", email}});
         }
     }
diff --git a/framework/src/domain/mime/mailtemplates.cpp b/framework/src/domain/mime/mailtemplates.cpp
index 8e644b34..30f9a48d 100644
--- a/framework/src/domain/mime/mailtemplates.cpp
+++ b/framework/src/domain/mime/mailtemplates.cpp
@@ -53,6 +53,18 @@ static bool operator==(const KMime::Types::Mailbox &left, const KMime::Types::Ma
     return (left.addrSpec().asString() == right.addrSpec().asString());
 }
     }
+
+    Message* contentToMessage(Content* content) {
+        content->assemble();
+        const auto encoded = content->encodedContent();
+
+        auto message = new Message();
+        message->setContent(encoded);
+        message->parse();
+
+        return message;
+    }
+
 }
 
 static KMime::Types::Mailbox::List stripMyAddressesFromAddressList(const KMime::Types::Mailbox::List &list, const KMime::Types::AddrSpecList me)
@@ -215,7 +227,7 @@ KMime::Content *createMultipartAlternativeContent(const QString &plainBody, cons
     //FIXME This is supposed to select a charset out of the available charsets that contains all necessary characters to render the text
     // QTextCodec *charset = selectCharset(m_charsets, htmlBody);
     // htmlPart->contentType()->setCharset(charset->name());
-    textPart->contentType()->setCharset("utf-8");
+    htmlPart->contentType()->setCharset("utf-8");
     htmlPart->contentTransferEncoding()->setEncoding(KMime::Headers::CE8Bit);
     htmlPart->fromUnicodeString(htmlBody);
     multipartAlternative->addContent(htmlPart);
@@ -223,6 +235,19 @@ KMime::Content *createMultipartAlternativeContent(const QString &plainBody, cons
     return multipartAlternative;
 }
 
+KMime::Content *createMultipartMixedContent(QVector<KMime::Content *> contents)
+{
+    KMime::Content *multiPartMixed = new KMime::Content();
+    multiPartMixed->contentType()->setMimeType("multipart/mixed");
+    multiPartMixed->contentType()->setBoundary(KMime::multiPartBoundary());
+
+    for (const auto &content : contents) {
+        multiPartMixed->addContent(content);
+    }
+
+    return multiPartMixed;
+}
+
 void addProcessedBodyToMessage(const KMime::Message::Ptr &msg, const QString &plainBody, const QString &htmlBody, bool forward)
 {
     //FIXME
@@ -864,27 +889,70 @@ void MailTemplates::reply(const KMime::Message::Ptr &origMsg, const std::functio
     });
 }
 
-void MailTemplates::forward(const KMime::Message::Ptr &origMsg, const std::function<void(const KMime::Message::Ptr &result)> &callback)
+void MailTemplates::forward(const KMime::Message::Ptr &origMsg,
+    const std::function<void(const KMime::Message::Ptr &result)> &callback)
 {
     KMime::Message::Ptr wrapperMsg(new KMime::Message);
 
     wrapperMsg->to()->clear();
     wrapperMsg->cc()->clear();
 
-    wrapperMsg->subject()->fromUnicodeString(forwardSubject(origMsg->subject()->asUnicodeString()), "utf-8");
+    // Decrypt the original message, it will be encrypted again in the composer
+    // for the right recipient
+    KMime::Message::Ptr forwardedMessage(new KMime::Message());
+    if (isEncrypted(origMsg.data())) {
+        qDebug() << "Original message was encrypted, decrypting it";
+        MimeTreeParser::ObjectTreeParser otp;
+        otp.parseObjectTree(origMsg.data());
+        otp.decryptParts();
 
-    const QByteArray refStr = getRefStr(origMsg);
+        auto htmlContent = otp.htmlContent();
+
+        KMime::Content *recreatedMsg =
+            htmlContent.isEmpty() ? createPlainPartContent(otp.plainTextContent()) :
+                                    createMultipartAlternativeContent(otp.plainTextContent(), htmlContent);
+
+        KMime::Message::Ptr tmpForwardedMessage;
+        auto attachments = otp.collectAttachmentParts();
+        if (!attachments.isEmpty()) {
+            QVector<KMime::Content *> contents = {recreatedMsg};
+            for (const auto &attachment : attachments) {
+                contents.append(attachment->node());
+            }
+
+            auto msg = createMultipartMixedContent(contents);
+
+            tmpForwardedMessage.reset(KMime::contentToMessage(msg));
+        } else {
+            tmpForwardedMessage.reset(KMime::contentToMessage(recreatedMsg));
+        }
+
+        origMsg->contentType()->fromUnicodeString(tmpForwardedMessage->contentType()->asUnicodeString(), "utf-8");
+        origMsg->assemble();
+        forwardedMessage->setHead(origMsg->head());
+        forwardedMessage->setBody(tmpForwardedMessage->encodedBody());
+        forwardedMessage->parse();
+
+    } else {
+        qDebug() << "Original message was not encrypted, using it as-is";
+        forwardedMessage = origMsg;
+    }
+
+    wrapperMsg->subject()->fromUnicodeString(
+        forwardSubject(forwardedMessage->subject()->asUnicodeString()), "utf-8");
+
+    const QByteArray refStr = getRefStr(forwardedMessage);
     if (!refStr.isEmpty()) {
         wrapperMsg->references()->fromUnicodeString(QString::fromLocal8Bit(refStr), "utf-8");
     }
 
-    KMime::Content* fwdAttachment = new KMime::Content;
+    KMime::Content *fwdAttachment = new KMime::Content;
 
     fwdAttachment->contentDisposition()->setDisposition(KMime::Headers::CDinline);
     fwdAttachment->contentType()->setMimeType("message/rfc822");
-    fwdAttachment->contentDisposition()->setFilename(origMsg->subject()->asUnicodeString() + ".eml");
+    fwdAttachment->contentDisposition()->setFilename(forwardedMessage->subject()->asUnicodeString() + ".eml");
     // The mail was parsed in loadMessage before, so no need to assemble it
-    fwdAttachment->setBody(origMsg->encodedContent());
+    fwdAttachment->setBody(forwardedMessage->encodedContent());
 
     wrapperMsg->addContent(fwdAttachment);
     wrapperMsg->assemble();
diff --git a/framework/src/domain/mime/mimetreeparser/tests/CMakeLists.txt b/framework/src/domain/mime/mimetreeparser/tests/CMakeLists.txt
index edc037bc..88f7c47a 100644
--- a/framework/src/domain/mime/mimetreeparser/tests/CMakeLists.txt
+++ b/framework/src/domain/mime/mimetreeparser/tests/CMakeLists.txt
@@ -11,7 +11,7 @@ include(ECMAddTests)
 find_package(Gpgmepp 1.7.1 CONFIG)
 find_package(QGpgme 1.7.1 CONFIG)
 
-add_executable(mimetreeparsertest interfacetest.cpp)
+add_executable(mimetreeparsertest mimetreeparsertest.cpp)
 add_gpg_crypto_test(mimetreeparsertest mimetreeparsertest)
 target_link_libraries(mimetreeparsertest
     kube_otp
diff --git a/framework/src/domain/mime/mimetreeparser/tests/interfacetest.cpp b/framework/src/domain/mime/mimetreeparser/tests/mimetreeparsertest.cpp
index 69509715..961dbf9a 100644
--- a/framework/src/domain/mime/mimetreeparser/tests/interfacetest.cpp
+++ b/framework/src/domain/mime/mimetreeparser/tests/mimetreeparsertest.cpp
@@ -374,4 +374,4 @@ private slots:
 };
 
 QTEST_GUILESS_MAIN(InterfaceTest)
-#include "interfacetest.moc"
+#include "mimetreeparsertest.moc"
diff --git a/framework/src/domain/mime/tests/mailtemplatetest.cpp b/framework/src/domain/mime/tests/mailtemplatetest.cpp
index 8d044608..6338cd58 100644
--- a/framework/src/domain/mime/tests/mailtemplatetest.cpp
+++ b/framework/src/domain/mime/tests/mailtemplatetest.cpp
@@ -248,6 +248,55 @@ private slots:
         QCOMPARE(origMsg->subject(false)->asUnicodeString(), {"A random subject with alternative contenttype"});
     }
 
+    void testEncryptedForwardAsAttachment()
+    {
+        auto msg = readMail("openpgp-encrypted.mbox");
+        KMime::Message::Ptr result;
+        MailTemplates::forward(msg, [&](const KMime::Message::Ptr &r) { result = r; });
+        QTRY_VERIFY(result);
+        QCOMPARE(result->subject(false)->asUnicodeString(), {"FW: OpenPGP encrypted"});
+        QCOMPARE(result->to()->addresses(), {});
+        QCOMPARE(result->cc()->addresses(), {});
+
+        auto attachments = result->attachments();
+        QCOMPARE(attachments.size(), 1);
+        auto attachment = attachments[0];
+        QCOMPARE(attachment->contentDisposition(false)->disposition(), KMime::Headers::CDinline);
+        QCOMPARE(attachment->contentDisposition(false)->filename(), {"OpenPGP encrypted.eml"});
+        QVERIFY(attachment->bodyIsMessage());
+
+        attachment->parse();
+        auto origMsg = attachment->bodyAsMessage();
+        QCOMPARE(origMsg->subject(false)->asUnicodeString(), {"OpenPGP encrypted"});
+    }
+
+    void testEncryptedWithAttachmentsForwardAsAttachment()
+    {
+        auto msg = readMail("openpgp-encrypted-two-attachments.mbox");
+        KMime::Message::Ptr result;
+        MailTemplates::forward(msg, [&](const KMime::Message::Ptr &r) { result = r; });
+        QTRY_VERIFY(result);
+        QCOMPARE(result->subject(false)->asUnicodeString(), {"FW: OpenPGP encrypted with 2 text attachments"});
+        QCOMPARE(result->to()->addresses(), {});
+        QCOMPARE(result->cc()->addresses(), {});
+
+        auto attachments = result->attachments();
+        QCOMPARE(attachments.size(), 1);
+        auto attachment = attachments[0];
+        QCOMPARE(attachment->contentDisposition(false)->disposition(), KMime::Headers::CDinline);
+        QCOMPARE(attachment->contentDisposition(false)->filename(), {"OpenPGP encrypted with 2 text attachments.eml"});
+        QVERIFY(attachment->bodyIsMessage());
+
+        attachment->parse();
+        auto origMsg = attachment->bodyAsMessage();
+        QCOMPARE(origMsg->subject(false)->asUnicodeString(), {"OpenPGP encrypted with 2 text attachments"});
+
+        auto attattachments = origMsg->attachments();
+        QCOMPARE(attattachments.size(), 2);
+        QCOMPARE(attattachments[0]->contentDisposition(false)->filename(), {"attachment1.txt"});
+        QCOMPARE(attattachments[1]->contentDisposition(false)->filename(), {"attachment2.txt"});
+    }
+
     void testCreatePlainMail()
     {
         QStringList to = {{"to@example.org"}};