diff --git a/CMakeLists.txt b/CMakeLists.txt
index 0fdec4c..fffe070 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,55 +1,55 @@
 # Copyright (C) 2018 by Intevation GmbH <info@intevation.de>
 #
 # This file is Free Software under the GNU GPL (v>=2)
 # and comes with ABSOLUTELY NO WARRANTY!
 # See LICENSE.txt for details.
 
 cmake_minimum_required(VERSION 2.8.8)
 project(gpg4win-tools)
 set(PRETTY_NAME cryp.do)
 
 ### Generic Setup
 
 set(KF5_VERSION "5.43.0")
 set(GPGME_REQUIRED_VERSION "1.8.0")
 set(QT_REQUIRED_VERSION "5.6.0")
-set(LIBKLEO_VERSION "5.16.81")
+set(LIBKLEO_VERSION "5.17.44")
 
 #Old qtmain linking behavior to be compatible with cmake versions < 2.8.11
 
 if(POLICY CMP0020)
   cmake_policy(SET CMP0020 OLD)
 endif()
 
 find_package(Qt5 ${QT_REQUIRED_VERSION} CONFIG REQUIRED Widgets)
 
 find_package(Gpgmepp ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
 find_package(QGpgme ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
 find_package(KF5Libkleo ${LIBKLEO_VERSION} CONFIG REQUIRED)
 find_package(KF5WidgetsAddons ${KF5_VERSION} CONFIG REQUIRED)
 
 set(CMAKE_AUTOMOC ON)
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 
 
 if(WIN32)
    add_definitions(-D_WIN32_WINNT=0x0600) # Windows vista
    add_definitions(-DWINVER=0x0600)
    add_definitions(-DUNICODE -D_UNICODE)
    add_definitions(-DMINGW_HAS_SECURE_API) # for _s functions
 endif(WIN32)
 
 
 set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
 # Cmake does not correctly identify gcc windres when cross compiling
 # making this line neccessary to set the correct flags for it.
 # See: http://public.kitware.com/Bug/view.php?id=11773
 SET(CMAKE_RC_COMPILE_OBJECT
       "<CMAKE_RC_COMPILER> <FLAGS> <DEFINES> -Ocoff <SOURCE> <OBJECT>")
 
 #add_subdirectory(img)
 ### Include the actual source directories
 add_subdirectory(src)
diff --git a/src/resolver/resolver.cpp b/src/resolver/resolver.cpp
index 34243c2..a54524b 100644
--- a/src/resolver/resolver.cpp
+++ b/src/resolver/resolver.cpp
@@ -1,176 +1,163 @@
 /* Copyright (C) 2018 by Intevation GmbH <info@intevation.de>
  *
  * This file is free software under the GNU GPL (v>=2)
  * and comes with ABSOLUTELY NO WARRANTY!
  * See LICENSE.txt for details.
  */
 
 #include "resolver.h"
 
 #include "util/overlay.h"
 
 #include <QApplication>
 #include <QCommandLineParser>
 #include <QDebug>
 
 #include <Libkleo/Enum>
 #include <Libkleo/KeyResolver>
 
 #include <gpgme++/key.h>
 
 #include <iostream>
 
 class Resolver::Private
 {
 public:
     Private(Resolver *qq): q(qq) {
     }
 
     void printResolvedKeys(const Kleo::KeyResolver *kr) {
-        const auto sigMap = kr->signingKeys();
-        for (const auto fmt: sigMap.keys()) {
-            for (const auto &key: sigMap[fmt]) {
-                std::string fmtStr;
-                if (fmt == GpgME::CMS) {
-                    fmtStr = "smime";
-                } else {
-                    fmtStr = "openpgp";
-                }
-                if (!key.isNull()) {
-                    std::cout << "sig:" << fmtStr << ":"
-                        << key.primaryFingerprint() << std::endl;
-                }
+        const auto result = kr->result();
+        for (const auto &key: result.signingKeys) {
+            if (!key.isNull()) {
+                const std::string protocol = key.protocol() == GpgME::CMS ? "smime" : "openpgp";
+                std::cout << "sig:" << protocol << ":"
+                    << key.primaryFingerprint() << std::endl;
             }
         }
-        const auto encMap = kr->encryptionKeys();
-        for (const auto fmt: encMap.keys()) {
-            for (const auto &mbox: encMap[fmt].keys()) {
-                for (const auto &key: encMap[fmt][mbox]) {
-                    std::string fmtStr;
-                    if (fmt == GpgME::CMS) {
-                        fmtStr = "smime";
-                    } else {
-                        fmtStr = "openpgp";
-                    }
-                    if (!key.isNull()) {
-                        std::cout << "enc:" << fmtStr << ":"
-                            << key.primaryFingerprint() << ":" << mbox.toUtf8().constData()
-                            << std::endl;
-                    }
+        for (auto it = std::cbegin(result.encryptionKeys); it != std::cend(result.encryptionKeys); ++it) {
+            const auto &mbox = it.key();
+            const auto &keys = it.value();
+            for (const auto &key: keys) {
+                if (!key.isNull()) {
+                    const std::string protocol = key.protocol() == GpgME::CMS ? "smime" : "openpgp";
+                    std::cout << "enc:" << protocol << ":"
+                        << key.primaryFingerprint() << ":" << mbox.toUtf8().constData()
+                        << std::endl;
                 }
             }
         }
     }
 
     void newOverlay(WId wid, const QString &text)
     {
         m_overlay = std::shared_ptr<Overlay>(new Overlay(wid, text));
     }
 
     void newResolver(const QCommandLineParser &parser) {
         const auto proto = parser.value(QStringLiteral("protocol")).toLower();
         GpgME::Protocol format;
         if (proto == QStringLiteral("cms")) {
             format = GpgME::CMS;
         } else if (proto == QStringLiteral("pgp")) {
             format = GpgME::OpenPGP;
         } else {
             format = GpgME::UnknownProtocol;
         }
 
         const auto preferredVal = parser.value(QStringLiteral("preferred-protocol")).toLower();
         GpgME::Protocol preferred = GpgME::UnknownProtocol;
         if (preferredVal == QStringLiteral("cms")) {
             preferred = GpgME::CMS;
         } else if (preferredVal == QStringLiteral("pgp")) {
             preferred = GpgME::OpenPGP;
         }
 
         QMap <GpgME::Protocol, QMap <QString, QStringList> > overrides;
 
         for (const QString &oride: parser.values("override")) {
             const QStringList split = oride.split(QLatin1Char(':'));
             GpgME::Protocol fmt = GpgME::UnknownProtocol;
             if (split.size() < 2 || split.size() > 3) {
                 qDebug() << "Invalid override format";
                 std::cout << "cancel" << std::endl;
                 qApp->quit();
             }
 
             if (split.size() == 3) {
                 const QString fmtStr = split[2].toLower();
                 if (fmtStr == "openpgp") {
                     fmt = GpgME::OpenPGP;
                 } else if (fmtStr == "smime") {
                     fmt = GpgME::CMS;
                 } else if (fmtStr == "auto") {
                     fmt = GpgME::UnknownProtocol;
                 } else {
                     qDebug() << "Invalid override format string";
                     std::cout << "cancel" << std::endl;
                     qApp->quit();
                 }
             }
             const QStringList fingerprints = split[1].split(QLatin1Char(','));
 
             auto map = overrides.value(fmt);
             map.insert(split[0], fingerprints);
             overrides.insert(fmt, map);
             qDebug () << "Passing overrides" << fingerprints << split[0];
         }
 
         const auto recps = parser.positionalArguments();
         auto *kr = new Kleo::KeyResolver (!recps.isEmpty() || parser.isSet(QStringLiteral("encrypt")) /* encrypt */,
                                           parser.isSet(QStringLiteral("sign")) /*sign*/,
                                           format /* CryptoMesssageFormat */,
                                           parser.isSet("allowMixed")/* AllowMixed */);
 
         kr->setRecipients(recps);
         kr->setSender(parser.value("sender"));
         kr->setOverrideKeys(overrides);
         kr->setPreferredProtocol(preferred);
 
         connect (kr, &Kleo::KeyResolver::keysResolved, q, [this, kr] (bool success, bool sendUnencrypted) {
             if (!success) {
                 std::cout << "cancel" << std::endl;
             } else if (sendUnencrypted) {
                 std::cout << "unencrypted" << std::endl;
             } else {
                 printResolvedKeys(kr);
             }
             delete kr;
             qApp->quit();
         });
         kr->setDialogWindowFlags(Qt::Window |
                                  Qt::CustomizeWindowHint |
                                  Qt::WindowTitleHint |
                                  Qt::WindowCloseButtonHint);
         kr->start(parser.isSet(QStringLiteral("alwaysShow")), m_overlay.get());
     }
     Resolver *q;
     std::shared_ptr<Overlay> m_overlay;
 };
 
 Resolver::Resolver(int &argc, char *argv[]) :
     QApplication(argc, argv),
     d(new Private(this))
 {
 
 }
 
 QString Resolver::newInstance(const QCommandLineParser &parser)
 {
     const auto hwnd = parser.value(QStringLiteral("hwnd"));
     if (!hwnd.isEmpty()) {
         bool ok;
         WId id = (WId) hwnd.toInt(&ok);
         if (!ok) {
             std::cerr << "invalid hwnd value" << std::endl;
             exit(EXIT_FAILURE);
         }
         d->newOverlay(id, parser.value(QStringLiteral("overlayText")));
     }
     d->newResolver(parser);
 
     return QString();
 }