sid
/
NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rework hashes (also fix Fletcher16 and CRC64)

This commit is contained in:
Jérôme Leclercq 2022-02-10 01:46:58 +01:00
parent 52100e3b3b
commit 97ee89afb7
29 changed files with 1262 additions and 1330 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/Nazara/Core/Algorithm.hpp
View File

@ -29,7 +29,7 @@ namespace Nz
template<typename O, typename F, typename Tuple> decltype(auto) Apply(O& object, F&& fn, Tuple&& t);
template<typename T> constexpr std::size_t BitCount();
template<typename T> ByteArray ComputeHash(HashType hash, const T& v);
template<typename T> ByteArray ComputeHash(AbstractHash* hash, const T& v);
template<typename T> ByteArray ComputeHash(AbstractHash& hash, const T& v);
template<typename T, std::size_t N> constexpr std::size_t CountOf(T(&name)[N]) noexcept;
template<typename T> std::size_t CountOf(const T& c);
inline bool HashAppend(AbstractHash* hash, const std::string_view& v);

14
include/Nazara/Core/Algorithm.inl
View File

@ -178,7 +178,7 @@ namespace Nz
template<typename T>
ByteArray ComputeHash(HashType hash, const T& v)
{
return ComputeHash(AbstractHash::Get(hash).get(), v);
return ComputeHash(*AbstractHash::Get(hash), v);
}
/*!
@ -195,15 +195,13 @@ namespace Nz
* \see ComputeHash
*/
template<typename T>
ByteArray ComputeHash(AbstractHash* hash, const T& v)
ByteArray ComputeHash(AbstractHash& hash, const T& v)
{
NazaraAssert(hash != nullptr, "Invalid abstracthash pointer");
hash->Begin();
hash.Begin();
HashAppend(hash, v);
return hash->End();
return hash.End();
}
/*!
@ -234,9 +232,9 @@ namespace Nz
return c.size();
}
inline bool HashAppend(AbstractHash* hash, const std::string_view& v)
inline bool HashAppend(AbstractHash& hash, const std::string_view& v)
{
hash->Append(reinterpret_cast<const UInt8*>(v.data()), v.size());
hash.Append(reinterpret_cast<const UInt8*>(v.data()), v.size());
return true;
}

2
include/Nazara/Core/ByteArray.hpp
View File

@ -129,7 +129,7 @@ namespace Nz
Container m_array;
};
inline bool HashAppend(AbstractHash* hash, const ByteArray& byteArray);
inline bool HashAppend(AbstractHash& hash, const ByteArray& byteArray);
}
namespace std

4
include/Nazara/Core/ByteArray.inl
View File

@ -732,9 +732,9 @@ namespace Nz
return m_array >= rhs.m_array;
}
inline bool HashAppend(AbstractHash* hash, const ByteArray& byteArray)
inline bool HashAppend(AbstractHash& hash, const ByteArray& byteArray)
{
hash->Append(byteArray.GetConstBuffer(), byteArray.GetSize());
hash.Append(byteArray.GetConstBuffer(), byteArray.GetSize());
return true;
}
}

4
include/Nazara/Core/File.hpp
View File

@ -60,7 +60,7 @@ namespace Nz
File& operator=(File&& file) noexcept;
static inline ByteArray ComputeHash(HashType hash, const std::filesystem::path& filePath);
static inline ByteArray ComputeHash(AbstractHash* hash, const std::filesystem::path& filePath);
static inline ByteArray ComputeHash(AbstractHash& hash, const std::filesystem::path& filePath);
private:
void FlushStream() override;
@ -71,7 +71,7 @@ namespace Nz
std::unique_ptr<FileImpl> m_impl;
};
NAZARA_CORE_API bool HashAppend(AbstractHash* hash, const File& originalFile);
NAZARA_CORE_API bool HashAppend(AbstractHash& hash, const File& originalFile);
}
#include <Nazara/Core/File.inl>

4
include/Nazara/Core/File.inl
View File

@ -18,7 +18,7 @@ namespace Nz
inline ByteArray File::ComputeHash(HashType hash, const std::filesystem::path& filePath)
{
return ComputeHash(AbstractHash::Get(hash).get(), filePath);
return ComputeHash(*AbstractHash::Get(hash), filePath);
}
/*!
@ -29,7 +29,7 @@ namespace Nz
* \param filePath Path for the file
*/
inline ByteArray File::ComputeHash(AbstractHash* hash, const std::filesystem::path& filePath)
inline ByteArray File::ComputeHash(AbstractHash& hash, const std::filesystem::path& filePath)
{
return Nz::ComputeHash(hash, File(filePath));
}

13
include/Nazara/Core/Hash/CRC32.hpp
View File

@ -13,13 +13,11 @@
namespace Nz
{
struct HashCRC32_state;
class NAZARA_CORE_API HashCRC32 : public AbstractHash
class NAZARA_CORE_API CRC32Hash final : public AbstractHash
{
public:
HashCRC32(UInt32 polynomial = 0x04c11db7);
virtual ~HashCRC32();
CRC32Hash(UInt32 polynomial = DefaultPolynomial);
virtual ~CRC32Hash();
void Append(const UInt8* data, std::size_t len) override;
void Begin() override;
@ -28,8 +26,11 @@ namespace Nz
std::size_t GetDigestLength() const override;
const char* GetHashName() const override;
static constexpr UInt32 DefaultPolynomial = 0x04C11DB7;
private:
HashCRC32_state* m_state;
UInt32 m_crc;
const UInt32* m_table;
};
}

6
include/Nazara/Core/Hash/CRC64.hpp
View File

