CommonSignatureVerificationDataAdapter.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 <memory>
 
/* Calypsonet Terminal Calypso */
#include "CommonSignatureVerificationData.h"
 
/* Keyple Core Util */
#include "IllegalStateException.h"
 
namespace keyple {
namespace card {
namespace calypso {
 
using namespace calypsonet::terminal::calypso::transaction;
using namespace keyple::core::util::cpp::exception;
 
template <typename T>
class CommonSignatureVerificationDataAdapter : virtual public CommonSignatureVerificationData<T> {
public:
    T& setData(const std::vector<uint8_t>& data,
               const std::vector<uint8_t>& signature,
               const uint8_t kif,
               const uint8_t kvc) override
    {
        mData = data;
        mSignature = signature;
        mKif = kif;
        mKvc = kvc;
 
        return dynamic_cast<T&>(*this);
    }
 
    T& setKeyDiversifier(const std::vector<uint8_t>& diversifier) override
    {
        mKeyDiversifier = diversifier;
        mIsKeyDiversifierSet = true;
 
        return dynamic_cast<T&>(*this);
    }
 
    bool isSignatureValid() const override
    {
        if (mIsSignatureValid == nullptr) {
            throw IllegalStateException("The command has not yet been processed");
        }
 
        return *mIsSignatureValid;
    }
 
    virtual const std::vector<uint8_t>& getData() const
    {
        return mData;
    }
 
    virtual const std::vector<uint8_t>& getSignature() const
    {
        return mSignature;
    }
 
    virtual uint8_t getKif() const
    {
        return mKif;
    }
 
    virtual uint8_t getKvc() const
    {
        return mKvc;
    }
 
    virtual void setSignatureValid(const bool isSignatureValid)
    {
        mIsSignatureValid = std::make_shared<bool>(isSignatureValid);
    }
 
    virtual const std::vector<uint8_t>& getKeyDiversifier() const
    {
        return mKeyDiversifier;
    }
 
    bool isKeyDiversifierSet() const
    {
        return mIsKeyDiversifierSet;
    }
 
private:
    std::vector<uint8_t> mData;
 
    std::vector<uint8_t> mSignature;
 
    uint8_t mKif;
 
    uint8_t mKvc;
 
    std::vector<uint8_t> mKeyDiversifier;
 
    bool mIsKeyDiversifierSet = false;
 
    std::shared_ptr<bool> mIsSignatureValid = nullptr;
};
 
}
}
}