信息计算2019级2班15号陈周易

陈周易

RSA加密原理

RSA加密是一种非对称加密。可以在不直接传递密钥的情况下，完成解密。是由一对密钥来进行加解密的过程，分别称为公钥和私钥。传递时只传递公钥，不传递私钥。⽤私钥加密的内容只能⽤对应的公钥解密，反之⽤公钥加密的内容只能⽤对应的私钥解密。

RSA加密过程

   A向B发送信息：A⽤⾃⼰的私钥加密，B只能⽤A的公钥解密。

   B向A发送信息：B⽤A的公钥加密数据，A只能⽤⾃⼰的私钥解密

RSA签名的过程

   A生成一对密钥（公钥和私钥），私钥不公开，A自己保留。公钥为公开的，任何人可以获取。

   A用自己的私钥对消息加签，形成签名，并将加签的消息和消息本身一起传递给B。

   B收到消息后，在获取A的公钥进行验签，如果验签出来的内容与消息本身一致，证明消息是A回复的。

　　在这个过程中，只有2次传递过程，第一次是A传递加签的消息和消息本身给B，第二次是B获取A的公钥，即使都被敌方截获，也没有危险性，因为只有A的私钥才能对消息进行签名，即使知道了消息内容，也无法伪造带签名的回复给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. }

复制代码

陈周易

椭圆曲线密码算法（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. }

复制代码