cCipherTypeDef.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cCipherTypeDef_H
#define _INC_cCipherTypeDef_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
#include "cCipherBase.h"
#include "GrayCore/include/cSingleton.h"
#include "GrayCore/include/cArraySort.h"
#include "GrayCore/include/cObjectFactory.h"
 
 
namespace GrayLib
{
        class cCipherPadding;
 
        enum SSL_Cipher_TYPE
        {
 
                SSL_Cipher_NONE = 0,
#define CIPHERTYPEDEF(a,b,c,d,e,f,g) SSL_Cipher_##a,
#include "cCipherTypeDef.tbl"
#undef CIPHERTYPEDEF
                SSL_Cipher_QTY,
        };
 
        class GRAYLIB_LINK cCipherTypeDef
        {
 
        public:
                // SSL_Cipher_TYPE m_eCipherType;
                // const char* const m_pszName;
 
                CIPHER_BLOCK_TYPE m_eBlockMode;         
 
                CipherKeySize_TYPE m_nSizeKey;  // size_t
 
                size_t m_nSizeIV;  
 
                CipherVariable_TYPE m_nVarFlags;        
 
                size_t m_nBlockAlignSize;       
 
                CipherAlgorithm_TYPE m_eCipherAlgorithm;
 
        public:
                static const cCipherTypeDef* GRAYCALL GetCipherTypeDef(SSL_Cipher_TYPE eCipherType);
 
                UNITTEST_FRIEND(cCipherTypeDef);
        };
 
        class GRAYLIB_LINK cCipherAlgDef // : public cObjectFactory
        {
        public:
                const CipherAlgorithm_TYPE m_eCipherAlgorithm;
 
        protected:
                cCipherAlgDef(CipherAlgorithm_TYPE eCipherAlgorithm) noexcept
                        : m_eCipherAlgorithm(eCipherAlgorithm)
                {
                }
                virtual ~cCipherAlgDef()
                {
                }
 
        public:
                CipherAlgorithm_TYPE get_HashCode() const noexcept
                {
                        return this->m_eCipherAlgorithm;
                }
                virtual cCipherBase* AllocCipherAlg(bool bEncodeMode) const = 0;
        };
 
        class GRAYLIB_LINK cCipherAlgMgr : public cSingleton<cCipherAlgMgr>
        {
        private:
                cArraySortPtrHash<const cCipherAlgDef, CipherAlgorithm_TYPE> m_a;
        public:
                cCipherAlgMgr();
                void AddCipherAlg(const cCipherAlgDef* pDef)
                {
                        m_a.Add(pDef);
                }
                const cCipherAlgDef* GetCipherAlg(CipherAlgorithm_TYPE e) const
                {
                        return m_a.FindArgForKey(e);
                }
                const cCipherAlgDef* GetCipherAlg(SSL_Cipher_TYPE eCipherType) const
                {
                        const cCipherTypeDef* p = cCipherTypeDef::GetCipherTypeDef(eCipherType);
                        if (p == nullptr)
                                return nullptr;
                        return GetCipherAlg(p->m_eCipherAlgorithm);
                }
 
                void LoadAllCipherAlgs();
        };
 
        class GRAYLIB_LINK cCipherAlgNone : public cCipherAlgDef
        {
        public:
                cCipherAlgNone() : cCipherAlgDef(CipherAlgorithm_NULL)
                {
                }
                virtual cCipherBase* AllocCipherAlg(bool bEncodeMode) const
                {
                        return new cCipherNone(bEncodeMode);
                }
        };
}
 
#endif