sha1算法c

① SHA1的基本处理块大小如何

你好，sha1算法的基本处理块大小是512。下面是具体的处理过程。
对于任意长度的明文，SHA1首先对其进行分组，使得每一组的长度为512位，然后对这些明文分组反复重复处理。

对于每个明文分组的摘要生成过程如下：

（1） 将512位的明文分组划分为16个子明文分组，每个子明文分组为32位。

（2） 申请5个32位的链接变量，记为A、B、C、D、E。

（3） 16份子明文分组扩展为80份。

（4） 80份子明文分组进行4轮运算。

（5） 链接变量与初始链接变量进行求和运算。

（6） 链接变量作为下一个明文分组的输入重复进行以上操作。

（7） 最后，5个链接变量里面的数据就是SHA1摘要。

② 很懂哈希值（SHA1）的高手请进

简单的说sha1叫做文件指纹和md5的功能是一样的，是一个不可逆算法，同一个文件生成的值是一样的。但是只要稍微修改，或重新压缩（只本来就是压缩文件，解压缩后重新压缩），都会有变化。但是拷贝和传输不会使其变化。

如果你发现sha1不同，只能证明他和官方的文件不同。没有别的。

不同的原因可能是被修改过，也可能是iso刻成盘后，又从光盘抓录成iso这样虽然文件内容一样但是，毕竟不是同一个文件，所以sha1码也不同。

另外注意一下下载下来的是不是 rar的，那样要解压缩成iso在试验iso的哈希值。

③ SHA1的SHA1算法描述

在SHA1算法中，我们必须把原始消息（字符串，文件等）转换成位字符串。SHA1算法只接受位作为输入。假设我们对字符串“abc”产生消息摘要。首先，我们将它转换成位字符串如下：
01100001 01100010 01100011
―――――――――――――
‘a’=97 ‘b’=98 ‘c’=99
这个位字符串的长度为24。下面我们需要5个步骤来计算消息摘要MAC。 消息必须进行补位，以使其长度在对512取模以后的余数是448。也就是说，（补位后的消息长度）%512 = 448。即使长度已经满足对512取模后余数是448，补位也必须要进行。
补位是这样进行的：先补一个1，然后再补0，直到长度满足对512取模后余数是448。总而言之，补位是至少补一位，最多补512位。还是以前面的“abc”为例显示补位的过程。
原始信息： 01100001 01100010 01100011
补位第一步：01100001 01100010 01100011 1
首先补一个“1”
补位第二步：01100001 01100010 01100011 10…..0
然后补423个“0”
我们可以把最后补位完成后的数据用16进制写成下面的样子
61626380 00000000 00000000 00000000
00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000000
00000000 00000000
经过以上的处理之后，数据的长度是448了，我们可以进行下一步操作。 所谓的补长度是将原始数据的长度补到已经进行了补位操作的消息后面。通常用一个64位的数据来表示原始消息的长度。如果消息长度不大于2^64，那么第一个字就是0。在进行了补长度的操作以后，整个消息就变成下面这样了（16进制格式）
61626380 00000000 00000000 00000000
00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000018
如果原始的消息长度超过了512，我们需要将它补成512的倍数。然后我们把整个消息分成一个一个512位的数据块，分别处理每一个数据块，从而得到消息摘要。 一系列的常量字K(0), K(1), ... , K(79)，如果以16进制给出。它们如下：
Kt = 0x5A827999 (0 <= t <= 19)
Kt = 0x6ED9EBA1 (20 <= t <= 39)
Kt = 0x8F1BBCDC (40 <= t <= 59)
Kt = 0xCA62C1D6 (60 <= t <= 79). 在SHA1中我们需要一系列的函数。每个函数ft (0 <= t <= 79)都操作32位字B，C，D并且产生32位字作为输出。ft(B,C,D)可以如下定义
ft(B,C,D) = (B AND C) or ((NOT B) AND D) ( 0 <= t <= 19)
ft(B,C,D) = B XOR C XOR D (20 <= t <= 39)
ft(B,C,D) = (B AND C) or (B AND D) or (C AND D) (40 <= t <= 59)
ft(B,C,D) = B XOR C XOR D (60 <= t <= 79). 必须使用进行了补位和补长度后的消息来计算消息摘要。计算需要两个缓冲区，每个都由5个32位的字组成，还需要一个80个32位字的缓冲区。第一个5个字的缓冲区被标识为A，B，C，D，E。第二个5个字的缓冲区被标识为H0, H1, H2, H3, H4
。80个字的缓冲区被标识为W0, W1,..., W79
另外还需要一个一个字的TEMP缓冲区。
为了产生消息摘要，在第3.2部分中定义的512位（16个字）的数据块M1, M2,..., Mn
会依次进行处理，处理每个数据块Mi 包含80个步骤。
在处理所有数据块之前，缓冲区{Hi} 被初始化为下面的值（16进制）
H0 = 0x67452301
H1 = 0xEFCDAB89
H2 = 0x98BADCFE
H3 = 0x10325476
H4 = 0xC3D2E1F0.
现在开始处理M1, M2, ... , Mn。为了处理 Mi,需要进行下面的步骤
(1). 将 Mi 分成 16 个字 W0, W1, ... , W15, W0 是最左边的字
(2). 对于 t = 16 到 79 令
W[t] = S1(W[t-3] XOR W[t-8] XOR W[t-14] XOR W[t-16]).
(3). 令 A = H0, B = H1, C = H2, D = H3, E = H4.
(4) 对于 t = 0 到 79，执行下面的循环
TEMP = S5(A) + ft(B,C,D) + E + Wt + Kt;
E = D; D = C; C = S30(B); B = A; A = TEMP;
(5). 令 H0 = H0 + A, H1 = H1 + B, H2 = H2 + C, H3 = H3 + D, H4 = H4 + E.
在处理完所有的 Mn, 后，消息摘要是一个160位的字符串，以下面的顺序标识
H0 H1 H2 H3 H4.
对于SHA256,SHA384,SHA512。你也可以用相似的办法来计算消息摘要。对消息进行补位的算法完全是一样的。
SHA1在许多安全协议中广为使用，包括TLS和SSL、PGP、SSH、S/MIME和IPsec，曾被视为是MD5（更早之前被广为使用的散列函数）的后继者。

