信息计算2019级2班3号徐柳婧

徐柳婧

RSA签名和加密

一、Java实现RSA签名和加密

在公开密钥加密和电子商业中RSA被广泛使用。RSA是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。

RSA属于非对称加密算法，有两个密钥。区别于共享密钥的对称加密算法，如DES和AES。公钥可以共享给任何人，私钥自己进行保管。公钥用于加密数据，使得该加密数据只能用私钥进行解密；私钥也可用于签名数据，签名和数据一起发送，然后使用公钥验证数据是否被篡改。

二、RSA实现密钥对
在实际做任何形式加密之前，需要有公钥和私钥两个密钥对。幸运的是，Java提供了非常简单的方法，首先获得RSA KeyPairGenerator实例，然后使用2048为长度进行初始化并传入SecureRandom实例。后者用作生成器的熵或随机数据源。第三行生成密钥对，所有内容都就是这样，非常简单。如果需要使用密钥对存储器，需要使用Java KeyStore工具,后面会详细解释。
三、加密和解密
这里使用base64编码，主要是典型的REST API中很常用，我们当然也可以不用base64编码而直接使用字节数组。确保明确地且一致地为字符串指定字节编码。否则字节错位将导致密文和无法解密或验证签名。首先获得RSA密码实例并设置为加密模式，然后使用公钥加密消息。然后一次性传入消息字符串的字节数组并获得加密后的字节数组，最后转码并返回。运维RSA是相当慢，比对称加密算法如AES要慢的多。
四、签名与验证
我们使用公钥进行加密，然后使用私钥解密。理论上反过来也行（私钥加密，公钥解密），但这不安全且大多数库(包括java.security)也不支持。然而，这种方式在构建API时比较有用。使用私钥对消息进行签名，然后使用公钥进行验证签名。这种机制可以确保消息确实来着公钥创建者(私钥持有者)，使得传输过程消息不会被篡改。

加密和签名都是为了安全性考虑，但略有不同。常有人问加密和签名是用私钥还是公钥？其实都是对加密和签名的作用有所混淆。简单的说，加密是为了防止信息被泄露，而签名是为了防止信息被篡改。

徐柳婧

程序代码：Base64.java

1. package com.ihep;
   
2. 
   
3. public final class Base64 {
   
4. 
   
5.     static private final int     BASELENGTH           = 128;
   
6.     static private final int     LOOKUPLENGTH         = 64;
   
7.     static private final int     TWENTYFOURBITGROUP   = 24;
   
8.     static private final int     EIGHTBIT             = 8;
   
9.     static private final int     SIXTEENBIT           = 16;
   
10.     static private final int     FOURBYTE             = 4;
    
11.     static private final int     SIGN                 = -128;
    
12.     static private final char    PAD                  = '=';
    
13.     static private final boolean fDebug               = false;
    
14.     static final private byte[]  base64Alphabet       = new byte[BASELENGTH];
    
15.     static final private char[]  lookUpBase64Alphabet = new char[LOOKUPLENGTH];
    
16. 
    
17.     static {
    
18.         for (int i = 0; i < BASELENGTH; ++i) {
    
19.             base64Alphabet[i] = -1;
    
20.         }
    
21.         for (int i = 'Z'; i >= 'A'; i--) {
    
22.             base64Alphabet[i] = (byte) (i - 'A');
    
23.         }
    
24.         for (int i = 'z'; i >= 'a'; i--) {
    
25.             base64Alphabet[i] = (byte) (i - 'a' + 26);
    
26.         }
    
27. 
    
28.         for (int i = '9'; i >= '0'; i--) {
    
29.             base64Alphabet[i] = (byte) (i - '0' + 52);
    
30.         }
    
31. 
    
32.         base64Alphabet['+'] = 62;
    
33.         base64Alphabet['/'] = 63;
    
34. 
    
35.         for (int i = 0; i <= 25; i++) {
    
36.             lookUpBase64Alphabet[i] = (char) ('A' + i);
    
37.         }
    
38. 
    
39.         for (int i = 26, j = 0; i <= 51; i++, j++) {
    
40.             lookUpBase64Alphabet[i] = (char) ('a' + j);
    
41.         }
    
42. 
    
43.         for (int i = 52, j = 0; i <= 61; i++, j++) {
    
44.             lookUpBase64Alphabet[i] = (char) ('0' + j);
    
45.         }
    
46.         lookUpBase64Alphabet[62] = (char) '+';
    
47.         lookUpBase64Alphabet[63] = (char) '/';
    
48. 
    
49.     }
    
50. 
    
51.     private static boolean isWhiteSpace(char octect) {
    
52.         return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9);
    
53.     }
    
54. 
    
55.     private static boolean isPad(char octect) {
    
56.         return (octect == PAD);
    
57.     }
    
58. 
    
59.     private static boolean isData(char octect) {
    
60.         return (octect < BASELENGTH && base64Alphabet[octect] != -1);
    
61.     }
    
62. 
    
