「 jasypt-spring-boot」敏感信息加密/解密利器_大白吃饱了吗的博客

link之家

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

1. 简介

Springboot 整合Jasypt，实现配置信息的安全，如数据库连接.账号和密码.接口凭证信息等。

Jasypt可以为Springboot加密的信息很多，主要有：

System Property 系统变量
Envirnment Property 环境变量
Command Line argument 命令行参数
Application.properties 应用配置文件
Yaml properties 应用配置文件
other custom property sources 其它配置文件

2. 如何整合

以下3种方法:

如果你的 Spring Boot 项目使用 @SpringBootApplication 或 @EnableAutoConfiguration 注解，在pom中加入以下starter jar依赖。

<dependency>
	<groupId>com.github.ulisesbocchio</groupId>
	<artifactId>jasypt-spring-boot-starter</artifactId>
	<version>3.0.3</version>
</dependency>

如果你不使用 @SpringBootApplication 或 @EnableAutoConfiguration 两个自动配置注解的话，可以添加如下依赖：
```
<dependency>
	<groupId>com.github.ulisesbocchio</groupId>
	<artifactId>jasypt-spring-boot</artifactId>
    <version>3.0.3</version>
</dependency>
```
然后在配置Java类中使用注解 @EncryptablePropertySource . 举例:
```
@Configuration
@EnableEncryptableProperties
public class MyApplication {
    ...
```
即可对整个Spring的环境的配置信息进行加密解密 (包括：System Property 系统变量、Envirnment Property 环境变量、Command Line argument 命令行参数、Application.properties 应用配置文件、Yaml properties 应用配置文件、other custom property sources 其它配置文件)
如果你不使用 @SpringBootApplication 或 @EnableAutoConfiguration 两个自动配置注解，又不想对整个spring环境的参数进行加密解密的话，这里有第3种方法. 首先，在你的工程中添加如下依赖：
```
<dependency>
	<groupId>com.github.ulisesbocchio</groupId>
	<artifactId>jasypt-spring-boot</artifactId>
	<version>3.0.3</version>
</dependency>
```
然后，在Java配置类中添加 @EncryptablePropertySource 注解. 类似于添加spring的 @PropertySource 注解. 比如：
```
@Configuration
@EncryptablePropertySource(name="EncryptedProperties", value="classpath:encrypted.properties")
public class MyApplication {
	...
```
非常方便的是，一个Java类中可以添加一个 @EncryptablePropertySources 注解，也可以添加一组 @EncryptablePropertySources 注解，就像这样：

