Spring配置文件中密码明文改为密文处理的通用方式_Java

一、背景

springboot和springcloud中涉及多个配置文件，配置文件中对于密码默认是明文方式，这种方式在生产环境一般是不被允许的。为避免配置文件中出现明文，应当在配置文件中配置为密文，然后在启动时在程序内部完成解密。

本文提供了通用的处理方式，可以适配以下几类配置文件：

本地bootstrap.properties 在spring的bean创建之前的配置
本地application.properties 在spring的配置，包括带profile环境的配置
配置中心上的配置（例如nacos上的data id）

为了适应配置文件涉及密码由明文改为密文，需要分为两步：

①将配置文件中涉及密文的配置项配置为密文字符串（需自己加密计算得到）；

②在spring启动中读取密文字符串并解密还原。

二、思路

对于以上第②步spring启动时的处理，由于以上配置文件在spring加载的时机和生命周期不同，有两种处理方式：

a) 普通方式

由于spring中的对本地application.properties或者配置中心上的配置（例如nacos上的data id）在spring bean创建过程中，会有对应的配置bean（通过注解@configuration申明的java类），spring会自动根据读取解析配置文件并赋值给bean。

因此，若需要对密文字符串并解密还原，可以对配置bean（通过注解@configuration申明的java类）进行继承，override重写对应的set方法，完成解密。

b) 适合bootstrap.properties方式

对于spring cloud，在bootstrap阶段还未创建bean，所以以上override重写对应的set方法并不适用。所以对于bootstrap.properties配置文件。可通过实现environmentpostprocessor接口，来捕获environment配置，解密后将配置新值设置到environment中。

三、示例

a) 普通方式（连接redis集群）

下面以连接redis集群为例进行说明，连接redis集群的配置项可以在本地application.properties或者配置中心上的配置（例如nacos上的data id），且其中spring.redis.password配置项值已经设置为密文。

下面代码对配置bean（通过注解@configuration申明的java类redisproperties）进行继承，override重写对应的set方法。java代码如下：

package 包指定忽略，请自定;
 
import 忽略解密计算工具类systemsecurityalgorithm，请自定;
import org.springframework.boot.autoconfigure.data.redis.redisproperties;
import org.springframework.context.annotation.configuration;
import org.springframework.context.annotation.primary;
import org.springframework.util.stringutils;
 
/**
 * 连接redis集群的配置类【通过@configuration覆盖原bean机制】:
 *   1、连接redis的连接password不得出现明文，故需在properties配置文件中配置为加密密文（加密算法java类为：systemsecurityalgorithm），然后在启动时通过本类解密
 *   2、贵金属应用服务采用多数据中心datacenter部署。而每逻辑中心均有独立的redis集群。 应用服务应连接同逻辑中心内的redis集群，既北京的应用服务不应该连接合肥redis集群
 *     既：对于同服务的不同实例，应根据服务实例所在逻辑中心（具体见枚举serviceconstant.datacenter定义的逻辑中心）连接相同逻辑中心下的redis集群。
 *     因此：
 *        a).以spring标准redis连接配置为基础，对nodes值中各个ip端口配置，在各ip前增加一个大写字母：该ip所在datacenter数据中心的英文代码
 *        b).以spring标准redis连接配置为基础，对password值改为可配多个密码，以逗号分隔，每个密码前增加一个大写字母，该密码是连接哪个redis集群的datacenter数据中心的英文代码
 * 为支持以上，定制化开发本类，实现处理最终还原至spring标准连接redis的配置，以供lettuce创建连接池。
 *  -----------------------------------------------------------
 * 机制适用性：
 * 除了通过@configuration覆盖原bean机制，还有通过实现environmentpostprocessor接口机制。两种机制适用性说明如下：
 *   bootstrap.properties配置文件（bootstrap阶段，还未创建bean） →→适合→→ 【实现environmentpostprocessor接口机制】
 *   本地application.properties配置文件（正常springboot启动，通过@configuration注解的bean） →→适合→→ 【实现environmentpostprocessor接口机制】和【通过@configuration覆盖原bean机制】均可
 *   从nacos等配置中心获取得到的配置文件 →→适合→→ 【通过@configuration覆盖原bean机制】
 *
 */
