CalypsoCardAdapter.h

Go to the documentation of this file.

/**************************************************************************************************
 * Copyright (c) 2023 Calypso Networks Association https://calypsonet.org/                        *
 *                                                                                                *
 * See the NOTICE file(s) distributed with this work for additional information regarding         *
 * copyright ownership.                                                                           *
 *                                                                                                *
 * This program and the accompanying materials are made available under the terms of the Eclipse  *
 * Public License 2.0 which is available at http://www.eclipse.org/legal/epl-2.0                  *
 *                                                                                                *
 * SPDX-License-Identifier: EPL-2.0                                                               *
 **************************************************************************************************/
 
#pragma once
 
#include <cstdint>
#include <memory>
#include <ostream>
#include <string>
#include <vector>
 
/* Calypsonet Terminal Calypso */
#include "CalypsoCard.h"
#include "DirectoryHeader.h"
#include "ElementaryFile.h"
 
/* Calypsonet Terminal Card */
#include "ApduResponseApi.h"
#include "CardSelectionResponseApi.h"
#include "SmartCardSpi.h"
 
/* Keyple Card Calypso */
#include "CalypsoCardClass.h"
#include "CmdCardGetDataFci.h"
#include "ElementaryFileAdapter.h"
#include "KeypleCardCalypsoExport.h"
 
