cCipherDES.h

Go to the documentation of this file.

//
//
#ifndef _INC_cCipherDES_H
#define _INC_cCipherDES_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
#include "cCipherBase.h"
#include "cCipherTypeDef.h"
 
namespace GrayLib
{
        class GRAYLIB_LINK cCipherDES : public cCipherBase
        {
 
        public:
                static const size_t k_KeySize = 8;      // bytes = 64 bits
                static const size_t k_BlockSize = 32;   //  
 
                size_t m_nSizeKey;                              
                UINT32 m_RK[k_BlockSize * 3];   
                BYTE m_IV[k_KeySize];           
 
        protected:
                static const UINT32 k_SB1[64];
                static const UINT32 k_SB2[64];
                static const UINT32 k_SB3[64];
                static const UINT32 k_SB4[64];
                static const UINT32 k_SB5[64];
                static const UINT32 k_SB6[64];
                static const UINT32 k_SB7[64];
                static const UINT32 k_SB8[64];
 
                static const UINT32 k_LHs[16];
                static const UINT32 k_RHs[16];
                static const BYTE k_odd_parity_table[128];
 
        private:
                static void SetCipherKeyInt1(UINT32 pSK[k_BlockSize], const BYTE pKey[k_KeySize]);
                static void SetCipherKeyInt2(UINT32 esk[96], UINT32 dsk[96], const BYTE pKey[k_KeySize * 2]);
                static void SetCipherKeyInt3(UINT32 esk[96], UINT32 dsk[96], const BYTE pKey[k_KeySize * 3]);
 
        public:
                cCipherDES(bool bEncodeMode)
                        : cCipherBase(bEncodeMode)
                        , m_nSizeKey(0)
                {
                        cMem::Zero(m_RK, sizeof(m_RK));
                }
                virtual ~cCipherDES()
                {
                        cMem::ZeroSecure(m_RK, sizeof(m_RK));
                }
 
                size_t get_BlockAlignSize() const override
                {
                        return k_KeySize;
                }
 
                static void GRAYCALL SetKeyParity(BYTE pKey[k_KeySize]);
                static bool GRAYCALL IsKeyParity(const BYTE pKey[k_KeySize]);
                static bool GRAYCALL IsKeyWeak(const BYTE pKey[k_KeySize]);
 
                virtual HRESULT SetCipherKey(const void* pKeyData, size_t nKeySize) override;
 
                virtual HRESULT CipherModeECB(BYTE pOutput[k_KeySize], const BYTE pInput[k_KeySize] ) override;
                virtual HRESULT CipherModeCBC(BYTE* pOutput, const BYTE* pInput, size_t nSize, BYTE* pIV) override;
 
                virtual HRESULT Cipher(BYTE* pOutput, const BYTE* pInput, size_t nSizeBytes) override;
 
                UNITTEST_FRIEND(cCipherDES);
        };
 
        class GRAYLIB_LINK cCipherAlgDES : public cCipherAlgDef
        {
        public:
                cCipherAlgDES() : cCipherAlgDef(CipherAlgorithm_DES)
                {
                }
                virtual cCipherBase* AllocCipherAlg(bool bEncodeMode) const
                {
                        return new cCipherDES(bEncodeMode);
                }
        };
}
#endif