@configuration
@primary // 由于默认redisproperties作为配置类会自动创建bean。 为避免存在两个同类型（redisproperties）bean，所以本类通过注解primary，使得只有本类生效。相当于替代默认redisproperties
public class gjsredisproperties extends redisproperties {
 
    private static final org.slf4j.logger log = org.slf4j.loggerfactory.getlogger(gjsredisproperties.class);
 
    @override
    public void setpassword(string orginpassword) {
        if(stringutils.hastext(orginpassword)) {
            // 对密文解密并设置
            if (stringutils.hastext(orginpassword) && orginpassword.length() >= 32 ) { // 如果满足密码密文的长度及大小写要求，视为密文，解密
                string padstr = systemsecurityalgorithm.decryptstr(orginpassword);
                log.debug("连接redis配置项spring.redis.password: 解密前orginpassword=[{}], 解密后padstr=[{}]", orginpassword, padstr); //为避免密码泄露，仅debug才输出明文
                log.info("连接redis配置项spring.redis.password: 对密文orginpassword=[{}]已完成解密", orginpassword);
                super.setpassword(padstr);
            } else { // 不满足密码密文的长度及大小写要求(视为明文,不解密)，保持不变
                log.warn("连接redis配置项spring.redis.password的:orginpassword=[{}]不满足密码密文的长度及大小写要求(视为明文,不解密)，保持不变", orginpassword);
                super.setpassword(orginpassword);
            }
        }
    }
}

a) 普通方式（连接rocketmq）

下面以连接rocketmq为例进行说明，连接rocketmq的配置项可以在本地application.properties或者配置中心上的配置（例如nacos上的data id），且其中rocketmq.producer.secret-key和rocketmq.consumer.secret-key配置项值已经设置为密文。

下面代码对配置bean（通过注解@configuration申明的java类rocketmqproperties）进行继承，override重写对应的set方法。java代码如下：

package 包指定忽略，请自定;
 
import 忽略解密计算工具类systemsecurityalgorithm，请自定;
import org.apache.rocketmq.spring.autoconfigure.rocketmqproperties;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.context.configurableapplicationcontext;
import org.springframework.context.annotation.configuration;
import org.springframework.context.annotation.primary;
import org.springframework.core.env.configurableenvironment;
import org.springframework.core.env.mappropertysource;
import org.springframework.util.stringutils;
 
import java.util.hashmap;
import java.util.map;
 
/**
 * 连接rocketmq的配置类【通过@configuration覆盖原bean机制】:
 *   因连接rocketmq的secret-key不得出现明文，故需在properties配置文件中配置为加密密文（加密算法java类为：systemsecurityalgorithm），然后在启动时通过本类解密
 *  -----------------------------------------------------------
 * 机制适用性：
 * 除了通过@configuration覆盖原bean机制，还有通过实现environmentpostprocessor接口机制。两种机制适用性说明如下：
 *   bootstrap.properties配置文件（bootstrap阶段，还未创建bean） →→适合→→ 【实现environmentpostprocessor接口机制】
 *   本地application.properties配置文件（正常springboot启动，通过@configuration注解的bean） →→适合→→ 【实现environmentpostprocessor接口机制】和【通过@configuration覆盖原bean机制】均可
 *   从nacos等配置中心获取得到的配置文件 →→适合→→ 【通过@configuration覆盖原bean机制】
 *
 */
@configuration
@primary // 由于默认rocketmqproperties作为配置类会自动创建bean。 为避免存在两个同类型（rocketmqproperties）bean，所以本类通过注解primary，使得只有本类生效。相当于替代默认rocketmqproperties
public class gjsrocketmqproperties extends rocketmqproperties {
 
