java 加密工具类（MD5、RSA、AES等加密方式）

1.加密工具类encryption

MD5加密

1. import org.apache.commons.codec.digest.DigestUtils;
2. /**
3. * MD5加密组件
4. *
5. * @author wbw
6. * @version 1.0
7. * @since 1.0
8. */
9. public abstract class MD5Util {
10. /**
11. * MD5加密
12. *
13. * @param data
14. *            待加密数据
15. * @return byte[] 消息摘要
16. *
17. * @throws Exception
18. */
19. public static byte[] encodeMD5(String data) throws Exception {
20. // 执行消息摘要
21. return DigestUtils.md5(data);
22. }
23. /**
24. * MD5加密
25. *
26. * @param data
27. *            待加密数据
28. * @return byte[] 消息摘要
29. *
30. * @throws Exception
31. */
32. public static String encodeMD5Hex(String data) {
33. // 执行消息摘要
34. return DigestUtils.md5Hex(data);
35. }
36. }

import org.apache.commons.codec.digest.DigestUtils;

/**

• MD5加密组件
• @author wbw
• @version 1.0
• @since 1.0
  
  */
  
  public abstract class MD5Util { /**
  • MD5加密
  • @param data

  •        待加密数据
    

  • @return byte[] 消息摘要

  • @throws Exception
    
    */
    
    public static byte[] encodeMD5(String data) throws Exception {

    // 执行消息摘要
    
    return DigestUtils.md5(data);
    
    }

  /**

  • MD5加密
  • @param data

  •        待加密数据
    

  • @return byte[] 消息摘要
  • @throws Exception
    
    */
    
    public static String encodeMD5Hex(String data) {
    
    // 执行消息摘要
    
    return DigestUtils.md5Hex(data);
    
    }
    
    }
    

    AES加密:

1. import javax.crypto.Cipher;
2. import javax.crypto.spec.SecretKeySpec;
3. public class AESUtil {
4. private static final String KEY_AES = "AES";
5. public static String encrypt(String src, String key) throws Exception {
6. if (key == null || key.length() != 16) {
7. throw new Exception("key不满足条件");
8. }
9. byte[] raw = key.getBytes();
10. SecretKeySpec skeySpec = new SecretKeySpec(raw, KEY_AES);
11. Cipher cipher = Cipher.getInstance(KEY_AES);
12. cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
13. byte[] encrypted = cipher.doFinal(src.getBytes());
14. return byte2hex(encrypted);
15. }
16. public static String decrypt(String src, String key) throws Exception {
17. if (key == null || key.length() != 16) {
18. throw new Exception("key不满足条件");
19. }
20. byte[] raw = key.getBytes();
21. SecretKeySpec skeySpec = new SecretKeySpec(raw, KEY_AES);
22. Cipher cipher = Cipher.getInstance(KEY_AES);
23. cipher.init(Cipher.DECRYPT_MODE, skeySpec);
24. byte[] encrypted1 = hex2byte(src);
25. byte[] original = cipher.doFinal(encrypted1);
26. String originalString = new String(original);
27. return originalString;
28. }
29. public static byte[] hex2byte(String strhex) {
30. if (strhex == null) {
31. return null;
32. }
33. int l = strhex.length();
34. if (l % 2 == 1) {
35. return null;
36. }
37. byte[] b = new byte[l / 2];
38. for (int i = 0; i != l / 2; i++) {
39. b[i] = (byte) Integer.parseInt(strhex.substring(i * 2, i * 2 + 2),
40. 16);
41. }
42. return b;
43. }
44. public static String byte2hex(byte[] b) {
45. String hs = "";
46. String stmp = "";
47. for (int n = 0; n < b.length; n++) {
48. stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));
49. if (stmp.length() == 1) {
50. hs = hs + "0" + stmp;
51. } else {
52. hs = hs + stmp;
53. }
54. }
55. return hs.toUpperCase();
56. }
57. }

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;

