diff --git a/CMakeLists.txt b/CMakeLists.txt
index 866bceb8e..769423050 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,178 +1,178 @@
 set(kleopatra_version 3.1.15)
 # The following is for Windows. Keep in line with kleopatra_version.
 set(kleopatra_fileversion 3,1,15,0)
 cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
 project(kleopatra VERSION ${kleopatra_version})
 
 # The RELEASE_SERVICE_VERSION is used by Gpg4win to add the Gpg4win version
 if (NOT RELEASE_SERVICE_VERSION)
     set (RELEASE_SERVICE_VERSION "21.07.40")
 endif()
 
 option(FORCE_DISABLE_KCMUTILS "Force building Kleopatra without KCMUtils. Doing this will disable configuration KCM Plugins. [default=OFF]" OFF)
 option(DISABLE_KWATCHGNUPG "Don't build the kwatchgnupg tool [default=OFF]" OFF)
 
 # Standalone build. Find / include everything necessary.
 set(KF5_MIN_VERSION "5.82.0")
 set(KMIME_VERSION "5.17.40")
-set(LIBKLEO_VERSION "5.17.43")
+set(LIBKLEO_VERSION "5.17.45")
 set(QT_REQUIRED_VERSION "5.15.0")
 set(GPGME_REQUIRED_VERSION "1.13.1")
 set(BOOST_REQUIRED_VERSION "1.58")
 
 if (WIN32)
   set(KF5_WANT_VERSION "5.70.0")
   set(KMIME_WANT_VERSION "5.12.0")
 else ()
   set(KF5_WANT_VERSION ${KF5_MIN_VERSION})
   set(KMIME_WANT_VERSION ${KMIME_VERSION})
 endif ()
 
 find_package(ECM ${KF5_WANT_VERSION} CONFIG REQUIRED)
 set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH})
 set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH})
 
 include(ECMInstallIcons)
 include(ECMSetupVersion)
 include(ECMAddTests)
 include(GenerateExportHeader)
 include(ECMGenerateHeaders)
 include(FeatureSummary)
 include(CheckFunctionExists)
 include(ECMGeneratePriFile)
 include(KDEInstallDirs)
 include(KDECMakeSettings)
 include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE)
 include(ECMAddAppIcon)
 include(ECMQtDeclareLoggingCategory)
 
 # Find KF5 packages
 if (NOT FORCE_DISABLE_KCMUTILS)
   find_package(KF5KCMUtils ${KF5_WANT_VERSION} CONFIG REQUIRED)
 endif()
 find_package(KF5WidgetsAddons ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5ConfigWidgets ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5CoreAddons ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5Codecs ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5Config ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5I18n ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5IconThemes ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5ItemModels ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5XmlGui ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5WindowSystem ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5DocTools ${KF5_WANT_VERSION} CONFIG)
 find_package(KF5Crash ${KF5_WANT_VERSION} REQUIRED)
 
 set_package_properties(KF5DocTools PROPERTIES
     DESCRIPTION "Documentation tools"
     PURPOSE "Required to generate Kleopatra documentation."
     TYPE OPTIONAL)
 
 # Optional packages
 if (WIN32)
   # Only a replacement available for Windows so this
   # is required on other platforms.
   find_package(KF5DBusAddons ${KF5_WANT_VERSION} CONFIG)
   set_package_properties(KF5DBusAddons PROPERTIES DESCRIPTION "Support library to work with DBus"
                          PURPOSE "DBus session integration"
                          URL "https://inqlude.org/libraries/kdbusaddons.html"
                          TYPE OPTIONAL)
 else()
   find_package(KF5DBusAddons ${KF5_WANT_VERSION} CONFIG REQUIRED)
   set(_kleopatra_dbusaddons_libs KF5::DBusAddons)
 endif()
 
 set(HAVE_QDBUS ${Qt5DBus_FOUND})
 
 find_package(Gpgmepp ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
 find_package(QGpgme ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
 if (QGpgme_VERSION VERSION_GREATER_EQUAL "1.15.2")
     set(QGPGME_SUPPORTS_TRUST_SIGNATURES 1)
 endif()
 
 # Kdepimlibs packages
 find_package(KF5Libkleo ${LIBKLEO_VERSION} CONFIG REQUIRED)
 find_package(KF5Mime ${KMIME_WANT_VERSION} CONFIG REQUIRED)
 
 find_package(Qt5 ${QT_REQUIRED_VERSION} CONFIG REQUIRED Widgets Test Network PrintSupport)
 
 find_package(Assuan2 REQUIRED)
 
 set(HAVE_KCMUTILS ${KF5KCMUtils_FOUND})
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 find_package(Boost ${BOOST_REQUIRED_VERSION} MODULE REQUIRED)
 
 find_path(Boost_TOPOLOGICAL_SORT_DIR NAMES boost/graph/topological_sort.hpp PATHS ${Boost_INCLUDE_DIRS})
 if(NOT Boost_TOPOLOGICAL_SORT_DIR)
     message(FATAL_ERROR "The Boost Topological_sort header was NOT found. Should be part of Boost graph module.")
 endif()
 
 set(kleopatra_release FALSE)
 
 if(NOT kleopatra_release)
     if(GIT_FOUND)
         execute_process(COMMAND ${GIT_EXECUTABLE} log -1 --oneline --format=%h ${CMAKE_CURRENT_SOURCE_DIR}
             WORKING_DIRECTORY ${kdepim_SOURCE_DIR}/kleopatra
             OUTPUT_VARIABLE Kleopatra_WC_REVISION)
         string(REGEX REPLACE "\n" "" Kleopatra_WC_REVISION "${Kleopatra_WC_REVISION}")
 
         execute_process(COMMAND ${GIT_EXECUTABLE} log -1 --oneline --format=%ci ${CMAKE_CURRENT_SOURCE_DIR}
             WORKING_DIRECTORY ${kdepim_SOURCE_DIR}/kleopatra
             OUTPUT_VARIABLE Kleopatra_WC_LAST_CHANGED_DATE)
         string(REGEX REPLACE " [-0-9:+ ]*\n" "" Kleopatra_WC_LAST_CHANGED_DATE "${Kleopatra_WC_LAST_CHANGED_DATE}")
 
         set(kleopatra_version "${kleopatra_version}-git${Kleopatra_WC_REVISION} (${Kleopatra_WC_LAST_CHANGED_DATE})")
     endif()
 endif()
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/version-kleopatra.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/version-kleopatra.h)
 
 include (ConfigureChecks.cmake)
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config-kleopatra.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-kleopatra.h)
 include_directories(
     ${CMAKE_CURRENT_BINARY_DIR}
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${Boost_INCLUDE_DIRS}
     ${ASSUAN2_INCLUDES}
     )
 
 add_definitions(-D_ASSUAN_ONLY_GPG_ERRORS)
 add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x050e00)
 add_definitions(-DKF_DISABLE_DEPRECATED_BEFORE_AND_AT=0x055300)
 if(CMAKE_COMPILER_IS_GNUCXX)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-braces -Wno-parentheses -Wno-ignored-qualifiers")
 endif()
 add_definitions(-DQT_NO_EMIT)
 remove_definitions(-DQT_NO_FOREACH)
 
 kde_enable_exceptions()
 option(USE_UNITY_CMAKE_SUPPORT "Use UNITY cmake support (speedup compile time)" OFF)
 
 set(COMPILE_WITH_UNITY_CMAKE_SUPPORT OFF)
 if (USE_UNITY_CMAKE_SUPPORT)
     set(COMPILE_WITH_UNITY_CMAKE_SUPPORT ON)
 endif()
 
 
 add_subdirectory(pics)
 add_subdirectory(src)
 
 if(BUILD_TESTING)
     add_subdirectory(tests)
     add_subdirectory(autotests)
 endif()
 
 ecm_qt_install_logging_categories(
         EXPORT KLEOPATRA
         FILE kleopatra.categories
         DESTINATION ${KDE_INSTALL_LOGGINGCATEGORIESDIR}
         )
 
 if(KF5DocTools_FOUND)
     add_subdirectory(doc)
 endif()
 feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
 
