信息计算2019级1班12号雷楚涵

19信计1班雷楚涵

RSA签名和加密

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

19信计1班雷楚涵

程序代码：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. }

复制代码

19信计1班雷楚涵

19信计1班雷楚涵 发表于 2022-6-2 14:28
程序代码：Base64.java

maintest.java

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

复制代码

19信计1班雷楚涵

19信计1班雷楚涵 发表于 2022-6-2 14:35
maintest.java

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. }

复制代码

19信计1班雷楚涵

19信计1班雷楚涵 发表于 2022-6-2 14:36
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. }
     

复制代码

19信计1班雷楚涵

19信计1班雷楚涵 发表于 2022-6-2 14:37
RSASignature.java

                                                            ECC-椭圆曲线加密算法
一、算法简介
椭圆加密算法（ECC）是一种公钥加密体制，最初由Koblitz和Miller两人于1985年提出，其数学基础是利用椭圆曲线上的有理点构成Abel加法群上椭圆离散对数的计算困难性。公钥密码体制根据其所依据的难题一般分为三类：大素数分解问题类、离散对数问题类、椭圆曲线类。有时也把椭圆曲线类归为离散对数类。
ECC的主要优势是在某些情况下它比其他的方法使用更小的密钥——比如RSA加密算法——提供相当的或更高等级的安全。ECC的另一个优势是可以定义群之间的双线性映射，基于Weil对或是Tate对；双线性映射已经在密码学中发现了大量的应用，例如基于身份的加密。不过一个缺点是加密和解密操作的实现比其他机制花费的时间长。
二、基本原理
设私钥、公钥分别为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分别为私钥、公钥。

椭圆曲线签名算法(ECDSA)
设私钥、公钥分别为d、Q，即Q = dG，其中G为基点。
私钥签名
选择随机数r，计算点rG(x, y)。
根据随机数r、消息M的哈希h、私钥d，计算s = (h + dx)/r。　　
将消息M、和签名{rG, s}发给接收方。

公钥验证签名：
接收方收到消息M、以及签名{rG=(x,y), s}。　　
根据消息求哈希h。　　
使用发送方公钥Q计算：hG/s + xQ/s，并与rG比较，如相等即验签成功。
原理：hG/s + xQ/s = hG/s + xG)/s = (h+xd)G/s = r(h+xd)G / (h+dx) = rG

19信计1班雷楚涵

19信计1班雷楚涵 发表于 2022-6-2 14:56
ECC-椭圆曲线加密算法
一、算法简介
椭圆 ...

三、代码

1. # include <stdio.h>
   
2. # include <math.h>
   
3. using System.Drawing;
   
4. 
   
5. int xy[22];
   
6. 
   
7. #define N 23
   
8. #define A 1
   
9. #define M 29
   
10. #define a1 1
    
11. #define b1 4
    
12. typedef struct point
    
13. {
    
14.         int x;
    
15.         int y;
    
16. }
    
17. Point;
    
18. typedef struct ecc
    
19. {
    
20.         struct point p[100];
    
21.         int len;
    
22. }
    
23. ECCPoint;
    
24. typedef struct generator
    
25. {
    
26.         Point p;
    
27.         int p_class;
    
28. }
    
29. GENE_SET;
    
30. ECCPoint eccPoint;
    
31. Point mul(Point p1, Point p2);
    
32. Point add_two_points(Point p1, Point p2);
    
33. GENE_SET geneSet[100];
    
34. int geneLen;
    
35. //判断平方根是否为整数
    
36. int int_sqrt(int s)
    
37. {
    
38.         int temp;
    
39.         temp = (int)sqrt(s);//转为整型
    
40.         if (temp * temp == s)
    
41.         {
    
42.                 return temp;
    
43.         }
    
44.         else
    
45.         {
    
46.                 return -1;
    
47.         }
    
48. }
    
49. //取模函数
    
50. int mod_p(int s)
    
51. {
    
52.         int i;  //保存s/p的倍数
    
53.         int result; //模运算的结果
    
54.         i = s / N;
    
55.         result = s - i * N;
    
56.         if (result >= 0)
    
57.         {
    
58.                 return result;
    
59.         }
    
60.         else
    
61.         {
    
62.                 return result + N;
    
63.         }
    
64. }
    
65. //打印点集
    
66. void print()
    
67. {
    
68.         int i;
    
69.         int len = eccPoint.len;
    
70.         printf("\n该椭圆曲线上共有%d个点(包含无穷远点)\n", len + 1);
    
71.         for (i = 0; i < len; i++)
    
72.         {
    
73.                 if (i % 8 == 0)
    
74.                 {
    
75.                         printf("\n");
    
76.                 }
    
77.                 printf("(%2d,%2d)\t", eccPoint.p[i].x, eccPoint.p[i].y);
    
78.         }
    
79.         printf("\n");
    
80. }
    
