信息计算2019级1班30号邓子龙

小1班31号邓子龙

小1班31号邓子龙

4月22日截图

小1班31号邓子龙

5月3日截图

小1班31号邓子龙

RSA加密、解密、签名、验签的原理及方法
一、RSA加密简介
　　RSA加密是一种非对称加密。可以在不直接传递密钥的情况下，完成解密。这能够确保信息的安全性，避免了直接传递密钥所造成的被破解的风险。是由一对密钥来进行加解密的过程，分别称为公钥和私钥。两者之间有数学相关，该加密算法的原理就是对一极大整数做因数分解的困难性来保证安全性。通常个人保存私钥，公钥是公开的（可能同时多人持有）。
二、RSA加密、签名区别

　　加密和签名都是为了安全性考虑，但略有不同。常有人问加密和签名是用私钥还是公钥？其实都是对加密和签名的作用有所混淆。简单的说，加密是为了防止信息被泄露，而签名是为了防止信息被篡改。这里举2个例子说明。

第一个场景：战场上，B要给A传递一条消息，内容为某一指令。

RSA的加密过程如下：

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

（2）A传递自己的公钥给B，B用A的公钥对消息进行加密。

（3）A接收到B加密的消息，利用A自己的私钥对消息进行解密。

　　在这个过程中，只有2次传递过程，第一次是A传递公钥给B，第二次是B传递加密消息给A，即使都被敌方截获，也没有危险性，因为只有A的私钥才能对消息进行解密，防止了消息内容的泄露。



第二个场景：A收到B发的消息后，需要进行回复“收到”。

RSA签名的过程如下：

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

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

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

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

　　但是，综合两个场景你会发现，第一个场景虽然被截获的消息没有泄露，但是可以利用截获的公钥，将假指令进行加密，然后传递给A。第二个场景虽然截获的消息不能被篡改，但是消息的内容可以利用公钥验签来获得，并不能防止泄露。所以在实际应用中，要根据情况使用，也可以同时使用加密和签名，比如A和B都有一套自己的公钥和私钥，当A要给B发送消息时，先用B的公钥对消息加密，再对加密的消息使用A的私钥加签名，达到既不泄露也不被篡改，更能保证消息的安全性。

　　总结：公钥加密、私钥解密、私钥签名、公钥验签。

小1班31号邓子龙

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

复制代码

小1班31号邓子龙

椭圆加密算法
椭圆加密算法（ECC）是一种公钥加密体制，最初由Koblitz和Miller两人于1985年提出，其数学基础是利用椭圆曲线上的有理点构成Abel加法群上椭圆离散对数的计算困难性。公钥密码体制根据其所依据的难题一般分为三类：大素数分解问题类、离散对数问题类、椭圆曲线类。有时也把椭圆曲线类归为离散对数类。

ECC的主要优势是在某些情况下它比其他的方法使用更小的密钥——比如RSA加密算法——提供相当的或更高等级的安全。ECC的另一个优势是可以定义群之间的双线性映射，基于Weil对或是Tate对；双线性映射已经在密码学中发现了大量的应用，例如基于身份的加密。不过一个缺点是加密和解密操作的实现比其他机制花费的时间长。

对于ECC系统来说，完成运行系统所必须的群操作比同样大小的因数分解系统或模整数离散对数系统要慢。不过，ECC系统的拥护者相信ECDLP问题比DLP或因数分解问题要难的多，并且因此使用ECC能用小的多的密钥长度来提供同等的安全，在这方面来说它确实比例如RSA之类的更快。已经公布的结果趋于支持这个结论，不过一些专家表示怀疑。
ECC被广泛认为是在给定密钥长度的情况下，最强大的非对称算法，因此在对带宽要求十分紧的连接中会十分有用。

小1班31号邓子龙

1.                 <dependency>
   
2.             <groupId>org.bouncycastle</groupId>
   
3.             <artifactId>bcprov-jdk15on</artifactId>
   
4.             <version>1.62</version>
   
5.         </dependency>
   
6. 
   
7.     /**
   
8.      * 生成密钥对(公钥和私钥)
   
9.      *
   
10.      * @return
    
11.      * @throws Exception
    
12.      */
    
