Port to gpgme only.

QGpgme and Gpgmepp are not readily available, the cmake files buggy, the
buildsystem horrendous and generally just difficult to build on windows.
Given that all they are is a wrapper around gpgme, we're better of
without all the indirections.

What we loose is:
* QGpgme moved the work to separate threads (but we then blocked
anyways), something that we can just do in our own code should we want to.
* QGpgme has a function to prettify dn's that was used to show the
signer. Also something we could bring back should we need to (don't know
where it is useful atm.)

Ported messagepart to gpgme

Almost there

Moved the crypto bits to a separate file

All gpg code is in one place.

All tests passing

Use error codes

Cleanup

1 files changed, 4 insertions, 188 deletions

diff --git a/framework/src/domain/mime/mailcrypto.cpp b/framework/src/domain/mime/mailcrypto.cpp
index a7f3772a..e429a212 100644
--- a/framework/src/domain/mime/mailcrypto.cpp
+++ b/framework/src/domain/mime/mailcrypto.cpp
@@ -22,22 +22,7 @@
 #include "mailcrypto.h"
 
 #include "framework/src/errors.h"
-
-#include <QGpgME/DataProvider>
-#include <QGpgME/EncryptJob>
-#include <QGpgME/ExportJob>
-#include <QGpgME/ImportFromKeyserverJob>
-#include <QGpgME/ImportJob>
-#include <QGpgME/Protocol>
-#include <QGpgME/SignEncryptJob>
-#include <QGpgME/SignJob>
-
-#include <gpgme++/data.h>
-#include <gpgme++/encryptionresult.h>
-#include <gpgme++/global.h>
-#include <gpgme++/importresult.h>
-#include <gpgme++/keylistresult.h>
-#include <gpgme++/signingresult.h>
+#include "crypto.h"
 
 #include <QDebug>
 
@@ -45,22 +30,8 @@
 #include <utility>
 
 using namespace MailCrypto;
+using namespace Crypto;
 
