常用算法之一详解 MD5 实现（基于算法的官方原文档）及源码详细注释

Dear 丶 2022-04-18 05:00 664阅读 0赞

# 写在前面 #

在之前的工作中，用到了**CRC16**、**MD5** 和 **SHA1** 算法，主要用来校验下发的文件。网上关于这些算法的文章铺天盖地，以下内容仅仅是自己在学习时候的一个记录，一些套话来自于互联网。下面先来看看 **MD5**。  
   以下算法分析基于 ***RFC 1321***。

> 1.  Request For Comments (RFC），所有关于Internet 的正式标准都是以RFC(Request for Comment )文档出版。需要注意的是，还有大量的RFC文档都不是正式的标准，出版目的都是为了提供信息。
> 2.  由互联网协会（Internet Society，简称ISOC）赞助发行，会交到互联网工程工作小组（IETF）和互联网结构委员会（IAB）。文档可由网站 [https://www.ietf.org/][https_www.ietf.org] 下载。

# 什么是 MD5 #

全称是 MD5 消息摘要算法（The MD5 Message-Digest Algorithm），对输入任意长度的消息进行处理，最终产生一个128位的消息摘要（散列值（hash value））。不同的输入得到的不同的结果（唯一性）。MD5 由美国密码学家罗纳德·李维斯特（Ronald Linn Rivest）设计，于1992年公开，用以取代 MD4 算法。***这套算法的程序在 RFC 1321 中被加以规范（具体见附件）。***

> 1.  MD5 是 MD4 的升级版，MD4 是麻省理工学院教授 Ronald Rivest 于1990年设计的一种信息摘要算法，目前用的也不是很多。再之前还有个 MD2，好像是 1989年发布的，目前基本已被淘汰。
> 2.  **散列（Hash）：** 把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。
> 3.  **杂凑冲撞/散列冲撞：** 发现两段原文对应同一个MD5，则称为一次杂凑散列碰撞。

# 与 MD4 区别 #

根据规范文档，主要有以下几点：

1.  增加了第四轮
2.  每一步均有唯一的加法常数
3.  为减弱第二轮中函数G的对称性从 `(X&Y)|(X&Z)|(Y&Z)` 变为 `(X&Z)|(Y&(~Z))`
4.  第一步加上了上一步的结果，这将引起更快的雪崩效应
5.  改变了第二轮和第三轮中访问消息子分组的次序，使其更不相似
6.  近似优化了每一轮中的循环左移位移量以实现更快的雪崩效应，各轮的位移量互不相同

# 安全性 #

1996年后被证实存在弱点，可以被加以破解。2004年，证实 MD5 算法无法防止碰撞（collision）。2004年的国际密码讨论年会（CRYPTO）尾声，王小云及其研究同事展示了 MD5、SHA-0 及其他相关散列函数的散列冲撞。

# 实现原理 #

MD5 以 `512 位分组`来处理输入的信息，且每一分组又被划分为`16个32位子分组`，经过了一系列的处理后，算法的输出由四个32位分组组成，将这四个32位分组级联后将生成一个128位散列值。基本就是下面这张图（*该图在许多大学的课本上就可以看到，具体忘了出处，就重新画了一下*）  
![MD5][]  
根据算法文档的描述，总共可以分为五步：

*  第一步：**附加填充位：** 如果输入信息的长度(bit)对512求余的结果不等于448，就需要填充使得对512求余的结果等于448。这里主要是为了保证计算的最后一定为512bits。具体看参见后文源码的函数：`void MD5Final(MD5_CTX *context, unsigned char digest[16])`  
      ***填充方法：*** 在消息后面进行填充，填充第一位为1，其余为0。具体见下面源码的数组`unsigned char PADDING[]`
 *  第二步：**附加长度：** 用64位来存储填充前信息长度。这64位加在第一步结果的后面。将总的比特位位数附加到最后一包的最后，进行转换。`448 + 64 = 512`
 *  第三步：**初始化 MD 缓冲区：** 四个字（每个字32位）初始值（A，B，C，D）用于计算消息摘要。依次为：`A = 0x67452301，B = 0xEFCDAB89，C = 0x98BADCFE，D = 0x10325476`
 *  第四步：**处理输入的数据：** 这一步较为复杂，总共分两层循环：第一层为消息长度分的512bits的总包数（注意第一步的填充）下面的源码中，函数`void MD5Update(MD5_CTX *context, unsigned char *input, unsigned int inputlen)`就是处理这层循环的，第二层循环为 16个32位子分组，以下面四个分组计算，共64次循环。下面的源码中，函数`static void MD5Transform(unsigned int state[4], unsigned char block[64])`就是处理这层循环的。
    
    1.  规范定义了四个辅助函数，每个函数将三个32位字作为输入，并产生一个32位字作为输出。（& 表示与操作、| 表示或操作、~ 表示非操作、^ 表示异或操作）。64次子循环中，F、G、H、I 交替使用，第一个16次使用 F，第二个16次使用 G，第三个16次使用 H，第四个16次使用 I。
    
        #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))
    
    1.  设 Mj 表示消息的第 j 个子分组（从0到15）。把原文的每512位再分成16等份，命名为M0 ~ M15，每一等份长度32。在64次子循环中，每16次循环，都会交替用到M1 ~ M16之一
    
        FF(a,b,c,d,Mj,s,ti) 表示 a=b+((a+F(b,c,d)+Mj+ti)<<<s)
        	GG(a,b,c,d,Mj,s,ti) 表示 a=b+((a+G(b,c,d)+Mj+ti)<<<s)
        	HH(a,b,c,d,Mj,s,ti) 表示 a=b+((a+H(b,c,d)+Mj+ti)<<<s)
        	II(a,b,c,d,Mj,s,ti) 表示 a=b+((a+I(b,c,d)+Mj+ti)<<<s)
    
    1.  四轮运算，算法规定必须是四轮。具体见下面源码的函数 `static void MD5Transform(unsigned int state[4], unsigned char block[64])`

举个例子，假设输入的消息长度为N，那么第一层循环次数为 `N / 512 (还需要考虑填充)`，第二层循环次数为`512 / 32 *4 = 64`。具体来看看下图（来自于维基百科的[MD5介绍][MD5 1]）。  
![MD5][MD5 2]  
  这张图所表达的就是 ***单次子循环*** 的流程。图中的绿色F，代表以上四个辅助函数中的 F；红色的田字代表相加；Mi表示分为32位后的第 i 包数据；Ki是一个算法规定的常量，在64次子循环中，每一次用到的常量都是不同的；黄色的<<<S表示左移S位，S的值也是算法规定的常量。  
新A = 原d  
新B = b+((a+F(b,c,d)+Mj+Ki)<<<s)  
新C = 原b  
新D = 原c

*  第五步：**输出：** 作为输出产生的消息摘要是A，B，C，D。也就是说，我们从A的低位字节开始，以D的高位字节结束。

# 源码 #

在RFC 1321文档中，作者不进给出了算法的具体描述以及与 MD4 的区别，还给出了一套实现好的 C 代码，下文说明就是基于该代码的。代码稍微简化了一下，因此与原文中的代码可能稍有不同。  
  仔细阅读以下源码会发现，源码的实现并不是严格按照上面说的顺序实现的。以下源码有非常详细的注释，具体参看注释即可，不在做过多说明。

*  **MD5.h**

#ifndef MD5_H
    #define MD5_H
    
    /* MD5 context. */
    typedef struct
    { 
    	/* 存储原始信息的bits数长度(不包括填充的bits)，最长为 2^64 bits。如果消息长度大于2^64，则只使用其低64位的值，即（消息长度 对 2^64取模） */
    	unsigned int count[2];
    	/* 四个32bits数，用于存放最终计算得到的消息摘要。当消息长度大于 512bits时，也用于存放每个512bits的中间结果 */ 
    	unsigned int state[4];
    	/*存放输入的信息的缓冲区，512bits */
    	unsigned char buffer[64];
    } MD5_CTX;
    
    void MD5Init(MD5_CTX *context);
    void MD5Update(MD5_CTX *context, unsigned char *input, unsigned int inputlen);
    void MD5Final(MD5_CTX *context, unsigned char digest[16]);
    #endif

*  **MD5.c**

#include <string.h>
    #include "MD5.h"
    
    /* MD5转换用到的常量，是算法本身规定的 */
    #define S11 7
    #define S12 12
    #define S13 17
    #define S14 22
    #define S21 5
    #define S22 9
    #define S23 14
    #define S24 20
    #define S31 4
    #define S32 11
    #define S33 16
    #define S34 23
    #define S41 6
    #define S42 10
    #define S43 15
    #define S44 21
    
    /* 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))
    
    /* 实现将x循环左移n位 */
    #define ROTATE_LEFT(x, n) ((x << n) | (x >> (32 - n)))
    
    /** MD5算法本身规定的 4 轮变换 * Rotation is separate from addition to prevent recomputation. **/
    #define FF(a, b, c, d, x, s, ac) \ { \ a += F(b, c, d) + x + ac; \ a = ROTATE_LEFT(a, s); \ a += b; \ }
    #define GG(a, b, c, d, x, s, ac) \ { \ a += G(b, c, d) + x + ac; \ a = ROTATE_LEFT(a, s); \ a += b; \ }
    #define HH(a, b, c, d, x, s, ac) \ { \ a += H(b, c, d) + x + ac; \ a = ROTATE_LEFT(a, s); \ a += b; \ }
    #define II(a, b, c, d, x, s, ac) \ { \ a += I(b, c, d) + x + ac; \ a = ROTATE_LEFT(a, s); \ a += b; \ }
    
    /** * 用于bits填充的缓冲区，为什么要64个字节呢？因为当欲加密的信息的bits数被512除其余数为448时， * 需要填充的bits的最大值为512=64*8 。 **/
    unsigned char PADDING[] = { 0x80, 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, 0, 0, 0, 0, 0, 0, 0};
    
    static void MD5Transform(unsigned int state[4], unsigned char block[64]);
    static void MD5Encode(unsigned char *output, unsigned int *input, unsigned int len);
    static void MD5Decode(unsigned int *output, unsigned char *input, unsigned int len);
    
    /* MD5 initialization. Begins an MD5 operation, writing a new context. */  
    /* 初始化md5的结构 */
    void MD5Init(MD5_CTX *context)
    { 
    	/* 将当前的有效信息的长度设成 0 */
    	context->count[0] = 0;
    	context->count[1] = 0;
    	/* Load magic initialization constants.*/
    	/* 初始化链接变量，算法要求这样 */
    	context->state[0] = 0x67452301;
    	context->state[1] = 0xEFCDAB89;
    	context->state[2] = 0x98BADCFE;
    	context->state[3] = 0x10325476;
    }
    
    /* MD5 block update operation. Continues an MD5 message-digest operation, processing another message block, and updating the context. */
    /* 将与加密的信息传递给md5结构，可以多次调用 context：初始化过了的md5结构 input：欲加密的信息，可以任意长 inputLen：指定input的长度 */
    void MD5Update(MD5_CTX *context, unsigned char *input, unsigned int inputlen)
    { 
    	unsigned int i = 0, index = 0, partlen = 0;
    
    	/* 计算已有信息的bits长度的字节数的模64（64bytes = 512bits）。 用于判断已有信息加上当前传过来的信息的总长度能不能达到 512bits， 如果能够达到则对凑够的512bits进行一次处理 */
    	index = (context->count[0] >> 3) & 0x3F;	/* (context->count[0] >> 3) = context->count[0]/8 ,即：算字节数； 后面的 & 3F 就是 Mod 64 */
    	partlen = 64 - index;						/* 计算已有的字节数长度还差多少字节可以凑成 64Bytes（512bits） */
    	/* 保存输入信息的比特位数 */
    	context->count[0] += inputlen << 3;
    	if (context->count[0] < (inputlen << 3))
    	{ 
    		context->count[1]++;
    	}
    	context->count[1] += inputlen >> 29;
    
    	/* 如果当前输入的字节数 大于 已有字节数长度补足64字节整倍数所差的字节数 */
    	if (inputlen >= partlen)
    	{ 
    		/* 用当前输入的内容把 context->buffer 的内容补足 512bits */
    		memcpy(&context->buffer[index], input, partlen);
    		/* 用基本函数对填充满的512bits（已经保存到context->buffer中） 做一次转换，转换结果保存到context->state中 */
    		MD5Transform(context->state, context->buffer);
    		/* 对当前输入的剩余字节做转换（如果剩余的字节大于512bits的话 ）， 转换结果保存到context->state中 */
    		for (i = partlen; i + 64 <= inputlen; i += 64)
    		{ 
    			MD5Transform(context->state, &input[i]);
    		}
    		index = 0;
    	}
    	else
    	{ 
    		i = 0;
    	}
    	/*将输入缓冲区中的不足填充满512bits的剩余内容填充到context->buffer中，留待以后再作处理*/
    	memcpy(&context->buffer[index], &input[i], inputlen - i);
    }
    
    /* MD5 finalization. Ends an MD5 message-digest operation, writing the the message digest and zeroizing the context. */  
    /*获取加密 的最终结果 digest：保存最终的加密串 context：你前面初始化并填入了信息的md5结构 */
    void MD5Final(MD5_CTX *context, unsigned char digest[16])
    { 
    	unsigned int index = 0, padlen = 0;
    	unsigned char bits[8];
    
    	/* 计算已有信息的bits长度的字节数的模64（64bytes = 512bits）。 */ 
    	index = (context->count[0] >> 3) & 0x3F;
    	/* 计算需要填充的字节数，padLen的取值范围在1-64之间 */
    	padlen = (index < 56) ? (56 - index) : (120 - index);
    
    	/* 将要被转换的信息(所有的)的bits长度拷贝到bits中 */
    	MD5Encode(bits, context->count, 8);
    	/* */
    	MD5Update(context, PADDING, padlen);
    
    	/* 补上原始信息的bits长度（bits长度固定的用64bits表示），这一次能够恰巧凑够512bits，不会多也不会少 */
    	MD5Update(context, bits, 8);
    
    	/* 将最终的结果保存到digest中。ok，终于大功告成了 */
    	MD5Encode(digest, context->state, 16);
    }
    
    /* Encodes input (UINT4) into output (unsigned char). Assumes len is a multiple of 4. */  
    /*将4字节的整数copy到字符形式的缓冲区中 output：用于输出的字符缓冲区 input：欲转换的四字节的整数形式的数组 len：output缓冲区的长度，要求是4的整数倍 */  
    static void MD5Encode(unsigned char *output, unsigned int *input, unsigned int len)
    { 
    	unsigned int i = 0, j = 0;
    	while (j < len)
    	{ 
    		output[j] = input[i] & 0xFF;
    		output[j + 1] = (input[i] >> 8) & 0xFF;
    		output[j + 2] = (input[i] >> 16) & 0xFF;
    		output[j + 3] = (input[i] >> 24) & 0xFF;
    		i++;
    		j += 4;
    	}
    }
    
    /* Decodes input (unsigned char) into output (UINT4). Assumes len is a multiple of 4. */  
    /*与上面的函数正好相反，这一个把字符形式的缓冲区中的数据copy到4字节的整数中（即以整数形式保存） output：保存转换出的整数 input：欲转换的字符缓冲区 len：输入的字符缓冲区的长度，要求是4的整数倍 */ 
    static void MD5Decode(unsigned int *output, unsigned char *input, unsigned int len)
    { 
    	unsigned int i = 0, j = 0;
    	while (j < len)
    	{ 
    		output[i] = (input[j]) |
    					(input[j + 1] << 8) |
    					(input[j + 2] << 16) |
    					(input[j + 3] << 24);
    		i++;
    		j += 4;
    	}
    }
    
    /* MD5 basic transformation. Transforms state based on block. */  
    /* 对512bits信息(即block缓冲区)进行一次处理，每次处理包括四轮 state[4]：md5结构中的state[4]，用于保存对512bits信息加密的中间结果或者最终结果 block[64]：欲加密的512bits信息 */
    static void MD5Transform(unsigned int state[4], unsigned char block[64])
    { 
    	unsigned int a = state[0];
    	unsigned int b = state[1];
    	unsigned int c = state[2];
    	unsigned int d = state[3];
    	unsigned int x[64];
    
    	MD5Decode(x, block, 64);
    
    	/* Round 1 */
    	FF(a, b, c, d, x[0], S11, 0xd76aa478);  /* 1 */
    	FF(d, a, b, c, x[1], S12, 0xe8c7b756);  /* 2 */
    	FF(c, d, a, b, x[2], S13, 0x242070db);  /* 3 */
    	FF(b, c, d, a, x[3], S14, 0xc1bdceee);  /* 4 */
    	FF(a, b, c, d, x[4], S11, 0xf57c0faf);  /* 5 */
    	FF(d, a, b, c, x[5], S12, 0x4787c62a);  /* 6 */
    	FF(c, d, a, b, x[6], S13, 0xa8304613);  /* 7 */
    	FF(b, c, d, a, x[7], S14, 0xfd469501);  /* 8 */
    	FF(a, b, c, d, x[8], S11, 0x698098d8);  /* 9 */
    	FF(d, a, b, c, x[9], S12, 0x8b44f7af);  /* 10 */
    	FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
    	FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
    	FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
    	FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
    	FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
    	FF(b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
    
    	/* Round 2 */
    	GG(a, b, c, d, x[1], S21, 0xf61e2562);  /* 17 */
    	GG(d, a, b, c, x[6], S22, 0xc040b340);  /* 18 */
    	GG(c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
    	GG(b, c, d, a, x[0], S24, 0xe9b6c7aa);  /* 20 */
    	GG(a, b, c, d, x[5], S21, 0xd62f105d);  /* 21 */
    	GG(d, a, b, c, x[10], S22, 0x2441453);  /* 22 */
    	GG(c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
    	GG(b, c, d, a, x[4], S24, 0xe7d3fbc8);  /* 24 */
    	GG(a, b, c, d, x[9], S21, 0x21e1cde6);  /* 25 */
    	GG(d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
    	GG(c, d, a, b, x[3], S23, 0xf4d50d87);  /* 27 */
    	GG(b, c, d, a, x[8], S24, 0x455a14ed);  /* 28 */
    	GG(a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
    	GG(d, a, b, c, x[2], S22, 0xfcefa3f8);  /* 30 */
    	GG(c, d, a, b, x[7], S23, 0x676f02d9);  /* 31 */
    	GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
    
    	/* Round 3 */
    	HH(a, b, c, d, x[5], S31, 0xfffa3942);  /* 33 */
    	HH(d, a, b, c, x[8], S32, 0x8771f681);  /* 34 */
    	HH(c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
    	HH(b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
    	HH(a, b, c, d, x[1], S31, 0xa4beea44);  /* 37 */
    	HH(d, a, b, c, x[4], S32, 0x4bdecfa9);  /* 38 */
    	HH(c, d, a, b, x[7], S33, 0xf6bb4b60);  /* 39 */
    	HH(b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
    	HH(a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
    	HH(d, a, b, c, x[0], S32, 0xeaa127fa);  /* 42 */
    	HH(c, d, a, b, x[3], S33, 0xd4ef3085);  /* 43 */
    	HH(b, c, d, a, x[6], S34, 0x4881d05);   /* 44 */
    	HH(a, b, c, d, x[9], S31, 0xd9d4d039);  /* 45 */
    	HH(d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
    	HH(c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
    	HH(b, c, d, a, x[2], S34, 0xc4ac5665);  /* 48 */
    
    	/* Round 4 */
    	II(a, b, c, d, x[0], S41, 0xf4292244);  /* 49 */
    	II(d, a, b, c, x[7], S42, 0x432aff97);  /* 50 */
    	II(c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
    	II(b, c, d, a, x[5], S44, 0xfc93a039);  /* 52 */
    	II(a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
    	II(d, a, b, c, x[3], S42, 0x8f0ccc92);  /* 54 */
    	II(c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
    	II(b, c, d, a, x[1], S44, 0x85845dd1);  /* 56 */
    	II(a, b, c, d, x[8], S41, 0x6fa87e4f);  /* 57 */
    	II(d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
    	II(c, d, a, b, x[6], S43, 0xa3014314);  /* 59 */
    	II(b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
    	II(a, b, c, d, x[4], S41, 0xf7537e82);  /* 61 */
    	II(d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
    	II(c, d, a, b, x[2], S43, 0x2ad7d2bb);  /* 63 */
    	II(b, c, d, a, x[9], S44, 0xeb86d391);  /* 64 */
    
    	state[0] += a;
    	state[1] += b;
    	state[2] += c;
    	state[3] += d;
    }

# 使用方式 #

在实际使用时，往往需要多次调用循环计算。因为要计算的内容可能很长，需要分包一次次计算。上面的源码就是考虑到该种问题而实现的！使用方式如下：

MD5_CTX md5;
    	unsigned char encrypt[] = "admin"; //21232f297a57a5a743894a0e4a801fc3
    	unsigned char decrypt[16];
    	/* 计算前，先初始化 */
    	MD5Init(&md5);
    	/* 多次调用 MD5Update 循环计算多个包数据（如果有的话） */
    	MD5Update(&md5, encrypt, strlen((char *)encrypt));
    	/* 最后调用 MD5Final 获取最终结果 */
    	MD5Final(&md5, decrypt);

最终，在数组`decrypt`中存放的就是最终计算结果！

# 附件 #

1.  [MD5 算法 官方文档 rfc1321][MD5 _ _ rfc1321]

[https_www.ietf.org]: https://www.ietf.org/
[MD5]: /images/20220418/e21beaff6b5a41bf9e296d4985664461.png
[MD5 1]: https://en.wikipedia.org/wiki/MD5
[MD5 2]: /images/20220418/d012d7630a5a49b09974c04bdec4bad9.png
[MD5 _ _ rfc1321]: https://download.csdn.net/download/zcshoucsdn/10773415