cHashCode.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cHashCode_H
#define _INC_cHashCode_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "GrayCore/include/cUnitTestDecl.h"
#include "GrayCore/include/cString.h"
#include "GrayCore/include/FileName.h"
#include "GrayCore/include/cHeap.h"
#include "GrayCore/include/cStreamProgress.h"
#include "GrayCore/include/cStream.h"
 
namespace GrayLib
{
        enum SSL_Hash_TYPE      // BYTE
        {
 
                SSL_Hash_NONE = 0,              // Choose no hashing ?
                SSL_Hash_MD5 = 1,               // 16 bytes
                SSL_Hash_SHA1 = 2,              // 20 bytes
                SSL_Hash_SHA224 = 3,
                SSL_Hash_SHA256 = 4,    // 32 bytes
                SSL_Hash_SHA384 = 5,    // 48 bytes
                SSL_Hash_SHA512 = 6,    // 64 bytes
 
                // SSL_Hash_X = 10,     // Add NON standard hashes here. MD2, MD4 ?
                SSL_Hash_QTY,
        };
 
        class GRAYLIB_LINK cHashCode : public cHeapBlock
        {
 
                typedef cHeapBlock SUPER_t;
                typedef cHashCode THIS_t;
 
        public:
 
                // k_HashSizeMax
 
                cHashCode() noexcept
                {
                }
                cHashCode(size_t nSize)  
                        : cHeapBlock(nSize)
                {
                        InitZeros();
                }
                cHashCode(const void* p, size_t nSize)
                        : cHeapBlock(p, nSize)
                {
                }
                cHashCode(const SUPER_t& h1)
                        : cHeapBlock(h1)
                {
                }
                ~cHashCode()
                {
                        SetErase();
                }
 
                bool isValidHash() const noexcept
                {
                        return !this->IsZeros();        // all zeros = bad.
                }
                size_t get_HashSize() const noexcept
                {
                        if (!isValidHash())
                                return 0;
                        return get_DataSize();
                }
                bool isMatch(const SUPER_t& match) const
                {
                        size_t nSize1 = get_HashSize();
                        size_t nSize2 = (match.IsZeros()) ? 0 : match.get_DataSize();
                        if (nSize1 != nSize2 || nSize2 == 0)
                                return false;
                        return !cMem::Compare(get_DataBytes(), match.get_DataBytes(), nSize1);
                }
                BYTE* SetRawDigest(const BYTE* pData, size_t nSize)
                {
                        ASSERT(nSize > 0);
                        SUPER_t::Alloc(pData, nSize);
                        return SUPER_t::get_DataBytes();
                }
                BYTE* put_RawDigest(const SUPER_t& m)
                {
                        return SetRawDigest(m.get_DataBytes(), m.get_DataSize());
                }
                BYTE* ref_RawDigest()
                {
                        return SUPER_t::get_DataBytes();
                }
 
                void SetErase()
                {
                        if (SUPER_t::isValidPtr())
                        {
                                InitZeros();
                                SUPER_t::Free();
                        }
                }
                THIS_t& operator = (const THIS_t& h1)
                {
                        SetCopy(h1);
                        return *this;
                }
 
                StrLen_t get_HexSize() const
                {
                        return cMem::GetHexDigestSize(get_DataSize());
                }
                StrLen_t GetHexDigest(OUT char* pszHexString) const
                {
                        return cMem::GetHexDigest(pszHexString, get_DataBytes(), get_HashSize());
                }
                cStringA get_HexDigest() const
                {
                        cStringA sTmp;
                        StrLen_t nLen = GetHexDigest(sTmp.GetBuffer(get_HexSize()));
                        sTmp.ReleaseBuffer(nLen);
                        return sTmp;
                }
                bool isMatchHexDigest(const char* pszHexStr) const
                {
                        cHashCode h2(get_DataSize());
                        HRESULT hRes = h2.put_HexDigest(pszHexStr);
                        if (FAILED(hRes))
                                return false;
                        return isMatch(h2);
                }
 
                HRESULT put_HexDigest(const char* pszInp)
                {
                        return cMem::SetHexDigest(pszInp, ref_RawDigest(), get_DataSize());
                }
        };
 
        template<int TYPE_SIZE>
        class GRAYLIB_LINK cHashCodeT : public cMemStatic<TYPE_SIZE>
        {
 
                typedef cMemStatic<TYPE_SIZE> SUPER_t;
 
        public:
                bool isValidHash() const noexcept
                {
                        return !cMem::IsZeros(this->m_Data, TYPE_SIZE);
                }
                size_t get_HashSize() const noexcept
                {
                        if (!isValidHash())
                                return 0;
                        return TYPE_SIZE;
                }
                cHashCode get_HashCode() const  
                {
                        return cHashCode(this->get_DataBytes(), this->get_HashSize());
                }
 
                StrLen_t GetHexDigest(OUT char* pszHexString) const
                {
                        return cMem::GetHexDigest(pszHexString, this->m_Data, this->get_HashSize());
                }
                cStringA get_HexDigest() const
                {
                        cStringA sTmp;
                        StrLen_t nLen = GetHexDigest(sTmp.GetBuffer(SUPER_t::k_SizeHexDigest));
                        sTmp.ReleaseBuffer(nLen);
                        return sTmp;
                }
                HRESULT put_HexDigest(const char* pszInp)
                {
                        return cMem::SetHexDigest(pszInp, this->m_Data, TYPE_SIZE);
                }
        };
 
#ifdef GRAY_DLL // force implementation/instantiate for DLL/SO.
        // Force 16, 20, 28, 32, 48, 64
        template class GRAYLIB_LINK cHashCodeT<16>;
        template class GRAYLIB_LINK cHashCodeT<20>;
        template class GRAYLIB_LINK cHashCodeT<28>;
        template class GRAYLIB_LINK cHashCodeT<32>;
        template class GRAYLIB_LINK cHashCodeT<48>;
        template class GRAYLIB_LINK cHashCodeT<64>;
#endif
} 
#endif