数据加密方法总结---散列函数加密（彩虹表、MD、SHA、HMAC）

1单向加密

特点：

1. 雪崩效应、定长输出、不可逆；
2. 可以确保数据的完整性；
3. 主要算法：MD5（message digest algorithm）及其家族、SHA（secure hash algorithm）家族等

单向散列算法就是哈希算法——将任意长度的信息压缩到某一固定长度（信息摘要）的函数（该过程不可逆）。

彩虹表

彩虹表不是“密码-明文”的存储。

从$c=hash(m)$逆向得到原始明文有三种方法：

1. 暴力破解；
2. 字典法：提前构建一个“明文–密文”对应的大数据库，破解时直接进行查找，但是这样的数据库维护起来十分麻烦且安全性难以维护；
3. 构建彩虹表：在字典法的基础上改进，以时间换空间。

因为存储所有的明文-密文对需要太多的空间，所以使用一种方法来减少存储空间的需求——预计算的哈希链集。

其中H函数是需要破解的哈希函数。R函数是构建这条链时定义的一个函数：它的值域和定义域与H函数相反，通过R函数可以将哈希值归约为一个与原文相同格式的值。对R函数唯一的要求就是可以把任意哈希值映射成特定字符的纯文本值。

这样的彩虹表只需要存储开头和结尾的节点。

彩虹表的使用方法：

1. 首先把给定的密文使用R函数归约为一个特定的字符，如4D5E6F使用R函数归约为ccc，发现恰好符合上述的哈希链，则证明4D5E6F对应的明文可能存在开头为aaa结尾为ccc的哈希链中，但是这个不一定是，因为可能H函数和R函数可能发生碰撞，不同的输入可能得到相同的输出；
2. 然后从aaa开始重复哈希链的生成过程，如果存在符合的条件，则破解成功；如果找不到满足条件的哈希链，则再次对已经经过一次R函数处理过的值再次使用R函数处理，如果处理k（k为哈希链中重复H函数和R函数的次数）次均没有找到，则证明该密文的明文不存在该哈希链中。

彩虹表的防御措施：

1. 主要是对H函数进行处理：加盐，因为一旦每个用户的“加盐量”不同，那么每个函数的H函数都不一样，产生的彩虹表也就不同；
2. 提高H函数的计算难度，这样的话意味着彩虹表的生成时间会大大增加，但是同时破解的难度也会对应的增加；

彩虹表存在的一些问题：

1. 对R函数要求特别高：要减少碰撞率，因为一旦碰撞率高的话，哈希链能解密的明文数量远远达不到理论的数量，所以可能会造成大量的容易和重复，所以R函数需要尽量保证输出值在值域内均匀分布，以尽量减少碰撞；

MD5及其类似算法

MD4（message digest 信息摘要）-3轮 × 16步–输出128位

算法步骤：

1. 数据填充：首先将数据的位数填充到512的倍数（和MD5的一样）；

2. 分组处理：将数据划分为512位每组，再对每一组分别进行处理；

3. 将每组512位的数据划分为16个子分块，处理数据段的三个函数：

   1. $F(X,Y,Z)=(X\&Y)|((\sim X)\&Z)$
   2. $G(X,Y,Z)=(X\&Z)|(X\&Z)|(Y\&Z)$
   3. $H(X,Y,Z)=X^{\wedge }{Y}^{\wedge }Z$

   然后对处理好的数据以512位为一个单位进行处理，每个单位的数据都要进行3轮的逻辑处理，在3轮中分别使用不同的函数$F、G、H$，每一轮以ABCD和当前的单位数据为输入，处理后存储到四个32位的寄存器$A、B、C、D$中，如此进行循环;

4. 输出：进行步骤3的循环，如果当前的已经是最后一个单位的数据，则将四个寄存器内的变量进行顺序拼接，即为MD5的输出结果。

MD5（message digest 信息摘要）-4轮 × 16步–输出128位

简单来说，MD5就是把数据以512位进行分组，来处理输入的信息，每一组后面再划分成16个32位子分组，经过一系列处理后，输出一个由4个32位分组组成的数据，这4个32位分组级联，形成一个128位散列值。

