csha1算法
你再知道里面搜“sha1算法”就有。void sha1_finish( sha1_context *ctx, uint8 digest[20] )函数就是你要的。
❷ SHA1 算法
安全哈希算法（Secure Hash Algorithm）主要适用于数字签名标准 （Digital Signature Standard DSS）里面定义的数字签名算法（Digital Signature Algorithm DSA）。对于长度小于2^64位的消息，SHA1会产生一个160位的消息摘要。当接收到消息的时候，这个消息摘要可以用来验证数据的完整性。在传输的过程中，数据很可能会发生变化，那么这时候就会产生不同的消息摘要。 SHA1有如下特性：不可以从消息摘要中复原信息；两个不同的消息不会产生同样的消息摘要,(但会有1x10 ^ 48分之一的机率出现相同的消息摘要,一般使用时忽略)。
举个栗子：123456
结果：
对照网站： http://tool.oschina.net/encrypt?type=2
❸ 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摘要。
❹ 如何使用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函数即可。
#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
}
❻ 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作为检错手段。
(6)csha1算法扩展阅读：
在MD5算法中，首先需要对信息进行填充，这个数据按位(bit)补充，要求最终的位数对512求模的结果为448。也就是说数据补位后，其位数长度只差64位(bit)就是512的整数倍。即便是这个数据的位数对512求模的结果正好是448也必须进行补位。
补位的实现过程：首先在数据后补一个1 bit； 接着在后面补上一堆0 bit, 直到整个数据的位数对512求模的结果正好为448。总之，至少补1位，而最多可能补512位 。
❼ 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)csha1算法扩展阅读：
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的值变换回原始的字符串，从数学原理上说，是因为原始的字符串有无穷多个，这有点象不存在反函数的数学函数。