springboot项目数据库密码如何加密

前言

在我们日常开发中，我们可能很随意把数据库密码直接明文暴露在配置文件中，在开发环境可以这么做，但是在生产环境，是相当不建议这么做，毕竟安全无小事，谁也不知道哪天密码就莫名其妙泄露了。今天就来聊聊在springboot项目中如何对数据库密码进行加密

正文

方案一、使用druid数据库连接池对数据库密码加密
1、pom.xml引入druid包

为了方便其他的操作，这边直接引入druid的starter

	<dependency>
		<groupId>com.alibabagroupId>
		<artifactId>druid-spring-boot-starterartifactId>
		<version>${druid.version}version>
	dependency>

2、利用com.alibaba.druid.filter.config.ConfigTools生成公私钥

ps： 生成的方式有两种，一种利用命令行生成，一种直接写个工具类生成。本文示例直接采用工具类生成

工具类代码如下

package loss.reduction.utils;

import com.alibaba.druid.filter.config.ConfigTools;
import lombok.SneakyThrows;

import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;

/**
 * 数据库加密解密
 * @author leishen
 */
public class DruidEncryptorUtils  {


    private static String privateKey;

    private static String publicKey;

    static {
        try {
            String[] keyPair = ConfigTools.genKeyPair(512);
            privateKey = keyPair[0];
            System.out.println(String.format("privateKey-->%s",privateKey));
            publicKey = keyPair[1];
            System.out.println(String.format("publicKey-->%s",publicKey));
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchProviderException e) {
            e.printStackTrace();
        }
    }

    /**
     * 明文加密
     * @param plaintext
     * @return
     */
    @SneakyThrows
    public static String encode(String plaintext){
        System.out.println("明文字符串：" + plaintext);
        String ciphertext = ConfigTools.encrypt(privateKey,plaintext);
        System.out.println("加密后字符串：" + ciphertext);
        return ciphertext;
    }

    /**
     * 解密
     * @param ciphertext
     * @return
     */
    @SneakyThrows
    public static String decode(String ciphertext){
        System.out.println("加密字符串：" + ciphertext);
        String plaintext = ConfigTools.decrypt(publicKey,ciphertext);
        System.out.println("解密后的字符串：" + plaintext);

        return plaintext;
    }

    public static void main(String[] args) {
        String a="nydndev";
        String encode = DruidEncryptorUtils.encode(a);
        System.out.println("encode =" + encode);
        String decode = DruidEncryptorUtils.decode(encode);
        System.out.println("decode =" + decode);
    }
}

3、修改数据库的配置文件内容信息

a 、 修改密码
把密码替换成用DruidEncryptorUtils这个工具类生成的密码

password: 
$ {DATASOURCE_PWD:HB5FmUeAI1U81YJrT/T6awImFg1/Az5o8imy765WkVJouOubC2H80jqmZrr8L9zWKuzS/8aGzuQ4YySAkhywnA==}

b、 filter开启config

filter:
	config:
		enabled: true

c、配置connectionProperties属性

connection-properties: config.decrypt=true;config.decrypt.key=${spring.datasource.publickey}

ps： spring.datasource.publickey为工具类生成的公钥

附录： 完整数据库配置

