RSA加密與解密

[html]  view plain  copy

1. package utils;  

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.Signature;  
9. import java.security.interfaces.RSAPrivateKey;  
10. import java.security.interfaces.RSAPublicKey;  
11. import java.security.spec.PKCS8EncodedKeySpec;  
12. import java.security.spec.X509EncodedKeySpec;  
13. import java.util.HashMap;  
14. import java.util.Map;  
15. import javax.crypto.Cipher;  
16. /**  
17.  * <p>  
18.  * RSA公鑰/私鑰/簽名工具包  
19.  * </p>  
21.  * 羅納德·李維斯特（Ron [R]ivest）、阿迪·薩莫爾（Adi [S]hamir）和倫納德·阿德曼（Leonard [A]dleman）  
24.  * 字元串格式的密鑰在未在特殊說明情況下都為BASE64編碼格式<br/>  
25.  * 由于非對稱加密速度極其緩慢，一般檔案不使用它來加密而是使用對稱加密，<br/>  
26.  * 非對稱加密算法可以用來對對稱加密的密鑰加密，這樣保證密鑰的安全也就保證了資料的安全  
28.  *   
29.  * @author IceWee  
30.  * @date 2012-4-26  
31.  * @version 1.0  
32.  */  
33. public class RSAUtils {  
34.     /**  
35.      * 加密算法RSA  
36.      */  
37.     public static final String KEY_ALGORITHM = "RSA";  
39.      * 簽名算法  
41.     public static final String SIGNATURE_ALGORITHM = "MD5withRSA";  
43.      * 擷取公鑰的key  
45.     private static final String PUBLIC_KEY = "RSAPublicKey";  
47.      * 擷取私鑰的key  
49.     private static final String PRIVATE_KEY = "RSAPrivateKey";  
51.      * RSA最大加密明文大小  
53.     private static final int MAX_ENCRYPT_BLOCK = 117;  
55.      * RSA最大解密密文大小  
57.     private static final int MAX_DECRYPT_BLOCK = 128;  
59.      * <p>  
60.      * 生成密鑰對(公鑰和私鑰)  
61.      * </p>  
62.      *   
63.      * @return  
64.      * @throws Exception  
66.     public static Map<String, Object> genKeyPair() throws Exception {  
67.         KeyPairGenerator keyPairGen = KeyPairGenerator  
68.                 .getInstance(KEY_ALGORITHM);  
69.         keyPairGen.initialize(1024);  
70.         KeyPair keyPair = keyPairGen.generateKeyPair();  
71.         RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();  
72.         RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();  
73.         Map<String, Object> keyMap = new HashMap<String, Object>(2);  
74.         keyMap.put(PUBLIC_KEY, publicKey);  
75.         keyMap.put(PRIVATE_KEY, privateKey);  
76.         return keyMap;  
77.     }  
80.      * 用私鑰對資訊生成數字簽名  
83.      * @param data  
84.      *            已加密資料  
85.      * @param privateKey  
86.      *            私鑰(BASE64編碼)  
91.     public static String sign(byte[] data, String privateKey) throws Exception {  
92.         byte[] keyBytes = Base64Utils.decode(privateKey);  
93.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  
94.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
95.         PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);  
96.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);  
97.         signature.initSign(privateK);  
98.         signature.update(data);  
99.         return Base64Utils.encode(signature.sign());  
103.      * 校驗數字簽名  
108.      * @param publicKey  
109.      *            公鑰(BASE64編碼)  
110.      * @param sign  
111.      *            數字簽名  
117.     public static boolean verify(byte[] data, String publicKey, String sign)  
118.             throws Exception {  
119.         byte[] keyBytes = Base64Utils.decode(publicKey);  
120.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);  
122.         PublicKey publicK = keyFactory.generatePublic(keySpec);  
124.         signature.initVerify(publicK);  
126.         return signature.verify(Base64Utils.decode(sign));  
129.      * <P>  
130.      * 私鑰解密  
133.      * @param encryptedData  
140.     public static byte[] decryptByPrivateKey(byte[] encryptedData,  
141.             String privateKey) throws Exception {  
145.         Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);  
146.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
147.         cipher.init(Cipher.DECRYPT_MODE, privateK);  
148.         int inputLen = encryptedData.length;  
149.         ByteArrayOutputStream out = new ByteArrayOutputStream();  
150.         int offSet = 0;  
151.         byte[] cache;  
152.         int i = 0;  
153.         // 對資料分段解密  
154.         while (inputLen - offSet > 0) {  
155.             if (inputLen - offSet > MAX_DECRYPT_BLOCK) {  
156.                 cache = cipher  
157.                         .doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);  
158.             } else {  
160.                         .doFinal(encryptedData, offSet, inputLen - offSet);  
161.             }  
162.             out.write(cache, 0, cache.length);  
163.             i++;  
164.             offSet = i * MAX_DECRYPT_BLOCK;  
165.         }  
166.         byte[] decryptedData = out.toByteArray();  
167.         out.close();  
168.         return decryptedData;  
172.      * 公鑰解密  
182.     public static byte[] decryptByPublicKey(byte[] encryptedData,  
183.             String publicKey) throws Exception {  
185.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);  
187.         Key publicK = keyFactory.generatePublic(x509KeySpec);  
189.         cipher.init(Cipher.DECRYPT_MODE, publicK);  
214.      * 公鑰加密  
218.      *            源資料  
224.     public static byte[] encryptByPublicKey(byte[] data, String publicKey)  
230.         // 對資料加密  
232.         cipher.init(Cipher.ENCRYPT_MODE, publicK);  
233.         int inputLen = data.length;  
238.         // 對資料分段加密  
240.             if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {  
241.                 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);  
243.                 cache = cipher.doFinal(data, offSet, inputLen - offSet);  
247.             offSet = i * MAX_ENCRYPT_BLOCK;  
249.         byte[] encryptedData = out.toByteArray();  
251.         return encryptedData;  
255.      * 私鑰加密  
265.     public static byte[] encryptByPrivateKey(byte[] data, String privateKey)  
272.         cipher.init(Cipher.ENCRYPT_MODE, privateK);  
295.      * 擷取私鑰  
298.      * @param keyMap  
299.      *            密鑰對  
303.     public static String getPrivateKey(Map<String, Object> keyMap)  
305.         Key key = (Key) keyMap.get(PRIVATE_KEY);  
306.         return Base64Utils.encode(key.getEncoded());  
310.      * 擷取公鑰  
318.     public static String getPublicKey(Map<String, Object> keyMap)  
320.         Key key = (Key) keyMap.get(PUBLIC_KEY);  
323. }  

