CardTransactionManagerAdapter.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 <atomic>
#include <memory>
#include <ostream>
 
/* Calypsonet Terminal Calypso */
#include "CardSecuritySetting.h"
#include "CardTransactionManager.h"
#include "CommonSignatureComputationData.h"
#include "CommonSignatureVerificationData.h"
#include "SearchCommandData.h"
#include "SvAction.h"
#include "WriteAccessLevel.h"
 
/* Calypsonet Terminal Card */
#include "ApduResponseApi.h"
#include "CardRequestSpi.h"
#include "CardResponseApi.h"
#include "ChannelControl.h"
#include "ProxyReaderApi.h"
 
/* Keyple Card Calypso */
#include "CalypsoCardAdapter.h"
#include "CardSecuritySettingAdapter.h"
#include "CardCommandException.h"
#include "CardControlSamTransactionManagerAdapter.h"
 
/* Keyple Core Util */
#include "Any.h"
#include "LoggerFactory.h"
 
namespace keyple {
namespace card {
namespace calypso {
 
using namespace calypsonet::terminal::calypso;
using namespace calypsonet::terminal::calypso::transaction;
using namespace calypsonet::terminal::card;
using namespace calypsonet::terminal::card::spi;
using namespace keyple::core::util::cpp;
 
class CardTransactionManagerAdapter final
: public CommonTransactionManagerAdapter<CardTransactionManager,
                                         CardSecuritySetting,
                                         CardSecuritySettingAdapter>,
  public CardTransactionManager {
public:
    CardTransactionManagerAdapter(const std::shared_ptr<ProxyReaderApi> cardReader,
                                  const std::shared_ptr<CalypsoCardAdapter> card,
                                  const std::shared_ptr<CardSecuritySettingAdapter> securitySetting);
 
    const std::vector<std::vector<uint8_t>>& getTransactionAuditData() const final
    {
        return CommonTransactionManagerAdapter::getTransactionAuditData();
    }
 
    const std::shared_ptr<CardReader> getCardReader() const override;
 
    const std::shared_ptr<CalypsoCard> getCalypsoCard() const override;
 
    const std::shared_ptr<CardSecuritySetting> getCardSecuritySetting() const override;
 
    CardTransactionManager& processOpening(const WriteAccessLevel writeAccessLevel) override;
 
    const std::shared_ptr<CommonSecuritySetting> getSecuritySetting() const override;
 
    CardTransactionManager& prepareComputeSignature(const any data) override;
 
    CardTransactionManager& prepareVerifySignature(const any data) override;
 
    CardTransactionManager& processCommands() override;
 
    CardTransactionManager& processCardCommands() override;
 
    CardTransactionManager& processClosing() override;
 
    CardTransactionManager& processCancel() override;
 
    CardTransactionManager& processVerifyPin(const std::vector<uint8_t>& pin) override;
    CardTransactionManager& processChangePin(const std::vector<uint8_t>& newPin) override;
 
    CardTransactionManager& processChangeKey(const uint8_t keyIndex,
                                             const uint8_t newKif,
                                             const uint8_t newKvc,
                                             const uint8_t issuerKif,
                                             const uint8_t issuerKvc) override;
 
    CardTransactionManager& prepareReleaseCardChannel() override;
 
    CardTransactionManager& prepareSelectFile(const std::vector<uint8_t>& lid) override;
 
    CardTransactionManager& prepareSelectFile(const uint16_t lid) override;
 
    CardTransactionManager& prepareSelectFile(const SelectFileControl selectFileControl) override;
 
    CardTransactionManager& prepareGetData(const GetDataTag tag) override;
 
    CardTransactionManager& prepareReadRecordFile(const uint8_t sfi, const uint8_t recordNumber)
        override;
 
    CardTransactionManager& prepareReadRecordFile(const uint8_t sfi,
                                                  const uint8_t firstRecordNumber,
                                                  const uint8_t numberOfRecords,
                                                  const uint8_t recordSize) override;
 
    CardTransactionManager& prepareReadCounterFile(const uint8_t sfi, const uint8_t countersNumber)
        override;
 
    CardTransactionManager& prepareReadRecord(const uint8_t sfi, const uint8_t recordNumber)
        override;
 
    CardTransactionManager& prepareReadRecords(const uint8_t sfi,
                                               const uint8_t fromRecordNumber,
                                               const uint8_t toRecordNumber,
                                               const uint8_t recordSize) override;
 
    CardTransactionManager& prepareReadRecordsPartially(const uint8_t sfi,
                                                        const uint8_t fromRecordNumber,
                                                        const uint8_t toRecordNumber,
                                                        const uint8_t offset,
                                                        const uint8_t nbBytesToRead) override;
 
    CardTransactionManager& prepareReadBinary(const uint8_t sfi,
                                              const int offset,
                                              const int nbBytesToRead) override;
 
    CardTransactionManager& prepareReadCounter(const uint8_t sfi, const uint8_t nbCountersToRead)
        override;
 
    CardTransactionManager& prepareSearchRecords(const std::shared_ptr<SearchCommandData> data)
        override;
 
    CardTransactionManager& prepareAppendRecord(const uint8_t sfi,
                                                const std::vector<uint8_t>& recordData) override;
 
    CardTransactionManager& prepareUpdateRecord(const uint8_t sfi,
                                                const uint8_t recordNumber,
                                                const std::vector<uint8_t>& recordData) override;
 
    CardTransactionManager& prepareWriteRecord(const uint8_t sfi,
                                               const uint8_t recordNumber,
                                               const std::vector<uint8_t>& recordData) override;
 
    CardTransactionManager& prepareUpdateBinary(const uint8_t sfi,
                                                const int offset,
                                                const std::vector<uint8_t>& data) final;
 
    CardTransactionManager& prepareWriteBinary(const uint8_t sfi,
                                               const int offset,
                                               const std::vector<uint8_t>& data) final;
 
    CardTransactionManager& prepareIncreaseCounter(const uint8_t sfi,
                                                   const uint8_t counterNumber,
                                                   const int incValue) override;
 
    CardTransactionManager& prepareDecreaseCounter(const uint8_t sfi,
                                                   const uint8_t counterNumber,
                                                   const int decValue) override;
 
    CardTransactionManager& prepareDecreaseCounters(
        const uint8_t sfi,
        const std::map<const int, const int>& counterNumberToDecValueMap) override;
 
    CardTransactionManager& prepareIncreaseCounters(
        const uint8_t sfi,
        const std::map<const int, const int>& counterNumberToIncValueMap) override;
 
    CardTransactionManager& prepareSetCounter(const uint8_t sfi,
                                              const uint8_t counterNumber,
                                              const int newValue) override;
 
    CardTransactionManager& prepareCheckPinStatus() override;
 
    CardTransactionManager& prepareSvGet(const SvOperation svOperation, const SvAction svAction)
        override;
 
    CardTransactionManager& prepareSvReload(const int amount,
                                            const std::vector<uint8_t>& date,
                                            const std::vector<uint8_t>& time,
                                            const std::vector<uint8_t>& free) override;
 
    CardTransactionManager& prepareSvReload(const int amount) override;
 
    CardTransactionManager& prepareSvDebit(const int amount,
                                           const std::vector<uint8_t>& date,
                                           const std::vector<uint8_t>& time) override;
 
    CardTransactionManager& prepareSvDebit(const int amount) override;
 
    CardTransactionManager& prepareSvReadAllLogs() override;
 
    CardTransactionManager& prepareInvalidate() override;
 
    CardTransactionManager& prepareRehabilitate() override;
 
    void addStoredValueCommand(const std::shared_ptr<AbstractCardCommand> command,
                               const SvOperation svOperation);
 
    void notifyCommandsProcessed();
 
    bool isSvOperationCompleteOneTime();
 
private:
    class ApduResponseAdapter final : public ApduResponseApi {
    public:
        friend class CardTransactionManagerAdapter;
 
        ApduResponseAdapter(const std::vector<uint8_t>& apdu);
 
        const std::vector<uint8_t>& getApdu() const override;
 
        const std::vector<uint8_t> getDataOut() const override;
 
        int getStatusWord() const override;
 
    private:
        const std::vector<uint8_t> mApdu;
 
        const int mStatusWord;
    };
 
    const std::unique_ptr<Logger> mLogger =
        LoggerFactory::getLogger(typeid(CardTransactionManagerAdapter));
 
    static const std::string PATTERN_1_BYTE_HEX;
 
    static const std::string MSG_CARD_READER_COMMUNICATION_ERROR;
    static const std::string MSG_CARD_COMMUNICATION_ERROR;
    static const std::string MSG_CARD_COMMAND_ERROR;
 
    static const std::string MSG_PIN_NOT_AVAILABLE;
    static const std::string MSG_CARD_SIGNATURE_NOT_VERIFIABLE;
    static const std::string MSG_CARD_SIGNATURE_NOT_VERIFIABLE_SV;
 
    static const std::string RECORD_NUMBER;
    static const std::string OFFSET;
 
    static const int SESSION_BUFFER_CMD_ADDITIONAL_COST;
    static const int APDU_HEADER_LENGTH;
 
    static const std::shared_ptr<ApduResponseApi> RESPONSE_OK;
    static const std::shared_ptr<ApduResponseApi> RESPONSE_OK_POSTPONED;
 
    const std::shared_ptr<ProxyReaderApi> mCardReader;
    const std::shared_ptr<CalypsoCardAdapter> mCard;
    const std::shared_ptr<CardSecuritySettingAdapter> mSecuritySetting;
    std::shared_ptr<CardControlSamTransactionManagerAdapter> mControlSamTransactionManager;
    std::vector<std::shared_ptr<AbstractApduCommand>> mCardCommands;
 
    bool mIsSessionOpen = false;
    WriteAccessLevel mWriteAccessLevel = WriteAccessLevel::DEBIT; /* MSVC: default value required */
    ChannelControl mChannelControl = ChannelControl::KEEP_OPEN;
    int mModificationsCounter = 0;
    SvOperation mSvOperation;
    SvAction mSvAction = SvAction::DO; /* MSVC: default value required */
    CalypsoCardCommand mSvLastCommandRef = CalypsoCardCommand::NONE; /* GCC: default value required */
    std::shared_ptr<AbstractCardCommand> mSvLastModifyingCommand;
    bool mIsSvOperationInsideSession = false;
    bool mIsSvOperationComplete = false;
    int mSvPostponedDataIndex = 0;
    int mNbPostponedData = 0;
 
    void processAtomicCardCommands(
        const std::vector<std::shared_ptr<AbstractApduCommand>> cardCommands,
        const ChannelControl channelControl);
 
    void checkMultipleSessionEnabled(std::shared_ptr<AbstractCardCommand> command) const;
 
    const std::vector<uint8_t> processSamCardCipherPin(const std::vector<uint8_t>& currentPin,
                                                       const std::vector<uint8_t>& newPin);
 
    void processAtomicClosing(
        const std::vector<std::shared_ptr<AbstractApduCommand>>& cardCommands,
        const bool isRatificationMechanismEnabled,
        const ChannelControl channelControl);
 
    int getCounterValue(const uint8_t sfi, const int counter);
 
    const std::map<const int, const int> getCounterValues(const uint8_t sfi,
                                                          const std::vector<int>& counters);
 
    const std::vector<uint8_t> buildAnticipatedIncreaseDecreaseResponseData(
        const bool isDecreaseCommand,
        const int currentCounterValue,
        const int incDecValue);
 
    const std::shared_ptr<ApduResponseApi> buildAnticipatedIncreaseDecreaseResponse(
        const std::vector<uint8_t>& data);
 
    const std::shared_ptr<ApduResponseApi> buildAnticipatedIncreaseDecreaseMultipleResponse(
        const bool isDecreaseCommand,
        const std::map<const int, const int>& counterNumberToCurrentValueMap,
        const std::map<const int, const int>& counterNumberToIncDecValueMap);
 
    const std::vector<std::shared_ptr<ApduResponseApi>> buildAnticipatedResponses(
        const std::vector<std::shared_ptr<AbstractApduCommand>>& cardCommands);
 
    void processCommandsOutsideSession(const ChannelControl channelControl);
 
    void processCommandsInsideSession();
 
    const std::vector<uint8_t> processSamCardGenerateKey(const uint8_t issuerKif,
                                                         const uint8_t issuerKvc,
                                                         const uint8_t newKif,
                                                         const uint8_t newKvc);
 
    const std::shared_ptr<CardResponseApi> transmitCardRequest(
        const std::shared_ptr<CardRequestSpi> cardRequest, const ChannelControl channelControl);
 
    void finalizeSvCommandIfNeeded();
 
    const std::vector<uint8_t> processSamSvPrepareLoad(
        const std::vector<uint8_t>& svGetHeader,
        const std::vector<uint8_t>& svGetData,
        const std::shared_ptr<CmdCardSvReload> cmdCardSvReload);
 
    const std::vector<uint8_t> processSamSvPrepareDebitOrUndebit(
        const bool isDebitCommand,
        const std::vector<uint8_t> svGetHeader,
        const std::vector<uint8_t> svGetData,
        const std::shared_ptr<CmdCardSvDebitOrUndebit> cmdCardSvDebitOrUndebit);
 
    const std::vector<uint8_t> computeOperationComplementaryData(
        const std::vector<uint8_t>& prepareOperationData);
 
    void processSamSvCheck(const std::vector<uint8_t>& svOperationData);
 
    const std::vector<uint8_t> processSamGetChallenge();
 
    const std::vector<uint8_t> processSamSessionClosing();
 
    void processSamDigestAuthenticate(const std::vector<uint8_t>& cardSignature);
 
    void checkSession();
 
    void checkNoSession();
 
    int computeCommandSessionBufferSize(std::shared_ptr<AbstractCardCommand> command);
 
    void resetModificationsBufferCounter();
 
    CardTransactionManager& prepareUpdateOrWriteBinary(const bool isUpdateCommand,
                                                       const uint8_t sfi,
                                                       const int offset,
                                                       const std::vector<uint8_t>& data);
 
    CardTransactionManager& prepareIncreaseOrDecreaseCounter(const bool isDecreaseCommand,
                                                             const uint8_t sfi,
                                                             const uint8_t counterNumber,
                                                             const int incDecValue);
 
    CardTransactionManager& prepareIncreaseOrDecreaseCounters(
        const bool isDecreaseCommand,
        const uint8_t sfi,
        const std::map<const int, const int>& counterNumberToIncDecValueMap);
 
 
 
    void checkControlSam() const;
 
    void processSamPreparedCommands();
 
    void processAtomicOpening(std::vector<std::shared_ptr<AbstractApduCommand>>& cardCommands);
 
    void abortSecureSessionSilently();
 
    void prepareInternalSvUndebit(const int amount,
                                  const std::vector<uint8_t>& date,
                                  const std::vector<uint8_t>& time,
                                  const bool useExtendedMode);
 
    void checkSvInsideSession();
 
    bool isExtendedModeAllowed() const;
 
    void parseApduResponses(const std::vector<std::shared_ptr<AbstractCardCommand>>& commands,
                            const std::vector<std::shared_ptr<ApduResponseApi>>& apduResponses);
 
    void checkResponseStatusForStrictAndBestEffortMode(
        const std::shared_ptr<AbstractCardCommand> command,
        const CardCommandException& e) const;
 
    friend std::ostream& operator<<(std::ostream& os, const ApduResponseAdapter& ara);
 
    friend std::ostream& operator<<(std::ostream& os,
                                    const std::shared_ptr<ApduResponseAdapter> ara);
};
 
}
}
}