360 lines
11 KiB
C++
360 lines
11 KiB
C++
#ifndef HGL_UTIL_HASH_INCLUDE
|
||
#define HGL_UTIL_HASH_INCLUDE
|
||
|
||
#include<hgl/type/String.h>
|
||
namespace hgl
|
||
{
|
||
namespace util
|
||
{
|
||
/**
|
||
* Hash算法枚举
|
||
*/
|
||
enum class HASH ///Hash算法枚举
|
||
{
|
||
Adler32, ///<一种较CRC32更为安全的快速HASH算法
|
||
CRC32, ///<最快速的HASH算法，但最不安全，仅用于低安全性的简单验证
|
||
MD4, ///<较MD5在安全性下稍弱。但仍未被攻破，且较MD5更快
|
||
MD5, ///<最常用的HASH算法
|
||
|
||
SHA1, ///<较MD5更为安全，但计算较慢
|
||
SHA1LE, ///<SHA1改版
|
||
SHA256,
|
||
SHA512,
|
||
|
||
xxH32,
|
||
xxH64,
|
||
XXH3_64,
|
||
XXH3_128,
|
||
|
||
|
||
ENUM_CLASS_RANGE(Adler32,XXH3_128)
|
||
};//enum HASH
|
||
|
||
/**
|
||
* Hash编码结构模板
|
||
*/
|
||
template<int SIZE> struct HashCode
|
||
{
|
||
unsigned char code[SIZE];
|
||
|
||
public:
|
||
|
||
template<typename T>
|
||
using CharArray=T[(SIZE<<1)+1];
|
||
|
||
public:
|
||
|
||
HashCode()
|
||
{
|
||
hgl_zero(code);
|
||
}
|
||
|
||
static constexpr int size(){return SIZE;}
|
||
|
||
const unsigned char operator[](int index)const
|
||
{
|
||
return code[index];
|
||
}
|
||
|
||
void CopyFrom(const void *ptr)
|
||
{
|
||
memcpy(code,ptr,SIZE);
|
||
}
|
||
|
||
void FromString(const char *str)
|
||
{
|
||
ParseHexStr(code,str,SIZE);
|
||
}
|
||
|
||
template<typename T>
|
||
void ToUpperString(T *str,const T gap_char=0) const
|
||
{
|
||
ToUpperHexStr<T>(str,code,SIZE,gap_char);
|
||
}
|
||
|
||
template<typename T>
|
||
void ToLowerString(T *str,const T gap_char=0) const
|
||
{
|
||
ToLowerHexStr<T>(str,code,SIZE,gap_char);
|
||
}
|
||
|
||
const int CompFunc(const HashCode<SIZE> &hash)const
|
||
{
|
||
const unsigned char *s=code;
|
||
const unsigned char *t=hash.code;
|
||
|
||
for(int i=0;i<SIZE;i++)
|
||
{
|
||
if(*s!=*t)
|
||
return(*s-*t);
|
||
|
||
s++;
|
||
t++;
|
||
}
|
||
|
||
return(0);
|
||
}
|
||
|
||
CompOperator(const HashCode<SIZE> &,CompFunc)
|
||
};//template<int SIZE> struct HashCode
|
||
|
||
using HashCodeCRC32 =HashCode<4> ;
|
||
using HashCodeAdler32 =HashCode<4> ;
|
||
using HashCodeMD5 =HashCode<16> ;
|
||
using HashCodeMD4 =HashCode<16> ;
|
||
using HashCodeSHA1 =HashCode<20> ;
|
||
using HashCodeSHA1LE =HashCode<20> ;
|
||
using HashCodeSHA256 =HashCode<32> ;
|
||
using HashCodeSHA512 =HashCode<64> ;
|
||
using HashCodexxH32 =HashCode<4> ;
|
||
using HashCodexxH64 =HashCode<8> ;
|
||
using HashCodeXXH3_64 =HashCode<8> ;
|
||
using HashCodeXXH3_128 =HashCode<16> ;
|
||
|
||
const int hash_code_bytes[]={4,4,16,16,20,20,32,64,4,8,16}; //hash码长度
|
||
|
||
/**
|
||
* 散列值计算功能基类
|
||
*/
|
||
class Hash ///散列值计算功能基类
|
||
{
|
||
public:
|
||
|
||
virtual ~Hash()=default;
|
||
|
||
virtual void GetName(UTF8String &)const=0; ///<取得HASH算法的名称
|
||
virtual void GetName(UTF16String &)const=0; ///<取得HASH算法的名称
|
||
virtual const int GetHashBytes()const=0; ///<取得HASH码字节长度(MD4/MD5为16,SHA1为20)
|
||
|
||
virtual void Init()=0; ///<初始化散列值计算
|
||
virtual void Update(const void *,uint)=0; ///<提交新的数据
|
||
virtual void Final(void *)=0; ///<结束并取得结果
|
||
|
||
template<typename T>
|
||
void Write(const T &data)
|
||
{
|
||
Update(&data,sizeof(T));
|
||
}
|
||
|
||
template<typename T>
|
||
void Write(const T *ptr,const uint count)
|
||
{
|
||
Update(ptr,sizeof(T)*count);
|
||
}
|
||
};//class Hash
|
||
|
||
template<HASH ha> Hash *CreateHash(); ///<创建一个hash值计算类实例
|
||
|
||
#define HGL_CREATE_HASH_FUNC(name) Hash *Create##name##Hash(); \
|
||
template<> inline Hash *CreateHash<HASH::name>(){return Create##name##Hash();}
|
||
|
||
HGL_CREATE_HASH_FUNC(Adler32)
|
||
HGL_CREATE_HASH_FUNC(CRC32)
|
||
HGL_CREATE_HASH_FUNC(MD4)
|
||
HGL_CREATE_HASH_FUNC(MD5)
|
||
HGL_CREATE_HASH_FUNC(SHA1)
|
||
HGL_CREATE_HASH_FUNC(SHA1LE)
|
||
HGL_CREATE_HASH_FUNC(SHA256)
|
||
HGL_CREATE_HASH_FUNC(SHA512)
|
||
HGL_CREATE_HASH_FUNC(xxH32)
|
||
HGL_CREATE_HASH_FUNC(xxH64)
|
||
HGL_CREATE_HASH_FUNC(XXH3_64)
|
||
HGL_CREATE_HASH_FUNC(XXH3_128)
|
||
|
||
#undef HGL_CREATE_HASH_FUNC
|
||
|
||
inline Hash *CreateHash(HASH ha)
|
||
{
|
||
RANGE_CHECK_RETURN_NULLPTR(ha)
|
||
|
||
using CreateHashFunc=Hash *(*)();
|
||
|
||
const CreateHashFunc func[(size_t)HASH::RANGE_SIZE]=
|
||
{
|
||
CreateAdler32Hash,
|
||
CreateCRC32Hash,
|
||
CreateMD4Hash,
|
||
CreateMD5Hash,
|
||
CreateSHA1Hash,
|
||
CreateSHA1LEHash,
|
||
CreateSHA256Hash,
|
||
CreateSHA512Hash,
|
||
CreatexxH32Hash,
|
||
CreatexxH64Hash,
|
||
CreateXXH3_64Hash,
|
||
CreateXXH3_128Hash,
|
||
};
|
||
|
||
return func[(size_t)ha]();
|
||
}
|
||
|
||
/**
|
||
* 计算一段数据的Hash值
|
||
* @param data 数据指针
|
||
* @param size 数据长度
|
||
* @param ha hash算法
|
||
* @param hash_code 计算后的hash值存放处
|
||
* @return 是否计算成功
|
||
*/
|
||
template<HASH ha> bool CountHash(const void *data,int size,void *hash_code)
|
||
{
|
||
if(!data||size<=0||!hash_code)return(false);
|
||
|
||
Hash *h=CreateHash<ha>();
|
||
|
||
if(!h)return(false);
|
||
|
||
h->Init();
|
||
h->Update(data,size);
|
||
h->Final(hash_code);
|
||
|
||
delete h;
|
||
return(true);
|
||
}
|
||
|
||
/**
|
||
* 计算一段数据的Hash值
|
||
* @param data 数据指针
|
||
* @param size 数据长度
|
||
* @param ha hash算法
|
||
* @param hash_code 计算后的hash值存放处
|
||
* @return 是否计算成功
|
||
*/
|
||
inline bool CountHash(const void *data,int size,HASH ha,void *hash_code)
|
||
{
|
||
RANGE_CHECK_RETURN_FALSE(ha)
|
||
if(!data||size<=0||!hash_code)return(false);
|
||
|
||
using CountHashFunc=bool (*)(const void *,int size,void *);
|
||
|
||
const CountHashFunc func[(size_t)HASH::RANGE_SIZE]=
|
||
{
|
||
CountHash<HASH::Adler32 >,
|
||
CountHash<HASH::CRC32 >,
|
||
CountHash<HASH::MD4 >,
|
||
CountHash<HASH::MD5 >,
|
||
CountHash<HASH::SHA1 >,
|
||
CountHash<HASH::SHA1LE >,
|
||
CountHash<HASH::SHA256 >,
|
||
CountHash<HASH::SHA512 >,
|
||
CountHash<HASH::xxH32 >,
|
||
CountHash<HASH::xxH64 >,
|
||
CountHash<HASH::XXH3_64 >,
|
||
CountHash<HASH::XXH3_128>
|
||
};
|
||
|
||
return func[(size_t)ha](data,size,hash_code);
|
||
}
|
||
|
||
/**
|
||
* 计算一段数据的Hash值
|
||
* @param data 数据指针
|
||
* @param size 数据长度
|
||
* @param ha hash算法
|
||
* @param hash_str 计算后的hash值存放处
|
||
* @param litter 小写字母
|
||
* @return 是否计算成功
|
||
*/
|
||
template<HASH ha> bool CountHashStr(const void *data,int size,UTF8String &hash_str,bool litter=true)
|
||
{
|
||
if(!data||size<=0)return(false);
|
||
|
||
Hash *h=CreateHash<ha>();
|
||
|
||
if(!h)return(false);
|
||
|
||
const int hash_bytes=hash_code_bytes[(size_t)ha];
|
||
|
||
uint8 *hash_code=new uint8[hash_bytes];
|
||
char *hash_code_str=new char[1+(hash_bytes<<1)];
|
||
|
||
h->Init();
|
||
h->Update(data,size);
|
||
h->Final(hash_code);
|
||
|
||
delete h;
|
||
|
||
DataToHexStr(hash_code_str,hash_code,hash_bytes,litter?LowerHexChar:UpperHexChar);
|
||
|
||
hash_str.SetInstance(hash_code_str,hash_bytes<<1);
|
||
|
||
delete[] hash_code;
|
||
return(true);
|
||
}
|
||
|
||
/**
|
||
* 计算一段数据的Hash值
|
||
* @param data 数据指针
|
||
* @param size 数据长度
|
||
* @param ha hash算法
|
||
* @param hash_str 计算后的hash值存放处
|
||
* @param litter 小写字母
|
||
* @return 是否计算成功
|
||
*/
|
||
inline bool CountHash(const void *data,int size,HASH ha,UTF8String &hash_str,bool litter=true)
|
||
{
|
||
RANGE_CHECK_RETURN_FALSE(ha)
|
||
if(!data||size<=0)return(false);
|
||
|
||
using CountHashFunc=bool (*)(const void *,int size,UTF8String &,bool);
|
||
|
||
const CountHashFunc func[(size_t)HASH::RANGE_SIZE]=
|
||
{
|
||
CountHashStr<HASH::Adler32 >,
|
||
CountHashStr<HASH::CRC32 >,
|
||
CountHashStr<HASH::MD4 >,
|
||
CountHashStr<HASH::MD5 >,
|
||
CountHashStr<HASH::SHA1 >,
|
||
CountHashStr<HASH::SHA1LE >,
|
||
CountHashStr<HASH::SHA256 >,
|
||
CountHashStr<HASH::SHA512 >,
|
||
CountHashStr<HASH::xxH32 >,
|
||
CountHashStr<HASH::xxH64 >,
|
||
CountHashStr<HASH::XXH3_64 >,
|
||
CountHashStr<HASH::XXH3_128 >
|
||
};
|
||
|
||
return func[(size_t)ha](data,size,hash_str,litter);
|
||
}
|
||
|
||
#define HGL_COUNT_HASH_FUNC(name) inline bool Count##name(const void *data, int size, HashCode##name &hc) { return CountHash<HASH::name>(data, size, &hc); } \
|
||
inline bool Count##name(const void *data, int size, UTF8String &hash_str, bool litter = true) { return CountHashStr<HASH::name>(data, size, hash_str, litter); } \
|
||
inline bool Count##name(const UTF8String &str, UTF8String &hash_str, bool litter = true) { return CountHashStr<HASH::name>(str.c_str(), str.Length(), hash_str, litter); }
|
||
|
||
HGL_COUNT_HASH_FUNC(Adler32)
|
||
HGL_COUNT_HASH_FUNC(CRC32)
|
||
HGL_COUNT_HASH_FUNC(MD4)
|
||
HGL_COUNT_HASH_FUNC(MD5)
|
||
HGL_COUNT_HASH_FUNC(SHA1)
|
||
HGL_COUNT_HASH_FUNC(SHA1LE)
|
||
HGL_COUNT_HASH_FUNC(SHA256)
|
||
HGL_COUNT_HASH_FUNC(SHA512)
|
||
HGL_COUNT_HASH_FUNC(xxH32)
|
||
HGL_COUNT_HASH_FUNC(xxH64)
|
||
HGL_COUNT_HASH_FUNC(XXH3_64)
|
||
HGL_COUNT_HASH_FUNC(XXH3_128)
|
||
|
||
#undef HGL_COUNT_HASH_FUNC
|
||
|
||
/**
|
||
* 取得一个文件的hash值
|
||
* @param filename 文件名
|
||
* @param ha hash算法
|
||
* @param hash_code 计算后的hash存放处
|
||
* @return 是否计算成功
|
||
*/
|
||
bool GetFileHash(const OSString &filename,HASH ha,void *hash_code);
|
||
|
||
/**
|
||
* 取得一个文件的hash值
|
||
* @param filename 文件名
|
||
* @param ha hash算法
|
||
* @param hash_str 计算后的hash值存放处
|
||
* @param litter 小写字母
|
||
* @return 是否计算成功
|
||
*/
|
||
bool GetFileHash(const OSString &filename,HASH ha,UTF8String &hash_str,bool litter=true);
|
||
}//namespace util
|
||
}//namespace hgl
|
||
#endif//HGL_UTIL_HASH_INCLUDE
|