信息计算2019级1班4号吴春滟

吴春滟

大数RSA算法的实现

一.原理：
1. 随意选择两个大的质数p和q，p不等于q，计算N = pq.
2. 根据欧拉函数，求得r=φ(N)=φ(p)φ(q)=(p-1)(q-1)。
3. 选择一个小于r的整数e,是e与r互质。并求得e关于r的模反元素，命名为d。(求d令ed≡1(mod r))。(模反元素存在，当且仅当e与r互质）
4.公开整数n和e，秘密保存d；
5.将明文m（m<n，是一个整数）加密成密文c，加密算法为c=E(m)=memodn；
6.将密文c解密为明文m，解密算法为m=D(c)=cdmodn。

1. package mm;
   
2. import java.util.Random;
   
3. import java.util.Scanner;
   
4. import java.math.BigInteger;
   
5. import java.security.SecureRandom;
   
6. 
   
7. public class Rsa1 {
   
8.         private static final int ORDER = 100000;// 随机数的数量级
   
9.         private static final int MIN = 10000; // 选择的随机数的最小值
   
10. 
    
11.         public static long getPrime() { // 获取一个随机数，判断是否为素数，并用MillerRabin方法检验
    
12.                 long x = 0;
    
13.                 while (x % 2 == 0 || !MillerRabin(x, 5)) {
    
14.                         x = getRandom();
    
15.                 }
    
16.                 return x;
    
17.         }
    
18. 
    
19.         public static long getRandom() {// 随机生成一个奇数
    
20.                 long x = 3;
    
21.                 Random rd = new Random();
    
22.                 do {
    
23.                         x = rd.nextInt(ORDER);
    
24.                 } while (x < MIN || x % 2 == 0);
    
25.                 return x;
    
26.         }
    
27. 
    
28.         public static boolean MillerRabin(long n, int t) {
    
29.                 for (int i = 0; i < t; i++)
    
30.                         if (!isPrime(n))
    
31.                                 return false;
    
32.                 return true;
    
33.         }
    
34. 
    
35.         public static boolean isPrime(long n) {
    
36.                 long k, q;
    
37.                 SecureRandom random = new SecureRandom();
    
38.                 for (k = 0; (((n - 1) >> k) & 1) == 0; k++)
    
39.                         ;
    
40.                 q = (n - 1) >> k;
    
41.                 long a = random.nextLong(n);
    
42.                 if (squareMultiply(a, q, n) == 1)
    
43.                         return true;
    
44.                 for (int j = 0; j < k; j++)
    
45.                         if (squareMultiply(a, (int) Math.pow(2, j) * q, n) == n - 1)
    
46.                                 return true;
    
47.                 return false;
    
48.         }
    
49. 
    
50.         public static long squareMultiply(long a, long b, long p) {
    
51.                 long x = 1, y = a;
    
52.                 long len = (long) Math.ceil((Math.log(b) / Math.log(2)));
    
53.                 for (int i = 0; i < len; i++) {
    
54.                         if (((b >> i) & 1) == 1) {
    
55.                                 x = (x * y) % p;
    
56.                         }
    
57.                         y = (y * y) % p;
    
58.                 }
    
59.                 return x;
    
60.         }
    
61. 
    
62.         public static long powMod(long x, long y, long z) {//模幂运算
    
63. 
    
64.                 if (y == 0)
    
65.                         return 1 % z;
    
66. 
    
67.                 long half = powMod(x, y >> 1, z);
    
68. 
    
69.                 half = (half * half) % z;
    
70. 
    
71.                 if ((y & 1) == 0) { // y是偶数
    
72. 
    
73.                         return half;
    
74. 
    
75.                 } else { // y是奇数
    
76. 
    
77.                         return (half * (x % z)) % z;
    
78. 
    
79.                 }
    
80. 
    
81.         }
    
82. 
    
83.         public static long Inverse(long a, long b) { // 模逆运算
    
84.                 long[] m = { 1, 0, a };
    
85.                 long[] n = { 0, 1, b };
    
86.                 long[] temp = new long[3];
    
87.                 long q = 0; // 初始化
    
88.                 boolean flag = true;
    
89.                 while (flag) {
    
90.                         q = m[2] / n[2];
    
91.                         for (int i = 0; i < 3; i++) {
    
92.                                 temp[i] = m[i] - q * n[i];
    
93.                                 m[i] = n[i];
    
94.                                 n[i] = temp[i];
    
95.                         }
    
96.                         if (n[2] == 1) {
    
97.                                 if (n[1] < 0) {
    
98.                                         n[1] = n[1] + a;
    
99.                                 }
    
100.                                 return n[1];
     
101.                         }
     
102.                         if (n[2] == 0) {
     
103.                                 flag = false;
     
104.                         }
     
105.                 }
     
106.                 return 0;
     
107.         }
     
108. 
     
109.         public static void main(String[] args) {
     
110.                 long p = getPrime(); // 生成两个素数
     
111.                 long q = getPrime();
     
112.                 while (p == q) {
     
113.                         q = getPrime();
     
114.                 }
     
115.                 long n = p * q;
     
116.                 long φ = (p - 1) * (q - 1);
     
117.                 long e = getPrime();
     
118.                 long d = Inverse(φ, e);
     
119.                 System.out.println("p:"+p);
     
120.                 System.out.println("q:"+q);
     
121.                 System.out.println("n:"+n);
     
122.                 System.out.println("φ:"+φ);
     
123.                 System.out.println("e:"+e);
     
124.                 System.out.println("d:"+d);
     
125. 
     
126.                 System.out.print("请输入明文：");
     
127.                 Scanner sc = new Scanner(System.in);
     
128.                 long m=sc.nextLong();
     
129.                 long c=powMod(m, e, n);
     
130.                 System.out.println("密文：" + c);
     
131.                 m = powMod(c, d, n);
     
132.                 System.out.println("解密得到明文：" + m);
     
133.                 sc.close();
     
134.         }
     
135. }

复制代码

吴春滟

ECC 一、算法简介 椭圆加密算法（ECC）是一种公钥加密体制，最初由Koblitz和Miller两人于1985年提出，其数学基础是利用椭圆曲线上的有理点构成Abel加法群上椭圆离散对数的计算困难性。公钥密码体制根据其所依据的难题一般分为三类：大素数分解问题类、离散对数问题类、椭圆曲线类。有时也把椭圆曲线类归为离散对数类。 相比RSA，ECC优势是可以使用更短的密钥，来实现与RSA相当或更高的安全，RSA加密算法也是一种非对称加密算法，在公开密钥加密和电子商业中RSA被广泛使用。 二、原理 1、用户A选定一条椭圆曲线Ep(a,b)，并取椭圆曲线上一点，作为基点G； 2、用户A选择一个私有密钥k，并生成公开密钥K=kG； 3、用户A将Ep(a,b)和点K，G传给用户B； 4、用户B接到信息后 ，将待传输的明文编码到Ep(a,b)上一点M，并产生一个随机整数r； 5、用户B计算点C1=M+rK，C2=rG； 6、用户B将C1、C2传给用户A； 7、用户A接到信息后，计算C1-kC2，结果就是点M。

1. #include<iostream>
   
2. #include<math.h>
   
3. #include<time.h>
   
4. using namespace std;
   
5. 
   
6. class point
   
7. {
   
8. public:
   
9.         int x;
   
10.         int y;
    
11. };
    
12. point P[100];
    
13. int num = 0;
    
14. 
    
15. //取模
    
16. int my_mod(int a, int p)
    
17. {
    
18.         int i;
    
19.         i = a / p;
    
20.         int re = a - i * p;
    
21.         if (re >= 0)
    
22.         {
    
23.                 return re;
    
24.         }
    
25.         else
    
26.         {
    
27.                 return re + p;
    
28.         }
    
29. }
    
30. 
    
31. int my_pow(int a, int m, int p)
    
32. {
    
33.         int result = 1;
    
34.         for (int i = 0; i < m; i++)
    
35.         {
    
36.                 result = (result * a) % p;
    
37.         }
    
38.         return result;
    
39. }
    
40. 
    
41. int my_sqrt(int s)
    
42. {
    
43.         int t;
    
44.         t = (int)sqrt(s);
    
45.         if (t * t == s)
    
46.         {
    
47.                 return t;
    
48.         }
    
49.         else {
    
50.                 return -1;
    
51.         }
    
52. }
    
53. 
    
54. void all_points(int a, int b, int p)
    
55. {
    
56.         for (int i = 0; i < p; i++)
    
57.         {
    
58.                 int s = i * i * i + a * i + b;
    
59.                 while (s < 0)
    
60.                 {
    
61.                         s += p;
    
62.                 }
    
63.                 s = my_mod(s, p);
    
64. 
    
65.                 int re = my_pow(s, (p - 1) / 2, p);
    
66.                 if (re == 1)
    
67.                 {
    
68.                         //求y
    
69.                         int n = 1, y;
    
70.                         int f = my_sqrt(s);
    
71.                         if (f != -1)
    
72.                         {
    
73.                                 y = f;
    
74.                         }
    
75.                         else
    
76.                         {
    
77.                                 for (; n <= p - 1;)
    
78.                                 {
    
79.                                         s = s + n * p;
    
80.                                         f = my_sqrt(s);
    
81.                                         if (f != -1)
    
82.                                         {
    
83.                                                 y = f;
    
84.                                                 break;
    
85.                                         }
    
86.                                         n++;
    
87.                                 }
    
88.                         }
    
89. y = my_mod(y, p);
    
90.                         P[num].x = i;
    
91.                         P[num].y = y;
    
92.                         num++;
    
93.                         if (y != 0)
    
94.                         {
    
95.                                 P[num].x = i;
    
96.                                 P[num].y = (p - y) % p;
    
97.                                 num++;
    
98.                         }
    
99.                 }
    
100.         }
     
101. }
     
102. 
     
103. void show()
     
104. {
     
105.         for (int i = 0; i < num; i++)
     
106.         {
     
107.                 cout << P[i].x << " " << P[i].y << endl;
     
108.         }
     
109. }
     
110. 
     
111. 
     
112. int extend(int a, int b, int& x, int& y)
     
113. {
     
114.         if (b == 0)
     
115.         {
     
116.                 x = 1;
     
117.                 y = 0;
     
118.                 return a;
     
119.         }
     
120.         int r = extend(b, a % b, x, y);
     
121.         int t = x;
     
122.         x = y;
     
123.         y = t - a / b * y;
     
124.         return r;
     
125. }
     
126. 
     
127. //递归扩展欧几里得求逆
     
128. int inv(int a, int b)
     
129. {
     
130.         int x, y;
     
131.         int r = extend(a, b, x, y);
     
132.         if (r != 1)
     
133.         {
     
134.                 return 0;
     
135.         }
     
136.         x = x % b;
     
137.         if (x < 0)
     
138.         {
     
139.                 x = x + b;
     
140.         }
     
141.         return x;
     
142. }
     
143. 
     
144. 
     
145. //加法运算
     
146. point add(point p1, point p2, int a, int p)
     
147. {
     
148.         long t; int flag = 0;
     
149.         int x1 = p1.x; int y1 = p1.y;
     
150.         int x2 = p2.x; int y2 = p2.y;
     
151.         int tx, ty; int x3, y3;
     
152. 
     
153.         if ((x2 == x1) && (y2 == y1))
     
154.         {
     
155.                 //相同点
     
156.                 if (y1 == 0)
     
157.                 {
     
158.                         flag = 1;
     
159.                 }
     
160.                 else
     
161.                 {
     
162.                         t = (3 * x1 * x1 + a) * inv(2 * y1, p) % p;
     
163.                 }
     
164.         }
     
165.         else
     
166.         {
     
167.                 //不同点
     
168.                 ty = y2 - y1;
     
169.                 tx = x2 - x1;
     
170.                 while (tx < 0)
     
171.                 {
     
172.                         tx = tx + p;
     
173.                 }
     
174.                 while (ty < 0)
     
175.                 {
     
176.                         ty = ty + p;
     
177.                 }
     
178. 
     
179.                 if (tx == 0 && ty != 0)
     
180.                 {
     
181.                         flag = 1;
     
182.                 }
     
183.                 else
     
184.                 {
     
185.                         //点不相等
     
186.                         t = ty * inv(tx, p) % p;
     
187.                 }
     
188.         }
     
189. 
     
190.         if (flag == 1)
     
191.         {
     
192.                 //无限点
     
193.                 p2.x = -1;
     
194.                 p2.y = -1;
     
195.         }
     
196.         else
     
197.         {
     
198.                 x3 = (t * t - x1 - x2) % p;
     
199.                 y3 = (t * (x1 - x3) - y1) % p;
     
200.                 while (x3 < 0)
     
201.                 {
     
202.                         x3 += p;
     
203.                 }
     
204.                 while (y3 < 0)
     
205.                 {
     
206.                         y3 += p;
     
207.                 }
     
208.                 p2.x = x3;
     
209.                 p2.y = y3;
     
210.         }
     
211.         return p2;
     
212. }
     
213. 
     
214. //随机选取一个生成元并计算阶
     
215. int jie(point& pp, int a, int p)
     
216. {
     
217.         int ii = rand() % num;
     
218.         point P0 = P[ii];
     
219.         point p1, p2;
     
220.         int number = 1;
     
221. p1.x = P0.x; p2.x = P0.x;
     
222.         p1.y = P0.y; p2.y = P0.y;
     
223.         while (true)
     
224.         {
     
225.                 p2 = add(p1, p2, a, p);
     
226.                 if (p2.x == -1 && p2.y == -1)
     
227.                 {
     
228.                         break;
     
229.                 }
     
230.                 number++;
     
231.                 if (p2.x == p1.x)
     
232.                 {
     
233.                         break;
     
234.                 }
     
235.         }
     
236.         pp.x = p1.x;
     
237.         pp.y = p1.y;
     
238.         int n = ++number;
     
239.         return n;
     
240. }
     
241. 
     
242. //素数判断
     
243. bool judge(int num)
     
244. {
     
245.         bool ret = true;
     
246.         int ubound = sqrt(num) + 1;
     
247.         for (int i = 2; i < ubound; i++)
     
248.         {
     
249.                 if (num % i == 0)
     
250.                 {
     
251.                         ret = false;
     
252.                         break;
     
253.                 }
     
254.         }
     
255.         return ret;
     
256. }
     
257. 
     
258. //计算kG
     
259. point cal(point G, int k, int a, int p)
     
260. {
     
261.         point temp = G;
     
262.         for (int i = 0; i < k - 1; i++)
     
263.         {
     
264.                 temp = add(temp, G, a, p);
     
265.         }
     
266.         return temp;
     
267. }
     
268. 
     
269. int main()
     
270. {
     
271.         srand(time(NULL));
     
272.         int a, b, p;
     
273.         point generator; int n;
     
274.         char SE[10];
     
275.         char CR[10];
     
276. 
     
277.         cout << "请输入椭圆曲线群（a,b,p）：";
     
278.         cin >> a >> b >> p;
     
279.         cout << "请输入明文：";
     
280.         cin >> SE;
     
281.         cout << "请输入密钥：";
     
282.         cin >> CR;
     
283. 
     
284.         //计算所有点
     
285.         all_points(a, b, p);
     
286.         //选取生成元，直到阶为素数
     
287.         do
     
288.         {
     
289.                 n = jie(generator, a, p);
     
290.         } while (judge(n) == false);
     
291.         cout << endl << "选取生成元（" << generator.x << "," << generator.y << "）,阶为：" << n << endl;
     
292.         //选取私钥
     
293.         int ka = int(CR[0]) % (n - 1) + 1;//选取使用的密钥
     
294.         point pa = cal(generator, ka, a, p);//计算公钥
     
295.         cout << "私钥：" << ka << endl;
     
296.         cout << "公钥：（" << pa.x << "," << pa.y << "）" << endl;
     
297. 
     
298.         //加密
     
299.         int k = 0;//随机数k
     
300.         k = rand() % (n - 2) + 1;
     
301.         point C1 = cal(generator, k, a, p);//计算C1
     
302. 
     
303.         //m嵌入到椭圆曲线
     
304.         int t = rand() % num; //选择映射点
     
305.         point Pt = P[t];
     
306.         point P2 = cal(pa, k, a, p);
     
307.         point Pm = add(Pt, P2, a, p);
     
308.         cout << endl << "要发送的密文：" << endl;
     
309.         cout << "kG=(" << C1.x << "," << C1.y << "),pt+kPa=(" << Pm.x << "," << Pm.y << ")";
     
310.         int C[100];
     
311.         cout << ",C = { ";
     
312.         for (int i = 0; i < strlen(SE); i++)
     
313.         {
     
314.                 C[i] = int(SE[i]) * Pt.x + Pt.y;//选取要加密的明文
     
315.                 cout << C[i] << " ";
     
316.         }
     
317.         cout << "}" << endl;
     
318. 
     
319. 
     
320.         //解密
     
321.         point temp, temp1;
     
322.         int m;
     
323.         temp = cal(C1, ka, a, p);
     
324.         temp.y = 0 - temp.y;
     
325.         temp1 = add(Pm, temp, a, p);//求解Pt
     
326.         printf("\n解密结果：\n");
     
327.         for (int i = 0; i < strlen(SE); i++)
     
328.         {
     
329.                 m = (C[i] - temp1.y) / temp1.x;
     
330.                 printf("%c", char(m));//输出密文
     
331.         }
     
332.         printf("\n");
     
333. 
     
334.         return 0;
     
335. }

复制代码

吴春滟

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

复制代码