算法步骤：

1. 按位补充数据：将数据进行填充，要求数据的最终位数对512取模运算，结果为448，即数据补位后，其位数距离512的整数倍只差64。需要注意的是，补位位数为1~512，也就意味着即便现有的数据位数满足上面的条件，也要进行补位。==补位的实现过程：==首先在数据后面补一个1，然后一直补0，直至满足要求；

2. 扩展长度：完成补位后，将一个表示数据原始长度的64位的数据放在最后（如果原数据的长度大于$2^{64}$，则只存储低64位的值，即数据长度 % $2^{64}$），此时，数据的长度正好为512的倍数；

3. 初始化MD缓存器：因为MD5最终输出的是一个128位的散列值，所以需要四个32位的寄存器$A,B,C,D$，将其分别初始化为：

   1. A：0x 67 45 23 01
   2. B：0x ef cd ab 89
   3. C：0x 98 ba dc fe
   4. D：0x 10 32 54 76

   这样初始化的原因是——进行小端表示后，四个缓存变量连起来就是（小端表示法：将最低位放在最高位，依次进行调换，如0x 12 34 56 78，小端表示为0x 78 56 34 12）：

   0x 01 23 45 67 89 ab cd ef fe dc ba 98 76 54 32 10

4. 处理数据段：首先定义四个函数：（$\&、\sim 、|、\oplus$）分别表示AND、NOT、OR、XOR

   1. $F(X,Y,Z)=(X\&Y)|((\sim X)\&Z)$
   2. $G(X,Y,Z)=(X\&Z)|((\sim Z)\&Y)$
   3. $H(X,Y,Z)=X\oplus Y\oplus Z$
   4. $I(X,Y,Z)=Y\oplus (X|(\sim Z))$

   然后对处理好的数据以512位为一个单位进行处理，每个单位的数据都要进行四轮的逻辑处理，在四轮中分别使用不同的函数$F、G、H、I$，每一轮以ABCD和当前的单位数据为输入，处理后存储到四个32位的寄存器$A、B、C、D$中，如此进行循环；

5. 输出：进行步骤4的循环，如果当前的已经是最后一个单位的数据，则将四个寄存器内的变量进行顺序拼接，即为MD5的输出结果。

==特性：==主要特点是不可逆，相同数据的MD5一定是相同的，而一般情况下，不同数据的MD5是一定不同的（存在极少的特殊情况）

1. ==压缩性：==任意长度的数据，经过处理后的MD5都是一样长度的——128位；
2. ==易于计算：==根据原始输入数据计算MD5非常简单且容易；
3. ==抗修改性：==因为MD5具有雪崩效应，所以对原始数据进行十分微小的修改，MD5也会产生非常不同的值，且差别非常大；
4. ==弱抗碰撞：==已知原数据及其MD5，想要找到一个具有相同MD5的数据是非常困难的（伪造数据非常困难）；
5. ==强抗碰撞：==想找到两个MD5相同的数据是非常困难的。

MD5的防御手段：

1. 加盐：在已有的明文上添加系统随机产生的盐值，每次密文对比之前也是先对输入的明文进行加盐，然后进行比对；

数据处理的过程就是每次把512位的数据压缩为128位的Hash值，压缩函数每一轮均使用16次对应的非线性布尔函数，每次均更新$A、B、C、D$的值，压缩函数为（其中$<<<s$表示左移S位，$M_j$表示第j个分组，其中$j\in [0,15]$，$t_i$表示$2^{32}\times abs(sin(i))$的整数部分，其中$i\in [1,64]$）：

1. $FF(a,b,c,d,M_j,s,t_i)=b+((a+F(b,c,d)+M_j+t_i)<<<s)$

2. $GG(a,b,c,d,M_j,s,t_i)=b+((a+G(b,c,d)+M_j+t_i)<<<s)$

3. $HH(a,b,c,d,M_j,s,t_i)=b+((a+H(b,c,d)+M_j+t_i)<<<s)$

4. $II(a,b,c,d,M_j,s,t_i)=b+((a+I(b,c,d)+M_j+t_i)<<<s)$

