数据库常见的存储密码的方式有以下三种：

1. 明文
2. MD5加密
3. 加盐算法

首先明文肯定是不可取的，在数据库中明文存储密码风险实在是太大了。

MD5（Message Digest Algorithm 5）是一种常用的哈希函数，用于将任意长度的数据进行不可逆的加密处理。MD5 可以将输入的任意长度的数据转换为一个128位（16字节）的哈希值，通常表示为32个十六进制数字。

MD5 加密的特点包括：

1. 不可逆性：MD5 加密是不可逆的，即无法从加密后的结果还原出原始数据。
2. 固定长度输出：不论输入数据的长度如何，MD5 始终输出固定长度的哈希值。
3. 高速度：MD5 的计算速度较快。

尽管 MD5 具有上述特点，但由于其安全性较低，已被证明容易受到碰撞攻击（collision attack）和彩虹表攻击（rainbow table attack）的影响，因此在一些安全要求较高的场景中，已经不推荐单独使用 MD5 来加密密码等敏感信息。

解释一下碰撞攻击（collision attack）和彩虹表攻击（rainbow table attack）

碰撞攻击（collision attack）是指在密码学中，通过寻找两个不同的输入（消息、密码等），使它们经过哈希函数计算后得到相同的哈希值的攻击方式。对于哈希函数来说，由于输出空间有限，理论上总会存在不同的输入对应相同的输出，但好的哈希函数应该尽可能减小碰撞的概率。如果输入的信息得到的哈希值与密码的哈希值相同，那么这个密码就别破解了。

彩虹表攻击（Rainbow Table Attack）彩虹表是一种预先计算并存储大量明文密码与其对应哈希值的对照表。攻击者利用这个表来加速破解哈希值的过程。彩虹表攻击的核心思想是遍历预生成的彩虹表，通过比对哈希值，查找对应的明文密码或者原始数据。

因此为了保证数据库中用户隐私数据的安全性，通常会采用加盐算法。

在密码学中，"盐"（salt）是指在对密码进行哈希处理之前，向密码中添加的一段随机数据。这个随机数据可以是任意长度的，通常是一段随机生成的比特串，作为密码哈希过程中的附加输入。

添加盐值的作用包括：

1. 增加密码复杂度：通过向密码添加随机的盐值，可以大大增加密码的复杂度，使得相同的原始密码在加密后也会产生不同的哈希值，从而防止彩虹表攻击等破解手段的有效性。
2. 防止单纯的碰撞攻击：盐值可以确保即使两个用户使用相同的密码，最终存储的哈希值也是不同的，从而防止碰撞攻击。

举个例子，假设有两个用户使用相同的密码 "password"，如果不使用盐值，它们的哈希值将完全相同。但是如果为每一个用户的密码添加不同的盐值，即使密码相同，由于盐值不同，最终的哈希值也会不同。

通常来说，盐值会与原始密码拼接在一起，然后再进行哈希计算。

总的来说，添加盐值可以增加密码的安全性，减少被暴力破解或预先计算攻击的风险。在实际应用中，使用盐值是密码安全的重要一环。

下面我会介绍两种加盐算法的实现方案

手写一个加盐算法

加密的实现思路：

每次调用的时候都会随机生成一个盐值（随机、唯一） + 用户输入的密码（使用MD5） = 加密的密码，盐值(32位)  + 加密密码(32位) = 最终的密码格式

解密（验证密码）的实现思路：

• 解密的时候需要两个密码 ： 用户输入的明文待验证密码 、 存储在数据库中的最终密码（自定义格式： 盐值(32位)$加密后的密码(32位)）
• 解密（验证密码）的核心在于得到 盐值
• 解密的时候，首先从最终数据库中的密码中来得到盐值，之后将用户输入的明文待验证密码加上这个盐值，生成加密后的密码，然后使用盐值  + 加密后的密码 生成 最终密码格式，再与数据库中最终的密码格式进行比对
• 要是一样的，那就说明这个用户输入的密码是没有问题的，要是不对就说明密码输入错误

最重要的是先理解加盐 解密的实现思路，这是最核心的！！！

就算使用加盐算法来对密码加密，也不能保证就一定是安全的，可以针对一个盐值来生成一个彩虹表，暴力破解也是可以的，但是这只是破解了一个账号密码，所以破解的成本是极大的，当破解的成本远大于收益的时候，可以看做是安全的

解密（验证密码）具体的实现步骤：

• 从数据库中真正的最终密码中得到盐值
• 将用户输入的明文密码+盐值 = 加密后的密码（使用MD5）
• 使用盐值  + 加密后的密码 生成 最终密码（最终密码的格式）
• 对比生成的最终密码和数据库中的最终密码是否相等
• 要是相等就说明用户名和密码都是对的，要是不对，就说明密码输入错误

