Java使用RSA加密解密签名及校验

淡淡的烟草味﹌ 2022-06-09 12:55 278阅读 0赞

由于项目要用到非对称加密解密签名校验什么的，于是参考《Java加密解密的艺术》写一个RSA进行加密解密签名及校验的Demo，代码很简单，特此分享！

RSA加密解密类：

**\[java\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  package com.ihep;  
2.    
3.  import java.io.BufferedReader;  
4.  import java.io.BufferedWriter;  
5.  import java.io.FileReader;  
6.  import java.io.FileWriter;  
7.  import java.io.IOException;  
8.  import java.security.InvalidKeyException;  
9.  import java.security.KeyFactory;  
10. import java.security.KeyPair;  
11. import java.security.KeyPairGenerator;  
12. import java.security.NoSuchAlgorithmException;  
13. import java.security.SecureRandom;  
14.   
15. import java.security.interfaces.RSAPrivateKey;  
16. import java.security.interfaces.RSAPublicKey;  
17. import java.security.spec.InvalidKeySpecException;  
18. import java.security.spec.PKCS8EncodedKeySpec;  
19. import java.security.spec.X509EncodedKeySpec;  
20.   
21. import javax.crypto.BadPaddingException;  
22. import javax.crypto.Cipher;  
23. import javax.crypto.IllegalBlockSizeException;  
24. import javax.crypto.NoSuchPaddingException;  
25.   
26. import com.fcplay.Base64;  
27.   
28. public class RSAEncrypt \{  
29.     /\*\* 
30.      \* 字节数据转字符串专用集合 
31.      \*/  
32.     private static final char\[\] HEX\_CHAR = \{ '0', '1', '2', '3', '4', '5', '6',  
33.             '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' \};  
34.   
35.     /\*\* 
36.      \* 随机生成密钥对 
37.      \*/  
38.     public static void genKeyPair(String filePath) \{  
39.         // KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象  
40.         KeyPairGenerator keyPairGen = null;  
41.         try \{  
42.             keyPairGen = KeyPairGenerator.getInstance("RSA");  
43.         \} catch (NoSuchAlgorithmException e) \{  
44.             // TODO Auto-generated catch block  
45.             e.printStackTrace();  
46.         \}  
47.         // 初始化密钥对生成器，密钥大小为96-1024位  
48.         keyPairGen.initialize(1024,new SecureRandom());  
49.         // 生成一个密钥对，保存在keyPair中  
50.         KeyPair keyPair = keyPairGen.generateKeyPair();  
51.         // 得到私钥  
52.         RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();  
53.         // 得到公钥  
54.         RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();  
55.         try \{  
56.             // 得到公钥字符串  
57.             String publicKeyString = Base64.encode(publicKey.getEncoded());  
58.             // 得到私钥字符串  
59.             String privateKeyString = Base64.encode(privateKey.getEncoded());  
60.             // 将密钥对写入到文件  
61.             FileWriter pubfw = new FileWriter(filePath + "/publicKey.keystore");  
62.             FileWriter prifw = new FileWriter(filePath + "/privateKey.keystore");  
63.             BufferedWriter pubbw = new BufferedWriter(pubfw);  
64.             BufferedWriter pribw = new BufferedWriter(prifw);  
65.             pubbw.write(publicKeyString);  
66.             pribw.write(privateKeyString);  
67.             pubbw.flush();  
68.             pubbw.close();  
69.             pubfw.close();  
70.             pribw.flush();  
71.             pribw.close();  
72.             prifw.close();  
73.         \} catch (Exception e) \{  
74.             e.printStackTrace();  
75.         \}  
76.     \}  
77.   
78.     /\*\* 
79.      \* 从文件中输入流中加载公钥 
80.      \*  
81.      \* @param in 
82.      \*            公钥输入流 
83.      \* @throws Exception 
84.      \*             加载公钥时产生的异常 
85.      \*/  
86.     public static String loadPublicKeyByFile(String path) throws Exception \{  
87.         try \{  
88.             BufferedReader br = new BufferedReader(new FileReader(path  
89.                     + "/publicKey.keystore"));  
90.             String readLine = null;  
91.             StringBuilder sb = new StringBuilder();  
92.             while ((readLine = br.readLine()) != null) \{  
93.                 sb.append(readLine);  
94.             \}  
95.             br.close();  
96.             return sb.toString();  
97.         \} catch (IOException e) \{  
98.             throw new Exception("公钥数据流读取错误");  
99.         \} catch (NullPointerException e) \{  
100.             throw new Exception("公钥输入流为空");  
101.         \}  
102.     \}  
103.   
104.     /\*\* 
105.      \* 从字符串中加载公钥 
106.      \*  
107.      \* @param publicKeyStr 
108.      \*            公钥数据字符串 
109.      \* @throws Exception 
110.      \*             加载公钥时产生的异常 
111.      \*/  
112.     public static RSAPublicKey loadPublicKeyByStr(String publicKeyStr)  
113.             throws Exception \{  
114.         try \{  
115.             byte\[\] buffer = Base64.decode(publicKeyStr);  
116.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
117.             X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);  
118.             return (RSAPublicKey) keyFactory.generatePublic(keySpec);  
119.         \} catch (NoSuchAlgorithmException e) \{  
120.             throw new Exception("无此算法");  
121.         \} catch (InvalidKeySpecException e) \{  
122.             throw new Exception("公钥非法");  
123.         \} catch (NullPointerException e) \{  
124.             throw new Exception("公钥数据为空");  
125.         \}  
126.     \}  
127.   
128.     /\*\* 
129.      \* 从文件中加载私钥 
130.      \*  
131.      \* @param keyFileName 
132.      \*            私钥文件名 
133.      \* @return 是否成功 
134.      \* @throws Exception 
135.      \*/  
136.     public static String loadPrivateKeyByFile(String path) throws Exception \{  
137.         try \{  
138.             BufferedReader br = new BufferedReader(new FileReader(path  
139.                     + "/privateKey.keystore"));  
140.             String readLine = null;  
141.             StringBuilder sb = new StringBuilder();  
142.             while ((readLine = br.readLine()) != null) \{  
143.                 sb.append(readLine);  
144.             \}  
145.             br.close();  
146.             return sb.toString();  
147.         \} catch (IOException e) \{  
148.             throw new Exception("私钥数据读取错误");  
149.         \} catch (NullPointerException e) \{  
150.             throw new Exception("私钥输入流为空");  
151.         \}  
152.     \}  
153.   
154.     public static RSAPrivateKey loadPrivateKeyByStr(String privateKeyStr)  
155.             throws Exception \{  
156.         try \{  
157.             byte\[\] buffer = Base64.decode(privateKeyStr);  
158.             PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);  
159.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
160.             return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);  
161.         \} catch (NoSuchAlgorithmException e) \{  
162.             throw new Exception("无此算法");  
163.         \} catch (InvalidKeySpecException e) \{  
164.             throw new Exception("私钥非法");  
165.         \} catch (NullPointerException e) \{  
166.             throw new Exception("私钥数据为空");  
167.         \}  
168.     \}  
169.   
170.     /\*\* 
171.      \* 公钥加密过程 
172.      \*  
173.      \* @param publicKey 
174.      \*            公钥 
175.      \* @param plainTextData 
176.      \*            明文数据 
177.      \* @return 
178.      \* @throws Exception 
179.      \*             加密过程中的异常信息 
180.      \*/  
181.     public static byte\[\] encrypt(RSAPublicKey publicKey, byte\[\] plainTextData)  
182.             throws Exception \{  
183.         if (publicKey == null) \{  
184.             throw new Exception("加密公钥为空, 请设置");  
185.         \}  
186.         Cipher cipher = null;  
187.         try \{  
188.             // 使用默认RSA  
189.             cipher = Cipher.getInstance("RSA");  
190.             // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());  
191.             cipher.init(Cipher.ENCRYPT\_MODE, publicKey);  
192.             byte\[\] output = cipher.doFinal(plainTextData);  
193.             return output;  
194.         \} catch (NoSuchAlgorithmException e) \{  
195.             throw new Exception("无此加密算法");  
196.         \} catch (NoSuchPaddingException e) \{  
197.             e.printStackTrace();  
198.             return null;  
199.         \} catch (InvalidKeyException e) \{  
200.             throw new Exception("加密公钥非法,请检查");  
201.         \} catch (IllegalBlockSizeException e) \{  
202.             throw new Exception("明文长度非法");  
203.         \} catch (BadPaddingException e) \{  
204.             throw new Exception("明文数据已损坏");  
205.         \}  
206.     \}  
207.   
208.     /\*\* 
209.      \* 私钥加密过程 
210.      \*  
211.      \* @param privateKey 
212.      \*            私钥 
213.      \* @param plainTextData 
214.      \*            明文数据 
215.      \* @return 
216.      \* @throws Exception 
217.      \*             加密过程中的异常信息 
218.      \*/  
219.     public static byte\[\] encrypt(RSAPrivateKey privateKey, byte\[\] plainTextData)  
220.             throws Exception \{  
221.         if (privateKey == null) \{  
222.             throw new Exception("加密私钥为空, 请设置");  
223.         \}  
224.         Cipher cipher = null;  
225.         try \{  
226.             // 使用默认RSA  
227.             cipher = Cipher.getInstance("RSA");  
228.             cipher.init(Cipher.ENCRYPT\_MODE, privateKey);  
229.             byte\[\] output = cipher.doFinal(plainTextData);  
230.             return output;  
231.         \} catch (NoSuchAlgorithmException e) \{  
232.             throw new Exception("无此加密算法");  
233.         \} catch (NoSuchPaddingException e) \{  
234.             e.printStackTrace();  
235.             return null;  
236.         \} catch (InvalidKeyException e) \{  
237.             throw new Exception("加密私钥非法,请检查");  
238.         \} catch (IllegalBlockSizeException e) \{  
239.             throw new Exception("明文长度非法");  
240.         \} catch (BadPaddingException e) \{  
241.             throw new Exception("明文数据已损坏");  
242.         \}  
243.     \}  
244.   
245.     /\*\* 
246.      \* 私钥解密过程 
247.      \*  
248.      \* @param privateKey 
249.      \*            私钥 
250.      \* @param cipherData 
251.      \*            密文数据 
252.      \* @return 明文 
253.      \* @throws Exception 
254.      \*             解密过程中的异常信息 
255.      \*/  
256.     public static byte\[\] decrypt(RSAPrivateKey privateKey, byte\[\] cipherData)  
257.             throws Exception \{  
258.         if (privateKey == null) \{  
259.             throw new Exception("解密私钥为空, 请设置");  
260.         \}  
261.         Cipher cipher = null;  
262.         try \{  
263.             // 使用默认RSA  
264.             cipher = Cipher.getInstance("RSA");  
265.             // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());  
266.             cipher.init(Cipher.DECRYPT\_MODE, privateKey);  
267.             byte\[\] output = cipher.doFinal(cipherData);  
268.             return output;  
269.         \} catch (NoSuchAlgorithmException e) \{  
270.             throw new Exception("无此解密算法");  
271.         \} catch (NoSuchPaddingException e) \{  
272.             e.printStackTrace();  
273.             return null;  
274.         \} catch (InvalidKeyException e) \{  
275.             throw new Exception("解密私钥非法,请检查");  
276.         \} catch (IllegalBlockSizeException e) \{  
277.             throw new Exception("密文长度非法");  
278.         \} catch (BadPaddingException e) \{  
279.             throw new Exception("密文数据已损坏");  
280.         \}  
281.     \}  
282.   
283.     /\*\* 
284.      \* 公钥解密过程 
285.      \*  
286.      \* @param publicKey 
287.      \*            公钥 
288.      \* @param cipherData 
289.      \*            密文数据 
290.      \* @return 明文 
291.      \* @throws Exception 
292.      \*             解密过程中的异常信息 
293.      \*/  
294.     public static byte\[\] decrypt(RSAPublicKey publicKey, byte\[\] cipherData)  
295.             throws Exception \{  
296.         if (publicKey == null) \{  
297.             throw new Exception("解密公钥为空, 请设置");  
298.         \}  
299.         Cipher cipher = null;  
300.         try \{  
301.             // 使用默认RSA  
302.             cipher = Cipher.getInstance("RSA");  
303.             // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());  
304.             cipher.init(Cipher.DECRYPT\_MODE, publicKey);  
305.             byte\[\] output = cipher.doFinal(cipherData);  
306.             return output;  
307.         \} catch (NoSuchAlgorithmException e) \{  
308.             throw new Exception("无此解密算法");  
309.         \} catch (NoSuchPaddingException e) \{  
310.             e.printStackTrace();  
311.             return null;  
312.         \} catch (InvalidKeyException e) \{  
313.             throw new Exception("解密公钥非法,请检查");  
314.         \} catch (IllegalBlockSizeException e) \{  
315.             throw new Exception("密文长度非法");  
316.         \} catch (BadPaddingException e) \{  
317.             throw new Exception("密文数据已损坏");  
318.         \}  
319.     \}  
320.   
321.     /\*\* 
322.      \* 字节数据转十六进制字符串 
323.      \*  
324.      \* @param data 
325.      \*            输入数据 
326.      \* @return 十六进制内容 
327.      \*/  
328.     public static String byteArrayToString(byte\[\] data) \{  
329.         StringBuilder stringBuilder = new StringBuilder();  
330.         for (int i = 0; i < data.length; i++) \{  
331.             // 取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移  
332.             stringBuilder.append(HEX\_CHAR\[(data\[i\] & 0xf0) >>> 4\]);  
333.             // 取出字节的低四位 作为索引得到相应的十六进制标识符  
334.             stringBuilder.append(HEX\_CHAR\[(data\[i\] & 0x0f)\]);  
335.             if (i < data.length - 1) \{  
336.                 stringBuilder.append(' ');  
337.             \}  
338.         \}  
339.         return stringBuilder.toString();  
340.     \}  
341. \}

