信息计算2019级1班29号敖若瑶

信息计算敖若瑶

RSA的加密和签名

一、原理

RSA加密：A和B进行通信加密，B要先生成一对RSA密钥，B自己持有私钥，给A公钥 ->A使用B的公钥加密要发送的内容，然后B接收到密文后通过自己的私钥解密内容。

RSA签名：A给B发送消息，A先计算出消息的消息摘要，然后使用自己的私钥加密消息摘要，被加密的消息摘要就是签名(A用自己的私钥给消息摘要加密成为签名)。

二、环境

java

三、源代码

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 Test {
    
14. 
    
15.     /**
    
16.      * RSA最大加密明文大小
    
17.      */
    
18.     private static final int MAX_ENCRYPT_BLOCK = 117;
    
19. 
    
20.     /**
    
21.      * RSA最大解密密文大小
    
22.      */
    
23.     private static final int MAX_DECRYPT_BLOCK = 128;
    
24. 
    
25.     /**
    
26.      * 获取密钥对
    
27.      *
    
28.      * @return 密钥对
    
29.      */
    
30.     public static KeyPair getKeyPair() throws Exception {
    
31.         KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
    
32.         generator.initialize(1024);
    
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 = "待加密的文字内容";
     
175.             String encryptData = encrypt(data, getPublicKey(publicKey));
     
176.             System.out.println("加密后内容:" + encryptData);
     
177.             // RSA解密
     
178.             String decryptData = decrypt(encryptData, getPrivateKey(privateKey));
     
179.             System.out.println("解密后内容:" + decryptData);
     
180. 
     
181.             // RSA签名
     
182.             String sign = sign(data, getPrivateKey(privateKey));
     
183.             // RSA验签
     
184.             boolean result = verify(data, getPublicKey(publicKey), sign);
     
185.             System.out.print("验签结果:" + result);
     
186.         } catch (Exception e) {
     
187.             e.printStackTrace();
     
188.             System.out.print("加解密异常");
     
189.         }
     
190.     }
     
191. }

复制代码

信息计算敖若瑶

ECC椭圆曲线加密

一、原理
      描述一条Fp上的椭圆曲线，常用到六个参量：T=(p,a,b,n,x,y)。（p,a,b）用来确定一条椭圆曲线，p为素数域内点的个数，a和b是其内的两个大数；x,y为G基点的坐标，也是两个大数；n为点G基点的阶；
      以上六个量就可以描述一条椭圆曲线，有时候我们还会用到h(椭圆曲线上所有点的个数p与n相除的整数部分)。现在我们描述一个利用椭圆曲线进行加密通信的过程：
      1、选定一条椭圆曲线 Ep(a,b) 并取椭圆曲线上一点，作为基点P。
      2、选择一个大数k作为私钥，并生成公钥 Q=kP。
      3、将 Ep(a,b) 和点Q、P传给用户。
      4、用户接到信息后 ，将待传输的明文编码到Ep(a,b)上的一点M，并产生一个随机整数r。
      5、公钥加密（密文C是一个点对）：C={rP, M+rQ}
      6、私钥解密（M + rQ - k(rP) ，解密结果就是点M），公式：M + rQ - k(rP) = M + r(kP) - k(rP) = M
      7、对点M进行解码就可以得到明文
      假设在加密过程中，有一个第三者H，H只能知道椭圆曲线 Ep(a,b)、公钥Q、基点P、密文点C，而通过公钥Q、基点P求私钥k或者通过密文点C、基点P求随机数r都是非常困难的，因此得以保证数据传输的安全。
二、环境
     C
三、源代码

1. #include <string.h>
   
2. #include <stdio.h>
   
3. #include <openssl/ec.h>
   
4. #include <openssl/ecdsa.h>
   
5. #include <openssl/objects.h>
   
6. #include <openssl/err.h>
   
7. 
   
8. int    main()
   
