cHashSHA512.h

Go to the documentation of this file.

//
//
#ifndef _INC_cHashSHA512_H
#define _INC_cHashSHA512_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
#include "cHashBase.h"
#include "cHashTypeDef.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cHashSHA512);
 
        class GRAYLIB_LINK cHashSHA512 : public cHashCodeT<64>
        {
 
                friend class cHashSHA512Builder;
        public:
                cHashSHA512() noexcept
                {}
                cHashSHA512(const char* pszHexDigest)
                {
                        put_HexDigest(pszHexDigest);
                }
 
                static size_t GRAYCALL ComputeHash(BYTE pOutput[k_Size], const void* pInput, size_t nInputSize, bool is384);
                static size_t GRAYCALL ComputeHmac(BYTE pOutput[k_Size], const BYTE* pKey, size_t nKeySize, const void* pInput, size_t nInputSize,bool is384);
 
                UNITTEST_FRIEND(cHashSHA512);
        };
 
        class GRAYLIB_LINK cHashSHA384 : public cHashCodeT<48>
        {
 
                friend class cHashSHA512Builder;
        public:
                cHashSHA384()
                {}
                cHashSHA384(const char* pszHexDigest)
                {
                        put_HexDigest(pszHexDigest);
                }
        };
 
        class GRAYLIB_LINK cHashSHA512Builder : public cHashBase
        {
 
                typedef cHashBase SUPER_t;
 
        public:
                static const size_t k_HashSize = 64; 
                static const UINT64 k_K[80];
 
                UINT64 m_total[2];   
                UINT64 m_state[8];   
                BYTE m_buffer[128];  
 
                BYTE m_ipad[128];    
                BYTE m_opad[128];    
 
                bool m_is384;        
 
        public:
                cHashSHA512Builder(bool is384=false)
                        : m_is384(is384)
                {
                        SetZeroHash();
                }
                virtual ~cHashSHA512Builder()
                {
                        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[128]) override;
                virtual void AddToHash(const void* pInput, size_t nSizeIn) override;
                virtual size_t FinalizeHash(BYTE* pOutput) override;
 
                virtual void InitHmac(const BYTE* pKey, size_t nKeySize) override;
                virtual size_t FinalizeHmac(BYTE pOutput[64]) override;
                virtual void ResetHmac() override;
        };
 
        class cHashSHA384Builder : public cHashSHA512Builder
        {
        public:
                static const size_t k_HashSize = 48;
        public:
                cHashSHA384Builder() : cHashSHA512Builder(true)
                {
                }
        };
 
        class GRAYLIB_LINK cHashTypeSHA384 : public cHashTypeDef
        {
        public:
                cHashTypeSHA384()
                        : cHashTypeDef(SSL_Hash_SHA384, "SHA384", cHashSHA384::k_Size)
                {
                }
                virtual cHashBase* AllocHash(void) const override
                {
                        return new cHashSHA512Builder(true);
                }
                virtual size_t ComputeHash(BYTE* pOutput, const BYTE* pInput, size_t nInputSize) const override
                {
                        return cHashSHA512::ComputeHash(pOutput, pInput, nInputSize, true);
                }
        };
 
        class GRAYLIB_LINK cHashTypeSHA512 : public cHashTypeDef
        {
        public:
                cHashTypeSHA512()
                        : cHashTypeDef(SSL_Hash_SHA512, "SHA512", cHashSHA512::k_Size)
                {
                }
                virtual cHashBase* AllocHash(void) const override
                {
                        return new cHashSHA512Builder(false);
                }
                virtual size_t ComputeHash(BYTE* pOutput, const BYTE* pInput, size_t nInputSize) const override
                {
                        return cHashSHA512::ComputeHash(pOutput, pInput, nInputSize, false);
                }
        };
 
}
 
#endif // _INC_cHashSHA512_H