diff --git a/src/smartcard/card.cpp b/src/smartcard/card.cpp
index 77fa53cd9..91aa62250 100644
--- a/src/smartcard/card.cpp
+++ b/src/smartcard/card.cpp
@@ -1,343 +1,348 @@
 /*  smartcard/card.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2017 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "card.h"
 
 #include "readerstatus.h"
 
 #include "kleopatra_debug.h"
 
 using namespace Kleo;
 using namespace Kleo::SmartCard;
 
 namespace {
 static QString formatVersion(int value)
 {
     if (value < 0) {
         return QString();
     }
 
     const unsigned int a = ((value >> 24) & 0xff);
     const unsigned int b = ((value >> 16) & 0xff);
     const unsigned int c = ((value >>  8) & 0xff);
     const unsigned int d = ((value      ) & 0xff);
     if (a) {
         return QStringLiteral("%1.%2.%3.%4").arg(QString::number(a), QString::number(b), QString::number(c), QString::number(d));
     } else if (b) {
         return QStringLiteral("%1.%2.%3").arg(QString::number(b), QString::number(c), QString::number(d));
     } else if (c) {
         return QStringLiteral("%1.%2").arg(QString::number(c), QString::number(d));
     }
     return QString::number(d);
 }
 }
 
 Card::Card()
 {
 }
 
 Card::~Card()
 {
 }
 
 void Card::setStatus(Status s)
 {
     mStatus = s;
 }
 
 Card::Status Card::status() const
 {
     return mStatus;
 }
 
 void Card::setSerialNumber(const std::string &sn)
 {
     mSerialNumber = sn;
 }
 
 std::string Card::serialNumber() const
 {
     return mSerialNumber;
 }
 
 QString Card::displaySerialNumber() const
 {
     return mDisplaySerialNumber;
 }
 
 void Card::setDisplaySerialNumber(const QString &serialNumber)
 {
     mDisplaySerialNumber = serialNumber;
 }
 
 std::string Card::appName() const
 {
     return mAppName;
 }
 
 void Card::setAppName(const std::string &name)
 {
     mAppName = name;
 }
 
 void Card::setAppVersion(int version)
 {
     mAppVersion = version;
 }
 
 int Card::appVersion() const
 {
     return mAppVersion;
 }
 
 QString Card::displayAppVersion() const
 {
     return formatVersion(mAppVersion);
 }
 
 void Card::setManufacturer(const std::string &value)
 {
     if (!manufacturer().empty()) {
         qCDebug(KLEOPATRA_LOG) << "Card manufacturer is already set; overwriting existing value";
         mCardInfo.erase("MANUFACTURER");
     }
     mCardInfo.insert({"MANUFACTURER", value});
 }
 
 std::string Card::manufacturer() const
 {
     return cardInfo("MANUFACTURER");
 }
 
 std::string Card::cardType() const
 {
     return mCardType;
 }
 
 int Card::cardVersion() const
 {
     return mCardVersion;
 }
 
 QString Card::displayCardVersion() const
 {
     return formatVersion(mCardVersion);
 }
 
 QString Card::cardHolder() const
 {
     return mCardHolder;
 }
 
 void Card::setSigningKeyRef(const std::string &keyRef)
 {
     mSigningKeyRef = keyRef;
 }
 
 std::string Card::signingKeyRef() const
 {
     return mSigningKeyRef;
 }
 
 bool Card::hasSigningKey() const
 {
     return !keyInfo(mSigningKeyRef).grip.empty();
 }
 
 void Card::setEncryptionKeyRef(const std::string &keyRef)
 {
     mEncryptionKeyRef = keyRef;
 }
 
 std::string Card::encryptionKeyRef() const
 {
     return mEncryptionKeyRef;
 }
 
 bool Card::hasEncryptionKey() const
 {
     return !keyInfo(mEncryptionKeyRef).grip.empty();
 }
 
 std::vector<Card::PinState> Card::pinStates() const
 {
     return mPinStates;
 }
 
 void Card::setPinStates(const std::vector<PinState> &pinStates)
 {
     mPinStates = pinStates;
 }
 
 bool Card::hasNullPin() const
 {
     return mHasNullPin;
 }
 
 void Card::setHasNullPin(bool value)
 {
     mHasNullPin = value;
 }
 
 bool Card::canLearnKeys() const
 {
     return mCanLearn;
 }
 
 void Card::setCanLearnKeys(bool value)
 {
     mCanLearn = value;
 }
 
 bool Card::operator == (const Card &other) const
 {
     return mStatus == other.status()
         && mSerialNumber == other.serialNumber()
         && mAppName == other.appName()
         && mAppVersion == other.appVersion()
         && mPinStates == other.pinStates()
         && mCanLearn == other.canLearnKeys()
         && mHasNullPin == other.hasNullPin()
         && mCardInfo == other.mCardInfo;
 }
 
 bool Card::operator != (const Card &other) const
 {
     return !operator==(other);
 }
 
 void Card::setErrorMsg(const QString &msg)
 {
     mErrMsg = msg;
 }
 
 QString Card::errorMsg() const
 {
     return mErrMsg;
 }
 
 void Card::setInitialKeyInfos(const std::vector<KeyPairInfo> &infos)
 {
     mKeyInfos = infos;
 }
 
 const std::vector<KeyPairInfo> & Card::keyInfos() const
 {
     return mKeyInfos;
 }
 
 const KeyPairInfo & Card::keyInfo(const std::string &keyRef) const
 {
     static const KeyPairInfo nullKey;
     for (const KeyPairInfo &k : mKeyInfos) {
         if (k.keyRef == keyRef) {
             return k;
         }
     }
     return nullKey;
 }
 
 void Card::setCardInfo(const std::vector<std::pair<std::string, std::string>> &infos)
 {
     qCDebug(KLEOPATRA_LOG) << "Card" << serialNumber().c_str() << "info:";
     for (const auto &pair: infos) {
         qCDebug(KLEOPATRA_LOG) << pair.first.c_str() << ":" << pair.second.c_str();
         parseCardInfo(pair.first, pair.second);
     }
     processCardInfo();
 }
 
 namespace {
 static int parseHexEncodedVersionTuple(const std::string &s) {
     // s is a hex-encoded, unsigned int-packed version tuple,
     // i.e. each byte represents one part of the version tuple
     bool ok;
     const auto version = QByteArray::fromStdString(s).toUInt(&ok, 16);
     return ok ? version : -1;
 }
 }
 
 void Card::parseCardInfo(const std::string &name, const std::string &value)
 {
     if (name == "APPVERSION") {
         mAppVersion = parseHexEncodedVersionTuple(value);
     } else if (name == "CARDTYPE") {
         mCardType = value;
     } else if (name == "CARDVERSION") {
         mCardVersion = parseHexEncodedVersionTuple(value);
     } else if (name == "DISP-NAME") {
         auto list = QString::fromUtf8(QByteArray::fromStdString(value)).
                     split(QStringLiteral("<<"), Qt::SkipEmptyParts);
         std::reverse(list.begin(), list.end());
         mCardHolder = list.join(QLatin1Char(' '));
     } else if (name == "KEYPAIRINFO") {
         const KeyPairInfo info = KeyPairInfo::fromStatusLine(value);
         if (info.grip.empty()) {
             qCWarning(KLEOPATRA_LOG) << "Invalid KEYPAIRINFO status line" << QString::fromStdString(value);
             setStatus(Card::CardError);
         } else {
             updateKeyInfo(info);
         }
     } else if (name == "KEY-FPR") {
         // handle OpenPGP key fingerprints
         const auto values = QString::fromStdString(value).split(QLatin1Char(' '));
         if (values.size() < 2) {
             qCWarning(KLEOPATRA_LOG) << "Invalid KEY-FPR status line" << QString::fromStdString(value);
             setStatus(Card::CardError);
         }
         const auto keyNumber = values[0];
         const std::string keyRef = "OPENPGP." + keyNumber.toStdString();
         const auto fpr = values[1].toStdString();
         if (keyNumber == QLatin1Char('1') || keyNumber == QLatin1Char('2') || keyNumber == QLatin1Char('3')) {
             addCardInfo("KLEO-FPR-" + keyRef, fpr);
         } else {
             // Maybe more keyslots in the future?
             qCDebug(KLEOPATRA_LOG) << "Unhandled keyslot" << keyNumber;
         }
     } else if (name == "MANUFACTURER") {
         // the value of MANUFACTURER is the manufacturer ID as unsigned number
         // optionally followed by the name of the manufacturer, e.g.
         // 6 Yubico
         // 65534 unmanaged S/N range
         // for PKCS#15 cards the manufacturer ID is always 0, e.g.
         // 0 www.atos.net/cardos [R&S]
         const auto startOfManufacturerName = value.find(' ');
         if (startOfManufacturerName != std::string::npos) {
             addCardInfo(name, value.substr(startOfManufacturerName + 1));
         }
     } else {
         mCardInfo.insert({name, value});
     }
 }
 
 void Card::processCardInfo()
 {
 }
 
 void Card::addCardInfo(const std::string &name, const std::string &value)
 {
     mCardInfo.insert({name, value});
 }
 
 std::string Card::cardInfo(const std::string &name) const
 {
     const auto range = mCardInfo.equal_range(name);
     return range.first != range.second ? range.first->second : std::string();
 }
 
 void Card::updateKeyInfo(const KeyPairInfo& keyPairInfo)
 {
     for (KeyPairInfo &k : mKeyInfos) {
         if (k.keyRef == keyPairInfo.keyRef) {
             k.update(keyPairInfo);
             return;
         }
     }
     mKeyInfos.push_back(keyPairInfo);
 }
+
+std::string Card::keyFingerprint(const std::string &keyRef) const
+{
+    return cardInfo("KLEO-FPR-" + keyRef);
+}
diff --git a/src/smartcard/card.h b/src/smartcard/card.h
index 7d8221dc7..0277d8355 100644
--- a/src/smartcard/card.h
+++ b/src/smartcard/card.h
@@ -1,141 +1,143 @@
 #pragma once
 /*  smartcard/card.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2017 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "keypairinfo.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include <QString>
 
 namespace Kleo
 {
 namespace SmartCard
 {
 
 /** Class representing an application on a smartcard or similar hardware token. */
 class Card
 {
 public:
     enum PinState {
         UnknownPinState,
         NullPin,
         PinBlocked,
         NoPin,
         PinOk,
 
         NumPinStates
     };
 
     enum Status {
         NoCard,
         CardPresent,
         CardActive,
         CardUsable,
 
         _NumScdStates,
 
         CardError = _NumScdStates,
 
         NumStates
     };
 
     Card();
     virtual ~Card();
 
     virtual bool operator == (const Card &other) const;
     bool operator != (const Card &other) const;
 
     void setStatus(Status s);
     Status status() const;
 
     void setSerialNumber(const std::string &sn);
     std::string serialNumber() const;
 
     void setCardInfo(const std::vector<std::pair<std::string, std::string>> &infos);
 
     QString displaySerialNumber() const;
     void setDisplaySerialNumber(const QString &sn);
 
     std::string appName() const;
 
     void setAppVersion(int version);
     int appVersion() const;
     QString displayAppVersion() const;
 
     void setManufacturer(const std::string &manufacturer);
     std::string manufacturer() const;
 
     std::string cardType() const;
 
     int cardVersion() const;
     QString displayCardVersion() const;
 
     QString cardHolder() const;
 
     void setSigningKeyRef(const std::string &keyRef);
     std::string signingKeyRef() const;
     bool hasSigningKey() const;
 
     void setEncryptionKeyRef(const std::string &keyRef);
     std::string encryptionKeyRef() const;
     bool hasEncryptionKey() const;
 
     std::vector<PinState> pinStates() const;
     void setPinStates(const std::vector<PinState> &pinStates);
 
     bool hasNullPin() const;
     void setHasNullPin(bool value);
 
     bool canLearnKeys() const;
     void setCanLearnKeys(bool value);
 
     QString errorMsg() const;
     void setErrorMsg(const QString &msg);
 
     const std::vector<KeyPairInfo> & keyInfos() const;
     const KeyPairInfo & keyInfo(const std::string &keyRef) const;
 
+    std::string keyFingerprint(const std::string &keyRef) const;
+
 protected:
     void setAppName(const std::string &name);
     void setInitialKeyInfos(const std::vector<KeyPairInfo> &infos);
 
     virtual void processCardInfo();
 
     void addCardInfo(const std::string &name, const std::string &value);
     std::string cardInfo(const std::string &name) const;
 
 private:
     void parseCardInfo(const std::string &name, const std::string &value);
 
     void updateKeyInfo(const KeyPairInfo &keyPairInfo);
 
 private:
     bool mCanLearn = false;
     bool mHasNullPin = false;
     Status mStatus = NoCard;
     std::string mSerialNumber;
     QString mDisplaySerialNumber;
     std::string mAppName;
     int mAppVersion = -1;
     std::string mCardType;
     int mCardVersion = -1;
     QString mCardHolder;
     std::string mSigningKeyRef;
     std::string mEncryptionKeyRef;
     std::vector<PinState> mPinStates;
     QString mErrMsg;
     std::vector<KeyPairInfo> mKeyInfos;
     std::multimap<std::string, std::string> mCardInfo;
 };
 } // namespace Smartcard
 } // namespace Kleopatra
 
