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

前言

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

正文

方案一、使用druid数据库连接池对数据库密码加密

1、pom.xml引入druid包

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

1. <dependency>
2. <groupId>com.alibaba</groupId>
3. <artifactId>druid-spring-boot-starter</artifactId>
4. <version>${druid.version}</version>
5. </dependency>

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

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

工具类代码如下

1. /**
2. * alibaba druid加解密规则：
3. * 明文密码+私钥(privateKey)加密=加密密码
4. * 加密密码+公钥(publicKey)解密=明文密码
5. */
6. public final class DruidEncryptorUtils {
7.  
8. private static String privateKey;
9.  
10. private static String publicKey;
11.  
12. static {
13. try {
14. String[] keyPair = ConfigTools.genKeyPair(512);
15. privateKey = keyPair[0];
16. System.out.println(String.format("privateKey-->%s",privateKey));
17. publicKey = keyPair[1];
18. System.out.println(String.format("publicKey-->%s",publicKey));
19. } catch (NoSuchAlgorithmException e) {
20. e.printStackTrace();
21. } catch (NoSuchProviderException e) {
22. e.printStackTrace();
23. }
24. }
25.  
26. /**
27. * 明文加密
28. * @param plaintext
29. * @return
30. */
31. @SneakyThrows
32. public static String encode(String plaintext){
33. System.out.println("明文字符串：" + plaintext);
34. String ciphertext = ConfigTools.encrypt(privateKey,plaintext);
35. System.out.println("加密后字符串：" + ciphertext);
36. return ciphertext;
37. }
38.  
39. /**
40. * 解密
41. * @param ciphertext
42. * @return
43. */
44. @SneakyThrows
45. public static String decode(String ciphertext){
46. System.out.println("加密字符串：" + ciphertext);
47. String plaintext = ConfigTools.decrypt(publicKey,ciphertext);
48. System.out.println("解密后的字符串：" + plaintext);
49.  
50. return plaintext;
51. }

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

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

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

b、 filter开启config

1. filter:
2. config:
3. enabled: true

c、配置connectionProperties属性

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

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

附录： 完整数据库配置

1. spring:
2. datasource:
3. type: com.alibaba.druid.pool.DruidDataSource
4. driverClassName: com.mysql.cj.jdbc.Driver
5. url: ${DATASOURCE_URL:jdbc:mysql://localhost:3306/demo?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai}
6. username: ${DATASOURCE_USERNAME:root}
7. password: ${DATASOURCE_PWD:HB5FmUeAI1U81YJrT/T6awImFg1/Az5o8imy765WkVJouOubC2H80jqmZrr8L9zWKuzS/8aGzuQ4YySAkhywnA==}
8. publickey: MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAIvP9xF4RCM4oFiu47NZY15iqNOAB9K2Ml9fiTLa05CWaXK7uFwBImR7xltZM1frl6ahWAXJB6a/FSjtJkTZUJECAwEAAQ==
9. druid:
10. # 初始连接数
11. initialSize: 5
12. # 最小连接池数量
13. minIdle: 10
14. # 最大连接池数量
15. maxActive: 20
16. # 配置获取连接等待超时的时间
17. maxWait: 60000
18. # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
19. timeBetweenEvictionRunsMillis: 60000
20. # 配置一个连接在池中最小生存的时间，单位是毫秒
21. minEvictableIdleTimeMillis: 300000
22. # 配置一个连接在池中最大生存的时间，单位是毫秒
23. maxEvictableIdleTimeMillis: 900000
24. # 配置检测连接是否有效
25. validationQuery: SELECT 1 FROM DUAL
26. testWhileIdle: true
27. testOnBorrow: false
28. testOnReturn: false
29. webStatFilter:
30. enabled: true
31. statViewServlet:
32. enabled: true
33. # 设置白名单，不填则允许所有访问
34. allow:
35. url-pattern: /druid/*
36. # 控制台管理用户名和密码
37. login-username:
38. login-password:
39. filter:
40. stat:
41. enabled: true
42. # 慢SQL记录
43. log-slow-sql: true
44. slow-sql-millis: 1000
45. merge-sql: true
46. wall:
47. config:
48. multi-statement-allow: true
49. config:
50. enabled: true
51. connection-properties: config.decrypt=true;config.decrypt.key=${spring.datasource.publickey}

方案二：使用jasypt对数据库密码加密

1、pom.xml引入jasypt包

1. <dependency>
2. <groupId>com.github.ulisesbocchio</groupId>
3. <artifactId>jasypt-spring-boot-starter</artifactId>
4. <version>${jasypt.verison}</version>
5. </dependency>

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

加密工具类如下

1. public final class JasyptEncryptorUtils {
2.  
3. private static final String salt = "lybgeek";
4.  
5. private static BasicTextEncryptor basicTextEncryptor = new BasicTextEncryptor();
6.  
7. static {
8. basicTextEncryptor.setPassword(salt);
9. }
10.  
11. private JasyptEncryptorUtils(){}
12.  
13. /**
14. * 明文加密
15. * @param plaintext
16. * @return
17. */
18. public static String encode(String plaintext){
19. System.out.println("明文字符串：" + plaintext);
20. String ciphertext = basicTextEncryptor.encrypt(plaintext);
21. System.out.println("加密后字符串：" + ciphertext);
22. return ciphertext;
23. }
24.  
25. /**
26. * 解密
27. * @param ciphertext
28. * @return
29. */
30. public static String decode(String ciphertext){
31. System.out.println("加密字符串：" + ciphertext);
32. ciphertext = "ENC(" + ciphertext + ")";
33. if (PropertyValueEncryptionUtils.isEncryptedValue(ciphertext)){
34. String plaintext = PropertyValueEncryptionUtils.decrypt(ciphertext,basicTextEncryptor);
35. System.out.println("解密后的字符串：" + plaintext);
36. return plaintext;
37. }
38. System.out.println("解密失败");
39. return "";
40. }
41. }

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

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

1. password: ${DATASOURCE_PWD:ENC(P8m43qmzqN4c07DCTPey4Q==)}

b、 配置密钥和指定加解密算法

1. jasypt:
2. encryptor:
3. password: lybgeek
4. algorithm: PBEWithMD5AndDES
5. iv-generator-classname: org.jasypt.iv.NoIvGenerator

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

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

1. java -jar -Djasypt.encryptor.password=lybgeek

附录： 完整数据库配置

1. spring:
2. datasource:
3. type: com.alibaba.druid.pool.DruidDataSource
4. driverClassName: com.mysql.cj.jdbc.Driver
5. url: ${DATASOURCE_URL:ENC(kT/gwazwzaFNEp7OCbsgCQN7PHRohaTKJNdGVgLsW2cH67zqBVEq7mN0BTIXAeF4/Fvv4l7myLFx0y6ap4umod7C2VWgyRU5UQtKmdwzQN3hxVxktIkrFPn9DM6+YahM0xP+ppO9HaWqA2ral0ejBCvmor3WScJNHCAhI9kHjYc=)}
6. username: ${DATASOURCE_USERNAME:ENC(rEQLlqM5nphqnsuPj3MlJw==)}
7. password: ${DATASOURCE_PWD:ENC(P8m43qmzqN4c07DCTPey4Q==)}
8. druid:
9. # 初始连接数
10. initialSize: 5
11. # 最小连接池数量
12. minIdle: 10
13. # 最大连接池数量
14. maxActive: 20
15. # 配置获取连接等待超时的时间
16. maxWait: 60000
17. # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
18. timeBetweenEvictionRunsMillis: 60000
19. # 配置一个连接在池中最小生存的时间，单位是毫秒
20. minEvictableIdleTimeMillis: 300000
21. # 配置一个连接在池中最大生存的时间，单位是毫秒
22. maxEvictableIdleTimeMillis: 900000
23. # 配置检测连接是否有效
24. validationQuery: SELECT 1 FROM DUAL
25. testWhileIdle: true
26. testOnBorrow: false
27. testOnReturn: false
28. webStatFilter:
29. enabled: true
30. statViewServlet:
31. enabled: true
32. # 设置白名单，不填则允许所有访问
33. allow:
34. url-pattern: /druid/*
35. # 控制台管理用户名和密码
36. login-username:
37. login-password:
38. filter:
39. stat:
40. enabled: true
41. # 慢SQL记录
42. log-slow-sql: true
43. slow-sql-millis: 1000
44. merge-sql: true
45. wall:
46. config:
47. multi-statement-allow: true
48. jasypt:
49. encryptor:
50. password: lybgeek
51. algorithm: PBEWithMD5AndDES
52. iv-generator-classname: org.jasypt.iv.NoIvGenerator

方案三：自定义实现

实现原理： 利用spring后置处理器修改DataSource

1、自定义加解密工具类

1. /**
2. * 利用hutool封装的加解密工具，以AES对称加密算法为例
3. */
4. public final class EncryptorUtils {
5.  
6. private static String secretKey;
7.  
8. static {
9. secretKey = Hex.encodeHexString(SecureUtil.generateKey(SymmetricAlgorithm.AES.getValue()).getEncoded());
10. System.out.println("secretKey-->" + secretKey);
11. System.out.println("--------------------------------------------------------------------------------------");
12. }
13.  
14. /**
15. * 明文加密
16. * @param plaintext
17. * @return
18. */
19. @SneakyThrows
20. public static String encode(String plaintext){
21. System.out.println("明文字符串：" + plaintext);
22. byte[] key = Hex.decodeHex(secretKey.toCharArray());
23. String ciphertext = SecureUtil.aes(key).encryptHex(plaintext);
24. System.out.println("加密后字符串：" + ciphertext);
25.  
26. return ciphertext;
27. }
28.  
29. /**
30. * 解密
31. * @param ciphertext
32. * @return
33. */
34. @SneakyThrows
35. public static String decode(String ciphertext){
36. System.out.println("加密字符串：" + ciphertext);
37. byte[] key = Hex.decodeHex(secretKey.toCharArray());
38. String plaintext = SecureUtil.aes(key).decryptStr(ciphertext);
39. System.out.println("解密后的字符串：" + plaintext);
40.  
41. return plaintext;
42. }
43.  
44. /**
45. * 明文加密
46. * @param plaintext
47. * @return
48. */
49. @SneakyThrows
50. public static String encode(String secretKey,String plaintext){
51. System.out.println("明文字符串：" + plaintext);
52. byte[] key = Hex.decodeHex(secretKey.toCharArray());
53. String ciphertext = SecureUtil.aes(key).encryptHex(plaintext);
54. System.out.println("加密后字符串：" + ciphertext);
55.  
56. return ciphertext;
57. }
58.  
59. /**
60. * 解密
61. * @param ciphertext
62. * @return
63. */
64. @SneakyThrows
65. public static String decode(String secretKey,String ciphertext){
66. System.out.println("加密字符串：" + ciphertext);
67. byte[] key = Hex.decodeHex(secretKey.toCharArray());
68. String plaintext = SecureUtil.aes(key).decryptStr(ciphertext);
69. System.out.println("解密后的字符串：" + plaintext);
70.  
71. return plaintext;
72. }
73. }

2、编写后置处理器

1. public class DruidDataSourceEncyptBeanPostProcessor implements BeanPostProcessor {
2.  
3. private CustomEncryptProperties customEncryptProperties;
4.  
5. private DataSourceProperties dataSourceProperties;
6.  
7. public DruidDataSourceEncyptBeanPostProcessor(CustomEncryptProperties customEncryptProperties, DataSourceProperties dataSourceProperties) {
8. this.customEncryptProperties = customEncryptProperties;
9. this.dataSourceProperties = dataSourceProperties;
10. }
11.  
12. @Override
13. public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
14. if(bean instanceof DruidDataSource){
15. if(customEncryptProperties.isEnabled()){
16. DruidDataSource druidDataSource = (DruidDataSource)bean;
17. System.out.println("--------------------------------------------------------------------------------------");
18. String username = dataSourceProperties.getUsername();
19. druidDataSource.setUsername(EncryptorUtils.decode(customEncryptProperties.getSecretKey(),username));
20. System.out.println("--------------------------------------------------------------------------------------");
21. String password = dataSourceProperties.getPassword();
22. druidDataSource.setPassword(EncryptorUtils.decode(customEncryptProperties.getSecretKey(),password));
23. System.out.println("--------------------------------------------------------------------------------------");
24. String url = dataSourceProperties.getUrl();
25. druidDataSource.setUrl(EncryptorUtils.decode(customEncryptProperties.getSecretKey(),url));
26. System.out.println("--------------------------------------------------------------------------------------");
27. }
28.  
29. }
30. return bean;
31. }
32. }

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

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

