Spring 配置文件加密
前文
在某些场景下，使用 Spring 作为开发组件时，不可避免地需要使用到配置文件，然而，对于配置文件中的某些敏感数据（如密码等信息字段），如果使用明文的方式，则可能在一定程度上导致信息泄露。为此，需要一种有效的方式来对这些字段进行加密处理，当前主流的一种加密方式就是 Jasypt
基本使用
对于主流的 Spring 应用程序，现在基本上都是采用 Spring-Boot 的方式进行开发，因此我们可以很方便地以 starter 的方式引入 Jasypt 对应的 starter 依赖
<dependency>
<groupId>com.github.ulisesbocchio</groupId>
<artifactId>jasypt-spring-boot-starter</artifactId>
<version>3.0.5</version> <!-- 具体以 Maven 仓库的为准 -->
</dependency>
然后，需要在对应的应用程序配置文件中配置 Jasypt 的相关配置属性：
jasypt:
encryptor:
# 解密时需要用到的对称密码
password: 1234567
# 解密时使用的解密算法，具体可以查看 com.sun.crypto.provider.PBEKeyFactory 的相关子类
algorithm: PBEWithHmacSHA224AndAES_128
# 一些通用的配置属性，如过滤字段是否需要解密、需要解密的字段的格式等
property:
# 如果字段需要解密，则这个字段的值的开始前缀
prefix: ENC(
# 如果字段需要解密，则这个字段的值的后缀
suffix: )
# 加密时的重 Hash 次数
key-obtention-iterations: 1000
然而，对于需要解密的字段，需要按照解密的规则对其进行加密处理，Jasypt 已经提供了现有的工具类，只需要传入我们需要的参数进行加密即可：
import org.jasypt.encryption.pbe.StandardPBEStringEncryptor;
import org.jasypt.encryption.pbe.config.EnvironmentStringPBEConfig;
import org.jasypt.iv.RandomIvGenerator;
import org.jasypt.salt.RandomSaltGenerator;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;
import javax.crypto.SecretKeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.Provider;
import java.security.Security;
@SpringBootTest(classes = {DemoApplication.class})
public class SimpleEncryptTest {
private final static Logger log = LoggerFactory.getLogger(SimpleEncryptTest.class);
// 注意，这里的 Config 必须与上文配置文件中的一致，否则会导致解密结果与最初值不一致
private static EnvironmentStringPBEConfig pbeConfig() {
String password = "1234567"; // 这里的密码需要与配置文件里的相对应
final EnvironmentStringPBEConfig config = new EnvironmentStringPBEConfig();
config.setPassword(password); // 当前对称加密算法需要的基本密码，而不是需要转换的文本
/*
具体对称加密算法，目前系统提供了 com.sun.crypto.provider.PBEKeyFactory 子类相关的算法
*/
config.setAlgorithm("PBEWithHmacSHA224AndAES_128");
/*
迭代计算次数，通过增加这个值可以提高加密效果的强度
*/
config.setKeyObtentionIterations(1000); // 如果配置文件不做配置，则默认 1000 次
config.setSaltGenerator(new RandomSaltGenerator()); // 具体的盐值生成器，未配置时默认使用 RandomSaltGenerator
/*
如果需要设置自定义的对称加密算法，那么这里可能需要设置成对应的算法提供对象，
在一般情况下，系统提供的加密算法已经足够满足需求，因此可以设置为 null
*/
config.setProvider(null);
config.setStringOutputType("Base64"); // 处理时的字节表示形式
config.setIvGenerator(new RandomIvGenerator()); // 某些算法可能需要使用到的初始向量生成器，默认为 RandomIvGenerator
return config;
}
@Test
public void encryptTest() {
String message = "123"; // 当前需要被加密的密码
final EnvironmentStringPBEConfig config = pbeConfig();
final StandardPBEStringEncryptor encryptor = new StandardPBEStringEncryptor();
encryptor.setConfig(config);
log.info("{}", encryptor.encrypt(message)); // 这里得到的就是加密后的结果
}
}
现在，将加密后的密码配置到我们系统的配置文件中，使用 jasypt 配置中定义的前后缀进行包装，以 Druid 配置为例，通过上文的加密算法，我将密码 "123" 加密后得到了 对应的加密文本 "354GiF5aGOgfrpisxVAw+y1fCNQ43Hv4vaHd9GVp8YZi86e0igV8sS6zyF1N14AP"，现在将它配置到 Druid 的登录密码中：
spring:
datasource:
druid:
stat-view-servlet:
enabled: true
login-username: admin
login-password: ENC(354GiF5aGOgfrpisxVAw+y1fCNQ43Hv4vaHd9GVp8YZi86e0igV8sS6zyF1N14AP)
之后，如果希望登录 Druid 监视界面，只需要输入用户名为 admin 并且密码 123 即可完成登录
组件配置
一般情况下，Jasypt 默认的配置已经足够满足大部分的应用场景，然而，如果希望能够自定义相关的配置，Jasypt 也提供了相应的配置选项，主要包括 "过滤器"、"解码器" 以及 "检测器"，这些组件在 com.ulisesbocchio.jasyptspringboot.properties.JasyptEncryptorConfigurationProperties.PropertyConfigurationProperties 有具体的描述
过滤器
过滤器的目的为了过滤那些需要进行解码的属性，默认情况下是对所有的配置属性都进行拦截处理，如果需要进行相关配置，可以在配置文件中加入相关的过滤属性字段：
jasypt:
encryptor:
property:
filter:
# 需要传入全限定名称，以过滤这些不需要解密的字段
exclude-names: ["spring.datasource.druid.stat-view-servlet.login-password"]
显然，如果需要过滤的字段太多，一个一个配置比较麻烦，因此我们可以自定顶一个过滤器来完成相关的过滤操作，具体的实现以 com.ulisesbocchio.jasyptspringboot.EncryptablePropertyFilter 定义的为准：
import com.ulisesbocchio.jasyptspringboot.EncryptablePropertyFilter;
import com.ulisesbocchio.jasyptspringboot.properties.JasyptEncryptorConfigurationProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.PropertySource;
import org.springframework.stereotype.Component;
import java.util.HashSet;
import java.util.Set;
// 设置过滤器 Bean 名称，使得能够被加载到 Jasypt 的配置中
@Component("jasyptPropertiesFilter")
public class PropertiesFilter
implements EncryptablePropertyFilter {
private final Set<String> excludeSet = new HashSet<>();
@Autowired
public PropertiesFilter(ConfigurableEnvironment env) {
// 复用 Jasypt 的过滤器配置属性
JasyptEncryptorConfigurationProperties props = JasyptEncryptorConfigurationProperties.bindConfigProps(env);
JasyptEncryptorConfigurationProperties.PropertyConfigurationProperties.FilterConfigurationProperties filterProps = props.getProperty().getFilter();
excludeSet.addAll(filterProps.getExcludeNames());
}
@Override
public boolean shouldInclude(PropertySource<?> source, String name) {
// 如果是开发环境，则不需要对字段进行加密处理
if (source.getName().endsWith("dev.yml")) {
return true;
}
// 如果前缀与配置的匹配，则不进行加密处理
for (String excludeName : excludeSet) {
if (excludeName.startsWith(name)) {
return false;
}
}
return true;
}
}
同时，需要将编写好的过滤器替换到原有的过滤器，可以通过配置如下属性来完成：
jasypt:
encryptor:
property:
filter:
# 通过我们自定的过滤器，就不再需要写全限定名称了，只需要写对应的不匹配前缀即可
exclude-names: ["spring.datasource.druid"]
filter-bean: jasyptPropertiesFilter
检测器
检测器的目的是为了检查配置的属性是否是被加密的，效果与过滤器类似，区别在于过滤器的效果会先于检测器，默认的检测器实现是通过配置的前后缀值来进行判断的，即配置的 ENC()。如果希望改变这个行为（虽然基本不会改变 😦），也可以自定编写检测器来替换现有的行为，具体的实现需要以 com.ulisesbocchio.jasyptspringboot.EncryptablePropertyDetector 定位为准：
import com.ulisesbocchio.jasyptspringboot.EncryptablePropertyDetector;
import com.ulisesbocchio.jasyptspringboot.detector.DefaultPropertyDetector;
import org.apache.commons.codec.binary.Base64;
import org.springframework.stereotype.Component;
@Component("jasyptPropertiesDetector")
public class PropertiesDetector
extends DefaultPropertyDetector
implements EncryptablePropertyDetector {
private String prefix = "ENC(";
public PropertiesDetector() {
super();
}
public PropertiesDetector(String prefix, String suffix) {
super(prefix, suffix);
this.prefix = prefix;
}
@Override
public boolean isEncrypted(String property) {
if (super.isEncrypted(property)) {
return true;
}
// 如果是以 Base64 的方式进行的编码，则我们认为它是被加密的
return property.length() >= 64 && Base64.isBase64(property);
}
@Override
public String unwrapEncryptedValue(String property) {
if (property.contains(prefix)) {
return super.unwrapEncryptedValue(property);
}
return property;
}
}
同样，需要将其配置到对应的配置文件中，替换默认的检测器使得其生效：
jasypt:
encryptor:
property:
detector-bean: jasyptPropertiesDetector
解码器
解码器是真正完成解码工作的组件，如果希望配置一些额外的加密选项（如加盐、替换向量生成器，使用自定义的解密算法等），都可以通过重写该组件来完成。
具体的解码器需要按照 com.ulisesbocchio.jasyptspringboot.EncryptablePropertyResolver 来实现：
import com.ulisesbocchio.jasyptspringboot.EncryptablePropertyDetector;
import com.ulisesbocchio.jasyptspringboot.EncryptablePropertyResolver;
import com.ulisesbocchio.jasyptspringboot.exception.DecryptionException;
import com.ulisesbocchio.jasyptspringboot.properties.JasyptEncryptorConfigurationProperties;
import org.jasypt.encryption.pbe.PooledPBEStringEncryptor;
import org.jasypt.encryption.pbe.config.SimpleStringPBEConfig;
import org.jasypt.exceptions.EncryptionOperationNotPossibleException;
import org.jasypt.iv.StringFixedIvGenerator;
import org.jasypt.salt.StringFixedSaltGenerator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;
import java.util.Optional;
@Component("jasyptPropertiesPropertyResolver")
public class PropertiesPropertyResolver
implements EncryptablePropertyResolver {
private final static Logger log = LoggerFactory.getLogger(PropertiesPropertyResolver.class);
private final static String IV_GEN_TEXT = "这是一个向量生成器";
private final static String SALT_TEXT = "我能够吞下玻璃而不伤身体";
private final Environment environment;
private final PooledPBEStringEncryptor encryptor;
private final EncryptablePropertyDetector detector;
@Autowired
public PropertiesPropertyResolver(ConfigurableEnvironment env,
@Qualifier("jasyptPropertiesDetector") EncryptablePropertyDetector detector) {
this.environment = env;
this.encryptor = new PooledPBEStringEncryptor();
this.detector = detector;
// 复用原有 Jasypt 的配置属性
JasyptEncryptorConfigurationProperties props = JasyptEncryptorConfigurationProperties.bindConfigProps(env);
String password = props.getPassword();
// 这里的配置将会覆盖原有配置文件中的相关配置，因为配置文件中的配置并不能显示地支持配置对象的设置
SimpleStringPBEConfig config = new SimpleStringPBEConfig();
config.setPasswordCharArray(password.toCharArray());
config.setAlgorithm("PBEWITHHMACSHA512ANDAES_256");
config.setKeyObtentionIterations("1000");
config.setPoolSize(1);
config.setProviderName("SunJCE");
config.setSaltGenerator(new StringFixedSaltGenerator(SALT_TEXT)); // 替换默认的盐值生成器
config.setIvGenerator(new StringFixedIvGenerator(IV_GEN_TEXT)); // 替换默认的向量生成器
config.setStringOutputType("base64");
this.encryptor.setConfig(config);
}
@Override
public String resolvePropertyValue(String value) {
return Optional.ofNullable(value)
.map(environment::resolvePlaceholders)
.filter(detector::isEncrypted)
.map(resolvedValue -> {
try {
String unwrappedProperty = detector.unwrapEncryptedValue(resolvedValue.trim());
String resolvedProperty = environment.resolvePlaceholders(unwrappedProperty);
String decrypt = encryptor.decrypt(resolvedProperty);
log.info("from {} to {}", resolvedProperty, decrypt);
return decrypt;
} catch (EncryptionOperationNotPossibleException e) {
throw new DecryptionException("Unable to decrypt property: "
+ value + " resolved to: " + resolvedValue + ". Decryption of Properties failed, make sure encryption/decryption " +
"passwords match", e);
}
})
.orElse(value);
}
}
同样地，也需要在配置文件中进行配置以替换默认的解码器：
jasypt:
encryptor:
property:
resolver-bean: jasyptPropertiesPropertyResolver
实现原理
一般来讲，在 SpringBoot 项目中引入 starter 来实现自动装配 功能，基本上都是通过加载 META/spring.factories 文件中的自动配置项来实现的，对于 Jassypt 的 starter 来讲，对应的 spring.factories 文件如下：
org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.ulisesbocchio.jasyptspringbootstarter.JasyptSpringBootAutoConfiguration
org.springframework.cloud.bootstrap.BootstrapConfiguration=com.ulisesbocchio.jasyptspringbootstarter.JasyptSpringCloudBootstrapConfiguration
SpringBoot 的加载接口从 EnableAutoConfiguration 配置引入，对应的配置项为 com.ulisesbocchio.jasyptspringbootstarter.JasyptSpringBootAutoConfiguration：
import com.ulisesbocchio.jasyptspringboot.configuration.EnableEncryptablePropertiesConfiguration;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
@Configuration
@Import(EnableEncryptablePropertiesConfiguration.class)
public class JasyptSpringBootAutoConfiguration {
}
实际上这个类并没有实际的配置操作，而是通过导入 EnableEncryptablePropertiesConfiguration 来间接实现的：
import com.ulisesbocchio.jasyptspringboot.EncryptablePropertySourceConverter;
import org.jasypt.encryption.StringEncryptor;
import org.jasypt.encryption.pbe.config.StringPBEConfig;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.Environment;
import org.springframework.core.env.PropertySource;
@Configuration
/*
EncryptablePropertyResolverConfiguration 这个配置类为上文的 "解码器" 等相关组件的配置类，也就是
实际完成解码工作的组件类
*/
@Import({EncryptablePropertyResolverConfiguration.class, CachingConfiguration.class})
public class EnableEncryptablePropertiesConfiguration {
@Bean
public static EnableEncryptablePropertiesBeanFactoryPostProcessor enableEncryptablePropertySourcesPostProcessor(final ConfigurableEnvironment environment, EncryptablePropertySourceConverter converter) {
return new EnableEncryptablePropertiesBeanFactoryPostProcessor(environment, converter);
}
}
对于内置的 EnableEncryptablePropertiesBeanFactoryPostProcessor Bean，Spring 会在初始化 BeanFactory 时调用这些 BeanPostProcessor 的 postProcessBeanFactory 方法，以实现对 BeanFactory 的配置处理。具体 EnableEncryptablePropertiesBeanFactoryPostProcessor 的处理如下：
import com.ulisesbocchio.jasyptspringboot.EncryptablePropertyResolver;
import com.ulisesbocchio.jasyptspringboot.EncryptablePropertySourceConverter;
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.core.Ordered;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.MutablePropertySources;
public class EnableEncryptablePropertiesBeanFactoryPostProcessor
implements BeanFactoryPostProcessor, Ordered {
private final ConfigurableEnvironment environment;
private final EncryptablePropertySourceConverter converter;
public EnableEncryptablePropertiesBeanFactoryPostProcessor(ConfigurableEnvironment environment, EncryptablePropertySourceConverter converter) {
this.environment = environment;
this.converter = converter;
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
log.info("Post-processing PropertySource instances");
/*
这里的作用是加载系统中存在的配置文件，包括系统自带的 System、BootStrap 以及 application 等配置文件
*/
MutablePropertySources propSources = environment.getPropertySources();
/*
替换原有的配置文件对象，以改变获取配置属性值的相关行为
*/
converter.convertPropertySources(propSources);
}
// 省略部分代码
}
关键的部分在于对 propSources 的替换处理，具体的源码如下：
public class EncryptablePropertySourceConverter {
public void convertPropertySources(MutablePropertySources propSources) {
propSources.stream()
.filter(ps -> !(ps instanceof EncryptablePropertySource))
.map(this::makeEncryptable)
.collect(toList())
.forEach(ps -> propSources.replace(ps.getName(), ps));
}
public <T> PropertySource<T> makeEncryptable(PropertySource<T> propertySource) {
// 省略部分代码。。。。
PropertySource<T> encryptablePropertySource = convertPropertySource(propertySource);
return encryptablePropertySource;
}
private <T> PropertySource<T> convertPropertySource(PropertySource<T> propertySource) {
// 默认不是代理模式，因此走 instantiatePropertySource 方法
return interceptionMode == InterceptionMode.PROXY
? proxyPropertySource(propertySource) : instantiatePropertySource(propertySource);
}
private <T> PropertySource<T> instantiatePropertySource(PropertySource<T> propertySource) {
PropertySource<T> encryptablePropertySource;
if (needsProxyAnyway(propertySource)) {
encryptablePropertySource = proxyPropertySource(propertySource);
} else if (propertySource instanceof SystemEnvironmentPropertySource) {
encryptablePropertySource = (PropertySource<T>) new EncryptableSystemEnvironmentPropertySourceWrapper((SystemEnvironmentPropertySource) propertySource, propertyResolver, propertyFilter);
} else if (propertySource instanceof MapPropertySource) {
/*
应用程序的配置文件对应的类型为 MapPropertySource，因此走这里，
即：将原有应用程序配置文件对应的属性配置对象替换成了 EncryptableMapPropertySourceWrapper 类型
*/
encryptablePropertySource = (PropertySource<T>) new EncryptableMapPropertySourceWrapper((MapPropertySource) propertySource, propertyResolver, propertyFilter);
} else if (propertySource instanceof EnumerablePropertySource) {
encryptablePropertySource = new EncryptableEnumerablePropertySourceWrapper<>((EnumerablePropertySource) propertySource, propertyResolver, propertyFilter);
} else {
encryptablePropertySource = new EncryptablePropertySourceWrapper<>(propertySource, propertyResolver, propertyFilter);
}
return encryptablePropertySource;
}
}
继续查看 EncryptableMapPropertySourceWrapper对应的源码：
import com.ulisesbocchio.jasyptspringboot.caching.CachingDelegateEncryptablePropertySource;
import com.ulisesbocchio.jasyptspringboot.EncryptablePropertyFilter;
import com.ulisesbocchio.jasyptspringboot.EncryptablePropertyResolver;
import com.ulisesbocchio.jasyptspringboot.EncryptablePropertySource;
import org.springframework.boot.origin.Origin;
import org.springframework.boot.origin.OriginLookup;
import org.springframework.boot.origin.OriginTrackedValue;
import org.springframework.core.env.MapPropertySource;
import org.springframework.core.env.PropertySource;
import java.util.Map;
public class EncryptableMapPropertySourceWrapper extends MapPropertySource implements EncryptablePropertySource<Map<String, Object>> {
private final CachingDelegateEncryptablePropertySource<Map<String, Object>> encryptableDelegate;
public EncryptableMapPropertySourceWrapper(MapPropertySource delegate, EncryptablePropertyResolver resolver, EncryptablePropertyFilter filter) {
super(delegate.getName(), delegate.getSource());
encryptableDelegate = new CachingDelegateEncryptablePropertySource<>(delegate, resolver, filter);
}
/*
重点在于对于获取属性时的特殊处理，具体是由 CachingDelegateEncryptablePropertySource 完成的实际处理
*/
@Override
public Object getProperty(String name) {
return encryptableDelegate.getProperty(name);
}
@Override
public PropertySource<Map<String, Object>> getDelegate() {
return encryptableDelegate;
}
}
继续查看 CachingDelegateEncryptablePropertySource ：
import com.ulisesbocchio.jasyptspringboot.EncryptablePropertyFilter;
import com.ulisesbocchio.jasyptspringboot.EncryptablePropertyResolver;
import com.ulisesbocchio.jasyptspringboot.EncryptablePropertySource;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import lombok.AllArgsConstructor;
import org.springframework.core.env.PropertySource;
import org.springframework.util.Assert;
public class CachingDelegateEncryptablePropertySource<T> extends PropertySource<T> implements EncryptablePropertySource<T> {
private final PropertySource<T> delegate; // 原有的配置属性对象
private final EncryptablePropertyResolver resolver; // 解码器
private final EncryptablePropertyFilter filter; // 过滤器
private final Map<String, CachedValue> cache; // 缓存，不重要
public CachingDelegateEncryptablePropertySource(PropertySource<T> delegate, EncryptablePropertyResolver resolver, EncryptablePropertyFilter filter) {
super(delegate.getName(), delegate.getSource());
Assert.notNull(delegate, "PropertySource delegate cannot be null");
Assert.notNull(resolver, "EncryptablePropertyResolver cannot be null");
Assert.notNull(filter, "EncryptablePropertyFilter cannot be null");
this.delegate = delegate;
this.resolver = resolver;
this.filter = filter;
this.cache = new ConcurrentHashMap<>();
}
// 省略部分源码。。。。
@Override
public Object getProperty(String name) {
Object originValue = delegate.getProperty(name);
if (!(originValue instanceof String)) {
/*
由于实际的解码器只能支持对 String 类型的解码，因此如果不是 String 类型的值则不做处理
*/
return originValue;
}
// 省略缓存的有关处理
// 如果该字段不在过滤器的排除选项中，则进一步考虑解密的处理
if (filter.shouldInclude(delegate, name)) {
String originStringValue = (String) originValue;
/*
解码器的实际解码处理，至此，完成了对加密字段的解密获取处理
*/
String resolved = resolver.resolvePropertyValue(originStringValue);
// 省略缓存的有关处理
return resolved;
}
return originValue;
}
// 省略部分源码。。。。
}
具体结构图如下所示：
