diff --git a/src/smartcard/netkeycard.cpp b/src/smartcard/netkeycard.cpp
index dff70c575..288400272 100644
--- a/src/smartcard/netkeycard.cpp
+++ b/src/smartcard/netkeycard.cpp
@@ -1,129 +1,139 @@
 /*  smartcard/netkeycard.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2017 Intevation GmbH
 
     Kleopatra is free software; you can redistribute it and/or modify
     it under the terms of 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.
 
     Kleopatra is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #include "netkeycard.h"
 
 #include "libkleo_debug.h"
 
 #include <gpgme++/error.h>
 #include <gpgme++/context.h>
 #include <gpgme++/keylistresult.h>
 
 #include <memory>
 #include <string>
 
 using namespace Kleo;
 using namespace Kleo::SmartCard;
 
+
+class NetKeyCard::Private
+{
+public:
+    Private ()
+    {
+    }
+    std::vector <GpgME::Key> mKeys;
+};
+
 namespace
 {
 static std::string parse_keypairinfo(const std::string &kpi)
 {
     static const char hexchars[] = "0123456789abcdefABCDEF";
     return '&' + kpi.substr(0, kpi.find_first_not_of(hexchars));
 }
 
 static GpgME::Key parse_keypairinfo_and_lookup_key(GpgME::Context *ctx, const std::string &kpi)
 {
     if (!ctx) {
         return GpgME::Key();
     }
     const std::string pattern = parse_keypairinfo(kpi);
     qCDebug(LIBKLEO_LOG) << "parse_keypairinfo_and_lookup_key: pattern=" << pattern.c_str();
     if (const auto err = ctx->startKeyListing(pattern.c_str())) {
         qCDebug(LIBKLEO_LOG) << "parse_keypairinfo_and_lookup_key: startKeyListing failed:" << err.asString();
         return GpgME::Key();
     }
     GpgME::Error e;
     const auto key = ctx->nextKey(e);
     ctx->endKeyListing();
     qCDebug(LIBKLEO_LOG) << "parse_keypairinfo_and_lookup_key: e=" << e.code() << "; key.isNull()" << key.isNull();
     return key;
 }
 
 } // namespace
 
-NetKeyCard::NetKeyCard()
+NetKeyCard::NetKeyCard(): d(new Private())
 {
     setAppType(Card::NksApplication);
 }
 
 void NetKeyCard::setKeyPairInfo(const std::vector<std::string> &infos)
 {
     // check that any of the keys are new
     const std::unique_ptr<GpgME::Context> klc(GpgME::Context::createForProtocol(GpgME::CMS));
     if (!klc.get()) {
         return;
     }
     klc->setKeyListMode(GpgME::Ephemeral);
     klc->addKeyListMode(GpgME::Validate);
 
     setCanLearnKeys(false);
-    mKeys.clear();
+    d->mKeys.clear();
     for (const auto &info: infos) {
         const auto key = parse_keypairinfo_and_lookup_key(klc.get(), info);
         if (key.isNull()) {
             setCanLearnKeys(true);
         }
-        mKeys.push_back(key);
+        d->mKeys.push_back(key);
     }
 }
 
 
 // State 0 -> NKS PIN Retry counter
 // State 1 -> NKS PUK Retry counter
 // State 2 -> SigG PIN Retry counter
 // State 3 -> SigG PUK Retry counter
 
 bool NetKeyCard::hasNKSNullPin() const
 {
     const auto states = pinStates();
     if (states.size() < 2) {
         qCWarning(LIBKLEO_LOG) << "Invalid size of pin states:" << states.size();
         return false;
     }
     return states[0] == Card::NullPin;
 }
 
 bool NetKeyCard::hasSigGNullPin() const
 {
     const auto states = pinStates();
     if (states.size() < 4) {
         qCWarning(LIBKLEO_LOG) << "Invalid size of pin states:" << states.size();
         return false;
     }
     return states[2] == Card::NullPin;
 }
 
 std::vector<GpgME::Key> NetKeyCard::keys() const
 {
-    return mKeys;
+    return d->mKeys;
 }
diff --git a/src/smartcard/netkeycard.h b/src/smartcard/netkeycard.h
index c4e2c9900..d8706cbc5 100644
--- a/src/smartcard/netkeycard.h
+++ b/src/smartcard/netkeycard.h
@@ -1,65 +1,65 @@
 #ifndef SMARTCARD_NETKEYCARD_H
 #define SMARTCARD_NETKEYCARD_H
 /*  smartcard/openpgpcard.h
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2017 Intevation GmbH
 
     Kleopatra is free software; you can redistribute it and/or modify
     it under the terms of 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.
 
     Kleopatra is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 
 #include "card.h"
 
+#include <memory>
 #include <gpgme++/key.h>
 
 namespace Kleo
 {
 namespace SmartCard
 {
 /** Class to work with OpenPGP Smartcards or compatible tokens */
 class NetKeyCard: public Card
 {
 public:
     NetKeyCard ();
 
     void setKeyPairInfo (const std::vector<std::string> &infos);
 
     bool hasSigGNullPin() const;
     bool hasNKSNullPin() const;
 
     std::vector <GpgME::Key> keys() const;
 
 private:
     class Private;
     std::shared_ptr<Private> d;
-    std::vector <GpgME::Key> mKeys;
 };
 } // namespace Smartcard
 } // namespace Kleopatra
 
 #endif // SMARTCARD_CARD_H
 
