Java 加密整理

對加密使用的整理：

1.須要導入jar包

'org.bouncycastle:bcprov-jdk16:1.46',
'commons-codec:commons-codec:1.9',

 

2.沒有找到對應的加密算法名稱，定義了算法名稱Enum：EncryptAlgorithmEnum.java

/**
 * 
 */
package org.rico.commons.utils.encrypt;

/**
 * @author rico
 * 加密算法名稱enum
 */
public enum EncryptAlgorithmEnum {
	MD5("MD5"),
	SHA("SHA"),
	SHA1("SHA1"),
	SHA256("SHA256"),
	
	DSA("DSA"),
	RSA("RSA"),
	
	AES("AES"),
	DES("DES"),
	DESede("DESede");
	
	
	private String name;
	
	private EncryptAlgorithmEnum(String name) {
		this.name = name;
	}
	
	public String value() {
		return this.getName();
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

3.加密工具類EncryptUtil.java

/**
 * 
 */
package org.rc.common.encrypt;

import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Security;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang3.StringUtils;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

/**
 * @author rico
 * md5加密工具 
 * message-digest algorithm 5 （信息-摘要算法）,經常使用於文件校驗
 * 
 * SHA(Secure Hash Algorithm，安全散列算法）
 * 數字簽名等密碼學應用中重要的工具，被普遍地應用於電子商務等信息安全領域。
 * SHA與MD5經過碰撞法都被破解了，可是SHA仍然是公認的安全加密算法，較之MD5更爲安全
 * https://my.oschina.net/u/733161/blog/756814
 */
public class EncryptUtil {
	private static final String CHARSET_UTF8 = "UTF-8";
	
	static {
		//TODO add Provider
		// Adds a provider to the next position available. 
		Security.addProvider(new BouncyCastleProvider());
	}
	
	
	//============================================================================
	// 單向加密 MD5,SHA
	//============================================================================
	/**
	 * 單向加密
	 * @param value
	 * @return
	 * @throws NoSuchAlgorithmException
	 */
	public static byte[] digest(String algorithm, String value) throws NoSuchAlgorithmException {
		if(StringUtils.isBlank(algorithm)) {
			throw new NullPointerException("algorithm is null.");
		}
		if(StringUtils.isBlank(value)) {
			throw new NullPointerException("digest value is null.");
		}
		
		MessageDigest digest = MessageDigest.getInstance(algorithm);
		digest.update(value.getBytes());
		
		return digest.digest();
	}
	
	/**
	 * 單向加密並轉換爲字符串格式
	 * @param value
	 * @return
	 * @throws NoSuchAlgorithmException
	 */
	public static String digestToString(String algorithm, String value) throws NoSuchAlgorithmException {
		byte[] bytes = digest(algorithm, value);
		return Base64.encodeBase64String(bytes);
	}
	
	/**
	 * md5 加密
	 * @param value
	 * @return
	 * @throws NoSuchAlgorithmException
	 */
	public static byte[] md5(String value) throws NoSuchAlgorithmException {
		return digest(EncryptAlgorithmEnum.MD5.value(), value);
	}
	
	/**
	 * md5加密並轉換爲字符串格式
	 * @param value
	 * @return
	 * @throws NoSuchAlgorithmException
	 */
	public static String md5ToString(String value) throws NoSuchAlgorithmException {
		return digestToString(EncryptAlgorithmEnum.MD5.value(), value);
	}
	
	/**
	 * sha加密
	 * @param value
	 * @return
	 * @throws NoSuchAlgorithmException
	 */
	public static byte[] sha(String value) throws NoSuchAlgorithmException {
		return digest(EncryptAlgorithmEnum.SHA.value(), value);
	}
	
	/**
	 * sha加密並轉換爲字符串格式
	 * @param value
	 * @return
	 * @throws NoSuchAlgorithmException
	 */
	public static String shaToString(String value) throws NoSuchAlgorithmException {
		return digestToString(EncryptAlgorithmEnum.SHA.value(), value);
	}
	
	
	//===============================================================================
	// 對稱雙向加密AES,DES
	//===============================================================================
	/**
	 * 生成密鑰
	 * @param algorithm
	 * @return
	 * @throws NoSuchAlgorithmException
	 */
	public static SecretKey generateSecretKey(String algorithm) throws NoSuchAlgorithmException {
		if(StringUtils.isBlank(algorithm)) {
			throw new NullPointerException("algorithm name is null");
		}
		KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);
		return keyGenerator.generateKey();
	}
	
	/**
	 * 生成密鑰字符串
	 * @param algorithm
	 * @return
	 * @throws NoSuchAlgorithmException
	 */
	public static String generateSecretKeyString(String algorithm) throws NoSuchAlgorithmException {
		SecretKey secretKey = generateSecretKey(algorithm);
		return Base64.encodeBase64String(secretKey.getEncoded());
	}

	/**
	 * 生成AES密鑰
	 * @return
	 * @throws NoSuchAlgorithmException
	 */
	public static SecretKey aesKey() throws NoSuchAlgorithmException {
		return generateSecretKey(EncryptAlgorithmEnum.AES.value());
	}
	
	/**
	 * 生成AES密鑰字符串
	 * @return
	 * @throws NoSuchAlgorithmException
	 */
	public static String aesKeyString() throws NoSuchAlgorithmException {
		return generateSecretKeyString(EncryptAlgorithmEnum.AES.value());
	}
	
	/**
	 * 生成DES密鑰
	 * @return
	 * @throws NoSuchAlgorithmException
	 */
	public static SecretKey desKey() throws NoSuchAlgorithmException {
		return generateSecretKey(EncryptAlgorithmEnum.DES.value());
	}
	
	/**
	 * 生成DES密鑰字符串
	 * @return
	 * @throws NoSuchAlgorithmException
	 */
	public static String desKeyString() throws NoSuchAlgorithmException {
		return generateSecretKeyString(EncryptAlgorithmEnum.DES.value());
	}
	
	/**
	 * 解析SecretKey
	 * @param algorithm
	 * @param value
	 * @return
	 * @throws NoSuchAlgorithmException
	 */
	public static SecretKey parseSecretKey(String algorithm, String value) throws NoSuchAlgorithmException {
		byte[] bytes = Base64.decodeBase64(value);
		return parseSecretKey(algorithm, bytes);
	}
	
	/**
	 * 解析SecretKey
	 * @param algorithm
	 * @param bytes
	 * @return
	 */
	public static SecretKey parseSecretKey(String algorithm, byte[] bytes) {
		SecretKey secretKey = new SecretKeySpec(bytes, 0, bytes.length, algorithm);
		return secretKey;
	}
	
	/**
	 * 解析 AES SecretKey
	 * @param value
	 * @return
	 * @throws NoSuchAlgorithmException
	 */
	public static SecretKey parseAESSecretKey(String value) throws NoSuchAlgorithmException {
		return parseSecretKey(EncryptAlgorithmEnum.AES.value(), value);
	}
	public static SecretKey parseAESSecretKey(byte[] byets) throws NoSuchAlgorithmException {
		return parseSecretKey(EncryptAlgorithmEnum.AES.value(), byets);
	}
	
	/**
	 * 解析 DES SecretKey
	 * @param value
	 * @return
	 * @throws NoSuchAlgorithmException
	 */
	public static SecretKey parseDESSecretKey(String value) throws NoSuchAlgorithmException {
		return parseSecretKey(EncryptAlgorithmEnum.DES.value(), value);
	}
	public static SecretKey parseDESSecretKey(byte[] bytes) throws NoSuchAlgorithmException {
		return parseSecretKey(EncryptAlgorithmEnum.DES.value(), bytes);
	}
	
	/**
	 * 對稱加密
	 * @param algorithm
	 * @param key
	 * @param value
	 * @return
	 * @throws NoSuchAlgorithmException
	 * @throws NoSuchPaddingException
	 * @throws InvalidKeyException
	 * @throws IllegalBlockSizeException
	 * @throws BadPaddingException
	 */
	public static byte[] encryptSymmetric(String algorithm, SecretKey key, String value) throws NoSuchAlgorithmException, 
			NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
		if(StringUtils.isBlank(algorithm)) {
			throw new NullPointerException("algorithm name is null");
		}
		if(StringUtils.isBlank(value)) {
			throw new NullPointerException("encrypt value is null");
		}
		
		Cipher cipher = Cipher.getInstance(algorithm);
		cipher.init(Cipher.ENCRYPT_MODE, key);
		return cipher.doFinal(value.getBytes());
	}
	public static String encryptSymmetricString(String algorithm, SecretKey key, String value) throws NoSuchAlgorithmException, 
			NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
		byte[] bytes = encryptSymmetric(algorithm, key, value);
		return Base64.encodeBase64String(bytes);
	}
	
	/**
	 * 對稱解密
	 * @param algorithm
	 * @param key
	 * @param value
	 * @return
	 * @throws NoSuchAlgorithmException
	 * @throws NoSuchPaddingException
	 * @throws InvalidKeyException
	 * @throws IllegalBlockSizeException
	 * @throws BadPaddingException
	 * @throws UnsupportedEncodingException
	 */
	public static byte[] decryptSymmetric(String algorithm, SecretKey key, String value) throws NoSuchAlgorithmException, 
		NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
		
		if(StringUtils.isBlank(algorithm)) {
			throw new NullPointerException("algorithm name is null");
		}
		if(StringUtils.isBlank(value)) {
			throw new NullPointerException("decrypt value is null");
		}
		
		Cipher cipher = Cipher.getInstance(algorithm);
		cipher.init(Cipher.DECRYPT_MODE, key);
		
		byte[] decodeBytes = Base64.decodeBase64(value);
		return cipher.doFinal(decodeBytes);
	}
	public static String decryptSymmetricString(String algorithm, SecretKey key, String value) throws NoSuchAlgorithmException,
			NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
		byte[] bytes = decryptSymmetric(algorithm, key, value);
		return new String(bytes, CHARSET_UTF8);
	}
	
	/**
	 * DES對稱加密
	 * @param key
	 * @param value
	 * @return
	 * @throws InvalidKeyException
	 * @throws NoSuchAlgorithmException
	 * @throws NoSuchPaddingException
	 * @throws IllegalBlockSizeException
	 * @throws BadPaddingException
	 */
	public static byte[] desEncrypt(SecretKey key, String value) throws InvalidKeyException, NoSuchAlgorithmException, 
			NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
		return encryptSymmetric(EncryptAlgorithmEnum.DES.value(), key, value);
	}
	public static String desEncryptString(SecretKey key, String value) throws InvalidKeyException, NoSuchAlgorithmException, 
			NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
		return encryptSymmetricString(EncryptAlgorithmEnum.DES.value(), key, value);
	}
	
	/**
	 * DES對稱解密
	 * @param key
	 * @param value
	 * @return
	 * @throws InvalidKeyException
	 * @throws NoSuchAlgorithmException
	 * @throws NoSuchPaddingException
	 * @throws IllegalBlockSizeException
	 * @throws BadPaddingException
	 * @throws UnsupportedEncodingException
	 */
	public static String desDecryptString(SecretKey key, String value) throws InvalidKeyException, NoSuchAlgorithmException, 
			NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
		return decryptSymmetricString(EncryptAlgorithmEnum.DES.value(), key, value);
	}
	public static byte[] desDecrypt(SecretKey key, String value) throws InvalidKeyException, NoSuchAlgorithmException, 
			NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
		return decryptSymmetric(EncryptAlgorithmEnum.DES.value(), key, value);
	}
	
	/**
	 * AES對稱加密
	 * @param key
	 * @param value
	 * @return
	 * @throws InvalidKeyException
	 * @throws NoSuchAlgorithmException
	 * @throws NoSuchPaddingException
	 * @throws IllegalBlockSizeException
	 * @throws BadPaddingException
	 */
	public static byte[] aesEncrypt(SecretKey key, String value) throws InvalidKeyException, NoSuchAlgorithmException, 
			NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
		return encryptSymmetric(EncryptAlgorithmEnum.AES.value(), key, value);
	}
	public static String aesEncryptString(SecretKey key, String value) throws InvalidKeyException, NoSuchAlgorithmException, 
			NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
		return encryptSymmetricString(EncryptAlgorithmEnum.AES.value(), key, value);
	}
	
	/**
	 * AES對稱解密
	 * @param key
	 * @param value
	 * @return
	 * @throws InvalidKeyException
	 * @throws NoSuchAlgorithmException
	 * @throws NoSuchPaddingException
	 * @throws IllegalBlockSizeException
	 * @throws BadPaddingException
	 * @throws UnsupportedEncodingException
	 */
	public static byte[] aesDecrypt(SecretKey key, String value) throws InvalidKeyException, NoSuchAlgorithmException, 
			NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
		return decryptSymmetric(EncryptAlgorithmEnum.AES.value(), key, value);
	}
	public static String aesDecryptString(SecretKey key, String value) throws InvalidKeyException, NoSuchAlgorithmException, 
			NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
		return decryptSymmetricString(EncryptAlgorithmEnum.AES.value(), key, value);
	}
	
	
	//=================================================================================
	// 非對稱雙向加密RSA/DSA
	//===========================非對稱雙向加密=========================================
	/**
	 * 生成密鑰對
	 * @param algorithm
	 * @param keysize
	 * @return
	 * @throws NoSuchAlgorithmException
	 */
	public static KeyPair generateKeyPair(String algorithm, int keysize) throws NoSuchAlgorithmException {
		if(StringUtils.isBlank(algorithm)) {
			throw new NullPointerException("algorithm name is null");
		}
		if(keysize <= 0) {
			throw new IllegalArgumentException("keysize should be great than zero.");
		}
		
		KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
		keyPairGenerator.initialize(keysize);
		
		return keyPairGenerator.generateKeyPair();
	}
	
	/**
	 * 生成密鑰對
	 * @param algorithm
	 * @param keysize
	 * @param random
	 * @return
	 * @throws NoSuchAlgorithmException
	 */
	public static KeyPair generateKeyPair(String algorithm, int keysize, SecureRandom random) throws NoSuchAlgorithmException {
		if(StringUtils.isBlank(algorithm)) {
			throw new NullPointerException("algorithm name is null");
		}
		if(keysize <= 0) {
			throw new IllegalArgumentException("keysize should be great than zero.");
		}
		
		KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
		keyPairGenerator.initialize(keysize, random);
		
		return keyPairGenerator.generateKeyPair();
	}
	
	/**
	 * 獲取RSA密鑰對
	 * @param keysize
	 * @return
	 * @throws NoSuchAlgorithmException
	 */
	public static KeyPair rsaKeyPair(int keysize) throws NoSuchAlgorithmException {
		return generateKeyPair(EncryptAlgorithmEnum.RSA.value(), keysize);
	}
	public static KeyPair rsaKeyPair(int keysize, SecureRandom random) throws NoSuchAlgorithmException {
		return generateKeyPair(EncryptAlgorithmEnum.RSA.value(), keysize, random);
	}
	
	/**
	 * 獲取DSA密鑰對
	 * @param keysize
	 * @return
	 * @throws NoSuchAlgorithmException
	 */
	public static KeyPair dsaKeyPair(int keysize) throws NoSuchAlgorithmException {
		return generateKeyPair(EncryptAlgorithmEnum.DSA.value(), keysize);
	}
	public static KeyPair dsaKeyPair(int keysize, SecureRandom random) throws NoSuchAlgorithmException {
		return generateKeyPair(EncryptAlgorithmEnum.DSA.value(), keysize, random);
	}
	
	public static String keyToString(Key key) {
		return Base64.encodeBase64String(key.getEncoded());
	}
	
	/**
	 * 非對稱加密
	 * @param algorithm
	 * @param key
	 * @param value
	 * @return
	 * @throws NoSuchAlgorithmException
	 * @throws NoSuchPaddingException
	 * @throws InvalidKeyException
	 * @throws IllegalBlockSizeException
	 * @throws BadPaddingException
	 * @throws UnsupportedEncodingException
	 */
	public static byte[] encryptNonSymmetric(String algorithm, Key key, String value) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
		if(StringUtils.isBlank(algorithm)) {
			throw new NullPointerException("algorithm name is null");
		}
		if(StringUtils.isBlank(value)) {
			throw new NullPointerException("encrypt value is null");
		}
		
		Cipher cipher = Cipher.getInstance(algorithm);
		cipher.init(Cipher.ENCRYPT_MODE, key);
		return cipher.doFinal(value.getBytes(CHARSET_UTF8));
	}
	public static String encryptNonSymmetricString(String algorithm, Key key, String value) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
		byte[] bytes = encryptNonSymmetric(algorithm, key, value);
		return Base64.encodeBase64String(bytes);
	}
	
	/**
	 * 非對稱解密
	 * @param algorithm
	 * @param key
	 * @param value
	 * @return
	 * @throws NoSuchAlgorithmException
	 * @throws NoSuchPaddingException
	 * @throws InvalidKeyException
	 * @throws IllegalBlockSizeException
	 * @throws BadPaddingException
	 * @throws UnsupportedEncodingException
	 */
	public static byte[] decryptNonSymmetric(String algorithm, Key key, String value) throws NoSuchAlgorithmException, NoSuchPaddingException, 
			InvalidKeyException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
		if(StringUtils.isBlank(algorithm)) {
			throw new NullPointerException("algorithm name is null");
		}
		if(StringUtils.isBlank(value)) {
			throw new NullPointerException("decrypt value is null");
		}
		
		byte[] bytes = Base64.decodeBase64(value);
		Cipher cipher = Cipher.getInstance(algorithm);
		cipher.init(Cipher.DECRYPT_MODE, key);
		return cipher.doFinal(bytes);
	}
	public static String decryptNonSymmetricString(String algorithm, Key key, String value) throws NoSuchAlgorithmException, 
			NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
		byte[] decryptBytes = decryptNonSymmetric(algorithm, key, value);
		return new String(decryptBytes, CHARSET_UTF8);
	}
	
	/**
	 * RSA加密
	 * @param key
	 * @param value
	 * @return
	 * @throws InvalidKeyException
	 * @throws NoSuchAlgorithmException
	 * @throws NoSuchPaddingException
	 * @throws IllegalBlockSizeException
	 * @throws BadPaddingException
	 * @throws UnsupportedEncodingException
	 */
	public static byte[] rsaEncrypt(Key key, String value) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, 
			IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
		return encryptNonSymmetric(EncryptAlgorithmEnum.RSA.value(), key, value);
	}
	public static String rsaEncryptString(Key key, String value) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, 
			IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
		return encryptNonSymmetricString(EncryptAlgorithmEnum.RSA.value(), key, value);
	}
	
	/**
	 * RSA解密
	 * @param key
	 * @param value
	 * @return
	 * @throws InvalidKeyException
	 * @throws NoSuchAlgorithmException
	 * @throws NoSuchPaddingException
	 * @throws IllegalBlockSizeException
	 * @throws BadPaddingException
	 * @throws UnsupportedEncodingException
	 */
	public static byte[] rsaDecrypt(Key key, String value) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, 
			IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
		return decryptNonSymmetric(EncryptAlgorithmEnum.RSA.value(), key, value);
	}
	public static String rsaDecryptString(Key key, String value) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, 
			IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
		return decryptNonSymmetricString(EncryptAlgorithmEnum.RSA.value(), key, value);
	}
	
	/**
	 * DSA加密
	 * @param key
	 * @param value
	 * @return
	 * @throws InvalidKeyException
	 * @throws NoSuchAlgorithmException
	 * @throws NoSuchPaddingException
	 * @throws IllegalBlockSizeException
	 * @throws BadPaddingException
	 * @throws UnsupportedEncodingException
	 */
	public static byte[] dsaEncrypt(Key key, String value) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, 
			IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
		return encryptNonSymmetric(EncryptAlgorithmEnum.DSA.value(), key, value);
	}
	public static String dsaEncryptString(Key key, String value) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, 
			IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
		return encryptNonSymmetricString(EncryptAlgorithmEnum.DSA.value(), key, value);
	}
	
	/**
	 * DSA解密
	 * @param algorithm
	 * @param key
	 * @param value
	 * @return
	 * @throws InvalidKeyException
	 * @throws NoSuchAlgorithmException
	 * @throws NoSuchPaddingException
	 * @throws IllegalBlockSizeException
	 * @throws BadPaddingException
	 * @throws UnsupportedEncodingException
	 */
	public static byte[] dsaDecrypt(String algorithm, Key key, String value) throws InvalidKeyException, NoSuchAlgorithmException, 
			NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
		return decryptNonSymmetric(EncryptAlgorithmEnum.DSA.value(), key, value);
	}
	public static String dsaDecryptString(String algorithm, Key key, String value) throws InvalidKeyException, NoSuchAlgorithmException, 
			NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
		return decryptNonSymmetricString(EncryptAlgorithmEnum.DSA.value(), key, value);
	}
	
	/**
	 * 解析私鑰
	 * @param keyFactory
	 * @param keyValue
	 * @return
	 * @throws InvalidKeySpecException
	 */
	public static PrivateKey parsePrivateKey(KeyFactory keyFactory, byte[] bytes) throws InvalidKeySpecException {
		// Creates a new PKCS8EncodedKeySpec with the given encoded key.
		// PKCS8EncodedKeySpec represents the ASN.1 encoding of a private key, encoded according to the ASN.1 type PrivateKeyInfo. 
		PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(bytes);
		PrivateKey key = (PrivateKey) keyFactory.generatePrivate(keySpec);
		
		return key;
	}
	public static PrivateKey parsePrivateKey(KeyFactory keyFactory, String keyValue) throws InvalidKeySpecException {
		return parsePrivateKey(keyFactory, Base64.decodeBase64(keyValue.getBytes()));
	}
	
	/**
	 * 解析私鑰(RSA)
	 * @param keyValue
	 * @return
	 * @throws InvalidKeySpecException
	 * @throws NoSuchAlgorithmException
	 */
	public static PrivateKey parseRSAPrivateKey(byte[] bytes) throws InvalidKeySpecException, NoSuchAlgorithmException {
		KeyFactory keyFactory = getKeyFactory(EncryptAlgorithmEnum.RSA.value());
		return parsePrivateKey(keyFactory, bytes);
	}
	public static PrivateKey parseRSAPrivateKey(String keyValue) throws InvalidKeySpecException, NoSuchAlgorithmException {
		KeyFactory keyFactory = getKeyFactory(EncryptAlgorithmEnum.RSA.value());
		return parsePrivateKey(keyFactory, keyValue);
	}
	
	/**
	 * 解析私鑰(DSA)
	 * @param keyValue
	 * @return
	 * @throws InvalidKeySpecException
	 * @throws NoSuchAlgorithmException
	 */
	public static PrivateKey parseDSAPrivateKey(byte[] bytes) throws InvalidKeySpecException, NoSuchAlgorithmException {
		KeyFactory keyFactory = getKeyFactory(EncryptAlgorithmEnum.DSA.value());
		return parsePrivateKey(keyFactory, bytes);
	}
	public static PrivateKey parseDSAPrivateKey(String keyValue) throws InvalidKeySpecException, NoSuchAlgorithmException {
		KeyFactory keyFactory = getKeyFactory(EncryptAlgorithmEnum.DSA.value());
		return parsePrivateKey(keyFactory, keyValue);
	}
	
	/**
	 * 解析公鑰
	 * @param keyFactory
	 * @param keyValue
	 * @return
	 * @throws InvalidKeySpecException
	 */
	public static PublicKey parsePublicKey(KeyFactory keyFactory, byte[] bytes) throws InvalidKeySpecException {
		// Creates a new X509EncodedKeySpec with the given encoded key.
		// X509EncodedKeySpec represents the ASN.1 encoding of a public key, encoded according to the ASN.1 type SubjectPublicKeyInfo. 
		X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes);
		PublicKey key = keyFactory.generatePublic(keySpec);
		
		return key;
	}
	public static PublicKey parsePublicKey(KeyFactory keyFactory, String keyValue) throws InvalidKeySpecException {
		return parsePublicKey(keyFactory, Base64.decodeBase64(keyValue.getBytes()));
	}
	
	/**
	 * 解析公鑰(RSA)
	 * @param keyValue
	 * @return
	 * @throws InvalidKeySpecException
	 * @throws NoSuchAlgorithmException
	 */
	public static PublicKey parseRSAPublicKey(byte[] bytes) throws InvalidKeySpecException, NoSuchAlgorithmException {
		KeyFactory keyFactory = getKeyFactory(EncryptAlgorithmEnum.RSA.value());
		return parsePublicKey(keyFactory, bytes);
	}
	public static PublicKey parseRSAPublicKey(String keyValue) throws InvalidKeySpecException, NoSuchAlgorithmException {
		KeyFactory keyFactory = getKeyFactory(EncryptAlgorithmEnum.RSA.value());
		return parsePublicKey(keyFactory, keyValue);
	}
	
	/**
	 * 解析公鑰(DSA)
	 * @param keyValue
	 * @return
	 * @throws InvalidKeySpecException
	 * @throws NoSuchAlgorithmException
	 */
	public static PublicKey parseDSAPublicKey(byte[] bytes) throws InvalidKeySpecException, NoSuchAlgorithmException {
		KeyFactory keyFactory = getKeyFactory(EncryptAlgorithmEnum.DSA.value());
		return parsePublicKey(keyFactory, bytes);
	}
	public static PublicKey parseDSAPublicKey(String keyValue) throws InvalidKeySpecException, NoSuchAlgorithmException {
		KeyFactory keyFactory = getKeyFactory(EncryptAlgorithmEnum.DSA.value());
		return parsePublicKey(keyFactory, keyValue);
	}
	
	
	/**
	 * 獲取祕鑰工廠類
	 * @param algorithm
	 * @return
	 * @throws NoSuchAlgorithmException
	 */
	public static KeyFactory getKeyFactory(String algorithm) throws NoSuchAlgorithmException {		
		return KeyFactory.getInstance(algorithm);
	}
	
	/**
	 * 獲取祕鑰工廠類(RSA)
	 * @param algorithm
	 * @return
	 * @throws NoSuchAlgorithmException
	 */
	public static KeyFactory getRSAKeyFactory() throws NoSuchAlgorithmException {
		return getKeyFactory(EncryptAlgorithmEnum.RSA.value());
	}
	
	/**
	 * 獲取祕鑰工廠類(DSA)
	 * @param algorithm
	 * @return
	 * @throws NoSuchAlgorithmException
	 */
	public static KeyFactory getDSAKeyFactory() throws NoSuchAlgorithmException {
		return getKeyFactory(EncryptAlgorithmEnum.DSA.value());
	}
	
}

附：

http://blog.csdn.net/u013142781/article/details/50405648

http://blog.csdn.net/wildandfly/article/details/21521857