c 语言常用的加密算法——MD5
发布时间:2025-05-14 19:18:48 发布人:远客网络
一、c 语言常用的加密算法——MD5
在C语言中，常用的加密算法主要包括AES、RSA、MD5、SHA-1及Base64编码。
AES加密算法是一种对称加密算法，广泛应用于数据加密。通过OpenSSL库在C语言中实现AES加密。
RSA加密算法为非对称加密算法，使用两把不同的密钥进行加密与解密，是最成熟且常用的非对称加密算法。同样使用OpenSSL库在C语言中实现RSA加密。
MD5算法作为加密散列函数，产生128位散列值，广泛应用于C语言中。通过OpenSSL库实现MD5加密。
SHA-1算法全称为Secure Hash Algorithm 1，用于数字签名、验证、消息摘要等，C语言中通过OpenSSL库实现SHA-1加密。
Base64编码虽非加密算法，但用于隐藏信息，C语言中通过OpenSSL库进行Base64编码与解码。
实现这些算法时通常利用OpenSSL库，因其提供了高效实现，避免了重复开发。
MD5算法在C语言中的实现示例如下：
unsigned char digest[MD5_DIGEST_LENGTH];
MD5((unsigned char*) str, strlen(str), digest);
printf("MD5 hash of\"%s\":", str);
for(int i= 0; i< MD5_DIGEST_LENGTH; i++){
通过OpenSSL库中的MD5函数，传入字符串与长度，将结果存储在数组中，然后打印数组内容即为MD5散列值。
二、求一个简单的md5加密程序C或C++代码
1、#define F(x, y, z)(((x)&(y))|((~x)&(z)))
2、#define G(x, y, z)(((x)&(z))|((y)&(~z)))
3、#define H(x, y, z)((x) ^(y) ^(z))
4、#define I(x, y, z)((y) ^((x)|(~z)))
5、#define RL(x, y)(((x)<<(y))|((x)>>(32-(y))))//x向左循环移y位
6、#define PP(x)(x<<24)|((x<<8)&0xff0000)|((x>>8)&0xff00)|(x>>24)//将x高低位互换,例如PP(aabbccdd)=ddccbbaa
7、#define FF(a, b, c, d, x, s, ac) a= b+(RL((a+ F(b,c,d)+ x+ ac),s))
8、#define GG(a, b, c, d, x, s, ac) a= b+(RL((a+ G(b,c,d)+ x+ ac),s))
9、#define HH(a, b, c, d, x, s, ac) a= b+(RL((a+ H(b,c,d)+ x+ ac),s))
10、#define II(a, b, c, d, x, s, ac) a= b+(RL((a+ I(b,c,d)+ x+ ac),s))
11、unsigned A,B,C,D,a,b,c,d,i,len,flen[2],x[16];//i临时变量,len文件长,flen[2]为64位二进制表示的文件初始长度
12、void md5(){//MD5核心算法,供64轮
13、 FF(a, b, c, d, x[ 0], 7, 0xd76aa478);/**//* 1*/
14、 FF(d, a, b, c, x[ 1], 12, 0xe8c7b756);/**//* 2*/
15、 FF(c, d, a, b, x[ 2], 17, 0x242070db);/**//* 3*/
16、 FF(b, c, d, a, x[ 3], 22, 0xc1bdceee);/**//* 4*/
17、 FF(a, b, c, d, x[ 4], 7, 0xf57c0faf);/**//* 5*/
18、 FF(d, a, b, c, x[ 5], 12, 0x4787c62a);/**//* 6*/
19、 FF(c, d, a, b, x[ 6], 17, 0xa8304613);/**//* 7*/
20、 FF(b, c, d, a, x[ 7], 22, 0xfd469501);/**//* 8*/
21、 FF(a, b, c, d, x[ 8], 7, 0x698098d8);/**//* 9*/
22、 FF(d, a, b, c, x[ 9], 12, 0x8b44f7af);/**//* 10*/
23、 FF(c, d, a, b, x[10], 17, 0xffff5bb1);/**//* 11*/
24、 FF(b, c, d, a, x[11], 22, 0x895cd7be);/**//* 12*/
25、 FF(a, b, c, d, x[12], 7, 0x6b901122);/**//* 13*/
26、 FF(d, a, b, c, x[13], 12, 0xfd987193);/**//* 14*/
27、 FF(c, d, a, b, x[14], 17, 0xa679438e);/**//* 15*/
28、 FF(b, c, d, a, x[15], 22, 0x49b40821);/**//* 16*/
29、 GG(a, b, c, d, x[ 1], 5, 0xf61e2562);/**//* 17*/
30、 GG(d, a, b, c, x[ 6], 9, 0xc040b340);/**//* 18*/
31、 GG(c, d, a, b, x[11], 14, 0x265e5a51);/**//* 19*/
32、 GG(b, c, d, a, x[ 0], 20, 0xe9b6c7aa);/**//* 20*/
33、 GG(a, b, c, d, x[ 5], 5, 0xd62f105d);/**//* 21*/
34、 GG(d, a, b, c, x[10], 9, 0x02441453);/**//* 22*/
35、 GG(c, d, a, b, x[15], 14, 0xd8a1e681);/**//* 23*/
36、 GG(b, c, d, a, x[ 4], 20, 0xe7d3fbc8);/**//* 24*/
37、 GG(a, b, c, d, x[ 9], 5, 0x21e1cde6);/**//* 25*/
38、 GG(d, a, b, c, x[14], 9, 0xc33707d6);/**//* 26*/
39、 GG(c, d, a, b, x[ 3], 14, 0xf4d50d87);/**//* 27*/
40、 GG(b, c, d, a, x[ 8], 20, 0x455a14ed);/**//* 28*/
41、 GG(a, b, c, d, x[13], 5, 0xa9e3e905);/**//* 29*/
42、 GG(d, a, b, c, x[ 2], 9, 0xfcefa3f8);/**//* 30*/
43、 GG(c, d, a, b, x[ 7], 14, 0x676f02d9);/**//* 31*/
44、 GG(b, c, d, a, x[12], 20, 0x8d2a4c8a);/**//* 32*/
45、 HH(a, b, c, d, x[ 5], 4, 0xfffa3942);/**//* 33*/
46、 HH(d, a, b, c, x[ 8], 11, 0x8771f681);/**//* 34*/
47、 HH(c, d, a, b, x[11], 16, 0x6d9d6122);/**//* 35*/
48、 HH(b, c, d, a, x[14], 23, 0xfde5380c);/**//* 36*/
49、 HH(a, b, c, d, x[ 1], 4, 0xa4beea44);/**//* 37*/
50、 HH(d, a, b, c, x[ 4], 11, 0x4bdecfa9);/**//* 38*/
51、 HH(c, d, a, b, x[ 7], 16, 0xf6bb4b60);/**//* 39*/
52、 HH(b, c, d, a, x[10], 23, 0xbebfbc70);/**//* 40*/
53、 HH(a, b, c, d, x[13], 4, 0x289b7ec6);/**//* 41*/
54、 HH(d, a, b, c, x[ 0], 11, 0xeaa127fa);/**//* 42*/
55、 HH(c, d, a, b, x[ 3], 16, 0xd4ef3085);/**//* 43*/
56、 HH(b, c, d, a, x[ 6], 23, 0x04881d05);/**//* 44*/
57、 HH(a, b, c, d, x[ 9], 4, 0xd9d4d039);/**//* 45*/
58、 HH(d, a, b, c, x[12], 11, 0xe6db99e5);/**//* 46*/
59、 HH(c, d, a, b, x[15], 16, 0x1fa27cf8);/**//* 47*/
60、 HH(b, c, d, a, x[ 2], 23, 0xc4ac5665);/**//* 48*/
61、 II(a, b, c, d, x[ 0], 6, 0xf4292244);/**//* 49*/
62、 II(d, a, b, c, x[ 7], 10, 0x432aff97);/**//* 50*/
63、 II(c, d, a, b, x[14], 15, 0xab9423a7);/**//* 51*/
64、 II(b, c, d, a, x[ 5], 21, 0xfc93a039);/**//* 52*/
65、 II(a, b, c, d, x[12], 6, 0x655b59c3);/**//* 53*/
66、 II(d, a, b, c, x[ 3], 10, 0x8f0ccc92);/**//* 54*/
67、 II(c, d, a, b, x[10], 15, 0xffeff47d);/**//* 55*/
68、 II(b, c, d, a, x[ 1], 21, 0x85845dd1);/**//* 56*/
69、 II(a, b, c, d, x[ 8], 6, 0x6fa87e4f);/**//* 57*/
70、 II(d, a, b, c, x[15], 10, 0xfe2ce6e0);/**//* 58*/
71、 II(c, d, a, b, x[ 6], 15, 0xa3014314);/**//* 59*/
72、 II(b, c, d, a, x[13], 21, 0x4e0811a1);/**//* 60*/
73、 II(a, b, c, d, x[ 4], 6, 0xf7537e82);/**//* 61*/
74、 II(d, a, b, c, x[11], 10, 0xbd3af235);/**//* 62*/
75、 II(c, d, a, b, x[ 2], 15, 0x2ad7d2bb);/**//* 63*/
76、 II(b, c, d, a, x[ 9], 21, 0xeb86d391);/**//* 64*/
77、 gets(filename);//用get函数,避免scanf以空格分割数据,
78、 if(filename[0]==34) filename[strlen(filename)-1]=0,strcpy(filename,filename+1);//支持文件拖曳,但会多出双引号,这里是处理多余的双引号
79、 if(!strcmp(filename,"exit")) exit(0);//输入exit退出
80、 if(!(fp=fopen(filename,"rb"))){printf("Can not open this file!\n");continue;}//以二进制打开文件
81、 fseek(fp, 0, SEEK_END);//文件指针转到文件末尾
82、 if((len=ftell(fp))==-1){printf("Sorry! Can not calculate files which larger than 2 GB!\n");fclose(fp);continue;}//ftell函数返回long,最大为2GB,超出返回-1
83、 rewind(fp);//文件指针复位到文件头
84、 A=0x67452301,B=0xefcdab89,C=0x98badcfe,D=0x10325476;//初始化链接变量
85、 flen[1]=len/0x20000000;//flen单位是bit
86、 memset(x,0,64);//初始化x数组为0
87、 fread(&x,4,16,fp);//以4字节为一组,读取16组数据
88、 for(i=0;i<len/64;i++){//循环运算直至文件结束
89、((char*)x)[len%64]=128;//文件结束补1,补0操作,128二进制即10000000
90、 if(len%64>55) md5(),memset(x,0,64);
91、 memcpy(x+14,flen,8);//文件末尾加入原文件的bit长度
92、 printf("MD5 Code:%08x%08x%08x%08x\n",PP(A),PP(B),PP(C),PP(D));//高低位逆反输出
三、java的md5的加密算法代码
/*******************************************************************************
* keyBean类实现了RSA Data Security, Inc.在提交给IETF的RFC1321中的keyBean message-digest
******************************************************************************/
*下面这些S11-S44实际上是一个4*4的矩阵，在原始的C实现中是用#define实现的，这里把它们实现成为static
* final是表示了只读，切能在同一个进程空间内的多个 Instance间共享
static final byte[] PADDING={-128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
*下面的三个成员是keyBean计算过程中用到的3个核心数据，在原始的C实现中被定义到keyBean_CTX结构中
private long[] state= new long[4];// state(ABCD)
private long[] count= new long[2];// number of bits, modulo 2^64(lsb
private byte[] buffer= new byte[64];// input buffer
* digestHexStr是keyBean的唯一一个公共成员，是最新一次计算结果的 16进制ASCII表示.
* digest,是最新一次计算结果的2进制内部表示，表示128bit的keyBean值.
private byte[] digest= new byte[16];
* getkeyBeanofStr是类keyBean最主要的公共方法，入口参数是你想要进行keyBean变换的字符串
*返回的是变换完的结果，这个结果是从公共成员digestHexStr取得的．
public String getkeyBeanofStr(String inbuf){
keyBeanUpdate(inbuf.getBytes(), inbuf.length());
for(int i= 0; i< 16; i++){
digestHexStr+= byteHEX(digest[i]);
//这是keyBean这个类的标准构造函数，JavaBean要求有一个public的并且没有参数的构造函数
/* keyBeanInit是一个初始化函数，初始化核心变量，装入标准的幻数*/
///* Load magic initialization constants.
* F, G, H,I是4个基本的keyBean函数，在原始的keyBean的C实现中，由于它们是
*简单的位运算，可能出于效率的考虑把它们实现成了宏，在java中，我们把它们实现成了private方法，名字保持了原来C中的。
private long F(long x, long y, long z){
private long G(long x, long y, long z){
private long H(long x, long y, long z){
private long I(long x, long y, long z){
* FF,GG,HH和II将调用F,G,H,I进行近一步变换 FF, GG, HH, and II transformations for
* rounds 1, 2, 3, and 4. Rotation is separate from addition to prevent
private long FF(long a, long b, long c, long d, long x, long s, long ac){
a=((int) a<< s)|((int) a>>>(32- s));
private long GG(long a, long b, long c, long d, long x, long s, long ac){
a=((int) a<< s)|((int) a>>>(32- s));
private long HH(long a, long b, long c, long d, long x, long s, long ac){
a=((int) a<< s)|((int) a>>>(32- s));
private long II(long a, long b, long c, long d, long x, long s, long ac){
a=((int) a<< s)|((int) a>>>(32- s));
* keyBeanUpdate是keyBean的主计算过程，inbuf是要变换的字节串，inputlen是长度，这个
*函数由getkeyBeanofStr调用，调用之前需要调用keyBeaninit，因此把它设计成private的
private void keyBeanUpdate(byte[] inbuf, int inputLen){
index=(int)(count[0]>>> 3)& 0x3F;
if((count[0]+=(inputLen<< 3))<(inputLen<< 3))
count[1]+=(inputLen>>> 29);
// Transform as many times as possible.
keyBeanMemcpy(buffer, inbuf, index, 0, partLen);
for(i= partLen; i+ 63< inputLen; i+= 64){
keyBeanMemcpy(block, inbuf, 0, i, 64);
keyBeanMemcpy(buffer, inbuf, index, i, inputLen- i);
* keyBeanFinal整理和填写输出结果
index=(int)(count[0]>>> 3)& 0x3f;
padLen=(index< 56)?(56- index):(120- index);
keyBeanUpdate(PADDING, padLen);
///* Append length(before padding)*/
* keyBeanMemcpy是一个内部使用的byte数组的块拷贝函数，从input的inpos开始把len长度的
*字节拷贝到output的outpos位置开始
private void keyBeanMemcpy(byte[] output, byte[] input, int outpos,
output[outpos+ i]= input[inpos+ i];
* keyBeanTransform是keyBean核心变换程序，有keyBeanUpdate调用，block是分块的原始字节
private void keyBeanTransform(byte block[]){
long a= state[0], b= state[1], c= state[2], d= state[3];
a= FF(a, b, c, d, x[0], S11, 0xd76aa478L);/* 1*/
d= FF(d, a, b, c, x[1], S12, 0xe8c7b756L);/* 2*/
c= FF(c, d, a, b, x[2], S13, 0x242070dbL);/* 3*/
b= FF(b, c, d, a, x[3], S14, 0xc1bdceeeL);/* 4*/
a= FF(a, b, c, d, x[4], S11, 0xf57c0fafL);/* 5*/
d= FF(d, a, b, c, x[5], S12, 0x4787c62aL);/* 6*/
c= FF(c, d, a, b, x[6], S13, 0xa8304613L);/* 7*/
b= FF(b, c, d, a, x[7], S14, 0xfd469501L);/* 8*/
a= FF(a, b, c, d, x[8], S11, 0x698098d8L);/* 9*/
d= FF(d, a, b, c, x[9], S12, 0x8b44f7afL);/* 10*/
c= FF(c, d, a, b, x[10], S13, 0xffff5bb1L);/* 11*/
b= FF(b, c, d, a, x[11], S14, 0x895cd7beL);/* 12*/
a= FF(a, b, c, d, x[12], S11, 0x6b901122L);/* 13*/
d= FF(d, a, b, c, x[13], S12, 0xfd987193L);/* 14*/
c= FF(c, d, a, b, x[14], S13, 0xa679438eL);/* 15*/
b= FF(b, c, d, a, x[15], S14, 0x49b40821L);/* 16*/
a= GG(a, b, c, d, x[1], S21, 0xf61e2562L);/* 17*/
d= GG(d, a, b, c, x[6], S22, 0xc040b340L);/* 18*/
c= GG(c, d, a, b, x[11], S23, 0x265e5a51L);/* 19*/
b= GG(b, c, d, a, x[0], S24, 0xe9b6c7aaL);/* 20*/
a= GG(a, b, c, d, x[5], S21, 0xd62f105dL);/* 21*/
d= GG(d, a, b, c, x[10], S22, 0x2441453L);/* 22*/
c= GG(c, d, a, b, x[15], S23, 0xd8a1e681L);/* 23*/
b= GG(b, c, d, a, x[4], S24, 0xe7d3fbc8L);/* 24*/
a= GG(a, b, c, d, x[9], S21, 0x21e1cde6L);/* 25*/
d= GG(d, a, b, c, x[14], S22, 0xc33707d6L);/* 26*/
c= GG(c, d, a, b, x[3], S23, 0xf4d50d87L);/* 27*/
b= GG(b, c, d, a, x[8], S24, 0x455a14edL);/* 28*/
a= GG(a, b, c, d, x[13], S21, 0xa9e3e905L);/* 29*/
d= GG(d, a, b, c, x[2], S22, 0xfcefa3f8L);/* 30*/
c= GG(c, d, a, b, x[7], S23, 0x676f02d9L);/* 31*/
b= GG(b, c, d, a, x[12], S24, 0x8d2a4c8aL);/* 32*/
a= HH(a, b, c, d, x[5], S31, 0xfffa3942L);/* 33*/
d= HH(d, a, b, c, x[8], S32, 0x8771f681L);/* 34*/
c= HH(c, d, a, b, x[11], S33, 0x6d9d6122L);/* 35*/
b= HH(b, c, d, a, x[14], S34, 0xfde5380cL);/* 36*/
a= HH(a, b, c, d, x[1], S31, 0xa4beea44L);/* 37*/
d= HH(d, a, b, c, x[4], S32, 0x4bdecfa9L);/* 38*/
c= HH(c, d, a, b, x[7], S33, 0xf6bb4b60L);/* 39*/
b= HH(b, c, d, a, x[10], S34, 0xbebfbc70L);/* 40*/
a= HH(a, b, c, d, x[13], S31, 0x289b7ec6L);/* 41*/
d= HH(d, a, b, c, x[0], S32, 0xeaa127faL);/* 42*/
c= HH(c, d, a, b, x[3], S33, 0xd4ef3085L);/* 43*/
b= HH(b, c, d, a, x[6], S34, 0x4881d05L);/* 44*/
a= HH(a, b, c, d, x[9], S31, 0xd9d4d039L);/* 45*/
d= HH(d, a, b, c, x[12], S32, 0xe6db99e5L);/* 46*/
c= HH(c, d, a, b, x[15], S33, 0x1fa27cf8L);/* 47*/
b= HH(b, c, d, a, x[2], S34, 0xc4ac5665L);/* 48*/
a= II(a, b, c, d, x[0], S41, 0xf4292244L);/* 49*/
d= II(d, a, b, c, x[7], S42, 0x432aff97L);/* 50*/
c= II(c, d, a, b, x[14], S43, 0xab9423a7L);/* 51*/
b= II(b, c, d, a, x[5], S44, 0xfc93a039L);/* 52*/
a= II(a, b, c, d, x[12], S41, 0x655b59c3L);/* 53*/
d= II(d, a, b, c, x[3], S42, 0x8f0ccc92L);/* 54*/
c= II(c, d, a, b, x[10], S43, 0xffeff47dL);/* 55*/
b= II(b, c, d, a, x[1], S44, 0x85845dd1L);/* 56*/
a= II(a, b, c, d, x[8], S41, 0x6fa87e4fL);/* 57*/
d= II(d, a, b, c, x[15], S42, 0xfe2ce6e0L);/* 58*/
c= II(c, d, a, b, x[6], S43, 0xa3014314L);/* 59*/
b= II(b, c, d, a, x[13], S44, 0x4e0811a1L);/* 60*/
a= II(a, b, c, d, x[4], S41, 0xf7537e82L);/* 61*/
d= II(d, a, b, c, x[11], S42, 0xbd3af235L);/* 62*/
c= II(c, d, a, b, x[2], S43, 0x2ad7d2bbL);/* 63*/
b= II(b, c, d, a, x[9], S44, 0xeb86d391L);/* 64*/
* Encode把long数组按顺序拆成byte数组，因为java的long类型是64bit的，只拆低32bit，以适应原始C实现的用途
private void Encode(byte[] output, long[] input, int len){
for(i= 0, j= 0; j< len; i++, j+= 4){
output[j]=(byte)(input[i]& 0xffL);
output[j+ 1]=(byte)((input[i]>>> 8)& 0xffL);
output[j+ 2]=(byte)((input[i]>>> 16)& 0xffL);
output[j+ 3]=(byte)((input[i]>>> 24)& 0xffL);
* Decode把byte数组按顺序合成成long数组，因为java的long类型是64bit的，
*只合成低32bit，高32bit清零，以适应原始C实现的用途
private void Decode(long[] output, byte[] input, int len){
for(i= 0, j= 0; j< len; i++, j+= 4)
output[i]= b2iu(input[j])|(b2iu(input[j+ 1])<< 8)
|(b2iu(input[j+ 2])<< 16)|(b2iu(input[j+ 3])<< 24);
* b2iu是我写的一个把byte按照不考虑正负号的原则的”升位”程序，因为java没有unsigned运算
public static long b2iu(byte b){
return b< 0? b& 0x7F+ 128: b;
* byteHEX()，用来把一个byte类型的数转换成十六进制的ASCII表示，
*因为java中的byte的toString无法实现这一点，我们又没有C语言中的 sprintf(outbuf,"%02X",ib)
public static String byteHEX(byte ib){
char[] Digit={'0','1','2','3','4','5','6','7','8','9','A',
'B','C','D','E','F'};
ob[0]= Digit[(ib>>> 4)& 0X0F];
public static void main(String args[]){
if(Array.getLength(args)== 0){//如果没有参数，执行标准的Test Suite
System.out.println("keyBean Test suite:");
System.out.println("keyBean(\"):"+ m.getkeyBeanofStr(""));
System.out.println("keyBean(\"a\"):"+ m.getkeyBeanofStr("a"));
System.out.println("keyBean(\"abc\"):"+ m.getkeyBeanofStr("abc"));
System.out.println("keyBean(\"message digest\"):"
+ m.getkeyBeanofStr("message digest"));
System.out.println("keyBean(\"abcdefghijklmnopqrstuvwxyz\"):"
+ m.getkeyBeanofStr("abcdefghijklmnopqrstuvwxyz"));
.println("keyBean(\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\"):"
.getkeyBeanofStr("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"));
System.out.println("keyBean("+ args[0]+")="
+ m.getkeyBeanofStr(args[0]));