④ MD5、SHA1、CRC32值是干什么的

MD5可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。MD5由MD4、MD3、MD2改进而来，主要增强算法复杂度和不可逆性。MD5算法因其普遍、稳定、快速的特点，仍广泛应用于普通数据的加密保护领域 。

SHA-1（英语：Secure Hash Algorithm 1，中文名：安全散列算法1）是一种密码散列函数，美国国家安全局设计，并由美国国家标准技术研究所（NIST）发布为联邦数据处理标准（FIPS）。SHA-1可以生成一个被称为消息摘要的160位（20字节）散列值，散列值通常的呈现形式为40个十六进制数。

CRC32检错能力极强，开销小，易于用编码器及检测电路实现。从其检错能力来看，它所不能发现的错误的几率仅为0.0047%以下。从性能上和开销上考虑，均远远优于奇偶校验及算术和校验等方式。

因而，在数据存储和数据通讯领域，CRC无处不在：着名的通讯协议X.25的FCS（帧检错序列）采用的是CRC-CCITT，ARJ、LHA等压缩工具软件采用的是CRC32，磁盘驱动器的读写采用了CRC16，通用的图像存储格式GIF、TIFF等也都用CRC作为检错手段。

(4)sha1算法c扩展阅读：

在MD5算法中，首先需要对信息进行填充，这个数据按位(bit)补充，要求最终的位数对512求模的结果为448。也就是说数据补位后，其位数长度只差64位(bit)就是512的整数倍。即便是这个数据的位数对512求模的结果正好是448也必须进行补位。

补位的实现过程：首先在数据后补一个1 bit； 接着在后面补上一堆0 bit, 直到整个数据的位数对512求模的结果正好为448。总之，至少补1位，而最多可能补512位 。

⑤ 如何使用c语言获取文件的SHA1哈希值

有现成的SHA1算法函数

复制过来。

然后打开文件， 读数据， 调用SHA1函数即可。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>
#include<errno.h>

#undefBIG_ENDIAN_HOST
typedefunsignedintu32;

