Java使用MD5加盐对密码进行加密处理,附注册和登录加密解密处理

缺乏、安全感 2023-09-24 19:42 86阅读 0赞

## 前言 ##

在开发的时候，有一些敏感信息是不能直接通过明白直接保存到数据库的。最经典的就是密码了。如果直接把密码以明文的形式入库，不仅会泄露用户的隐私，对系统也是极其的不厉，这样做是非常危险的。

那么我们就需要对这些铭文进行加密。

## Java常用加密手段 ##

现在市场是加密的方式已经有很多了，像Base64加密算法(编码方式)，MD5加密(消息摘要算法，验证信息完整性)，对称加密算法，非对称加密算法，数字签名算法，数字证书，CA认证等等。。

## 场景加密手段应用场景 ##

Base64应用场景：图片转码(应用于邮件，img标签，http加密)

MD5应用场景：密码加密、imei加密、文件校验

非对称加密：电商订单付款、银行相关业务

## MD5加密的风险 ##

如果直接使用MD5进行加密，其实是不安全的，这是是可以验证的，比如下面这个例子：

我直接使用MD5对123456的密码进行加密。看着很牛是吧，一串随机数，但是其实一碰就碎

![在这里插入图片描述][24ca3407acd74a0e97cf5472f9644b0b.png]

接下来就使用大家常用的一个网站进行破解：[MD5破解网站][MD5]

把刚才生成的MD5加密后的密码进行解密。

轻松破解，别说黑客了，这个网站都能破解出来，那风险有多大就不用说了

![在这里插入图片描述][6712e23f4adb42ac92f6a4899f194792.png]

所以我们需要采取一些措施，用于二次不强MD5加密后的密码，针对这种方式，现在大多数采取的方式就是加盐

## 什么是盐？ ##

盐（salt）一般是一个随机生成的字符串或者常量。我们将盐与原始密码连接在一起（放在前面或后面都可以），然后将拼接后的字符串加密。salt这个值是由系统随机生成的，并且只有系统知道。即便两个用户使用了同一个密码，由于系统为它们生成的salt值不同，散列值也是不同的。

加salt可以一定程度上解决这一问题。所谓加salt方法，就是加点“佐料”。其基本想法是这样的：当用户首次提供密码时（通常是注册时），由系统自动往这个密码里撒一些“佐料”，然后再散列。而当用户登录时，系统为用户提供的代码撒上同样的“佐料”，然后散列，再比较散列值，已确定密码是否正确。

这样也就变成了将密码+自定义的盐值来取MD5。但是如果黑客拿到了你的固定的盐值，那这样也不安全了。所以比较好的做法是用随机盐值。用户登陆时再根据用户名取到这个随机的盐值来计算MD5。

> 个人建议把盐设置成随机数而不是常量，这样更加安全。

## 引入MD5工具类 ##

坐标如下：

<dependency>
       <groupId>commons-codec</groupId>
       <artifactId>commons-codec</artifactId>
    </dependency>

![在这里插入图片描述][a34ca1265f494154a9d42971fd09ee29.png]

## 编写MD5加盐工具类 ##

这种对铭文加密的操作，我们可以封装成一个工具类，在这里我们主要进行对明文密码进行MD5加密，并且进行二次加盐加密，以及对比加盐后的密码和初始密码是否相同。

直接把全部代码附上：

