cCipherCamellia.h

Go to the documentation of this file.

//
//
#ifndef _INC_cCipherCamellia_H
#define _INC_cCipherCamellia_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
#include "cCipherBase.h"
#include "cCipherTypeDef.h"
 
namespace GrayLib
{
        class GRAYLIB_LINK cCipherCamellia : public cCipherBase
        {
 
        private:
                static const BYTE k_SIGMA_CHARS[6][8];
 
                static const BYTE k_FSb[4][256];        // SBOX 4
 
                static const BYTE k_shifts[2][4][4];
                static const signed char k_indexes[2][4][20];
                static const signed char k_transposes[2][20];
 
        public:
                static const size_t k_BlockAlign = 16;
                int m_nRounds;                     
                UINT32 m_RK[68];            
 
        private:
                static void feistel(const UINT32 x[2], const UINT32 k[2], OUT UINT32 z[2]);
 
        public:
                cCipherCamellia(bool bEncodeMode)
                        : cCipherBase(bEncodeMode)
                        , m_nRounds(0)
                {
                        cMem::Zero(m_RK, sizeof(m_RK));
                }
                virtual ~cCipherCamellia()
                {
                        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[k_BlockAlign], const BYTE pInput[k_BlockAlign]) 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 nSize) override;
 
                UNITTEST_FRIEND(cCipherCamellia);
        };
 
        class GRAYLIB_LINK cCipherAlgCamellia : public cCipherAlgDef
        {
        public:
                cCipherAlgCamellia() : cCipherAlgDef(CipherAlgorithm_Camellia)
                {
                }
                virtual cCipherBase* AllocCipherAlg(bool bEncodeMode) const
                {
                        return new cCipherCamellia(bEncodeMode);
                }
        };
}
 
#endif