Base64Utils檔案

2. import java.io.ByteArrayInputStream;  
4. import java.io.File;  
5. import java.io.FileInputStream;  
6. import java.io.FileOutputStream;  
7. import java.io.InputStream;  
8. import java.io.OutputStream;  
9. import com.sun.org.apache.xml.internal.security.utils.Base64;    
12.  * BASE64編碼解碼工具包  
15.  * 依賴javabase64-1.3.1.jar  
19.  * @date 2012-5-19  
22. public class Base64Utils {  
24.      * 檔案讀取緩沖區大小  
26.     private static final int CACHE_SIZE = 1024;  
29.      * BASE64字元串解碼為二進制資料  
32.      * @param base64  
36.     public static byte[] decode(String base64) throws Exception {  
37.         return Base64.decode(base64.getBytes());  
41.      * 二進制資料編碼為BASE64字元串  
44.      * @param bytes  
48.     public static String encode(byte[] bytes) throws Exception {  
49.         return new String(Base64.encode(bytes));  
53.      * 将檔案編碼為BASE64字元串  
56.      * 大檔案慎用，可能會導緻記憶體溢出  
59.      * @param filePath 檔案絕對路徑  
63.     public static String encodeFile(String filePath) throws Exception {  
64.         byte[] bytes = fileToByte(filePath);  
65.         return encode(bytes);  
69.      * BASE64字元串轉回檔案  
73.      * @param base64 編碼字元串  
76.     public static void decodeToFile(String filePath, String base64) throws Exception {  
77.         byte[] bytes = decode(base64);  
78.         byteArrayToFile(bytes, filePath);  
82.      * 檔案轉換為二進制數組  
85.      * @param filePath 檔案路徑  
89.     public static byte[] fileToByte(String filePath) throws Exception {  
90.         byte[] data = new byte[0];  
91.         File file = new File(filePath);  
92.         if (file.exists()) {  
93.             FileInputStream in = new FileInputStream(file);  
94.             ByteArrayOutputStream out = new ByteArrayOutputStream(2048);  
95.             byte[] cache = new byte[CACHE_SIZE];  
96.             int nRead = 0;  
97.             while ((nRead = in.read(cache)) != -1) {  
98.                 out.write(cache, 0, nRead);  
99.                 out.flush();  
101.             out.close();  
102.             in.close();  
103.             data = out.toByteArray();  
104.          }  
105.         return data;  
109.      * 二進制資料寫檔案  
112.      * @param bytes 二進制資料  
113.      * @param filePath 檔案生成目錄  
115.     public static void byteArrayToFile(byte[] bytes, String filePath) throws Exception {  
116.         InputStream in = new ByteArrayInputStream(bytes);     
117.         File destFile = new File(filePath);  
118.         if (!destFile.getParentFile().exists()) {  
119.             destFile.getParentFile().mkdirs();  
121.         destFile.createNewFile();  
122.         OutputStream out = new FileOutputStream(destFile);  
123.         byte[] cache = new byte[CACHE_SIZE];  
124.         int nRead = 0;  
125.         while ((nRead = in.read(cache)) != -1) {     
126.             out.write(cache, 0, nRead);  
127.             out.flush();  
130.         in.close();  

測試用例：

1. package util;  
3. import RSAUtils;  
4. public class RSATester {  
5.     static String publicKey;  
6.     static String privateKey;  
7.     static {  
8.         try {  
9.             Map<String, Object> keyMap = RSAUtils.genKeyPair();  
10.             publicKey = RSAUtils.getPublicKey(keyMap);  
11.             privateKey = RSAUtils.getPrivateKey(keyMap);  
12.             System.err.println("公鑰: \n\r" + publicKey);  
13.             System.err.println("私鑰： \n\r" + privateKey);  
14.         } catch (Exception e) {  
15.             e.printStackTrace();  
18.     public static void main(String[] args) throws Exception {  
19.         test();  
20.         testSign();  
22.     static void test() throws Exception {  
23.         System.err.println("公鑰加密——私鑰解密");  
24.         String source = "這是一行沒有任何意義的文字，你看完了等于沒看，不是嗎？";  
25.         System.out.println("\r加密前文字：\r\n" + source);  
26.         byte[] data = source.getBytes();  
27.         byte[] encodedData = RSAUtils.encryptByPublicKey(data, publicKey);  
28.         System.out.println("加密後文字：\r\n" + new String(encodedData));  
29.         byte[] decodedData = RSAUtils.decryptByPrivateKey(encodedData, privateKey);  
30.         String target = new String(decodedData);  
31.         System.out.println("解密後文字: \r\n" + target);  
33.     static void testSign() throws Exception {  
34.         System.err.println("私鑰加密——公鑰解密");  
35.         String source = "這是一行測試RSA數字簽名的無意義文字";  
36.         System.out.println("原文字：\r\n" + source);  
38.         byte[] encodedData = RSAUtils.encryptByPrivateKey(data, privateKey);  
39.         System.out.println("加密後：\r\n" + new String(encodedData));  
40.         byte[] decodedData = RSAUtils.decryptByPublicKey(encodedData, publicKey);  
42.         System.out.println("解密後: \r\n" + target);  
43.         System.err.println("私鑰簽名——公鑰驗證簽名");  
44.         String sign = RSAUtils.sign(encodedData, privateKey);  
45.         System.err.println("簽名:\r" + sign);  
46.         boolean status = RSAUtils.verify(encodedData, publicKey, sign);  
47.         System.err.println("驗證結果:\r" + status);  

生成RSA密鑰、儲存到檔案、從檔案讀取、加密、解密等操作

1. import java.security.Key;     
2. import java.security.KeyFactory;     
3. import java.security.KeyPair;     
4. import java.security.KeyPairGenerator;     
5. import java.security.NoSuchAlgorithmException;     
6. import java.security.PrivateKey;     
7. import java.security.PublicKey;     
8. import java.security.SecureRandom;     
9. import java.security.interfaces.RSAPrivateKey;     
10. import java.security.interfaces.RSAPublicKey;     
11. import java.security.spec.InvalidKeySpecException;     
12. import java.security.spec.PKCS8EncodedKeySpec;     
13. import java.security.spec.X509EncodedKeySpec;     
14. import javax.crypto.Cipher;     
15. import org.apache.commons.configuration.ConfigurationException;     
16. import org.apache.commons.configuration.PropertiesConfiguration;     
17. import org.bouncycastle.jce.provider.BouncyCastleProvider;     
18. public class RSATest {     
19.     public static void main(String[] args) {     
20.         try {     
21.             RSATest encrypt = new RSATest();     
22.             String encryptText = "encryptText";     
23.             // Generate keys     
24.             KeyPair keyPair = encrypt.generateKey();     
25.             RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();     
26.             RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();     
27.             byte[] e = encrypt.encrypt(publicKey, encryptText.getBytes());     
28.             byte[] de = encrypt.decrypt(privateKey, e);     
29.             System.out.println(toHexString(e));     
30.             System.out.println(toHexString(de));     
31.         } catch (Exception e) {     
32.             e.printStackTrace();     
33.         }     
34.     }     
35.     public KeyPair generateKey() throws NoSuchAlgorithmException {     
36.         KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");     
37.         keyPairGen.initialize(1024, new SecureRandom());     
38.         KeyPair keyPair = keyPairGen.generateKeyPair();     
39.         return keyPair;     
41.     public void saveKey(KeyPair keyPair, String publicKeyFile,     
42.             String privateKeyFile) throws ConfigurationException {     
43.         PublicKey pubkey = keyPair.getPublic();     
44.         PrivateKey prikey = keyPair.getPrivate();     
45.         // save public key     
46.         PropertiesConfiguration publicConfig = new PropertiesConfiguration(     
47.                 publicKeyFile);     
48.         publicConfig.setProperty("PULIICKEY", toHexString(pubkey.getEncoded()));     
49.         publicConfig.save();     
50.         // save private key     
51.         PropertiesConfiguration privateConfig = new PropertiesConfiguration(     
52.                 privateKeyFile);     
53.         privateConfig.setProperty("PRIVATEKEY",     
54.                 toHexString(prikey.getEncoded()));     
55.         privateConfig.save();     
57.     /**    
58.      * @param filename    
59.      * @param type：    
60.      *            1-public 0-private    
61.      * @return    
62.      * @throws ConfigurationException    
63.      * @throws NoSuchAlgorithmException    
64.      * @throws InvalidKeySpecException    
65.      */    
66.     public Key loadKey(String filename, int type)     
67.             throws ConfigurationException, NoSuchAlgorithmException,     
68.             InvalidKeySpecException {     
69.         PropertiesConfiguration config = new PropertiesConfiguration(filename);     
70.         KeyFactory keyFactory = KeyFactory.getInstance("RSA",     
71.                 new BouncyCastleProvider());     
72.         if (type == 0) {     
73.             // privateKey     
74.             String privateKeyValue = config.getString("PULIICKEY");     
75.             PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(     
76.                     toBytes(privateKeyValue));     
77.             PrivateKey privateKey = keyFactory.generatePrivate(priPKCS8);     
78.             return privateKey;     
79.         } else {     
80.             // publicKey     
81.             String privateKeyValue = config.getString("PRIVATEKEY");     
82.             X509EncodedKeySpec bobPubKeySpec = new X509EncodedKeySpec(     
84.             PublicKey publicKey = keyFactory.generatePublic(bobPubKeySpec);     
85.             return publicKey;     
89.      * Encrypt String.    
90.      *     
91.      * @return byte[]    
93.     protected byte[] encrypt(RSAPublicKey publicKey, byte[] data) {     
94.         if (publicKey != null) {     
95.             try {     
96.                 Cipher cipher = Cipher.getInstance("RSA",     
97.                         new BouncyCastleProvider());     
98.                 cipher.init(Cipher.ENCRYPT_MODE, publicKey);     
99.                 return cipher.doFinal(data);     
100.             } catch (Exception e) {     
101.                 e.printStackTrace();     
102.             }     
104.         return null;     
107.      * Basic decrypt method    
111.     protected byte[] decrypt(RSAPrivateKey privateKey, byte[] raw) {     
112.         if (privateKey != null) {     
116.                 cipher.init(Cipher.DECRYPT_MODE, privateKey);     
117.                 return cipher.doFinal(raw);     
124.     public static String toHexString(byte[] b) {     
125.         StringBuilder sb = new StringBuilder(b.length * 2);     
126.         for (int i = 0; i < b.length; i++) {     
127.             sb.append(HEXCHAR[(b[i] & 0xf0) >>> 4]);     
128.             sb.append(HEXCHAR[b[i] & 0x0f]);     
130.         return sb.toString();     
132.     public static final byte[] toBytes(String s) {     
133.         byte[] bytes;     
134.         bytes = new byte[s.length() / 2];     
135.         for (int i = 0; i < bytes.length; i++) {     
136.             bytes[i] = (byte) Integer.parseInt(s.substring(2 * i, 2 * i + 2),     
137.                     16);     
139.         return bytes;     
141.     private static char[] HEXCHAR = { '0', '1', '2', '3', '4', '5', '6', '7',     
142.             '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };     

Java中RSA非對稱密鑰加解密使用示例

一、簡介：

　　RSA加密算法是最常用的非對稱加密算法，CFCA在證書服務中離不了它。RSA是第一個比較完善的公開密鑰算法，它既能用于加密，也能用于數字簽名。這個算法經受住了多年深入的密碼分析，雖然密碼分析者既不能證明也不能否定RSA的安全性，但這恰恰說明該算法有一定的可信性，目前它已經成為最流行的公開密鑰算法。

　　二、RSA的公鑰、私鑰的組成，以及加密、解密的公式可見于下表

　　三、使用方式：

　　① 假設A、B機器進行通信，已A機器為主；

　　② A首先需要用自己的私鑰為發送請求資料簽名，并将公鑰一同發送給B；

　　③ B收到資料後，需要用A發送的公鑰進行驗證，已確定收到的資料是未經篡改的；

　　④ B驗簽通過後，處理邏輯，并把處理結果傳回，傳回資料需要用A發送的公鑰進行加密（公鑰加密後，隻能用配對的私鑰解密）；

　　⑤ A收到B傳回的資料，使用私鑰解密，至此，一次資料互動完成。

　　四、代碼示例：

　　1、第一步擷取私鑰，為簽名做準備。

2.      * 讀取私鑰  傳回PrivateKey  
3.      * @param path  包含私鑰的證書路徑  
4.      * @param password  私鑰證書密碼  
5.      * @return 傳回私鑰PrivateKey  
6.      * @throws KeyStoreException  
7.      * @throws NoSuchAlgorithmException  
8.      * @throws CertificateException  
9.      * @throws IOException  
10.      * @throws UnrecoverableKeyException  
12.     private static PrivateKey getPrivateKey(String path,String password)  
13.             throws KeyStoreException, NoSuchAlgorithmException, CertificateException,  
14.             IOException, UnrecoverableKeyException {  
15.         KeyStore ks = KeyStore.getInstance("PKCS12");  
16.         FileInputStream fis = new FileInputStream(path);  
17.         char[] nPassword = null;  
18.         if ((password == null) || password.trim().equals("")) {  
19.             nPassword = null;  
20.         } else {  
21.             nPassword = password.toCharArray();  
23.         ks.load(fis, nPassword);  
24.         fis.close();  
25.         Enumeration<String> en = ks.aliases();  
26.         String keyAlias = null;  
27.         if (en.hasMoreElements()) {  
28.             keyAlias = (String) en.nextElement();  
30.         return (PrivateKey) ks.getKey(keyAlias, nPassword);  

2、簽名示例：通過第一步得到的私鑰，進行簽名操作，具體請看以下代碼：

2.      * 私鑰簽名： 簽名方法如下：BASE64(RSA(MD5(src),privatekey))，其中src為需要簽名的字元串，  
3. privatekey是商戶的CFCA憑證私鑰。  
4.      * @param plainText 待簽名字元串  
5.      * @param path 簽名私鑰路徑  
6.      * @param password  簽名私鑰密碼  
7.      * @return 傳回簽名後的字元串  
10.     public static String sign(String plainText,String path,String password)  
11.             throws Exception  {  
12.         /*  
13.          * MD5加密  
14.          */  
15.         MessageDigest md5 = MessageDigest.getInstance("MD5");  
16.         md5.update(plainText.getBytes("utf-8"));  
17.         byte[] digestBytes = md5.digest();  
19.          * 用私鑰進行簽名 RSA  
20.          * Cipher負責完成加密或解密工作，基于RSA  
22.         Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");  
23.         //ENCRYPT_MODE表示為加密模式  
24.         cipher.init(Cipher.ENCRYPT_MODE, getPrivateKey(path, password));  
25.         //加密  
26.         byte[] rsaBytes = cipher.doFinal(digestBytes);  
27.         //Base64編碼  
28.         return Base64.byteArrayToBase64(rsaBytes);}  

3、B收到資料後，需要使用A提供的公鑰資訊進行驗簽，此處使用公鑰的N、E進行驗簽

　　首先通過公鑰N、E得到公鑰PublicKey，如下：

1. /**   
2.      * 根據公鑰n、e生成公鑰  
3.      * @param modulus   公鑰n串  
4.      * @param publicExponent  公鑰e串  
5.      * @return 傳回公鑰PublicKey  
8.     public static PublicKey getPublickKey(String modulus, String publicExponent)  
10.         KeySpec publicKeySpec = new RSAPublicKeySpec(  
11.                 new BigInteger(modulus, 16), new BigInteger(publicExponent, 16));  
12.         KeyFactory factory = KeyFactory.getInstance("RSA");  
13.         PublicKey publicKey = factory.generatePublic(publicKeySpec);  
14.         return publicKey;  

得到公鑰PublicKey後，再去驗證簽名，代碼如下：

2.      * 用公鑰證書進行驗簽  
3.      * @param message  簽名之前的原文  
4.      * @param cipherText  簽名  
5.      * @param pubKeyn 公鑰n串  
6.      * @param pubKeye 公鑰e串  
7.      * @return boolean 驗簽成功為true,失敗為false  
10.     public static boolean verify(String message, String cipherText,String pubKeyn,  
11.             String pubKeye) throws Exception {  
12.         Cipher c4 = Cipher.getInstance("RSA/ECB/PKCS1Padding");  
13.         // 根據密鑰，對Cipher對象進行初始化,DECRYPT_MODE表示解密模式  
14.         c4.init(Cipher.DECRYPT_MODE, getPublickKey(pubKeyn,pubKeye));  
15.         // 解密  
16.         byte[] desDecTextBytes = c4.doFinal(Base64.base64ToByteArray(cipherText));  
17.         // 得到前置對原文進行的MD5  
18.         String md5Digest1 = Base64.byteArrayToBase64(desDecTextBytes);  
20.         md5.update(message.getBytes("utf-8"));  
22.         // 得到商戶對原文進行的MD5  
23.         String md5Digest2 = Base64.byteArrayToBase64(digestBytes);  
24.         // 驗證簽名  
25.         if (md5Digest1.equals(md5Digest2)) {  
26.             return true;  
28.             return false;  

2.      * 讀取公鑰cer  
3.      * @param path .cer檔案的路徑  如：c:/abc.cer  
4.      * @return  base64後的公鑰串  
8.     public static String getPublicKey(String path) throws IOException,  
9.     CertificateException{  
10.         InputStream inStream = new FileInputStream(path);  
12.         int ch;  
13.         String res = "";  
14.         while ((ch = inStream.read()) != -1) {  
15.             out.write(ch);  
17.         byte[] result = out.toByteArray();  
18.         res = Base64.byteArrayToBase64(result);  
19.         return res;  
20.     }