[自用门户]加密解密，每次生成的结果不一样（Base64Utils+RSAUtils）

Base64Utils+RSAUtils+EncryptPropertyPlaceholderConfigurer（加密解密类）

/*
	Copyright (C) 2017 Shanghai Huizhao e-Bidding Services Co., Ltd.
	All rights reserved.

	Author: WGY
	Version: 1.0
	Created Time: 2017年8月21日 下午3:11:15
	
	Revision History:
	Version          Date               Author			Comments
	1.0         	2017年8月21日下午3:11:15		WGY			Create file
=========================================================================
*/

package ebs_cms_test;

import java.util.Base64;


/**
 * <p> 
 * Static methods for translating Base64 encoded strings to byte arrays and vice-versa.
 * </p> 
 * @author WGY
 *
 */
public class Base64Utils {
	 /**
     * <p> 
     * BASE64字符串解码为二进制数据 
     * </p> 
     *  
     * @param base64 
     * @return 
     * @throws Exception 
     */  
    public static byte[] decode(byte[] base64) throws Exception {  
        return Base64.getDecoder().decode(base64);  
    }  
      
    /** 
     * <p> 
     * 二进制数据编码为BASE64字符串 
     * </p> 
     *  
     * @param bytes 
     * @return 
     * @throws Exception 
     */  
    public static byte[] encode(byte[] bytes) throws Exception {  
        return Base64.getEncoder().encode(bytes);  
    }  
    
}

/*
	Copyright (C) 2017 Shanghai Huizhao e-Bidding Services Co., Ltd.
	All rights reserved.

	Author: WGY
	Version: 1.0
	Created Time: 2017年8月21日 下午3:07:17
	
	Revision History:
	Version          Date               Author			Comments
	1.0         	2017年8月21日下午3:07:17		WGY			Create file
=========================================================================
*/

package ebs_cms_test;

import java.security.Key; 
import java.io.ByteArrayOutputStream;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PublicKey;
import java.security.interfaces.RSAKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;

/**
 * <p> 
 * RSA公钥/私钥/签名工具包 
 * </p> 
 * <p> 
 * 字符串格式的密钥在未在特殊说明情况下都为BASE64编码格式<br/> 
 * 由于非对称加密速度极其缓慢，一般文件不使用它来加密而是使用对称加密，<br/> 
 * 非对称加密算法可以用来对对称加密的密钥加密，这样保证密钥的安全也就保证了数据的安全 
 * </p> 
 *
 */
public class RSAUtils {
	
	/** 默认私钥 */
	private static final String DEFAULT_PRIVATE_KEY_STRING = "MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBALOuNbJkZHuQ12WeMNim0QH2YRzXQ1Tnea5Qz/S9vMPyK96RfnO4no/tWuPNPtUi7Wv1T0Hb7FfNIX7a2KcTMGkTzP8MB4vbflmY1RAkUhUa+sZRiziruePbWfio2XB9uOkQfaQ+QEbeOAB4QcxePi2Rojk1v/oqv7IJmlpKfZT7AgMBAAECgYBk8rdQZn7dvV6GxP2EexRqGdYtsfMuPG5stRJg2ki3fdOP1AZLVaogCqZJ3gIzFNB3GvdQdRKvsZvj/WhDVdCYA+tGB/mVVpww3ySdcnlC+2sdq8eMxfj1dUc3ozTgUebQOapWj1CH+a0v9KPocWqfM7gCbURqe+OqSP4iYGWxoQJBAP62v48y6eansUSXtf004I5t2OBx/g+JTVLm7tVzY199l0hjXFe4kFpFgliu1QXxaI/WbwBv2jj3z1vRlmWH1g0CQQC0lniIfG9WzlFeaHudoCgyO9K5HtfJgnes0kjbPN3R88ZcpqtJEhr0C5EbA5fVNJj3Sfssq/x0ndH1unJrHp0nAkEA4hzU3Igz/6Apy1xqIAcKuSVme4h2ItCeJdP/fNjcBG73FzmtRen/q0M9PQCm9omhat7O1zJ0JFJIb5gUzLjTGQJBAKQ1gyrQw8lSWGkZZvaA8Kwk+8s7gYqJ6Vqr6HX61dWY7pHHOE98eCfb8Ll4vfKwHjwW+J+5UBmWfJoOTQac0tcCQQD+oZa16KxdyYd4vzcyAoghTAhYr+pAyTUvqpx4cBe0nnDaClIbPbh3sz/ZZwZAq02H/lqSHiErVPUiEQ8ir4pq";
	
