Java加密技術（四）

    接下來我們介紹典型的非對稱加密算法——RSA

RSA

    這種算法1978年就出現了，它是第一個既能用于資料加密也能用于數字簽名的算法。它易于了解和操作，也很流行。算法的名字以發明者的名字命名：Ron Rivest, AdiShamir 和Leonard Adleman。

    這種加密算法的特點主要是密鑰的變化，上文我們看到DES隻有一個密鑰。相當于隻有一把鑰匙，如果這把鑰匙丢了，資料也就不安全了。RSA同時有兩把鑰匙，公鑰與私鑰。同時支援數字簽名。數字簽名的意義在于，對傳輸過來的資料進行校驗。確定資料在傳輸工程中不被修改。

流程分析：

1. 甲方建構密鑰對兒，将公鑰公布給乙方，将私鑰保留。
2. 甲方使用私鑰加密資料，然後用私鑰對加密後的資料簽名，發送給乙方簽名以及加密後的資料；乙方使用公鑰、簽名來驗證待解密資料是否有效，如果有效使用公鑰對資料解密。
3. 乙方使用公鑰加密資料，向甲方發送經過加密後的資料；甲方獲得加密資料，通過私鑰解密。

按如上步驟給出序列圖，如下：

1. 

2. 

3. 

通過java代碼實作如下： Coder類見 Java加密技術（一）

Java代碼

