信息计算2019级2班18号汪浩男

汪浩男

一、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加密原理：
1、用户A选定一条适合加密的椭圆曲线Ep(a,b)(如:y2=x3+ax+b)，并取椭圆曲线上一点，作为基点G。
　2、用户A选择一个私有密钥k，并生成公开密钥K=kG。
　3、用户A将Ep(a,b)和点K，G传给用户B。
　4、用户B接到信息后 ，将待传输的明文编码到Ep(a,b)上一点M，并产生一个随机整数r（r<n）。
　5、用户B计算点C1=M+rK；C2=rG。
　6、用户B将C1、C2传给用户A。
　7、用户A接到信息后，计算C1-kC2，结果就是点M。因为
          C1-kC2=M+rK-k(rG)=M+rK-r(kG)=M
　　　再对点M进行解码就可以得到明文。

代码：

1. #include <iostream>
   
2. #define Ea 20
   
3. #define Eb 4
   
4. #define Ep 29
   
5. using namespace std;
   
6. int fast_pow(int a, int b, int c)
   
7. {
   
8.     int ans = 1;   ///记录结果
   
9.     a = a % c;   ///预处理，使得a处于c的数据范围之下
   
10.     while (b != 0)
    
11.     {
    
12.         if (b & 1)///奇数
    
13.         {
    
14.             ans = (ans * a) % c;///消除指数为奇数的影响
    
15.         }
    
16.         b >>= 1;    ///二进制的移位操作,不断的遍历b的二进制位
    
17.         a = (a * a) % c;   ///不断的加倍
    
18.     }
    
19.     return ans;
    
20. }
    
21. struct point {
    
22.     int x;
    
23.     int y;
    
24.     point():x(0),y(0){}
    
25.     point(int a, int b):x(a),y(b) { }
    
26.     bool operator==(const point& b) {
    
27.         return this->x == b.x && this->y == b.y;
    
28.     }
    
29.     point operator+(const point& b) {
    
30.         point result;
    
31.         if (*this == b) {
    
32.             long aaa = 3 * this->x * this->x + Ea;
    
33.             long bbb = 2 * this->y;
    
34.             //int m = (3 * this->x * this->x + Ea) / (2 * this->y) mod Ep;
    
35.             long m;
    
36.             if (aaa % bbb != 0) {
    
37.                 m = ((aaa % Ep) * fast_pow(bbb, (Ep - 2), Ep)) % Ep;
    
38.             }
    
39.             else {
    
40.                 m = (aaa / bbb) % Ep;
    
41.             }
    
42.             result.x = (m * m - 2 * this->x) % Ep;
    
43.             result.y = (m * (this->x - result.x) - this->y) % Ep;  
    
44.         }
    
45.         else {
    
46.             long aaa = b.y - this->y;
    
47.             long bbb = b.x - this->x;
    
48.             if (bbb == 0) {
    
49.                 return point(13, 23);
    
50.             }
    
51.             long m;
    
52.             if (aaa % bbb != 0) {
    
53.                 m = ((aaa % Ep) * fast_pow(bbb, (Ep - 2), Ep)) % Ep;
    
54.             }
    
55.             else {
    
56.                 m = (aaa / bbb) % Ep;
    
57.             }
    
58.             result.x = (m * m - this->x - b.x) % Ep;
    
59.             result.y = (m * (this->x - result.x) - this->y) % Ep;
    
60.         }
    
61.         if (result.x < 0) {
    
62.             result.x += Ep;
    
63.         }
    
64.         if (result.y < 0) {
    
65.             result.y += Ep;
    
66.         }
    
67.         return result;
    
68.     }
    
69.     point operator-() {
    
70.         this->y = Ep - this->y;
    
71.         return *this;
    
72.     }
    
73. };
    
74. void getG(point x,int& G) {
    
75.     point Gx = x;
    
76.     G = 1;
    
77.     int num = 0;
    
78.     do{
    
79.         cout<<G<<"x:" << Gx.x << " " << Gx.y << endl;
    
80.         Gx = Gx + x;
    
81.         G++;
    
82.     } while (Gx.x != x.x);
    
83.     G++;
    
84.     cout << G << "x:" << Gx.x << " " << Gx.y << endl;
    
85. }
    
86. point getNG(point x,int n) {
    
87.     point result = x;
    
88.     for (int i = 1; i < n; ++i) {
    
89.         result = result + x;
    
90.     }
    
91. 
    
92.     return result;
    
93. }
    
94. void print(point p) {
    
95.     cout << "[" << " " << p.x << "," << p.y << " " << "]" << endl;
    
96. }
    
97. int main()
    
98. {
    
99.     //Alice
    
100.     //椭圆曲线 E29(20,4) 基点(13,23)
     
101.     //第一步，计算椭圆曲线的阶数
     
102.     int G;
     
103.     point* x=new point(13, 23);
     
104.     getG(*x, G);
     
105.     cout << "阶数为：" << G << endl;
     
106.     //求得G=36
     
107.     //第二步，选择一个私有密钥p（p<G）
     
108.     int p =25;
     
109.     //第三步，公开密钥K=p*(13,23)
     
110.     point K = getNG(*x, p);
     
111.     //将 曲线 基点 密钥 公开
     
112.     cout << "公开密钥："<< endl;
     
113.     print(K);
     
114.     //Bob
     
115.     //第四步，需要加密的信息msg，并将msg按照某种编码方式编码到曲线上一点M
     
116.     int msg = 13;
     
117.     cout << "需要加密的信息：" << msg << endl;;
     
118.     point M(13,23);
     
119. 
     
120.     //第五步，产生一个随机数r<G
     
121.     //srand(unsigned(time(NULL)));
     
122.     int r = 6;
     
123.     //第六步,计算c1=M+r*K
     
124.     //           c2=r*(13,23)
     
125.     //(c1,c2)
     
126.     point c1 = M;
     
127.     for (int i = 0; i < r; ++i) {
     
128.         c1 = c1 + K;
     
129.     }
     
130.     point c2=*x;
     
131.     for (int i = 1; i < r; ++i) {
     
132.         c2 = c2 + *x;
     
133.     }
     
134.     cout << "密文为:" << endl;;
     
135.     print(c1);
     
136.     print(c2);
     
137. 
     
138.     //Alice解密
     
139.     //第七步：计算c1-p*c2
     
140.     point c3;
     
141.     point c4=*x;
     
142.     p = p*r % G;
     
143.     for (int i = 1; i < p; ++i) {
     
144.         c4 = c4 + *x;
     
145.     }
     
146.     c3 = c1 + (-c4);
     
147.     cout << "明文为：" << c3.x << endl;
     
148.     return 0;
     
149. }
     

复制代码

运行结果：