devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java项目中，如何加密配置文件中的敏感信息

作者：从前慢现在也慢 | 2024-06-08 22:18:45

赞

踩

java配置信息怎么不让别人知道

在日常开发中，我们常常会把一些敏感信息写进*.properties配置文件中，比如数据库密码、redis密码、admin用户的密码甚至系统用户的密码等。

我在某银行做运维时，经常会遇到这样的情况：

银行的系统都是通过堡垒机管理的，应用管理人员理论上不应该知道任何系统用户的密码，只需通过堡垒机，使用只读key或可写key即可登录相应的用户。但在一次偶尔查看应用的配置文件时，我发现应用在调用CD时需要登录系统用户，而用户名和密码均使用明文写在了配置文件中。知道了用户名密码，就可以使用su命令随意切换用户了。诸如此类的还有数据库密码等，均可在配置文件中找到，这在信息安全和权限控制等方面有很大的隐患。

所以出于安全考虑，对配置文件中敏感信息的加密就很有必要了。

不多说了，直接上方法：

  1. 重写PropertyPlaceholderConfigurer  
    1. import java.io.IOException;
    2. import java.util.HashMap;
    3. import java.util.List;
    4. import java.util.Map;
    5. import java.util.MissingResourceException;
    6. import java.util.Properties;
    7.  
    8. import org.apache.commons.lang3.StringUtils;
    9. import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;
    10.  
    11.  
    12. public final class PropertiesUtil extends PropertyPlaceholderConfigurer {
    13.     private static final byte[] KEY = {9, -1, 0, 5, 39, 8, 6, 19};
    14.     private static Map<String, String> ctxPropertiesMap;
    15.     private List<String> decryptProperties;
    16.  
    17.     @Override
    18.     protected void loadProperties(Properties props) throws IOException {
    19.         super.loadProperties(props);
    20.         ctxPropertiesMap = new HashMap<String, String>();
    21.         for (Object key : props.keySet()) {
    22.             String keyStr = key.toString();
    23.             String value = props.getProperty(keyStr);
    24.             if (decryptProperties != null && decryptProperties.contains(keyStr)) {
    25.                 value = SecurityUtil.decryptDes(value, KEY);
    26.                 props.setProperty(keyStr, value);
    27.             }
    28.             ctxPropertiesMap.put(keyStr, value);
    29.         }
    30.     }
    31.  
    32.     /**
    33.      * @param decryptPropertiesMap the decryptPropertiesMap to set
    34.      */
    35.     public void setDecryptProperties(List<String> decryptProperties) {
    36.         this.decryptProperties = decryptProperties;
    37.     }
    38.  
    39.     /**
    40.      * Get a value based on key , if key does not exist , null is returned
    41.      * 
    42.      * @param key
    43.      * @return
    44.      */
    45.     public static String getString(String key) {
    46.         try {
    47.             return ctxPropertiesMap.get(key);
    48.         } catch (MissingResourceException e) {
    49.             return null;
    50.         }
    51.     }
    52.  
    53.     /**
    54.      * 根据key获取值
    55.      * 
    56.      * @param key
    57.      * @return
    58.      */
    59.     public static int getInt(String key) {
    60.         return Integer.parseInt(ctxPropertiesMap.get(key));
    61.     }
    62.  
    63.     /**
    64.      * 根据key获取值
    65.      * 
    66.      * @param key
    67.      * @param defaultValue
    68.      * @return
    69.      */
    70.     public static int getInt(String key, int defaultValue) {
    71.         String value = ctxPropertiesMap.get(key);
    72.         if (StringUtils.isBlank(value)) {
    73.             return defaultValue;
    74.         }
    75.         return Integer.parseInt(value);
    76.     }
    77.  
    78.     /**
    79.      * 根据key获取值
    80.      * @param key
    81.      * @param defaultValue
    82.      * @return
    83.      */
    84.     public static boolean getBoolean(String key, boolean defaultValue) {
    85.         String value = ctxPropertiesMap.get(key);
    86.         if (StringUtils.isBlank(value)) {
    87.             return defaultValue;
    88.         }
    89.         return new Boolean(value);
    90.     }
    91.  
    92.     public static void main(String[] args) {
    93.         String encrypt = SecurityUtil.encryptDes("ROOT", KEY);
    94.         System.out.println(encrypt);
    95.         System.out.println(SecurityUtil.decryptDes(encrypt, KEY));
    96.     }
    97. }
      
    1. public final class SecurityUtil {
    2. 	private SecurityUtil() {
    3. 	}
    4.  
    5. 	public static final String CHARSET = "UTF-8";
    6.  
    7. 	/**
    8. 	 * BASE64解码
    9. 	 * 
    10. 	 * @param key
    11. 	 * @return
    12. 	 * @throws Exception
    13. 	 */
    14. 	public static final byte[] decryptBASE64(String key) {
    15. 		try {
    16. 			return new BASE64Encoder().decode(key);
    17. 		} catch (Exception e) {
    18. 			throw new RuntimeException("解密错误，错误信息：", e);
    19. 		}
    20. 	}
    21.  
    22. 	/**
    23. 	 * BASE64编码
    24. 	 * 
    25. 	 * @param key
    26. 	 * @return
    27. 	 * @throws Exception
    28. 	 */
    29. 	public static final String encryptBASE64(byte[] key) {
    30. 		try {
    31. 			return new BASE64Encoder().encode(key);
    32. 		} catch (Exception e) {
    33. 			throw new RuntimeException("加密错误，错误信息：", e);
    34. 		}
    35. 	}
    36.  
    37.  
    38. 	/**
    39. 	 * 数据解密，算法（DES）
    40. 	 * 
    41. 	 * @param cryptData
    42. 	 *            加密数据
    43. 	 * @return 解密后的数据
    44. 	 */
    45. 	public static final String decryptDes(String cryptData, byte[] key) {
    46. 		String decryptedData = null;
    47. 		try {
    48. 			// 把字符串解码为字节数组，并解密
    49. 			decryptedData = new String(DESCoder.decrypt(decryptBASE64(cryptData), key));
    50. 		} catch (Exception e) {
    51. 			throw new RuntimeException("解密错误，错误信息：", e);
    52. 		}
    53. 		return decryptedData;
    54. 	}
    55.  
    56. 	/**
    57. 	 * 数据加密，算法（DES）
    58. 	 * 
    59. 	 * @param data
    60. 	 *            要进行加密的数据
    61. 	 * @return 加密后的数据
    62. 	 */
    63. 	public static final String encryptDes(String data, byte[] key) {
    64. 		String encryptedData = null;
    65. 		try {
    66. 			// 加密，并把字节数组编码成字符串
    67. 			encryptedData = encryptBASE64(DESCoder.encrypt(data.getBytes(), key));
    68. 		} catch (Exception e) {
    69. 			throw new RuntimeException("加密错误，错误信息：", e);
    70. 		}
    71. 		return encryptedData;
    72. 	}
    73.  
    74.  
    75. }
      
    1. import java.io.UnsupportedEncodingException;
    2.  
    3. /**
    4.  * Hex encoder and decoder. The charset used for certain operation can be set,
    5.  * the default is set in
    6.  * 
    7.  * @author ShenHuaJie
    8.  * @version $Id: Hex.java, v 0.1 2014年3月25日 上午9:39:07 ShenHuaJie Exp $
    9.  */
    10. public class Hex {
    11.  
    12. 	/***
    13. 	 * Default charset name is {@link CharEncoding#UTF_8}
    14. 	 */
    15. 	public static final String DEFAULT_CHARSET_NAME = "UTF-8";
    16.  
    17. 	/***
    18. 	 * Used to build output as Hex
    19. 	 */
    20. 	private static final char[] DIGITS_LOWER = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd',
    21. 			'e', 'f' };
    22.  
    23. 	/***
    24. 	 * Used to build output as Hex
    25. 	 */
    26. 	private static final char[] DIGITS_UPPER = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D',
    27. 			'E', 'F' };
    28.  
    29. 	/***
    30. 	 * Converts an array of characters representing hexadecimal values into an
    31. 	 * array of bytes of those same values. The returned array will be half the
    32. 	 * length of the passed array, as it takes two characters to represent any
    33. 	 * given byte. An exception is thrown if the passed char array has an odd
    34. 	 * number of elements.
    35. 	 * 
    36. 	 * @param data An array of characters containing hexadecimal digits
    37. 	 * @return A byte array containing binary data decoded from the supplied
    38. 	 *         char array.
    39. 	 * @throws Exception Thrown if an odd number or illegal of characters is
    40. 	 *             supplied
    41. 	 */
    42. 	public static byte[] decodeHex(char[] data) throws Exception {
    43.  
    44. 		int len = data.length;
    45.  
    46. 		if ((len & 0x01) != 0) {
    47. 			throw new Exception("Odd number of characters.");
    48. 		}
    49.  
    50. 		byte[] out = new byte[len >> 1];
    51.  
    52. 		// two characters form the hex value.
    53. 		for (int i = 0, j = 0; j < len; i++) {
    54. 			int f = toDigit(data[j], j) << 4;
    55. 			j++;
    56. 			f = f | toDigit(data[j], j);
    57. 			j++;
    58. 			out[i] = (byte) (f & 0xFF);
    59. 		}
    60.  
    61. 		return out;
    62. 	}
    63.  
    64. 	/***
    65. 	 * Converts an array of bytes into an array of characters representing the
    66. 	 * hexadecimal values of each byte in order. The returned array will be
    67. 	 * double the length of the passed array, as it takes two characters to
    68. 	 * represent any given byte.
    69. 	 * 
    70. 	 * @param data a byte[] to convert to Hex characters
    71. 	 * @return A char[] containing hexadecimal characters
    72. 	 */
    73. 	public static char[] encodeHex(byte[] data) {
    74. 		return encodeHex(data, true);
    75. 	}
    76.  
    77. 	/***
    78. 	 * Converts an array of bytes into an array of characters representing the
    79. 	 * hexadecimal values of each byte in order. The returned array will be
    80. 	 * double the length of the passed array, as it takes two characters to
    81. 	 * represent any given byte.
    82. 	 * 
    83. 	 * @param data a byte[] to convert to Hex characters
    84. 	 * @param toLowerCase <code>true</code> converts to lowercase,
    85. 	 *            <code>false</code> to uppercase
    86. 	 * @return A char[] containing hexadecimal characters
    87. 	 * @since 1.4
    88. 	 */
    89. 	public static char[] encodeHex(byte[] data, boolean toLowerCase) {
    90. 		return encodeHex(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
    91. 	}
    92.  
    93. 	/***
    94. 	 * Converts an array of bytes into an array of characters representing the
    95. 	 * hexadecimal values of each byte in order. The returned array will be
    96. 	 * double the length of the passed array, as it takes two characters to
    97. 	 * represent any given byte.
    98. 	 * 
    99. 	 * @param data a byte[] to convert to Hex characters
    100. 	 * @param toDigits the output alphabet
    101. 	 * @return A char[] containing hexadecimal characters
    102. 	 * @since 1.4
    103. 	 */
    104. 	protected static char[] encodeHex(byte[] data, char[] toDigits) {
    105. 		int l = data.length;
    106. 		char[] out = new char[l << 1];
    107. 		// two characters form the hex value.
    108. 		for (int i = 0, j = 0; i < l; i++) {
    109. 			out[j++] = toDigits[(0xF0 & data[i]) >>> 4];
    110. 			out[j++] = toDigits[0x0F & data[i]];
    111. 		}
    112. 		return out;
    113. 	}
    114.  
    115. 	/***
    116. 	 * Converts an array of bytes into a String representing the hexadecimal
    117. 	 * values of each byte in order. The returned String will be double the
    118. 	 * length of the passed array, as it takes two characters to represent any
    119. 	 * given byte.
    120. 	 * 
    121. 	 * @param data a byte[] to convert to Hex characters
    122. 	 * @return A String containing hexadecimal characters
    123. 	 * @since 1.4
    124. 	 */
    125. 	public static String encodeHexString(byte[] data) {
    126. 		return new String(encodeHex(data));
    127. 	}
    128.  
    129. 	/***
    130. 	 * Converts a hexadecimal character to an integer.
    131. 	 * 
    132. 	 * @param ch A character to convert to an integer digit
    133. 	 * @param index The index of the character in the source
    134. 	 * @return An integer
    135. 	 * @throws Exception Thrown if ch is an illegal hex character
    136. 	 */
    137. 	protected static int toDigit(char ch, int index) throws Exception {
    138. 		int digit = Character.digit(ch, 16);
    139. 		if (digit == -1) {
    140. 			throw new Exception("Illegal hexadecimal charcter " + ch + " at index " + index);
    141. 		}
    142. 		return digit;
    143. 	}
    144.  
    145. 	private static String charsetName = DEFAULT_CHARSET_NAME;
    146.  
    147. 	/***
    148. 	 * Creates a new codec with the default charset name
    149. 	 * {@link #DEFAULT_CHARSET_NAME}
    150. 	 */
    151. 	public Hex() {
    152. 	}
    153.  
    154. 	/***
    155. 	 * Creates a new codec with the given charset name.
    156. 	 * 
    157. 	 * @param csName the charset name.
    158. 	 * @since 1.4
    159. 	 */
    160. 	public Hex(String csName) {
    161. 		charsetName = csName;
    162. 	}
    163.  
    164. 	/***
    165. 	 * Converts an array of character bytes representing hexadecimal values into
    166. 	 * an array of bytes of those same values. The returned array will be half
    167. 	 * the length of the passed array, as it takes two characters to represent
    168. 	 * any given byte. An exception is thrown if the passed char array has an
    169. 	 * odd number of elements.
    170. 	 * 
    171. 	 * @param array An array of character bytes containing hexadecimal digits
    172. 	 * @return A byte array containing binary data decoded from the supplied
    173. 	 *         byte array (representing characters).
    174. 	 * @throws Exception Thrown if an odd number of characters is supplied to
    175. 	 *             this function
    176. 	 * @see #decodeHex(char[])
    177. 	 */
    178. 	public byte[] decode(byte[] array) throws Exception {
    179. 		try {
    180. 			return decodeHex(new String(array, getCharsetName()).toCharArray());
    181. 		} catch (Exception e) {
    182. 			throw new Exception(e.getMessage(), e);
    183. 		}
    184. 	}
    185.  
    186. 	/***
    187. 	 * Converts a String or an array of character bytes representing hexadecimal
    188. 	 * values into an array of bytes of those same values. The returned array
    189. 	 * will be half the length of the passed String or array, as it takes two
    190. 	 * characters to represent any given byte. An exception is thrown if the
    191. 	 * passed char array has an odd number of elements.
    192. 	 * 
    193. 	 * @param object A String or, an array of character bytes containing
    194. 	 *            hexadecimal digits
    195. 	 * @return A byte array containing binary data decoded from the supplied
    196. 	 *         byte array (representing characters).
    197. 	 * @throws Exception Thrown if an odd number of characters is supplied to
    198. 	 *             this function or the object is not a String or char[]
    199. 	 * @see #decodeHex(char[])
    200. 	 */
    201. 	public Object decode(Object object) throws Exception {
    202. 		try {
    203. 			char[] charArray = object instanceof String ? ((String) object).toCharArray() : (char[]) object;
    204. 			return decodeHex(charArray);
    205. 		} catch (ClassCastException e) {
    206. 			throw new Exception(e.getMessage(), e);
    207. 		}
    208. 	}
    209.  
    210. 	/***
    211. 	 * Converts an array of bytes into an array of bytes for the characters
    212. 	 * representing the hexadecimal values of each byte in order. The returned
    213. 	 * array will be double the length of the passed array, as it takes two
    214. 	 * characters to represent any given byte.
    215. 	 * <p>
    216. 	 * The conversion from hexadecimal characters to the returned bytes is
    217. 	 * performed with the charset named by {@link #getCharsetName()}.
    218. 	 * </p>
    219. 	 * 
    220. 	 * @param array a byte[] to convert to Hex characters
    221. 	 * @return A byte[] containing the bytes of the hexadecimal characters
    222. 	 * @throws IllegalStateException if the charsetName is invalid. This API
    223. 	 *             throws {@link IllegalStateException} instead of
    224. 	 *             {@link Exception} for backward compatibility.
    225. 	 * @see #encodeHex(byte[])
    226. 	 */
    227. 	public static byte[] encode(byte[] array) throws UnsupportedEncodingException {
    228. 		String string = encodeHexString(array);
    229. 		if (string == null) {
    230. 			return null;
    231. 		}
    232. 		return string.getBytes(charsetName);
    233. 	}
    234.  
    235. 	/***
    236. 	 * Converts a String or an array of bytes into an array of characters
    237. 	 * representing the hexadecimal values of each byte in order. The returned
    238. 	 * array will be double the length of the passed String or array, as it
    239. 	 * takes two characters to represent any given byte.
    240. 	 * <p>
    241. 	 * The conversion from hexadecimal characters to bytes to be encoded to
    242. 	 * performed with the charset named by {@link #getCharsetName()}.
    243. 	 * </p>
    244. 	 * 
    245. 	 * @param object a String, or byte[] to convert to Hex characters
    246. 	 * @return A char[] containing hexadecimal characters
    247. 	 * @throws Exception Thrown if the given object is not a String or byte[]
    248. 	 * @see #encodeHex(byte[])
    249. 	 */
    250. 	public Object encode(Object object) throws Exception {
    251. 		try {
    252. 			byte[] byteArray = object instanceof String ? ((String) object).getBytes(getCharsetName())
    253. 					: (byte[]) object;
    254. 			return encodeHex(byteArray);
    255. 		} catch (ClassCastException e) {
    256. 			throw new Exception(e.getMessage(), e);
    257. 		} catch (Exception e) {
    258. 			throw new Exception(e.getMessage(), e);
    259. 		}
    260. 	}
    261.  
    262. 	/***
    263. 	 * Gets the charset name.
    264. 	 * 
    265. 	 * @return the charset name.
    266. 	 * @since 1.4
    267. 	 */
    268. 	public String getCharsetName() {
    269. 		return charsetName;
    270. 	}
    271.  
    272. 	/***
    273. 	 * Returns a string representation of the object, which includes the charset
    274. 	 * name.
    275. 	 * 
    276. 	 * @return a string representation of the object.
    277. 	 */
    278. 	@Override
    279. 	public String toString() {
    280. 		return super.toString() + "[charsetName=" + charsetName + "]";
    281. 	}
    282. }
      
    1. import java.security.MessageDigest;
    2.  
    3. /**
    4.  * MD加密组件
    5.  * 
    6.  * @author du
    7.  * @version 1.0
    8.  * @since 1.0
    9.  */
    10. public abstract class MDCoder {
    11.  
    12. 	/**
    13. 	 * MD2加密
    14. 	 * 
    15. 	 * @param data 待加密数据
    16. 	 * @return byte[] 消息摘要
    17. 	 * @throws Exception
    18. 	 */
    19. 	public static byte[] encodeMD2(byte[] data) throws Exception {
    20. 		// 初始化MessageDigest
    21. 		MessageDigest md = MessageDigest.getInstance("MD2");
    22. 		// 执行消息摘要
    23. 		return md.digest(data);
    24. 	}
    25.  
    26. 	/**
    27. 	 * MD4加密
    28. 	 * 
    29. 	 * @param data 待加密数据
    30. 	 * @return byte[] 消息摘要
    31. 	 * @throws Exception
    32. 	 */
    33. 	public static byte[] encodeMD4(byte[] data) throws Exception {
    34. 		// 初始化MessageDigest
    35. 		MessageDigest md = MessageDigest.getInstance("MD4");
    36. 		// 执行消息摘要
    37. 		return md.digest(data);
    38. 	}
    39.  
    40. 	/**
    41. 	 * MD5加密
    42. 	 * 
    43. 	 * @param data 待加密数据
    44. 	 * @return byte[] 消息摘要
    45. 	 * @throws Exception
    46. 	 */
    47. 	public static byte[] encodeMD5(byte[] data) throws Exception {
    48. 		// 初始化MessageDigest
    49. 		MessageDigest md = MessageDigest.getInstance("MD5");
    50. 		// 执行消息摘要
    51. 		return md.digest(data);
    52. 	}
    53.  
    54. 	/**
    55. 	 * Tiger加密
    56. 	 * 
    57. 	 * @param data 待加密数据
    58. 	 * @return byte[] 消息摘要
    59. 	 * @throws Exception
    60. 	 */
    61. 	public static byte[] encodeTiger(byte[] data) throws Exception {
    62. 		// 初始化MessageDigest
    63. 		MessageDigest md = MessageDigest.getInstance("Tiger");
    64. 		// 执行消息摘要
    65. 		return md.digest(data);
    66. 	}
    67.  
    68. 	/**
    69. 	 * TigerHex加密
    70. 	 * 
    71. 	 * @param data 待加密数据
    72. 	 * @return byte[] 消息摘要
    73. 	 * @throws Exception
    74. 	 */
    75. 	public static String encodeTigerHex(byte[] data) throws Exception {
    76. 		// 执行消息摘要
    77. 		byte[] b = encodeTiger(data);
    78. 		// 做十六进制编码处理
    79. 		return new String(Hex.encode(b));
    80. 	}
    81.  
    82. 	/**
    83. 	 * Whirlpool加密
    84. 	 * 
    85. 	 * @param data 待加密数据
    86. 	 * @return byte[] 消息摘要
    87. 	 * @throws Exception
    88. 	 */
    89. 	public static byte[] encodeWhirlpool(byte[] data) throws Exception {
    90. 		// 初始化MessageDigest
    91. 		MessageDigest md = MessageDigest.getInstance("Whirlpool");
    92. 		// 执行消息摘要
    93. 		return md.digest(data);
    94. 	}
    95.  
    96. 	/**
    97. 	 * WhirlpoolHex加密
    98. 	 * 
    99. 	 * @param data 待加密数据
    100. 	 * @return byte[] 消息摘要
    101. 	 * @throws Exception
    102. 	 */
    103. 	public static String encodeWhirlpoolHex(byte[] data) throws Exception {
    104. 		// 执行消息摘要
    105. 		byte[] b = encodeWhirlpool(data);
    106. 		// 做十六进制编码处理
    107. 		return new String(Hex.encode(b));
    108. 	}
    109.  
    110. 	/**
    111. 	 * GOST3411加密
    112. 	 * 
    113. 	 * @param data 待加密数据
    114. 	 * @return byte[] 消息摘要
    115. 	 * @throws Exception
    116. 	 */
    117. 	public static byte[] encodeGOST3411(byte[] data) throws Exception {
    118. 		// 初始化MessageDigest
    119. 		MessageDigest md = MessageDigest.getInstance("GOST3411");
    120. 		// 执行消息摘要
    121. 		return md.digest(data);
    122. 	}
    123.  
    124. 	/**
    125. 	 * GOST3411Hex加密
    126. 	 * 
    127. 	 * @param data 待加密数据
    128. 	 * @return byte[] 消息摘要
    129. 	 * @throws Exception
    130. 	 */
    131. 	public static String encodeGOST3411Hex(byte[] data) throws Exception {
    132. 		// 执行消息摘要
    133. 		byte[] b = encodeGOST3411(data);
    134. 		// 做十六进制编码处理
    135. 		return new String(Hex.encode(b));
    136. 	}
    137. }
      
    1. import java.security.InvalidKeyException;
    2. import java.security.Key;
    3. import java.security.NoSuchAlgorithmException;
    4. import java.security.SecureRandom;
    5. import java.security.spec.InvalidKeySpecException;
    6.  
    7. import javax.crypto.BadPaddingException;
    8. import javax.crypto.Cipher;
    9. import javax.crypto.IllegalBlockSizeException;
    10. import javax.crypto.KeyGenerator;
    11. import javax.crypto.NoSuchPaddingException;
    12. import javax.crypto.SecretKey;
    13. import javax.crypto.SecretKeyFactory;
    14. import javax.crypto.spec.DESKeySpec;
    15.  
    16. /**
    17.  * DES安全编码组件
    18.  * 
    19.  * @author du
    20.  * @version 1.0
    21.  * @since 1.0
    22.  */
    23. public abstract class DESCoder {
    24.  
    25. 	/**
    26. 	 * 密钥算法 <br>
    27. 	 * Java 6 只支持56bit密钥 <br>
    28. 	 * Bouncy Castle 支持64bit密钥
    29. 	 */
    30. 	public static final String KEY_ALGORITHM = "DES";
    31.  
    32. 	/**
    33. 	 * 加密/解密算法 / 工作模式 / 填充方式
    34. 	 */
    35. 	public static final String CIPHER_ALGORITHM = "DES/ECB/PKCS5PADDING";
    36.  
    37. 	/**
    38. 	 * 转换密钥
    39. 	 * 
    40. 	 * @param key 二进制密钥
    41. 	 * @return Key 密钥
    42. 	 * @throws InvalidKeyException
    43. 	 * @throws NoSuchAlgorithmException
    44. 	 * @throws InvalidKeySpecException
    45. 	 * @throws Exception
    46. 	 */
    47. 	private static Key toKey(byte[] key) throws InvalidKeyException, NoSuchAlgorithmException, InvalidKeySpecException {
    48. 		// 实例化DES密钥材料
    49. 		DESKeySpec dks = new DESKeySpec(key);
    50. 		// 实例化秘密密钥工厂
    51. 		SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(KEY_ALGORITHM);
    52. 		// 生成秘密密钥
    53. 		SecretKey secretKey = keyFactory.generateSecret(dks);
    54. 		return secretKey;
    55. 	}
    56.  
    57. 	/**
    58. 	 * 解密
    59. 	 * 
    60. 	 * @param data 待解密数据
    61. 	 * @param key 密钥
    62. 	 * @return byte[] 解密数据
    63. 	 * @throws InvalidKeySpecException
    64. 	 * @throws NoSuchAlgorithmException
    65. 	 * @throws InvalidKeyException
    66. 	 * @throws NoSuchPaddingException
    67. 	 * @throws BadPaddingException
    68. 	 * @throws IllegalBlockSizeException
    69. 	 * @throws Exception
    70. 	 */
    71. 	public static byte[] decrypt(byte[] data, byte[] key) throws InvalidKeyException, NoSuchAlgorithmException,
    72. 			InvalidKeySpecException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
    73. 		// 还原密钥
    74. 		Key k = toKey(key);
    75. 		// 实例化
    76. 		Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
    77. 		// 初始化，设置为解密模式
    78. 		cipher.init(Cipher.DECRYPT_MODE, k);
    79. 		// 执行操作
    80. 		return cipher.doFinal(data);
    81. 	}
    82.  
    83. 	/**
    84. 	 * 加密
    85. 	 * 
    86. 	 * @param data 待加密数据
    87. 	 * @param key 密钥
    88. 	 * @return byte[] 加密数据
    89. 	 * @throws NoSuchPaddingException
    90. 	 * @throws NoSuchAlgorithmException
    91. 	 * @throws InvalidKeyException
    92. 	 * @throws BadPaddingException
    93. 	 * @throws IllegalBlockSizeException
    94. 	 * @throws InvalidKeySpecException
    95. 	 * @throws Exception
    96. 	 */
    97. 	public static byte[] encrypt(byte[] data, byte[] key) throws NoSuchAlgorithmException, NoSuchPaddingException,
    98. 			InvalidKeyException, IllegalBlockSizeException, BadPaddingException, InvalidKeySpecException {
    99. 		// 还原密钥
    100. 		Key k = toKey(key);
    101. 		// 实例化
    102. 		Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
    103. 		// 初始化，设置为加密模式
    104. 		cipher.init(Cipher.ENCRYPT_MODE, k);
    105. 		// 执行操作
    106. 		return cipher.doFinal(data);
    107. 	}
    108.  
    109. 	/**
    110. 	 * 生成密钥 <br>
    111. 	 * Java 6 只支持56bit密钥 <br>
    112. 	 * Bouncy Castle 支持64bit密钥 <br>
    113. 	 * 
    114. 	 * @return byte[] 二进制密钥
    115. 	 * @throws NoSuchAlgorithmException
    116. 	 * @throws Exception
    117. 	 */
    118. 	public static byte[] initKey() throws NoSuchAlgorithmException {
    119. 		/*
    120. 		 * 实例化密钥生成器
    121. 		 * 
    122. 		 * 若要使用64bit密钥注意替换 将下述代码中的KeyGenerator.getInstance(CIPHER_ALGORITHM);
    123. 		 * 替换为KeyGenerator.getInstance(CIPHER_ALGORITHM, "BC");
    124. 		 */
    125. 		KeyGenerator kg = KeyGenerator.getInstance(KEY_ALGORITHM);
    126. 		/*
    127. 		 * 初始化密钥生成器 若要使用64bit密钥注意替换 将下述代码kg.init(56); 替换为kg.init(64);
    128. 		 */
    129. 		kg.init(56, new SecureRandom());
    130. 		// 生成秘密密钥
    131. 		SecretKey secretKey = kg.generateKey();
    132. 		// 获得密钥的二进制编码形式
    133. 		return secretKey.getEncoded();
    134. 	}
    135. }
      
    1. import java.io.ByteArrayInputStream;
    2. import java.io.ByteArrayOutputStream;
    3. import java.io.IOException;
    4. import java.io.InputStream;
    5. import java.io.OutputStream;
    6. import java.io.PushbackInputStream;
    7.  
    8. /**
    9.  * 密码器类
    10.  * 
    11.  * @author du
    12.  * @since 2017-11-19
    13.  */
    14. public class BASE64Encoder {
    15.  
    16.     /**
    17.      * 译码数据源
    18.      */
    19.     private static final char[] PEM_ARRAY = {
    20.         // 0  1   2   3    4    5    6    7
    21.         'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', // 0
    22.         'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', // 1
    23.         'q', 'r', 's', 't', 'u', 'v', 'w', 'x', // 2
    24.         'y', 'z', '1', '2', '3', '4', '5', '6', // 3
    25.         '7', '8', '9', '0', 'A', 'B', 'C', 'D', // 4
    26.         'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', // 5
    27.         'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', // 6
    28.         'U', 'V', 'W', 'X', 'Y', 'Z', '+', '/' // 7
    29.     };
    30.  
    31.     private static final byte[] pem_convert_array = new byte[256];
    32.  
    33.     private byte[] decode_buffer = new byte[4];
    34.  
    35.     public BASE64Encoder() {
    36.     }
    37.  
    38.     /**
    39.      * 编码
    40.      */
    41.     public String encode(byte[] bt) {
    42.         int totalBits = bt.length * 8;
    43.         int nn = totalBits % 6;
    44.         int curPos = 0;// process bits
    45.         StringBuilder toReturn = new StringBuilder(32);
    46.         while (curPos < totalBits) {
    47.             int bytePos = curPos / 8;
    48.             switch (curPos % 8) {
    49.             case 0:
    50.                 toReturn.append(PEM_ARRAY[(bt[bytePos] & 0xfc) >> 2]);
    51.                 break;
    52.             case 2:
    53.                 toReturn.append(PEM_ARRAY[(bt[bytePos] & 0x3f)]);
    54.                 break;
    55.             case 4:
    56.                 if (bytePos == bt.length - 1) {
    57.                     toReturn.append(PEM_ARRAY[((bt[bytePos] & 0x0f) << 2) & 0x3f]);
    58.                 } else {
    59.                     int pos = (((bt[bytePos] & 0x0f) << 2) | ((bt[bytePos + 1] & 0xc0) >> 6)) & 0x3f;
    60.                     toReturn.append(PEM_ARRAY[pos]);
    61.                 }
    62.                 break;
    63.             case 6:
    64.                 if (bytePos == bt.length - 1) {
    65.                     toReturn.append(PEM_ARRAY[((bt[bytePos] & 0x03) << 4) & 0x3f]);
    66.                 } else {
    67.                     int pos = (((bt[bytePos] & 0x03) << 4) | ((bt[bytePos + 1] & 0xf0) >> 4)) & 0x3f;
    68.                     toReturn.append(PEM_ARRAY[pos]);
    69.                 }
    70.                 break;
    71.             default:
    72.                 break;
    73.             }
    74.             curPos += 6;
    75.         }
    76.         if (nn == 2) {
    77.             toReturn.append("==");
    78.         } else if (nn == 4) {
    79.             toReturn.append("=");
    80.         }
    81.         return toReturn.toString();
    82.     }
    83.  
    84.     /**
    85.      * 解码
    86.      */
    87.     public byte[] decode(String str) throws IOException {
    88.         byte[] arrayOfByte = str.getBytes();
    89.         ByteArrayInputStream inputStream = new ByteArrayInputStream(arrayOfByte);
    90.         ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    91.         decodeBuffer(inputStream, outputStream);
    92.         return outputStream.toByteArray();
    93.     }
    94.  
    95.     private void decodeBuffer(InputStream paramInputStream, OutputStream paramOutputStream) throws IOException {
    96.         PushbackInputStream localPushbackInputStream = new PushbackInputStream(paramInputStream);
    97.         int j = 0;
    98.         while (true) {
    99.             try {
    100.                 int k = bytesPerLine();
    101.                 int i = 0;
    102.                 if (i + bytesPerAtom() < k) {
    103.                     decodeAtom(localPushbackInputStream, paramOutputStream, bytesPerAtom());
    104.                     j += bytesPerAtom();
    105.                     i += bytesPerAtom();
    106.                     continue;
    107.                 }
    108.  
    109.                 if (i + bytesPerAtom() == k) {
    110.                     decodeAtom(localPushbackInputStream, paramOutputStream, bytesPerAtom());
    111.                     j += bytesPerAtom();
    112.                 } else {
    113.                     decodeAtom(localPushbackInputStream, paramOutputStream, k - i);
    114.                     j += k - i;
    115.                 }
    116.             } catch (RuntimeException e) {
    117.                 String.valueOf(j);
    118.                 break;
    119.             }
    120.         }
    121.     }
    122.  
    123.     private int bytesPerAtom() {
    124.         return 4;
    125.     }
    126.  
    127.     private int bytesPerLine() {
    128.         return 72;
    129.     }
    130.  
    131.     private void decodeAtom(PushbackInputStream paramPushbackInputStream, OutputStream paramOutputStream, int paramInt)
    132.         throws IOException {
    133.         int i;
    134.         int j = -1;
    135.         int k = -1;
    136.         int m = -1;
    137.         int n = -1;
    138.  
    139.         if (paramInt < 2) {
    140.             throw new java.lang.ArrayStoreException("BASE64Decoder: Not enough bytes for an atom.");
    141.         }
    142.         do {
    143.             i = paramPushbackInputStream.read();
    144.             if (i == -1) {
    145.                 throw new RuntimeException();
    146.             }
    147.         } while ((i == 10) || (i == 13));
    148.         this.decode_buffer[0] = (byte)i;
    149.  
    150.         i = readFully(paramPushbackInputStream, this.decode_buffer, 1, paramInt - 1);
    151.         if (i == -1) {
    152.             throw new RuntimeException();
    153.         }
    154.  
    155.         if ((paramInt > 3) && (this.decode_buffer[3] == 61)) {
    156.             paramInt = 3;
    157.         }
    158.         if ((paramInt > 2) && (this.decode_buffer[2] == 61)) {
    159.             paramInt = 2;
    160.         }
    161.         switch (paramInt) {
    162.         case 4:
    163.             n = pem_convert_array[(this.decode_buffer[3] & 0xFF)];
    164.         case 3:
    165.             m = pem_convert_array[(this.decode_buffer[2] & 0xFF)];
    166.         case 2:
    167.             k = pem_convert_array[(this.decode_buffer[1] & 0xFF)];
    168.             j = pem_convert_array[(this.decode_buffer[0] & 0xFF)];
    169.         }
    170.  
    171.         switch (paramInt) {
    172.         case 2:
    173.             paramOutputStream.write((byte)(j << 2 & 0xFC | k >>> 4 & 0x3));
    174.             break;
    175.         case 3:
    176.             paramOutputStream.write((byte)(j << 2 & 0xFC | k >>> 4 & 0x3));
    177.             paramOutputStream.write((byte)(k << 4 & 0xF0 | m >>> 2 & 0xF));
    178.             break;
    179.         case 4:
    180.             paramOutputStream.write((byte)(j << 2 & 0xFC | k >>> 4 & 0x3));
    181.             paramOutputStream.write((byte)(k << 4 & 0xF0 | m >>> 2 & 0xF));
    182.             paramOutputStream.write((byte)(m << 6 & 0xC0 | n & 0x3F));
    183.         }
    184.     }
    185.  
    186.     private int readFully(InputStream paramInputStream, byte[] paramArrayOfByte, int paramInt1, int paramInt2)
    187.         throws IOException {
    188.         for (int i = 0; i < paramInt2; i++) {
    189.             int j = paramInputStream.read();
    190.             if (j == -1) {
    191.                 return i == 0 ? -1 : i;
    192.             }
    193.             paramArrayOfByte[(i + paramInt1)] = (byte)j;
    194.         }
    195.         return paramInt2;
    196.     }
    197.  
    198.     static {
    199.         for (int i = 0; i < 255; i++) {
    200.             pem_convert_array[i] = -1;
    201.         }
    202.         for (int i = 0; i < PEM_ARRAY.length; i++)
    203.             pem_convert_array[PEM_ARRAY[i]] = (byte)i;
    204.     }
    205. }
     
  2. 加密敏感信息：

    执行PropertiesUtil类中的main方法：

    1.     public static void main(String[] args) {//ROOT为要加密的明文
    2.         String encrypt = SecurityUtil.encryptDes("ROOT", KEY);
    3.         System.out.println(encrypt);
    4.         System.out.println(SecurityUtil.decryptDes(encrypt, KEY));
    5.     }
     此处加密数据库密码，假设数据库密码为ROOT

     

  3. 配置文件中该明文为密文： 
    1. db.writer.username=root
    2. db.writer.password=9u7x63ZJmcy=
     
  4. 在spring配置文件中引入配置： 
    1. 	<!-- 引入属性文件 -->
    2. 	<bean class="com.ds.core.util.PropertiesUtil">
    3. 		<property name="systemPropertiesModeName" value="SYSTEM_PROPERTIES_MODE_OVERRIDE" />
    4. 		<property name="ignoreResourceNotFound" value="true" />
    5. 		<property name="locations">
    6. 			<list>
    7. 				<value>classpath:config/jdbc.properties</value>
    8. 			</list>
    9. 		</property>
    10. 		<property name="decryptProperties">
    11. 			<array>
    12. 				<!-- 需要解密的配置 -->
    13. 				<value>db.writer.password</value>
    14. 			</array>
    15. 		</property>
    16. 	</bean>
     

 搞定！酷

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/691419
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号