密码如何“加盐加密”处理？程序员一定要掌握的知识

今天药忘吃喽~ 2023-09-25 18:12 25阅读 0赞

**目录**

前言

一、手写加盐算法

1.1、加密

1.1.1、加密思路

1.1.2、加密简图

1.1.3、代码实现

1.2、解密

1.2.1、解密思路

1.2.2、解密代码

1.3、验证

二、使用 Spring Security 框架实现加盐算法

--------------------

# 前言 #

--------------------

为什么要使用加盐的方式对密码进行加密？我们知道传统的 md5 加密方式是可以通过 “彩虹表” 很容易破解的，因为 md5 加密每次生成的密码都是固定的~ 为了解决这个问题，就出现了加盐加密方式，每次生成的密码都是不一样的~

接下来我会讲两种加盐加密方式（**手写加盐算法、使用 Spring Security 框架**），那么就一起来看一下使用加盐的方式进行加密和解密吧~

# 一、手写加盐算法 #

--------------------

实际上就是一个加密解密的过程~

## 1.1、加密 ##

### 1.1.1、加密思路 ###

加密的主要有以下几步：

1.  **产生随机盐值（32位）。**解释：这里可以使用 UUID 中的 randomUUID 方法生成一个长度为 36 位的随机盐值（格式为xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx (8-4-4-4-12)），而我们约定的格式中（完全由自己定义）不需要"-"，因此将产生的随机盐值先使用 toString 方法转化成字符串，最后用 replaceAll 方法将字符串中的 "-" 用空字符串代替即可。
2.  **将盐值和明文拼接起来，然后整体使用 md5 加密，得到密文（32位）。**解释：这里就是对明文进行加密的过程。
3.  **根据自己约定的格式，使用 “32位盐值 +&+ 32位加盐后得到的密文” 方式进行加密得到最终密码。**解释：我们这样去约定格式，是为了更容易的得到盐值（通过 split 以 $ 为分割符进行分割，得到的字符串数组下标 0 的就是我们需要的盐值），让我们能够解密。

> Ps：UUID的第一个部分与时间有关，如果你在生成一个UUID之后，过几秒又生成一个UUID，则第一个部分不同，其余相同。UUID的唯一缺陷在于生成的结果串会比较长。

### 1.1.2、加密简图 ###

![eaad121e19b64cfda1d8b0acb89f2bad.png][]

### 1.1.3、代码实现 ###

/**
         * 加盐并生成密码
         * @param password 用户输入的明文密码
         * @return 保存到数据库中的密码
         */
        public static String encrypt(String password) {
            // 产生盐值(32位)  这里要注意去掉 UUID 生成 -
            String salt = UUID.randomUUID().toString().replaceAll("-", "");
            // 生成加盐之后的密码((盐值 + 密码)整体 md5 加密)
            String saltPassword = DigestUtils.md5DigestAsHex((salt + password).getBytes());
            // 生成最终密码(保存到数据库中的密码)[自己约定的格式：32位盐值 +&+ 32位加盐后的密码]
            // 这样约定格式是为了解密的时候方便得到盐值
            String finalPassword = salt + "$" + saltPassword;
            return finalPassword;
        }

## 1.2、解密 ##

### 1.2.1、解密思路 ###

解密的一个大体思路如下：

1.  **用户输入的密码使用刚刚讲到的加密思路再进行加密一次。**解释：这里我们重载上面讲到的加密方法，需要传入两个参数，分别是用户输入的密码和盐值（这里的盐值我们可以通过对数据库中的最终加密密码进行字符串分割 $ 符号得到），然后对用户信息进行加密。
2.  将刚刚加密的密码 对比 数据库保存的用户加密的最终密码 是否一致即可。

通过上述思路可以知道，实习解密思路需要两个方法~

### 1.2.2、解密代码 ###

/**
         * 加盐生成密码(方法1的重载)
         * 此方法在验证密码的适合需要(将用户输入的密码使用同样的盐值加密后对比)
         * @param password 明文
         * @param salt 固定的盐值
         * @return 最终密码
         */
        public static String encrypt(String password, String salt) {
            // 生成加盐后的密码
            String saltPassword = DigestUtils.md5DigestAsHex((salt + password).getBytes());
            // 生成最终密码(约定格式: 32位 盐值 +&+ 32位加盐后的密码)
            String finalPassword = salt + "$" + saltPassword;
            return finalPassword;
        }
    
        /**
         * 验证密码
         * @param inputPassword 用户输入明文密码
         * @param finalPassword 数据库中保存的最终密码
         * @return
         */
        public static boolean check(String inputPassword, String finalPassword) {
            // 判空处理
            if(StringUtils.hasLength(inputPassword) && StringUtils.hasLength(finalPassword) &&
            finalPassword.length() == 65) {
                // 得到盐值(之前约定: $前面的就是盐值)
                String salt = finalPassword.split("\\$")[0];// 由于 $ 在这里也可以表示通配符，所以需要使用 \\ 进行转义
                // 使用之前的加密步骤将明文进行加密，生成最终密码
                String confirmPassword = PasswordUtils.encrypt(inputPassword, salt);
                // 对比两个最终密码是否相同
                return confirmPassword.equals(finalPassword);
            }
            return false;
        }

## 1.3、验证 ##

我们可以先将上述方法都封装在一个类中，测试的时候直接调用此类即可。

代码如下：

