SpringBoot实现敏感配置信息加密与解密_Java

一、为什么要加密配置？

先说说springboot的配置加载机制。我们知道，springboot支持多种配置加载方式，优先级从高到低大概是：

命令行参数
环境变量
application-{profile}.yml
application.yml
@configurationproperties注解

不管用哪种方式，敏感信息（比如数据库密码、redis密码、第三方api密钥）如果明文存储，都会有泄露风险：

开发环境：本地配置文件可能被传到git 测试环境：测试服务器可能被非授权访问 生产环境：配置文件权限管理不当，被运维人员误看

更重要的是，《网络安全法》明确要求对敏感信息进行加密存储。去年某银行就因为数据库密码明文存储被罚款200万。

所以，给配置文件加密不是选择题，是必答题。

二、方案一：jasypt集成（推荐）

jasypt是springboot生态中相对成熟的配置加密工具，开箱即用，配置简单。

1. 添加依赖

添加jasypt依赖

<dependency>
    <groupid>com.github.ulisesbocchio</groupid>
    <artifactid>jasypt-spring-boot-starter</artifactid>
    <version>3.0.5</version>
</dependency>

2. 配置加密密钥

在application.yml中添加jasypt配置：

jasypt:
  encryptor:
    password: ${encrypt_key}  # 密钥从环境变量获取
    algorithm: pbewithhmacsha512andaes_256  # 推荐使用强加密算法
    iv-generator-classname: org.jasypt.iv.randomivgenerator

划重点：密钥千万不要写在配置文件里！这里用环境变量${encrypt_key}，docker部署时通过-e encrypt_key=xxx传入。

3. 加密敏感配置

用jasypt提供的命令行工具加密明文密码：

# 下载jasypt-cli包
wget https://github.com/jasypt/jasypt/releases/download/jasypt-1.9.3/jasypt-1.9.3-dist.zip
unzip jasypt-1.9.3-dist.zip

# 执行加密命令（密钥用你的实际密钥替换）
java -cp jasypt-1.9.3/lib/jasypt-1.9.3.jar org.jasypt.intf.cli.jasyptpbestringencryptioncli input="你的明文密码" password=你的密钥(32字节) algorithm=pbewithhmacsha512andaes_256 ivgeneratorclassname=org.jasypt.iv.randomivgenerator

执行后会输出加密后的密文，类似这样：

----environment-----------------
runtime: openjdk 64-bit server vm 11.0.18+10

----arguments-------------------
input: 你的明文密码
password: 你的密钥
algorithm: pbewithhmacsha512andaes_256

----output----------------------
加密后的密文

4. 在配置文件中使用密文

把加密后的密文用enc()包裹，放到配置文件里：

spring:
  datasource:
    url: jdbc:mysql://prod-db:3306/order_db
    username: root
    password: enc(加密后的密文)  # 用enc()包裹

5. 启动应用

启动时传入密钥：

java -jar app.jar -djasypt.encryptor.password=你的密钥
# 或者用环境变量
encrypt_key=你的密钥 
java -jar app.jar

三、方案二：自定义加密解密（适合有特殊需求）

如果jasypt满足不了你的需求（比如要对接企业内部的密钥管理系统），可以自己实现加密解密逻辑。

比如，某些时候项目需要用国密算法sm4，jasypt不支持，就需要自定义个解密处理器。

1. 实现思路

springboot启动时会加载配置文件，我们可以通过自定义propertysource，在配置被读取前进行解密。

2. 代码实现

第一步：创建加密工具类

package com.example.config.encrypt;

import org.bouncycastle.jce.provider.bouncycastleprovider;
import javax.crypto.cipher;
import javax.crypto.spec.secretkeyspec;
import java.security.security;
import java.util.base64;

/**
 * 国密sm4加密工具类
 * 依赖bcprov-jdk15on
 */
public class sm4utils {
    static {
        security.addprovider(new bouncycastleprovider());
    }
    
    private static final string algorithm_name = "sm4";
    private static final string algorithm_name_ecb_padding = "sm4/ecb/pkcs7padding";
    private secretkeyspec secretkeyspec;
    private cipher cipher;

    public sm4utils(string key) {
        try {
            secretkeyspec = new secretkeyspec(key.getbytes(), algorithm_name);
            cipher = cipher.getinstance(algorithm_name_ecb_padding, "bc");
        } catch (exception e) {
            throw new runtimeexception("初始化sm4加密工具失败", e);
        }
    }

