spring*.xml配置文件明文加密的实现

2023-07-07 00:27:03 80

说明：客户要求spring*.xml中Oracle/Redis/MongoDB的IP、端口、用户名、密码不能明文存放，接到需求的我，很无奈，但是还是的硬着头皮搞

系统架构：spring+mvc（Oracle是用jdbc自己封装的接口）

1.数据库配置文件加密

原xml配置
















.....

加密实现过程

思路：继承DruidDataSource，在初始化set值的时候进行解密

/**
*数据库连接解密
*@author:Geoff
*@create:2020-12-3016:46
**/
publicclassDataBaseXmlextendsDruidDataSource{


/**
*Log4jlogger
*/
privatefinalstaticLoggerlg=LoggerFactory.getLogger(DataBaseXml.class);

@Override
publicStringgetUrl(){
returnthis.jdbcUrl;
}

@Override
publicvoidsetUrl(StringjdbcUrl){
if(GEOFF.DATA_BASE_IS_ENCRYPTION){
lg.info("数据库【jdbcUrl】解密初始化加载...");
try{
jdbcUrl=Encryption.decrypt(jdbcUrl,GEOFF.DATA_BASE_ENCRYPTION_KEY);
}catch(Exceptione){
lg.error("数据库【jdbcUrl】密文解密失败...");
e.printStackTrace();
}
}
this.jdbcUrl=jdbcUrl;
}

@Override
publicStringgetUsername(){
returnthis.username;
}

@Override
publicvoidsetUsername(Stringusername){
if(GEOFF.DATA_BASE_IS_ENCRYPTION){
lg.info("数据库【username】解密初始化加载...");
try{
username=Encryption.decrypt(username,GEOFF.DATA_BASE_ENCRYPTION_KEY);
}catch(Exceptione){
lg.error("数据库【username】密文解密失败...");
e.printStackTrace();
}
}
this.username=username;
}

@Override
publicStringgetPassword(){
returnthis.password;
}

@Override
publicvoidsetPassword(Stringpassword){
if(GEOFF.DATA_BASE_IS_ENCRYPTION){
lg.info("数据库【password】解密初始化加载...");
try{
password=Encryption.decrypt(password,GEOFF.DATA_BASE_ENCRYPTION_KEY);
}catch(Exceptione){
lg.error("数据库【password】密文解密失败...");
e.printStackTrace();
}
}
this.password=password;
}



}

修改后配置文件
















.....

2.Redis配置文件加密

原配置文件

加密实现思路：由于JedisPool使用构造函数来创建，所以继承JedisPool后，在调用JedisPool构造函数的时候，调用static解密方法进行解密

importorg.apache.commons.pool2.impl.GenericObjectPoolConfig;
importorg.slf4j.Logger;
importorg.slf4j.LoggerFactory;
importredis.clients.jedis.*;

