Skip to content

Instantly share code, notes, and snippets.

@Talv

Talv/hash.c

Last active November 19, 2017 02:43
Show Gist options
  • Save Talv/70219cf70f1115aeb6e757d4c870a7bc to your computer and use it in GitHub Desktop.
Save Talv/70219cf70f1115aeb6e757d4c870a7bc to your computer and use it in GitHub Desktop.
Download ZIP
Raw
hash.c
//-------------------------------------------------------------------------------------------------------------
// MD5/SHA256 Hash Library
// by magnificence7 of SC2Mapster.com.
// Project page: <http://www.sc2mapster.com/assets/md5-hash/>
//-------------------------------------------------------------------------------------------------------------
// '>>' operator is currently broken, so we workaround that by using its custom implementation
// @Talv
int shift_right(int v, int s)
{
if (v == -1 || v == 0) { // 0xFFFFFFFF || 0x00000000
// value won't change in any case, so we just exit early
return v;
}
if (s >= 32) {
// most compilers would throw an error if we attempted to shift more bits than there really is
// but in case of Galaxy, compiler seems to ignore it and just performs mod 32 as a safety check
// so we do the same here
s %= 32;
}
if (v & (1 << 31)) {
// if MSB is set, we need to clear it
// in order to get the correct result from division
v = shift_right(v & ~(1 << 31), s);
// then we need to set the vacant bits to high
// as it would normally happen as a result of sign extension
v |= -1 << (31 - s);
return v;
}
// when shifting by more than 18 bits we need to do a second iteration
// because int overflows for PowI(2, 19) and above
for (; s > 0; s -= 18) {
v /= PowI(2, MinI(s, 18));
}
return v;
}
// Hash Input
byte[1024] libHash_HashInputData;
int libHash_HashInputSize = 0;
int libHash_GetHashInputLittleEndianInt( int position )
{
int temp;
int result;
position *= 4;
result = libHash_HashInputData[position];
temp = libHash_HashInputData[position + 1];
result |= temp << 8;
temp = libHash_HashInputData[position + 2];
result |= temp << 16;
temp = libHash_HashInputData[position + 3];
result |= temp << 24;
return result;
}
int libHash_GetHashInputBigEndianInt( int position )
{
int temp;
int result;
position *= 4;
temp = libHash_HashInputData[position];
result = temp << 24;
temp = libHash_HashInputData[position + 1];
result |= temp << 16;
temp = libHash_HashInputData[position + 2];
result |= temp << 8;
temp = libHash_HashInputData[position + 3];
result |= temp;
return result;
}
// ASCII conversion
string libHash_asciiTable = "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff";
byte libHash_CharToAsciiCode(string charContainingString, int charPosition)
{
return StringFind( libHash_asciiTable, StringSub( charContainingString, charPosition + 1, charPosition + 1), c_stringCase );
}
// Hex Conversion
string[16] libHash_HexTable;
string libHash_GetHexChar( int number )
{
return libHash_HexTable[number];
}
string libHash_GetUnsignedLittleEndianHexRepresentation( int unsignedInt )
{
string representation = "";
representation += libHash_GetHexChar( shift_right(( unsignedInt & 0x000000F0 ), 4) );
representation += libHash_GetHexChar( ( unsignedInt & 0x0000000F ) );
representation += libHash_GetHexChar( shift_right(( unsignedInt & 0x0000F000 ), 12) );
representation += libHash_GetHexChar( shift_right(( unsignedInt & 0x00000F00), 8) );
representation += libHash_GetHexChar( shift_right(( unsignedInt & 0x00F00000 ), 20) );
representation += libHash_GetHexChar( shift_right(( unsignedInt & 0x000F0000), 16) );
if ( unsignedInt >= 0 )
{
representation += libHash_GetHexChar( shift_right(unsignedInt, 28) );
}
else
{
unsignedInt += 0x7FFFFFFF + 1;
representation += libHash_GetHexChar( 0x8 + ( shift_right(unsignedInt, 28) ) );
}
representation += libHash_GetHexChar( shift_right(( unsignedInt & 0x0F000000), 24) );
return representation;
}
string libHash_GetUnsignedHexRepresentation( int unsignedInt )
{
string representation = "";
if ( unsignedInt >= 0 )
{
representation += libHash_GetHexChar( shift_right(unsignedInt, 28) );
}
else
{
unsignedInt += 0x7FFFFFFF + 1;
representation += libHash_GetHexChar( 0x8 + ( shift_right(unsignedInt, 28) ) );
}
representation += libHash_GetHexChar( shift_right(( unsignedInt & 0x0F000000), 24) );
representation += libHash_GetHexChar( shift_right(( unsignedInt & 0x00F00000 ), 20) );
representation += libHash_GetHexChar( shift_right(( unsignedInt & 0x000F0000), 16) );
representation += libHash_GetHexChar( shift_right(( unsignedInt & 0x0000F000 ), 12) );
representation += libHash_GetHexChar( shift_right(( unsignedInt & 0x00000F00), 8) );
representation += libHash_GetHexChar( shift_right(( unsignedInt & 0x000000F0 ), 4) );
representation += libHash_GetHexChar( ( unsignedInt & 0x0000000F ) );
return representation;
}
// Resolve data function
int libHash_GetFixedDataAsInt(fixed fixedVar)
{
int data;
data= ( FixedToInt(fixedVar) << 12 );
fixedVar -= data;
data|= FixedToInt( fixedVar* Pow2(12) );
return data;
}
// Operations
int libHash_UnsignedRightShift( int input, int shift ) // Right shift pads bit 1's when the value is under zero for signed integers. So this is the work-around.
{
return shift_right(input, shift) & ~( -1 << ( 32 - shift ) );
}
int libHash_UnsignedLeftRotate( int input, int rotation )
{
rotation = ModI( rotation, 32 );
return ( input << rotation ) | libHash_UnsignedRightShift (input, 32 - rotation );
}
int libHash_UnsignedRightRotate( int input, int rotation )
{
rotation = ModI( rotation, 32 );
return libHash_UnsignedRightShift( input, rotation ) | ( input << ( 32 - rotation ) );
}
int libHash_UnsignedLeftRotate32( int input, int rotation ) // Optimized version for rotation within range 0 =< x =< 32
{
return ( input << rotation ) | libHash_UnsignedRightShift (input, 32 - rotation );
}
int libHash_UnsignedRightRotate32( int input, int rotation ) // Optimized version for rotation within range 0 =< x =< 32
{
return libHash_UnsignedRightShift( input, rotation ) | ( input << ( 32 - rotation ) );
}
//--------------------------------------------------------------------------------------------------
// Custom Script: MD5 Script
//--------------------------------------------------------------------------------------------------
int libHash_Md5F( int b, int c, int d )
{
return d ^ ( b & ( c ^ d ) );
}
int libHash_Md5G( int b, int c, int d )
{
return c ^ ( d & ( b ^ c ) );
}
int libHash_Md5H( int b, int c, int d )
{
return b ^ c ^ d;
}
int libHash_Md5I( int b, int c, int d )
{
return c ^ (b | (~d));
}
int libHash_Md5FF( int a, int b, int c, int d, int w, int r, int k )
{
return libHash_UnsignedLeftRotate32( ( a + libHash_Md5F( b, c, d ) + k + w ), r ) + b;
}
int libHash_Md5GG( int a, int b, int c, int d, int w, int r, int k )
{
return libHash_UnsignedLeftRotate32( ( a + libHash_Md5G( b, c, d ) + k + w ), r ) + b;
}
int libHash_Md5HH( int a, int b, int c, int d, int w, int r, int k )
{
return libHash_UnsignedLeftRotate32( ( a + libHash_Md5H( b, c, d ) + k + w ), r ) + b;
}
int libHash_Md5II( int a, int b, int c, int d, int w, int r, int k )
{
return libHash_UnsignedLeftRotate32( ( a + libHash_Md5I( b, c, d ) + k + w ), r ) + b;
}
string libHash_GeneratelibHash_Md5HashCode()
{
// Variables
int h0 = 0x67452301;
int h1 = 0x0E000000 << 4 | 0x0FCDAB89;
int h2 = 0x09000000 << 4 | 0x08BADCFE;
int h3 = 0x10325476;
int a; int b; int c; int d;
int i = 0; int j = 0;
int messageNBits;
int paddingLength;
// Prepare message
messageNBits = libHash_HashInputSize * 8;
libHash_HashInputData[libHash_HashInputSize] = 0x80;
libHash_HashInputSize += 1;
paddingLength = 56 - ModI( libHash_HashInputSize, 64 );
if ( paddingLength < 0 )
{
paddingLength += 64;
}
while ( i < paddingLength )
{
libHash_HashInputData[libHash_HashInputSize] = 0;
libHash_HashInputSize += 1;
i += 1;
}
//Note: You might want to change this when the hash input increases in size.
libHash_HashInputData[libHash_HashInputSize] = messageNBits;
libHash_HashInputSize += 1;
libHash_HashInputData[libHash_HashInputSize] = shift_right(messageNBits, 8);
libHash_HashInputSize += 1;
libHash_HashInputData[libHash_HashInputSize] = 0;
libHash_HashInputSize += 1;
libHash_HashInputData[libHash_HashInputSize] = 0;
libHash_HashInputSize += 1;
libHash_HashInputData[libHash_HashInputSize] = 0;
libHash_HashInputSize += 1;
libHash_HashInputData[libHash_HashInputSize] = 0;
libHash_HashInputSize += 1;
libHash_HashInputData[libHash_HashInputSize] = 0;
libHash_HashInputSize += 1;
libHash_HashInputData[libHash_HashInputSize] = 0;
libHash_HashInputSize += 1;
// Loop
i = 0;
while ( i < ( libHash_HashInputSize - 1 ) )
{
a = h0;
b = h1;
c = h2;
d = h3;
a = libHash_Md5FF( a, b, c, d, libHash_GetHashInputLittleEndianInt( j ), 7, 0x0d000000 << 4 | 0x076aa478 );
d = libHash_Md5FF( d, a, b, c, libHash_GetHashInputLittleEndianInt( j + 1 ), 12, 0x0e000000 << 4 | 0x08c7b756 );
c = libHash_Md5FF( c, d, a, b, libHash_GetHashInputLittleEndianInt( j + 2 ), 17, 0x242070db );
b = libHash_Md5FF( b, c, d, a, libHash_GetHashInputLittleEndianInt( j + 3 ), 22, 0x0c000000 << 4 | 0x01bdceee );
a = libHash_Md5FF( a, b, c, d, libHash_GetHashInputLittleEndianInt( j + 4 ), 7, 0x0f000000 << 4 | 0x057c0faf );
d = libHash_Md5FF( d, a, b, c, libHash_GetHashInputLittleEndianInt( j + 5 ), 12, 0x4787c62a );
c = libHash_Md5FF( c, d, a, b, libHash_GetHashInputLittleEndianInt( j + 6 ), 17, 0x0a000000 << 4 | 0x08304613 );
b = libHash_Md5FF( b, c, d, a, libHash_GetHashInputLittleEndianInt( j + 7 ), 22, 0x0f000000 << 4 | 0x0d469501 );
a = libHash_Md5FF( a, b, c, d, libHash_GetHashInputLittleEndianInt( j + 8 ), 7, 0x698098d8 );
d = libHash_Md5FF( d, a, b, c, libHash_GetHashInputLittleEndianInt( j + 9 ), 12, 0x08000000 << 4 | 0x0b44f7af );
c = libHash_Md5FF( c, d, a, b, libHash_GetHashInputLittleEndianInt( j + 10 ), 17, 0x0f000000 << 4 | 0x0fff5bb1 );
b = libHash_Md5FF( b, c, d, a, libHash_GetHashInputLittleEndianInt( j + 11 ), 22, 0x08000000 << 4 | 0x095cd7be );
a = libHash_Md5FF( a, b, c, d, libHash_GetHashInputLittleEndianInt( j + 12 ), 7, 0x6b901122 );
d = libHash_Md5FF( d, a, b, c, libHash_GetHashInputLittleEndianInt( j + 13 ), 12, 0x0f000000 << 4 | 0x0d987193 );
c = libHash_Md5FF( c, d, a, b, libHash_GetHashInputLittleEndianInt( j+ 14 ), 17, 0x0a000000 << 4 | 0x0679438e );
b = libHash_Md5FF( b, c, d, a, libHash_GetHashInputLittleEndianInt( j + 15 ), 22, 0x49b40821 );
a = libHash_Md5GG( a, b, c, d, libHash_GetHashInputLittleEndianInt( j + 1 ), 5, 0x0f000000 << 4 | 0x061e2562 );
d = libHash_Md5GG( d, a, b, c, libHash_GetHashInputLittleEndianInt( j + 6 ), 9, 0x0c000000 << 4 | 0x0040b340 );
c = libHash_Md5GG( c, d, a, b, libHash_GetHashInputLittleEndianInt( j + 11 ), 14, 0x265e5a51 );
b = libHash_Md5GG( b, c, d, a, libHash_GetHashInputLittleEndianInt( j ), 20, 0x0e000000 << 4 | 0x09b6c7aa );
a = libHash_Md5GG( a, b, c, d, libHash_GetHashInputLittleEndianInt( j + 5 ), 5, 0x0d000000 << 4 | 0x062f105d );
d = libHash_Md5GG( d, a, b, c, libHash_GetHashInputLittleEndianInt( j + 10 ), 9, 0x02441453 );
c = libHash_Md5GG( c, d, a, b, libHash_GetHashInputLittleEndianInt( j + 15 ), 14, 0x0d000000 << 4 | 0x08a1e681 );
b = libHash_Md5GG( b, c, d, a, libHash_GetHashInputLittleEndianInt( j + 4 ), 20, 0x0e000000 << 4 | 0x07d3fbc8 );
a = libHash_Md5GG( a, b, c, d, libHash_GetHashInputLittleEndianInt( j + 9 ), 5, 0x21e1cde6 );
d = libHash_Md5GG( d, a, b, c, libHash_GetHashInputLittleEndianInt( j + 14 ), 9, 0x0c000000 << 4 | 0x033707d6 );
c = libHash_Md5GG( c, d, a, b, libHash_GetHashInputLittleEndianInt( j + 3 ), 14, 0x0f000000 << 4 | 0x04d50d87 );
b = libHash_Md5GG( b, c, d, a, libHash_GetHashInputLittleEndianInt( j + 8 ), 20, 0x455a14ed );
a = libHash_Md5GG( a, b, c, d, libHash_GetHashInputLittleEndianInt( j + 13 ), 5, 0x0a000000 << 4 | 0x09e3e905 );
d = libHash_Md5GG( d, a, b, c, libHash_GetHashInputLittleEndianInt( j + 2 ), 9, 0x0f000000 << 4 | 0x0cefa3f8 );
c = libHash_Md5GG( c, d, a, b, libHash_GetHashInputLittleEndianInt( j + 7 ), 14, 0x676f02d9 );
b = libHash_Md5GG( b, c, d, a, libHash_GetHashInputLittleEndianInt( j + 12 ), 20, 0x08000000 << 4 | 0x0d2a4c8a );
a = libHash_Md5HH( a, b, c, d, libHash_GetHashInputLittleEndianInt( j + 5 ), 4, 0x0f000000 << 4 | 0x0ffa3942 );
d = libHash_Md5HH( d, a, b, c, libHash_GetHashInputLittleEndianInt( j + 8 ), 11, 0x08000000 << 4 | 0x0771f681 );
c = libHash_Md5HH( c, d, a, b, libHash_GetHashInputLittleEndianInt( j + 11 ), 16, 0x6d9d6122 );
b = libHash_Md5HH( b, c, d, a, libHash_GetHashInputLittleEndianInt( j + 14 ), 23, 0x0f000000 << 4 | 0x0de5380c );
a = libHash_Md5HH( a, b, c, d, libHash_GetHashInputLittleEndianInt( j + 1 ), 4, 0x0a000000 << 4 | 0x04beea44 );
d = libHash_Md5HH( d, a, b, c, libHash_GetHashInputLittleEndianInt( j + 4 ), 11, 0x4bdecfa9 );
c = libHash_Md5HH( c, d, a, b, libHash_GetHashInputLittleEndianInt( j + 7 ), 16, 0x0f000000 << 4 | 0x06bb4b60 );
b = libHash_Md5HH( b, c, d, a, libHash_GetHashInputLittleEndianInt( j + 10 ), 23, 0x0b000000 << 4 | 0x0ebfbc70 );
a = libHash_Md5HH( a, b, c, d, libHash_GetHashInputLittleEndianInt( j + 13 ), 4, 0x289b7ec6 );
d = libHash_Md5HH( d, a, b, c, libHash_GetHashInputLittleEndianInt( j + 0 ), 11, 0x0e000000 << 4 | 0x0aa127fa );
c = libHash_Md5HH( c, d, a, b, libHash_GetHashInputLittleEndianInt( j + 3 ), 16, 0x0d000000 << 4 | 0x04ef3085 );
b = libHash_Md5HH( b, c, d, a, libHash_GetHashInputLittleEndianInt( j + 6 ), 23, 0x04881d05 );
a = libHash_Md5HH( a, b, c, d, libHash_GetHashInputLittleEndianInt( j + 9 ), 4, 0x0d000000 << 4 | 0x09d4d039 );
d = libHash_Md5HH( d, a, b, c, libHash_GetHashInputLittleEndianInt( j + 12 ), 11, 0x0e000000 << 4 | 0x06db99e5 );
c = libHash_Md5HH( c, d, a, b, libHash_GetHashInputLittleEndianInt( j + 15 ), 16, 0x1fa27cf8 );
b = libHash_Md5HH( b, c, d, a, libHash_GetHashInputLittleEndianInt( j + 2 ), 23, 0x0c000000 << 4 | 0x04ac5665 );
a = libHash_Md5II( a, b, c, d, libHash_GetHashInputLittleEndianInt( j ), 6, 0x0f000000 << 4 | 0x04292244 );
d = libHash_Md5II( d, a, b, c, libHash_GetHashInputLittleEndianInt( j + 7 ), 10, 0x432aff97 );
c = libHash_Md5II( c, d, a, b, libHash_GetHashInputLittleEndianInt( j + 14 ), 15, 0x0a000000 << 4 | 0x0b9423a7 );
b = libHash_Md5II( b, c, d, a, libHash_GetHashInputLittleEndianInt( j + 5 ), 21, 0x0f000000 << 4 | 0x0c93a039 );
a = libHash_Md5II( a, b, c, d, libHash_GetHashInputLittleEndianInt( j + 12 ), 6, 0x655b59c3 );
d = libHash_Md5II( d, a, b, c, libHash_GetHashInputLittleEndianInt( j + 3 ), 10, 0x08000000 << 4 | 0x0f0ccc92 );
c = libHash_Md5II( c, d, a, b, libHash_GetHashInputLittleEndianInt( j + 10 ), 15, 0x0f000000 << 4 | 0x0feff47d );
b = libHash_Md5II( b, c, d, a, libHash_GetHashInputLittleEndianInt( j + 1 ), 21, 0x08000000 << 4 | 0x05845dd1 );
a = libHash_Md5II( a, b, c, d, libHash_GetHashInputLittleEndianInt( j + 8 ), 6, 0x6fa87e4f );
d = libHash_Md5II( d, a, b, c, libHash_GetHashInputLittleEndianInt( j + 15 ), 10, 0x0f000000 << 4 | 0x0e2ce6e0 );
c = libHash_Md5II( c, d, a, b, libHash_GetHashInputLittleEndianInt( j + 6 ), 15, 0x0a000000 << 4 | 0x03014314 );
b = libHash_Md5II( b, c, d, a, libHash_GetHashInputLittleEndianInt( j + 13 ), 21, 0x4e0811a1 );
a = libHash_Md5II( a, b, c, d, libHash_GetHashInputLittleEndianInt( j + 4 ), 6, 0x0f000000 << 4 | 0x07537e82 );
d = libHash_Md5II( d, a, b, c, libHash_GetHashInputLittleEndianInt( j + 11 ), 10, 0x0b000000 << 4 | 0x0d3af235 );
c = libHash_Md5II( c, d, a, b, libHash_GetHashInputLittleEndianInt( j + 2 ), 15, 0x2ad7d2bb );
b = libHash_Md5II( b, c, d, a, libHash_GetHashInputLittleEndianInt( j + 9 ), 21, 0x0e000000 << 4 | 0x0b86d391 );
h0 += a;
h1 += b;
h2 += c;
h3 += d;
i += 64;
j += 16;
}
return libHash_GetUnsignedLittleEndianHexRepresentation( h0 ) + libHash_GetUnsignedLittleEndianHexRepresentation( h1 ) + libHash_GetUnsignedLittleEndianHexRepresentation( h2 ) + libHash_GetUnsignedLittleEndianHexRepresentation( h3 );
}
//--------------------------------------------------------------------------------------------------
// Custom Script: SHA256 Script
//--------------------------------------------------------------------------------------------------
int libHash_Sha256Ch( int x, int y, int z )
{
return ( x & y ) ^ ( ~x & z );
}
int libHash_Sha256Maj( int x, int y, int z )
{
return ( x & y ) ^ ( x & z ) ^ ( y & z );
}
int libHash_Sha256CapitalSigma0( int x )
{
return libHash_UnsignedRightRotate32( x, 2 ) ^ libHash_UnsignedRightRotate32( x, 13 ) ^ libHash_UnsignedRightRotate32( x, 22 );
}
int libHash_Sha256CapitalSigma1( int x )
{
return libHash_UnsignedRightRotate32( x, 6 ) ^ libHash_UnsignedRightRotate32( x, 11 ) ^ libHash_UnsignedRightRotate32( x, 25 );
}
int libHash_Sha256Sigma0( int x )
{
return libHash_UnsignedRightRotate32( x, 7 ) ^ libHash_UnsignedRightRotate32( x, 18 ) ^ libHash_UnsignedRightShift( x, 3 );
}
int libHash_Sha256Sigma1( int x )
{
return libHash_UnsignedRightRotate32( x, 17 ) ^ libHash_UnsignedRightRotate32( x, 19 ) ^ libHash_UnsignedRightShift( x, 10 );
}
int libHash_Sha256T0( int e, int f, int g, int h, int k, int w )
{
return h + libHash_Sha256CapitalSigma1( e ) + libHash_Sha256Ch( e, f, g ) + k + w;
}
int libHash_Sha256T1( int a, int b, int c )
{
return libHash_Sha256CapitalSigma0( a ) + libHash_Sha256Maj( a, b, c );
}
string libHash_GenerateSha256HashCode()
{
// Variables
int h0 = 0x6a09e667;
int h1 = 0x0b000000 << 4 | 0x0b67ae85;
int h2 = 0x3c6ef372;
int h3 = 0x0a000000 << 4 | 0x054ff53a;
int h4 = 0x510e527f;
int h5 = 0x09000000 << 4 | 0x0b05688c;
int h6 = 0x1f83d9ab;
int h7 = 0x5be0cd19;
int a; int b; int c; int d; int e; int f; int g; int h; int t0; int t1;
int[64] w;
int i = 0; int j = 0; int k = 0;
int messageNBits;
int paddingLength;
// Prepare message
messageNBits = libHash_HashInputSize * 8;
libHash_HashInputData[libHash_HashInputSize] = 0x80;
libHash_HashInputSize += 1;
paddingLength = 56 - ModI( libHash_HashInputSize, 64 );
if ( paddingLength < 0 )
{
paddingLength += 64;
}
while ( i < paddingLength )
{
libHash_HashInputData[libHash_HashInputSize] = 0;
libHash_HashInputSize += 1;
i += 1;
}
//Note: You might want to change this when the hash input increases in size.
libHash_HashInputData[libHash_HashInputSize] = 0;
libHash_HashInputSize += 1;
libHash_HashInputData[libHash_HashInputSize] = 0;
libHash_HashInputSize += 1;
libHash_HashInputData[libHash_HashInputSize] = 0;
libHash_HashInputSize += 1;
libHash_HashInputData[libHash_HashInputSize] = 0;
libHash_HashInputSize += 1;
libHash_HashInputData[libHash_HashInputSize] = 0;
libHash_HashInputSize += 1;
libHash_HashInputData[libHash_HashInputSize] = 0;
libHash_HashInputSize += 1;
libHash_HashInputData[libHash_HashInputSize] = shift_right(messageNBits, 8);
libHash_HashInputSize += 1;
libHash_HashInputData[libHash_HashInputSize] = messageNBits;
libHash_HashInputSize += 1;
// Loop
i = 0;
while ( i < ( libHash_HashInputSize - 1 ) )
{
// Working Variables
a = h0;
b = h1;
c = h2;
d = h3;
e = h4;
f = h5;
g = h6;
h = h7;
// Preparing Extra Message Schedule
j = 0;
while ( j < 16 )
{
w[j] = libHash_GetHashInputBigEndianInt( k );
j += 1;
k += 1;
}
while ( j < 64 )
{
w[j] = libHash_Sha256Sigma1( w[j - 2] ) +
w[j - 7] +
libHash_Sha256Sigma0( w[j - 15] ) +
w[j - 16];
j += 1;
}
// 0 to 15
t0 = libHash_Sha256T0( e, f, g, h, 0x428a2f98, w[0] ); t1 = libHash_Sha256T1( a, b, c );
h = t0 + t1; d += t0; i += 1;
t0 = libHash_Sha256T0( d, e, f, g, 0x71374491, w[1] ); t1 = libHash_Sha256T1( h, a, b );
g = t0 + t1; c += t0; i += 1;
t0 = libHash_Sha256T0( c, d, e, f, 0x0b000000 << 4 | 0x05c0fbcf, w[2] ); t1 = libHash_Sha256T1( g, h, a );
f = t0 + t1; b += t0; i += 1;
t0 = libHash_Sha256T0( b, c, d, e, 0x0e000000 << 4 | 0x09b5dba5, w[3] ); t1 = libHash_Sha256T1( f, g, h );
e = t0 + t1; a += t0; i += 1;
t0 = libHash_Sha256T0( a, b, c, d, 0x3956c25b, w[4] ); t1 = libHash_Sha256T1( e, f, g );
d = t0 + t1; h += t0; i += 1;
t0 = libHash_Sha256T0( h, a, b, c, 0x59f111f1, w[5] ); t1 = libHash_Sha256T1( d, e, f );
c = t0 + t1; g += t0; i += 1;
t0 = libHash_Sha256T0( g, h, a, b, 0x09000000 << 4 | 0x023f82a4, w[6] ); t1 = libHash_Sha256T1( c, d, e );
b = t0 + t1; f += t0; i += 1;
t0 = libHash_Sha256T0( f, g, h, a, 0x0a000000 << 4 | 0x0b1c5ed5, w[7] ); t1 = libHash_Sha256T1( b, c, d );
a = t0 + t1; e += t0; i += 1;
t0 = libHash_Sha256T0( e, f, g, h, 0x0d000000 << 4 | 0x0807aa98, w[8] ); t1 = libHash_Sha256T1( a, b, c );
h = t0 + t1; d += t0; i += 1;
t0 = libHash_Sha256T0( d, e, f, g, 0x12835b01, w[9] ); t1 = libHash_Sha256T1( h, a, b );
g = t0 + t1; c += t0; i += 1;
t0 = libHash_Sha256T0( c, d, e, f, 0x243185be, w[10] ); t1 = libHash_Sha256T1( g, h, a );
f = t0 + t1; b += t0; i += 1;
t0 = libHash_Sha256T0( b, c, d, e, 0x550c7dc3, w[11] ); t1 = libHash_Sha256T1( f, g, h );
e = t0 + t1; a += t0; i += 1;
t0 = libHash_Sha256T0( a, b, c, d, 0x72be5d74, w[12] ); t1 = libHash_Sha256T1( e, f, g );
d = t0 + t1; h += t0; i += 1;
t0 = libHash_Sha256T0( h, a, b, c, 0x08000000 << 4 | 0x00deb1fe, w[13] ); t1 = libHash_Sha256T1( d, e, f );
c = t0 + t1; g += t0; i += 1;
t0 = libHash_Sha256T0( g, h, a, b, 0x09000000 << 4 | 0x0bdc06a7, w[14] ); t1 = libHash_Sha256T1( c, d, e );
b = t0 + t1; f += t0; i += 1;
t0 = libHash_Sha256T0( f, g, h, a, 0x0c000000 << 4 | 0x019bf174, w[15] ); t1 = libHash_Sha256T1( b, c, d );
a = t0 + t1; e += t0;
// 16 to 31
t0 = libHash_Sha256T0( e, f, g, h, 0x0e000000 << 4 | 0x049b69c1, w[16] ); t1 = libHash_Sha256T1( a, b, c );
h = t0 + t1; d += t0;
t0 = libHash_Sha256T0( d, e, f, g, 0x0e000000 << 4 | 0x0fbe4786, w[17] ); t1 = libHash_Sha256T1( h, a, b );
g = t0 + t1; c += t0;
t0 = libHash_Sha256T0( c, d, e, f, 0x0fc19dc6, w[18] ); t1 = libHash_Sha256T1( g, h, a );
f = t0 + t1; b += t0;
t0 = libHash_Sha256T0( b, c, d, e, 0x240ca1cc, w[19] ); t1 = libHash_Sha256T1( f, g, h );
e = t0 + t1; a += t0;
t0 = libHash_Sha256T0( a, b, c, d, 0x2de92c6f, w[20] ); t1 = libHash_Sha256T1( e, f, g );
d = t0 + t1; h += t0;
t0 = libHash_Sha256T0( h, a, b, c, 0x4a7484aa, w[21] ); t1 = libHash_Sha256T1( d, e, f );
c = t0 + t1; g += t0;
t0 = libHash_Sha256T0( g, h, a, b, 0x5cb0a9dc, w[22] ); t1 = libHash_Sha256T1( c, d, e );
b = t0 + t1; f += t0;
t0 = libHash_Sha256T0( f, g, h, a, 0x76f988da, w[23] ); t1 = libHash_Sha256T1( b, c, d );
a = t0 + t1; e += t0;
t0 = libHash_Sha256T0( e, f, g, h, 0x09000000 << 4 | 0x083e5152, w[24] ); t1 = libHash_Sha256T1( a, b, c );
h = t0 + t1; d += t0;
t0 = libHash_Sha256T0( d, e, f, g, 0x0a000000 << 4 | 0x0831c66d, w[25] ); t1 = libHash_Sha256T1( h, a, b );
g = t0 + t1; c += t0;
t0 = libHash_Sha256T0( c, d, e, f, 0x0b000000 << 4 | 0x000327c8, w[26] ); t1 = libHash_Sha256T1( g, h, a );
f = t0 + t1; b += t0;
t0 = libHash_Sha256T0( b, c, d, e, 0x0b000000 << 4 | 0x0f597fc7, w[27] ); t1 = libHash_Sha256T1( f, g, h );
e = t0 + t1; a += t0;
t0 = libHash_Sha256T0( a, b, c, d, 0x0c000000 << 4 | 0x06e00bf3, w[28] ); t1 = libHash_Sha256T1( e, f, g );
d = t0 + t1; h += t0;
t0 = libHash_Sha256T0( h, a, b, c, 0x0d000000 << 4 | 0x05a79147, w[29] ); t1 = libHash_Sha256T1( d, e, f );
c = t0 + t1; g += t0;
t0 = libHash_Sha256T0( g, h, a, b, 0x06ca6351, w[30] ); t1 = libHash_Sha256T1( c, d, e );
b = t0 + t1; f += t0;
t0 = libHash_Sha256T0( f, g, h, a, 0x14292967, w[31] ); t1 = libHash_Sha256T1( b, c, d );
a = t0 + t1; e += t0;
// 32 to 47
t0 = libHash_Sha256T0( e, f, g, h, 0x27b70a85, w[32] ); t1 = libHash_Sha256T1( a, b, c );
h = t0 + t1; d += t0;
t0 = libHash_Sha256T0( d, e, f, g, 0x2e1b2138, w[33] ); t1 = libHash_Sha256T1( h, a, b );
g = t0 + t1; c += t0;
t0 = libHash_Sha256T0( c, d, e, f, 0x4d2c6dfc, w[34] ); t1 = libHash_Sha256T1( g, h, a );
f = t0 + t1; b += t0;
t0 = libHash_Sha256T0( b, c, d, e, 0x53380d13, w[35] ); t1 = libHash_Sha256T1( f, g, h );
e = t0 + t1; a += t0;
t0 = libHash_Sha256T0( a, b, c, d, 0x650a7354, w[36] ); t1 = libHash_Sha256T1( e, f, g );
d = t0 + t1; h += t0;
t0 = libHash_Sha256T0( h, a, b, c, 0x766a0abb, w[37] ); t1 = libHash_Sha256T1( d, e, f );
c = t0 + t1; g += t0;
t0 = libHash_Sha256T0( g, h, a, b, 0x08000000 << 4 | 0x01c2c92e, w[38] ); t1 = libHash_Sha256T1( c, d, e );
b = t0 + t1; f += t0;
t0 = libHash_Sha256T0( f, g, h, a, 0x09000000 << 4 | 0x02722c85, w[39] ); t1 = libHash_Sha256T1( b, c, d );
a = t0 + t1; e += t0;
t0 = libHash_Sha256T0( e, f, g, h, 0x0a000000 << 4 | 0x02bfe8a1, w[40] ); t1 = libHash_Sha256T1( a, b, c );
h = t0 + t1; d += t0;
t0 = libHash_Sha256T0( d, e, f, g, 0x0a000000 << 4 | 0x081a664b, w[41] ); t1 = libHash_Sha256T1( h, a, b );
g = t0 + t1; c += t0;
t0 = libHash_Sha256T0( c, d, e, f, 0x0c000000 << 4 | 0x024b8b70, w[42] ); t1 = libHash_Sha256T1( g, h, a );
f = t0 + t1; b += t0;
t0 = libHash_Sha256T0( b, c, d, e, 0x0c000000 << 4 | 0x076c51a3, w[43] ); t1 = libHash_Sha256T1( f, g, h );
e = t0 + t1; a += t0;
t0 = libHash_Sha256T0( a, b, c, d, 0x0d000000 << 4 | 0x0192e819, w[44] ); t1 = libHash_Sha256T1( e, f, g );
d = t0 + t1; h += t0;
t0 = libHash_Sha256T0( h, a, b, c, 0x0d000000 << 4 | 0x06990624, w[45] ); t1 = libHash_Sha256T1( d, e, f );
c = t0 + t1; g += t0;
t0 = libHash_Sha256T0( g, h, a, b, 0x0f000000 << 4 | 0x040e3585, w[46] ); t1 = libHash_Sha256T1( c, d, e );
b = t0 + t1; f += t0;
t0 = libHash_Sha256T0( f, g, h, a, 0x106aa070, w[47] ); t1 = libHash_Sha256T1( b, c, d );
a = t0 + t1; e += t0;
// 48 to 63
t0 = libHash_Sha256T0( e, f, g, h, 0x19a4c116, w[48] ); t1 = libHash_Sha256T1( a, b, c );
h = t0 + t1; d += t0;
t0 = libHash_Sha256T0( d, e, f, g, 0x1e376c08, w[49] ); t1 = libHash_Sha256T1( h, a, b );
g = t0 + t1; c += t0;
t0 = libHash_Sha256T0( c, d, e, f, 0x2748774c, w[50] ); t1 = libHash_Sha256T1( g, h, a );
f = t0 + t1; b += t0;
t0 = libHash_Sha256T0( b, c, d, e, 0x34b0bcb5, w[51] ); t1 = libHash_Sha256T1( f, g, h );
e = t0 + t1; a += t0;
t0 = libHash_Sha256T0( a, b, c, d, 0x391c0cb3, w[52] ); t1 = libHash_Sha256T1( e, f, g );
d = t0 + t1; h += t0;
t0 = libHash_Sha256T0( h, a, b, c, 0x4ed8aa4a, w[53] ); t1 = libHash_Sha256T1( d, e, f );
c = t0 + t1; g += t0;
t0 = libHash_Sha256T0( g, h, a, b, 0x5b9cca4f, w[54] ); t1 = libHash_Sha256T1( c, d, e );
b = t0 + t1; f += t0;
t0 = libHash_Sha256T0( f, g, h, a, 0x682e6ff3, w[55] ); t1 = libHash_Sha256T1( b, c, d );
a = t0 + t1; e += t0;
t0 = libHash_Sha256T0( e, f, g, h, 0x748f82ee, w[56] ); t1 = libHash_Sha256T1( a, b, c );
h = t0 + t1; d += t0;
t0 = libHash_Sha256T0( d, e, f, g, 0x78a5636f, w[57] ); t1 = libHash_Sha256T1( h, a, b );
g = t0 + t1; c += t0;
t0 = libHash_Sha256T0( c, d, e, f, 0x08000000 << 4 | 0x04c87814, w[58] ); t1 = libHash_Sha256T1( g, h, a );
f = t0 + t1; b += t0;
t0 = libHash_Sha256T0( b, c, d, e, 0x08000000 << 4 | 0x0cc70208, w[59] ); t1 = libHash_Sha256T1( f, g, h );
e = t0 + t1; a += t0;
t0 = libHash_Sha256T0( a, b, c, d, 0x09000000 << 4 | 0x00befffa, w[60] ); t1 = libHash_Sha256T1( e, f, g );
d = t0 + t1; h += t0;
t0 = libHash_Sha256T0( h, a, b, c, 0x0a000000 << 4 | 0x04506ceb, w[61] ); t1 = libHash_Sha256T1( d, e, f );
c = t0 + t1; g += t0;
t0 = libHash_Sha256T0( g, h, a, b, 0x0b000000 << 4 | 0x0ef9a3f7, w[62] ); t1 = libHash_Sha256T1( c, d, e );
b = t0 + t1; f += t0;
t0 = libHash_Sha256T0( f, g, h, a, 0x0c000000 << 4 | 0x067178f2, w[63] ); t1 = libHash_Sha256T1( b, c, d );
a = t0 + t1; e += t0;
h0 += a;
h1 += b;
h2 += c;
h3 += d;
h4 += e;
h5 += f;
h6 += g;
h7 += h;
i += 49;
}
return libHash_GetUnsignedHexRepresentation(h0) +
libHash_GetUnsignedHexRepresentation(h1) +
libHash_GetUnsignedHexRepresentation(h2) +
libHash_GetUnsignedHexRepresentation(h3) +
libHash_GetUnsignedHexRepresentation(h4) +
libHash_GetUnsignedHexRepresentation(h5) +
libHash_GetUnsignedHexRepresentation(h6) +
libHash_GetUnsignedHexRepresentation(h7);
}
// Functions
void libHash_InitializeHashInput () {
// Implementation
libHash_HashInputSize = 0;
if ( libHash_HexTable[0] == "" )
{
libHash_HexTable[0] = "0"; libHash_HexTable[1] = "1"; libHash_HexTable[2] = "2"; libHash_HexTable[3] = "3";
libHash_HexTable[4] = "4"; libHash_HexTable[5] = "5"; libHash_HexTable[6] = "6"; libHash_HexTable[7] = "7";
libHash_HexTable[8] = "8"; libHash_HexTable[9] = "9"; libHash_HexTable[10] = "a"; libHash_HexTable[11] = "b";
libHash_HexTable[12] = "c"; libHash_HexTable[13] = "d"; libHash_HexTable[14] = "e"; libHash_HexTable[15] = "f";
}
}
void libHash_AddByteToHashInput (byte lp_byte) {
// Implementation
libHash_HashInputData[libHash_HashInputSize] = lp_byte;
libHash_HashInputSize += 1;
}
void libHash_AddIntegerToHashInput (int lp_integer) {
// Implementation
libHash_AddByteToHashInput(lp_integer);
libHash_AddByteToHashInput(shift_right(lp_integer, 8));
libHash_AddByteToHashInput(shift_right(lp_integer, 16));
libHash_AddByteToHashInput(shift_right(lp_integer, 24));
}
void libHash_AddRealToHashInput (fixed lp_real) {
// Implementation
libHash_AddIntegerToHashInput(libHash_GetFixedDataAsInt( lp_real ));
}
void libHash_AddStringToHashInput (string lp_string) {
// Implementation
int i;
for (i = 0; i < StringLength(lp_string); i += 1) {
libHash_AddByteToHashInput(libHash_CharToAsciiCode( lp_string, i ));
}
}
void libHash_InitLib()
{
libHash_InitializeHashInput();
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment