323 lines
12 KiB
C
323 lines
12 KiB
C
/*
|
|
***********************************************************************
|
|
** md5.c **
|
|
** RSA Data Security, Inc. MD5 Message-Digest Algorithm **
|
|
** Created: 2/17/90 RLR **
|
|
** Revised: 1/91 SRD,AJ,BSK,JT Reference C Version **
|
|
***********************************************************************
|
|
*/
|
|
|
|
/*
|
|
***********************************************************************
|
|
** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved. **
|
|
** **
|
|
** License to copy and use this software is granted provided that **
|
|
** it is identified as the "RSA Data Security, Inc. MD5 Message- **
|
|
** Digest Algorithm" in all material mentioning or referencing this **
|
|
** software or this function. **
|
|
** **
|
|
** License is also granted to make and use derivative works **
|
|
** provided that such works are identified as "derived from the RSA **
|
|
** Data Security, Inc. MD5 Message-Digest Algorithm" in all **
|
|
** material mentioning or referencing the derived work. **
|
|
** **
|
|
** RSA Data Security, Inc. makes no representations concerning **
|
|
** either the merchantability of this software or the suitability **
|
|
** of this software for any particular purpose. It is provided "as **
|
|
** is" without express or implied warranty of any kind. **
|
|
** **
|
|
** These notices must be retained in any copies of any part of this **
|
|
** documentation and/or software. **
|
|
***********************************************************************
|
|
*/
|
|
|
|
// Portions copyright (c) 1992 Microsoft Corp.
|
|
// All rights reserved
|
|
|
|
//
|
|
// This copy of md5.c modified and adapted for my purposes, tommcg 6/28/96
|
|
// Copyright (C) 1996-1999, Microsoft Corporation.
|
|
//
|
|
|
|
|
|
#include "md5.h"
|
|
|
|
#ifndef PCUCHAR
|
|
typedef const unsigned char * PCUCHAR;
|
|
#endif
|
|
#ifndef PCULONG
|
|
typedef const unsigned long * PCULONG;
|
|
#endif
|
|
|
|
#include <stdlib.h> /* _rotl */
|
|
#include <memory.h> /* memcpy, memset */
|
|
|
|
#pragma intrinsic(memcpy, memset)
|
|
|
|
/* Constants for Transform routine. */
|
|
#define S11 7
|
|
#define S12 12
|
|
#define S13 17
|
|
#define S14 22
|
|
#define S21 5
|
|
#define S22 9
|
|
#define S23 14
|
|
#define S24 20
|
|
#define S31 4
|
|
#define S32 11
|
|
#define S33 16
|
|
#define S34 23
|
|
#define S41 6
|
|
#define S42 10
|
|
#define S43 15
|
|
#define S44 21
|
|
|
|
|
|
/* ROTATE_LEFT rotates x left n bits. */
|
|
|
|
#define ROTATE_LEFT(x, n) ((x << n) | (x >> (32 - n)))
|
|
|
|
//
|
|
// Intel and PowerPC both have a hardware rotate instruction with intrinsic
|
|
// (inline) function for them. Rough measurements show a 25% speed increase
|
|
// for Intel and 10% speed increase for PowerPC when using the instrinsic
|
|
// rotate versus the above defined shift/shift/or implemenation.
|
|
//
|
|
|
|
#if defined(_M_IX86) || defined(_M_PPC)
|
|
#undef ROTATE_LEFT
|
|
#define ROTATE_LEFT(x, n) _rotl(x, n)
|
|
#pragma intrinsic(_rotl)
|
|
#endif
|
|
|
|
|
|
/* F, G and H are basic MD5 functions */
|
|
#define F(x, y, z) ((x & y) | (~x & z))
|
|
#define G(x, y, z) ((x & z) | (y & ~z))
|
|
#define H(x, y, z) (x ^ y ^ z)
|
|
#define I(x, y, z) (y ^ (x | ~z))
|
|
|
|
|
|
/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4 */
|
|
/* Rotation is separate from addition to prevent recomputation */
|
|
#define FF(a, b, c, d, x, s, ac) \
|
|
a += F(b, c, d) + x + ac; \
|
|
a = ROTATE_LEFT(a, s); \
|
|
a += b;
|
|
|
|
#define GG(a, b, c, d, x, s, ac) \
|
|
a += G(b, c, d) + x + ac; \
|
|
a = ROTATE_LEFT(a, s); \
|
|
a += b;
|
|
|
|
#define HH(a, b, c, d, x, s, ac) \
|
|
a += H(b, c, d) + x + ac; \
|
|
a = ROTATE_LEFT(a, s); \
|
|
a += b;
|
|
|
|
#define II(a, b, c, d, x, s, ac) \
|
|
a += I(b, c, d) + x + ac; \
|
|
a = ROTATE_LEFT(a, s); \
|
|
a += b;
|
|
|
|
|
|
VOID
|
|
InitMD5(
|
|
IN OUT PMD5_HASH HashValue
|
|
)
|
|
{
|
|
HashValue->Word32[ 0 ] = 0x67452301;
|
|
HashValue->Word32[ 1 ] = 0xefcdab89;
|
|
HashValue->Word32[ 2 ] = 0x98badcfe;
|
|
HashValue->Word32[ 3 ] = 0x10325476;
|
|
}
|
|
|
|
VOID
|
|
UpdateMD5_64ByteChunk(
|
|
IN OUT PMD5_HASH HashValue, // existing hash value
|
|
IN PCVOID DataChunk // ULONG-aligned pointer to 64-byte message chunk
|
|
)
|
|
{
|
|
PCULONG MessageWord32 = DataChunk;
|
|
ULONG a = HashValue->Word32[ 0 ];
|
|
ULONG b = HashValue->Word32[ 1 ];
|
|
ULONG c = HashValue->Word32[ 2 ];
|
|
ULONG d = HashValue->Word32[ 3 ];
|
|
|
|
/* Round 1 */
|
|
FF ( a, b, c, d, MessageWord32[ 0 ], S11, 0xd76aa478 ) /* 1 */
|
|
FF ( d, a, b, c, MessageWord32[ 1 ], S12, 0xe8c7b756 ) /* 2 */
|
|
FF ( c, d, a, b, MessageWord32[ 2 ], S13, 0x242070db ) /* 3 */
|
|
FF ( b, c, d, a, MessageWord32[ 3 ], S14, 0xc1bdceee ) /* 4 */
|
|
FF ( a, b, c, d, MessageWord32[ 4 ], S11, 0xf57c0faf ) /* 5 */
|
|
FF ( d, a, b, c, MessageWord32[ 5 ], S12, 0x4787c62a ) /* 6 */
|
|
FF ( c, d, a, b, MessageWord32[ 6 ], S13, 0xa8304613 ) /* 7 */
|
|
FF ( b, c, d, a, MessageWord32[ 7 ], S14, 0xfd469501 ) /* 8 */
|
|
FF ( a, b, c, d, MessageWord32[ 8 ], S11, 0x698098d8 ) /* 9 */
|
|
FF ( d, a, b, c, MessageWord32[ 9 ], S12, 0x8b44f7af ) /* 10 */
|
|
FF ( c, d, a, b, MessageWord32[ 10 ], S13, 0xffff5bb1 ) /* 11 */
|
|
FF ( b, c, d, a, MessageWord32[ 11 ], S14, 0x895cd7be ) /* 12 */
|
|
FF ( a, b, c, d, MessageWord32[ 12 ], S11, 0x6b901122 ) /* 13 */
|
|
FF ( d, a, b, c, MessageWord32[ 13 ], S12, 0xfd987193 ) /* 14 */
|
|
FF ( c, d, a, b, MessageWord32[ 14 ], S13, 0xa679438e ) /* 15 */
|
|
FF ( b, c, d, a, MessageWord32[ 15 ], S14, 0x49b40821 ) /* 16 */
|
|
|
|
/* Round 2 */
|
|
GG ( a, b, c, d, MessageWord32[ 1 ], S21, 0xf61e2562 ) /* 17 */
|
|
GG ( d, a, b, c, MessageWord32[ 6 ], S22, 0xc040b340 ) /* 18 */
|
|
GG ( c, d, a, b, MessageWord32[ 11 ], S23, 0x265e5a51 ) /* 19 */
|
|
GG ( b, c, d, a, MessageWord32[ 0 ], S24, 0xe9b6c7aa ) /* 20 */
|
|
GG ( a, b, c, d, MessageWord32[ 5 ], S21, 0xd62f105d ) /* 21 */
|
|
GG ( d, a, b, c, MessageWord32[ 10 ], S22, 0x02441453 ) /* 22 */
|
|
GG ( c, d, a, b, MessageWord32[ 15 ], S23, 0xd8a1e681 ) /* 23 */
|
|
GG ( b, c, d, a, MessageWord32[ 4 ], S24, 0xe7d3fbc8 ) /* 24 */
|
|
GG ( a, b, c, d, MessageWord32[ 9 ], S21, 0x21e1cde6 ) /* 25 */
|
|
GG ( d, a, b, c, MessageWord32[ 14 ], S22, 0xc33707d6 ) /* 26 */
|
|
GG ( c, d, a, b, MessageWord32[ 3 ], S23, 0xf4d50d87 ) /* 27 */
|
|
GG ( b, c, d, a, MessageWord32[ 8 ], S24, 0x455a14ed ) /* 28 */
|
|
GG ( a, b, c, d, MessageWord32[ 13 ], S21, 0xa9e3e905 ) /* 29 */
|
|
GG ( d, a, b, c, MessageWord32[ 2 ], S22, 0xfcefa3f8 ) /* 30 */
|
|
GG ( c, d, a, b, MessageWord32[ 7 ], S23, 0x676f02d9 ) /* 31 */
|
|
GG ( b, c, d, a, MessageWord32[ 12 ], S24, 0x8d2a4c8a ) /* 32 */
|
|
|
|
/* Round 3 */
|
|
HH ( a, b, c, d, MessageWord32[ 5 ], S31, 0xfffa3942 ) /* 33 */
|
|
HH ( d, a, b, c, MessageWord32[ 8 ], S32, 0x8771f681 ) /* 34 */
|
|
HH ( c, d, a, b, MessageWord32[ 11 ], S33, 0x6d9d6122 ) /* 35 */
|
|
HH ( b, c, d, a, MessageWord32[ 14 ], S34, 0xfde5380c ) /* 36 */
|
|
HH ( a, b, c, d, MessageWord32[ 1 ], S31, 0xa4beea44 ) /* 37 */
|
|
HH ( d, a, b, c, MessageWord32[ 4 ], S32, 0x4bdecfa9 ) /* 38 */
|
|
HH ( c, d, a, b, MessageWord32[ 7 ], S33, 0xf6bb4b60 ) /* 39 */
|
|
HH ( b, c, d, a, MessageWord32[ 10 ], S34, 0xbebfbc70 ) /* 40 */
|
|
HH ( a, b, c, d, MessageWord32[ 13 ], S31, 0x289b7ec6 ) /* 41 */
|
|
HH ( d, a, b, c, MessageWord32[ 0 ], S32, 0xeaa127fa ) /* 42 */
|
|
HH ( c, d, a, b, MessageWord32[ 3 ], S33, 0xd4ef3085 ) /* 43 */
|
|
HH ( b, c, d, a, MessageWord32[ 6 ], S34, 0x04881d05 ) /* 44 */
|
|
HH ( a, b, c, d, MessageWord32[ 9 ], S31, 0xd9d4d039 ) /* 45 */
|
|
HH ( d, a, b, c, MessageWord32[ 12 ], S32, 0xe6db99e5 ) /* 46 */
|
|
HH ( c, d, a, b, MessageWord32[ 15 ], S33, 0x1fa27cf8 ) /* 47 */
|
|
HH ( b, c, d, a, MessageWord32[ 2 ], S34, 0xc4ac5665 ) /* 48 */
|
|
|
|
/* Round 4 */
|
|
II ( a, b, c, d, MessageWord32[ 0 ], S41, 0xf4292244 ) /* 49 */
|
|
II ( d, a, b, c, MessageWord32[ 7 ], S42, 0x432aff97 ) /* 50 */
|
|
II ( c, d, a, b, MessageWord32[ 14 ], S43, 0xab9423a7 ) /* 51 */
|
|
II ( b, c, d, a, MessageWord32[ 5 ], S44, 0xfc93a039 ) /* 52 */
|
|
II ( a, b, c, d, MessageWord32[ 12 ], S41, 0x655b59c3 ) /* 53 */
|
|
II ( d, a, b, c, MessageWord32[ 3 ], S42, 0x8f0ccc92 ) /* 54 */
|
|
II ( c, d, a, b, MessageWord32[ 10 ], S43, 0xffeff47d ) /* 55 */
|
|
II ( b, c, d, a, MessageWord32[ 1 ], S44, 0x85845dd1 ) /* 56 */
|
|
II ( a, b, c, d, MessageWord32[ 8 ], S41, 0x6fa87e4f ) /* 57 */
|
|
II ( d, a, b, c, MessageWord32[ 15 ], S42, 0xfe2ce6e0 ) /* 58 */
|
|
II ( c, d, a, b, MessageWord32[ 6 ], S43, 0xa3014314 ) /* 59 */
|
|
II ( b, c, d, a, MessageWord32[ 13 ], S44, 0x4e0811a1 ) /* 60 */
|
|
II ( a, b, c, d, MessageWord32[ 4 ], S41, 0xf7537e82 ) /* 61 */
|
|
II ( d, a, b, c, MessageWord32[ 11 ], S42, 0xbd3af235 ) /* 62 */
|
|
II ( c, d, a, b, MessageWord32[ 2 ], S43, 0x2ad7d2bb ) /* 63 */
|
|
II ( b, c, d, a, MessageWord32[ 9 ], S44, 0xeb86d391 ) /* 64 */
|
|
|
|
HashValue->Word32[ 0 ] += a;
|
|
HashValue->Word32[ 1 ] += b;
|
|
HashValue->Word32[ 2 ] += c;
|
|
HashValue->Word32[ 3 ] += d;
|
|
}
|
|
|
|
|
|
VOID
|
|
FinalizeMD5(
|
|
IN OUT PMD5_HASH HashValue,
|
|
IN PCVOID RemainingData, // remaining data to hash
|
|
IN ULONG RemainingBytes, // 0 <= RemainingBytes < 64
|
|
IN ULONGLONG TotalBytesHashed // total bytes hashed
|
|
)
|
|
{
|
|
union {
|
|
ULONGLONG Qword[ 8 ];
|
|
UCHAR Byte [ 64 ];
|
|
} LocalBuffer;
|
|
|
|
//
|
|
// Always append a pad byte of 0x80 to the message.
|
|
//
|
|
// If RemainingBytes is less than (but not equal to) 56 bytes, then
|
|
// the final bits hashed count will be stored in the last 8 bytes of
|
|
// this 64 byte hash chunk.
|
|
//
|
|
// If RemainingBytes is exactly 56 bytes, the appended 0x80 pad byte
|
|
// will force an extra chunk.
|
|
//
|
|
// If RemainingBytes is greater than or equal to 56 bytes, then the
|
|
// final bits hashed count will be stored in the last 8 bytes of the
|
|
// NEXT 64 byte chunk that is otherwise zeroed, so THIS chunk needs to
|
|
// be zero-padded beyond the first pad byte and then hashed, then zero
|
|
// the first 56 bytes of the LocalBuffer for the NEXT chunk hash.
|
|
//
|
|
|
|
RemainingBytes &= 63; // only care about partial frames
|
|
|
|
//
|
|
// Zero init local buffer.
|
|
//
|
|
|
|
memset( &LocalBuffer, 0, 64 );
|
|
|
|
//
|
|
// Append 0x80 pad byte to message.
|
|
//
|
|
|
|
LocalBuffer.Byte[ RemainingBytes ] = 0x80;
|
|
|
|
if ( RemainingBytes > 0 ) {
|
|
|
|
//
|
|
// Copy remaining data bytes (0 < RemainingBytes < 64) to LocalBuffer
|
|
// (remainder of LocalBuffer already zeroed except for pad byte).
|
|
//
|
|
|
|
memcpy( &LocalBuffer, RemainingData, RemainingBytes );
|
|
|
|
if ( RemainingBytes >= 56 ) {
|
|
|
|
UpdateMD5_64ByteChunk( HashValue, &LocalBuffer );
|
|
|
|
memset( &LocalBuffer, 0, 56 );
|
|
|
|
}
|
|
}
|
|
|
|
//
|
|
// Number of BITS hashed goes into last 8 bytes of last chunk. This
|
|
// is a 64-bit value. Note that if the number of BITS exceeds 2^64
|
|
// then this number is the low order 64 bits of the result.
|
|
///
|
|
|
|
LocalBuffer.Qword[ 7 ] = ( TotalBytesHashed * 8 ); // number of BITS
|
|
|
|
UpdateMD5_64ByteChunk( HashValue, &LocalBuffer );
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
ComputeCompleteMD5(
|
|
IN PCVOID DataBuffer,
|
|
IN ULONGLONG DataLength,
|
|
OUT PMD5_HASH HashValue
|
|
)
|
|
{
|
|
PCUCHAR DataPointer = DataBuffer;
|
|
ULONGLONG ChunkCount = DataLength / 64;
|
|
ULONG OddBytes = (ULONG)DataLength & 63;
|
|
|
|
InitMD5( HashValue );
|
|
|
|
while ( ChunkCount-- ) {
|
|
UpdateMD5_64ByteChunk( HashValue, DataPointer );
|
|
DataPointer += 64;
|
|
}
|
|
|
|
FinalizeMD5( HashValue, DataPointer, OddBytes, DataLength );
|
|
}
|
|
|
|
|