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);
    bool LoadSoftwareKeyPair();
    bool LoadHardwareKeyPair();
    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