5. 这四轮（64步）是：
   第一轮
   FF(a,b,c,d,M0,7,0xd76aa478)
   FF(d,a,b,c,M1,12,0xe8c7b756)
   FF(c,d,a,b,M2,17,0x242070db)
   FF(b,c,d,a,M3,22,0xc1bdceee)
   FF(a,b,c,d,M4,7,0xf57c0faf)
   FF(d,a,b,c,M5,12,0x4787c62a)
   FF(c,d,a,b,M6,17,0xa8304613)
   FF(b,c,d,a,M7,22,0xfd469501)
   FF(a,b,c,d,M8,7,0x698098d8)
   FF(d,a,b,c,M9,12,0x8b44f7af)
   FF(c,d,a,b,M10,17,0xffff5bb1)
   FF(b,c,d,a,M11,22,0x895cd7be)
   FF(a,b,c,d,M12,7,0x6b901122)
   FF(d,a,b,c,M13,12,0xfd987193)
   FF(c,d,a,b,M14,17,0xa679438e)
   FF(b,c,d,a,M15,22,0x49b40821)
   第二轮
   GG(a,b,c,d,M1,5,0xf61e2562)
   GG(d,a,b,c,M6,9,0xc040b340)
   GG(c,d,a,b,M11,14,0x265e5a51)
   GG(b,c,d,a,M0,20,0xe9b6c7aa)
   GG(a,b,c,d,M5,5,0xd62f105d)
   GG(d,a,b,c,M10,9,0x02441453)
   GG(c,d,a,b,M15,14,0xd8a1e681)
   GG(b,c,d,a,M4,20,0xe7d3fbc8)
   GG(a,b,c,d,M9,5,0x21e1cde6)
   GG(d,a,b,c,M14,9,0xc33707d6)
   GG(c,d,a,b,M3,14,0xf4d50d87)
   GG(b,c,d,a,M8,20,0x455a14ed)
   GG(a,b,c,d,M13,5,0xa9e3e905)
   GG(d,a,b,c,M2,9,0xfcefa3f8)
   GG(c,d,a,b,M7,14,0x676f02d9)
   GG(b,c,d,a,M12,20,0x8d2a4c8a)
   第三轮
   HH(a,b,c,d,M5,4,0xfffa3942)
   HH(d,a,b,c,M8,11,0x8771f681)
   HH(c,d,a,b,M11,16,0x6d9d6122)
   HH(b,c,d,a,M14,23,0xfde5380c)
   HH(a,b,c,d,M1,4,0xa4beea44)
   HH(d,a,b,c,M4,11,0x4bdecfa9)
   HH(c,d,a,b,M7,16,0xf6bb4b60)
   HH(b,c,d,a,M10,23,0xbebfbc70)
   HH(a,b,c,d,M13,4,0x289b7ec6)
   HH(d,a,b,c,M0,11,0xeaa127fa)
   HH(c,d,a,b,M3,16,0xd4ef3085)
   HH(b,c,d,a,M6,23,0x04881d05)
   HH(a,b,c,d,M9,4,0xd9d4d039)
   HH(d,a,b,c,M12,11,0xe6db99e5)
   HH(c,d,a,b,M15,16,0x1fa27cf8)
   HH(b,c,d,a,M2,23,0xc4ac5665)
   第四轮
   II(a,b,c,d,M0,6,0xf4292244)
   II(d,a,b,c,M7,10,0x432aff97)
   II(c,d,a,b,M14,15,0xab9423a7)
   II(b,c,d,a,M5,21,0xfc93a039)
   II(a,b,c,d,M12,6,0x655b59c3)
   II(d,a,b,c,M3,10,0x8f0ccc92)
   II(c,d,a,b,M10,15,0xffeff47d)
   II(b,c,d,a,M1,21,0x85845dd1)
   II(a,b,c,d,M8,6,0x6fa87e4f)
   II(d,a,b,c,M15,10,0xfe2ce6e0)
   II(c,d,a,b,M6,15,0xa3014314)
   II(b,c,d,a,M13,21,0x4e0811a1)
   II(a,b,c,d,M4,6,0xf7537e82)
   II(d,a,b,c,M11,10,0xbd3af235)
   II(c,d,a,b,M2,15,0x2ad7d2bb)
   II(b,c,d,a,M9,21,0xeb86d391)