package com.ihep;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.security.InvalidKeyException;
    import java.security.KeyFactory;
    import java.security.KeyPair;
    import java.security.KeyPairGenerator;
    import java.security.NoSuchAlgorithmException;
    import java.security.SecureRandom;
    
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
    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.NoSuchPaddingException;
    
    import com.fcplay.Base64;
    
    public class RSAEncrypt {
    	/**
    	 * 字节数据转字符串专用集合
    	 */
    	private static final char[] HEX_CHAR = { '0', '1', '2', '3', '4', '5', '6',
    			'7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
    
    	/**
    	 * 随机生成密钥对
    	 */
    	public static void genKeyPair(String filePath) {
    		// KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象
    		KeyPairGenerator keyPairGen = null;
    		try {
    			keyPairGen = KeyPairGenerator.getInstance("RSA");
    		} catch (NoSuchAlgorithmException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		// 初始化密钥对生成器，密钥大小为96-1024位
    		keyPairGen.initialize(1024,new SecureRandom());
    		// 生成一个密钥对，保存在keyPair中
    		KeyPair keyPair = keyPairGen.generateKeyPair();
    		// 得到私钥
    		RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
    		// 得到公钥
    		RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
    		try {
    			// 得到公钥字符串
    			String publicKeyString = Base64.encode(publicKey.getEncoded());
    			// 得到私钥字符串
    			String privateKeyString = Base64.encode(privateKey.getEncoded());
    			// 将密钥对写入到文件
    			FileWriter pubfw = new FileWriter(filePath + "/publicKey.keystore");
    			FileWriter prifw = new FileWriter(filePath + "/privateKey.keystore");
    			BufferedWriter pubbw = new BufferedWriter(pubfw);
    			BufferedWriter pribw = new BufferedWriter(prifw);
    			pubbw.write(publicKeyString);
    			pribw.write(privateKeyString);
    			pubbw.flush();
    			pubbw.close();
    			pubfw.close();
    			pribw.flush();
    			pribw.close();
    			prifw.close();
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    
    	/**
    	 * 从文件中输入流中加载公钥
    	 * 
    	 * @param in
    	 *            公钥输入流
    	 * @throws Exception
    	 *             加载公钥时产生的异常
    	 */
    	public static String loadPublicKeyByFile(String path) throws Exception {
    		try {
    			BufferedReader br = new BufferedReader(new FileReader(path
    					+ "/publicKey.keystore"));
    			String readLine = null;
    			StringBuilder sb = new StringBuilder();
    			while ((readLine = br.readLine()) != null) {
    				sb.append(readLine);
    			}
    			br.close();
    			return sb.toString();
    		} catch (IOException e) {
    			throw new Exception("公钥数据流读取错误");
    		} catch (NullPointerException e) {
    			throw new Exception("公钥输入流为空");
    		}
    	}
    
    	/**
    	 * 从字符串中加载公钥
    	 * 
    	 * @param publicKeyStr
    	 *            公钥数据字符串
    	 * @throws Exception
    	 *             加载公钥时产生的异常
    	 */
    	public static RSAPublicKey loadPublicKeyByStr(String publicKeyStr)
    			throws Exception {
    		try {
    			byte[] buffer = Base64.decode(publicKeyStr);
    			KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    			X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
    			return (RSAPublicKey) keyFactory.generatePublic(keySpec);
    		} catch (NoSuchAlgorithmException e) {
    			throw new Exception("无此算法");
    		} catch (InvalidKeySpecException e) {
    			throw new Exception("公钥非法");
    		} catch (NullPointerException e) {
    			throw new Exception("公钥数据为空");
    		}
    	}
    
    	/**
    	 * 从文件中加载私钥
    	 * 
    	 * @param keyFileName
    	 *            私钥文件名
    	 * @return 是否成功
    	 * @throws Exception
    	 */
    	public static String loadPrivateKeyByFile(String path) throws Exception {
    		try {
    			BufferedReader br = new BufferedReader(new FileReader(path
    					+ "/privateKey.keystore"));
    			String readLine = null;
    			StringBuilder sb = new StringBuilder();
    			while ((readLine = br.readLine()) != null) {
    				sb.append(readLine);
    			}
    			br.close();
    			return sb.toString();
    		} catch (IOException e) {
    			throw new Exception("私钥数据读取错误");
    		} catch (NullPointerException e) {
    			throw new Exception("私钥输入流为空");
    		}
    	}
    
    	public static RSAPrivateKey loadPrivateKeyByStr(String privateKeyStr)
    			throws Exception {
    		try {
    			byte[] buffer = Base64.decode(privateKeyStr);
    			PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
    			KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    			return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
    		} catch (NoSuchAlgorithmException e) {
    			throw new Exception("无此算法");
    		} catch (InvalidKeySpecException e) {
    			throw new Exception("私钥非法");
    		} catch (NullPointerException e) {
    			throw new Exception("私钥数据为空");
    		}
    	}
    
    	/**
    	 * 公钥加密过程
    	 * 
    	 * @param publicKey
    	 *            公钥
    	 * @param plainTextData
    	 *            明文数据
    	 * @return
    	 * @throws Exception
    	 *             加密过程中的异常信息
    	 */
    	public static byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData)
    			throws Exception {
    		if (publicKey == null) {
    			throw new Exception("加密公钥为空, 请设置");
    		}
    		Cipher cipher = null;
    		try {
    			// 使用默认RSA
    			cipher = Cipher.getInstance("RSA");
    			// cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
    			cipher.init(Cipher.ENCRYPT_MODE, publicKey);
    			byte[] output = cipher.doFinal(plainTextData);
    			return output;
    		} catch (NoSuchAlgorithmException e) {
    			throw new Exception("无此加密算法");
    		} catch (NoSuchPaddingException e) {
    			e.printStackTrace();
    			return null;
    		} catch (InvalidKeyException e) {
    			throw new Exception("加密公钥非法,请检查");
    		} catch (IllegalBlockSizeException e) {
    			throw new Exception("明文长度非法");
    		} catch (BadPaddingException e) {
    			throw new Exception("明文数据已损坏");
    		}
    	}
    
    	/**
    	 * 私钥加密过程
    	 * 
    	 * @param privateKey
    	 *            私钥
    	 * @param plainTextData
    	 *            明文数据
    	 * @return
    	 * @throws Exception
    	 *             加密过程中的异常信息
    	 */
    	public static byte[] encrypt(RSAPrivateKey privateKey, byte[] plainTextData)
    			throws Exception {
    		if (privateKey == null) {
    			throw new Exception("加密私钥为空, 请设置");
    		}
    		Cipher cipher = null;
    		try {
    			// 使用默认RSA
    			cipher = Cipher.getInstance("RSA");
    			cipher.init(Cipher.ENCRYPT_MODE, privateKey);
    			byte[] output = cipher.doFinal(plainTextData);
    			return output;
    		} catch (NoSuchAlgorithmException e) {
    			throw new Exception("无此加密算法");
    		} catch (NoSuchPaddingException e) {
    			e.printStackTrace();
    			return null;
    		} catch (InvalidKeyException e) {
    			throw new Exception("加密私钥非法,请检查");
    		} catch (IllegalBlockSizeException e) {
    			throw new Exception("明文长度非法");
    		} catch (BadPaddingException e) {
    			throw new Exception("明文数据已损坏");
    		}
    	}
    
    	/**
    	 * 私钥解密过程
    	 * 
    	 * @param privateKey
    	 *            私钥
    	 * @param cipherData
    	 *            密文数据
    	 * @return 明文
    	 * @throws Exception
    	 *             解密过程中的异常信息
    	 */
    	public static byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData)
    			throws Exception {
    		if (privateKey == null) {
    			throw new Exception("解密私钥为空, 请设置");
    		}
    		Cipher cipher = null;
    		try {
    			// 使用默认RSA
    			cipher = Cipher.getInstance("RSA");
    			// cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
    			cipher.init(Cipher.DECRYPT_MODE, privateKey);
    			byte[] output = cipher.doFinal(cipherData);
    			return output;
    		} catch (NoSuchAlgorithmException e) {
    			throw new Exception("无此解密算法");
    		} catch (NoSuchPaddingException e) {
    			e.printStackTrace();
    			return null;
    		} catch (InvalidKeyException e) {
    			throw new Exception("解密私钥非法,请检查");
    		} catch (IllegalBlockSizeException e) {
    			throw new Exception("密文长度非法");
    		} catch (BadPaddingException e) {
    			throw new Exception("密文数据已损坏");
    		}
    	}
    
    	/**
    	 * 公钥解密过程
    	 * 
    	 * @param publicKey
    	 *            公钥
    	 * @param cipherData
    	 *            密文数据
    	 * @return 明文
    	 * @throws Exception
    	 *             解密过程中的异常信息
    	 */
    	public static byte[] decrypt(RSAPublicKey publicKey, byte[] cipherData)
    			throws Exception {
    		if (publicKey == null) {
    			throw new Exception("解密公钥为空, 请设置");
    		}
    		Cipher cipher = null;
    		try {
    			// 使用默认RSA
    			cipher = Cipher.getInstance("RSA");
    			// cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
    			cipher.init(Cipher.DECRYPT_MODE, publicKey);
    			byte[] output = cipher.doFinal(cipherData);
    			return output;
    		} catch (NoSuchAlgorithmException e) {
    			throw new Exception("无此解密算法");
    		} catch (NoSuchPaddingException e) {
    			e.printStackTrace();
    			return null;
    		} catch (InvalidKeyException e) {
    			throw new Exception("解密公钥非法,请检查");
    		} catch (IllegalBlockSizeException e) {
    			throw new Exception("密文长度非法");
    		} catch (BadPaddingException e) {
    			throw new Exception("密文数据已损坏");
    		}
    	}
    
    	/**
    	 * 字节数据转十六进制字符串
    	 * 
    	 * @param data
    	 *            输入数据
    	 * @return 十六进制内容
    	 */
    	public static String byteArrayToString(byte[] data) {
    		StringBuilder stringBuilder = new StringBuilder();
    		for (int i = 0; i < data.length; i++) {
    			// 取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移
    			stringBuilder.append(HEX_CHAR[(data[i] & 0xf0) >>> 4]);
    			// 取出字节的低四位 作为索引得到相应的十六进制标识符
    			stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);
    			if (i < data.length - 1) {
    				stringBuilder.append(' ');
    			}
    		}
    		return stringBuilder.toString();
    	}
    }

签名及校验类：

**\[java\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  package com.ihep;  
2.    
3.  import java.security.KeyFactory;  
4.  import java.security.PrivateKey;  
5.  import java.security.PublicKey;  
6.  import java.security.spec.PKCS8EncodedKeySpec;  
7.  import java.security.spec.X509EncodedKeySpec;  
8.    
9.    
10.   
11. /\*\* 
12.  \* RSA签名验签类 
13.  \*/  
14. public class RSASignature\{  
15.       
16.     /\*\* 
17.      \* 签名算法 
18.      \*/  
19.     public static final String SIGN\_ALGORITHMS = "SHA1WithRSA";  
20.   
21.     /\*\* 
22.     \* RSA签名 
23.     \* @param content 待签名数据 
24.     \* @param privateKey 商户私钥 
25.     \* @param encode 字符集编码 
26.     \* @return 签名值 
27.     \*/  
28.     public static String sign(String content, String privateKey, String encode)  
29.     \{  
30.         try   
31.         \{  
32.             PKCS8EncodedKeySpec priPKCS8    = new PKCS8EncodedKeySpec( Base64.decode(privateKey) );   
33.               
34.             KeyFactory keyf                 = KeyFactory.getInstance("RSA");  
35.             PrivateKey priKey               = keyf.generatePrivate(priPKCS8);  
36.   
37.             java.security.Signature signature = java.security.Signature.getInstance(SIGN\_ALGORITHMS);  
38.   
39.             signature.initSign(priKey);  
40.             signature.update( content.getBytes(encode));  
41.   
42.             byte\[\] signed = signature.sign();  
43.               
44.             return Base64.encode(signed);  
45.         \}  
46.         catch (Exception e)   
47.         \{  
48.             e.printStackTrace();  
49.         \}  
50.           
51.         return null;  
52.     \}  
53.       
54.     public static String sign(String content, String privateKey)  
55.     \{  
56.         try   
57.         \{  
58.             PKCS8EncodedKeySpec priPKCS8    = new PKCS8EncodedKeySpec( Base64.decode(privateKey) );   
59.             KeyFactory keyf = KeyFactory.getInstance("RSA");  
60.             PrivateKey priKey = keyf.generatePrivate(priPKCS8);  
61.             java.security.Signature signature = java.security.Signature.getInstance(SIGN\_ALGORITHMS);  
62.             signature.initSign(priKey);  
63.             signature.update( content.getBytes());  
64.             byte\[\] signed = signature.sign();  
65.             return Base64.encode(signed);  
66.         \}  
67.         catch (Exception e)   
68.         \{  
69.             e.printStackTrace();  
70.         \}  
71.         return null;  
72.     \}  
73.       
74.     /\*\* 
75.     \* RSA验签名检查 
76.     \* @param content 待签名数据 
77.     \* @param sign 签名值 
78.     \* @param publicKey 分配给开发商公钥 
79.     \* @param encode 字符集编码 
80.     \* @return 布尔值 
81.     \*/  
82.     public static boolean doCheck(String content, String sign, String publicKey,String encode)  
83.     \{  
84.         try   
85.         \{  
86.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
87.             byte\[\] encodedKey = Base64.decode(publicKey);  
88.             PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));  
89.   
90.           
91.             java.security.Signature signature = java.security.Signature  
92.             .getInstance(SIGN\_ALGORITHMS);  
93.           
94.             signature.initVerify(pubKey);  
95.             signature.update( content.getBytes(encode) );  
96.           
97.             boolean bverify = signature.verify( Base64.decode(sign) );  
98.             return bverify;  
99.               
100.         \}   
101.         catch (Exception e)   
102.         \{  
103.             e.printStackTrace();  
104.         \}  
105.           
106.         return false;  
107.     \}  
108.       
109.     public static boolean doCheck(String content, String sign, String publicKey)  
110.     \{  
111.         try   
112.         \{  
113.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
114.             byte\[\] encodedKey = Base64.decode(publicKey);  
115.             PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));  
116.   
117.           
118.             java.security.Signature signature = java.security.Signature  
119.             .getInstance(SIGN\_ALGORITHMS);  
120.           
121.             signature.initVerify(pubKey);  
122.             signature.update( content.getBytes() );  
123.           
124.             boolean bverify = signature.verify( Base64.decode(sign) );  
125.             return bverify;  
126.               
127.         \}   
128.         catch (Exception e)   
129.         \{  
130.             e.printStackTrace();  
131.         \}  
132.           
133.         return false;  
134.     \}  
135.       
136. \}