81. //task1:求出椭圆曲线上所有点
    
82. void get_all_points()
    
83. {
    
84.         int i = 0;
    
85.         int j = 0;
    
86.         int s, y = 0;
    
87.         int n = 0, q = 0;
    
88.         int modsqrt = 0;
    
89.         int flag = 0;
    
90.         if (a1 * a1 * a1 + b1 * b1 + 4 != 0)
    
91.         {
    
92.                 for (i = 0; i <= N - 1; i++)
    
93.                 {
    
94.                         flag = 0;
    
95.                         n = 1;
    
96.                         y = 0;
    
97.                         s = i * i * i + a1 * i + b1;
    
98.                         while (s < 0)
    
99.                         {
    
100.                                 s += N;
     
101.                         }
     
102.                         s = mod_p(s);
     
103.                         modsqrt = int_sqrt(s);
     
104.                         if (modsqrt != -1)
     
105.                         {
     
106.                                 flag = 1;
     
107.                                 y = modsqrt;
     
108.                         }
     
109.                         else
     
110.                         {
     
111.                                 while (n <= N - 1)
     
112.                                 {
     
113.                                         q = s + n * N;
     
114.                                         modsqrt = int_sqrt(q);
     
115.                                         if (modsqrt != -1)
     
116.                                         {
     
117.                                                 y = modsqrt;
     
118.                                                 flag = 1;
     
119.                                                 break;
     
120.                                         }
     
121.                                         flag = 0;
     
122.                                         n++;
     
123.                                 }
     
124.                         }
     
125.                         if (flag == 1)
     
126.                         {
     
127.                                 eccPoint.p[j].x = i;
     
128.                                 eccPoint.p[j].y = y;
     
129.                                 j++;
     
130.                                 if (y != 0)
     
131.                                 {
     
132.                                         eccPoint.p[j].x = i;
     
133.                                         eccPoint.p[j].y = (N - y) % N;
     
134.                                         j++;
     
135.                                 }
     
136.                         }
     
137.                 }
     
138.                 eccPoint.len = j;//点集个数
     
139.                 print(); //打印点集
     
140.         }
     
141. }
     
142. 
     
143. //task3:求生成元以及阶
     
144. void get_generetor_class()
     
145. {
     
146.         int i, j = 0;
     
147.         int count = 1;
     
148.         Point p1, p2;
     
149.         get_all_points();
     
150.         printf("\n**********************************输出生成元以及阶：*************************************\n");
     
151.         for (i = 0; i < eccPoint.len; i++)
     
152.         {
     
153.                 count = 1;
     
154.                 p1.x = p2.x = eccPoint.p[i].x;
     
155.                 p1.y = p2.y = eccPoint.p[i].y;
     
156.                 while (1)
     
157.                 {
     
158.                         p2 = add_two_points(p1, p2);
     
159.                         if (p2.x == -1 && p2.y == -1)
     
160.                         {
     
161.                                 break;
     
162.                         }
     
163.                         count++;
     
164.                         if (p2.x == p1.x)
     
165.                         {
     
166.                                 break;
     
167.                         }
     
168.                 }
     
169.                 count++;
     
170.                 if (count <= eccPoint.len + 1)
     
171.                 {
     
172.                         geneSet[j].p.x = p1.x;
     
173.                         geneSet[j].p.y = p1.y;
     
174.                         geneSet[j].p_class = count;
     
175.                         printf("(%d,%d)--->>%d\t", geneSet[j].p.x, geneSet[j].p.y, geneSet[j].p_class);
     
176.                         j++;
     
177.                         if (j % 6 == 0)
     
178.                         {
     
179.                                 printf("\n");
     
180.                         }
     
181.                 }
     
182.                 geneLen = j;
     
183.         }
     
184. }

复制代码

19信计1班雷楚涵

19信计1班雷楚涵 发表于 2022-6-2 15:03
三、代码

1. // 求 a mod b 的逆元
   
2. void exGcd(int a, int b)
   
3. {
   
4.         if (b == 0)
   
5.         {
   
6.                 xy[0] = 1;
   
7.                 xy[1] = 0;
   
8.         }
   
9.         else
   
10.         {
    
11.                 exGcd(b, a % b);
    
12.                 int x = xy[0];
    
13.                 xy[0] = xy[1];
    
14.                 xy[1] = x - (a / b) * xy[1];
    
15.         }
    
16. 
    
17. }
    
18. int calculate3(int y, int k, int p)
    
19. {
    
20. 
    
21.         int l = 1;
    
22.         for (int i = 0; i < k; i++)
    
23.         {
    
24.                 l = l * y;
    
25.                 l = l % p;
    
26.         }
    
27. 
    
28.         return l;
    
29. }
    
30. 
    
