No OneTemporary
Actions

Size

80 KB

Subscribers

None

View Options

	diff --git a/CMakeLists.txt b/CMakeLists.txt
	index e9cf9bdf7..c799d765d 100644
	--- a/CMakeLists.txt
	+++ b/CMakeLists.txt
	@@ -1,219 +1,212 @@
	# SPDX-FileCopyrightText: none
	# SPDX-License-Identifier: BSD-3-Clause
	cmake_minimum_required(VERSION 3.16 FATAL_ERROR)

	set(RELEASE_SERVICE_VERSION_MAJOR "22")
	set(RELEASE_SERVICE_VERSION_MINOR "07")
	set(RELEASE_SERVICE_VERSION_MICRO "70")

	# The RELEASE_SERVICE_VERSION is used by Gpg4win to add the Gpg4win version
	if (NOT RELEASE_SERVICE_VERSION)
	set(RELEASE_SERVICE_VERSION "${RELEASE_SERVICE_VERSION_MAJOR}.${RELEASE_SERVICE_VERSION_MINOR}.${RELEASE_SERVICE_VERSION_MICRO}")
	endif()
	if(RELEASE_SERVICE_VERSION_MICRO LESS 10)
	set(KDE_APPLICATIONS_COMPACT_VERSION "${RELEASE_SERVICE_VERSION_MAJOR}${RELEASE_SERVICE_VERSION_MINOR}0${RELEASE_SERVICE_VERSION_MICRO}")
	else()
	set(KDE_APPLICATIONS_COMPACT_VERSION "${RELEASE_SERVICE_VERSION_MAJOR}${RELEASE_SERVICE_VERSION_MINOR}${RELEASE_SERVICE_VERSION_MICRO}")
	endif()

	set(KLEOPATRA_VERSION_MAJOR "3")
	set(KLEOPATRA_VERSION_MINOR "1")
	set(KLEOPATRA_VERSION_MICRO "21")

	set(kleopatra_version "${KLEOPATRA_VERSION_MAJOR}.${KLEOPATRA_VERSION_MINOR}.${KLEOPATRA_VERSION_MICRO}.${KDE_APPLICATIONS_COMPACT_VERSION}")
	# The following is for Windows
	set(kleopatra_version_win "${KLEOPATRA_VERSION_MAJOR}.${KLEOPATRA_VERSION_MINOR}.${KLEOPATRA_VERSION_MICRO}")
	set(kleopatra_fileversion_win "${KLEOPATRA_VERSION_MAJOR},${KLEOPATRA_VERSION_MINOR},${KLEOPATRA_VERSION_MICRO},0")

	project(kleopatra VERSION ${kleopatra_version})

	option(DISABLE_KWATCHGNUPG "Don't build the kwatchgnupg tool [default=OFF]" OFF)

	# Standalone build. Find / include everything necessary.
	set(KF5_MIN_VERSION "5.92.0")
	set(KMIME_VERSION "5.20.40")
	set(LIBKLEO_VERSION "5.20.41")
	set(QT_REQUIRED_VERSION "5.15.2")
	-set(GPGME_REQUIRED_VERSION "1.15.0")
	+set(GPGME_REQUIRED_VERSION "1.16.0")

	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(KDEInstallDirs)
	include(KDECMakeSettings)
	include(KDECompilerSettings NO_POLICY_SCOPE)
	include(ECMAddAppIcon)
	include(ECMQtDeclareLoggingCategory)
	include(ECMDeprecationSettings)

	# Find KF5 packages
	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 ${Qt${QT_MAJOR_VERSION}DBus_FOUND})

	find_package(Gpgmepp ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
	-if (Gpgmepp_VERSION VERSION_GREATER_EQUAL "1.16.0")
	- set(GPGMEPP_SUPPORTS_TRUST_SIGNATURES 1)
	-endif()
	find_package(QGpgme ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
	-if (QGpgme_VERSION VERSION_GREATER_EQUAL "1.16.0")
	- set(QGPGME_SUPPORTS_TRUST_SIGNATURES 1)
	- set(QGPGME_SUPPORTS_SIGNATURE_EXPIRATION 1)
	-endif()
	if (QGpgme_VERSION VERSION_GREATER_EQUAL "1.17.0")
	set(QGPGME_SUPPORTS_CHANGING_EXPIRATION_OF_COMPLETE_KEY 1)
	set(QGPGME_CRYPTOCONFIGENTRY_HAS_DEFAULT_VALUE 1)
	set(QGPGME_SUPPORTS_WKDLOOKUP 1)
	set(QGPGME_SUPPORTS_IMPORT_WITH_FILTER 1)
	set(QGPGME_SUPPORTS_IMPORT_WITH_KEY_ORIGIN 1)
	set(QGPGME_SUPPORTS_SECRET_KEY_EXPORT 1)
	set(QGPGME_SUPPORTS_SECRET_SUBKEY_EXPORT 1)
	set(QGPGME_SUPPORTS_RECEIVING_KEYS_BY_KEY_ID 1)
	endif()
	if (QGpgme_VERSION VERSION_GREATER_EQUAL "1.17.2")
	set(QGPGME_SUPPORTS_KEY_REVOCATION 1)
	endif()

	# Kdepimlibs packages
	find_package(KF5Libkleo ${LIBKLEO_VERSION} CONFIG REQUIRED)
	find_package(KF5Mime ${KMIME_WANT_VERSION} CONFIG REQUIRED)

	find_package(Qt${QT_MAJOR_VERSION} ${QT_REQUIRED_VERSION} CONFIG REQUIRED Widgets Test Network PrintSupport)

	find_package(Assuan2 REQUIRED)


	set(kleopatra_release FALSE)

	if(NOT kleopatra_release)
	find_package(Git)
	if(GIT_FOUND)
	execute_process(COMMAND ${GIT_EXECUTABLE} rev-parse
	WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
	RESULT_VARIABLE rc
	ERROR_QUIET)
	if(rc EQUAL 0)
	execute_process(COMMAND ${GIT_EXECUTABLE} log -1 --oneline --format=%h ${CMAKE_CURRENT_SOURCE_DIR}
	WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
	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 ${CMAKE_CURRENT_SOURCE_DIR}
	OUTPUT_VARIABLE Kleopatra_WC_LAST_CHANGED_DATE)
	string(REGEX REPLACE "^([0-9]+)-([0-9]+)-([0-9]+)T([0-9]+):([0-9]+):([0-9]+).*$" "\\1\\2\\3T\\4\\5\\6"
	Kleopatra_WC_LAST_CHANGED_DATE "${Kleopatra_WC_LAST_CHANGED_DATE}")

	set(kleopatra_version "${kleopatra_version}+git${Kleopatra_WC_LAST_CHANGED_DATE}~${Kleopatra_WC_REVISION}")
	endif()
	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}
	${ASSUAN2_INCLUDES}
	)

	add_definitions(-D_ASSUAN_ONLY_GPG_ERRORS)
	ecm_set_disabled_deprecation_versions(QT 5.14.0 KF 5.93.0)

	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)

	# Disable the use of QStringBuilder for operator+ to prevent crashes when
	# returning the result of concatenating string temporaries in lambdas. We do
	# this for example in some std::transform expressions.
	# This is a known issue: https://bugreports.qt.io/browse/QTBUG-47066
	# Alternatively, one would always have to remember to force the lambdas to
	# return a QString instead of QStringBuilder, but that's just too easy to
	# forget and, unfortunately, the compiler doesn't issue a warning if one forgets
	# this. So, it's just too dangerous.
	# One can still use QStringBuilder explicitly with the operator% if necessary.
	remove_definitions(-DQT_USE_FAST_OPERATOR_PLUS)
	remove_definitions(-DQT_USE_QSTRINGBUILDER)

	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}
	)

	ki18n_install(po)
	if(KF5DocTools_FOUND)
	kdoctools_install(po)
	add_subdirectory(doc)
	endif()
	feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)

	diff --git a/config-kleopatra.h.cmake b/config-kleopatra.h.cmake
	index fabfc7b3d..fd9a9edb4 100644
	--- a/config-kleopatra.h.cmake
	+++ b/config-kleopatra.h.cmake
	@@ -1,61 +1,52 @@
	/* Define to 1 if you have a recent enough libassuan */
	#cmakedefine HAVE_USABLE_ASSUAN 1

	/* Define to 1 if you have libassuan v2 */
	#cmakedefine HAVE_ASSUAN2 1

	#ifndef HAVE_ASSUAN2
	/* Define to 1 if your libassuan has the assuan_fd_t type */
	#cmakedefine HAVE_ASSUAN_FD_T 1

	/* Define to 1 if your libassuan has the assuan_inquire_ext function */
	#cmakedefine HAVE_ASSUAN_INQUIRE_EXT 1

	/* Define to 1 if your assuan_inquire_ext puts the buffer arguments into the callback signature */
	#cmakedefine HAVE_NEW_STYLE_ASSUAN_INQUIRE_EXT 1

	/* Define to 1 if your libassuan has the assuan_sock_get_nonce function */
	#cmakedefine HAVE_ASSUAN_SOCK_GET_NONCE 1

	#endif
	/* Define to 1 if you build libkleopatraclient */
	#cmakedefine HAVE_KLEOPATRACLIENT_LIBRARY 1

	/* DBus available */
	#cmakedefine01 HAVE_QDBUS

	-/* Defined if GpgME++ supports trust signatures */
	-#cmakedefine GPGMEPP_SUPPORTS_TRUST_SIGNATURES 1
	-
	-/* Defined if QGpgME supports trust signatures */
	-#cmakedefine QGPGME_SUPPORTS_TRUST_SIGNATURES 1
	-
	-/* Defined if QGpgME supports setting an expiration date for signatures */
	-#cmakedefine QGPGME_SUPPORTS_SIGNATURE_EXPIRATION 1
	-
	/* Defined if QGpgME supports changing the expiration date of the primary key and the subkeys simultaneously */
	#cmakedefine QGPGME_SUPPORTS_CHANGING_EXPIRATION_OF_COMPLETE_KEY 1

	/* Defined if QGpgME supports retrieving the default value of a config entry */
	#cmakedefine QGPGME_CRYPTOCONFIGENTRY_HAS_DEFAULT_VALUE 1

	/* Defined if QGpgME supports WKD lookup */
	#cmakedefine QGPGME_SUPPORTS_WKDLOOKUP 1

	/* Defined if QGpgME supports specifying an import filter when importing keys */
	#cmakedefine QGPGME_SUPPORTS_IMPORT_WITH_FILTER 1

	/* Defined if QGpgME supports setting key origin when importing keys */
	#cmakedefine QGPGME_SUPPORTS_IMPORT_WITH_KEY_ORIGIN 1

	/* Defined if QGpgME supports the export of secret keys */
	#cmakedefine QGPGME_SUPPORTS_SECRET_KEY_EXPORT 1

	/* Defined if QGpgME supports the export of secret subkeys */
	#cmakedefine QGPGME_SUPPORTS_SECRET_SUBKEY_EXPORT 1

	/* Defined if QGpgME supports receiving keys by their key ids */
	#cmakedefine QGPGME_SUPPORTS_RECEIVING_KEYS_BY_KEY_ID 1

	/* Defined if QGpgME supports revoking own OpenPGP keys */
	#cmakedefine QGPGME_SUPPORTS_KEY_REVOCATION 1
	diff --git a/src/commands/certifycertificatecommand.cpp b/src/commands/certifycertificatecommand.cpp
	index f5c589cf0..3707bd67a 100644
	--- a/src/commands/certifycertificatecommand.cpp
	+++ b/src/commands/certifycertificatecommand.cpp
	@@ -1,322 +1,318 @@
	/* -- mode: c++; c-basic-offset:4 --
	commands/signcertificatecommand.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
	SPDX-FileCopyrightText: 2019 g10code GmbH

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "certifycertificatecommand.h"
	#include "newcertificatecommand.h"

	#include "command_p.h"

	#include "exportopenpgpcertstoservercommand.h"
	#include "dialogs/certifycertificatedialog.h"
	#include "utils/tags.h"

	#include <Libkleo/KeyCache>
	#include <Libkleo/Formatting>

	#include <QGpgME/Protocol>
	#include <QGpgME/SignKeyJob>

	#include <QDate>
	#include <QEventLoop>

	#include <gpgme++/key.h>

	#include <KLocalizedString>
	#include "kleopatra_debug.h"

	using namespace Kleo;
	using namespace Kleo::Commands;
	using namespace GpgME;
	using namespace QGpgME;

	class CertifyCertificateCommand::Private : public Command::Private
	{
	friend class ::Kleo::Commands::CertifyCertificateCommand;
	CertifyCertificateCommand *q_func() const
	{
	return static_cast<CertifyCertificateCommand *>(q);
	}
	public:
	explicit Private(CertifyCertificateCommand qq, KeyListController c);
	~Private() override;

	void init();

	private:
	void slotDialogRejected();
	void slotResult(const Error &err);
	void slotCertificationPrepared();

	private:
	void ensureDialogCreated();
	void createJob();

	private:
	std::vector<UserID> uids;
	QPointer<CertifyCertificateDialog> dialog;
	QPointer<QGpgME::SignKeyJob> job;
	};

	CertifyCertificateCommand::Private *CertifyCertificateCommand::d_func()
	{
	return static_cast<Private *>(d.get());
	}
	const CertifyCertificateCommand::Private *CertifyCertificateCommand::d_func() const
	{
	return static_cast<const Private *>(d.get());
	}

	#define d d_func()
	#define q q_func()

	CertifyCertificateCommand::Private::Private(CertifyCertificateCommand qq, KeyListController c)
	: Command::Private(qq, c),
	uids(),
	dialog(),
	job()
	{
	}

	CertifyCertificateCommand::Private::~Private()
	{
	qCDebug(KLEOPATRA_LOG);
	if (dialog) {
	delete dialog;
	dialog = nullptr;
	}
	}

	CertifyCertificateCommand::CertifyCertificateCommand(KeyListController *c)
	: Command(new Private(this, c))
	{
	d->init();
	}

	CertifyCertificateCommand::CertifyCertificateCommand(QAbstractItemView v, KeyListController c)
	: Command(v, new Private(this, c))
	{
	d->init();
	}

	CertifyCertificateCommand::CertifyCertificateCommand(const GpgME::Key &key)
	: Command(key, new Private(this, nullptr))
	{
	d->init();
	}

	CertifyCertificateCommand::CertifyCertificateCommand(const GpgME::UserID &uid)
	: Command(uid.parent(), new Private(this, nullptr))
	{
	std::vector<UserID>(1, uid).swap(d->uids);
	d->init();
	}

	CertifyCertificateCommand::CertifyCertificateCommand(const std::vector<GpgME::UserID> &uids)
	: Command(uids.empty() ? Key() : uids.front().parent(), new Private(this, nullptr))
	{
	d->uids = uids;
	d->init();
	}

	void CertifyCertificateCommand::Private::init()
	{
	}

	CertifyCertificateCommand::~CertifyCertificateCommand()
	{
	qCDebug(KLEOPATRA_LOG);
	}

	void CertifyCertificateCommand::doStart()
	{

	const std::vector<Key> keys = d->keys();
	if (keys.size() != 1 \|\|
	keys.front().protocol() != GpgME::OpenPGP) {
	d->finished();
	return;
	}

	std::vector<Key> secKeys;
	Q_FOREACH (const Key &secKey, KeyCache::instance()->secretKeys()) {
	// Only include usable keys.
	if (secKey.canCertify() && secKey.protocol() == OpenPGP && !secKey.isRevoked() &&
	!secKey.isExpired() && !secKey.isInvalid()) {
	secKeys.push_back(secKey);
	}
	}

	if (secKeys.empty()) {
	auto sel = KMessageBox::questionYesNo(d->parentWidgetOrView(),
	xi18nc("@info", "To certify other certificates, you first need to create an OpenPGP certificate for yourself.") +
	QStringLiteral("<br><br>") +
	i18n("Do you wish to create one now?"),
	i18n("Certification Not Possible"));
	if (sel == KMessageBox::Yes) {
	QEventLoop loop;
	auto cmd = new Commands::NewCertificateCommand();
	cmd->setParentWidget(d->parentWidgetOrView());
	cmd->setProtocol(GpgME::OpenPGP);
	loop.connect(cmd, SIGNAL(finished()), SLOT(quit()));
	QMetaObject::invokeMethod(cmd, &Commands::NewCertificateCommand::start, Qt::QueuedConnection);
	loop.exec();
	} else {
	Q_EMIT(canceled());
	d->finished();
	return;
	}
	Q_FOREACH (const Key &secKey, KeyCache::instance()->secretKeys()) {
	// Check again for secret keys
	if (secKey.canCertify() && secKey.protocol() == OpenPGP && !secKey.isRevoked() &&
	!secKey.isExpired() && !secKey.isInvalid()) {
	secKeys.push_back(secKey);
	}
	}
	if (secKeys.empty()) {
	qCDebug(KLEOPATRA_LOG) << "Sec Keys still empty after keygen.";
	Q_EMIT(canceled());
	d->finished();
	return;
	}
	}
	const Key &key = keys.front();

	for (const UserID &uid : std::as_const(d->uids))
	if (qstricmp(uid.parent().primaryFingerprint(), key.primaryFingerprint()) != 0) {
	qCWarning(KLEOPATRA_LOG) << "User-ID <-> Key mismatch!";
	d->finished();
	return;
	}

	d->ensureDialogCreated();
	Q_ASSERT(d->dialog);

	Key target = d->key();
	if (!(target.keyListMode() & GpgME::SignatureNotations)) {
	target.update();
	}
	d->dialog->setCertificateToCertify(target);
	if (d->uids.size()) {
	d->dialog->setSelectedUserIDs(d->uids);
	}
	d->dialog->show();
	}

	void CertifyCertificateCommand::Private::slotDialogRejected()
	{
	Q_EMIT q->canceled();
	finished();
	}

	void CertifyCertificateCommand::Private::slotResult(const Error &err)
	{
	if (!err && !err.isCanceled() && dialog && dialog->exportableCertificationSelected() && dialog->sendToServer()) {
	auto const cmd = new ExportOpenPGPCertsToServerCommand(key());
	cmd->start();
	} else if (!err) {
	information(i18n("Certification successful."),
	i18n("Certification Succeeded"));
	} else {
	error(i18n("<p>An error occurred while trying to certify<br/><br/>"
	"<b>%1</b>:</p><p>\t%2</p>",
	Formatting::formatForComboBox(key()),
	QString::fromUtf8(err.asString())),
	i18n("Certification Error"));
	}
	if (!dialog->tags().isEmpty()) {
	Tags::enableTags();
	}

	finished();
	}

	void CertifyCertificateCommand::Private::slotCertificationPrepared()
	{
	Q_ASSERT(dialog);

	createJob();
	Q_ASSERT(job);
	job->setExportable(dialog->exportableCertificationSelected());
	job->setNonRevocable(dialog->nonRevocableCertificationSelected());
	job->setUserIDsToSign(dialog->selectedUserIDs());
	job->setSigningKey(dialog->selectedSecretKey());
	job->setCheckLevel(dialog->selectedCheckLevel());
	if (!dialog->tags().isEmpty()) {
	// do not set an empty remark to avoid an empty signature notation (GnuPG bug T5142)
	job->setRemark(dialog->tags());
	}
	job->setDupeOk(true);
	-#ifdef QGPGME_SUPPORTS_TRUST_SIGNATURES
	if (dialog->trustSignatureSelected() && !dialog->trustSignatureDomain().isEmpty()) {
	// always create level 1 trust signatures with complete trust
	job->setTrustSignature(TrustSignatureTrust::Complete, 1, dialog->trustSignatureDomain());
	}
	-#endif
	-#ifdef QGPGME_SUPPORTS_SIGNATURE_EXPIRATION
	if (!dialog->expirationDate().isNull()) {
	job->setExpirationDate(dialog->expirationDate());
	}
	-#endif

	if (const Error err = job->start(key())) {
	slotResult(err);
	}
	}

	void CertifyCertificateCommand::doCancel()
	{
	qCDebug(KLEOPATRA_LOG);
	if (d->job) {
	d->job->slotCancel();
	}
	}

	void CertifyCertificateCommand::Private::ensureDialogCreated()
	{
	if (dialog) {
	return;
	}

	dialog = new CertifyCertificateDialog;
	applyWindowID(dialog);

	connect(dialog, SIGNAL(rejected()), q, SLOT(slotDialogRejected()));
	connect(dialog, SIGNAL(accepted()), q, SLOT(slotCertificationPrepared()));
	}

	void CertifyCertificateCommand::Private::createJob()
	{
	Q_ASSERT(!job);

	Q_ASSERT(key().protocol() == OpenPGP);
	const auto backend = QGpgME::openpgp();
	if (!backend) {
	return;
	}

	SignKeyJob *const j = backend->signKeyJob();
	if (!j) {
	return;
	}

	connect(j, &Job::progress,
	q, &Command::progress);
	connect(j, SIGNAL(result(GpgME::Error)),
	q, SLOT(slotResult(GpgME::Error)));

	job = j;
	}

	#undef d
	#undef q

	#include "moc_certifycertificatecommand.cpp"
	diff --git a/src/dialogs/certificatedetailswidget.cpp b/src/dialogs/certificatedetailswidget.cpp
	index d4d344ef5..435b191d3 100644
	--- a/src/dialogs/certificatedetailswidget.cpp
	+++ b/src/dialogs/certificatedetailswidget.cpp
	@@ -1,943 +1,937 @@
	/* SPDX-FileCopyrightText: 2016 Klarälvdalens Datakonsult AB
	SPDX-FileCopyrightText: 2017 Intevation GmbH

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "certificatedetailswidget.h"

	#include "kleopatra_debug.h"
	#include "exportdialog.h"
	#include "trustchainwidget.h"
	#include "subkeyswidget.h"
	#include "weboftrustdialog.h"

	#include "commands/changepassphrasecommand.h"
	#include "commands/changeexpirycommand.h"
	#include "commands/certifycertificatecommand.h"
	#include "commands/revokecertificationcommand.h"
	#include "commands/adduseridcommand.h"
	#include "commands/genrevokecommand.h"
	#include "commands/detailscommand.h"
	#include "commands/dumpcertificatecommand.h"

	#include "utils/tags.h"

	#include <Libkleo/Formatting>
	#include <Libkleo/Dn>
	#include <Libkleo/KeyCache>
	#include <Libkleo/GnuPG>

	#include <KLocalizedString>

	#include <gpgme++/context.h>
	#include <gpgme++/key.h>
	#include <gpgme++/keylistresult.h>
	#include <gpgme++/tofuinfo.h>

	#include <QGpgME/Debug>
	#include <QGpgME/Protocol>
	#include <QGpgME/KeyListJob>

	#include <QClipboard>
	#include <QDateTime>
	#include <QGridLayout>
	#include <QGroupBox>
	#include <QGuiApplication>
	#include <QHBoxLayout>
	#include <QLabel>
	#include <QLocale>
	#include <QMenu>
	#include <QPushButton>
	#include <QSpacerItem>
	#include <QStringBuilder>
	#include <QTreeWidget>

	#include <set>

	#define HIDE_ROW(row) \
	ui.row->setVisible(false); \
	ui.row##Lbl->setVisible(false);

	#define SHOW_ROW(row) \
	ui.row->setVisible(true); \
	ui.row##Lbl->setVisible(true);

	Q_DECLARE_METATYPE(GpgME::UserID)

	using namespace Kleo;

	class CertificateDetailsWidget::Private
	{
	public:
	Private(CertificateDetailsWidget *qq);

	void setupCommonProperties();
	void setupPGPProperties();
	void setupSMIMEProperties();

	void revokeUID(const GpgME::UserID &uid);
	void genRevokeCert();
	void certifyClicked();
	void webOfTrustClicked();
	void exportClicked();
	void addUserID();
	void changePassphrase();
	void changeExpiration();
	void keysMayHaveChanged();
	void showTrustChainDialog();
	void showMoreDetails();
	void publishCertificate();
	void userIDTableContextMenuRequested(const QPoint &p);

	QString tofuTooltipString(const GpgME::UserID &uid) const;

	void smimeLinkActivated(const QString &link);

	void setUpdatedKey(const GpgME::Key &key);
	void keyListDone(const GpgME::KeyListResult &,
	const std::vector<GpgME::Key> &, const QString &,
	const GpgME::Error &);
	void copyFingerprintToClipboard();

	private:
	CertificateDetailsWidget *const q;

	public:
	GpgME::Key key;
	bool updateInProgress = false;

	private:
	struct UI {
	QGridLayout *gridLayout_2;
	QHBoxLayout *hboxLayout_1;
	QPushButton *addUserIDBtn;
	QPushButton *changePassphraseBtn;
	QPushButton *trustChainDetailsBtn;
	QPushButton *genRevokeBtn;
	QPushButton *certifyBtn;
	QGroupBox *groupBox;
	QGridLayout *gridLayout;
	QLabel *validFromLbl;
	QLabel *validFrom;
	QSpacerItem *horizontalSpacer_3;
	QLabel *expiresLbl;
	QHBoxLayout *horizontalLayout_3;
	QLabel *expires;
	QPushButton *changeExpirationBtn;
	QLabel *typeLbl;
	QLabel *type;
	QLabel *fingerprintLbl;
	QLabel *fingerprint;
	QPushButton *copyFingerprintBtn;
	QLabel *publishingLbl;
	QPushButton *publishing;
	QLabel *smimeIssuerLbl;
	QLabel *smimeIssuer;
	QLabel *compliance;
	QLabel *complianceLbl;
	QLabel *trustedIntroducerLbl;
	QLabel *trustedIntroducer;
	QHBoxLayout *horizontalLayout;
	QPushButton *moreDetailsBtn;
	QPushButton *exportBtn;
	QPushButton *webOfTrustBtn;
	QSpacerItem *horizontalSpacer;
	QTreeWidget *userIDTable;
	QLabel *label;
	QLabel *smimeOwnerLbl;
	QLabel *smimeRelatedAddresses;
	QLabel *smimeOwner;

	void setupUi(QWidget *parent)
	{
	gridLayout_2 = new QGridLayout(parent);
	gridLayout_2->setContentsMargins(0, 0, 0, 0);
	hboxLayout_1 = new QHBoxLayout();
	addUserIDBtn = new QPushButton(i18n("Add email address"), parent);

	hboxLayout_1->addWidget(addUserIDBtn);

	changePassphraseBtn = new QPushButton(i18n("Change passphrase"), parent);

	hboxLayout_1->addWidget(changePassphraseBtn);

	trustChainDetailsBtn = new QPushButton(i18n("Trust chain details..."), parent);

	hboxLayout_1->addWidget(trustChainDetailsBtn);

	genRevokeBtn = new QPushButton(i18n("Generate revocation certificate"), parent);
	genRevokeBtn->setToolTip(u"<html>" %
	i18n("A revocation certificate is a file that serves as a \"kill switch\" to publicly "
	"declare that a key shall not anymore be used. It is not possible "
	"to retract such a revocation certificate once it has been published.") %
	u"</html>");

	hboxLayout_1->addWidget(genRevokeBtn);

	certifyBtn = new QPushButton(i18n("Certify"), parent);

	hboxLayout_1->addWidget(certifyBtn);

	gridLayout_2->addLayout(hboxLayout_1, 4, 0, 1, 3);

	groupBox = new QGroupBox(i18n("Certificate Details"), parent);
	groupBox->setFlat(false);
	gridLayout = new QGridLayout(groupBox);
	int row = 0;
	validFromLbl = new QLabel(i18n("Valid from:"), groupBox);

	gridLayout->addWidget(validFromLbl, row, 0, 1, 1);

	validFrom = new QLabel(groupBox);
	validFrom->setTextInteractionFlags(Qt::TextSelectableByMouse);

	gridLayout->addWidget(validFrom, row, 1, 1, 1);

	horizontalSpacer_3 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);

	gridLayout->addItem(horizontalSpacer_3, row, 2, 1, 1);
	row++;

	expiresLbl = new QLabel(i18n("Expires:"), groupBox);

	gridLayout->addWidget(expiresLbl, row, 0, 1, 1);

	horizontalLayout_3 = new QHBoxLayout();
	expires = new QLabel(groupBox);
	expires->setTextInteractionFlags(Qt::TextSelectableByMouse);

	horizontalLayout_3->addWidget(expires);

	changeExpirationBtn = new QPushButton(groupBox);
	changeExpirationBtn->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
	changeExpirationBtn->setIcon(QIcon::fromTheme(QStringLiteral("editor")));
	changeExpirationBtn->setToolTip(i18nc("@info:tooltip", "Change the expiration date"));

	horizontalLayout_3->addWidget(changeExpirationBtn);

	gridLayout->addLayout(horizontalLayout_3, row, 1, 1, 1);
	row++;

	typeLbl = new QLabel(i18n("Type:"), groupBox);

	gridLayout->addWidget(typeLbl, row, 0, 1, 1);

	type = new QLabel(groupBox);
	type->setTextInteractionFlags(Qt::TextSelectableByMouse);

	gridLayout->addWidget(type, row, 1, 1, 1);
	row++;

	fingerprintLbl = new QLabel(i18n("Fingerprint:"), groupBox);

	gridLayout->addWidget(fingerprintLbl, row, 0, 1, 1);

	{
	auto hbox = new QHBoxLayout;
	fingerprint = new QLabel{groupBox};
	fingerprint->setTextInteractionFlags(Qt::TextSelectableByMouse);
	hbox->addWidget(fingerprint);
	copyFingerprintBtn = new QPushButton{groupBox};
	copyFingerprintBtn->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
	copyFingerprintBtn->setIcon(QIcon::fromTheme(QStringLiteral("edit-copy")));
	copyFingerprintBtn->setToolTip(i18nc("@info:tooltip", "Copy the fingerprint to the clipboard"));
	copyFingerprintBtn->setVisible(QGuiApplication::clipboard());
	hbox->addWidget(copyFingerprintBtn);
	hbox->addStretch();

	gridLayout->addLayout(hbox, row, 1, 1, 2);
	}
	row++;

	publishingLbl = new QLabel(i18n("Publishing:"), groupBox);

	gridLayout->addWidget(publishingLbl, row, 0, 1, 1);

	publishing = new QPushButton(i18n("Publish Certificate"), groupBox);

	gridLayout->addWidget(publishing, row, 1, 1, 1);
	row++;

	smimeIssuerLbl = new QLabel(i18n("Issuer:"), groupBox);

	gridLayout->addWidget(smimeIssuerLbl, row, 0, 1, 1);

	smimeIssuer = new QLabel(groupBox);
	smimeIssuer->setWordWrap(true);
	smimeIssuer->setTextInteractionFlags(Qt::TextBrowserInteraction);

	gridLayout->addWidget(smimeIssuer, row, 1, 1, 2);
	row++;

	compliance = new QLabel(i18n("Compliance:"), groupBox);
	compliance->setWordWrap(true);
	compliance->setTextInteractionFlags(Qt::TextBrowserInteraction);

	gridLayout->addWidget(compliance, row, 0, 1, 1);

	complianceLbl = new QLabel(groupBox);
	complianceLbl->setWordWrap(true);
	complianceLbl->setTextInteractionFlags(Qt::TextBrowserInteraction);

	gridLayout->addWidget(complianceLbl, row, 1, 1, 2);
	row++;

	trustedIntroducerLbl = new QLabel(i18n("Trusted introducer for:"), groupBox);
	trustedIntroducerLbl->setToolTip(i18n("See certifications for details."));
	trustedIntroducerLbl->setTextInteractionFlags(Qt::TextBrowserInteraction);

	gridLayout->addWidget(trustedIntroducerLbl, row, 0, 1, 1);

	trustedIntroducer = new QLabel(groupBox);
	trustedIntroducer->setWordWrap(true);
	trustedIntroducer->setToolTip(i18n("See certifications for details."));
	trustedIntroducer->setTextInteractionFlags(Qt::TextBrowserInteraction);

	gridLayout->addWidget(trustedIntroducer, row, 1, 1, 2);
	row++;

	horizontalLayout = new QHBoxLayout();
	moreDetailsBtn = new QPushButton(i18n("More details..."), groupBox);

	horizontalLayout->addWidget(moreDetailsBtn);

	exportBtn = new QPushButton(i18n("Export..."), groupBox);

	horizontalLayout->addWidget(exportBtn);

	webOfTrustBtn = new QPushButton(i18n("Certifications..."), groupBox);

	horizontalLayout->addWidget(webOfTrustBtn);

	horizontalSpacer = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);

	horizontalLayout->addItem(horizontalSpacer);

	gridLayout->addLayout(horizontalLayout, row, 0, 1, 3);

	gridLayout_2->addWidget(groupBox, 6, 0, 1, 3);

	userIDTable = new QTreeWidget(parent);
	QTreeWidgetItem *__qtreewidgetitem = new QTreeWidgetItem();
	__qtreewidgetitem->setText(0, QString::fromUtf8("1"));
	userIDTable->setHeaderItem(__qtreewidgetitem);
	userIDTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
	userIDTable->setSelectionMode(QAbstractItemView::SingleSelection);
	userIDTable->setRootIsDecorated(false);
	userIDTable->setUniformRowHeights(true);
	userIDTable->setAllColumnsShowFocus(true);

	gridLayout_2->addWidget(userIDTable, 3, 0, 1, 3);

	label = new QLabel(i18n("You can use this certificate to secure communication with the following email addresses:"), parent);
	label->setWordWrap(true);

	gridLayout_2->addWidget(label, 0, 0, 1, 3);

	smimeOwnerLbl = new QLabel(i18n("Owner:"), parent);

	gridLayout_2->addWidget(smimeOwnerLbl, 1, 0, 1, 1);

	smimeRelatedAddresses = new QLabel(i18n("Related addresses:"), parent);
	QFont font;
	font.setBold(true);
	font.setWeight(75);
	smimeRelatedAddresses->setFont(font);

	gridLayout_2->addWidget(smimeRelatedAddresses, 2, 0, 1, 1);

	smimeOwner = new QLabel(parent);
	smimeOwner->setWordWrap(true);
	smimeOwner->setTextInteractionFlags(Qt::TextBrowserInteraction);

	gridLayout_2->addWidget(smimeOwner, 1, 1, 1, 2);
	}
	} ui;
	};

	CertificateDetailsWidget::Private::Private(CertificateDetailsWidget *qq)
	: q{qq}
	{
	ui.setupUi(q);

	connect(ui.addUserIDBtn, &QPushButton::clicked,
	q, [this]() { addUserID(); });
	connect(ui.changePassphraseBtn, &QPushButton::clicked,
	q, [this]() { changePassphrase(); });
	connect(ui.genRevokeBtn, &QPushButton::clicked,
	q, [this]() { genRevokeCert(); });
	connect(ui.changeExpirationBtn, &QPushButton::clicked,
	q, [this]() { changeExpiration(); });
	connect(ui.smimeOwner, &QLabel::linkActivated,
	q, [this](const QString &link) { smimeLinkActivated(link); });
	connect(ui.smimeIssuer, &QLabel::linkActivated,
	q, [this](const QString &link) { smimeLinkActivated(link); });
	connect(ui.trustChainDetailsBtn, &QPushButton::pressed,
	q, [this]() { showTrustChainDialog(); });
	connect(ui.moreDetailsBtn, &QPushButton::pressed,
	q, [this]() { showMoreDetails(); });
	connect(ui.publishing, &QPushButton::pressed,
	q, [this]() { publishCertificate(); });
	connect(ui.certifyBtn, &QPushButton::clicked,
	q, [this]() { certifyClicked(); });
	connect(ui.webOfTrustBtn, &QPushButton::clicked,
	q, [this]() { webOfTrustClicked(); });
	connect(ui.exportBtn, &QPushButton::clicked,
	q, [this]() { exportClicked(); });
	connect(ui.copyFingerprintBtn, &QPushButton::clicked,
	q, [this]() { copyFingerprintToClipboard(); });

	connect(Kleo::KeyCache::instance().get(), &Kleo::KeyCache::keysMayHaveChanged,
	q, [this]() { keysMayHaveChanged(); });
	}

	void CertificateDetailsWidget::Private::setupCommonProperties()
	{
	// TODO: Enable once implemented
	HIDE_ROW(publishing)

	const bool hasSecret = key.hasSecret();
	const bool isOpenPGP = key.protocol() == GpgME::OpenPGP;
	// TODO: Enable once implemented
	const bool canRevokeUID = false; // isOpenPGP && hasSecret

	ui.changePassphraseBtn->setVisible(hasSecret);
	ui.genRevokeBtn->setVisible(isOpenPGP && hasSecret);
	ui.certifyBtn->setVisible(isOpenPGP && !hasSecret);
	ui.changeExpirationBtn->setVisible(isOpenPGP && hasSecret);
	ui.addUserIDBtn->setVisible(hasSecret && isOpenPGP);
	ui.webOfTrustBtn->setVisible(isOpenPGP);

	ui.hboxLayout_1->addStretch(1);

	ui.validFrom->setText(Kleo::Formatting::creationDateString(key));
	const QString expiry = Kleo::Formatting::expirationDateString(key);
	ui.expires->setText(expiry.isEmpty() ? i18nc("Expires", "never") : expiry);
	ui.type->setText(Kleo::Formatting::type(key));
	ui.fingerprint->setText(Formatting::prettyID(key.primaryFingerprint()));

	if (!Kleo::gnupgIsDeVsCompliant()) {
	HIDE_ROW(compliance)
	} else {
	ui.complianceLbl->setText(Kleo::Formatting::complianceStringForKey(key));
	}

	ui.userIDTable->clear();

	QStringList headers = { i18n("Email"), i18n("Name"), i18n("Trust Level"), i18n("Tags") };
	if (canRevokeUID) {
	headers << QString();
	}
	ui.userIDTable->setColumnCount(headers.count());
	ui.userIDTable->setColumnWidth(0, 200);
	ui.userIDTable->setColumnWidth(1, 200);
	ui.userIDTable->setHeaderLabels(headers);

	const auto uids = key.userIDs();
	for (unsigned int i = 0; i < uids.size(); ++i) {
	const auto &uid = uids[i];
	auto item = new QTreeWidgetItem;
	const QString toolTip = tofuTooltipString(uid);
	item->setData(0, Qt::UserRole, QVariant::fromValue(uid));

	auto pMail = Kleo::Formatting::prettyEMail(uid);
	auto pName = Kleo::Formatting::prettyName(uid);
	if (!isOpenPGP && pMail.isEmpty() && !pName.isEmpty()) {
	// S/MIME UserIDs are sometimes split, with one userID
	// containing the name another the Mail, we merge these
	// UID's into a single item.

	if (i + 1 < uids.size()) {
	pMail = Kleo::Formatting::prettyEMail(uids[i + 1]);
	// skip next uid
	++i;
	}
	}

	if (!isOpenPGP && pMail.isEmpty() && pName.isEmpty()) {
	// S/MIME certificates sometimes contain urls where both
	// name and mail is empty. In that case we print whatever
	// the uid is as name.
	//
	// Can be ugly like (3:uri24:http://ca.intevation.org), but
	// this is better then showing an empty entry.
	pName = QString::fromLatin1(uid.id());
	}

	item->setData(0, Qt::DisplayRole, pMail);
	item->setData(0, Qt::ToolTipRole, toolTip);
	item->setData(1, Qt::DisplayRole, pName);
	item->setData(1, Qt::ToolTipRole, toolTip);

	QIcon trustIcon;
	if (updateInProgress) {
	trustIcon = QIcon::fromTheme(QStringLiteral("emblem-question"));
	item->setData(2, Qt::DisplayRole, i18n("Updating..."));
	} else {
	switch (uid.validity()) {
	case GpgME::UserID::Unknown:
	case GpgME::UserID::Undefined:
	trustIcon = QIcon::fromTheme(QStringLiteral("emblem-question"));
	break;
	case GpgME::UserID::Never:
	trustIcon = QIcon::fromTheme(QStringLiteral("emblem-error"));
	break;
	case GpgME::UserID::Marginal:
	trustIcon = QIcon::fromTheme(QStringLiteral("emblem-warning"));
	break;
	case GpgME::UserID::Full:
	case GpgME::UserID::Ultimate:
	trustIcon = QIcon::fromTheme(QStringLiteral("emblem-success"));
	break;
	}
	item->setData(2, Qt::DisplayRole, Kleo::Formatting::validityShort(uid));
	}
	item->setData(2, Qt::DecorationRole, trustIcon);
	item->setData(2, Qt::ToolTipRole, toolTip);

	GpgME::Error err;
	QStringList tagList;
	for (const auto &tag: uid.remarks(Tags::tagKeys(), err)) {
	if (err) {
	qCWarning(KLEOPATRA_LOG) << "Getting remarks for user id" << uid.id() << "failed:" << err;
	}
	tagList << QString::fromStdString(tag);
	}
	qCDebug(KLEOPATRA_LOG) << "tagList:" << tagList;
	const auto tags = tagList.join(QStringLiteral("; "));
	item->setData(3, Qt::DisplayRole, tags);
	item->setData(3, Qt::ToolTipRole, toolTip);

	ui.userIDTable->addTopLevelItem(item);

	if (canRevokeUID) {
	auto button = new QPushButton;
	button->setIcon(QIcon::fromTheme(QStringLiteral("entry-delete")));
	button->setToolTip(i18n("Revoke this User ID"));
	button->setMaximumWidth(32);
	QObject::connect(button, &QPushButton::clicked,
	q, [this, uid]() { revokeUID(uid); });
	ui.userIDTable->setItemWidget(item, 4, button);
	}
	}
	if (!Tags::tagsEnabled()) {
	ui.userIDTable->hideColumn(3);
	}
	}

	void CertificateDetailsWidget::Private::revokeUID(const GpgME::UserID &uid)
	{
	Q_UNUSED(uid)
	qCWarning(KLEOPATRA_LOG) << "Revoking UserID is not implemented. How did you even get here?!?!";
	}

	void CertificateDetailsWidget::Private::changeExpiration()
	{
	auto cmd = new Kleo::Commands::ChangeExpiryCommand(key);
	QObject::connect(cmd, &Kleo::Commands::ChangeExpiryCommand::finished,
	q, [this]() {
	ui.changeExpirationBtn->setEnabled(true);
	});
	ui.changeExpirationBtn->setEnabled(false);
	cmd->start();
	}

	void CertificateDetailsWidget::Private::changePassphrase()
	{
	auto cmd = new Kleo::Commands::ChangePassphraseCommand(key);
	QObject::connect(cmd, &Kleo::Commands::ChangePassphraseCommand::finished,
	q, [this]() {
	ui.changePassphraseBtn->setEnabled(true);
	});
	ui.changePassphraseBtn->setEnabled(false);
	cmd->start();
	}

	void CertificateDetailsWidget::Private::genRevokeCert()
	{
	auto cmd = new Kleo::Commands::GenRevokeCommand(key);
	QObject::connect(cmd, &Kleo::Commands::GenRevokeCommand::finished,
	q, [this]() {
	ui.genRevokeBtn->setEnabled(true);
	});
	ui.genRevokeBtn->setEnabled(false);
	cmd->start();
	}

	void CertificateDetailsWidget::Private::certifyClicked()
	{
	auto cmd = new Kleo::Commands::CertifyCertificateCommand(key);
	QObject::connect(cmd, &Kleo::Commands::CertifyCertificateCommand::finished,
	q, [this]() {
	ui.certifyBtn->setEnabled(true);
	});
	ui.certifyBtn->setEnabled(false);
	cmd->start();
	}

	void CertificateDetailsWidget::Private::webOfTrustClicked()
	{
	QScopedPointer<WebOfTrustDialog> dlg(new WebOfTrustDialog(q));
	dlg->setKey(key);
	dlg->exec();
	}

	void CertificateDetailsWidget::Private::exportClicked()
	{
	QScopedPointer<ExportDialog> dlg(new ExportDialog(q));
	dlg->setKey(key);
	dlg->exec();
	}

	void CertificateDetailsWidget::Private::addUserID()
	{
	auto cmd = new Kleo::Commands::AddUserIDCommand(key);
	QObject::connect(cmd, &Kleo::Commands::AddUserIDCommand::finished,
	q, [this]() {
	ui.addUserIDBtn->setEnabled(true);
	key.update();
	q->setKey(key);
	});
	ui.addUserIDBtn->setEnabled(false);
	cmd->start();
	}

	void CertificateDetailsWidget::Private::keysMayHaveChanged()
	{
	auto newKey = Kleo::KeyCache::instance()->findByFingerprint(key.primaryFingerprint());
	if (!newKey.isNull()) {
	setUpdatedKey(newKey);
	}
	}

	void CertificateDetailsWidget::Private::showTrustChainDialog()
	{
	QScopedPointer<TrustChainDialog> dlg(new TrustChainDialog(q));
	dlg->setKey(key);
	dlg->exec();
	}

	void CertificateDetailsWidget::Private::publishCertificate()
	{
	qCWarning(KLEOPATRA_LOG) << "publishCertificateis not implemented.";
	//TODO
	}

	void CertificateDetailsWidget::Private::userIDTableContextMenuRequested(const QPoint &p)
	{
	auto item = ui.userIDTable->itemAt(p);
	if (!item) {
	return;
	}

	const auto userID = item->data(0, Qt::UserRole).value<GpgME::UserID>();

	auto menu = new QMenu(q);
	menu->addAction(QIcon::fromTheme(QStringLiteral("view-certificate-sign")),
	i18n("Certify..."),
	q, [this, userID]() {
	auto cmd = new Kleo::Commands::CertifyCertificateCommand(userID);
	ui.userIDTable->setEnabled(false);
	connect(cmd, &Kleo::Commands::CertifyCertificateCommand::finished,
	q, [this]() {
	ui.userIDTable->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);
	ui.userIDTable->setEnabled(false);
	connect(cmd, &Kleo::Commands::RevokeCertificationCommand::finished,
	q, [this]() {
	ui.userIDTable->setEnabled(true);
	// Trigger an update when done
	q->setKey(key);
	});
	cmd->start();
	});
	}
	connect(menu, &QMenu::aboutToHide, menu, &QObject::deleteLater);
	menu->popup(ui.userIDTable->viewport()->mapToGlobal(p));
	}

	void CertificateDetailsWidget::Private::showMoreDetails()
	{
	ui.moreDetailsBtn->setEnabled(false);
	if (key.protocol() == GpgME::CMS) {
	auto cmd = new Kleo::Commands::DumpCertificateCommand(key);
	connect(cmd, &Kleo::Commands::DumpCertificateCommand::finished,
	q, [this]() {
	ui.moreDetailsBtn->setEnabled(true);
	});
	cmd->setUseDialog(true);
	cmd->start();
	} else {
	QScopedPointer<SubKeysDialog> dlg(new SubKeysDialog(q));
	dlg->setKey(key);
	dlg->exec();
	ui.moreDetailsBtn->setEnabled(true);
	}
	}

	QString CertificateDetailsWidget::Private::tofuTooltipString(const GpgME::UserID &uid) const
	{
	const auto tofu = uid.tofuInfo();
	if (tofu.isNull()) {
	return QString();
	}

	QString html = QStringLiteral("<table border=\"0\" cell-padding=\"5\">");
	const auto appendRow = [&html](const QString &lbl, const QString &val) {
	html += QStringLiteral("<tr>"
	"<th style=\"text-align: right; padding-right: 5px; white-space: nowrap;\">%1:</th>"
	"<td style=\"white-space: nowrap;\">%2</td>"
	"</tr>")
	.arg(lbl, val);
	};
	const auto appendHeader = [this, &html](const QString &hdr) {
	html += QStringLiteral("<tr><th colspan=\"2\" style=\"background-color: %1; color: %2\">%3</th></tr>")
	.arg(q->palette().highlight().color().name(),
	q->palette().highlightedText().color().name(),
	hdr);
	};
	const auto dateTime = [](long ts) {
	QLocale l;
	return ts == 0 ? i18n("never") : l.toString(QDateTime::fromSecsSinceEpoch(ts), QLocale::ShortFormat);
	};
	appendHeader(i18n("Signing"));
	appendRow(i18n("First message"), dateTime(tofu.signFirst()));
	appendRow(i18n("Last message"), dateTime(tofu.signLast()));
	appendRow(i18n("Message count"), QString::number(tofu.signCount()));
	appendHeader(i18n("Encryption"));
	appendRow(i18n("First message"), dateTime(tofu.encrFirst()));
	appendRow(i18n("Last message"), dateTime(tofu.encrLast()));
	appendRow(i18n("Message count"), QString::number(tofu.encrCount()));

	html += QStringLiteral("</table>");
	// Make sure the tooltip string is different for each UserID, even if the
	// data are the same, otherwise the tooltip is not updated and moved when
	// user moves mouse from one row to another.
	html += QStringLiteral("<!-- %1 //-->").arg(QString::fromUtf8(uid.id()));
	return html;
	}

	-#ifdef GPGMEPP_SUPPORTS_TRUST_SIGNATURES
	namespace
	{
	auto isGood(const GpgME::UserID::Signature &signature)
	{
	return signature.status() == GpgME::UserID::Signature::NoError &&
	!signature.isInvalid() &&
	0x10 <= signature.certClass() && signature.certClass() <= 0x13;
	}

	auto accumulateTrustDomains(const std::vector<GpgME::UserID::Signature> &signatures)
	{
	return std::accumulate(
	std::begin(signatures), std::end(signatures),
	std::set<QString>(),
	[] (auto domains, const auto &signature) {
	if (isGood(signature) && signature.isTrustSignature()) {
	domains.insert(Formatting::trustSignatureDomain(signature));
	}
	return domains;
	}
	);
	}

	auto accumulateTrustDomains(const std::vector<GpgME::UserID> &userIds)
	{
	return std::accumulate(
	std::begin(userIds), std::end(userIds),
	std::set<QString>(),
	[] (auto domains, const auto &userID) {
	const auto newDomains = accumulateTrustDomains(userID.signatures());
	std::copy(std::begin(newDomains), std::end(newDomains), std::inserter(domains, std::end(domains)));
	return domains;
	}
	);
	}
	}
	-#endif

	void CertificateDetailsWidget::Private::setupPGPProperties()
	{
	HIDE_ROW(smimeOwner)
	HIDE_ROW(smimeIssuer)
	ui.smimeRelatedAddresses->setVisible(false);
	ui.trustChainDetailsBtn->setVisible(false);

	ui.userIDTable->setContextMenuPolicy(Qt::CustomContextMenu);
	connect(ui.userIDTable, &QAbstractItemView::customContextMenuRequested,
	q, [this](const QPoint &p) { userIDTableContextMenuRequested(p); });

	-#ifdef GPGMEPP_SUPPORTS_TRUST_SIGNATURES
	const auto trustDomains = accumulateTrustDomains(key.userIDs());
	if (trustDomains.empty()) {
	HIDE_ROW(trustedIntroducer)
	} else {
	SHOW_ROW(trustedIntroducer)
	ui.trustedIntroducer->setText(QStringList(std::begin(trustDomains), std::end(trustDomains)).join(u", "));
	}
	-#else
	- HIDE_ROW(trustedIntroducer)
	-#endif
	}

	static QString formatDNToolTip(const Kleo::DN &dn)
	{
	QString html = QStringLiteral("<table border=\"0\" cell-spacing=15>");

	const auto appendRow = [&html, dn](const QString &lbl, const QString &attr) {
	const QString val = dn[attr];
	if (!val.isEmpty()) {
	html += QStringLiteral(
	"<tr><th style=\"text-align: left; white-space: nowrap\">%1:</th>"
	"<td style=\"white-space: nowrap\">%2</td>"
	"</tr>").arg(lbl, val);
	}
	};
	appendRow(i18n("Common Name"), QStringLiteral("CN"));
	appendRow(i18n("Organization"), QStringLiteral("O"));
	appendRow(i18n("Street"), QStringLiteral("STREET"));
	appendRow(i18n("City"), QStringLiteral("L"));
	appendRow(i18n("State"), QStringLiteral("ST"));
	appendRow(i18n("Country"), QStringLiteral("C"));
	html += QStringLiteral("</table>");

	return html;
	}

	void CertificateDetailsWidget::Private::setupSMIMEProperties()
	{
	HIDE_ROW(publishing)
	HIDE_ROW(trustedIntroducer)

	const auto ownerId = key.userID(0);
	const Kleo::DN dn(ownerId.id());
	const QString cn = dn[QStringLiteral("CN")];
	const QString o = dn[QStringLiteral("O")];
	const QString dnEmail = dn[QStringLiteral("EMAIL")];
	const QString name = cn.isEmpty() ? dnEmail : cn;

	QString owner;
	if (name.isEmpty()) {
	owner = dn.dn();
	} else if (o.isEmpty()) {
	owner = name;
	} else {
	owner = i18nc("<name> of <company>", "%1 of %2", name, o);
	}
	ui.smimeOwner->setText(owner);
	ui.smimeOwner->setTextInteractionFlags(Qt::TextBrowserInteraction);

	const Kleo::DN issuerDN(key.issuerName());
	const QString issuerCN = issuerDN[QStringLiteral("CN")];
	const QString issuer = issuerCN.isEmpty() ? QString::fromUtf8(key.issuerName()) : issuerCN;
	ui.smimeIssuer->setText(QStringLiteral("<a href=\"#issuerDetails\">%1</a>").arg(issuer));

	ui.smimeIssuer->setToolTip(formatDNToolTip(issuerDN));

	ui.smimeOwner->setToolTip(formatDNToolTip(dn));

	}

	void CertificateDetailsWidget::Private::smimeLinkActivated(const QString &link)
	{
	if (link == QLatin1String("#issuerDetails")) {
	const auto parentKey = KeyCache::instance()->findIssuers(key, KeyCache::NoOption);

	if (!parentKey.size()) {
	return;
	}
	auto cmd = new Kleo::Commands::DetailsCommand(parentKey[0], nullptr);
	cmd->setParentWidget(q);
	cmd->start();
	return;
	}
	qCWarning(KLEOPATRA_LOG) << "Unknown link activated:" << link;
	}

	void CertificateDetailsWidget::Private::copyFingerprintToClipboard()
	{
	if (auto clipboard = QGuiApplication::clipboard()) {
	clipboard->setText(QString::fromLatin1(key.primaryFingerprint()));
	}
	}

	CertificateDetailsWidget::CertificateDetailsWidget(QWidget *parent)
	: QWidget{parent}
	, d{std::make_unique<Private>(this)}
	{
	}

	CertificateDetailsWidget::~CertificateDetailsWidget() = default;

	void CertificateDetailsWidget::Private::keyListDone(const GpgME::KeyListResult &,
	const std::vector<GpgME::Key> &keys,
	const QString &,
	const GpgME::Error &)
	{
	updateInProgress = false;
	if (keys.size() != 1) {
	qCWarning(KLEOPATRA_LOG) << "Invalid keylist result in update.";
	return;
	}
	// As we listen for keysmayhavechanged we get the update
	// after updating the keycache.
	KeyCache::mutableInstance()->insert(keys);
	}

	void CertificateDetailsWidget::Private::setUpdatedKey(const GpgME::Key &k)
	{
	key = k;

	setupCommonProperties();
	if (key.protocol() == GpgME::OpenPGP) {
	setupPGPProperties();
	} else {
	setupSMIMEProperties();
	}
	}

	void CertificateDetailsWidget::setKey(const GpgME::Key &key)
	{
	if (key.protocol() == GpgME::CMS) {
	// For everything but S/MIME this should be quick
	// and we don't need to show another status.
	d->updateInProgress = true;
	}
	d->setUpdatedKey(key);

	// Run a keylistjob with full details (TOFU / Validate)
	QGpgME::KeyListJob *job = key.protocol() == GpgME::OpenPGP ? QGpgME::openpgp()->keyListJob(false, true, true) :
	QGpgME::smime()->keyListJob(false, true, true);

	auto ctx = QGpgME::Job::context(job);
	ctx->addKeyListMode(GpgME::WithTofu);
	ctx->addKeyListMode(GpgME::SignatureNotations);
	if (key.hasSecret()) {
	ctx->addKeyListMode(GpgME::WithSecret);
	}

	// Windows QGpgME new style connect problem makes this necessary.
	connect(job, SIGNAL(result(GpgME::KeyListResult,std::vector<GpgME::Key>,QString,GpgME::Error)),
	this, SLOT(keyListDone(GpgME::KeyListResult,std::vector<GpgME::Key>,QString,GpgME::Error)));

	job->start(QStringList() << QLatin1String(key.primaryFingerprint()));
	}

	GpgME::Key CertificateDetailsWidget::key() const
	{
	return d->key;
	}

	#include "moc_certificatedetailswidget.cpp"
	diff --git a/src/dialogs/certifywidget.cpp b/src/dialogs/certifywidget.cpp
	index 9418f764d..5701f39d3 100644
	--- a/src/dialogs/certifywidget.cpp
	+++ b/src/dialogs/certifywidget.cpp
	@@ -1,727 +1,715 @@
	/* dialogs/certifywidget.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2019, 2021 g10 Code GmbH
	SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "certifywidget.h"

	#include "kleopatra_debug.h"

	#include <KLocalizedString>
	#include <KConfigGroup>
	#include <KDateComboBox>
	#include <KMessageBox>
	#include <KMessageWidget>
	#include <KSeparator>
	#include <KSharedConfig>

	#include <Libkleo/DefaultKeyFilter>
	#include <Libkleo/KeySelectionCombo>
	#include <Libkleo/Formatting>
	#include <Libkleo/KeyCache>
	#include <Libkleo/Predicates>

	#include <QGpgME/ChangeOwnerTrustJob>
	#include <QGpgME/Protocol>

	#include <QAction>
	#include <QCheckBox>
	#include <QHBoxLayout>
	#include <QIcon>
	#include <QLabel>
	#include <QLineEdit>
	#include <QListView>
	#include <QParallelAnimationGroup>
	#include <QPropertyAnimation>
	#include <QPushButton>
	#include <QScrollArea>
	#include <QStandardItemModel>
	#include <QToolButton>
	#include <QToolTip>
	#include <QVBoxLayout>

	#include <gpgme++/key.h>

	using namespace Kleo;

	namespace {

	// Maybe move this in its own file
	// based on code from StackOverflow
	class AnimatedExpander: public QWidget
	{
	Q_OBJECT
	public:
	explicit AnimatedExpander(const QString &title = QString(),
	QWidget *parent = nullptr);
	void setContentLayout(QLayout *contentLayout);

	private:
	QGridLayout mainLayout;
	QToolButton toggleButton;
	QFrame headerLine;
	QParallelAnimationGroup toggleAnimation;
	QScrollArea contentArea;
	int animationDuration{300};
	};

	AnimatedExpander::AnimatedExpander(const QString &title, QWidget *parent):
	QWidget(parent)
	{
	toggleButton.setStyleSheet(QStringLiteral("QToolButton { border: none; }"));
	toggleButton.setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
	toggleButton.setArrowType(Qt::ArrowType::RightArrow);
	toggleButton.setText(title);
	toggleButton.setCheckable(true);
	toggleButton.setChecked(false);

	headerLine.setFrameShape(QFrame::HLine);
	headerLine.setFrameShadow(QFrame::Sunken);
	headerLine.setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Maximum);

	contentArea.setStyleSheet(QStringLiteral("QScrollArea { border: none; }"));
	contentArea.setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);

	// start out collapsed
	contentArea.setMaximumHeight(0);
	contentArea.setMinimumHeight(0);

	// let the entire widget grow and shrink with its content
	toggleAnimation.addAnimation(new QPropertyAnimation(this, "minimumHeight"));
	toggleAnimation.addAnimation(new QPropertyAnimation(this, "maximumHeight"));
	toggleAnimation.addAnimation(new QPropertyAnimation(&contentArea, "maximumHeight"));

	mainLayout.setVerticalSpacing(0);
	mainLayout.setContentsMargins(0, 0, 0, 0);
	int row = 0;
	mainLayout.addWidget(&toggleButton, row, 0, 1, 1, Qt::AlignLeft);
	mainLayout.addWidget(&headerLine, row++, 2, 1, 1);
	mainLayout.addWidget(&contentArea, row, 0, 1, 3);
	setLayout(&mainLayout);
	QObject::connect(&toggleButton, &QToolButton::clicked, [this](const bool checked) {
	toggleButton.setArrowType(checked ? Qt::ArrowType::DownArrow : Qt::ArrowType::RightArrow);
	toggleAnimation.setDirection(checked ? QAbstractAnimation::Forward : QAbstractAnimation::Backward);
	toggleAnimation.start();
	});
	}

	void AnimatedExpander::setContentLayout(QLayout *contentLayout)
	{
	delete contentArea.layout();
	contentArea.setLayout(contentLayout);
	const auto collapsedHeight = sizeHint().height() - contentArea.maximumHeight();
	auto contentHeight = contentLayout->sizeHint().height();
	for (int i = 0; i < toggleAnimation.animationCount() - 1; ++i) {
	auto expanderAnimation = static_cast<QPropertyAnimation *>(toggleAnimation.animationAt(i));
	expanderAnimation->setDuration(animationDuration);
	expanderAnimation->setStartValue(collapsedHeight);
	expanderAnimation->setEndValue(collapsedHeight + contentHeight);
	}
	auto contentAnimation = static_cast<QPropertyAnimation *>(toggleAnimation.animationAt(toggleAnimation.animationCount() - 1));
	contentAnimation->setDuration(animationDuration);
	contentAnimation->setStartValue(0);
	contentAnimation->setEndValue(contentHeight);
	}

	class SecKeyFilter: public DefaultKeyFilter
	{
	public:
	SecKeyFilter() : DefaultKeyFilter()
	{
	setRevoked(DefaultKeyFilter::NotSet);
	setExpired(DefaultKeyFilter::NotSet);
	setHasSecret(DefaultKeyFilter::Set);
	setCanCertify(DefaultKeyFilter::Set);
	setIsOpenPGP(DefaultKeyFilter::Set);
	}

	bool matches(const GpgME::Key &key, Kleo::KeyFilter::MatchContexts contexts) const override
	{
	if (!(availableMatchContexts() & contexts)) {
	return false;
	}
	if (_detail::ByFingerprint<std::equal_to>()(key, mExcludedKey)) {
	return false;
	}
	return DefaultKeyFilter::matches(key, contexts);
	}

	void setExcludedKey(const GpgME::Key &key)
	{
	mExcludedKey = key;
	}

	private:
	GpgME::Key mExcludedKey;
	};

	class UserIDModel : public QStandardItemModel
	{
	Q_OBJECT
	public:
	enum Role {
	UserIDIndex = Qt::UserRole
	};
	explicit UserIDModel(QObject *parent = nullptr) : QStandardItemModel(parent) {}

	GpgME::Key certificateToCertify() const
	{
	return m_key;
	}

	void setKey(const GpgME::Key &key)
	{
	m_key = key;
	clear();
	const std::vector<GpgME::UserID> ids = key.userIDs();
	int i = 0;
	for (const auto &uid: key.userIDs()) {
	if (uid.isRevoked() \|\| uid.isInvalid()) {
	// Skip user ID's that cannot really be certified.
	i++;
	continue;
	}
	auto const item = new QStandardItem;
	item->setText(Formatting::prettyUserID(uid));
	item->setData(i, UserIDIndex);
	item->setCheckable(true);
	item->setEditable(false);
	item->setCheckState(Qt::Checked);
	appendRow(item);
	i++;
	}
	}

	void setCheckedUserIDs(const std::vector<unsigned int> &uids)
	{
	std::vector<unsigned int> sorted = uids;
	std::sort(sorted.begin(), sorted.end());
	for (int i = 0, end = rowCount(); i != end; ++i) {
	item(i)->setCheckState(std::binary_search(sorted.begin(), sorted.end(), i) ? Qt::Checked : Qt::Unchecked);
	}
	}

	std::vector<unsigned int> checkedUserIDs() const
	{
	std::vector<unsigned int> ids;
	for (int i = 0; i < rowCount(); ++i) {
	if (item(i)->checkState() == Qt::Checked) {
	ids.push_back(item(i)->data(UserIDIndex).toUInt());
	}
	}
	qCDebug(KLEOPATRA_LOG) << "Checked uids are: " << ids;
	return ids;
	}

	private:
	GpgME::Key m_key;
	};

	static bool uidEqual(const GpgME::UserID &lhs, const GpgME::UserID &rhs)
	{
	return qstrcmp(lhs.parent().primaryFingerprint(),
	rhs.parent().primaryFingerprint()) == 0
	&& qstrcmp(lhs.id(), rhs.id()) == 0;
	}

	auto checkBoxSize(const QCheckBox *checkBox)
	{
	QStyleOptionButton opt;
	return checkBox->style()->sizeFromContents(QStyle::CT_CheckBox, &opt, QSize(), checkBox);
	}

	auto createInfoButton(const QString &text, QWidget *parent)
	{
	auto infoBtn = new QPushButton{parent};
	infoBtn->setIcon(QIcon::fromTheme(QStringLiteral("help-contextual")));
	infoBtn->setFlat(true);

	QObject::connect(infoBtn, &QPushButton::clicked, infoBtn, [infoBtn, text] () {
	QToolTip::showText(infoBtn->mapToGlobal(QPoint()) + QPoint(infoBtn->width(), 0),
	text, infoBtn, QRect(), 30000);
	});

	return infoBtn;
	}

	-#ifdef QGPGME_SUPPORTS_SIGNATURE_EXPIRATION
	QString dateFormatWithFourDigitYear(QLocale::FormatType format)
	{
	// Force the year to be formatted as four digit number, so that
	// the user can distinguish between 2006 and 2106.
	return QLocale{}.dateFormat(format).
	replace(QLatin1String("yy"), QLatin1String("yyyy")).
	replace(QLatin1String("yyyyyyyy"), QLatin1String("yyyy"));
	}

	QString formatDate(const QDate &date, QLocale::FormatType format)
	{
	return QLocale{}.toString(date, dateFormatWithFourDigitYear(format));
	}
	-#endif

	}

	class CertifyWidget::Private
	{
	public:
	Private(CertifyWidget *qq)
	: q{qq}
	, mFprLabel{new QLabel{q}}
	, mSecKeySelect{new KeySelectionCombo{/* secretOnly= */true, q}}
	, mMissingOwnerTrustInfo{new KMessageWidget{q}}
	, mExportCB{new QCheckBox{q}}
	, mPublishCB{new QCheckBox{q}}
	, mTagsLE{new QLineEdit{q}}
	, mTrustSignatureCB{new QCheckBox{q}}
	, mTrustSignatureDomainLE{new QLineEdit{q}}
	, mExpirationCheckBox{new QCheckBox{q}}
	, mExpirationDateEdit{new KDateComboBox{q}}
	, mSetOwnerTrustAction{new QAction{q}}
	{
	auto mainLay = new QVBoxLayout{q};
	mainLay->addWidget(mFprLabel);

	auto secKeyLay = new QHBoxLayout{q};
	secKeyLay->addWidget(new QLabel(i18n("Certify with:")));

	mSecKeySelect->setKeyFilter(std::make_shared<SecKeyFilter>());

	secKeyLay->addWidget(mSecKeySelect, 1);
	mainLay->addLayout(secKeyLay);

	mSetOwnerTrustAction->setText(i18nc("@action:button", "Set Owner Trust"));
	mSetOwnerTrustAction->setToolTip(QLatin1String("<html>") +
	i18nc("@info:tooltip",
	"Click to set the trust level of the selected certification key to ultimate trust. "
	"This is what you usually want to do for your own keys.") +
	QLatin1String("</html>"));
	connect(mSetOwnerTrustAction, &QAction::triggered, q, [this] () { setOwnerTrust(); });
	mMissingOwnerTrustInfo->addAction(mSetOwnerTrustAction);
	mMissingOwnerTrustInfo->setVisible(false);

	mainLay->addWidget(mMissingOwnerTrustInfo);

	mainLay->addWidget(new KSeparator{Qt::Horizontal, q});

	auto listView = new QListView{q};
	listView->setModel(&mUserIDModel);
	mainLay->addWidget(listView, 1);

	// Setup the advanced area
	auto expander = new AnimatedExpander{i18n("Advanced"), q};
	mainLay->addWidget(expander);

	auto advLay = new QVBoxLayout{q};

	mExportCB->setText(i18n("Certify for everyone to see (exportable)"));
	advLay->addWidget(mExportCB);

	{
	auto layout = new QHBoxLayout{q};

	mPublishCB->setText(i18n("Publish on keyserver afterwards"));
	mPublishCB->setEnabled(mExportCB->isChecked());

	layout->addSpacing(checkBoxSize(mExportCB).width());
	layout->addWidget(mPublishCB);

	advLay->addLayout(layout);
	}

	{
	auto tagsLay = new QHBoxLayout{q};

	mTagsLE->setPlaceholderText(i18n("Tags"));
	auto infoBtn = createInfoButton(i18n("You can use this to add additional info to a certification.") +
	QStringLiteral("<br/><br/>") +
	i18n("Tags created by anyone with full certification trust "
	"are shown in the keylist and can be searched."),
	q);

	tagsLay->addWidget(new QLabel{i18n("Tags:"), q});
	tagsLay->addWidget(mTagsLE, 1);
	tagsLay->addWidget(infoBtn);

	advLay->addLayout(tagsLay);
	}

	-#ifndef QGPGME_SUPPORTS_SIGNATURE_EXPIRATION
	- mExpirationCheckBox->setVisible(false);
	- mExpirationDateEdit->setVisible(false);
	-#else
	{
	auto layout = new QHBoxLayout{q};

	mExpirationCheckBox->setText(i18n("Expiration:"));

	mExpirationDateEdit->setOptions(KDateComboBox::EditDate \| KDateComboBox::SelectDate \| KDateComboBox::DatePicker \|
	KDateComboBox::DateKeywords \| KDateComboBox::WarnOnInvalid);
	static const QDate maxAllowedDate{2106, 2, 6};
	const QDate today = QDate::currentDate();
	mExpirationDateEdit->setDateRange(today.addDays(1), maxAllowedDate,
	i18n("The certification must be valid at least until tomorrow."),
	i18n("The latest allowed certification date is %1.",
	formatDate(maxAllowedDate, QLocale::ShortFormat)));
	mExpirationDateEdit->setDateMap({
	{today.addYears(2), i18nc("Date for expiration of certification", "Two years from now")},
	{today.addYears(1), i18nc("Date for expiration of certification", "One year from now")}
	});
	mExpirationDateEdit->setDate(today.addYears(2));
	mExpirationDateEdit->setEnabled(mExpirationCheckBox->isChecked());

	auto infoBtn = createInfoButton(i18n("You can use this to set an expiration date for a certification.") +
	QStringLiteral("<br/><br/>") +
	i18n("By setting an expiration date, you can limit the validity of "
	"your certification to a certain amount of time. Once the expiration "
	"date has passed, your certification is no longer valid."),
	q);

	layout->addWidget(mExpirationCheckBox);
	layout->addWidget(mExpirationDateEdit, 1);
	layout->addWidget(infoBtn);

	advLay->addLayout(layout);
	}
	-#endif

	-#ifndef QGPGME_SUPPORTS_TRUST_SIGNATURES
	- mTrustSignatureCB->setVisible(false);
	- mTrustSignatureDomainLE->setVisible(false);
	-#else
	{
	auto layout = new QHBoxLayout{q};

	mTrustSignatureCB->setText(i18n("Certify as trusted introducer"));
	auto infoBtn = createInfoButton(i18n("You can use this to certify a trusted introducer for a domain.") +
	QStringLiteral("<br/><br/>") +
	i18n("All certificates with email addresses belonging to the domain "
	"that have been certified by the trusted introducer are treated "
	"as certified, i.e. a trusted introducer acts as a kind of "
	"intermediate CA for a domain."),
	q);

	layout->addWidget(mTrustSignatureCB, 1);
	layout->addWidget(infoBtn);

	advLay->addLayout(layout);
	}
	{
	auto layout = new QHBoxLayout{q};

	mTrustSignatureDomainLE->setPlaceholderText(i18n("Domain"));
	mTrustSignatureDomainLE->setEnabled(mTrustSignatureCB->isChecked());

	layout->addSpacing(checkBoxSize(mTrustSignatureCB).width());
	layout->addWidget(mTrustSignatureDomainLE);

	advLay->addLayout(layout);
	}
	-#endif

	expander->setContentLayout(advLay);

	connect(&mUserIDModel, &QStandardItemModel::itemChanged, q, &CertifyWidget::changed);

	connect(mExportCB, &QCheckBox::toggled, [this] (bool on) {
	mPublishCB->setEnabled(on);
	});

	connect(mSecKeySelect, &KeySelectionCombo::currentKeyChanged, [this] (const GpgME::Key &) {
	updateTags();
	checkOwnerTrust();
	Q_EMIT q->changed();
	});

	connect(mExpirationCheckBox, &QCheckBox::toggled, q, [this] (bool checked) {
	mExpirationDateEdit->setEnabled(checked);
	Q_EMIT q->changed();
	});
	connect(mExpirationDateEdit, &KDateComboBox::dateChanged, q, &CertifyWidget::changed);

	connect(mTrustSignatureCB, &QCheckBox::toggled, q, [this] (bool on) {
	mTrustSignatureDomainLE->setEnabled(on);
	Q_EMIT q->changed();
	});
	connect(mTrustSignatureDomainLE, &QLineEdit::textChanged, q, &CertifyWidget::changed);

	loadConfig();
	}

	~Private() = default;

	void loadConfig()
	{
	const KConfigGroup conf(KSharedConfig::openConfig(), "CertifySettings");
	mSecKeySelect->setDefaultKey(conf.readEntry("LastKey", QString()));
	mExportCB->setChecked(conf.readEntry("ExportCheckState", false));
	mPublishCB->setChecked(conf.readEntry("PublishCheckState", false));
	}

	void updateTags()
	{
	if (mTagsLE->isModified()) {
	return;
	}
	GpgME::Key remarkKey = mSecKeySelect->currentKey();

	if (!remarkKey.isNull()) {
	std::vector<GpgME::UserID> uidsWithRemark;
	QString remark;
	for (const auto &uid: mTarget.userIDs()) {
	GpgME::Error err;
	const char *c_remark = uid.remark(remarkKey, err);
	if (c_remark) {
	const QString candidate = QString::fromUtf8(c_remark);
	if (candidate != remark) {
	qCDebug(KLEOPATRA_LOG) << "Different remarks on user ids. Taking last.";
	remark = candidate;
	uidsWithRemark.clear();
	}
	uidsWithRemark.push_back(uid);
	}
	}
	// Only select the user ids with the correct remark
	if (!remark.isEmpty()) {
	selectUserIDs(uidsWithRemark);
	}
	mTagsLE->setText(remark);
	}
	}

	void updateTrustSignatureDomain()
	{
	if (mTrustSignatureDomainLE->text().isEmpty() && mTarget.numUserIDs() == 1) {
	// try to guess the domain to use for the trust signature
	const auto address = mTarget.userID(0).addrSpec();
	const auto atPos = address.find('@');
	if (atPos != std::string::npos) {
	const auto domain = address.substr(atPos + 1);
	mTrustSignatureDomainLE->setText(QString::fromUtf8(domain.c_str(), domain.size()));
	}
	}
	}

	void setTarget(const GpgME::Key &key)
	{
	mFprLabel->setText(i18n("Fingerprint: <b>%1</b>",
	Formatting::prettyID(key.primaryFingerprint())) + QStringLiteral("<br/>") +
	i18n("<i>Only the fingerprint clearly identifies the key and its owner.</i>"));
	mUserIDModel.setKey(key);
	mTarget = key;

	auto keyFilter = std::make_shared<SecKeyFilter>();
	keyFilter->setExcludedKey(mTarget);
	mSecKeySelect->setKeyFilter(keyFilter);

	updateTags();
	updateTrustSignatureDomain();
	}

	GpgME::Key secKey() const
	{
	return mSecKeySelect->currentKey();
	}

	void selectUserIDs(const std::vector<GpgME::UserID> &uids)
	{
	const auto all = mTarget.userIDs();

	std::vector<unsigned int> indexes;
	indexes.reserve(uids.size());

	for (const auto &uid: uids) {
	const unsigned int idx =
	std::distance(all.cbegin(), std::find_if(all.cbegin(), all.cend(),
	[uid](const GpgME::UserID &other) { return uidEqual(uid, other); }));
	if (idx < all.size()) {
	indexes.push_back(idx);
	}
	}

	mUserIDModel.setCheckedUserIDs(indexes);
	}

	std::vector<unsigned int> selectedUserIDs() const
	{
	return mUserIDModel.checkedUserIDs();
	}

	bool exportableSelected() const
	{
	return mExportCB->isChecked();
	}

	bool publishSelected() const
	{
	return mPublishCB->isChecked();
	}

	QString tags() const
	{
	return mTagsLE->text().trimmed();
	}

	GpgME::Key target() const
	{
	return mTarget;
	}

	bool isValid() const
	{
	static const QRegularExpression domainNameRegExp{QStringLiteral(R"(^\s((xn--)?[a-z0-9]+(-[a-z0-9]+)\.)+[a-z]{2,}\s*$)"),
	QRegularExpression::CaseInsensitiveOption};

	// do not accept null keys
	if (mTarget.isNull() \|\| mSecKeySelect->currentKey().isNull()) {
	return false;
	}
	// do not accept empty list of user ids
	if (selectedUserIDs().empty()) {
	return false;
	}
	// do not accept if the key to certify is selected as certification key;
	// this shouldn't happen because the key to certify is excluded from the choice, but better safe than sorry
	if (_detail::ByFingerprint<std::equal_to>()(mTarget, mSecKeySelect->currentKey())) {
	return false;
	}
	if (mExpirationCheckBox->isChecked() && !mExpirationDateEdit->isValid()) {
	return false;
	}
	if (mTrustSignatureCB->isChecked() && !domainNameRegExp.match(mTrustSignatureDomainLE->text()).hasMatch()) {
	return false;
	}
	return true;
	}

	void checkOwnerTrust()
	{
	const auto secretKey = secKey();
	if (secretKey.ownerTrust() != GpgME::Key::Ultimate) {
	mMissingOwnerTrustInfo->setMessageType(KMessageWidget::Information);
	mMissingOwnerTrustInfo->setIcon(QIcon::fromTheme(QStringLiteral("question")));
	mMissingOwnerTrustInfo->setText(i18n("Is this your own key?"));
	mSetOwnerTrustAction->setEnabled(true);
	mMissingOwnerTrustInfo->animatedShow();
	} else {
	mMissingOwnerTrustInfo->animatedHide();
	}
	}

	void setOwnerTrust()
	{
	mSetOwnerTrustAction->setEnabled(false);
	QGpgME::ChangeOwnerTrustJob *const j = QGpgME::openpgp()->changeOwnerTrustJob();
	connect(j, &QGpgME::ChangeOwnerTrustJob::result, q, [this] (const GpgME::Error &err) {
	if (err) {
	KMessageBox::sorry(q,
	i18n("<p>Changing the certification trust of the key <b>%1</b> failed:</p><p>%2</p>",
	Formatting::formatForComboBox(secKey()),
	QString::fromLocal8Bit(err.asString())),
	i18n("Certification Trust Change Failed"));
	}
	if (err \|\| err.isCanceled()) {
	mSetOwnerTrustAction->setEnabled(true);
	} else {
	mMissingOwnerTrustInfo->setMessageType(KMessageWidget::Positive);
	mMissingOwnerTrustInfo->setIcon(QIcon::fromTheme(QStringLiteral("checkmark")));
	mMissingOwnerTrustInfo->setText(i18n("Owner trust set successfully."));
	}
	});
	j->start(secKey(), GpgME::Key::Ultimate);
	}

	public:
	CertifyWidget *const q;
	QLabel *mFprLabel = nullptr;
	KeySelectionCombo *mSecKeySelect = nullptr;
	KMessageWidget *mMissingOwnerTrustInfo = nullptr;
	QCheckBox *mExportCB = nullptr;
	QCheckBox *mPublishCB = nullptr;
	QLineEdit *mTagsLE = nullptr;
	QCheckBox *mTrustSignatureCB = nullptr;
	QLineEdit *mTrustSignatureDomainLE = nullptr;
	QCheckBox *mExpirationCheckBox = nullptr;
	KDateComboBox *mExpirationDateEdit = nullptr;
	QAction *mSetOwnerTrustAction = nullptr;

	UserIDModel mUserIDModel;
	GpgME::Key mTarget;
	};

	CertifyWidget::CertifyWidget(QWidget *parent)
	: QWidget{parent}
	, d{std::make_unique<Private>(this)}
	{
	}

	Kleo::CertifyWidget::~CertifyWidget() = default;

	void CertifyWidget::setTarget(const GpgME::Key &key)
	{
	d->setTarget(key);
	}

	GpgME::Key CertifyWidget::target() const
	{
	return d->target();
	}

	void CertifyWidget::selectUserIDs(const std::vector<GpgME::UserID> &uids)
	{
	d->selectUserIDs(uids);
	}

	std::vector<unsigned int> CertifyWidget::selectedUserIDs() const
	{
	return d->selectedUserIDs();
	}

	GpgME::Key CertifyWidget::secKey() const
	{
	return d->secKey();
	}

	bool CertifyWidget::exportableSelected() const
	{
	return d->exportableSelected();
	}

	QString CertifyWidget::tags() const
	{
	return d->tags();
	}

	bool CertifyWidget::publishSelected() const
	{
	return d->publishSelected();
	}

	bool CertifyWidget::trustSignatureSelected() const
	{
	return d->mTrustSignatureCB->isChecked();
	}

	QString CertifyWidget::trustSignatureDomain() const
	{
	return d->mTrustSignatureDomainLE->text().trimmed();
	}

	QDate CertifyWidget::expirationDate() const
	{
	return d->mExpirationCheckBox->isChecked() ? d->mExpirationDateEdit->date() : QDate{};
	}

	bool CertifyWidget::isValid() const
	{
	return d->isValid();
	}

	// For UserID model
	#include "certifywidget.moc"

File Metadata

Mime Type: text/x-diff
Expires: Thu, Feb 26, 6:26 PM (11 h, 41 m)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 83/6d/e0170d50d1bd0d9a8888eef1c065

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions