CalypsoCardAdapter.h

Go to the documentation of this file.

/**************************************************************************************************
 * Copyright (c) 2022 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 "SmartCardSpi.h"
 
/* Keyple Card Calypso */
#include "CalypsoCardClass.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;
 
class KEYPLECARDCALYPSO_API CalypsoCardAdapter final : public CalypsoCard, public SmartCardSpi {
public:
    CalypsoCardAdapter();
 
    void initializeWithPowerOnData(const std::string& powerOnData);
 
    void initializeWithFci(const std::shared_ptr<ApduResponseApi> selectApplicationResponse);
 
    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;
 
    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 uint8_t offset);
 
    void fillContent(const uint8_t sfi,
                     const uint8_t numRecord,
                     const std::vector<uint8_t>& content,
                     const uint8_t 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;
 
    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:
    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 uint8_t PAY_LOAD_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;
 
    bool mIsRatificationOnDeselectSupported;
 
    bool mIsSvFeatureAvailable;
 
    bool mIsPinFeatureAvailable;
 
    bool mIsPkiModeSupported;
 
    bool mIsDfInvalidated;
 
    CalypsoCardClass mCalypsoCardClass;
 
    std::vector<uint8_t> mCalypsoSerialNumber;
 
    std::vector<uint8_t> mStartupInfo;
 
    CalypsoCard::ProductType mProductType;
 
    std::vector<uint8_t> mDfName;
 
    int mModificationsCounterMax;
 
    bool mIsModificationCounterInBytes;
 
    std::shared_ptr<DirectoryHeader> mDirectoryHeader;
 
    std::vector<std::shared_ptr<ElementaryFile>> mFiles;
 
    std::vector<std::shared_ptr<ElementaryFile>> mFilesBackup;
 
    uint8_t mCurrentSfi;
 
    uint16_t mCurrentLid;
 
    std::shared_ptr<bool> mIsDfRatified;
 
    std::shared_ptr<int> mPinAttemptCounter;
 
    std::shared_ptr<int> mSvBalance;
 
    int mSvLastTNum;
 
    std::shared_ptr<SvLoadLogRecord> mSvLoadLogRecord;
 
    std::shared_ptr<SvDebitLogRecord> mSvDebitLogRecord;
 
    bool mIsHce;
 
    std::vector<uint8_t> mCardChallenge;
 
    std::vector<uint8_t> mTraceabilityInformation;
 
    uint8_t mSvKvc;
 
    std::vector<uint8_t> mSvGetHeader;
 
    std::vector<uint8_t> mSvGetData;
 
    std::vector<uint8_t> mSvOperationSignature;
 
    uint8_t mApplicationSubType;
 
    uint8_t mApplicationType;
 
    uint8_t mSessionModification;
 
    CalypsoCard::ProductType computeProductType(const int applicationType) const;
 
    void updateCurrentSfi(const uint8_t sfi);
 
    void updateCurrentLid(const uint16_t lid);
 
    const std::shared_ptr<ElementaryFileAdapter> getOrCreateFile();
 
    static void copyFiles(const std::vector<std::shared_ptr<ElementaryFile>>& src,
                          std::vector<std::shared_ptr<ElementaryFile>>& dest);
};
 
}
}
}