自动更新系统（二）

标签：c

如何生成一个SHA1表

#include "list.h"

INT32 mnuSearch_i32OSM = 0;

void  sha1_init( SHA1_CONTEXT *hd )  
{  
	hd->h0 = 0x67452301U;  
	hd->h1 = 0xefcdab89U;  
	hd->h2 = 0x98badcfeU;  
	hd->h3 = 0x10325476U;  
	hd->h4 = 0xc3d2e1f0U;  
	hd->nblocks = 0U;  
	hd->count = 0;  
}  

/**************** 
* Transform the message X which consists of 16 32-bit-words 
*/  
static void transform(
					SHA1_CONTEXT *hd, const UINT8 *data
					  )

{  
	UINT32 a,b,c,d,e,tm;  
	UINT32 x[16];  

	/* get values from the chaining vars */  
	a = hd->h0;  
	b = hd->h1;  
	c = hd->h2;  
	d = hd->h3;  
	e = hd->h4;  

#ifdef BIG_ENDIAN_HOST  
	memcpy( x, data, 64 );  
#else  
	{  
		INT32 i;  
		UINT8 *p2;  
		for((i=0, p2=(UINT8*)x); i < 16; (i++, p2 += 4))   
		{  
			p2[3] = *data++;  
			p2[2] = *data++;  
			p2[1] = *data++;  
			p2[0] = *data++;  
		}  
	}  
#endif  

#define R(a,b,c,d,e,f,k,m)  do {e += rol( a, 5 )  + f( b, c, d ) + k  + m;b = rol( b, 30 ); } while(0)  
	R( a, b, c, d, e, F1, K1, x[ 0] );  
	R( e, a, b, c, d, F1, K1, x[ 1] );  
	R( d, e, a, b, c, F1, K1, x[ 2] );  
	R( c, d, e, a, b, F1, K1, x[ 3] );  
	R( b, c, d, e, a, F1, K1, x[ 4] );  
	R( a, b, c, d, e, F1, K1, x[ 5] );  
	R( e, a, b, c, d, F1, K1, x[ 6] );  
	R( d, e, a, b, c, F1, K1, x[ 7] );  
	R( c, d, e, a, b, F1, K1, x[ 8] );  
	R( b, c, d, e, a, F1, K1, x[ 9] );  
	R( a, b, c, d, e, F1, K1, x[10] );  
	R( e, a, b, c, d, F1, K1, x[11] );  
	R( d, e, a, b, c, F1, K1, x[12] );  
	R( c, d, e, a, b, F1, K1, x[13] );  
	R( b, c, d, e, a, F1, K1, x[14] );  
	R( a, b, c, d, e, F1, K1, x[15] );  
	R( e, a, b, c, d, F1, K1, M(16) );  
	R( d, e, a, b, c, F1, K1, M(17) );  
	R( c, d, e, a, b, F1, K1, M(18) );  
	R( b, c, d, e, a, F1, K1, M(19) );  
	R( a, b, c, d, e, F2, K2, M(20) );  
	R( e, a, b, c, d, F2, K2, M(21) );  
	R( d, e, a, b, c, F2, K2, M(22) );  
	R( c, d, e, a, b, F2, K2, M(23) );  
	R( b, c, d, e, a, F2, K2, M(24) );  
	R( a, b, c, d, e, F2, K2, M(25) );  
	R( e, a, b, c, d, F2, K2, M(26) );  
	R( d, e, a, b, c, F2, K2, M(27) );  
	R( c, d, e, a, b, F2, K2, M(28) );  
	R( b, c, d, e, a, F2, K2, M(29) );  
	R( a, b, c, d, e, F2, K2, M(30) );  
	R( e, a, b, c, d, F2, K2, M(31) );  
	R( d, e, a, b, c, F2, K2, M(32) );  
	R( c, d, e, a, b, F2, K2, M(33) );  
	R( b, c, d, e, a, F2, K2, M(34) );  
	R( a, b, c, d, e, F2, K2, M(35) );  
	R( e, a, b, c, d, F2, K2, M(36) );  
	R( d, e, a, b, c, F2, K2, M(37) );  
	R( c, d, e, a, b, F2, K2, M(38) );  
	R( b, c, d, e, a, F2, K2, M(39) );  
	R( a, b, c, d, e, F3, K3, M(40) );  
	R( e, a, b, c, d, F3, K3, M(41) );  
	R( d, e, a, b, c, F3, K3, M(42) );  
	R( c, d, e, a, b, F3, K3, M(43) );  
	R( b, c, d, e, a, F3, K3, M(44) );  
	R( a, b, c, d, e, F3, K3, M(45) );  
	R( e, a, b, c, d, F3, K3, M(46) );  
	R( d, e, a, b, c, F3, K3, M(47) );  
	R( c, d, e, a, b, F3, K3, M(48) );  
	R( b, c, d, e, a, F3, K3, M(49) );  
	R( a, b, c, d, e, F3, K3, M(50) );  
	R( e, a, b, c, d, F3, K3, M(51) );  
	R( d, e, a, b, c, F3, K3, M(52) );  
	R( c, d, e, a, b, F3, K3, M(53) );  
	R( b, c, d, e, a, F3, K3, M(54) );  
	R( a, b, c, d, e, F3, K3, M(55) );  
	R( e, a, b, c, d, F3, K3, M(56) );  
	R( d, e, a, b, c, F3, K3, M(57) );  
	R( c, d, e, a, b, F3, K3, M(58) );  
	R( b, c, d, e, a, F3, K3, M(59) );  
	R( a, b, c, d, e, F4, K4, M(60) );  
	R( e, a, b, c, d, F4, K4, M(61) );  
	R( d, e, a, b, c, F4, K4, M(62) );  
	R( c, d, e, a, b, F4, K4, M(63) );  
	R( b, c, d, e, a, F4, K4, M(64) );  
	R( a, b, c, d, e, F4, K4, M(65) );  
	R( e, a, b, c, d, F4, K4, M(66) );  
	R( d, e, a, b, c, F4, K4, M(67) );  
	R( c, d, e, a, b, F4, K4, M(68) );  
	R( b, c, d, e, a, F4, K4, M(69) );  
	R( a, b, c, d, e, F4, K4, M(70) );  
	R( e, a, b, c, d, F4, K4, M(71) );  
	R( d, e, a, b, c, F4, K4, M(72) );  
	R( c, d, e, a, b, F4, K4, M(73) );  
	R( b, c, d, e, a, F4, K4, M(74) );  
	R( a, b, c, d, e, F4, K4, M(75) );  
	R( e, a, b, c, d, F4, K4, M(76) );  
	R( d, e, a, b, c, F4, K4, M(77) );  
	R( c, d, e, a, b, F4, K4, M(78) );  
	R( b, c, d, e, a, F4, K4, M(79) );  

	/* Update chaining vars */  
	hd->h0 += a;  
	hd->h1 += b;  
	hd->h2 += c;  
	hd->h3 += d;  
	hd->h4 += e;  
}  


