diff --git a/src/commands/certificatetopivcardcommand.cpp b/src/commands/certificatetopivcardcommand.cpp
index 88eb33b3f..f97fa64b8 100644
--- a/src/commands/certificatetopivcardcommand.cpp
+++ b/src/commands/certificatetopivcardcommand.cpp
@@ -1,234 +1,246 @@
 /* commands/certificatetopivcardcommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2020 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "certificatetopivcardcommand.h"
 
 #include "command_p.h"
 
-#include "smartcard/readerstatus.h"
-#include "smartcard/pivcard.h"
-
 #include "commands/authenticatepivcardapplicationcommand.h"
 
+#include "smartcard/pivcard.h"
+#include "smartcard/readerstatus.h"
+
 #include "utils/writecertassuantransaction.h"
 
+#include <Libkleo/Dn>
+#include <Libkleo/Formatting>
 #include <Libkleo/KeyCache>
 
 #include <KLocalizedString>
 
 #include <qgpgme/dataprovider.h>
 
 #include <gpgme++/context.h>
 
 #include "kleopatra_debug.h"
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace Kleo::SmartCard;
 using namespace GpgME;
 
 class CertificateToPIVCardCommand::Private : public Command::Private
 {
     friend class ::Kleo::Commands::CertificateToPIVCardCommand;
     CertificateToPIVCardCommand *q_func() const
     {
         return static_cast<CertificateToPIVCardCommand *>(q);
     }
 public:
-    explicit Private(CertificateToPIVCardCommand *qq, const GpgME::Subkey &key, const std::string &serialno);
-    explicit Private(CertificateToPIVCardCommand *qq, const std::string &cardSlot, const std::string &serialno);
+    explicit Private(CertificateToPIVCardCommand *qq, const std::string &slot, const std::string &serialno);
     ~Private();
 
 private:
     void start();
     void startCertificateToPIVCard();
 
     void authenticate();
     void authenticationFinished();
     void authenticationCanceled();
 
 private:
-    std::string mSerial;
-    GpgME::Subkey mSubkey;
+    std::string serialNumber;
     std::string cardSlot;
-    bool overwriteExistingAlreadyApproved = false;
+    Key certificate;
     bool hasBeenCanceled = false;
 };
 
 CertificateToPIVCardCommand::Private *CertificateToPIVCardCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const CertificateToPIVCardCommand::Private *CertificateToPIVCardCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define q q_func()
 #define d d_func()
 
 
-CertificateToPIVCardCommand::Private::Private(CertificateToPIVCardCommand *qq,
-                                   const GpgME::Subkey &key,
-                                   const std::string &serialno)
-    : Command::Private(qq, nullptr),
-      mSerial(serialno),
-      mSubkey(key)
-{
-}
-
-CertificateToPIVCardCommand::Private::Private(CertificateToPIVCardCommand *qq, const std::string &cardSlot_, const std::string &serialno)
+CertificateToPIVCardCommand::Private::Private(CertificateToPIVCardCommand *qq, const std::string &slot, const std::string &serialno)
     : Command::Private(qq, nullptr)
-    , mSerial(serialno)
-    , cardSlot(cardSlot_)
+    , serialNumber(serialno)
+    , cardSlot(slot)
 {
 }
 
 CertificateToPIVCardCommand::Private::~Private()
 {
 }
 
 namespace {
-static GpgME::Subkey getSubkeyToTransferToPIVCard(const std::string &cardSlot, const std::shared_ptr<PIVCard> &card)
+static Key getCertificateToWriteToPIVCard(const std::string &cardSlot, const std::shared_ptr<PIVCard> &card)
 {
     if (!cardSlot.empty()) {
         const std::string cardKeygrip = card->keyGrip(cardSlot);
-        const auto subkey = KeyCache::instance()->findSubkeyByKeyGrip(cardKeygrip);
-        if (subkey.isNull() || subkey.parent().protocol() != GpgME::CMS) {
-            return GpgME::Subkey();
+        const auto certificate = KeyCache::instance()->findSubkeyByKeyGrip(cardKeygrip).parent();
+        if (certificate.isNull() || certificate.protocol() != GpgME::CMS) {
+            return Key();
         }
-        if ((cardSlot == PIVCard::digitalSignatureKeyRef() && subkey.canSign()) ||
-            (cardSlot == PIVCard::keyManagementKeyRef() && subkey.canEncrypt())) {
-            return subkey;
+        if ((cardSlot == PIVCard::pivAuthenticationKeyRef() && certificate.canSign()) ||
+            (cardSlot == PIVCard::cardAuthenticationKeyRef() && certificate.canSign()) ||
+            (cardSlot == PIVCard::digitalSignatureKeyRef() && certificate.canSign()) ||
+            (cardSlot == PIVCard::keyManagementKeyRef() && certificate.canEncrypt())) {
+            return certificate;
         }
     }
 
-    return GpgME::Subkey();
+    return Key();
 }
 }
 
 void CertificateToPIVCardCommand::Private::start()
 {
     qCDebug(KLEOPATRA_LOG) << "CertificateToPIVCardCommand::Private::start()";
 
-    const auto pivCard = SmartCard::ReaderStatus::instance()->getCard<PIVCard>(mSerial);
+    const auto pivCard = SmartCard::ReaderStatus::instance()->getCard<PIVCard>(serialNumber);
     if (!pivCard) {
-        error(i18n("Failed to find the PIV card with the serial number: %1", QString::fromStdString(mSerial)));
+        error(i18n("Failed to find the PIV card with the serial number: %1", QString::fromStdString(serialNumber)));
         finished();
         return;
     }
 
-    mSubkey = getSubkeyToTransferToPIVCard(cardSlot, pivCard);
-    if (mSubkey.isNull()) {
+    certificate = getCertificateToWriteToPIVCard(cardSlot, pivCard);
+    if (certificate.isNull()) {
         error(i18n("Sorry! No suitable certificate to write to this card slot was found."));
         finished();
         return;
     }
 
+    const QString certificateInfo = i18nc("X.509 certificate DN (validity, created: date)", "%1 (%2, created: %3)",
+                                          DN(certificate.userID(0).id()).prettyDN(),
+                                          Formatting::complianceStringShort(certificate),
+                                          Formatting::creationDateString(certificate));
+    const QString message = i18nc(
+        "@info %1 name of card slot, %2 serial number of card",
+        "<p>Please confirm that you want to write the following certificate to the %1 slot of card %2:</p>"
+        "<center>%3</center>",
+        PIVCard::keyDisplayName(cardSlot), QString::fromStdString(serialNumber), certificateInfo);
+    auto confirmButton = KStandardGuiItem::yes();
+    confirmButton.setText(i18nc("@action:button", "Write certificate"));
+    confirmButton.setToolTip(QString());
+    const auto choice = KMessageBox::questionYesNo(
+        parentWidgetOrView(), message, i18nc("@title:window", "Write certificate to card"),
+        confirmButton, KStandardGuiItem::cancel(), QString(), KMessageBox::Notify | KMessageBox::WindowModal);
+    if (choice != KMessageBox::Yes) {
+        finished();
+        return;
+    }
+
     startCertificateToPIVCard();
 }
 
 void CertificateToPIVCardCommand::Private::startCertificateToPIVCard()
 {
     qCDebug(KLEOPATRA_LOG) << "KeyToCardCommand::Private::startCertificateToPIVCard()";
 
     auto ctx = Context::createForProtocol(GpgME::CMS);
     QGpgME::QByteArrayDataProvider dp;
     Data data(&dp);
-    const Error err = ctx->exportPublicKeys(mSubkey.parent().primaryFingerprint(), data);
+    const Error err = ctx->exportPublicKeys(certificate.primaryFingerprint(), data);
     if (err) {
         error(i18nc("@info", "Exporting the certificate failed: %1", QString::fromUtf8(err.asString())),
               i18nc("@title", "Error"));
         finished();
         return;
     }
     const QByteArray certificateData = dp.data();
 
     const QString cmd = QStringLiteral("SCD WRITECERT %1")
         .arg(QString::fromStdString(cardSlot));
     auto transaction = std::unique_ptr<AssuanTransaction>(new WriteCertAssuanTransaction(certificateData));
     ReaderStatus::mutableInstance()->startTransaction(cmd.toUtf8(), q_func(), "certificateToPIVCardDone", std::move(transaction));
 }
 
 void CertificateToPIVCardCommand::Private::authenticate()
 {
     qCDebug(KLEOPATRA_LOG) << "CertificateToPIVCardCommand::authenticate()";
 
-    auto cmd = new AuthenticatePIVCardApplicationCommand(mSerial, parentWidgetOrView());
+    auto cmd = new AuthenticatePIVCardApplicationCommand(serialNumber, parentWidgetOrView());
     connect(cmd, &AuthenticatePIVCardApplicationCommand::finished,
             q, [this]() { authenticationFinished(); });
     connect(cmd, &AuthenticatePIVCardApplicationCommand::canceled,
             q, [this]() { authenticationCanceled(); });
     cmd->start();
 }
 
 void CertificateToPIVCardCommand::Private::authenticationFinished()
 {
     qCDebug(KLEOPATRA_LOG) << "CertificateToPIVCardCommand::authenticationFinished()";
     if (!hasBeenCanceled) {
         startCertificateToPIVCard();
     }
 }
 
 void CertificateToPIVCardCommand::Private::authenticationCanceled()
 {
     qCDebug(KLEOPATRA_LOG) << "CertificateToPIVCardCommand::authenticationCanceled()";
     hasBeenCanceled = true;
     canceled();
 }
 
 CertificateToPIVCardCommand::CertificateToPIVCardCommand(const std::string& cardSlot, const std::string &serialno)
     : Command(new Private(this, cardSlot, serialno))
 {
 }
 
 CertificateToPIVCardCommand::~CertificateToPIVCardCommand()
 {
     qCDebug(KLEOPATRA_LOG) << "CertificateToPIVCardCommand::~CertificateToPIVCardCommand()";
 }
 
 void CertificateToPIVCardCommand::certificateToPIVCardDone(const Error &err)
 {
     qCDebug(KLEOPATRA_LOG) << "CertificateToPIVCardCommand::certificateToPIVCardDone():"
                            << err.asString() << "(" << err.code() << ")";
     if (err) {
         // gpgme 1.13 reports "BAD PIN" instead of "NO AUTH"
         if (err.code() == GPG_ERR_NO_AUTH || err.code() == GPG_ERR_BAD_PIN) {
             d->authenticate();
             return;
         }
 
-        d->error(i18nc("@info",
-                       "Writing the certificate to the card failed: %1", QString::fromUtf8(err.asString())),
-                        i18nc("@title", "Error"));
+        d->error(i18nc("@info", "Writing the certificate to the card failed: %1", QString::fromUtf8(err.asString())),
+                 i18nc("@title", "Error"));
     } else if (!err.isCanceled()) {
         KMessageBox::information(d->parentWidgetOrView(),
-                                 i18n("Successfully copied the certificate to the card."),
+                                 i18nc("@info", "Writing the certificate to the card succeeded."),
                                  i18nc("@title", "Success"));
         ReaderStatus::mutableInstance()->updateStatus();
     }
 
     d->finished();
 }
 
 void CertificateToPIVCardCommand::doStart()
 {
     qCDebug(KLEOPATRA_LOG) << "CertificateToPIVCardCommand::doStart()";
 
     d->start();
 }
 
 void CertificateToPIVCardCommand::doCancel()
 {
 }
 
 #undef q_func
 #undef d_func
diff --git a/src/view/pivcardwidget.cpp b/src/view/pivcardwidget.cpp
index a7897d7c5..c26e928d7 100644
--- a/src/view/pivcardwidget.cpp
+++ b/src/view/pivcardwidget.cpp
@@ -1,280 +1,293 @@
 /*  view/pivcardwiget.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2020 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "pivcardwidget.h"
 
 #include "commands/certificatetopivcardcommand.h"
 #include "commands/changepincommand.h"
 #include "commands/pivgeneratecardkeycommand.h"
 #include "commands/setpivcardapplicationadministrationkeycommand.h"
 
 #include "smartcard/pivcard.h"
 #include "smartcard/readerstatus.h"
 
 #include <QFrame>
 #include <QGridLayout>
 #include <QLabel>
 #include <QPushButton>
 #include <QScrollArea>
 #include <QVBoxLayout>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace Kleo::SmartCard;
 
 namespace {
 static QString formatVersion(int value)
 {
     if (value < 0) {
         return QLatin1String("n/a");
     }
 
     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);
 }
 } // Namespace
 
 PIVCardWidget::PIVCardWidget(QWidget *parent):
     QWidget(parent),
     mSerialNumber(new QLabel(this)),
     mVersionLabel(new QLabel(this)),
     mPIVAuthenticationKey(new QLabel(this)),
     mCardAuthenticationKey(new QLabel(this)),
     mDigitalSignatureKey(new QLabel(this)),
     mKeyManagementKey(new QLabel(this)),
     mGeneratePIVAuthenticationKeyBtn(new QPushButton(this)),
+    mWritePIVAuthenticationCertificateBtn(new QPushButton(this)),
     mGenerateCardAuthenticationKeyBtn(new QPushButton(this)),
+    mWriteCardAuthenticationCertificateBtn(new QPushButton(this)),
     mGenerateDigitalSignatureKeyBtn(new QPushButton(this)),
     mWriteDigitalSignatureCertificateBtn(new QPushButton(this)),
     mGenerateKeyManagementKeyBtn(new QPushButton(this)),
     mWriteKeyManagementCertificateBtn(new QPushButton(this))
 {
     auto grid = new QGridLayout;
     int row = 0;
 
     // Set up the scroll are
     auto area = new QScrollArea;
     area->setFrameShape(QFrame::NoFrame);
     area->setWidgetResizable(true);
     auto areaWidget = new QWidget;
     auto areaVLay = new QVBoxLayout(areaWidget);
     areaVLay->addLayout(grid);
     areaVLay->addStretch(1);
     area->setWidget(areaWidget);
     auto myLayout = new QVBoxLayout(this);
     myLayout->addWidget(area);
 
     // Version and Serialnumber
     grid->addWidget(mVersionLabel, row++, 0, 1, 2);
     mVersionLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
     grid->addWidget(new QLabel(i18n("Serial number:")), row, 0);
 
     grid->addWidget(mSerialNumber, row++, 1);
     mSerialNumber->setTextInteractionFlags(Qt::TextBrowserInteraction);
 
     // The keys
     auto line1 = new QFrame();
     line1->setFrameShape(QFrame::HLine);
     grid->addWidget(line1, row++, 0, 1, 4);
     grid->addWidget(new QLabel(QStringLiteral("<b>%1</b>").arg(i18n("Keys:"))), row++, 0);
 
     grid->addWidget(new QLabel(i18n("PIV authentication:")), row, 0);
     grid->addWidget(mPIVAuthenticationKey, row, 1);
     mPIVAuthenticationKey->setTextInteractionFlags(Qt::TextBrowserInteraction);
-    mGeneratePIVAuthenticationKeyBtn->setText(i18n("Generate"));
+    mGeneratePIVAuthenticationKeyBtn->setText(i18nc("@action:button", "Generate"));
     mGeneratePIVAuthenticationKeyBtn->setEnabled(false);
     grid->addWidget(mGeneratePIVAuthenticationKeyBtn, row, 2);
     connect(mGeneratePIVAuthenticationKeyBtn, &QPushButton::clicked, this, &PIVCardWidget::generatePIVAuthenticationKey);
+    mWritePIVAuthenticationCertificateBtn->setText(i18nc("@action:button", "Write Certificate"));
+    mWritePIVAuthenticationCertificateBtn->setToolTip(i18nc("@info:tooltip", "Write the certificate corresponding to this key to the card"));
+    mWritePIVAuthenticationCertificateBtn->setEnabled(false);
+    grid->addWidget(mWritePIVAuthenticationCertificateBtn, row, 3);
+    connect(mWritePIVAuthenticationCertificateBtn, &QPushButton::clicked, this, [this] () { writeCertificateToCard(PIVCard::pivAuthenticationKeyRef()); });
     row++;
 
     grid->addWidget(new QLabel(i18n("Card authentication:")), row, 0);
     grid->addWidget(mCardAuthenticationKey, row, 1);
     mCardAuthenticationKey->setTextInteractionFlags(Qt::TextBrowserInteraction);
-    mGenerateCardAuthenticationKeyBtn->setText(i18n("Generate"));
+    mGenerateCardAuthenticationKeyBtn->setText(i18nc("@action:button", "Generate"));
     mGenerateCardAuthenticationKeyBtn->setEnabled(false);
     grid->addWidget(mGenerateCardAuthenticationKeyBtn, row, 2);
     connect(mGenerateCardAuthenticationKeyBtn, &QPushButton::clicked, this, &PIVCardWidget::generateCardAuthenticationKey);
+    mWriteCardAuthenticationCertificateBtn->setText(i18nc("@action:button", "Write Certificate"));
+    mWriteCardAuthenticationCertificateBtn->setToolTip(i18nc("@info:tooltip", "Write the certificate corresponding to this key to the card"));
+    mWriteCardAuthenticationCertificateBtn->setEnabled(false);
+    grid->addWidget(mWriteCardAuthenticationCertificateBtn, row, 3);
+    connect(mWriteCardAuthenticationCertificateBtn, &QPushButton::clicked, this, [this] () { writeCertificateToCard(PIVCard::cardAuthenticationKeyRef()); });
     row++;
 
     grid->addWidget(new QLabel(i18n("Digital signature:")), row, 0);
     grid->addWidget(mDigitalSignatureKey, row, 1);
     mDigitalSignatureKey->setTextInteractionFlags(Qt::TextBrowserInteraction);
-    mGenerateDigitalSignatureKeyBtn->setText(i18n("Generate"));
+    mGenerateDigitalSignatureKeyBtn->setText(i18nc("@action:button", "Generate"));
     mGenerateDigitalSignatureKeyBtn->setEnabled(false);
     grid->addWidget(mGenerateDigitalSignatureKeyBtn, row, 2);
     connect(mGenerateDigitalSignatureKeyBtn, &QPushButton::clicked, this, &PIVCardWidget::generateDigitalSignatureKey);
-    mWriteDigitalSignatureCertificateBtn->setText(i18n("Write Certificate"));
-    mWriteDigitalSignatureCertificateBtn->setToolTip(i18n("Write the certificate corresponding to this key to the card"));
+    mWriteDigitalSignatureCertificateBtn->setText(i18nc("@action:button", "Write Certificate"));
+    mWriteDigitalSignatureCertificateBtn->setToolTip(i18nc("@info:tooltip", "Write the certificate corresponding to this key to the card"));
     mWriteDigitalSignatureCertificateBtn->setEnabled(false);
     grid->addWidget(mWriteDigitalSignatureCertificateBtn, row, 3);
     connect(mWriteDigitalSignatureCertificateBtn, &QPushButton::clicked, this, [this] () { writeCertificateToCard(PIVCard::digitalSignatureKeyRef()); });
     row++;
 
     grid->addWidget(new QLabel(i18n("Key management:")), row, 0);
     grid->addWidget(mKeyManagementKey, row, 1);
     mKeyManagementKey->setTextInteractionFlags(Qt::TextBrowserInteraction);
-    mGenerateKeyManagementKeyBtn->setText(i18n("Generate"));
+    mGenerateKeyManagementKeyBtn->setText(i18nc("@action:button", "Generate"));
     mGenerateKeyManagementKeyBtn->setEnabled(false);
     grid->addWidget(mGenerateKeyManagementKeyBtn, row, 2);
     connect(mGenerateKeyManagementKeyBtn, &QPushButton::clicked, this, &PIVCardWidget::generateKeyManagementKey);
-    mWriteKeyManagementCertificateBtn->setText(i18n("Write Certificate"));
-    mWriteKeyManagementCertificateBtn->setToolTip(i18n("Write the certificate corresponding to this key to the card"));
+    mWriteKeyManagementCertificateBtn->setText(i18nc("@action:button", "Write Certificate"));
+    mWriteKeyManagementCertificateBtn->setToolTip(i18nc("@info:tooltip", "Write the certificate corresponding to this key to the card"));
     mWriteKeyManagementCertificateBtn->setEnabled(false);
     grid->addWidget(mWriteKeyManagementCertificateBtn, row, 3);
     connect(mWriteKeyManagementCertificateBtn, &QPushButton::clicked, this, [this] () { writeCertificateToCard(PIVCard::keyManagementKeyRef()); });
     row++;
 
     auto line2 = new QFrame();
     line2->setFrameShape(QFrame::HLine);
     grid->addWidget(line2, row++, 0, 1, 4);
 
     auto actionLayout = new QHBoxLayout;
 
     {
-        auto button = new QPushButton(i18n("Change PIN"));
-        button->setToolTip(i18n("Change the PIV Card Application PIN that activates the PIV Card and enables private key operations using the stored keys."));
+        auto button = new QPushButton(i18nc("@action:button", "Change PIN"));
+        button->setToolTip(i18nc("@info:tooltip", "Change the PIV Card Application PIN that activates the PIV Card "
+                                 "and enables private key operations using the stored keys."));
         actionLayout->addWidget(button);
         connect(button, &QPushButton::clicked, this, [this] () { changePin(PIVCard::pinKeyRef()); });
     }
     {
-        auto button = new QPushButton(i18n("Change PUK"));
-        button->setToolTip(i18n("Change the PIN Unblocking Key that enables a reset of the PIN."));
+        auto button = new QPushButton(i18nc("@action:button", "Change PUK"));
+        button->setToolTip(i18nc("@info:tooltip", "Change the PIN Unblocking Key that enables a reset of the PIN."));
         actionLayout->addWidget(button);
         connect(button, &QPushButton::clicked, this, [this] () { changePin(PIVCard::pukKeyRef()); });
     }
     {
-        auto button = new QPushButton(i18n("Change Admin Key"));
-        button->setToolTip(i18n("Change the PIV Card Application Administration Key that is used by the "
-            "PIV Card Application to authenticate the PIV Card Application Administrator and by the "
-            "administrator (resp. Kleopatra) to authenticate the PIV Card Application."));
+        auto button = new QPushButton(i18nc("@action:button", "Change Admin Key"));
+        button->setToolTip(i18nc("@info:tooltip", "Change the PIV Card Application Administration Key that is used by the "
+                                 "PIV Card Application to authenticate the PIV Card Application Administrator and by the "
+                                 "administrator (resp. Kleopatra) to authenticate the PIV Card Application."));
         actionLayout->addWidget(button);
         connect(button, &QPushButton::clicked, this, [this] () { setAdminKey(); });
     }
 
     actionLayout->addStretch(-1);
     grid->addLayout(actionLayout, row++, 0, 1, 4);
 
     grid->setColumnStretch(4, -1);
 }
 
 PIVCardWidget::~PIVCardWidget()
 {
 }
 
 void PIVCardWidget::setCard(const PIVCard *card)
 {
     mCardSerialNumber = card->serialNumber();
-    mVersionLabel->setText(i18nc("Placeholder is a version number", "PIV v%1 card", formatVersion(card->appVersion())));
+    mVersionLabel->setText(i18nc("%1 version number", "PIV v%1 card", formatVersion(card->appVersion())));
 
     if (card->displaySerialNumber() != card->serialNumber()) {
         mSerialNumber->setText(QStringLiteral("%1 (%2)").arg(QString::fromStdString(card->displaySerialNumber()),
                                                              QString::fromStdString(card->serialNumber())));
     } else {
         mSerialNumber->setText(QString::fromStdString(card->serialNumber()));
     }
 
-    updateKey(PIVCard::pivAuthenticationKeyRef(), card, mPIVAuthenticationKey, mGeneratePIVAuthenticationKeyBtn, nullptr);
-    updateKey(PIVCard::cardAuthenticationKeyRef(), card, mCardAuthenticationKey, mGenerateCardAuthenticationKeyBtn, nullptr);
+    updateKey(PIVCard::pivAuthenticationKeyRef(), card, mPIVAuthenticationKey, mGeneratePIVAuthenticationKeyBtn, mWritePIVAuthenticationCertificateBtn);
+    updateKey(PIVCard::cardAuthenticationKeyRef(), card, mCardAuthenticationKey, mGenerateCardAuthenticationKeyBtn, mWriteCardAuthenticationCertificateBtn);
     updateKey(PIVCard::digitalSignatureKeyRef(), card, mDigitalSignatureKey, mGenerateDigitalSignatureKeyBtn, mWriteDigitalSignatureCertificateBtn);
     updateKey(PIVCard::keyManagementKeyRef(), card, mKeyManagementKey, mGenerateKeyManagementKeyBtn, mWriteKeyManagementCertificateBtn);
 }
 
 void PIVCardWidget::updateKey(const std::string &keyRef, const PIVCard *card, QLabel *label, QPushButton *generateButton, QPushButton *writeButton)
 {
     const std::string grip = card->keyGrip(keyRef);
-    label->setText(grip.empty() ? i18n("Slot empty") : QString::fromStdString(grip));
-    generateButton->setText(grip.empty() ? i18n("Generate") : i18n("Replace"));
+    label->setText(grip.empty() ? i18nc("@info", "Slot empty") : QString::fromStdString(grip));
+    generateButton->setText(grip.empty() ? i18nc("@action:button", "Generate") : i18nc("@action:button", "Replace"));
     generateButton->setToolTip(grip.empty() ?
-        i18nc("Placeholder is the display name of a key", "Generate %1", PIVCard::keyDisplayName(keyRef)) :
-        i18nc("Placeholder is the display name of a key", "Replace %1 with new key", PIVCard::keyDisplayName(keyRef)));
+        i18nc("@info:tooltip %1 display name of a key", "Generate %1", PIVCard::keyDisplayName(keyRef)) :
+        i18nc("@info:tooltip %1 display name of a key", "Replace %1 with new key", PIVCard::keyDisplayName(keyRef)));
     generateButton->setEnabled(true);
     if (writeButton) {
         writeButton->setEnabled(!grip.empty());
     }
 }
 
 void PIVCardWidget::generateKey(const std::string &keyref)
 {
     auto cmd = new PIVGenerateCardKeyCommand(mCardSerialNumber, this);
     this->setEnabled(false);
     connect(cmd, &PIVGenerateCardKeyCommand::finished,
             this, [this]() {
                 this->setEnabled(true);
             });
     cmd->setKeyRef(keyref);
     cmd->start();
 }
 
 void PIVCardWidget::writeCertificateToCard(const std::string &keyref)
 {
     auto cmd = new CertificateToPIVCardCommand(keyref, mCardSerialNumber);
     this->setEnabled(false);
     connect(cmd, &CertificateToPIVCardCommand::finished,
             this, [this]() {
                 this->setEnabled(true);
             });
     cmd->setParentWidget(this);
     cmd->start();
 }
 
 void PIVCardWidget::generatePIVAuthenticationKey()
 {
     generateKey(PIVCard::pivAuthenticationKeyRef());
 }
 
 void PIVCardWidget::generateCardAuthenticationKey()
 {
     generateKey(PIVCard::cardAuthenticationKeyRef());
 }
 
 void PIVCardWidget::generateDigitalSignatureKey()
 {
     generateKey(PIVCard::digitalSignatureKeyRef());
 }
 
 void PIVCardWidget::generateKeyManagementKey()
 {
     generateKey(PIVCard::keyManagementKeyRef());
 }
 
 void PIVCardWidget::changePin(const std::string &keyRef)
 {
     auto cmd = new ChangePinCommand(mCardSerialNumber, this);
     this->setEnabled(false);
     connect(cmd, &ChangePinCommand::finished,
             this, [this]() {
                 this->setEnabled(true);
             });
     cmd->setKeyRef(keyRef);
     cmd->start();
 }
 
 void PIVCardWidget::setAdminKey()
 {
     auto cmd = new SetPIVCardApplicationAdministrationKeyCommand(mCardSerialNumber, this);
     this->setEnabled(false);
     connect(cmd, &SetPIVCardApplicationAdministrationKeyCommand::finished,
             this, [this]() {
                 this->setEnabled(true);
             });
     cmd->start();
 }
diff --git a/src/view/pivcardwidget.h b/src/view/pivcardwidget.h
index d8aa89210..f59462d95 100644
--- a/src/view/pivcardwidget.h
+++ b/src/view/pivcardwidget.h
@@ -1,66 +1,68 @@
 /*  view/pivcardwiget.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2020 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 #ifndef VIEW_PIVCARDWIDGET_H
 #define VIEW_PIVCARDWIDGET_H
 
 #include <QWidget>
 
 #include <gpgme++/error.h>
 
 class QLabel;
 class QPushButton;
 
 namespace Kleo
 {
 
 namespace SmartCard
 {
 class PIVCard;
 } // namespace SmartCard
 
 class PIVCardWidget: public QWidget
 {
     Q_OBJECT
 public:
     explicit PIVCardWidget(QWidget *parent = nullptr);
     ~PIVCardWidget();
 
     void setCard(const SmartCard::PIVCard* card);
 
 private:
     void updateKey(const std::string &keyRef, const SmartCard::PIVCard *card, QLabel *label, QPushButton *generateButton, QPushButton *writeButton);
     void generateKey(const std::string &keyref);
     void writeCertificateToCard(const std::string &keyref);
     void changePin(const std::string &keyRef);
     void setAdminKey();
 
 private Q_SLOTS:
     void generatePIVAuthenticationKey();
     void generateCardAuthenticationKey();
     void generateDigitalSignatureKey();
     void generateKeyManagementKey();
 
 private:
     std::string mCardSerialNumber;
     QLabel *mSerialNumber = nullptr,
            *mVersionLabel = nullptr,
            *mPIVAuthenticationKey = nullptr,
            *mCardAuthenticationKey = nullptr,
            *mDigitalSignatureKey = nullptr,
            *mKeyManagementKey = nullptr;
     QPushButton *mGeneratePIVAuthenticationKeyBtn = nullptr,
+                *mWritePIVAuthenticationCertificateBtn = nullptr,
                 *mGenerateCardAuthenticationKeyBtn = nullptr,
+                *mWriteCardAuthenticationCertificateBtn = nullptr,
                 *mGenerateDigitalSignatureKeyBtn = nullptr,
                 *mWriteDigitalSignatureCertificateBtn = nullptr,
                 *mGenerateKeyManagementKeyBtn = nullptr,
                 *mWriteKeyManagementCertificateBtn = nullptr;
 };
 } // namespace Kleo
 
 #endif // VIEW_PIVCARDWIDGET_H