spring:
	datasource:
	type: com.alibaba.druid.pool.DruidDataSource
	driverClassName: com.mysql.cj.jdbc.Driver
	url: ${DATASOURCE_URL:jdbc:mysql://localhost:3306/demo?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai}
	username: ${DATASOURCE_USERNAME:root}
	#工具类加密之后密码
	password: ${DATASOURCE_PWD:HB5FmUeAI1U81YJrT/T6awImFg1/Az5o8imy765WkVJouOubC2H80jqmZrr8L9zWKuzS/8aGzuQ4YySAkhywnA==}
	publickey: MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAIvP9xF4RCM4oFiu47NZY15iqNOAB9K2Ml9fiTLa05CWaXK7uFwBImR7xltZM1frl6ahWAXJB6a/FSjtJkTZUJECAwEAAQ==
	druid:
		# 初始连接数
		initialSize: 5
		# 最小连接池数量
		minIdle: 10
		# 最大连接池数量
		maxActive: 20
		# 配置获取连接等待超时的时间
		maxWait: 60000
		# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
		timeBetweenEvictionRunsMillis: 60000
		# 配置一个连接在池中最小生存的时间，单位是毫秒
		minEvictableIdleTimeMillis: 300000
		# 配置一个连接在池中最大生存的时间，单位是毫秒
		maxEvictableIdleTimeMillis: 900000
		# 配置检测连接是否有效
		validationQuery: SELECT 1 FROM DUAL
		testWhileIdle: true
		testOnBorrow: false
		testOnReturn: false
		webStatFilter:
		enabled: true
		statViewServlet:
		enabled: true
		# 设置白名单，不填则允许所有访问
		allow:
		url-pattern: /druid/*
		# 控制台管理用户名和密码
		login-username:
		login-password:
		filter:
		stat:
		enabled: true
		# 慢SQL记录
		log-slow-sql: true
		slow-sql-millis: 1000
		merge-sql: true
		wall:
		config:
		multi-statement-allow: true
		config:
		enabled: true
		connection-properties: config.decrypt=true;config.decrypt.key=${spring.datasource.publickey}

方案二：使用jasypt对数据库密码加密
1、pom.xml引入jasypt包

	<dependency>
		<groupId>com.github.ulisesbocchiogroupId>
		<artifactId>jasypt-spring-boot-starterartifactId>
		<version>${jasypt.verison}version>
	dependency>

2、利用jasypt提供的工具类对明文密码进行加密

加密工具类如下

public final class JasyptEncryptorUtils {
 
	private static final String salt = "lybgeek";
	 
	private static BasicTextEncryptor basicTextEncryptor = new BasicTextEncryptor();
	 
	static {
	basicTextEncryptor.setPassword(salt);
	}
	 
	private JasyptEncryptorUtils(){}
 
	/**
	* 明文加密
	* @param plaintext
	* @return
	*/
	public static String encode(String plaintext){
		System.out.println("明文字符串：" + plaintext);
		String ciphertext = basicTextEncryptor.encrypt(plaintext);
		System.out.println("加密后字符串：" + ciphertext);
		return ciphertext;
	}
 
	/**
	* 解密
	* @param ciphertext
	* @return
	*/
	public static String decode(String ciphertext){
		System.out.println("加密字符串：" + ciphertext);
		ciphertext = "ENC(" + ciphertext + ")";
		if (PropertyValueEncryptionUtils.isEncryptedValue(ciphertext)){
		String plaintext = PropertyValueEncryptionUtils.decrypt(ciphertext,basicTextEncryptor);
		System.out.println("解密后的字符串：" + plaintext);
		return plaintext;
		}
		System.out.println("解密失败");
		return "";
	}
}

3、修改数据库的配置文件内容信息

a、 用ENC包裹用JasyptEncryptorUtils 生成的加密串

password: ${DATASOURCE_PWD:ENC(P8m43qmzqN4c07DCTPey4Q==)}
b、 配置密钥和指定加解密算法

jasypt:
	encryptor:
	password: lybgeek
	algorithm: PBEWithMD5AndDES
	iv-generator-classname: org.jasypt.iv.NoIvGenerator

因为我工具类使用的是加解密的工具类是BasicTextEncryptor，其对应配置加解密就是PBEWithMD5AndDES和org.jasypt.iv.NoIvGenerator

ps： 在生产环境中，建议使用如下方式配置密钥，避免密钥泄露

java -jar -Djasypt.encryptor.password=lybgeek
附录： 完整数据库配置