    // 加密
    public string encrypt(string plaintext) {
        try {
            cipher.init(cipher.encrypt_mode, secretkeyspec);
            byte[] encrypted = cipher.dofinal(plaintext.getbytes());
            return base64.getencoder().encodetostring(encrypted);
        } catch (exception e) {
            throw new runtimeexception("sm4加密失败", e);
        }
    }

    // 解密
    public string decrypt(string ciphertext) {
        try {
            cipher.init(cipher.decrypt_mode, secretkeyspec);
            byte[] decrypted = cipher.dofinal(base64.getdecoder().decode(ciphertext));
            return new string(decrypted);
        } catch (exception e) {
            throw new runtimeexception("sm4解密失败", e);
        }
    }
}

第二步：创建自定义propertysource

package com.example.config.encrypt;

import org.springframework.core.env.propertysource;

/**
 * 自定义加密配置源
 * 解密以"sm4:"开头的配置项
 */
public class sm4encryptedpropertysource extends propertysource<object> {
    private final propertysource<?> source;
    private final sm4utils sm4utils;

    public sm4encryptedpropertysource(string name, propertysource<?> source, string key) {
        super(name);
        this.source = source;
        this.sm4utils = new sm4utils(key);
    }

    @override
    public object getproperty(string name) {
        object value = source.getproperty(name);
        if (value instanceof string) {
            string strvalue = (string) value;
            // 解密以"sm4:"开头的配置
            if (strvalue.startswith("sm4:")) {
                string ciphertext = strvalue.substring(4);
                return sm4utils.decrypt(ciphertext);
            }
        }
        return value;
    }
}

第三步：注册propertysource

package com.example.config.encrypt;

import org.springframework.boot.springapplication;
import org.springframework.boot.env.environmentpostprocessor;
import org.springframework.core.env.configurableenvironment;
import org.springframework.core.env.mutablepropertysources;
import org.springframework.core.env.propertysource;

/**
 * 环境后置处理器，注册自定义propertysource
 */
public class encryptedenvironmentpostprocessor implements environmentpostprocessor {
    @override
    public void postprocessenvironment(configurableenvironment environment, springapplication application) {
        mutablepropertysources propertysources = environment.getpropertysources();
        
        // 从环境变量获取sm4密钥
        string sm4key = environment.getproperty("sm4_key");
        if (sm4key == null) {
            throw new runtimeexception("环境变量sm4_key未配置");
        }
        
        // 遍历所有propertysource，包装需要解密的配置
        for (propertysource<?> source : propertysources) {
            if (source.getname().contains("application.yaml")) {
                propertysources.replace(source.getname(), 
                    new sm4encryptedpropertysource(source.getname(), source, sm4key));
            }
        }
    }
}

第四步：配置spring.factories

在src/main/resources/meta-inf/spring.factories中注册后置处理器：

org.springframework.boot.env.environmentpostprocessor=\
com.example.config.encrypt.encryptedenvironmentpostprocessor

3. 使用方式

在配置文件中用sm4:前缀标识需要加密的配置：

spring:
  datasource:
    password: sm4:加密后的密文  # 用sm4加密

启动时传入密钥：

sm4_key=你的密钥
java -jar app.jar

适用场景

需要更灵活的自定义敏感数据加解密逻辑
需要对接企业内部密钥管理系统（如从数据库/接口获取密钥）
需要更细粒度的解密控制（如按配置项类型解密）

四、从开发到生产的完整流程

1. 开发环境

用jasypt加密，密钥存在本地环境变量
idea配置run configuration，自动注入密钥
gitignore过滤所有包含密钥的配置文件

2. 测试环境

jenkins pipeline从凭据管理获取密钥
构建时自动加密配置文件
部署时通过环境变量注入密钥

3. 生产环境

密钥可以存储在阿里云kms
应用启动时通过iam角色获取密钥
配置文件通过ansible或其他方式统一分发

4. 验证方法

部署后一定要验证配置是否解密成功，可以写个简单的接口：

@restcontroller
public class configtestcontroller {
    @value("${spring.datasource.password}")
    private string dbpassword;

    @getmapping("/test/config")
    public string testconfig() {
        // 打印脱敏后的密码（只显示前3位和后3位）
        if (dbpassword.length() > 6) {
            return "密码解密成功：" + dbpassword.substring(0, 3) + "******" + dbpassword.substring(dbpassword.length() - 3);
        }
        return "密码解密成功";
    }
}