MD5加密算法（C语言实现，已编译，亲试可用！）
MD5
- MD5信息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。
- MD5将任意长度的“字节串”变换成128位（4个32位）的大整数，它是一个不可逆的数据转换过程。
MD5算法步骤
步骤1：补位
将原始数据转换为二进制看，先在末尾补一个1，再补0，再补一个64位的原始数据长度（单位bit），补完后数据位数长度为512的倍数；
注意：即便是这个数据的位数长度对512求模的结果正好是448也必须进行补位。总之，至少补1位，而最多可能补512位
步骤2：分组
以512位分组，每组又分为16个32位的子分组M[0]~M[15]；
步骤3：每组计算
输入量
每个512 bit分组都要经历一次4轮的逻辑处理；
每4轮逻辑处理的输入量为：链接变量A、B、C、D 和 每组的M[0]~M[15]；
四个链接变量A、B、C、D初始值为:
A=0x12345678
B=0x89ABCDEF
C=0xFEDCBA98
D=0x76543210
注意：初始的A、B、C、D 4个链接变量与每组的M[0]~M[15]在进入计算前要先经过大小端处理。
定义4个非线性函数F、G、H、I
每轮用一个非线性函数计算，即：
在第一轮中，M[0]~M[15]分别代入到函数F中运算；
在第二轮中，M[0]~M[15]分别代入到函数G中运算；
在第三轮中，M[0]~M[15]分别代入到函数H中运算；
在第四轮中，M[0]~M[15]分别代入到函数I中运算；
那么4轮一共会进行16 * 4 = 64次运算；
输出量
每一个512 bit分组经过4轮的逻辑处理后，会得到四个32位的值a、b、c、d;将它们分别加上输入时的链接变量的值，就会得到新的链接变量的值，此值再继续输入参与下一512 bit分组的4轮逻辑处理；
A = a + A
B = b + B
C = c + C
D = d + D
步骤4： 最终结果输出
经过了一系列的计算处理后，输出结果由4个32位数据组成，将这4个32位数据级联后将生成一个128位散列值，即为MD5值。
MD5算法流程图：
C语言实现MD5，代码干货
变量定义
//举例用的待处理文件原始数据
uint8_t FileBuff[] = "qwertyuiopasdfghjklzxcvbnm\
qwertyuiopasdfghjklzxcvbnm\
qwertyuiopasdfghjklzxcvbnm\
qwertyuiopasdfghjklzxcvbnm\
qwertyuiopasdfghjklzxcvbnm\
qwertyuiopasdfghjklzxcvbnm\
qwertyuiopasdfghjklzxcvbnm\
qwerty";
//四个32位链接变量的初始化值
uint32_t A = 0x67452301;
uint32_t B = 0xefcdab89;
uint32_t C = 0x98badcfe;
uint32_t D = 0x10325476;
uint32_t a,b,c,d = 0; //4轮逻辑计算中链接变量的过程量
uint32_t FileLen_Byte; //文件填充前的长度（单位 - 字节）
uint32_t FileLen_Bit[2]; //文件填充前的长度（单位 - 位 bit）
uint8_t MD5_ChangeBuff[64]; //临时缓存区 - 用于补位操作
uint32_t MD5_Buff[16]; //临时缓存区 - 用于每次运算装每组512 bit数据
uint8_t MD5_Data[16]; //最终计算结果 - 文件的MD5值四个非线性函数及对应的四种操作
#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))
#define RL(x, y) (((x) << (y)) | ((x) >> (32 - (y)))) //x向左循环移y位
#define FF(a, b, c, d, x, s, ac) a = b + (RL((a + F(b,c,d) + x + ac),s))
#define GG(a, b, c, d, x, s, ac) a = b + (RL((a + G(b,c,d) + x + ac),s))
#define HH(a, b, c, d, x, s, ac) a = b + (RL((a + H(b,c,d) + x + ac),s))
#define II(a, b, c, d, x, s, ac) a = b + (RL((a + I(b,c,d) + x + ac),s))四轮逻辑计算函数
//MD5核心算法,4轮共64次计算
void MD5_Calculate(void)
{
a = A, b = B, c = C, d = D;
/* Round 1 */
FF (a, b, c, d, MD5_Buff[ 0], 7, 0xd76aa478); /**//* 1 */
FF (d, a, b, c, MD5_Buff[ 1], 12, 0xe8c7b756); /**//* 2 */
FF (c, d, a, b, MD5_Buff[ 2], 17, 0x242070db); /**//* 3 */
FF (b, c, d, a, MD5_Buff[ 3], 22, 0xc1bdceee); /**//* 4 */
FF (a, b, c, d, MD5_Buff[ 4], 7, 0xf57c0faf); /**//* 5 */
FF (d, a, b, c, MD5_Buff[ 5], 12, 0x4787c62a); /**//* 6 */
FF (c, d, a, b, MD5_Buff[ 6], 17, 0xa8304613); /**//* 7 */
FF (b, c, d, a, MD5_Buff[ 7], 22, 0xfd469501); /**//* 8 */
FF (a, b, c, d, MD5_Buff[ 8], 7, 0x698098d8); /**//* 9 */
FF (d, a, b, c, MD5_Buff[ 9], 12, 0x8b44f7af); /**//* 10 */
FF (c, d, a, b, MD5_Buff[10], 17, 0xffff5bb1); /**//* 11 */
FF (b, c, d, a, MD5_Buff[11], 22, 0x895cd7be); /**//* 12 */
FF (a, b, c, d, MD5_Buff[12], 7, 0x6b901122); /**//* 13 */
FF (d, a, b, c, MD5_Buff[13], 12, 0xfd987193); /**//* 14 */
FF (c, d, a, b, MD5_Buff[14], 17, 0xa679438e); /**//* 15 */
FF (b, c, d, a, MD5_Buff[15], 22, 0x49b40821); /**//* 16 */
/* Round 2 */
GG (a, b, c, d, MD5_Buff[ 1], 5, 0xf61e2562); /**//* 17 */
GG (d, a, b, c, MD5_Buff[ 6], 9, 0xc040b340); /**//* 18 */
GG (c, d, a, b, MD5_Buff[11], 14, 0x265e5a51); /**//* 19 */
GG (b, c, d, a, MD5_Buff[ 0], 20, 0xe9b6c7aa); /**//* 20 */
GG (a, b, c, d, MD5_Buff[ 5], 5, 0xd62f105d); /**//* 21 */
GG (d, a, b, c, MD5_Buff[10], 9, 0x02441453); /**//* 22 */
GG (c, d, a, b, MD5_Buff[15], 14, 0xd8a1e681); /**//* 23 */
GG (b, c, d, a, MD5_Buff[ 4], 20, 0xe7d3fbc8); /**//* 24 */
GG (a, b, c, d, MD5_Buff[ 9], 5, 0x21e1cde6); /**//* 25 */
GG (d, a, b, c, MD5_Buff[14], 9, 0xc33707d6); /**//* 26 */
GG (c, d, a, b, MD5_Buff[ 3], 14, 0xf4d50d87); /**//* 27 */
GG (b, c, d, a, MD5_Buff[ 8], 20, 0x455a14ed); /**//* 28 */
GG (a, b, c, d, MD5_Buff[13], 5, 0xa9e3e905); /**//* 29 */
GG (d, a, b, c, MD5_Buff[ 2], 9, 0xfcefa3f8); /**//* 30 */
GG (c, d, a, b, MD5_Buff[ 7], 14, 0x676f02d9); /**//* 31 */
GG (b, c, d, a, MD5_Buff[12], 20, 0x8d2a4c8a); /**//* 32 */
/* Round 3 */
HH (a, b, c, d, MD5_Buff[ 5], 4, 0xfffa3942); /**//* 33 */
HH (d, a, b, c, MD5_Buff[ 8], 11, 0x8771f681); /**//* 34 */
HH (c, d, a, b, MD5_Buff[11], 16, 0x6d9d6122); /**//* 35 */
HH (b, c, d, a, MD5_Buff[14], 23, 0xfde5380c); /**//* 36 */
HH (a, b, c, d, MD5_Buff[ 1], 4, 0xa4beea44); /**//* 37 */
HH (d, a, b, c, MD5_Buff[ 4], 11, 0x4bdecfa9); /**//* 38 */
HH (c, d, a, b, MD5_Buff[ 7], 16, 0xf6bb4b60); /**//* 39 */
HH (b, c, d, a, MD5_Buff[10], 23, 0xbebfbc70); /**//* 40 */
HH (a, b, c, d, MD5_Buff[13], 4, 0x289b7ec6); /**//* 41 */
HH (d, a, b, c, MD5_Buff[ 0], 11, 0xeaa127fa); /**//* 42 */
HH (c, d, a, b, MD5_Buff[ 3], 16, 0xd4ef3085); /**//* 43 */
HH (b, c, d, a, MD5_Buff[ 6], 23, 0x04881d05); /**//* 44 */
HH (a, b, c, d, MD5_Buff[ 9], 4, 0xd9d4d039); /**//* 45 */
HH (d, a, b, c, MD5_Buff[12], 11, 0xe6db99e5); /**//* 46 */
HH (c, d, a, b, MD5_Buff[15], 16, 0x1fa27cf8); /**//* 47 */
HH (b, c, d, a, MD5_Buff[ 2], 23, 0xc4ac5665); /**//* 48 */
/* Round 4 */
II (a, b, c, d, MD5_Buff[ 0], 6, 0xf4292244); /**//* 49 */
II (d, a, b, c, MD5_Buff[ 7], 10, 0x432aff97); /**//* 50 */
II (c, d, a, b, MD5_Buff[14], 15, 0xab9423a7); /**//* 51 */
II (b, c, d, a, MD5_Buff[ 5], 21, 0xfc93a039); /**//* 52 */
II (a, b, c, d, MD5_Buff[12], 6, 0x655b59c3); /**//* 53 */
II (d, a, b, c, MD5_Buff[ 3], 10, 0x8f0ccc92); /**//* 54 */
II (c, d, a, b, MD5_Buff[10], 15, 0xffeff47d); /**//* 55 */
II (b, c, d, a, MD5_Buff[ 1], 21, 0x85845dd1); /**//* 56 */
II (a, b, c, d, MD5_Buff[ 8], 6, 0x6fa87e4f); /**//* 57 */
II (d, a, b, c, MD5_Buff[15], 10, 0xfe2ce6e0); /**//* 58 */
II (c, d, a, b, MD5_Buff[ 6], 15, 0xa3014314); /**//* 59 */
II (b, c, d, a, MD5_Buff[13], 21, 0x4e0811a1); /**//* 60 */
II (a, b, c, d, MD5_Buff[ 4], 6, 0xf7537e82); /**//* 61 */
II (d, a, b, c, MD5_Buff[11], 10, 0xbd3af235); /**//* 62 */
II (c, d, a, b, MD5_Buff[ 2], 15, 0x2ad7d2bb); /**//* 63 */
II (b, c, d, a, MD5_Buff[ 9], 21, 0xeb86d391); /**//* 64 */
A += a;
B += b;
C += c;
D += d;
}main函数
int main(void)
{
uint8_t i = 0;
//获取加密数据长度（单位 - 字节）
FileLen_Byte = (sizeof(FileBuff) / sizeof(FileBuff[0])) - 1; //这里要注意减去字符串结束符'\0'占的一个字节长度
//分组循环运算直至文件结束（每组 512 bit 即 每组 64 字节）
for(i = 0; i < FileLen_Byte / 64; i++)
{
memset(MD5_Buff, 0, 64); //初始化 MD5_Buff 数组为0
memcpy(&MD5_Buff[0], &FileBuff[i * 64], 64); //高低位倒序赋值（大小端转换）
MD5_Calculate(); //进行四轮逻辑计算
}
//最后一组不足512 bit，补位 “1” 和 “0”
memset(MD5_Buff, 0, 64); //初始化 MD5_Buff（数组大小16，数据类型长度4字节）
memset(MD5_ChangeBuff, 0, 64); //初始化 MD5_ChangeBuff（数组大小64，数据类型长度1字节）
memcpy(MD5_ChangeBuff, &FileBuff[FileLen_Byte - (FileLen_Byte % 64)], FileLen_Byte % 64);
MD5_ChangeBuff[FileLen_Byte % 64] = 128; //在文件末尾先补一个1和七个0，十进制128的二进制即1000 0000
memcpy(&MD5_Buff[0], &MD5_ChangeBuff[0], 64); //高低位倒序赋值（大小端转换）
//补完第一个字节，128的二进制即1000 0000后，判断这一组还有没有空位放 文件填充前的长度（64bit,即8个字节）
//若不够位置放，则再补一组512 bit，在那组的最后放文件填充前长度。
if((FileLen_Byte % 64) > 55) //64 - 1 - 8 = 55
{
MD5_Calculate(); //进行四轮逻辑计算
memset(MD5_Buff, 0, 64); //初始化 MD5_Buff 数组为0
}
//在最后一个分组的最后补上原始文件填充前的长度（单位 - 位 bit）
FileLen_Bit[1] = FileLen_Byte / 0x20000000;
FileLen_Bit[0] = (FileLen_Byte % 0x20000000) * 8; //这一步要注意大小端转换，和前面的转换方式不太一样
memcpy(&MD5_Buff[14], FileLen_Bit, 8); //末尾加入原文件的bit长度（文件填充前的长度（单位 - bit））
MD5_Calculate();
memcpy(&MD5_Data[0], &A, 4); //高低位倒序赋值
memcpy(&MD5_Data[4], &B, 4); //高低位倒序赋值
memcpy(&MD5_Data[8], &C, 4); //高低位倒序赋值
memcpy(&MD5_Data[12], &D, 4); //高低位倒序赋值
// 打印出MD5值 - 想打印的时候就删掉注释
// printf("\r\n MD5值为： ");
// for(i = 0; i < 16; i++)
// {
// printf(" %02x ", MD5_Data[i]);
// }
while(1)
{
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
