cHashSHA1.h

Go to the documentation of this file.

//
//
#ifndef _INC_cHashSHA1_H
#define _INC_cHashSHA1_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
#include "cHashBase.h"
#include "cHashTypeDef.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cHashSHA1);
 
        class GRAYLIB_LINK cHashSHA1 : public cHashCodeT<20>
        {
 
                friend class cHashSHA1Builder;
        public:
                cHashSHA1()
                {}
                cHashSHA1(const char* pszHexDigest)
                {
                        put_HexDigest(pszHexDigest);
                }
 
                static size_t GRAYCALL ComputeHash(BYTE pOutput[20], const void* pInput, size_t nInputSize);
                static size_t GRAYCALL ComputeHmac(BYTE pOutput[20], const BYTE* pKey, size_t nKeySize, const void* pInput, size_t nInputSize);
 
                UNITTEST_FRIEND(cHashSHA1);
        };
 
        class GRAYLIB_LINK cHashSHA1Builder : public cHashBase
        {
 
                typedef cHashBase SUPER_t;
 
        public:
                static const size_t k_HashSize = 20;
 
                UINT32 m_total[2];   
                UINT32 m_state[5];   
                BYTE m_buffer[64];   
 
                BYTE m_ipad[64];     
                BYTE m_opad[64];     
 
        public:
                cHashSHA1Builder()
                {
                        cMem::Zero(m_buffer, sizeof(m_buffer));
                        cMem::Zero(m_ipad, sizeof(m_ipad));
                        cMem::Zero(m_opad, sizeof(m_opad));
                        ResetHash();
                }
 
                virtual ~cHashSHA1Builder()
                {
                        cMem::ZeroSecure(m_total, sizeof(m_total));
                        cMem::ZeroSecure(m_state, sizeof(m_state));
                        cMem::ZeroSecure(m_buffer, sizeof(m_buffer));
                }
 
                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[20]) override;
                virtual void ResetHmac() override;
        };
 
        class GRAYLIB_LINK cHashTypeSHA1 : public cHashTypeDef
        {
 
        public:
                cHashTypeSHA1()
                        : cHashTypeDef(SSL_Hash_SHA1, "SHA1", cHashSHA1::k_Size)
                {
                }
                virtual cHashBase* AllocHash(void) const override
                {
                        return new cHashSHA1Builder();
                }
                virtual size_t ComputeHash(BYTE* pOutput, const BYTE* pInput, size_t nInputSize) const override
                {
                        return cHashSHA1::ComputeHash(pOutput, pInput, nInputSize);
                }
        };
}
#endif // _INC_cHashSHA1_H