具体的加盐算法的工具类

package com.kjz.utils.common;

import org.springframework.util.DigestUtils;
import org.springframework.util.StringUtils;

import java.util.UUID;

/**
 * @author CSDN编程小猹
 * @data 2024/03/24
 * @description
 */
public class PasswordUtils{

    /**
     * 1.加盐并生成最终的密码
     * @param password 明文的密码
     * @return 最终生成的密码
     */
    public static String encrypt(String password){
        //a.产生盐值
        //UUID.randomUUID()会生成32位数字+4位-，是随机的唯一的，将4位-去掉就得到32位数字的盐值
        String salt = UUID.randomUUID().toString().replace("-","");
        //生成加盐后的密码(需要使用MD5)
        String saltPassword = DigestUtils.md5DigestAsHex((salt + password).getBytes());
        //生成最终的密码格式
        String finalPassword = salt + "$" + saltPassword;
        return finalPassword;
    }

    /**
     * 2.加盐并生成最终密码格式（方法一的重载），区别于上面的方法：这个方法是用来解密的，给定了盐值，生成一个最终密码，
     后面要和正确的最终密码进行比对
     * @param password 需要验证的明文密码
     * @param salt
     * @return
     */
    public static  String encrypt(String password, String salt){
        //1.生成一个加密后的密码
        String saltPassword = DigestUtils.md5DigestAsHex((salt + password).getBytes());
        //2.生成最终的密码（待验证）
        String finalPassword = salt + "$" + saltPassword;
        return finalPassword;
    }

    /**
     * 3.验证密码
     * @param inputPassword  登录用户输入的明文密码
     * @param finalPassword  数据库中实际的最终密码格式
     * @return
     */
    public static boolean check(String inputPassword, String finalPassword){
        //首先判断这两个参数到底有没有值,数据库中的最终密码是不是65位
        if(StringUtils.hasLength(inputPassword) && StringUtils.hasLength(finalPassword)
        && finalPassword.length() == 65){
            //a.首先从最终的密码中得到盐值
            //使用$将finalPassword划分成两个部分，前面的32位的部分就是盐值
            //注意：这里的$是被认为是一个通配符，所以要转义一下
            String salt = finalPassword.split("\\$")[0];
            //b.使用之前加密的方法，生成最终的密码格式（待验证）
            String checkPassword = encrypt(inputPassword,salt);
            if(checkPassword.equals(finalPassword)){
                return true;
            }
        }
        return false;
    }
}

SpringSecurity提供

要想使用spring security首先要先引入依赖（可以通过插件Edit Starters来引入依赖）

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

在spring security框架中在项目启动的时候，会自动注入登录的页面，在一般的项目中都是有自己的登录页面的，所以不需要自动注入登录，所以要将其去掉

在项目的启动类前面的@SpringBootApplication注解加上排除SecurityAutoConfiguration.class这个类对象就行了

package com.kjz.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;

//关闭spring security的验证
@SpringBootApplication(exclude = SecurityAutoConfiguration.class)
public class Demo3Application {
    public static void main(String[] args) {
        SpringApplication.run(Demo3Application.class, args);
    }
}

在单元测试中使用spring security中的密码加盐算法

package com.kjz.demo;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

@SpringBootTest
class Demo3ApplicationTests {

    @Test
    void contextLoads() {
        BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
        String str = "111";
        //进行加密
        String finalPassword = bCryptPasswordEncoder.encode(str);
        System.out.println(finalPassword);
        //验证密码
        String inputPassword1 = "123";
        String inputPassword2 = "111";
        //inputPassword是用户输入的密码（待验证），finalPassword是存储在数据库中的最终密码格式
        System.out.println(bCryptPasswordEncoder.matches(inputPassword1,finalPassword));
        System.out.println(bCryptPasswordEncoder.matches(inputPassword2,finalPassword));
    }

}

加密之后的最终密码格式： 

$2a10BXpuKmotUdqoS3rFE59anOTrSfk7gCYX5wfsg9ZblBHvc79EyVFOi

spring security中的最终密码的格式：

其实spring security的加盐算法就是bCryptPasswordEncoder对象的encode方法和matches方法

加密的时候encode方法传的参数是用户输入的密码

解密（验证）的时候，使用的matches方法的参数分别是用户输入的明文密码 和 数据库中最终密码格式

也可以使用SpringSecurity提供的MessageDigest包下的md5加密算法，自己手动封装成一个加盐算法的工具类