SHA算法家族（secure hash algorithm 安全哈希算法）(补充一下)

有很多种类：SHA-1、SHA-256、SHA-384、SHA-512等，分别可以产生160位、256位、384位、512位的散列值。

SHA-1

于MD5相比，存在以下区别

	MD5	SHA-1	SHA-256
输入长度	任意	不能超过$2^{64}$	任意
输出长度	128	160	256
每个数据块的处理步骤	4轮 × 16次 = 64次	4轮 × 20次 = 80次	64次
基本逻辑函数	4个	4个	6个
常数数量	64个$t_i$的取值+4个寄存器初始值	4个$K_t$的取值+5个寄存器的初始值	8个寄存器的初始值+64个$K_j$的取值
寄存器存储	小端存储	大端存储	大端存储

算法步骤：

1. 按位补充（与MD5一样，长度补充到512的整数倍-64，补位的数量范围在1-512）；

2. 扩展长度（与MD5一样，尾部加上64位表示原始长度的信息）；

3. 初始化MD缓存器：与MD5不同的是，这里使用了5个32位寄存器，且寄存器使用大端存储的方式，前四个包含的值大小与MD5的相同，具体为：

   1. $H_1$：0x 67 45 23 01
   2. $H_2$：0x ef cd ab 89
   3. $H_3$：0x 98 ba dc fe
   4. $H_4$：0x 10 32 54 76
   5. $H_5$：0x c3 d2 e1 f0

4. 处理数据段：首先定义四个函数：（$\&、\sim 、|、\oplus$）分别表示AND、NOT、OR、XOR

   1. $F(X,Y,Z)=(X\&Y)|((\sim X)\&Z),t\in [0,19]$
   2. $G(X,Y,Z)=X\oplus Y\oplus Z,t\in [20,39]$
   3. $H(X,Y,Z)=(X\&Y)|(Y\&Z)|(X\&Z),t\in [40,59]$
   4. $I(X,Y,Z)=X\oplus Y\oplus Z,t\in [60,79]$

   与MD5不同的是，这四个函数的使用方法不同，具体的使用范围详见上面的t的范围，其中$t$是步骤的索引值。

   每个数据段的长度为512位，处理方法和MD5一样，但是会将每个512位的数据先划分成16份子明文分组$M_t,t\in [0,15]$，每组32位，然后将16份子明文分组扩充为80份子明文分组$W[t],t\in [0,79]$，扩充方法为：

   $$\begin{gathered} W_t=M_t,t\in [0,15] \\ {W}_t=(W_{t-3}\oplus W_{t-8}\oplus W_{t-14}\oplus W_{t-16}),t\in [16,79] \end{gathered}$$

   对数据段的处理共四轮，每轮20步，共计80步。

   80轮的共用一个操作步骤：

   $$\begin{gathered} A=(A<<<5)+f(B,C,D)+E+W_t+K_t, \\ B=A, \\ C=(B<<<30), \\ D=C, \\ E=D \end{gathered}$$

   其中$f()$函数根据处理步骤的索引进行动态变化，$K_t$是固定常数，$W_t$是子明文分组$W[t]$

   其中$K_t$的取值：

   1. $K_t=5a827999,t\in [0,19]$
   2. $K_t=6ed9eba1,t\in [20,39]$
   3. $K_t=8f188cdc,t\in [40,59]$
   4. $K_t=ca62c1d6,t\in [60,79]$

5. 输出：最后将5个32位寄存器的数据取出，分别和A，B，C，D，E中的数据进行相加——$H_1=H_1+A,H_2=H_2+B,H_3=H_3+C,H_4=H_4+D,H_5=H_5+E$，然后进行拼接即为最终的160位的输出。

SHA-256

算法步骤：

1. 按位补充（与MD5、SHA-1一样，长度补充到512的整数倍-64，补位的数量范围在1-512）；