1. import java.security.Key;   
2. import java.security.KeyFactory;   
3. import java.security.KeyPair;   
4. import java.security.KeyPairGenerator;   
5. import java.security.PrivateKey;   
6. import java.security.PublicKey;   
7. import java.security.Signature;   
8. import java.security.interfaces.RSAPrivateKey;   
9. import java.security.interfaces.RSAPublicKey;   
10. import java.security.spec.PKCS8EncodedKeySpec;   
11. import java.security.spec.X509EncodedKeySpec;   
12. import java.util.HashMap;   
13. import java.util.Map;   
14. import javax.crypto.Cipher;   
15. public abstract class RSACoder extends Coder {   
16.     public static final String KEY_ALGORITHM = "RSA";   
17.     public static final String SIGNATURE_ALGORITHM = "MD5withRSA";   
18.     private static final String PUBLIC_KEY = "RSAPublicKey";   
19.     private static final String PRIVATE_KEY = "RSAPrivateKey";   
20.     public static String sign(byte[] data, String privateKey) throws Exception {   
21.         // 解密由base64編碼的私鑰   
22.         byte[] keyBytes = decryptBASE64(privateKey);   
23.         // 構造PKCS8EncodedKeySpec對象   
24.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);   
25.         // KEY_ALGORITHM 指定的加密算法   
26.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);   
27.         // 取私鑰匙對象   
28.         PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);   
29.         // 用私鑰對資訊生成數字簽名   
30.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);   
31.         signature.initSign(priKey);   
32.         signature.update(data);   
33.         return encryptBASE64(signature.sign());   
34.     }   
35.     public static boolean verify(byte[] data, String publicKey, String sign)   
36.             throws Exception {   
37.         // 解密由base64編碼的公鑰   
38.         byte[] keyBytes = decryptBASE64(publicKey);   
39.         // 構造X509EncodedKeySpec對象   
40.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);   
41.         // KEY_ALGORITHM 指定的加密算法   
42.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);   
43.         // 取公鑰匙對象   
44.         PublicKey pubKey = keyFactory.generatePublic(keySpec);   
45.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);   
46.         signature.initVerify(pubKey);   
47.         signature.update(data);   
48.         // 驗證簽名是否正常   
49.         return signature.verify(decryptBASE64(sign));   
50.     }   
51.     public static byte[] decryptByPrivateKey(byte[] data, String key)   
52.             throws Exception {   
53.         // 對密鑰解密   
54.         byte[] keyBytes = decryptBASE64(key);   
55.         // 取得私鑰   
56.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);   
57.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);   
58.         Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);   
59.         // 對資料解密   
60.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());   
61.         cipher.init(Cipher.DECRYPT_MODE, privateKey);   
62.         return cipher.doFinal(data);   
63.     }   
64.     public static byte[] decryptByPublicKey(byte[] data, String key)   
65.             throws Exception {   
66.         // 對密鑰解密   
67.         byte[] keyBytes = decryptBASE64(key);   
68.         // 取得公鑰   
69.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);   
70.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);   
71.         Key publicKey = keyFactory.generatePublic(x509KeySpec);   
72.         // 對資料解密   
73.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());   
74.         cipher.init(Cipher.DECRYPT_MODE, publicKey);   
75.         return cipher.doFinal(data);   
76.     }   
77.     public static byte[] encryptByPublicKey(byte[] data, String key)   
78.             throws Exception {   
79.         // 對公鑰解密   
80.         byte[] keyBytes = decryptBASE64(key);   
81.         // 取得公鑰   
82.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);   
83.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);   
84.         Key publicKey = keyFactory.generatePublic(x509KeySpec);   
85.         // 對資料加密   
86.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());   
87.         cipher.init(Cipher.ENCRYPT_MODE, publicKey);   
88.         return cipher.doFinal(data);   
89.     }   
90.     public static byte[] encryptByPrivateKey(byte[] data, String key)   
91.             throws Exception {   
92.         // 對密鑰解密   
93.         byte[] keyBytes = decryptBASE64(key);   
94.         // 取得私鑰   
95.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);   
96.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);   
97.         Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);   
98.         // 對資料加密   
99.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());   
100.         cipher.init(Cipher.ENCRYPT_MODE, privateKey);   
101.         return cipher.doFinal(data);   
102.     }   
103.     public static String getPrivateKey(Map<String, Object> keyMap)   
104.             throws Exception {   
105.         Key key = (Key) keyMap.get(PRIVATE_KEY);   
106.         return encryptBASE64(key.getEncoded());   
107.     }   
108.     public static String getPublicKey(Map<String, Object> keyMap)   
109.             throws Exception {   
110.         Key key = (Key) keyMap.get(PUBLIC_KEY);   
111.         return encryptBASE64(key.getEncoded());   
112.     }   
113.     public static Map<String, Object> initKey() throws Exception {   
114.         KeyPairGenerator keyPairGen = KeyPairGenerator   
115.                 .getInstance(KEY_ALGORITHM);   
116.         keyPairGen.initialize(1024);   
117.         KeyPair keyPair = keyPairGen.generateKeyPair();   
118.         // 公鑰   
119.         RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();   
120.         // 私鑰   
121.         RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();   
122.         Map<String, Object> keyMap = new HashMap<String, Object>(2);   
123.         keyMap.put(PUBLIC_KEY, publicKey);   
124.         keyMap.put(PRIVATE_KEY, privateKey);   
125.         return keyMap;   
126.     }   
127. }  

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.Signature;
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 javax.crypto.Cipher;

/**
 * RSA安全編碼元件
 * 
 * @author 梁棟
 * @version 1.0
 * @since 1.0
 */
public abstract class RSACoder extends Coder {
	public static final String KEY_ALGORITHM = "RSA";
	public static final String SIGNATURE_ALGORITHM = "MD5withRSA";

	private static final String PUBLIC_KEY = "RSAPublicKey";
	private static final String PRIVATE_KEY = "RSAPrivateKey";

	/**
	 * 用私鑰對資訊生成數字簽名
	 * 
	 * @param data
	 *            加密資料
	 * @param privateKey
	 *            私鑰
	 * 
	 * @return
	 * @throws Exception
	 */
	public static String sign(byte[] data, String privateKey) throws Exception {
		// 解密由base64編碼的私鑰
		byte[] keyBytes = decryptBASE64(privateKey);

		// 構造PKCS8EncodedKeySpec對象
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

		// KEY_ALGORITHM 指定的加密算法
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

		// 取私鑰匙對象
		PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);

		// 用私鑰對資訊生成數字簽名
		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
		signature.initSign(priKey);
		signature.update(data);