31. Point eccmutiply(int n, Point p)
    
32. {
    
33.         int a, b, l, k, m;
    
34.         a = p.x;
    
35.         b = p.y;
    
36.         for (int i = 0; i < n - 1; i++)
    
37.         {
    
38. 
    
39.                 if (a == p.x && b == p.y)
    
40.                 {
    
41.                         exGcd(2 * p.y, N);
    
42.                         k = xy[0];
    
43.                         if (k < 0) k = k + N;
    
44.                         printf("逆元=%d\n", k);
    
45.                         l = (3 * p.x * p.x + A) * k;
    
46.                         l = calculate3(l, 1, N);
    
47.                         if (l < 0)
    
48.                         {
    
49.                                 l = l + N;
    
50.                         }
    
51.                 }
    
52.                 else
    
53.                 {
    
54.                         exGcd(a - p.x + N, N);
    
55.                         k = xy[0];
    
56.                         if (k < 0) k = k + N;
    
57.                         printf("else逆元=%d\n", k);
    
58.                         l = (b - p.y) * k;
    
59.                         l = calculate3(l, 1, N);
    
60.                         if (l < 0)
    
61.                         {
    
62.                                 l = l + N;
    
63.                         }
    
64.                         printf("l=%d\n", l);
    
65.                 }
    
66.                 m = p.x;
    
67.                 a = l * l - a - p.x;
    
68.                 a = calculate3(a, 1, N);
    
69.                 if (a < 0)
    
70.                 {
    
71.                         a = a + N;
    
72.                 }
    
73.                 b = l * (m - a) - p.y;
    
74.                 b = calculate3(b, 1, N);
    
75. 
    
76.                 if (b < 0)
    
77.                 {
    
78.                         b = b + N;
    
79.                 }
    
80.                 printf("%d(a,b)=(%d,%d)\n", i + 2, a, b);
    
81.                 //if(a==4&&b==5)break;
    
82.         }
    
83.         Point p3;
    
84.         p3.x = a;
    
85.         p3.y = b;
    
86.         return p3;
    
87. }
    
88. Point mul(Point p1, Point p2)
    
89. {
    
90.         int k, l;
    
91.         exGcd(p2.x - p1.x + N, N);
    
92.         k = xy[0];
    
93.         if (k < 0) k = k + N;
    
94.         //printf("else逆元=%d\n",k);
    
95.         l = (p2.y - p1.y) * k;
    
96.         l = calculate3(l, 1, N);
    
97.         if (l < 0)
    
98.         {
    
99.                 l = l + N;
    
100.         }
     
101.         //printf("l=%d\n",l);      
     
102.         Point p3;
     
103.         p3.x = l * l - p1.x - p2.x;
     
104.         p3.x = calculate3(p3.x, 1, N);
     
105.         if (p3.x < 0) p3.x = p3.x + N;
     
106. 
     
107.         p3.y = l * (p1.x - p3.x) - p1.y;
     
108.         p3.y = calculate3(p3.y, 1, N);
     
109.         if (p3.y < 0) p3.y = p3.y + N;
     
110.         return p3;
     
111. }
     
112. 
     
113. //求b关于n的逆元
     
114. int inverse(int n, int b)
     
115. {
     
116.         int q, r, r1 = n, r2 = b, t, t1 = 0, t2 = 1, i = 1;
     
117.         while (r2 > 0)
     
118.         {
     
119.                 q = r1 / r2;
     
120.                 r = r1 % r2;
     
121.                 r1 = r2;
     
122.                 r2 = r;
     
123.                 t = t1 - q * t2;
     
124.                 t1 = t2;
     
125.                 t2 = t;
     
126.         }
     
127.         if (t1 >= 0)
     
128.                 return t1 % n;
     
129.         else
     
130.         {
     
131.                 while ((t1 + i * n) < 0)
     
132.                         i++;
     
133.                 return t1 + i * n;
     
134.         }
     
135. }
     
136. //两点的加法运算
     
137. Point add_two_points(Point p1, Point p2)
     
