c071f53f2c
Replace the only hasher called MD5 with the ones listed below.
(+) CRC32, MD5, SHA1, SHA256, SHA3 224 BIT, SHA3 256 BIT, SHA3 384 BIT,
SHA3 512 BIT, Keccak 224 BIT, Keccak 256 BIT, Keccak 384 BIT and Keccak
512 BIT.
Add the natives listed below.
(+) hash_string(const string[], hashType:type, output[], const
outputSize)
(+) hash_file(const fileName, hashType:type, output[], const outputSize)
(+) is_arkshine_a_doctor() : Hidden native, but a sign of recompense
for him being very active since 1.8.3 version of AMX Mod X
(+) get_system_endianness() : Checks if the system is currently Big
Endian or Little Endian.
Add the following Enum.
(+) hashType {}
(+) sysEndianness {}
Deprecate the following natives.
(-) amx_md5()
(-) amx_md5_file()
It has been tested on Windows and Linux. The sanity checks seems to be
properly working, so no worries about them.
These are useful if people are using Sockets, cURLs or MySQLs in order
to compare hashes of different files On-line for further investigation.
You are not able to check if the files are older or newer, but you can
see if the content is different (Hash Checksum mismatch).
I'm glad I did this. Thanks to
73 lines
1.9 KiB
C++
73 lines
1.9 KiB
C++
// //////////////////////////////////////////////////////////
|
|
// sha3.h
|
|
// Copyright (c) 2014 Stephan Brumme. All rights reserved.
|
|
// see http://create.stephan-brumme.com/disclaimer.html
|
|
//
|
|
|
|
#pragma once
|
|
|
|
#include "../hashing.h"
|
|
|
|
/// compute SHA3 hash
|
|
/** Usage:
|
|
SHA3 sha3;
|
|
std::string myHash = sha3("Hello World"); // std::string
|
|
std::string myHash2 = sha3("How are you", 11); // arbitrary data, 11 bytes
|
|
|
|
// or in a streaming fashion:
|
|
|
|
SHA3 sha3;
|
|
while (more data available)
|
|
sha3.add(pointer to fresh data, number of new bytes);
|
|
std::string myHash3 = sha3.getHash();
|
|
*/
|
|
class SHA3 //: public Hash
|
|
{
|
|
public:
|
|
/// algorithm variants
|
|
enum Bits { Bits224 = 224, Bits256 = 256, Bits384 = 384, Bits512 = 512 };
|
|
|
|
/// same as reset()
|
|
explicit SHA3(Bits bits = Bits256);
|
|
|
|
/// compute hash of a memory block
|
|
const char* operator()(const void* data, size_t numBytes);
|
|
/// compute hash of a string, excluding final zero
|
|
const char* operator()(const char* text, size_t size);
|
|
|
|
/// add arbitrary number of bytes
|
|
void add(const void* data, size_t numBytes);
|
|
|
|
/// return latest hash as hex characters
|
|
const char* getHash();
|
|
|
|
/// same as reset()
|
|
void changeBits(Bits bits);
|
|
|
|
/// restart
|
|
void reset();
|
|
|
|
private:
|
|
/// process a full block
|
|
void processBlock(const void* data);
|
|
/// process everything left in the internal buffer
|
|
void processBuffer();
|
|
|
|
/// 1600 bits, stored as 25x64 bit, BlockSize is no more than 1152 bits (Keccak224)
|
|
enum { StateSize = 1600 / (8 * 8),
|
|
MaxBlockSize = 200 - 2 * (224 / 8) };
|
|
|
|
/// hash
|
|
uint64_t m_hash[StateSize];
|
|
/// size of processed data in bytes
|
|
uint64_t m_numBytes;
|
|
/// block size (less or equal to MaxBlockSize)
|
|
size_t m_blockSize;
|
|
/// valid bytes in m_buffer
|
|
size_t m_bufferSize;
|
|
/// bytes not processed yet
|
|
uint8_t m_buffer[MaxBlockSize];
|
|
/// variant
|
|
Bits m_bits;
|
|
};
|