9. {
   
10.       EC_KEY                *key1,*key2;
    
11.       EC_POINT            *pubkey1,*pubkey2;
    
12.       EC_GROUP           *group1,*group2;
    
13.       int                         ret,nid,size,i,sig_len;
    
14.       unsigned char*signature,digest[20];
    
15.       BIO                      *berr;
    
16.       EC_builtin_curve    *curves;
    
17.       int                                crv_len;
    
18.       char               shareKey1[128],shareKey2[128];
    
19.       int                         len1,len2;
    
20. 
    
21.       /* 构造EC_KEY数据结构 */
    
22.       key1=EC_KEY_new();
    
23.       if(key1==NULL)
    
24.       {
    
25.              printf("EC_KEY_new err!\n");
    
26.              return -1;
    
27.       }
    
28.       key2=EC_KEY_new();
    
29.       if(key2==NULL)
    
30.       {
    
31.              printf("EC_KEY_new err!\n");
    
32.              return -1;
    
33.       }
    
34.       /* 获取实现的椭圆曲线个数 */
    
35.       crv_len = EC_get_builtin_curves(NULL, 0);
    
36.       curves = (EC_builtin_curve *)malloc(sizeof(EC_builtin_curve) * crv_len);
    
37.       /* 获取椭圆曲线列表 */
    
38.       EC_get_builtin_curves(curves, crv_len);
    
39.       /*
    
40.       nid=curves[0].nid;会有错误，原因是密钥太短
    
41.       */
    
42.       /* 选取一种椭圆曲线 */
    
43.       nid=curves[25].nid;
    
44.       /* 根据选择的椭圆曲线生成密钥参数group */
    
45.       group1=EC_GROUP_new_by_curve_name(nid);
    
46.       if(group1==NULL)
    
47.       {
    
48.              printf("EC_GROUP_new_by_curve_name err!\n");
    
49.              return -1;
    
50.       }
    
51.       group2=EC_GROUP_new_by_curve_name(nid);
    
52.       if(group1==NULL)
    
53.       {
    
54.              printf("EC_GROUP_new_by_curve_name err!\n");
    
55.              return -1;
    
56.       }
    
57.       /* 设置密钥参数 */
    
58.       ret=EC_KEY_set_group(key1,group1);
    
59.       if(ret!=1)
    
60.       {
    
61.              printf("EC_KEY_set_group err.\n");
    
62.              return -1;
    
63.       }
    
64.       ret=EC_KEY_set_group(key2,group2);
    
65.       if(ret!=1)
    
66.       {
    
67.              printf("EC_KEY_set_group err.\n");
    
68.              return -1;
    
69.       }
    
70.       /* 生成密钥 */
    
71.       ret=EC_KEY_generate_key(key1);
    
72.       if(ret!=1)
    
73.       {
    
74.              printf("EC_KEY_generate_key err.\n");
    
75.              return -1;
    
76.       }
    
77.       ret=EC_KEY_generate_key(key2);
    
78.       if(ret!=1)
    
79.       {
    
80.              printf("EC_KEY_generate_key err.\n");
    
81.              return -1;
    
82.       }
    
83.       /* 检查密钥 */
    
84.       ret=EC_KEY_check_key(key1);
    
85.       if(ret!=1)
    
86.       {
    
87.              printf("check key err.\n");
    
88.              return -1;
    
89.       }
    
90.       /* 获取密钥大小 */
    
91.       size=ECDSA_size(key1);
    
92.       printf("size %d \n",size);
    
93.       for(i=0;i<20;i++)
    
94.              memset(&digest[i],i+1,1);
    
95.       signature=malloc(size);
    
96.       ERR_load_crypto_strings();
    
97.       berr=BIO_new(BIO_s_file());
    
98.       BIO_set_fp(berr,stdout,BIO_NOCLOSE);
    
99.       /* 签名数据，本例未做摘要，可将digest中的数据看作是sha1摘要结果 */
    
100.       ret=ECDSA_sign(0,digest,20,signature,&sig_len,key1);
     
101.       if(ret!=1)
     
102.       {
     
103.              ERR_print_errors(berr);
     
104.              printf("sign err!\n");
     
105.              return -1;
     
106.       }
     
107.       /* 验证签名 */
     
108.       ret=ECDSA_verify(0,digest,20,signature,sig_len,key1);
     
109.       if(ret!=1)
     
110.       {
     
111.              ERR_print_errors(berr);
     
112.              printf("ECDSA_verify err!\n");
     
113.              return -1;
     
114.       }
     
115.       /* 获取对方公钥，不能直接引用 */
     
116.       pubkey2 = EC_KEY_get0_public_key(key2);
     
117.       /* 生成一方的共享密钥 */
     
118.       len1=ECDH_compute_key(shareKey1, 128, pubkey2, key1, NULL);
     
119.       pubkey1 = EC_KEY_get0_public_key(key1);
     
120.       /* 生成另一方共享密钥 */
     
121.       len2=ECDH_compute_key(shareKey2, 128, pubkey1, key2, NULL);
     
122.       if(len1!=len2)
     
123.       {
     
124.              printf("err\n");
     
125.       }
     
126.       else
     
127.       {
     
128.              ret=memcmp(shareKey1,shareKey2,len1);
     
129.              if(ret==0)
     
130.                     printf("生成共享密钥成功\n");
     
131.              else
     
132.                     printf("生成共享密钥失败\n");
     
133.       }
     
134.       printf("test ok!\n");
     
135.       BIO_free(berr);
     
136.       EC_KEY_free(key1);
     
137.       EC_KEY_free(key2);
     
138.       free(signature);
     
139.       free(curves);
     
140.       return 0;
     
141. }

复制代码