		return encryptBASE64(signature.sign());
	}

	/**
	 * 校驗數字簽名
	 * 
	 * @param data
	 *            加密資料
	 * @param publicKey
	 *            公鑰
	 * @param sign
	 *            數字簽名
	 * 
	 * @return 校驗成功傳回true 失敗傳回false
	 * @throws Exception
	 * 
	 */
	public static boolean verify(byte[] data, String publicKey, String sign)
			throws Exception {

		// 解密由base64編碼的公鑰
		byte[] keyBytes = decryptBASE64(publicKey);

		// 構造X509EncodedKeySpec對象
		X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

		// KEY_ALGORITHM 指定的加密算法
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

		// 取公鑰匙對象
		PublicKey pubKey = keyFactory.generatePublic(keySpec);

		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
		signature.initVerify(pubKey);
		signature.update(data);

		// 驗證簽名是否正常
		return signature.verify(decryptBASE64(sign));
	}

	/**
	 * 解密<br>
	 * 用私鑰解密
	 * 
	 * @param data
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static byte[] decryptByPrivateKey(byte[] data, String key)
			throws Exception {
		// 對密鑰解密
		byte[] keyBytes = decryptBASE64(key);

		// 取得私鑰
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);

		// 對資料解密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.DECRYPT_MODE, privateKey);

		return cipher.doFinal(data);
	}

	/**
	 * 解密<br>
	 * 用私鑰解密
	 * 
	 * @param data
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static byte[] decryptByPublicKey(byte[] data, String key)
			throws Exception {
		// 對密鑰解密
		byte[] keyBytes = decryptBASE64(key);

		// 取得公鑰
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		Key publicKey = keyFactory.generatePublic(x509KeySpec);

		// 對資料解密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.DECRYPT_MODE, publicKey);

		return cipher.doFinal(data);
	}

	/**
	 * 加密<br>
	 * 用公鑰加密
	 * 
	 * @param data
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static byte[] encryptByPublicKey(byte[] data, String key)
			throws Exception {
		// 對公鑰解密
		byte[] keyBytes = decryptBASE64(key);

		// 取得公鑰
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		Key publicKey = keyFactory.generatePublic(x509KeySpec);

		// 對資料加密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.ENCRYPT_MODE, publicKey);

		return cipher.doFinal(data);
	}

	/**
	 * 加密<br>
	 * 用私鑰加密
	 * 
	 * @param data
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static byte[] encryptByPrivateKey(byte[] data, String key)
			throws Exception {
		// 對密鑰解密
		byte[] keyBytes = decryptBASE64(key);

		// 取得私鑰
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);

		// 對資料加密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.ENCRYPT_MODE, privateKey);

		return cipher.doFinal(data);
	}

	/**
	 * 取得私鑰
	 * 
	 * @param keyMap
	 * @return
	 * @throws Exception
	 */
	public static String getPrivateKey(Map<String, Object> keyMap)
			throws Exception {
		Key key = (Key) keyMap.get(PRIVATE_KEY);

		return encryptBASE64(key.getEncoded());
	}

	/**
	 * 取得公鑰
	 * 
	 * @param keyMap
	 * @return
	 * @throws Exception
	 */
	public static String getPublicKey(Map<String, Object> keyMap)
			throws Exception {
		Key key = (Key) keyMap.get(PUBLIC_KEY);

		return encryptBASE64(key.getEncoded());
	}

	/**
	 * 初始化密鑰
	 * 
	 * @return
	 * @throws Exception
	 */
	public static Map<String, Object> initKey() throws Exception {
		KeyPairGenerator keyPairGen = KeyPairGenerator
				.getInstance(KEY_ALGORITHM);
		keyPairGen.initialize(1024);

		KeyPair keyPair = keyPairGen.generateKeyPair();

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

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

		Map<String, Object> keyMap = new HashMap<String, Object>(2);

		keyMap.put(PUBLIC_KEY, publicKey);
		keyMap.put(PRIVATE_KEY, privateKey);
		return keyMap;
	}
}
           

再給出一個測試類：

Java代碼