diff --git a/src/smartcard/openpgpcard.cpp b/src/smartcard/openpgpcard.cpp
index 308a19887..cf3c14c71 100644
--- a/src/smartcard/openpgpcard.cpp
+++ b/src/smartcard/openpgpcard.cpp
@@ -1,110 +1,105 @@
 /*  smartcard/openpgpcard.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2017 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
     SPDX-FileCopyrightText: 2020 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 /* Code in this file is partly based on the GNU Privacy Assistant
  * (cm-openpgp.c) git rev. 0a78795146661234070681737b3e08228616441f
  *
  * Whis is:
  * SPDX-FileCopyrightText: 2008, 2009 g 10 Code GmbH
  *
  * And may be licensed under the GNU General Public License
  * as published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  */
 
 #include "openpgpcard.h"
 
 #include <KLocalizedString>
 
 #include "kleopatra_debug.h"
 
 using namespace Kleo;
 using namespace Kleo::SmartCard;
 
 // static
 const std::string OpenPGPCard::AppName = "openpgp";
 
 OpenPGPCard::OpenPGPCard(const Card &card)
     : Card(card)
 {
     setAppName(AppName);
     setInitialKeyInfos(OpenPGPCard::supportedKeys());
 }
 
 // static
 std::string OpenPGPCard::pgpSigKeyRef()
 {
     return std::string("OPENPGP.1");
 }
 
 // static
 std::string OpenPGPCard::pgpEncKeyRef()
 {
     return std::string("OPENPGP.2");
 }
 
 // static
 std::string OpenPGPCard::pgpAuthKeyRef()
 {
     return std::string("OPENPGP.3");
 }
 
 // static
 std::string OpenPGPCard::pinKeyRef()
 {
     return std::string("OPENPGP.1");
 }
 
 // static
 std::string OpenPGPCard::adminPinKeyRef()
 {
     return std::string("OPENPGP.3");
 }
 
 // static
 std::string OpenPGPCard::resetCodeKeyRef()
 {
     return std::string("OPENPGP.2");
 }
 
 // static
 const std::vector<KeyPairInfo> & OpenPGPCard::supportedKeys()
 {
     static const std::vector<KeyPairInfo> keyInfos = {
         {OpenPGPCard::pgpSigKeyRef(), "", "sc", "", ""},
         {OpenPGPCard::pgpEncKeyRef(), "", "e", "", ""},
         {OpenPGPCard::pgpAuthKeyRef(), "", "a", "", ""}
     };
 
     return keyInfos;
 }
 
 // static
 QString OpenPGPCard::keyDisplayName(const std::string &keyRef)
 {
     static const QMap<std::string, QString> displayNames = {
         { OpenPGPCard::pgpSigKeyRef(), i18n("Signature") },
         { OpenPGPCard::pgpEncKeyRef(), i18n("Encryption") },
         { OpenPGPCard::pgpAuthKeyRef(), i18n("Authentication") }
     };
 
     return displayNames.value(keyRef);
 }
 
