信息计算2019级1班刘阔

刘阔

RSA大数算法实现

RSA的定理模型：

设p，q是两个素数，n=p*q；

假设整数e满足1<e<φ（n）,(e, φ（n）)=1;

1、
那么就存在整数s、d，e*d+s* φ（n）=1；

2、
假设存在一个整数a，（a，n）=1；那么a和q，p也应该互素，即（a，p）=1；（a，q）=1；

所以a^φ（p）=1 mod p；

等式两边同时做φ（q）次幂运算，得到（a^φ（p））^φ（q）=1^φ（q） mod p,

整理得a^(φ（p）*φ（q）)=1 mod p;

φ（n）=φ（p）*φ（q），所以a^φ（n）=1 mod p;

等式两边同时做s次幂运算，得到a^（s*φ（n））=(1^s) mod
p=1 mod p;

左右在个乘以a，得到a^(1+（s*φ（n））)=a mod p;

所以：

a^(e*d)=a mod p;①同理，q，p在本质上是相同的，所以

a^(e*d)=a mod q;②

a^(e*d)=a mod （p*q），因为n=p*q;所以a^（e*d）=a mod n;

刘阔

1. import java.io.ByteArrayOutputStream;
   
2. import java.security.Key;
   
3. import java.security.KeyFactory;
   
4. import java.security.KeyPair;
   
5. import java.security.KeyPairGenerator;
   
6. import java.security.PrivateKey;
   
7. import java.security.PublicKey;
   
8. import java.security.Signature;
   
9. import java.security.interfaces.RSAPrivateKey;
   
10. import java.security.interfaces.RSAPublicKey;
    
11. import java.security.spec.PKCS8EncodedKeySpec;
    
12. import java.security.spec.X509EncodedKeySpec;
    
13. import java.util.*;
    
14. import java.util.HashMap;
    
15. import java.util.Map;
    
16. import javax.crypto.Cipher;
    
17. 
    
18. public class RSAUtils {
    
19.     /**
    
20.      * 加密算法RSA
    
21.      */
    
22.     public static final String KEY_ALGORITHM = "RSA";
    
23. 
    
24.     /**
    
25.      * 签名算法
    
26.      */
    
27.     public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
    
28. 
    
29.     /**
    
30.      * 获取公钥的key
    
31.      */
    
32.     private static final String PUBLIC_KEY = "RSAPublicKey";
    
33. 
    
34.     /**
    
35.      * 获取私钥的key
    
36.      */
    
37.     private static final String PRIVATE_KEY = "RSAPrivateKey";
    
38. 
    
39.     /**
    
40.      * RSA最大加密明文大小
    
41.      */
    
42.     private static final int MAX_ENCRYPT_BLOCK = 117;
    
43. 
    
44.     /**
    
45.      * RSA最大解密密文大小
    
46.      */
    
47.     private static final int MAX_DECRYPT_BLOCK = 128;
    
48. 
    
49.     /**
    
50.      * <p>
    
51.      * 生成密钥对(公钥和私钥)
    
52.      * </p>
    
53.      */
    
54.     public static Map<String, Object> genKeyPair() throws Exception {
    
55.         KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
    
56.         keyPairGen.initialize(1024);
    
57.         KeyPair keyPair = keyPairGen.generateKeyPair();
    
58.         RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
    
59.         RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
    
60.         Map<String, Object> keyMap = new HashMap<String, Object>(2);
    
61.         keyMap.put(PUBLIC_KEY, publicKey);
    
62.         keyMap.put(PRIVATE_KEY, privateKey);
    
63.         return keyMap;
    
64.     }
    
65. 
    
66.     /**
    
67.      * <p>
    
68.      * 用私钥对信息生成数字签名
    
69.      * </p>
    
70. 
    
71.      */
    
72.     public static String sign(byte[] data, String privateKey) throws Exception {
    
73.         byte[] keyBytes = Base64.decode(privateKey);
    
74.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
    
75.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    
76.         PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
    
77.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
    
78.         signature.initSign(privateK);
    
79.         signature.update(data);
    
80.         return Base64.encode(signature.sign());
    
81.     }
    
82. 
    
83.     /**
    
84.      * <p>
    
85.      * 校验数字签名
    
86.      * </p>
    
87.      */
    
88.     public static boolean verify(byte[] data, String publicKey, String sign)
    
89.             throws Exception {
    
90.         byte[] keyBytes = Base64.decode(publicKey);
    
91.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
    
92.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    
93.         PublicKey publicK = keyFactory.generatePublic(keySpec);
    
94.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
    
95.         signature.initVerify(publicK);
    
96.         signature.update(data);
    
97.         return signature.verify(Base64.decode(sign));
    
98.     }
    
99. 
    
100.     /**
     
101.      * <P>
     
102.      * 私钥解密
     
103.      * </p>
     
104.      */
     
105.     public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey)
     