	/** 默认公钥 */
	public static final String DEFAULT_PUBLIC_KEY_STRING = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCzrjWyZGR7kNdlnjDYptEB9mEc10NU53muUM/0vbzD8ivekX5zuJ6P7VrjzT7VIu1r9U9B2+xXzSF+2tinEzBpE8z/DAeL235ZmNUQJFIVGvrGUYs4q7nj21n4qNlwfbjpEH2kPkBG3jgAeEHMXj4tkaI5Nb/6Kr+yCZpaSn2U+wIDAQAB";
	
    /**  
     * 加密算法RSA 
     */  
    public static final String KEY_ALGORITHM = "RSA";  
      
    /**  
     * 签名算法 
     */  
    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";  
  
    /** 
     * 获取公钥的key 
     */  
    public static final String PUBLIC_KEY = "RSAPublicKey";  
      
    /** 
     * 获取私钥的key 
     */  
    public static final String PRIVATE_KEY = "RSAPrivateKey";  
      
    /**  
     * RSA最大加密明文大小 
     */  
    private static final int MAX_ENCRYPT_BLOCK = 117;  
      
    /**  
     * RSA最大解密密文大小 
     */  
    private static final int MAX_DECRYPT_BLOCK = 128;  
  
    /** 
     * <p> 
     * 生成密钥对(公钥和私钥) 
     * </p> 
     *  
     * @return 
     * @throws Exception 
     */  
    public static Map<String, RSAKey> genKeyPair() throws Exception {  
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);  
        keyPairGen.initialize(1024);  
        KeyPair keyPair = keyPairGen.generateKeyPair();  
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();  
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();  
        Map<String, RSAKey> keyMap = new HashMap<String, RSAKey>(2);  
        keyMap.put(PUBLIC_KEY, publicKey);  
        keyMap.put(PRIVATE_KEY, privateKey);  
        return keyMap;  
    }  
    /**  
     * <P> 
     * 默认私钥解密 
     * </p> 
     *  
     * @param encryptedData 已加密数据 
     * @return 
     * @throws Exception 
     */  
    public static byte[] decryptByPrivateKey(byte[] encryptedData)  throws Exception {  
    	return decryptByPrivateKey(encryptedData,null);
    }
  
    /**  
     * <P> 
     * 私钥解密 
     * </p> 
     *  
     * @param encryptedData 已加密数据 
     * @param privateKey 私钥(BASE64编码) 
     * @return 
     * @throws Exception 
     */  
    public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey)  
            throws Exception {  
    	if(null==privateKey || "".equals(privateKey)){
    		privateKey = DEFAULT_PRIVATE_KEY_STRING;
    	}
        byte[] keyBytes = Base64Utils.decode(privateKey.getBytes());  
        encryptedData = Base64Utils.decode(encryptedData);  
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);  
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
        cipher.init(Cipher.DECRYPT_MODE, privateK);  
        int inputLen = encryptedData.length;  
        ByteArrayOutputStream out = new ByteArrayOutputStream();  
        int offSet = 0;  
        byte[] cache;  
        int i = 0;  
        // 对数据分段解密  
        while (inputLen - offSet > 0) {  
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {  
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);  
            } else {  
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);  
            }  
            out.write(cache, 0, cache.length);  
            i++;  
            offSet = i * MAX_DECRYPT_BLOCK;  
        }  
        byte[] decryptedData = out.toByteArray();  
        out.close();  
        return decryptedData;  
    }  
    /**  
     * <p> 
     * 默认公钥解密 
     * </p> 
     *  
     * @param encryptedData 已加密数据 
     * @return  
     * @throws Exception 
     */  
    public static byte[] decryptByPublicKey(byte[] encryptedData)  throws Exception { 
    	return decryptByPublicKey(encryptedData, null);
    }
    /**  
     * <p> 
     * 公钥解密 
     * </p> 
     *  
     * @param encryptedData 已加密数据 
     * @param publicKey 公钥(BASE64编码) 
     * @return  
     * @throws Exception 
     */  
    public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey)  
            throws Exception {  
    	if(null==publicKey || "".equals(publicKey)){
    		publicKey = DEFAULT_PUBLIC_KEY_STRING;
    	}
        byte[] keyBytes = Base64Utils.decode(publicKey.getBytes()); 
        encryptedData = Base64Utils.decode(encryptedData);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);  
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
        Key publicK = keyFactory.generatePublic(x509KeySpec);  
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
        cipher.init(Cipher.DECRYPT_MODE, publicK);  
        int inputLen = encryptedData.length;  
        ByteArrayOutputStream out = new ByteArrayOutputStream();  
        int offSet = 0;  
        byte[] cache;  
        int i = 0;  
        // 对数据分段解密  
        while (inputLen - offSet > 0) {  
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {  
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);  
            } else {  
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);  
            }  
            out.write(cache, 0, cache.length);  
            i++;  
            offSet = i * MAX_DECRYPT_BLOCK;  
        }  
        byte[] decryptedData = out.toByteArray();  
        out.close();  
        return decryptedData;  
    }  
    /**  
     * <p> 
     * 默认公钥加密 
     * </p> 
     *  
     * @param data 源数据 
     * @return  base64加密的公钥加密结果
     * @throws Exception 
     */  
    public static byte[] encryptByPublicKey(byte[] data)  throws Exception {  
    	return encryptByPublicKey(data, null);
    }
    /**  
     * <p> 
     * 公钥加密 
     * </p> 
     *  
     * @param data 源数据 
     * @param publicKey 公钥(BASE64编码) 
     * @return  base64加密的公钥加密结果
     * @throws Exception 
     */  
    public static byte[] encryptByPublicKey(byte[] data, String publicKey)  
            throws Exception {  
    	if(null==publicKey || "".equals(publicKey)){
    		publicKey = DEFAULT_PUBLIC_KEY_STRING;
    	}
        byte[] keyBytes = Base64Utils.decode(publicKey.getBytes());  
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);  
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
        Key publicK = keyFactory.generatePublic(x509KeySpec);  
        // 对数据加密  
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
        cipher.init(Cipher.ENCRYPT_MODE, publicK);  
        int inputLen = data.length;  
        ByteArrayOutputStream out = new ByteArrayOutputStream();  
        int offSet = 0;  
        byte[] cache;  
        int i = 0;  
        // 对数据分段加密  
        while (inputLen - offSet > 0) {  
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {  
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);  
            } else {  
                cache = cipher.doFinal(data, offSet, inputLen - offSet);  
            }  
            out.write(cache, 0, cache.length);  
            i++;  
            offSet = i * MAX_ENCRYPT_BLOCK;  
        }  
        byte[] encryptedData = out.toByteArray();  
       
        out.close();  
        return  Base64Utils.encode(encryptedData);  
    }  
    /**  
     * <p> 
     * 默认私钥加密 
     * </p> 
     *  
     * @param data 源数据 
     * @param privateKey 私钥(BASE64编码) 
     * @throws Exception 
     */  
    public static byte[] encryptByPrivateKey(byte[] data)   throws Exception { 
    	return encryptByPrivateKey(data, null);
    }
    /**  
     * <p> 
     * 私钥加密 
     * </p> 
     *  
     * @param data 源数据 
     * @param privateKey 私钥(BASE64编码) 
     * @return base64加密的私钥加密结果
     * @throws Exception 
     */  
    public static byte[] encryptByPrivateKey(byte[] data, String privateKey)  
            throws Exception {  
    	if(null==privateKey || "".equals(privateKey)){
    		privateKey = DEFAULT_PRIVATE_KEY_STRING;
    	}
        byte[] keyBytes = Base64Utils.decode(privateKey.getBytes());  
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);  
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
        cipher.init(Cipher.ENCRYPT_MODE, privateK);  
        int inputLen = data.length;  
        ByteArrayOutputStream out = new ByteArrayOutputStream();  
        int offSet = 0;  
        byte[] cache;  
        int i = 0;  
        // 对数据分段加密  
        while (inputLen - offSet > 0) {  
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {  
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);  
            } else {  
                cache = cipher.doFinal(data, offSet, inputLen - offSet);  
            }  
            out.write(cache, 0, cache.length);  
            i++;  
            offSet = i * MAX_ENCRYPT_BLOCK;  
        }  
        byte[] encryptedData = out.toByteArray();  
        out.close();  
        return Base64Utils.encode(encryptedData);  
    }  
    
    public static void printPPKeys() throws Exception{
    	Map<String, RSAKey> keys=RSAUtils.genKeyPair();
    	System.out.println("============================ 公钥 =================================");
		System.out.println(Base64.getEncoder().encodeToString(((Key)keys.get(PUBLIC_KEY)).getEncoded()));
		System.out.println();
		System.out.println("============================ 私钥 =================================");
		System.out.println(Base64.getEncoder().encodeToString(((Key)keys.get(PRIVATE_KEY)).getEncoded()));
    }
  
    /**  
     * <p> 
     * 获取私钥 
     * </p> 
     *  
     * @param keyMap 密钥对 
     * @return 
     * @throws Exception 
     */  
    public static String getPrivateKey(Map<String, Object> keyMap)  
            throws Exception {  
        Key key = (Key) keyMap.get(PRIVATE_KEY);  
        return new String(Base64Utils.encode(key.getEncoded()));  
    }  
  
    /**  
     * <p> 
     * 获取公钥 
     * </p> 
     *  
     * @param keyMap 密钥对 
     * @return 
     * @throws Exception 
     */  
    public static String getPublicKey(Map<String, Object> keyMap)  
            throws Exception {  
        Key key = (Key) keyMap.get(PUBLIC_KEY);  
        return new String(Base64Utils.encode(key.getEncoded()));  
    }  
    
}