diff --git a/src/smartcard/openpgpcard.cpp b/src/smartcard/openpgpcard.cpp
index be7fc046b..e60b95f60 100644
--- a/src/smartcard/openpgpcard.cpp
+++ b/src/smartcard/openpgpcard.cpp
@@ -1,236 +1,250 @@
 /*  smartcard/openpgpcard.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2017 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
     Kleopatra is free software; you can redistribute it and/or modify
     it under the terms of 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.
 
     Kleopatra is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 /* Code in this file is partly based on the GNU Privacy Assistant
  * (cm-openpgp.c) git rev. 0a78795146661234070681737b3e08228616441f
  *
  * Whis is:
  * Copyright (C) 2008, 2009 g10 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 "libkleo_debug.h"
 
 
 using namespace Kleo;
 using namespace Kleo::SmartCard;
 
 #define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
                      *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
 #define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
 
 namespace
 {
 static const char * get_manufacturer (unsigned int no)
 {
     switch (no) {
         case 0x0001: return "PPC Card Systems";
         case 0x0002: return "Prism";
         case 0x0003: return "OpenFortress";
         case 0x0004: return "Wewid";
         case 0x0005: return "ZeitControl";
         case 0x0006: return "Yubico";
         case 0x0007: return "OpenKMS";
         case 0x0008: return "LogoEmail";
 
         case 0x002A: return "Magrathea";
 
         case 0x1337: return "Warsaw Hackerspace";
 
         case 0xF517: return "FSIJ";
 
      /* 0x0000 and 0xFFFF are defined as test cards per spec,
         0xFF00 to 0xFFFE are assigned for use with randomly created
         serial numbers.  */
         case 0x0000:
         case 0xffff: return "test card";
         default: return (no & 0xff00) == 0xff00? "unmanaged S/N range":"unknown";
     }
 }
 
 } // namespace
 
