KeyAgreement.h

gehe zur Dokumentation dieser Datei

 
#pragma once
 
#include "CardConnectionWorker.h"
#include "GeneralAuthenticateResponse.h"
#include "pace/KeyDerivationFunction.h"
 
#include <QSharedPointer>
 
namespace governikus
{
 
enum class KeyAgreementStatus
{
    SUCCESS,
    RETRY_ALLOWED,
    COMMUNICATION_ERROR,
    FAILED,
    PROTOCOL_ERROR
};
 
class KeyAgreement
{
    protected:
        struct CardResult
        {
            CardReturnCode mReturnCode = CardReturnCode::UNDEFINED;
            QByteArray mData = QByteArray();
        };
 
    private:
        const QSharedPointer<CardConnectionWorker> mCardConnectionWorker;
        QByteArray mEncryptionKey;
        QByteArray mMacKey;
        QByteArray mCarCurr, mCarPrev;
 
 
        CardResult createTransmitResult(CardReturnCode pReturnCode,
                StatusCode pResponseReturnCode,
                const QByteArray& pResultData,
                const char* pLogMessage) const;
 
        CardResult determineNonce(const QByteArray& pPin);
 
        virtual CardResult determineSharedSecret(const QByteArray& pNonce) = 0;
 
        virtual QByteArray getUncompressedTerminalPublicKey() = 0;
 
        CardResult transmitGAEncryptedNonce();
 
        KeyAgreementStatus performMutualAuthenticate();
 
    protected:
        const QSharedPointer<const PaceInfo> mPaceInfo;
        KeyDerivationFunction mKeyDerivationFunction;
 
        KeyAgreement(const QSharedPointer<const PaceInfo>& pPaceInfo, const QSharedPointer<CardConnectionWorker>& pCardConnectionWorker);
 
        [[nodiscard]] CardResult transmitGAMappingData(const QByteArray& pMappingData) const;
 
        CardResult transmitGAEphemeralPublicKey(const QByteArray& pEphemeralPublicKey);
 
        GAMutualAuthenticationResponse transmitGAMutualAuthentication(const QByteArray& pMutualAuthenticationData);
 
    public:
        virtual QByteArray getUncompressedCardPublicKey() = 0;
 
        virtual QByteArray getCompressedCardPublicKey() = 0;
 
        static QSharedPointer<KeyAgreement> create(const QSharedPointer<const PaceInfo>& pPaceInfo,
                QSharedPointer<CardConnectionWorker> pCardConnectionWorker);
        virtual ~KeyAgreement();
 
        KeyAgreementStatus perform(const QByteArray& pPin);
 
        [[nodiscard]] const QByteArray& getEncryptionKey() const;
 
        [[nodiscard]] const QByteArray& getMacKey() const;
 
        [[nodiscard]] const QByteArray& getCarCurr() const;
 
        [[nodiscard]] const QByteArray& getCarPrev() const;
};
 
} // namespace governikus