spring:
	datasource:
		type: com.alibaba.druid.pool.DruidDataSource
		driverClassName: com.mysql.cj.jdbc.Driver
		url: ${DATASOURCE_URL:ENC(kT/gwazwzaFNEp7OCbsgCQN7PHRohaTKJNdGVgLsW2cH67zqBVEq7mN0BTIXAeF4/Fvv4l7myLFx0y6ap4umod7C2VWgyRU5UQtKmdwzQN3hxVxktIkrFPn9DM6+YahM0xP+ppO9HaWqA2ral0ejBCvmor3WScJNHCAhI9kHjYc=)}
		username: ${DATASOURCE_USERNAME:ENC(rEQLlqM5nphqnsuPj3MlJw==)}
		password: ${DATASOURCE_PWD:ENC(P8m43qmzqN4c07DCTPey4Q==)}
		druid:
			# 初始连接数
			initialSize: 5
			# 最小连接池数量
			minIdle: 10
			# 最大连接池数量
			maxActive: 20
			# 配置获取连接等待超时的时间
			maxWait: 60000
			# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
			timeBetweenEvictionRunsMillis: 60000
			# 配置一个连接在池中最小生存的时间，单位是毫秒
			minEvictableIdleTimeMillis: 300000
			# 配置一个连接在池中最大生存的时间，单位是毫秒
			maxEvictableIdleTimeMillis: 900000
			# 配置检测连接是否有效
			validationQuery: SELECT 1 FROM DUAL
			testWhileIdle: true
			testOnBorrow: false
			testOnReturn: false
			webStatFilter:
			enabled: true
			statViewServlet:
			enabled: true
			# 设置白名单，不填则允许所有访问
			allow:
			url-pattern: /druid/*
			# 控制台管理用户名和密码
			login-username:
			login-password:
			filter:
			stat:
			enabled: true
			# 慢SQL记录
			log-slow-sql: true
			slow-sql-millis: 1000
			merge-sql: true
			wall:
			config:
			multi-statement-allow: true
			jasypt:
			encryptor:
			password: lybgeek
			algorithm: PBEWithMD5AndDES
			iv-generator-classname: org.jasypt.iv.NoIvGenerator

方案三：自定义实现
实现原理： 利用spring后置处理器修改DataSource

1、自定义加解密工具类

/**
* 利用hutool封装的加解密工具，以AES对称加密算法为例
*/
public final class EncryptorUtils {
	 
		private static String secretKey;
		 
		static {
			secretKey = Hex.encodeHexString(SecureUtil.generateKey(SymmetricAlgorithm.AES.getValue()).getEncoded());
			System.out.println("secretKey-->" + secretKey);
			System.out.println("--------------------------------------------------------------------------------------");
		}
		 
		/**
		* 明文加密
		* @param plaintext
		* @return
		*/
		@SneakyThrows
		public static String encode(String plaintext){
			System.out.println("明文字符串：" + plaintext);
			byte[] key = Hex.decodeHex(secretKey.toCharArray());
			String ciphertext = SecureUtil.aes(key).encryptHex(plaintext);
			System.out.println("加密后字符串：" + ciphertext);
			return ciphertext;
		}
		 
		/**
		* 解密
		* @param ciphertext
		* @return
		*/
		@SneakyThrows
		public static String decode(String ciphertext){
			System.out.println("加密字符串：" + ciphertext);
			byte[] key = Hex.decodeHex(secretKey.toCharArray());
			String plaintext = SecureUtil.aes(key).decryptStr(ciphertext);
			System.out.println("解密后的字符串：" + plaintext); 
			return plaintext;
		}
		 
		/**
		* 明文加密
		* @param plaintext
		* @return
		*/
		@SneakyThrows
		public static String encode(String secretKey,String plaintext){
			System.out.println("明文字符串：" + plaintext);
			byte[] key = Hex.decodeHex(secretKey.toCharArray());
			String ciphertext = SecureUtil.aes(key).encryptHex(plaintext);
			System.out.println("加密后字符串：" + ciphertext);
			return ciphertext;
		}
	 
		/**
		* 解密
		* @param ciphertext
		* @return
		*/
		@SneakyThrows
		public static String decode(String secretKey,String ciphertext){
			System.out.println("加密字符串：" + ciphertext);
			byte[] key = Hex.decodeHex(secretKey.toCharArray());
			String plaintext = SecureUtil.aes(key).decryptStr(ciphertext);
			System.out.println("解密后的字符串：" + plaintext); 
			return plaintext;
		}
	}