-OpenPGPCard::OpenPGPCard()
+class OpenPGPCard::Private
+{
+public:
+    Private (): mIsV2(false)
+    {
+
+    }
+
+    bool mIsV2 = false;
+    std::string mCardVersion;
+    QMap <std::string, std::string> mMetaInfo;
+    std::string mManufacturer;
+};
+
+OpenPGPCard::OpenPGPCard(): d(new Private())
 {
     setAppType(Card::OpenPGPApplication);
 }
 
 OpenPGPCard::OpenPGPCard(const std::string &serialno): OpenPGPCard()
 {
     setSerialNumber(serialno);
 }
 
 std::string OpenPGPCard::sigFpr() const
 {
-    return mMetaInfo.value("SIGKEY-FPR");
+    return d->mMetaInfo.value("SIGKEY-FPR");
 }
 
 std::string OpenPGPCard::encFpr() const
 {
-    return mMetaInfo.value("ENCKEY-FPR");
+    return d->mMetaInfo.value("ENCKEY-FPR");
 }
 
 std::string OpenPGPCard::authFpr() const
 {
-    return mMetaInfo.value("AUTHKEY-FPR");
+    return d->mMetaInfo.value("AUTHKEY-FPR");
 }
 
 void OpenPGPCard::setKeyPairInfo(const std::vector< std::pair<std::string, std::string> > &infos)
 {
     qCDebug(LIBKLEO_LOG) << "Card" << serialNumber().c_str() << "info:";
     for (const auto &pair: infos) {
         qCDebug(LIBKLEO_LOG) << pair.first.c_str() << ":" << pair.second.c_str();
         if (pair.first == "KEY-FPR" ||
             pair.first == "KEY-TIME") {
             // Key fpr and key time need to be distinguished, the number
             // of the key decides the usage.
             const auto values = QString::fromStdString(pair.second).split(QLatin1Char(' '));
             if (values.size() < 2) {
                 qCWarning(LIBKLEO_LOG) << "Invalid entry.";
                 setStatus(Card::CardError);
                 continue;
             }
             const auto usage = values[0];
             const auto fpr = values[1].toStdString();
             if (usage == QLatin1Char('1')) {
-                mMetaInfo.insert(std::string("SIG") + pair.first, fpr);
+                d->mMetaInfo.insert(std::string("SIG") + pair.first, fpr);
             } else if (usage == QLatin1Char('2')) {
-                mMetaInfo.insert(std::string("ENC") + pair.first, fpr);
+                d->mMetaInfo.insert(std::string("ENC") + pair.first, fpr);
             } else if (usage == QLatin1Char('3')) {
-                mMetaInfo.insert(std::string("AUTH") + pair.first, fpr);
+                d->mMetaInfo.insert(std::string("AUTH") + pair.first, fpr);
             } else {
-                // Maybe more keyslots in the future?
+                // d->maybe more keyslots in the future?
                 qCDebug(LIBKLEO_LOG) << "Unhandled keyslot";
             }
         } else if (pair.first == "KEYPAIRINFO") {
             // Fun, same as above but the other way around.
             const auto values = QString::fromStdString(pair.second).split(QLatin1Char(' '));
             if (values.size() < 2) {
                 qCWarning(LIBKLEO_LOG) << "Invalid entry.";
                 setStatus(Card::CardError);
                 continue;
             }
             const auto usage = values[1];
             const auto grip = values[0].toStdString();
             if (usage == QLatin1String("OPENPGP.1")) {
-                mMetaInfo.insert(std::string("SIG") + pair.first, grip);
+                d->mMetaInfo.insert(std::string("SIG") + pair.first, grip);
             } else if (usage == QLatin1String("OPENPGP.2")) {
-                mMetaInfo.insert(std::string("ENC") + pair.first, grip);
+                d->mMetaInfo.insert(std::string("ENC") + pair.first, grip);
             } else if (usage == QLatin1String("OPENPGP.3")) {
-                mMetaInfo.insert(std::string("AUTH") + pair.first, grip);
+                d->mMetaInfo.insert(std::string("AUTH") + pair.first, grip);
             } else {
-                // Maybe more keyslots in the future?
+                // d->maybe more keyslots in the future?
                 qCDebug(LIBKLEO_LOG) << "Unhandled keyslot";
             }
         } else {
-            mMetaInfo.insert(pair.first, pair.second);
+            d->mMetaInfo.insert(pair.first, pair.second);
         }
     }
 }
 
 void OpenPGPCard::setSerialNumber(const std::string &serialno)
 {
     char version_buffer[6];
     const char *version = "";
     const char *string = serialno.c_str();
 
     Card::setSerialNumber(serialno);
     if (strncmp(string, "D27600012401", 12) || strlen(string) != 32 ) {
         /* Not a proper OpenPGP card serialnumber.  Display the full
            serialnumber. */
-        mManufacturer = "unknown";
+        d->mManufacturer = "unknown";
     } else {
         /* Reformat the version number to be better human readable.  */
         char *p = version_buffer;
         if (string[12] != '0') {
             *p++ = string[12];
         }
         *p++ = string[13];
         *p++ = '.';
         if (string[14] != '0') {
             *p++ = string[14];
         }
         *p++ = string[15];
         *p++ = '\0';
         version = version_buffer;
 
         /* Get the manufacturer.  */
-        mManufacturer = get_manufacturer(xtoi_2(string + 16)*256 + xtoi_2(string + 18));
+        d->mManufacturer = get_manufacturer(xtoi_2(string + 16)*256 + xtoi_2(string + 18));
     }
 
-    mIsV2 = !((*version == '1' || *version == '0') && version[1] == '.');
-    mCardVersion = version;
+    d->mIsV2 = !((*version == '1' || *version == '0') && version[1] == '.');
+    d->mCardVersion = version;
 }
 
 bool OpenPGPCard::operator == (const Card& rhs) const
 {
     const OpenPGPCard *other = dynamic_cast<const OpenPGPCard *>(&rhs);
     if (!other) {
         return false;
     }
 
     return Card::operator ==(rhs)
         && sigFpr() == other->sigFpr()
         && encFpr() == other->encFpr()
         && authFpr() == other->authFpr()
         && manufacturer() == other->manufacturer()
         && cardVersion() == other->cardVersion()
         && cardHolder() == other->cardHolder()
         && pubkeyUrl() == other->pubkeyUrl();
 }
 
 std::string OpenPGPCard::manufacturer() const
 {
-    return mManufacturer;
+    return d->mManufacturer;
 }
 
 std::string OpenPGPCard::cardVersion() const
 {
-    return mCardVersion;
+    return d->mCardVersion;
 }
 
 std::string OpenPGPCard::cardHolder() const
 {
-    auto list = QString::fromStdString(mMetaInfo.value("DISP-NAME")).split(QStringLiteral("<<"));
+    auto list = QString::fromStdString(d->mMetaInfo.value("DISP-NAME")).split(QStringLiteral("<<"));
     std::reverse(list.begin(), list.end());
     return list.join(QLatin1Char(' ')).toStdString();
 }
 
 std::string OpenPGPCard::pubkeyUrl() const
 {
-    return mMetaInfo.value("PUBKEY-URL");
+    return d->mMetaInfo.value("PUBKEY-URL");
 }