    final private string keyname_producer_secret = "rocketmq.producer.secret-key";
    final private string keyname_consumer_secret = "rocketmq.consumer.secret-key";
 
    @autowired
    configurableapplicationcontext springcontext;
 
    private static final org.slf4j.logger log = org.slf4j.loggerfactory.getlogger(gjsrocketmqproperties.class);
 
    @override
    public void setproducer(producer producer) {
        final string orginsecretkey = producer.getsecretkey();
        // 对密文解密并设置
        if (stringutils.hastext(orginsecretkey) && orginsecretkey.length() >= 32) { // 如果满足密码密文的长度及大小写要求，视为密文，解密
            string padstr = systemsecurityalgorithm.decryptstr(orginsecretkey);
            log.debug("连接rocketmq配置项{}: 解密前orginsecretkey=[{}], 解密后padstr=[{}]", keyname_producer_secret, orginsecretkey, padstr); //为避免密码泄露，仅debug才输出明文
            log.info("连接rocketmq配置项{}: 对密文orginsecretkey=[{}]已完成解密", keyname_producer_secret, orginsecretkey);
            producer.setsecretkey(padstr);
 
            // 由于rocketmq在构建defaultrocketmqlistenercontainer过程中，会从spring的environment中获取配置。
            // 附调用关系简要说明如下：
            //     org.apache.rocketmq.spring.support.defaultrocketmqlistenercontainer.afterpropertiesset()
            //       org.apache.rocketmq.spring.support.defaultrocketmqlistenercontainer.initrocketmqpushconsumer()
            //         org.apache.rocketmq.spring.support.rocketmqutil.getrpchookbyaksk()
            //           org.springframework.core.env.abstractenvironment.resolverequiredplaceholders()
            //             ......
            //               org.springframework.boot.context.properties.source.configurationpropertysourcespropertyresolver.findpropertyvalue()
            // 因此一并修改环境中的值，使其能取得新值
            modifyenvironmentvalue(springcontext.getenvironment(), keyname_producer_secret, padstr);
 
        } else { // 不满足密码密文的长度及大小写要求(视为明文,不解密)，保持不变
            log.warn("连接rocketmq配置项rocketmq.producer.secret-key值=[{}]不满足密码密文的长度及大小写要求(视为明文,不解密)，保持不变", orginsecretkey);
        }
 
        super.setproducer(producer);
    }
 
    @override
    public void setconsumer(pushconsumer pushconsumer) {
        final string orginsecretkey = pushconsumer.getsecretkey();
        // 对密文解密并设置
        if (stringutils.hastext(orginsecretkey) && orginsecretkey.length() >= 32 ) { // 如果满足密码密文的长度及大小写要求，视为密文，解密
            string padstr = systemsecurityalgorithm.decryptstr(orginsecretkey);
            log.debug("连接rocketmq配置项{}: 解密前orginsecretkey=[{}], 解密后padstr=[{}]", keyname_consumer_secret, orginsecretkey, padstr); //为避免密码泄露，仅debug才输出明文
            log.info("连接rocketmq配置项{}: 对密文orginsecretkey=[{}]已完成解密", keyname_consumer_secret, orginsecretkey);
            pushconsumer.setsecretkey(padstr);
 
            // 由于rocketmq在构建defaultrocketmqlistenercontainer过程中，会从spring的environment中获取配置。
            // 附调用关系简要说明如下：
            //     org.apache.rocketmq.spring.support.defaultrocketmqlistenercontainer.afterpropertiesset()
            //       org.apache.rocketmq.spring.support.defaultrocketmqlistenercontainer.initrocketmqpushconsumer()
            //         org.apache.rocketmq.spring.support.rocketmqutil.getrpchookbyaksk()
            //           org.springframework.core.env.abstractenvironment.resolverequiredplaceholders()
            //             ......
            //               org.springframework.boot.context.properties.source.configurationpropertysourcespropertyresolver.findpropertyvalue()
            // 因此一并修改环境中的值，使其能取得新值
            modifyenvironmentvalue(springcontext.getenvironment(), keyname_consumer_secret, padstr);
 
        } else { // 不满足密码密文的长度及大小写要求(视为明文,不解密)，保持不变
            log.warn("连接rocketmq配置项{}的值=[{}]不满足密码密文的长度及大小写要求(视为明文,不解密)，保持不变", keyname_consumer_secret, orginsecretkey);
        }
 
        super.setconsumer(pushconsumer);
    }
 
