1 package gboat2.base.bridge.util.security;
2 import java.io.File;
3 import java.io.FileInputStream;
4 import java.io.FileNotFoundException;
5 import java.security.InvalidKeyException;
6 import java.security.NoSuchAlgorithmException;
7 import java.security.PrivateKey;
8 import java.security.PublicKey;
9 import java.security.Signature;
10 import java.security.SignatureException;
11 import java.security.spec.RSAPrivateKeySpec;
12 import java.security.spec.RSAPublicKeySpec;
13
14 import org.apache.commons.codec.binary.Base64;
15 import org.apache.commons.io.IOUtils;
16 import org.apache.commons.lang3.StringUtils;
17
18 /**
19 * 对数据或文件进行 RSA 签名和签名校验的工具类。<br>
20 * 如果要和 .NET 平台进行交互，请使用 {@value #SHA1_WITH_RSA} 算法进行签名和校验，因为 .NET 默认是使用该算法。<br>
21 * 进行签名和校验操作的示例代码：
22 *
23 * <pre>
24 * <code>
25 * String privateKey = "MIICeQIBADANBgkqhkiG9w0BAQEFAASCAmMwggJfAgEAAoGBAL6VJN4ZkfZA3aPPgKC3xaqT/yZT5FOl"
26 * + "Q5TGg6heVqDVEHHVLH1E+HEEmWmuTv2ngz9pZbzy9KWkJpV59W1dgNHSSk575VjUAv0BhZXFSH0lng2m"
27 * + "Z2Q5/2dVxKsASjJ2bQiEGUD8LO5KpaLlfQpo3ANovBZvUtHw5exegnyXyZbDAgMBAAECgYEAr7YEWr1K"
28 * + "hLcDYg9jMUqd9QokOSspnTEGoPlx016/EeO/GKSJMynOwSyTYQszisvRxzoecdmyU7GHXVMnQ2Ds7Wvb"
29 * + "cuNkIRWmxFa4nTkk2zNF6KByvvFwLiW4LQXF6B+uV7+ZNqvfhCoD/j2wki8jfWkuuAaKnTda/axHMi+z"
30 * + "RYECQQD73iC2GjZyur4amJQPK6d+kDlJ0dYyyUvQa0vd6mfoPnQDOIqayBaueSwWIpLI/L7eUuP9CDFr"
31 * + "yQtdBvWqD/dBAkEAwbWcrybn0eaxiPZacZLZXzXO8g12hYoXT1h0DTLvy1rnVUOspNfKZcBZMjPxT4+Q"
32 * + "EknoTShSnSbJ5sHitfZxAwJBANMlU2z2KqEh1k77jFvvb9oVVEGDbTtkL2+JE6/1W6iB+sXcd63sgb9A"
33 * + "i+n+j+l4oRZGjSTJ4oyGnUUemYI5IkECQQCA9JNrcv4PGYIFCOPrCfTV0m+Dan0Fp4mfE+amRsumWEz6"
34 * + "0UOktdeS53s51aSG767czgDtJLPi1MjCaz6vHnHbAkEA4NxLLg6UCAoCpXMgqqZHWMgbMwNNFr9diCWP"
35 * + "/tZ5OJmWYHgn7zfqMXa/RNaethjdG1biIkj5h7qm6XDBBqGuxw==";
36 * String publicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC+lSTeGZH2QN2jz4Cgt8Wqk/8mU+RTpUOUxoOoXlag"
37 * + "1RBx1Sx9RPhxBJlprk79p4M/aWW88vSlpCaVefVtXYDR0kpOe+VY1AL9AYWVxUh9JZ4NpmdkOf9nVcSr"
38 * + "AEoydm0IhBlA/CzuSqWi5X0KaNwDaLwWb1LR8OXsXoJ8l8mWwwIDAQAB";
39 *
40 * String data = "this is a test 中文";
41 * String signature = sign(data, privateKey);
42 * System.out.println("签名信息：" + signature);
43 * boolean verifyResult = verify(data, publicKey, signature);
44 * System.out.println("校验结果：" + verifyResult);
45 *
46 * File file = new File("D:/temp/活法.pdf");
47 * String signature_2 = Base64.encodeBase64String(sign(file, privateKey));
48 * System.out.println("签名信息2：" + signature_2);
49 *
50 * boolean verifyResult_2 = verify(file, publicKey, signature_2);
51 * System.out.println("校验结果2：" + verifyResult_2);
52 * </code>
53 * </pre>
54 *
55 * @author <a href="mailto:[email protected]">何明旺</a>
56 * @since 3.0
57 * @date 2014年3月24日
58 * @see Base64Util
59 * @see RSAUtil
60 * @see CertificateUtil
61 */
62 public class RSASignUtil {
63 public static final String MD2_WITH_RSA = "MD2withRSA";
64 public static final String MD5_WITH_RSA = "MD5withRSA";
65 public static final String SHA1_WITH_RSA = "SHA1withRSA";
66 public static final String SHA256_WITH_RSA = "SHA256withRSA";
67 public static final String SHA384_with_RSA = "SHA384withRSA";
68 public static final String SHA512_WITH_RSA = "SHA512withRSA";
69
70 /** 文件读取缓冲区大小 */
71 private static final int FILE_CACHE_SIZE = 2048;
72
73 /**
74 * 根据 MD5withRSA 算法使用私钥对数据生成数字签名
75 * @param data 要进行签名的数据
76 * @param privateKey 私钥
77 * @return 签名后的数据
78 */
79 public static byte[] sign(byte[] data, PrivateKey privateKey) {
80 return sign(data, privateKey, MD5_WITH_RSA);
81 }
82
83 /**
84 * 使用私钥对数据生成数字签名
85 * @param data 要进行签名的数据
86 * @param privateKey 私钥
87 * @param algorithm 签名算法，请参见本类中的名称为 {@code *__WITH_RSA} 的常量
88 * @return 签名后的数据
89 */
90 public static byte[] sign(byte[] data, PrivateKey privateKey, String algorithm){
91 try {
92 Signature signature = Signature.getInstance(algorithm);
93 signature.initSign(privateKey);
94 signature.update(data);
95 return signature.sign();
96 } catch (InvalidKeyException e) {
97 throw new GboatSecurityException("无效的私钥", e);
98 } catch (NoSuchAlgorithmException e) {
99 throw new GboatSecurityException("算法 [" + algorithm + "] 不存在，或当前 JDK 不支持该算法。", e);
100 } catch (SignatureException e) {
101 throw new GboatSecurityException("数据签名失败", e);
102 }
103 }
104
105 /**
106 * 根据 MD5withRSA 算法使用私钥对文件生成数字签名
107 * @param file 要进行签名的文件
108 * @param privateKey 私钥
109 * @return 对文件签名后的数据
110 */
111 public static byte[] sign(File file, PrivateKey privateKey){
112 return sign(file, privateKey, MD5_WITH_RSA);
113 }
114
115 /**
116 * 使用私钥对文件生成数字签名
117 * @param file 要进行签名的文件
118 * @param privateKey 私钥
119 * @param algorithm 签名算法，请参见本类中的名称为 {@code *__WITH_RSA} 的常量
120 * @return 对文件签名后的数据
121 */
122 public static byte[] sign(File file, PrivateKey privateKey, String algorithm) {
123 FileInputStream in = null;
124 try {
125 Signature signature = Signature.getInstance(algorithm);
126 signature.initSign(privateKey);
127 in = new FileInputStream(file);
128 byte[] cache = new byte[FILE_CACHE_SIZE];
129 int nRead = 0;
130 while ((nRead = in.read(cache)) != -1) {
131 signature.update(cache, 0, nRead);
132 }
133 return signature.sign();
134 } catch (FileNotFoundException e) {
135 throw new GboatSecurityException("要进行签名的文件 [" + file.getAbsolutePath() + "] 不存在。", e);
136 } catch (InvalidKeyException e) {
137 throw new GboatSecurityException("无效的私钥", e);
138 } catch (NoSuchAlgorithmException e) {
139 throw new GboatSecurityException("算法 [" + algorithm + "] 不存在，或当前 JDK 不支持该算法。", e);
140 } catch (Exception e) {
141 throw new GboatSecurityException("数据签名失败", e);
142 } finally {
143 IOUtils.closeQuietly(in);
144 }
145 }
146
147 /**
148 * 根据 MD5withRSA 算法使用私钥对字符串生成数字签名
149 * @param data 要进行签名的字符串
150 * @param privateKey 私钥
151 * @return 经过 BASE64 编码的签名后的数据
152 */
153 public static String sign(String data, PrivateKey privateKey){
154 return sign(data, privateKey, MD5_WITH_RSA);
155 }
156
157 /**使用私钥对字符串生成数字签名
158 * @param data 要进行签名的字符串
159 * @param privateKey 私钥
160 * @param algorithm 签名算法，请参见本类中的名称为 {@code *__WITH_RSA} 的常量
161 * @return 经过 BASE64 编码的签名后的数据
162 */
163 public static String sign(String data, PrivateKey privateKey, String algorithm){
164 if(StringUtils.isEmpty(data))
165 return data;
166
167 byte[] result = sign(data.getBytes(), privateKey, algorithm);
168 return Base64.encodeBase64String(result);
169 }
170
171 /**
172 * 根据 MD5withRSA 算法使用私钥对数据生成数字签名
173 * @param data 要进行签名的数据
174 * @param privateKeySpec RSA 专用私钥
175 * @return 签名后的数据
176 */
177 public static byte[] sign(byte[] data, RSAPrivateKeySpec privateKeySpec) {
178 return sign(data, privateKeySpec, MD5_WITH_RSA);
179 }
180
181 /**
182 * 使用私钥对数据生成数字签名
183 * @param data 要进行签名的数据
184 * @param privateKeySpec RSA 专用私钥
185 * @param algorithm 签名算法，请参见本类中的名称为 {@code *__WITH_RSA} 的常量
186 * @return 签名后的数据
187 */
188 public static byte[] sign(byte[] data, RSAPrivateKeySpec privateKeySpec, String algorithm){
189 return sign(data, RSAUtil.getPrivateKey(privateKeySpec), algorithm);
190 }
191
192 /**
193 * 根据 MD5withRSA 算法使用私钥对文件生成数字签名
194 * @param file 要进行签名的文件
195 * @param privateKeySpec RSA 专用私钥
196 * @return 对文件签名后的数据
197 */
198 public static byte[] sign(File file, RSAPrivateKeySpec privateKeySpec){
199 return sign(file, privateKeySpec, MD5_WITH_RSA);
200 }
201
202 /**
203 * 使用私钥对文件生成数字签名
204 * @param file 要进行签名的文件
205 * @param privateKeySpec RSA 专用私钥
206 * @param algorithm 签名算法，请参见本类中的名称为 {@code *__WITH_RSA} 的常量
207 * @return 对文件签名后的数据
208 */
209 public static byte[] sign(File file, RSAPrivateKeySpec privateKeySpec, String algorithm) {
210 return sign(file, RSAUtil.getPrivateKey(privateKeySpec), algorithm);
211 }
212
213 /**
214 * 根据 MD5withRSA 算法使用私钥对字符串生成数字签名
215 * @param data 要进行签名的字符串
216 * @param privateKeySpec RSA 专用私钥
217 * @return 经过 BASE64 编码的签名后的数据
218 */
219 public static String sign(String data, RSAPrivateKeySpec privateKeySpec){
220 return sign(data, privateKeySpec, MD5_WITH_RSA);
221 }
222
223 /**使用私钥对字符串生成数字签名
224 * @param data 要进行签名的字符串
225 * @param privateKeySpec RSA 专用私钥
226 * @param algorithm 签名算法，请参见本类中的名称为 {@code *__WITH_RSA} 的常量
227 * @return 经过 BASE64 编码的签名后的数据
228 */
229 public static String sign(String data, RSAPrivateKeySpec privateKeySpec, String algorithm){
230 return sign(data, RSAUtil.getPrivateKey(privateKeySpec), algorithm);
231 }
232
233 /**
234 * 根据 MD5withRSA 算法使用私钥对数据生成数字签名
235 * @param data 要进行签名的数据
236 * @param privateKey 经过 BASE64 编码的私钥字符串
237 * @return 签名后的数据
238 */
239 public static byte[] sign(byte[] data, String privateKey) {
240 return sign(data, privateKey, MD5_WITH_RSA);
241 }
242
243 /**
244 * 使用私钥对数据生成数字签名
245 * @param data 要进行签名的数据
246 * @param privateKey 经过 BASE64 编码的私钥字符串
247 * @param algorithm 签名算法，请参见本类中的名称为 {@code *__WITH_RSA} 的常量
248 * @return 签名后的数据
249 */
250 public static byte[] sign(byte[] data, String privateKey, String algorithm){
251 return sign(data, RSAUtil.getPrivateKey(privateKey), algorithm);
252 }
253
254 /**
255 * 根据 MD5withRSA 算法使用私钥对文件生成数字签名
256 * @param file 要进行签名的文件
257 * @param privateKey 经过 BASE64 编码的私钥字符串
258 * @return 对文件签名后的数据
259 */
260 public static byte[] sign(File file, String privateKey){
261 return sign(file, privateKey, MD5_WITH_RSA);
262 }
263
264 /**
265 * 使用私钥对文件生成数字签名
266 * @param file 要进行签名的文件
267 * @param privateKey 经过 BASE64 编码的私钥字符串
268 * @param algorithm 签名算法，请参见本类中的名称为 {@code *__WITH_RSA} 的常量
269 * @return 对文件签名后的数据
270 */
271 public static byte[] sign(File file, String privateKey, String algorithm) {
272 return sign(file, RSAUtil.getPrivateKey(privateKey), algorithm);
273 }
274
275 /**
276 * 根据 MD5withRSA 算法使用私钥对字符串生成数字签名
277 * @param data 要进行签名的字符串
278 * @param privateKey 经过 BASE64 编码的私钥字符串
279 * @return 经过 BASE64 编码的签名后的数据
280 */
281 public static String sign(String data, String privateKey){
282 return sign(data, privateKey, MD5_WITH_RSA);
283 }
284
285 /**使用私钥对字符串生成数字签名
286 * @param data 要进行签名的字符串
287 * @param privateKey 经过 BASE64 编码的私钥字符串
288 * @param algorithm 签名算法，请参见本类中的名称为 {@code *__WITH_RSA} 的常量
289 * @return 经过 BASE64 编码的签名后的数据
290 */
291 public static String sign(String data, String privateKey, String algorithm){
292 return sign(data, RSAUtil.getPrivateKey(privateKey), algorithm);
293 }
294
295 /*##########################################################################################################*/
296
297 /**
298 * 根据 MD5withRSA 算法使用公钥验证签名
299 * @param data 要进行校验的数据
300 * @param publicKey 公钥
301 * @param signature 数字签名
302 * @return 签名校验后的数据
303 */
304 public static boolean verify(byte[] data, PublicKey publicKey, byte[] signature) {
305 return verify(data, publicKey, signature, MD5_WITH_RSA);
306 }
307
308 /**
309 * 使用公钥验证签名
310 * @param data 要进行校验的数据
311 * @param publicKey 公钥
312 * @param algorithm 签名校验算法，请参见本类中的名称为 {@code *__WITH_RSA} 的常量
313 * @param signature 数字签名
314 * @return
315 */
316 public static boolean verify(byte[] data, PublicKey publicKey, byte[] signature, String algorithm) {
317 try {
318 Signature sign = Signature.getInstance(algorithm);
319 sign.initVerify(publicKey);
320 sign.update(data);
321 // 验证签名是否正常
322 return sign.verify(signature);
323 } catch (InvalidKeyException e) {
324 throw new GboatSecurityException("无效的公钥", e);
325 } catch (NoSuchAlgorithmException e) {
326 throw new GboatSecurityException("算法 [" + algorithm + "] 不存在，或当前 JDK 不支持该算法。", e);
327 } catch (SignatureException e) {
328 throw new GboatSecurityException("数据签名校验失败", e);
329 }
330 }
331
332 /**
333 * 根据 MD5withRSA 算法使用公钥对文件生成数字签名校验
334 * @param file 要进行签名校验的文件
335 * @param publicKey 公钥
336 * @param signature 数字签名
337 * @return
338 */
339 public static boolean verify(File file, PublicKey publicKey, byte[] signature){
340 return verify(file, publicKey, signature, MD5_WITH_RSA);
341 }
342
343 /**
344 * 使用公钥对文件进行签名校验
345 * @param file 要进行签名校验的文件
346 * @param publicKey 公钥
347 * @param signature 数字签名
348 * @param algorithm 签名校验算法，请参见本类中的名称为 {@code *__WITH_RSA} 的常量
349 * @return
350 */
351 public static boolean verify(File file, PublicKey publicKey, byte[] signature, String algorithm) {
352 FileInputStream in = null;
353 try {
354 // 构建签名
355 Signature sign = Signature.getInstance(algorithm);
356 sign.initVerify(publicKey);
357 in = new FileInputStream(file);
358 byte[] cache = new byte[FILE_CACHE_SIZE];
359 int nRead = 0;
360 while ((nRead = in.read(cache)) != -1) {
361 sign.update(cache, 0, nRead);
362 }
363 return sign.verify(signature);
364 } catch (InvalidKeyException e) {
365 throw new GboatSecurityException("无效的公钥", e);
366 } catch (NoSuchAlgorithmException e) {
367 throw new GboatSecurityException("算法 [" + algorithm + "] 不存在，或当前 JDK 不支持该算法。", e);
368 } catch (FileNotFoundException e) {
369 throw new GboatSecurityException("校验的文件 [" + file.getAbsolutePath() + "] 不存在。", e);
370 } catch (Exception e) {
371 throw new GboatSecurityException("文件签名校验失败", e);
372 } finally {
373 IOUtils.closeQuietly(in);
374 }
375 }
376
377 /**
378 * 根据 MD5withRSA 算法使用公钥对经过 BASE64 编码后的数据进行签名校验
379 * @param base64String 经过 BASE64 编码后的数据
380 * @param publicKey 公钥
381 * @param signature 数字签名
382 * @return
383 */
384 public static boolean verify(String base64String, PublicKey publicKey, byte[] signature){
385 return verify(base64String, publicKey, signature, MD5_WITH_RSA);
386 }
387
388 /**
389 * 使用公钥对经过 BASE64 编码后的数据进行签名校验
390 * @param data 要进行校验的数据
391 * @param publicKey 公钥
392 * @param signature 数字签名
393 * @param algorithm 签名校验算法，请参见本类中的名称为 {@code *__WITH_RSA} 的常量
394 * @return
395 */
396 public static boolean verify(String data, PublicKey publicKey, byte[] signature, String algorithm){
397 return verify(data.getBytes(), publicKey, signature, algorithm);
398 }
399
400 /**
401 * 根据 MD5withRSA 算法使用公钥对文件生成数字签名校验
402 * @param file 要进行签名校验的文件
403 * @param publicKey 公钥
404 * @param 经过 BASE64 编码后的数字签名
405 * @return
406 */
407 public static boolean verify(File file, PublicKey publicKey, String base64Singature){
408 return verify(file, publicKey, base64Singature, MD5_WITH_RSA);
409 }
410
411 /**
412 * 使用公钥对文件进行签名校验
413 * @param file 要进行签名校验的文件
414 * @param publicKey 公钥
415 * @param 经过 BASE64 编码后的数字签名
416 * @param algorithm 签名校验算法，请参见本类中的名称为 {@code *__WITH_RSA} 的常量
417 * @return
418 */
419 public static boolean verify(File file, PublicKey publicKey, String base64Singature, String algorithm) {
420 return verify(file, publicKey, Base64.decodeBase64(base64Singature), algorithm);
421 }
422
423 /**
424 * 根据 MD5withRSA 算法使用公钥对经过 BASE64 编码后的数据进行签名校验
425 * @param base64String 经过 BASE64 编码后的数据
426 * @param publicKey 公钥
427 * @param 经过 BASE64 编码后的数字签名
428 * @return
429 */
430 public static boolean verify(String base64String, PublicKey publicKey, String base64Singature){
431 return verify(base64String, publicKey, base64Singature, MD5_WITH_RSA);
432 }
433
434 /**
435 * 使用公钥对经过 BASE64 编码后的数据进行签名校验
436 * @param data 要进行校验的数据
437 * @param publicKey 公钥
438 * @param 经过 BASE64 编码后的数字签名
439 * @param algorithm 签名校验算法，请参见本类中的名称为 {@code *__WITH_RSA} 的常量
440 * @return
441 */
442 public static boolean verify(String data, PublicKey publicKey, String base64Singature, String algorithm){
443 return verify(data, publicKey, Base64.decodeBase64(base64Singature), algorithm);
444 }
445
446 /**
447 * 根据 MD5withRSA 算法使用公钥验证签名
448 * @param data 要进行校验的数据
449 * @param publicKeySpec RSA 专用公钥
450 * @param signature 数字签名
451 * @return 签名校验后的数据
452 */
453 public static boolean verify(byte[] data, RSAPublicKeySpec publicKeySpec, byte[] signature) {
454 return verify(data, publicKeySpec, signature, MD5_WITH_RSA);
455 }
456
457 /**
458 * 使用公钥验证签名
459 * @param data 要进行校验的数据
460 * @param publicKeySpec RSA 专用公钥
461 * @param algorithm 签名校验算法，请参见本类中的名称为 {@code *__WITH_RSA} 的常量
462 * @param signature 数字签名
463 * @return
464 */
465 public static boolean verify(byte[] data, RSAPublicKeySpec publicKeySpec, byte[] signature, String algorithm) {
466 return verify(data, RSAUtil.getPublicKey(publicKeySpec), signature, algorithm);
467 }
468
469 /**
470 * 根据 MD5withRSA 算法使用公钥对文件生成数字签名校验
471 * @param file 要进行签名校验的文件
472 * @param publicKeySpec RSA 专用公钥
473 * @param signature 数字签名
474 * @return
475 */
476 public static boolean verify(File file, RSAPublicKeySpec publicKeySpec, byte[] signature){
477 return verify(file, publicKeySpec, signature, MD5_WITH_RSA);
478 }
479
480 /**
481 * 使用公钥对文件进行签名校验
482 * @param file 要进行签名校验的文件
483 * @param publicKeySpec RSA 专用公钥
484 * @param signature 数字签名
485 * @param algorithm 签名校验算法，请参见本类中的名称为 {@code *__WITH_RSA} 的常量
486 * @return
487 */
488 public static boolean verify(File file, RSAPublicKeySpec publicKeySpec, byte[] signature, String algorithm) {
489 return verify(file, RSAUtil.getPublicKey(publicKeySpec), signature, algorithm);
490 }
491
492 /**
493 * 根据 MD5withRSA 算法使用公钥对经过 BASE64 编码后的数据进行签名校验
494 * @param base64String 经过 BASE64 编码后的数据
495 * @param publicKeySpec RSA 专用公钥
496 * @param signature 数字签名
497 * @return
498 */
499 public static boolean verify(String base64String, RSAPublicKeySpec publicKeySpec, byte[] signature){
500 return verify(base64String, publicKeySpec, signature, MD5_WITH_RSA);
501 }
502
503 /**
504 * 使用公钥对经过 BASE64 编码后的数据进行签名校验
505 * @param base64String 经过 BASE64 编码后的数据
506 * @param publicKeySpec RSA 专用公钥
507 * @param signature 数字签名
508 * @param algorithm 签名校验算法，请参见本类中的名称为 {@code *__WITH_RSA} 的常量
509 * @return
510 */
511 public static boolean verify(String base64String, RSAPublicKeySpec publicKeySpec, byte[] signature, String algorithm){
512 return verify(base64String, RSAUtil.getPublicKey(publicKeySpec), signature, algorithm);
513 }
514
515 /**
516 * 根据 MD5withRSA 算法使用公钥对文件生成数字签名校验
517 * @param file 要进行签名校验的文件
518 * @param publicKeySpec RSA 专用公钥
519 * @param 经过 BASE64 编码后的数字签名
520 * @return
521 */
522 public static boolean verify(File file, RSAPublicKeySpec publicKeySpec, String base64Singature){
523 return verify(file, publicKeySpec, base64Singature, MD5_WITH_RSA);
524 }
525
526 /**
527 * 使用公钥对文件进行签名校验
528 * @param file 要进行签名校验的文件
529 * @param publicKeySpec RSA 专用公钥
530 * @param 经过 BASE64 编码后的数字签名
531 * @param algorithm 签名校验算法，请参见本类中的名称为 {@code *__WITH_RSA} 的常量
532 * @return
533 */
534 public static boolean verify(File file, RSAPublicKeySpec publicKeySpec, String base64Singature, String algorithm) {
535 return verify(file, RSAUtil.getPublicKey(publicKeySpec), base64Singature, algorithm);
536 }
537
538 /**
539 * 根据 MD5withRSA 算法使用公钥对经过 BASE64 编码后的数据进行签名校验
540 * @param data 要进行校验的数据
541 * @param publicKeySpec RSA 专用公钥
542 * @param 经过 BASE64 编码后的数字签名
543 * @return
544 */
545 public static boolean verify(String data, RSAPublicKeySpec publicKeySpec, String base64Singature){
546 return verify(data, publicKeySpec, base64Singature, MD5_WITH_RSA);
547 }
548
549 /**
550 * 使用公钥对经过 BASE64 编码后的数据进行签名校验
551 * @param data 要进行校验的数据
552 * @param publicKeySpec RSA 专用公钥
553 * @param 经过 BASE64 编码后的数字签名
554 * @param algorithm 签名校验算法，请参见本类中的名称为 {@code *__WITH_RSA} 的常量
555 * @return
556 */
557 public static boolean verify(String data, RSAPublicKeySpec publicKeySpec, String base64Singature, String algorithm){
558 return verify(data, RSAUtil.getPublicKey(publicKeySpec), base64Singature, algorithm);
559 }
560
561 /**
562 * 根据 MD5withRSA 算法使用经过 BASE64 编码的公钥字符串验证签名
563 * @param data 要进行校验的数据
564 * @param publicKey RSA 专用经过 BASE64 编码的公钥字符串
565 * @param signature 数字签名
566 * @return 签名校验后的数据
567 */
568 public static boolean verify(byte[] data, String publicKey, byte[] signature) {
569 return verify(data, publicKey, signature, MD5_WITH_RSA);
570 }
571
572 /**
573 * 使用经过 BASE64 编码的公钥字符串验证签名
574 * @param data 要进行校验的数据
575 * @param publicKey RSA 专用经过 BASE64 编码的公钥字符串
576 * @param algorithm 签名校验算法，请参见本类中的名称为 {@code *__WITH_RSA} 的常量
577 * @param signature 数字签名
578 * @return
579 */
580 public static boolean verify(byte[] data, String publicKey, byte[] signature, String algorithm) {
581 return verify(data, RSAUtil.getPublicKey(publicKey), signature, algorithm);
582 }
583
584 /**
585 * 根据 MD5withRSA 算法使用经过 BASE64 编码的公钥字符串对文件生成数字签名校验
586 * @param file 要进行签名校验的文件
587 * @param publicKey RSA 专用经过 BASE64 编码的公钥字符串
588 * @param signature 数字签名
589 * @return
590 */
591 public static boolean verify(File file, String publicKey, byte[] signature){
592 return verify(file, publicKey, signature, MD5_WITH_RSA);
593 }
594
595 /**
596 * 使用经过 BASE64 编码的公钥字符串对文件进行签名校验
597 * @param file 要进行签名校验的文件
598 * @param publicKey RSA 专用经过 BASE64 编码的公钥字符串
599 * @param signature 数字签名
600 * @param algorithm 签名校验算法，请参见本类中的名称为 {@code *__WITH_RSA} 的常量
601 * @return
602 */
603 public static boolean verify(File file, String publicKey, byte[] signature, String algorithm) {
604 return verify(file, RSAUtil.getPublicKey(publicKey), signature, algorithm);
605 }
606
607 /**
608 * 根据 MD5withRSA 算法使用经过 BASE64 编码的公钥字符串对经过 BASE64 编码后的数据进行签名校验
609 * @param base64String 经过 BASE64 编码后的数据
610 * @param publicKey RSA 专用经过 BASE64 编码的公钥字符串
611 * @param signature 数字签名
612 * @return
613 */
614 public static boolean verify(String base64String, String publicKey, byte[] signature){
615 return verify(base64String, publicKey, signature, MD5_WITH_RSA);
616 }
617
618 /**
619 * 使用经过 BASE64 编码的公钥字符串对经过 BASE64 编码后的数据进行签名校验
620 * @param base64String 经过 BASE64 编码后的数据
621 * @param publicKey RSA 专用经过 BASE64 编码的公钥字符串
622 * @param signature 数字签名
623 * @param algorithm 签名校验算法，请参见本类中的名称为 {@code *__WITH_RSA} 的常量
624 * @return
625 */
626 public static boolean verify(String base64String, String publicKey, byte[] signature, String algorithm){
627 return verify(base64String, RSAUtil.getPublicKey(publicKey), signature, algorithm);
628 }
629
630 /**
631 * 根据 MD5withRSA 算法使用经过 BASE64 编码的公钥字符串对文件生成数字签名校验
632 * @param file 要进行签名校验的文件
633 * @param publicKey RSA 专用经过 BASE64 编码的公钥字符串
634 * @param 经过 BASE64 编码后的数字签名
635 * @return
636 */
637 public static boolean verify(File file, String publicKey, String base64Singature){
638 return verify(file, publicKey, base64Singature, MD5_WITH_RSA);
639 }
640
641 /**
642 * 使用经过 BASE64 编码的公钥字符串对文件进行签名校验
643 * @param file 要进行签名校验的文件
644 * @param publicKey RSA 专用经过 BASE64 编码的公钥字符串
645 * @param 经过 BASE64 编码后的数字签名
646 * @param algorithm 签名校验算法，请参见本类中的名称为 {@code *__WITH_RSA} 的常量
647 * @return
648 */
649 public static boolean verify(File file, String publicKey, String base64Singature, String algorithm) {
650 return verify(file, RSAUtil.getPublicKey(publicKey), base64Singature, algorithm);
651 }
652
653 /**
654 * 根据 MD5withRSA 算法使用经过 BASE64 编码的公钥字符串对经过 BASE64 编码后的数据进行签名校验
655 * @param data 要进行校验的数据
656 * @param publicKey RSA 专用经过 BASE64 编码的公钥字符串
657 * @param 经过 BASE64 编码后的数字签名
658 * @return
659 */
660 public static boolean verify(String data, String publicKey, String base64Singature){
661 return verify(data, publicKey, base64Singature, MD5_WITH_RSA);
662 }
663
664 /**
665 * 使用经过 BASE64 编码的公钥字符串对经过 BASE64 编码后的数据进行签名校验
666 * @param data 要进行校验的数据
667 * @param publicKey RSA 专用经过 BASE64 编码的公钥字符串
668 * @param 经过 BASE64 编码后的数字签名
669 * @param algorithm 签名校验算法，请参见本类中的名称为 {@code *__WITH_RSA} 的常量
670 * @return
671 */
672 public static boolean verify(String data, String publicKey, String base64Singature, String algorithm){
673 return verify(data, RSAUtil.getPublicKey(publicKey), base64Singature, algorithm);
674 }
675
676 }