public class AESUtil {
private static final String KEY_AES = "AES";

public static String encrypt(String src, String key) throws Exception {
	if (key == null || key.length() != 16) {
		throw new Exception("key不满足条件");
	}
	byte[] raw = key.getBytes();
	SecretKeySpec skeySpec = new SecretKeySpec(raw, KEY_AES);
	Cipher cipher = Cipher.getInstance(KEY_AES);
	cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
	byte[] encrypted = cipher.doFinal(src.getBytes());
	return byte2hex(encrypted);
}

public static String decrypt(String src, String key) throws Exception {
	if (key == null || key.length() != 16) {
		throw new Exception("key不满足条件");
	}
	byte[] raw = key.getBytes();
	SecretKeySpec skeySpec = new SecretKeySpec(raw, KEY_AES);
	Cipher cipher = Cipher.getInstance(KEY_AES);
	cipher.init(Cipher.DECRYPT_MODE, skeySpec);
	byte[] encrypted1 = hex2byte(src);
	byte[] original = cipher.doFinal(encrypted1);
	String originalString = new String(original);
	return originalString;
}

public static byte[] hex2byte(String strhex) {
	if (strhex == null) {
		return null;
	}
	int l = strhex.length();
	if (l % 2 == 1) {
		return null;
	}
	byte[] b = new byte[l / 2];
	for (int i = 0; i != l / 2; i++) {
		b[i] = (byte) Integer.parseInt(strhex.substring(i * 2, i * 2 + 2),
				16);
	}
	return b;
}

public static String byte2hex(byte[] b) {
	String hs = "";
	String stmp = "";
	for (int n = 0; n < b.length; n++) {
		stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));
		if (stmp.length() == 1) {
			hs = hs + "0" + stmp;
		} else {
			hs = hs + stmp;
		}
	}
	return hs.toUpperCase();
}

}

Base64加密：

1. import org.apache.commons.codec.binary.Base64;
2. /**
3. * Base64组件
4. *
5. * @author wbw
6. * @version 1.0
7. * @since 1.0
8. */
9. public abstract class Base64Util {
10. /**
11. * 字符编码
12. */
13. public final static String ENCODING = "UTF-8";
14. /**
15. * Base64编码
16. *
17. * @param data 待编码数据
18. * @return String 编码数据
19. * @throws Exception
20. */
21. public static String encode(String data) throws Exception {
22. // 执行编码
23. byte[] b = Base64.encodeBase64(data.getBytes(ENCODING));
24. return new String(b, ENCODING);
25. }
26. /**
27. * Base64安全编码<br>
28. * 遵循RFC 2045实现
29. *
30. * @param data
31. *            待编码数据
32. * @return String 编码数据
33. *
34. * @throws Exception
35. */
36. public static String encodeSafe(String data) throws Exception {
37. // 执行编码
38. byte[] b = Base64.encodeBase64(data.getBytes(ENCODING), true);
39. return new String(b, ENCODING);
40. }
41. /**
42. * Base64解码
43. *
44. * @param data 待解码数据
45. * @return String 解码数据
46. * @throws Exception
47. */
48. public static String decode(String data) throws Exception {
49. // 执行解码
50. byte[] b = Base64.decodeBase64(data.getBytes(ENCODING));
51. return new String(b, ENCODING);
52. }
53. }

import org.apache.commons.codec.binary.Base64;

/**

• Base64组件
• @author wbw
• @version 1.0
• @since 1.0
  
  */
  
  public abstract class Base64Util { /**
  • 字符编码
    
    */
    
    public final static String ENCODING = "UTF-8";
  /**
  • Base64编码
  • @param data 待编码数据
  • @return String 编码数据
  • @throws Exception
    
    */
    
    public static String encode(String data) throws Exception { // 执行编码
    
    byte[] b = Base64.encodeBase64(data.getBytes(ENCODING)); return new String(b, ENCODING);
    
    }
  /**
  • Base64安全编码<br>
  • 遵循RFC 2045实现
  • @param data

  •        待编码数据
    

  • @return String 编码数据

  • @throws Exception
    
    */
    
    public static String encodeSafe(String data) throws Exception {

    // 执行编码
    
    byte[] b = Base64.encodeBase64(data.getBytes(ENCODING), true);

    return new String(b, ENCODING);
    
    }

  /**

  • Base64解码

  • @param data 待解码数据

  • @return String 解码数据

  • @throws Exception
    
    */
    
    public static String decode(String data) throws Exception {

    // 执行解码
    
    byte[] b = Base64.decodeBase64(data.getBytes(ENCODING));

    return new String(b, ENCODING);
    
    }

}

DES加密：