diff --git a/src/dialogs/weboftrustwidget.cpp b/src/dialogs/weboftrustwidget.cpp
index 9782240bb..69040f245 100644
--- a/src/dialogs/weboftrustwidget.cpp
+++ b/src/dialogs/weboftrustwidget.cpp
@@ -1,267 +1,270 @@
 /*
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2017 Intevation GmbH
     SPDX-FileCopyrightText: 2020 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "weboftrustwidget.h"
 
 #include "commands/certifycertificatecommand.h"
 #include "commands/revokecertificationcommand.h"
 #include "utils/tags.h"
 
 #include <Libkleo/KeyCache>
 #include <Libkleo/UserIDListModel>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 
 #include <QHeaderView>
 #include <QMenu>
 #include <QTreeView>
 #include <QVBoxLayout>
 
 #include <QGpgME/KeyListJob>
 #include <QGpgME/Protocol>
 
 #include <gpgme++/key.h>
 #include <gpgme++/keylistresult.h>
 
 #include "kleopatra_debug.h"
 
 using namespace Kleo;
 
 class WebOfTrustWidget::Private
 {
     friend class ::Kleo::WebOfTrustWidget;
     WebOfTrustWidget *const q;
 
 private:
     GpgME::Key key;
     UserIDListModel certificationsModel;
     QGpgME::KeyListJob *keyListJob = nullptr;
     QTreeView *certificationsTV = nullptr;
 
 public:
     Private(WebOfTrustWidget *qq)
         : q{qq}
     {
         certificationsModel.enableRemarks(Tags::tagsEnabled());
 
         certificationsTV = new QTreeView;
         certificationsTV->setModel(&certificationsModel);
         certificationsTV->setAllColumnsShowFocus(true);
         certificationsTV->setSelectionMode(QAbstractItemView::ExtendedSelection);
+        if (!Tags::tagsEnabled()) {
+            certificationsTV->hideColumn(static_cast<int>(UserIDListModel::Column::Tags));
+        }
 
         auto vLay = new QVBoxLayout(q);
         vLay->setContentsMargins(0, 0, 0, 0);
         vLay->addWidget(certificationsTV);
 
         connect(certificationsTV, &QAbstractItemView::doubleClicked,
                 q, [this] (const QModelIndex &idx) {
                     certificationDblClicked(idx);
                 });
         certificationsTV->setContextMenuPolicy(Qt::CustomContextMenu);
         connect(certificationsTV, &QWidget::customContextMenuRequested,
                 q, [this] (const QPoint &p) {
                     contextMenuRequested(p);
                 });
     }
 
     void certificationDblClicked(const QModelIndex &idx)
     {
         if (!idx.isValid()) {
             return;
         }
 
         if (!idx.parent().isValid()) {
             // No parent -> root item.
             return;
         }
 
         // grab the keyid
         const auto query = certificationsModel.data(idx.sibling(idx.row(), 0)).toString();
 
         // Show details widget or search
         auto cmd = Command::commandForQuery(query);
         cmd->setParentWId(q->winId());
         cmd->start();
     }
 
     void addActionsForUserID(QMenu *menu, const GpgME::UserID &userID)
     {
         menu->addAction(QIcon::fromTheme(QStringLiteral("view-certificate-sign")),
                         i18n("Certify..."),
                         q, [this, userID]() {
             auto cmd = new Kleo::Commands::CertifyCertificateCommand(userID);
             cmd->setParentWidget(q);
             certificationsTV->setEnabled(false);
             connect(cmd, &Kleo::Commands::CertifyCertificateCommand::finished,
                     q, [this]() {
                 certificationsTV->setEnabled(true);
                 // Trigger an update when done
                 q->setKey(key);
             });
             cmd->start();
         });
         if (Kleo::Commands::RevokeCertificationCommand::isSupported()) {
             menu->addAction(QIcon::fromTheme(QStringLiteral("view-certificate-revoke")),
                             i18n("Revoke Certification..."),
                             q, [this, userID]() {
                 auto cmd = new Kleo::Commands::RevokeCertificationCommand(userID);
                 cmd->setParentWidget(q);
                 certificationsTV->setEnabled(false);
                 connect(cmd, &Kleo::Commands::RevokeCertificationCommand::finished,
                         q, [this]() {
                     certificationsTV->setEnabled(true);
                     // Trigger an update when done
                     q->setKey(key);
                 });
                 cmd->start();
             });
         }
     }
 
     void addActionsForSignature(QMenu *menu, const GpgME::UserID::Signature &signature)
     {
         menu->addAction(QIcon::fromTheme(QStringLiteral("dialog-information")),
                         i18n("Show Certificate Details..."),
                         q, [this, signature]() {
             auto cmd = Command::commandForQuery(QString::fromUtf8(signature.signerKeyID()));
             cmd->setParentWId(q->winId());
             cmd->start();
         });
         if (Kleo::Commands::RevokeCertificationCommand::isSupported()) {
             auto action = menu->addAction(QIcon::fromTheme(QStringLiteral("view-certificate-revoke")),
                                           i18n("Revoke Certification..."),
                                           q, [this, signature]() {
                 auto cmd = new Kleo::Commands::RevokeCertificationCommand(signature);
                 cmd->setParentWidget(q);
                 certificationsTV->setEnabled(false);
                 connect(cmd, &Kleo::Commands::RevokeCertificationCommand::finished,
                         q, [this]() {
                     certificationsTV->setEnabled(true);
                     // Trigger an update when done
                     q->setKey(key);
                 });
                 cmd->start();
             });
             const auto certificationKey = KeyCache::instance()->findByKeyIDOrFingerprint(signature.signerKeyID());
             const bool isSelfSignature = qstrcmp(signature.parent().parent().keyID(), signature.signerKeyID()) == 0;
             action->setEnabled(!isSelfSignature && certificationKey.hasSecret() && !signature.isRevokation() && !signature.isExpired() && !signature.isInvalid());
             if (isSelfSignature) {
                 action->setToolTip(i18n("Revocation of self-certifications is currently not possible."));
             } else if (!certificationKey.hasSecret()) {
                 action->setToolTip(i18n("You cannot revoke this certification because it wasn't made with one of your keys (or the required secret key is missing)."));
             } else if (signature.isRevokation()) {
                 action->setToolTip(i18n("You cannot revoke this revocation certification. (But you can re-certify the corresponding user ID.)"));
             } else if (signature.isExpired()) {
                 action->setToolTip(i18n("You cannot revoke this expired certification."));
             } else if (signature.isInvalid()) {
                 action->setToolTip(i18n("You cannot revoke this invalid certification."));
             }
             if (!action->isEnabled()) {
                 menu->setToolTipsVisible(true);
             }
         }
     }
 
     void contextMenuRequested(const QPoint &p)
     {
         const auto index = certificationsTV->indexAt(p);
         const auto userID = certificationsModel.userID(index);
         const auto signature = certificationsModel.signature(index);
 
         if (userID.isNull() && signature.isNull()) {
             return;
         }
 
         auto menu = new QMenu(q);
         if (!userID.isNull()) {
             addActionsForUserID(menu, userID);
         }
         else if (!signature.isNull()) {
             addActionsForSignature(menu, signature);
         }
         connect(menu, &QMenu::aboutToHide, menu, &QObject::deleteLater);
         menu->popup(certificationsTV->viewport()->mapToGlobal(p));
     }
 
     void startSignatureListing()
     {
         if (keyListJob) {
             return;
         }
         QGpgME::KeyListJob *const job = QGpgME::openpgp()->keyListJob(/*remote*/false, /*includeSigs*/true, /*validate*/true);
         if (!job) {
             return;
         }
 
         if (Tags::tagsEnabled()) {
             job->addMode(GpgME::SignatureNotations);
         }
 
 
         /* Old style connect here again as QGPGME newstyle connects with
          * default arguments don't work on windows. */
 
         connect(job, &QGpgME::KeyListJob::result,
             q, &WebOfTrustWidget::signatureListingDone);
 
         connect(job, &QGpgME::KeyListJob::nextKey,
             q, &WebOfTrustWidget::signatureListingNextKey);
 
         job->start(QStringList(QString::fromLatin1(key.primaryFingerprint())));
         keyListJob = job;
     }
 };
 
 
 WebOfTrustWidget::WebOfTrustWidget(QWidget *parent)
     : QWidget{parent}
     , d{std::make_unique<Private>(this)}
 {
 }
 
 WebOfTrustWidget::~WebOfTrustWidget() = default;
 
 GpgME::Key WebOfTrustWidget::key() const
 {
     return d->key;
 }
 
 void WebOfTrustWidget::setKey(const GpgME::Key &key)
 {
     if (key.protocol() != GpgME::OpenPGP) {
         qCDebug(KLEOPATRA_LOG) << "Trust chain is only supported for CMS keys";
         return;
     }
 
     d->key = key;
     d->certificationsModel.setKey(key);
     d->certificationsTV->expandAll();
     d->certificationsTV->header()->resizeSections(QHeaderView::ResizeToContents);
     d->startSignatureListing();
 }
 
 void WebOfTrustWidget::signatureListingNextKey(const GpgME::Key &key)
 {
     GpgME::Key merged = key;
     merged.mergeWith(d->key);
     setKey(merged);
 }
 
 void WebOfTrustWidget::signatureListingDone(const GpgME::KeyListResult &result)
 {
     if (result.error()) {
         KMessageBox::information(this, xi18nc("@info",
                                            "<para>An error occurred while loading the certifications: "
                                            "<message>%1</message></para>",
                                            QString::fromLocal8Bit(result.error().asString())),
                                  i18nc("@title", "Certifications Loading Failed"));
     }
     d->keyListJob = nullptr;
 }