package com.ihep;
    
    import java.security.KeyFactory;
    import java.security.PrivateKey;
    import java.security.PublicKey;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    
    
    
    /**
     * RSA签名验签类
     */
    public class RSASignature{
    	
    	/**
    	 * 签名算法
    	 */
    	public static final String SIGN_ALGORITHMS = "SHA1WithRSA";
    
    	/**
    	* RSA签名
    	* @param content 待签名数据
    	* @param privateKey 商户私钥
    	* @param encode 字符集编码
    	* @return 签名值
    	*/
    	public static String sign(String content, String privateKey, String encode)
    	{
            try 
            {
            	PKCS8EncodedKeySpec priPKCS8 	= new PKCS8EncodedKeySpec( Base64.decode(privateKey) ); 
            	
            	KeyFactory keyf 				= KeyFactory.getInstance("RSA");
            	PrivateKey priKey 				= keyf.generatePrivate(priPKCS8);
    
                java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);
    
                signature.initSign(priKey);
                signature.update( content.getBytes(encode));
    
                byte[] signed = signature.sign();
                
                return Base64.encode(signed);
            }
            catch (Exception e) 
            {
            	e.printStackTrace();
            }
            
            return null;
        }
    	
    	public static String sign(String content, String privateKey)
    	{
            try 
            {
            	PKCS8EncodedKeySpec priPKCS8 	= new PKCS8EncodedKeySpec( Base64.decode(privateKey) ); 
            	KeyFactory keyf = KeyFactory.getInstance("RSA");
            	PrivateKey priKey = keyf.generatePrivate(priPKCS8);
                java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);
                signature.initSign(priKey);
                signature.update( content.getBytes());
                byte[] signed = signature.sign();
                return Base64.encode(signed);
            }
            catch (Exception e) 
            {
            	e.printStackTrace();
            }
            return null;
        }
    	
    	/**
    	* RSA验签名检查
    	* @param content 待签名数据
    	* @param sign 签名值
    	* @param publicKey 分配给开发商公钥
    	* @param encode 字符集编码
    	* @return 布尔值
    	*/
    	public static boolean doCheck(String content, String sign, String publicKey,String encode)
    	{
    		try 
    		{
    			KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    	        byte[] encodedKey = Base64.decode(publicKey);
    	        PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));
    
    		
    			java.security.Signature signature = java.security.Signature
    			.getInstance(SIGN_ALGORITHMS);
    		
    			signature.initVerify(pubKey);
    			signature.update( content.getBytes(encode) );
    		
    			boolean bverify = signature.verify( Base64.decode(sign) );
    			return bverify;
    			
    		} 
    		catch (Exception e) 
    		{
    			e.printStackTrace();
    		}
    		
    		return false;
    	}
    	
    	public static boolean doCheck(String content, String sign, String publicKey)
    	{
    		try 
    		{
    			KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    	        byte[] encodedKey = Base64.decode(publicKey);
    	        PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));
    
    		
    			java.security.Signature signature = java.security.Signature
    			.getInstance(SIGN_ALGORITHMS);
    		
    			signature.initVerify(pubKey);
    			signature.update( content.getBytes() );
    		
    			boolean bverify = signature.verify( Base64.decode(sign) );
    			return bverify;
    			
    		} 
    		catch (Exception e) 
    		{
    			e.printStackTrace();
    		}
    		
    		return false;
    	}
    	
    }