138. {
     
139.         long t;
     
140.         int x1 = p1.x;
     
141.         int y1 = p1.y;
     
142.         int x2 = p2.x;
     
143.         int y2 = p2.y;
     
144.         int tx, ty;
     
145.         int x3, y3;
     
146.         int flag = 0;
     
147.         //求
     
148.         if ((x2 == x1) && (y2 == y1))
     
149.         {
     
150.                 //相同点相加
     
151.                 if (y1 == 0)
     
152.                 {
     
153.                         flag = 1;
     
154.                 }
     
155.                 else
     
156.                 {
     
157.                         t = (3 * x1 * x1 + a1) * inverse(N, 2 * y1) % N;
     
158.                 }
     
159.                 //printf("inverse(p,2*y1)=%d\n",inverse(p,2*y1));
     
160.         }
     
161.         else
     
162.         {
     
163.                 //不同点相加
     
164.                 ty = y2 - y1;
     
165.                 tx = x2 - x1;
     
166.                 while (ty < 0)
     
167.                 {
     
168.                         ty += N;
     
169.                 }
     
170.                 while (tx < 0)
     
171.                 {
     
172.                         tx += N;
     
173.                 }
     
174.                 if (tx == 0 && ty != 0)
     
175.                 {
     
176.                         flag = 1;
     
177.                 }
     
178.                 else
     
179.                 {
     
180.                         t = ty * inverse(N, tx) % N;
     
181.                 }
     
182.         }
     
183.         if (flag == 1)
     
184.         {
     
185.                 p2.x = -1;
     
186.                 p2.y = -1;
     
187.         }
     
188.         else
     
189.         {
     
190.                 x3 = (t * t - x1 - x2) % N;
     
191.                 y3 = (t * (x1 - x3) - y1) % N;
     
192.                 //使结果在有限域GF(P)上
     
193.                 while (x3 < 0)
     
194.                 {
     
195.                         x3 += N;
     
196.                 }
     
197.                 while (y3 < 0)
     
198.                 {
     
199.                         y3 += N;
     
200.                 }
     
201.                 p2.x = x3;
     
202.                 p2.y = y3;
     
203.         }
     
204.         return p2;
     
205. }
     
206. //task2:倍点运算的递归算法
     
207. Point timesPiont(int k, Point p0)
     
208. {
     
209.         if (k == 1)
     
210.         {
     
211.                 return p0;
     
212.         }
     
213.         else if (k == 2)
     
214.         {
     
215.                 return add_two_points(p0, p0);
     
216.         }
     
217.         else
     
218.         {
     
219.                 return add_two_points(p0, timesPiont(k - 1, p0));
     
220.         }
     
221. }
     
222. main(){
     
223.         get_generetor_class();
     
224.         Point p1, p2, p, p4, p5, p6, p7, p8, p9, p10;
     
225.         int na, k, h, r, s, u1, u2;
     
226.         printf("选择生成元");
     
227.         scanf("%d%d", &p1.x, &p1.y);
     
228.         int j = 0;
     
229.         while (j < N)
     
230.         {
     
231. 
     
232.                 if (geneSet[j].p.x == p1.x && geneSet[j].p.y == p1.y)
     
233.                 {
     
234.                         break;
     
235.                 }
     
236.                 printf("j=%d\n", j);
     
237.                 ++j;
     
238.         }
     
239.         int M = geneSet[j].p_class;
     
240.         printf("M=%d", M);
     
241.         //        p1.x=0;
     
242.         //        p1.y=2;
     
243.         //p.x=20;
     
244.         //p.y=1;
     
245.         printf("请输入私钥");
     
246.         scanf("%d", &na);
     
247.         p2 = eccmutiply(na, p1);
     
248.         printf("公钥为（%d,%d)", p2.x, p2.y);
     
249.         //p2=mul(p,p1);
     
250. 
     
251.         //printf("(%d,%d)",p2.x,p2.y);
     
252. 
     
253.         //签名过程
     
254.         printf("输入随机数k\n");
     
255.         scanf("%d", &k);
     
256.         printf("输入hash\n");
     
257.         scanf("%d", &h);
     
258. 
     
259. 
     
260.         p4 = eccmutiply(k, p1);
     
261.         r = calculate3(p4.x, 1, N);
     
262.         if (r < 0) r = r + N;
     
263.         s = inverse(M, k) * (h + na * r) % M;
     
264.         if (s < 0) s = s + N;
     
265.         printf("签名为(%d,%d)\n", r, s);
     
266.         printf("========================");
     
267.         //验证过程
     
268.         u1 = h * inverse(M, s) % M;
     
269. 
     
270.         if (u1 < 0) u1 = u1 + M;
     
271.         u2 = r * inverse(M, s) % M;
     
272. 
     
273.         if (u2 < 0) u2 = u2 + M;
     
274. 
     
275.         printf("u1u2=%d,%d\n", u1, u2);
     
276. 
     
277.         p5 = eccmutiply(u1, p1);
     
278.         printf("sG=(%d,%d)\n", p5.x, p5.y);
     
279. 
     
280.         p6 = eccmutiply(u2, p2);
     
281.         printf("HP=(%d,%d)\n", p6.x, p6.y);
     
282. 
     
283.         p7 = add_two_points(p5, p6);
     
284.         printf("sG+HP=(%d,%d)\n", p7.x, p7.y);
     
285.         if (calculate3(p7.x, 1, N) == r)
     
286.         {
     
287.                 printf("通过");
     
288.         }
     
289.         else
     
290.         {
     
291.                 printf("失败");
     
292.         }
     
293. 
     
294. }

复制代码