【密码学】轻松理解“加盐”的原理与java实现

一、什么是加盐？

1.背景

        现在很多公司后台以hash值形式存储用户密码（虽然本文以MD5哈希函数为例，但becrypt函数最常用的），用于哈希函数存在碰撞的特性，当后台数据库被攻击然后获取到用户密码哈希值时，还是能通过一定的方法（比如彩虹表攻击）破解用户密码。

举个例子：http://www.cmd5.com/

能破解。

2.加盐原理简介

        简单来说：由原来的H(p)变成了H（p+salt）,相当于哈希函数H发生了变化，每次哈希计算使用的salt是随机的

        H如果发生了改变，则已有的彩虹表数据就完全无法使用，必须针对特定的H重新生成，这样就提高了破解的难度。

二、如何加盐？

        如何加盐，不同的哈希算法不同的公司不尽相同但思路都是差不多的。本文以MD5的一个简单加盐处理为例，讲解加盐的java实现：

1.生成盐

[html]  view plain  copy

1. private static char[] hex = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};  
2.   
3.     /**  
4.      * @Author: DavidHuang  
5.      * @Time: 2018/5/10 21:14  
6.      * @return: salt  
7.      * @params:  
8.      * @Descrption: 自定义简单生成盐，是一个随机生成的长度为16的字符串，每一个字符是随机的十六进制字符  
9.      */  
10.     public static String salt() {  
11.         Random random = new Random();  
12.         StringBuilder sb = new StringBuilder(16);  
13.         for (int i = 0; i < sb.capacity(); i++) {  
14.             sb.append(hex[random.nextInt(16)]);  
15.         }  
16.         return sb.toString();  
17.     }  

        这只是一个生成盐的想法而已，你可以按自己的想法来，只要保证每次执行生成的盐随机即可。

2.输入加盐

[java]  view plain  copy

1. String inputWithSalt = inputStr + salt;//加盐，输入加盐  

       加盐非常简单吧

3.输出带盐

        输出带盐是我自己取的一个名字而已，这个过程可选不要。实际上是将这次哈希计算过程用到的salt存储到这次hash值中，用于后面进行验证密码时进行hash计算，即注册存储密码时和登陆验证密码时用到的salt要一样，免除了另存hash操作。

[html]  view plain  copy

1. /**  
2. *@Author: DavidHuang  
3. *@Time: 2018/5/11 14:47  
4. *@return:  
5. *@params: [inputStr, type] inputStr是输入的明文;type是处理类型，0表示注册存hash值到库时，1表示登录验证时  
6. *@Descrption:  MD5加盐，盐的获取分两种情况;输入明文加盐；输出密文带盐(将salt存储到hash值中)  
7. */  
8. public static String MD5WithSalt(String inputStr, int type) {  
9.     try {  
10.         MessageDigest md = MessageDigest.getInstance("MD5");//申明使用MD5算法,更改参数为"SHA"就是SHA算法了  
11.   
12.         String salt = ;  
13.         if (type == 0) {//注册存hash值到库时，new salt  
14.             salt = salt();  
15.         } else if (type == 1) {//登录验证时，使用从库中查找到的hash值提取出的salt  
16.             String queriedHash=;//从库中查找到的hash值  
17.             salt=getSaltFromHash(queriedHash);  
18.         }  
19.   
20.         String inputWithSalt = inputStr + salt;//加盐，输入加盐  
21.         String hashResult = byte2HexStr(md.digest(inputWithSalt.getBytes()));//哈希计算,转换输出  
22.         System.out.println("加盐密文："+hashResult);  
23.   
24.         /*将salt存储到hash值中，用于登陆验证密码时使用相同的盐*/  
25.         char[] cs = new char[48];  
26.         for (int i = 0; i < 48; i += 3) {  
27.             cs[i] = hashResult.charAt(i / 3 * 2);  
28.             cs[i + 1] = salt.charAt(i / 3);//输出带盐，存储盐到hash值中;每两个hash字符中间插入一个盐字符  
29.             cs[i + 2] = hashResult.charAt(i / 3 * 2 + 1);  
30.         }  
31.         hashResult = new String(cs);  
32.         return hashResult;  
33.     } catch (Exception e) {  
34.         e.printStackTrace();  
35.         return e.toString();  
36.     }  
37. }  

        将salt存到hash值的操作也很简单，假定输出hash值是32字节，我们生成的是16字节的盐，我们可以简单的每两个hash字符中间插入一个盐字符。带盐也很简单吧。