106.             throws Exception {
     
107.         byte[] keyBytes = Base64.decode(privateKey);
     
108.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
     
109.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
     
110.         Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
     
111.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
     
112.         cipher.init(Cipher.DECRYPT_MODE, privateK);
     
113.         int inputLen = encryptedData.length;
     
114.         ByteArrayOutputStream out = new ByteArrayOutputStream();
     
115.         int offSet = 0;
     
116.         byte[] cache;
     
117.         int i = 0;
     
118.         while (inputLen - offSet > 0) {
     
119.             if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
     
120.                 cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
     
121.             } else {
     
122.                 cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
     
123.             }
     
124.             out.write(cache, 0, cache.length);
     
125.             i++;
     
126.             offSet = i * MAX_DECRYPT_BLOCK;
     
127.         }
     
128.         byte[] decryptedData = out.toByteArray();
     
129.         out.close();
     
130.         return decryptedData;
     
131.     }
     
132. 
     
133.     /**
     
134.      * <p>
     
135.      * 公钥解密
     
136.      * </p>
     
137. 
     
138.      */
     
139.     public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey)
     
140.             throws Exception {
     
141.         byte[] keyBytes = Base64.decode(publicKey);
     
142.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
     
143.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
     
144.         Key publicK = keyFactory.generatePublic(x509KeySpec);
     
145.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
     
146.         cipher.init(Cipher.DECRYPT_MODE, publicK);
     
147.         int inputLen = encryptedData.length;
     
148.         ByteArrayOutputStream out = new ByteArrayOutputStream();
     
149.         int offSet = 0;
     
150.         byte[] cache;
     
151.         int i = 0;
     
152. 
     
153.         while (inputLen - offSet > 0) {
     
154.             if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
     
155.                 cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
     
156.             } else {
     
157.                 cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
     
158.             }
     
159.             out.write(cache, 0, cache.length);
     
160.             i++;
     
161.             offSet = i * MAX_DECRYPT_BLOCK;
     
162.         }
     
163.         byte[] decryptedData = out.toByteArray();
     
164.         out.close();
     
165.         return decryptedData;
     
166.     }
     
167. 
     
168.     /**
     
169.      * <p>
     
170.      * 公钥加密
     
171.      * </p>
     
172. 
     
173.      */
     
174.     public static byte[] encryptByPublicKey(byte[] data, String publicKey)
     
175.             throws Exception {
     
176.         byte[] keyBytes = Base64.decode(publicKey);
     
177.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
     
178.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
     
179.         Key publicK = keyFactory.generatePublic(x509KeySpec);
     
180. 
     
181.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
     
182.         cipher.init(Cipher.ENCRYPT_MODE, publicK);
     
183.         int inputLen = data.length;
     
184.         ByteArrayOutputStream out = new ByteArrayOutputStream();
     
185.         int offSet = 0;
     
186.         byte[] cache;
     
187.         int i = 0;
     
188. 
     
189.         while (inputLen - offSet > 0) {
     
190.             if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
     
191.                 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
     
192.             } else {
     
193.                 cache = cipher.doFinal(data, offSet, inputLen - offSet);
     
194.             }
     
195.             out.write(cache, 0, cache.length);
     
196.             i++;
     
197.             offSet = i * MAX_ENCRYPT_BLOCK;
     
198.         }
     
199.         byte[] encryptedData = out.toByteArray();
     
200.         out.close();
     
201.         return encryptedData;
     
202.     }
     
203. 
     
204.     /**
     
205.      * <p>
     
206.      * 私钥加密
     
207.      * </p>
     
208. 
     
209.      */
     
210.     public static byte[] encryptByPrivateKey(byte[] data, String privateKey)
     
211.             throws Exception {
     
212.         byte[] keyBytes = Base64.decode(privateKey);
     
213.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
     
214.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
     
215.         Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
     
216.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
     
217.         cipher.init(Cipher.ENCRYPT_MODE, privateK);
     
218.         int inputLen = data.length;
     
219.         ByteArrayOutputStream out = new ByteArrayOutputStream();
     
220.         int offSet = 0;
     
221.         byte[] cache;
     
222.         int i = 0;
     
223. 
     
224.         while (inputLen - offSet > 0) {
     
225.             if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
     
226.                 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
     
227.             } else {
     
228.                 cache = cipher.doFinal(data, offSet, inputLen - offSet);
     
229.             }
     
230.             out.write(cache, 0, cache.length);
     
231.             i++;
     
232.             offSet = i * MAX_ENCRYPT_BLOCK;
     
233.         }
     
234.         byte[] encryptedData = out.toByteArray();
     
235.         out.close();
     
236.         return encryptedData;
     
237.     }
     
238. 
     
239.     /**
     
240.      * <p>
     
241.      * 获取私钥
     
242.      * </p>
     
243. 
     
244.      */
     
245.     public static String getPrivateKey(Map<String, Object> keyMap)
     
246.             throws Exception {
     
247.         Key key = (Key) keyMap.get(PRIVATE_KEY);
     
248.         return Base64.encode(key.getEncoded());
     
249.     }
     
