qt/qtconnectivity/src/nfc/pcsc/qpcsccard.cpp

Revision control

++ // Copyright (C) 2022 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++ // Qt-Security score:critical reason:data-parser
++
++ #include "qpcsccard_p.h"
++ #include "ndef/qnfctagtype4ndeffsm_p.h"
++ #include "qapduutils_p.h"
++ #include <QtCore/QLoggingCategory>
++ #include <QtCore/QTimer>
++
++ #if defined(Q_OS_DARWIN)
++ # define SCARD_ATTR_MAXINPUT 0x0007A007
++ #elif !defined(Q_OS_WIN)
++ # include <reader.h>
++ #endif
++
++ QT_BEGIN_NAMESPACE
++
++ Q_DECLARE_LOGGING_CATEGORY(QT_NFC_PCSC)
++
++ /*
++ Windows SCardBeginTransaction() documentation says the following:
++
++ If a transaction is held on the card for more than five seconds with no
++ operations happening on that card, then the card is reset. Calling any
++ of the Smart Card and Reader Access Functions or Direct Card Access
++ Functions on the card that is transacted results in the timer being
++ reset to continue allowing the transaction to be used.
++
++ We use a timer to ensure that transactions do not timeout unexpectedly.
++ */
++ static constexpr int KeepAliveIntervalMs = 2500;
++
++ /*
++ Start a temporary transaction if a persistent transaction was not already
++ started due to call to onSendCommandRequest().
++
++ If a temporary transaction was initiated, it is ended when this object is
++ destroyed.
++ */
++ QPcscCard::Transaction::Transaction(QPcscCard *card) : m_card(card)
++ {
++ qCDebug(QT_NFC_PCSC) << Q_FUNC_INFO;
++ if (!m_card->isValid() || m_card->m_inAutoTransaction)
++ return;
++
++ auto ret = SCardBeginTransaction(m_card->m_handle);
++ if (ret != SCARD_S_SUCCESS) {
++ qCWarning(QT_NFC_PCSC) << "SCardBeginTransaction failed:" << QPcsc::errorMessage(ret);
++ m_card->invalidate();
++ return;
++ }
++
++ m_initiated = true;
++ }
++
++ QPcscCard::Transaction::~Transaction()
++ {
++ qCDebug(QT_NFC_PCSC) << Q_FUNC_INFO;
++ if (!m_initiated || !m_card->isValid())
++ return;
++
++ auto ret = SCardEndTransaction(m_card->m_handle, SCARD_LEAVE_CARD);
++
++ if (ret != SCARD_S_SUCCESS) {
++ qCWarning(QT_NFC_PCSC) << "SCardEndTransaction failed:" << QPcsc::errorMessage(ret);
++ m_card->invalidate();
++ }
++ }
++
++ QPcscCard::QPcscCard(SCARDHANDLE handle, DWORD protocol, QObject *parent)
++ : QObject(parent), m_handle(handle)
++ {
++ qCDebug(QT_NFC_PCSC) << Q_FUNC_INFO;
++
++ m_keepAliveTimer = new QTimer(this);
++ m_keepAliveTimer->setInterval(KeepAliveIntervalMs);
++ connect(m_keepAliveTimer, &QTimer::timeout, this, &QPcscCard::onKeepAliveTimeout);
++
++ m_ioPci.dwProtocol = protocol;
++ m_ioPci.cbPciLength = sizeof(m_ioPci);
++
++ // Assume that everything is NFC Tag Type 4 for now
++ m_tagDetectionFsm = std::make_unique<QNfcTagType4NdefFsm>();
++
++ performNdefDetection();
++ }
++
++ QPcscCard::~QPcscCard()
++ {
++ qCDebug(QT_NFC_PCSC) << Q_FUNC_INFO;
++ invalidate();
++ }
++
++ void QPcscCard::performNdefDetection()
++ {
++ qCDebug(QT_NFC_PCSC) << Q_FUNC_INFO;
++
++ if (!m_isValid)
++ return;
++
++ Transaction transaction(this);
++
++ auto action = m_tagDetectionFsm->detectNdefSupport();
++
++ while (action == QNdefAccessFsm::SendCommand) {
++ auto command = m_tagDetectionFsm->getCommand(action);
++
++ if (action == QNdefAccessFsm::ProvideResponse) {
++ auto result = sendCommand(command, NoAutoTransaction);
++ action = m_tagDetectionFsm->provideResponse(result.response);
++ }
++ }
++
++ qCDebug(QT_NFC_PCSC) << "NDEF detection result" << action;
++
++ m_supportsNdef = action == QNdefAccessFsm::Done;
++ qCDebug(QT_NFC_PCSC) << "NDEF supported:" << m_supportsNdef;
++ }
++
++ /*
++ Release the resource associated with the card and notify the NFC target
++ about disconnection. The card is deleted when automatic deletion is enabled.
++ */
++ void QPcscCard::invalidate()
++ {
++ if (!m_isValid)
++ return;
++
++ SCardDisconnect(m_handle, m_inAutoTransaction ? SCARD_RESET_CARD : SCARD_LEAVE_CARD);
++
++ m_isValid = false;
++ m_inAutoTransaction = false;
++
++ Q_EMIT disconnected();
++ Q_EMIT invalidated();
++
++ if (m_autodelete)
++ deleteLater();
++ }
++
++ /*
++ Send the given command to the card.
++
++ Start an automatic transaction if autoTransaction is StartAutoTransaction
++ and it is not already started. This automatic transaction lasts until the
++ invalidate() or onDisconnectRequest() is called.
++
++ The automatic transaction is used to ensure that other applications do not
++ interfere with commands sent by the user application.
++
++ If autoTransaction is NoAutoTransaction, then the calling code should ensure
++ that either the command is atomic or that a temporary transaction is started
++ using Transaction object.
++ */
++ QPcsc::RawCommandResult QPcscCard::sendCommand(const QByteArray &command,
++ QPcscCard::AutoTransaction autoTransaction)
++ {
++ if (!m_isValid)
++ return {};
++
++ if (!m_inAutoTransaction && autoTransaction == StartAutoTransaction) {
++ qCDebug(QT_NFC_PCSC) << "Starting transaction";
++
++ // FIXME: Is there a timeout on this?
++ auto ret = SCardBeginTransaction(m_handle);
++ if (ret != SCARD_S_SUCCESS) {
++ qCWarning(QT_NFC_PCSC) << "SCardBeginTransaction failed:" << QPcsc::errorMessage(ret);
++ invalidate();
++ return {};
++ }
++ m_inAutoTransaction = true;
++ m_keepAliveTimer->start();
++ }
++
++ QPcsc::RawCommandResult result;
++ result.response.resize(0xFFFF + 2);
++ DWORD recvLength = result.response.size();
++
++ qCDebug(QT_NFC_PCSC) << "TX:" << command.toHex(':');
++
++ result.ret = SCardTransmit(m_handle, &m_ioPci, reinterpret_cast<LPCBYTE>(command.constData()),
++ command.size(), nullptr,
++ reinterpret_cast<LPBYTE>(result.response.data()), &recvLength);
++ if (result.ret != SCARD_S_SUCCESS) {
++ qCWarning(QT_NFC_PCSC) << "SCardTransmit failed:" << QPcsc::errorMessage(result.ret);
++ result.response.clear();
++ invalidate();
++ } else {
++ result.response.resize(recvLength);
++ qCDebug(QT_NFC_PCSC) << "RX:" << result.response.toHex(':');
++ }
++
++ return result;
++ }
++
++ void QPcscCard::onKeepAliveTimeout()
++ {
++ if (!m_isValid || !m_inAutoTransaction) {
++ m_keepAliveTimer->stop();
++ return;
++ }
++
++ checkCardPresent();
++ }
++
++ QByteArray QPcscCard::readUid()
++ {
++ QByteArray command = QCommandApdu::build(0xFF, QCommandApdu::GetData, 0x00, 0x00, {}, 256);
++
++ // Atomic command, no need for transaction.
++ QResponseApdu res(sendCommand(command, NoAutoTransaction).response);
++ if (!res.isOk())
++ return {};
++ return res.data();
++ }
++
++ void QPcscCard::onReadNdefMessagesRequest(const QNearFieldTarget::RequestId &request)
++ {
++ if (!m_isValid) {
++ Q_EMIT requestCompleted(request, QNearFieldTarget::ConnectionError, {});
++ return;
++ }
++
++ if (!m_supportsNdef) {
++ Q_EMIT requestCompleted(request, QNearFieldTarget::UnsupportedError, {});
++ return;
++ }
++
++ Transaction transaction(this);
++
++ auto nextState = m_tagDetectionFsm->readMessages();
++
++ while (true) {
++ if (nextState == QNdefAccessFsm::SendCommand) {
++ auto command = m_tagDetectionFsm->getCommand(nextState);
++
++ if (nextState == QNdefAccessFsm::ProvideResponse) {
++ auto result = sendCommand(command, NoAutoTransaction);
++ nextState = m_tagDetectionFsm->provideResponse(result.response);
++ }
++ } else if (nextState == QNdefAccessFsm::GetMessage) {
++ auto message = m_tagDetectionFsm->getMessage(nextState);
++ Q_EMIT ndefMessageRead(message);
++ } else {
++ break;
++ }
++ }
++
++ qCDebug(QT_NFC_PCSC) << "Final state:" << nextState;
++ auto errorCode = (nextState == QNdefAccessFsm::Done) ? QNearFieldTarget::NoError
++ : QNearFieldTarget::NdefReadError;
++ Q_EMIT requestCompleted(request, errorCode, {});
++ }
++
++ /*
++ Ends the persistent transaction and resets the card if sendCommand() was
++ used by user.
++
++ Resetting the card ensures that the current state of the card does not get
++ shared with other processes.
++ */
++ void QPcscCard::onDisconnectRequest()
++ {
++ qCDebug(QT_NFC_PCSC) << Q_FUNC_INFO;
++
++ if (!m_isValid)
++ return;
++
++ LONG ret;
++ if (m_inAutoTransaction) {
++ // NOTE: PCSCLite does not automatically release transaction in
++ ret = SCardEndTransaction(m_handle, SCARD_RESET_CARD);
++ if (ret != SCARD_S_SUCCESS) {
++ qCWarning(QT_NFC_PCSC) << "SCardEndTransaction failed:" << QPcsc::errorMessage(ret);
++ invalidate();
++ return;
++ }
++
++ m_inAutoTransaction = false;
++ }
++
++ DWORD activeProtocol;
++ ret = SCardReconnect(m_handle, SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1,
++ SCARD_LEAVE_CARD, &activeProtocol);
++ if (ret != SCARD_S_SUCCESS) {
++ qCWarning(QT_NFC_PCSC) << "SCardReconnect failed:" << QPcsc::errorMessage(ret);
++ invalidate();
++ return;
++ }
++
++ Q_EMIT disconnected();
++ }
++
++ void QPcscCard::onTargetDestroyed()
++ {
++ qCDebug(QT_NFC_PCSC) << Q_FUNC_INFO;
++ invalidate();
++ }
++
++ void QPcscCard::onSendCommandRequest(const QNearFieldTarget::RequestId &request,
++ const QByteArray &command)
++ {
++ qCDebug(QT_NFC_PCSC) << Q_FUNC_INFO;
++
++ if (!m_isValid) {
++ Q_EMIT requestCompleted(request, QNearFieldTarget::ConnectionError, {});
++ return;
++ }
++
++ auto result = sendCommand(command, StartAutoTransaction);
++ if (result.isOk())
++ Q_EMIT requestCompleted(request, QNearFieldTarget::NoError, result.response);
++ else
++ Q_EMIT requestCompleted(request, QNearFieldTarget::CommandError, {});
++ }
++
++ void QPcscCard::onWriteNdefMessagesRequest(const QNearFieldTarget::RequestId &request,
++ const QList<QNdefMessage> &messages)
++ {
++ qCDebug(QT_NFC_PCSC) << Q_FUNC_INFO;
++
++ if (!m_isValid) {
++ Q_EMIT requestCompleted(request, QNearFieldTarget::ConnectionError, {});
++ return;
++ }
++
++ if (!m_supportsNdef) {
++ Q_EMIT requestCompleted(request, QNearFieldTarget::UnsupportedError, {});
++ return;
++ }
++
++ Transaction transaction(this);
++
++ auto nextState = m_tagDetectionFsm->writeMessages(messages);
++
++ while (nextState == QNdefAccessFsm::SendCommand) {
++ auto command = m_tagDetectionFsm->getCommand(nextState);
++ if (nextState == QNdefAccessFsm::ProvideResponse) {
++ auto result = sendCommand(command, NoAutoTransaction);
++ nextState = m_tagDetectionFsm->provideResponse(result.response);
++ }
++ }
++
++ auto errorCode = (nextState == QNdefAccessFsm::Done) ? QNearFieldTarget::NoError
++ : QNearFieldTarget::NdefWriteError;
++ Q_EMIT requestCompleted(request, errorCode, {});
++ }
++
++ /*
++ Enable automatic card deletion when the connection is closed by the user
++ or the card otherwise becomes unavailable.
++
++ The automatic deletion is prevented initially so that
++ QNearFieldManagerPrivate can safely establish connections between this
++ object and a QNearFieldTargetPrivate proxy.
++ */
++ void QPcscCard::enableAutodelete()
++ {
++ qCDebug(QT_NFC_PCSC) << Q_FUNC_INFO;
++
++ m_autodelete = true;
++ if (!m_isValid)
++ deleteLater();
++ }
++
++ /*
++ Check if the card is still present in the reader.
++
++ Invalidates the object if card is not present.
++ */
++ bool QPcscCard::checkCardPresent()
++ {
++ qCDebug(QT_NFC_PCSC) << Q_FUNC_INFO;
++
++ if (!m_isValid)
++ return false;
++
++ DWORD state;
++ auto ret = SCardStatus(m_handle, nullptr, nullptr, &state, nullptr, nullptr, nullptr);
++ if (ret != SCARD_S_SUCCESS) {
++ qCWarning(QT_NFC_PCSC) << "SCardStatus failed:" << QPcsc::errorMessage(ret);
++ invalidate();
++ return false;
++ }
++
++ qCDebug(QT_NFC_PCSC) << "State:" << Qt::hex << state;
++
++ return (state & SCARD_PRESENT) != 0;
++ }
++
++ int QPcscCard::readMaxInputLength()
++ {
++ if (!m_isValid)
++ return 0;
++
++ // Maximum standard APDU length
++ static constexpr int DefaultMaxInputLength = 261;
++
++ uint32_t maxInput;
++ DWORD attrSize = sizeof(maxInput);
++ auto ret = SCardGetAttrib(m_handle, SCARD_ATTR_MAXINPUT, reinterpret_cast<LPBYTE>(&maxInput),
++ &attrSize);
++ if (ret != SCARD_S_SUCCESS) {
++ qCDebug(QT_NFC_PCSC) << "SCardGetAttrib failed:" << QPcsc::errorMessage(ret);
++ return DefaultMaxInputLength;
++ }
++
++ if (attrSize != sizeof(maxInput)) {
++ qCWarning(QT_NFC_PCSC) << "Unexpected attribute size for SCARD_ATTR_MAXINPUT:" << attrSize;
++ return DefaultMaxInputLength;
++ }
++
++ return static_cast<int>(maxInput);
++ }
++
++ QT_END_NAMESPACE