2. 扩展长度（与MD5、SHA-1一样，尾部加上64位表示原始长度的信息）；

3. 初始化MD缓存器：与MD5、SHA-1不同的是，这里使用了8个32位寄存器，且寄存器使用大端存储的方式，取值为前8个素数{2，3，5，7，11，13，17，19}的平方根的小数部分的前32位，如2的平方根为1.41421356…，就取小数部分的前32位：41421356…，然后转换为16进制数：0x6a09e667：

   1. $H_1=0x6a09e667$;
   2. $H_2=0xbb67ae85$;
   3. $H_3=0x3c6ef372$;
   4. $H_4=0xa54ff53a$;
   5. $H_5=0x510e527f$;
   6. $H_6=0x9b05688c$;
   7. $H_7=0x1f83d9ab$;
   8. $H_8=0x5be0cd19$;

4. 处理数据段：先定义6个函数：（$\&、\sim 、|、\oplus 、S^n、R^n$）分别表示AND、NOT、OR、XOR、循环右移n位、右移n位

   1. $Ch(X,Y,Z)=(X\&Y)\oplus ((\sim X)\&Z)$
   2. $Ma(X,Y,Z)=(X\&Y)\oplus (Y\&Z)\oplus (X\&Z)$
   3. ${\sum }_0(x)=S^2(x)\oplus S^{13}(x)\oplus S^{22}$
   4. ${\sum }_1(x)=S^6(x)\oplus S^{11}(x)\oplus S^{25}$
   5. ${\sigma }_0(x)=S^7(x)\oplus S^{18}(x)\oplus R^3$
   6. ${\sigma }_1(x)=S^{17}(x)\oplus S^{19}(x)\oplus R^{10}$

   每个数据段的长度为512位，处理方法和MD5一样，但是会将每个512位的数据先划分成16份子明文分组$M_t,t\in [0,15]$，每组32位，然后将16份子明文分组扩充为64份子明文分组$W[t],t\in [0,79]$，扩充方法为：

   $$\begin{gathered} W_t=M_t,t\in [0,15] \\ {W}_t=(W_{t-3}\oplus W_{t-8}\oplus W_{t-14}\oplus W_{t-16}),t\in [16,63] \end{gathered}$$

   假设完成扩展长度后数据长度为L，需要处理的数据块数量为$L/512=N$，处理步骤伪代码为：

   其中$H_i^0$分别对应初始的8个寄存器初始值$H_i$，$K_j$分别对应前64个素数{2，3，5，7，11，13…}立方根的小数部分的前32位，$W_j$为子明文分组。

   $\begin{array}{rl}for(i=1& \to N)---loop1\\ & a=H_1^{(i-1)}\\ & b=H_2^{(i-1)}\\ & c=H_3^{(i-1)}\\ & d=H_4^{(i-1)}\\ & e=H_5^{(i-1)}\\ & f=H_6^{(i-1)}\\ & g=H_7^{(i-1)}\\ & h=H_8^{(i-1)}\\ & \\ for& (j=0\to 63)---loop2\\ & T_1=h+\sum _1(e)+Ch(e,f,g)+K_j+W_j\\ & T_2=\sum _0(a)+M{a}_j(a,b,c)\\ & h=g\\ & g=f\\ & f=e\\ & e=d+T_1\\ & d=c\\ & c=b\\ & b=a\\ & a=T_1+T_2\\ end& --loop2\\ & \\ H_1^{(i)}& =a+H_1^{(i-1)}\\ H_2^{(i)}& =b+H_2^{(i-1)}\\ H_3^{(i)}& =c+H_3^{(i-1)}\\ H_4^{(i)}& =d+H_4^{(i-1)}\\ H_5^{(i)}& =e+H_5^{(i-1)}\\ H_6^{(i)}& =f+H_6^{(i-1)}\\ H_7^{(i)}& =g+H_7^{(i-1)}\\ H_8^{(i)}& =h+H_8^{(i-1)}\\ end--loop1& \end{array}$

5. 输出：最后将$H_1^N-H_8^N$拼接起来，形成256位的输出结果。

HMAC（hash message authentication code哈希信息鉴别码）

