keypair.hxx

#pragma once
 
#include <StormByte/crypto/algorithm.hxx>
#include <StormByte/crypto/exception.hxx>
#include <StormByte/expected.hxx>
 
#include <optional>
#include <string>
 
namespace StormByte::Crypto {
    class STORMBYTE_CRYPTO_PUBLIC KeyPair final {
        public:
            KeyPair(const std::string& pub, const std::string& priv) noexcept;
 
            KeyPair(const std::string& pub) noexcept;
 
            KeyPair(std::string&& pub, std::string&& priv) noexcept;
 
            KeyPair(std::string&& pub) noexcept;
 
            KeyPair(const KeyPair& other)                   = default;
 
            KeyPair(KeyPair&& other) noexcept               = default;
 
            ~KeyPair() noexcept                             = default;
 
            KeyPair& operator=(const KeyPair& other)        = default;
 
            KeyPair& operator=(KeyPair&& other) noexcept    = default;
 
            const std::string&                              PublicKey() const noexcept;
 
            const std::optional<std::string>&               PrivateKey() const noexcept;
 
            [[nodiscard]]
            static Expected<KeyPair, Exception>             Generate(const Algorithm::Asymmetric& algo, const size_t& key_size) noexcept;
 
            [[nodiscard]]
            static Expected<KeyPair, Exception>             Generate(const Algorithm::Asymmetric& algo, const std::string& curve_name) noexcept;
 
            [[nodiscard]]
            static Expected<KeyPair, Exception>             Generate(const Algorithm::Sign& algo, const size_t& key_size) noexcept;
 
            [[nodiscard]]
            static Expected<KeyPair, Exception>             Generate(const Algorithm::Sign& algo, const std::string& curve_name) noexcept;
 
            [[nodiscard]]
            static Expected<KeyPair, Exception>             Generate(const Algorithm::SecretShare& algo, const std::string& curve_name) noexcept;
 
        private:
            std::string m_public_key; 
            std::optional<std::string> m_private_key; 
    };
}