63.     public static String encode(byte[] binaryData) {
    
64. 
    
65.         if (binaryData == null) {
    
66.             return null;
    
67.         }
    
68. 
    
69.         int lengthDataBits = binaryData.length * EIGHTBIT;
    
70.         if (lengthDataBits == 0) {
    
71.             return "";
    
72.         }
    
73. 
    
74.         int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;
    
75.         int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;
    
76.         int numberQuartet = fewerThan24bits != 0 ? numberTriplets + 1 : numberTriplets;
    
77.         char encodedData[] = null;
    
78. 
    
79.         encodedData = new char[numberQuartet * 4];
    
80. 
    
81.         byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;
    
82. 
    
83.         int encodedIndex = 0;
    
84.         int dataIndex = 0;
    
85.         if (fDebug) {
    
86.             System.out.println("number of triplets = " + numberTriplets);
    
87.         }
    
88. 
    
89.         for (int i = 0; i < numberTriplets; i++) {
    
90.             b1 = binaryData[dataIndex++];
    
91.             b2 = binaryData[dataIndex++];
    
92.             b3 = binaryData[dataIndex++];
    
93. 
    
94.             if (fDebug) {
    
95.                 System.out.println("b1= " + b1 + ", b2= " + b2 + ", b3= " + b3);
    
96.             }
    
97. 
    
98.             l = (byte) (b2 & 0x0f);
    
99.             k = (byte) (b1 & 0x03);
    
100. 
     
101.             byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
     
102.             byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);
     
103.             byte val3 = ((b3 & SIGN) == 0) ? (byte) (b3 >> 6) : (byte) ((b3) >> 6 ^ 0xfc);
     
104. 
     
105.             if (fDebug) {
     
106.                 System.out.println("val2 = " + val2);
     
107.                 System.out.println("k4   = " + (k << 4));
     
108.                 System.out.println("vak  = " + (val2 | (k << 4)));
     
109.             }
     
110. 
     
111.             encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
     
112.             encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];
     
113.             encodedData[encodedIndex++] = lookUpBase64Alphabet[(l << 2) | val3];
     
114.             encodedData[encodedIndex++] = lookUpBase64Alphabet[b3 & 0x3f];
     
115.         }
     
116. 
     
117.         // form integral number of 6-bit groups
     
118.         if (fewerThan24bits == EIGHTBIT) {
     
119.             b1 = binaryData[dataIndex];
     
120.             k = (byte) (b1 & 0x03);
     
121.             if (fDebug) {
     
122.                 System.out.println("b1=" + b1);
     
123.                 System.out.println("b1<<2 = " + (b1 >> 2));
     
124.             }
     
125.             byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
     
126.             encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
     
127.             encodedData[encodedIndex++] = lookUpBase64Alphabet[k << 4];
     
128.             encodedData[encodedIndex++] = PAD;
     
129.             encodedData[encodedIndex++] = PAD;
     
130.         } else if (fewerThan24bits == SIXTEENBIT) {
     
131.             b1 = binaryData[dataIndex];
     
132.             b2 = binaryData[dataIndex + 1];
     
133.             l = (byte) (b2 & 0x0f);
     
134.             k = (byte) (b1 & 0x03);
     
135. 
     
136.             byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
     
137.             byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);
     
138. 
     
139.             encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
     
140.             encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];
     
141.             encodedData[encodedIndex++] = lookUpBase64Alphabet[l << 2];
     
142.             encodedData[encodedIndex++] = PAD;
     
143.         }
     
144. 
     
145.         return new String(encodedData);
     
146.     }
     
147. 
     
148.     public static byte[] decode(String encoded) {
     
149. 
     
150.         if (encoded == null) {
     
151.             return null;
     
152.         }
     
153. 
     
154.         char[] base64Data = encoded.toCharArray();
     
155.         // remove white spaces
     
156.         int len = removeWhiteSpace(base64Data);
     
157. 
     
158.         if (len % FOURBYTE != 0) {
     
159.             return null;//should be divisible by four
     
160.         }
     
161. 
     
162.         int numberQuadruple = (len / FOURBYTE);
     
163. 
     
164.         if (numberQuadruple == 0) {
     
165.             return new byte[0];
     
166.         }
     
167. 
     
168.         byte decodedData[] = null;
     
169.         byte b1 = 0, b2 = 0, b3 = 0, b4 = 0;
     
170.         char d1 = 0, d2 = 0, d3 = 0, d4 = 0;
     
171. 
     
172.         int i = 0;
     
173.         int encodedIndex = 0;
     
174.         int dataIndex = 0;
     
175.         decodedData = new byte[(numberQuadruple) * 3];
     
176. 
     
177.         for (; i < numberQuadruple - 1; i++) {
     
178. 
     
179.             if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))
     
180.                     || !isData((d3 = base64Data[dataIndex++]))
     
181.                     || !isData((d4 = base64Data[dataIndex++]))) {
     
182.                 return null;
     
183.             }//if found "no data" just return null
     
184. 
     
185.             b1 = base64Alphabet[d1];
     
