Remove CardInfo and add EstEID Thales support

src/controller/application.cpp

@@ -185,12 +185,12 @@ CommandWithArgumentsPtr Application::parseArgs()
 void Application::registerMetatypes()
 {
     qRegisterMetaType<electronic_id::AutoSelectFailed::Reason>();
-    qRegisterMetaType<electronic_id::CardInfo::ptr>();
-    qRegisterMetaType<std::vector<electronic_id::CardInfo::ptr>>();
+    qRegisterMetaType<electronic_id::ElectronicID::ptr>();
+    qRegisterMetaType<std::vector<electronic_id::ElectronicID::ptr>>();
     qRegisterMetaType<electronic_id::VerifyPinFailed::Status>();
 
-    qRegisterMetaType<CardCertificateAndPinInfo>();
-    qRegisterMetaType<std::vector<CardCertificateAndPinInfo>>();
+    qRegisterMetaType<EidCertificateAndPinInfo>();
+    qRegisterMetaType<std::vector<EidCertificateAndPinInfo>>();
 
     qRegisterMetaType<RetriableError>();
 }

src/controller/certandpininfo.hpp

@@ -48,13 +48,13 @@ struct PinInfo
     static constexpr int PIN_PAD_PIN_ENTRY_TIMEOUT = pcsc_cpp::PIN_PAD_PIN_ENTRY_TIMEOUT;
 };
 
-struct CardCertificateAndPinInfo
+struct EidCertificateAndPinInfo
 {
-    electronic_id::CardInfo::ptr cardInfo;
+    electronic_id::ElectronicID::ptr eid;
     QByteArray certificateBytesInDer;
     QSslCertificate certificate {};
     CertificateInfo certInfo;
     PinInfo pinInfo;
 };
 
-Q_DECLARE_METATYPE(CardCertificateAndPinInfo)
+Q_DECLARE_METATYPE(EidCertificateAndPinInfo)

src/controller/command-handlers/authenticate.cpp

