【MD5信息摘要算法】

啊哈的哲学路途

已于 2024-01-26 18:35:11 修改

阅读量577

点赞数 13

文章标签：算法 c语言

于 2024-01-26 16:59:45 首次发布

本文链接：https://blog.csdn.net/yf910404/article/details/135868742

版权

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值。
————————————————

原文链接：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)
	{
		
	}
}

啊哈的哲学路途

关注

13
点赞
踩
10

收藏

觉得还不错? 一键收藏
1
评论
【MD5信息摘要算法】

将它们分别加上输入时的链接变量的值，就会得到新的链接变量的值，此值再继续输入参与下一512 bit分组的4轮逻辑处理；将原始数据转换为二进制看，先在末尾补一个1，再补0，再补一个64位的原始数据长度（单位bit），补完后数据位数长度为512的倍数；注意：初始的A、B、C、D 4个链接变量与每组的M[0]~M[15]在进入计算前要先经过大小端处理。每4轮逻辑处理的输入量为：链接变量A、B、C、D 和每组的M[0]~M[15]；以512位分组，每组又分为16个32位的子分组M[0]~M[15]；
复制链接

扫一扫