1. import java.security.Key;
2. import java.security.SecureRandom;
3. import java.security.Security;
4. import javax.crypto.Cipher;
5. import javax.crypto.KeyGenerator;
6. import javax.crypto.SecretKey;
7. import javax.crypto.SecretKeyFactory;
8. import javax.crypto.spec.DESKeySpec;
9. import org.apache.commons.codec.binary.Base64;
10. import org.bouncycastle.jce.provider.BouncyCastleProvider;
11. /**
12. * DES安全编码组件
13. *
14. * @author wbw
15. * @version 1.0
16. */
17. public abstract class DESUtil {
18. static{
19. Security.insertProviderAt(new BouncyCastleProvider(), 1);
20. }
21. /**
22. * 密钥算法 <br>
23. * Java 6 只支持56bit密钥 <br>
24. * Bouncy Castle 支持64bit密钥
25. */
26. public static final String KEY_ALGORITHM = "DES";
27. /**
28. * 加密/解密算法 / 工作模式 / 填充方式
29. */
30. public static final String CIPHER_ALGORITHM = "DES/ECB/PKCS5PADDING";
31. /**
32. * 转换密钥
33. *
34. * @param key
35. *            二进制密钥
36. * @return Key 密钥
37. * @throws Exception
38. */
39. private static Key toKey(byte[] key) throws Exception {
40. // 实例化DES密钥材料
41. DESKeySpec dks = new DESKeySpec(key);
42. // 实例化秘密密钥工厂
43. SecretKeyFactory keyFactory = SecretKeyFactory
44. .getInstance(KEY_ALGORITHM);
45. // 生成秘密密钥
46. SecretKey secretKey = keyFactory.generateSecret(dks);
47. return secretKey;
48. }
49. /**
50. * 解密
51. *
52. * @param data
53. *            待解密数据
54. * @param key
55. *            密钥
56. * @return byte[] 解密数据
57. * @throws Exception
58. */
59. public static byte[] decrypt(byte[] data, byte[] key) throws Exception {
60. // 还原密钥
61. Key k = toKey(key);
62. // 实例化
63. Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
64. // 初始化，设置为解密模式
65. cipher.init(Cipher.DECRYPT_MODE, k);
66. // 执行操作
67. return cipher.doFinal(data);
68. }
69. /**
70. * 加密
71. *
72. * @param data
73. *            待加密数据
74. * @param key
75. *            密钥
76. * @return byte[] 加密数据
77. * @throws Exception
78. */
79. public static byte[] encrypt(byte[] data, byte[] key) throws Exception {
80. // 还原密钥
81. Key k = toKey(key);
82. // 实例化
83. Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
84. // 初始化，设置为加密模式
85. cipher.init(Cipher.ENCRYPT_MODE, k);
86. // 执行操作
87. return cipher.doFinal(data);
88. }
89. /**
90. * 生成密钥 <br>
91. * Java 6 只支持56bit密钥 <br>
92. * Bouncy Castle 支持64bit密钥 <br>
93. *
94. * @return byte[] 二进制密钥
95. * @throws Exception
96. */
97. public static byte[] initKey() throws Exception {
98. /*
99. * 实例化密钥生成器
100. *
101. * 若要使用64bit密钥注意替换 将下述代码中的KeyGenerator.getInstance(CIPHER_ALGORITHM);
102. * 替换为KeyGenerator.getInstance(CIPHER_ALGORITHM, "BC");
103. */
104. KeyGenerator kg = KeyGenerator.getInstance(KEY_ALGORITHM);
105. /*
106. * 初始化密钥生成器 若要使用64bit密钥注意替换 将下述代码kg.init(56); 替换为kg.init(64);
107. */
108. kg.init(56, new SecureRandom());
109. // 生成秘密密钥
110. SecretKey secretKey = kg.generateKey();
111. // 获得密钥的二进制编码形式
112. return secretKey.getEncoded();
113. }
114. public static byte[] initKey(String seed) throws Exception {
115. KeyGenerator kg = KeyGenerator.getInstance(KEY_ALGORITHM);
116. SecureRandom secureRandom = new SecureRandom(new Base64().decode(seed));
117. kg.init(secureRandom);
118. SecretKey secretKey = kg.generateKey();
119. return secretKey.getEncoded();
120. }
121. }

import java.security.Key;
import java.security.SecureRandom;
import java.security.Security;

import javax.crypto.Cipher;

import javax.crypto.KeyGenerator;

import javax.crypto.SecretKey;

import javax.crypto.SecretKeyFactory;