再来一个Base64的类，当然你也可以用commons-codec-1.9.jar

**\[java\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  package com.ihep;  
2.    
3.  public final class Base64 \{  
4.    
5.      static private final int     BASELENGTH           = 128;  
6.      static private final int     LOOKUPLENGTH         = 64;  
7.      static private final int     TWENTYFOURBITGROUP   = 24;  
8.      static private final int     EIGHTBIT             = 8;  
9.      static private final int     SIXTEENBIT           = 16;  
10.     static private final int     FOURBYTE             = 4;  
11.     static private final int     SIGN                 = -128;  
12.     static private final char    PAD                  = '=';  
13.     static private final boolean fDebug               = false;  
14.     static final private byte\[\]  base64Alphabet       = new byte\[BASELENGTH\];  
15.     static final private char\[\]  lookUpBase64Alphabet = new char\[LOOKUPLENGTH\];  
16.   
17.     static \{  
18.         for (int i = 0; i < BASELENGTH; ++i) \{  
19.             base64Alphabet\[i\] = -1;  
20.         \}  
21.         for (int i = 'Z'; i >= 'A'; i--) \{  
22.             base64Alphabet\[i\] = (byte) (i - 'A');  
23.         \}  
24.         for (int i = 'z'; i >= 'a'; i--) \{  
25.             base64Alphabet\[i\] = (byte) (i - 'a' + 26);  
26.         \}  
27.   
28.         for (int i = '9'; i >= '0'; i--) \{  
29.             base64Alphabet\[i\] = (byte) (i - '0' + 52);  
30.         \}  
31.   
32.         base64Alphabet\['+'\] = 62;  
33.         base64Alphabet\['/'\] = 63;  
34.   
35.         for (int i = 0; i <= 25; i++) \{  
36.             lookUpBase64Alphabet\[i\] = (char) ('A' + i);  
37.         \}  
38.   
39.         for (int i = 26, j = 0; i <= 51; i++, j++) \{  
40.             lookUpBase64Alphabet\[i\] = (char) ('a' + j);  
41.         \}  
42.   
43.         for (int i = 52, j = 0; i <= 61; i++, j++) \{  
44.             lookUpBase64Alphabet\[i\] = (char) ('0' + j);  
45.         \}  
46.         lookUpBase64Alphabet\[62\] = (char) '+';  
47.         lookUpBase64Alphabet\[63\] = (char) '/';  
48.   
49.     \}  
50.   
51.     private static boolean isWhiteSpace(char octect) \{  
52.         return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9);  
53.     \}  
54.   
55.     private static boolean isPad(char octect) \{  
56.         return (octect == PAD);  
57.     \}  
58.   
59.     private static boolean isData(char octect) \{  
60.         return (octect < BASELENGTH && base64Alphabet\[octect\] != -1);  
61.     \}  
62.   
63.     /\*\* 
64.      \* Encodes hex octects into Base64 
65.      \* 
66.      \* @param binaryData Array containing binaryData 
67.      \* @return Encoded Base64 array 
68.      \*/  
69.     public static String encode(byte\[\] binaryData) \{  
70.   
71.         if (binaryData == null) \{  
72.             return null;  
73.         \}  
74.   
75.         int lengthDataBits = binaryData.length \* EIGHTBIT;  
76.         if (lengthDataBits == 0) \{  
77.             return "";  
78.         \}  
79.   
80.         int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;  
81.         int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;  
82.         int numberQuartet = fewerThan24bits != 0 ? numberTriplets + 1 : numberTriplets;  
83.         char encodedData\[\] = null;  
84.   
85.         encodedData = new char\[numberQuartet \* 4\];  
86.   
87.         byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;  
88.   
89.         int encodedIndex = 0;  
90.         int dataIndex = 0;  
91.         if (fDebug) \{  
92.             System.out.println("number of triplets = " + numberTriplets);  
93.         \}  
94.   
95.         for (int i = 0; i < numberTriplets; i++) \{  
96.             b1 = binaryData\[dataIndex++\];  
97.             b2 = binaryData\[dataIndex++\];  
98.             b3 = binaryData\[dataIndex++\];  
99.   
100.             if (fDebug) \{  
101.                 System.out.println("b1= " + b1 + ", b2= " + b2 + ", b3= " + b3);  
102.             \}  
103.   
104.             l = (byte) (b2 & 0x0f);  
105.             k = (byte) (b1 & 0x03);  
106.   
107.             byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);  
108.             byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);  
109.             byte val3 = ((b3 & SIGN) == 0) ? (byte) (b3 >> 6) : (byte) ((b3) >> 6 ^ 0xfc);  
110.   
111.             if (fDebug) \{  
112.                 System.out.println("val2 = " + val2);  
113.                 System.out.println("k4   = " + (k << 4));  
114.                 System.out.println("vak  = " + (val2 | (k << 4)));  
115.             \}  
116.   
117.             encodedData\[encodedIndex++\] = lookUpBase64Alphabet\[val1\];  
118.             encodedData\[encodedIndex++\] = lookUpBase64Alphabet\[val2 | (k << 4)\];  
119.             encodedData\[encodedIndex++\] = lookUpBase64Alphabet\[(l << 2) | val3\];  
120.             encodedData\[encodedIndex++\] = lookUpBase64Alphabet\[b3 & 0x3f\];  
121.         \}  
122.   
123.         // form integral number of 6-bit groups  
124.         if (fewerThan24bits == EIGHTBIT) \{  
125.             b1 = binaryData\[dataIndex\];  
126.             k = (byte) (b1 & 0x03);  
127.             if (fDebug) \{  
128.                 System.out.println("b1=" + b1);  
129.                 System.out.println("b1<<2 = " + (b1 >> 2));  
130.             \}  
131.             byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);  
132.             encodedData\[encodedIndex++\] = lookUpBase64Alphabet\[val1\];  
133.             encodedData\[encodedIndex++\] = lookUpBase64Alphabet\[k << 4\];  
134.             encodedData\[encodedIndex++\] = PAD;  
135.             encodedData\[encodedIndex++\] = PAD;  
136.         \} else if (fewerThan24bits == SIXTEENBIT) \{  
137.             b1 = binaryData\[dataIndex\];  
138.             b2 = binaryData\[dataIndex + 1\];  
139.             l = (byte) (b2 & 0x0f);  
140.             k = (byte) (b1 & 0x03);  
141.   
142.             byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);  
143.             byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);  
144.   
145.             encodedData\[encodedIndex++\] = lookUpBase64Alphabet\[val1\];  
146.             encodedData\[encodedIndex++\] = lookUpBase64Alphabet\[val2 | (k << 4)\];  
147.             encodedData\[encodedIndex++\] = lookUpBase64Alphabet\[l << 2\];  
148.             encodedData\[encodedIndex++\] = PAD;  
149.         \}  
150.   
151.         return new String(encodedData);  
152.     \}  
153.   
154.     /\*\* 
155.      \* Decodes Base64 data into octects 
156.      \* 
157.      \* @param encoded string containing Base64 data 
158.      \* @return Array containind decoded data. 
159.      \*/  
160.     public static byte\[\] decode(String encoded) \{  
161.   
162.         if (encoded == null) \{  
163.             return null;  
164.         \}  
165.   
166.         char\[\] base64Data = encoded.toCharArray();  
167.         // remove white spaces  
168.         int len = removeWhiteSpace(base64Data);  
169.   
170.         if (len % FOURBYTE != 0) \{  
171.             return null;//should be divisible by four  
172.         \}  
173.   
174.         int numberQuadruple = (len / FOURBYTE);  
175.   
176.         if (numberQuadruple == 0) \{  
177.             return new byte\[0\];  
178.         \}  
179.   
180.         byte decodedData\[\] = null;  
181.         byte b1 = 0, b2 = 0, b3 = 0, b4 = 0;  
182.         char d1 = 0, d2 = 0, d3 = 0, d4 = 0;  
183.   
184.         int i = 0;  
185.         int encodedIndex = 0;  
186.         int dataIndex = 0;  
187.         decodedData = new byte\[(numberQuadruple) \* 3\];  
188.   
189.         for (; i < numberQuadruple - 1; i++) \{  
190.   
191.             if (!isData((d1 = base64Data\[dataIndex++\])) || !isData((d2 = base64Data\[dataIndex++\]))  
192.                 || !isData((d3 = base64Data\[dataIndex++\]))  
193.                 || !isData((d4 = base64Data\[dataIndex++\]))) \{  
194.                 return null;  
195.             \}//if found "no data" just return null  
196.   
197.             b1 = base64Alphabet\[d1\];  
198.             b2 = base64Alphabet\[d2\];  
199.             b3 = base64Alphabet\[d3\];  
200.             b4 = base64Alphabet\[d4\];  
201.   
202.             decodedData\[encodedIndex++\] = (byte) (b1 << 2 | b2 >> 4);  
203.             decodedData\[encodedIndex++\] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));  
204.             decodedData\[encodedIndex++\] = (byte) (b3 << 6 | b4);  
205.         \}  
206.   
207.         if (!isData((d1 = base64Data\[dataIndex++\])) || !isData((d2 = base64Data\[dataIndex++\]))) \{  
208.             return null;//if found "no data" just return null  
209.         \}  
210.   
211.         b1 = base64Alphabet\[d1\];  
212.         b2 = base64Alphabet\[d2\];  
213.   
214.         d3 = base64Data\[dataIndex++\];  
215.         d4 = base64Data\[dataIndex++\];  
216.         if (!isData((d3)) || !isData((d4))) \{ //Check if they are PAD characters  
217.             if (isPad(d3) && isPad(d4)) \{  
218.                 if ((b2 & 0xf) != 0)//last 4 bits should be zero  
219.                 \{  
220.                     return null;  
221.                 \}  
222.                 byte\[\] tmp = new byte\[i \* 3 + 1\];  
223.                 System.arraycopy(decodedData, 0, tmp, 0, i \* 3);  
224.                 tmp\[encodedIndex\] = (byte) (b1 << 2 | b2 >> 4);  
225.                 return tmp;  
226.             \} else if (!isPad(d3) && isPad(d4)) \{  
227.                 b3 = base64Alphabet\[d3\];  
228.                 if ((b3 & 0x3) != 0)//last 2 bits should be zero  
229.                 \{  
230.                     return null;  
231.                 \}  
232.                 byte\[\] tmp = new byte\[i \* 3 + 2\];  
233.                 System.arraycopy(decodedData, 0, tmp, 0, i \* 3);  
234.                 tmp\[encodedIndex++\] = (byte) (b1 << 2 | b2 >> 4);  
235.                 tmp\[encodedIndex\] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));  
236.                 return tmp;  
237.             \} else \{  
238.                 return null;  
239.             \}  
240.         \} else \{ //No PAD e.g 3cQl  
241.             b3 = base64Alphabet\[d3\];  
242.             b4 = base64Alphabet\[d4\];  
243.             decodedData\[encodedIndex++\] = (byte) (b1 << 2 | b2 >> 4);  
244.             decodedData\[encodedIndex++\] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));  
245.             decodedData\[encodedIndex++\] = (byte) (b3 << 6 | b4);  
246.   
247.         \}  
248.   
249.         return decodedData;  
250.     \}  
251.   
252.     /\*\* 
253.      \* remove WhiteSpace from MIME containing encoded Base64 data. 
254.      \* 
255.      \* @param data  the byte array of base64 data (with WS) 
256.      \* @return      the new length 
257.      \*/  
258.     private static int removeWhiteSpace(char\[\] data) \{  
259.         if (data == null) \{  
260.             return 0;  
261.         \}  
262.   
263.         // count characters that's not whitespace  
264.         int newSize = 0;  
265.         int len = data.length;  
266.         for (int i = 0; i < len; i++) \{  
267.             if (!isWhiteSpace(data\[i\])) \{  
268.                 data\[newSize++\] = data\[i\];  
269.             \}  
270.         \}  
271.         return newSize;  
272.     \}  
273. \}

