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
(可電話激活)