sha1calc.c

md5和sha-2的源码

/** #######################################
    Sha1 Calculator
###########################################
*/

#include "Sha1Calc.h"

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

SZ_T  Sha1Calc_init( Sha1Calc* t ){
	return Sha1Calc_reset( t );
}

SZ_T Sha1Calc_uninit( Sha1Calc* t ){ return RET_OK; }

SZ_T Sha1Calc_reset( Sha1Calc* t ){
	SZ_INT x;
	t->reg[0] = 0x67452301;
	t->reg[1] = 0xefcdab89;
	t->reg[2] = 0x98badcfe;
	t->reg[3] = 0x10325476;
	t->reg[4] = 0xC3D2E1F0;
	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 Sha1Calc_calculate( Sha1Calc* t, SZ_CHAR* dp, SZ_T dl ){
	SZ_INT w,x,y,z;
	SZ_INT reg[ 6 ];

	/** 
	   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 < 5; 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 -- SHA1 is Big endian Order !
	*/
	while( w > 0 ){
		while( x < 16 ){
			t->Padding[ x ] = ( t->Padding[ x ] & ~( 0x000000ff << ( 24 - y ))) | (( dp[ z ] & 0x000000ff ) << ( 24 - y ));
			y = y + 8; x += ( y >> 5 ); y &= 0x1f; z ++; 
		}
		Sha1Calc_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. -- Also Big endian Order !
	*/
	w = ( SZ_INT )( dl - z ); 
	while( w > 0 ){
		t->DwordBuf[ x ] = t->Padding[ x ] = 
			( t->Padding[ x ] & ~( 0x000000ff << ( 24 - y ))) | (( dp[ z ] & 0x000000ff ) << ( 24 - y ));
		y = y + 8; x += ( y >> 5 ); y &= 0x1f; z ++;
		w --;
	}

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

	/** Save Old Value */
	for( w = 0; w < 5; w ++ ){ t->reg[ w ] = reg[ w ]; }
	
	/** Check if Length + 0x80 could append */
	t->DwordBufBytes =  x * 4  + ( y >> 3 );
	if( t->DwordBufBytes > 55 ){
		Sha1Calc_calcBlock( t->Padding, reg );
		for( w = 0; w < 16; w ++ ){ t->Padding[ w ] = 0; }
	}
		
	/** Append Length */
	t->Padding[ 15 ] = t->ByteNumLo << 3;
	t->Padding[ 14 ] = (( t->ByteNumLo >> 29 ) & 0x3 ) | ( t->ByteNumHi << 3 );
	Sha1Calc_calcBlock( t->Padding, reg );

	/** Output ordered Value -- big endian order */
	for( w = 0, x = 0; w < 20; w ++, x = ( x + 8 ) & 0x1f ){
		/** high byte first output value */
		t->Value[ w ] = ( SZ_CHAR )( reg[ w >> 2 ] >> ( 24 - x ));
	}

	return RET_OK;
}

SZ_T Sha1Calc_calcBlock( SZ_INT* dp, SZ_INT* rp ){
	SZ_INT a,b,c,d,e;
	SZ_INT f,k;
	SZ_INT x;

 	a = rp[0]; b = rp[1]; c = rp[2]; d = rp[3]; e = rp[4];
	
	/** main loop */
	for( x = 0; x < 16; x ++ ){
		k = (( a << 5 ) | (( a >> 27 ) & 0x1f )) + ( d ^ ( b & ( c ^ d ) )) + e + 0x5a827999 + dp[ x ];
		e = d; d = c; c = (( b << 30 ) | (( b >> 2 ) & 0x3fffffff )); b = a; a = k;
    	}
	for( x = 16; x < 20; x ++ ){
		k =  dp[( x + 13 ) & 0xf ] ^ dp[( x + 8 ) & 0xf ] ^ dp[( x + 2 ) & 0xf ] ^ dp[ x & 0xf ];
		dp[ x & 0xf ] = k = (( k << 1 ) | (( k >> 31 ) & 1 ));
		k = (( a << 5 ) | (( a >> 27 ) & 0x1f )) + ( d ^ ( b & ( c ^ d ) )) + e + 0x5a827999 + k;
		e = d; d = c; c = (( b << 30 ) | (( b >> 2 ) & 0x3fffffff )); b = a; a = k;
	}

	for( x = 20; x < 40; x ++ ){
		k =  dp[( x + 13 ) & 0xf ] ^ dp[( x + 8 ) & 0xf ] ^ dp[( x + 2 ) & 0xf ] ^ dp[ x & 0xf ];
		dp[ x & 0xf ] = k = (( k << 1 ) | (( k >> 31 ) & 1 ));
	
		k =  (( a << 5 ) | (( a >> 27 ) & 0x1f )) + ( b ^ c ^ d ) + e + 0x6ed9eba1 + k;
		e = d; d = c; c = ( b << 30 ) | (( b >> 2 ) & 0x3fffffff ); b = a; a = k;
	}

	for( x = 40; x < 60; x ++ ){
		k =  dp[( x + 13 ) & 0xf ] ^ dp[( x + 8 ) & 0xf ] ^ dp[( x + 2 ) & 0xf ] ^ dp[ x & 0xf ];
		dp[ x & 0xf ] = k = (( k << 1 ) | (( k >> 31 ) & 1 ));
	
		k =  (( a << 5 ) | (( a >> 27 ) & 0x1f )) + (( b & c ) | ( d & ( b | c ))) + e + 0x8f1bbcdc + k;
		e = d; d = c; c = ( b << 30 ) | (( b >> 2 ) & 0x3fffffff ); b = a; a = k;
	}
	
	for( x = 60; x < 80; x ++ ){
		k =  dp[( x + 13 ) & 0xf ] ^ dp[( x + 8 ) & 0xf ] ^ dp[( x + 2 ) & 0xf ] ^ dp[ x & 0xf ];
		dp[ x & 0xf ] = k = (( k << 1 ) | (( k >> 31 ) & 1 ));
	
		k =  (( a << 5 ) | (( a >> 27 ) & 0x1f )) + ( b ^ c ^ d ) + e + 0xca62c1d6 + k;
		e = d; d = c; c = ( b << 30 ) | (( b >> 2 ) & 0x3fffffff ); b = a; a = k;
	}

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

	return RET_OK;
}