cHashSHA256.h

Go to the documentation of this file.

//
 
#ifndef _INC_cHashSHA256_H
#define _INC_cHashSHA256_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
#include "cHashBase.h"
#include "cHashTypeDef.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cHashSHA256);
 
        class GRAYLIB_LINK cHashSHA256 : public cHashCodeT<32>
        {
 
                friend class cHashSHA256Builder;
        public:
                cHashSHA256()
                {}
                cHashSHA256(const char* pszHexDigest)
                {
                        put_HexDigest(pszHexDigest);
                }
                static size_t GRAYCALL ComputeHash(BYTE pOutput[32], const void* pInput, size_t nInputSize, bool is224);
                static size_t GRAYCALL ComputeHmac(BYTE pOutput[32], const BYTE* pKey, size_t nKeySize, const void* pInput, size_t nInputSize,bool is224);
 
                UNITTEST_FRIEND(cHashSHA256);
        };
 
        class GRAYLIB_LINK cHashSHA224 : public cHashCodeT<28>
        {
 
                friend class cHashSHA256Builder;
        public:
                cHashSHA224()
                {}
                cHashSHA224(const char* pszHexDigest)
                {
                        put_HexDigest(pszHexDigest);
                }
        };
 
        class GRAYLIB_LINK cHashSHA256Builder : public cHashBase
        {
 
                typedef cHashBase SUPER_t;
 
        public:
                static const size_t k_HashSize = 32;    // SHA-256
 
                UINT32 m_total[2];      
                UINT32 m_state[8];      
                BYTE m_buffer[64];              
 
                BYTE m_ipad[64];                
                BYTE m_opad[64];                
 
                bool m_is224;                   
 
        public:
                cHashSHA256Builder(bool is224=false)
                        : m_is224(is224)
                {
                        SetZeroHash();
                }
                virtual ~cHashSHA256Builder()
                {
                        cMem::ZeroSecure(m_total, sizeof(m_total));
                        cMem::ZeroSecure(m_state, sizeof(m_state));
                        cMem::ZeroSecure(m_buffer, sizeof(m_buffer));
                }
                void SetZeroHash()
                {
                        cMem::Zero(m_buffer, sizeof(m_buffer));
                        cMem::Zero(m_ipad, sizeof(m_ipad));
                        cMem::Zero(m_opad, sizeof(m_opad));
                        ResetHash();
                }
 
                virtual void ResetHash() override;
                virtual void ProcessHashBuffer(const BYTE pBuffer[64]) override;
                virtual void AddToHash(const void* pInput, size_t nInputSize) override;
                virtual size_t FinalizeHash(BYTE* pOutput) override;
 
                virtual void InitHmac(const BYTE* pKey, size_t nKeySize) override;
                virtual size_t FinalizeHmac(BYTE pOutput[32]) override;
                virtual void ResetHmac() override;
        };
 
        class cHashSHA224Builder : public cHashSHA256Builder
        {
        public:
                static const size_t k_HashSize = 28;
        public:
                cHashSHA224Builder() : cHashSHA256Builder(true)
                {
                }
        };
 
        class GRAYLIB_LINK cHashTypeSHA224 : public cHashTypeDef
        {
        public:
                cHashTypeSHA224()
                        : cHashTypeDef(SSL_Hash_SHA224, "SHA224", cHashSHA224::k_Size)
                {
                }
                virtual cHashBase* AllocHash(void) const override
                {
                        return new cHashSHA256Builder(true);
                }
                virtual size_t ComputeHash(BYTE* pOutput, const BYTE* pInput, size_t nInputSize) const override
                {
                        return cHashSHA256::ComputeHash(pOutput, pInput, nInputSize, true);
                }
        };
        class GRAYLIB_LINK cHashTypeSHA256 : public cHashTypeDef
        {
        public:
                cHashTypeSHA256()
                        : cHashTypeDef(SSL_Hash_SHA256, "SHA256", cHashSHA256::k_Size)
                {
                }
                virtual cHashBase* AllocHash(void) const override
                {
                        return new cHashSHA256Builder(false);
                }
                virtual size_t ComputeHash(BYTE* pOutput, const BYTE* pInput, size_t nInputSize) const override
                {
                        return cHashSHA256::ComputeHash(pOutput, pInput, nInputSize, false);
                }
        };
}
 
#endif // _INC_cHashSHA256_H