diff --git a/src/commands/signclipboardcommand.cpp b/src/commands/signclipboardcommand.cpp
index 3fe3e8c15..adebbf210 100644
--- a/src/commands/signclipboardcommand.cpp
+++ b/src/commands/signclipboardcommand.cpp
@@ -1,187 +1,179 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/signclipboardcommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "signclipboardcommand.h"
 
 #ifndef QT_NO_CLIPBOARD
 
 #include "command_p.h"
 
 #include <crypto/signemailcontroller.h>
 
 #include <utils/input.h>
 #include <utils/output.h>
 
-#include <Libkleo/Algorithm>
-#include <Libkleo/KeyCache>
 #include <Libkleo/Stl_Util>
 
 #include <KLocalizedString>
 #include "kleopatra_debug.h"
 
 #include <QApplication>
 #include <QClipboard>
 #include <QMimeData>
 
-#include <gpgme++/key.h>
-
 #include <exception>
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace Kleo::Crypto;
 
 class SignClipboardCommand::Private : public Command::Private
 {
     friend class ::Kleo::Commands::SignClipboardCommand;
     SignClipboardCommand *q_func() const
     {
         return static_cast<SignClipboardCommand *>(q);
     }
 public:
     explicit Private(SignClipboardCommand *qq, KeyListController *c);
     ~Private() override;
 
     void init();
 
 private:
     void slotSignersResolved();
     void slotControllerDone()
     {
         finished();
     }
     void slotControllerError(int, const QString &)
     {
         finished();
     }
 
 private:
     std::shared_ptr<const ExecutionContext> shared_qq;
     std::shared_ptr<Input> input;
     SignEMailController controller;
 };
 
 SignClipboardCommand::Private *SignClipboardCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const SignClipboardCommand::Private *SignClipboardCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define d d_func()
 #define q q_func()
 
 SignClipboardCommand::Private::Private(SignClipboardCommand *qq, KeyListController *c)
     : Command::Private(qq, c),
       shared_qq(qq, [](SignClipboardCommand*){}),
       input(),
       controller(SignEMailController::ClipboardMode)
 {
 
 }
 
 SignClipboardCommand::Private::~Private()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 SignClipboardCommand::SignClipboardCommand(GpgME::Protocol protocol, KeyListController *c)
     : Command(new Private(this, c))
 {
     d->init();
     d->controller.setProtocol(protocol);
 }
 
 SignClipboardCommand::SignClipboardCommand(GpgME::Protocol protocol, QAbstractItemView *v, KeyListController *c)
     : Command(v, new Private(this, c))
 {
     d->init();
     d->controller.setProtocol(protocol);
 }
 
 void SignClipboardCommand::Private::init()
 {
     controller.setExecutionContext(shared_qq);
     controller.setDetachedSignature(false);
     connect(&controller, SIGNAL(done()), q, SLOT(slotControllerDone()));
     connect(&controller, SIGNAL(error(int,QString)), q, SLOT(slotControllerError(int,QString)));
 }
 
 SignClipboardCommand::~SignClipboardCommand()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 // static
-bool SignClipboardCommand::canSignCurrentClipboard(GpgME::Protocol protocol)
+bool SignClipboardCommand::canSignCurrentClipboard()
 {
     bool canSign = false;
     if (const QClipboard *const clip = QApplication::clipboard()) {
         if (const QMimeData *const mime = clip->mimeData()) {
             canSign = mime->hasText();
         }
     }
-    if (canSign) {
-        canSign &= Kleo::any_of(KeyCache::instance()->secretKeys(),
-                                [](const auto &k) { return k.hasSecret(); });
-    }
     return canSign;
 }
 
 void SignClipboardCommand::doStart()
 {
 
     try {
 
         // snapshot clipboard content here, in case it's being changed...
         d->input = Input::createFromClipboard();
 
         connect(&d->controller, SIGNAL(signersResolved()),
                 this, SLOT(slotSignersResolved()));
 
         d->controller.startResolveSigners();
 
     } catch (const std::exception &e) {
         d->information(i18n("An error occurred: %1",
                             QString::fromLocal8Bit(e.what())),
                        i18n("Sign Clipboard Error"));
         d->finished();
     }
 }
 
 void SignClipboardCommand::Private::slotSignersResolved()
 {
     try {
         controller.setInputAndOutput(input, Output::createFromClipboard());
         input.reset(); // no longer needed, so don't keep a reference
         controller.start();
     } catch (const std::exception &e) {
         information(i18n("An error occurred: %1",
                          QString::fromLocal8Bit(e.what())),
                     i18n("Sign Clipboard Error"));
         finished();
     }
 }
 
 void SignClipboardCommand::doCancel()
 {
     qCDebug(KLEOPATRA_LOG);
     d->controller.cancel();
 }
 
 #undef d
 #undef q
 
 #include "moc_signclipboardcommand.cpp"
 
 #endif // QT_NO_CLIPBOARD
