md5calc.c

md5和sha-2的源码

/** #######################################
    MD5 Calculator
-- Static Space Used: 64 * 4  Bytes
###########################################
*/

#include "Md5Calc.h"

SZ_T Md5Calc_calcBlock( SZ_INT* DwordBufPtr, SZ_INT* regPtr );

static SZ_INT Md5Calc_t[ 64 ] = {
	0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 
	0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501, 
	0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, 
	0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,

	0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, 
	0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8, 
	0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
	0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,

	0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, 
	0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70, 
	0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,
	0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,

	0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
	0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
	0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
	0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
};

SZ_T  Md5Calc_init( Md5Calc* t ){
	return Md5Calc_reset( t );
}

SZ_T Md5Calc_uninit( Md5Calc* t ){ return RET_OK; }

SZ_T Md5Calc_reset( Md5Calc* t ){
	SZ_INT x;
	t->reg[0] = 0x67452301;
	t->reg[1] = 0xefcdab89;
	t->reg[2] = 0x98badcfe;
	t->reg[3] = 0x10325476;
	for( x = 0; x < 16; x ++ ){ t->Padding[ x ] = t->DwordBuf[ x ] = 0; }
	t->ByteNumLo = t->ByteNumHi = t->DwordBufBytes = 0;	
	return RET_OK;
}

SZ_T Md5Calc_calculate( Md5Calc* t, SZ_CHAR* dp, SZ_T dl ){
	SZ_INT w,x,y,z;
	SZ_INT reg[ 4 ];

	/** 
	   Set x, y, z, w 
	   x -- Dword Buffer Offset
	   y -- Bytes Offset in a Dword * 8
	   z -- Source Data Idx
	   w -- 64Bytes Block Number
	*/
	z = ( SZ_INT )(( t->ByteNumLo & 0x7fffffff ) + dl);
	x = (( t->ByteNumLo >> 31 ) & 0x01 ) + (( z >> 31 ) & 0x01 );
	z = ( z & 0x7fffffff ) | ( x << 31 );
	y = t->ByteNumHi + ( x >> 1 );
	if( y > 0x1fffffff ){ return RET_OVER_LIMIT; }

	t->ByteNumLo = z; 
	t->ByteNumHi = y;	

	for( w = 0; w < 16; w ++ ){ t->Padding[ w ] = t->DwordBuf[ w ]; }
	for( w = 0; w < 4; w ++ ){ reg[ w ] = t->reg[ w ]; }	
	x = t->DwordBufBytes / 4;
	y = ( t->DwordBufBytes & 3 ) * 8;
	w = ( SZ_INT )((( t->DwordBufBytes + dl ) >> 6 ) & 0x03ffffff );
	z = 0;

	/** 
	    64Bytes Full Blocks Loop
	*/
	while( w > 0 ){
		while( x < 16 ){
			t->Padding[ x ] = ( t->Padding[ x ] & ~( 0x000000ff << y )) | (( dp[ z ] & 0x000000ff ) << y );
			y = y + 8; x += ( y >> 5 ); y &= 0x1f; z ++; 
		}
		Md5Calc_calcBlock( t->Padding, reg );
		x = y = 0; w --;
	}
	
	/** Clear Dirty Data */
	if(( x | y ) == 0 ){
		for( w = 0; w < 16; w ++ ){ t->DwordBuf[ w ] = t->Padding[ w ] = 0; }
	}

	/** 
	   Last Blocks Loop 
	   z is how many bytes used. dl is bigger than z. 
	*/
	w = ( SZ_INT )( dl - z ); 
	while( w > 0 ){
		t->DwordBuf[ x ] = t->Padding[ x ] = 
			( t->Padding[ x ] & ~( 0x000000ff << y )) | (( dp[ z ] & 0x000000ff ) << y );
		y = y + 8; x += ( y >> 5 ); y &= 0x1f; z ++;
		w --;
	}

	/** Append 0x80 */
	t->Padding[ x ] |= 0x00000080 << y; 

	/** Save Old Value */
	for( w = 0; w < 4; w ++ ){ t->reg[ w ] = reg[ w ]; }
	
	/** Check if Length + 0x80 could append */
	t->DwordBufBytes =  x * 4  + ( y >> 3 );
	if( t->DwordBufBytes > 55 ){
		Md5Calc_calcBlock( t->Padding, reg );
		for( w = 0; w < 16; w ++ ){ t->Padding[ w ] = 0; }
	}

	/** Append Length */
	t->Padding[ 14 ] = t->ByteNumLo << 3;
	t->Padding[ 15 ] = (( t->ByteNumLo >> 29 ) & 0x3 ) | ( t->ByteNumHi << 3 );
	Md5Calc_calcBlock( t->Padding, reg );

	/** Output ordered Value -- Low Byte First Order */
	for( w = 0, x = 0; w < 16; w ++, x = ( x + 8 ) & 0x1f ){
		t->Value[ w ] = ( SZ_CHAR )( reg[ w >> 2 ] >> x );
	}

	return RET_OK;
}


