generic.hxx

#pragma once
 
#include <StormByte/clonable.hxx>
#include <StormByte/crypto/typedefs.hxx>
#include <StormByte/crypto/visibility.h>
 
#include <filesystem>
#include <optional>
#include <string>
 
namespace StormByte::Crypto::KeyPair {
    enum class Type {
        DSA,                                                    
        ECC,                                                    
        ECDH,                                                   
        ECDSA,                                                  
        ED25519,                                                
        RSA,                                                    
        X25519,                                                 
    };
 
    class STORMBYTE_CRYPTO_PUBLIC Generic: public StormByte::Clonable<Generic> {
        public:
            Generic(const Generic& other)                       = default;
 
            Generic(Generic&& other) noexcept                   = default;
 
            virtual ~Generic() noexcept                         = default;
 
            Generic& operator=(const Generic& other)            = default;
 
            Generic& operator=(Generic&& other) noexcept        = default;
 
            inline const std::string&                           PublicKey() const noexcept {
                return m_public_key;
            }
 
            inline const std::optional<std::string>&            PrivateKey() const noexcept {
                return m_private_key;
            }
 
            inline enum Type                                    Type() const noexcept {
                return m_type;
            }
 
            bool                                                Save(const std::filesystem::path& path, const std::string& name) const noexcept;
 
        protected:
            enum Type m_type;                                   
            std::string m_public_key;                           
            std::optional<std::string> m_private_key;           
 
            inline                                              Generic(enum Type type, const std::string& public_key, std::optional<std::string> private_key = std::nullopt):
            m_type(type), m_public_key(public_key), m_private_key(private_key) {}
 
        private:
            
    };
 
    STORMBYTE_CRYPTO_PUBLIC Generic::PointerType                Generate(Type type, unsigned short bits) noexcept;
 
    STORMBYTE_CRYPTO_PUBLIC Generic::PointerType                Load(const std::filesystem::path& publicKeyPath, const std::filesystem::path& privateKeyPath) noexcept;
}