cCipherGCM.h

Go to the documentation of this file.

//
//
#ifndef _INC_cCipherGCM_H
#define _INC_cCipherGCM_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cCipherBase.h"
#include "cCipherTypeDef.h"
 
namespace GrayLib
{
        class GRAYLIB_LINK cCipherGCM : public cCipherBlockBase
        {
 
        public:
                static const size_t k_BlockAlign = 16; // 128
                static const UINT64 k_last4[k_BlockAlign];
 
        public:
                UINT64 m_HL[k_BlockAlign];            
                UINT64 m_HH[k_BlockAlign];            
 
                UINT64 m_len;                                           
                UINT64 m_add_len;                                       
                BYTE m_base_ectr[k_BlockAlign];         
                BYTE m_y[k_BlockAlign];                         
                BYTE m_buf[k_BlockAlign];                       
 
        private:
                HRESULT BuildGCMTable();
                void MultiplyGCM(const BYTE x[k_BlockAlign], BYTE pOutput[k_BlockAlign]);
                void SetZeroGCM();
 
        public:
                cCipherGCM(bool bEncodeMode, CipherAlgorithm_TYPE eCipherAlgorithm)
                        : cCipherBlockBase(bEncodeMode, eCipherAlgorithm)
                        , m_len(0)
                        , m_add_len(0)
                {
                }
                virtual ~cCipherGCM()
                {
                        SetZeroGCM();
                }
 
                virtual HRESULT SetCipherKey(const void* pKeyData, size_t nKeySize) override;
 
                virtual HRESULT AuthEncrypt(BYTE* pOutput, const BYTE* pInput, size_t nSize,
                        const BYTE* pIV, size_t nSizeIV,
                        const BYTE* pAdd, size_t nSizeAdd,
                        BYTE* pTag, size_t nSizeTag) override;
 
                virtual HRESULT AuthDecrypt(BYTE* pOutput, const BYTE* pInput, size_t nSize,
                        const BYTE* pIV, size_t nSizeIV,
                        const BYTE* pAdd, size_t nSizeAdd,
                        const BYTE* pTag, size_t nSizeTag) override;
 
                //
                HRESULT StartGCM(const BYTE* pIV, size_t nSizeIV, const BYTE* pAdd, size_t nSizeAdd);
 
                //       If buffers overlap, the output buffer must trail at least 8 bytes
                //       behind the input buffer.
 
                HRESULT UpdateGCM(BYTE* pOutput, const BYTE* pInput, size_t nSize);
 
                HRESULT FinishGCM(BYTE* pTag, size_t nSizeTag);
 
                UNITTEST_FRIEND(cCipherGCM);
        };
 
        class GRAYLIB_LINK cCipherAlgGCM_AES : public cCipherAlgDef
        {
        public:
                cCipherAlgGCM_AES() : cCipherAlgDef(CipherAlgorithm_GCM_AES)
                {
                }
                virtual cCipherBase* AllocCipherAlg(bool bEncodeMode) const
                {
                        return new cCipherGCM(bEncodeMode, CipherAlgorithm_AES);
                }
        };
 
        class GRAYLIB_LINK cCipherAlgGCM_Camellia : public cCipherAlgDef
        {
        public:
                cCipherAlgGCM_Camellia() : cCipherAlgDef(CipherAlgorithm_GCM_Camellia)
                {
                }
                virtual cCipherBase* AllocCipherAlg(bool bEncodeMode) const
                {
                        return new cCipherGCM(bEncodeMode, CipherAlgorithm_Camellia);
                }
        };
}
 
#endif // _INC_