    @override
    public void setpullconsumer(pullconsumer pullconsumer) {
        final string orginsecretkey = pullconsumer.getsecretkey();
        // 对密文解密并设置
        if (stringutils.hastext(orginsecretkey) && orginsecretkey.length() >= 32 ) { // 如果满足密码密文的长度及大小写要求，视为密文，解密
            string padstr = systemsecurityalgorithm.decryptstr(orginsecretkey);
            log.debug("连接rocketmq配置项{}: 解密前orginsecretkey=[{}], 解密后padstr=[{}]", keyname_consumer_secret, orginsecretkey, padstr); //为避免密码泄露，仅debug才输出明文
            log.info("连接rocketmq配置项{}: 对密文orginsecretkey=[{}]已完成解密", keyname_consumer_secret, orginsecretkey);
            pullconsumer.setsecretkey(padstr);
 
            // 由于rocketmq在构建defaultrocketmqlistenercontainer过程中，会从spring的environment中获取配置。
            // 附调用关系简要说明如下：
            //     org.apache.rocketmq.spring.support.defaultrocketmqlistenercontainer.afterpropertiesset()
            //       org.apache.rocketmq.spring.support.defaultrocketmqlistenercontainer.initrocketmqpushconsumer()
            //         org.apache.rocketmq.spring.support.rocketmqutil.getrpchookbyaksk()
            //           org.springframework.core.env.abstractenvironment.resolverequiredplaceholders()
            //             ......
            //               org.springframework.boot.context.properties.source.configurationpropertysourcespropertyresolver.findpropertyvalue()
            // 因此一并修改环境中的值，使其能取得新值
            modifyenvironmentvalue(springcontext.getenvironment(), keyname_consumer_secret, padstr);
 
        } else { // 不满足密码密文的长度及大小写要求(视为明文,不解密)，保持不变
            log.warn("连接rocketmq配置项{}的值=[{}]不满足密码密文的长度及大小写要求(视为明文,不解密)，保持不变", keyname_consumer_secret, orginsecretkey);
        }
 
        super.setpullconsumer(pullconsumer);
    }
 
 
    /**
     * 对spring的environment的配置项的值修改为新值
     * @param environment spring的environment对象
     * @param keyname 配置项名
     * @param newvalue 新值
     */
    private void modifyenvironmentvalue(configurableenvironment environment, final string keyname, string newvalue) {
        if(!environment.containsproperty(keyname)) {
            log.warn("当前spring的environment中不存在名为{}的配置项", keyname);
            return;
        }
        if(environment.getproperty(keyname, "").equals(newvalue)) {
            log.debug("当前spring的environment中配置项{}的值已与新值相同，无需修改", keyname);
            return;
        }
        map<string, object> map = new hashmap<>(); //用于存放新值
        map.put(keyname, newvalue);
        // 若有map有值，则把该map作为propertysource加入列表中，以实现：把environment中对应key的value覆盖为新值
        // 必须加到first并且不能存在两个相同的name的mappropertysource，值覆盖才能生效
        environment.getpropertysources().addfirst(new mappropertysource("modifyenvironmentvalue-"+keyname, map));
        log.info("已对spring的environment的配置项{}的值修改为新值", keyname);
    }
}

b) 适合bootstrap.properties方式

