加盐实现分享

加盐”的安全及必要性：

现在很多公司密码加密的方式选择的是MD5，一些恶意的网络攻击通过一定的方法（比如彩虹表攻击等）破解用户密码，MD5很容易被攻破，如果加长密码的长度并不能很好的预防攻击，用户体验也受到了很大的限制.

---

加盐原理简介：

在用户的短密码后面加上一段随机的长字符，再计算 md5，这样反推出原始密码就变得非常困难，而且即使两个用户密码相同，数据库保存的密码也不一样；"加盐“已成为主流的加密选择.
下面图解一下加密过程

---

用户密码加密解决方案：

①设置用户登录次数

数据库添加字段，记录登录次数，标识判断即可

②MD5+加盐
注意：只有在添加用户的时候自动生成加密盐，后面比较的时候都是数据库查出来的；自动生成只在添加用户的时候使用就可以了
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实现

**

package EncryptAndDecrypt;
 
import java.security.MessageDigest;
import java.util.Random;
 
/**
 * 散列加密之32位哈希值的MD5算法，调用JDK里的API
 *ps：准确来说散列加密不是加密算法，因为它是不可逆的（只能加密，不能解密）
 */
public class MyMD5 {
 
    private static char[] hex = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
 
    public static void main(String[] args) throws Exception {
        String input = "123456";
        System.out.println("MD5加密" + "\n"
                         + "明文：" + input + "\n"
                         + "无盐密文：" + MD5WithoutSalt(input));
        System.out.println("带盐密文：" + MD5WithSalt(input,0));
    }
 
    /**
    *@params: [inputStr] 输入明文
    *@Descrption: 不加盐MD5
    */
    public static String MD5WithoutSalt(String inputStr) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");//申明使用MD5算法,更改参数为"SHA"就是SHA算法了
            return byte2HexStr(md.digest(inputStr.getBytes()));//哈希计算,转换输出
        } catch (Exception e) {
            e.printStackTrace();
            return e.toString();
        }
 
    }
 
    /**
    *@params: [inputStr, type] inputStr是输入的明文;type是处理类型，0表示注册存hash值到库时，1表示登录验证时
    *@Descrption:  MD5加盐，盐的获取分两种情况;输入明文加盐；输出密文带盐(将salt存储到hash值中)
    */
    public static String MD5WithSalt(String inputStr, int type) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");//申明使用MD5算法,更改参数为"SHA"就是SHA算法了
 
            String salt = null;
            if (type == 0) {//注册存hash值到库时，new salt
                salt = salt();
            } else if (type == 1) {//登录验证时，使用从库中查找到的hash值提取出的salt
                String queriedHash=null;//从库中查找到的hash值
                salt=getSaltFromHash(queriedHash);
            }
 
            String inputWithSalt = inputStr + salt;//加盐，输入加盐
            String hashResult = byte2HexStr(md.digest(inputWithSalt.getBytes()));//哈希计算,转换输出
            System.out.println("加盐密文："+hashResult);
 
            /*将salt存储到hash值中，用于登陆验证密码时使用相同的盐*/
            char[] cs = new char[48];
            for (int i = 0; i < 48; i += 3) {
                cs[i] = hashResult.charAt(i / 3 * 2);
                cs[i + 1] = salt.charAt(i / 3);//输出带盐，存储盐到hash值中;每两个hash字符中间插入一个盐字符
                cs[i + 2] = hashResult.charAt(i / 3 * 2 + 1);
            }
            hashResult = new String(cs);
            return hashResult;
        } catch (Exception e) {
            e.printStackTrace();
            return e.toString();
        }
    }
 
 
    /**
     * @return: salt
     * @params:
     * @Descrption: 自定义简单生成盐，是一个随机生成的长度为16的字符串，每一个字符是随机的十六进制字符
     */
    public static String salt() {
        Random random = new Random();
        StringBuilder sb = new StringBuilder(16);
        for (int i = 0; i < sb.capacity(); i++) {
            sb.append(hex[random.nextInt(16)]);
        }
        return sb.toString();
    }
 
    /**
     * @return: 十六进制字符串
     * @params: [bytes]
     * @Descrption: 将字节数组转换成十六进制字符串
     */
    private static String byte2HexStr(byte[] bytes) {
        /**
         *@Author: DavidHuang
         *@Time: 19:41 2018/5/10
         *@return: java.lang.String
         *@params:  * @param bytes
         *@Descrption:
         */
        int len = bytes.length;
        StringBuffer result = new StringBuffer();
        for (int i = 0; i < len; i++) {
            byte byte0 = bytes[i];
            result.append(hex[byte0 >>> 4 & 0xf]);
            result.append(hex[byte0 & 0xf]);
        }
        return result.toString();
    }
 
 
    /**
    *@return: 提取的salt
    *@params: [hash] 3i byte带盐的hash值,带盐方法与MD5WithSalt中相同
    *@Descrption:  从库中查找到的hash值提取出的salt
    */
    public static String getSaltFromHash(String hash){
        StringBuilder sb=new StringBuilder();
        char [] h=hash.toCharArray();
        for(int i=0;i<hash.length();i+=3){
            sb.append(h[i+1]);
        }
        return sb.toString();
    }
 
}

分享到这里就结束了，希望我的分享可以帮到你，欢迎指正！

附源码：

package com.bdqn.it.util;

import java.math.BigInteger;
import java.security.MessageDigest;

public class MD5Util {
	
	// 加盐位置
	public static int[] salts = { 3, 8, 16, 22, 25 };
	// 加密
	public static String degst(String str){
		try {
			MessageDigest md5 = MessageDigest.getInstance("md5");
			byte[] bb = md5.digest(str.getBytes("utf-8"));
			
			// 1:不需要正负号，16:输出十六进制数据
			String r = new BigInteger(1, bb).toString(16);
			return r;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
	
	// 加盐方法
	public static String addSalt(String md5Str) {

		StringBuffer sb = new StringBuffer(md5Str);

		for (int n = salts.length - 1; n >= 0; n--) {
			int r = (int) (Math.random() * 10);

			// 插入随机数
			sb.insert(salts[n], r);
		}
		return sb.toString();
	}

	// 去盐方法
	public static String delSalt(String md5Str) {
		StringBuffer sb = new StringBuffer(md5Str);

		for (int n = 0; n < salts.length; n++) {
			sb.deleteCharAt(salts[n]);
		}
		return sb.toString();
	}
}