/* Update the message digest with the contents 
* of INBUF with length INLEN. 
*/  
static void  
	sha1_write( SHA1_CONTEXT *hd, const UINT8 *inbuf, UINT32 inlen)  
{  
	if( hd->count == 64 )		/* flush the buffer */  
	{ 
		transform( hd, hd->buf );  
		hd->count = 0;  
		hd->nblocks++;  
	}  
	if( !inbuf  )  
		return;  
	if( hd->count ) 
	{  
		for( ; (inlen) && (hd->count < 64); inlen-- )  
		{
			hd->buf[hd->count++] = *inbuf++;  
		}
		sha1_write( hd, NULL, 0U );  
		if( !inlen )  
			return;  
	}  

	while( inlen >= 64U ) 
	{  
		transform( hd, inbuf );  
		hd->count = 0;  
		hd->nblocks++;  
		inlen -= 64U;  
		inbuf += 64U;  
	}  
	for( ; (inlen) && (hd->count < 64); inlen-- )  
	{
		hd->buf[hd->count++] = *inbuf++;  
	}
}  


/* The routine final terminates the computation and 
* returns the digest. 
* The handle is prepared for a new cycle, but adding bytes to the 
* handle will the destroy the returned buffer. 
* Returns: 20 bytes representing the digest. 
*/  