package ebs_cms_test;

/*import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;*/

public class EncryptPropertyPlaceholderConfigurer {
	private static final String privateKey="MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBAJvqdVcoYG8/pLDuBrDC4QyOR21pVY/VtLq2nkyQdN9SstNCixmsORqXsq4aBh2WzkEBrhQM8W+MHBj1XTf4+zncz7MFH0jWo9+CjhsUdhHCKQK6QMdYjFPhXtMgQRKHvD/DjpKednC5eeUHhpqg7t/MPp2C47+jBTZ4veRGuDLxAgMBAAECgYEAji+0rrU9rHaHxGptY4l1HrQp41dqFe+4D4Y2unAKhRavygUnQVRUBzJMWoWVCirbEWFs1RAwpZ9KiGBKkJ7YyzARS7UBLRGXEQCznV6CA+IXEEnlt2yZlgZl96mdx2AhtXwdMC6+GQXfMsjS7CzmawNirn0/qe9or/q0es004ZkCQQDaBAp9jusPGd+TMfaEDVOjSvj9NP4afK0CTPoH68IRhd+rTYcBdedyKLV6V9RVu/KWo7flNmUIUeg2fEN3drhHAkEAtxShfISCd7AX8KRtv8/Dv5wSjt8LfwtMGSTJ8ThLZADgsN4kGxynPsQ+LMG3NV5KtSpJogl3kFlf6K42uGsPBwJBAMnlIh3ig1XpvP0gMM1bVhALdwdt0r+Oo91UkdtR/deiZV7LHfJBUMOMZXtV6MI4mk/cb4lp1SheSbBjZUs1ezMCQEaIDC6MXjb+ADsVHbLnt+H5nqysASHQmGCXa7UimujL7cQ10HMhds0XjVxwxMQqr11cDUH/o7BYvjpF447or8ECQQDAd3g/ywUVpVPtRHSN377Mjp6d8ZFMYR/EYRrTrTT70Zq+EknRd/asVbEifMLruJWBMf/v5NATFeEFNcQQiQK0";
	private static final String publicKey="MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCb6nVXKGBvP6Sw7gawwuEMjkdtaVWP1bS6tp5MkHTfUrLTQosZrDkal7KuGgYdls5BAa4UDPFvjBwY9V03+Ps53M+zBR9I1qPfgo4bFHYRwikCukDHWIxT4V7TIEESh7w/w46SnnZwuXnlB4aaoO7fzD6dguO/owU2eL3kRrgy8QIDAQAB";
	private String[] encryptPropNames = { "jdbc.username", "jdbc.password","jdbc.url" };
	private static final  String charset="utf-8";