1. import static org.junit.Assert.*;   
2. import org.junit.Before;   
3. import org.junit.Test;   
4. import java.util.Map;   
5. public class RSACoderTest {   
6.     private String publicKey;   
7.     private String privateKey;   
8.     @Before  
9.     public void setUp() throws Exception {   
10.         Map<String, Object> keyMap = RSACoder.initKey();   
11.         publicKey = RSACoder.getPublicKey(keyMap);   
12.         privateKey = RSACoder.getPrivateKey(keyMap);   
13.         System.err.println("公鑰: \n\r" + publicKey);   
14.         System.err.println("私鑰： \n\r" + privateKey);   
15.     }   
16.     @Test  
17.     public void test() throws Exception {   
18.         System.err.println("公鑰加密——私鑰解密");   
19.         String inputStr = "abc";   
20.         byte[] data = inputStr.getBytes();   
21.         byte[] encodedData = RSACoder.encryptByPublicKey(data, publicKey);   
22.         byte[] decodedData = RSACoder.decryptByPrivateKey(encodedData,   
23.                 privateKey);   
24.         String outputStr = new String(decodedData);   
25.         System.err.println("加密前: " + inputStr + "\n\r" + "解密後: " + outputStr);   
26.         assertEquals(inputStr, outputStr);   
27.     }   
28.     @Test  
29.     public void testSign() throws Exception {   
30.         System.err.println("私鑰加密——公鑰解密");   
31.         String inputStr = "sign";   
32.         byte[] data = inputStr.getBytes();   
33.         byte[] encodedData = RSACoder.encryptByPrivateKey(data, privateKey);   
34.         byte[] decodedData = RSACoder   
35.                 .decryptByPublicKey(encodedData, publicKey);   
36.         String outputStr = new String(decodedData);   
37.         System.err.println("加密前: " + inputStr + "\n\r" + "解密後: " + outputStr);   
38.         assertEquals(inputStr, outputStr);   
39.         System.err.println("私鑰簽名——公鑰驗證簽名");   
40.         // 産生簽名   
41.         String sign = RSACoder.sign(encodedData, privateKey);   
42.         System.err.println("簽名:\r" + sign);   
43.         // 驗證簽名   
44.         boolean status = RSACoder.verify(encodedData, publicKey, sign);   
45.         System.err.println("狀态:\r" + status);   
46.         assertTrue(status);   
47.     }   
48. }  

import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Test;

import java.util.Map;

/**
 * 
 * @author 梁棟
 * @version 1.0
 * @since 1.0
 */
public class RSACoderTest {
	private String publicKey;
	private String privateKey;

	@Before
	public void setUp() throws Exception {
		Map<String, Object> keyMap = RSACoder.initKey();

		publicKey = RSACoder.getPublicKey(keyMap);
		privateKey = RSACoder.getPrivateKey(keyMap);
		System.err.println("公鑰: \n\r" + publicKey);
		System.err.println("私鑰： \n\r" + privateKey);
	}

	@Test
	public void test() throws Exception {
		System.err.println("公鑰加密——私鑰解密");
		String inputStr = "abc";
		byte[] data = inputStr.getBytes();

		byte[] encodedData = RSACoder.encryptByPublicKey(data, publicKey);

		byte[] decodedData = RSACoder.decryptByPrivateKey(encodedData,
				privateKey);

		String outputStr = new String(decodedData);
		System.err.println("加密前: " + inputStr + "\n\r" + "解密後: " + outputStr);
		assertEquals(inputStr, outputStr);

	}

	@Test
	public void testSign() throws Exception {
		System.err.println("私鑰加密——公鑰解密");
		String inputStr = "sign";
		byte[] data = inputStr.getBytes();

		byte[] encodedData = RSACoder.encryptByPrivateKey(data, privateKey);

		byte[] decodedData = RSACoder
				.decryptByPublicKey(encodedData, publicKey);

		String outputStr = new String(decodedData);
		System.err.println("加密前: " + inputStr + "\n\r" + "解密後: " + outputStr);
		assertEquals(inputStr, outputStr);

		System.err.println("私鑰簽名——公鑰驗證簽名");
		// 産生簽名
		String sign = RSACoder.sign(encodedData, privateKey);
		System.err.println("簽名:\r" + sign);

		// 驗證簽名
		boolean status = RSACoder.verify(encodedData, publicKey, sign);
		System.err.println("狀态:\r" + status);
		assertTrue(status);

	}

}
           

