generic.hxx

#pragma once
 
#include <StormByte/buffer/consumer.hxx>
#include <StormByte/clonable.hxx>
#include <StormByte/crypto/typedefs.hxx>
#include <StormByte/crypto/visibility.h>
 
namespace StormByte::Crypto::Crypter {
    enum class Type {
        AES_GCM,                                                
        AES,                                                    
        Camellia,                                               
        ChaChaPoly,                                             
        ECC,                                                    
        Serpent,                                                
        RSA,                                                    
        TwoFish,                                                
    };
 
    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 bool                                         Encrypt(std::span<const std::byte> input, Buffer::WriteOnly& output) const noexcept {
                return DoEncrypt(input, output);
            }
 
            inline bool                                         Encrypt(const Buffer::ReadOnly& input, Buffer::WriteOnly& output) const noexcept {
                return DoEncrypt(const_cast<Buffer::ReadOnly&>(input), output, ReadMode::Copy);
            }
 
            inline bool                                         Encrypt(Buffer::ReadOnly& input, Buffer::WriteOnly& output) const noexcept {
                return DoEncrypt(input, output, ReadMode::Move);
            }
 
            inline Buffer::Consumer                             Encrypt(Buffer::Consumer consumer, ReadMode mode = ReadMode::Move) const noexcept {
                return DoEncrypt(consumer, mode);
            }
 
            inline bool                                         Decrypt(std::span<const std::byte> input, Buffer::WriteOnly& output) const noexcept {
                return DoDecrypt(input, output);
            }
 
            inline bool                                         Decrypt(const Buffer::ReadOnly& input, Buffer::WriteOnly& output) const noexcept {
                return DoDecrypt(const_cast<Buffer::ReadOnly&>(input), output, ReadMode::Copy);
            }
 
            inline bool                                         Decrypt(Buffer::ReadOnly& input, Buffer::WriteOnly& output) const noexcept {
                return DoDecrypt(input, output, ReadMode::Move);
            }
 
            inline Buffer::Consumer                             Decrypt(Buffer::Consumer consumer, ReadMode mode = ReadMode::Move) const noexcept {
                return DoDecrypt(consumer, mode);
            }
 
            inline enum Type                                    Type() const noexcept {
                return m_type;
            }
 
        protected:
            enum Type m_type;                                   
 
            inline                                              Generic(enum Type type):
            m_type(type) {}
 
        private:
            bool                                                DoDecrypt(Buffer::ReadOnly& input, Buffer::WriteOnly& output, ReadMode mode) const noexcept;
 
            virtual bool                                        DoEncrypt(std::span<const std::byte> input, Buffer::WriteOnly& output) const noexcept = 0;
 
            virtual Buffer::Consumer                            DoEncrypt(Buffer::Consumer consumer, ReadMode mode) const noexcept = 0;
 
            bool                                                DoEncrypt(Buffer::ReadOnly& input, Buffer::WriteOnly& output, ReadMode mode) const noexcept;
 
            virtual bool                                        DoDecrypt(std::span<const std::byte> input, Buffer::WriteOnly& output) const noexcept = 0;
 
            virtual Buffer::Consumer                            DoDecrypt(Buffer::Consumer consumer, ReadMode mode) const noexcept = 0;
    };
}