250. 
     
251.     /**
     
252.      * <p>
     
253.      * 获取公钥
     
254.      * </p>
     
255.      */
     
256.     public static String getPublicKey(Map<String, Object> keyMap)
     
257.             throws Exception {
     
258.         Key key = (Key) keyMap.get(PUBLIC_KEY);
     
259.         return Base64.encode(key.getEncoded());
     
260.     }
     
261. }

复制代码

刘阔

椭圆加密算法ECC算法原理:设私钥、公钥分别为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分别为私钥、公钥

刘阔

1. 
   
2. import org.bouncycastle.jce.provider.BouncyCastleProvider;
   
3. import javax.crypto.Cipher;
   
4. import java.security.*;
   
5. import java.security.interfaces.ECPrivateKey;
   
6. import java.security.spec.PKCS8EncodedKeySpec;
   
7. import java.security.spec.X509EncodedKeySpec;
   
8. import java.util.Base64;
   
9. 
   
10. public class ECC {
    
11.         // 生成公钥和私钥
    
12.         public static KeyPair initKey(int keySize, String KEY_ALGORITHM) throws Exception {
    
13.                 KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
    
14.                 keyPairGen.initialize(keySize);
    
15.                 KeyPair keyPair = keyPairGen.generateKeyPair();
    
16.                 return keyPair;
    
17.         }
    
18. 
    
19.         // 公钥加密
    
20.         public static String encryptByPublicKey(String data, String publicKey) throws Exception {
    
21.                 byte[] keyBytes = Base64.getDecoder().decode(publicKey);
    
22.                 Security.addProvider(new BouncyCastleProvider());
    
23.                 X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
    
24.                 KeyFactory keyFactory = KeyFactory.getInstance("EC");
    
25.                 Cipher cipher = Cipher.getInstance("ECIES", "BC");
    
26.                 cipher.init(Cipher.ENCRYPT_MODE, keyFactory.generatePublic(x509KeySpec));
    
27.                 return Base64.getEncoder().encodeToString(cipher.doFinal(data.getBytes()));
    
28. 
    
29.         }
    
30. 
    
31.         // 私钥解密
    
32.         public static String decryptByPrivateKey(String encryptedData, String privateKey) throws Exception {
    
33.                 byte[] keyBytes = Base64.getDecoder().decode(privateKey);
    
34.                 PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
    
35.                 KeyFactory keyFactory = KeyFactory.getInstance("EC");
    
36.                 Security.addProvider(new BouncyCastleProvider());
    
37.                 Cipher cipher = Cipher.getInstance("ECIES", "BC");
    
38.                 cipher.init(Cipher.DECRYPT_MODE, keyFactory.generatePrivate(pkcs8KeySpec));
    
39.                 return Base64.getEncoder().encodeToString(cipher.doFinal(Base64.getDecoder().decode(encryptedData)));
    
40.         }
    
41. 
    
42.         // 用私钥对信息生成数字签名
    
43.         public static String sign(String content, String priKey, String signatureAl) throws Exception {
    
44.                 PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(priKey));
    
45.                 KeyFactory keyFactory = KeyFactory.getInstance("EC");
    
46.                 ECPrivateKey privateK = (ECPrivateKey) keyFactory.generatePrivate(pkcs8KeySpec);
    
47.                 Signature sign = Signature.getInstance(signatureAl);
    
48.                 sign.initSign(privateK);
    
49.                 sign.update(Base64.getDecoder().decode(content));
    
50.                 return Base64.getEncoder().encodeToString(sign.sign());
    
51.         }
    
52. 
    
53.         public static void main(String[] args) {
    
54.                 try {
    
55.                         // 初始化获取公钥和私钥
    
56.                         KeyPair keypair = initKey(256, "EC");
    
57.                         PublicKey publicKey = keypair.getPublic();
    
58.                         PrivateKey privateKey = keypair.getPrivate();
    
59.                         System.out.println("私钥：" + privateKey);
    
60.                         System.out.println("公钥：" + publicKey);
    
61. 
    
62.                         // 生成固定公钥私钥
    
63.                         String publicKeyBase64 = "xinxijisuan";
    
64.                         String privateKeyBase64 = "yuanminting";
    
65.                         System.out.println("公钥：" + publicKeyBase64);
    
66.                         System.out.println("私钥：" + privateKeyBase64);
    
67.                         String c = "信息计算";
    
68.                         System.out.println("加密之前：" + c);
    
69.                         String content = encryptByPublicKey(c, publicKeyBase64);
    
70.                         String contentDe = decryptByPrivateKey(content, privateKeyBase64);
    
71.                         String d = new String(Base64.getDecoder().decode(contentDe));
    
72.                         System.out.println("解密之后：" + d);
    
73.                 } catch (Exception e) {
    
74.                         e.printStackTrace();
    
75.                 }
    
76.         }
    
77. }

复制代码