package com.kjz.utils.common;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
 * @author CSDN编程小猹
 * @data 2024/03/24
 * @description
 */
public class MD5Utils {

    /**
     * MD5加密
     * @param str
     * @return
     */
    public final static String encode(String str) {
        try {
            //创建具有指定算法名称的摘要
            MessageDigest md = MessageDigest.getInstance("MD5");
            //使用指定的字节数组更新摘要
            md.update(str.getBytes());
            //进行哈希计算并返回一个字节数组
            byte mdBytes[] = md.digest();
            String hash = "";
            //循环字节数组
            for (int i = 0; i < mdBytes.length; i++) {
                int temp;
                //如果有小于0的字节,则转换为正数
                if (mdBytes[i] < 0)
                    temp = 256 + mdBytes[i];
                else
                    temp = mdBytes[i];
                if (temp < 16)
                    hash += "0";
                //将字节转换为16进制后，转换为字符串
                hash += Integer.toString(temp, 16);
            }
            return hash;
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return "";
    }

    public static String encodeWithSalt(String numStr, String salt) {
        return encode(encode(numStr) + salt);
    }

    public static void main(String[] args) {
        System.out.println(encode("test"));//e10adc3949ba59abbe56e057f20f883e
        System.out.println(encodeWithSalt("123456","123456"));//5f1d7a84db00d2fce00b31a7fc73224f
    }
}

案例应用

下面使用加盐算法来做一个案例应用

用户信息表结构如下

登录注册时对应的加密逻辑如下：

注册->生成盐

登录->使用盐来配合验证

具体代码如下：

控制层controller:

package com.kjz.user.controller.v1;

import com.kjz.model.common.dtos.ResponseResult;
import com.kjz.model.user.dtos.LoginDto;
import com.kjz.user.service.ApUserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


@RestController
@RequestMapping("/api/v1/login")
@Api(value = "app端用户登录",tags = "app端用户登录")
public class ApUserLoginController {

    @Autowired
    private ApUserService apUserService;

    @PostMapping("/login_auth")
    @ApiOperation("用户登录")
    public ResponseResult login(@RequestBody LoginDto dto){
        return apUserService.login(dto);
    }
}

业务层service:

package com.kjz.user.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.kjz.model.common.dtos.ResponseResult;
import com.kjz.model.user.dtos.LoginDto;
import com.kjz.model.user.pojos.ApUser;

public interface ApUserService extends IService<ApUser>{

    /**
     * app端登录
     * @param dto
     * @return
     */
    public ResponseResult login(LoginDto dto);
    
}

实现类：

package com.kjz.user.service.impl;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.kjz.model.common.dtos.ResponseResult;
import com.kjz.model.common.enums.AppHttpCodeEnum;
import com.kjz.model.user.dtos.LoginDto;
import com.kjz.model.user.pojos.ApUser;
import com.kjz.user.mapper.ApUserMapper;
import com.kjz.user.service.ApUserService;
import com.kjz.utils.common.AppJwtUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.DigestUtils;

import java.util.HashMap;
import java.util.Map;


@Service
public class ApUserServiceImpl extends ServiceImpl<ApUserMapper, ApUser> implements ApUserService {

    @Override
    public ResponseResult login(LoginDto dto) {

        //1.正常登录（手机号+密码登录）
        if (!StringUtils.isBlank(dto.getPhone()) && !StringUtils.isBlank(dto.getPassword())) {
            //1.1查询用户
            ApUser apUser = getOne(Wrappers.<ApUser>lambdaQuery().eq(ApUser::getPhone, dto.getPhone()));
            if (apUser == null) {
                return ResponseResult.errorResult(AppHttpCodeEnum.DATA_NOT_EXIST,"用户不存在");
            }

            //1.2 比对密码
            String salt = apUser.getSalt();
            String pswd = dto.getPassword();
            pswd = DigestUtils.md5DigestAsHex((pswd + salt).getBytes());
            if (!pswd.equals(apUser.getPassword())) {
                return ResponseResult.errorResult(AppHttpCodeEnum.LOGIN_PASSWORD_ERROR);
            }
            //1.3 返回数据  jwt
            Map<String, Object> map = new HashMap<>();
            map.put("token", AppJwtUtil.getToken(apUser.getId().longValue()));
            apUser.setSalt("");
            apUser.setPassword("");
            map.put("user", apUser);
            return ResponseResult.okResult(map);
        } else {
            //2.游客  同样返回token  id = 0
            Map<String, Object> map = new HashMap<>();
            map.put("token", AppJwtUtil.getToken(0l));
            return ResponseResult.okResult(map);
        }
    }
}