SSM项目中数据库连接properties文件加密

Spring配置文件中数据库配置文件properties文件的加密

思路：在项目开始运行之前，先使用加密程序把正确的明文密码进行加密得到密文信息，修改配置文件中的password为密文，在项目启动的时候要把这个密文进行解开为明文、让spring连接数据库使用。
参考文章来源

一、加密原因

数据库连接进行加密的主要目的是为了保证应用软件的数据的正确性，防止恶意修改。

在Spring配置文件中，将数据库配置信息存储在properties文件中可以方便地管理和维护应用程序的配置。然而，如果这些敏感信息（例如数据库用户名和密码）未加密，在不法分子的攻击下，被获取和滥用进行恶意攻击和数据泄漏的风险将会显著增加。

#这里db.properties文件中外露了数据库连接信息，这会导致数据库存在很大的安全隐患
db.username=root
db.password=123456
db.url=jdbc:mysql:///schoolproject?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
db.driverClass=com.mysql.cj.jdbc.Driver

二、对SSM项目中数据库连接加密流程

1. 首先，使用一个加密工具类实现对数据库连接的url、username、password、driverClass等明文信息通过工具类加密成密文。

package com.yjr.utils;

public class KaisaUtil {

    /***
     * 使用凯撒加密方式加密数据
     * @param orignal 原文
     * @param key 密钥
     * @return 加密后的字符
     */
    public static String encryptKaisa(String orignal, int key) {
        //将字符串转换为数组
        char[] chars = orignal.toCharArray();
        StringBuffer buffer = new StringBuffer();
        //遍历数组
        for(char aChar : chars) {
            //获取字符的ASCII编码
            int asciiCode = aChar;
            //偏移数据
            asciiCode += key;
            //将偏移后的数据转为字符
            char result = (char)asciiCode;
            //拼接数据
            buffer.append(result);
        }
        return buffer.toString();
    }