2、编写后置处理器

	public class DruidDataSourceEncyptBeanPostProcessor implements BeanPostProcessor {
	 
	private CustomEncryptProperties customEncryptProperties;
	 
	private DataSourceProperties dataSourceProperties;
	 
	public DruidDataSourceEncyptBeanPostProcessor(CustomEncryptProperties customEncryptProperties, DataSourceProperties dataSourceProperties) {
		this.customEncryptProperties = customEncryptProperties;
		this.dataSourceProperties = dataSourceProperties;
	}
	 
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		if(bean instanceof DruidDataSource){
			if(customEncryptProperties.isEnabled()){
			DruidDataSource druidDataSource = (DruidDataSource)bean;
			System.out.println("--------------------------------------------------------------------------------------");
			String username = dataSourceProperties.getUsername();
			druidDataSource.setUsername(EncryptorUtils.decode(customEncryptProperties.getSecretKey(),username));
			System.out.println("--------------------------------------------------------------------------------------");
			String password = dataSourceProperties.getPassword();
			druidDataSource.setPassword(EncryptorUtils.decode(customEncryptProperties.getSecretKey(),password));
			System.out.println("--------------------------------------------------------------------------------------");
			String url = dataSourceProperties.getUrl();
			druidDataSource.setUrl(EncryptorUtils.decode(customEncryptProperties.getSecretKey(),url));
			System.out.println("--------------------------------------------------------------------------------------");
			}		 
		}
		return bean;
	}
}

3、修改数据库的配置文件内容信息

a 、 修改密码
把密码替换成用自定义加密工具类生成的加密密码

password: ${DATASOURCE_PWD:fb31cdd78a5fa2c43f530b849f1135e7}
b 、 指定密钥和开启加密功能

custom:
	encrypt:
	enabled: true
	secret-key: 2f8ba810011e0973728afa3f28a0ecb6

ps： 同理secret-key最好也不要直接暴露在配置文件中，可以用-Dcustom.encrypt.secret-key指定
附录： 完整数据库配置

spring:
datasource:
	type: com.alibaba.druid.pool.DruidDataSource
	driverClassName: com.mysql.cj.jdbc.Driver
	url: ${DATASOURCE_URL:dcb268cf3a2626381d2bc5c96f94fb3d7f99352e0e392362cb818a321b0ca61f3a8dad3aeb084242b745c61a1d3dc244ed1484bf745c858c44560dde10e60e90ac65f77ce2926676df7af6b35aefd2bb984ff9a868f1f9052ee9cae5572fa015b66a602f32df39fb1bbc36e04cc0f148e4d610a3e5d54f2eb7c57e4729c9d7b4}
	username: ${DATASOURCE_USERNAME:61db3bf3c6d3fe3ce87549c1af1e9061}
	password: ${DATASOURCE_PWD:fb31cdd78a5fa2c43f530b849f1135e7}
	druid:
		# 初始连接数
		initialSize: 5
		# 最小连接池数量
		minIdle: 10
		# 最大连接池数量
		maxActive: 20
		# 配置获取连接等待超时的时间
		maxWait: 60000
		# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
		timeBetweenEvictionRunsMillis: 60000
		# 配置一个连接在池中最小生存的时间，单位是毫秒
		minEvictableIdleTimeMillis: 300000
		# 配置一个连接在池中最大生存的时间，单位是毫秒
		maxEvictableIdleTimeMillis: 900000
		# 配置检测连接是否有效
		validationQuery: SELECT 1 FROM DUAL
		testWhileIdle: true
		testOnBorrow: false
		testOnReturn: false
		webStatFilter:
		enabled: true
		statViewServlet:
		enabled: true
		# 设置白名单，不填则允许所有访问
		allow:
		url-pattern: /druid/*
		# 控制台管理用户名和密码
		login-username:
		login-password:
		filter:
		stat:
		enabled: true
		# 慢SQL记录
		log-slow-sql: true
		slow-sql-millis: 1000
		merge-sql: true
		wall:
		config:
		multi-statement-allow: true
		custom:
		encrypt:
		enabled: true
		secret-key: 2f8ba810011e0973728afa3f28a0ecb6

总结

上面三种方案，个人比较推荐用jasypt这种方案，因为它不仅可以对密码加密，也可以对其他内容加密。而druid只能对数据库密码加密。至于自定义的方案，属于练手，毕竟开源已经有的东西，就不要再自己造轮子了。
最后还有一个注意点就是jasypt如果是高于2版本，且以低于3.0.3，会导致配置中心，比如apollo或者nacos的动态刷新配置失效（最新版的3.0.3官方说已经修复了这个问题）。