MD5加密算法(C语言实现,已编译,亲试可用!)
本文有部分内容参考引用百度百科-MD5 。
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值。
————————————————
版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
原文链接:https://blog.csdn.net/lnfiniteloop/article/details/114276680
变量定义
//举例用的待处理文件原始数据
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);
//* &FileBuff[FileLen_Byte - (FileLen_Byte % 64)]
//* 需要补位再处理的数组起始元素号 = 文件填充前的长度(单位 - 字节) - 未处理的数据长度(求余就是需要补位处理的数据)
MD5_ChangeBuff[FileLen_Byte % 64] = 128; //在文件末尾先补一个1和七个0,十进制128的二进制即1000 0000
//* 从 第(FileLen_Byte % 64)个元素开始补,也就是从文件末尾开始补。
memcpy(&MD5_Buff[0], &MD5_ChangeBuff[0], 64); //高低位倒序赋值(大小端转换)
//补完第一个字节,128的二进制即1000 0000后,判断这一组还有没有空位放 文件填充前的长度(64bit,即8个字节)
//若不够位置放,则再补一组512 bit,在那组的最后放文件填充前长度。
if((FileLen_Byte % 64) > 55) //64 - 1 - 8 = 55
//* 除余后的余数就是需要处理的字节数,当比55个还多,当前512位放不下,先把当前512位做四轮运算。之后再补位、补数据长度,再做四轮运算。
{
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)
{
}
}