-std::string OpenPGPCard::keyFingerprint(const std::string &keyRef) const
-{
-    return cardInfo("KLEO-FPR-" + keyRef);
-}
-
 std::string OpenPGPCard::pubkeyUrl() const
 {
     return cardInfo("PUBKEY-URL");
 }
diff --git a/src/smartcard/openpgpcard.h b/src/smartcard/openpgpcard.h
index 949344c0f..af8b2fada 100644
--- a/src/smartcard/openpgpcard.h
+++ b/src/smartcard/openpgpcard.h
@@ -1,47 +1,45 @@
 /*  smartcard/openpgpcard.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2017 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
     SPDX-FileCopyrightText: 2020 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 #pragma once
 
 #include "card.h"
 
 namespace Kleo
 {
 namespace SmartCard
 {
 struct KeyPairInfo;
 
 /** Class to work with OpenPGP smartcards or compatible tokens */
 class OpenPGPCard: public Card
 {
 public:
     explicit OpenPGPCard(const Card &card);
 
     static const std::string AppName;
 
     static std::string pgpSigKeyRef();
     static std::string pgpEncKeyRef();
     static std::string pgpAuthKeyRef();
 
     static std::string pinKeyRef();
     static std::string adminPinKeyRef();
     static std::string resetCodeKeyRef();
 
     static const std::vector<KeyPairInfo> & supportedKeys();
     static QString keyDisplayName(const std::string &keyRef);
 
-    std::string keyFingerprint(const std::string &keyRef) const;
-
     std::string pubkeyUrl() const;
 };
 } // namespace Smartcard
 } // namespace Kleopatra