1 import java.io.File;
2 import java.io.FileInputStream;
3 import java.math.BigInteger;
4 import java.security.KeyFactory;
5 import java.security.KeyPair;
6 import java.security.KeyPairGenerator;
7 import java.security.NoSuchAlgorithmException;
8 import java.security.NoSuchProviderException;
9 import java.security.Security;
10 import java.security.interfaces.RSAPrivateKey;
11 import java.security.interfaces.RSAPublicKey;
12 import java.security.spec.PKCS8EncodedKeySpec;
13 import java.security.spec.RSAPrivateKeySpec;
14 import java.security.spec.RSAPublicKeySpec;
15 import java.security.spec.X509EncodedKeySpec;
16 import java.util.HashMap;
17 import java.util.Map;
18
19 import javax.crypto.Cipher;
20
21 import org.apache.commons.codec.binary.Base64;
22 import org.apache.commons.lang.StringUtils;
23 import org.bouncycastle.jce.provider.BouncyCastleProvider;
24
27
28 /**
29 * 非对称加密工具
30 *
31 * @author lKF71480
32 */
33 public class RSAUtils { 36
37 /**
38 * PublicKey4UP:用户中心公钥匙
39 */
40 public static Map<String, Object> keyMap = new HashMap<String, Object>();
41
42 static {
43 try {
44 Security.addProvider(new BouncyCastleProvider());
45 } catch (Exception e) {
46 e.printStackTrace();
47 }
48 }
49
50 /**
51 * 生成公钥和私钥
52 *
53 * @throws NoSuchAlgorithmException
54 * @throws NoSuchProviderException
55 *
56 */
57 public static HashMap<String, Object> getKeys() throws NoSuchAlgorithmException, NoSuchProviderException {
58 HashMap<String, Object> map = new HashMap<String, Object>();
59 KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA", "BC");
60 keyPairGen.initialize(1024);
61 KeyPair keyPair = keyPairGen.generateKeyPair();
62 RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
63 RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
64
65 map.put("public", publicKey);
66 map.put("private", privateKey);
67 return map;
68 }
69
70 /**
71 * 使用模和指数生成RSA公钥
72 * 注意：【此代码用了默认补位方式，为RSA/None/PKCS1Padding，不同JDK默认的补位方式可能不同，如Android默认是RSA
73 * /None/NoPadding】
74 *
75 * @param modulus
76 * 模
77 * @param exponent
78 * 指数
79 * @return
80 */
81 public static RSAPublicKey getPublicKey(String modulus, String exponent) {
82 try {
83 BigInteger b1 = new BigInteger(modulus);
84 BigInteger b2 = new BigInteger(exponent);
85 KeyFactory keyFactory = KeyFactory.getInstance("RSA", "BC");
86 RSAPublicKeySpec keySpec = new RSAPublicKeySpec(b1, b2);
87 return (RSAPublicKey) keyFactory.generatePublic(keySpec);
88 } catch (Exception e) {
89 e.printStackTrace();
90 return null;
91 }
92 }
93
94 public static RSAPublicKey getPublicKey(X509EncodedKeySpec publicKey) {
95 try {
96 KeyFactory keyfactoryNew = KeyFactory.getInstance("RSA", "BC");
97 return (RSAPublicKey) keyfactoryNew.generatePublic(publicKey);
98 } catch (Exception e) {
99 e.printStackTrace();
100 return null;
101 }
102 }
103
104 /**
105 * 使用模和指数生成RSA私钥
106 * 注意：【此代码用了默认补位方式，为RSA/None/PKCS1Padding，不同JDK默认的补位方式可能不同，如Android默认是RSA
107 * /None/NoPadding】
108 * @param modulus 模
109 * @param exponent 指数
110 * @return
111 */
112 public static RSAPrivateKey getPrivateKey(String modulus, String exponent) {
113 try {
114 BigInteger b1 = new BigInteger(modulus);
115 BigInteger b2 = new BigInteger(exponent);
116 KeyFactory keyFactory = KeyFactory.getInstance("RSA", "BC");
117 RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(b1, b2);
118 return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
119 } catch (Exception e) {
120 e.printStackTrace();
121 return null;
122 }
123 }
124
125 /**
126 * 公钥加密
127 *
128 * @param data
129 * @param publicKey
130 * @return
131 * @throws Exception
132 */
133 public static String encryptByPublicKey(String data, RSAPublicKey publicKey) throws Exception {
134 Cipher cipher = Cipher.getInstance("RSA/None/PKCS1Padding", "BC");
135 cipher.init(Cipher.ENCRYPT_MODE, publicKey);
136 // 模长
137 int key_len = publicKey.getModulus().bitLength() / 8;
138 // 加密数据长度 <= 模长-11
139 String[] datas = splitString(data, key_len - 11);
140 String mi = "";
141 // 如果明文长度大于模长-11则要分组加密
142 for (String s : datas) {
143 mi += bcd2Str(cipher.doFinal(s.getBytes()));
144 }
145 return mi;
146 }
147
148 /**
149 * 私钥解密
150 *
151 * @param data
152 * @param privateKey
153 * @return
154 * @throws Exception
155 */
156 public static String decryptByPrivateKey(String data, RSAPrivateKey privateKey) throws Exception {
157 Cipher cipher = Cipher.getInstance("RSA/None/PKCS1Padding", "BC");
158 cipher.init(Cipher.DECRYPT_MODE, privateKey);
159 // 模长
160 int key_len = privateKey.getModulus().bitLength() / 8;
161 byte[] bytes = data.getBytes();
162 byte[] bcd = ASCII_To_BCD(bytes, bytes.length);
163 System.err.println(bcd.length);
164 // 如果密文长度大于模长则要分组解密
165 String ming = "";
166 byte[][] arrays = splitArray(bcd, key_len);
167 for (byte[] arr : arrays) {
168 ming += new String(cipher.doFinal(arr));
169 }
170 return ming;
171 }
172
173 /**
174 * 公钥解密
175 *
176 * @param data
177 * @param privateKey
178 * @return
179 * @throws Exception
180 */
181 public static String decryptByPublicKey(String data, RSAPublicKey publicKey) throws Exception {
182 Cipher cipher = Cipher.getInstance("RSA/None/PKCS1Padding", "BC");
183 cipher.init(Cipher.DECRYPT_MODE, publicKey);
184 // 模长
185 int key_len = publicKey.getModulus().bitLength() / 8;
186 byte[] bytes = data.getBytes();
187 byte[] bcd = ASCII_To_BCD(bytes, bytes.length);
188 System.err.println(bcd.length);
189 // 如果密文长度大于模长则要分组解密
190 String ming = "";
191 byte[][] arrays = splitArray(bcd, key_len);
192 for (byte[] arr : arrays) {
193 ming += new String(cipher.doFinal(arr));
194 }
195 return ming;
196 }
197 /**
198 * <p>
199 * 解密
200 * </P>
201 * <功能详细描述>
202 *
203 * @return 解密后的明文
204 * @see [类、类#方法、类#成员]
205 */
206 public static String decrypt(String cryptStr) {
207 return null;
208 }
209
210 /**
211 * ASCII码转BCD码
212 *
213 */
214 public static byte[] ASCII_To_BCD(byte[] ascii, int asc_len) {
215 byte[] bcd = new byte[asc_len / 2];
216 int j = 0;
217 for (int i = 0; i < (asc_len + 1) / 2; i++) {
218 bcd[i] = asc_to_bcd(ascii[j++]);
219 bcd[i] = (byte) (((j >= asc_len) ? 0x00 : asc_to_bcd(ascii[j++])) + (bcd[i] << 4));
220 }
221 return bcd;
222 }
223
224 public static byte asc_to_bcd(byte asc) {
225 byte bcd;
226
227 if ((asc >= '0') && (asc <= '9'))
228 bcd = (byte) (asc - '0');
229 else if ((asc >= 'A') && (asc <= 'F'))
230 bcd = (byte) (asc - 'A' + 10);
231 else if ((asc >= 'a') && (asc <= 'f'))
232 bcd = (byte) (asc - 'a' + 10);
233 else
234 bcd = (byte) (asc - 48);
235 return bcd;
236 }
237
238 /**
239 * BCD转字符串
240 */
241 public static String bcd2Str(byte[] bytes) {
242 char temp[] = new char[bytes.length * 2], val;
243
244 for (int i = 0; i < bytes.length; i++) {
245 val = (char) (((bytes[i] & 0xf0) >> 4) & 0x0f);
246 temp[i * 2] = (char) (val > 9 ? val + 'A' - 10 : val + '0');
247
248 val = (char) (bytes[i] & 0x0f);
249 temp[i * 2 + 1] = (char) (val > 9 ? val + 'A' - 10 : val + '0');
250 }
251 return new String(temp);
252 }
253
254 /**
255 * 拆分字符串
256 */
257 public static String[] splitString(String string, int len) {
258 int x = string.length() / len;
259 int y = string.length() % len;
260 int z = 0;
261 if (y != 0) {
262 z = 1;
263 }
264 String[] strings = new String[x + z];
265 String str = "";
266 for (int i = 0; i < x + z; i++) {
267 if (i == x + z - 1 && y != 0) {
268 str = string.substring(i * len, i * len + y);
269 } else {
270 str = string.substring(i * len, i * len + len);
271 }
272 strings[i] = str;
273 }
274 return strings;
275 }
276
277 /**
278 * 拆分数组
279 */
280 public static byte[][] splitArray(byte[] data, int len) {
281 int x = data.length / len;
282 int y = data.length % len;
283 int z = 0;
284 if (y != 0) {
285 z = 1;
286 }
287 byte[][] arrays = new byte[x + z][];
288 byte[] arr;
289 for (int i = 0; i < x + z; i++) {
290 arr = new byte[len];
291 if (i == x + z - 1 && y != 0) {
292 System.arraycopy(data, i * len, arr, 0, y);
293 } else {
294 System.arraycopy(data, i * len, arr, 0, len);
295 }
296 arrays[i] = arr;
297 }
298 return arrays;
299 }
300
301 public static String getUpPrivateEncodeStr (String encodeStr) {
302 String result = "";
303 try {
304 RSAPrivateKey priKey = null;
305 if (keyMap.get("PrivateKey4UP") == null) {
306 String rootPath = StringUtils.remove(Thread.currentThread().getContextClassLoader().getResource("").getPath(), "classes/");
307 String localPath = rootPath + File.separator + "keystore";
308 File privateKeyFile = new File(localPath + File.separator + "private.key");
309 FileInputStream privateKeyInputStream = new FileInputStream(privateKeyFile);
310 byte[] privateKeyByte = new byte[(int) privateKeyFile.length()];
311 // 将私钥文件读入内存
312 privateKeyInputStream.read(privateKeyByte);
313 privateKeyInputStream.close();
314 // 生成私钥钥对象privateKey
315 PKCS8EncodedKeySpec priPKCS8new = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKeyByte));
316 KeyFactory keyfactoryNew = KeyFactory.getInstance("RSA", "BC");
317 priKey = (RSAPrivateKey) keyfactoryNew.generatePrivate(priPKCS8new);
318 keyMap.put("PrivateKey4UP", priKey);
319 } else {
320 priKey = (RSAPrivateKey) keyMap.get("PrivateKey4UP");
321 }
322 // 私钥解密
323 result = RSAUtils.decryptByPrivateKey(encodeStr, priKey);
324 } catch (Exception e) {
325 e.printStackTrace();
326 }
327 return result;
328 }
329
330 public static String getUpPublicEncodeStr(String str) {
331 // 公钥加密
332 String result = "";
333 try {
334 RSAPublicKey pubKey = null;
335 if (keyMap.get("PublicKey4UP") == null){
336 // 公钥文件
337 String rootPath = StringUtils.remove(Thread.currentThread().getContextClassLoader().getResource("").getPath(), "classes/");
338 String localPath = rootPath + File.separator + "keystore";
339 File publicKeyFile = new File(localPath + File.separator + "publicUp.key");
340 Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
341 FileInputStream publicKeyInputStream = new FileInputStream(publicKeyFile);
342 byte[] publicKeyByte = new byte[(int) publicKeyFile.length()];
343 // 将公钥文件读入内存
344 publicKeyInputStream.read(publicKeyByte);
345 publicKeyInputStream.close();
346 // 生成公钥对象PublicKey
347 X509EncodedKeySpec pubX509new = new X509EncodedKeySpec(Base64.decodeBase64(publicKeyByte));
348 KeyFactory keyfactoryNew = KeyFactory.getInstance("RSA", "BC");
349 pubKey = (RSAPublicKey) keyfactoryNew.generatePublic(pubX509new);
350 keyMap.put("PublicKey4UP", pubKey);
351 } else {
352 pubKey = (RSAPublicKey)keyMap.get("PublicKey4UP");
353 }
354 result = RSAUtils.encryptByPublicKey(str, pubKey);
355 } catch (Exception e) {
356 e.printStackTrace();
357 DEBUGGER.debug(e.getMessage());
358 }
359 return result;
360 }
361
362 /**
363 * 获取秘钥对文件
364 * @param args
365 * @throws Exception
366 */
367 public static void makeThePairFile(String[] args) throws Exception {
368
369 /*HashMap<String, Object> map = RSAUtils.getKeys();
370 // 生成公钥和私钥
371 RSAPublicKey publicKey = (RSAPublicKey) map.get("public");
372 RSAPrivateKey privateKey = (RSAPrivateKey) map.get("private");
373 // 生成公钥文件
374 File publicKeyFile = new File("D:" + File.separator + "public.key");
375 FileOutputStream publicKeyStream = new FileOutputStream(publicKeyFile);
376 // 获取公钥标准编码并进行base64加密
377 String publicKeyBase = new String(Base64.encodeBase64(publicKey.getEncoded()));
378 System.out.println("公钥为：" + new String(publicKey.getEncoded()));
379 System.out.println("BASE64公钥为：" + publicKeyBase);
380 publicKeyStream.write(publicKeyBase.getBytes());
381 publicKeyStream.close();
382 //
383 // // // 生成私钥文件
384 File privateKeyFile = new File("D:" + File.separator + "private.key");
385 FileOutputStream privateKeyStream = new FileOutputStream(privateKeyFile);
386 // 获取私钥标准编码并进行base64加密
387 String privateKeyBase = new String(Base64.encodeBase64(privateKey.getEncoded()));
388 System.out.println("私钥为：" + new String(privateKey.getEncoded()));
389 System.out.println("BASE64私钥为：" + privateKeyBase);
390 privateKeyStream.write(privateKeyBase.getBytes());
391 privateKeyStream.close();
392
393 X509EncodedKeySpec pubX509 = new X509EncodedKeySpec(Base64.decodeBase64(publicKeyBase.getBytes()));
394 PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKeyBase.getBytes()));
395
396 KeyFactory keyfactory = KeyFactory.getInstance("RSA");
397 RSAPublicKey newPublicKey = (RSAPublicKey) keyfactory.generatePublic(pubX509);
398 RSAPrivateKey newPrivateKey = (RSAPrivateKey) keyfactory.generatePrivate(priPKCS8);
399 System.out.println(publicKey.equals(newPublicKey));
400 System.out.println(privateKey.equals(newPrivateKey));*/
401 }
402 }
浙公网安备 33010602011771号