@@ -118,20 +118,20 @@ Authenticate::Authenticate(const CommandWithArguments& cmd) : CertificateReader(
 }
 
 QVariantMap Authenticate::onConfirm(WebEidUI* window,
-                                    const CardCertificateAndPinInfo& cardCertAndPin)
+                                    const EidCertificateAndPinInfo& certAndPinInfo)
 {
     try {
         const auto signatureAlgorithm =
-            QString::fromStdString(cardCertAndPin.cardInfo->eid().authSignatureAlgorithm());
+            QString::fromStdString(certAndPinInfo.eid->authSignatureAlgorithm());
         pcsc_cpp::byte_vector pin;
         // Reserve space for APDU overhead (5 bytes) + PIN padding (16 bytes) to prevent PIN memory
         // reallocation. The 16-byte limit comes from the max PIN length of 12 bytes across all card
         // implementations in lib/libelectronic-id/src/electronic-ids/pcsc/.
         pin.reserve(5 + 16);
-        getPin(pin, cardCertAndPin.cardInfo->eid(), window);
-        const auto signature = createSignature(origin.url(), challengeNonce,
-                                               cardCertAndPin.cardInfo->eid(), std::move(pin));
-        return createAuthenticationToken(signatureAlgorithm, cardCertAndPin.certificateBytesInDer,
+        getPin(pin, *certAndPinInfo.eid, window);
+        const auto signature =
+            createSignature(origin.url(), challengeNonce, *certAndPinInfo.eid, std::move(pin));
+        return createAuthenticationToken(signatureAlgorithm, certAndPinInfo.certificateBytesInDer,
                                          signature);
 
     } catch (const VerifyPinFailed& failure) {

src/controller/command-handlers/authenticate.hpp

@@ -33,7 +33,7 @@ class Authenticate : public CertificateReader
 
     void connectSignals(const WebEidUI* window) override;
     QVariantMap onConfirm(WebEidUI* window,
-                          const CardCertificateAndPinInfo& cardCertAndPin) override;
+                          const EidCertificateAndPinInfo& certAndPinInfo) override;
 
 signals:
     void verifyPinFailed(const electronic_id::VerifyPinFailed::Status status,

src/controller/command-handlers/certificatereader.cpp

@@ -31,17 +31,17 @@ using namespace electronic_id;
 namespace
 {
 
-CardCertificateAndPinInfo getCertificateWithStatusAndInfo(const CardInfo::ptr& card,
-                                                          const CertificateType certificateType)
+EidCertificateAndPinInfo getCertificateWithStatusAndInfo(const ElectronicID::ptr& eid,
+                                                         const CertificateType certificateType)
 {
-    const auto certificateBytes = card->eid().getCertificate(certificateType);
+    const auto certificateBytes = eid->getCertificate(certificateType);
 
     QByteArray certificateDer(reinterpret_cast<const char*>(certificateBytes.data()),
                               int(certificateBytes.size()));
     QSslCertificate certificate(certificateDer, QSsl::Der);
     if (certificate.isNull()) {
         THROW(SmartCardChangeRequiredError,
-              "Invalid certificate returned by electronic ID " + card->eid().name());
+              "Invalid certificate returned by electronic ID " + eid->name());
     }
 
     auto subject = certificate.subjectInfo(QSslCertificate::CommonName).join(' ');
@@ -61,16 +61,16 @@ CardCertificateAndPinInfo getCertificateWithStatusAndInfo(const CardInfo::ptr& c
     CertificateInfo certInfo {
         certificateType, certificate.expiryDate() < QDateTime::currentDateTimeUtc(),
         certificate.effectiveDate() > QDateTime::currentDateTimeUtc(), std::move(subject)};
-    PinInfo pinInfo {certificateType.isAuthentication() ? card->eid().authPinMinMaxLength()
-                                                        : card->eid().signingPinMinMaxLength(),
-                     certificateType.isAuthentication() ? card->eid().authPinRetriesLeft()
-                                                        : card->eid().signingPinRetriesLeft(),
-                     card->eid().smartcard().readerHasPinPad()};
+    PinInfo pinInfo {certificateType.isAuthentication() ? eid->authPinMinMaxLength()
+                                                        : eid->signingPinMinMaxLength(),
+                     certificateType.isAuthentication() ? eid->authPinRetriesLeft()
+                                                        : eid->signingPinRetriesLeft(),
+                     eid->smartcard().readerHasPinPad()};
     if (pinInfo.pinRetriesCount.first == 0) {
         pinInfo.pinIsBlocked = true;
     }
 
-    return {card, std::move(certificateDer), certificate, std::move(certInfo), std::move(pinInfo)};
+    return {eid, std::move(certificateDer), certificate, std::move(certInfo), std::move(pinInfo)};
 }
 
 } // namespace
@@ -83,27 +83,27 @@ CertificateReader::CertificateReader(const CommandWithArguments& cmd) : CommandH
     }
 }
 
-void CertificateReader::run(const std::vector<CardInfo::ptr>& cards)
+void CertificateReader::run(const std::vector<ElectronicID::ptr>& eids)
 {
-    REQUIRE_NOT_EMPTY_CONTAINS_NON_NULL_PTRS(cards)
+    REQUIRE_NOT_EMPTY_CONTAINS_NON_NULL_PTRS(eids)
 
     certificateType = command.first == CommandType::AUTHENTICATE ? CertificateType::AUTHENTICATION
                                                                  : CertificateType::SIGNING;
 
-    std::vector<CardCertificateAndPinInfo> certInfos;
-    certInfos.reserve(cards.size());
-    for (const auto& card : cards) {
+    std::vector<EidCertificateAndPinInfo> certAndPinInfos;
+    certAndPinInfos.reserve(eids.size());
+    for (const auto& eid : eids) {
         try {
-            certInfos.push_back(getCertificateWithStatusAndInfo(card, certificateType));
+            certAndPinInfos.push_back(getCertificateWithStatusAndInfo(eid, certificateType));
         } catch (const WrongCertificateTypeError&) {
             // Ignore eIDs that don't support the given ceritifcate type.
         }
     }
 
-    if (certInfos.empty()) {
+    if (certAndPinInfos.empty()) {
         emit retry(RetriableError::NO_VALID_CERTIFICATE_AVAILABLE);
     } else {
-        emitCertificatesReady(certInfos);
+        emitCertificatesReady(certAndPinInfos);
     }
 }
 
@@ -117,12 +117,12 @@ void CertificateReader::connectSignals(const WebEidUI* window)
 }
 
 void CertificateReader::emitCertificatesReady(
-    const std::vector<CardCertificateAndPinInfo>& certInfos)
+    const std::vector<EidCertificateAndPinInfo>& certAndPinInfos)
 {
-    if (certInfos.size() == 1) {
-        emit singleCertificateReady(origin, certInfos[0]);
+    if (certAndPinInfos.size() == 1) {
+        emit singleCertificateReady(origin, certAndPinInfos[0]);
     } else {
-        emit multipleCertificatesReady(origin, certInfos);
+        emit multipleCertificatesReady(origin, certAndPinInfos);
     }
 }
 

src/controller/command-handlers/certificatereader.hpp

@@ -33,12 +33,12 @@ class CertificateReader : public CommandHandler
 public:
     explicit CertificateReader(const CommandWithArguments& cmd);
 
-    void run(const std::vector<electronic_id::CardInfo::ptr>& cards) override;
+    void run(const std::vector<electronic_id::ElectronicID::ptr>& eids) override;
     void connectSignals(const WebEidUI* window) override;
 
 protected:
     virtual void
-    emitCertificatesReady(const std::vector<CardCertificateAndPinInfo>& cardCertAndPinInfos);
+    emitCertificatesReady(const std::vector<EidCertificateAndPinInfo>& certAndPinInfos);
     void validateAndStoreOrigin(const QVariantMap& arguments);
 
     electronic_id::CertificateType certificateType = electronic_id::CertificateType::NONE;

src/controller/command-handlers/getcertificate.cpp

@@ -47,12 +47,12 @@ GetCertificate::GetCertificate(const CommandWithArguments& cmd) : CertificateRea
 }
 
 QVariantMap GetCertificate::onConfirm(WebEidUI* /* window */,
-                                      const CardCertificateAndPinInfo& cardCertAndPin)
+                                      const EidCertificateAndPinInfo& certAndPinInfo)
 {
     // Quoting https://tools.ietf.org/html/rfc7515#section-4.1.6:
     // Each string in the array is a Base64-encoded (Section 4 of [RFC4648] -- not
     // Base64url-encoded) DER [ITU.X690.2008] PKIX certificate value.
-    auto certPem = cardCertAndPin.certificateBytesInDer.toBase64();
-    auto algos = supportedSigningAlgos(cardCertAndPin.cardInfo->eid());
+    auto certPem = certAndPinInfo.certificateBytesInDer.toBase64();
+    auto algos = supportedSigningAlgos(*certAndPinInfo.eid);
     return {{"certificate", QString(certPem)}, {"supportedSignatureAlgorithms", algos}};
 }