/**
*redis数据库用户名密码解密
*@author:Geoff
*@create:2020-12-3017:20
**/
publicclassJedisPoolXmlextendsJedisPool{


/**
*Log4jlogger
*/
privatefinalstaticLoggerlg=LoggerFactory.getLogger(JedisPoolXml.class);



publicJedisPoolXml(GenericObjectPoolConfigpoolConfig,Stringhost,Stringport,Stringtimeout,Stringpassword){
super(poolConfig,decryptHost(host),decryptPort(port),decryptTimeout(timeout),decryptPassword(password),0,(String)null);
}

privateJedisPoolXml(GenericObjectPoolConfigpoolConfig,Stringhost,Stringport,Stringtimeout,Stringpassword,Stringdatabase){
super(poolConfig,decryptHost(host),decryptPort(port),decryptTimeout(timeout),decryptPassword(password),decryptDatabase(database));
}


privatestaticStringdecryptHost(Stringhost){
if(GEOFF.DATA_BASE_IS_ENCRYPTION){
lg.info("Redis【host】解密初始化加载...");
try{
host=Encryption.decrypt(host,GEOFF.DATA_BASE_ENCRYPTION_KEY);
}catch(Exceptione){
lg.error("Redis【host】密文解密失败...");
e.printStackTrace();
}
}
returnhost;
}

privatestaticintdecryptPort(Stringport){
if(GEOFF.DATA_BASE_IS_ENCRYPTION){
lg.info("Redis【port】解密初始化加载...");
try{
port=Encryption.decrypt(port,GEOFF.DATA_BASE_ENCRYPTION_KEY);
}catch(Exceptione){
lg.error("Redis【port】密文解密失败...");
e.printStackTrace();
}
}
returnInteger.parseInt(port);
}

privatestaticintdecryptTimeout(Stringtimeout){
if(GEOFF.DATA_BASE_IS_ENCRYPTION){
lg.info("Redis【timeout】解密初始化加载...");
try{
timeout=Encryption.decrypt(timeout,GEOFF.DATA_BASE_ENCRYPTION_KEY);
}catch(Exceptione){
lg.error("Redis【timeout】密文解密失败...");
e.printStackTrace();
}
}
returnInteger.parseInt(timeout);
}

privatestaticStringdecryptPassword(Stringpassword){
if(GEOFF.DATA_BASE_IS_ENCRYPTION){
lg.info("Redis【password】解密初始化加载...");
try{
password=Encryption.decrypt(password,GEOFF.DATA_BASE_ENCRYPTION_KEY);
}catch(Exceptione){
lg.error("Redis【password】密文解密失败...");
e.printStackTrace();
}
}
returnpassword;
}

privatestaticintdecryptDatabase(Stringdatabase){
if(GEOFF.DATA_BASE_IS_ENCRYPTION){
lg.info("Redis【database】解密初始化加载...");
try{
database=Encryption.decrypt(database,GEOFF.DATA_BASE_ENCRYPTION_KEY);
}catch(Exceptione){
lg.error("Redis【database】密文解密失败...");
e.printStackTrace();
}
}
returnInteger.parseInt(database);
}

}

修改后xml

3.MongoDB配置文件加密（使用的是spring-data-mognodb框架）

原xml配置

加密思路：由于项目使用的时候是获取bean的方式来获取MongoTemplate和mongoDbFactory的，尝试过各种方法来继承后加密，但是最后都不行，后面只能通过手动的方法进行初始化，并将对应MongoTemplate和mongoDbFactory注入到bean中

importcom.mongodb.*;
importorg.slf4j.Logger;
importorg.slf4j.LoggerFactory;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.context.annotation.Bean;

importorg.springframework.context.annotation.Configuration;
importorg.springframework.data.mongodb.core.MongoTemplate;
importorg.springframework.data.mongodb.core.SimpleMongoDbFactory;
importorg.springframework.data.mongodb.core.convert.DefaultDbRefResolver;
importorg.springframework.data.mongodb.core.convert.MappingMongoConverter;
importorg.springframework.data.mongodb.core.mapping.MongoMappingContext;
importorg.springframework.data.mongodb.gridfs.GridFsTemplate;

importjava.util.ArrayList;
importjava.util.List;

/**
*@author:Geoff
*@create:2020-12-3116:15
**/

