diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index ffc7fd4d8..19c5bf2d0 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -1,605 +1,611 @@ # SPDX-FileCopyrightText: none # SPDX-License-Identifier: BSD-3-Clause add_subdirectory(icons) add_subdirectory(mimetypes) include_directories(${CMAKE_CURRENT_BINARY_DIR}) include_directories(${CMAKE_CURRENT_SOURCE_DIR}) if (NOT DISABLE_KWATCHGNUPG) add_subdirectory(kwatchgnupg) endif() add_subdirectory(libkleopatraclient) add_subdirectory(conf) add_subdirectory(kconf_update) if(WIN32) set(_kleopatra_extra_uiserver_SRCS uiserver/uiserver_win.cpp) set(_kleopatra_extra_SRCS selftest/registrycheck.cpp utils/gnupg-registry.c utils/userinfo_win.cpp utils/windowsprocessdevice.cpp ) else() set(_kleopatra_extra_uiserver_SRCS uiserver/uiserver_unix.cpp) set(_kleopatra_extra_SRCS) endif() set(_kleopatra_uiserver_SRCS ${_kleopatra_extra_uiserver_SRCS} selftest/uiservercheck.cpp uiserver/assuanserverconnection.cpp uiserver/createchecksumscommand.cpp uiserver/decryptverifycommandemailbase.cpp uiserver/decryptverifycommandfilesbase.cpp uiserver/echocommand.cpp uiserver/encryptcommand.cpp uiserver/importfilescommand.cpp uiserver/prepencryptcommand.cpp uiserver/prepsigncommand.cpp uiserver/selectcertificatecommand.cpp uiserver/sessiondata.cpp uiserver/signcommand.cpp uiserver/signencryptfilescommand.cpp uiserver/uiserver.cpp uiserver/verifychecksumscommand.cpp ) if(ASSUAN2_FOUND) include_directories(${ASSUAN2_INCLUDES}) set(_kleopatra_uiserver_extra_libs ${ASSUAN2_LIBRARIES}) else() include_directories(${ASSUAN_INCLUDES}) if(WIN32) set(_kleopatra_uiserver_extra_libs ${ASSUAN_VANILLA_LIBRARIES}) else() set(_kleopatra_uiserver_extra_libs ${ASSUAN_PTHREAD_LIBRARIES}) endif() endif() if(HAVE_GPG_ERR_SOURCE_KLEO) add_definitions(-DGPG_ERR_SOURCE_DEFAULT=GPG_ERR_SOURCE_KLEO) add_definitions(-DGPGMEPP_ERR_SOURCE_DEFAULT=GPG_ERR_SOURCE_KLEO) else() add_definitions(-DGPG_ERR_SOURCE_DEFAULT=GPG_ERR_SOURCE_USER_1) add_definitions(-DGPGMEPP_ERR_SOURCE_DEFAULT=GPG_ERR_SOURCE_USER_1) endif() if(KF5IdentityManagement_FOUND AND KF5MailTransport_FOUND AND KF5MailTransportAkonadi_FOUND) set(_kleopatra_mail_libs KF5::IdentityManagement # Export OpenPGP keys using WKS KF5::MailTransport KF5::MailTransportAkonadi ) add_definitions(-DMAILAKONADI_ENABLED) endif() ki18n_wrap_ui(_kleopatra_uiserver_SRCS crypto/gui/signingcertificateselectionwidget.ui) set(_kleopatra_SRCS ${_kleopatra_extra_SRCS} accessibility/accessiblerichtextlabel.cpp accessibility/accessiblerichtextlabel_p.h accessibility/accessiblewidgetfactory.cpp accessibility/accessiblewidgetfactory.h commands/adduseridcommand.cpp commands/adduseridcommand.h commands/authenticatepivcardapplicationcommand.cpp commands/authenticatepivcardapplicationcommand.h commands/cardcommand.cpp commands/cardcommand.h commands/certificatetopivcardcommand.cpp commands/certificatetopivcardcommand.h commands/certifycertificatecommand.cpp commands/certifycertificatecommand.h commands/changeexpirycommand.cpp commands/changeexpirycommand.h commands/changeownertrustcommand.cpp commands/changeownertrustcommand.h commands/changepassphrasecommand.cpp commands/changepassphrasecommand.h commands/changepincommand.cpp commands/changepincommand.h commands/changeroottrustcommand.cpp commands/changeroottrustcommand.h commands/checksumcreatefilescommand.cpp commands/checksumcreatefilescommand.h commands/checksumverifyfilescommand.cpp commands/checksumverifyfilescommand.h commands/clearcrlcachecommand.cpp commands/clearcrlcachecommand.h commands/command.cpp commands/command.h commands/createcsrforcardkeycommand.cpp commands/createcsrforcardkeycommand.h commands/createopenpgpkeyfromcardkeyscommand.cpp commands/createopenpgpkeyfromcardkeyscommand.h commands/decryptverifyclipboardcommand.cpp commands/decryptverifyclipboardcommand.h commands/decryptverifyfilescommand.cpp commands/decryptverifyfilescommand.h commands/deletecertificatescommand.cpp commands/deletecertificatescommand.h commands/detailscommand.cpp commands/detailscommand.h commands/dumpcertificatecommand.cpp commands/dumpcertificatecommand.h commands/dumpcrlcachecommand.cpp commands/dumpcrlcachecommand.h commands/encryptclipboardcommand.cpp commands/encryptclipboardcommand.h commands/exportcertificatecommand.cpp commands/exportcertificatecommand.h commands/exportgroupscommand.cpp commands/exportgroupscommand.h commands/exportopenpgpcertstoservercommand.cpp commands/exportopenpgpcertstoservercommand.h commands/exportopenpgpcerttoprovidercommand.cpp commands/exportopenpgpcerttoprovidercommand.h commands/exportpaperkeycommand.cpp commands/exportpaperkeycommand.h commands/exportsecretkeycommand.cpp commands/exportsecretkeycommand.h commands/exportsecretkeycommand_old.cpp commands/exportsecretkeycommand_old.h commands/exportsecretsubkeycommand.cpp commands/exportsecretsubkeycommand.h commands/genrevokecommand.cpp commands/genrevokecommand.h commands/gnupgprocesscommand.cpp commands/gnupgprocesscommand.h commands/importcertificatefromclipboardcommand.cpp commands/importcertificatefromclipboardcommand.h commands/importcertificatefromdatacommand.cpp commands/importcertificatefromdatacommand.h commands/importcertificatefromfilecommand.cpp commands/importcertificatefromfilecommand.h commands/importcertificatefromkeyservercommand.cpp commands/importcertificatefromkeyservercommand.h commands/importcertificatefrompivcardcommand.cpp commands/importcertificatefrompivcardcommand.h commands/importcertificatescommand.cpp commands/importcertificatescommand.h commands/importcrlcommand.cpp commands/importcrlcommand.h commands/importpaperkeycommand.cpp commands/importpaperkeycommand.h commands/keytocardcommand.cpp commands/keytocardcommand.h commands/learncardkeyscommand.cpp commands/learncardkeyscommand.h commands/lookupcertificatescommand.cpp commands/lookupcertificatescommand.h commands/newcertificatecommand.cpp commands/newcertificatecommand.h + commands/newopenpgpcertificatecommand.cpp + commands/newopenpgpcertificatecommand.h commands/pivgeneratecardkeycommand.cpp commands/pivgeneratecardkeycommand.h commands/refreshcertificatecommand.cpp commands/refreshcertificatecommand.h commands/refreshopenpgpcertscommand.cpp commands/refreshopenpgpcertscommand.h commands/refreshx509certscommand.cpp commands/refreshx509certscommand.h commands/reloadkeyscommand.cpp commands/reloadkeyscommand.h commands/revokecertificationcommand.cpp commands/revokecertificationcommand.h commands/revokekeycommand.cpp commands/revokekeycommand.h commands/revokeuseridcommand.cpp commands/revokeuseridcommand.h commands/selftestcommand.cpp commands/selftestcommand.h commands/setinitialpincommand.cpp commands/setinitialpincommand.h commands/setpivcardapplicationadministrationkeycommand.cpp commands/setpivcardapplicationadministrationkeycommand.h commands/signclipboardcommand.cpp commands/signclipboardcommand.h commands/signencryptfilescommand.cpp commands/signencryptfilescommand.h commands/signencryptfoldercommand.cpp commands/signencryptfoldercommand.h conf/configuredialog.cpp conf/configuredialog.h conf/groupsconfigdialog.cpp conf/groupsconfigdialog.h conf/groupsconfigpage.cpp conf/groupsconfigpage.h conf/groupsconfigwidget.cpp conf/groupsconfigwidget.h crypto/autodecryptverifyfilescontroller.cpp crypto/autodecryptverifyfilescontroller.h crypto/certificateresolver.cpp crypto/certificateresolver.h crypto/checksumsutils_p.cpp crypto/checksumsutils_p.h crypto/controller.cpp crypto/controller.h crypto/createchecksumscontroller.cpp crypto/createchecksumscontroller.h crypto/decryptverifyemailcontroller.cpp crypto/decryptverifyemailcontroller.h crypto/decryptverifyfilescontroller.cpp crypto/decryptverifyfilescontroller.h crypto/decryptverifytask.cpp crypto/decryptverifytask.h crypto/encryptemailcontroller.cpp crypto/encryptemailcontroller.h crypto/encryptemailtask.cpp crypto/encryptemailtask.h crypto/gui/certificatelineedit.cpp crypto/gui/certificatelineedit.h crypto/gui/certificateselectionline.cpp crypto/gui/certificateselectionline.h crypto/gui/decryptverifyfilesdialog.cpp crypto/gui/decryptverifyfilesdialog.h crypto/gui/decryptverifyfileswizard.cpp crypto/gui/decryptverifyfileswizard.h crypto/gui/decryptverifyoperationwidget.cpp crypto/gui/decryptverifyoperationwidget.h crypto/gui/encryptemailwizard.cpp crypto/gui/encryptemailwizard.h crypto/gui/newresultpage.cpp crypto/gui/newresultpage.h crypto/gui/objectspage.cpp crypto/gui/objectspage.h crypto/gui/resolverecipientspage.cpp crypto/gui/resolverecipientspage.h crypto/gui/resultitemwidget.cpp crypto/gui/resultitemwidget.h crypto/gui/resultlistwidget.cpp crypto/gui/resultlistwidget.h crypto/gui/resultpage.cpp crypto/gui/resultpage.h crypto/gui/signemailwizard.cpp crypto/gui/signemailwizard.h crypto/gui/signencryptemailconflictdialog.cpp crypto/gui/signencryptemailconflictdialog.h crypto/gui/signencryptfileswizard.cpp crypto/gui/signencryptfileswizard.h crypto/gui/signencryptwidget.cpp crypto/gui/signencryptwidget.h crypto/gui/signencryptwizard.cpp crypto/gui/signencryptwizard.h crypto/gui/signerresolvepage.cpp crypto/gui/signerresolvepage.h crypto/gui/signingcertificateselectiondialog.cpp crypto/gui/signingcertificateselectiondialog.h crypto/gui/signingcertificateselectionwidget.cpp crypto/gui/signingcertificateselectionwidget.h crypto/gui/unknownrecipientwidget.cpp crypto/gui/unknownrecipientwidget.h crypto/gui/verifychecksumsdialog.cpp crypto/gui/verifychecksumsdialog.h crypto/gui/wizard.cpp crypto/gui/wizard.h crypto/gui/wizardpage.cpp crypto/gui/wizardpage.h crypto/newsignencryptemailcontroller.cpp crypto/newsignencryptemailcontroller.h crypto/recipient.cpp crypto/recipient.h crypto/sender.cpp crypto/sender.h crypto/signemailcontroller.cpp crypto/signemailcontroller.h crypto/signemailtask.cpp crypto/signemailtask.h crypto/signencryptfilescontroller.cpp crypto/signencryptfilescontroller.h crypto/signencrypttask.cpp crypto/signencrypttask.h crypto/task.cpp crypto/task.h crypto/taskcollection.cpp crypto/taskcollection.h crypto/verifychecksumscontroller.cpp crypto/verifychecksumscontroller.h dialogs/adduseriddialog.cpp dialogs/adduseriddialog.h dialogs/certificatedetailsdialog.cpp dialogs/certificatedetailsdialog.h dialogs/certificatedetailsinputwidget.cpp dialogs/certificatedetailsinputwidget.h dialogs/certificatedetailswidget.cpp dialogs/certificatedetailswidget.h dialogs/certificateselectiondialog.cpp dialogs/certificateselectiondialog.h dialogs/certifycertificatedialog.cpp dialogs/certifycertificatedialog.h dialogs/certifywidget.cpp dialogs/certifywidget.h dialogs/choosecertificateprotocoldialog.cpp dialogs/choosecertificateprotocoldialog.h dialogs/createcsrforcardkeydialog.cpp dialogs/createcsrforcardkeydialog.h dialogs/deletecertificatesdialog.cpp dialogs/deletecertificatesdialog.h dialogs/editgroupdialog.cpp dialogs/editgroupdialog.h dialogs/expirydialog.cpp dialogs/expirydialog.h dialogs/exportdialog.cpp dialogs/exportdialog.h dialogs/gencardkeydialog.cpp dialogs/gencardkeydialog.h dialogs/groupdetailsdialog.cpp dialogs/groupdetailsdialog.h dialogs/lookupcertificatesdialog.cpp dialogs/lookupcertificatesdialog.h dialogs/nameandemailwidget.cpp dialogs/nameandemailwidget.h + dialogs/newopenpgpcertificatedetailsdialog.cpp + dialogs/newopenpgpcertificatedetailsdialog.h + dialogs/newopenpgpcertificateresultdialog.cpp + dialogs/newopenpgpcertificateresultdialog.h dialogs/ownertrustdialog.cpp dialogs/ownertrustdialog.h dialogs/pivcardapplicationadministrationkeyinputdialog.cpp dialogs/pivcardapplicationadministrationkeyinputdialog.h dialogs/revokecertificationdialog.cpp dialogs/revokecertificationdialog.h dialogs/revokecertificationwidget.cpp dialogs/revokecertificationwidget.h dialogs/revokekeydialog.cpp dialogs/revokekeydialog.h dialogs/selftestdialog.cpp dialogs/selftestdialog.h dialogs/setinitialpindialog.cpp dialogs/setinitialpindialog.h dialogs/subkeyswidget.cpp dialogs/subkeyswidget.h dialogs/trustchainwidget.cpp dialogs/trustchainwidget.h dialogs/updatenotification.cpp dialogs/updatenotification.h dialogs/weboftrustdialog.cpp dialogs/weboftrustdialog.h dialogs/weboftrustwidget.cpp dialogs/weboftrustwidget.h newcertificatewizard/advancedsettingsdialog.cpp newcertificatewizard/advancedsettingsdialog_p.h newcertificatewizard/enterdetailspage.cpp newcertificatewizard/enterdetailspage_p.h newcertificatewizard/keyalgo.cpp newcertificatewizard/keyalgo_p.h newcertificatewizard/keycreationpage.cpp newcertificatewizard/keycreationpage_p.h newcertificatewizard/listwidget.cpp newcertificatewizard/listwidget.h newcertificatewizard/newcertificatewizard.cpp newcertificatewizard/newcertificatewizard.h newcertificatewizard/resultpage.cpp newcertificatewizard/resultpage_p.h newcertificatewizard/wizardpage.cpp newcertificatewizard/wizardpage_p.h selftest/compliancecheck.cpp selftest/compliancecheck.h selftest/enginecheck.cpp selftest/enginecheck.h selftest/gpgagentcheck.cpp selftest/gpgagentcheck.h selftest/gpgconfcheck.cpp selftest/gpgconfcheck.h selftest/libkleopatrarccheck.cpp selftest/libkleopatrarccheck.h selftest/selftest.cpp selftest/selftest.h smartcard/card.cpp smartcard/card.h smartcard/deviceinfowatcher.cpp smartcard/deviceinfowatcher.h smartcard/keypairinfo.cpp smartcard/keypairinfo.h smartcard/netkeycard.cpp smartcard/netkeycard.h smartcard/openpgpcard.cpp smartcard/openpgpcard.h smartcard/p15card.cpp smartcard/p15card.h smartcard/pivcard.cpp smartcard/pivcard.h smartcard/readerstatus.cpp smartcard/readerstatus.h smartcard/utils.cpp smartcard/utils.h utils/accessibility.cpp utils/accessibility.h utils/action_data.cpp utils/action_data.h utils/archivedefinition.cpp utils/archivedefinition.h utils/auditlog.cpp utils/auditlog.h utils/clipboardmenu.cpp utils/clipboardmenu.h utils/dragqueen.cpp utils/dragqueen.h utils/email.cpp utils/email.h utils/emptypassphraseprovider.cpp utils/emptypassphraseprovider.h utils/filedialog.cpp utils/filedialog.h utils/gui-helper.cpp utils/gui-helper.h utils/headerview.cpp utils/headerview.h utils/input.cpp utils/input.h utils/iodevicelogger.cpp utils/iodevicelogger.h utils/kdpipeiodevice.cpp utils/kdpipeiodevice.h utils/keyparameters.cpp utils/keyparameters.h utils/keys.cpp utils/keys.h utils/kuniqueservice.cpp utils/kuniqueservice.h utils/log.cpp utils/log.h utils/multivalidator.cpp utils/multivalidator.h utils/output.cpp utils/output.h utils/path-helper.cpp utils/path-helper.h utils/scrollarea.cpp utils/scrollarea.h utils/systemtrayicon.cpp utils/systemtrayicon.h utils/tags.cpp utils/tags.h utils/types.cpp utils/types.h utils/userinfo.cpp utils/userinfo.h utils/validation.cpp utils/validation.h utils/writecertassuantransaction.cpp utils/writecertassuantransaction.h utils/wsastarter.cpp utils/wsastarter.h view/errorlabel.cpp view/errorlabel.h view/formtextinput.cpp view/formtextinput.h view/htmllabel.cpp view/htmllabel.h view/keycacheoverlay.cpp view/keycacheoverlay.h view/keylistcontroller.cpp view/keylistcontroller.h view/keytreeview.cpp view/keytreeview.h view/netkeywidget.cpp view/netkeywidget.h view/nullpinwidget.cpp view/nullpinwidget.h view/openpgpkeycardwidget.cpp view/openpgpkeycardwidget.h view/p15cardwidget.cpp view/p15cardwidget.h view/padwidget.cpp view/padwidget.h view/pgpcardwidget.cpp view/pgpcardwidget.h view/pivcardwidget.cpp view/pivcardwidget.h view/searchbar.cpp view/searchbar.h view/smartcardwidget.cpp view/smartcardwidget.h view/tabwidget.cpp view/tabwidget.h view/urllabel.cpp view/urllabel.h view/waitwidget.cpp view/waitwidget.h view/welcomewidget.cpp view/welcomewidget.h aboutdata.cpp aboutdata.h kleopatra.qrc kleopatraapplication.cpp kleopatraapplication.h main.cpp mainwindow.cpp mainwindow.h systrayicon.cpp systrayicon.h ) if(WIN32) configure_file (versioninfo.rc.in versioninfo.rc) set(_kleopatra_SRCS ${CMAKE_CURRENT_BINARY_DIR}/versioninfo.rc ${_kleopatra_SRCS}) endif() set (_kleopatra_SRCS conf/kleopageconfigdialog.cpp ${_kleopatra_SRCS}) ecm_qt_declare_logging_category(_kleopatra_SRCS HEADER kleopatra_debug.h IDENTIFIER KLEOPATRA_LOG CATEGORY_NAME org.kde.pim.kleopatra DESCRIPTION "kleopatra (kleopatra)" OLD_CATEGORY_NAMES log_kleopatra EXPORT KLEOPATRA ) if(KLEO_MODEL_TEST) add_definitions(-DKLEO_MODEL_TEST) set(_kleopatra_SRCS ${_kleopatra_SRCS} models/modeltest.cpp) endif() ki18n_wrap_ui(_kleopatra_SRCS dialogs/ownertrustdialog.ui dialogs/selectchecklevelwidget.ui dialogs/selftestdialog.ui dialogs/setinitialpindialog.ui dialogs/subkeyswidget.ui dialogs/trustchainwidget.ui newcertificatewizard/listwidget.ui ) kconfig_add_kcfg_files(_kleopatra_SRCS kcfg/emailoperationspreferences.kcfgc kcfg/fileoperationspreferences.kcfgc kcfg/settings.kcfgc kcfg/smimevalidationpreferences.kcfgc kcfg/tagspreferences.kcfgc kcfg/tooltippreferences.kcfgc ) file(GLOB ICONS_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/icons/*-apps-kleopatra.png") ecm_add_app_icon(_kleopatra_SRCS ICONS ${ICONS_SRCS}) add_executable(kleopatra_bin ${_kleopatra_SRCS} ${_kleopatra_uiserver_SRCS}) # For the ConfigureDialog & KCMs target_link_libraries(kleopatra_bin kcm_kleopatra_static) #if (COMPILE_WITH_UNITY_CMAKE_SUPPORT) # set_target_properties(kleopatra_bin PROPERTIES UNITY_BUILD ON) #endif() set_target_properties(kleopatra_bin PROPERTIES OUTPUT_NAME kleopatra) if (WIN32) set(_kleopatra_platform_libs "secur32") endif () target_link_libraries(kleopatra_bin Gpgmepp QGpgme ${_kleopatra_extra_libs} KF5::Libkleo KF5::Mime KF5::I18n KF5::XmlGui KF5::IconThemes KF5::WindowSystem KF5::CoreAddons KF5::ItemModels KF5::Crash ${_kleopatra_mail_libs} Qt${QT_MAJOR_VERSION}::Network Qt${QT_MAJOR_VERSION}::PrintSupport # Printing secret keys ${_kleopatra_uiserver_extra_libs} ${_kleopatra_dbusaddons_libs} kleopatraclientcore ${_kleopatra_platform_libs} ) install(TARGETS kleopatra_bin ${KDE_INSTALL_TARGETS_DEFAULT_ARGS}) install( PROGRAMS data/org.kde.kleopatra.desktop data/kleopatra_import.desktop DESTINATION ${KDE_INSTALL_APPDIR} ) install(FILES data/org.kde.kleopatra.appdata.xml DESTINATION ${KDE_INSTALL_METAINFODIR}) install( PROGRAMS data/kleopatra_signencryptfiles.desktop data/kleopatra_signencryptfolders.desktop data/kleopatra_decryptverifyfiles.desktop data/kleopatra_decryptverifyfolders.desktop DESTINATION ${KDE_INSTALL_DATADIR}/kio/servicemenus ) diff --git a/src/commands/newcertificatecommand.cpp b/src/commands/newcertificatecommand.cpp index 01a671fa3..f396c2ee9 100644 --- a/src/commands/newcertificatecommand.cpp +++ b/src/commands/newcertificatecommand.cpp @@ -1,172 +1,189 @@ /* -*- mode: c++; c-basic-offset:4 -*- commands/newcertificatecommand.cpp This file is part of Kleopatra, the KDE keymanager SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB + SPDX-FileCopyrightText: 2022 g10 Code GmbH + SPDX-FileContributor: Ingo Klöcker SPDX-License-Identifier: GPL-2.0-or-later */ #include #include "newcertificatecommand.h" #include "command_p.h" +#include "newopenpgpcertificatecommand.h" #include "dialogs/choosecertificateprotocoldialog.h" #include "newcertificatewizard/newcertificatewizard.h" #include +#include using namespace Kleo; using namespace Kleo::Commands; using namespace GpgME; class NewCertificateCommand::Private : public Command::Private { friend class ::Kleo::Commands::NewCertificateCommand; NewCertificateCommand *q_func() const { return static_cast(q); } public: explicit Private(NewCertificateCommand *qq, KeyListController *c) : Command::Private{qq, c} { } void chooseProtocol(); void createCertificate(); private: void onProtocolChosen(); void slotDialogAccepted(); private: void ensureDialogCreated(); private: Protocol protocol = GpgME::UnknownProtocol; QPointer protocolDialog; QPointer dialog; }; NewCertificateCommand::Private *NewCertificateCommand::d_func() { return static_cast(d.get()); } const NewCertificateCommand::Private *NewCertificateCommand::d_func() const { return static_cast(d.get()); } #define d d_func() #define q q_func() void NewCertificateCommand::Private::chooseProtocol() { Q_ASSERT(protocol == GpgME::UnknownProtocol); Q_ASSERT(!protocolDialog); protocolDialog = new ChooseCertificateProtocolDialog; applyWindowID(protocolDialog); connect(protocolDialog, &QDialog::accepted, q, [this]() { onProtocolChosen(); }); connect(protocolDialog, &QDialog::rejected, q, [this]() { canceled(); protocolDialog->deleteLater(); }); protocolDialog->show(); } void NewCertificateCommand::Private::onProtocolChosen() { protocol = protocolDialog->protocol(); protocolDialog->deleteLater(); - createCertificate(); + if (protocol == GpgME::OpenPGP) { + auto cmd = new NewOpenPGPCertificateCommand{view(), controller()}; + if (parentWidgetOrView() != view()) { + cmd->setParentWidget(parentWidgetOrView()); + } + cmd->setParentWId(parentWId()); + connect(cmd, &NewOpenPGPCertificateCommand::finished, + q, [this]() { finished(); }); + connect(cmd, &NewOpenPGPCertificateCommand::canceled, + q, [this]() { canceled(); }); + cmd->start(); + } else { + createCertificate(); + } } void Kleo::Commands::NewCertificateCommand::Private::createCertificate() { Q_ASSERT(protocol != GpgME::UnknownProtocol); Q_ASSERT(!dialog); dialog = new NewCertificateWizard; applyWindowID(dialog); dialog->setAttribute(Qt::WA_DeleteOnClose); connect(dialog, &QDialog::accepted, q, [this]() { slotDialogAccepted(); }); connect(dialog, &QDialog::rejected, q, [this]() { canceled(); }); dialog->setProtocol(protocol); dialog->show(); } void NewCertificateCommand::Private::slotDialogAccepted() { finished(); } NewCertificateCommand::NewCertificateCommand() : Command(new Private(this, nullptr)) { } NewCertificateCommand::NewCertificateCommand(KeyListController *c) : Command(new Private(this, c)) { } NewCertificateCommand::NewCertificateCommand(QAbstractItemView *v, KeyListController *c) : Command(v, new Private(this, c)) { } NewCertificateCommand::~NewCertificateCommand() = default; void NewCertificateCommand::setProtocol(Protocol proto) { d->protocol = proto; } Protocol NewCertificateCommand::protocol() const { return d->protocol; } void NewCertificateCommand::doStart() { const Kleo::Settings settings{}; const auto cmsAllowed = settings.cmsEnabled() && settings.cmsCertificateCreationAllowed(); if (d->protocol == UnknownProtocol && !cmsAllowed) { d->protocol = GpgME::OpenPGP; } if (d->protocol == UnknownProtocol) { d->chooseProtocol(); } else { d->createCertificate(); } } void NewCertificateCommand::doCancel() { if (d->dialog) { d->dialog->close(); } } #undef d #undef q #include "moc_newcertificatecommand.cpp" diff --git a/src/commands/newopenpgpcertificatecommand.cpp b/src/commands/newopenpgpcertificatecommand.cpp new file mode 100644 index 000000000..9ec42ebff --- /dev/null +++ b/src/commands/newopenpgpcertificatecommand.cpp @@ -0,0 +1,301 @@ +/* -*- mode: c++; c-basic-offset:4 -*- + commands/newopenpgpcertificatecommand.cpp + + This file is part of Kleopatra, the KDE keymanager + SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB + SPDX-FileCopyrightText: 2022 g10 Code GmbH + SPDX-FileContributor: Ingo Klöcker + + SPDX-License-Identifier: GPL-2.0-or-later +*/ + +#include + +#include "newopenpgpcertificatecommand.h" + +#include "command_p.h" + +#include "commands/detailscommand.h" +#include "dialogs/newopenpgpcertificatedetailsdialog.h" +#include "dialogs/newopenpgpcertificateresultdialog.h" +#include "utils/emptypassphraseprovider.h" +#include "utils/keyparameters.h" +#include "utils/userinfo.h" + +#include + +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include + +#include + +#include +#include + +#include + +using namespace Kleo; +using namespace GpgME; + +class NewOpenPGPCertificateCommand::Private : public Command::Private +{ + friend class ::Kleo::NewOpenPGPCertificateCommand; + NewOpenPGPCertificateCommand *q_func() const + { + return static_cast(q); + } + +public: + explicit Private(NewOpenPGPCertificateCommand *qq, KeyListController *c) + : Command::Private{qq, c} + { + } + + void getCertificateDetails(); + void createCertificate(); + void showResult(const KeyGenerationResult &result); + void showResultDialog(const KeyGenerationResult &result, const Key &key); + void showErrorDialog(const KeyGenerationResult &result); + +private: + KeyParameters keyParameters; + bool protectKeyWithPassword = false; + EmptyPassphraseProvider emptyPassphraseProvider; + QPointer detailsDialog; + QPointer job; + QPointer progressDialog; + QPointer resultDialog; +}; + +NewOpenPGPCertificateCommand::Private *NewOpenPGPCertificateCommand::d_func() +{ + return static_cast(d.get()); +} +const NewOpenPGPCertificateCommand::Private *NewOpenPGPCertificateCommand::d_func() const +{ + return static_cast(d.get()); +} + +#define d d_func() +#define q q_func() + +void NewOpenPGPCertificateCommand::Private::getCertificateDetails() +{ + detailsDialog = new NewOpenPGPCertificateDetailsDialog; + detailsDialog->setAttribute(Qt::WA_DeleteOnClose); + applyWindowID(detailsDialog); + + if (keyParameters.protocol() == KeyParameters::NoProtocol) { + const auto settings = Kleo::Settings{}; + const KConfigGroup config{KSharedConfig::openConfig(), "CertificateCreationWizard"}; + // prefer the last used name and email address over the values retrieved from the system + detailsDialog->setName(config.readEntry("NAME", QString{})); + if (detailsDialog->name().isEmpty() && settings.prefillName()) { + detailsDialog->setName(userFullName()); + } + detailsDialog->setEmail(config.readEntry("EMAIL", QString{})); + if (detailsDialog->email().isEmpty() && settings.prefillEmail()) { + detailsDialog->setEmail(userEmailAddress()); + } + } else { + detailsDialog->setKeyParameters(keyParameters); + detailsDialog->setProtectKeyWithPassword(protectKeyWithPassword); + } + + connect(detailsDialog, &QDialog::accepted, q, [this]() { + keyParameters = detailsDialog->keyParameters(); + protectKeyWithPassword = detailsDialog->protectKeyWithPassword(); + QMetaObject::invokeMethod( + q, + [this] { + createCertificate(); + }, + Qt::QueuedConnection); + }); + connect(detailsDialog, &QDialog::rejected, q, [this]() { + canceled(); + }); + + detailsDialog->show(); +} + +void NewOpenPGPCertificateCommand::Private::createCertificate() +{ + Q_ASSERT(keyParameters.protocol() == KeyParameters::OpenPGP); + + auto keyGenJob = QGpgME::openpgp()->keyGenerationJob(); + if (!keyGenJob) { + finished(); + return; + } + if (!protectKeyWithPassword) { + auto ctx = QGpgME::Job::context(keyGenJob); + ctx->setPassphraseProvider(&emptyPassphraseProvider); + ctx->setPinentryMode(Context::PinentryLoopback); + } + connect(keyGenJob, &QGpgME::KeyGenerationJob::result, q, [this](const KeyGenerationResult &result) { + QMetaObject::invokeMethod( + q, + [this, result] { + showResult(result); + }, + Qt::QueuedConnection); + }); + if (const Error err = keyGenJob->start(keyParameters.toString())) { + error(i18n("Could not start key pair creation: %1", QString::fromUtf8(err.asString()))); + finished(); + return; + } else { + job = keyGenJob; + } + progressDialog = new QProgressDialog; + progressDialog->setAttribute(Qt::WA_DeleteOnClose); + applyWindowID(progressDialog); + progressDialog->setModal(true); + progressDialog->setWindowTitle(i18nc("@title", "Creating Key Pair...")); + progressDialog->setLabelText(i18n("The process of creating a key requires large amounts of random numbers. This may require several minutes...")); + progressDialog->setRange(0, 0); + connect(progressDialog, &QProgressDialog::canceled, job, &QGpgME::Job::slotCancel); + connect(job, &QGpgME::Job::done, q, [this]() { + if (progressDialog) { + progressDialog->accept(); + } + }); + progressDialog->show(); +} + +void NewOpenPGPCertificateCommand::Private::showResult(const KeyGenerationResult &result) +{ + if (result.error().isCanceled()) { + finished(); + return; + } + + // Ensure that we have the key in the cache + Key key; + if (!result.error().code() && result.fingerprint()) { + std::unique_ptr ctx{Context::createForProtocol(OpenPGP)}; + if (ctx) { + Error err; + key = ctx->key(result.fingerprint(), err, /*secret=*/true); + if (!key.isNull()) { + KeyCache::mutableInstance()->insert(key); + } + } + } + + const KConfigGroup config(KSharedConfig::openConfig(), "CertificateCreationWizard"); + if (config.readEntry("SkipResultPage", false)) { + if (!key.isNull()) { + auto cmd = new Commands::DetailsCommand(key, view(), controller()); + cmd->setParentWidget(parentWidgetOrView()); + cmd->setParentWId(parentWId()); + cmd->start(); + } + finished(); + return; + } + + if (!key.isNull()) { + showResultDialog(result, key); + } else { + showErrorDialog(result); + } +} + +void NewOpenPGPCertificateCommand::Private::showResultDialog(const KeyGenerationResult &result, const Key &key) +{ + resultDialog = new NewOpenPGPCertificateResultDialog{result, key}; + resultDialog->setAttribute(Qt::WA_DeleteOnClose); + applyWindowID(resultDialog); + + connect(resultDialog, &NewOpenPGPCertificateResultDialog::retry, q, [this]() { + QMetaObject::invokeMethod( + q, + [this]() { + getCertificateDetails(); + }, + Qt::QueuedConnection); + }); + connect(resultDialog, &QDialog::accepted, q, [this]() { + finished(); + }); + connect(resultDialog, &QDialog::rejected, q, [this]() { + finished(); + }); + + resultDialog->show(); +} + +void NewOpenPGPCertificateCommand::Private::showErrorDialog(const KeyGenerationResult &result) +{ + QString text; + if (result.error() || !result.fingerprint()) { + text = xi18n( + "The creation of a new OpenPGP certificate failed." + "Error: %1", + QString::fromLocal8Bit(result.error().asString())); + } else { + // no error and we have a fingerprint, but there was no corresponding key in the key ring + text = xi18n( + "A new OpenPGP certificate was created successfully, but it has not been found in the key ring." + "Fingerprint of the new certificate:%1", + Formatting::prettyID(result.fingerprint())); + } + + auto dialog = new QDialog; + applyWindowID(dialog); + dialog->setWindowTitle(i18nc("@title:window", "Error")); + auto buttonBox = new QDialogButtonBox{QDialogButtonBox::Retry | QDialogButtonBox::Ok, dialog}; + const auto buttonCode = KMessageBox::createKMessageBox(dialog, buttonBox, QMessageBox::Critical, text, {}, {}, nullptr, {}); + if (buttonCode == QDialogButtonBox::Retry) { + QMetaObject::invokeMethod( + q, + [this]() { + getCertificateDetails(); + }, + Qt::QueuedConnection); + } else { + finished(); + } +} + +NewOpenPGPCertificateCommand::NewOpenPGPCertificateCommand(QAbstractItemView *v, KeyListController *c) + : Command(v, new Private(this, c)) +{ +} + +NewOpenPGPCertificateCommand::~NewOpenPGPCertificateCommand() = default; + +void NewOpenPGPCertificateCommand::doStart() +{ + d->getCertificateDetails(); +} + +void NewOpenPGPCertificateCommand::doCancel() +{ + if (d->detailsDialog) { + d->detailsDialog->close(); + } + if (d->resultDialog) { + d->resultDialog->close(); + } + if (d->job) { + d->job->slotCancel(); + } +} + +#undef d +#undef q + +#include "moc_newopenpgpcertificatecommand.cpp" diff --git a/src/commands/newopenpgpcertificatecommand.h b/src/commands/newopenpgpcertificatecommand.h new file mode 100644 index 000000000..529adb612 --- /dev/null +++ b/src/commands/newopenpgpcertificatecommand.h @@ -0,0 +1,36 @@ +/* -*- mode: c++; c-basic-offset:4 -*- + commands/newopenpgpcertificatecommand.h + + This file is part of Kleopatra, the KDE keymanager + SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB + SPDX-FileCopyrightText: 2022 g10 Code GmbH + SPDX-FileContributor: Ingo Klöcker + + SPDX-License-Identifier: GPL-2.0-or-later +*/ + +#pragma once + +#include "command.h" + +namespace Kleo +{ + +class NewOpenPGPCertificateCommand : public Command +{ + Q_OBJECT +public: + NewOpenPGPCertificateCommand(QAbstractItemView *view, KeyListController *parent); + ~NewOpenPGPCertificateCommand() override; + +private: + void doStart() override; + void doCancel() override; + +private: + class Private; + inline Private *d_func(); + inline const Private *d_func() const; +}; + +} diff --git a/src/dialogs/newopenpgpcertificatedetailsdialog.cpp b/src/dialogs/newopenpgpcertificatedetailsdialog.cpp new file mode 100644 index 000000000..4c7f7f4fc --- /dev/null +++ b/src/dialogs/newopenpgpcertificatedetailsdialog.cpp @@ -0,0 +1,324 @@ +/* -*- mode: c++; c-basic-offset:4 -*- + dialogs/newopenpgpcertificatedetailsdialog.cpp + + This file is part of Kleopatra, the KDE keymanager + SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB + SPDX-FileCopyrightText: 2022 g10 Code GmbH + SPDX-FileContributor: Ingo Klöcker + + SPDX-License-Identifier: GPL-2.0-or-later +*/ + +#include + +#include "newopenpgpcertificatedetailsdialog.h" + +#include "nameandemailwidget.h" + +#include "newcertificatewizard/advancedsettingsdialog_p.h" +#include "newcertificatewizard/keyalgo_p.h" +#include "utils/keyparameters.h" +#include "utils/keyusage.h" +#include "utils/scrollarea.h" + +#include + +#include + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include + +#include "kleopatra_debug.h" + +using namespace Kleo; +using namespace Kleo::NewCertificateUi; + +class NewOpenPGPCertificateDetailsDialog::Private +{ + friend class ::Kleo::NewOpenPGPCertificateDetailsDialog; + NewOpenPGPCertificateDetailsDialog *const q; + + struct UI { + QLabel *infoLabel; + ScrollArea *scrollArea; + NameAndEmailWidget *nameAndEmail; + QCheckBox *withPassCheckBox; + QPushButton *advancedButton; + QDialogButtonBox *buttonBox; + + UI(QWidget *dialog) + { + auto mainLayout = new QVBoxLayout{dialog}; + + infoLabel = new QLabel{dialog}; + infoLabel->setWordWrap(true); + mainLayout->addWidget(infoLabel); + + mainLayout->addWidget(new KSeparator{Qt::Horizontal, dialog}); + + scrollArea = new ScrollArea{dialog}; + scrollArea->setFocusPolicy(Qt::NoFocus); + scrollArea->setFrameStyle(QFrame::NoFrame); + scrollArea->setBackgroundRole(dialog->backgroundRole()); + scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); + scrollArea->setSizeAdjustPolicy(QScrollArea::AdjustToContents); + auto scrollAreaLayout = qobject_cast(scrollArea->widget()->layout()); + scrollAreaLayout->setContentsMargins(0, 0, 0, 0); + + nameAndEmail = new NameAndEmailWidget{dialog}; + scrollAreaLayout->addWidget(nameAndEmail); + + withPassCheckBox = new QCheckBox{i18n("Protect the generated key with a passphrase."), dialog}; + withPassCheckBox->setToolTip( + i18n("Encrypts the secret key with an unrecoverable passphrase. You will be asked for the passphrase during key generation.")); + scrollAreaLayout->addWidget(withPassCheckBox); + + { + auto layout = new QHBoxLayout; + advancedButton = new QPushButton{i18n("Advanced Settings..."), dialog}; + advancedButton->setAutoDefault(false); + layout->addStretch(1); + layout->addWidget(advancedButton); + scrollAreaLayout->addLayout(layout); + } + + scrollAreaLayout->addStretch(1); + + mainLayout->addWidget(scrollArea); + + mainLayout->addWidget(new KSeparator{Qt::Horizontal, dialog}); + + buttonBox = new QDialogButtonBox{QDialogButtonBox::Ok | QDialogButtonBox::Cancel, dialog}; + + mainLayout->addWidget(buttonBox); + } + } ui; + +public: + explicit Private(NewOpenPGPCertificateDetailsDialog *qq) + : q{qq} + , ui{qq} + , advancedSettingsDlg{new AdvancedSettingsDialog{qq}} + , technicalParameters{KeyParameters::OpenPGP} + { + q->setWindowTitle(i18nc("title:window", "Create OpenPGP Certificate")); + + const KConfigGroup config{KSharedConfig::openConfig(), "CertificateCreationWizard"}; + const auto attrOrder = config.readEntry("OpenPGPAttributeOrder", QStringList{}); + const auto nameIsRequired = attrOrder.contains(QLatin1String{"NAME!"}, Qt::CaseInsensitive); + const auto emailIsRequired = attrOrder.contains(QLatin1String{"EMAIL!"}, Qt::CaseInsensitive); + + ui.infoLabel->setText(nameIsRequired || emailIsRequired // + ? i18n("Enter a name and an email address to use for the certificate.") + : i18n("Enter a name and/or an email address to use for the certificate.")); + + ui.nameAndEmail->setNameIsRequired(nameIsRequired); + ui.nameAndEmail->setNamePattern(config.readEntry("NAME_regex")); + ui.nameAndEmail->setEmailIsRequired(emailIsRequired); + ui.nameAndEmail->setEmailPattern(config.readEntry("EMAIL_regex")); + + Settings settings; + ui.advancedButton->setVisible(!settings.hideAdvanced()); + + const auto conf = QGpgME::cryptoConfig(); + const auto entry = getCryptoConfigEntry(conf, "gpg-agent", "enforce-passphrase-constraints"); + if (entry && entry->boolValue()) { + qCDebug(KLEOPATRA_LOG) << "Disabling passphrase check box because of agent config."; + ui.withPassCheckBox->setEnabled(false); + ui.withPassCheckBox->setChecked(true); + } else { + ui.withPassCheckBox->setChecked(config.readEntry("WithPassphrase", false)); + ui.withPassCheckBox->setEnabled(!config.isEntryImmutable("WithPassphrase")); + } + + advancedSettingsDlg->setProtocol(GpgME::OpenPGP); + updateTechnicalParameters(); // set key parameters to default values for OpenPGP + + connect(advancedSettingsDlg, &QDialog::accepted, q, [this]() { + updateTechnicalParameters(); + }); + connect(ui.advancedButton, &QPushButton::clicked, q, [this]() { + advancedSettingsDlg->open(); + }); + connect(ui.buttonBox, &QDialogButtonBox::accepted, q, [this]() { + checkAccept(); + }); + connect(ui.buttonBox, &QDialogButtonBox::rejected, q, &QDialog::reject); + } + +private: + KeyUsage keyUsage() const + { + KeyUsage usage; + if (advancedSettingsDlg->signingAllowed()) { + usage.setCanSign(true); + } + if (advancedSettingsDlg->encryptionAllowed() // + && !is_ecdh(advancedSettingsDlg->subkeyType()) && !is_dsa(advancedSettingsDlg->keyType()) && !is_rsa(advancedSettingsDlg->subkeyType())) { + usage.setCanEncrypt(true); + } + if (advancedSettingsDlg->authenticationAllowed()) { + usage.setCanAuthenticate(true); + } + if (advancedSettingsDlg->certificationAllowed()) { + usage.setCanCertify(true); + } + return usage; + } + + KeyUsage subkeyUsage() const + { + KeyUsage usage; + if (advancedSettingsDlg->encryptionAllowed() + && (is_dsa(advancedSettingsDlg->keyType()) || is_rsa(advancedSettingsDlg->subkeyType()) || is_ecdh(advancedSettingsDlg->subkeyType()))) { + Q_ASSERT(advancedSettingsDlg->subkeyType()); + usage.setCanEncrypt(true); + } + return usage; + } + + void updateTechnicalParameters() + { + technicalParameters = KeyParameters{KeyParameters::OpenPGP}; + + const auto keyType = advancedSettingsDlg->keyType(); + technicalParameters.setKeyType(keyType); + if (is_ecdsa(keyType) || is_eddsa(keyType)) { + technicalParameters.setKeyCurve(advancedSettingsDlg->keyCurve()); + } else if (const unsigned int strength = advancedSettingsDlg->keyStrength()) { + technicalParameters.setKeyLength(strength); + } + technicalParameters.setKeyUsage(keyUsage()); + + const auto subkeyType = advancedSettingsDlg->subkeyType(); + if (subkeyType) { + technicalParameters.setSubkeyType(subkeyType); + if (is_ecdh(subkeyType)) { + technicalParameters.setSubkeyCurve(advancedSettingsDlg->subkeyCurve()); + } else if (const unsigned int strength = advancedSettingsDlg->subkeyStrength()) { + technicalParameters.setSubkeyLength(strength); + } + technicalParameters.setSubkeyUsage(subkeyUsage()); + } + + if (advancedSettingsDlg->expiryDate().isValid()) { + technicalParameters.setExpirationDate(advancedSettingsDlg->expiryDate()); + } + // name and email are set later + } + + void setTechnicalParameters(const KeyParameters ¶meters) + { + advancedSettingsDlg->setKeyType(parameters.keyType()); + advancedSettingsDlg->setKeyStrength(parameters.keyLength()); + advancedSettingsDlg->setKeyCurve(parameters.keyCurve()); + advancedSettingsDlg->setSubkeyType(parameters.subkeyType()); + advancedSettingsDlg->setSubkeyStrength(parameters.subkeyLength()); + advancedSettingsDlg->setSubkeyCurve(parameters.subkeyCurve()); + advancedSettingsDlg->setSigningAllowed(parameters.keyUsage().canSign() || parameters.subkeyUsage().canSign()); + advancedSettingsDlg->setEncryptionAllowed(parameters.keyUsage().canEncrypt() || parameters.subkeyUsage().canEncrypt()); + advancedSettingsDlg->setCertificationAllowed(parameters.keyUsage().canCertify() || parameters.subkeyUsage().canCertify()); + advancedSettingsDlg->setAuthenticationAllowed(parameters.keyUsage().canAuthenticate() || parameters.subkeyUsage().canAuthenticate()); + advancedSettingsDlg->setExpiryDate(parameters.expirationDate()); + } + + void checkAccept() + { + QStringList errors; + if (ui.nameAndEmail->userID().isEmpty() && !ui.nameAndEmail->nameIsRequired() && !ui.nameAndEmail->emailIsRequired()) { + errors.push_back(i18n("Enter a name or an email address.")); + } + const auto nameError = ui.nameAndEmail->nameError(); + if (!nameError.isEmpty()) { + errors.push_back(nameError); + } + const auto emailError = ui.nameAndEmail->emailError(); + if (!emailError.isEmpty()) { + errors.push_back(emailError); + } + if (errors.size() > 1) { + KMessageBox::errorList(q, i18n("There is a problem."), errors); + } else if (!errors.empty()) { + KMessageBox::error(q, errors.first()); + } else { + q->accept(); + } + } + +private: + AdvancedSettingsDialog *const advancedSettingsDlg; + KeyParameters technicalParameters; +}; + +NewOpenPGPCertificateDetailsDialog::NewOpenPGPCertificateDetailsDialog(QWidget *parent, Qt::WindowFlags f) + : QDialog{parent, f} + , d(new Private{this}) +{ +} + +NewOpenPGPCertificateDetailsDialog::~NewOpenPGPCertificateDetailsDialog() = default; + +void NewOpenPGPCertificateDetailsDialog::setName(const QString &name) +{ + d->ui.nameAndEmail->setName(name); +} + +QString NewOpenPGPCertificateDetailsDialog::name() const +{ + return d->ui.nameAndEmail->name(); +} + +void NewOpenPGPCertificateDetailsDialog::setEmail(const QString &email) +{ + d->ui.nameAndEmail->setEmail(email); +} + +QString NewOpenPGPCertificateDetailsDialog::email() const +{ + return d->ui.nameAndEmail->email(); +} + +void Kleo::NewOpenPGPCertificateDetailsDialog::setKeyParameters(const Kleo::KeyParameters ¶meters) +{ + setName(parameters.name()); + const auto emails = parameters.emails(); + if (!emails.empty()) { + setEmail(emails.front()); + } + d->setTechnicalParameters(parameters); +} + +KeyParameters NewOpenPGPCertificateDetailsDialog::keyParameters() const +{ + // set name and email on a copy of the technical parameters + auto parameters = d->technicalParameters; + if (!name().isEmpty()) { + parameters.setName(name()); + } + if (!email().isEmpty()) { + parameters.setEmail(email()); + } + return parameters; +} + +void Kleo::NewOpenPGPCertificateDetailsDialog::setProtectKeyWithPassword(bool protectKey) +{ + d->ui.withPassCheckBox->setChecked(protectKey); +} + +bool NewOpenPGPCertificateDetailsDialog::protectKeyWithPassword() const +{ + return d->ui.withPassCheckBox->isChecked(); +} diff --git a/src/dialogs/newopenpgpcertificatedetailsdialog.h b/src/dialogs/newopenpgpcertificatedetailsdialog.h new file mode 100644 index 000000000..77d2f2221 --- /dev/null +++ b/src/dialogs/newopenpgpcertificatedetailsdialog.h @@ -0,0 +1,46 @@ +/* -*- mode: c++; c-basic-offset:4 -*- + dialogs/newopenpgpcertificatedetailsdialog.h + + This file is part of Kleopatra, the KDE keymanager + SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB + SPDX-FileCopyrightText: 2022 g10 Code GmbH + SPDX-FileContributor: Ingo Klöcker + + SPDX-License-Identifier: GPL-2.0-or-later +*/ + +#pragma once + +#include + +#include + +namespace Kleo +{ +class KeyParameters; + +class NewOpenPGPCertificateDetailsDialog : public QDialog +{ + Q_OBJECT +public: + explicit NewOpenPGPCertificateDetailsDialog(QWidget *parent = nullptr, Qt::WindowFlags f = {}); + ~NewOpenPGPCertificateDetailsDialog() override; + + void setName(const QString &name); + QString name() const; + + void setEmail(const QString &email); + QString email() const; + + void setKeyParameters(const KeyParameters ¶meters); + KeyParameters keyParameters() const; + + void setProtectKeyWithPassword(bool protectKey); + bool protectKeyWithPassword() const; + +private: + class Private; + const std::unique_ptr d; +}; + +} // namespace Kleo diff --git a/src/dialogs/newopenpgpcertificateresultdialog.cpp b/src/dialogs/newopenpgpcertificateresultdialog.cpp new file mode 100644 index 000000000..92bbacb52 --- /dev/null +++ b/src/dialogs/newopenpgpcertificateresultdialog.cpp @@ -0,0 +1,235 @@ +/* -*- mode: c++; c-basic-offset:4 -*- + dialogs/newopenpgpcertificateresultdialog.cpp + + This file is part of Kleopatra, the KDE keymanager + SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB + SPDX-FileCopyrightText: 2016, 2017 Bundesamt für Sicherheit in der Informationstechnik + SPDX-FileContributor: Intevation GmbH + SPDX-FileCopyrightText: 2022 g10 Code GmbH + SPDX-FileContributor: Ingo Klöcker + + SPDX-License-Identifier: GPL-2.0-or-later +*/ + +#include + +#include "newopenpgpcertificateresultdialog.h" + +#include "commands/exportcertificatecommand.h" +#include "commands/exportopenpgpcertstoservercommand.h" +#ifdef QGPGME_SUPPORTS_SECRET_KEY_EXPORT +#include "commands/exportsecretkeycommand.h" +#else +#include "commands/exportsecretkeycommand_old.h" +#endif +#include "utils/email.h" +#include "utils/scrollarea.h" + +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include + +#include + +using namespace Kleo; +using namespace Kleo::Commands; +using namespace GpgME; +#ifndef QGPGME_SUPPORTS_SECRET_KEY_EXPORT +using Kleo::Commands::Compat::ExportSecretKeyCommand; +#endif + +class NewOpenPGPCertificateResultDialog::Private +{ + friend class ::Kleo::NewOpenPGPCertificateResultDialog; + NewOpenPGPCertificateResultDialog *const q; + + struct UI { + QLabel *infoLabel = nullptr; + QPushButton *makeBackupPB = nullptr; + QPushButton *sendCertificateByEMailPB = nullptr; + QPushButton *uploadToKeyserverPB = nullptr; + QDialogButtonBox *buttonBox = nullptr; + + UI(QDialog *parent) + { + auto mainLayout = new QVBoxLayout{parent}; + + infoLabel = new QLabel{parent}; + infoLabel->setWordWrap(true); + mainLayout->addWidget(infoLabel); + + mainLayout->addWidget(new KSeparator{Qt::Horizontal, parent}); + + auto scrollArea = new ScrollArea{parent}; + scrollArea->setFocusPolicy(Qt::NoFocus); + scrollArea->setFrameStyle(QFrame::NoFrame); + scrollArea->setBackgroundRole(parent->backgroundRole()); + scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); + scrollArea->setSizeAdjustPolicy(QScrollArea::AdjustToContents); + auto scrollAreaLayout = qobject_cast(scrollArea->widget()->layout()); + scrollAreaLayout->setContentsMargins(0, 0, 0, 0); + + auto nextStepsGB = new QGroupBox{i18nc("@title:group", "Next Steps"), parent}; + nextStepsGB->setFlat(true); + auto nextStepsGBLayout = new QVBoxLayout{nextStepsGB}; + + makeBackupPB = new QPushButton{i18nc("@action:button", "Make a Backup Of Your Key Pair..."), nextStepsGB}; + nextStepsGBLayout->addWidget(makeBackupPB); + + sendCertificateByEMailPB = new QPushButton{i18nc("@action:button", "Send Public Key By EMail..."), nextStepsGB}; + nextStepsGBLayout->addWidget(sendCertificateByEMailPB); + + uploadToKeyserverPB = new QPushButton{i18nc("@action:button", "Upload Public Key To Directory Service..."), nextStepsGB}; + nextStepsGBLayout->addWidget(uploadToKeyserverPB); + + scrollAreaLayout->addWidget(nextStepsGB); + + mainLayout->addWidget(scrollArea); + + mainLayout->addStretch(1); + + mainLayout->addWidget(new KSeparator{Qt::Horizontal, parent}); + + buttonBox = new QDialogButtonBox{QDialogButtonBox::Retry | QDialogButtonBox::Close, parent}; + buttonBox->button(QDialogButtonBox::Retry)->setAutoDefault(false); + buttonBox->button(QDialogButtonBox::Close)->setAutoDefault(false); + + mainLayout->addWidget(buttonBox); + } + } ui; + +public: + Private(const KeyGenerationResult &result, const Key &key, NewOpenPGPCertificateResultDialog *qq); + + void slotSendCertificateByEMail(); + void slotSendCertificateByEMailContinuation(); + void slotUploadCertificateToDirectoryServer(); + void slotBackupCertificate(); + +private: + KeyGenerationResult result; + Key key; + std::unique_ptr tmpDir; + QPointer exportCertificateCommand; +}; + +NewOpenPGPCertificateResultDialog::Private::Private(const KeyGenerationResult &result_, const Key &key_, NewOpenPGPCertificateResultDialog *qq) + : q{qq} + , ui{qq} + , result{result_} + , key{key_} +{ + if (key.protocol() != GpgME::OpenPGP) { + qCWarning(KLEOPATRA_LOG) << q << "Key has wrong protocol:" << key; + key = Key{}; + } + + q->setWindowTitle(i18nc("@title:window", "Success")); + + ui.infoLabel->setText( + xi18n("A new OpenPGP certificate was created successfully. Find some suggested next steps below." + "Fingerprint of the new certificate: %1", + Formatting::prettyID(key.primaryFingerprint()))); + + connect(ui.sendCertificateByEMailPB, &QPushButton::clicked, q, [this]() { + slotSendCertificateByEMail(); + }); + connect(ui.uploadToKeyserverPB, &QPushButton::clicked, q, [this]() { + slotUploadCertificateToDirectoryServer(); + }); + connect(ui.makeBackupPB, &QPushButton::clicked, q, [this]() { + slotBackupCertificate(); + }); + + // handle the Retry button + connect(ui.buttonBox, &QDialogButtonBox::accepted, q, [this]() { + Q_EMIT q->retry(); + q->done(-1); // neither Accepted nor Rejected + }); + // handle the Close button + connect(ui.buttonBox, &QDialogButtonBox::rejected, q, &QDialog::accept); +} + +void NewOpenPGPCertificateResultDialog::Private::slotSendCertificateByEMail() +{ + if (key.isNull() || exportCertificateCommand) { + return; + } + auto cmd = new ExportCertificateCommand{key}; + if (!tmpDir) { + tmpDir = std::make_unique(); + } + const QString filename = QString::fromLatin1(key.primaryFingerprint()) + QLatin1String(".asc"); + const QString filePath = QDir{tmpDir->path()}.absoluteFilePath(filename); + cmd->setOpenPGPFileName(filePath); + connect(cmd, &ExportCertificateCommand::finished, q, [this]() { + slotSendCertificateByEMailContinuation(); + }); + cmd->start(); + exportCertificateCommand = cmd; +} + +void NewOpenPGPCertificateResultDialog::Private::slotSendCertificateByEMailContinuation() +{ + if (!exportCertificateCommand) { + return; + } + // ### better error handling? + const QString filePath = exportCertificateCommand->openPGPFileName(); + qCDebug(KLEOPATRA_LOG) << __func__ << "filePath:" << filePath; + exportCertificateCommand = nullptr; + if (filePath.isEmpty()) { + return; + } + invokeMailer(i18n("My new public OpenPGP key"), i18n("Please find attached my new public OpenPGP key."), QFileInfo{filePath}); + KMessageBox::information(q, + xi18nc("@info", + "Kleopatra tried to send a mail via your default mail client." + "Some mail clients are known not to support attachments when invoked this way." + "If your mail client does not have an attachment, then attach the file %1 manually.", + filePath), + i18nc("@title:window", "Sending Mail"), + QStringLiteral("newcertificatewizard-openpgp-mailto-troubles")); +} + +void NewOpenPGPCertificateResultDialog::Private::slotUploadCertificateToDirectoryServer() +{ + if (key.isNull()) { + return; + } + (new ExportOpenPGPCertsToServerCommand{key})->start(); +} + +void NewOpenPGPCertificateResultDialog::Private::slotBackupCertificate() +{ + if (key.isNull()) { + return; + } + (new ExportSecretKeyCommand{key})->start(); +} + +NewOpenPGPCertificateResultDialog::NewOpenPGPCertificateResultDialog(const GpgME::KeyGenerationResult &result, + const GpgME::Key &key, + QWidget *parent, + Qt::WindowFlags f) + : QDialog{parent, f} + , d{new Private{result, key, this}} +{ + Q_ASSERT(!result.error().code() && result.fingerprint() && !key.isNull() && (key.protocol() == GpgME::OpenPGP) + && !qstrcmp(result.fingerprint(), key.primaryFingerprint())); +} + +NewOpenPGPCertificateResultDialog::~NewOpenPGPCertificateResultDialog() = default; diff --git a/src/dialogs/newopenpgpcertificateresultdialog.h b/src/dialogs/newopenpgpcertificateresultdialog.h new file mode 100644 index 000000000..8e2574f91 --- /dev/null +++ b/src/dialogs/newopenpgpcertificateresultdialog.h @@ -0,0 +1,48 @@ +/* -*- mode: c++; c-basic-offset:4 -*- + dialogs/newopenpgpcertificateresultdialog.h + + This file is part of Kleopatra, the KDE keymanager + SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB + SPDX-FileCopyrightText: 2016, 2017 Bundesamt für Sicherheit in der Informationstechnik + SPDX-FileContributor: Intevation GmbH + SPDX-FileCopyrightText: 2022 g10 Code GmbH + SPDX-FileContributor: Ingo Klöcker + + SPDX-License-Identifier: GPL-2.0-or-later +*/ + +#pragma once + +#include + +#include + +namespace GpgME +{ +class Key; +class KeyGenerationResult; +} + +namespace Kleo +{ +class KeyParameters; + +class NewOpenPGPCertificateResultDialog : public QDialog +{ + Q_OBJECT +public: + explicit NewOpenPGPCertificateResultDialog(const GpgME::KeyGenerationResult &result, + const GpgME::Key &key, + QWidget *parent = nullptr, + Qt::WindowFlags f = {}); + ~NewOpenPGPCertificateResultDialog() override; + +Q_SIGNALS: + void retry(); + +private: + class Private; + const std::unique_ptr d; +}; + +}