186.             b2 = base64Alphabet[d2];
     
187.             b3 = base64Alphabet[d3];
     
188.             b4 = base64Alphabet[d4];
     
189. 
     
190.             decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
     
191.             decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
     
192.             decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);
     
193.         }
     
194. 
     
195.         if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))) {
     
196.             return null;//if found "no data" just return null
     
197.         }
     
198. 
     
199.         b1 = base64Alphabet[d1];
     
200.         b2 = base64Alphabet[d2];
     
201. 
     
202.         d3 = base64Data[dataIndex++];
     
203.         d4 = base64Data[dataIndex++];
     
204.         if (!isData((d3)) || !isData((d4))) {//Check if they are PAD characters
     
205.             if (isPad(d3) && isPad(d4)) {
     
206.                 if ((b2 & 0xf) != 0)//last 4 bits should be zero
     
207.                 {
     
208.                     return null;
     
209.                 }
     
210.                 byte[] tmp = new byte[i * 3 + 1];
     
211.                 System.arraycopy(decodedData, 0, tmp, 0, i * 3);
     
212.                 tmp[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
     
213.                 return tmp;
     
214.             } else if (!isPad(d3) && isPad(d4)) {
     
215.                 b3 = base64Alphabet[d3];
     
216.                 if ((b3 & 0x3) != 0)//last 2 bits should be zero
     
217.                 {
     
218.                     return null;
     
219.                 }
     
220.                 byte[] tmp = new byte[i * 3 + 2];
     
221.                 System.arraycopy(decodedData, 0, tmp, 0, i * 3);
     
222.                 tmp[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
     
223.                 tmp[encodedIndex] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
     
224.                 return tmp;
     
225.             } else {
     
226.                 return null;
     
227.             }
     
228.         } else { //No PAD e.g 3cQl
     
229.             b3 = base64Alphabet[d3];
     
230.             b4 = base64Alphabet[d4];
     
231.             decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
     
232.             decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
     
233.             decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);
     
234. 
     
235.         }
     
236. 
     
237.         return decodedData;
     
238.     }
     
239. 
     
240.     private static int removeWhiteSpace(char[] data) {
     
241.         if (data == null) {
     
242.             return 0;
     
243.         }
     
244. 
     
245.         // count characters that's not whitespace
     
246.         int newSize = 0;
     
247.         int len = data.length;
     
248.         for (int i = 0; i < len; i++) {
     
249.             if (!isWhiteSpace(data[i])) {
     
250.                 data[newSize++] = data[i];
     
251.             }
     
252.         }
     
253.         return newSize;
     
254.     }
     
255. }

复制代码

徐柳婧

主测试

1. maintest.java
   
2. package com.ihep;
   
3. 
   
4. public class MainTest {
   
5. 
   
6. public static void main（String[] args） throw exception {
   
7. String filepath = “E：/tmp/”;
   
8. 
   
9. // 生成公钥和私钥文件
   
10. RSAEncrypt.genKeyPair（filepath）;
    
11. 
    
12. System.out.println（“--------------公钥加密私钥解密过程-------------------”）;
    
13. String plainText = “徐柳婧”;
    
14. // 公钥加密过程，得到加密后的数据
    
15. byte[] cipherData = RSAEncrypt.encrypt（RSAEncrypt.loadPublicKeyByStr（RSAEncrypt.loadPublicKeyByFile（filepath））， plainText.getBytes（））;
    
16. // 对加密数据进行编码处理，得到加密后的字符串
    
17. String cipher = Base64.encode（cipherData）;
    
18. // 私钥解密过程
    
19. byte[] res = RSAEncrypt.decrypt（RSAEncrypt.loadPrivateKeyByStr（RSAEncrypt.loadPrivateKeyByFile（filepath））， Base64.decode（cipher））;
    
20. String restr = new String（res）;
    
21. System.out.println（“原文：” + plainText）;
    
22. System.out.println（“加密：” + cipher）;
    
23. System.out.println（“解密：” + restr）;
    
24. System.out.println（）;
    
25. 
    
26. System.out.println（“--------------私钥加密公钥解密过程-------------------”）;
    
27. plainText = “徐柳婧”;
    
28. //私钥加密过程
    
29. cipherData = RSAEncrypt.encrypt（RSAEncrypt.loadPrivateKeyByStr（RSAEncrypt.loadPrivateKeyByFile（filepath））， plainText.getBytes（））;
    
30. cipher = Base64.encode（cipherData）;
    
31. //公钥解密过程
    
32. res = RSAEncrypt.decrypt（RSAEncrypt.loadPublicKeyByStr（RSAEncrypt.loadPublicKeyByFile（filepath））， Base64.decode（cipher））;
    
33. restr = new String（res）;
    
34. System.out.println（“原文：” + plainText）;
    
35. System.out.println（“加密：” + cipher）;
    
36. System.out.println（“解密：” + restr）;
    
37. System.out.println（）;
    
38. 
    
39. System.out.println（“---------------私钥签名过程------------------”）;
    
40. String content = “徐柳婧想喝奶茶”;
    
41. String signstr = RSASignature.sign（content， RSAEncrypt.loadPrivateKeyByFile（filepath））;
    
42. System.out.println（“签名原串：” + content）;
    
43. System.out.println（“签名串：” + signstr）;
    
44. System.out.println（）;
    
45. 
    
46. System.out.println（“---------------公钥校验签名------------------”）;
    
47. System.out.println（“签名原串：” + content）;
    
48. System.out.println（“签名串：” + signstr）;
    
49. 
    
50. System.out.println（“验签结果：” + RSASignature.doCheck（content， signstr， RSAEncrypt.loadPublicKeyByFile（filepath）））;
    
51. System.out.println（）;
    
52. 
    
53.     }
    
54. }