import javax.crypto.spec.DESKeySpec;

import org.apache.commons.codec.binary.Base64;

import org.bouncycastle.jce.provider.BouncyCastleProvider;

/**

• DES安全编码组件
• @author wbw
• @version 1.0
  
  /
  
  public abstract class DESUtil {
  
  static{
  
  Security.insertProviderAt(new BouncyCastleProvider(), 1);
  
  }
  
  /*
  • 密钥算法 <br>
  • Java 6 只支持56bit密钥 <br>
  • Bouncy Castle 支持64bit密钥
    
    */
    
    public static final String KEY_ALGORITHM = "DES";
  /**
  • 加密/解密算法 / 工作模式 / 填充方式
    
    */
    
    public static final String CIPHER_ALGORITHM = "DES/ECB/PKCS5PADDING";
  /**
  • 转换密钥
  • @param key

  •        二进制密钥
    

  • @return Key 密钥

  • @throws Exception
    
    */
    
    private static Key toKey(byte[] key) throws Exception {

    // 实例化DES密钥材料
    
    DESKeySpec dks = new DESKeySpec(key);

    // 实例化秘密密钥工厂
    
    SecretKeyFactory keyFactory = SecretKeyFactory
    
    .getInstance(KEY_ALGORITHM);

    // 生成秘密密钥
    
    SecretKey secretKey = keyFactory.generateSecret(dks);

    return secretKey;
    
    }

  /**

  • 解密

  • @param data

  •        待解密数据
    

  • @param key

  •        密钥
    

  • @return byte[] 解密数据

  • @throws Exception
    
    */
    
    public static byte[] decrypt(byte[] data, byte[] key) throws Exception {

    // 还原密钥
    
    Key k = toKey(key);

    // 实例化
    
    Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);

    // 初始化，设置为解密模式
    
    cipher.init(Cipher.DECRYPT_MODE, k);

    // 执行操作
    
    return cipher.doFinal(data);
    
    }

  /**

  • 加密

  • @param data

  •        待加密数据
    

  • @param key

  •        密钥
    

  • @return byte[] 加密数据

  • @throws Exception
    
    */
    
    public static byte[] encrypt(byte[] data, byte[] key) throws Exception {

    // 还原密钥
    
    Key k = toKey(key);

    // 实例化
    
    Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);

    // 初始化，设置为加密模式
    
    cipher.init(Cipher.ENCRYPT_MODE, k);

    // 执行操作
    
    return cipher.doFinal(data);
    
    }

  /**

  • 生成密钥 <br>

  • Java 6 只支持56bit密钥 <br>

  • Bouncy Castle 支持64bit密钥 <br>

  • @return byte[] 二进制密钥

  • @throws Exception
    
    */
    
    public static byte[] initKey() throws Exception {

    /*

    • 实例化密钥生成器
    • 若要使用64bit密钥注意替换 将下述代码中的KeyGenerator.getInstance(CIPHER_ALGORITHM);
    • 替换为KeyGenerator.getInstance(CIPHER_ALGORITHM, "BC");
      
      */
      
      KeyGenerator kg = KeyGenerator.getInstance(KEY_ALGORITHM);

    /*

    • 初始化密钥生成器 若要使用64bit密钥注意替换 将下述代码kg.init(56); 替换为kg.init(64);
      
      */
      
      kg.init(56, new SecureRandom());

    // 生成秘密密钥
    
    SecretKey secretKey = kg.generateKey();

    // 获得密钥的二进制编码形式
    
    return secretKey.getEncoded();
    
    }

  public static byte[] initKey(String seed) throws Exception {
  
  KeyGenerator kg = KeyGenerator.getInstance(KEY_ALGORITHM);
  
  SecureRandom secureRandom = new SecureRandom(new Base64().decode(seed));
  
  kg.init(secureRandom);
  
  SecretKey secretKey = kg.generateKey();
  
  return secretKey.getEncoded();
  
  }
  
  }
  

  RSA加密：