后续更新
------------2021.6.7日更新------------
首先是MAC（message authentication code信息鉴别码），MAC的实现由MAC算法+密钥+需要加密的明文信息三部分组成，其中发送方和接收方的密钥是一致的。

与Hash算法相比，Hash方法只能保证信息的完整性——信息摘要A是信息B生成的，而MAC可以确保信息的正确性和信息完整性——发送的是信息A而不是信息C。

对于HMAC而言，意味着MAC算法采用Hash函数，所以HMAC的加密强度取决于采用的Hash函数的加密强度、Hash函数的输出长度、Hash函数密钥的长度和质量。

HMAC会进行两次Hash函数计算，而提供的密钥会用来产生内部密钥和外部密钥。

1. 第一次进行Hash计算时，通过信息和内部密钥产生一个内部Hash；
2. 第二次进行Hash计算时，通过内部Hash和外部密钥产生HMAC的最终结果。

公式

其中

1. H表示Hash函数；
2. K是密钥；
3. ipad是内部密钥；
4. opad是外部密钥；
5. m是需要信息鉴别的信息；
6. 需要注意的是，如果K的长度大于Hash函数分块的数量，则先使用Hash函数对密钥K进行处理，然后再使用；

算法步骤（因为HMAC中间使用的是Hash函数，关于Hash函数的加密过程前文中已经包含，所以不再进行详细描述）（根据上面的叙述，HMAC除了Hash函数部分所需要的常数外，还需要提供以下几个常数：初始密钥K、内部密钥innerKey、外部密钥outerKey）：

1. 对初始密钥K进行处理：假设采用的Hash函数的分组每组大小为b位，如果K的长度大于b，则使用Hash函数进行处理$K^{\prime }=Hash(K)$；若原始的K或使用Hash函数处理过的K的长度小于b，则在右侧填充0，直至长度等于b；最终$K^{\prime }$的长度一定是等于b的；
2. 分别得到内部密钥和外部密钥：$ipad=K^{\prime }\oplus innerKey，opad=K^{\prime }\oplus outerKey$，其中inner是$b/8$个$00110110（十六进制36）$的重复相连（0011011000110110…共b/8个…00110110），outer是个$01011100（十六进制5c）$的重复相连；
3. 第一次Hash计算：在ipad后面拼接信息M，然后经过Hash函数得到内部Hash——h，此时的结果对于上面公式的$H((K^{\prime }\oplus ipad)||M)$，然后根据h的长度，进行填充，直至其长度为b，得到$h^{\prime }$；
4. 第二次Hash计算：在opad后面拼接第3步得到的$h^{\prime }$，然后经过Hash函数得到HMAC的输出结果。

需要注意的是，HMAC是信息鉴别码，所以它并不加密信息，而是把经过Hash处理过的信息作为认证码，并且信息必须要和HMAC得到的Hash值一起传输，进行鉴别时，拥有密钥的人对信息再次进行Hash，如果信息没有发生任何改变，得到的Hash值与接收到的Hash值将会是一致的。

简单来说就是，对于同一个密钥K，只有发送方A和接收方B持有该密钥，发送方根据密钥K对随机信息M（M的内容并不重要）采用HMAC算法进行处理，得到信息鉴别码$H_1$，将信息M和信息鉴别码$H_1$都传输给B，然后B根据密钥K对随机信息M采用同样的HMAC算法进行处理，若得到的信息鉴别码$H_2$与$H_1$完全一致，则证明发送方是A，注意，HMAC的作用是证明发送信息的人是A，而不是信息M的加密结果，一旦验证完身份，信息M就没用了。

因此Hash拥有了以下安全性：

1. 因为只有通信双方持有密钥，所以一旦信息在通信过程中被截取，第三方只能拥有随机信息M和用来验证的信息鉴别码$H_1$，因为不知道密钥，所以无法再次通过某一HMAC算法得到同样的信息鉴别码，而仅根据M和$H_1$也无法破解出密钥；
2. HMAC是时效性的，一旦使用完就失效，对应的密钥也失效。而对于加密算法而言，一旦算法被破解，之前的加密结果可能会被破解。