springboot项目实现对加密数据自动解密
前段时间收到一个需求，需要对配置文件的加密数据在服务启动的时候进行自动解密，最主要的是要通用。理想的状态是别人直接引入jar，不需要对原有代码有任何改动就可以实现自动解密。
我们知道常规的加解密是通过在代码里面约定好（硬编码），对从配置文件读取出来的加密数据进行解密然后再使用的，每个项目需要解密都会有这样一段解密的代码，而且是硬编码进去的，不够灵活方便。既然要共用，主要是要解决两点问题：
一是要支持常规的加密方式。
二是要对原有项目要是无侵入的（如果要使用解密，只需要引入对应的jar）。
基于以上两点，解决方案也不复杂，针对第一点，我们可以内置常用的加密方式，并且针对对应加密方式指定规定的格式，使我们可以方便的辨别出到底使用的是哪种加密方式，然后按照对应的方式去解密。针对第二点，可以把 jar 做成自动装配的效果，只对满足我们条件的数据进行解密，由此也就诞生了这个小工具，闲话少说，开整！
因为考虑到使用的方便性，这里就使用对称加密方式，而常用的对称加密考虑到安全性等问题，这里选择AES和国密算法SM4（如果需要其他的算法可以自行扩展实现）。
上代码，先给出完整的 pom 文件：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.info</groupId>
<artifactId>custom-descriptor</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<scope>compile</scope>
<version>1.18.20</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-autoconfigure</artifactId>
<version>2.4.5</version>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.7.16</version>
</dependency>
<dependency>
<groupId>org.bouncycastle</groupId>
<artifactId>bcprov-jdk15to18</artifactId>
<version>1.66</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.32</version>
</dependency>
</dependencies>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
</project>
主要是使用了国产开源库类hutool，同时添加lombok以及一些spring相关的jar。
接下来是要两个加解密相关的工具类，主要是对 hutool 的简单封装，方便自己调用。
Sm4Util：
package com.info.descriptor.util;
import cn.hutool.core.codec.Base64;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.crypto.symmetric.SM4;
import cn.hutool.crypto.symmetric.SymmetricCrypto;
import static cn.hutool.crypto.Mode.CBC;
import static cn.hutool.crypto.Padding.ZeroPadding;
public class Sm4Util {
/**
* 加密偏移量
*/
private static final String IV_PARAMETERS = "1a2b3c4d5e6f7g8h";
public static String encrypt(String plainTxt, String key) {
SymmetricCrypto sm4 = new SM4(CBC, ZeroPadding, key.getBytes(CharsetUtil.CHARSET_UTF_8), IV_PARAMETERS.getBytes(CharsetUtil.CHARSET_UTF_8));
return Base64.encode(sm4.encrypt(plainTxt));
}
public static String decrypt(String cipherTxt, String key) {
SymmetricCrypto sm4 = new SM4(CBC, ZeroPadding, key.getBytes(CharsetUtil.CHARSET_UTF_8), IV_PARAMETERS.getBytes(CharsetUtil.CHARSET_UTF_8));
byte[] cipherHex = Base64.decode(cipherTxt);
return sm4.decryptStr(cipherHex, CharsetUtil.CHARSET_UTF_8);
}
public static String generateSm4Key() {
return RandomUtil.randomString(16);
}
public static String getIvParameters() {
return IV_PARAMETERS;
}
}
AesUtil：
package com.info.descriptor.util;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.crypto.symmetric.AES;
import com.info.descriptor.enums.AesKeyTypeEnum;
public class AesUtil {
private static final String IV = "1a2b3c4d5e6f7g8h";
private static final String AES_MODE = "CBC";
private static final String AES_PADDING_STR = "PKCS7Padding";
public static String generateRandomKey() {
return generateRandomKey(AesKeyTypeEnum.KEY_TYPE_128);
}
public static String getIv() {
return IV;
}
public static String generateRandomKey(AesKeyTypeEnum KeyType) {
int keyLength;
switch (KeyType) {
case KEY_TYPE_192:
keyLength = 192 / 8;
break;
case KEY_TYPE_256:
keyLength = 256 / 8;
break;
case KEY_TYPE_128:
default:
keyLength = 128 / 8;
break;
}
return RandomUtil.randomString(keyLength);
}
public static String encrypt(String data, String key, String iv) {
AES aes = new AES(AES_MODE, AES_PADDING_STR, key.getBytes(), iv.getBytes());
return aes.encryptHex(data);
}
public static String decrypt(String data, String key, String iv) {
AES aes = new AES(AES_MODE, AES_PADDING_STR, key.getBytes(), iv.getBytes());
return aes.decryptStr(data);
}
public static String encrypt(String data, String key) {
AES aes = new AES(AES_MODE, AES_PADDING_STR, key.getBytes(), IV.getBytes());
return aes.encryptHex(data);
}
public static String decrypt(String data, String key) {
AES aes = new AES(AES_MODE, AES_PADDING_STR, key.getBytes(), IV.getBytes());
return aes.decryptStr(data);
}
}
AesKeyTypeEnum：
package com.info.descriptor.enums;
public enum AesKeyTypeEnum {
KEY_TYPE_128,
KEY_TYPE_192,
KEY_TYPE_256;
}
工具类都有了，接下来就是代码的主题，其实也就一个类，其核心思想是，通过spring的环境对象获取所有的配置信息，然后过滤对需要解密的值按指定方式进行解密，解密完成后覆盖原来读取到的值。
package com.info.descriptor;
import com.info.descriptor.util.AesUtil;
import com.info.descriptor.util.Sm4Util;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.EnvironmentAware;
import org.springframework.core.PriorityOrdered;
import org.springframework.core.env.*;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Pattern;
/**
* 和BeanPostProcessor原理一致，Spring提供了对BeanFactory进行操作的处理器BeanFactoryProcessor，
* 简单来说就是获取容器BeanFactory，这样就可以在真正初始化bean之前对bean做一些处理操作。
* 允许我们在工厂里所有的bean被加载进来后但是还没初始化前，对所有bean的属性进行修改也可以add属性值。
*/
@Slf4j
public class Descriptor implements BeanFactoryPostProcessor, EnvironmentAware, PriorityOrdered {
private ConfigurableEnvironment environment;
private String secretKey;
private static final String DEFAULT_KEY_NAME = "secret.key";
private static final String AES_REGEX = "^((?i)AES-)(\w+)((?i)-AES)$";
private static final String SM4_REGEX = "^((?i)SM4-)([\w=]+)((?i)-SM4)$";
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
final Iterator<PropertySource<?>> iterator = this.environment.getPropertySources().iterator();
while (iterator.hasNext()) {
final PropertySource<?> source = iterator.next();
if (source instanceof SimpleCommandLinePropertySource) {
SimpleCommandLinePropertySource commandLinePropertySource = (SimpleCommandLinePropertySource) source;
this.secretKey = commandLinePropertySource.getProperty(DEFAULT_KEY_NAME);
break;
}
}
if (!StringUtils.hasLength(this.secretKey)) {
this.secretKey = !StringUtils.hasLength(System.getProperty(DEFAULT_KEY_NAME)) ? System.getenv(DEFAULT_KEY_NAME) : System.getProperty(DEFAULT_KEY_NAME);
}
if (!StringUtils.hasLength(this.secretKey)) {
this.secretKey = environment.getProperty(DEFAULT_KEY_NAME);
}
if (!StringUtils.hasLength(this.secretKey)) {
return;
}
log.info("this.secretKey = {}", this.secretKey);
Map<String, Object> map = new ConcurrentHashMap<>();
final Iterator<PropertySource<?>> propertyIterator = this.environment.getPropertySources().iterator();
List<PropertySource<?>> propertySourceList = new ArrayList<>(1 << 3);
while (propertyIterator.hasNext()) {
propertySourceList.add(propertyIterator.next());
}
propertySourceList.stream()
.filter(propertySource -> propertySource instanceof EnumerablePropertySource)
.forEach(source -> this.processValue(map, (EnumerablePropertySource) source));
if (!CollectionUtils.isEmpty(map)) {
this.environment.getPropertySources().addFirst(new MapPropertySource("custom-decode", map));
}
}
/**
* @param map 处理完成后的键值对的存放集合
* @param source 待处理的键值对
*/
private void processValue(Map<String, Object> map, EnumerablePropertySource source) {
final String[] names = source.getPropertyNames();
for (String name : names) {
final Object value = source.getProperty(name);
if (!(value instanceof String)) {
continue;
}
String str = (String) value;
if (match(AES_REGEX, str)) {
map.put(name, AesUtil.decrypt(Pattern.compile(AES_REGEX).matcher(str).replaceAll("$2"), this.secretKey));
}
if (match(SM4_REGEX, str)) {
map.put(name, Sm4Util.decrypt(Pattern.compile(SM4_REGEX).matcher(str).replaceAll("$2"), this.secretKey));
}
}
}
@Override
public void setEnvironment(Environment environment) {
this.environment = (ConfigurableEnvironment) environment;
}
@Override
public int getOrder() {
return Integer.MAX_VALUE;
}
private boolean match(String regex, String str) {
if (!StringUtils.hasLength(regex) || !StringUtils.hasLength(str)) {
return false;
}
Pattern pattern = Pattern.compile(regex);
return pattern.matcher(str).matches();
}
}
当然，为了是它能在被其他项目使用的时候自动生成，我们还需要把我们的解密器做成自动装配的效果，这点可以利用自定义spring-boot-starter的方式来实现。
首先新建一个配置类
package com.info.descriptor.config;
import com.info.descriptor.Descriptor;
import com.info.descriptor.annotation.DecodeAutoConfigAnnotation;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class DecodeAutoConfig {
@Bean
public static Descriptor descriptor() {
return new Descriptor();
}
}
resources目录下新建META-INF文件夹，在其内新建 spring.factories 文件，在spring.factories文件内添加如下内容
org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.info.descriptor.config.DecodeAutoConfig
至此，所有工作基本已完成，下面来测试看下效果：
新建springboot项目，首先引入我们写好的jar
<dependency>
<groupId>com.info</groupId>
<artifactId>custom-descriptor</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
配置文件application.yml配置如下信息
secret:
# 解密秘钥
key: 8gsidftmog4851zt
test:
# 待解密的数据 AES加密的数据应该是 ‘AES-加密后的内容-AES’ 的形式，SM4加密的数据应该是 ‘SM4-加密后的内容-SM4’ 的形式
# 当然 aes sm4也可以是小写字母
key: AES-aaba5a242cd5002715b5531dac3b0562-AES
新建一个controller获取test.key的进行测试
package com.example.demo.controller;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class IndexController {
@Value("${test.key}")
private String key;
@GetMapping("/index")
public String index() {
return this.key;
}
}
打开浏览器，输入http://localhost:8080/index，我们发现发挥的是已经解密的结果123test。
当然，还可以给这个加解密做一个开关：
自定义注解：
package com.info.descriptor.annotation;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import java.lang.annotation.*;
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@ConditionalOnProperty(name = "decode.enabled",havingValue = "true")
public @interface DecodeAutoConfigAnnotation {
}
在配置类加上检查是否启用自动解密的注解：
package com.info.descriptor.config;
import com.info.descriptor.Descriptor;
import com.info.descriptor.annotation.DecodeAutoConfigAnnotation;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class DecodeAutoConfig {
@Bean
@DecodeAutoConfigAnnotation
public static Descriptor descriptor() {
return new Descriptor();
}
}
这时，如果如果需要开启自动解密，需要在配置文件添加配置：
decode:
# 开启自动解密
enabled: true
至此，我们的需求已经完全实现了，有需要类似使用场景的的，可以参考这个demo来完成。
由于aes、sm4的具体加密方式可能存在差别（例如 是否对加密后的结果进行了base64编码等），必要的时候可能需要对配皮是否加密的正则进行调整，否则可能会出现匹配不到加密字符串的情况，匹配不到自然也就不会进行解密。
今天的内容就到这里了，由于笔者认知有限，文中肯定有描述错误的地方，希望大家多多包涵，及时指正，感谢。