From 6e4a285f3b2d6a4f8a29ac0004e31e5b22993001 Mon Sep 17 00:00:00 2001 From: Dmitry Kuzkin Date: Wed, 11 Jul 2012 10:10:55 +0000 Subject: version 2.0 + exclude from calculation debug information and timestamps in debug and export entries + print to stdout only filename+hash + support for wildcards and stdin input + remove mir_core.dll dependency git-svn-id: http://svn.miranda-ng.org/main/trunk@898 1316c22d-e87f-b044-9b9b-93d7a3e3ba9c --- tools/checksum/checksum.cpp | 370 +++++++++++++++++++++++++------------ tools/checksum/checksum_10.vcxproj | 4 + tools/checksum/commonheaders.h | 32 ++++ tools/checksum/make.bat | 2 +- tools/checksum/md5.cpp | 358 +++++++++++++++++++++++++++++++++++ 5 files changed, 643 insertions(+), 123 deletions(-) create mode 100644 tools/checksum/commonheaders.h create mode 100644 tools/checksum/md5.cpp (limited to 'tools/checksum') diff --git a/tools/checksum/checksum.cpp b/tools/checksum/checksum.cpp index 1dce5c3052..13d13eb9ae 100644 --- a/tools/checksum/checksum.cpp +++ b/tools/checksum/checksum.cpp @@ -1,21 +1,12 @@ // Checksum Tool -// Version 1.0 // By Bio (C) 2012 -#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers +#define _VERSION_ "2.0" -#include -#include -#include -#include - -#include - -#define DEBUG_MSGS 1 -#define DEBUG_ARCH 1 -// #define DEBUG_SECTIONS 1 +#include "commonheaders.h" +//#define DEBUG_SECTIONS 1 // Return codes #define RESULT_OK 0 @@ -27,16 +18,16 @@ #define RESULT_NONE 100 -int PEChecksum(TCHAR *filename, mir_md5_byte_t digest[16]) +int PEChecksum( TCHAR *filename, mir_md5_byte_t digest[16] ) { HANDLE hFile = INVALID_HANDLE_VALUE; HANDLE hMap; PBYTE ptr = 0; - int res = RESULT_OK; - DWORD size; - DWORD hsize = 0; + int res = RESULT_OK; + DWORD filesize; + DWORD hsize = 0; - WORD machine = 0; + WORD machine = 0; DWORD sections = 0; hFile = CreateFile( filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL ); @@ -46,30 +37,29 @@ int PEChecksum(TCHAR *filename, mir_md5_byte_t digest[16]) } // check minimum and maximum size - size = GetFileSize(hFile, &hsize); + filesize = GetFileSize( hFile, &hsize ); - if ( !size || size == INVALID_FILE_SIZE || hsize ) + if ( !filesize || filesize == INVALID_FILE_SIZE || hsize ) { CloseHandle( hFile ); - return RESULT_INVALID; + return RESULT_INVALID; } - if ( size < sizeof(IMAGE_DOS_HEADER) + sizeof(IMAGE_NT_HEADERS) ) + if ( filesize < sizeof(IMAGE_DOS_HEADER) + sizeof(IMAGE_NT_HEADERS) ) { CloseHandle( hFile ); - return RESULT_NOTPE; + return RESULT_NOTPE; } - hMap = CreateFileMapping( hFile, NULL, PAGE_READONLY, 0, 0, NULL ); + hMap = CreateFileMapping( hFile, NULL, PAGE_WRITECOPY, 0, 0, NULL ); - if (hMap) - ptr = (PBYTE)MapViewOfFile(hMap, FILE_MAP_READ, 0, 0 ,0); + if ( hMap ) + ptr = (PBYTE)MapViewOfFile( hMap, FILE_MAP_COPY, 0, 0 ,0 ); - if (ptr) + if ( ptr ) { PIMAGE_DOS_HEADER pIDH = 0; PIMAGE_NT_HEADERS pINTH = 0; - PIMAGE_SECTION_HEADER pISH = 0; pIDH = (PIMAGE_DOS_HEADER)ptr; @@ -79,7 +69,7 @@ int PEChecksum(TCHAR *filename, mir_md5_byte_t digest[16]) if ( !pINTH) res = RESULT_NOTPE; else - if ( (PBYTE)pINTH + sizeof(IMAGE_NT_HEADERS) >= ptr + size ) + if ( (PBYTE)pINTH + sizeof(IMAGE_NT_HEADERS) >= ptr + filesize ) res = RESULT_CORRUPTED; else if ( pINTH->Signature != IMAGE_NT_SIGNATURE ) @@ -87,68 +77,152 @@ int PEChecksum(TCHAR *filename, mir_md5_byte_t digest[16]) else { machine = pINTH->FileHeader.Machine; - -#if defined(DEBUG_ARCH) && defined(DEBUG_MSGS) - switch(machine) - { - case IMAGE_FILE_MACHINE_I386: - fprintf( stdout, "(x86) "); - break; - case IMAGE_FILE_MACHINE_AMD64: - fprintf( stdout, "(x64) "); - break; - case IMAGE_FILE_MACHINE_IA64: - fprintf( stdout, "(IA64 :-) "); - break; - default: - fprintf( stdout, "(unknown) "); +/* + switch(machine) + { + case IMAGE_FILE_MACHINE_I386: + _ftprintf( stderr, _T("(x86) ") ); + break; + case IMAGE_FILE_MACHINE_AMD64: + _ftprintf( stderr, _T("(x64) ") ); + break; + case IMAGE_FILE_MACHINE_IA64: + _ftprintf( stderr, _T("(IA64 :-) ") ); break; - } -#endif + default: + _ftprintf( stderr, _T("(unknown) ") ); + break; + } +*/ sections = pINTH->FileHeader.NumberOfSections; if ( !sections ) res = RESULT_INVALID; else { - DWORD idx = 0; - mir_md5_state_t pms; - - mir_md5_init( &pms ); - -#if defined(DEBUG_SECTIONS) && defined(DEBUG_MSGS) - fprintf( stdout, "\n" ); -#endif - // try to found correct offset independent of architectures - DWORD offset = pIDH->e_lfanew + pINTH->FileHeader.SizeOfOptionalHeader + sizeof(IMAGE_NT_HEADERS) - sizeof(IMAGE_OPTIONAL_HEADER); + PIMAGE_DATA_DIRECTORY pIDD = 0; + DWORD dbgsize = 0; + DWORD dbgvaddr = 0; + DWORD expsize = 0; + DWORD expvaddr = 0; + + if ( ( machine == IMAGE_FILE_MACHINE_I386 ) && + ( pINTH->FileHeader.SizeOfOptionalHeader >= sizeof(IMAGE_OPTIONAL_HEADER32) ) && + ( pINTH->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC ) ) + { + pIDD = (PIMAGE_DATA_DIRECTORY)( (PBYTE)pINTH + offsetof( IMAGE_NT_HEADERS32, OptionalHeader.DataDirectory ) ); + } + else + if ( ( machine == IMAGE_FILE_MACHINE_AMD64 ) && + ( pINTH->FileHeader.SizeOfOptionalHeader >= sizeof(IMAGE_OPTIONAL_HEADER64) ) && + ( pINTH->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC ) ) + { - while ( idx < sections ) + pIDD = (PIMAGE_DATA_DIRECTORY)( (PBYTE)pINTH + offsetof( IMAGE_NT_HEADERS64, OptionalHeader.DataDirectory ) ); + } + else + res = RESULT_CORRUPTED; + + if ( pIDD ) + { + // Debugging information entry + dbgvaddr = pIDD[IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress; + dbgsize = pIDD[IMAGE_DIRECTORY_ENTRY_DEBUG].Size; + + // Export information entry + expvaddr = pIDD[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress; + expsize = pIDD[IMAGE_DIRECTORY_ENTRY_EXPORT].Size; + } + + if ( res == RESULT_OK ) { - pISH = (PIMAGE_SECTION_HEADER)( ptr + offset + idx * sizeof(IMAGE_SECTION_HEADER) ); - - if ( (PBYTE)pISH + sizeof(IMAGE_SECTION_HEADER) > ptr + size ) - { - res = RESULT_CORRUPTED; - break; - } - - if ( pISH->PointerToRawData + pISH->SizeOfRawData > size ) - { - res = RESULT_CORRUPTED; - break; - } - -#if defined(DEBUG_SECTIONS) && defined(DEBUG_MSGS) - fprintf( stdout, "%s - %d - %d \n", pISH->Name, pISH->PointerToRawData, pISH->SizeOfRawData); + PIMAGE_SECTION_HEADER pISH = 0; + DWORD offset; + DWORD idx = 0; + mir_md5_state_t pms; + + mir_md5_init( &pms ); + + // try to found correct offset independent of architectures + offset = pIDH->e_lfanew + pINTH->FileHeader.SizeOfOptionalHeader + sizeof(IMAGE_NT_HEADERS) - sizeof(IMAGE_OPTIONAL_HEADER); + + while ( idx < sections ) + { + pISH = (PIMAGE_SECTION_HEADER)( ptr + offset + idx * sizeof(IMAGE_SECTION_HEADER) ); + + if ( (PBYTE)pISH + sizeof(IMAGE_SECTION_HEADER) > ptr + filesize ) + { + res = RESULT_CORRUPTED; + break; + } + + if ( pISH->PointerToRawData + pISH->SizeOfRawData > filesize ) + { + res = RESULT_CORRUPTED; + break; + } + +#ifdef DEBUG_SECTIONS + _ftprintf( stderr, _T("%s - %08X - %d "), pISH->Name, pISH->PointerToRawData, pISH->SizeOfRawData); + + { + int i; + mir_md5_byte_t digest2[16]; + mir_md5_state_t pms2; + + mir_md5_init( &pms2 ); + mir_md5_append( &pms2, ptr + pISH->PointerToRawData, pISH->SizeOfRawData ); + mir_md5_finish( &pms2, digest2 ); + + for ( i = 0; i < sizeof( digest2 ) / sizeof( digest2[0] ); i++ ) + _ftprintf( stderr, _T("%02X"), digest2[i] ); + _ftprintf( stderr, _T("\n") ); + } +#endif + // erase timestamp and debug information + if (( dbgsize >= sizeof( IMAGE_DEBUG_DIRECTORY ) ) && + ( dbgvaddr >= pISH->VirtualAddress ) && + ( dbgvaddr + dbgsize <= pISH->VirtualAddress + pISH->SizeOfRawData ) ) + { + DWORD shift = dbgvaddr - pISH->VirtualAddress; + PIMAGE_DEBUG_DIRECTORY pDBG = (PIMAGE_DEBUG_DIRECTORY)( ptr + shift + pISH->PointerToRawData ); + + pDBG->TimeDateStamp = 0; +#ifdef DEBUG_SECTIONS + _ftprintf( stderr, _T("found debug section entry %08X ( %d ), data %08X ( %d ) \n"), pISH->PointerToRawData + shift, dbgsize, pDBG->PointerToRawData, pDBG->SizeOfData ); +#endif + if ( pDBG->SizeOfData > 0 && + ( pDBG->PointerToRawData >= pISH->PointerToRawData ) && + ( pDBG->PointerToRawData + pDBG->SizeOfData <= pISH->PointerToRawData + pISH->SizeOfRawData ) ) + { + ZeroMemory( ptr + pDBG->PointerToRawData, pDBG->SizeOfData ); + } + + //ZeroMemory( ptr + pISH->PointerToRawData + shift, dbgsize ); + } + + // erase export timestamp + if (( expsize >= sizeof( IMAGE_EXPORT_DIRECTORY ) ) && + ( expvaddr >= pISH->VirtualAddress ) && + ( expvaddr + expsize <= pISH->VirtualAddress + pISH->SizeOfRawData ) ) + { + DWORD shift = expvaddr - pISH->VirtualAddress; + PIMAGE_EXPORT_DIRECTORY pEXP = (PIMAGE_EXPORT_DIRECTORY)( ptr + shift + pISH->PointerToRawData ); + + pEXP->TimeDateStamp = 0; +#ifdef DEBUG_SECTIONS + _ftprintf( stderr, _T("found export section entry %08X\n"), pISH->PointerToRawData + shift ); #endif - mir_md5_append( &pms, ptr + pISH->PointerToRawData, pISH->SizeOfRawData ); + } - idx++; - } + mir_md5_append( &pms, ptr + pISH->PointerToRawData, pISH->SizeOfRawData ); - if ( res == RESULT_OK ) - mir_md5_finish( &pms, digest ); + idx++; + } + if ( res == RESULT_OK ) + mir_md5_finish( &pms, digest ); + } } } } @@ -167,66 +241,118 @@ int PEChecksum(TCHAR *filename, mir_md5_byte_t digest[16]) } -int main( int argc, char** argv ) +TCHAR* trtrim( TCHAR *str ) +{ + if ( str == NULL ) + return NULL; + + TCHAR* p = _tcschr( str, 0 ); + while ( --p >= str ) + { + switch ( *p ) + { + case L' ': case L'\t': case L'\n': case L'\r': + *p = 0; break; + default: + return str; + } + } + return str; +} + + +int process(TCHAR *filename) { - mir_md5_byte_t digest[16] = {0}; - int res = 0; + int res; + mir_md5_byte_t digest[16] = {0}; + + res = PEChecksum( filename, digest); + + switch(res) + { + case RESULT_NOTFOUND: + _ftprintf( stderr, _T("'%s'... not found!\n"), filename ); + break; + case RESULT_READERROR: + _ftprintf( stderr, _T("'%s'... read error!\n"), filename ); + break; + case RESULT_NOTPE: + _ftprintf( stderr, _T("'%s'... not PE type!\n"), filename ); + break; + case RESULT_CORRUPTED: + _ftprintf( stderr, _T("'%s'... corrupted!\n"), filename ); + break; + case RESULT_OK: + { + int i; + _ftprintf( stdout, _T("%s "), filename ); + for ( i = 0; i < sizeof( digest ) / sizeof( digest[0] ); i++ ) + _ftprintf( stdout, _T("%02X"), digest[i] ); + _ftprintf( stdout, _T("\n") ); + break; + } + default: + break; + } + return res; +} + + +int _tmain( int argc, TCHAR *argv[] ) +{ + TCHAR buf[ MAX_PATH ]; + int res = 0; + int cnt = 0; + + _ftprintf( stderr, _T("* PE CHECKSUM TOOL * VERSION %s\n\n"), _VERSION_ ); if ( argc > 1 ) { + WIN32_FIND_DATA ffd; + HANDLE hFind = INVALID_HANDLE_VALUE; + + _ftprintf( stderr, _T("Processing ... \n") ); + for ( int i=1; i < argc; i++ ) { -#ifdef DEBUG_MSGS - fprintf( stdout, "Processing '%s'... ", argv[ i ] ); -#endif - res = PEChecksum( argv[ i ], digest); + hFind = FindFirstFile( argv[i], &ffd ); - switch(res) - { -#ifdef DEBUG_MSGS - case RESULT_NOTFOUND: - { - fprintf( stdout, "not found!\n"); - break; - } - case RESULT_READERROR: - { - fprintf( stdout, "read error!\n"); - break; - } - case RESULT_NOTPE: - { - fprintf( stdout, "not PE type!\n"); - break; - } - case RESULT_CORRUPTED: - { - fprintf( stdout, "corrupted\n"); - break; + while( hFind != INVALID_HANDLE_VALUE ) + { + if ( ! ( ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) ) + { + res = process( ffd.cFileName ); + cnt++; } -#endif - case RESULT_OK: - { - int i; - for ( i = 0; i < sizeof(digest) / sizeof(digest[0]); i++ ) - fprintf( stdout, "%02X", digest[i] ); - } // no break - default: - { - fprintf( stdout, "\n"); + if ( !FindNextFile( hFind, &ffd ) ) break; - } } + + FindClose( hFind ); } + _ftprintf( stderr, _T("%d file(s) processed.\n"), cnt ); } else { - fprintf( stderr, "PE CHECKSUM TOOL v1.0\n\n" ); - fprintf( stderr, "Usage: checksum.exe [filename] ... [filename]\n"); - fprintf( stderr, "Output: MD5 checksum of all sections in PE file.\n"); - return RESULT_NONE; + while ( _fgetts( buf, sizeof( buf ), stdin ) != NULL ) + { + if ( !cnt ) + _ftprintf( stderr, _T("Processing ... \n") ); + trtrim( buf ); + res = process( buf ); + cnt++; + } + + if ( cnt ) + _ftprintf( stderr, _T("%d file(s) processed.\n"), cnt ); + else + { + _ftprintf( stderr, _T("Usage: checksum.exe [*.dll] ... [*.exe]\n") ); + _ftprintf( stderr, _T("Example: dir /b /s | checksum.exe > hashes.txt\n") ); + res = RESULT_NONE; + } } return res; -} \ No newline at end of file +} diff --git a/tools/checksum/checksum_10.vcxproj b/tools/checksum/checksum_10.vcxproj index 2a46c76f84..45e051e7b0 100644 --- a/tools/checksum/checksum_10.vcxproj +++ b/tools/checksum/checksum_10.vcxproj @@ -20,6 +20,10 @@ + + + + CheckSum diff --git a/tools/checksum/commonheaders.h b/tools/checksum/commonheaders.h new file mode 100644 index 0000000000..dcd24ecf1b --- /dev/null +++ b/tools/checksum/commonheaders.h @@ -0,0 +1,32 @@ + +#define WINVER 0x0700 +#define _WIN32_WINNT 0x0700 + + +#include +#include +#include +#include +#include +#include + +// #include + +// mir_core hack for MD5 +#define MIR_CORE_DLL(T) T __cdecl + + +/* Define the state of the MD5 Algorithm. */ +typedef unsigned char mir_md5_byte_t; /* 8-bit byte */ +typedef unsigned int mir_md5_word_t; /* 32-bit word */ + +typedef struct mir_md5_state_s { + mir_md5_word_t count[2]; /* message length in bits, lsw first */ + mir_md5_word_t abcd[4]; /* digest buffer */ + mir_md5_byte_t buf[64]; /* accumulate block */ +} mir_md5_state_t; + +MIR_CORE_DLL(void) mir_md5_init(mir_md5_state_t *pms); +MIR_CORE_DLL(void) mir_md5_append(mir_md5_state_t *pms, const mir_md5_byte_t *data, int nbytes); +MIR_CORE_DLL(void) mir_md5_finish(mir_md5_state_t *pms, mir_md5_byte_t digest[16]); +MIR_CORE_DLL(void) mir_md5_hash(const mir_md5_byte_t *data, int len, mir_md5_byte_t digest[16]); diff --git a/tools/checksum/make.bat b/tools/checksum/make.bat index ade2bb93d8..54a612b9d1 100644 --- a/tools/checksum/make.bat +++ b/tools/checksum/make.bat @@ -1 +1 @@ -@cl /MD /Fe../../bin10/Release/checksum.exe checksum.cpp ../../bin10/lib/mir_core.lib /link /filealign:512 \ No newline at end of file +@cl /MD /Fe../../bin10/checksum.exe md5.cpp checksum.cpp /link /filealign:512 diff --git a/tools/checksum/md5.cpp b/tools/checksum/md5.cpp new file mode 100644 index 0000000000..a7d7a641e3 --- /dev/null +++ b/tools/checksum/md5.cpp @@ -0,0 +1,358 @@ +/* + Copyright (C) 1999, 2000, 2002 Aladdin Enterprises. All rights reserved. + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + L. Peter Deutsch + ghost@aladdin.com + + */ +/* $Id: md5.c 2874 2006-05-16 21:38:00Z ghazan $ */ +/* + Independent implementation of MD5 (RFC 1321). + + This code implements the MD5 Algorithm defined in RFC 1321, whose + text is available at + http://www.ietf.org/rfc/rfc1321.txt + The code is derived from the text of the RFC, including the test suite + (section A.5) but excluding the rest of Appendix A. It does not include + any code or documentation that is identified in the RFC as being + copyrighted. + + The original and principal author of md5.c is L. Peter Deutsch + . Other authors are noted in the change history + that follows (in reverse chronological order): + + 2002-04-13 lpd Clarified derivation from RFC 1321; now handles byte order + either statically or dynamically; added missing #include + in library. + 2002-03-11 lpd Corrected argument list for main(), and added int return + type, in test program and T value program. + 2002-02-21 lpd Added missing #include in test program. + 2000-07-03 lpd Patched to eliminate warnings about "constant is + unsigned in ANSI C, signed in traditional"; made test program + self-checking. + 1999-11-04 lpd Edited comments slightly for automatic TOC extraction. + 1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5). + 1999-05-03 lpd Original version. + */ + +// (C) 2005 Joe @ Whale - changed to compile with Miranda + +#include "commonheaders.h" + +#define T_MASK ((mir_md5_word_t)~0) +#define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87) +#define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9) +#define T3 0x242070db +#define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111) +#define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050) +#define T6 0x4787c62a +#define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec) +#define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe) +#define T9 0x698098d8 +#define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850) +#define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e) +#define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841) +#define T13 0x6b901122 +#define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c) +#define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71) +#define T16 0x49b40821 +#define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d) +#define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf) +#define T19 0x265e5a51 +#define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855) +#define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2) +#define T22 0x02441453 +#define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e) +#define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437) +#define T25 0x21e1cde6 +#define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829) +#define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278) +#define T28 0x455a14ed +#define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa) +#define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07) +#define T31 0x676f02d9 +#define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375) +#define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd) +#define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e) +#define T35 0x6d9d6122 +#define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3) +#define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb) +#define T38 0x4bdecfa9 +#define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f) +#define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f) +#define T41 0x289b7ec6 +#define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805) +#define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a) +#define T44 0x04881d05 +#define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6) +#define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a) +#define T47 0x1fa27cf8 +#define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a) +#define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb) +#define T50 0x432aff97 +#define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58) +#define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6) +#define T53 0x655b59c3 +#define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d) +#define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82) +#define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e) +#define T57 0x6fa87e4f +#define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f) +#define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb) +#define T60 0x4e0811a1 +#define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d) +#define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca) +#define T63 0x2ad7d2bb +#define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e) + +//gfd* +static void md5_process(mir_md5_state_t *pms, const mir_md5_byte_t *data /*[64]*/) +{ + mir_md5_word_t + a = pms->abcd[0], b = pms->abcd[1], + c = pms->abcd[2], d = pms->abcd[3]; + mir_md5_word_t t; + /* Define storage for little-endian or both types of CPUs. */ + mir_md5_word_t xbuf[16]; + const mir_md5_word_t *X; + + { + /* + * Determine dynamically whether this is a big-endian or + * little-endian machine, since we can use a more efficient + * algorithm on the latter. + */ + static const int w = 1; + + if (*((const mir_md5_byte_t *)&w)) /* dynamic little-endian */ + { + /* + * On little-endian machines, we can process properly aligned + * data without copying it. + */ + if ( !((data - (const mir_md5_byte_t *)0) & 3)) { + /* data are properly aligned */ + X = (const mir_md5_word_t *)data; + } else { + /* not aligned */ + memcpy(xbuf, data, 64); + X = xbuf; + } + } + else /* dynamic big-endian */ + { + /* + * On big-endian machines, we must arrange the bytes in the + * right order. + */ + const mir_md5_byte_t *xp = data; + int i; + + X = xbuf; /* (dynamic only) */ + for (i = 0; i < 16; ++i, xp += 4) + xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24); + } + } + +#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 SET1(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. */ + SET1(a, b, c, d, 0, 7, T1); + SET1(d, a, b, c, 1, 12, T2); + SET1(c, d, a, b, 2, 17, T3); + SET1(b, c, d, a, 3, 22, T4); + SET1(a, b, c, d, 4, 7, T5); + SET1(d, a, b, c, 5, 12, T6); + SET1(c, d, a, b, 6, 17, T7); + SET1(b, c, d, a, 7, 22, T8); + SET1(a, b, c, d, 8, 7, T9); + SET1(d, a, b, c, 9, 12, T10); + SET1(c, d, a, b, 10, 17, T11); + SET1(b, c, d, a, 11, 22, T12); + SET1(a, b, c, d, 12, 7, T13); + SET1(d, a, b, c, 13, 12, T14); + SET1(c, d, a, b, 14, 17, T15); + SET1(b, c, d, a, 15, 22, T16); + + /* 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 SET2(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. */ + SET2(a, b, c, d, 1, 5, T17); + SET2(d, a, b, c, 6, 9, T18); + SET2(c, d, a, b, 11, 14, T19); + SET2(b, c, d, a, 0, 20, T20); + SET2(a, b, c, d, 5, 5, T21); + SET2(d, a, b, c, 10, 9, T22); + SET2(c, d, a, b, 15, 14, T23); + SET2(b, c, d, a, 4, 20, T24); + SET2(a, b, c, d, 9, 5, T25); + SET2(d, a, b, c, 14, 9, T26); + SET2(c, d, a, b, 3, 14, T27); + SET2(b, c, d, a, 8, 20, T28); + SET2(a, b, c, d, 13, 5, T29); + SET2(d, a, b, c, 2, 9, T30); + SET2(c, d, a, b, 7, 14, T31); + SET2(b, c, d, a, 12, 20, T32); + + /* 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 SET3(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. */ + SET3(a, b, c, d, 5, 4, T33); + SET3(d, a, b, c, 8, 11, T34); + SET3(c, d, a, b, 11, 16, T35); + SET3(b, c, d, a, 14, 23, T36); + SET3(a, b, c, d, 1, 4, T37); + SET3(d, a, b, c, 4, 11, T38); + SET3(c, d, a, b, 7, 16, T39); + SET3(b, c, d, a, 10, 23, T40); + SET3(a, b, c, d, 13, 4, T41); + SET3(d, a, b, c, 0, 11, T42); + SET3(c, d, a, b, 3, 16, T43); + SET3(b, c, d, a, 6, 23, T44); + SET3(a, b, c, d, 9, 4, T45); + SET3(d, a, b, c, 12, 11, T46); + SET3(c, d, a, b, 15, 16, T47); + SET3(b, c, d, a, 2, 23, T48); + + /* 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 SET4(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. */ + SET4(a, b, c, d, 0, 6, T49); + SET4(d, a, b, c, 7, 10, T50); + SET4(c, d, a, b, 14, 15, T51); + SET4(b, c, d, a, 5, 21, T52); + SET4(a, b, c, d, 12, 6, T53); + SET4(d, a, b, c, 3, 10, T54); + SET4(c, d, a, b, 10, 15, T55); + SET4(b, c, d, a, 1, 21, T56); + SET4(a, b, c, d, 8, 6, T57); + SET4(d, a, b, c, 15, 10, T58); + SET4(c, d, a, b, 6, 15, T59); + SET4(b, c, d, a, 13, 21, T60); + SET4(a, b, c, d, 4, 6, T61); + SET4(d, a, b, c, 11, 10, T62); + SET4(c, d, a, b, 2, 15, T63); + SET4(b, c, d, a, 9, 21, T64); + + /* Then perform the following additions. (That is increment each + of the four registers by the value it had before this block + was started.) */ + pms->abcd[0] += a; + pms->abcd[1] += b; + pms->abcd[2] += c; + pms->abcd[3] += d; +} + +MIR_CORE_DLL(void) mir_md5_init(mir_md5_state_t *pms) +{ + pms->count[0] = pms->count[1] = 0; + pms->abcd[0] = 0x67452301; + pms->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476; + pms->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301; + pms->abcd[3] = 0x10325476; +} + +MIR_CORE_DLL(void) mir_md5_append(mir_md5_state_t *pms, const mir_md5_byte_t *data, int nbytes) +{ + const mir_md5_byte_t *p = data; + int left = nbytes; + int offset = (pms->count[0] >> 3) & 63; + mir_md5_word_t nbits = (mir_md5_word_t)(nbytes << 3); + + if (nbytes <= 0) + return; + + /* Update the message length. */ + pms->count[1] += nbytes >> 29; + pms->count[0] += nbits; + if (pms->count[0] < nbits) + pms->count[1]++; + + /* Process an initial partial block. */ + if (offset) { + int copy = (offset + nbytes > 64 ? 64 - offset : nbytes); + + memcpy(pms->buf + offset, p, copy); + if (offset + copy < 64) + return; + p += copy; + left -= copy; + md5_process(pms, pms->buf); + } + + /* Process full blocks. */ + for (; left >= 64; p += 64, left -= 64) + md5_process(pms, p); + + /* Process a final partial block. */ + if (left) + memcpy(pms->buf, p, left); +} + +MIR_CORE_DLL(void) mir_md5_finish(mir_md5_state_t *pms, mir_md5_byte_t digest[16]) +{ + static const mir_md5_byte_t pad[64] = { + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }; + mir_md5_byte_t data[8]; + int i; + + /* Save the length before padding. */ + for (i = 0; i < 8; ++i) + data[i] = (mir_md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3)); + /* Pad to 56 bytes mod 64. */ + mir_md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1); + /* Append the length. */ + mir_md5_append(pms, data, 8); + for (i = 0; i < 16; ++i) + digest[i] = (mir_md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3)); +} + +MIR_CORE_DLL(void) mir_md5_hash(const mir_md5_byte_t *data, int len, mir_md5_byte_t digest[16]) +{ + mir_md5_state_t state; + mir_md5_init(&state); + mir_md5_append(&state, data, len); + mir_md5_finish(&state, digest); +} -- cgit v1.2.3