控制台輸出：

Console代碼

1. 公鑰:    
2. MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCYU/+I0+z1aBl5X6DUUOHQ7FZpmBSDbKTtx89J   
3. EcB64jFCkunELT8qiKly7fzEqD03g8ALlu5XvX+bBqHFy7YPJJP0ekE2X3wjUnh2NxlqpH3/B/xm   
4. 1ZdSlCwDIkbijhBVDjA/bu5BObhZqQmDwIxlQInL9oVz+o6FbAZCyHBd7wIDAQAB   
5. 私鑰：    
6. MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAJhT/4jT7PVoGXlfoNRQ4dDsVmmY   
7. FINspO3Hz0kRwHriMUKS6cQtPyqIqXLt/MSoPTeDwAuW7le9f5sGocXLtg8kk/R6QTZffCNSeHY3   
8. GWqkff8H/GbVl1KULAMiRuKOEFUOMD9u7kE5uFmpCYPAjGVAicv2hXP6joVsBkLIcF3vAgMBAAEC   
9. gYBvZHWoZHmS2EZQqKqeuGr58eobG9hcZzWQoJ4nq/CarBAjw/VovUHE490uK3S9ht4FW7Yzg3LV   
10. /MB06Huifh6qf/X9NQA7SeZRRC8gnCQk6JuDIEVJOud5jU+9tyumJakDKodQ3Jf2zQtNr+5ZdEPl   
11. uwWgv9c4kmpjhAdyMuQmYQJBANn6pcgvyYaia52dnu+yBUsGkaFfwXkzFSExIbi0MXTkhEb/ER/D   
12. rLytukkUu5S5ecz/KBa8U4xIslZDYQbLz5ECQQCy5dutt7RsxN4+dxCWn0/1FrkWl2G329Ucewm3   
13. QU9CKu4D+7Kqdj+Ha3lXP8F0Etaaapi7+EfkRUpukn2ItZV/AkEAlk+I0iphxT1rCB0Q5CjWDY5S   
14. Df2B5JmdEG5Y2o0nLXwG2w44OLct/k2uD4cEcuITY5Dvi/4BftMCZwm/dnhEgQJACIktJSnJwxLV   
15. o9dchENPtlsCM9C/Sd2EWpqISSUlmfugZbJBwR5pQ5XeMUqKeXZYpP+HEBj1nS+tMH9u2/IGEwJA   
16. fL8mZiZXan/oBKrblAbplNcKWGRVD/3y65042PAEeghahlJMiYquV5DzZajuuT0wbJ5xQuZB01+X   
17. nfpFpBJ2dw==   
18. 公鑰加密——私鑰解密   
19. 加密前: abc   
20. 解密後: abc   
21. 公鑰:    
22. MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDdOj40yEB48XqWxmPILmJAc7UecIN7F32etSHF   
23. 9rwbuEh3+iTPOGSxhoSQpOED0vOb0ZIMkBXZSgsxLaBSin2RZ09YKWRjtpCA0kDkiD11gj4tzTiM   
24. l9qq1kwSK7ZkGAgodEn3yIILVmQDuEImHOXFtulvJ71ka07u3LuwUNdB/wIDAQAB   
25. 私鑰：    
26. MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAN06PjTIQHjxepbGY8guYkBztR5w   
27. g3sXfZ61IcX2vBu4SHf6JM84ZLGGhJCk4QPS85vRkgyQFdlKCzEtoFKKfZFnT1gpZGO2kIDSQOSI   
28. PXWCPi3NOIyX2qrWTBIrtmQYCCh0SffIggtWZAO4QiYc5cW26W8nvWRrTu7cu7BQ10H/AgMBAAEC   
29. gYEAz2JWBizjI31bqhP4XiP9PuY5F3vqBW4T+L9cFbQiyumKJc58yzTWUAUGKIIn3enXLG7dNqGr   
30. mbJro4JeFIJ3CiVDpXR9+FluIgI4SXm7ioGKF2NOMA9LR5Fu82W+pLfpTN2y2SaLYWEDZyp53BxY   
31. j9gUxaxi1MQs+C1ZgDF2xmECQQDy70bQntbRfysP+ppCtd56YRnES1Tyekw0wryS2tr+ivQJl7JF   
32. gp5rPAOXpgrq36xHDwUspQ0sJ0vj0O7ywxr1AkEA6SAaLhrJJrYucC0jxwAhUYyaPN+aOsWymaRh   
33. 9jA/Wc0wp29SbGTh5CcMuGpXm1g0M+FKW3dGiHgS3rVUKim4owJAbnxgapUzAgiiHxxMeDaavnHW   
34. 9C2GrtjsO7qtZOTgYI/1uT8itvZW8lJTF+9OW8/qXE76fXl7ai9dFnl5kzMk2QJBALfHz/vCsArt   
35. mkRiwY6zApE4Z6tPl1V33ymSVovvUzHnOdD1SKQdD5t+UV/crb3QVi8ED0t2B0u0ZSPfDT/D7kMC   
36. QDpwdj9k2F5aokLHBHUNJPFDAp7a5QMaT64gv/d48ITJ68Co+v5WzLMpzJBYXK6PAtqIhxbuPEc2   
37. I2k1Afmrwyw=   
38. 私鑰加密——公鑰解密   
39. 加密前: sign   
40. 解密後: sign   
41. 私鑰簽名——公鑰驗證簽名   
42. 簽名:   
43. ud1RsIwmSC1pN22I4IXteg1VD2FbiehKUfNxgVSHzvQNIK+d20FCkHCqh9djP3h94iWnIUY0ifU+   
44. mbJkhAl/i5krExOE0hknOnPMcEP+lZV1RbJI2zG2YooSp2XDleqrQk5e/QF2Mx0Zxt8Xsg7ucVpn   
45. i3wwbYWs9wSzIf0UjlM=   
46. 狀态:   
47. true  