package com.wyh.util;
    
    import org.apache.commons.codec.binary.Hex;
    
    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    import java.util.Random;
    
    /**
     * @Author 魏一鹤
     * @Description 将明文密码进行MD5加盐加密
     * @Date 23:18 2023/2/7
     **/
    public class SaltMD5Util {
        
    
        /**
         * @Author 魏一鹤
         * @Description 生成普通的MD5密码
         * @Date 23:17 2023/2/7
         **/
        public static String MD5(String input) {
        
            MessageDigest md5 = null;
            try {
        
                // 生成普通的MD5密码
                md5 = MessageDigest.getInstance("MD5");
            } catch (NoSuchAlgorithmException e) {
        
                return "check jdk";
            } catch (Exception e) {
        
                e.printStackTrace();
                return "";
            }
            char[] charArray = input.toCharArray();
            byte[] byteArray = new byte[charArray.length];
            for (int i = 0; i < charArray.length; i++)
                byteArray[i] = (byte) charArray[i];
            byte[] md5Bytes = md5.digest(byteArray);
            StringBuffer hexValue = new StringBuffer();
            for (int i = 0; i < md5Bytes.length; i++) {
        
                int val = ((int) md5Bytes[i]) & 0xff;
                if (val < 16)
                    hexValue.append("0");
                hexValue.append(Integer.toHexString(val));
            }
            return hexValue.toString();
        }
    
        /**
         * @Author 魏一鹤
         * @Description 生成盐和加盐后的MD5码，并将盐混入到MD5码中,对MD5密码进行加强
         * @Date 23:17 2023/2/7
         **/
        public static String generateSaltPassword(String password) {
        
            Random random = new Random();
            //生成一个16位的随机数，也就是所谓的盐
            /**
             * 此处的盐也可以定义成一个系统复杂点的常量,而不是非要靠靠随机数随机出来 两种方式任选其一 例如下面这行代码:
             * 盐加密 ：SALT的字符串是随意打的，目的是把MD5加密后的再次加密变得复杂
             * public static final String SALT = "fskdhfiuhjfshfjhsad4354%@!@#%3";
             **/
            StringBuilder stringBuilder = new StringBuilder(16);
            stringBuilder.append(random.nextInt(99999999)).append(random.nextInt(99999999));
            int len = stringBuilder.length();
            if (len < 16) {
        
                for (int i = 0; i < 16 - len; i++) {
        
                    stringBuilder.append("0");
                }
            }
            // 生成盐
            String salt = stringBuilder.toString();
            //将盐加到明文中，并生成新的MD5码
            password = md5Hex(password + salt);
            //将盐混到新生成的MD5码中，之所以这样做是为了后期更方便的校验明文和秘文，也可以不用这么做，不过要将盐单独存下来，不推荐这种方式
            char[] cs = new char[48];
            for (int i = 0; i < 48; i += 3) {
        
                cs[i] = password.charAt(i / 3 * 2);
                char c = salt.charAt(i / 3);
                cs[i + 1] = c;
                cs[i + 2] = password.charAt(i / 3 * 2 + 1);
            }
            return new String(cs);
        }
    
        /**
         * @Author 魏一鹤
         * @Description 验证明文和加盐后的MD5码是否匹配
         * @Date 23:16 2023/2/7
         **/
        public static boolean verifySaltPassword(String password, String md5) {
        
            //先从MD5码中取出之前加的盐和加盐后生成的MD5码
            char[] cs1 = new char[32];
            char[] cs2 = new char[16];
            for (int i = 0; i < 48; i += 3) {
        
                cs1[i / 3 * 2] = md5.charAt(i);
                cs1[i / 3 * 2 + 1] = md5.charAt(i + 2);
                cs2[i / 3] = md5.charAt(i + 1);
            }
            String salt = new String(cs2);
            //比较二者是否相同
            return md5Hex(password + salt).equals(new String(cs1));
        }
    
        /**
         * @Author 魏一鹤
         * @Description 生成MD5密码
         * @Date 23:16 2023/2/7
         **/
        private static String md5Hex(String src) {
        
            try {
        
                MessageDigest md5 = MessageDigest.getInstance("MD5");
                byte[] bs = md5.digest(src.getBytes());
                return new String(new Hex().encode(bs));
            } catch (Exception e) {
        
                return null;
            }
        }
    
        public static void main(String args[]) {
        
            // 原密码
            String password = "123456";
            System.out.println("明文(原生)密码：" + password);
            // MD5加密后的密码
            String MD5Password = MD5(password);
            System.out.println("普通MD5加密密码：" + MD5Password);
            // 获取加盐后的MD5值
            String SaltPassword = generateSaltPassword(password);
            System.out.println("加盐后的MD密码：" + SaltPassword);
            System.out.println("加盐后的密码和原生密码是否是同一字符串:" + verifySaltPassword(password, SaltPassword));
        }
    
    }

## 测试盐加密强度 ##

这样我们就可以简单的测试下，这传说中的盐是否真的这么厉害，还是刚才的套路，我们定义一个明文为123456的密码。然后再对生成的MD5密码进行加盐处理，分别进行破解，以及对比加盐后的密码和初始密码是否相同。

![在这里插入图片描述][a5183e859c9b4c40af886a17c3c00387.png]

拿着MD5的密码进行破解，不用想，基本就是一碰就碎

![在这里插入图片描述][7551aa92e8f84a22abe8ef7be9e184a7.png]

然后试试加了盐之后的把，你会发现它破解不了。

![在这里插入图片描述][c6e1d00d59924cdb9a12ba9b6f73724f.png]

