generic.hxx

#pragma once
 
#include <StormByte/buffer/consumer.hxx>
#include <StormByte/clonable.hxx>
#include <StormByte/crypto/keypair/generic.hxx>
 
namespace StormByte::Crypto::Signer {
    enum class Type {
        DSA,                                                            
        ECDSA,                                                          
        ED25519,                                                        
        RSA,                                                            
    };
 
    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;
 
            KeyPair::Generic::PointerType                           KeyPair() const noexcept {
                return m_keypair;
            }
 
            inline bool                                             Sign(std::span<const std::byte> input, Buffer::WriteOnly& output) const noexcept {
                return DoSign(input, output);
            }
 
            inline bool                                             Sign(const Buffer::ReadOnly& input, Buffer::WriteOnly& output) const noexcept {
                return DoSign(const_cast<Buffer::ReadOnly&>(input), output, ReadMode::Copy);
            }
 
            inline bool                                             Sign(Buffer::ReadOnly& input, Buffer::WriteOnly& output) const noexcept {
                return DoSign(input, output, ReadMode::Move);
            }
 
            inline Buffer::Consumer                                 Sign(Buffer::Consumer consumer, ReadMode mode = ReadMode::Move) const noexcept {
                return DoSign(consumer, mode);
            }
 
            inline bool                                             Verify(std::span<const std::byte> input, const std::string& signature) const noexcept {
                return DoVerify(input, signature);
            }
 
            inline bool                                             Verify(const Buffer::ReadOnly& input, const std::string& signature) const noexcept {
                return DoVerify(const_cast<Buffer::ReadOnly&>(input), signature, ReadMode::Copy);
            }
 
            inline bool                                             Verify(Buffer::ReadOnly& input, const std::string& signature) const noexcept {
                return DoVerify(input, signature, ReadMode::Move);
            }
 
            inline bool                                             Verify(Buffer::Consumer consumer, const std::string& signature, ReadMode mode = ReadMode::Move) const noexcept {
                return DoVerify(consumer, signature, mode);
            }
 
        protected:
            enum Type m_type;                                       
            KeyPair::Generic::PointerType m_keypair;                
 
            inline                                                  Generic(enum Type type, KeyPair::Generic::PointerType keypair):
            m_type(type), m_keypair(keypair) {}
 
            inline                                                  Generic(enum Type type, const KeyPair::Generic& keypair):
            m_type(type), m_keypair(keypair.Clone()) {}
 
            inline                                                  Generic(enum Type type, KeyPair::Generic&& keypair):
            m_type(type), m_keypair(keypair.Move()) {}
 
        private:
            bool                                                    DoSign(Buffer::ReadOnly& input, Buffer::WriteOnly& output, ReadMode mode) const noexcept;
 
            virtual bool                                            DoSign(std::span<const std::byte> input, Buffer::WriteOnly& output) const noexcept = 0;
 
            virtual Buffer::Consumer                                DoSign(Buffer::Consumer consumer, ReadMode mode) const noexcept = 0;
 
            bool                                                    DoVerify(Buffer::ReadOnly& input, const std::string& signature, ReadMode mode) const noexcept;
 
            virtual bool                                            DoVerify(std::span<const std::byte> input, const std::string& signature) const noexcept = 0;
 
            virtual bool                                            DoVerify(Buffer::Consumer consumer, const std::string& signature, ReadMode mode) const noexcept = 0;
    };
 
    STORMBYTE_CRYPTO_PUBLIC Generic::PointerType                    Create(enum Type type, KeyPair::Generic::PointerType keypair) noexcept;
    
    STORMBYTE_CRYPTO_PUBLIC Generic::PointerType                    Create(enum Type type, const KeyPair::Generic& keypair) noexcept;
    STORMBYTE_CRYPTO_PUBLIC Generic::PointerType                    Create(enum Type type, KeyPair::Generic&& keypair) noexcept;
}