1. import java.io.ByteArrayOutputStream;
2. import java.security.Key;
3. import java.security.KeyFactory;
4. import java.security.KeyPair;
5. import java.security.KeyPairGenerator;
6. import java.security.PrivateKey;
7. import java.security.PublicKey;
8. import java.security.SecureRandom;
9. import java.security.Security;
10. import java.security.interfaces.RSAPrivateKey;
11. import java.security.interfaces.RSAPublicKey;
12. import java.security.spec.PKCS8EncodedKeySpec;
13. import java.security.spec.X509EncodedKeySpec;
14. import java.util.HashMap;
15. import java.util.Map;
16. import java.util.UUID;
17. import javax.crypto.Cipher;
18. import org.bouncycastle.jce.provider.BouncyCastleProvider;
19. import org.bouncycastle.util.encoders.Base64;
20. /**
21. * RSA安全编码组件
22. *
23. * @author wbw
24. * @version 1.0
25. */
26. public class RSAUtil {
27. /**
28. * 非对称加密密钥算法
29. */
30. public static final String KEY_ALGORITHM_RSA = "RSA";
31. /**
32. * 公钥
33. */
34. private static final String RSA_PUBLIC_KEY = "RSAPublicKey";
35. /**
36. * 私钥
37. */
38. private static final String RSA_PRIVATE_KEY = "RSAPrivateKey";
39. /**
40. * RSA密钥长度
41. * 默认1024位，
42. * 密钥长度必须是64的倍数，
43. * 范围在512至65536位之间。
44. */
45. private static final int KEY_SIZE = 1024;
46. static{
47. Security.insertProviderAt(new BouncyCastleProvider(), 1);
48. }
49. /**
50. * 私钥解密
51. *
52. * @param data
53. *            待解密数据
54. * @param key
55. *            私钥
56. * @return byte[] 解密数据
57. * @throws Exception
58. */
59. public static byte[] decryptByPrivateKey(byte[] data, byte[] key)
60. throws Exception {
61. // 取得私钥
62. PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
63. KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_RSA);
64. // 生成私钥
65. PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
66. // 对数据解密
67. Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
68. cipher.init(Cipher.DECRYPT_MODE, privateKey);
69. int blockSize = cipher.getBlockSize();
70. if(blockSize>0){
71. ByteArrayOutputStream bout = new ByteArrayOutputStream(64);
72. int j = 0;
73. while (data.length - j * blockSize > 0) {
74. bout.write(cipher.doFinal(data, j * blockSize, blockSize));
75. j++;
76. }
77. return bout.toByteArray();
78. }
79. return cipher.doFinal(data);
80. }
81. /**
82. * 公钥解密
83. *
84. * @param data
85. *            待解密数据
86. * @param key
87. *            公钥
88. * @return byte[] 解密数据
89. * @throws Exception
90. */
91. public static byte[] decryptByPublicKey(byte[] data, byte[] key)
92. throws Exception {
93. // 取得公钥
94. X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
95. KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_RSA);
96. // 生成公钥
97. PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
98. // 对数据解密
99. Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
100. cipher.init(Cipher.DECRYPT_MODE, publicKey);
101. return cipher.doFinal(data);
102. }
103. /**
104. * 公钥加密
105. *
106. * @param data
107. *            待加密数据
108. * @param key
109. *            公钥
110. * @return byte[] 加密数据
111. * @throws Exception
112. */
113. public static byte[] encryptByPublicKey(byte[] data, byte[] key)
114. throws Exception {
115. // 取得公钥
116. X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
117. KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_RSA);
118. PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
119. // 对数据加密
120. Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
121. cipher.init(Cipher.ENCRYPT_MODE, publicKey);
122. int blockSize = cipher.getBlockSize();
123. if(blockSize>0){
124. int outputSize = cipher.getOutputSize(data.length);
125. int leavedSize = data.length % blockSize;
126. int blocksSize = leavedSize != 0 ? data.length / blockSize + 1
127. : data.length / blockSize;
128. byte[] raw = new byte[outputSize * blocksSize];
129. int i = 0,remainSize=0;
130. while ((remainSize = data.length - i * blockSize) > 0) {
131. int inputLen = remainSize > blockSize?blockSize:remainSize;
132. cipher.doFinal(data, i * blockSize, inputLen, raw, i * outputSize);
133. i++;
134. }
135. return raw;
136. }
137. return cipher.doFinal(data);
138. }
139. /**
140. * 私钥加密
141. *
142. * @param data
143. *            待加密数据
144. * @param key
145. *            私钥
146. * @return byte[] 加密数据
147. * @throws Exception
148. */
149. public static byte[] encryptByPrivateKey(byte[] data, byte[] key)
150. throws Exception {
151. // 取得私钥
152. PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
153. KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_RSA);
154. // 生成私钥
155. PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
156. // 对数据加密
157. Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
158. cipher.init(Cipher.ENCRYPT_MODE, privateKey);
159. int blockSize = cipher.getBlockSize();
160. if(blockSize>0){
161. int outputSize = cipher.getOutputSize(data.length);
162. int leavedSize = data.length % blockSize;
163. int blocksSize = leavedSize != 0 ? data.length / blockSize + 1
164. : data.length / blockSize;
165. byte[] raw = new byte[outputSize * blocksSize];
166. int i = 0,remainSize=0;
167. while ((remainSize = data.length - i * blockSize) > 0) {
168. int inputLen = remainSize > blockSize?blockSize:remainSize;
169. cipher.doFinal(data, i * blockSize, inputLen, raw, i * outputSize);
170. i++;
171. }
172. return raw;
173. }
174. return cipher.doFinal(data);
175. }
176. /**
177. * 取得私钥
178. *
179. * @param keyMap
180. *            密钥Map
181. * @return key 私钥
182. * @throws Exception
183. */
184. public static Key getPrivateKey(Map<String, Key> keyMap)
185. throws Exception {
186. return keyMap.get(RSA_PRIVATE_KEY);
187. }
188. /**
189. * 取得私钥
190. *
191. * @param keyMap
192. *            密钥Map
193. * @return byte[] 私钥
194. * @throws Exception
195. */
196. public static byte[] getPrivateKeyByte(Map<String, Key> keyMap)
197. throws Exception {
198. return keyMap.get(RSA_PRIVATE_KEY).getEncoded();
199. }
200. /**
201. * 取得公钥
202. *
203. * @param keyMap
204. *            密钥Map
205. * @return key 公钥
206. * @throws Exception
207. */
208. public static Key getPublicKey(Map<String, Key> keyMap)
209. throws Exception {
210. return keyMap.get(RSA_PUBLIC_KEY);
211. }
212. /**
213. * 取得公钥
214. *
215. * @param keyMap
216. *            密钥Map
217. * @return byte[] 公钥
218. * @throws Exception
219. */
220. public static byte[] getPublicKeyByte(Map<String, Key> keyMap)
221. throws Exception {
222. return keyMap.get(RSA_PUBLIC_KEY).getEncoded();
223. }
224. /**
225. * 初始化密钥
226. * @param byte[] seed 种子
227. * @return Map 密钥Map
228. * @throws Exception
229. */
230. public static Map<String,Key> initKey(byte[] seed)throws Exception{
231. // 实例化密钥对生成器
232. KeyPairGenerator keyPairGen = KeyPairGenerator
233. .getInstance(KEY_ALGORITHM_RSA);
234. // 初始化密钥对生成器
235. keyPairGen.initialize(KEY_SIZE, new SecureRandom(seed) );
236. // 生成密钥对
237. KeyPair keyPair = keyPairGen.generateKeyPair();
238. // 公钥
239. RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
240. // 私钥
241. RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
242. // 封装密钥
243. Map<String, Key> keyMap = new HashMap<String, Key>(2);
244. keyMap.put(RSA_PUBLIC_KEY, publicKey);
245. keyMap.put(RSA_PRIVATE_KEY, privateKey);
246. return keyMap;
247. }
248. /**
249. * 初始化密钥
250. * @param seed 种子
251. * @return Map 密钥Map
252. * @throws Exception
253. */
254. public static Map<String,Key> initKey(String seed)throws Exception{
255. return initKey(seed.getBytes());
256. }
257. /**
258. * 初始化密钥
259. *
260. * @return Map 密钥Map
261. * @throws Exception
262. */
263. public static Map<String, Key> initKey() throws Exception {
264. return initKey(UUID.randomUUID().toString().getBytes());
265. }
266. public static PublicKey getPublicRSAKey(String key) throws Exception {
267. X509EncodedKeySpec x509 = new X509EncodedKeySpec(Base64.decode(key));
268. KeyFactory kf = KeyFactory.getInstance(KEY_ALGORITHM_RSA);
269. return kf.generatePublic(x509);
270. }
271. public static PrivateKey getPrivateRSAKey(String key) throws Exception {
272. PKCS8EncodedKeySpec pkgs8 = new PKCS8EncodedKeySpec(Base64.decode(key));
273. KeyFactory kf = KeyFactory.getInstance(KEY_ALGORITHM_RSA);
274. return kf.generatePrivate(pkgs8);
275. }
276. }