公鑰: 

MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCYU/+I0+z1aBl5X6DUUOHQ7FZpmBSDbKTtx89J
EcB64jFCkunELT8qiKly7fzEqD03g8ALlu5XvX+bBqHFy7YPJJP0ekE2X3wjUnh2NxlqpH3/B/xm
1ZdSlCwDIkbijhBVDjA/bu5BObhZqQmDwIxlQInL9oVz+o6FbAZCyHBd7wIDAQAB

私鑰： 

MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAJhT/4jT7PVoGXlfoNRQ4dDsVmmY
FINspO3Hz0kRwHriMUKS6cQtPyqIqXLt/MSoPTeDwAuW7le9f5sGocXLtg8kk/R6QTZffCNSeHY3
GWqkff8H/GbVl1KULAMiRuKOEFUOMD9u7kE5uFmpCYPAjGVAicv2hXP6joVsBkLIcF3vAgMBAAEC
gYBvZHWoZHmS2EZQqKqeuGr58eobG9hcZzWQoJ4nq/CarBAjw/VovUHE490uK3S9ht4FW7Yzg3LV
/MB06Huifh6qf/X9NQA7SeZRRC8gnCQk6JuDIEVJOud5jU+9tyumJakDKodQ3Jf2zQtNr+5ZdEPl
uwWgv9c4kmpjhAdyMuQmYQJBANn6pcgvyYaia52dnu+yBUsGkaFfwXkzFSExIbi0MXTkhEb/ER/D
rLytukkUu5S5ecz/KBa8U4xIslZDYQbLz5ECQQCy5dutt7RsxN4+dxCWn0/1FrkWl2G329Ucewm3
QU9CKu4D+7Kqdj+Ha3lXP8F0Etaaapi7+EfkRUpukn2ItZV/AkEAlk+I0iphxT1rCB0Q5CjWDY5S
Df2B5JmdEG5Y2o0nLXwG2w44OLct/k2uD4cEcuITY5Dvi/4BftMCZwm/dnhEgQJACIktJSnJwxLV
o9dchENPtlsCM9C/Sd2EWpqISSUlmfugZbJBwR5pQ5XeMUqKeXZYpP+HEBj1nS+tMH9u2/IGEwJA
fL8mZiZXan/oBKrblAbplNcKWGRVD/3y65042PAEeghahlJMiYquV5DzZajuuT0wbJ5xQuZB01+X
nfpFpBJ2dw==