复制代码

徐柳婧

徐柳婧 发表于 2022-6-2 20:53

RSAEncrypt.java

1. package com.ihep;
   
2. 
   
3. import javax.crypto.BadPaddingException;
   
4. import javax.crypto.Cipher;
   
5. import javax.crypto.IllegalBlockSizeException;
   
6. import javax.crypto.NoSuchPaddingException;
   
7. import java.io.*;
   
8. import java.security.*;
   
9. import java.security.interfaces.RSAPrivateKey;
   
10. import java.security.interfaces.RSAPublicKey;
    
11. import java.security.spec.InvalidKeySpecException;
    
12. import java.security.spec.PKCS8EncodedKeySpec;
    
13. import java.security.spec.X509EncodedKeySpec;
    
14. private static final char[] HEX_CHAR = {'0', '1', '2', '3', '4', '5', '6',
    
15. '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
    
16. public static void genKeyPair(String filePath) {
    
17. // 密钥对生成器
    
18. KeyPairGenerator keyPairGen = null;
    
19. try {
    
20. // KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象
    
21. keyPairGen = KeyPairGenerator.getInstance("RSA");
    
22. } catch (NoSuchAlgorithmException e) {
    
23. // TODO Auto-generated catch block
    
24. e.printStackTrace();
    
25. }
    
26. // 初始化密钥对生成器，密钥大小为96-1024位
    
27. keyPairGen.initialize(1024, new SecureRandom());
    
28. // 生成一个密钥对，保存在keyPair中
    
29. KeyPair keyPair = keyPairGen.generateKeyPair();
    
30. // 得到私钥
    
31. RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
    
32. // 得到公钥
    
33. RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
    
34. try {
    
35. // 得到公钥字符串
    
36. String publicKeyString = Base64.encode(publicKey.getEncoded());
    
37. // 得到私钥字符串
    
38. String privateKeyString = Base64.encode(privateKey.getEncoded());
    
39. // 将密钥对写入到文件
    
40. FileWriter pubfw = new FileWriter(filePath + "/publicKey.keystore");
    
41. FileWriter prifw = new FileWriter(filePath + "/privateKey.keystore");
    
42. BufferedWriter pubbw = new BufferedWriter(pubfw);
    
43. BufferedWriter pribw = new BufferedWriter(prifw);
    
44. pubbw.write(publicKeyString);
    
45. pribw.write(privateKeyString);
    
46. pubbw.flush();
    
47. pubbw.close();
    
48. pubfw.close();
    
49. pribw.flush();
    
50. pribw.close();
    
51. prifw.close();
    
52. } catch (Exception e) {
    
53. e.printStackTrace();
    
54. }
    
55. }
    
56. public static String loadPublicKeyByFile(String path) throws Exception {
    
57. try {
    
58. BufferedReader br = new BufferedReader(new FileReader(path
    
59. + "/publicKey.keystore"));
    
60. String readLine = null;
    
61. StringBuilder sb = new StringBuilder();
    
62. while ((readLine = br.readLine()) != null) {
    
63. sb.append(readLine);
    
64. }
    
65. br.close();
    
66. return sb.toString();
    
67. } catch (IOException e) {
    
68. throw new Exception("公钥数据流读取错误");
    
69. } catch (NullPointerException e) {
    
70. throw new Exception("公钥输入流为空");
    
71. }
    
72. }
    
73. public static RSAPublicKey loadPublicKeyByStr(String publicKeyStr)
    
74. throws Exception {
    
75. try {
    
76. byte[] buffer = Base64.decode(publicKeyStr);
    
77. KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    
78. X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
    
79. return (RSAPublicKey) keyFactory.generatePublic(keySpec);
    
80. } catch (NoSuchAlgorithmException e) {
    
81. throw new Exception("无此算法");
    
82. } catch (InvalidKeySpecException e) {
    
83. throw new Exception("公钥非法");
    
84. } catch (NullPointerException e) {
    
85. throw new Exception("公钥数据为空");
    
86. }
    
87. }
    
88. public static String loadPrivateKeyByFile(String path) throws Exception {
    
89. try {
    
90. BufferedReader br = new BufferedReader(new FileReader(path
    
91. + "/privateKey.keystore"));
    
92. String readLine = null;
    
93. StringBuilder sb = new StringBuilder();
    
94. while ((readLine = br.readLine()) != null) {
    
95. sb.append(readLine);
    
96. }
    
97. br.close();
    
98. /** 该字符串从私钥文件中获取，称之为私钥字符串
    
99. * MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBALaIDyyav7J8oD/8sONfP772aa1foDlHmoXRArqe+2po14c1q7nGR8DLk
    
100. * 55J0sgxt/EOvtvxtwo4cPFtoLSBzdKVn/ZmR7uyHQXsMzqcmz7n7DGAzNNqxlu0SLHVjZ4HscWxnC+dGa037Ec9m5DKRT6aMckNmxZp3G
     
101. * xic9wzId6zAgMBAAECgYEAhpOUFH/XvEH0aJjm1gzA1AubaI8rc2/edrDeQTe8B/1agr7IaMTO3E97++VT+fPmOV10zHbPTELGysnYBZ3
     
102. * 6X/wLaKs+GMO/uewNAsyu46u3izwNVCygBiM62mlmhk3Y9J8ZcmoQHzXGV0p0TuGJsIlAofCAN1ielWLPcEVUPckCQQDoQm4GKe2C26oU
     
103. * aXRwLy2WLczfmqLTlJ8QyJs8ruL78JikhDgLWaLPBJ+lHmTxahC4HjJ9LhNxNVcpbyMiHhM1AkEAyTBjkOGwBJTlYMmS1hn6BoqA5xCRF
     
104. * Iv8gZZMxj+xcvSSEfZU9ObVArOBQRUoIO3GdsyaVfG/DNwuP7zGI16/RwJBAMfyIEu4HpsvxeyKmE3Xn5QQ27WHpzMkWAeX22RTXl7r0k
     
105. * yW8rR6txkm7tS0JMxbtgb7IBX564zjEaU+4u0FHR0CQG+v+zYM9Ag3GHd4r5lH5nMHJLQhkEjVxaGy7IAKD9p/Ry/NjjA+jPXo7NJSimp
     
106. * tVYXR48PeZm8fNFWR2HT+PjUCQFu3yN71iiXA0EW35Y1HHIE814gUV/O5T4gpUNzK9NLvHLFQNbzgoZER5yIGgBWDju1keBkojm8P69A7
     
107. * qdtXILU=
     
108. */
     
109. return sb.toString();
     
110. } catch (IOException e) {
     
111. throw new Exception("私钥数据读取错误");
     
112. } catch (NullPointerException e) {
     
113. throw new Exception("私钥输入流为空");
     
114. }
     
115. }
     
116. public static RSAPrivateKey loadPrivateKeyByStr(String privateKeyStr)
     
117. throws Exception {
     
118. try {
     
119. byte[] buffer = Base64.decode(privateKeyStr);
     
120. PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
     
121. KeyFactory keyFactory = KeyFactory.getInstance("RSA");
     
122. return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
     
123. } catch (NoSuchAlgorithmException e) {
     
124. throw new Exception("无此算法");
     
125. } catch (InvalidKeySpecException e) {
     
126. throw new Exception("私钥非法");
     
127. } catch (NullPointerException e) {
     
128. throw new Exception("私钥数据为空");
     
129. }
     
130. }
     
131. public static byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData)
     