diff --git a/src/smartcard/openpgpcard.h b/src/smartcard/openpgpcard.h
index 65c3e0e68..f03050f4f 100644
--- a/src/smartcard/openpgpcard.h
+++ b/src/smartcard/openpgpcard.h
@@ -1,73 +1,73 @@
 #ifndef SMARTCARD_OPENPGPCARD_H
 #define SMARTCARD_OPENPGPCARD_H
 /*  smartcard/openpgpcard.h
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2017 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
     Kleopatra is free software; you can redistribute it and/or modify
     it under the terms of 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.
 
     Kleopatra is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #include <QMap>
 
+#include <memory>
+
 #include "card.h"
 
 namespace Kleo
 {
 namespace SmartCard
 {
 /** Class to work with OpenPGP Smartcards or compatible tokens */
 class OpenPGPCard: public Card
 {
 public:
     OpenPGPCard ();
     OpenPGPCard (const std::string &serialno);
     void setSerialNumber(const std::string &sn) override;
 
     std::string encFpr() const;
     std::string sigFpr() const;
     std::string authFpr() const;
 
     void setKeyPairInfo (const std::vector< std::pair<std::string, std::string> > &infos);
 
     bool operator == (const Card& other) const override;
 
     std::string manufacturer() const;
     std::string cardVersion() const;
     std::string cardHolder() const;
     std::string pubkeyUrl() const;
 private:
-    bool mIsV2 = false;
-    std::string mCardVersion;
-    QMap <std::string, std::string> mMetaInfo;
-    std::string mManufacturer;
+    class Private;
+    std::shared_ptr<Private> d;
 };
 } // namespace Smartcard
 } // namespace Kleopatra
 
 #endif // SMARTCARD_CARD_H