cHashMD5.h

Go to the documentation of this file.

//
#ifndef _INC_cHashMD5_H
#define _INC_cHashMD5_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
#include "cHashBase.h"
#include "cHashTypeDef.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cHashMD5);
 
        class GRAYLIB_LINK cHashMD5 : public cHashCodeT<16>
        {
 
                friend class cHashMD5Builder;
        public:
                cHashMD5() noexcept
                {}
                cHashMD5(const char* pszHexDigest) 
                {
                        put_HexDigest(pszHexDigest);
                }
 
                static size_t GRAYCALL ComputeHash(BYTE pOutput[16], const void* pInput, size_t nSize);
                void SetHashFrom(const void* pInput, size_t nInputSize)
                {
                        ComputeHash(m_Data, pInput, nInputSize);
                }
                void SetHashFromStr(const char* pszString)
                {
                        // Built a hash (and finalize) for a COMPLETE string.
                        if (pszString == nullptr)
                                return;
                        ComputeHash(m_Data, pszString, StrT::Len(pszString));
                }
 
                static size_t GRAYCALL ComputeHmac(BYTE pOutput[16],const BYTE* pKey, size_t nKeySize, const void* pInput, size_t nSize);
                void SetHmacFrom(const BYTE* pKey, size_t nKeySize, const void* pInput, size_t nInputSize)
                {
                        ComputeHmac(m_Data, pKey, nKeySize, pInput, nInputSize);
                }
 
                UNITTEST_FRIEND(cHashMD5);
        };
 
        class GRAYLIB_LINK cHashMD5Builder : public cHashBase
        {
 
                typedef cHashBase SUPER_t;
 
        public:
                static const size_t k_HashSize = 16; // size bytes.
 
                UINT32 m_total[2];   
                UINT32 m_state[4];   
                BYTE m_buffer[64];   
 
                BYTE m_ipad[64];     
                BYTE m_opad[64];     
 
        public:
                cHashMD5Builder() noexcept
                {
                        cMem::Zero(m_buffer, sizeof(m_buffer));
                        cMem::Zero(m_ipad, sizeof(m_ipad));
                        cMem::Zero(m_opad, sizeof(m_opad));
                        ResetHash();
                }
                virtual ~cHashMD5Builder() noexcept
                {
                        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 nSize) override;
                virtual size_t FinalizeHash(BYTE* pOutput) override;
 
                virtual void InitHmac(const BYTE* pKey, size_t nKeySize) override;
                virtual size_t FinalizeHmac(BYTE pOutput[16]) override;
                virtual void ResetHmac() override;
        };
 
        class GRAYLIB_LINK cHashTypeMD5 : public cHashTypeDef
        {
        public:
                cHashTypeMD5() noexcept
                        : cHashTypeDef(SSL_Hash_MD5, "MD5", cHashMD5::k_Size)
                {
                }
                virtual cHashBase* AllocHash(void) const override
                {
                        return new cHashMD5Builder();
                }
                virtual size_t ComputeHash(BYTE* pOutput, const BYTE* pInput, size_t nInputSize) const override
                {
                        return cHashMD5::ComputeHash(pOutput, pInput, nInputSize);
                }
        };
}
 
#endif // _INC_cHashMD5_H