1 import org.apache.commons.codec.binary.Base64;
2
3 import javax.crypto.Cipher;
4 import java.security.*;
5 import java.security.spec.PKCS8EncodedKeySpec;
6 import java.security.spec.X509EncodedKeySpec;
7 import java.util.HashMap;
8 import java.util.Map;
9
10 /**
11 * RSA加密和解密工具
12 *
13 * @Author: syj
14 * @CreateDate: 2018/7/20 16:52
15 */
16 public class RSAUtil {
17
18 /**
19 * 数字签名，密钥算法
20 */
21 private static final String RSA_KEY_ALGORITHM = "RSA";
22
23 /**
24 * 数字签名签名/验证算法
25 */
26 private static final String SIGNATURE_ALGORITHM = "MD5withRSA";
27
28 /**
29 * RSA密钥长度，RSA算法的默认密钥长度是1024密钥长度必须是64的倍数，在512到65536位之间
30 */
31 private static final int KEY_SIZE = 1024;
32
33 /**
34 * 生成密钥对
35 */
36 private static Map<String, String> initKey() throws Exception {
37 KeyPairGenerator keygen = KeyPairGenerator.getInstance(RSA_KEY_ALGORITHM);
38 SecureRandom secrand = new SecureRandom();
39 /**
40 * 初始化随机产生器
41 */
42 secrand.setSeed("initSeed".getBytes());
43 /**
44 * 初始化密钥生成器
45 */
46 keygen.initialize(KEY_SIZE, secrand);
47 KeyPair keys = keygen.genKeyPair();
48
49 byte[] pub_key = keys.getPublic().getEncoded();
50 String publicKeyString = Base64.encodeBase64String(pub_key);
51
52 byte[] pri_key = keys.getPrivate().getEncoded();
53 String privateKeyString = Base64.encodeBase64String(pri_key);
54
55 Map<String, String> keyPairMap = new HashMap<>();
56 keyPairMap.put("publicKeyString", publicKeyString);
57 keyPairMap.put("privateKeyString", privateKeyString);
58
59 return keyPairMap;
60 }
61
62 /**
63 * 密钥转成字符串
64 *
65 * @param key
66 * @return
67 */
68 public static String encodeBase64String(byte[] key) {
69 return Base64.encodeBase64String(key);
70 }
71
72 /**
73 * 密钥转成byte[]
74 *
75 * @param key
76 * @return
77 */
78 public static byte[] decodeBase64(String key) {
79 return Base64.decodeBase64(key);
80 }
81
82 /**
83 * 公钥加密
84 *
85 * @param data 加密前的字符串
86 * @param publicKey 公钥
87 * @return 加密后的字符串
88 * @throws Exception
89 */
90 public static String encryptByPubKey(String data, String publicKey) throws Exception {
91 byte[] pubKey = RSAUtil.decodeBase64(publicKey);
92 byte[] enSign = encryptByPubKey(data.getBytes(), pubKey);
93 return Base64.encodeBase64String(enSign);
94 }
95
96 /**
97 * 公钥加密
98 *
99 * @param data 待加密数据
100 * @param pubKey 公钥
101 * @return
102 * @throws Exception
103 */
104 public static byte[] encryptByPubKey(byte[] data, byte[] pubKey) throws Exception {
105 X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(pubKey);
106 KeyFactory keyFactory = KeyFactory.getInstance(RSA_KEY_ALGORITHM);
107 PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
108 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
109 cipher.init(Cipher.ENCRYPT_MODE, publicKey);
110 return cipher.doFinal(data);
111 }
112
113 /**
114 * 私钥加密
115 *
116 * @param data 加密前的字符串
117 * @param privateKey 私钥
118 * @return 加密后的字符串
119 * @throws Exception
120 */
121 public static String encryptByPriKey(String data, String privateKey) throws Exception {
122 byte[] priKey = RSAUtil.decodeBase64(privateKey);
123 byte[] enSign = encryptByPriKey(data.getBytes(), priKey);
124 return Base64.encodeBase64String(enSign);
125 }
126
127 /**
128 * 私钥加密
129 *
130 * @param data 待加密的数据
131 * @param priKey 私钥
132 * @return 加密后的数据
133 * @throws Exception
134 */
135 public static byte[] encryptByPriKey(byte[] data, byte[] priKey) throws Exception {
136 PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(priKey);
137 KeyFactory keyFactory = KeyFactory.getInstance(RSA_KEY_ALGORITHM);
138 PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
139 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
140 cipher.init(Cipher.ENCRYPT_MODE, privateKey);
141 return cipher.doFinal(data);
142 }
143
144 /**
145 * 公钥解密
146 *
147 * @param data 待解密的数据
148 * @param pubKey 公钥
149 * @return 解密后的数据
150 * @throws Exception
151 */
152 public static byte[] decryptByPubKey(byte[] data, byte[] pubKey) throws Exception {
153 X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(pubKey);
154 KeyFactory keyFactory = KeyFactory.getInstance(RSA_KEY_ALGORITHM);
155 PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
156 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
157 cipher.init(Cipher.DECRYPT_MODE, publicKey);
158 return cipher.doFinal(data);
159 }
160
161 /**
162 * 公钥解密
163 *
164 * @param data 解密前的字符串
165 * @param publicKey 公钥
166 * @return 解密后的字符串
167 * @throws Exception
168 */
169 public static String decryptByPubKey(String data, String publicKey) throws Exception {
170 byte[] pubKey = RSAUtil.decodeBase64(publicKey);
171 byte[] design = decryptByPubKey(Base64.decodeBase64(data), pubKey);
172 return new String(design);
173 }
174
175 /**
176 * 私钥解密
177 *
178 * @param data 待解密的数据
179 * @param priKey 私钥
180 * @return
181 * @throws Exception
182 */
183 public static byte[] decryptByPriKey(byte[] data, byte[] priKey) throws Exception {
184 PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(priKey);
185 KeyFactory keyFactory = KeyFactory.getInstance(RSA_KEY_ALGORITHM);
186 PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
187 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
188 cipher.init(Cipher.DECRYPT_MODE, privateKey);
189 return cipher.doFinal(data);
190 }
191
192 /**
193 * 私钥解密
194 *
195 * @param data 解密前的字符串
196 * @param privateKey 私钥
197 * @return 解密后的字符串
198 * @throws Exception
199 */
200 public static String decryptByPriKey(String data, String privateKey) throws Exception {
201 byte[] priKey = RSAUtil.decodeBase64(privateKey);
202 byte[] design = decryptByPriKey(Base64.decodeBase64(data), priKey);
203 return new String(design);
204 }
205
206 /**
207 * RSA签名
208 *
209 * @param data 待签名数据
210 * @param priKey 私钥
211 * @return 签名
212 * @throws Exception
213 */
214 public static String sign(byte[] data, byte[] priKey) throws Exception {
215 // 取得私钥
216 PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(priKey);
217 KeyFactory keyFactory = KeyFactory.getInstance(RSA_KEY_ALGORITHM);
218 // 生成私钥
219 PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
220 // 实例化Signature
221 Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
222 // 初始化Signature
223 signature.initSign(privateKey);
224 // 更新
225 signature.update(data);
226 return Base64.encodeBase64String(signature.sign());
227 }
228
229 /**
230 * RSA校验数字签名
231 *
232 * @param data 待校验数据
233 * @param sign 数字签名
234 * @param pubKey 公钥
235 * @return boolean 校验成功返回true，失败返回false
236 */
237 public boolean verify(byte[] data, byte[] sign, byte[] pubKey) throws Exception {
238 // 实例化密钥工厂
239 KeyFactory keyFactory = KeyFactory.getInstance(RSA_KEY_ALGORITHM);
240 // 初始化公钥
241 X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(pubKey);
242 // 产生公钥
243 PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
244 // 实例化Signature
245 Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
246 // 初始化Signature
247 signature.initVerify(publicKey);
248 // 更新
249 signature.update(data);
250 // 验证
251 return signature.verify(sign);
252 }
253
254 public static void main(String[] args) {
255 try {
256 Map<String, String> keyMap = initKey();
257 String publicKeyString = keyMap.get("publicKeyString");
258 String privateKeyString = keyMap.get("privateKeyString");
259 System.out.println("公钥:" + publicKeyString);
260 System.out.println("私钥:" + privateKeyString);
261
262 // 待加密数据
263 String data = "admin123";
264 // 公钥加密
265 String encrypt = RSAUtil.encryptByPubKey(data, publicKeyString);
266 // 私钥解密
267 String decrypt = RSAUtil.decryptByPriKey(encrypt, privateKeyString);
268
269 System.out.println("加密前:" + data);
270 System.out.println("加密后:" + encrypt);
271 System.out.println("解密后:" + decrypt);
272 } catch (Exception e) {
273 e.printStackTrace();
274 }
275 }
276
277 }