-QDebug operator<< (QDebug d, const MailCrypto::Key &key)
-{
-    d << key.key.primaryFingerprint();
-    return d;
-}
-
-static std::vector<GpgME::Key> toGpgME(const std::vector<Key> keys)
-{
-    std::vector<GpgME::Key> list;
-    std::transform(keys.begin(), keys.end(), std::back_inserter(list), [] (const Key &key) { return key.key; });
-    return list;
-}
-
-// replace simple LFs by CRLFs for all MIME supporting CryptPlugs
-// according to RfC 2633, 3.1.1 Canonicalization
 static QByteArray canonicalizeContent(KMime::Content *content)
 {
     // if (d->format & Kleo::InlineOpenPGPFormat) {
@@ -125,29 +96,6 @@ static QByteArray canonicalizeContent(KMime::Content *content)
 }
 
 /**
- * Get the given `key` in the armor format.
- */
-Expected<Error, QByteArray> exportPublicKey(const Key &key)
-{
-    // Not using the Qt API because it apparently blocks (the `result` signal is never
-    // triggered)
-    std::unique_ptr<GpgME::Context> ctx(GpgME::Context::createForProtocol(GpgME::OpenPGP));
-    ctx->setArmor(true);
-
-    QGpgME::QByteArrayDataProvider dp;
-    GpgME::Data data(&dp);
-
-    qDebug() << "Exporting public key:" << key.key.shortKeyID();
-    auto error = ctx->exportPublicKeys(key.key.keyID(), data);
-
-    if (error.code()) {
-        return makeUnexpected(Error{error});
-    }
-
-    return dp.data();
-}
-
-/**
  * Create an Email with `msg` as a body and `key` as an attachment.
  *
  * Will create the given structure:
@@ -178,7 +126,7 @@ appendPublicKey(std::unique_ptr<KMime::Content> msg, const Key &key)
     {
         keyAttachment->contentType()->setMimeType("application/pgp-keys");
         keyAttachment->contentDisposition()->setDisposition(KMime::Headers::CDattachment);
-        keyAttachment->contentDisposition()->setFilename(QString("0x") + key.key.shortKeyID() + ".asc");
+        keyAttachment->contentDisposition()->setFilename(QString("0x") + key.shortKeyId + ".asc");
         keyAttachment->setBody(publicKeyData);
     }
 
@@ -192,44 +140,6 @@ appendPublicKey(std::unique_ptr<KMime::Content> msg, const Key &key)
     return result;
 }
 
-Expected<Error, QByteArray> encrypt(const QByteArray &content, const std::vector<Key> &encryptionKeys)
-{
-    QByteArray resultData;
-
-    const QGpgME::Protocol *const proto = QGpgME::openpgp();
-    std::unique_ptr<QGpgME::EncryptJob> job(proto->encryptJob(/* armor = */ true));
-    const auto result = job->exec(toGpgME(encryptionKeys), content, /* alwaysTrust = */ true, resultData);
-
-    if (result.error().code()) {
-        qWarning() << "Encryption failed:" << result.error().asString();
-        return makeUnexpected(Error{result.error()});
-    }
-
-    return resultData;
-}
-
-Expected<Error, QByteArray> signAndEncrypt(const QByteArray &content,
-    const std::vector<Key> &signingKeys, const std::vector<Key> &encryptionKeys)
-{
-    QByteArray resultData;
-
-    const QGpgME::Protocol *const proto = QGpgME::openpgp();
-    std::unique_ptr<QGpgME::SignEncryptJob> job(proto->signEncryptJob(/* armor = */ true));
-    const auto result = job->exec(toGpgME(signingKeys), toGpgME(encryptionKeys), content, /* alwaysTrust = */ true, resultData);
-
-    if (result.first.error().code()) {
-        qWarning() << "Signing failed:" << result.first.error().asString();
-        return makeUnexpected(Error{result.first.error()});
-    }
-
-    if (result.second.error().code()) {
-        qWarning() << "Encryption failed:" << result.second.error().asString();
-        return makeUnexpected(Error{result.second.error()});
-    }
-
-    return resultData;
-}
-
 /**
  * Create a message part like this (according to RFC 3156 Section 4):
  *
@@ -295,11 +205,7 @@ Expected<Error, std::unique_ptr<KMime::Content>>
 createEncryptedEmail(KMime::Content *content, const std::vector<Key> &encryptionKeys,
     const Key &attachedKey, const std::vector<Key> &signingKeys = {})
 {
-    auto contentToEncrypt = canonicalizeContent(content);
-
-    auto encryptionResult = signingKeys.empty() ?
-                                encrypt(contentToEncrypt, encryptionKeys) :
-                                signAndEncrypt(contentToEncrypt, signingKeys, encryptionKeys);
+    auto encryptionResult = signAndEncrypt(canonicalizeContent(content), encryptionKeys, signingKeys);
 
     if (!encryptionResult) {
         return makeUnexpected(Error{encryptionResult.error()});
@@ -317,33 +223,6 @@ createEncryptedEmail(KMime::Content *content, const std::vector<Key> &encryption
 }
 
 /**
- * Sign the given content and returns the signing data and the algorithm used
- * for integrity check in the "pgp-<algorithm>" format.
- */
-Expected<Error, std::pair<QByteArray, QString>>
-sign(const QByteArray &content, const std::vector<Key> &signingKeys)
-{
-    QByteArray resultData;
-
-    const QGpgME::Protocol *const proto = QGpgME::openpgp();
-    std::unique_ptr<QGpgME::SignJob> job(proto->signJob(/* armor = */ true));
-    const auto result = job->exec(toGpgME(signingKeys), content, GpgME::Detached, resultData);
-
-    if (result.error().code()) {
-        qWarning() << "Signing failed:" << result.error().asString();
-        return makeUnexpected(Error{result.error()});
-    }
-
-    auto algo = result.createdSignature(0).hashAlgorithmAsString();
-    // RFC 3156 Section 5:
-    // Hash-symbols are constructed [...] by converting the text name to lower
-    // case and prefixing it with the four characters "pgp-".
-    auto micAlg = (QString("pgp-") + algo).toLower();
-
-    return std::pair<QByteArray, QString>{resultData, micAlg};
-}
-
-/**
  * Create a message part like this (according to RFC 3156 Section 5):
  *
  * + `multipart/signed`
@@ -438,66 +317,3 @@ MailCrypto::processCrypto(std::unique_ptr<KMime::Content> content, const std::ve
     }
 }
 
-void MailCrypto::importKeys(const std::vector<Key> &keys)
-{
-    const QGpgME::Protocol *const backend = QGpgME::openpgp();
-    Q_ASSERT(backend);
-    auto *job = backend->importFromKeyserverJob();
-    job->exec(toGpgME(keys));
-}
-
-MailCrypto::ImportResult MailCrypto::importKey(const QByteArray &pkey)
-{
-    const auto *proto = QGpgME::openpgp();
-    std::unique_ptr<QGpgME::ImportJob> job(proto->importJob());
-    auto result = job->exec(pkey);
-    return {result.numConsidered(), result.numImported(), result.numUnchanged()};
-}
-
-static GpgME::KeyListResult listKeys(const QStringList &patterns, bool secretOnly, int keyListMode, std::vector<Key> &keys)
-{
-    QByteArrayList list;
-    std::transform(patterns.constBegin(), patterns.constEnd(), std::back_inserter(list), [] (const QString &s) { return s.toUtf8(); });
-    std::vector<char const *> pattern;
-    std::transform(list.constBegin(), list.constEnd(), std::back_inserter(pattern), [] (const QByteArray &s) { return s.constData(); });
-    pattern.push_back(0);
-
-    GpgME::initializeLibrary();
-    auto ctx = QSharedPointer<GpgME::Context>{GpgME::Context::createForProtocol(GpgME::OpenPGP)};
-    ctx->setKeyListMode(keyListMode);
-    if (const GpgME::Error err = ctx->startKeyListing(pattern.data(), secretOnly)) {
-        return GpgME::KeyListResult(0, err);
-    }
-
-    GpgME::Error err;
-    do {
-        keys.push_back( Key{ctx->nextKey(err)});
-    } while ( !err );
-
-    keys.pop_back();
-
-    const GpgME::KeyListResult result = ctx->endKeyListing();
-    ctx->cancelPendingOperation();
-    return result;
-}
-
-std::vector<Key> MailCrypto::findKeys(const QStringList &filter, bool findPrivate, bool remote)
-{
-    std::vector<Key> keys;
-    GpgME::KeyListResult res = listKeys(filter, findPrivate, remote ? GpgME::Extern : GpgME::Local, keys);
-    if (res.error()) {
-        qWarning() << "Failed to lookup keys: " << res.error().asString();
-        return {};
-    }
-    qWarning() << "got keys:" << keys.size();
-
-    for (auto i = keys.begin(); i != keys.end(); ++i) {
-        qWarning() << "key isnull:" << i->key.isNull() << "isexpired:" << i->key.isExpired();
-        qWarning() << "key numuserIds:" << i->key.numUserIDs();
-        for (uint k = 0; k < i->key.numUserIDs(); ++k) {
-            qWarning() << "userIDs:" << i->key.userID(k).email();
-        }
-    }
-
-    return keys;
-}