通过 PropertyPlaceholderConfigurer 来加解密数据

浅浅的花香味﹌ 2021-09-24 05:04 336阅读 0赞

在 properties 文件中一般有数据库的密码等重要信息，这些密码都是明文的话是很危险的。如下面 properties 文件：

*  application.properties

jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://123.153.230.165:3306/lxh?useUnicode=true&characterEncoding=utf-8
    jdbc.user=zzz
    jdbc.password=1234242

有两种解决方法：

1.  先将密码加密后写入 properties 文件中，在初始化时读取 properties 文件的时候再解密。
2.  将密码明文写入 properties 文件中，在初始化时读取完 properties 文件的时候将此 properties 文件需要加密的字段加密，其实也就是读取文件全部内容，再写回此文件中。

下面是第二种方法的思路：

### 1.自定义类继承 PropertyPlaceholderConfigurer ###

需要在此类构造函数里：

*  load 此 application.properties 文件内容作为 Properties 对象。
 *  再调用 this.setProperties(props); 后可以对此 Properties 对象的键值作修改，具体是体现在重写 PropertyPlaceholderConfigurer 的 convertProperties() 方法。
 *  convertProperties(Properties props) 方法：判断每个键值是否有要加密的数据，若有的话则把标识记为需要重写文件，最后会调用 doEncrypt() 方法加密文件。当然如果读进来本身就是加密的，那此值还需要解密存在内存中才能正确连接到数据库，只是文件不需要加密而已。

public class EncryptPropertyPlaceholderConfigurer extends PropertyPlaceholderConfigurer {
    
    	private Set<String> encKeys; // 要加密的字段
    	private Map<String, String> encMap = new HashMap<>(); // 存储加密的字段与加密后的值
    	private Resource defaultResource; // 默认配置文件路径
    	private Resource locationResource; // 外置配置文件路径
    	private String encoding;
    	private Resource resource;
    
    	public EncryptPropertyPlaceholderConfigurer(Resource defaultPath, Resource locationPath, String encoding)
    			throws IOException {
    		// resource = new ClassPathResource("db.properties");
    
    		this.logger.info("——————Initializing Properties using "
    				+ EncryptPropertyPlaceholderConfigurer.class.getSimpleName() + "——————");
    		this.defaultResource = defaultPath;
    		this.locationResource = locationPath;
    		this.setFileEncoding(encoding);
    		// this.ignoreUnresolvablePlaceholders = true; // 不可有多个类继承PropertyPlaceholderConfigurer
    
    		Properties props = null;
    
    		if (locationPath == null || !locationPath.isReadable()) {
    			resource = defaultResource;
    		} else {
    			resource = locationResource;
    		}
    
    		props = PropertiesLoaderUtils.loadProperties(new EncodedResource(resource, encoding)); // 加载文件
    
    		this.setProperties(props); // 父类方法
    	}
    
    	@Override
    	protected void convertProperties(Properties props) {
    		
    		boolean isSave = false; // 判断是否需要加密
    		Enumeration<?> propertyNames = props.propertyNames();
    		while (propertyNames.hasMoreElements()) {
    			String propertyName = (String) propertyNames.nextElement();
    			String propertyValue = props.getProperty(propertyName);
    
    			System.out.println(propertyName + "=" + propertyValue);
    			if (encKeys.contains(propertyName)) {
    				encMap.put(propertyName, propertyValue);
    				if (propertyValue.startsWith("{enc}")) {
    					String convertedValue = convertProperty(propertyName, propertyValue); // 解密
    					props.setProperty(propertyName, convertedValue);
    				} else {
    					// 加密
    					// encValues.put(propertyName, encryptValue(propertyValue));
    					isSave = true;
    				}
    			} else {
    				props.setProperty(propertyName, propertyValue);
    			}
    
    		}
    
    		// 是否加密文件
    		if (isSave) {
    			this.doEncrypt();
    		}
    
    	}
    
    	/*
    	 * 其实就是读出文件内容，再写回去
    	 */
    	private void doEncrypt() {
    		
    		boolean isSave = false;
    		List<String> newLines = new ArrayList<>();
    		try {
    			BufferedReader br = new BufferedReader(new InputStreamReader(this.resource.getInputStream()));
    
    			String line = null;
    			while ((line = br.readLine()) != null) {
    				String[] str = line.split("=");
    				if (str.length > 1 && encMap.containsKey(str[0].trim())) {
    					String value = encMap.get(str[0].trim());
    					if (!value.startsWith("{enc}")) {
    						// 此行没加密则加密
    						line = str[0].trim() + "=" + encryptValue(value);
    						isSave = true;
    					}
    				}
    				newLines.add(line);
    			}
    			br.close();
    			if (isSave) {
    				BufferedWriter bw = new BufferedWriter(new FileWriter(this.resource.getFile()));
    				for (String string : newLines) {
    					bw.write(string);
    					bw.newLine();
    				}
    				bw.flush();
    				bw.close();
    			}
    
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    
    	/**
    	 * 加密数据
    	 */
    	private String encryptValue(String propertyValue) {
    		return "{enc}" + propertyValue;
    	}
    
    	/**
    	 * 解密数据
    	 */
    	@Override
    	protected String convertProperty(String propertyName, String propertyValue) {
    		if (propertyValue.startsWith("{enc}")) {
    			int idx = propertyValue.indexOf("}");
    			return propertyValue.substring(idx + 1);
    		}
    		return propertyValue;
    	}
    
    	public Set<String> getEncKeys() {
    		return encKeys;
    	}
    
    	public void setEncKeys(Set<String> encKeys) {
    		this.encKeys = encKeys;
    	}
    
    	public Map<String, String> getEncMap() {
    		return encMap;
    	}
    
    	public void setEncMap(Map<String, String> encValues) {
    		this.encMap = encValues;
    	}
    
    
    	public String getEncoding() {
    		return encoding;
    	}
    
    	public void setEncoding(String encoding) {
    		this.encoding = encoding;
    	}
    
    	public Resource getResource() {
    		return resource;
    	}
    
    	public void setResource(Resource resource) {
    		this.resource = resource;
    	}
    
    	public static void main(String[] args) {
    		Resource resource = new ClassPathResource("a2pplication.properties");
    		System.out.println(resource.isReadable());
    	}
    }

### 2. 将此类交由 Spring 容器来管理 ###

*  encKeys：加密的属性，这里只加密 jdbc.password 属性的值

<bean id="EncryptPropertyPlaceholderConfigurer"
    		class="com.qhf.config.EncryptPropertyPlaceholderConfigurer">
    		<constructor-arg index="0" value="classpath:/application.properties" />
    		<constructor-arg index="1" value="" />
    		<constructor-arg index="2" value="UTF-8" />
    		<property name="encKeys">
    			<set>
    				<value>jdbc.password</value>
    			</set>
    		</property>
    	</bean>

### 3.结果  ###

在发布服务运行后 application.properties 会加密 jdbc.password 的值