132. throws Exception {
     
133. if (publicKey == null) {
     
134. throw new Exception("加密公钥为空, 请设置");
     
135. }
     
136. Cipher cipher = null;
     
137. try {
     
138. // 使用默认RSA
     
139. cipher = Cipher.getInstance("RSA");
     
140. // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
     
141. // 初始化算法:公钥加密
     
142. cipher.init(Cipher.ENCRYPT_MODE, publicKey);
     
143. // 公钥加密后的字节数组
     
144. byte[] output = cipher.doFinal(plainTextData);
     
145. return output;
     
146. } catch (NoSuchAlgorithmException e) {
     
147. throw new Exception("无此加密算法");
     
148. } catch (NoSuchPaddingException e) {
     
149. e.printStackTrace();
     
150. return null;
     
151. } catch (InvalidKeyException e) {
     
152. throw new Exception("加密公钥非法,请检查");
     
153. } catch (IllegalBlockSizeException e) {
     
154. throw new Exception("明文长度非法");
     
155. } catch (BadPaddingException e) {
     
156. throw new Exception("明文数据已损坏");
     
157. }
     
158. }
     
159. 
     
160. public static byte[] encrypt(RSAPrivateKey privateKey, byte[] plainTextData)
     
161. throws Exception {
     
162. if (privateKey == null) {
     
163. throw new Exception("加密私钥为空, 请设置");
     
164. }
     
165. Cipher cipher = null;
     
166. try {
     
167. // 使用默认RSA
     
168. cipher = Cipher.getInstance("RSA");
     
169. // 初始化算法：私钥加密
     
170. cipher.init(Cipher.ENCRYPT_MODE, privateKey);
     
171. // 加密后的密文数据，以字符数组的形式存在
     
172. byte[] output = cipher.doFinal(plainTextData);
     
173. return output;
     
174. } catch (NoSuchAlgorithmException e) {
     
175. throw new Exception("无此加密算法");
     
176. } catch (NoSuchPaddingException e) {
     
177. e.printStackTrace();
     
178. return null;
     
179. } catch (InvalidKeyException e) {
     
180. throw new Exception("加密私钥非法,请检查");
     
181. } catch (IllegalBlockSizeException e) {
     
182. throw new Exception("明文长度非法");
     
183. } catch (BadPaddingException e) {
     
184. throw new Exception("明文数据已损坏");
     
185. }
     
186. }
     