下面以连接nacos配置中心为例进行说明，需要在本地bootstrap.properties配置文件中指定连接nacos配置中心的nacos用户名、密码、服务端地址、data id等信息。bootstrap.properties配置文件有关连接nacos配置中心类似如下：

#nacos配置中心及注册中心的authenticate鉴权用户名和密码（需nacos服务端开启auth鉴权）
spring.cloud.nacos.username=nacos
spring.cloud.nacos.password=760dee29f9fc82af0cc1d6074879dc39
#nacos配置中心服务端的地址和端口(形式ip:port,ip:port,...) 。注：nacos-client1.x会按顺序选其中地址进行连接(前个连接失败则自动选后一个)。nacos-client2.x会随机选其中地址进行连接(若连接失败则自动另选)
spring.cloud.nacos.config.server-addr=ip1:8848,ip2:8848,ip3:8848,ip4:8848
 
#data id的前缀（如果不设置，则默认取 ${spring.application.name}）
#spring.cloud.nacos.config.prefix=
#默认指定为开发环境
#spring.profiles.active=
#nacos命名空间，此处不设置，保持默认
#spring.cloud.nacos.config.namespace=
#配置组（如果不设置，则默认为default_group）
spring.cloud.nacos.config.group=g_config_gjs_service
#指定文件后缀（如果不设置，则默认为properties）
spring.cloud.nacos.config.file-extension=properties
 
#以下为全局data id
spring.cloud.nacos.config.shared-configs[0].data-id=nacosregdiscoveryinfo.properties
spring.cloud.nacos.config.shared-configs[0].group=g_config_gjs_globalshared
spring.cloud.nacos.config.shared-configs[0].refresh=true
 
spring.cloud.nacos.config.shared-configs[1].data-id=xxxxx.properties
spring.cloud.nacos.config.shared-configs[1].group=g_config_gjs_globalshared
spring.cloud.nacos.config.shared-configs[1].refresh=true
 
spring.cloud.nacos.config.shared-configs[2].data-id=yyyyy.properties
spring.cloud.nacos.config.shared-configs[2].group=g_config_gjs_globalshared
spring.cloud.nacos.config.shared-configs[2].refresh=true

其中spring.cloud.nacos.password配置项值已经设置为密文。

下面的代码通过实现environmentpostprocessor接口，来捕获配置，并将配置新值设置到environment中。java代码如下：

package 包指定忽略，请自定;
 
import 忽略解密计算工具类systemsecurityalgorithm，请自定;
import org.apache.commons.logging.log;
import org.springframework.boot.configurablebootstrapcontext;
import org.springframework.boot.springapplication;
import org.springframework.boot.env.environmentpostprocessor;
import org.springframework.boot.logging.deferredlogfactory;
import org.springframework.core.ordered;
import org.springframework.core.env.configurableenvironment;
import org.springframework.core.env.mappropertysource;
import org.springframework.util.stringutils;
 
import java.util.hashmap;
import java.util.map;
 
/**
 * 本类通过实现environmentpostprocessor接口，实现在spring启动过程中从environment中读取指定的key值，处理后，然后把environment中对应key的value覆盖为新值。
 * 通过本类已经实现对bootstrap阶段的配置文件处理：
 *   因连接nacos的password不得出现明文，故bootstrap配置文件中为加密密文（加密算法java类为：systemsecurityalgorithm），然后在启动时通过本类解密
 * -----------------------------------------------------------
 * 注意：
 *   a) 需要在meta-inf下的spring.factories文件中配置本类后，本类才会生效(才被spring扫描识别到)
 *   b) 因为本类是通过实现environmentpostprocessor接口方式，所以本类在springcloud启动过程中会被调用两次：
 *         首先是在bootstrap配置文件加载后（springcloud为支持配置中心的bootstrap阶段）
 *         其次是在application配置文件加载后（springboot的正常启动时加载配置文件阶段）
 * 机制适用性：
 * 除了通过实现environmentpostprocessor接口机制，还有通过@configuration覆盖原bean机制。两种机制适用性说明如下：
 *   bootstrap.properties配置文件（bootstrap阶段，还未创建bean） →→适合→→ 【实现environmentpostprocessor接口机制】
 *   本地application.properties配置文件（正常springboot启动，通过@configuration注解的bean） →→适合→→ 【实现environmentpostprocessor接口机制】和【通过@configuration覆盖原bean机制】均可
 *   从nacos等配置中心获取得到的配置文件 →→适合→→ 【通过@configuration覆盖原bean机制】
 *
 */