/****************
*Rotatea32bitintegerbynbytes
*/
#ifdefined(__GNUC__)&&defined(__i386__)
staticinlineu32
	rol(u32x,intn)
{
	__asm__("roll%%cl,%0"
		:"=r"(x)
		:"0"(x),"c"(n));
	returnx;
}
#else
#definerol(x,n)(((x)<<(n))|((x)>>(32-(n))))
#endif


typedefstruct{
	u32h0,h1,h2,h3,h4;
	u32nblocks;
	unsignedcharbuf[64];
	intcount;
}SHA1_CONTEXT;void
	sha1_init(SHA1_CONTEXT*hd)
{
	hd->h0=0x67452301;
	hd->h1=0xefcdab89;
	hd->h2=0x98badcfe;
	hd->h3=0x10325476;
	hd->h4=0xc3d2e1f0;
	hd->nblocks=0;
	hd->count=0;
}


/****************
*-bit-words
*/
staticvoid
	transform(SHA1_CONTEXT*hd,unsignedchar*data)
{
	u32a,b,c,d,e,tm;
	u32x[16];

	/*getvaluesfromthechainingvars*/
	a=hd->h0;
	b=hd->h1;
	c=hd->h2;
	d=hd->h3;
	e=hd->h4;

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


#defineK10x5A827999L
#defineK20x6ED9EBA1L
#defineK30x8F1BBCDCL
#defineK40xCA62C1D6L
#defineF1(x,y,z)(z^(x&(y^z)))
#defineF2(x,y,z)(x^y^z)
#defineF3(x,y,z)((x&y)|(z&(x|y)))
#defineF4(x,y,z)(x^y^z)


#defineM(i)(tm=x[i&0x0f]^x[(i-14)&0x0f]
	^x[(i-8)&0x0f]^x[(i-3)&0x0f]
	,(x[i&0x0f]=rol(tm,1)))

#defineR(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));

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


/*
*ofINBUFwithlengthINLEN.
*/
staticvoid
	sha1_write(SHA1_CONTEXT*hd,unsignedchar*inbuf,size_tinlen)
{
	if(hd->count==64){/*flushthebuffer*/
		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,0);
		if(!inlen)
			return;
	}

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


/*
*returnsthedigest.
*,butaddingbytestothe
*.
*Returns:20bytesrepresentingthedigest.
*/

staticvoid
	sha1_final(SHA1_CONTEXT*hd)
{
	u32t,msb,lsb;
	unsignedchar*p;

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

	t=hd->nblocks;
	/*multiplyby64tomakeabytecount*/
	lsb=t<<6;
	msb=t>>26;
	/*addthecount*/
	t=lsb;
	if((lsb+=hd->count)<t)
		msb++;
	/*multiplyby8tomakeabitcount*/
	t=lsb;
	lsb<<=3;
	msb<<=3;
	msb|=t>>29;

	if(hd->count<56){/*enoughroom*/
		hd->buf[hd->count++]=0x80;/*pad*/
		while(hd->count<56)
			hd->buf[hd->count++]=0;/*pad*/
	}
	else{/*needoneextrablock*/
		hd->buf[hd->count++]=0x80;/*padcharacter*/
		while(hd->count<64)
			hd->buf[hd->count++]=0;
		sha1_write(hd,NULL,0);/*flush*/;
		memset(hd->buf,0,56);/*fillnextblockwithzeroes*/
	}
	/*appendthe64bitcount*/
	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;
#ifdefBIG_ENDIAN_HOST
#defineX(a)do{*(u32*)p=hd->h##a;p+=4;}while(0)
#else/*littleendian*/
#defineX(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);
#undefX
}

⑥ c语言 实现sha1算法

你再知道里面搜“sha1算法”就有。void sha1_finish( sha1_context *ctx, uint8 digest[20] )函数就是你要的。

⑦ MD5,sha1,sha256分别输出多少位啊

MD5输出128位、SHA1输出160位、SHA256输出256位。

1、MD5消息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。

2、SHA1安全哈希算法（Secure Hash Algorithm）主要适用于数字签名标准 里面定义的数字签名算法。对于长度小于2^64位的消息，SHA1会产生一个160位的消息摘要。

3、sha256哈希值用作表示大量数据的固定大小的唯一值。数据的少量更改会在哈希值中产生不可预知的大量更改。SHA256 算法的哈希值大小为 256 位。