187. 
     
188. public static byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData)
     
189. throws Exception {
     
190. if (privateKey == null) {
     
191. throw new Exception("解密私钥为空, 请设置");
     
192. }
     
193. Cipher cipher = null;
     
194. try {
     
195. // 使用默认RSA
     
196. cipher = Cipher.getInstance("RSA");
     
197. // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
     
198. // 初始化解密算法：私钥解密
     
199. cipher.init(Cipher.DECRYPT_MODE, privateKey);
     
200. // 解密，生成以字符数组形式存在的明文数据
     
201. byte[] output = cipher.doFinal(cipherData);
     
202. return output;
     
203. } catch (NoSuchAlgorithmException e) {
     
204. throw new Exception("无此解密算法");
     
205. } catch (NoSuchPaddingException e) {
     
206. e.printStackTrace();
     
207. return null;
     
208. } catch (InvalidKeyException e) {
     
209. throw new Exception("解密私钥非法,请检查");
     
210. } catch (IllegalBlockSizeException e) {
     
211. throw new Exception("密文长度非法");
     
212. } catch (BadPaddingException e) {
     
213. throw new Exception("密文数据已损坏");
     
214. }
     
215. }
     
216. public static byte[] decrypt(RSAPublicKey publicKey, byte[] cipherData)
     
217. throws Exception {
     
218. if (publicKey == null) {
     
219. throw new Exception("解密公钥为空, 请设置");
     
220. }
     
221. Cipher cipher = null;
     
222. try {
     
223. // 使用默认RSA
     
224. cipher = Cipher.getInstance("RSA");
     
225. // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
     
226. // 初始化加密算法：公钥解密
     
227. cipher.init(Cipher.DECRYPT_MODE, publicKey);
     
228. byte[] output = cipher.doFinal(cipherData);
     
229. // 以字符数组形式存在的明文数据
     
230. return output;
     
231. } catch (NoSuchAlgorithmException e) {
     
232. throw new Exception("无此解密算法");
     
233. } catch (NoSuchPaddingException e) {
     
234. e.printStackTrace();
     
235. return null;
     
236. } catch (InvalidKeyException e) {
     
237. throw new Exception("解密公钥非法,请检查");
     
238. } catch (IllegalBlockSizeException e) {
     
239. throw new Exception("密文长度非法");
     
240. } catch (BadPaddingException e) {
     
241. throw new Exception("密文数据已损坏");
     
242. }
     
243. }
     
244. public static String byteArrayToString(byte[] data) {
     
245. StringBuilder stringBuilder = new StringBuilder();
     
246. for (int i = 0; i < data.length; i++) {
     
247. // 取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移
     
248. stringBuilder.append(HEX_CHAR[(data[i] & 0xf0) >>> 4]);
     
249. // 取出字节的低四位 作为索引得到相应的十六进制标识符
     
250. stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);
     
251. if (i < data.length - 1) {
     
252. stringBuilder.append(' ');
     
253. }
     
254. }
     
255. return stringBuilder.toString();
     
256. }
     
257. }

复制代码

徐柳婧

徐柳婧 发表于 2022-6-2 20:54
RSAEncrypt.java

RSASignature.java

1. package com.ihep;
   
2. 
   
3. import java.security.KeyFactory;
   
4. import java.security.PrivateKey;
   
5. import java.security.PublicKey;
   
6. import java.security.spec.PKCS8EncodedKeySpec;
   
7. import java.security.spec.X509EncodedKeySpec;
   
8. 
   
9. /**
   
10. * RSA签名验签类
    
11. */
    
12. public class RSASignature {
    
13. 
    
14.     /**
    
15.      * 签名算法
    
16.      */
    
17.     public static final String SIGN_ALGORITHMS = "SHA1WithRSA";
    
18. 
    
19.     public static String sign(String content, String privateKey, String encode) {
    
20.         try {
    
21.             PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(Base64.decode(privateKey));
    
22. 
    
23.             KeyFactory keyf = KeyFactory.getInstance("RSA");
    
24.             PrivateKey priKey = keyf.generatePrivate(priPKCS8);
    
25. 
    
26.             java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);
    
27. 
    
28.             signature.initSign(priKey);
    
29.             signature.update(content.getBytes(encode));
    
30. 
    
31.             byte[] signed = signature.sign();
    
32. 
    
33.             return Base64.encode(signed);
    
34.         } catch (Exception e) {
    
35.             e.printStackTrace();
    
36.         }
    
37. 
    
38.         return null;
    
39.     }
    