import java.io.ByteArrayOutputStream;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Security;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

import javax.crypto.Cipher;

import org.bouncycastle.jce.provider.BouncyCastleProvider;

import org.bouncycastle.util.encoders.Base64;

/**

• RSA安全编码组件
• @author wbw
• @version 1.0
  
  /
  
  public class RSAUtil {
  
  /*
  • 非对称加密密钥算法
    
    */
    
    public static final String KEY_ALGORITHM_RSA = "RSA";
  /**
  • 公钥
    
    */
    
    private static final String RSA_PUBLIC_KEY = "RSAPublicKey";
  /**
  • 私钥
    
    */
    
    private static final String RSA_PRIVATE_KEY = "RSAPrivateKey";
  /**
  • RSA密钥长度
  • 默认1024位，
  • 密钥长度必须是64的倍数，
  • 范围在512至65536位之间。
    
    */
    
    private static final int KEY_SIZE = 1024;
  static{
  
  Security.insertProviderAt(new BouncyCastleProvider(), 1);
  
  }
  
  /**
  • 私钥解密
  • @param data

  •        待解密数据
    

  • @param key

  •        私钥
    

  • @return byte[] 解密数据

  • @throws Exception
    
    */
    
    public static byte[] decryptByPrivateKey(byte[] data, byte[] key)
    
    throws Exception {

    // 取得私钥
    
    PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);

    KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_RSA);

    // 生成私钥
    
    PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);

    // 对数据解密
    
    Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

    cipher.init(Cipher.DECRYPT_MODE, privateKey);

    int blockSize = cipher.getBlockSize();
    
    if(blockSize>0){
    
    ByteArrayOutputStream bout = new ByteArrayOutputStream(64);
    
    int j = 0;
    
    while (data.length - j * blockSize > 0) {
    
    bout.write(cipher.doFinal(data, j * blockSize, blockSize));
    
    j++;
    
    }
    
    return bout.toByteArray();
    
    }
    
    return cipher.doFinal(data);
    
    }

  /**

  • 公钥解密

  • @param data

  •        待解密数据
    

  • @param key

  •        公钥
    

  • @return byte[] 解密数据

  • @throws Exception
    
    */
    
    public static byte[] decryptByPublicKey(byte[] data, byte[] key)
    
    throws Exception {

    // 取得公钥
    
    X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);

    KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_RSA);

    // 生成公钥
    
    PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);

    // 对数据解密
    
    Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

    cipher.init(Cipher.DECRYPT_MODE, publicKey);

    return cipher.doFinal(data);
    
    }

  /**

  • 公钥加密

  • @param data

  •        待加密数据
    

  • @param key

  •        公钥
    

  • @return byte[] 加密数据

  • @throws Exception
    
    */
    
    public static byte[] encryptByPublicKey(byte[] data, byte[] key)
    
    throws Exception {

    // 取得公钥
    
    X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);

    KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_RSA);

    PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);

    // 对数据加密
    
    Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

    cipher.init(Cipher.ENCRYPT_MODE, publicKey);

    int blockSize = cipher.getBlockSize();
    
    if(blockSize>0){
    
    int outputSize = cipher.getOutputSize(data.length);
    
    int leavedSize = data.length % blockSize;
    
    int blocksSize = leavedSize != 0 ? data.length / blockSize + 1
    
    : data.length / blockSize;
    
    byte[] raw = new byte[outputSize * blocksSize];
    
    int i = 0,remainSize=0;
    
    while ((remainSize = data.length - i * blockSize) > 0) {
    
    int inputLen = remainSize > blockSize?blockSize:remainSize;
    
    cipher.doFinal(data, i * blockSize, inputLen, raw, i * outputSize);
    
    i++;
    
    }
    
    return raw;
    
    }
    
    return cipher.doFinal(data);
    
    }

  /**

  • 私钥加密

  • @param data

  •        待加密数据
    

  • @param key

  •        私钥
    

  • @return byte[] 加密数据

  • @throws Exception
    
    */
    
    public static byte[] encryptByPrivateKey(byte[] data, byte[] key)
    
    throws Exception {

    // 取得私钥
    
    PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);

    KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_RSA);

    // 生成私钥
    
    PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);

    // 对数据加密
    
    Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

    cipher.init(Cipher.ENCRYPT_MODE, privateKey);

    int blockSize = cipher.getBlockSize();
    
    if(blockSize>0){
    
    int outputSize = cipher.getOutputSize(data.length);
    
    int leavedSize = data.length % blockSize;
    
    int blocksSize = leavedSize != 0 ? data.length / blockSize + 1
    
    : data.length / blockSize;
    
    byte[] raw = new byte[outputSize * blocksSize];
    
    int i = 0,remainSize=0;
    
    while ((remainSize = data.length - i * blockSize) > 0) {
    
    int inputLen = remainSize > blockSize?blockSize:remainSize;
    
    cipher.doFinal(data, i * blockSize, inputLen, raw, i * outputSize);
    
    i++;
    
    }
    
    return raw;
    
    }
    
    return cipher.doFinal(data);
    
    }

  /**

  • 取得私钥
  • @param keyMap

  •        密钥Map
    

  • @return key 私钥
  • @throws Exception
    
    */
    
    public static Key getPrivateKey(Map<String, Key> keyMap)
    
    throws Exception {
    
    return keyMap.get(RSA_PRIVATE_KEY);
    
    }

  /**

  • 取得私钥
  • @param keyMap

  •        密钥Map
    

  • @return byte[] 私钥
  • @throws Exception
    
    */
    
    public static byte[] getPrivateKeyByte(Map<String, Key> keyMap)
    
    throws Exception {
    
    return keyMap.get(RSA_PRIVATE_KEY).getEncoded();
    
    }

  /**

  • 取得公钥
  • @param keyMap

  •        密钥Map
    

  • @return key 公钥
  • @throws Exception
    
    */
    
    public static Key getPublicKey(Map<String, Key> keyMap)
    
    throws Exception {
    
    return keyMap.get(RSA_PUBLIC_KEY);
    
    }

  /**

  • 取得公钥
  • @param keyMap

  •        密钥Map
    

  • @return byte[] 公钥
  • @throws Exception
    
    */
    
    public static byte[] getPublicKeyByte(Map<String, Key> keyMap)
    
    throws Exception {
    
    return keyMap.get(RSA_PUBLIC_KEY).getEncoded();
    
    }

  /**

  • 初始化密钥

  • @param byte[] seed 种子

  • @return Map 密钥Map

  • @throws Exception
    
    */
    
    public static Map<String,Key> initKey(byte[] seed)throws Exception{
    
    // 实例化密钥对生成器
    
    KeyPairGenerator keyPairGen = KeyPairGenerator
    
    .getInstance(KEY_ALGORITHM_RSA);

    // 初始化密钥对生成器
    
    keyPairGen.initialize(KEY_SIZE, new SecureRandom(seed) );

    // 生成密钥对
    
    KeyPair keyPair = keyPairGen.generateKeyPair();

    // 公钥
    
    RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();

    // 私钥
    
    RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

    // 封装密钥
    
    Map<String, Key> keyMap = new HashMap<String, Key>(2);

    keyMap.put(RSA_PUBLIC_KEY, publicKey);
    
    keyMap.put(RSA_PRIVATE_KEY, privateKey);

    return keyMap;
    
    }

  /**

  • 初始化密钥
  • @param seed 种子
  • @return Map 密钥Map
  • @throws Exception
    
    */
    
    public static Map<String,Key> initKey(String seed)throws Exception{
    
    return initKey(seed.getBytes());
    
    }

  /**

  • 初始化密钥
  • @return Map 密钥Map
  • @throws Exception
    
    */
    
    public static Map<String, Key> initKey() throws Exception {
    
    return initKey(UUID.randomUUID().toString().getBytes());
    
    }

  public static PublicKey getPublicRSAKey(String key) throws Exception {
  
  X509EncodedKeySpec x509 = new X509EncodedKeySpec(Base64.decode(key));
  
  KeyFactory kf = KeyFactory.getInstance(KEY_ALGORITHM_RSA);
  
  return kf.generatePublic(x509);
  
  }

  public static PrivateKey getPrivateRSAKey(String key) throws Exception {
  
  PKCS8EncodedKeySpec pkgs8 = new PKCS8EncodedKeySpec(Base64.decode(key));
  
  KeyFactory kf = KeyFactory.getInstance(KEY_ALGORITHM_RSA);
  
  return kf.generatePrivate(pkgs8);
  
  }

}