cCipherAES.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cCipherAES_H
#define _INC_cCipherAES_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
#include "cCipherBase.h"
#include "cCipherTypeDef.h"
 
namespace GrayLib
{
        class GRAYLIB_LINK cCipherAESTable
        {
 
        public:
                // Forward S-box & tables
                BYTE m_FSb[256];
                UINT32 m_FT0[256];
                UINT32 m_FT1[256];
                UINT32 m_FT2[256];
                UINT32 m_FT3[256];
 
                // Reverse S-box & tables
                BYTE m_RSb[256];
                UINT32 m_RT0[256];
                UINT32 m_RT1[256];
                UINT32 m_RT2[256];
                UINT32 m_RT3[256];
 
                // Round constants
                UINT32 m_RCON[10];
 
        private:
                inline static BYTE GetX(BYTE x)
                {
                        return (BYTE)((x << 1) ^ ((x & 0x80) ? 0x1B : 0x00));
                }
 
        public:
                cCipherAESTable(void);
        };
 
        class GRAYLIB_LINK cCipherAES : public cCipherBase
        {
 
        public:
                static const size_t k_BlockAlign = 16; // AES data block alignment. 128 bits.
 
                int m_nRounds;             
                UINT32 m_RK[68];           
 
                static const cCipherAESTable* s_T;              
 
        public:
                cCipherAES(bool bEncodeMode)
                        : cCipherBase(bEncodeMode)
                        , m_nRounds(0)
                {
                        cMem::Zero(m_RK, sizeof(m_RK));
                }
                virtual ~cCipherAES()
                {
                        m_nRounds = 0;
                        cMem::ZeroSecure(m_RK, sizeof(m_RK));
                }
 
                virtual size_t get_BlockAlignSize() const override
                {
                        return k_BlockAlign;
                }
 
                virtual HRESULT SetCipherKey(const void* pKeyData, size_t nKeySize) override;
 
                virtual HRESULT CipherModeECB(BYTE* pOutput, const BYTE* pInput) override;      // [k_BlockAlign]
                virtual HRESULT CipherModeCBC(BYTE* pOutput, const BYTE* pInput, size_t nSize, BYTE* pIV) override;     // [k_BlockAlign]
                virtual HRESULT CipherModeCFB(BYTE* pOutput, const BYTE* pInput, size_t nSize, BYTE pIV[k_BlockAlign], size_t* pnIVOffset) override; // [k_BlockAlign]
                virtual HRESULT CipherModeCTR(BYTE* pOutput, const BYTE* pInput, size_t nSize, BYTE pNonceCounter[k_BlockAlign], size_t* pNCOffset, BYTE pStreamBlock[k_BlockAlign] ) override; // [k_BlockAlign]
 
                virtual HRESULT Cipher(BYTE* pOutput, const BYTE* pInput, size_t nSizeBytes) override;
 
                UNITTEST_FRIEND(cCipherAES);
        };
 
        class GRAYLIB_LINK cCipherAlgAES : public cCipherAlgDef
        {
        public:
                cCipherAlgAES() : cCipherAlgDef(CipherAlgorithm_AES)
                {
                }
                virtual cCipherBase* AllocCipherAlg(bool bEncodeMode) const
                {
                        return new cCipherAES(bEncodeMode);
                }
        };
}
#endif // _INC_cCipherAES_H