/* Keyple Core Util */
#include "LoggerFactory.h"
 
 
namespace keyple {
namespace card {
namespace calypso {
 
using namespace calypsonet::terminal::calypso::card;
using namespace calypsonet::terminal::card;
using namespace calypsonet::terminal::card::spi;
using namespace keyple::core::util::cpp;
 
/* Forward declaration */
class CmdCardGetDataFci;
 
class KEYPLECARDCALYPSO_API CalypsoCardAdapter final
: public CalypsoCard,
  public SmartCardSpi,
  public std::enable_shared_from_this<CalypsoCardAdapter> {
public:
    CalypsoCardAdapter();
 
    void initialize(const std::shared_ptr<CardSelectionResponseApi> cardSelectionResponse);
 
    void initializeWithFci(const std::shared_ptr<CmdCardGetDataFci> cmdCardGetDataFci);
 
    const CalypsoCard::ProductType& getProductType() const override;
 
    bool isHce() const override;
 
    const std::vector<uint8_t>& getDfName() const override;
 
    const std::vector<uint8_t>& getCalypsoSerialNumberFull() const;
 
    const std::vector<uint8_t> getApplicationSerialNumber() const override;
 
    const std::vector<uint8_t>& getStartupInfoRawData() const override;
 
    uint8_t getPayloadCapacity() const;
 
    bool isModificationsCounterInBytes() const;
 
    int getModificationsCounter() const;
 
    uint8_t getPlatform() const override;
 
    uint8_t getApplicationType() const override;
 
    bool isExtendedModeSupported() const override;
 
    bool isRatificationOnDeselectSupported() const override;
 
    bool isSvFeatureAvailable() const override;
 
    bool isPinFeatureAvailable() const override;
 
    bool isPkiModeSupported() const override;
 
    uint8_t getApplicationSubtype() const override;
 
    uint8_t getSoftwareIssuer() const override;
 
    uint8_t getSoftwareVersion() const override;
 
    uint8_t getSoftwareRevision() const override;
 
    uint8_t getSessionModification() const override;
 
    const std::vector<uint8_t> getTraceabilityInformation() const override;
 
    bool isDfInvalidated() const override;
 
    bool isDfRatified() const override;
 
    int getTransactionCounter() const override;
 
    void setTransactionCounter(const int transactionCounter);
 
    void setSvData(const uint8_t svKvc,
                   const std::vector<uint8_t>& svGetHeader,
                   const std::vector<uint8_t>& svGetData,
                   const int svBalance,
                   const int svLastTNum,
                   const std::shared_ptr<SvLoadLogRecord> svLoadLogRecord,
                   const std::shared_ptr<SvDebitLogRecord> svDebitLogRecord);
 
    int getSvBalance() const override;
 
    int getSvLastTNum() const override;
 
    const std::shared_ptr<SvLoadLogRecord> getSvLoadLogRecord() override;
 
    const std::shared_ptr<SvDebitLogRecord> getSvDebitLogLastRecord() override;
 
    const std::vector<std::shared_ptr<SvDebitLogRecord>> getSvDebitLogAllRecords() const override;
 
    void setDfRatified(const bool dfRatified);
 
    CalypsoCardClass getCardClass() const;
 
    const std::shared_ptr<DirectoryHeader> getDirectoryHeader() const override;
 
    CalypsoCard& setDirectoryHeader(const std::shared_ptr<DirectoryHeader> directoryHeader);
 
    const std::shared_ptr<ElementaryFile> getFileBySfi(const uint8_t sfi) const override;
 
    const std::shared_ptr<ElementaryFile> getFileByLid(const uint16_t lid) const override;
 
    const std::map<const uint8_t, const std::shared_ptr<ElementaryFile>> getAllFiles() const
        override;
 
    const std::vector<std::shared_ptr<ElementaryFile>>& getFiles() const override;
 
    bool isPinBlocked() const override;
 
    int getPinAttemptRemaining() const override;
 
    void setPinAttemptRemaining(const int pinAttemptCounter);
 
    void setFileHeader(const uint8_t sfi, const std::shared_ptr<FileHeaderAdapter> header);
 
    void setContent(const uint8_t sfi,
                    const uint8_t numRecord,
                    const std::vector<uint8_t>& content);
 
    void setCounter(const uint8_t sfi,
                    const uint8_t numCounter,
                    const std::vector<uint8_t>& content);
 
    void setContent(const uint8_t sfi,
                    const uint8_t numRecord,
                    const std::vector<uint8_t>& content,
                    const int offset);
 
    void fillContent(const uint8_t sfi,
                     const uint8_t numRecord,
                     const std::vector<uint8_t>& content,
                     const int offset);
 
    void addCyclicContent(const uint8_t sfi, const std::vector<uint8_t> content);
 
    void backupFiles();
 
    void restoreFiles();
 
    const std::string& getPowerOnData() const override;
 
    const std::vector<uint8_t> getSelectApplicationResponse() const override;
 
    void setCardChallenge(const std::vector<uint8_t>& cardChallenge);
 
    void setTraceabilityInformation(const std::vector<uint8_t>& traceabilityInformation);
 
    void setSvOperationSignature(const std::vector<uint8_t>& svOperationSignature);
 
    const std::vector<uint8_t>& getCardChallenge() const;
 
    uint8_t getSvKvc() const;
 
    const std::vector<uint8_t>& getSvGetHeader() const;
 
    const std::vector<uint8_t>& getSvGetData() const;
 
    const std::vector<uint8_t>& getSvOperationSignature() const;
 
    bool isCounterValuePostponed() const;
 
    friend KEYPLECARDCALYPSO_API std::ostream& operator<<(std::ostream& os,
                                                          const CalypsoCardAdapter& cca);
 
    friend KEYPLECARDCALYPSO_API std::ostream& operator<<(
        std::ostream& os, const std::shared_ptr<CalypsoCardAdapter> cca);
 
private:
    class Patch {
    public:
        friend class CalypsoCardAdapter;
 
        virtual void apply(CalypsoCardAdapter* calypsoCard) = 0;
 
    private:
        const uint64_t mStartupInfo;
 
        const uint64_t mMask = ~0;
 
        Patch(const std::string& startupInfo);
 
        Patch(const std::string& startupInfo, const std::string& mask);
 
        bool isApplicableTo(const uint64_t startupInfo) const;
    };
 
    class PatchRev3 : public Patch {
    public:
        friend class CalypsoCardAdapter;
 
        virtual ~PatchRev3() = default;
 
        void apply(CalypsoCardAdapter* calypsoCard) override;
 
    private:
        std::shared_ptr<int> mPayloadCapacity;
 
        PatchRev3(const std::string& startupInfo);
 
        PatchRev3(const std::string& startupInfo, const std::string& mask);
 
 
        PatchRev3& setPayloadCapacity(const int payloadCapacity);
    };
 
    class PatchRev12 : public Patch {
    public:
        friend class CalypsoCardAdapter;
 
        virtual ~PatchRev12() = default;
 
        void apply(CalypsoCardAdapter* calypsoCard) override;
 
    private:
        std::shared_ptr<bool> mIsCounterValuePostponed;
 
        PatchRev12(const std::string& startupInfo);
 
        PatchRev12(const std::string& startupInfo, const std::string& mask);
 
        PatchRev12& setCounterValuePostponed();
    };
 
    const std::unique_ptr<Logger> mLogger = LoggerFactory::getLogger(typeid(CalypsoCardAdapter));
 
    static const std::string PATTERN_1_BYTE_HEX;
    static const std::string PATTERN_2_BYTES_HEX;
 
    static const int CARD_REV1_ATR_LENGTH;
    static const int REV1_CARD_DEFAULT_WRITE_OPERATIONS_NUMBER_SUPPORTED_PER_SESSION;
    static const int REV2_CARD_DEFAULT_WRITE_OPERATIONS_NUMBER_SUPPORTED_PER_SESSION;
    static const int SI_BUFFER_SIZE_INDICATOR;
    static const int SI_PLATFORM;
    static const int SI_APPLICATION_TYPE;
    static const int SI_APPLICATION_SUBTYPE;
    static const int SI_SOFTWARE_ISSUER;
    static const int SI_SOFTWARE_VERSION;
    static const int SI_SOFTWARE_REVISION;
    static const int DEFAULT_PAYLOAD_CAPACITY;
 
    static const uint8_t APP_TYPE_WITH_CALYPSO_PIN;
    static const uint8_t APP_TYPE_WITH_CALYPSO_SV;
    static const uint8_t APP_TYPE_RATIFICATION_COMMAND_REQUIRED;
    static const uint8_t APP_TYPE_CALYPSO_REV_32_MODE;
    static const uint8_t APP_TYPE_WITH_PUBLIC_AUTHENTICATION;
 
    static const std::vector<int> BUFFER_SIZE_INDICATOR_TO_BUFFER_SIZE;
 
    std::shared_ptr<ApduResponseApi> mSelectApplicationResponse;
 
    std::string mPowerOnData;
 
    bool mIsExtendedModeSupported = false;
 
    bool mIsRatificationOnDeselectSupported = false;
 
    bool mIsSvFeatureAvailable = false;
 
    bool mIsPinFeatureAvailable = false;
 
    bool mIsPkiModeSupported = false;
 
    bool mIsDfInvalidated = false;
 
    CalypsoCardClass mCalypsoCardClass = CalypsoCardClass::UNKNOWN;
 
    std::vector<uint8_t> mCalypsoSerialNumber;
 
    std::vector<uint8_t> mStartupInfo;
 
    CalypsoCard::ProductType mProductType = ProductType::UNKNOWN;
 
    std::vector<uint8_t> mDfName;
 
    int mModificationsCounterMax = 0;
 
    bool mIsModificationCounterInBytes = true;
 
    std::shared_ptr<DirectoryHeader> mDirectoryHeader;
 
    std::vector<std::shared_ptr<ElementaryFile>> mFiles;
 
    std::vector<std::shared_ptr<ElementaryFile>> mFilesBackup;
 
    std::shared_ptr<ElementaryFileAdapter> mCurrentEf;
 
    std::shared_ptr<bool> mIsDfRatified;
 
    std::shared_ptr<int> mTransactionCounter = nullptr;
 
    std::shared_ptr<int> mPinAttemptCounter;
 
    std::shared_ptr<int> mSvBalance;
 
    int mSvLastTNum = 0;
 
    std::shared_ptr<SvLoadLogRecord> mSvLoadLogRecord;
 
    std::shared_ptr<SvDebitLogRecord> mSvDebitLogRecord;
 
    bool mIsHce = false;
 
    std::vector<uint8_t> mCardChallenge;
 
    std::vector<uint8_t> mTraceabilityInformation;
 
    uint8_t mSvKvc = 0;
 
    std::vector<uint8_t> mSvGetHeader;
 
    std::vector<uint8_t> mSvGetData;
 
    std::vector<uint8_t> mSvOperationSignature;
 
    uint8_t mApplicationSubType = 0;
 
    uint8_t mApplicationType = 0;
 
    uint8_t mSessionModification = 0;
 
    int mPayloadCapacity = DEFAULT_PAYLOAD_CAPACITY;
 
    bool mIsCounterValuePostponed = false;
 
    static const std::vector<std::shared_ptr<PatchRev3>> mPatchesRev3;
 
    static const std::vector<std::shared_ptr<PatchRev12>> mPatchesRev12;
 
    CalypsoCard::ProductType computeProductType(const int applicationType) const;
 
    const std::shared_ptr<ElementaryFileAdapter> getOrCreateFile(const uint8_t sfi,
                                                                 const uint16_t lid);
 
    static void copyFiles(const std::vector<std::shared_ptr<ElementaryFile>>& src,
                          std::vector<std::shared_ptr<ElementaryFile>>& dest);
 
    void initializeWithPowerOnData(const std::string& powerOnData);
 
    void initializeWithFci(const std::shared_ptr<ApduResponseApi> selectApplicationResponse);
 
    static const std::vector<std::shared_ptr<PatchRev12>> initPatchRev12();
 
    static const std::vector<std::shared_ptr<PatchRev3>> initPatchRev3();
 
    void applyPatchIfNeeded();
 
    void applyPatchIfNeededForRevision(const std::vector<std::shared_ptr<Patch>>& patches,
                                       const uint64_t startupInfoLong);
};
 
}
}
}