diff --git a/src/commands/signclipboardcommand.h b/src/commands/signclipboardcommand.h
index e7dbbf06f..e6aafdb5e 100644
--- a/src/commands/signclipboardcommand.h
+++ b/src/commands/signclipboardcommand.h
@@ -1,52 +1,52 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/signclipboardcommand.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
 #include <commands/command.h>
 
 #ifndef QT_NO_CLIPBOARD
 
 #include <utils/types.h>
 
 #include <gpgme++/global.h>
 
 namespace Kleo
 {
 namespace Commands
 {
 
 class SignClipboardCommand : public Command
 {
     Q_OBJECT
 public:
     explicit SignClipboardCommand(GpgME::Protocol protocol, QAbstractItemView *view, KeyListController *parent);
     explicit SignClipboardCommand(GpgME::Protocol protocol, KeyListController *parent);
     ~SignClipboardCommand() override;
 
-    static bool canSignCurrentClipboard(GpgME::Protocol protocol);
+    static bool canSignCurrentClipboard();
 
 private:
     void doStart() override;
     void doCancel() override;
 
 private:
     class Private;
     inline Private *d_func();
     inline const Private *d_func() const;
     Q_PRIVATE_SLOT(d_func(), void slotSignersResolved())
     Q_PRIVATE_SLOT(d_func(), void slotControllerDone())
     Q_PRIVATE_SLOT(d_func(), void slotControllerError(int, QString))
 };
 
 }
 }
 
 #endif // QT_NO_CLIPBOARD
 
diff --git a/src/utils/clipboardmenu.cpp b/src/utils/clipboardmenu.cpp
index 4cfb21698..734221fd8 100644
--- a/src/utils/clipboardmenu.cpp
+++ b/src/utils/clipboardmenu.cpp
@@ -1,123 +1,144 @@
 /*
   SPDX-FileCopyrightText: 2014-2021 Laurent Montel <montel@kde.org>
 
   SPDX-License-Identifier: GPL-2.0-only
 */
 
 #include "clipboardmenu.h"
 
 #include "kdtoolsglobal.h"
 #include "mainwindow.h"
 
 #include <settings.h>
 
 #include <commands/importcertificatefromclipboardcommand.h>
 #include <commands/encryptclipboardcommand.h>
 #include <commands/signclipboardcommand.h>
 #include <commands/decryptverifyclipboardcommand.h>
 
+#include <Libkleo/Algorithm>
+#include <Libkleo/KeyCache>
+
 #include <KLocalizedString>
 #include <KActionMenu>
 
 #include <QAction>
 #include <QApplication>
 #include <QClipboard>
 #include <QSignalBlocker>
 