package com.ihep;
    
    public final class Base64 {
    
        static private final int     BASELENGTH           = 128;
        static private final int     LOOKUPLENGTH         = 64;
        static private final int     TWENTYFOURBITGROUP   = 24;
        static private final int     EIGHTBIT             = 8;
        static private final int     SIXTEENBIT           = 16;
        static private final int     FOURBYTE             = 4;
        static private final int     SIGN                 = -128;
        static private final char    PAD                  = '=';
        static private final boolean fDebug               = false;
        static final private byte[]  base64Alphabet       = new byte[BASELENGTH];
        static final private char[]  lookUpBase64Alphabet = new char[LOOKUPLENGTH];
    
        static {
            for (int i = 0; i < BASELENGTH; ++i) {
                base64Alphabet[i] = -1;
            }
            for (int i = 'Z'; i >= 'A'; i--) {
                base64Alphabet[i] = (byte) (i - 'A');
            }
            for (int i = 'z'; i >= 'a'; i--) {
                base64Alphabet[i] = (byte) (i - 'a' + 26);
            }
    
            for (int i = '9'; i >= '0'; i--) {
                base64Alphabet[i] = (byte) (i - '0' + 52);
            }
    
            base64Alphabet['+'] = 62;
            base64Alphabet['/'] = 63;
    
            for (int i = 0; i <= 25; i++) {
                lookUpBase64Alphabet[i] = (char) ('A' + i);
            }
    
            for (int i = 26, j = 0; i <= 51; i++, j++) {
                lookUpBase64Alphabet[i] = (char) ('a' + j);
            }
    
            for (int i = 52, j = 0; i <= 61; i++, j++) {
                lookUpBase64Alphabet[i] = (char) ('0' + j);
            }
            lookUpBase64Alphabet[62] = (char) '+';
            lookUpBase64Alphabet[63] = (char) '/';
    
        }
    
        private static boolean isWhiteSpace(char octect) {
            return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9);
        }
    
        private static boolean isPad(char octect) {
            return (octect == PAD);
        }
    
        private static boolean isData(char octect) {
            return (octect < BASELENGTH && base64Alphabet[octect] != -1);
        }
    
        /**
         * Encodes hex octects into Base64
         *
         * @param binaryData Array containing binaryData
         * @return Encoded Base64 array
         */
        public static String encode(byte[] binaryData) {
    
            if (binaryData == null) {
                return null;
            }
    
            int lengthDataBits = binaryData.length * EIGHTBIT;
            if (lengthDataBits == 0) {
                return "";
            }
    
            int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;
            int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;
            int numberQuartet = fewerThan24bits != 0 ? numberTriplets + 1 : numberTriplets;
            char encodedData[] = null;
    
            encodedData = new char[numberQuartet * 4];
    
            byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;
    
            int encodedIndex = 0;
            int dataIndex = 0;
            if (fDebug) {
                System.out.println("number of triplets = " + numberTriplets);
            }
    
            for (int i = 0; i < numberTriplets; i++) {
                b1 = binaryData[dataIndex++];
                b2 = binaryData[dataIndex++];
                b3 = binaryData[dataIndex++];
    
                if (fDebug) {
                    System.out.println("b1= " + b1 + ", b2= " + b2 + ", b3= " + b3);
                }
    
                l = (byte) (b2 & 0x0f);
                k = (byte) (b1 & 0x03);
    
                byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
                byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);
                byte val3 = ((b3 & SIGN) == 0) ? (byte) (b3 >> 6) : (byte) ((b3) >> 6 ^ 0xfc);
    
                if (fDebug) {
                    System.out.println("val2 = " + val2);
                    System.out.println("k4   = " + (k << 4));
                    System.out.println("vak  = " + (val2 | (k << 4)));
                }
    
                encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
                encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];
                encodedData[encodedIndex++] = lookUpBase64Alphabet[(l << 2) | val3];
                encodedData[encodedIndex++] = lookUpBase64Alphabet[b3 & 0x3f];
            }
    
            // form integral number of 6-bit groups
            if (fewerThan24bits == EIGHTBIT) {
                b1 = binaryData[dataIndex];
                k = (byte) (b1 & 0x03);
                if (fDebug) {
                    System.out.println("b1=" + b1);
                    System.out.println("b1<<2 = " + (b1 >> 2));
                }
                byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
                encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
                encodedData[encodedIndex++] = lookUpBase64Alphabet[k << 4];
                encodedData[encodedIndex++] = PAD;
                encodedData[encodedIndex++] = PAD;
            } else if (fewerThan24bits == SIXTEENBIT) {
                b1 = binaryData[dataIndex];
                b2 = binaryData[dataIndex + 1];
                l = (byte) (b2 & 0x0f);
                k = (byte) (b1 & 0x03);
    
                byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
                byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);
    
                encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
                encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];
                encodedData[encodedIndex++] = lookUpBase64Alphabet[l << 2];
                encodedData[encodedIndex++] = PAD;
            }
    
            return new String(encodedData);
        }
    
        /**
         * Decodes Base64 data into octects
         *
         * @param encoded string containing Base64 data
         * @return Array containind decoded data.
         */
        public static byte[] decode(String encoded) {
    
            if (encoded == null) {
                return null;
            }
    
            char[] base64Data = encoded.toCharArray();
            // remove white spaces
            int len = removeWhiteSpace(base64Data);
    
            if (len % FOURBYTE != 0) {
                return null;//should be divisible by four
            }
    
            int numberQuadruple = (len / FOURBYTE);
    
            if (numberQuadruple == 0) {
                return new byte[0];
            }
    
            byte decodedData[] = null;
            byte b1 = 0, b2 = 0, b3 = 0, b4 = 0;
            char d1 = 0, d2 = 0, d3 = 0, d4 = 0;
    
            int i = 0;
            int encodedIndex = 0;
            int dataIndex = 0;
            decodedData = new byte[(numberQuadruple) * 3];
    
            for (; i < numberQuadruple - 1; i++) {
    
                if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))
                    || !isData((d3 = base64Data[dataIndex++]))
                    || !isData((d4 = base64Data[dataIndex++]))) {
                    return null;
                }//if found "no data" just return null
    
                b1 = base64Alphabet[d1];
                b2 = base64Alphabet[d2];
                b3 = base64Alphabet[d3];
                b4 = base64Alphabet[d4];
    
                decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
                decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
                decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);
            }
    
            if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))) {
                return null;//if found "no data" just return null
            }
    
            b1 = base64Alphabet[d1];
            b2 = base64Alphabet[d2];
    
            d3 = base64Data[dataIndex++];
            d4 = base64Data[dataIndex++];
            if (!isData((d3)) || !isData((d4))) {//Check if they are PAD characters
                if (isPad(d3) && isPad(d4)) {
                    if ((b2 & 0xf) != 0)//last 4 bits should be zero
                    {
                        return null;
                    }
                    byte[] tmp = new byte[i * 3 + 1];
                    System.arraycopy(decodedData, 0, tmp, 0, i * 3);
                    tmp[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
                    return tmp;
                } else if (!isPad(d3) && isPad(d4)) {
                    b3 = base64Alphabet[d3];
                    if ((b3 & 0x3) != 0)//last 2 bits should be zero
                    {
                        return null;
                    }
                    byte[] tmp = new byte[i * 3 + 2];
                    System.arraycopy(decodedData, 0, tmp, 0, i * 3);
                    tmp[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
                    tmp[encodedIndex] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
                    return tmp;
                } else {
                    return null;
                }
            } else { //No PAD e.g 3cQl
                b3 = base64Alphabet[d3];
                b4 = base64Alphabet[d4];
                decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
                decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
                decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);
    
            }
    
            return decodedData;
        }
    
        /**
         * remove WhiteSpace from MIME containing encoded Base64 data.
         *
         * @param data  the byte array of base64 data (with WS)
         * @return      the new length
         */
        private static int removeWhiteSpace(char[] data) {
            if (data == null) {
                return 0;
            }
    
            // count characters that's not whitespace
            int newSize = 0;
            int len = data.length;
            for (int i = 0; i < len; i++) {
                if (!isWhiteSpace(data[i])) {
                    data[newSize++] = data[i];
                }
            }
            return newSize;
        }
    }