public class gjsenvironmentpostprocessor implements environmentpostprocessor, ordered {
 
    /**
     * the default order for the processor.  值越小，优先级越高
     * 因bootstrap配置文件是通过{@link org.springframework.boot.context.config.configdataenvironmentpostprocessor}完成加载处理
     * 由于本environmentpostprocessor类需等待springcloud对bootstrap配置文件后才能执行，所以本environmentpostprocessor类优先级需更低
     */
    public static final int order = ordered.highest_precedence + 50;
 
    private final deferredlogfactory logfactory;
 
    private final log logger;
 
    public gjsenvironmentpostprocessor(deferredlogfactory logfactory,
                                       configurablebootstrapcontext bootstrapcontext) {
        this.logfactory = logfactory;
        this.logger = logfactory.getlog(getclass());
    }
 
 
    @override
    public int getorder() {
        return order;
    }
 
 
    /**
     * 从environment中读取指定的key，并进行解密，解密后的结果放入map对象中
     * @param environment 已经有的spring环境
     * @param keyname 指定的key名
     * @param map 若完成解密，则将解密后的结果放入map对象
     */
    private void decodepwd(configurableenvironment environment, string keyname, map<string, object> map ) {
        if(!environment.containsproperty(keyname)) {
            this.logger.debug("environmentpostprocessor 当前spring的environment中不存在名为"+keyname+"的配置项");
            return;
        }
 
        final string origalvalue = environment.getproperty(keyname);
        // 对密文解密并设置
        if (stringutils.hastext(origalvalue) && origalvalue.length() >= 32) { // 如果满足密码密文的长度及大小写要求，视为密文，解密
            string padstr = systemsecurityalgorithm.decryptstr(origalvalue);
            this.logger.debug("environmentpostprocessor 配置项"+keyname+"原值=["+origalvalue+"], 解密后值=["+padstr+"]"); //为避免在日志中密码泄露，仅debug才输出明文
            this.logger.info("environmentpostprocessor 配置项"+keyname+"原值=["+origalvalue+"]已完成解密");
            map.put(keyname, padstr);
        }else {
            this.logger.warn("environmentpostprocessor 配置项"+keyname+"值=["+origalvalue+"]不满足密码密文的长度及大小写要求(视为明文,不解密)，保持不变");
        }
    }
 
    @override
    public void postprocessenvironment(configurableenvironment environment, springapplication application) {
        this.logger.debug("environmentpostprocessor before propertysources size=" + environment.getpropertysources().size());
        this.logger.debug("environmentpostprocessor before propertysources : " + environment.getpropertysources());
        map<string, object> map = new hashmap<>(); //用于存放新值
 
        decodepwd(environment, "spring.cloud.nacos.password", map);
 
        if(!map.isempty()) {
            // 若有map有值，则把该map作为propertysource加入列表中，以实现：把environment中对应key的value覆盖为新值
            // 必须加到first并且不能存在两个相同的name的mappropertysource，值覆盖才能生效
            environment.getpropertysources().addfirst(new mappropertysource("afterdecodepassword", map));
        }
        this.logger.debug("environmentpostprocessor after propertysources size=" + environment.getpropertysources().size());
        this.logger.debug("environmentpostprocessor after propertysources : " + environment.getpropertysources());
    }
 
}