(7)sha1算法c扩展阅读：

MD5应用：

1、一致性验证

MD5的典型应用是对一段信息产生信息摘要，以防止被篡改。具体来说文件的MD5值就像是这个文件的“数字指纹”。每个文件的MD5值是不同的，如果任何人对文件做了任何改动，其MD5值也就是对应的“数字指纹”就会发生变化。

比如下载服务器针对一个文件预先提供一个MD5值，用户下载完该文件后，用我这个算法重新计算下载文件的MD5值，通过比较这两个值是否相同，就能判断下载的文件是否出错，或者说下载的文件是否被篡改了。

2、数字签名

MD5的典型应用是对一段Message(字节串)产生fingerprint(指纹），以防止被“篡改”。

例子：将一段话写在一个叫 readme.txt文件中，并对这个readme.txt产生一个MD5的值并记录在案，然后可以传播这个文件给，如果修改了文件中的任何内容，你对这个文件重新计算MD5时就会发现（两个MD5值不相同）。

如果再有一个第三方的认证机构，用MD5还可以防止文件作者的“抵赖”，这就是所谓的数字签名应用。

3、安全访问认证

MD5还广泛用于操作系统的登陆认证上，如Unix、各类BSD系统登录密码、数字签名等诸多方面。如在Unix系统中用户的密码是以MD5（或其它类似的算法）经Hash运算后存储在文件系统中。

当用户登录的时候，系统把用户输入的密码进行MD5 Hash运算，然后再去和保存在文件系统中的MD5值进行比较，进而确定输入的密码是否正确。

即使暴露源程序和算法描述，也无法将一个MD5的值变换回原始的字符串，从数学原理上说，是因为原始的字符串有无穷多个，这有点象不存在反函数的数学函数。

⑧ 如何使用C#的SHA1对字符串加密

private static string SHA1(string text)
{
byte[] cleanBytes = Encoding.Default.GetBytes(text);
byte[] hashedBytes = System.Security.Cryptography.SHA1.Create().ComputeHash(cleanBytes);
return BitConverter.ToString(hashedBytes).Replace("-", "");
}

调用这个函数就可以得到你要的sha1值了。
另外还有个概念要澄清，SHA1是散列算法，不是加密。

⑨ C语言 sha1编码 返回二进制源码怎么写

sha1函数返回的就是经过sha1算法计算过后的值

⑩ 电脑系统的MD5值和SHA1值是什么意思

MD5和SHA1是2种加密算法，用于计算出一段不可逆向计算的数值，以此来验证该文件是否被修改的。
这个不是激活码。
序列号：(不保证全部有效)
DY8QR-678FB-T4XXH-DP93B-6D7C7
88WRV-VDYHX-22KH2-P9CJM-GW8YY
PVYFQ-2JTBV-9KXQ2-FQHDY-MTBVH
WBVG8-4JPQB-6HJ6H-XH7YY-D2GQY
R4HB8-QGQK4-79X38-QH3HK-Q3PJ6
GKFV7-F2D9H-QKYXY-777P3-4M73W
TGX39-HB48W-R29DH-6BVKB-3XFDW
WBVG8-4JPQB-6HJ6H-XH7YY-D2GQY
WBVG8-4JPQB-6HJ6H-XH7YY-D2GQY
R4HB8-QGQK4-79X38-QH3HK-Q3PJ6
PVYFQ-2JTBV-9KXQ2-FQHDY-MTBVH
83339-738RD-PDJJD-P8W66-C9396
BF276-V2Q8T-3TP8K-CVRMT-KYTFX
482D2-C4R3F-3V8QV-RRVVX-V8DRX
C2X3D-VDTKD-9KJVP-6VHTW-PDJKY
WBVGB-4JPQB-6HJ6H-XH7YY-D2GQY
我用粉红色一个激活的....
GHMGD-CDP96-Q39TT-467PY-R3PDM
2J4JT-P34KF-YMGH8-FKDRQ-JP8M9
GHMGD-CDP96-Q39TT-467PY-R3PDM
(可电话激活)
2J4JT-P34KF-YMGH8-FKDRQ-JP8M9
(可电话激活)