cCipherBlowfish.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cCipherBlowfish_H
#define _INC_cCipherBlowfish_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cCipherBase.h"
#include "cCipherTypeDef.h"
#include "GrayCore/include/cMem.h"
#include "GrayCore/include/cTypes.h"
 
namespace GrayLib
{
        class GRAYLIB_LINK cCipherBlowfishBlock
        {
 
        public:
                cUnion64 m_v;
        public:
                cCipherBlowfishBlock() noexcept
                {
                        this->m_v.u_qw = 0;
                }
                cCipherBlowfishBlock(const BYTE* pInput)
                {
                        cMem::CopyNtoH(&m_v.u_qw, pInput, sizeof(m_v));
                }
                cCipherBlowfishBlock(const cCipherBlowfishBlock& b) noexcept
                {
                        this->m_v.u_qw = b.m_v.u_qw;
                }
                cCipherBlowfishBlock& operator^=(const cCipherBlowfishBlock& b)
                {
                        this->m_v.u_qw ^= b.m_v.u_qw;
                        return *this;
                }
                void put_BytesToBlock(const BYTE* pInput)
                {
                        cMem::CopyNtoH(&m_v.u_qw, pInput, sizeof(m_v));
                }
                void get_BlockBytes(BYTE* pOutput) const
                {
                        cMem::CopyHtoN(pOutput, &m_v.u_qw, sizeof(m_v));
                }
        };
 
        class GRAYLIB_LINK cCipherBlowfish : public cCipherBase
        {
 
        private:
                static const int k_Rounds = 16;
                static const UINT32 k_P[k_Rounds + 2];
                static const UINT32 k_S[4][256];
 
                UINT32 m_RK[k_Rounds + 2];
                UINT32 m_S[4][256];
 
                cCipherBlowfishBlock m_oChain;  // The Initialization Vector, by default {0, 0} for use with CIPHER_BLOCK_TYPE
 
        public:
                static const size_t k_BlockAlign = 8;   
                static const size_t k_KeySizeMax = 56;  
 
        private:
                inline UINT32 F(UINT32 ui) const noexcept
                {
                        return ((m_S[0][LOBYTE(ui >> 24)] + m_S[1][LOBYTE(ui >> 16)]) ^ m_S[2][LOBYTE(ui >> 8)]) + m_S[3][LOBYTE(ui)];
                }
                void EncryptBlock(cCipherBlowfishBlock& b) const;
                void DecryptBlock(cCipherBlowfishBlock& b) const;
 
        public:
                // Constructor - Initialize the P and S boxes for a given Key
                cCipherBlowfish(bool bEncodeMode = true, const void* pKeyData = nullptr, size_t nKeySize = 0);
                virtual ~cCipherBlowfish();
 
                // cCipherBase support
                virtual size_t get_BlockAlignSize() const override 
                {
                        // k_BlockAlign
                        return sizeof(cCipherBlowfishBlock);
                }
 
                virtual HRESULT SetCipherKey(const void* pKeyData = nullptr, size_t nKeySize = 0) 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 nSizeBytes) override;
 
                UNITTEST_FRIEND(cCipherBlowfish);
        };
 
        class GRAYLIB_LINK cCipherAlgBlowfish : public cCipherAlgDef
        {
        public:
                cCipherAlgBlowfish() : cCipherAlgDef(CipherAlgorithm_Blowfish)
                {
                }
                virtual cCipherBase* AllocCipherAlg(bool bEncodeMode) const
                {
                        return new cCipherBlowfish(bEncodeMode);
                }
        };
}
 
#endif // _INC_cCipherBlowfish_H