+#include <gpgme++/key.h>
+
 using namespace Kleo;
 
 using namespace Kleo::Commands;
 
 ClipboardMenu::ClipboardMenu(QObject *parent)
     : QObject{parent}
 {
     mClipboardMenu = new KActionMenu(i18n("Clipboard"), this);
     mImportClipboardAction = new QAction(i18n("Certificate Import"), this);
     mEncryptClipboardAction = new QAction(i18n("Encrypt..."), this);
     const Kleo::Settings settings{};
     if (settings.cmsEnabled() && settings.cmsSigningAllowed()) {
         mSmimeSignClipboardAction = new QAction(i18n("S/MIME-Sign..."), this);
     }
     mOpenPGPSignClipboardAction = new QAction(i18n("OpenPGP-Sign..."), this);
     mDecryptVerifyClipboardAction = new QAction(i18n("Decrypt/Verify..."), this);
 
     KDAB_SET_OBJECT_NAME(mClipboardMenu);
     KDAB_SET_OBJECT_NAME(mImportClipboardAction);
     KDAB_SET_OBJECT_NAME(mEncryptClipboardAction);
     KDAB_SET_OBJECT_NAME(mSmimeSignClipboardAction);
     KDAB_SET_OBJECT_NAME(mOpenPGPSignClipboardAction);
     KDAB_SET_OBJECT_NAME(mDecryptVerifyClipboardAction);
 
     connect(mImportClipboardAction, &QAction::triggered, this, &ClipboardMenu::slotImportClipboard);
     connect(mEncryptClipboardAction, &QAction::triggered, this, &ClipboardMenu::slotEncryptClipboard);
     if (mSmimeSignClipboardAction) {
         connect(mSmimeSignClipboardAction, &QAction::triggered, this, &ClipboardMenu::slotSMIMESignClipboard);
     }
     connect(mOpenPGPSignClipboardAction, &QAction::triggered, this, &ClipboardMenu::slotOpenPGPSignClipboard);
     connect(mDecryptVerifyClipboardAction, &QAction::triggered, this, &ClipboardMenu::slotDecryptVerifyClipboard);
     mClipboardMenu->addAction(mImportClipboardAction);
     mClipboardMenu->addAction(mEncryptClipboardAction);
     if (mSmimeSignClipboardAction) {
         mClipboardMenu->addAction(mSmimeSignClipboardAction);
     }
     mClipboardMenu->addAction(mOpenPGPSignClipboardAction);
     mClipboardMenu->addAction(mDecryptVerifyClipboardAction);
     connect(QApplication::clipboard(), &QClipboard::changed, this, &ClipboardMenu::slotEnableDisableActions);
+    connect(KeyCache::instance().get(), &KeyCache::keyListingDone, this, &ClipboardMenu::slotEnableDisableActions);
     slotEnableDisableActions();
 }
 
 ClipboardMenu::~ClipboardMenu() = default;
 
 void ClipboardMenu::setMainWindow(MainWindow *window)
 {
     mWindow = window;
 }
 
 KActionMenu *ClipboardMenu::clipboardMenu() const
 {
     return mClipboardMenu;
 }
 
 void ClipboardMenu::startCommand(Command *cmd)
 {
     Q_ASSERT(cmd);
     cmd->setParent(mWindow);
     cmd->start();
 }
 
 void ClipboardMenu::slotImportClipboard()
 {
     startCommand(new ImportCertificateFromClipboardCommand(nullptr));
 }
 
 void ClipboardMenu::slotEncryptClipboard()
 {
     startCommand(new EncryptClipboardCommand(nullptr));
 }
 
 void ClipboardMenu::slotOpenPGPSignClipboard()
 {
     startCommand(new SignClipboardCommand(GpgME::OpenPGP, nullptr));
 }
 
 void ClipboardMenu::slotSMIMESignClipboard()
 {
     startCommand(new SignClipboardCommand(GpgME::CMS, nullptr));
 }
 
 void ClipboardMenu::slotDecryptVerifyClipboard()
 {
     startCommand(new DecryptVerifyClipboardCommand(nullptr));
 }
 
+namespace
+{
+
+bool hasSigningKeys(GpgME::Protocol protocol) {
+    if (!KeyCache::instance()->initialized()) {
+        return false;
+    }
+    return Kleo::any_of(KeyCache::instance()->keys(),
+                        [protocol](const auto &k) {
+                            return k.hasSecret() && k.canReallySign() && (k.protocol() == protocol);
+                        });
+}
+
+}
+
 void ClipboardMenu::slotEnableDisableActions()
 {
     const QSignalBlocker blocker(QApplication::clipboard());
     mImportClipboardAction->setEnabled(ImportCertificateFromClipboardCommand::canImportCurrentClipboard());
     mEncryptClipboardAction->setEnabled(EncryptClipboardCommand::canEncryptCurrentClipboard());
-    mOpenPGPSignClipboardAction->setEnabled(SignClipboardCommand::canSignCurrentClipboard(GpgME::OpenPGP));
+    mOpenPGPSignClipboardAction->setEnabled(SignClipboardCommand::canSignCurrentClipboard() && hasSigningKeys(GpgME::OpenPGP));
     if (mSmimeSignClipboardAction) {
-        mSmimeSignClipboardAction->setEnabled(SignClipboardCommand::canSignCurrentClipboard(GpgME::CMS));
+        mSmimeSignClipboardAction->setEnabled(SignClipboardCommand::canSignCurrentClipboard() && hasSigningKeys(GpgME::CMS));
     }
     mDecryptVerifyClipboardAction->setEnabled(DecryptVerifyClipboardCommand::canDecryptVerifyCurrentClipboard());
 }