加密算法使用（五）：RSA使用全过程

加密算法使⽤（五）：RSA使⽤全过程
RSA是⼀种⾮对称加密算法，使⽤RSA前先⽣成⼀对公钥和私钥。

使⽤公钥加密的数据可以⽤私钥解密，同样私钥加密的数据也可以⽤公钥解密，
不同之处在于，私钥加密数据的同时还可以⽣成⼀组签名，签名是⽤来验证数据是否在传输过程中有变动的，使⽤公钥、签名、以及公钥加密后的数据，就可以验证是否有变动，当然也可以不验证。

代码⽰例如下，两个main⽅法：main和main1。

加密解密都是针对byte数组的，考虑到我们实际使⽤的时候⼤部分场景应该是⽤字符串来传递数据，所以演⽰代码中频繁的将byte数组转化为字符串，有些byte数组不是从字符串直接转化来的，直接通过new String的⽅式转字符串会出现乱码，所以⽤到了Base64来解决这⼀问题。

另外，演⽰代码为了⽅便看到全过程，基本上没有抽出⽅法，实际使⽤的时候建议重构⼀下。

说明就到此为⽌，代码如下：
1package testEncrypt;
2
3import java.security.Key;
4import java.security.KeyFactory;
5import java.security.KeyPair;
6import java.security.KeyPairGenerator;
7import java.security.NoSuchAlgorithmException;
8import java.security.PrivateKey;
9import java.security.PublicKey;
10import java.security.Signature;
11import java.security.interfaces.RSAPrivateKey;
12import java.security.interfaces.RSAPublicKey;
13import java.security.spec.InvalidKeySpecException;
14import java.security.spec.PKCS8EncodedKeySpec;
15import java.security.spec.X509EncodedKeySpec;
16import java.util.HashMap;
17import java.util.Map;
18
19import javax.crypto.Cipher;
20
21import mons.codec.binary.Base64;
22
23/**
24 *
25 * @ClassName: TestRsaEncrypt
26 * @Description: TODO
27 * @author: liuyx
28 * @date: 2016年4⽉28⽇上午10:20:59
29*/
30public class TestRsaEncrypt {
31public static final String KEY_ALGORITHM = "RSA";
32private static final String PUBLIC_KEY = "RSAPublicKey";
33private static final String PRIVATE_KEY = "RSAPrivateKey";
34public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
35private static KeyFactory keyFactory = null;
36static {
37try {
38 keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
39 } catch (NoSuchAlgorithmException e) {
40// TODO Auto-generated catch block
41 e.printStackTrace();
42 }
43 }
44//公钥加密私钥解密
45public static void main(String[] args) throws Exception {
46//⽣成密钥对
47
48 KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
49 keyPairGen.initialize(512);
50
51 KeyPair keyPair = keyPairGen.generateKeyPair();
52
53// 公钥
54 RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
55
56// 私钥
57 RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
58
59 Map<String, Object> keyMap = new HashMap<String, Object>(2);
60
61 keyMap.put(PUBLIC_KEY, publicKey);
62 keyMap.put(PRIVATE_KEY, privateKey);
63
64 String publicKeyStr = getBase64KeyEncodeStrFromKey(publicKey);
65 String privateKeyStr = getBase64KeyEncodeStrFromKey(privateKey);
66 System.out.println("公钥:"+publicKeyStr);
67 System.out.println("私钥:"+privateKeyStr);
68
69//数据加密过程演⽰
70 System.out.println("公钥加密——私钥解密");
71
72//要加密的数据
73 String dataStr = "abcdefghhhhhhhopqrst";
74 System.out.println("要加密的数据:"+dataStr);
75byte[] data = dataStr.getBytes();
76
77
78// 对公钥解密
79 Key decodePublicKey = getPublicKeyFromBase64KeyEncodeStr(publicKeyStr);
80
81// 对数据加密
82 Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
83 cipher.init(Cipher.ENCRYPT_MODE, decodePublicKey);
84byte[] encodedData = cipher.doFinal(data);
85 String encodedDataStr = Base64.encodeBase64String(encodedData);
86 System.out.println("公钥加密后的数据:"+encodedDataStr);
87
88//对私钥解密
89 Key decodePrivateKey = getPrivateKeyFromBase64KeyEncodeStr(privateKeyStr);
90 cipher.init(Cipher.DECRYPT_MODE, decodePrivateKey);
91 encodedData = Base64.decodeBase64(encodedDataStr);
92byte[] decodedData = cipher.doFinal(encodedData);
93 String decodedDataStr = new String(decodedData);
94 System.out.println("私钥解密后的数据:"+decodedDataStr);
95 }
96
97//私钥加密公钥解密,附带签名验证过程
98public static void main1(String[] args) throws Exception {
99//⽣成密钥对
100
101 KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM); 102 keyPairGen.initialize(512);
103
104 KeyPair keyPair = keyPairGen.generateKeyPair();
105
106// 公钥
107 RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
108
109// 私钥
110 RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
111
112 Map<String, Object> keyMap = new HashMap<String, Object>(2);
113
114 keyMap.put(PUBLIC_KEY, publicKey);
115 keyMap.put(PRIVATE_KEY, privateKey);
116
117 String publicKeyStr = getBase64KeyEncodeStrFromKey(publicKey);
118 String privateKeyStr = getBase64KeyEncodeStrFromKey(privateKey);
119 System.out.println("公钥:"+publicKeyStr);
120 System.out.println("私钥:"+privateKeyStr);
121
122//数据加密过程演⽰
123 System.out.println("私钥加密——公钥解密");
124
125//要加密的数据
126 String dataStr = "abcdefghhhhhhhopqrst1";
127 System.out.println("要加密的数据:"+dataStr);
128byte[] data = dataStr.getBytes();
129
130//对私钥解密
131 Key decodePrivateKey = getPrivateKeyFromBase64KeyEncodeStr(privateKeyStr); 132//对公钥解密
133 Key decodePublicKey = getPublicKeyFromBase64KeyEncodeStr(publicKeyStr); 134
135// 对数据加密
136 Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
137 cipher.init(Cipher.ENCRYPT_MODE, decodePrivateKey);
138byte[] encodedData = cipher.doFinal(data);
139
140//插曲，加密后的数据+私钥，⽣成签名，验证签名
141 Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
142 signature.initSign((PrivateKey)decodePrivateKey); //⽤的是私钥
143 signature.update(encodedData); //⽤的是加密后的数据字节数组
144
145//取得签名
146 String sign = Base64.encodeBase64String((signature.sign()));
147
148//初始化验证签名
149 signature = Signature.getInstance(SIGNATURE_ALGORITHM);
150 signature.initVerify((PublicKey )decodePublicKey); //⽤的是公钥
151 signature.update(encodedData); //⽤的是加密后的数据字节数组
152
153//实际的验证过程，获取验证结果
154boolean ret = signature.verify(Base64.decodeBase64(sign));
155 System.out.println("验证结果:"+ret);
156//插曲结束
157
158
159 String encodedDataStr = Base64.encodeBase64String(encodedData);
160 System.out.println("私钥加密后的数据:"+encodedDataStr);
161
162
163
164 cipher.init(Cipher.DECRYPT_MODE, decodePublicKey);
165 encodedData = Base64.decodeBase64(encodedDataStr);
166byte[] decodedData = cipher.doFinal(encodedData);
167 String decodedDataStr = new String(decodedData);
168 System.out.println("公钥解密后的数据:"+decodedDataStr);
169
170 }
171
172/*
173 * 获取key的base64加密后的字符串
174*/
175private static String getBase64KeyEncodeStrFromKey(Key key) {
176return Base64.encodeBase64String(key.getEncoded());
177 }
178
179/*
180 * 获取base64加密后的字符串的原始公钥
181*/
182private static Key getPublicKeyFromBase64KeyEncodeStr(String keyStr) {
183byte[] keyBytes = Base64.decodeBase64(keyStr);
184 X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
185 Key publicKey = null;
186try {
187 publicKey = keyFactory.generatePublic(x509KeySpec);
188 } catch (Exception e) {
189// TODO Auto-generated catch block
190 e.printStackTrace();
191 }
192return publicKey;
193 }
194
195private static Key getPrivateKeyFromBase64KeyEncodeStr(String keyStr) {
196byte[] keyBytes = Base64.decodeBase64(keyStr);
197// 取得私钥
198 PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes); 199
200 Key privateKey=null;
201try {
202 privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
203 } catch (InvalidKeySpecException e) {
204// TODO Auto-generated catch block
205 e.printStackTrace();
206 }
207return privateKey;
208 }
209 }。