有了这些的基础后，我们就可以对用户注册和登录分别进行加盐加密，以及破解密码对比是否一致了

## 注册加密 ##

其实很简单，再原有的密码上进行加密即可：

![在这里插入图片描述][245160bc0d4647fdbe274e26164e196b.png]

@PostMapping(value = "/save")
        public Result save(@RequestBody User user) {
        
            return userService.saveUser(user);
        }
      
    	@Override
        public Result saveUser(User user) {
        
            // 密码 进行MD5加盐再入库
            user.setPassword(SaltMD5Util.generateSaltPassword(user.getPassword()));
            // 默认头像
            user.setImage("http://localhost:9090/upload/defaultUserImage.jpg");
            if (this.save(user)) {
        
                return Result.ok(user);
            }
            return Result.fail("保存用户信息失败");
        }

接口简单测试下把，可以看到是以加密的方式入库的：

![在这里插入图片描述][ec425aeb903d45f1a35e75640f702553.png]

## 登录解密 ##

加密后入库了可不够，还要进行对比呢，随意登录也要处理下：

@GetMapping(value = "/login")
        public Result login(User user) {
        
            return userService.login(user);
        }
        
     public Result login(User user) {
        
            // 账号
            String account = user.getAccount();
            // 密码
            String password = user.getPassword();
            // 如果账号或者密码为空,返回错误信息
            if (StringUtils.isEmpty(account) || StringUtils.isEmpty(password)) {
        
                return Result.fail("账号和密码都不能为空！");
            }
            // 根据账号和密码查询对应的用户信息
            User loginUser = this.query()
                    .eq("account", account)
                    .one();
            if (!StringUtils.isEmpty(loginUser)) {
        
                // 获取该用户在数据库里面的加密过的密码
                String saltPassword = loginUser.getPassword();
                // 输入的密码和加密后的密码进行比较
                boolean passwordFlag = SaltMD5Util.verifySaltPassword(password, saltPassword);
                // 如果根据账号查询和校验加密密码失败,则返回错误信息
                if (StringUtils.isEmpty(loginUser) || !passwordFlag) {
        
                    return Result.fail("登录失败,账号或者密码错误！");
                }
                // 如果账号状态被禁用了
                if (loginUser.getStatus().equals(ACCOUNT_DISABLE.getCode())) {
        
                    return Result.fail("登录失败,该账号已被引用,请联系管理员！", loginUser);
                }
                // 存在的话返回查询到的用户信息
                return Result.ok(loginUser);
            }
            return Result.fail("登录失败,账号或者密码错误！");
        }

我们还以刚才注册的用户为例进行登录，可以看到虽然库里是加密后的密码，我们输入的是明文，但是一样可以匹配上的：

![在这里插入图片描述][a808e6ec32d94c959e87db35f763069e.png]

## 总结 ##

加密真的很重要，重要的信息千万不能以明文保存！！！

[24ca3407acd74a0e97cf5472f9644b0b.png]: https://img-blog.csdnimg.cn/24ca3407acd74a0e97cf5472f9644b0b.png
[MD5]: https://www.cmd5.com/
[6712e23f4adb42ac92f6a4899f194792.png]: https://img-blog.csdnimg.cn/6712e23f4adb42ac92f6a4899f194792.png
[a34ca1265f494154a9d42971fd09ee29.png]: https://img-blog.csdnimg.cn/a34ca1265f494154a9d42971fd09ee29.png
[a5183e859c9b4c40af886a17c3c00387.png]: https://img-blog.csdnimg.cn/a5183e859c9b4c40af886a17c3c00387.png
[7551aa92e8f84a22abe8ef7be9e184a7.png]: https://img-blog.csdnimg.cn/7551aa92e8f84a22abe8ef7be9e184a7.png
[c6e1d00d59924cdb9a12ba9b6f73724f.png]: https://img-blog.csdnimg.cn/c6e1d00d59924cdb9a12ba9b6f73724f.png
[245160bc0d4647fdbe274e26164e196b.png]: https://img-blog.csdnimg.cn/245160bc0d4647fdbe274e26164e196b.png
[ec425aeb903d45f1a35e75640f702553.png]: https://img-blog.csdnimg.cn/ec425aeb903d45f1a35e75640f702553.png
[a808e6ec32d94c959e87db35f763069e.png]: https://img-blog.csdnimg.cn/a808e6ec32d94c959e87db35f763069e.png