13.     public static KeyPair initKey(int keySize,String KEY_ALGORITHM) throws Exception {
    
14.         KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
    
15.         keyPairGen.initialize(keySize);
    
16.         KeyPair keyPair = keyPairGen.generateKeyPair();
    
17.         return keyPair;
    
18.     }
    
19. 
    
20.     /**
    
21.      * 公钥加密
    
22.      * @param data      源数据
    
23.      * @param publicKey 公钥(BASE64编码)
    
24.      * @return
    
25.      * @throws Exception
    
26.      */
    
27.     public static String encryptByPublicKey(String data, String publicKey)
    
28.             throws Exception {
    
29.         Security.addProvider(new BouncyCastleProvider());
    
30.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
    
31.         KeyFactory keyFactory = KeyFactory.getInstance("EC");      
    
32.         Cipher cipher = Cipher.getInstance("ECIES","BC");
    
33.         cipher.init(Cipher.ENCRYPT_MODE, keyFactory.generatePublic(x509KeySpec));
    
34.         return Base64.getEncoder().encodeToString(cipher.doFinal(Base64.getDecoder().decode(data)));
    
35.       
    
36.     }
    
37.     /**
    
38.      * 私钥解密
    
39.      *
    
40.      * @param encryptedData 已加密数据
    
41.      * @param privateKey    私钥(BASE64编码)
    
42.      * @return
    
43.      * @throws Exception
    
44.      */
    
45.     public static String decryptByPrivateKey(String encryptedData, String privateKey)
    
46.             throws Exception {
    
47.         byte[] keyBytes = Base64.getDecoder().decode(privateKey);
    
48.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
    
49.         KeyFactory keyFactory = KeyFactory.getInstance("EC");
    
50.         Security.addProvider(new BouncyCastleProvider());
    
51.         Cipher cipher = Cipher.getInstance("ECIES","BC");
    
52.         cipher.init(Cipher.DECRYPT_MODE, keyFactory.generatePrivate(pkcs8KeySpec));
    
53.         return Base64.getEncoder().encodeToString(cipher.doFinal(Base64.getDecoder().decode(encryptedData)));
    
54.     }
    
55. 
    
56.          /**
    
57.      * 用私钥对信息生成数字签名
    
58.      *
    
59.      * @param content       已加密数据 base64
    
60.      * @param priKey 私钥(BASE64编码)
    
61.      * @param signatureAl 签名算法
    
62.      * @return
    
63.      * @throws Exception
    
64.      */
    
65.     public static String sign(String content, String priKey,String signatureAl) throws Exception {
    
66.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(priKey));
    
67.         KeyFactory keyFactory = KeyFactory.getInstance("EC");
    
68.         ECPrivateKey privateK = (ECPrivateKey)keyFactory.generatePrivate(pkcs8KeySpec);
    
69.         Signature sign = Signature.getInstance(signatureAl);//"SHA256withECDSA"
    
70.         sign.initSign(privateK);
    
71.         sign.update(Base64.getDecoder().decode(content));
    
72.         return Base64.getEncoder().encodeToString(sign.sign());
    
73.     }
    
74. 
    
75. /**
    
76.      * 用私钥对信息生成数字签名
    
77.      *
    
78.      * @param content       已加密数据 base64
    
79.      * @param priKey 私钥(BASE64编码)
    
80.      * @param signatureAl 签名算法
    
81.      * @return
    
82.      * @throws Exception
    
83.      */
    
84.     public static String sign(String content, String priKey,String signatureAl) throws Exception {
    
85.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(priKey));
    
86.         KeyFactory keyFactory = KeyFactory.getInstance("EC");
    
87.         ECPrivateKey privateK = (ECPrivateKey)keyFactory.generatePrivate(pkcs8KeySpec);
    
88.         Signature sign = Signature.getInstance(signatureAl);//"SHA256withECDSA/"
    
89.         sign.initSign(privateK);
    
90.         sign.update(Base64.getDecoder().decode(content));
    
91.         return Base64.getEncoder().encodeToString(sign.sign());
    
92.     }
    
93. 
    
94. 
    

复制代码