信息计算2019级2班17号戴隆俊

戴隆俊

一、RSA加密

RSA加密是一种非对称加密。可以在不直接传递密钥的情况下，完成解密；是由一对密钥来进行加解密的过程，分别称为公钥和私钥。两者之间有数学相关，该加密算法的原理就是对一极大整数做因数分解的困难性来保证安全性。通常个人保存私钥，公钥是公开的（可能同时多人持有）。

二、对签名和验签过程详细解释:

签名过程:

• A计算消息m的消息摘要,记为 h(m)
• A使用私钥(n,d)对h(m)加密,生成签名s, s满足:s=(h(m))^d mod n;
  由于A是用自己的私钥对消息摘要加密,所以只用使用s的公钥才能解密该消息摘要,这样A就不可否认自己发送了该消息给B.
• A发送消息和签名(m,s)给B
  

验签过程:

• B计算消息m的消息摘要(计算方式和A相同),记为h(m)
• B使用A的公钥(n,e)解密s,得到 H(m), H(m) = s^e mod n
• B比较H(m)与h(m),相同才能证明验签成功
  

三、对加密/解密和签名/验签完整过程详细解释:
A->B:
1.A提取消息m的消息摘要h(m),并使用自己的私钥对摘要h(m)进行加密,生成签名s
2.A将签名s和消息m一起,使用B的公钥进行加密,生成密文c,发送给B

B:
1.B接收到密文c,使用自己的私钥解密c得到明文m和数字签名s
2.B使用A的公钥解密数字签名s解密得到H(m)
3.B使用相同的方法提取消息m的消息摘要h(m)
4.B比较两个消息摘要。相同则验证成功;不同则验证失败

1. import java.io.ByteArrayOutputStream;
   
2. import java.security.KeyFactory;
   
3. import java.security.KeyPair;
   
4. import java.security.KeyPairGenerator;
   
5. import java.security.PrivateKey;
   
6. import java.security.PublicKey;
   
7. import java.security.Signature;
   
8. import java.security.spec.PKCS8EncodedKeySpec;
   
9. import java.security.spec.X509EncodedKeySpec;
   
10. import javax.crypto.Cipher;
    
11. import org.apache.commons.codec.binary.Base64;
    
12. 
    
