cCipherWrap.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cCipherWrap_H
#define _INC_cCipherWrap_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
#include "cCipherTypeDef.h"
#include "GrayCore/include/cNewPtr.h"
 
namespace GrayLib
{
        class cCipherPadding;
 
        class GRAYLIB_LINK cCipherWrap
        {
 
        public:
                const cCipherTypeDef* m_pCipherTypeDef;                 
                cNewPtr<cCipherBase> m_pCryptBase;                              
 
                size_t m_nSizeKey;                      
                bool m_bEncodeMode;                     
 
                const cCipherPadding* m_pCBCPadding;                    
 
                static const size_t k_MAX_BLOCK_LENGTH = 16;    
                BYTE m_Unprocessed[k_MAX_BLOCK_LENGTH];                 
                size_t m_nSizeUnprocessed;                                              
 
                static const size_t k_MAX_IV_LENGTH = 16;               
                BYTE m_iv[k_MAX_IV_LENGTH];                                             
                size_t m_nSizeIV;                                                               
 
        public:
                cCipherWrap()
                        : m_pCipherTypeDef(nullptr)
                        , m_nSizeKey(0)
                        , m_bEncodeMode(false)
                        , m_pCBCPadding(nullptr)
                        , m_nSizeUnprocessed(0)
                        , m_nSizeIV(0)
                {
                        cMem::Zero(m_Unprocessed, sizeof(m_Unprocessed));
                        cMem::Zero(m_iv, sizeof(m_iv));
                }
                ~cCipherWrap()
                {
                        SetZeroCipher();
                }
 
                HRESULT SetCipherType(bool bEncodeMode, const cCipherTypeDef* pCipherTypeDef, const void* pKeyData);
 
                void SetZeroCipher();
 
                HRESULT SetCipherKey(const void* pKeyData, size_t nSizeKey);
                HRESULT SetCipherIV(const BYTE* pIV, size_t nSizeIV);
                void ResetCipher();
                HRESULT UpdateCipher(BYTE* pOutput, const BYTE* pInput, size_t nInputSize);
                HRESULT FinishCipher(BYTE* pOutput, size_t* nOutputSize);
 
                inline size_t get_BlockAlignSize() const
                {
                        if ( nullptr == this->m_pCipherTypeDef)
                                return 0;
                        return this->m_pCipherTypeDef->m_nBlockAlignSize;
                }
 
                inline CIPHER_BLOCK_TYPE get_CipherMode() const
                {
                        if ( nullptr == this->m_pCipherTypeDef)
                                return CIPHER_BLOCK_UNK;
                        return this->m_pCipherTypeDef->m_eBlockMode;
                }
 
                inline size_t get_CipherIVSize() const
                {
                        if (this->m_nSizeIV != 0)       // overridden?
                                return this->m_nSizeIV;
                        if (nullptr == this->m_pCipherTypeDef)
                                return 0;
                        return this->m_pCipherTypeDef->m_nSizeIV;
                }
 
                HRESULT CipherCrypt(BYTE* pOutput, const BYTE* pInput, size_t nInputSize, const BYTE* pIV, size_t nSizeIV);
 
                HRESULT put_CBCPadding(const cCipherPadding* pPadding = nullptr);
 
                HRESULT WriteGCMTag(BYTE* pTag, size_t nSizeTag);
                HRESULT CheckGCMTag(const BYTE* pTag, size_t nSizeTag);
 
                // For CIPHER_BLOCK_GCM or CIPHER_BLOCK_CCM
                HRESULT AuthEncrypt(BYTE* pOutput, const BYTE* pInput, size_t nInputSize, const BYTE* pIV, size_t nSizeIV, const BYTE* pAdd, size_t nSizeAdd, BYTE* pTag, size_t nSizeTag);
                HRESULT AuthDecrypt(BYTE* pOutput, const BYTE* pInput, size_t nInputSize, const BYTE* pIV, size_t nSizeIV, const BYTE* pAdd, size_t nSizeAdd, const BYTE* pTag, size_t nSizeTag);
 
                UNITTEST_FRIEND(cCipherWrap);
        };
}
 
#endif // _INC_cCipherWrap_H