-
Notifications
You must be signed in to change notification settings - Fork 19
/
Test.java
1217 lines (1120 loc) · 48.4 KB
/
Test.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
package com.github.xiangyuecn.rsajava;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.nio.charset.Charset;
import java.security.MessageDigest;
import java.security.Provider;
import java.security.Security;
import java.security.Signature;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.crypto.Cipher;
/**
* RSA_PEM测试控制台主程序
*
* GitHub:https://github.com/xiangyuecn/RSA-java
*/
public class Test {
public static void main(String[] args) throws Exception{
//【请在这里编写你自己的测试代码】
ShowMenu(args);
}
static void RSATest(boolean fast) throws Exception{
//新生成一个RSA密钥，也可以通过已有的pem、xml文本密钥来创建RSA
RSA_Util rsa = new RSA_Util(512);
// RSA_Util rsa = new RSA_Util("pem或xml文本密钥");
// RSA_Util rsa = new RSA_Util(RSA_PEM.FromPEM("pem文本密钥"));
// RSA_Util rsa = new RSA_Util(RSA_PEM.FromXML("xml文本密钥"));
//得到pem对象
RSA_PEM pem=rsa.ToPEM(false);
//提取密钥pem字符串
String pem_pkcs1 = pem.ToPEM_PKCS1(false);
String pem_pkcs8 = pem.ToPEM_PKCS8(false);
//提取密钥xml字符串
String xml = rsa.ToXML(false);
AssertMsg(T("【"+rsa.keySize()+"私钥（XML）】：", "[ "+rsa.keySize()+" Private Key (XML) ]:"), rsa.keySize()==512);
S(xml);
S();
ST("【"+rsa.keySize()+"私钥（PKCS#1）】：", "[ "+rsa.keySize()+" Private Key (PKCS#1) ]:");
S(pem_pkcs1);
S();
ST("【"+rsa.keySize()+"公钥（PKCS#8）】：", "[ "+rsa.keySize()+" Public Key (PKCS#8) ]:");
S(pem.ToPEM_PKCS8(true));
S();
String str = T("abc内容123", "abc123");
String en=rsa.Encrypt("PKCS1", str);
ST("【加密】：", "[ Encrypt ]:");
S(en);
ST("【解密】：", "[ Decrypt ]:");
String de=rsa.Decrypt("PKCS1", en);
AssertMsg(de, de.equals(str));
if (!fast) {
String str2 = str; for (int i = 0; i < 15; i++) str2 += str2;
ST("【长文本加密解密】：", "[ Long text encryption and decryption ]:");
AssertMsg(str2.length() + T("个字 OK"," characters OK"), rsa.Decrypt("PKCS1", rsa.Encrypt("PKCS1",str2)).equals(str2));
}
ST("【签名SHA1】：", "[ Signature SHA1 ]:");
String sign = rsa.Sign("SHA1", str);
S(sign);
AssertMsg(T("校验 OK","Verify OK"), rsa.Verify("SHA1", sign, str));
S();
//用pem文本创建RSA
RSA_Util rsa2=new RSA_Util(RSA_PEM.FromPEM(pem_pkcs8));
RSA_PEM pem2=rsa2.ToPEM(false);
ST("【用PEM新创建的RSA是否和上面的一致】：", "[ Is the newly created RSA with PEM consistent with the above ]:");
Assert("XML：", pem2.ToXML(false) .equals( pem.ToXML(false) ));
Assert("PKCS1：", pem2.ToPEM_PKCS1(false) .equals( pem.ToPEM_PKCS1(false) ));
Assert("PKCS8：", pem2.ToPEM_PKCS8(false) .equals( pem.ToPEM_PKCS8(false) ));
//用xml文本创建RSA
RSA_Util rsa3=new RSA_Util(RSA_PEM.FromXML(xml));
RSA_PEM pem3=rsa3.ToPEM(false);
ST("【用XML新创建的RSA是否和上面的一致】：", "[ Is the newly created RSA with XML consistent with the above ]:");
Assert("XML：", pem3.ToXML(false) .equals( pem.ToXML(false) ));
Assert("PKCS1：", pem3.ToPEM_PKCS1(false) .equals( pem.ToPEM_PKCS1(false) ));
Assert("PKCS8：", pem3.ToPEM_PKCS8(false) .equals( pem.ToPEM_PKCS8(false) ));
//--------RSA_PEM私钥验证---------
//使用PEM全量参数构造pem对象
RSA_PEM pemX = new RSA_PEM(pem.Key_Modulus, pem.Key_Exponent, pem.Key_D
, pem.Val_P, pem.Val_Q, pem.Val_DP, pem.Val_DQ, pem.Val_InverseQ);
ST("【RSA_PEM是否和原始RSA一致】：", "[ Is RSA_PEM consistent with the original RSA ]:");
S(pemX.keySize() + T("位"," bits"));
Assert("XML：", pemX.ToXML(false) .equals( pem.ToXML(false) ));
Assert("PKCS1：", pemX.ToPEM_PKCS1(false) .equals( pem.ToPEM_PKCS1(false) ));
Assert("PKCS8：", pemX.ToPEM_PKCS8(false) .equals( pem.ToPEM_PKCS8(false) ));
ST("仅公钥：", "Public Key Only:");
Assert("XML：", pemX.ToXML(true) .equals( pem.ToXML(true) ));
Assert("PKCS1：", pemX.ToPEM_PKCS1(true) .equals( pem.ToPEM_PKCS1(true) ));
Assert("PKCS8：", pemX.ToPEM_PKCS8(true) .equals( pem.ToPEM_PKCS8(true) ));
//--------RSA_PEM公钥验证---------
RSA_PEM pemY = new RSA_PEM(pem.Key_Modulus, pem.Key_Exponent, null);
ST("【RSA_PEM仅公钥是否和原始RSA一致】：", "[ RSA_PEM only public key is consistent with the original RSA ]:");
S(pemY.keySize() + T("位"," bits"));
Assert("XML：", pemY.ToXML(false) .equals( pem.ToXML(true) ));
Assert("PKCS1：", pemY.ToPEM_PKCS1(false) .equals( pem.ToPEM_PKCS1(true) ));
Assert("PKCS8：", pemY.ToPEM_PKCS8(false) .equals( pem.ToPEM_PKCS8(true) ));
if (!fast) {
//使用n、e、d构造pem对象
RSA_PEM pem4 = new RSA_PEM(pem.Key_Modulus, pem.Key_Exponent, pem.Key_D);
RSA_Util rsa4=new RSA_Util(pem4);
ST("【用n、e、d构造解密】", "[ Construct decryption with n, e, d ]");
de=rsa4.Decrypt("PKCS1",en);
AssertMsg(de, de.equals(str));
AssertMsg(T("校验 OK","Verify OK"), rsa4.Verify("SHA1", sign, str));
//对调交换公钥私钥
ST("【Unsafe|对调公钥私钥，私钥加密公钥解密】", "[ Unsafe | Swap the public key and private key, private key encryption and public key decryption ]");
RSA_Util rsaPri=rsa.SwapKey_Exponent_D__Unsafe();
RSA_Util rsaPub=new RSA_Util(rsa.ToPEM(true)).SwapKey_Exponent_D__Unsafe();
String enPri=rsaPri.Encrypt("PKCS1", str);
String signPub=rsaPub.Sign("SHA1", str);
de=rsaPub.Decrypt("PKCS1",enPri);
AssertMsg(de, de.equals(str));
AssertMsg(T("校验 OK","Verify OK"), rsaPri.Verify("SHA1", signPub, str));
rsa4 = rsaPri.SwapKey_Exponent_D__Unsafe();
de=rsa4.Decrypt("PKCS1",en);
AssertMsg(de, de.equals(str));
AssertMsg(T("校验 OK","Verify OK"), rsa4.Verify("SHA1", sign, str));
}
if (!fast) {
S();
ST("【测试一遍所有的加密、解密填充方式】 按回车键继续测试...", "[ Test all the encryption and decryption padding mode ] Press Enter to continue testing...");
ReadIn();
RSA_Util rsa5 = new RSA_Util(2048);
testPaddings(false, rsa5, new RSA_Util(rsa5.ToPEM(true)), true);
}
}
static void Assert(String msg, boolean check) throws Exception {
AssertMsg(msg + check, check);
}
static void AssertMsg(String msg, boolean check) throws Exception {
if (!check) throw new Exception(msg);
System.out.println(msg);
}
/** 控制台输出一个换行 **/
static private void S() {
System.out.println();
}
/** 控制台输出内容 **/
static private void S(String s) {
System.out.println(s);
}
/** 控制台输出内容 + 简版多语言支持，根据当前语言返回中文或英文，简化调用{@link RSA_PEM#T(String, String)} **/
static private void ST(String zh, String en) {
System.out.println(T(zh, en));
}
/** 简版多语言支持，根据当前语言返回中文或英文，简化调用{@link RSA_PEM#T(String, String)} **/
static private String T(String zh, String en) {
return RSA_PEM.T(zh, en);
}
static public String ReadIn() throws Exception {
ByteArrayOutputStream in=new ByteArrayOutputStream();
while(true) {
int byt=System.in.read();
if(byt=='\r') continue;
if(byt=='\n') {
break;
}
if(in.size()>=2048) {//防止内存溢出，某些环境下可能会有无限的输入
byte[] bytes=in.toByteArray();
in=new ByteArrayOutputStream();
in.write(bytes, bytes.length-1024, 1024);
}
in.write(byt);
}
return in.toString();
}
static String ReadPath(String tips, String tips2) throws Exception {
while (true) {
ST("请输入"+tips+"路径"+tips2+": ","Please enter "+tips+" path"+tips2+":");
System.out.print("> ");
String path = ReadIn().trim();
if(path.length()==0 || path.startsWith("+")) {
return path;
}
if(!new File(path).exists()) {
ST("文件[" + path + "]不存在","File [" + path + "] does not exist");
continue;
}
return path;
}
}
static byte[] ReadFile(String path) throws Exception {
ByteArrayOutputStream bs=new ByteArrayOutputStream();
byte[] buffer=new byte[32*1024]; int len;
try(FileInputStream in=new FileInputStream(path)){
while((len=in.read(buffer))!=-1) {
bs.write(buffer, 0, len);
}
}
return bs.toByteArray();
}
static void WriteFile(String path, byte[] val) throws Exception {
try(FileOutputStream out=new FileOutputStream(path)){
out.write(val);
}
}
static String HR="-----------------------------------";
static boolean CanLoad_BouncyCastle() {
try {
Class.forName("org.bouncycastle.jce.provider.BouncyCastleProvider");
return true;
}catch(Exception e) {
return false;
}
}
static void printEnv() {
S("Java Version: "+System.getProperty("java.version")+" | "+System.getProperty("os.name")+" RSA_PEM.Lang="+RSA_PEM.Lang());
String errs="";
try {
Signature.getInstance("RSASSA-PSS");
}catch(Exception e) {
errs+=errs.length()>0?T("、",", "):"";
errs+=T("PSS签名填充模式（其他填充模式不影响）","PSS signature padding mode (other padding modes do not affect)");
}
try {
MessageDigest.getInstance("SHA-512/256");
}catch(Exception e) {
errs+=errs.length()>0?T("、",", "):"";
errs+=T("SHA-512/224（/256）摘要算法","SHA-512/224 (/256) digest algorithm");
}
try {
MessageDigest.getInstance("SHA3-256");
}catch(Exception e) {
errs+=errs.length()>0?T("、",", "):"";
errs+=T("SHA3系列摘要算法","SHA3 series digest algorithm");
}
if(errs.length()>0) {
ST("*** 当前Java版本太低，不支持："+errs+"；如需获得这些功能支持，解决办法1：升级使用高版本Java来运行本测试程序；解决办法2：引入BouncyCastle的jar加密增强包来兼容低版本Java，先到 https://www.bouncycastle.org/latest_releases.html 下载 bcprov-jdk**-**.jar 放到本测试程序源码目录，然后通过测试菜单B进行注册即可得到全部支持。","*** The current Java version is too low to support: "+errs+"; if you want to obtain these functions, solution 1: upgrade and use a higher version of Java to run this test program; solution 2: introduce the jar encryption enhancement package of BouncyCastle to be compatible with lower Version Java, first go to https://www.bouncycastle.org/latest_releases.html to download bcprov-jdk**-**.jar and put it in the source code directory of this test program, and then register through test menu B to get full support.");
}
}
static Provider BcProvider=null;
static void testProvider(boolean checkOpenSSL) throws Exception{
if(CanLoad_BouncyCastle()) {
if(BcProvider==null) {
ST("检测到BouncyCastle加密增强包，是否要进行注册？(Y/N) Y","The BouncyCastle encryption enhancement package is detected, do you want to register? (Y/N) Y");
}else {
ST("已注册BouncyCastle加密增强包，是否要保持注册？(Y/N) Y","BouncyCastle encryption enhancement package has been registered, do you want to keep it registered? (Y/N) Y");
}
System.out.print("> ");
String val = ReadIn().trim().toUpperCase();
try {
if(BcProvider==null && !"N".equals(val)) {
Class<?> cls=Class.forName("org.bouncycastle.jce.provider.BouncyCastleProvider");
Provider bc=(Provider)cls.getConstructor().newInstance();
Security.addProvider(bc);
RSA_Util.UseBouncyCastle(bc.getName());
BcProvider=bc;
ST("已注册BouncyCastle加密增强包","BouncyCastle encryption enhancement package registered");
}
if(BcProvider!=null && "N".equals(val)) {
Security.removeProvider(BcProvider.getName());
RSA_Util.UseBouncyCastle(null);
BcProvider=null;
ST("已取消注册BouncyCastle加密增强包","Unregistered BouncyCastle encryption enhancement package");
}
}catch(Exception e) {
S(T("BouncyCastle操作失败：","BouncyCastle operation failed: ")+e.getMessage());
}
}
printEnv();
S();
S("Security.getProviders:");
Provider[] ps=Security.getProviders();
for(Provider s : ps) {
S(" Provider: "+s.toString());
}
S();
String[] Hashs=new String[] {
"SHA-1","SHA-256","SHA-224","SHA-384","SHA-512"
,"SHA3-256","SHA3-224","SHA3-384","SHA3-512"
,"SHA-512/224","SHA-512/256","MD5"
};
S("MessageDigest.getInstance"+T("支持情况："," support status:"));
{
ArrayList<String> S=new ArrayList<String>(Arrays.asList(Hashs));
S.add("MD2");
S.add("SHAKE128"); S.add("SHAKE256");//https://blog.csdn.net/weixin_42579622/article/details/111644921
for(String s : S) {
String key=s;
try {
MessageDigest v=MessageDigest.getInstance(key);
S(" "+key+" | Provider: "+v.getProvider().toString());
}catch(Exception e) {
S(" [x] "+key);
}
}
}
S("Cipher.getInstance"+T("支持情况："," support status:"));
for(int i=0;i<1;i++) {
String v1=i==9999?"NONE":"ECB";
ArrayList<String> S=new ArrayList<>(Arrays.asList(new String[] {"NoPadding"
,"PKCS1Padding"
,"OAEPPadding"}));
for(String s : Hashs) {
S.add("OAEPwith"+s+"andMGF1Padding");
}
for(String s : S) {
String key="RSA/"+v1+"/"+s,key2=key;
while(true) {
try {
Cipher v=Cipher.getInstance(key2);
S(" "+key+" | Provider: "+v.getProvider().toString());
}catch(Exception e) {
if(key2.contains("512/2")) {
key2=key2.replace("/224", "(224)").replace("/256", "(256)");
continue;
}
S(" [x] "+key);
}
break;
}
}
}
S("Signature.getInstance"+T("支持情况："," support status:"));
for(int i=0;i<3;i++) {
String v2=i==1?"/PSS":"";
String[] S=i==2?new String[] {"RSASSA-PSS"}:Hashs;
for(String s : S) {
String key=i==2?s:(s.replace("SHA-", "SHA")+"withRSA"+v2),key2=key;
while(true) {
try {
Signature v=Signature.getInstance(key2);
S(" "+key+" | Provider: "+v.getProvider().toString());
}catch(Exception e) {
if(key2.contains("512/2")) {
key2=key2.replace("/224", "(224)").replace("/256", "(256)");
continue;
}
S(" [x] "+key);
}
break;
}
}
}
S(HR);
ST("测试一遍所有的加密、解密填充方式：","Test all the encryption and decryption padding mode:");
RSA_Util rsa = new RSA_Util(2048);
testPaddings(checkOpenSSL, rsa, new RSA_Util(rsa.ToPEM(true)), true);
S(HR);
ST("Unsafe|是否要对调公钥私钥（私钥加密公钥解密）重新测试一遍？(Y/N) N", "Unsafe | Do you want to swap the public and private keys (private key encryption and public key decryption) and test again? (Y/N) N");
System.out.print("> ");
String yn = ReadIn().trim().toUpperCase();
if (yn.equals("Y")) {
RSA_Util rsaPri = rsa.SwapKey_Exponent_D__Unsafe();
RSA_Util rsaPub = new RSA_Util(rsa.ToPEM(true)).SwapKey_Exponent_D__Unsafe();
testPaddings(checkOpenSSL, rsaPub, rsaPri, true);
}
}
/** 测试一遍所有的加密、解密填充方式 **/
static int testPaddings(boolean checkOpenSSL, RSA_Util rsaPri, RSA_Util rsaPub, boolean log) {
int errCount=0;
ArrayList<String> errMsgs=new ArrayList<>();
String txt="1234567890";
if(!checkOpenSSL) {
txt+=txt+txt+txt+txt; txt+=txt;//100
txt+=txt+txt+txt+txt; txt+=txt+"a";//1001
}
byte[] txtData=txt.getBytes(Charset.forName("utf-8"));
if(checkOpenSSL) {
try {
runOpenSSL(rsaPri.hasPrivate()?rsaPri:rsaPub, txtData);
}catch(Exception e) {
S(T("运行OpenSSL失败：","Failed to run OpenSSL: ")+e.getMessage());
return errCount;
}
}
String[] encKeys=RSA_Util.RSAPadding_Enc_DefaultKeys();
for(String type : encKeys) {
String errMsg="";
try {
{
byte[] enc=rsaPub.Encrypt(type, txtData);
byte[] dec=rsaPri.Decrypt(type, enc);
boolean isOk=true;
if(dec.length!=txtData.length) {
isOk=false;
}else {
for(int i=0;i<dec.length;i++) {
if(dec[i]!=txtData[i]) {
isOk=false;break;
}
}
}
if(!isOk) {
errMsg=T("解密结果不一致","Decryption results are inconsistent");
throw new Exception(errMsg);
}
}
if(checkOpenSSL) {
byte[] enc;
try {
enc=testOpenSSL(true, type);
}catch(Exception e) {
errMsg="+OpenSSL: "+T("OpenSSL加密出错", "OpenSSL encryption error");
throw e;
}
byte[] dec=rsaPri.Decrypt(type, enc);
boolean isOk=true;
if(dec.length!=txtData.length) {
isOk=false;
}else {
for(int i=0;i<dec.length;i++) {
if(dec[i]!=txtData[i]) {
isOk=false;break;
}
}
}
if(!isOk) {
errMsg="+OpenSSL: "+T("解密结果不一致","Decryption results are inconsistent");
throw new Exception(errMsg);
}
}
if(log) {
S(" "+(checkOpenSSL?" [+OpenSSL]":"")+" "+T("加密解密：","Encryption decryption: ")+type+" | "+RSA_Util.RSAPadding_Enc(type));
}
}catch (Exception e) {
if(!log && RSA_Util.IsJavaLowVerSupportError(e)) {
//NOOP
}else {
errCount++;
if(errMsg.length()==0)errMsg=T("加密解密出现异常","An exception occurred in encryption decryption");
errMsg=" [x] "+errMsg+": "+type+" | "+RSA_Util.RSAPadding_Enc(type);
S(errMsg);
errMsgs.add(errMsg+T("。",". ")+e.getMessage());
}
}
}
String[] signKeys=RSA_Util.RSAPadding_Sign_DefaultKeys();
for(String type : signKeys) {
String errMsg="";
try {
{
byte[] sign=rsaPri.Sign(type, txtData);
boolean isOk=rsaPub.Verify(type, sign, txtData);
if(!isOk) {
errMsg=T("未通过校验","Failed verification");
throw new Exception(errMsg);
}
}
if(checkOpenSSL) {
byte[] sign;
try {
sign=testOpenSSL(false, type);
}catch(Exception e) {
errMsg="+OpenSSL: "+T("OpenSSL签名出错", "OpenSSL signature error");
throw e;
}
boolean isOk=rsaPub.Verify(type, sign, txtData);
if(!isOk) {
errMsg="+OpenSSL: "+T("未通过校验","Failed verification");
throw new Exception(errMsg);
}
}
if(log) {
S(" "+(checkOpenSSL?" [+OpenSSL]":"")+" "+T("签名验证：","Signature verification: ")+type+" | "+RSA_Util.RSAPadding_Sign(type));
}
}catch (Exception e) {
if(!log && RSA_Util.IsJavaLowVerSupportError(e)) {
//NOOP
}else if(!log && type.equals("PSS+MD5")) {
//NOOP 不同实现下不一定支持，没有提前检测
}else {
errCount++;
if(errMsg.length()==0) errMsg=T("签名验证出现异常","An exception occurred in signature verification");
errMsg=" [x] "+errMsg+": "+type+" | "+RSA_Util.RSAPadding_Sign(type);
S(errMsg);
errMsgs.add(errMsg+T("。",". ")+e.getMessage());
}
}
}
if(log) {
if(errMsgs.size()==0) {
ST("填充方式全部测试通过。", "All padding mode tests passed.");
}else {
ST("按回车键显示详细错误消息...", "Press Enter to display detailed error message...");
try{ ReadIn(); }catch(Exception e) {}
}
}
if(errMsgs.size()>0) {
S(String.join("\n", errMsgs));
}
closeOpenSSL();
return errCount;
}
/** 多线程并发调用同一个RSA **/
static void threadRun() throws Exception {
int ThreadCount=Math.max(5, Runtime.getRuntime().availableProcessors()-1);
AtomicBoolean Abort=new AtomicBoolean(false);
AtomicInteger Count=new AtomicInteger(0);
AtomicInteger ErrCount=new AtomicInteger(0);
RSA_Util rsa=new RSA_Util(2048);
RSA_Util rsaPub=new RSA_Util(rsa.ToPEM(true));
S(T("正在测试中，线程数：","Under test, number of threads: ")+ThreadCount+T("，按回车键结束测试...",", press enter to end the test..."));
for(int i=0;i<ThreadCount;i++) {
new Thread(new Runnable() {
public void run() {
while(!Abort.get()) {
int err=testPaddings(false, rsa, rsaPub, false);
if(err>0) {
ErrCount.addAndGet(err);
}
Count.incrementAndGet();
}
}
}).start();
}
long t1=System.currentTimeMillis();
new Thread(new Runnable() {
public void run() {
while(!Abort.get()) {
System.out.print("\r"+T("已测试"+Count.get()+"次，","Tested "+Count.get()+" times, ")
+ErrCount.get()+T("个错误，"," errors, ")
+T("耗时","")+(System.currentTimeMillis()-t1)/1000+T("秒"," seconds total"));
try {
Thread.sleep(1000);
}catch (Exception e) {}
}
}
}).start();
ReadIn();
Abort.set(true);
ST("多线程并发调用同一个RSA测试已结束。","Multiple threads concurrently calling the same RSA test is over.");
S();
}
static void keyTools() throws Exception {
ST("===== RSA密钥工具：生成密钥、转换密钥格式 ====="
, "===== RSA key tool: generate key, convert key format =====");
ST("请使用下面可用命令进行操作，命令[]内的为可选参数，参数可用\"\"包裹。","Please use the following commands to operate. The parameters in the command `[]` are optional parameters, and the parameters can be wrapped with \"\".");
S(HR);
S("`new 1024 [-pkcs8] [saveFile [puboutFile]]`: "+T("生成新的RSA密钥，指定位数和格式：xml、pkcs1、或pkcs8（默认），提供saveFile可保存私钥到文件，提供puboutFile可额外保存一个公钥文件","Generate a new RSA key, specify the number of digits and format: xml, pkcs1, or pkcs8 (default), provide saveFile to save the private key to a file, and provide puboutFile to save an additional public key file"));
S(HR);
S("`convert -pkcs1 [-pubout] [-swap] oldFile [newFile]`: "+T("转换密钥格式，提供已有密钥文件oldFile（支持xml、pem格式公钥或私钥），指定要转换成的格式：xml、pkcs1、或pkcs8，提供了-pubout时只导出公钥，提供了-swap时交换公钥指数私钥指数（非常规的：私钥加密公钥解密），提供newFile可保存到文件","To convert the key format, provide the existing key file oldFile (support xml, pem format public key or private key), specify the format to be converted into: xml, pkcs1, or pkcs8, only export the public key when -pubout is provided, swap public key exponent and private key exponent when -swap is provided (unconventional: private key encryption and public key decryption), and provide newFile Can save to file"));
S(HR);
S("`exit`: "+T("输入 exit 退出工具","Enter exit to quit the tool"));
loop: while(true){
System.out.print("> ");
String inStr=ReadIn().trim();
if(inStr.length()==0) {
ST("输入为空，请重新输入！如需退出请输入exit","The input is empty, please re-enter! If you need to exit, please enter exit");
continue;
}
if(inStr.toLowerCase().equals("exit")) {
ST("bye! 已退出。","bye! has exited.");
S();
return;
}
ArrayList<String> args=new ArrayList<>();
Pattern exp=Pattern.compile("(-?)(?:([^\"\\s]+)|\"(.*?)\")\\s*");
Matcher m=exp.matcher(inStr);
StringBuffer sb = new StringBuffer();
while(m.find()) {
if(m.group(2)!=null&&m.group(2).length()>0) {
args.add(m.group(1)+m.group(2));
}else {
args.add(m.group(1)+m.group(3));
}
m.appendReplacement(sb, "");
}
m.appendTail(sb);
if(sb.length()>0) {
ST("参数无效："+sb,"Invalid parameter: "+sb);
continue;
}
String cmdName=args.get(0).toLowerCase(); args.remove(0);
boolean nextSave=false;
RSA_Util rsa=null; String type="", save="", save2=""; boolean pubOut=false;
if(cmdName.equals("new")) {// 生成新的pem密钥
type="pkcs8"; String len="";
while(args.size()>0) {
String param=args.get(0),p=param.toLowerCase(); args.remove(0);
m=Pattern.compile("^(\\d+)$").matcher(p);
if(m.find()) { len=m.group(1); continue; }
m=Pattern.compile("^-(xml|pkcs1|pkcs8)$").matcher(p);
if(m.find()) { type=m.group(1); continue; }
if(save.length()==0 && !p.startsWith("-")) { save=param; continue; }
if(save2.length()==0 && !p.startsWith("-")) { save2=param; continue; }
ST("未知参数："+param,"Unknown parameter: "+param);
continue loop;
}
if(len.length()==0) { ST("请提供密钥位数！","Please provide key digits!");continue loop; }
try {
rsa=new RSA_Util(Integer.parseInt(len));
}catch(Exception e) {
S(T("生成密钥出错：","Error generating key: ")+e.getMessage());
continue loop;
}
nextSave=true;
}
if(cmdName.equals("convert")) {// 转换密钥格式
String old=""; boolean swap=false;
while(args.size()>0) {
String param=args.get(0),p=param.toLowerCase(); args.remove(0);
m=Pattern.compile("^-(xml|pkcs1|pkcs8)$").matcher(p);
if(m.find()) { type=m.group(1); continue; }
if(p.equals("-pubout")) { pubOut=true; continue; }
if(p.equals("-swap")) { swap=true; continue; }
if(old.length()==0 && !p.startsWith("-")) { old=param; continue; }
if(save.length()==0 && !p.startsWith("-")) { save=param; continue; }
ST("未知参数："+param,"Unknown parameter: "+param);
continue loop;
}
if(type.length()==0) { ST("请提供要转换成的格式！","Please provide the format to convert to!");continue loop; }
if(old.length()==0) { ST("请提供已有密钥文件！","Please provide an existing key file!");continue loop; }
try {
String oldTxt=new String(ReadFile(old),"utf-8");
rsa=new RSA_Util(oldTxt);
if(swap) rsa=rsa.SwapKey_Exponent_D__Unsafe();
}catch(Exception e) {
S(T("读取密钥文件出错","Error reading key file ")+" ("+old+"): "+e.getMessage());
continue loop;
}
nextSave=true;
}
while(nextSave) {
String val;
if(type.equals("xml")) {
val=rsa.ToXML(pubOut);
}else {
boolean pkcs8=type.equals("pkcs8");
val=rsa.ToPEM(false).ToPEM(pubOut, pkcs8, pkcs8);
}
if(save.length()==0) {
S(val);
}else {
save=new File(save).getAbsolutePath();
try{
WriteFile(save, val.getBytes("utf-8"));
}catch(Exception e) {
S(T("保存文件出错","Error saving file ")+" ("+save+"): "+e.getMessage());
}
S(T("密钥文件已保存到：","The key file has been saved to: ")+save);
}
if(save2.length()>0) {
save=save2; save2="";
pubOut=true;
continue;
}
S();
continue loop;
}
ST("未知命令："+cmdName,"Unknown command: "+cmdName);
}
}
static RSA_PEM loadKey=null; static String loadKeyFile="";
/** 设置：加载密钥PEM文件 **/
static void setLoadKey() throws Exception {
String path=ReadPath(T("密钥文件","Key File")
, T("，或文件夹（内含private.pem、test.txt）。或输入'+1024 pkcs8'生成一个新密钥（填写位数、pkcs1、pkcs8）", ", or a folder (containing private.pem, test.txt). Or enter '+1024 pkcs8' to generate a new key (fill in digits, pkcs1, pkcs8) "));
if(path.startsWith("+")) {//创建一个新密钥
Matcher m=Pattern.compile("^\\+(\\d+)\\s+pkcs([18])$",Pattern.CASE_INSENSITIVE).matcher(path);
if(!m.find()) {
ST("格式不正确，请重新输入！","The format is incorrect, please re-enter!");
setLoadKey();
}else {
int keySize=Integer.parseInt(m.group(1));
RSA_Util rsa=new RSA_Util(keySize);
boolean isPkcs8=m.group(2).equals("8");
RSA_PEM pem=rsa.ToPEM(false);
S(keySize+T("位私钥已生成，请复制此文本保存到private.pem文件："," bit private key has been generated. Please copy this text and save it to the private.pem file:"));
S(pem.ToPEM(false, isPkcs8, isPkcs8));
S(keySize+T("位公钥已生成，请复制此文本保存到public.pem文件："," bit public key has been generated. Please copy this text and save it to the public.pem file:"));
S(pem.ToPEM(true, isPkcs8, isPkcs8));
waitAnyKey=true;
}
return;
}
if(path.length()==0 && loadKeyFile.length()==0) {
ST("未输入文件，已取消操作","No file input, operation cancelled");
return;
}
if(path.length()==0) {
path=loadKeyFile;
ST("重新加载密钥文件","Reload key file");
}
if(new File(path).isDirectory()) {
String txtPath=path+File.separator+"test.txt";
path=path+File.separator+"private.pem";
if(!new File(path).exists()) {
ST("此文件夹中没有private.pem文件！","There is no private.pem file in this folder!");
setLoadKey();
return;
}
if(new File(txtPath).exists()) {//顺带加载文件夹里面的目标源文件
loadSrcBytes=ReadFile(txtPath);
loadSrcFile=txtPath;
}
}
String pem=new String(ReadFile(path),"utf-8");
loadKey=RSA_PEM.FromPEM(pem);
loadKeyFile=path;
}
static byte[] loadSrcBytes=null; static String loadSrcFile="";
/** 设置：加载目标源文件 **/
static void setLoadSrcBytes() throws Exception {
String path=ReadPath(T("目标源文件","Target Source File"), "");
if(path.length()==0 && loadSrcFile.length()==0) {
ST("未输入文件，已取消操作","No file input, operation cancelled");
return;
}
if(path.length()==0) {
path=loadSrcFile;
ST("重新加载目标源文件","Reload target source file");
}
loadSrcBytes=ReadFile(path);
loadSrcFile=path;
}
static String encType="";
/** 设置加密填充模式 **/
static boolean setEncType() throws Exception {
S(T("请输入加密填充模式","Please enter the encryption Padding mode")
+(encType.length()>0?T("，回车使用当前值",", press Enter to use the current value ")+encType:"")
+T("；填充模式取值可选：","; Padding mode values: ")+String.join(", ", RSA_Util.RSAPadding_Enc_DefaultKeys())
+T(", 或其他支持的值",", or other supported values"));
System.out.print("> ");
String val = ReadIn().trim();
if(val.length()>0) {
encType=val;
}
if(encType.length()==0) {
ST("未设置，已取消操作","Not set, operation canceled");
}
return encType.length()>0;
}
/** 加密 **/
static void execEnc() throws Exception {
String save=loadSrcFile+".enc.bin";
S(T("密钥文件：","Key file: ")+loadKeyFile);
S(T("目标文件：","Target file: ")+loadSrcFile);
S(T("填充模式：","Padding mode: ")+encType+" | "+RSA_Util.RSAPadding_Enc(encType));
ST("正在加密目标源文件...","Encrypting target source file...");
RSA_Util rsa=new RSA_Util(loadKey);
long t1=System.currentTimeMillis();
byte[] data=rsa.Encrypt(encType, loadSrcBytes);
S(T("加密耗时：","Encryption time: ")+(System.currentTimeMillis()-t1)+"ms");
WriteFile(save, data);
S(T("已加密，结果已保存：","Encrypted, the result is saved: ")+save);
}
/** 解密对比 **/
static void execDec() throws Exception {
String encPath=loadSrcFile+".enc.bin";
S(T("密钥文件：","Key file: ")+loadKeyFile);
S(T("密文文件：","Ciphertext file: ")+encPath);
S(T("对比文件：","Compare files: ")+loadSrcFile);
S(T("填充模式：","Padding mode: ")+encType+" | "+RSA_Util.RSAPadding_Enc(encType));
byte[] data=ReadFile(encPath);
ST("正在解密文件...","Decrypting file...");
RSA_Util rsa=new RSA_Util(loadKey);
long t1=System.currentTimeMillis();
byte[] val=rsa.Decrypt(encType, data);
S(T("解密耗时：","Decryption time: ")+(System.currentTimeMillis()-t1)+"ms");
WriteFile(loadSrcFile+".dec.txt",val);
boolean isOk=true;
if(val.length!=loadSrcBytes.length) {
isOk=false;
}else {
for(int i=0;i<val.length;i++) {
if(val[i]!=loadSrcBytes[i]) {
isOk=false;break;
}
}
}
if(isOk) {
ST("解密成功，和对比文件的内容一致。","The decryption is successful, which is consistent with the content of the comparison file.");
return;
}
throw new Exception(T("解密结果和对比文件的内容不一致！","The decryption result is inconsistent with the content of the comparison file!"));
}
static String signType="";
/** 设置签名hash+填充模式 **/
static boolean setSignType() throws Exception {
S(T("请输入签名Hash+填充模式","Please enter the signature Hash+Padding mode")
+(signType.length()>0?T("，回车使用当前值",", press Enter to use the current value ")+signType:"")
+T("；签名模式取值可选：","; Signature mode values: ")+String.join(", ", RSA_Util.RSAPadding_Sign_DefaultKeys())
+T(", 或其他支持的值",", or other supported values"));
System.out.print("> ");
String val = ReadIn().trim();
if(val.length()>0) {
signType=val;
}
if(signType.length()==0) {
ST("未设置，已取消操作","Not set, operation canceled");
}
return signType.length()>0;
}
/** 签名 **/
static void execSign() throws Exception {
String save=loadSrcFile+".sign.bin";
S(T("密钥文件：","Key file: ")+loadKeyFile);
S(T("目标文件：","Target file: ")+loadSrcFile);
S(T("签名模式：","Signature mode: ")+signType+" | "+RSA_Util.RSAPadding_Sign(signType));
ST("正在给目标源文件签名...","Signing target source file...");
RSA_Util rsa=new RSA_Util(loadKey);
byte[] data=rsa.Sign(signType, loadSrcBytes);
WriteFile(save, data);
S(T("已签名，结果已保存：","Signed, results saved: ")+save);
}
/** 验证签名 **/
static void execVerify() throws Exception {
String binPath=loadSrcFile+".sign.bin";
S(T("密钥文件：","Key file: ")+loadKeyFile);
S(T("目标文件：","Target file: ")+loadSrcFile);
S(T("签名文件：","Signature file: ")+binPath);
S(T("签名模式：","Signature mode: ")+signType+" | "+RSA_Util.RSAPadding_Sign(signType));
byte[] data=ReadFile(binPath);
ST("正在验证签名...","Verifying signature...");
RSA_Util rsa=new RSA_Util(loadKey);
boolean val=rsa.Verify(signType, data, loadSrcBytes);
if(val) {
ST("签名验证成功。","Signature verification successful.");
return;
}
throw new Exception(T("签名验证失败！","Signature verification failed!"));
}
/** 调用openssl相关测试代码 **/
static void runOpenSSL(RSA_Util rsa, byte[] data) throws Exception{
String shell="/bin/bash", charset="utf-8";
if(System.getProperty("os.name").toLowerCase().contains("windows")) {
shell="cmd"; charset="gbk";
}
S(T("正在打开OpenSSL...","Opening OpenSSL...")+" Shell: "+shell);
closeOpenSSL();
openSSLProc=Runtime.getRuntime().exec(new String[] { shell });
openSSLWrite=new BufferedWriter(new OutputStreamWriter(openSSLProc.getOutputStream(), charset));
openSSLRead=new BufferedReader(new InputStreamReader(openSSLProc.getInputStream(), charset));
openSSLErrRead=new BufferedReader(new InputStreamReader(openSSLProc.getErrorStream(), charset));
openSSLBuffer=new StringBuffer();
openSSLErrBuffer=new StringBuffer();
openSSLThread1=new Thread(new Runnable() {
public void run() {
try {
while(true){
String line=openSSLRead.readLine();
if(line!=null) {
openSSLBuffer.append(line).append('\n');
}
}
}catch (Exception e) { }
}
});
openSSLThread2=new Thread(new Runnable() {
public void run() {
try {
while(true){
String line=openSSLErrRead.readLine();
if(line!=null) {
openSSLErrBuffer.append(line).append('\n');
}
}
}catch (Exception e) { }
}
});
openSSLThread1.start();
openSSLThread2.start();
WriteFile("test_openssl_key.pem", rsa.ToPEM(false).ToPEM_PKCS8(false).getBytes("utf-8"));
WriteFile("test_openssl_data.txt", data);
byte[] no=new byte[rsa.keySize()/8];
System.arraycopy(data, 0, no, no.length-data.length, data.length);
WriteFile("test_openssl_data.txt.nopadding.txt", no);
openSSLWrite.write("openssl version\necho "+openSSLBoundary+"\n");
openSSLWrite.flush();
while(true) {
if(openSSLBuffer.indexOf(openSSLBoundary)!=-1) {
if(openSSLErrBuffer.length()>0) {
closeOpenSSL();
throw new Exception(T("打开OpenSSL出错：","Error opening OpenSSL: ")+openSSLErrBuffer.toString().trim());
}
S("OpenSSL Version: "+openSSLBuffer.toString().trim());
break;
}
Thread.sleep(10);
}
}
static private Process openSSLProc;
static private BufferedWriter openSSLWrite;
static private BufferedReader openSSLRead, openSSLErrRead;
static private StringBuffer openSSLBuffer, openSSLErrBuffer;
static private Thread openSSLThread1, openSSLThread2;
static private final String openSSLBoundary="--openSSL boundary--";
static void closeOpenSSL() {
if(openSSLProc==null)return;
try {openSSLWrite.close();}catch(Exception e) { }
try {openSSLRead.close();}catch(Exception e) { }
try {openSSLErrRead.close();}catch(Exception e) { }
try {openSSLProc.destroy();}catch(Exception e) { }
try {openSSLThread1.interrupt(); openSSLThread2.interrupt();}catch(Exception e) { }
openSSLProc=null;
}
static byte[] testOpenSSL(boolean encOrSign, String mode) throws Exception {
boolean debug=false; String cmd="";
String keyFile="test_openssl_key.pem",txtFile="test_openssl_data.txt";
String save=txtFile+(encOrSign?".enc.bin":".sign.bin");
if(encOrSign) {//加密
if(mode.equals("NO")) {
cmd="openssl pkeyutl -encrypt -pkeyopt rsa_padding_mode:none -in "+txtFile+".nopadding.txt -inkey "+keyFile+" -out "+save;
} else if(mode.equals("PKCS1")) {
cmd="openssl pkeyutl -encrypt -pkeyopt rsa_padding_mode:pkcs1 -in "+txtFile+" -inkey "+keyFile+" -out "+save;
} else if(mode.startsWith("OAEP+")) {
String hash=mode.replace("OAEP+", "").replace("-512/", "512-");
cmd="openssl pkeyutl -encrypt -pkeyopt rsa_padding_mode:oaep -pkeyopt rsa_oaep_md:"+hash+" -in "+txtFile+" -inkey "+keyFile+" -out "+save;
}
}else {//签名
if(mode.startsWith("PKCS1+")) {
String hash=mode.replace("PKCS1+", "").replace("-512/", "512-");
cmd="openssl dgst -"+hash+" -binary -sign "+keyFile+" -out "+save+" "+txtFile;
}else if(mode.startsWith("PSS+")) {
String hash=mode.replace("PSS+", "").replace("-512/", "512-");
cmd="openssl dgst -"+hash+" -binary -out "+txtFile+".hash "+txtFile;
cmd+="\n";
cmd+="openssl pkeyutl -sign -pkeyopt digest:"+hash+" -pkeyopt rsa_padding_mode:pss -pkeyopt rsa_pss_saltlen:-1 -in "+txtFile+".hash -inkey "+keyFile+" -out "+save;