import org.springframework.util.DigestUtils;
    import org.springframework.util.StringUtils;
    
    import java.util.UUID;
    
    public class PasswordUtils {
    
        /**
         * 加盐并生成密码
         * @param password 用户输入的明文密码
         * @return 保存到数据库中的密码
         */
        public static String encrypt(String password) {
            // 产生盐值(32位)  这里要注意去掉 UUID 生成 -
            String salt = UUID.randomUUID().toString().replaceAll("-", "");
            // 生成加盐之后的密码((盐值 + 密码)整体 md5 加密)
            String saltPassword = DigestUtils.md5DigestAsHex((salt + password).getBytes());
            // 生成最终密码(保存到数据库中的密码)[自己约定的格式：32位盐值 +&+ 32位加盐后的密码]
            // 这样约定格式是为了解密的时候方便得到盐值
            String finalPassword = salt + "$" + saltPassword;
            return finalPassword;
        }
    
        /**
         * 加盐生成密码(方法1的重载)
         * 此方法在验证密码的适合需要(将用户输入的密码使用同样的盐值加密后对比)
         * @param password 明文
         * @param salt 固定的盐值
         * @return 最终密码
         */
        public static String encrypt(String password, String salt) {
            // 生成加盐后的密码
            String saltPassword = DigestUtils.md5DigestAsHex((salt + password).getBytes());
            // 生成最终密码(约定格式: 32位 盐值 +&+ 32位加盐后的密码)
            String finalPassword = salt + "$" + saltPassword;
            return finalPassword;
        }
    
        /**
         * 验证密码
         * @param inputPassword 用户输入明文密码
         * @param finalPassword 数据库中保存的最终密码
         * @return
         */
        public static boolean check(String inputPassword, String finalPassword) {
            // 判空处理
            if(StringUtils.hasLength(inputPassword) && StringUtils.hasLength(finalPassword) &&
            finalPassword.length() == 65) {
                // 得到盐值(之前约定: $前面的就是盐值)
                String salt = finalPassword.split("\\$")[0];// 由于 $ 在这里也可以表示通配符，所以需要使用 \\ 进行转义
                // 使用之前的加密步骤将明文进行加密，生成最终密码
                String confirmPassword = PasswordUtils.encrypt(inputPassword, salt);
                // 对比两个最终密码是否相同
                return confirmPassword.equals(finalPassword);
            }
            return false;
        }
    
    }

首先我们可以模拟用户注册，对密码进行连续的三次加密，观察最后结果，是否每次产生的密码都不一致~ 最后模拟用户登录，分别输入正确的密码和错误的密码，观察运行结果~

代码如下：

public static void main(String[] args) {
    		//用户注册时的密码
    		String password = "1234";
    		//分别进行三次解密，观察结果
    		String finalPassword = PasswordUtils.encrypt(password);
    		System.out.println(finalPassword);
    		System.out.println(PasswordUtils.encrypt(password));
    		System.out.println(PasswordUtils.encrypt(password));
    		//验证密码(用户登录)
    		String input1 = "1234";//正确密码
    		String input2= "12345";//错误密码
    		System.out.println("密码1为正确密码:" + PasswordUtils.check(input1, finalPassword));
    		System.out.println("密码2为错误密码:" + PasswordUtils.check(input2, finalPassword));
    	}

运行结果如下：

![88e41ea40f974a3db9f90c1ac090fa73.png][]

# 二、使用 **Spring Security 框架实现加盐算法** #

--------------------

首先需要引入 Spring Security 依赖

<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-security</artifactId>
    		</dependency>

具体实现：

实际上我们刚刚手写的加盐算法就是在模仿着写 Spring Security 的加盐算法的底层，因此使用上也差不多，直接上代码~

> Ps：值得注意的是，如果你只需要使用该框架中的加密方法，那么需要在文件的启动类 DemoApplication 中排除 Spring Security 框架的自检测机制（此框架有自己的登录验证机制，不关闭的话会多出一个登录页面）代码如下：
> 
>     @SpringBootApplication(exclude = {SecurityAutoConfiguration.class})//排除 Spring Security 自动加载

代码如下：

/**
    	 * 使用 spring Security 实现加盐
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		//加盐的工具类
    		BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
    		//用户注册时的密码
    		String password = "1234";
    		//加密(连续加密三次观察结果)
    		String finalPassword = passwordEncoder.encode(password);
    		System.out.println(finalPassword);
    		System.out.println(passwordEncoder.encode(password));
    		System.out.println(passwordEncoder.encode(password));
    		//模拟用户登录
    		String s1 = "1234";//正确密码
    		String s2 = "12345";//错误密码
    		System.out.println("输入正确的密码:" + passwordEncoder.matches(s1, finalPassword));
    		System.out.println("输入错误的密码:" + passwordEncoder.matches(s2, finalPassword));
    	}

![7afa23232d634d6cbc51f8936cc18812.gif][]

[eaad121e19b64cfda1d8b0acb89f2bad.png]: https://img-blog.csdnimg.cn/eaad121e19b64cfda1d8b0acb89f2bad.png
[88e41ea40f974a3db9f90c1ac090fa73.png]: https://img-blog.csdnimg.cn/88e41ea40f974a3db9f90c1ac090fa73.png
[7afa23232d634d6cbc51f8936cc18812.gif]: https://img-blog.csdnimg.cn/7afa23232d634d6cbc51f8936cc18812.gif