40. 
    
41.     public static String sign(String content, String privateKey) {
    
42.         try {
    
43.             PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(Base64.decode(privateKey));
    
44.             KeyFactory keyf = KeyFactory.getInstance("RSA");
    
45.             PrivateKey priKey = keyf.generatePrivate(priPKCS8);
    
46.             // 这里签名使用的是 SHA1WithRSA
    
47.             java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);
    
48.             // 以私钥字符串初始化签名
    
49.             signature.initSign(priKey);
    
50.             // 将原始串注入签名中
    
51.             signature.update(content.getBytes());
    
52.             // 签名后的结果，以字符数组形式存在
    
53.             byte[] signed = signature.sign();
    
54.             // 签名后的结果,以base64编码形式存在
    
55.             return Base64.encode(signed);
    
56.         } catch (Exception e) {
    
57.             e.printStackTrace();
    
58.         }
    
59.         return null;
    
60.     }
    
61. 
    
62.     public static boolean doCheck(String content, String sign, String publicKey, String encode) {
    
63.         try {
    
64.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    
65.             byte[] encodedKey = Base64.decode(publicKey);
    
66.             PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));
    
67. 
    
68. 
    
69.             java.security.Signature signature = java.security.Signature
    
70.                     .getInstance(SIGN_ALGORITHMS);
    
71. 
    
72.             signature.initVerify(pubKey);
    
73.             signature.update(content.getBytes(encode));
    
74. 
    
75.             boolean bverify = signature.verify(Base64.decode(sign));
    
76.             return bverify;
    
77. 
    
78.         } catch (Exception e) {
    
79.             e.printStackTrace();
    
80.         }
    
81. 
    
82.         return false;
    
83.     }
    
84. 
    
85.     public static boolean doCheck(String content, String sign, String publicKey) {
    
86.         try {
    
87.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    
88.             byte[] encodedKey = Base64.decode(publicKey);
    
89.             PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));
    
90.             // 使用 SHA1WithRSA 签名算法
    
91.             java.security.Signature signature = java.security.Signature
    
92.                     .getInstance(SIGN_ALGORITHMS);
    
93.             // 用公钥初始化签名校验
    
94.             signature.initVerify(pubKey);
    
95.             // 原始串注入签名校验中
    
96.             signature.update(content.getBytes());
    
97.             // 验证签名结果
    
98.             boolean bverify = signature.verify(Base64.decode(sign));
    
99.             // 返回签名是否成功
    
100.             return bverify;
     
101.         } catch (Exception e) {
     
102.             e.printStackTrace();
     
103.         }
     
104.         return false;
     
105.     }
     
106. }
     

复制代码

徐柳婧

徐柳婧 发表于 2022-6-2 20:54
RSASignature.java

ECC-椭圆曲线加密算法

一、算法简介
椭圆加密算法（ECC）是一种公钥加密体制，最初由Koblitz和Miller两人于1985年提出，其数学基础是利用椭圆曲线上的有理点构成Abel加法群上椭圆离散对数的计算困难性。公钥密码体制根据其所依据的难题一般分为三类：大素数分解问题类、离散对数问题类、椭圆曲线类。有时也把椭圆曲线类归为离散对数类。
ECC的主要优势是在某些情况下它比其他的方法使用更小的密钥——比如RSA加密算法——提供相当的或更高等级的安全。ECC的另一个优势是可以定义群之间的双线性映射，基于Weil对或是Tate对；双线性映射已经在密码学中发现了大量的应用，例如基于身份的加密。不过一个缺点是加密和解密操作的实现比其他机制花费的时间长。ECC是基于椭圆曲线数学理论实现的一种非对称加密算法。 相比RSA，ECC优势是可以使用更短的密钥，来实现与RSA相当或更高的安全，RSA加密算法也是一种非对称加密算法，在公开密钥加密和电子商业中RSA被广泛使用。 据研究，160位ECC加密安全性相当于1024位RSA加密，210位ECC加密安全性相当于2048位RSA加密。
二、基本原理
设私钥、公钥分别为d、Q，即Q = dG，其中G为基点，椭圆曲线上的已知G和dG，求d是非常困难的，也就是说已知公钥和基点，想要算出私钥是非常困难的。
公钥加密：选择随机数r，将消息M生成密文C，该密文是一个点对，C = {rG, M+rQ}，其中Q为公钥。
私钥解密：M + rQ - d(rG) = M + r(dG) - d(rG) = M，其中d、Q分别为私钥、公钥。

徐柳婧

徐柳婧 发表于 2022-6-2 21：06

1. #include “stdafx.h”
   
2. #include <弦>
   
3. #include <iostream>
   
4. 使用命名空间标准;
   
5. const int k = 9;
   
6. const int a = 5;
   
7. const int b = 37;
   
8. const int p = 127;
   
9. const int r =7;
   
10. 
    