/** Calculate 64 bytes block. and it return 16 bytes value */
SZ_T Md5Calc_calcBlock( SZ_INT* dp, SZ_INT* rp ){
	SZ_INT a,b,c,d,e;
	SZ_INT s,k,x;

	a = rp[0]; b = rp[1]; c = rp[2]; d = rp[3];
	
	/** Turn 1, F */
	s = 0x16110c07;
	for( x = 0; x < 16; x ++ ){
		e = ( b & c ) | ( ~b & d ); 
		k =  s & 0xff;
		s = (( s >> 8 ) & 0x00ffffff ) | ( s << 24 ); /** round shift right */
	
		e = a + e + dp[ x ] + Md5Calc_t[ x ];
		e = (( e >> ( 32 - k )) & ~((~0) << k ) ) | ( e << k );
		a = b + e;
		e = d; d = c; c = b; b = a; a = e;
	}

	/** Turn 2, G */
	s = 0x140e0905;
	for( x = 16; x < 32; x ++ ){
		e = ( b & d ) | ( c & ~d );
		k = s & 0xff; 
		s = (( s >> 8 ) & 0x00ffffff ) | ( s << 24 ); 

		e = a + e + dp[ (( x - 16 ) * 5 + 1 ) & 0x0f ] + Md5Calc_t[ x ];
		e = (( e >> ( 32 - k )) & ~((~0) << k ) ) | ( e << k );
		a = b + e;
		e = d; d = c; c = b; b = a; a = e;
	}

	/** Turn 3, H */
	s = 0x17100b04;
	for( x = 32; x < 48; x ++ ){
		e = b ^ c ^ d;
		k = s & 0xff; 
		s = (( s >> 8 ) & 0x00ffffff ) | ( s << 24 ); 

		e = a + e + dp[ (( x - 32 ) * 3 + 5 ) & 0x0f ] + Md5Calc_t[ x ];
		e = (( e >> ( 32 - k )) & ~((~0) << k ) ) | ( e << k );
		a = b + e;
		e = d; d = c; c = b; b = a; a = e;
	}

	/** Turn 4, I */
	s = 0x150f0a06;
	for( x = 48; x < 64; x ++ ){
		e = c ^ ( b | ~d );
		k = s & 0xff;
		s = (( s >> 8 ) & 0x00ffffff ) | ( s << 24 ); 

		e = a + e + dp[ (( x - 48 ) * 7 ) & 0x0f ] + Md5Calc_t[ x ];
		e = (( e >> ( 32 - k )) & ~((~0) << k )) | ( e << k );
		a = b + e;
		e = d; d = c; c = b; b = a; a = e;
	}

	rp[0] += a; rp[1] += b; rp[2] += c; rp[3] += d;

	return RET_OK;
}