@Configuration
publicclassMongoDBXml{

/**
*Log4jlogger
*/
privatefinalstaticLoggerlg=LoggerFactory.getLogger(MongoDBXml.class);

privateStringhost;
privateIntegerport;
privateStringuserName;
privateStringpassWord;
privateStringdataBase;

privateSimpleMongoDbFactorymongoDbFactory=null;
privateMappingMongoConverterconverter=null;


publicStringgetHost(){
returnhost;
}


publicvoidsetHost(Stringhost){
this.host=decryptHost(host);
}

publicIntegergetPort(){
returnport;
}


publicvoidsetPort(Stringport){
this.port=decryptPort(port);
}

publicStringgetUserName(){
returnuserName;
}

publicvoidsetUserName(StringuserName){
this.userName=decryptUserName(userName);
}

publicStringgetPassWord(){
returnpassWord;
}

publicvoidsetPassWord(StringpassWord){
this.passWord=decryptPassword(passWord);
}

publicStringgetDataBase(){
returndataBase;
}

publicvoidsetDataBase(StringdataBase){
this.dataBase=decryptDatabase(dataBase);
}

privateStringdecryptHost(Stringhost){
if(GEOFF.DATA_BASE_IS_ENCRYPTION){
lg.info("MongoDB【host】解密初始化加载...");
try{
host=Encryption.decrypt(host,GEOFF.DATA_BASE_ENCRYPTION_KEY);
}catch(Exceptione){
lg.error("MongoDB【host】密文解密失败...");
e.printStackTrace();
}
}
returnhost;
}

privateintdecryptPort(Stringport){
if(GEOFF.DATA_BASE_IS_ENCRYPTION){
lg.info("MongoDB【port】解密初始化加载...");
try{
port=Encryption.decrypt(port,GEOFF.DATA_BASE_ENCRYPTION_KEY);
}catch(Exceptione){
lg.error("MongoDB【port】密文解密失败...");
e.printStackTrace();
}
}
returnInteger.parseInt(port);
}

privateStringdecryptUserName(StringuserName){
if(GEOFF.DATA_BASE_IS_ENCRYPTION){
lg.info("MongoDB【userName】解密初始化加载...");
try{
userName=Encryption.decrypt(userName,GEOFF.DATA_BASE_ENCRYPTION_KEY);
}catch(Exceptione){
lg.error("MongoDB【userName】密文解密失败...");
e.printStackTrace();
}
}
returnuserName;
}

privateStringdecryptPassword(StringpassWord){
if(GEOFF.DATA_BASE_IS_ENCRYPTION){
lg.info("MongoDB【password】解密初始化加载...");
try{
passWord=Encryption.decrypt(passWord,GEOFF.DATA_BASE_ENCRYPTION_KEY);
}catch(Exceptione){
lg.error("MongoDB【password】密文解密失败...");
e.printStackTrace();
}
}
returnpassWord;
}

privateStringdecryptDatabase(StringdataBase){
if(GEOFF.DATA_BASE_IS_ENCRYPTION){
lg.info("MongoDB【database】解密初始化加载...");
try{
dataBase=Encryption.decrypt(dataBase,GEOFF.DATA_BASE_ENCRYPTION_KEY);
}catch(Exceptione){
lg.error("MongoDB【database】密文解密失败...");
e.printStackTrace();
}
}
returndataBase;
}




publicvoidinit(){
MongoClientOptions.Builderbuild=newMongoClientOptions.Builder();
MongoClientOptionsoptions=build.build();
try{
Listaddrs=newArrayList();
ServerAddressserverAddress=newServerAddress(host,port);
addrs.add(serverAddress);
MongoCredentialcredential=MongoCredential.createScramSha1Credential(userName,dataBase,passWord.toCharArray());
Listcredentials=newArrayList();
credentials.add(credential);
MongoClientmongoClient=newMongoClient(addrs,credentials,options);
mongoDbFactory=newSimpleMongoDbFactory(mongoClient,dataBase);
DefaultDbRefResolverdbRefResolver=newDefaultDbRefResolver(mongoDbFactory);
MongoMappingContextmongoMappingContext=newMongoMappingContext();
converter=newMappingMongoConverter(dbRefResolver,mongoMappingContext);
lg.info("mongodb客户端创建成功");
}catch(Exceptione){
lg.info("mongodb客户端创建失败");
e.printStackTrace();
}
documentTemplate();
gridFsTemplate();


}

@Bean
publicMongoTemplatedocumentTemplate(){
if(mongoDbFactory!=null&&converter!=null){
lg.info("MongoTemplate初始化成功......");
MongoTemplatemongoTemplate=newMongoTemplate(mongoDbFactory,converter);
returnmongoTemplate;
}else{
lg.error("MongoTemplate初始化失败......");
returnnull;
}
}

@Bean
publicGridFsTemplategridFsTemplate(){
if(mongoDbFactory!=null&&converter!=null){
lg.info("GridFsTemplate初始化成功......");
GridFsTemplategridFsTemplate=newGridFsTemplate(mongoDbFactory,converter);
returngridFsTemplate;
}else{
lg.error("GridFsTemplate初始化失败......");
returnnull;
}
}

publicvoiddestroy(){
try{
this.mongoDbFactory.destroy();
}catch(Exceptione){
e.printStackTrace();
}
}


}