三、后台密码存储和验证过程

        这里假定从前端传到后台的密码时明文。

1.注册时存储密码

（1）用户注册时输入的账号、密码p1从前端传到后台；

（2）后台随机生成一个salt；

（3）H(p1+salt)生成哈希值，将此哈希值带盐（存储salt）后的结果hash1存储到数据库中；

2.登录时验证密码

（1）用户登陆时输入的账号、密码p2从前端传到后台；

（2）用登陆账号在数据库中查询账号相同的记录，取其哈希值hash2

（3）从hash2获取salt（保证存储时和验证时salt相同）

（4）H（p2+salt）生成哈希值hash3，判断if（hash2==hash3）；若相等登陆成功，否则登陆失败。

四、java实现

哈希函数选择MD5，javaApi中MD5没有加盐的过程，需要我们自己实现加盐。关于Becrypt的加盐更简单，可以看我Becrypt那篇博客的源码。

[java]  view plain  copy

1. package EncryptAndDecrypt;  
2.   
3. import java.security.MessageDigest;  
4. import java.util.Random;  
5.   
6. /** 
7.  * 散列加密之32位哈希值的MD5算法，调用JDK里的API 
8.  *ps：准确来说散列加密不是加密算法，因为它是不可逆的（只能加密，不能解密） 
9.  */  
10. public class MyMD5 {  
11.   
12.     private static char[] hex = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};  
13.   
14.     public static void main(String[] args) throws Exception {  
15.         String input = "123456";  
16.         System.out.println("MD5加密" + "\n"  
17.                          + "明文：" + input + "\n"  
18.                          + "无盐密文：" + MD5WithoutSalt(input));  
19.         System.out.println("带盐密文：" + MD5WithSalt(input,0));  
20.     }  
21.   
22.     /** 
23.     *@Author: DavidHuang 
24.     *@Time: 2018/5/11 14:55 
25.     *@return: 
26.     *@params: [inputStr] 输入明文 
27.     *@Descrption: 不加盐MD5 
28.     */  
29.     public static String MD5WithoutSalt(String inputStr) {  
30.         try {  
31.             MessageDigest md = MessageDigest.getInstance("MD5");//申明使用MD5算法,更改参数为"SHA"就是SHA算法了  
32.             return byte2HexStr(md.digest(inputStr.getBytes()));//哈希计算,转换输出  
33.         } catch (Exception e) {  
34.             e.printStackTrace();  
35.             return e.toString();  
36.         }  
37.   
38.     }  
39.   
40.     /** 
41.     *@Author: DavidHuang 
42.     *@Time: 2018/5/11 14:47 
43.     *@return: 
44.     *@params: [inputStr, type] inputStr是输入的明文;type是处理类型，0表示注册存hash值到库时，1表示登录验证时 
45.     *@Descrption:  MD5加盐，盐的获取分两种情况;输入明文加盐；输出密文带盐(将salt存储到hash值中) 
46.     */  
47.     public static String MD5WithSalt(String inputStr, int type) {  
48.         try {  
49.             MessageDigest md = MessageDigest.getInstance("MD5");//申明使用MD5算法,更改参数为"SHA"就是SHA算法了  
50.   
51.             String salt = ;  
52.             if (type == 0) {//注册存hash值到库时，new salt  
53.                 salt = salt();  
54.             } else if (type == 1) {//登录验证时，使用从库中查找到的hash值提取出的salt  
55.                 String queriedHash=;//从库中查找到的hash值  
56.                 salt=getSaltFromHash(queriedHash);  
57.             }  
58.   
59.             String inputWithSalt = inputStr + salt;//加盐，输入加盐  
60.             String hashResult = byte2HexStr(md.digest(inputWithSalt.getBytes()));//哈希计算,转换输出  
61.             System.out.println("加盐密文："+hashResult);  
62.   
63.             /*将salt存储到hash值中，用于登陆验证密码时使用相同的盐*/  
64.             char[] cs = new char[48];  
65.             for (int i = 0; i < 48; i += 3) {  
66.                 cs[i] = hashResult.charAt(i / 3 * 2);  
67.                 cs[i + 1] = salt.charAt(i / 3);//输出带盐，存储盐到hash值中;每两个hash字符中间插入一个盐字符  
68.                 cs[i + 2] = hashResult.charAt(i / 3 * 2 + 1);  
69.             }  
70.             hashResult = new String(cs);  
71.             return hashResult;  
72.         } catch (Exception e) {  
73.             e.printStackTrace();  
74.             return e.toString();  
75.         }  
76.     }  
77.   
78.   
79.     /** 
80.      * @Author: DavidHuang 
81.      * @Time: 2018/5/10 21:14 
82.      * @return: salt 
83.      * @params: 
84.      * @Descrption: 自定义简单生成盐，是一个随机生成的长度为16的字符串，每一个字符是随机的十六进制字符 
85.      */  
86.     public static String salt() {  
87.         Random random = new Random();  
88.         StringBuilder sb = new StringBuilder(16);  
89.         for (int i = 0; i < sb.capacity(); i++) {  
90.             sb.append(hex[random.nextInt(16)]);  
91.         }  
92.         return sb.toString();  
93.     }  
94.   
95.     /** 
96.      * @Author: DavidHuang 
97.      * @Time: 2018/5/11 14:08 
98.      * @return: 十六进制字符串 
99.      * @params: [bytes] 
100.      * @Descrption: 将字节数组转换成十六进制字符串 
101.      */  
102.     private static String byte2HexStr(byte[] bytes) {  
103.         /** 
104.          *@Author: DavidHuang 
105.          *@Time: 19:41 2018/5/10 
106.          *@return: java.lang.String 
107.          *@params:  * @param bytes 
108.          *@Descrption: 
109.          */  
110.         int len = bytes.length;  
111.         StringBuffer result = new StringBuffer();  
112.         for (int i = 0; i < len; i++) {  
113.             byte byte0 = bytes[i];  
114.             result.append(hex[byte0 >>> 4 & 0xf]);  
115.             result.append(hex[byte0 & 0xf]);  
116.         }  
117.         return result.toString();  
118.     }  
119.   
120.   
121.     /** 
122.     *@Author: DavidHuang 
123.     *@Time: 2018/5/11 14:32 
124.     *@return: 提取的salt 
125.     *@params: [hash] 3i byte带盐的hash值,带盐方法与MD5WithSalt中相同 
126.     *@Descrption:  从库中查找到的hash值提取出的salt 
127.     */  
128.     public static String getSaltFromHash(String hash){  
129.         StringBuilder sb=new StringBuilder();  
130.         char [] h=hash.toCharArray();  
131.         for(int i=0;i<hash.length();i+=3){  
132.             sb.append(h[i+1]);  
133.         }  
134.         return sb.toString();  
135.     }  
136.   
137. }  