公鑰加密——私鑰解密
加密前: abc

解密後: abc
公鑰: 

MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDdOj40yEB48XqWxmPILmJAc7UecIN7F32etSHF
9rwbuEh3+iTPOGSxhoSQpOED0vOb0ZIMkBXZSgsxLaBSin2RZ09YKWRjtpCA0kDkiD11gj4tzTiM
l9qq1kwSK7ZkGAgodEn3yIILVmQDuEImHOXFtulvJ71ka07u3LuwUNdB/wIDAQAB

私鑰： 

MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAN06PjTIQHjxepbGY8guYkBztR5w
g3sXfZ61IcX2vBu4SHf6JM84ZLGGhJCk4QPS85vRkgyQFdlKCzEtoFKKfZFnT1gpZGO2kIDSQOSI
PXWCPi3NOIyX2qrWTBIrtmQYCCh0SffIggtWZAO4QiYc5cW26W8nvWRrTu7cu7BQ10H/AgMBAAEC
gYEAz2JWBizjI31bqhP4XiP9PuY5F3vqBW4T+L9cFbQiyumKJc58yzTWUAUGKIIn3enXLG7dNqGr
mbJro4JeFIJ3CiVDpXR9+FluIgI4SXm7ioGKF2NOMA9LR5Fu82W+pLfpTN2y2SaLYWEDZyp53BxY
j9gUxaxi1MQs+C1ZgDF2xmECQQDy70bQntbRfysP+ppCtd56YRnES1Tyekw0wryS2tr+ivQJl7JF
gp5rPAOXpgrq36xHDwUspQ0sJ0vj0O7ywxr1AkEA6SAaLhrJJrYucC0jxwAhUYyaPN+aOsWymaRh
9jA/Wc0wp29SbGTh5CcMuGpXm1g0M+FKW3dGiHgS3rVUKim4owJAbnxgapUzAgiiHxxMeDaavnHW
9C2GrtjsO7qtZOTgYI/1uT8itvZW8lJTF+9OW8/qXE76fXl7ai9dFnl5kzMk2QJBALfHz/vCsArt
mkRiwY6zApE4Z6tPl1V33ymSVovvUzHnOdD1SKQdD5t+UV/crb3QVi8ED0t2B0u0ZSPfDT/D7kMC
QDpwdj9k2F5aokLHBHUNJPFDAp7a5QMaT64gv/d48ITJ68Co+v5WzLMpzJBYXK6PAtqIhxbuPEc2
I2k1Afmrwyw=

私鑰加密——公鑰解密
加密前: sign

解密後: sign
私鑰簽名——公鑰驗證簽名
簽名:
ud1RsIwmSC1pN22I4IXteg1VD2FbiehKUfNxgVSHzvQNIK+d20FCkHCqh9djP3h94iWnIUY0ifU+
mbJkhAl/i5krExOE0hknOnPMcEP+lZV1RbJI2zG2YooSp2XDleqrQk5e/QF2Mx0Zxt8Xsg7ucVpn
i3wwbYWs9wSzIf0UjlM=

狀态:
true

      

    簡要總結一下，使用公鑰加密、私鑰解密，完成了乙方到甲方的一次資料傳遞，通過私鑰加密、公鑰解密，同時通過私鑰簽名、公鑰驗證簽名，完成了一次甲方到乙方的資料傳遞與驗證，兩次資料傳遞完成一整套的資料互動！