13. public class TestRSA {
    
14. 
    
15.     /**
    
16.      * RSA最大加密明文大小
    
17.      */
    
18.     private static final int MAX_ENCRYPT_BLOCK = 64;
    
19. 
    
20.     /**
    
21.      * RSA最大解密密文大小
    
22.      */
    
23.     private static final int MAX_DECRYPT_BLOCK = 75;
    
24. 
    
25.     /**
    
26.      * 获取密钥对
    
27.      *
    
28.      * @return 密钥对
    
29.      */
    
30.     public static KeyPair getKeyPair() throws Exception {
    
31.         KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
    
32.         generator.initialize(512);
    
33.         return generator.generateKeyPair();
    
34.     }
    
35. 
    
36.     /**
    
37.      * 获取私钥
    
38.      *
    
39.      * @param privateKey 私钥字符串
    
40.      * @return
    
41.      */
    
42.     public static PrivateKey getPrivateKey(String privateKey) throws Exception {
    
43.         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    
44.         byte[] decodedKey = Base64.decodeBase64(privateKey.getBytes());
    
45.         PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(decodedKey);
    
46.         return keyFactory.generatePrivate(keySpec);
    
47.     }
    
48. 
    
49.     /**
    
50.      * 获取公钥
    
51.      *
    
52.      * @param publicKey 公钥字符串
    
53.      * @return
    
54.      */
    
55.     public static PublicKey getPublicKey(String publicKey) throws Exception {
    
56.         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    
57.         byte[] decodedKey = Base64.decodeBase64(publicKey.getBytes());
    
58.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(decodedKey);
    
59.         return keyFactory.generatePublic(keySpec);
    
60.     }
    
61. 
    
62.     /**
    
63.      * RSA加密
    
64.      *
    
65.      * @param data 待加密数据
    
66.      * @param publicKey 公钥
    
67.      * @return
    
68.      */
    
69.     public static String encrypt(String data, PublicKey publicKey) throws Exception {
    
70.         Cipher cipher = Cipher.getInstance("RSA");
    
71.         cipher.init(Cipher.ENCRYPT_MODE, publicKey);
    
72.         int inputLen = data.getBytes().length;
    
73.         ByteArrayOutputStream out = new ByteArrayOutputStream();
    
74.         int offset = 0;
    
75.         byte[] cache;
    
76.         int i = 0;
    
77.         // 对数据分段加密
    
78.         while (inputLen - offset > 0) {
    
79.             if (inputLen - offset > MAX_ENCRYPT_BLOCK) {
    
80.                 cache = cipher.doFinal(data.getBytes(), offset, MAX_ENCRYPT_BLOCK);
    
81.             } else {
    
82.                 cache = cipher.doFinal(data.getBytes(), offset, inputLen - offset);
    
83.             }
    
84.             out.write(cache, 0, cache.length);
    
85.             i++;
    
86.             offset = i * MAX_ENCRYPT_BLOCK;
    
87.         }
    
88.         byte[] encryptedData = out.toByteArray();
    
89.         out.close();
    
90.         // 获取加密内容使用base64进行编码,并以UTF-8为标准转化成字符串
    
91.         // 加密后的字符串
    
92.         return new String(Base64.encodeBase64String(encryptedData));
    
93.     }
    
94. 
    
95.     /**
    
96.      * RSA解密
    
97.      *
    
98.      * @param data 待解密数据
    
99.      * @param privateKey 私钥
    
100.      * @return
     
101.      */
     
102.     public static String decrypt(String data, PrivateKey privateKey) throws Exception {
     
103.         Cipher cipher = Cipher.getInstance("RSA");
     
104.         cipher.init(Cipher.DECRYPT_MODE, privateKey);
     
105.         byte[] dataBytes = Base64.decodeBase64(data);
     
106.         int inputLen = dataBytes.length;
     
107.         ByteArrayOutputStream out = new ByteArrayOutputStream();
     
108.         int offset = 0;
     
109.         byte[] cache;
     
110.         int i = 0;
     
111.         // 对数据分段解密
     
112.         while (inputLen - offset > 0) {
     
113.             if (inputLen - offset > MAX_DECRYPT_BLOCK) {
     
114.                 cache = cipher.doFinal(dataBytes, offset, MAX_DECRYPT_BLOCK);
     
115.             } else {
     
116.                 cache = cipher.doFinal(dataBytes, offset, inputLen - offset);
     
117.             }
     
118.             out.write(cache, 0, cache.length);
     
119.             i++;
     
120.             offset = i * MAX_DECRYPT_BLOCK;
     
121.         }
     
122.         byte[] decryptedData = out.toByteArray();
     
123.         out.close();
     
124.         // 解密后的内容
     
125.         return new String(decryptedData, "UTF-8");
     
126.     }
     
127. 
     
128.     /**
     
129.      * 签名
     
130.      *
     
131.      * @param data 待签名数据
     
132.      * @param privateKey 私钥
     
133.      * @return 签名
     
134.      */
     
135.     public static String sign(String data, PrivateKey privateKey) throws Exception {
     
136.         byte[] keyBytes = privateKey.getEncoded();
     
137.         PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
     
138.         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
     
139.         PrivateKey key = keyFactory.generatePrivate(keySpec);
     
140.         Signature signature = Signature.getInstance("MD5withRSA");
     
141.         signature.initSign(key);
     
142.         signature.update(data.getBytes());
     
143.         return new String(Base64.encodeBase64(signature.sign()));
     
144.     }
     
145. 
     
146.     /**
     
147.      * 验签
     
148.      *
     
149.      * @param srcData 原始字符串
     
150.      * @param publicKey 公钥
     
151.      * @param sign 签名
     
152.      * @return 是否验签通过
     
153.      */
     
154.     public static boolean verify(String srcData, PublicKey publicKey, String sign) throws Exception {
     
155.         byte[] keyBytes = publicKey.getEncoded();
     
156.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
     
157.         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
     
158.         PublicKey key = keyFactory.generatePublic(keySpec);
     
159.         Signature signature = Signature.getInstance("MD5withRSA");
     
160.         signature.initVerify(key);
     
161.         signature.update(srcData.getBytes());
     
162.         return signature.verify(Base64.decodeBase64(sign.getBytes()));
     
163.     }
     
164. }
     
165. public static void main(String[] args) {
     
166.         try {
     
167.             // 生成密钥对
     
168.             KeyPair keyPair = getKeyPair();
     
169.             String privateKey = new String(Base64.encodeBase64(keyPair.getPrivate().getEncoded()));
     
170.             String publicKey = new String(Base64.encodeBase64(keyPair.getPublic().getEncoded()));
     
171.             System.out.println("私钥:" + privateKey);
     
172.             System.out.println("公钥:" + publicKey);
     
173.             // RSA加密 待加密的文字内容
     
174.             String data = "123456";
     
175.             String encryptData = encrypt(data, getPublicKey(publicKey));
     
176.             System.out.println("加密前内容:" + data);
     
177.             System.out.println("加密后内容:" + encryptData);
     
178.             // RSA解密
     
179.             String decryptData = decrypt(encryptData, getPrivateKey(privateKey));
     
180.             System.out.println("解密后内容:" + decryptData);
     
181. 
     
182.             // RSA签名
     
183.             String sign = sign(data, getPrivateKey(privateKey));
     
184.             // RSA验签
     
185.             boolean result = verify(data, getPublicKey(publicKey), sign);
     
186.             System.out.print("验签结果:" + result);
     
187.         } catch (Exception e) {
     
188.             e.printStackTrace();
     
189.             System.out.print("加解密异常");
     
190.         }
     
191. }
     
192. 
     
193. 
     

复制代码

戴隆俊

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

源代码：

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

复制代码

戴隆俊

戴隆俊 发表于 2022-6-3 12:56
ECC-椭圆曲线加密
一、算法简介
椭圆加密算法（ECC）是一种公钥加密体制，最初由Koblitz和Miller两人于1985 ...

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

复制代码