static void  
	sha1_final(SHA1_CONTEXT *hd)  
{  
	UINT32 t, msb, lsb;  
	UINT8 *p;  

	sha1_write(hd, NULL, 0U); /* flush */  

	t = hd->nblocks;  
	/* multiply by 64 to make a byte count */  
	lsb = t << 6;  
	msb = t >> 26;  
	/* add the count */  
	t = lsb;  
	if( (lsb += hd->count) < t )  
	{
		msb++;  
	}
	/* multiply by 8 to make a bit count */  
	t = lsb;  
	lsb <<= 3;  
	msb <<= 3;  
	msb |= t >> 29;  

	if( hd->count < 56 )   /* enough room */
	{   
		hd->buf[hd->count++] = 0x80U; /* pad */  
		while( hd->count < 56 ) 
		{
			hd->buf[hd->count++] = 0U;  /* pad */  
		}
	}  
	else			/* need one extra block */  
	{ 
		hd->buf[hd->count++] = 0x80U; /* pad character */  
		while( hd->count < 64 ) 
		{
			hd->buf[hd->count++] = 0U;  
		}
		sha1_write(hd, NULL, 0U);  /* flush */;  
		memset(hd->buf, 0, 56U ); /* fill next block with zeroes */  
	}  
	/* append the 64 bit count */  
	hd->buf[56] = msb >> 24;  
	hd->buf[57] = msb >> 16;  
	hd->buf[58] = msb >>  8;  
	hd->buf[59] = msb       ;  
	hd->buf[60] = lsb >> 24;  
	hd->buf[61] = lsb >> 16;  
	hd->buf[62] = lsb >>  8;  
	hd->buf[63] = lsb       ;  
	transform( hd, hd->buf );  

	p = hd->buf;  
#ifdef BIG_ENDIAN_HOST  
#define X(a) do { *(u32*)p = hd->h##a ; p += 4; } while(0)  
#else /* little endian */  
#define X(a) do { *p++ = hd->h##a >> 24; *p++ = hd->h##a >> 16; *p++ = hd->h##a >> 8; *p++ = hd->h##a; } while(0)  
#endif  
	X(0);  
	X(1);  
	X(2);  
	X(3);  
	X(4);  
#undef X  
}  

/*获取文件的SHA1值，如果发生错误则将错误信息写入outError 
* FileNameInPut:文件路径 
* outSHA1:SHA1输出变量 
* outError:错误信息输出变量 
* returns:outSHA1 
*/  
char *GetFileSHA1(char *FileNameInPut, char *outSHA1, char *outError)  
{  
	if(FileNameInPut==NULL)   
	{  
		if (outError != NULL)  
		{  
			sprintf(outError, "%s", "FileNameInPut Is NULL");  
		}  
	}  
	else
	{
		FILE *fp;  
		CHAR buffer[4096];  
		UINT32 n;  
		SHA1_CONTEXT ctx;  
		INT32 i32i = 0;  
		CHAR p[100] = "E:\\C program\\program\\1\\";
		strcat(p,FileNameInPut);
		fopen_s (&fp, p , "rb");  
		if (!fp)              
		{  
			if (outError != NULL)  
			{  
				/*sprintf(outError, "打开文件“%s”失败\n", FileNameInPut);  */
			}  
		}
		else
		{
			sha1_init (&ctx);  
			while ( (n = fread (buffer, 1, sizeof(buffer), fp)))     
			{
				sha1_write (&ctx, (UINT8 *)buffer, n);  
			}
			if (ferror (fp))  
			{  
				if (outError != NULL)  
				{  
					sprintf(outError, "读取文件“%s”失败\n", FileNameInPut);  
				}   
			}
			else
			{
				sha1_final (&ctx);  
				fclose (fp);  

				for ( i32i=0; i32i < 20; i32i++)  
				{  
					sprintf(outSHA1 + 2*i32i, "%02x", (UINT8)ctx.buf[i32i]);  
				}  
				outSHA1[2*i32i] = '\0';  
			}
		}
	}
	return outSHA1;  
}  

LNode *GenerateSHA1()  
{	
	CHAR *argv;
	LNode *head;
	lONG64 Handle;
	struct _finddata_t FileInfo;
	head = CreateList();
	Handle = _findfirst("E:\\C program\\program\\1\\*.*", &FileInfo);
	if(Handle == -1L)
	{
		mnuSearch_i32OSM = OSM_Printf("没有找到匹配的项目\n");
	}
	else
	{
		do{
			CHAR sha1[41] = { 0 };
			(argv) = FileInfo.name;
			if ((argv)[0] != '.')
			{
				mnuSearch_i32OSM = OSM_Printf("\r\n");  
				CHAR eror[256] = { 0 };  
				if ( NULL != FileInfo.name)
				{
					mnuSearch_i32OSM = OSM_Printf("%s\n", FileInfo.name);
				}
				mnuSearch_i32OSM = OSM_Printf("SHA1值为:");

				mnuSearch_i32OSM = OSM_Printf("%s\r\n", GetFileSHA1((argv), sha1, NULL));  
				if (strlen(eror) != 0U)  
				{  
					mnuSearch_i32OSM = OSM_Printf("获取SHA1发生错误：%s\r\n", eror);  
				}  
				AddElem(head, FileInfo.name, GetFileSHA1((argv), sha1, NULL));
			}
		}while(_findnext(Handle, &FileInfo) == 0);
	}
	return (head); 
}

INT32 main()
{
	LNode *head;
	head = GenerateSHA1();
	while(1);
}

这个执行的结果是：

这个里面的1.txt和4.txt中的文件内容完全相同，只是文件名不同。

自动更新系统（二）

标签：c

原文地址：http://blog.csdn.net/u011046042/article/details/42262457