非对称加密算法-RSA算法

一、概述

 1、RSA是基于大数因子分解难题。目前各种主流计算机语言都支持RSA算法的实现

 2、java6支持RSA算法

 3、RSA算法可以用于数据加密和数字签名

 4、RSA算法相对于DES/AES等对称加密算法，他的速度要慢的多

 5、总原则：公钥加密，私钥解密  /   私钥加密，公钥解密

 

二、模型分析

RSA算法构建密钥对简单的很，这里我们还是以甲乙双方发送数据为模型

1、甲方在本地构建密钥对（公钥+私钥），并将公钥公布给乙方

2、甲方将数据用私钥进行加密，发送给乙方

3、乙方用甲方提供的公钥对数据进行解密

 

如果乙方向传送数据给甲方：

4、乙方用公钥对数据进行加密，然后传送给甲方

5、甲方用私钥对数据进行解密

 

 

三、代码分析

 

[java]  view plain copy

 

1. package com.ca.test;  
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.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. import javax.crypto.interfaces.DHPrivateKey;  
16. import javax.crypto.interfaces.DHPublicKey;  
17. import org.apache.commons.codec.binary.Base64;  
18. /** 
19.  * 非对称加密算法RSA算法组件 
20.  * 非对称算法一般是用来传送对称加密算法的密钥来使用的，相对于DH算法，RSA算法只需要一方构造密钥，不需要 
21.  * 大费周章的构造各自本地的密钥对了。DH算法只能算法非对称算法的底层实现。而RSA算法算法实现起来较为简单 
22.  * @author kongqz 
23.  * */  
24. public class RSACoder {  
25.     //非对称密钥算法  
26.     public static final String KEY_ALGORITHM="RSA";  
27.       
28.       
29.     /** 
30.      * 密钥长度，DH算法的默认密钥长度是1024 
31.      * 密钥长度必须是64的倍数，在512到65536位之间 
32.      * */  
33.     private static final int KEY_SIZE=512;  
34.     //公钥  
35.     private static final String PUBLIC_KEY="RSAPublicKey";  
36.       
37.     //私钥  
38.     private static final String PRIVATE_KEY="RSAPrivateKey";  
39.       
40.     /** 
41.      * 初始化密钥对 
42.      * @return Map 甲方密钥的Map 
43.      * */  
44.     public static Map<String,Object> initKey() throws Exception{  
45.         //实例化密钥生成器  
46.         KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance(KEY_ALGORITHM);  
47.         //初始化密钥生成器  
48.         keyPairGenerator.initialize(KEY_SIZE);  
49.         //生成密钥对  
50.         KeyPair keyPair=keyPairGenerator.generateKeyPair();  
51.         //甲方公钥  
52.         RSAPublicKey publicKey=(RSAPublicKey) keyPair.getPublic();  
53.         //甲方私钥  
54.         RSAPrivateKey privateKey=(RSAPrivateKey) keyPair.getPrivate();  
55.         //将密钥存储在map中  
56.         Map<String,Object> keyMap=new HashMap<String,Object>();  
57.         keyMap.put(PUBLIC_KEY, publicKey);  
58.         keyMap.put(PRIVATE_KEY, privateKey);  
59.         return keyMap;  
60.           
61.     }  
62.       
63.       
64.     /** 
65.      * 私钥加密 
66.      * @param data待加密数据 
67.      * @param key 密钥 
68.      * @return byte[] 加密数据 
69.      * */  
70.     public static byte[] encryptByPrivateKey(byte[] data,byte[] key) throws Exception{  
71.           
72.         //取得私钥  
73.         PKCS8EncodedKeySpec pkcs8KeySpec=new PKCS8EncodedKeySpec(key);  
74.         KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);  
75.         //生成私钥  
76.         PrivateKey privateKey=keyFactory.generatePrivate(pkcs8KeySpec);  
77.         //数据加密  
78.         Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());  
79.         cipher.init(Cipher.ENCRYPT_MODE, privateKey);  
80.         return cipher.doFinal(data);  
81.     }  
82.     /** 
83.      * 公钥加密 
84.      * @param data待加密数据 
85.      * @param key 密钥 
86.      * @return byte[] 加密数据 
87.      * */  
88.     public static byte[] encryptByPublicKey(byte[] data,byte[] key) throws Exception{  
89.           
90.         //实例化密钥工厂  
91.         KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);  
92.         //初始化公钥  
93.         //密钥材料转换  
94.         X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(key);  
95.         //产生公钥  
96.         PublicKey pubKey=keyFactory.generatePublic(x509KeySpec);  
97.           
98.         //数据加密  
99.         Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());  
100.         cipher.init(Cipher.ENCRYPT_MODE, pubKey);  
101.         return cipher.doFinal(data);  
102.     }  
103.     /** 
104.      * 私钥解密 
105.      * @param data 待解密数据 
106.      * @param key 密钥 
107.      * @return byte[] 解密数据 
108.      * */  
109.     public static byte[] decryptByPrivateKey(byte[] data,byte[] key) throws Exception{  
110.         //取得私钥  
111.         PKCS8EncodedKeySpec pkcs8KeySpec=new PKCS8EncodedKeySpec(key);  
112.         KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);  
113.         //生成私钥  
114.         PrivateKey privateKey=keyFactory.generatePrivate(pkcs8KeySpec);  
115.         //数据解密  
116.         Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());  
117.         cipher.init(Cipher.DECRYPT_MODE, privateKey);  
118.         return cipher.doFinal(data);  
119.     }  
120.     /** 
121.      * 公钥解密 
122.      * @param data 待解密数据 
123.      * @param key 密钥 
124.      * @return byte[] 解密数据 
125.      * */  
126.     public static byte[] decryptByPublicKey(byte[] data,byte[] key) throws Exception{  
127.           
128.         //实例化密钥工厂  
129.         KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);  
130.         //初始化公钥  
131.         //密钥材料转换  
132.         X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(key);  
133.         //产生公钥  
134.         PublicKey pubKey=keyFactory.generatePublic(x509KeySpec);  
135.         //数据解密  
136.         Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());  
137.         cipher.init(Cipher.DECRYPT_MODE, pubKey);  
138.         return cipher.doFinal(data);  
139.     }  
140.     /** 
141.      * 取得私钥 
142.      * @param keyMap 密钥map 
143.      * @return byte[] 私钥 
144.      * */  
145.     public static byte[] getPrivateKey(Map<String,Object> keyMap){  
146.         Key key=(Key)keyMap.get(PRIVATE_KEY);  
147.         return key.getEncoded();  
148.     }  
149.     /** 
150.      * 取得公钥 
151.      * @param keyMap 密钥map 
152.      * @return byte[] 公钥 
153.      * */  
154.     public static byte[] getPublicKey(Map<String,Object> keyMap) throws Exception{  
155.         Key key=(Key) keyMap.get(PUBLIC_KEY);  
156.         return key.getEncoded();  
157.     }  
158.     /** 
159.      * @param args 
160.      * @throws Exception  
161.      */  
162.     public static void main(String[] args) throws Exception {  
163.         //初始化密钥  
164.         //生成密钥对  
165.         Map<String,Object> keyMap=RSACoder.initKey();  
166.         //公钥  
167.         byte[] publicKey=RSACoder.getPublicKey(keyMap);  
168.           
169.         //私钥  
170.         byte[] privateKey=RSACoder.getPrivateKey(keyMap);  
171.         System.out.println("公钥：/n"+Base64.encodeBase64String(publicKey));  
172.         System.out.println("私钥：/n"+Base64.encodeBase64String(privateKey));  
173.           
174.         System.out.println("================密钥对构造完毕,甲方将公钥公布给乙方，开始进行加密数据的传输=============");  
175.         String str="RSA密码交换算法";  
176.         System.out.println("/n===========甲方向乙方发送加密数据==============");  
177.         System.out.println("原文:"+str);  
178.         //甲方进行数据的加密  
179.         byte[] code1=RSACoder.encryptByPrivateKey(str.getBytes(), privateKey);  
180.         System.out.println("加密后的数据："+Base64.encodeBase64String(code1));  
181.         System.out.println("===========乙方使用甲方提供的公钥对数据进行解密==============");  
182.         //乙方进行数据的解密  
183.         byte[] decode1=RSACoder.decryptByPublicKey(code1, publicKey);  
184.         System.out.println("乙方解密后的数据："+new String(decode1)+"/n/n");  
185.           
186.         System.out.println("===========反向进行操作，乙方向甲方发送数据==============/n/n");  
187.           
188.         str="乙方向甲方发送数据RSA算法";  
189.           
190.         System.out.println("原文:"+str);  
191.           
192.         //乙方使用公钥对数据进行加密  
193.         byte[] code2=RSACoder.encryptByPublicKey(str.getBytes(), publicKey);  
194.         System.out.println("===========乙方使用公钥对数据进行加密==============");  
195.         System.out.println("加密后的数据："+Base64.encodeBase64String(code2));  
196.           
197.         System.out.println("=============乙方将数据传送给甲方======================");  
198.         System.out.println("===========甲方使用私钥对数据进行解密==============");  
199.           
200.         //甲方使用私钥对数据进行解密  
201.         byte[] decode2=RSACoder.decryptByPrivateKey(code2, privateKey);  
202.           
203.         System.out.println("甲方解密后的数据："+new String(decode2));  
204.     }  
205. }  
206.   
207. 控制台输出：  
208. 公钥：  
209. MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAM0qc+eVm4pyBbCBuM4jRxOYsxWkylLXVklyWp3JNs71  
210. B6vLVg2Iwh6TwPbpXbGWOI11RMLhe5bwLpdeBqP4f4MCAwEAAQ==  
211. 私钥：  
212. MIIBVQIBADANBgkqhkiG9w0BAQEFAASCAT8wggE7AgEAAkEAzSpz55WbinIFsIG4ziNHE5izFaTK  
213. UtdWSXJanck2zvUHq8tWDYjCHpPA9uldsZY4jXVEwuF7lvAul14Go/h/gwIDAQABAkByhW3pKSOH  
214. Zhoy6lYkCqEUGTptrGybTUQG/2QBi12iqzenm7rKlasjdMEr6Q8RX5RpGArzvhvLepAPqPZ5LXjR  
215. AiEA7vI8/9HHrZSbHQ4Up7xby7bOULknoRjZy68HRMPRSXUCIQDbzwQfvrYNqLiauTcNsg6ejCJw  
216. cxSCLlJupgwBBjyOFwIgVEbWIviPr/ZpGz9bI6o4ykoozKnxg01ri/6o1qUmTP0CIQDBC0XO73oJ  
217. 8vT2BdZA8/D884vHgHoxfqcswC3otGZ4TwIhANGXz8GHxM0zuOg8pds54S1ARlrkUXFULocVZ2Ka  
218. ngFf  
219. ================密钥对构造完毕,甲方将公钥公布给乙方，开始进行加密数据的传输=============  
220. ===========甲方向乙方发送加密数据==============  
221. 原文:RSA密码交换算法  
222. 加密后的数据：kF3vekz0DpJmLzwdrWjfZLyGBWsKzFOwm+8im85KZr6QA49csvCl9KgsfjSVLuXwgsPrFoEhkiqQ  
223. 0+VApr001A==  
224. ===========乙方使用甲方提供的公钥对数据进行解密==============  
225. 乙方解密后的数据：RSA密码交换算法  
226.   
227. ===========反向进行操作，乙方向甲方发送数据==============  
228.   
229. 原文:乙方向甲方发送数据RSA算法  
230. ===========乙方使用公钥对数据进行加密==============  
231. 加密后的数据：xM1MB3DlDKRwSozf9z8YQlftrWpKT8lkabi17cN/ZLOEkOO8jVLKVAjpjsMwtJMcpHTjntdkHKOm  
232. s1V8xbh3og==  
233. =============乙方将数据传送给甲方======================  
234. ===========甲方使用私钥对数据进行解密==============  
235. 甲方解密后的数据：乙方向甲方发送数据RSA算法  

 

四、总结

1、RSA与DH算法不同，只需要一套密钥就能完成加密、解密的工作

2、通过代码能看出来，公钥长度明显小于私钥

3、遵循：公钥加密-私钥解密，私钥加密-公钥解密的原则

4、公钥和私钥肯定是完全不同