1. password: ${DATASOURCE_PWD:fb31cdd78a5fa2c43f530b849f1135e7}

b 、 指定密钥和开启加密功能

1. custom:
2. encrypt:
3. enabled: true
4. secret-key: 2f8ba810011e0973728afa3f28a0ecb6

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

1. spring:
2. datasource:
3. type: com.alibaba.druid.pool.DruidDataSource
4. driverClassName: com.mysql.cj.jdbc.Driver
5. url: ${DATASOURCE_URL:dcb268cf3a2626381d2bc5c96f94fb3d7f99352e0e392362cb818a321b0ca61f3a8dad3aeb084242b745c61a1d3dc244ed1484bf745c858c44560dde10e60e90ac65f77ce2926676df7af6b35aefd2bb984ff9a868f1f9052ee9cae5572fa015b66a602f32df39fb1bbc36e04cc0f148e4d610a3e5d54f2eb7c57e4729c9d7b4}
6. username: ${DATASOURCE_USERNAME:61db3bf3c6d3fe3ce87549c1af1e9061}
7. password: ${DATASOURCE_PWD:fb31cdd78a5fa2c43f530b849f1135e7}
8. druid:
9. # 初始连接数
10. initialSize: 5
11. # 最小连接池数量
12. minIdle: 10
13. # 最大连接池数量
14. maxActive: 20
15. # 配置获取连接等待超时的时间
16. maxWait: 60000
17. # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
18. timeBetweenEvictionRunsMillis: 60000
19. # 配置一个连接在池中最小生存的时间，单位是毫秒
20. minEvictableIdleTimeMillis: 300000
21. # 配置一个连接在池中最大生存的时间，单位是毫秒
22. maxEvictableIdleTimeMillis: 900000
23. # 配置检测连接是否有效
24. validationQuery: SELECT 1 FROM DUAL
25. testWhileIdle: true
26. testOnBorrow: false
27. testOnReturn: false
28. webStatFilter:
29. enabled: true
30. statViewServlet:
31. enabled: true
32. # 设置白名单，不填则允许所有访问
33. allow:
34. url-pattern: /druid/*
35. # 控制台管理用户名和密码
36. login-username:
37. login-password:
38. filter:
39. stat:
40. enabled: true
41. # 慢SQL记录
42. log-slow-sql: true
43. slow-sql-millis: 1000
44. merge-sql: true
45. wall:
46. config:
47. multi-statement-allow: true
48. custom:
49. encrypt:
50. enabled: true
51. secret-key: 2f8ba810011e0973728afa3f28a0ecb6

总结

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

 

 

如果有使用配置中心的话，jasypt推荐使用3版本以下，或者使用3.0.3版本
demo链接

到此这篇关于springboot项目数据库密码如何加密的文章就介绍到这了,更多相关springboot数据库密码加密内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！