IdentityStore.hpp

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/AppDomainSingleton.hxx"
#include "Arp/System/Commons/Logging.h"
#include "Arp/System/Commons/Io/Path.hpp"
#include "Arp/System/Commons/Security/KeyPair.hpp"
#include "Arp/System/Commons/Security/Certificate.hpp"
#include "Arp/System/Commons/Security/SecurityListType.hpp"
#include "Arp/System/Commons/Security/ItemInfo.hpp"
#include "Arp/System/Commons/Security/KeyPairType.hpp"
#include "Arp/System/Commons/Security/SecurityConfigurationError.hpp"
#include <map>
#include <vector>
#include <openssl/evp.h>

namespace Arp { namespace System { namespace Commons { namespace Security
{

class IdentityStore : private Loggable<IdentityStore>
{
public: // type definitions
    enum KeyMustExist : bool
    {
        IgnoreMissingKey = false,
        RequireKeyExists = true
    };

public: // construction/destruction
    IdentityStore(const String& basePath, const String& name, KeyMustExist requireKeyExists = RequireKeyExists);
    IdentityStore(const IdentityStore& arg) = delete;
    IdentityStore& operator=(const IdentityStore& arg) = delete;
    ~IdentityStore(void) = default;

public: // operators

public: // static operations

public: // setter/getter operations
    String GetName(void) const;
    String GetFullCertificateFileName(void) const;
    String GetFullKeyFileName(void) const;
    String GetFullTpmKeyFileName(void) const;
    bool HasCertificate(void);
    const std::shared_ptr<KeyPair>& GetKeyPair(void);
    KeyPairType GetKeyType(void);

public: // operations
    void InitSslContext(SSL_CTX* pSslCtx)const;

    std::vector<byte> GetPublicKey(void);

    SecurityConfigurationError SetKeyPair(const std::vector<byte>& pemData);

    SecurityConfigurationError SetCertificate(const std::vector<byte>& pemData);

    std::vector<byte> GetPemCertificate(void);

    std::vector<byte> GetDerCertificate(void);

    std::vector<byte> GetPemCertificateWithChain(void);

    std::vector<byte> GetDerCertificateWithChain(void);

    std::vector<std::vector<byte>> GetIssuerPemCertificates(void);

    void CreateAllDirectories(void);


    SecurityConfigurationError ListContent(SecurityListType type, std::vector<ItemInfo>& result);


    SecurityConfigurationError AddElement(SecurityListType type, const std::vector<byte>& pemData);


    SecurityConfigurationError DeleteElement(SecurityListType type, const String& identifier);


    SecurityConfigurationError GenerateKeyPair(KeyPairType type);

    std::vector<byte> GenerateCSR();

    bool VerifyCertMatchesWithPrivateKey(void);

protected: // operations

private: // static methods

private: // methods
    void loadKeyPair(KeyMustExist requireKeyExists);
    void loadCertWithChain(const String& file);

    void listIssuerList(std::vector<ItemInfo>& result);
    void listIdentityCert(std::vector<ItemInfo>& result);

    void save(void);

private: // fields
    String  storePath;

    std::shared_ptr<KeyPair> keyPair;
    Certificate cert;
    std::vector<Certificate> issuers;

private: // static fields

    static const String CertificateFileName;
    static const String KeyFileName;
    static const String TpmKeyFileName;
    static const String DirectorySeparator;
};

// inline methods of class CertificateStore

inline String IdentityStore::GetName(void) const
{
    return Io::Path::GetFileName(this->storePath);
}

inline String IdentityStore::GetFullCertificateFileName(void) const
{
    return this->storePath + DirectorySeparator + CertificateFileName;
}

inline String IdentityStore::GetFullKeyFileName(void) const
{
    return this->storePath + DirectorySeparator + KeyFileName;
}

inline String IdentityStore::GetFullTpmKeyFileName(void) const
{
    return this->storePath + DirectorySeparator + TpmKeyFileName;
}

inline KeyPairType IdentityStore::GetKeyType(void)
{
    return this->keyPair->GetKeyType();
}

}}}} // end of namespace Arp::System::Commons::Security