@ -13,11 +13,11 @@
namespace Nz
{
class NAZARA_CORE_API HashCRC64 : public AbstractHash
class NAZARA_CORE_API CRC64Hash final : public AbstractHash
{
public:
HashCRC64() = default;
~HashCRC64() = default;
CRC64Hash() = default;
~CRC64Hash() = default;
void Append(const UInt8* data, std::size_t len) override;
void Begin() override;

11
include/Nazara/Core/Hash/Fletcher16.hpp
View File

@ -13,13 +13,11 @@
namespace Nz
{
struct HashFletcher16_state;
class NAZARA_CORE_API HashFletcher16 : public AbstractHash
class NAZARA_CORE_API Fletcher16Hash final : public AbstractHash
{
public:
HashFletcher16();
virtual ~HashFletcher16();
Fletcher16Hash() = default;
~Fletcher16Hash() = default;
void Append(const UInt8* data, std::size_t len) override;
void Begin() override;
@ -29,7 +27,8 @@ namespace Nz
const char* GetHashName() const override;
private:
HashFletcher16_state* m_state;
UInt16 m_sum1;
UInt16 m_sum2;
};
}

14
include/Nazara/Core/Hash/MD5.hpp
View File

@ -13,13 +13,11 @@
namespace Nz
{
struct HashMD5_state;
class NAZARA_CORE_API HashMD5 : public AbstractHash
class NAZARA_CORE_API MD5Hash final : public AbstractHash
{
public:
HashMD5();
virtual ~HashMD5();
MD5Hash() = default;
~MD5Hash() = default;
void Append(const UInt8* data, std::size_t len) override;
void Begin() override;
@ -29,7 +27,11 @@ namespace Nz
const char* GetHashName() const override;
private:
HashMD5_state* m_state;
void md5_process(const UInt8* data);
std::size_t m_count[2]; /* message length in bits, lsw first */
UInt32 m_abcd[4]; /* digest buffer */
UInt8 m_buf[64]; /* accumulate block */
};
}

6
include/Nazara/Core/Hash/SHA1.hpp
View File

@ -15,11 +15,11 @@ namespace Nz
{
union SHA_CTX;
class NAZARA_CORE_API HashSHA1 : public AbstractHash
class NAZARA_CORE_API SHA1Hash final : public AbstractHash
{
public:
HashSHA1();
virtual ~HashSHA1();
SHA1Hash();
~SHA1Hash();
void Append(const UInt8* data, std::size_t len) override;
void Begin() override;

6
include/Nazara/Core/Hash/SHA224.hpp
View File

@ -15,11 +15,11 @@ namespace Nz
{
union SHA_CTX;
class NAZARA_CORE_API HashSHA224 : public AbstractHash
class NAZARA_CORE_API SHA224Hash final : public AbstractHash
{
public:
HashSHA224();
virtual ~HashSHA224();
SHA224Hash();
~SHA224Hash();
void Append(const UInt8* data, std::size_t len) override;
void Begin() override;

6
include/Nazara/Core/Hash/SHA256.hpp
View File

@ -15,11 +15,11 @@ namespace Nz
{
union SHA_CTX;
class NAZARA_CORE_API HashSHA256 : public AbstractHash
class NAZARA_CORE_API SHA256Hash final : public AbstractHash
{
public:
HashSHA256();
virtual ~HashSHA256();
SHA256Hash();
~SHA256Hash();
void Append(const UInt8* data, std::size_t len) override;
void Begin() override;

6
include/Nazara/Core/Hash/SHA384.hpp
View File

@ -15,11 +15,11 @@ namespace Nz
{
union SHA_CTX;
class NAZARA_CORE_API HashSHA384 : public AbstractHash
class NAZARA_CORE_API SHA384Hash final : public AbstractHash
{
public:
HashSHA384();
virtual ~HashSHA384();
SHA384Hash();
~SHA384Hash();
void Append(const UInt8* data, std::size_t len) override;
void Begin() override;

6
include/Nazara/Core/Hash/SHA512.hpp
View File

@ -15,11 +15,11 @@ namespace Nz
{
union SHA_CTX;
class NAZARA_CORE_API HashSHA512 : public AbstractHash
class NAZARA_CORE_API SHA512Hash final : public AbstractHash
{
public:
HashSHA512();
virtual ~HashSHA512();
SHA512Hash();
~SHA512Hash();
void Append(const UInt8* data, std::size_t len) override;
void Begin() override;

16
include/Nazara/Core/Hash/Whirlpool.hpp
View File

@ -13,13 +13,11 @@
namespace Nz
{
struct HashWhirlpool_state;
class NAZARA_CORE_API HashWhirlpool : public AbstractHash
class NAZARA_CORE_API WhirlpoolHash final : public AbstractHash
{
public:
HashWhirlpool();
virtual ~HashWhirlpool();
WhirlpoolHash() = default;
~WhirlpoolHash() = default;
void Append(const UInt8* data, std::size_t len) override;
void Begin() override;
@ -29,7 +27,13 @@ namespace Nz
const char* GetHashName() const override;
private:
HashWhirlpool_state* m_state;
void ProcessBuffer();
std::size_t m_bufferBits; // current number of bits on the buffer */
std::size_t m_bufferPos; // current (possibly incomplete) byte slot on the buffer */
UInt8 m_bitLength[32]; // global number of hashed bits (256-bit counter) */
UInt8 m_buffer[64]; // buffer of data to hash */
UInt64 m_hash[8]; // the hashing state */
};
}

20
src/Nazara/Core/AbstractHash.cpp
View File

@ -46,34 +46,34 @@ namespace Nz
switch (type)
{
case HashType::Fletcher16:
return std::make_unique<HashFletcher16>();
return std::make_unique<Fletcher16Hash>();
case HashType::CRC32:
return std::make_unique<HashCRC32>();
return std::make_unique<CRC32Hash>();
case HashType::CRC64:
return std::make_unique<HashCRC64>();
return std::make_unique<CRC64Hash>();
case HashType::MD5:
return std::make_unique<HashMD5>();
return std::make_unique<MD5Hash>();
case HashType::SHA1:
return std::make_unique<HashSHA1>();
return std::make_unique<SHA1Hash>();
case HashType::SHA224:
return std::make_unique<HashSHA224>();
return std::make_unique<SHA224Hash>();
case HashType::SHA256:
return std::make_unique<HashSHA256>();
return std::make_unique<SHA256Hash>();
case HashType::SHA384:
return std::make_unique<HashSHA384>();
return std::make_unique<SHA384Hash>();
case HashType::SHA512:
return std::make_unique<HashSHA512>();
return std::make_unique<SHA512Hash>();
case HashType::Whirlpool:
return std::make_unique<HashWhirlpool>();
return std::make_unique<WhirlpoolHash>();
}
NazaraInternalError("Hash type not handled (0x" + NumberToString(UnderlyingCast(type), 16) + ')');

6
src/Nazara/Core/File.cpp
View File

@ -424,10 +424,8 @@ namespace Nz
* \remark Produces a NazaraError if file could not be read
*/
NAZARA_CORE_API bool HashAppend(AbstractHash* hash, const File& originalFile)
NAZARA_CORE_API bool HashAppend(AbstractHash& hash, const File& originalFile)
{
NazaraAssert(hash, "Invalid hash");
File file(originalFile.GetPath());
if (!file.Open(OpenMode::ReadOnly))
{
@ -448,7 +446,7 @@ namespace Nz
}
remainingSize -= size;
hash->Append(reinterpret_cast<UInt8*>(&buffer[0]), size);
hash.Append(reinterpret_cast<UInt8*>(&buffer[0]), size);
}
return true;

108
src/Nazara/Core/Hash/CRC32.cpp
View File

@ -8,12 +8,6 @@
namespace Nz
{
struct HashCRC32_state
{
UInt32 crc;
const UInt32* table;
};
namespace
{
UInt32 crc32_reflect(UInt32 ref, unsigned int j)
@ -32,47 +26,45 @@ namespace Nz
}
static const UInt32 crc32_table[256] = {
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
};
}
HashCRC32::HashCRC32(UInt32 polynomial)
CRC32Hash::CRC32Hash(UInt32 polynomial)
{
m_state = new HashCRC32_state;
if (polynomial == 0x04c11db7)
m_state->table = crc32_table; // Table précalculée (Bien plus rapide)
if (polynomial == DefaultPolynomial)
m_table = crc32_table;
else
{
UInt32* table = new UInt32[256];
@ -86,46 +78,44 @@ namespace Nz
table[i] = crc32_reflect(table[i], 32);
}
m_state->table = table;
m_table = table;
}
}
HashCRC32::~HashCRC32()
CRC32Hash::~CRC32Hash()
{
if (m_state->table != crc32_table)
delete[] m_state->table;
delete m_state;
if (m_table != crc32_table)
delete[] m_table;
}
void HashCRC32::Append(const UInt8* data, std::size_t len)
void CRC32Hash::Append(const UInt8* data, std::size_t len)
{
while (len--)
m_state->crc = m_state->table[(m_state->crc ^ *data++) & 0xFF] ^ (m_state->crc >> 8);
m_crc = m_table[(m_crc ^ *data++) & 0xFF] ^ (m_crc >> 8);
}
void HashCRC32::Begin()
void CRC32Hash::Begin()
{
m_state->crc = 0xFFFFFFFF;
m_crc = 0xFFFFFFFF;
}
ByteArray HashCRC32::End()
ByteArray CRC32Hash::End()
{
m_state->crc ^= 0xFFFFFFFF;
m_crc ^= 0xFFFFFFFF;
#ifdef NAZARA_LITTLE_ENDIAN
SwapBytes(&m_state->crc, sizeof(UInt32));
SwapBytes(&m_crc, sizeof(UInt32));
#endif
return ByteArray(reinterpret_cast<UInt8*>(&m_state->crc), 4);
return ByteArray(reinterpret_cast<UInt8*>(&m_crc), 4);
}
std::size_t HashCRC32::GetDigestLength() const
std::size_t CRC32Hash::GetDigestLength() const
{
return 4;
}
const char* HashCRC32::GetHashName() const
const char* CRC32Hash::GetHashName() const
{
return "CRC32";
}

147
src/Nazara/Core/Hash/CRC64.cpp
View File

@ -8,93 +8,88 @@
namespace Nz
{
struct HashCRC64_state
{
UInt64 crc;
};
namespace
{
static const UInt64 crc64_table[256] = {
0x0000000000000000ULL, 0x7ad870c830358979ULL, 0xf5b0e190606b12f2ULL, 0x8f689158505e9b8bULL,
0xc038e5739841b68fULL, 0xbae095bba8743ff6ULL, 0x358804e3f82aa47dULL, 0x4f50742bc81f2d04ULL,
0xab28ecb46814fe75ULL, 0xd1f09c7c5821770cULL, 0x5e980d24087fec87ULL, 0x24407dec384a65feULL,
0x6b1009c7f05548faULL, 0x11c8790fc060c183ULL, 0x9ea0e857903e5a08ULL, 0xe478989fa00bd371ULL,
0x7d08ff3b88be6f81ULL, 0x07d08ff3b88be6f8ULL, 0x88b81eabe8d57d73ULL, 0xf2606e63d8e0f40aULL,
0xbd301a4810ffd90eULL, 0xc7e86a8020ca5077ULL, 0x4880fbd87094cbfcULL, 0x32588b1040a14285ULL,
0xd620138fe0aa91f4ULL, 0xacf86347d09f188dULL, 0x2390f21f80c18306ULL, 0x594882d7b0f40a7fULL,
0x1618f6fc78eb277bULL, 0x6cc0863448deae02ULL, 0xe3a8176c18803589ULL, 0x997067a428b5bcf0ULL,
0xfa11fe77117cdf02ULL, 0x80c98ebf2149567bULL, 0x0fa11fe77117cdf0ULL, 0x75796f2f41224489ULL,
0x3a291b04893d698dULL, 0x40f16bccb908e0f4ULL, 0xcf99fa94e9567b7fULL, 0xb5418a5cd963f206ULL,
0x513912c379682177ULL, 0x2be1620b495da80eULL, 0xa489f35319033385ULL, 0xde51839b2936bafcULL,
0x9101f7b0e12997f8ULL, 0xebd98778d11c1e81ULL, 0x64b116208142850aULL, 0x1e6966e8b1770c73ULL,
0x8719014c99c2b083ULL, 0xfdc17184a9f739faULL, 0x72a9e0dcf9a9a271ULL, 0x08719014c99c2b08ULL,
0x4721e43f0183060cULL, 0x3df994f731b68f75ULL, 0xb29105af61e814feULL, 0xc849756751dd9d87ULL,
0x2c31edf8f1d64ef6ULL, 0x56e99d30c1e3c78fULL, 0xd9810c6891bd5c04ULL, 0xa3597ca0a188d57dULL,
0xec09088b6997f879ULL, 0x96d1784359a27100ULL, 0x19b9e91b09fcea8bULL, 0x636199d339c963f2ULL,
0xdf7adabd7a6e2d6fULL, 0xa5a2aa754a5ba416ULL, 0x2aca3b2d1a053f9dULL, 0x50124be52a30b6e4ULL,
0x1f423fcee22f9be0ULL, 0x659a4f06d21a1299ULL, 0xeaf2de5e82448912ULL, 0x902aae96b271006bULL,
0x74523609127ad31aULL, 0x0e8a46c1224f5a63ULL, 0x81e2d7997211c1e8ULL, 0xfb3aa75142244891ULL,
0xb46ad37a8a3b6595ULL, 0xceb2a3b2ba0eececULL, 0x41da32eaea507767ULL, 0x3b024222da65fe1eULL,
0xa2722586f2d042eeULL, 0xd8aa554ec2e5cb97ULL, 0x57c2c41692bb501cULL, 0x2d1ab4dea28ed965ULL,
0x624ac0f56a91f461ULL, 0x1892b03d5aa47d18ULL, 0x97fa21650afae693ULL, 0xed2251ad3acf6feaULL,
0x095ac9329ac4bc9bULL, 0x7382b9faaaf135e2ULL, 0xfcea28a2faafae69ULL, 0x8632586aca9a2710ULL,
0xc9622c4102850a14ULL, 0xb3ba5c8932b0836dULL, 0x3cd2cdd162ee18e6ULL, 0x460abd1952db919fULL,
0x256b24ca6b12f26dULL, 0x5fb354025b277b14ULL, 0xd0dbc55a0b79e09fULL, 0xaa03b5923b4c69e6ULL,
0xe553c1b9f35344e2ULL, 0x9f8bb171c366cd9bULL, 0x10e3202993385610ULL, 0x6a3b50e1a30ddf69ULL,
0x8e43c87e03060c18ULL, 0xf49bb8b633338561ULL, 0x7bf329ee636d1eeaULL, 0x012b592653589793ULL,
0x4e7b2d0d9b47ba97ULL, 0x34a35dc5ab7233eeULL, 0xbbcbcc9dfb2ca865ULL, 0xc113bc55cb19211cULL,
0x5863dbf1e3ac9decULL, 0x22bbab39d3991495ULL, 0xadd33a6183c78f1eULL, 0xd70b4aa9b3f20667ULL,
0x985b3e827bed2b63ULL, 0xe2834e4a4bd8a21aULL, 0x6debdf121b863991ULL, 0x1733afda2bb3b0e8ULL,
0xf34b37458bb86399ULL, 0x8993478dbb8deae0ULL, 0x06fbd6d5ebd3716bULL, 0x7c23a61ddbe6f812ULL,
0x3373d23613f9d516ULL, 0x49aba2fe23cc5c6fULL, 0xc6c333a67392c7e4ULL, 0xbc1b436e43a74e9dULL,
0x95ac9329ac4bc9b5ULL, 0xef74e3e19c7e40ccULL, 0x601c72b9cc20db47ULL, 0x1ac40271fc15523eULL,
0x5594765a340a7f3aULL, 0x2f4c0692043ff643ULL, 0xa02497ca54616dc8ULL, 0xdafce7026454e4b1ULL,
0x3e847f9dc45f37c0ULL, 0x445c0f55f46abeb9ULL, 0xcb349e0da4342532ULL, 0xb1eceec59401ac4bULL,
0xfebc9aee5c1e814fULL, 0x8464ea266c2b0836ULL, 0x0b0c7b7e3c7593bdULL, 0x71d40bb60c401ac4ULL,
0xe8a46c1224f5a634ULL, 0x927c1cda14c02f4dULL, 0x1d148d82449eb4c6ULL, 0x67ccfd4a74ab3dbfULL,
0x289c8961bcb410bbULL, 0x5244f9a98c8199c2ULL, 0xdd2c68f1dcdf0249ULL, 0xa7f41839ecea8b30ULL,
0x438c80a64ce15841ULL, 0x3954f06e7cd4d138ULL, 0xb63c61362c8a4ab3ULL, 0xcce411fe1cbfc3caULL,
0x83b465d5d4a0eeceULL, 0xf96c151de49567b7ULL, 0x76048445b4cbfc3cULL, 0x0cdcf48d84fe7545ULL,
0x6fbd6d5ebd3716b7ULL, 0x15651d968d029fceULL, 0x9a0d8ccedd5c0445ULL, 0xe0d5fc06ed698d3cULL,
0xaf85882d2576a038ULL, 0xd55df8e515432941ULL, 0x5a3569bd451db2caULL, 0x20ed197575283bb3ULL,
0xc49581ead523e8c2ULL, 0xbe4df122e51661bbULL, 0x3125607ab548fa30ULL, 0x4bfd10b2857d7349ULL,
0x04ad64994d625e4dULL, 0x7e7514517d57d734ULL, 0xf11d85092d094cbfULL, 0x8bc5f5c11d3cc5c6ULL,
0x12b5926535897936ULL, 0x686de2ad05bcf04fULL, 0xe70573f555e26bc4ULL, 0x9ddd033d65d7e2bdULL,
0xd28d7716adc8cfb9ULL, 0xa85507de9dfd46c0ULL, 0x273d9686cda3dd4bULL, 0x5de5e64efd965432ULL,
0xb99d7ed15d9d8743ULL, 0xc3450e196da80e3aULL, 0x4c2d9f413df695b1ULL, 0x36f5ef890dc31cc8ULL,
0x79a59ba2c5dc31ccULL, 0x037deb6af5e9b8b5ULL, 0x8c157a32a5b7233eULL, 0xf6cd0afa9582aa47ULL,
0x4ad64994d625e4daULL, 0x300e395ce6106da3ULL, 0xbf66a804b64ef628ULL, 0xc5bed8cc867b7f51ULL,
0x8aeeace74e645255ULL, 0xf036dc2f7e51db2cULL, 0x7f5e4d772e0f40a7ULL, 0x05863dbf1e3ac9deULL,
0xe1fea520be311aafULL, 0x9b26d5e88e0493d6ULL, 0x144e44b0de5a085dULL, 0x6e963478ee6f8124ULL,
0x21c640532670ac20ULL, 0x5b1e309b16452559ULL, 0xd476a1c3461bbed2ULL, 0xaeaed10b762e37abULL,
0x37deb6af5e9b8b5bULL, 0x4d06c6676eae0222ULL, 0xc26e573f3ef099a9ULL, 0xb8b627f70ec510d0ULL,
0xf7e653dcc6da3dd4ULL, 0x8d3e2314f6efb4adULL, 0x0256b24ca6b12f26ULL, 0x788ec2849684a65fULL,
0x9cf65a1b368f752eULL, 0xe62e2ad306bafc57ULL, 0x6946bb8b56e467dcULL, 0x139ecb4366d1eea5ULL,
0x5ccebf68aecec3a1ULL, 0x2616cfa09efb4ad8ULL, 0xa97e5ef8cea5d153ULL, 0xd3a62e30fe90582aULL,
0xb0c7b7e3c7593bd8ULL, 0xca1fc72bf76cb2a1ULL, 0x45775673a732292aULL, 0x3faf26bb9707a053ULL,
0x70ff52905f188d57ULL, 0x0a2722586f2d042eULL, 0x854fb3003f739fa5ULL, 0xff97c3c80f4616dcULL,
0x1bef5b57af4dc5adULL, 0x61372b9f9f784cd4ULL, 0xee5fbac7cf26d75fULL, 0x9487ca0fff135e26ULL,
0xdbd7be24370c7322ULL, 0xa10fceec0739fa5bULL, 0x2e675fb4576761d0ULL, 0x54bf2f7c6752e8a9ULL,
0xcdcf48d84fe75459ULL, 0xb71738107fd2dd20ULL, 0x387fa9482f8c46abULL, 0x42a7d9801fb9cfd2ULL,
0x0df7adabd7a6e2d6ULL, 0x772fdd63e7936bafULL, 0xf8474c3bb7cdf024ULL, 0x829f3cf387f8795dULL,
0x66e7a46c27f3aa2cULL, 0x1c3fd4a417c62355ULL, 0x935745fc4798b8deULL, 0xe98f353477ad31a7ULL,
0xa6df411fbfb21ca3ULL, 0xdc0731d78f8795daULL, 0x536fa08fdfd90e51ULL, 0x29b7d047efec8728ULL
static const UInt64 crc64_table[] = {
0x0000000000000000ULL, 0x42F0E1EBA9EA3693ULL, 0x85E1C3D753D46D26ULL, 0xC711223CFA3E5BB5ULL,
0x493366450E42ECDFULL, 0x0BC387AEA7A8DA4CULL, 0xCCD2A5925D9681F9ULL, 0x8E224479F47CB76AULL,
0x9266CC8A1C85D9BEULL, 0xD0962D61B56FEF2DULL, 0x17870F5D4F51B498ULL, 0x5577EEB6E6BB820BULL,
0xDB55AACF12C73561ULL, 0x99A54B24BB2D03F2ULL, 0x5EB4691841135847ULL, 0x1C4488F3E8F96ED4ULL,
0x663D78FF90E185EFULL, 0x24CD9914390BB37CULL, 0xE3DCBB28C335E8C9ULL, 0xA12C5AC36ADFDE5AULL,
0x2F0E1EBA9EA36930ULL, 0x6DFEFF5137495FA3ULL, 0xAAEFDD6DCD770416ULL, 0xE81F3C86649D3285ULL,
0xF45BB4758C645C51ULL, 0xB6AB559E258E6AC2ULL, 0x71BA77A2DFB03177ULL, 0x334A9649765A07E4ULL,
0xBD68D2308226B08EULL, 0xFF9833DB2BCC861DULL, 0x388911E7D1F2DDA8ULL, 0x7A79F00C7818EB3BULL,
0xCC7AF1FF21C30BDEULL, 0x8E8A101488293D4DULL, 0x499B3228721766F8ULL, 0x0B6BD3C3DBFD506BULL,
0x854997BA2F81E701ULL, 0xC7B97651866BD192ULL, 0x00A8546D7C558A27ULL, 0x4258B586D5BFBCB4ULL,
0x5E1C3D753D46D260ULL, 0x1CECDC9E94ACE4F3ULL, 0xDBFDFEA26E92BF46ULL, 0x990D1F49C77889D5ULL,
0x172F5B3033043EBFULL, 0x55DFBADB9AEE082CULL, 0x92CE98E760D05399ULL, 0xD03E790CC93A650AULL,
0xAA478900B1228E31ULL, 0xE8B768EB18C8B8A2ULL, 0x2FA64AD7E2F6E317ULL, 0x6D56AB3C4B1CD584ULL,
0xE374EF45BF6062EEULL, 0xA1840EAE168A547DULL, 0x66952C92ECB40FC8ULL, 0x2465CD79455E395BULL,
0x3821458AADA7578FULL, 0x7AD1A461044D611CULL, 0xBDC0865DFE733AA9ULL, 0xFF3067B657990C3AULL,
0x711223CFA3E5BB50ULL, 0x33E2C2240A0F8DC3ULL, 0xF4F3E018F031D676ULL, 0xB60301F359DBE0E5ULL,
0xDA050215EA6C212FULL, 0x98F5E3FE438617BCULL, 0x5FE4C1C2B9B84C09ULL, 0x1D14202910527A9AULL,
0x93366450E42ECDF0ULL, 0xD1C685BB4DC4FB63ULL, 0x16D7A787B7FAA0D6ULL, 0x5427466C1E109645ULL,
0x4863CE9FF6E9F891ULL, 0x0A932F745F03CE02ULL, 0xCD820D48A53D95B7ULL, 0x8F72ECA30CD7A324ULL,
0x0150A8DAF8AB144EULL, 0x43A04931514122DDULL, 0x84B16B0DAB7F7968ULL, 0xC6418AE602954FFBULL,
0xBC387AEA7A8DA4C0ULL, 0xFEC89B01D3679253ULL, 0x39D9B93D2959C9E6ULL, 0x7B2958D680B3FF75ULL,
0xF50B1CAF74CF481FULL, 0xB7FBFD44DD257E8CULL, 0x70EADF78271B2539ULL, 0x321A3E938EF113AAULL,
0x2E5EB66066087D7EULL, 0x6CAE578BCFE24BEDULL, 0xABBF75B735DC1058ULL, 0xE94F945C9C3626CBULL,
0x676DD025684A91A1ULL, 0x259D31CEC1A0A732ULL, 0xE28C13F23B9EFC87ULL, 0xA07CF2199274CA14ULL,
0x167FF3EACBAF2AF1ULL, 0x548F120162451C62ULL, 0x939E303D987B47D7ULL, 0xD16ED1D631917144ULL,
0x5F4C95AFC5EDC62EULL, 0x1DBC74446C07F0BDULL, 0xDAAD56789639AB08ULL, 0x985DB7933FD39D9BULL,
0x84193F60D72AF34FULL, 0xC6E9DE8B7EC0C5DCULL, 0x01F8FCB784FE9E69ULL, 0x43081D5C2D14A8FAULL,
0xCD2A5925D9681F90ULL, 0x8FDAB8CE70822903ULL, 0x48CB9AF28ABC72B6ULL, 0x0A3B7B1923564425ULL,
0x70428B155B4EAF1EULL, 0x32B26AFEF2A4998DULL, 0xF5A348C2089AC238ULL, 0xB753A929A170F4ABULL,
0x3971ED50550C43C1ULL, 0x7B810CBBFCE67552ULL, 0xBC902E8706D82EE7ULL, 0xFE60CF6CAF321874ULL,
0xE224479F47CB76A0ULL, 0xA0D4A674EE214033ULL, 0x67C58448141F1B86ULL, 0x253565A3BDF52D15ULL,
0xAB1721DA49899A7FULL, 0xE9E7C031E063ACECULL, 0x2EF6E20D1A5DF759ULL, 0x6C0603E6B3B7C1CAULL,
0xF6FAE5C07D3274CDULL, 0xB40A042BD4D8425EULL, 0x731B26172EE619EBULL, 0x31EBC7FC870C2F78ULL,
0xBFC9838573709812ULL, 0xFD39626EDA9AAE81ULL, 0x3A28405220A4F534ULL, 0x78D8A1B9894EC3A7ULL,
0x649C294A61B7AD73ULL, 0x266CC8A1C85D9BE0ULL, 0xE17DEA9D3263C055ULL, 0xA38D0B769B89F6C6ULL,
0x2DAF4F0F6FF541ACULL, 0x6F5FAEE4C61F773FULL, 0xA84E8CD83C212C8AULL, 0xEABE6D3395CB1A19ULL,
0x90C79D3FEDD3F122ULL, 0xD2377CD44439C7B1ULL, 0x15265EE8BE079C04ULL, 0x57D6BF0317EDAA97ULL,
0xD9F4FB7AE3911DFDULL, 0x9B041A914A7B2B6EULL, 0x5C1538ADB04570DBULL, 0x1EE5D94619AF4648ULL,
0x02A151B5F156289CULL, 0x4051B05E58BC1E0FULL, 0x87409262A28245BAULL, 0xC5B073890B687329ULL,
0x4B9237F0FF14C443ULL, 0x0962D61B56FEF2D0ULL, 0xCE73F427ACC0A965ULL, 0x8C8315CC052A9FF6ULL,
0x3A80143F5CF17F13ULL, 0x7870F5D4F51B4980ULL, 0xBF61D7E80F251235ULL, 0xFD913603A6CF24A6ULL,
0x73B3727A52B393CCULL, 0x31439391FB59A55FULL, 0xF652B1AD0167FEEAULL, 0xB4A25046A88DC879ULL,
0xA8E6D8B54074A6ADULL, 0xEA16395EE99E903EULL, 0x2D071B6213A0CB8BULL, 0x6FF7FA89BA4AFD18ULL,
0xE1D5BEF04E364A72ULL, 0xA3255F1BE7DC7CE1ULL, 0x64347D271DE22754ULL, 0x26C49CCCB40811C7ULL,
0x5CBD6CC0CC10FAFCULL, 0x1E4D8D2B65FACC6FULL, 0xD95CAF179FC497DAULL, 0x9BAC4EFC362EA149ULL,
0x158E0A85C2521623ULL, 0x577EEB6E6BB820B0ULL, 0x906FC95291867B05ULL, 0xD29F28B9386C4D96ULL,
0xCEDBA04AD0952342ULL, 0x8C2B41A1797F15D1ULL, 0x4B3A639D83414E64ULL, 0x09CA82762AAB78F7ULL,
0x87E8C60FDED7CF9DULL, 0xC51827E4773DF90EULL, 0x020905D88D03A2BBULL, 0x40F9E43324E99428ULL,
0x2CFFE7D5975E55E2ULL, 0x6E0F063E3EB46371ULL, 0xA91E2402C48A38C4ULL, 0xEBEEC5E96D600E57ULL,
0x65CC8190991CB93DULL, 0x273C607B30F68FAEULL, 0xE02D4247CAC8D41BULL, 0xA2DDA3AC6322E288ULL,
0xBE992B5F8BDB8C5CULL, 0xFC69CAB42231BACFULL, 0x3B78E888D80FE17AULL, 0x7988096371E5D7E9ULL,
0xF7AA4D1A85996083ULL, 0xB55AACF12C735610ULL, 0x724B8ECDD64D0DA5ULL, 0x30BB6F267FA73B36ULL,
0x4AC29F2A07BFD00DULL, 0x08327EC1AE55E69EULL, 0xCF235CFD546BBD2BULL, 0x8DD3BD16FD818BB8ULL,
0x03F1F96F09FD3CD2ULL, 0x41011884A0170A41ULL, 0x86103AB85A2951F4ULL, 0xC4E0DB53F3C36767ULL,
0xD8A453A01B3A09B3ULL, 0x9A54B24BB2D03F20ULL, 0x5D45907748EE6495ULL, 0x1FB5719CE1045206ULL,
0x919735E51578E56CULL, 0xD367D40EBC92D3FFULL, 0x1476F63246AC884AULL, 0x568617D9EF46BED9ULL,
0xE085162AB69D5E3CULL, 0xA275F7C11F7768AFULL, 0x6564D5FDE549331AULL, 0x279434164CA30589ULL,
0xA9B6706FB8DFB2E3ULL, 0xEB46918411358470ULL, 0x2C57B3B8EB0BDFC5ULL, 0x6EA7525342E1E956ULL,
0x72E3DAA0AA188782ULL, 0x30133B4B03F2B111ULL, 0xF7021977F9CCEAA4ULL, 0xB5F2F89C5026DC37ULL,
0x3BD0BCE5A45A6B5DULL, 0x79205D0E0DB05DCEULL, 0xBE317F32F78E067BULL, 0xFCC19ED95E6430E8ULL,
0x86B86ED5267CDBD3ULL, 0xC4488F3E8F96ED40ULL, 0x0359AD0275A8B6F5ULL, 0x41A94CE9DC428066ULL,
0xCF8B0890283E370CULL, 0x8D7BE97B81D4019FULL, 0x4A6ACB477BEA5A2AULL, 0x089A2AACD2006CB9ULL,
0x14DEA25F3AF9026DULL, 0x562E43B4931334FEULL, 0x913F6188692D6F4BULL, 0xD3CF8063C0C759D8ULL,
0x5DEDC41A34BBEEB2ULL, 0x1F1D25F19D51D821ULL, 0xD80C07CD676F8394ULL, 0x9AFCE626CE85B507ULL
};
}
void HashCRC64::Append(const UInt8* data, std::size_t len)
void CRC64Hash::Append(const UInt8* data, std::size_t len)
{
while (len--)
m_crc = crc64_table[(m_crc ^ *data++) & 0xFF] ^ (m_crc >> 8);
m_crc = (m_crc << 8) ^ crc64_table[((m_crc >> 56) ^ *data++) & 0xFF];
}
void HashCRC64::Begin()
void CRC64Hash::Begin()
{
m_crc = 0;
}
ByteArray HashCRC64::End()
ByteArray CRC64Hash::End()
{
#ifdef NAZARA_LITTLE_ENDIAN
SwapBytes(&m_crc, sizeof(UInt64));
@ -103,12 +98,12 @@ namespace Nz
return ByteArray(reinterpret_cast<UInt8*>(&m_crc), 8);
}
std::size_t HashCRC64::GetDigestLength() const
std::size_t CRC64Hash::GetDigestLength() const
{
return 8;
}
const char* HashCRC64::GetHashName() const
const char* CRC64Hash::GetHashName() const
{
return "CRC64";
}

53
src/Nazara/Core/Hash/Fletcher16.cpp
View File

@ -8,66 +8,51 @@
namespace Nz
{
struct HashFletcher16_state
void Fletcher16Hash::Append(const UInt8* data, std::size_t len)
{
UInt16 sum1;
UInt16 sum2;
};
HashFletcher16::HashFletcher16()
{
m_state = new HashFletcher16_state;
}
HashFletcher16::~HashFletcher16()
{
delete m_state;
}
void HashFletcher16::Append(const UInt8* data, std::size_t len)
{
while (len)
while (len > 0)
{
std::size_t tlen = std::min<std::size_t>(len, 21U);
std::size_t tlen = std::min<std::size_t>(len, 20U);
len -= tlen;
do
{
m_state->sum1 += *data++;
m_state->sum2 += m_state->sum1;
m_sum1 += *data++;
m_sum2 += m_sum1;
}
while (--tlen);
m_state->sum1 = (m_state->sum1 & 0xff) + (m_state->sum1 >> 8);
m_state->sum2 = (m_state->sum2 & 0xff) + (m_state->sum2 >> 8);
m_sum1 = (m_sum1 & 0xFF) + (m_sum1 >> 8);
m_sum2 = (m_sum2 & 0xFF) + (m_sum2 >> 8);
}
}
void HashFletcher16::Begin()
void Fletcher16Hash::Begin()
{
m_state->sum1 = 0xff;
m_state->sum2 = 0xff;
m_sum1 = 0xFF;
m_sum2 = 0xFF;
}
ByteArray HashFletcher16::End()
ByteArray Fletcher16Hash::End()
{
m_state->sum1 = (m_state->sum1 & 0xff) + (m_state->sum1 >> 8);
m_state->sum2 = (m_state->sum2 & 0xff) + (m_state->sum2 >> 8);
m_sum1 = (m_sum1 & 0xFF) + (m_sum1 >> 8);
m_sum2 = (m_sum2 & 0xFF) + (m_sum2 >> 8);
UInt32 fletcher = (m_state->sum2 << 8) | m_state->sum1;
UInt16 fletcher = (m_sum2 << 8) | m_sum1;
#ifdef NAZARA_BIG_ENDIAN
SwapBytes(&fletcher, sizeof(UInt32));
#ifdef NAZARA_LITTLE_ENDIAN
fletcher = SwapBytes(fletcher);
#endif
return ByteArray(reinterpret_cast<UInt8*>(&fletcher), 2);
}
std::size_t HashFletcher16::GetDigestLength() const
std::size_t Fletcher16Hash::GetDigestLength() const
{
return 2;
}
const char* HashFletcher16::GetHashName() const
const char* Fletcher16Hash::GetHashName() const
{
return "Fletcher16";
}

380
src/Nazara/Core/Hash/MD5.cpp
View File

@ -99,233 +99,55 @@
namespace Nz
{
struct HashMD5_state
{
std::size_t count[2]; /* message length in bits, lsw first */
UInt32 abcd[4]; /* digest buffer */
UInt8 buf[64]; /* accumulate block */
};
namespace
{
void md5_process(HashMD5_state* state, const UInt8* data)
{
UInt32 a = state->abcd[0];
UInt32 b = state->abcd[1];
UInt32 c = state->abcd[2];
UInt32 d = state->abcd[3];
UInt32 t;
#ifdef NAZARA_BIG_ENDIAN
/* Define storage only for big-endian CPUs. */
UInt32 X[16];
/*
* On big-endian machines, we must arrange the bytes in the
* right order.
*/
const UInt8* xp = data;
int i;
for (i = 0; i < 16; ++i, xp += 4)
X[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
#else
/* Define storage for little-endian or both types of CPUs. */
UInt32 xbuf[16];
const UInt32* X;
/*
* On little-endian machines, we can process properly aligned
* data without copying it.
*/
if (!((data - static_cast<const UInt8*>(nullptr)) & 3))
{
/* data are properly aligned */
X = reinterpret_cast<const UInt32*>(data);
}
else
{
/* not aligned */
std::memcpy(xbuf, data, 64);
X = xbuf;
}
#endif
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
/* Round 1. */
/* Let [abcd k s i] denote the operation
a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
#define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
#define SET(a, b, c, d, k, s, Ti)\
t = a + F(b,c,d) + X[k] + Ti;\
a = ROTATE_LEFT(t, s) + b
/* Do the following 16 operations. */
SET(a, b, c, d, 0, 7, T1);
SET(d, a, b, c, 1, 12, T2);
SET(c, d, a, b, 2, 17, T3);
SET(b, c, d, a, 3, 22, T4);
SET(a, b, c, d, 4, 7, T5);
SET(d, a, b, c, 5, 12, T6);
SET(c, d, a, b, 6, 17, T7);
SET(b, c, d, a, 7, 22, T8);
SET(a, b, c, d, 8, 7, T9);
SET(d, a, b, c, 9, 12, T10);
SET(c, d, a, b, 10, 17, T11);
SET(b, c, d, a, 11, 22, T12);
SET(a, b, c, d, 12, 7, T13);
SET(d, a, b, c, 13, 12, T14);
SET(c, d, a, b, 14, 17, T15);
SET(b, c, d, a, 15, 22, T16);
#undef SET
/* Round 2. */
/* Let [abcd k s i] denote the operation
a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
#define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
#define SET(a, b, c, d, k, s, Ti)\
t = a + G(b,c,d) + X[k] + Ti;\
a = ROTATE_LEFT(t, s) + b
/* Do the following 16 operations. */
SET(a, b, c, d, 1, 5, T17);
SET(d, a, b, c, 6, 9, T18);
SET(c, d, a, b, 11, 14, T19);
SET(b, c, d, a, 0, 20, T20);
SET(a, b, c, d, 5, 5, T21);
SET(d, a, b, c, 10, 9, T22);
SET(c, d, a, b, 15, 14, T23);
SET(b, c, d, a, 4, 20, T24);
SET(a, b, c, d, 9, 5, T25);
SET(d, a, b, c, 14, 9, T26);
SET(c, d, a, b, 3, 14, T27);
SET(b, c, d, a, 8, 20, T28);
SET(a, b, c, d, 13, 5, T29);
SET(d, a, b, c, 2, 9, T30);
SET(c, d, a, b, 7, 14, T31);
SET(b, c, d, a, 12, 20, T32);
#undef SET
/* Round 3. */
/* Let [abcd k s t] denote the operation
a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define SET(a, b, c, d, k, s, Ti)\
t = a + H(b,c,d) + X[k] + Ti;\
a = ROTATE_LEFT(t, s) + b
/* Do the following 16 operations. */
SET(a, b, c, d, 5, 4, T33);
SET(d, a, b, c, 8, 11, T34);
SET(c, d, a, b, 11, 16, T35);
SET(b, c, d, a, 14, 23, T36);
SET(a, b, c, d, 1, 4, T37);
SET(d, a, b, c, 4, 11, T38);
SET(c, d, a, b, 7, 16, T39);
SET(b, c, d, a, 10, 23, T40);
SET(a, b, c, d, 13, 4, T41);
SET(d, a, b, c, 0, 11, T42);
SET(c, d, a, b, 3, 16, T43);
SET(b, c, d, a, 6, 23, T44);
SET(a, b, c, d, 9, 4, T45);
SET(d, a, b, c, 12, 11, T46);
SET(c, d, a, b, 15, 16, T47);
SET(b, c, d, a, 2, 23, T48);
#undef SET
/* Round 4. */
/* Let [abcd k s t] denote the operation
a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
#define I(x, y, z) ((y) ^ ((x) | ~(z)))
#define SET(a, b, c, d, k, s, Ti)\
t = a + I(b,c,d) + X[k] + Ti;\
a = ROTATE_LEFT(t, s) + b
/* Do the following 16 operations. */
SET(a, b, c, d, 0, 6, T49);
SET(d, a, b, c, 7, 10, T50);
SET(c, d, a, b, 14, 15, T51);
SET(b, c, d, a, 5, 21, T52);
SET(a, b, c, d, 12, 6, T53);
SET(d, a, b, c, 3, 10, T54);
SET(c, d, a, b, 10, 15, T55);
SET(b, c, d, a, 1, 21, T56);
SET(a, b, c, d, 8, 6, T57);
SET(d, a, b, c, 15, 10, T58);
SET(c, d, a, b, 6, 15, T59);
SET(b, c, d, a, 13, 21, T60);
SET(a, b, c, d, 4, 6, T61);
SET(d, a, b, c, 11, 10, T62);
SET(c, d, a, b, 2, 15, T63);
SET(b, c, d, a, 9, 21, T64);
#undef SET
/* Then perform the following additions. (That is increment each
of the four registers by the value it had before this block
was started.) */
state->abcd[0] += a;
state->abcd[1] += b;
state->abcd[2] += c;
state->abcd[3] += d;
}
}
HashMD5::HashMD5()
{
m_state = new HashMD5_state;
}
HashMD5::~HashMD5()
{
delete m_state;
}
void HashMD5::Append(const UInt8* data, std::size_t len)
void MD5Hash::Append(const UInt8* data, std::size_t len)
{
const UInt8 *p = data;
std::size_t left = len;
int offset = (m_state->count[0] >> 3) & 63;
int offset = (m_count[0] >> 3) & 63;
std::size_t nbits = len << 3;
if (len <= 0)
return;
/* Update the message length. */
m_state->count[1] += len >> 29;
m_state->count[0] += nbits;
if (m_state->count[0] < nbits)
m_state->count[1]++;
m_count[1] += len >> 29;
m_count[0] += nbits;
if (m_count[0] < nbits)
m_count[1]++;
/* Process an initial partial block. */
if (offset)
{
std::size_t copy = (offset + len > 64 ? 64 - offset : len);
std::memcpy(m_state->buf + offset, p, copy);
std::memcpy(m_buf + offset, p, copy);
if (offset + copy < 64)
return;
p += copy;
left -= copy;
md5_process(m_state, m_state->buf);
md5_process(m_buf);
}
/* Process full blocks. */
for (; left >= 64; p += 64, left -= 64)
md5_process(m_state, p);
md5_process(p);
/* Process a final partial block. */
if (left)
std::memcpy(m_state->buf, p, left);
std::memcpy(m_buf, p, left);
}
void HashMD5::Begin()
void MD5Hash::Begin()
{
m_state->count[0] = m_state->count[1] = 0;
m_state->abcd[0] = 0x67452301;
m_state->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476;
m_state->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301;
m_state->abcd[3] = 0x10325476;
m_count[0] = m_count[1] = 0;
m_abcd[0] = 0x67452301;
m_abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476;
m_abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301;
m_abcd[3] = 0x10325476;
}
ByteArray HashMD5::End()
ByteArray MD5Hash::End()
{
static const unsigned char pad[64] = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@ -339,26 +161,184 @@ namespace Nz
/* Save the length before padding. */
for (i = 0; i < 8; ++i)
data[i] = static_cast<UInt8>(m_state->count[i >> 2] >> ((i & 3) << 3));
data[i] = static_cast<UInt8>(m_count[i >> 2] >> ((i & 3) << 3));
/* Pad to 56 bytes mod 64. */
Append(pad, ((55 - (m_state->count[0] >> 3)) & 63) + 1);
Append(pad, ((55 - (m_count[0] >> 3)) & 63) + 1);
/* Append the length. */
Append(data, 8);
UInt8 digest[16];
for (i = 0; i < 16; ++i)
digest[i] = static_cast<UInt8>(m_state->abcd[i >> 2] >> ((i & 3) << 3));
digest[i] = static_cast<UInt8>(m_abcd[i >> 2] >> ((i & 3) << 3));
return ByteArray(&digest[0], 16);
}
std::size_t HashMD5::GetDigestLength() const
std::size_t MD5Hash::GetDigestLength() const
{
return 16;
}
const char* HashMD5::GetHashName() const
const char* MD5Hash::GetHashName() const
{
return "MD5";
}
void MD5Hash::md5_process(const UInt8* data)
{
UInt32 a = m_abcd[0];
UInt32 b = m_abcd[1];
UInt32 c = m_abcd[2];
UInt32 d = m_abcd[3];
UInt32 t;
#ifdef NAZARA_BIG_ENDIAN
/* Define storage only for big-endian CPUs. */
UInt32 X[16];
/*
* On big-endian machines, we must arrange the bytes in the
* right order.
*/
const UInt8* xp = data;
int i;
for (i = 0; i < 16; ++i, xp += 4)
X[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
#else
/* Define storage for little-endian or both types of CPUs. */
UInt32 xbuf[16];
const UInt32* X;
/*
* On little-endian machines, we can process properly aligned
* data without copying it.
*/
if (!((data - static_cast<const UInt8*>(nullptr)) & 3))
{
/* data are properly aligned */
X = reinterpret_cast<const UInt32*>(data);
}
else
{
/* not aligned */
std::memcpy(xbuf, data, 64);
X = xbuf;
}
#endif
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
/* Round 1. */
/* Let [abcd k s i] denote the operation
a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
#define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
#define SET(a, b, c, d, k, s, Ti)\
t = a + F(b,c,d) + X[k] + Ti;\
a = ROTATE_LEFT(t, s) + b
/* Do the following 16 operations. */
SET(a, b, c, d, 0, 7, T1);
SET(d, a, b, c, 1, 12, T2);
SET(c, d, a, b, 2, 17, T3);
SET(b, c, d, a, 3, 22, T4);
SET(a, b, c, d, 4, 7, T5);
SET(d, a, b, c, 5, 12, T6);
SET(c, d, a, b, 6, 17, T7);
SET(b, c, d, a, 7, 22, T8);
SET(a, b, c, d, 8, 7, T9);
SET(d, a, b, c, 9, 12, T10);
SET(c, d, a, b, 10, 17, T11);
SET(b, c, d, a, 11, 22, T12);
SET(a, b, c, d, 12, 7, T13);
SET(d, a, b, c, 13, 12, T14);
SET(c, d, a, b, 14, 17, T15);
SET(b, c, d, a, 15, 22, T16);
#undef SET
/* Round 2. */
/* Let [abcd k s i] denote the operation
a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
#define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
#define SET(a, b, c, d, k, s, Ti)\
t = a + G(b,c,d) + X[k] + Ti;\
a = ROTATE_LEFT(t, s) + b
/* Do the following 16 operations. */
SET(a, b, c, d, 1, 5, T17);
SET(d, a, b, c, 6, 9, T18);
SET(c, d, a, b, 11, 14, T19);
SET(b, c, d, a, 0, 20, T20);
SET(a, b, c, d, 5, 5, T21);
SET(d, a, b, c, 10, 9, T22);
SET(c, d, a, b, 15, 14, T23);
SET(b, c, d, a, 4, 20, T24);
SET(a, b, c, d, 9, 5, T25);
SET(d, a, b, c, 14, 9, T26);
SET(c, d, a, b, 3, 14, T27);
SET(b, c, d, a, 8, 20, T28);
SET(a, b, c, d, 13, 5, T29);
SET(d, a, b, c, 2, 9, T30);
SET(c, d, a, b, 7, 14, T31);
SET(b, c, d, a, 12, 20, T32);
#undef SET
/* Round 3. */
/* Let [abcd k s t] denote the operation
a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define SET(a, b, c, d, k, s, Ti)\
t = a + H(b,c,d) + X[k] + Ti;\
a = ROTATE_LEFT(t, s) + b
/* Do the following 16 operations. */
SET(a, b, c, d, 5, 4, T33);
SET(d, a, b, c, 8, 11, T34);
SET(c, d, a, b, 11, 16, T35);
SET(b, c, d, a, 14, 23, T36);
SET(a, b, c, d, 1, 4, T37);
SET(d, a, b, c, 4, 11, T38);
SET(c, d, a, b, 7, 16, T39);
SET(b, c, d, a, 10, 23, T40);
SET(a, b, c, d, 13, 4, T41);
SET(d, a, b, c, 0, 11, T42);
SET(c, d, a, b, 3, 16, T43);
SET(b, c, d, a, 6, 23, T44);
SET(a, b, c, d, 9, 4, T45);
SET(d, a, b, c, 12, 11, T46);
SET(c, d, a, b, 15, 16, T47);
SET(b, c, d, a, 2, 23, T48);
#undef SET
/* Round 4. */
/* Let [abcd k s t] denote the operation
a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
#define I(x, y, z) ((y) ^ ((x) | ~(z)))
#define SET(a, b, c, d, k, s, Ti)\
t = a + I(b,c,d) + X[k] + Ti;\
a = ROTATE_LEFT(t, s) + b
/* Do the following 16 operations. */
SET(a, b, c, d, 0, 6, T49);
SET(d, a, b, c, 7, 10, T50);
SET(c, d, a, b, 14, 15, T51);
SET(b, c, d, a, 5, 21, T52);
SET(a, b, c, d, 12, 6, T53);
SET(d, a, b, c, 3, 10, T54);
SET(c, d, a, b, 10, 15, T55);
SET(b, c, d, a, 1, 21, T56);
SET(a, b, c, d, 8, 6, T57);
SET(d, a, b, c, 15, 10, T58);
SET(c, d, a, b, 6, 15, T59);
SET(b, c, d, a, 13, 21, T60);
SET(a, b, c, d, 4, 6, T61);
SET(d, a, b, c, 11, 10, T62);
SET(c, d, a, b, 2, 15, T63);
SET(b, c, d, a, 9, 21, T64);
#undef SET
/* Then perform the following additions. (That is increment each
of the four registers by the value it had before this block
was started.) */
m_abcd[0] += a;
m_abcd[1] += b;
m_abcd[2] += c;
m_abcd[3] += d;
}
}

14
src/Nazara/Core/Hash/SHA1.cpp
View File

@ -8,27 +8,27 @@
namespace Nz
{
HashSHA1::HashSHA1()
SHA1Hash::SHA1Hash()
{
m_state = new SHA_CTX;
}
HashSHA1::~HashSHA1()
SHA1Hash::~SHA1Hash()
{
delete m_state;
}
void HashSHA1::Append(const UInt8* data, std::size_t len)
void SHA1Hash::Append(const UInt8* data, std::size_t len)
{
SHA1_Update(m_state, data, len);
}
void HashSHA1::Begin()
void SHA1Hash::Begin()
{
SHA1_Init(m_state);
}
ByteArray HashSHA1::End()
ByteArray SHA1Hash::End()
{
UInt8 digest[SHA1_DIGEST_LENGTH];
@ -37,12 +37,12 @@ namespace Nz
return ByteArray(digest, SHA1_DIGEST_LENGTH);
}
std::size_t HashSHA1::GetDigestLength() const
std::size_t SHA1Hash::GetDigestLength() const
{
return SHA1_DIGEST_LENGTH;
}
const char* HashSHA1::GetHashName() const
const char* SHA1Hash::GetHashName() const
{
return "SHA1";
}

14
src/Nazara/Core/Hash/SHA224.cpp
View File

@ -8,27 +8,27 @@
namespace Nz
{
HashSHA224::HashSHA224()
SHA224Hash::SHA224Hash()
{
m_state = new SHA_CTX;
}
HashSHA224::~HashSHA224()
SHA224Hash::~SHA224Hash()
{
delete m_state;
}
void HashSHA224::Append(const UInt8* data, std::size_t len)
void SHA224Hash::Append(const UInt8* data, std::size_t len)
{
SHA224_Update(m_state, data, len);
}
void HashSHA224::Begin()
void SHA224Hash::Begin()
{
SHA224_Init(m_state);
}
ByteArray HashSHA224::End()
ByteArray SHA224Hash::End()
{
UInt8 digest[SHA224_DIGEST_LENGTH];
@ -37,12 +37,12 @@ namespace Nz
return ByteArray(digest, SHA224_DIGEST_LENGTH);
}
std::size_t HashSHA224::GetDigestLength() const
std::size_t SHA224Hash::GetDigestLength() const
{
return SHA224_DIGEST_LENGTH;
}
const char* HashSHA224::GetHashName() const
const char* SHA224Hash::GetHashName() const
{
return "SHA224";
}

14
src/Nazara/Core/Hash/SHA256.cpp
View File

@ -8,27 +8,27 @@
namespace Nz
{
HashSHA256::HashSHA256()
SHA256Hash::SHA256Hash()
{
m_state = new SHA_CTX;
}
HashSHA256::~HashSHA256()
SHA256Hash::~SHA256Hash()
{
delete m_state;
}
void HashSHA256::Append(const UInt8* data, std::size_t len)
void SHA256Hash::Append(const UInt8* data, std::size_t len)
{
SHA256_Update(m_state, data, len);
}
void HashSHA256::Begin()
void SHA256Hash::Begin()
{
SHA256_Init(m_state);
}
ByteArray HashSHA256::End()
ByteArray SHA256Hash::End()
{
UInt8 digest[SHA256_DIGEST_LENGTH];
@ -37,12 +37,12 @@ namespace Nz
return ByteArray(digest, SHA256_DIGEST_LENGTH);
}
std::size_t HashSHA256::GetDigestLength() const
std::size_t SHA256Hash::GetDigestLength() const
{
return SHA256_DIGEST_LENGTH;
}
const char* HashSHA256::GetHashName() const
const char* SHA256Hash::GetHashName() const
{
return "SHA256";
}

14
src/Nazara/Core/Hash/SHA384.cpp
View File

@ -8,27 +8,27 @@
namespace Nz
{
HashSHA384::HashSHA384()
SHA384Hash::SHA384Hash()
{
m_state = new SHA_CTX;
}
HashSHA384::~HashSHA384()
SHA384Hash::~SHA384Hash()
{
delete m_state;
}
void HashSHA384::Append(const UInt8* data, std::size_t len)
void SHA384Hash::Append(const UInt8* data, std::size_t len)
{
SHA384_Update(m_state, data, len);
}
void HashSHA384::Begin()
void SHA384Hash::Begin()
{
SHA384_Init(m_state);
}
ByteArray HashSHA384::End()
ByteArray SHA384Hash::End()
{
UInt8 digest[SHA384_DIGEST_LENGTH];
@ -37,12 +37,12 @@ namespace Nz
return ByteArray(digest, SHA384_DIGEST_LENGTH);
}
std::size_t HashSHA384::GetDigestLength() const
std::size_t SHA384Hash::GetDigestLength() const
{
return SHA384_DIGEST_LENGTH;
}
const char* HashSHA384::GetHashName() const
const char* SHA384Hash::GetHashName() const
{
return "SHA384";
}

14
src/Nazara/Core/Hash/SHA512.cpp
View File

@ -8,27 +8,27 @@
namespace Nz
{
HashSHA512::HashSHA512()
SHA512Hash::SHA512Hash()
{
m_state = new SHA_CTX;
}
HashSHA512::~HashSHA512()
SHA512Hash::~SHA512Hash()
{
delete m_state;
}
void HashSHA512::Append(const UInt8* data, std::size_t len)
void SHA512Hash::Append(const UInt8* data, std::size_t len)
{
SHA512_Update(m_state, data, len);
}
void HashSHA512::Begin()
void SHA512Hash::Begin()
{
SHA512_Init(m_state);
}
ByteArray HashSHA512::End()
ByteArray SHA512Hash::End()
{
UInt8 digest[SHA512_DIGEST_LENGTH];
@ -37,12 +37,12 @@ namespace Nz
return ByteArray(digest, SHA512_DIGEST_LENGTH);
}
std::size_t HashSHA512::GetDigestLength() const
std::size_t SHA512Hash::GetDigestLength() const
{
return SHA512_DIGEST_LENGTH;
}
const char* HashSHA512::GetHashName() const
const char* SHA512Hash::GetHashName() const
{
return "SHA512";
}

1599
src/Nazara/Core/Hash/Whirlpool.cpp
View File

File diff suppressed because it is too large Load Diff

89
tests/Engine/Core/AlgorithmCoreTest.cpp
View File

@ -2,6 +2,7 @@
#include <Nazara/Core/StringExt.hpp>
#include <Nazara/Math/Vector2.hpp>
#include <catch2/catch.hpp>
#include <array>
TEST_CASE("Apply", "[CORE][ALGORITHM]")
{
@ -30,63 +31,47 @@ TEST_CASE("Apply", "[CORE][ALGORITHM]")
TEST_CASE("ComputeHash", "[CORE][ALGORITHM]")
{
/*SECTION("Compute CRC32 of '1234'")
struct Test
{
auto result = Nz::ComputeHash(Nz::HashType::CRC32, "1234");
REQUIRE(Nz::ToUpper(result.ToHex()) == "596A3B55");
}
Nz::HashType hashType;
const char* input;
const char* expectedOutput;
};
SECTION("Compute CRC64 of '1234'")
{
auto result = Nz::ComputeHash(Nz::HashType::CRC64, "1234");
REQUIRE(Nz::ToUpper(result.ToHex()) == "33302B9FC23855A8");
}
std::array tests{
//Test{ Nz::HashType::CRC16, "Nazara Engine", "9412" },
Test{ Nz::HashType::CRC32, "Nazara Engine", "8A2F5235" },
Test{ Nz::HashType::CRC64, "Nazara Engine", "87211217C5FFCDDD" },
Test{ Nz::HashType::Fletcher16, "Nazara Engine", "71D7" },
Test{ Nz::HashType::MD5, "Nazara Engine", "71FF4EC3B56010ABC03E4B2C1C8A14B9" },
Test{ Nz::HashType::SHA1, "Nazara Engine", "FCE7C077A1ED0881A8C60C4822BB1369B672CA5B" },
Test{ Nz::HashType::SHA224, "Nazara Engine", "673677224E9B0D24C3828FE6CD36A37C2D43BA27C31B6E6E54756BD4" },
Test{ Nz::HashType::SHA256, "Nazara Engine", "7E66722931B65BF780FB55D41834C3D67455029CC1CB497976D2D41A90D3FD4C" },
Test{ Nz::HashType::SHA384, "Nazara Engine", "80064D11A4E4C2A44DE03406E03025C52641E04BA80DE78B1BB0BA6EA577B4B6914F2BDED5B95BB7285F8EA785B9B996" },
Test{ Nz::HashType::SHA512, "Nazara Engine", "C3A8212B61B88D77E8C4B40884D49BA6A54202865CAA847F676D2EA20E60F43B1C8024DE982A214EB3670B752AF3EE37189F1EBDCA608DD0DD427D8C19371FA5" },
Test{ Nz::HashType::Whirlpool, "Nazara Engine", "92113DC95C25057C4154E9A8B2A4C4C800D24DD22FA7D796F300AF9C4EFA4FAAB6030F66B0DC74B270A911DA18E007544B79B84440A1D58AA7C79A73C39C29F8" },
SECTION("Compute Fletcher16 of '1234'")
{
auto result = Nz::ComputeHash(Nz::HashType::Fletcher16, "1234");
REQUIRE(Nz::ToUpper(result.ToHex()) == "F5CA");
}*/
//Test{ Nz::HashType::CRC16, "The quick brown fox jumps over the lazy dog", "FCDF" },
Test{ Nz::HashType::CRC32, "The quick brown fox jumps over the lazy dog", "414FA339" },
Test{ Nz::HashType::CRC64, "The quick brown fox jumps over the lazy dog", "41E05242FFA9883B" },
Test{ Nz::HashType::Fletcher16, "The quick brown fox jumps over the lazy dog", "FEE8" },
Test{ Nz::HashType::MD5, "The quick brown fox jumps over the lazy dog", "9E107D9D372BB6826BD81D3542A419D6" },
Test{ Nz::HashType::SHA1, "The quick brown fox jumps over the lazy dog", "2FD4E1C67A2D28FCED849EE1BB76E7391B93EB12" },
Test{ Nz::HashType::SHA224, "The quick brown fox jumps over the lazy dog", "730E109BD7A8A32B1CB9D9A09AA2325D2430587DDBC0C38BAD911525" },
Test{ Nz::HashType::SHA256, "The quick brown fox jumps over the lazy dog", "D7A8FBB307D7809469CA9ABCB0082E4F8D5651E46D3CDB762D02D0BF37C9E592" },
Test{ Nz::HashType::SHA384, "The quick brown fox jumps over the lazy dog", "CA737F1014A48F4C0B6DD43CB177B0AFD9E5169367544C494011E3317DBF9A509CB1E5DC1E85A941BBEE3D7F2AFBC9B1" },
Test{ Nz::HashType::SHA512, "The quick brown fox jumps over the lazy dog", "07E547D9586F6A73F73FBAC0435ED76951218FB7D0C8D788A309D785436BBB642E93A252A954F23912547D1E8A3B5ED6E1BFD7097821233FA0538F3DB854FEE6" },
Test{ Nz::HashType::Whirlpool, "The quick brown fox jumps over the lazy dog", "B97DE512E91E3828B40D2B0FDCE9CEB3C4A71F9BEA8D88E75C4FA854DF36725FD2B52EB6544EDCACD6F8BEDDFEA403CB55AE31F03AD62A5EF54E42EE82C3FB35" },
};
SECTION("Compute MD5 of '1234'")
for (const Test& test : tests)
{
auto result = Nz::ComputeHash(Nz::HashType::MD5, "1234");
REQUIRE(Nz::ToUpper(result.ToHex()) == "81DC9BDB52D04DC20036DBD8313ED055");
}
auto hash = Nz::AbstractHash::Get(test.hashType);
SECTION("Compute SHA1 of '1234'")
{
auto result = Nz::ComputeHash(Nz::HashType::SHA1, "1234");
REQUIRE(Nz::ToUpper(result.ToHex()) == "7110EDA4D09E062AA5E4A390B0A572AC0D2C0220");
}
SECTION("Compute SHA224 of '1234'")
{
auto result = Nz::ComputeHash(Nz::HashType::SHA224, "1234");
REQUIRE(Nz::ToUpper(result.ToHex()) == "99FB2F48C6AF4761F904FC85F95EB56190E5D40B1F44EC3A9C1FA319");
}
SECTION("Compute SHA256 of '1234'")
{
auto result = Nz::ComputeHash(Nz::HashType::SHA256, "1234");
REQUIRE(Nz::ToUpper(result.ToHex()) == "03AC674216F3E15C761EE1A5E255F067953623C8B388B4459E13F978D7C846F4");
}
SECTION("Compute SHA384 of '1234'")
{
auto result = Nz::ComputeHash(Nz::HashType::SHA384, "1234");
REQUIRE(Nz::ToUpper(result.ToHex()) == "504F008C8FCF8B2ED5DFCDE752FC5464AB8BA064215D9C5B5FC486AF3D9AB8C81B14785180D2AD7CEE1AB792AD44798C");
}
SECTION("Compute SHA512 of '1234'")
{
auto result = Nz::ComputeHash(Nz::HashType::SHA512, "1234");
REQUIRE(Nz::ToUpper(result.ToHex()) == "D404559F602EAB6FD602AC7680DACBFAADD13630335E951F097AF3900E9DE176B6DB28512F2E000B9D04FBA5133E8B1C6E8DF59DB3A8AB9D60BE4B97CC9E81DB");
}
SECTION("Compute Whirlpool of '1234'")
{
auto result = Nz::ComputeHash(Nz::HashType::Whirlpool, "1234");
REQUIRE(Nz::ToUpper(result.ToHex()) == "2F9959B230A44678DD2DC29F037BA1159F233AA9AB183CE3A0678EAAE002E5AA6F27F47144A1A4365116D3DB1B58EC47896623B92D85CB2F191705DAF11858B8");
WHEN("We compute " << hash->GetHashName() << " of '" << test.input << '"')
{
auto result = Nz::ComputeHash(*hash, test.input);
REQUIRE(Nz::ToUpper(result.ToHex()) == test.expectedOutput);
}
}
}