cHashBase.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cHashBase_H
#define _INC_cHashBase_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cHashCode.h"
#include "GrayCore/include/cBits.h"
#include "GrayCore/include/cMem.h"
#include "GrayCore/include/cObject.h"
 
namespace GrayLib
{
        class GRAYLIB_LINK cHashBase : public CObject // for cObjectFactory.
        {
        public:
                static const BYTE k_Padding[128];       
                static const size_t k_HashSizeMax = 64; 
 
        public:
                virtual ~cHashBase()
                {
                }
 
                virtual void ResetHash() = 0;
 
                virtual void ProcessHashBuffer(const BYTE* pBuffer)
                {
                        UNREFERENCED_PARAMETER(pBuffer);
                }
 
                virtual void AddToHash(const void* pInput, size_t nInputSize) = 0;
 
                virtual size_t FinalizeHash(OUT BYTE* pOutput) = 0;
 
                size_t ComputeHash(BYTE* pOutput, const void* pInput, size_t nInputSize)
                {
                        AddToHash(pInput, nInputSize);
                        return FinalizeHash(pOutput);
                }
 
                virtual void InitHmac(const BYTE* pKey, size_t nKeySize)
                {
                        UNREFERENCED_PARAMETER(pKey);
                        UNREFERENCED_PARAMETER(nKeySize);
                }
 
                virtual size_t FinalizeHmac(OUT BYTE* pOutput)
                {
                        UNREFERENCED_PARAMETER(pOutput);
                        return 0;
                }
 
                virtual void ResetHmac()
                {
                        ResetHash();
                }
 
                size_t ComputeHmac(BYTE* pOutput, const BYTE* pKey, size_t nKeySize, const void* pInput, size_t nInputSize)
                {
                        InitHmac(pKey, nKeySize);
                        AddToHash(pInput, nInputSize);
                        return FinalizeHmac(pOutput);
                }
 
                void AddToHashFromBlock(const cHeapBlock& m)
                {
                        AddToHash(m.get_Data(), m.get_DataSize());
                }
 
                StrLen_t AddToHashFromStr(const char* pszStr);
                HRESULT AddToHashFromStream(cStreamInput& file, IStreamProgressCallback* pProgress = nullptr);
                HRESULT AddToHashFromFile(const FILECHAR_t* pszFileName, IStreamProgressCallback* pProgress = nullptr);
 
                HRESULT ComputeHashFromStream(OUT BYTE* pOutput, cStreamInput& fin, IStreamProgressCallback* pProgress = nullptr);
                HRESULT ComputeHashFromFile(OUT BYTE* pOutput, const FILECHAR_t* pszFileName, IStreamProgressCallback* pProgress = nullptr);
        };
 
        typedef cMemBlock cHashTestData;        // static init.
        typedef cMemBlock cHashTestKey;         // static init.
}
 
#endif