	/*@Override*/
	protected String convertProperty(String propertyName, String propertyValue) {

		// 如果在加密属性名单中发现该属性
		if (isEncryptProp(propertyName)) {
			String decryptValue;
			try {
				decryptValue = new String(RSAUtils.decryptByPrivateKey(propertyValue.getBytes(charset), privateKey),charset);
				return decryptValue;
			}  catch (Exception e) {
				throw new RuntimeException(e);
			}
		} else {
			return propertyValue;
		}
	}

	private boolean isEncryptProp(String propertyName) {
		for (String encryptName : encryptPropNames) {
			if (encryptName.equals(propertyName)) {
				return true;
			}
		}
		return false;
	}
	
	
	public static void main(String[] args) throws Exception {
//		RSAUtils.printPPKeys();
//		ebs_zcm25
		//加密变量
		String url="jdbc:mysql://devdb.zcjb.com.cn:3306/ebs_cms?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true";
		String username="ebs";
		String password="ebs";
		url=new String(RSAUtils.encryptByPublicKey(url.getBytes(charset),publicKey),charset);
		username=new String(RSAUtils.encryptByPublicKey(username.getBytes(charset),publicKey),charset);
		password=new String(RSAUtils.encryptByPublicKey(password.getBytes(charset),publicKey),charset);
		System.out.println("*****加密结果*****");
		System.out.println(url);
		System.out.println(username);
		System.out.println(password);
		/*单独解密变量，如果要解密把密文放到这个变量里如:
		username="LlaGDhUYTjredYineqYCCMArrGsANYyWqMsUtyAhKRDI5r/hffIYTyjGsJUg6RX7lkB5T2N+B2fJ2JtOyGwGJD5Wf0OOb7RtrG/aTwFlM0vrx3/v9k9WX++JfWO+KGCfVPpboOW1rTRWV36gr+hv+2NNrevMjsDkKVlZJJDPMJc=";
		username="N3GA5OdGvBKbFZH9Xe/FgmFuA43YHqVr6uKh+KGCU8ud7DuHOguEllMTUBDiMi5R729WUiE0KWUVvhdAsjVy8G0WEOy1aE/BPC3pA6haY8PKAgejySyzHvRHF8hHDjiVvMlD0QA36pjfZ5poChcMHjpuvoh4KYa7chsFOeE3LeM=";
		password="k1pkriScPHW/EazBgj7H+axya4OhHCtgH/kBzXgDoGGAAm7IsyW3+kDrP6W7JX9861y5r4+IWWkVtKmOTcE71ZNX/bYERexFEs+0Yrpb454hHz2Tg+UmSHi8sP/AQu2oa502COU9hlGR04LkzLxX6T/MdebgFRFY8E1aTqE1z6w=";
*/
		
		System.out.println("*****解密结果*****");
		EncryptPropertyPlaceholderConfigurer config=new EncryptPropertyPlaceholderConfigurer();
		System.out.println(config.convertProperty("jdbc.url", url));
		System.out.println(config.convertProperty("jdbc.username", username));
		System.out.println(config.convertProperty("jdbc.password", password));
		
	}
	
}

以上自我调适，jdk1.8+eclipse高版本，