    /**
     * 使用凯撒加密方式解密数据
     *
     * @param encryptedData :密文
     * @param key           :密钥
     * @return : 源数据
     */
    public static String decryptKaiser(String encryptedData, int key) {
        // 将字符串转为字符数组
        char[] chars = encryptedData.toCharArray();
        StringBuilder sb = new StringBuilder();
        // 遍历数组
        for (char aChar : chars) {
            // 获取字符的ASCII编码
            int asciiCode = aChar;
            // 偏移数据
            asciiCode -= key;
            // 将偏移后的数据转为字符
            char result = (char) asciiCode;
            // 拼接数据
            sb.append(result);
        }
        return sb.toString();
    }
    public static void main(String[] args) {
        String str = "com.mysql.cj.jdbc.Driver";
        String encode = encryptKaisa(str,255);
        System.out.println("加密后："+encode);
        System.out.println(encode);
        String decode = decryptKaiser(encode, 255);
        System.out.println("解密后："+decode);
    }

2. 其次：将获取到密文数据后将db.properties中的明文改成密文

#数据库连接密文--此时数据库中的数据较为安全
db.username=űŮŮų
db.password=UVWXYZ
db.url=ũţšŢĹŬŸŲŰūĹĮĮĮŲŢŧŮŮūůűŮũŤŢųľŴŲŤŔŭŨŢŮţŤļųűŴŤĥŢŧŠűŠŢųŤűńŭŢŮţŨŭŦļŔœŅĬķĥŲŤűŵŤűœŨŬŤŹŮŭŤļŀŲŨŠĮŒŧŠŭŦŧŠŨ
db.driverClass=ŢŮŬĭŬŸŲŰūĭŢũĭũţšŢĭŃűŨŵŤű

3. 自定义PropertiesPersist 解密类

该类继承spring的读取配置文件的类使spring启动时会加载这个类进行解密(需要在配置文件里面配置这个类的名称才会进行加载)
本项目是在applicationContext.xml里面配置了

package com.yjr.config;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Properties;

import com.yjr.utils.KaisaUtil;
import org.springframework.util.DefaultPropertiesPersister;

//该类继承spring的读取配置文件的类使spring启动时会加载这个类进行解密(需要在配置文件里面配置这个类的名称才会进行加载)
//本项目是在applicationContext.xml里面配置了
//项目启动时候可以在这个类中打断点进入看解密过程
public class PropertiesPersist extends DefaultPropertiesPersister{
    @Override
    public void load(Properties props, InputStream is) throws IOException {

            //读取到配置文件(****..properties)信息内容
            Properties properties=new Properties();
            properties.load(is);
            //判断读取配置文件中的信息是否为password属性
            if(properties.get("db.password")!=null){
                System.out.println("==========密文======="+properties.get("db.password"));
                System.out.println("==========密文======="+properties.get("db.username"));
                System.out.println("==========密文======="+properties.get("db.url"));
                System.out.println("==========密文======="+properties.get("db.driverClass"));

                System.out.println("===================进行配置数据库密码解密、注入配置文件===");
                //进行解密
                String username= KaisaUtil.decryptKaiser(properties.get("db.username").toString().trim(),255);
                String driverClass= KaisaUtil.decryptKaiser(properties.get("db.driverClass").toString().trim(),255);
                String url= KaisaUtil.decryptKaiser(properties.get("db.url").toString().trim(),255);
                String password= KaisaUtil.decryptKaiser(properties.get("db.password").toString().trim(),36);
                System.out.println("解密后的password="+password);
                System.out.println("解密后的username="+username);
                System.out.println("解密后的url="+url);
                System.out.println("解密后的driverClass="+driverClass);
                //在写入到配置文件中
                properties.setProperty("db.password", password);
                properties.setProperty("db.username", username);
                properties.setProperty("db.driverClass", driverClass);
                properties.setProperty("db.url", url);
            }
            OutputStream outputStream=null;
            try {
                outputStream=new ByteArrayOutputStream();
                properties.store(outputStream, "");
                is=outStream2InputStream(outputStream);
                super.load(props, is);
                System.out.println("=========配置数据库密码解密、注入配置文件=========【Success】==");
                System.out.println("=======注入的明文密码======:" +properties.get("db.password"));
                System.out.println("=======注入的明文账号======:" +properties.get("db.username"));
                System.out.println("=======注入的明文url======:" +properties.get("db.url"));
                System.out.println("=======注入的明文driverClass=====:" +properties.get("db.driverClass"));
            } catch (Exception e) {
                try {
                    throw e;
                } catch (Exception e1) {
                    e1.printStackTrace();
                }
            }finally{
                outputStream.close();
            }
    }
    private InputStream outStream2InputStream(OutputStream out) {
        ByteArrayOutputStream bos=new ByteArrayOutputStream();
        bos=(ByteArrayOutputStream) out;
        ByteArrayInputStream swapSTream=new ByteArrayInputStream(bos.toByteArray());
        return swapSTream;
    }
}

4. 最后：在applicationContext.xml修改配置文件

<!--  首先：将原本的<context:property-placeholder location="classpath:db.properties"/> 修改为新的bean -->
     <!--    它定义了一个名为 configReader 的 Bean 对象，用于读取数据库配置文件 db.properties-->
    <bean id="configReader" class="org.springframework.beans.factory.config.PreferencesPlaceholderConfigurer">
    <!--        class="org.springframework.beans.factory.config.PreferencesPlaceholderConfigurer"：指定了这个 Bean 对象实现的类。-->
        <property name="locations">
            <list>
                <value>classpath*:db.properties</value>
            </list>
        </property>
    <!--        propertiesPersister 属性：表示将要使用一个自定义的 PropertiesPersist 类对象实现对配置文件中属性的解密操作。-->
        <property name="propertiesPersister">
    <!--            自定义解密类的全称-->
            <bean class="com.yjr.config.PropertiesPersist"/>
        </property>
    <!--       ignoreResourceNotFound 属性：设为 true； 表示即使没有找到这个配置文件也不会抛出异常。-->
        <property name="ignoreResourceNotFound" value="true"/>
    </bean>