@Configuration
@EncryptablePropertySources({@EncryptablePropertySource("classpath:encrypted.properties"),@EncryptablePropertySource("classpath:encrypted2.properties")})
public class MyApplication {
	...
 另外，需要注意的是从1.8版本开始，@EncryptablePropertySource支持YAML文件. 
3. 自定义环境
 
从版本1.15开始，支持使用第4种方法启用加密属性. 自定义一个ConfigurableEnvironment类，比如：EncryptableEnvironment、StandardEncryptableEnvironment、StandardEncryptableServletEnvironment，与SpringApplicationBuilder类一起使用，以这种方式自定义使用环境: 
new SpringApplicationBuilder()
    .environment(new StandardEncryptableEnvironment())
    .sources(YourApplicationClass.class).run(args);
这个方法只需要使用jasypt-spring-boot的依赖. 不需要starter jar依赖项. 这种方法对于在启动过程中访问加密属性非常有用. 虽然在大多数场景中不是必需的，但在定制Spring Boot的初始化行为或整合某些初始化配置的功能时可能很有用(如日志配置)。举个具体的例子，在logback-spring.xml文件中，我们如果要对springProperty 标签的属性启用加密，这是唯一一种方法。例如: 
<springProperty name="user" source="db.user"/>
<springProperty name="password" source="db.password"/>
<appender name="db" class="ch.qos.logback.classic.db.DBAppender">
    <connectionSource
        class="ch.qos.logback.core.db.DriverManagerConnectionSource">
        <driverClass>org.postgresql.Driver</driverClass>
        <url>jdbc:postgresql://localhost:5432/simple</url>
        <user>${user}</user>
        <password>${password}</password>
    </connectionSource>
</appender>
使用这种机制可以用来初始化需要传递敏感凭证的数据库日志记录Appender（Database Logging Appender）。另外，我们需要提供一个自定义的StringEncryptor，以及一个静态构建器方法StandardEncryptableEnvironment#builder 来进行操作:




    
 
StandardEncryptableEnvironment
    .builder()
    .encryptor(new MyEncryptor())
    .build()
4. 工作原理
 
SpringBoot启用jasypt加密解密配置机制，会做如下2件事： 
注册一个Spring post处理器，该处理器装饰了Spring环境中包含的所有PropertySource对象，使它们具有“加密标识”，当属性按照jasypt的约定进行加密时，注册的处理器可以检测到。
定义了一个默认的StringEncryptor，可以通过常规属性、系统属性或命令行参数配置。 
5. 加密的属性如何处理
 
使用上文中提到的整合方法1和方法2时，可以在任何包含于spring环境的配置文件中定义加密的属性。例如，使用@PropertySource注释: 
    @SpringBootApplication
    @EnableEncryptableProperties
    @PropertySource(name="EncryptedProperties", value = "classpath:encrypted.properties")
    public class MyApplication {
        ...
然后，配置文件中定义的属性使用如下标识定义： 
	secret.property=ENC(nrmZtkF7T0kjG/VodDvBw93Ct8EgjCA+)
现在，当你使用environment.getProperty("secret.property")或使用@Value("${secret.property}")时，你得到的是secret.property的解密版本。 
当使用整合方法3(@EncryptablePropertySource)时，获取加密属性的方式是相同的，唯一的区别是，Java配置类中要使用@EncryptablePropertySource注解。 
6. 基于密码的加密配置
 
Jasypt 使用 StringEncryptor类来加密属性资源. 在上文提到的3种整合方法中, 如果Spring上下文中没有自定义的 StringEncryptor 类, 则会使用Jasypt默认的类，通过在配置文件中配置如下表格中的属性来起到加密解密的作用: 
配置项 是否必须 默认值
jasypt.encryptor.password True -
jasypt.encryptor.algorithm False PBEWITHHMACSHA512ANDAES_256
jasypt.encryptor.key-obtention-iterations False 1000
jasypt.encryptor.pool-size False 1
jasypt.encryptor.provider-name False SunJCE
jasypt.encryptor.provider-class-name False null
jasypt.encryptor.salt-generator-classname False org.jasypt.salt.RandomSaltGenerator
jasypt.encryptor.iv-generator-classname False org.jasypt.iv.RandomIvGenerator
jasypt.encryptor.string-output-type False base64
jasypt.encryptor.proxy-property-sources False false
jasypt.encryptor.skip-property-sources False empty list 
唯一必须的加密属性是加密密码，其余的配置项都可以使用默认值。虽然所有这些属性都可以在属性文件中声明，但加密器密码不应该存储在属性文件中，它应该作为系统属性、命令行参数或环境变量传递，只要它的名称是’ jasypt.encryptor '。 
最后一个属性，jasypt.encryptor.proxyPropertySources用于标识jasypt -spring-boot如何截获属性值以进行解密。默认值为false时，使用PropertySource 、EnumerablePropertySource和MapPropertySource自定义的包装器实现。当为该属性指定true 时，拦截机制将在每个PropertySource标识的属性类上实现上使用CGLib代理。在必须保留原始“PropertySource”类型的某些场景中，这可能很有用。 
7. 使用自定义的加密程序
 
当在spring上下文中使用自定义的StringEncryptor类时，默认的加密器将被忽略，我们可以自定义相关配置，比如： 
    @Bean("jasyptStringEncryptor")
    public StringEncryptor stringEncryptor() {
        PooledPBEStringEncryptor encryptor = new PooledPBEStringEncryptor();
        SimpleStringPBEConfig config = new SimpleStringPBEConfig();
        config.setPassword("password");
        config.setAlgorithm("PBEWITHHMACSHA512ANDAES_256");
        config.setKeyObtentionIterations("1000");
        config.setPoolSize("1");
        config.setProviderName("SunJCE");
        config.setSaltGeneratorClassName("org.jasypt.salt.RandomSaltGenerator");
        config.setIvGeneratorClassName("org.jasypt.iv.RandomIvGenerator");
        config.setStringOutputType("base64");
        encryptor.setConfig(config);
        return encryptor;
注意，加密器的类名是一般是固定的，因为jasypt-spring-boot从1.5版本开始，是根据名称来检测自定义字符串加密器的。默认的类名是: 
jasyptStringEncryptor
但是可以通过如下配置项来重写： 
jasypt.encryptor.bean
举个例子, 如果 jasypt.encryptor.bean=encryptorBean ，那么，就可以使用encryptorBean这个名称来定义加密器: 
    @Bean("encryptorBean")
    public StringEncryptor stringEncryptor() {
        ...
8. 自定义Property Detector, Prefix, Suffix 和 Resolver
 
在jasypt-spring-boot-1.10中有新的扩展，使用EncryptablePropertyResolver来解析所有的属性: 
public interface EncryptablePropertyResolver {
    String resolvePropertyValue(String value);
8.1 自定义EncryptablePropertyDetector
 
定义一个名称为encryptablePropertyDetector的Java类，实现并重写EncryptablePropertyDetector接口。也可以通过配置项jasypt.encryptor.property.detector-bean 自己定义Java类的名称，而这样做后，则由定义的类来负责检测加密属性，如下例子: 
private static class MyEncryptablePropertyDetector implements EncryptablePropertyDetector {
    @Override
    public boolean isEncrypted(String value) {
        if (value != null) {
            return value.startsWith("ENC@");
        return false;
    @Override
    public String unwrapEncryptedValue(String value) {
        return value.substring("ENC@".length());
@Bean(name = "encryptablePropertyDetector")
    public EncryptablePropertyDetector encryptablePropertyDetector() {
        return new MyEncryptablePropertyDetector();
8.2 自定义加密属性前缀和后缀
 
如果想为加密的属性添加不同的前缀/后缀，所有的默认实现可以继续沿用，而只是覆盖application.properties (或 application.yml)中的以下属性: 
jasypt:
  encryptor:
    property:
      prefix: "ENC@["
      suffix: "]"
8.3 自定义EncryptablePropertyResolver
 
定义一个名称为encryptablePropertyResolver的Java类，实现并重写EncryptablePropertyResolver接口。也可以通过配置项jasypt.encryptor.property.resolver-bean 自己定义Java类的名称，而这样做后，则由定义的类来负责检测和解密已加密的属性，如下例子: 
    class MyEncryptablePropertyResolver implements EncryptablePropertyResolver {
        private final PooledPBEStringEncryptor encryptor;
        public MyEncryptablePropertyResolver(char[] password) {
            this.encryptor = new PooledPBEStringEncryptor();
            SimpleStringPBEConfig config = new SimpleStringPBEConfig();
            config.setPasswordCharArray(password);
            config.setAlgorithm("PBEWITHHMACSHA512ANDAES_256");
            config.setKeyObtentionIterations("1000");
            config.setPoolSize(1);
            config.setProviderName("SunJCE");
            config.setSaltGeneratorClassName("org.jasypt.salt.RandomSaltGenerator");
            config.setIvGeneratorClassName("org.jasypt.iv.RandomIvGenerator");
            config.setStringOutputType("base64");
            encryptor.setConfig(config);
        @Override
        public String resolvePropertyValue(String value) {
            if (value != null && value.startsWith("{cipher}")) {
                return encryptor.decrypt(value.substring("{cipher}".length()));
            return value;
	  @Bean(name="encryptablePropertyResolver")
    EncryptablePropertyResolver encryptablePropertyResolver(@Value("${jasypt.encryptor.password}") String password) {
        return new MyEncryptablePropertyResolver(password.toCharArray());
注意，通过覆盖EncryptablePropertyResolver，修改任何其他配置都可能有自定义的前缀，后缀，那么EncryptablePropertyDetector and StringEncryptor将停止解析检测工作，因为使用它们的是默认的解析器。需要自己把这些配置项组装起来。幸运的是，在大多数情况下不必重写这个bean，默认的配置选项应该就足够了。




    
 
但是，在这个实例中可以看到，对于加密属性的检测和解密工作是在自定义的MyEncryptablePropertyResolver类中实现的。 
9. 使用过滤器
 
jasypt-spring-boot:2.1.0引入了一个新特性来指定属性过滤器。这个过滤器是EncryptablePropertyResolverAPI的一部分，允许指定哪些属性要进行解密。这项工作是在检查搜索或尝试解密实际属性值之前进行的。例如，默认情况下，所有名称以jasypt开头的属性。不在检查范围内。 
9.1 DefaultPropertyFilter类的属性
 
默认情况下，DefaultPropertyResolver 使用DefaultPropertyFilter，允许指定以下列表中的字符串模式: 
jasypt.encryptor.property.filter.include-sources: 指定要包含用于解密的属性源名称模式
jasypt.encryptor.property.filter.exclude-sources: 指定要排除用于解密的属性源名称模式
jasypt.encryptor.property.filter.include-names: 指定要包含用于解密的属性名称模式
jasypt.encryptor.property.filter.exclude-names: 指定要排除用于解密的属性名称模式 
9.2 自定义EncryptablePropertyFilter
 
通过定义名称为encryptablePropertyFilter ，类型为EncryptablePropertyFilter的Bean来覆盖默认实现，或者如果定义自己的Bean名称，则覆盖属性jasypt.encryptor.property.filter-bean。然后指定bean的名称。这样做时，您将负责检测用于解密的属性和/或属性源。例子: 
    class MyEncryptablePropertyFilter implements EncryptablePropertyFilter {
        public boolean shouldInclude(PropertySource<?> source, String name) {
            return name.startsWith('encrypted.');
	  @Bean(name="encryptablePropertyFilter")
    EncryptablePropertyFilter encryptablePropertyFilter() {
        return new MyEncryptablePropertyFilter();
注意，如果自定义EncryptablePropertyFilter，那就不应该提供自定义的EncryptablePropertyResolver，而应该使用默认的解析器。如果提供自定义解析器，则需要负责检测和解密属性的整个过程。 
10. 过滤不需要加密/解密的属性类
 
定义一个属性名称为jasypt.encryptor.skip-property-sources，属性值为用逗号分隔的全限定类名列表，这些类将从加载过程中跳过。并且将不会被这个插件包装/代理，因此其中包含的属性将不会被加密/解密: 
jasypt.encryptor.skip-property-sources=org.springframework.boot.env.RandomValuePropertySource,org.springframework.boot.ansi.AnsiPropertySource
11. Maven 插件使用
 
Maven插件提供了许多有用的实用程序，要使用这个插件，只需将以下内容添加到你的pom.xml中: 
<build>
  <plugins>
    <plugin>
      <groupId>com.github.ulisesbocchio</groupId>
      <artifactId>jasypt-maven-plugin</artifactId>
      <version>3.0.3</version>
    </plugin>
  </plugins>
</build>
当使用这个插件时，最简单的方式是通过一个系统属性提供你的加密密码，即-Djasypt.encryptor.password=“自定义的密码”. 
默认情况下，插件会在./src/main/resources下的标准Spring启动配置文件中检测加密配置。还可以使用系统属性或环境变量来提供此配置。注意，其余的应用程序代码和资源对插件是不可用的，因为Maven插件不与项目共享类路径。如果应用程序通过StringEncryptor bean提供加密配置，那么将不会起作用，一般来说，建议只依赖默认配置。 
11.1 Encryption
 
加密单个值: 
mvn jasypt:encrypt-value -Djasypt.encryptor.password="the password" -Djasypt.plugin.value="theValueYouWantToEncrypt"
在 src/main/resources/application.properties配置文件中, 用 DEC(...)标识括起来的任何内容都可以加密，包括空格. 示例: 
sensitive.password=DEC(secret value)
regular.property=example
然后运行命令： 
mvn jasypt:encrypt -Djasypt.encryptor.password="the password"
文件加密结果将以如下形式展示: 
sensitive.password=ENC(encrypted)
regular.property=example
可以自定义配置文件名和位置. 
11.2 Decryption
 
解密单个值，运行以下命令： 
mvn jasypt:decrypt-value -Djasypt.encryptor.password="the password" -Djasypt.plugin.value="DbG1GppXOsFa2G69PnmADvQFI3esceEhJYbaEIKCcEO5C85JEqGAhfcjFMGnoRFf"
在 src/main/resources/application.properties配置文件中, 用 ENC(...)标识括起来的任何内容都可以解密，包括空格. 示例: 
sensitive.password=ENC(encrypted)
regular.property=example
通过如下命令会达到解密效果: 
mvn jasypt:decrypt -Djasypt.encryptor.password="the password"
解密内容将会输出到屏幕上： 
sensitive.password=DEC(decrypted)
regular.property=example
注意，将数据输出到屏幕，而不是在适当的地方重新编辑文件，是为了减少意外地将解密后的值提交给版本控制。在解密时，您很可能只想检查已加密的值，而不是永久地解密该值。 
11.3 Re-encryption
 
使用加密/解密目标更改现有加密属性的配置有点困难。必须使用旧配置运行解密目标，然后将解密后的输出复制回原始文件，最后再使用新配置运行加密目标。 
重新加密的目标通过在适当的地方重新加密文件来达成。但是必须提供2套配置，提供新配置的方式与配置其他maven目标的方式相同。旧的配置是通过带"jasypt.plugin "前缀的系统属性提供的。 
例如，重新加密应用程序之前，应当用旧密码先加密，然后再用新密码加密: 
mvn jasypt:reencrypt -Djasypt.plugin.old.password=OLD -Djasypt.encryptor.password=NEW
注意:所有旧的配置必须作为系统属性传递。不支持环境变量和Spring引导配置文件。 
11.4 Upgrade
 
有时，默认的加密配置可能会在jasypt-spring-boot的不同版本之间发生变化。您可以根据升级目标自动将加密的属性升级到新的默认值。这将解密您的应用程序。属性文件使用旧的默认配置，并使用新的默认配置重新加密。 
mvn jasypt:upgrade -Djasypt.encryptor.password=EXAMPLE
11.5 Load
 
当想让加密的属性对其他Maven插件可用时，可以将属性文件中所有属性加载到内存中，使Maven可以访问它们。 
可以将其它插件的目标直接连接到这个插件之后。例如，使用flyway: 
mvn jasypt:load flyway:migrate -Djasypt.encryptor.password="the password"
你也可以用-Djasypt.plugin.keyPrefix=example. 为每个属性指定一个前缀。这有助于避免与其他Maven属性发生潜在的冲突。 
11.6 加密并改变属性文件路径
 
对于上述所有内容，要加密/解密的文件的路径默认为file:src/main/resources/application.properties, 
相对而言，我们可以使用-Djasypt.plugin.path来指定文件路径，并且还有其他特性，如下： 
可以加密test resources目录中的文件 
mvn jasypt:encrypt -Djasypt.plugin.path="file:src/main/test/application.properties" -Djasypt.encryptor.password="the password"
也可以加密非application.properties名称的配置文件: 
mvn jasypt:encrypt -Djasypt.plugin.path="file:src/main/resources/flyway.properties" -Djasypt.encryptor.password="the password"
同样支持.yaml格式的配置文件: 
mvn jasypt:encrypt -Djasypt.plugin.path="file:src/main/resources/application.yaml" -Djasypt.encryptor.password="the password"
注意 load模块只支持 .property 格式的文件 
11.7 加密Spring属性文件
 
当运行这个插件时，你可以覆盖你在应用程序中支持的任何spring配置，例如选择一个给定的spring配置文件: 
mvn jasypt:encrypt -Dspring.profiles.active=cloud -Djasypt.encryptor.password="the password" 
12. 非对称加密
 
jasypt-spring-boot:2.1.1 引入了一个新特性，使用一对DER或PEM格式的私钥/公钥非对称加密对属性进行加密/解密。




    
 
12.1 配置属性
 
以下是可用于配置属性的非对称解密的配置属性; 
属性名 默认值 描述
jasypt.encryptor.privateKeyString null 用于解密的字符串格式的私钥
jasypt.encryptor.privateKeyLocation null 用于以spring资源格式解密的私钥的位置
jasypt.encryptor.privateKeyFormat DER 秘钥编码格式 DER 或者 PEM 
可以使用字符串或者秘钥路径来定义key，若是直接以字符串格式定义秘钥，应当先base64编码 
注意 以jasypt.encryptor.password 方式配置加密优先于非对称加密配置 
12.2 配置实例
 
12.2.1 以字符串格式配置DER编码的秘钥
 
jasypt:
    encryptor:
      privateKeyString: MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCtB/IYK8E52CYMZTpyIY9U0HqMewyKnRvSo6s+9VNIn/HSh9+MoBGiADa2MaPKvetS3CD3CgwGq/+LIQ1HQYGchRrSORizOcIp7KBx+Wc1riatV/tcpcuFLC1j6QJ7d2I+T7RA98Sx8X39orqlYFQVysTw/aTawX/yajx0UlTW3rNAY+ykeQ0CBHowtTxKM9nGcxLoQbvbYx1iG9JgAqye7TYejOpviOH+BpD8To2S8zcOSojIhixEfayay0gURv0IKJN2LP86wkpAuAbL+mohUq1qLeWdTEBrIRXjlnrWs1M66w0l/6JwaFnGOqEB6haMzE4JWZULYYpr2yKyoGCRAgMBAAECggEAQxURhs1v3D0wgx27ywO3zeoFmPEbq6G9Z6yMd5wk7cMUvcpvoNVuAKCUlY4pMjDvSvCM1znN78g/CnGF9FoxJb106Iu6R8HcxOQ4T/ehS+54kDvL999PSBIYhuOPUs62B/Jer9FfMJ2veuXb9sGh19EFCWlMwILEV/dX+MDyo1qQaNzbzyyyaXP8XDBRDsvPL6fPxL4r6YHywfcPdBfTc71/cEPksG8ts6um8uAVYbLIDYcsWopjVZY/nUwsz49xBCyRcyPnlEUJedyF8HANfVEO2zlSyRshn/F+rrjD6aKBV/yVWfTEyTSxZrBPl4I4Tv89EG5CwuuGaSagxfQpAQKBgQDXEe7FqXSaGk9xzuPazXy8okCX5pT6545EmqTP7/JtkMSBHh/xw8GPp+JfrEJEAJJl/ISbdsOAbU+9KAXuPmkicFKbodBtBa46wprGBQ8XkR4JQoBFj1SJf7Gj9ozmDycozO2Oy8a1QXKhHUPkbPQ0+w3efwoYdfE67ZodpFNhswKBgQDN9eaYrEL7YyD7951WiK0joq0BVBLK3rwO5+4g9IEEQjhP8jSo1DP+zS495t5ruuuuPsIeodA79jI8Ty+lpYqqCGJTE6muqLMJDiy7KlMpe0NZjXrdSh6edywSz3YMX1eAP5U31pLk0itMDTf2idGcZfrtxTLrpRffumowdJ5qqwKBgF+XZ+JRHDN2aEM0atAQr1WEZGNfqG4Qx4o0lfaaNs1+H+knw5kIohrAyvwtK1LgUjGkWChlVCXb8CoqBODMupwFAqKL/IDImpUhc/t5uiiGZqxE85B3UWK/7+vppNyIdaZL13a1mf9sNI/p2whHaQ+3WoW/P3R5z5uaifqM1EbDAoGAN584JnUnJcLwrnuBx1PkBmKxfFFbPeSHPzNNsSK3ERJdKOINbKbaX+7DlT4bRVbWvVj/jcw/c2Ia0QTFpmOdnivjefIuehffOgvU8rsMeIBsgOvfiZGx0TP3+CCFDfRVqjIBt3HAfAFyZfiP64nuzOERslL2XINafjZW5T0pZz8CgYAJ3UbEMbKdvIuK+uTl54R1Vt6FO9T5bgtHR4luPKoBv1ttvSC6BlalgxA0Ts/AQ9tCsUK2JxisUcVgMjxBVvG0lfq/EHpL0Wmn59SHvNwtHU2qx3Ne6M0nQtneCCfR78OcnqQ7+L+3YCMqYGJHNFSard+dewfKoPnWw0WyGFEWCg==
12.2.2 配置项指定DER编码的秘钥文件路径
 
jasypt:
    encryptor:
      privateKeyLocation: classpath:private_key.der
12.2.3 以字符串格式配置PEM编码的秘钥
 
jasypt:
    encryptor:
      privateKeyFormat: PEM
      privateKeyString: |-
          -----BEGIN PRIVATE KEY-----
          MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCtB/IYK8E52CYM
          ZTpyIY9U0HqMewyKnRvSo6s+9VNIn/HSh9+MoBGiADa2MaPKvetS3CD3CgwGq/+L
          IQ1HQYGchRrSORizOcIp7KBx+Wc1riatV/tcpcuFLC1j6QJ7d2I+T7RA98Sx8X39
          orqlYFQVysTw/aTawX/yajx0UlTW3rNAY+ykeQ0CBHowtTxKM9nGcxLoQbvbYx1i
          G9JgAqye7TYejOpviOH+BpD8To2S8zcOSojIhixEfayay0gURv0IKJN2LP86wkpA
          uAbL+mohUq1qLeWdTEBrIRXjlnrWs1M66w0l/6JwaFnGOqEB6haMzE4JWZULYYpr
          2yKyoGCRAgMBAAECggEAQxURhs1v3D0wgx27ywO3zeoFmPEbq6G9Z6yMd5wk7cMU
          vcpvoNVuAKCUlY4pMjDvSvCM1znN78g/CnGF9FoxJb106Iu6R8HcxOQ4T/ehS+54
          kDvL999PSBIYhuOPUs62B/Jer9FfMJ2veuXb9sGh19EFCWlMwILEV/dX+MDyo1qQ
          aNzbzyyyaXP8XDBRDsvPL6fPxL4r6YHywfcPdBfTc71/cEPksG8ts6um8uAVYbLI
          DYcsWopjVZY/nUwsz49xBCyRcyPnlEUJedyF8HANfVEO2zlSyRshn/F+rrjD6aKB
          V/yVWfTEyTSxZrBPl4I4Tv89EG5CwuuGaSagxfQpAQKBgQDXEe7FqXSaGk9xzuPa
          zXy8okCX5pT6545EmqTP7/JtkMSBHh/xw8GPp+JfrEJEAJJl/ISbdsOAbU+9KAXu
          PmkicFKbodBtBa46wprGBQ8XkR4JQoBFj1SJf7Gj9ozmDycozO2Oy8a1QXKhHUPk
          bPQ0+w3efwoYdfE67ZodpFNhswKBgQDN9eaYrEL7YyD7951WiK0joq0BVBLK3rwO
          5+4g9IEEQjhP8jSo1DP+zS495t5ruuuuPsIeodA79jI8Ty+lpYqqCGJTE6muqLMJ
          Diy7KlMpe0NZjXrdSh6edywSz3YMX1eAP5U31pLk0itMDTf2idGcZfrtxTLrpRff
          umowdJ5qqwKBgF+XZ+JRHDN2aEM0atAQr1WEZGNfqG4Qx4o0lfaaNs1+H+knw5kI
          ohrAyvwtK1LgUjGkWChlVCXb8CoqBODMupwFAqKL/IDImpUhc/t5uiiGZqxE85B3
          UWK/7+vppNyIdaZL13a1mf9sNI/p2whHaQ+3WoW/P3R5z5uaifqM1EbDAoGAN584
          JnUnJcLwrnuBx1PkBmKxfFFbPeSHPzNNsSK3ERJdKOINbKbaX+7DlT4bRVbWvVj/
          jcw/c2Ia0QTFpmOdnivjefIuehffOgvU8rsMeIBsgOvfiZGx0TP3+CCFDfRVqjIB
          t3HAfAFyZfiP64nuzOERslL2XINafjZW5T0pZz8CgYAJ3UbEMbKdvIuK+uTl54R1
          Vt6FO9T5bgtHR4luPKoBv1ttvSC6BlalgxA0Ts/AQ9tCsUK2JxisUcVgMjxBVvG0
          lfq/EHpL0Wmn59SHvNwtHU2qx3Ne6M0nQtneCCfR78OcnqQ7+L+3YCMqYGJHNFSa
          rd+dewfKoPnWw0WyGFEWCg==
          -----END PRIVATE KEY-----
12.2.4 配置项指定PEM编码的秘钥文件路径
 
jasypt:
    encryptor:
      privateKeyFormat: PEM
      privateKeyLocation: classpath:private_key.pem
12.3 Java代码加密属性
 
12.3.1 DER格式
 
import com.ulisesbocchio.jasyptspringboot.encryptor.SimpleAsymmetricConfig;
import com.ulisesbocchio.jasyptspringboot.encryptor.SimpleAsymmetricStringEncryptor;
import org.jasypt.encryption.StringEncryptor;
public class PropertyEncryptor {
    public static void main(String[] args) {
        SimpleAsymmetricConfig config = new SimpleAsymmetricConfig();
        config.setPublicKey("MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArQfyGCvBOdgmDGU6ciGPVNB6jHsMip0b0qOrPvVTSJ/x0offjKARogA2tjGjyr3rUtwg9woMBqv/iyENR0GBnIUa0jkYsznCKeygcflnNa4mrVf7XKXLhSwtY+kCe3diPk+0QPfEsfF9/aK6pWBUFcrE8P2k2sF/8mo8dFJU1t6zQGPspHkNAgR6MLU8SjPZxnMS6EG722MdYhvSYAKsnu02Hozqb4jh/gaQ/E6NkvM3DkqIyIYsRH2smstIFEb9CCiTdiz/OsJKQLgGy/pqIVKtai3lnUxAayEV45Z61rNTOusNJf+icGhZxjqhAeoWjMxOCVmVC2GKa9sisqBgkQIDAQAB");
        StringEncryptor encryptor = new SimpleAsymmetricStringEncryptor(config);
        String message = "chupacabras";
        String encrypted = encryptor.encrypt(message);
        System.out.printf("Encrypted message %s\n", encrypted);
12.3.2 PEM格式
 
import com.ulisesbocchio.jasyptspringboot.encryptor.SimpleAsymmetricConfig;
import com.ulisesbocchio.jasyptspringboot.encryptor.SimpleAsymmetricStringEncryptor;
import org.jasypt.encryption.StringEncryptor;
import static com.ulisesbocchio.jasyptspringboot.util.AsymmetricCryptography.KeyFormat.PEM;
public class PropertyEncryptor {
    public static void main(String[] args) {
        SimpleAsymmetricConfig config = new SimpleAsymmetricConfig();
        config.setKeyFormat(PEM);
        config.setPublicKey("-----BEGIN PUBLIC KEY-----\n" +
                "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArQfyGCvBOdgmDGU6ciGP\n" +
                "VNB6jHsMip0b0qOrPvVTSJ/x0offjKARogA2tjGjyr3rUtwg9woMBqv/iyENR0GB\n" +
                "nIUa0jkYsznCKeygcflnNa4mrVf7XKXLhSwtY+kCe3diPk+0QPfEsfF9/aK6pWBU\n" +
                "FcrE8P2k2sF/8mo8dFJU1t6zQGPspHkNAgR6MLU8SjPZxnMS6EG722MdYhvSYAKs\n" +
                "nu02Hozqb4jh/gaQ/E6NkvM3DkqIyIYsRH2smstIFEb9CCiTdiz/OsJKQLgGy/pq\n" +
                "IVKtai3lnUxAayEV45Z61rNTOusNJf+icGhZxjqhAeoWjMxOCVmVC2GKa9sisqBg\n" +
                "kQIDAQAB\n" +
                "-----END PUBLIC KEY-----\n");
        StringEncryptor encryptor = new SimpleAsymmetricStringEncryptor(config);
        String message = "chupacabras";
        String encrypted = encryptor.encrypt(message);
        System.out.printf("Encrypted message %s\n", encrypted);
13.Demo App
 
jasypt-spring-boot-demo-samples 仓库包含了Spring Boot应用的示例。主要的jasypt-spring-boot-demo应用程序在运行之前显式地设置了一个带有加密密码的系统属性。为了有一个更真实的场景，建议尝试删除设置了system属性的行，用maven构建应用程序，然后运行: 
	java -jar target/jasypt-spring-boot-demo-0.0.1-SNAPSHOT.jar --jasypt.encryptor.password=password
把加密密码作为命令行参数传递: 
	java -Djasypt.encryptor.password=password -jar target/jasypt-spring-boot-demo-0.0.1-SNAPSHOT.jar
也可以通过创建application.properties 或者 application.yml文件，并且添加如下配置项： 
jasypt.encryptor.password=${JASYPT_ENCRYPTOR_PASSWORD:}
jasypt:
    encryptor:
        password: ${JASYPT_ENCRYPTOR_PASSWORD:}
定义jasypt.encryptor.password属性是基础做法，也可以指向另一个属性JASYPT_ENCRYPTOR_PASSWORD，既可以通过环境变量设置，也可以通过系统属性重写它。这种方式还可以用于为您需要的任何其他库翻译属性名/值，demo中也有涉及: 
JASYPT_ENCRYPTOR_PASSWORD=password java -jar target/jasypt-spring-boot-demo-1.5-SNAPSHOT.jar
注意:当使用Gradle作为构建工具时，processResources任务会因为$字符而失败，要解决这个问题，需要替换掉$这样的变量。 
14.其它 demo app
 
jasypt-spring-boot-demo是一个综合的演示demo，它展示了加密/解密属性的所有可能方法，但还有其他多个demo演示了独立特性的使用场景。 
15.参考
 
翻译自：jasypt-spring-boot.README.md
                    文章目录1. 简介2. 如何整合3. 自定义环境4. 工作原理5. 加密的属性如何处理6. 基于密码的加密配置7. 使用自定义的加密程序8. 自定义`Property Detector`, `Prefix`, `Suffix` 和 `Resolver`8.1 自定义`EncryptablePropertyDetector`8.2 自定义加密属性前缀和后缀8.3 自定义`EncryptablePropertyResolver`9. 使用过滤器9.1 `DefaultPropertyFilter`类的属性9.2
				jasypt-spring-boot-starter实现加解密和数据返显
一、jasypt-spring-boot-starter在springboot中的加解密（默认加密法）
  <!--实现自动 加密解密-->
        <dependency>
            <groupId>com.github.ulisesbocchio</groupId>
            <artifactId>jasypt-sprin
				jasypt-spring-boot
 用于Spring Boot 1.4.X，1.5.X和2.0.X的集成
 Jasypt Spring Boot为Spring Boot应用程序中的属性源提供了加密支持。 有3种方法可以将jasypt-spring-boot集成到您的项目中：
 如果使用@SpringBootApplication或@EnableAutoConfiguration只需将启动程序jar jasypt-spring-boot-starter到您的类路径中， @SpringBootApplication在整个Spring环境中启用可加密属性
将jasypt-spring-boot添加到您的类路径中，并将@EnableEncryptableProperties添加到您的主Configuration类中，以在整个Spring环境中启用可加密属性
将jasypt-spring-boot添加到您的类路径中，并使用@EncrytablePropertySource声明各个可加密的属性源
什么是新的？
更新05/31/2020：版本3.0.3发行版包括
修正了一些小错误
				目录1. 简介2. 引入依赖3. 自定义加解密的方式4. 获取密文5. 编写配置文件6. 验证结果
1. 简介
在项目开发的过程中，经常会需要在配置文件中存储一些敏感的信息，如数据库的账号密码，支付相关信息，密钥等等，这些信息在开发的过程中一般是以明文的方式存储在配置文件中。这种方式的存储会存在非常大的安全隐患。jasypt能够很好的解决这一类的问题，特此记录，一遍后面学习使用。
2. 引入依赖
<!--springboot整合jasypt-->
  <dependency>
				赠送jar包：jasypt-spring-boot-3.0.4.jar；
赠送原API文档：jasypt-spring-boot-3.0.4-javadoc.jar；
赠送源代码：jasypt-spring-boot-3.0.4-sources.jar；
赠送Maven依赖信息文件：jasypt-spring-boot-3.0.4.pom；
包含翻译后的API文档：jasypt-spring-boot-3.0.4-javadoc-API文档-中文(简体)-英语-对照版.zip；
Maven坐标：com.github.ulisesbocchio:jasypt-spring-boot:3.0.4；
标签：github、ulisesbocchio、jasypt、spring、boot、中英对照文档、jar包、java；
使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。
人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。
双语对照，边学技术、边学英语。
				在上一篇文章《springboot + jasypt实现配置文件application.yaml敏感数据加密》中，我们已阐述jasypt工具的集成，上一期用的是2.x.x版本，
jasypt-spring-boot-starter从3.x.x版本开始，使用有些许变化了，当然这两个版本的starter对应的核心包版本同样是jasypt-1.9.3，下面开始实践一下，没看过上一篇文章的道友可以快速去阅览一下。（阅读本文耗时不足1分钟）1、将jasypt-spring-boot-starter版本从2.1.2 改
				赠送jar包：jasypt-spring-boot-3.0.4.jar；
赠送原API文档：jasypt-spring-boot-3.0.4-javadoc.jar；
赠送源代码：jasypt-spring-boot-3.0.4-sources.jar；
赠送Maven依赖信息文件：jasypt-spring-boot-3.0.4.pom；
包含翻译后的API文档：jasypt-spring-boot-3.0.4-javadoc-API文档-中文(简体)版.zip；
Maven坐标：com.github.ulisesbocchio:jasypt-spring-boot:3.0.4；
标签：github、ulisesbocchio、jasypt、spring、boot、中文文档、jar包、java；
使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。
人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。
				为了回答这个问题，首先需要了解jasypt-spring-boot-starter是什么。jasypt-spring-boot-starter是一个用于Spring Boot的开源库，它提供了对加密和解密功能的支持。它基于Jasypt（Java Simplified Encryption）库，并与Spring Boot框架集成，使加密和解密配置变得容易。
要下载jasypt-spring-boot-starter，可以按照以下步骤进行操作：
1. 打开您的项目的pom.xml文件。
2. 在<dependencies>节点中添加以下内容：
```xml
<dependency>
    <groupId>com.github.ulisesbocchio</groupId>
    <artifactId>jasypt-spring-boot-starter</artifactId>
    <version>2.1.2</version>
</dependency>
3. 保存pom.xml文件，并等待Maven自动下载所需的库文件。
这样，您就成功地将jasypt-spring-boot-starter库添加到了您的项目中。现在，您可以在Spring Boot应用程序中使用jasypt库的功能，例如配置加密和解密属性文件、加密数据库密码等。
请确保您的项目已经配置了正确的Maven中央仓库，以便下载所需的库文件。此外，还应确保您的项目的依赖管理工具（如Maven或Gradle）已正确配置，以便从仓库或存储库中下载所需的库文件。
希望这个回答能对您有所帮助！

配置项	是否必须	默认值
jasypt.encryptor.password	True	-
jasypt.encryptor.algorithm	False	PBEWITHHMACSHA512ANDAES_256
jasypt.encryptor.key-obtention-iterations	False	1000
jasypt.encryptor.pool-size	False	1
jasypt.encryptor.provider-name	False	SunJCE
jasypt.encryptor.provider-class-name	False	null
jasypt.encryptor.salt-generator-classname	False	org.jasypt.salt.RandomSaltGenerator
jasypt.encryptor.iv-generator-classname	False	org.jasypt.iv.RandomIvGenerator
jasypt.encryptor.string-output-type	False	base64
jasypt.encryptor.proxy-property-sources	False	false
jasypt.encryptor.skip-property-sources	False	empty list

属性名	默认值	描述
jasypt.encryptor.privateKeyString	null	用于解密的字符串格式的私钥
jasypt.encryptor.privateKeyLocation	null	用于以spring资源格式解密的私钥的位置
jasypt.encryptor.privateKeyFormat	DER	秘钥编码格式 DER 或者 PEM