11. int getX_1（int x，int mod）{
    
12. 国际 Q，X1，X2，X3，Y1，Y2，Y3，T1，T2，T3;
    
13. X1 = 1;
    
14. X2 = 0;
    
15. X3 = mod;
    
16. Y1 = 0;
    
17. Y2 = 1;
    
18. Y3 = （x%mod + mod） %mod;//获得正整数
    
19. 而（Y3 ！= 1）{
    
20. Q = X3 / Y3;
    
21. T1 = X1 - Q * Y1;
    
22. T2 = X2 - Q * Y2;
    
23. T3 = X3 - Q * Y3;
    
24. X1 = Y1;
    
25. X2 = Y2;
    
26. X3 = Y3;
    
27. Y1 = T1;
    
28. Y2 = T2;
    
29. Y3 = T3;
    
30.         }
    
31. 返回 Y2;
    
32. }//获得其乘法逆元
    
33. 
    
34. 结构点{
    
35. 整型 x;
    
36. int y;
    
37. };
    
38. A点，B点;//公钥
    
39. 类型定义对<点，点>两点;
    
40. bool operator == （point pa，point pb）{
    
41. return pa.x == pb.x && pa.y == pb.y;
    
42. }
    
43. 点运算符 + （点 pa ， 点 pb）{
    
44. 整型 k;
    
45.         
    
46. if（pa == pb）
    
47. k = （（3 * pa.x * pa.x + a） * getX_1（2* pa.y ，p）） % p ;
    
48. 还
    
49. k = （pb.y - pa.y） * getX_1（pb.x - pa.x ， p） %p;
    
50. c点;
    
51. c.x = （k*k - pa.x -pb.x） %p;
    
52. c.y = （k * （pa.x - c.x） - pa.y）%p ;
    
53. c.x = （c.x + p） %p;
    
54. c.y = （c.y + p） %p;
    
55.                
    
56. 返回 c;
    
57. }
    
58. 点运算符 * （点 &b，int n）{
    
59. 点 q = b;
    
60. n = n -1;
    
61. for（int i = 1 ; i < n;i++）{
    
62. q = q + b ;
    
63.                 }
    
64. 返回 q;
    
65. }
    
66. 两点 ECodePoint（point m）{
    
67. 点 c1，c2;
    
68. c1 = A * r ;
    
69. 点 Y = B * r ;
    
70. c2.x = Y.x * m.x % p ;
    
71. c2.y = Y.y * m.y % p ;
    
72. 返回两点（c1，c2）;
    
73. }
    
74. 点 DCodePoint（两点 t）{
    
75. 点 Z = t.first * k;
    
76. 点 m;
    
77. m.x = t.second.x * getX_1（Z.x，p） % p ;
    
78. m.y = t.second.y * getX_1（Z.y，p） % p ;
    
79. 返回 m;
    
80. }
    
81. 字符串代码（字符串输入）{
    
82. 字符串输出 = “”;
    
83. M点;
    
84. 两点 C;
    
85. for（int i =0; i < input.length（）;i++）{
    
86. M.x = i;
    
87. M.y = 输入[i];
    
88. C = ECodePoint（M）;
    
89. 输出 += （字符）C.first.x ;
    
90. 输出 += （字符）C.first.y ;
    
91. 输出 += （字符）C.second.x ;
    
92. 输出 += （字符）C.second.y ;
    
93.         }
    
94. 返回输出;
    
95. }
    
96. 字符串 DCode（字符串输入）{
    
97. 字符串输出 = “”;
    
98. M点;
    
99. 两点 C;
    
100. if（input.length（）%4 ！= 0）
     
101. 返回 “错误输入”;
     
102. for（int i = 0;i < input.length（）;){
     
103. C.first.x = input[i++];
     
104. C.first.y = input[i++];
     
105. C.second.x = input[i++];
     
106. C.second.y = input[i++];
     
107. M = DCodePoint（C）;
     
108. 输出 += （字符）M.y;
     
109.         }
     
110. 返回输出;
     
111. }
     
112. int main（）
     
113. {
     
114. A.x = 11;
     
115. A.y = 4;
     
116. B = A*k;
     
117. 字符串 s = “”;
     
118. cout<<“使用在素域上的曲线 y^2 = x^3 + 5*x +37 ，使用Menezes-Vanstone的算法：”<<endl;
     
119. cout<<“在素域p=127上，私钥为k=9，公钥A（11，4），B（120，41），对明文字符串直接转换为int进行加密”<<endl;
     
120. cout<<“请输入要加密的内容：”<<endl;
     
121. 辛>>斯;
     
122. cout<<“密文如下：”<<“\r\n”;
     
123. s = ECode（s）;
     
124. cout<<s<<endl;
     
125. cout<<“对之前密文解密，得到明文如下（由于输入密文不正确绝对会使这个程序出错，所以只能解密绝对安全的密文）：”<<“\r\n”;
     
126. s = DCode（s）;
     
127. cout<<s<<“\r\n”<<“完成”<<endl;
     
128. 辛>>斯;
     
129. 返回 0;
     
130. }

复制代码