最后是一个MainTest：

**\[java\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.  package com.ihep;  
2.    
3.  public class MainTest \{  
4.    
5.      public static void main(String\[\] args) throws Exception \{  
6.          String filepath="G:/tmp/";  
7.    
8.          //RSAEncrypt.genKeyPair(filepath);  
9.            
10.           
11.         System.out.println("--------------公钥加密私钥解密过程-------------------");  
12.         String plainText="ihep\_公钥加密私钥解密";  
13.         //公钥加密过程  
14.         byte\[\] cipherData=RSAEncrypt.encrypt(RSAEncrypt.loadPublicKeyByStr(RSAEncrypt.loadPublicKeyByFile(filepath)),plainText.getBytes());  
15.         String cipher=Base64.encode(cipherData);  
16.         //私钥解密过程  
17.         byte\[\] res=RSAEncrypt.decrypt(RSAEncrypt.loadPrivateKeyByStr(RSAEncrypt.loadPrivateKeyByFile(filepath)), Base64.decode(cipher));  
18.         String restr=new String(res);  
19.         System.out.println("原文："\+plainText);  
20.         System.out.println("加密："\+cipher);  
21.         System.out.println("解密："\+restr);  
22.         System.out.println();  
23.           
24.         System.out.println("--------------私钥加密公钥解密过程-------------------");  
25.         plainText="ihep\_私钥加密公钥解密";  
26.         //私钥加密过程  
27.         cipherData=RSAEncrypt.encrypt(RSAEncrypt.loadPrivateKeyByStr(RSAEncrypt.loadPrivateKeyByFile(filepath)),plainText.getBytes());  
28.         cipher=Base64.encode(cipherData);  
29.         //公钥解密过程  
30.         res=RSAEncrypt.decrypt(RSAEncrypt.loadPublicKeyByStr(RSAEncrypt.loadPublicKeyByFile(filepath)), Base64.decode(cipher));  
31.         restr=new String(res);  
32.         System.out.println("原文："\+plainText);  
33.         System.out.println("加密："\+cipher);  
34.         System.out.println("解密："\+restr);  
35.         System.out.println();  
36.           
37.         System.out.println("---------------私钥签名过程------------------");  
38.         String content="ihep\_这是用于签名的原始数据";  
39.         String signstr=RSASignature.sign(content,RSAEncrypt.loadPrivateKeyByFile(filepath));  
40.         System.out.println("签名原串："\+content);  
41.         System.out.println("签名串："\+signstr);  
42.         System.out.println();  
43.           
44.         System.out.println("---------------公钥校验签名------------------");  
45.         System.out.println("签名原串："\+content);  
46.         System.out.println("签名串："\+signstr);  
47.           
48.         System.out.println("验签结果："\+RSASignature.doCheck(content, signstr, RSAEncrypt.loadPublicKeyByFile(filepath)));  
49.         System.out.println();  
50.           
51.     \}  
52. \}

package com.ihep;
    
    public class MainTest {
    
    	public static void main(String[] args) throws Exception {
    		String filepath="G:/tmp/";
    
    		//RSAEncrypt.genKeyPair(filepath);
    		
    		
    		System.out.println("--------------公钥加密私钥解密过程-------------------");
    		String plainText="ihep_公钥加密私钥解密";
    		//公钥加密过程
    		byte[] cipherData=RSAEncrypt.encrypt(RSAEncrypt.loadPublicKeyByStr(RSAEncrypt.loadPublicKeyByFile(filepath)),plainText.getBytes());
    		String cipher=Base64.encode(cipherData);
    		//私钥解密过程
    		byte[] res=RSAEncrypt.decrypt(RSAEncrypt.loadPrivateKeyByStr(RSAEncrypt.loadPrivateKeyByFile(filepath)), Base64.decode(cipher));
    		String restr=new String(res);
    		System.out.println("原文："+plainText);
    		System.out.println("加密："+cipher);
    		System.out.println("解密："+restr);
    		System.out.println();
    		
    		System.out.println("--------------私钥加密公钥解密过程-------------------");
    		plainText="ihep_私钥加密公钥解密";
    		//私钥加密过程
    		cipherData=RSAEncrypt.encrypt(RSAEncrypt.loadPrivateKeyByStr(RSAEncrypt.loadPrivateKeyByFile(filepath)),plainText.getBytes());
    		cipher=Base64.encode(cipherData);
    		//公钥解密过程
    		res=RSAEncrypt.decrypt(RSAEncrypt.loadPublicKeyByStr(RSAEncrypt.loadPublicKeyByFile(filepath)), Base64.decode(cipher));
    		restr=new String(res);
    		System.out.println("原文："+plainText);
    		System.out.println("加密："+cipher);
    		System.out.println("解密："+restr);
    		System.out.println();
    		
    		System.out.println("---------------私钥签名过程------------------");
    		String content="ihep_这是用于签名的原始数据";
    		String signstr=RSASignature.sign(content,RSAEncrypt.loadPrivateKeyByFile(filepath));
    		System.out.println("签名原串："+content);
    		System.out.println("签名串："+signstr);
    		System.out.println();
    		
    		System.out.println("---------------公钥校验签名------------------");
    		System.out.println("签名原串："+content);
    		System.out.println("签名串："+signstr);
    		
    		System.out.println("验签结果："+RSASignature.doCheck(content, signstr, RSAEncrypt.loadPublicKeyByFile(filepath)));
    		System.out.println();
    		
    	}
    }

看看运行截图：

![Center][]

![Center 1][]

转载请注明：[http://blog.csdn.net/wangqiuyun/article/details/42143957][http_blog.csdn.net_wangqiuyun_article_details_42143957]

[view plain]: http://blog.csdn.net/wangqiuyun/article/details/42143957#
[Center]: /images/20220609/42c121f323854b67a97e682e4253cb38.png
[Center 1]: /images/20220609/3fbb1a5bc65d4c66a2f2c94561378eb1.png
[http_blog.csdn.net_wangqiuyun_article_details_42143957]: http://blog.csdn.net/wangqiuyun/article/details/42143957