用c语言实现sha1
for(I = 0；istrlen(消息)；I)如果信息很大，这个句子可能很耗时。
其实只要int len = strlen(message) first，那么
for(I = 0；我len我)是的。只算一次。
C语言中每个字符串都包含一个【字符串终止符】吗？ C语言中的每个字符串都包含一个[字符串终止符]-即“空字符”，用' \0 '表示。
sha1算法的
c语言实现
如果你又知道的话，可以搜索“sha1算法”。void sha1 _ finish(sha1 _ context * CTX，uint8digest [20])函数就是你想要的。
祖冲之(zuc)密码算法算法加密C语言实现代码。 这么久没人回答，我什么都明白了。祖冲之算法分为三个算法ZUC，它是祖冲之算法的核心，只产生秘密密钥流KS。由EEA3和EIA3调用。EEA3是一种加密算法，将用户的密钥与KS绑定，对用户数据D进行加密，变成密文。相当于国际上的RSA、DES、AES算法。EIA3是一种对称加密和解密算法，是一种数据完整性算法，也是一种MAC。绑定用户的密钥，结合KS生成一个哈希值。它相当于国际通用的HMAC与MD5和SHA1的组合。用于生成和保存密码授权值。
求MD5算法用C语言实现。 #包含stdio.h
#包含stdlib.h
#包含字符串. h
#如果定义了(__APPLE__)
# define COMMON _ DIGEST _ FOR _ OPENSSL
#包含CommonCrypto/CommonDigest.h
#定义SHA1 SHA1 CC
#否则
#包含openssl/md5.h
#endif
//这是自己写的函数，用来计算MD5。
//参数str:要转换的字符串。
//参数lengthL:字符串的长度可以通过strlen(str)直接得到。
//返回值:MD5字符串
char * str 2d 5(const char * str，int length) {
int n；
MD5 _ CTX c；
无符号字符摘要[16]；
char * out =(char *)malloc(33)；
MD5 _ Init(c)；
while(长度0) {
if(长度512) {
MD5_Update(c，str，512)；
}否则{
MD5_Update(c，str，length)；
}
长度-= 512；
str = 512
}
MD5_Final(digest，c)；
for(n = 0；n16；n) {
snprintf((out[n*2])，16*2，“x”，(unsigned int)digest[n])；
}
退了出来；
}
int main(int argc，char **argv) {
char *output = str2md5("hello "，strlen(" hello "))；
printf("%s\n "，输出)；
//上面会输出hello的MD5字符串:
//5d 41402 ABC 4b 2 a 76 b 9719d 911017 c 592
免费(输出)；
返回0；
}
如何用C语言获取文件的SHA1哈希值 有现成的SHA1算法函数。
复制它。
然后打开文件，读取数据，并调用SHA1函数。
#包含stdio.h
#包含stdlib.h
#包含字符串. h
#include assert.h
#包含错误号h
#undef大端主机
typedef无符号int u32
/****************
*将32位整数旋转n个字节
*/
#如果已定义(__GNUC__)已定义(__i386__)
静态内嵌u32
rol( u32 x，整数n)
{
__asm__("roll %%cl，%0 "
:" =r" (x)
:“0”(x)，“c”(n))；
返回x；
}
#否则
#定义rol(x，n) ( ((x) (n)) | ((x) (32-(n))))
#endif
typedef结构{
u32 h0，h1，h2，h3，H4；
u32 nblocks
无符号char buf[64]；
int计数；
} SHA1 _上下文；
空的
sha1 _ init(SHA1 _上下文*高清)
{
HD-h0 = 0x 67452301；
HD-h1 = 0x efcdab 89；
HD-H2 = 0x 98 bad cfe；
HD-H3 = 0x 10325476；
HD-H4 = 0x C3 D2 e1f 0；
HD-n blocks = 0；
HD-count = 0；
}
/****************
*转换由16个32位字组成的消息X
*/
静态空隙
转换(SHA1 _上下文*高清，无符号字符*数据)
{
u32 a、b、c、d、e、TM；
u32x[16]；
/*从链接变量中获取值*/
a = HD-h0；
b = HD-h1；
c = HD-H2；
d = HD-H3；
e = HD-H4；
#ifdef大端主机
memcpy( x，data，64)；
#否则
{
int I；
无符号字符* p2
for(i=0，p2 =(unsigned char *)x；i 16I，p2 = 4)
{
p2[3]= *数据；
p2[2]= *数据；
p2[1]= *数据；
p2[0]= *数据；
}
}
#endif
#定义K1 0x5A827999L
#定义K2 0x6ED9EBA1L
#定义K3 0x8F1BBCDCL
#定义K4 0xCA62C1D6L
#定义F1(x，y，z) ( z ^ ( x ( y ^ z)))
#定义F2(x，y，z) ( x ^ y ^ z)
#定义F3(x，y，z) ( ( x y ) | ( z ( x | y)))
#定义F4(x，y，z) ( x ^ y ^ z)
#定义m(I)(TM = x[i0x 0f]^ x[(I-14)0x0f]\
^ x[(i-8)0x0f] ^ x[(i-3)0x0f] \
，(x[i0x0f] = rol(tm，1)))
#定义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(阿、中、英、法、东、F4、K4、米(60))；
(英、阿、乙、丙、丁、F4、K4、米(61))；
(民主、英、阿、乙、丙、F4、K4、米(62))；
r(中、英、法、俄、西、F4、K4、米(63))；
R( b、c、d、e、a、F4、K4，M(64))；
r(阿、中、英、法、东、F4、K4、米(65))；
(英、阿、乙、丙、丁、F4、K4、米(66))；
(民主、英、阿、乙、丙、F4、K4、米(67))；
r(中、英、法、俄、西、F4、K4、米(68))；
R( b、c、d、e、a、F4、K4、M(69))；
r(阿、中、英、法、东、F4、K4、米(70))；
(英、阿、乙、丙、丁、F4、K4、米(71))；
(民主、英、阿、乙、丙、F4、K4、米(72))；
r(中、英、法、俄、西、F4、K4、米(73))；
R( b、c、d、e、a、F4、K4、M(74))；
r(阿、中、英、法、东、F4、K4、米(75))；
(英、阿、乙、丙、丁、F4、K4、米(76))；
(民主、英、阿、乙、丙、F4、K4、米(77))；
r(中、英、法、俄、西、F4、K4、米(78))；
R( b、c、d、e、a、F4、K4、M(79))；
/*更新链接变量*/
HD-h0 = a；
HD-h1 = b；
HD-H2 = c；
HD-H3 = d；
HD-H4 = e；
}
/*用内容更新消息摘要
*长度为INLEN的INBUF。
*/
静态空隙
sha1 _ write(SHA1 _上下文*hd，无符号字符*inbuf，size_t inlen)
{
if( hd-count == 64 ) { /*刷新缓冲器*/
transform( hd，HD-buf)；
HD-count = 0；
HD-n blocks；
}
如果(！inbuf)
返回；
if(高清计数){
for(；inlen HD-count 64；inlen -)
HD-buf[HD-count]= * in buf；
sha1_write( hd，NULL，0)；
如果(！inlen)
返回；
}
while( inlen = 64 ) {
transform(高清，in buf)；
HD-count = 0；
HD-n blocks；
inlen-= 64；
inbuf = 64
}
for(；inlen HD-count 64；inlen -)
HD-buf[HD-count]= * in buf；
}
/*例程final终止计算，并
*返回摘要。
*句柄为新的周期做好了准备，但是向
*句柄将销毁返回的缓冲区。
*返回:代表摘要的20个字节。
*/
静态空隙
sha1 _ final(SHA1 _ CONTEXT *高清)
{
u32 t，msb，lsb
无符号char * p；
sha1_write(hd，NULL，0)；/*齐平*/；
t = HD-n blocks；
/*乘以64得出字节数*/
LSB = t 6；
msb = t 26
/*添加计数*/
t = lsb
if( (lsb = hd-count) t)
msb
/*乘以8进行位计数*/
t = lsb
LSB = 3；
msb = 3；
msb | = t 29
if( hd-count 56 ) { /*足够的空间*/
HD-buf[HD-count]= 0x 80；/* pad */
while(高清计数56)
HD-buf[HD-count]= 0；/* pad */
}
否则{ /*需要一个额外的块*/
HD-buf[HD-count]= 0x 80；/*填充字符*/
while(高清计数64)
HD-buf[HD-count]= 0；
sha1_write(hd，NULL，0)；/*齐平*/；
memset(hd-buf，0，56)；/*用零填充下一个块*/
}
/*追加64位计数*/
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大端主机
#定义X(a)do { *(u32 *)p = HD-h # # a；p = 4；} while(0)
#else /* little endian */
#定义X(a)do { * p = HD-h # # a 24；* p = HD-h # # a 16；\
* p = HD-h # # A8；* p = HD-h # # a；} while(0)
#endif
x(0)；
x(1)；
x(2)；
x(3)；
x(4)；
#undef X
}
最后更新于 2023-10-12 14:43:36 并被添加「」标签，已有 位童鞋阅读过。
本站使用「署名 4.0 国际」创作共享协议，可自由转载、引用，但需署名作者且注明文章出处
相关文章