src/controller/command-handlers/getcertificate.hpp

@@ -32,5 +32,5 @@ class GetCertificate : public CertificateReader
     GetCertificate(const CommandWithArguments& cmd);
 
     QVariantMap onConfirm(WebEidUI* window,
-                          const CardCertificateAndPinInfo& cardCertAndPin) override;
+                          const EidCertificateAndPinInfo& certAndPinInfo) override;
 };

src/controller/command-handlers/sign.cpp

@@ -69,14 +69,14 @@ Sign::Sign(const CommandWithArguments& cmd) : CertificateReader(cmd)
     validateAndStoreOrigin(arguments);
 }
 
-void Sign::emitCertificatesReady(const std::vector<CardCertificateAndPinInfo>& cardCertAndPinInfos)
+void Sign::emitCertificatesReady(const std::vector<EidCertificateAndPinInfo>& certAndPinInfos)
 {
-    const CardCertificateAndPinInfo* cardWithCertificateFromArgs = nullptr;
+    const EidCertificateAndPinInfo* cardWithCertificateFromArgs = nullptr;
 
-    for (const auto& cardCertAndPin : cardCertAndPinInfos) {
+    for (const auto& certAndPinInfo : certAndPinInfos) {
         // Check if the certificate read from the eID matches the certificate provided as argument.
-        if (cardCertAndPin.certificate.toDer() == userEidCertificateFromArgs) {
-            cardWithCertificateFromArgs = &cardCertAndPin;
+        if (certAndPinInfo.certificate.toDer() == userEidCertificateFromArgs) {
+            cardWithCertificateFromArgs = &certAndPinInfo;
         }
     }
 
@@ -86,28 +86,27 @@ void Sign::emitCertificatesReady(const std::vector<CardCertificateAndPinInfo>& c
         return;
     }
 
-    if (!cardWithCertificateFromArgs->cardInfo->eid().isSupportedSigningHashAlgorithm(hashAlgo)) {
+    if (!cardWithCertificateFromArgs->eid->isSupportedSigningHashAlgorithm(hashAlgo)) {
         THROW(ArgumentFatalError,
-              "Electronic ID " + cardWithCertificateFromArgs->cardInfo->eid().name()
+              "Electronic ID " + cardWithCertificateFromArgs->eid->name()
                   + " does not support hash algorithm " + std::string(hashAlgo));
     }
 
     emit singleCertificateReady(origin, *cardWithCertificateFromArgs);
 }
 
-QVariantMap Sign::onConfirm(WebEidUI* window, const CardCertificateAndPinInfo& cardCertAndPin)
+QVariantMap Sign::onConfirm(WebEidUI* window, const EidCertificateAndPinInfo& certAndPinInfo)
 {
     try {
         pcsc_cpp::byte_vector pin;
         // Reserve space for APDU overhead (5 bytes) + PIN padding (16 bytes) to prevent PIN memory
         // reallocation. The 16-byte limit comes from the max PIN length of 12 bytes across all card
         // implementations in lib/libelectronic-id/src/electronic-ids/pcsc/.
         pin.reserve(5 + 16);
-        getPin(pin, cardCertAndPin.cardInfo->eid(), window);
-        const auto signature =
-            signHash(cardCertAndPin.cardInfo->eid(), std::move(pin), docHash, hashAlgo);
-        return {{QStringLiteral("signature"), signature.first},
-                {QStringLiteral("signatureAlgorithm"), signature.second}};
+        getPin(pin, *certAndPinInfo.eid, window);
+        auto signature = signHash(*certAndPinInfo.eid, std::move(pin), docHash, hashAlgo);
+        return {{QStringLiteral("signature"), std::move(signature.first)},
+                {QStringLiteral("signatureAlgorithm"), std::move(signature.second)}};
 
     } catch (const VerifyPinFailed& failure) {
         switch (failure.status()) {

src/controller/command-handlers/sign.hpp

@@ -33,16 +33,16 @@ class Sign : public CertificateReader
 
     void connectSignals(const WebEidUI* window) override;
     QVariantMap onConfirm(WebEidUI* window,
-                          const CardCertificateAndPinInfo& cardCertAndPin) override;
+                          const EidCertificateAndPinInfo& certAndPinInfo) override;
 
 signals:
     void signingCertificateMismatch();
     void verifyPinFailed(const electronic_id::VerifyPinFailed::Status status,
                          const qint8 retriesLeft);
 
 private:
-    void emitCertificatesReady(
-        const std::vector<CardCertificateAndPinInfo>& cardCertAndPinInfos) override;
+    void
+    emitCertificatesReady(const std::vector<EidCertificateAndPinInfo>& certAndPinInfos) override;
     void validateAndStoreDocHashAndHashAlgo(const QVariantMap& args);
 
     QByteArray docHash;

src/controller/commandhandler.hpp

@@ -33,20 +33,18 @@ class CommandHandler : public QObject
 public:
     using ptr = std::unique_ptr<CommandHandler>;
 
-    virtual void run(const std::vector<electronic_id::CardInfo::ptr>& cards) = 0;
+    virtual void run(const std::vector<electronic_id::ElectronicID::ptr>& eids) = 0;
     virtual void connectSignals(const WebEidUI* window) = 0;
     virtual QVariantMap onConfirm(WebEidUI* window,
-                                  const CardCertificateAndPinInfo& cardCertAndPin) = 0;
+                                  const EidCertificateAndPinInfo& certAndPinInfo) = 0;
 
     CommandType commandType() const { return command.first; }
 
 signals:
     void retry(const RetriableError error);
-    void
-    multipleCertificatesReady(const QUrl& origin,
-                              const std::vector<CardCertificateAndPinInfo>& cardCertAndPinInfos);
-    void singleCertificateReady(const QUrl& origin,
-                                const CardCertificateAndPinInfo& cardCertAndPinInfo);
+    void multipleCertificatesReady(const QUrl& origin,
+                                   const std::vector<EidCertificateAndPinInfo>& certAndPinInfos);
+    void singleCertificateReady(const QUrl& origin, const EidCertificateAndPinInfo& certAndPinInfo);
 
 protected:
     CommandHandler(const CommandWithArguments& cmd) : command(cmd) {}

src/controller/controller.cpp

@@ -163,36 +163,37 @@ void Controller::connectOkCancelWaitingForPinPad()
     connect(window, &WebEidUI::waitingForPinPad, this, &Controller::onConfirmCommandHandler);
 }
 
-void Controller::onCardsAvailable(const std::vector<electronic_id::CardInfo::ptr>& availableCards)
+void Controller::onCardsAvailable(
+    const std::vector<electronic_id::ElectronicID::ptr>& availableEids)
 {
     try {
         REQUIRE_NON_NULL(commandHandler)
         REQUIRE_NON_NULL(window)
-        REQUIRE_NOT_EMPTY_CONTAINS_NON_NULL_PTRS(availableCards)
+        REQUIRE_NOT_EMPTY_CONTAINS_NON_NULL_PTRS(availableEids)
 
-        for (const auto& card : availableCards) {
+        for (const auto& card : availableEids) {
             const auto protocol =
-                card->eid().smartcard().protocol() == SmartCard::Protocol::T0 ? "T=0" : "T=1";
-            qInfo() << "Card" << card->eid().name() << "in reader" << card->reader().name
+                card->smartcard().protocol() == SmartCard::Protocol::T0 ? "T=0" : "T=1";
+            qInfo() << "Card" << card->name() << "in reader" << card->smartcard().readerName()
                     << "using protocol" << protocol;
         }
 
         window->showWaitingForCardPage(commandHandler->commandType());
 
         commandHandler->connectSignals(window);
 
-        runCommandHandler(availableCards);
+        runCommandHandler(availableEids);
 
     } catch (const std::exception& error) {
         onCriticalFailure(error.what());
     }
 }
 
-void Controller::runCommandHandler(const std::vector<electronic_id::CardInfo::ptr>& availableCards)
+void Controller::runCommandHandler(const std::vector<ElectronicID::ptr>& availableEids)
 {
     try {
         CommandHandlerRunThread* commandHandlerRunThread =
-            new CommandHandlerRunThread(this, *commandHandler, availableCards);
+            new CommandHandlerRunThread(this, *commandHandler, availableEids);
         saveChildThreadPtrAndConnectFailureFinish(commandHandlerRunThread);
         connectRetry(commandHandlerRunThread);
 
@@ -247,13 +248,13 @@ void Controller::disposeUI()
     }
 }
 
-void Controller::onConfirmCommandHandler(const CardCertificateAndPinInfo& cardCertAndPinInfo)
+void Controller::onConfirmCommandHandler(const EidCertificateAndPinInfo& certAndPinInfo)
 {
     stopCardEventMonitorThread();
 
     try {
         CommandHandlerConfirmThread* commandHandlerConfirmThread =
-            new CommandHandlerConfirmThread(this, *commandHandler, window, cardCertAndPinInfo);
+            new CommandHandlerConfirmThread(this, *commandHandler, window, certAndPinInfo);
         connect(commandHandlerConfirmThread, &CommandHandlerConfirmThread::completed, this,
                 &Controller::onCommandHandlerConfirmCompleted);
         saveChildThreadPtrAndConnectFailureFinish(commandHandlerConfirmThread);
@@ -317,10 +318,10 @@ void Controller::connectRetry(const ControllerChildThread* childThread)
     connect(window, &WebEidUI::retry, this, &Controller::onRetry);
 }
 
-void Controller::onDialogOK(const CardCertificateAndPinInfo& cardCertAndPinInfo)
+void Controller::onDialogOK(const EidCertificateAndPinInfo& certAndPinInfo)
 {
     if (commandHandler) {
-        onConfirmCommandHandler(cardCertAndPinInfo);
+        onConfirmCommandHandler(certAndPinInfo);
     } else {
         // This should not happen, and when it does, OK should be equivalent to cancel.
         onPinPadCancel();