修改后配置文件

4.最后附上对应的加解密类

importorg.apache.commons.codec.binary.Base64;

importjavax.crypto.Cipher;
importjavax.crypto.SecretKey;
importjavax.crypto.SecretKeyFactory;
importjavax.crypto.spec.DESKeySpec;
importjava.security.Key;
importjava.security.SecureRandom;

/**
*加密生成token的方法
*
*@author:Geoff
*@create:2020-12-3017:03
**/

publicclassEncryption{
//算法名称
publicstaticfinalStringKEY_ALGORITHM="DES";
//算法名称/加密模式/填充方式
//DES共有四种工作模式-->>ECB：电子密码本模式、CBC：加密分组链接模式、CFB：加密反馈模式、OFB：输出反馈模式
publicstaticfinalStringCIPHER_ALGORITHM="DES/ECB/PKCS5Padding";

/**
*生成密钥key对象
*
*@param
*@return密钥对象
*@throwsException
*/
privatestaticSecretKeykeyGenerator(StringkeyStr)throwsException{
byte[]input=HexString2Bytes(keyStr);
DESKeySpecdesKey=newDESKeySpec(input);
//创建一个密匙工厂，然后用它把DESKeySpec转换成
SecretKeyFactorykeyFactory=SecretKeyFactory.getInstance(KEY_ALGORITHM);
SecretKeysecurekey=keyFactory.generateSecret(desKey);
returnsecurekey;
}


/**
*从十六进制字符串到字节数组转换
*/
publicstaticbyte[]HexString2Bytes(StringhexStr){
byte[]keyBytes=hexStr.getBytes();
if(keyBytes.length==16){
byte[]tmpKey=newbyte[24];
System.arraycopy(keyBytes,0,tmpKey,0,16);
System.arraycopy(keyBytes,0,tmpKey,16,8);
keyBytes=tmpKey;
}
returnkeyBytes;
}

/**
*加密数据
*
*@paramdata待加密数据
*@paramkey密钥
*@return加密后的数据
*/
publicstaticStringencrypt(Stringdata,Stringkey)throwsException{
Keydeskey=keyGenerator(key);
//实例化Cipher对象，它用于完成实际的加密操作
Ciphercipher=Cipher.getInstance(CIPHER_ALGORITHM);
SecureRandomrandom=newSecureRandom();
//初始化Cipher对象，设置为加密模式
cipher.init(Cipher.ENCRYPT_MODE,deskey,random);
byte[]results=cipher.doFinal(data.getBytes());
//执行加密操作。加密后的结果通常都会用Base64编码进行传输
returnBase64.encodeBase64String(results);
}

/**
*解密数据
*
*@paramdata待解密数据
*@paramkey密钥
*@return解密后的数据
*/
publicstaticStringdecrypt(Stringdata,Stringkey)throwsException{
Keydeskey=keyGenerator(key);
Ciphercipher=Cipher.getInstance(CIPHER_ALGORITHM);
//初始化Cipher对象，设置为解密模式
cipher.init(Cipher.DECRYPT_MODE,deskey);
//执行解密操作
returnnewString(cipher.doFinal(Base64.decodeBase64(data)));
}

}

到此这篇关于spring*.xml配置文件明文加密的实现的文章就介绍到这了,更多相关spring*.xml配置文件加密内容请搜索毛票票以前的文章或继续浏览下面的相关文章希望大家以后多多支持毛票票！

spring*.xml配置文件明文加密的实现

1.数据库配置文件加密

2.Redis配置文件加密

3.MongoDB配置文件加密（使用的是spring-data-mognodb框架）

4.最后附上对应的加解密类

热门推荐

随机推荐