第一次运行结果：

[html]  view plain  copy

1. MD5加密  
2. 明文：123456  
3. 无盐密文：E10ADC3949BA59ABBE56E057F20F883E  
4. 加盐密文：80D05C08F8879B2C84BA0C40143D224F  
5. 带盐密文：8D0D8053C0F8F6887791B2BC804B7A0EC4901543DD2B241F  

第二运行结果：

[html]  view plain  copy

1. MD5加密  
2. 明文：123456  
3. 无盐密文：E10ADC3949BA59ABBE56E057F20F883E  
4. 加盐密文：2CFFE57B054378D926A6FF14A1985F22  
5. 带盐密文：21CF7FE957CB0354C37B8DC9256AD6F0F174A719785AF222  

        可以看到对于相同明文，多次MD5哈希的无盐密文相同，带盐密文和加盐密文不同。由哈希函数的特征很容易明白无盐密文相同。由于每次哈希计算生成的salt是随机的，相当于每次哈希函数不同，所以带盐密文和加盐密文不同。

由此可以看出加盐后安全性更高了吧。

参考：https://blog.csdn.net/dingsai88/article/details/51637977

          https://blog.csdn.net/hao_hl1314/article/details/53141005

原文链接：https://blog.csdn.net/DavidHuang2017/article/details/80283469