信息计算2019级2班11号谢春晖

谢春晖

RSA加密、解密和签名算法

一、RSA加密、解密和签名算法简介

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

二、加密和签名的流程

RSA虽然是非对称加密，但是有独特的对称性：公钥加密、私钥解密 私钥加密、公钥解密。

加密：接受方公钥加密、接受方私钥解密；签名：发送方私钥加签、发送方公钥解签，加密和签名一起使用才能防止泄露和篡改，具体流程如下：

1、A给B发送信息STR

2、A先用SHA256对信息STR计算，得到摘要Z

3、A用A的私钥对Z进行加密，得到签名S（只有发送者的私钥才能代表发送者，只能使用发送方的私钥加密才能达到不可抵赖性）

4、A用B的公钥对信息STR和签名S加密，得到传输数据M

传输M：

1、B用B的私钥对M解密，得到信息STR和签名S

2、B用SHA256对信息STR计算，得到摘要Z1

3、B用A的公钥对签名S解密，得到摘要Z（A的公钥可以解签S，证明签名也是A亲自加密的）

4、对比Z和Z1，相等证明信息没有被篡改

三、程序代码

RSAEncrypt.java

1. package com.ihep;
   
2. 
   
3. import java.security.KeyFactory;
   
4. import java.security.PrivateKey;
   
5. import java.security.PublicKey;
   
6. import java.security.spec.PKCS8EncodedKeySpec;
   
7. import java.security.spec.X509EncodedKeySpec;
   
8. 
   
9. /**
   
10. * RSA签名验签类
    
11. */
    
12. public class RSASignature {
    
13. 
    
14.     /**
    
15.      * 签名算法
    
16.      */
    
17.     public static final String SIGN_ALGORITHMS = "SHA1WithRSA";
    
18. 
    
19.     /**
    
20.      * RSA签名
    
21.      *
    
22.      * @param content    待签名数据
    
23.      * @param privateKey 商户私钥
    
24.      * @param encode     字符集编码
    
25.      * @return 签名值
    
26.      */
    
27.     public static String sign(String content, String privateKey, String encode) {
    
28.         try {
    
29.             PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(Base64.decode(privateKey));
    
30. 
    
31.             KeyFactory keyf = KeyFactory.getInstance("RSA");
    
32.             PrivateKey priKey = keyf.generatePrivate(priPKCS8);
    
33. 
    
34.             java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);
    
35. 
    
36.             signature.initSign(priKey);
    
37.             signature.update(content.getBytes(encode));
    
38. 
    
39.             byte[] signed = signature.sign();
    
40. 
    
41.             return Base64.encode(signed);
    
42.         } catch (Exception e) {
    
43.             e.printStackTrace();
    
44.         }
    
45. 
    
46.         return null;
    
47.     }
    
48. 
    
49.     /**
    
50.      * 功能描述：私钥签名
    
51.      *
    
52.      * @param content    明文数据，以字符串形式存在
    
53.      * @param privateKey 字符串私钥
    
54.      * @return String 签名后的结果
    
55.      * @author cakin
    
56.      * @date 2020/11/12
    
57.      */
    
58.     public static String sign(String content, String privateKey) {
    
59.         try {
    
60.             PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(Base64.decode(privateKey));
    
61.             KeyFactory keyf = KeyFactory.getInstance("RSA");
    
62.             PrivateKey priKey = keyf.generatePrivate(priPKCS8);
    
63.             // 这里签名使用的是 SHA1WithRSA
    
64.             java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);
    
65.             // 以私钥字符串初始化签名
    
66.             signature.initSign(priKey);
    
67.             // 将原始串注入签名中
    
68.             signature.update(content.getBytes());
    
69.             // 签名后的结果，以字符数组形式存在
    
70.             byte[] signed = signature.sign();
    
71.             // 签名后的结果,以base64编码形式存在
    
72.             return Base64.encode(signed);
    
73.         } catch (Exception e) {
    
74.             e.printStackTrace();
    
75.         }
    
76.         return null;
    
77.     }
    
78. 
    
79.     /**
    
80.      * RSA验签名检查
    
81.      *
    
82.      * @param content   待签名数据
    
83.      * @param sign      签名值
    
84.      * @param publicKey 分配给开发商公钥
    
85.      * @param encode    字符集编码
    
86.      * @return 布尔值
    
87.      */
    
88.     public static boolean doCheck(String content, String sign, String publicKey, String encode) {
    
89.         try {
    
90.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    
91.             byte[] encodedKey = Base64.decode(publicKey);
    
92.             PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));
    
93. 
    
94. 
    
95.             java.security.Signature signature = java.security.Signature
    
96.                     .getInstance(SIGN_ALGORITHMS);
    
97. 
    
98.             signature.initVerify(pubKey);
    
99.             signature.update(content.getBytes(encode));
    
100. 
     
101.             boolean bverify = signature.verify(Base64.decode(sign));
     
102.             return bverify;
     
103. 
     
104.         } catch (Exception e) {
     
105.             e.printStackTrace();
     
106.         }
     
107. 
     
108.         return false;
     
109.     }
     
110. 
     
111.     /**
     
112.      * 功能描述：公钥校验签名
     
113.      *
     
114.      * @param content   签名原串
     
115.      * @param sign      签名串
     
116.      * @param publicKey 公钥字符串
     
117.      * @return boolean 校验是否成功
     
118.      * @author cakin
     
119.      * @date 2020/11/12
     
120.      * @description:
     
121.      */
     
122.     public static boolean doCheck(String content, String sign, String publicKey) {
     
123.         try {
     
124.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");
     
125.             byte[] encodedKey = Base64.decode(publicKey);
     
126.             PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));
     
127.             // 使用 SHA1WithRSA 签名算法
     
128.             java.security.Signature signature = java.security.Signature
     
129.                     .getInstance(SIGN_ALGORITHMS);
     
130.             // 用公钥初始化签名校验
     
131.             signature.initVerify(pubKey);
     
132.             // 原始串注入签名校验中
     
133.             signature.update(content.getBytes());
     
134.             // 验证签名结果
     
135.             boolean bverify = signature.verify(Base64.decode(sign));
     
136.             // 返回签名是否成功
     
137.             return bverify;
     
138.         } catch (Exception e) {
     
139.             e.printStackTrace();
     
140.         }
     
141.         return false;
     
142.     }
     
143. }

复制代码

四、运行结果截图

谢春晖

RSA加密、解密和签名算法后续代码
RSAEncrypt.java

1. package com.ihep;
   
2. import javax.crypto.BadPaddingException;
   
3. import javax.crypto.Cipher;
   
4. import javax.crypto.IllegalBlockSizeException;
   
5. import javax.crypto.NoSuchPaddingException;
   
6. import java.io.*;
   
7. import java.security.*;
   
8. import java.security.interfaces.RSAPrivateKey;
   
9. import java.security.interfaces.RSAPublicKey;
   
10. import java.security.spec.InvalidKeySpecException;
    
11. import java.security.spec.PKCS8EncodedKeySpec;
    
12. import java.security.spec.X509EncodedKeySpec;
    
13. public class RSAEncrypt {private static final char[] HEX_CHAR = {'0', '1', '2', '3', '4', '5', '6','7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
    
14. public static void genKeyPair(String filePath) {// 密钥对生成器KeyPairGenerator keyPairGen = null;
    
15. try {// KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象
    
16. keyPairGen = KeyPairGenerator.getInstance("RSA");} catch (NoSuchAlgorithmException e) {
    
17. // TODO Auto-generated catch block
    
18. e.printStackTrace();}
    
19. // 初始化密钥对生成器，密钥大小为96-1024位
    
20. keyPairGen.initialize(1024, new SecureRandom());
    
21. // 生成一个密钥对，保存在keyPair中
    
22. KeyPair keyPair = keyPairGen.generateKeyPair();
    
23. // 得到私钥
    
24. RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
    
25. // 得到公钥
    
26. RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
    
27. try {// 得到公钥字符串
    
28. String publicKeyString = Base64.encode(publicKey.getEncoded());
    
29.             // 得到私钥字符串
    
30.             String privateKeyString = Base64.encode(privateKey.getEncoded());
    
31.             // 将密钥对写入到文件
    
32.             FileWriter pubfw = new FileWriter(filePath + "/publicKey.keystore");
    
33.             FileWriter prifw = new FileWriter(filePath + "/privateKey.keystore");
    
34.             BufferedWriter pubbw = new BufferedWriter(pubfw);
    
35.             BufferedWriter pribw = new BufferedWriter(prifw);
    
36.             pubbw.write(publicKeyString);
    
37.             pribw.write(privateKeyString);
    
38.             pubbw.flush();
    
39.             pubbw.close();
    
40.             pubfw.close();
    
41.             pribw.flush();
    
42.             pribw.close();
    
43.             prifw.close();} catch (Exception e) {e.printStackTrace();}}
    
44.     public static String loadPublicKeyByFile(String path) throws Exception {try {
    
45.             BufferedReader br = new BufferedReader(new FileReader(path + "/publicKey.keystore"));
    
46.             String readLine = null;
    
47.             StringBuilder sb = new StringBuilder();
    
48.             while ((readLine = br.readLine()) != null) {sb.append(readLine);}br.close();
    
49.             return sb.toString();} catch (IOException e) {throw new Exception("公钥数据流读取错误");
    
50.         } catch (NullPointerException e) {throw new Exception("公钥输入流为空");}}
    
51.     public static RSAPublicKey loadPublicKeyByStr(String publicKeyStr)
    
52.             throws Exception {try {byte[] buffer = Base64.decode(publicKeyStr);
    
53.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    
54.             X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
    
55.             return (RSAPublicKey) keyFactory.generatePublic(keySpec);
    
56.         } catch (NoSuchAlgorithmException e) {throw new Exception("无此算法");
    
57.         } catch (InvalidKeySpecException e) {throw new Exception("公钥非法");
    
58.         } catch (NullPointerException e) {throw new Exception("公钥数据为空");}}
    
59.     public static String loadPrivateKeyByFile(String path) throws Exception {
    
60.         try {BufferedReader br = new BufferedReader(new FileReader(path+ "/privateKey.keystore"));
    
61.             String readLine = null;
    
62.             StringBuilder sb = new StringBuilder();
    
63.             while ((readLine = br.readLine()) != null) {
    
64.                 sb.append(readLine);
    
65.             }
    
66.             br.close();
    
67.             return sb.toString();
    
68.         } catch (IOException e) {
    
69.             throw new Exception("私钥数据读取错误");
    
70.         } catch (NullPointerException e) {
    
71.             throw new Exception("私钥输入流为空");
    
72.         }
    
73.     }
    
74.     public static RSAPrivateKey loadPrivateKeyByStr(String privateKeyStr)
    
75.             throws Exception {
    
76.         try {
    
77.             byte[] buffer = Base64.decode(privateKeyStr);
    
78.             PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
    
79.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    
80.             return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
    
81.         } catch (NoSuchAlgorithmException e) {
    
82.             throw new Exception("无此算法");
    
83.         } catch (InvalidKeySpecException e) {
    
84.             throw new Exception("私钥非法");
    
85.         } catch (NullPointerException e) {
    
86.             throw new Exception("私钥数据为空");
    
87.         }
    
88.     }
    
89.     public static byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData)
    
90.             throws Exception {
    
91.         if (publicKey == null) {
    
92.             throw new Exception("加密公钥为空, 请设置");
    
93.         }
    
94.         Cipher cipher = null;
    
95.         try {
    
96.             // 使用默认RSA
    
97.             cipher = Cipher.getInstance("RSA");
    
98.             // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
    
99.             // 初始化算法:公钥加密
    
100.             cipher.init(Cipher.ENCRYPT_MODE, publicKey);
     
101.             // 公钥加密后的字节数组
     
102.             byte[] output = cipher.doFinal(plainTextData);
     
103.             return output;} catch (NoSuchAlgorithmException e) {
     
104.             throw new Exception("无此加密算法"); } catch (NoSuchPaddingException e) { e.printStackTrace();
     
105.             return null;} catch (InvalidKeyException e) {
     
106.             throw new Exception("加密公钥非法,请检查");} catch (IllegalBlockSizeException e) {
     
107.             throw new Exception("明文长度非法");} catch (BadPaddingException e) {
     
108.             throw new Exception("明文数据已损坏"); }}
     
109.     public static byte[] encrypt(RSAPrivateKey privateKey, byte[] plainTextData)
     
110.             throws Exception {if (privateKey == null) {throw new Exception("加密私钥为空, 请设置");}
     
111.         Cipher cipher = null;
     
112.         try {
     
113.             // 使用默认RSA
     
114.             cipher = Cipher.getInstance("RSA");
     
115.             // 初始化算法：私钥加密
     
116.             cipher.init(Cipher.ENCRYPT_MODE, privateKey);
     
117.             // 加密后的密文数据，以字符数组的形式存在
     
118.             byte[] output = cipher.doFinal(plainTextData);
     
119.             return output;
     
120.         } catch (NoSuchAlgorithmException e) {throw new Exception("无此加密算法");
     
121.         } catch (NoSuchPaddingException e) {e.printStackTrace();
     
122.             return null;
     
123.         } catch (InvalidKeyException e) {throw new Exception("加密私钥非法,请检查");
     
124.         } catch (IllegalBlockSizeException e) { throw new Exception("明文长度非法");
     
125.         } catch (BadPaddingException e) {throw new Exception("明文数据已损坏");}}
     
126.     public static byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData)throws Exception {
     
127.         if (privateKey == null) { throw new Exception("解密私钥为空, 请设置");}
     
128.         Cipher cipher = null;
     
129.         try {
     
130.             // 使用默认RSA
     
131.             cipher = Cipher.getInstance("RSA");
     
132.             // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
     
133.             // 初始化解密算法：私钥解密
     
134.             cipher.init(Cipher.DECRYPT_MODE, privateKey);
     
135.             // 解密，生成以字符数组形式存在的明文数据
     
136.             byte[] output = cipher.doFinal(cipherData);
     
137.             return output;} catch (NoSuchAlgorithmException e) {
     
138.             throw new Exception("无此解密算法");} catch (NoSuchPaddingException e) {
     
139.             e.printStackTrace();
     
140.             return null;} catch (InvalidKeyException e) {
     
141.             throw new Exception("解密私钥非法,请检查");} catch (IllegalBlockSizeException e) {
     
142.             throw new Exception("密文长度非法");} catch (BadPaddingException e) {
     
143.             throw new Exception("密文数据已损坏");}}
     
144.     public static byte[] decrypt(RSAPublicKey publicKey, byte[] cipherData)
     
145.             throws Exception {
     
146.         if (publicKey == null) {
     
147.             throw new Exception("解密公钥为空, 请设置");}
     
148.         Cipher cipher = null;
     
149.         try {
     
150.             // 使用默认RSA
     
151.             cipher = Cipher.getInstance("RSA");
     
152.             // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
     
153.             // 初始化加密算法：公钥解密
     
154.             cipher.init(Cipher.DECRYPT_MODE, publicKey);
     
155.             byte[] output = cipher.doFinal(cipherData);
     
156.             // 以字符数组形式存在的明文数据
     
157.             return output;} catch (NoSuchAlgorithmException e) {
     
158.             throw new Exception("无此解密算法");} catch (NoSuchPaddingException e) {
     
159.   e.printStackTrace();return null;} catch (InvalidKeyException e) {throw new Exception("解密公钥非法,请检查");
     
160.         } catch (IllegalBlockSizeException e) {throw new Exception("密文长度非法");
     
161.         } catch (BadPaddingException e) {throw new Exception("密文数据已损坏"); }}
     
162.     public static String byteArrayToString(byte[] data) {
     
163.         StringBuilder stringBuilder = new StringBuilder();
     
164.         for (int i = 0; i < data.length; i++) {
     
165.             // 取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移
     
166.             stringBuilder.append(HEX_CHAR[(data[i] & 0xf0) >>> 4]);
     
167.             // 取出字节的低四位 作为索引得到相应的十六进制标识符
     
168.             stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);
     
169.             if (i < data.length - 1) {
     
170.                 stringBuilder.append(' ');}}
     
171.         return stringBuilder.toString();}}

复制代码

谢春晖

RSA加密、解密和签名算法后续代码
MainTest.java

1. package com.ihep;
   
2. 
   
3. public class MainTest {
   
4. 
   
5.     public static void main(String[] args) throws Exception {
   
6.         String filepath = "D:\\密码学\\publicKey.keystore";
   
7. 
   
8.         // 生成公钥和私钥文件
   
9.         RSAEncrypt.genKeyPair(filepath);
   
10. 
    
11.         System.out.println("--------------公钥加密私钥解密过程-------------------");
    
12.         String plainText = "你总会遇见为了你的快乐费尽心思的人";
    
13.         // 公钥加密过程，得到加密后的数据
    
14.         byte[] cipherData = RSAEncrypt.encrypt(RSAEncrypt.loadPublicKeyByStr(RSAEncrypt.loadPublicKeyByFile(filepath)), plainText.getBytes());
    
15.         // 对加密数据进行编码处理，得到加密后的字符串
    
16.         String cipher = Base64.encode(cipherData);
    
17.         // 私钥解密过程
    
18.         byte[] res = RSAEncrypt.decrypt(RSAEncrypt.loadPrivateKeyByStr(RSAEncrypt.loadPrivateKeyByFile(filepath)), Base64.decode(cipher));
    
19.         String restr = new String(res);
    
20.         System.out.println("原文：" + plainText);
    
21.         System.out.println("加密：" + cipher);
    
22.         System.out.println("解密：" + restr);
    
23.         System.out.println();
    
24. 
    
25.         System.out.println("--------------私钥加密公钥解密过程-------------------");
    
26.         plainText = "你总会遇见为了你的快乐费尽心思的人";
    
27.         //私钥加密过程
    
28.         cipherData = RSAEncrypt.encrypt(RSAEncrypt.loadPrivateKeyByStr(RSAEncrypt.loadPrivateKeyByFile(filepath)), plainText.getBytes());
    
29.         cipher = Base64.encode(cipherData);
    
30.         //公钥解密过程
    
31.         res = RSAEncrypt.decrypt(RSAEncrypt.loadPublicKeyByStr(RSAEncrypt.loadPublicKeyByFile(filepath)), Base64.decode(cipher));
    
32.         restr = new String(res);
    
33.         System.out.println("原文：" + plainText);
    
34.         System.out.println("加密：" + cipher);
    
35.         System.out.println("解密：" + restr);
    
36.         System.out.println();
    
37. 
    
38.         System.out.println("---------------私钥签名过程------------------");
    
39.         String content = "你总会遇见为了你的快乐费尽心思的人";
    
40.         String signstr = RSASignature.sign(content, RSAEncrypt.loadPrivateKeyByFile(filepath));
    
41.         System.out.println("签名原串：" + content);
    
42.         System.out.println("签名串：" + signstr);
    
43.         System.out.println();
    
44. 
    
45.         System.out.println("---------------公钥校验签名------------------");
    
46.         System.out.println("签名原串：" + content);
    
47.         System.out.println("签名串：" + signstr);
    
48. 
    
49.         System.out.println("验签结果：" + RSASignature.doCheck(content, signstr, RSAEncrypt.loadPublicKeyByFile(filepath)));
    
50.         System.out.println();
    
51. 
    
52.     }
    
53. }

复制代码

谢春晖

RSA加密、解密和签名算法后续代码
Base64.java

1. package com.ihep;
   
2. public final class Base64 {
   
3.     static private final int     BASELENGTH           = 128;
   
4.     static private final int     LOOKUPLENGTH         = 64;
   
5.     static private final int     TWENTYFOURBITGROUP   = 24;
   
6.     static private final int     EIGHTBIT             = 8;
   
7.     static private final int     SIXTEENBIT           = 16;
   
8.     static private final int     FOURBYTE             = 4;
   
9.     static private final int     SIGN                 = -128;
   
10.     static private final char    PAD                  = '=';
    
11.     static private final boolean fDebug               = false;
    
12.     static final private byte[]  base64Alphabet       = new byte[BASELENGTH];
    
13.     static final private char[]  lookUpBase64Alphabet = new char[LOOKUPLENGTH];
    
14.     static {for (int i = 0; i < BASELENGTH; ++i) {base64Alphabet[i] = -1;}
    
15.         for (int i = 'Z'; i >= 'A'; i--) {base64Alphabet[i] = (byte) (i - 'A');}
    
16.         for (int i = 'z'; i >= 'a'; i--) {base64Alphabet[i] = (byte) (i - 'a' + 26);}
    
17.         for (int i = '9'; i >= '0'; i--) {base64Alphabet[i] = (byte) (i - '0' + 52);}
    
18.         base64Alphabet['+'] = 62;
    
19.         base64Alphabet['/'] = 63;
    
20.         for (int i = 0; i <= 25; i++) {lookUpBase64Alphabet[i] = (char) ('A' + i);}
    
21.         for (int i = 26, j = 0; i <= 51; i++, j++) {lookUpBase64Alphabet[i] = (char) ('a' + j);}
    
22.         for (int i = 52, j = 0; i <= 61; i++, j++) {lookUpBase64Alphabet[i] = (char) ('0' + j);}
    
23.         lookUpBase64Alphabet[62] = (char) '+';
    
24.         lookUpBase64Alphabet[63] = (char) '/';}
    
25.     private static boolean isWhiteSpace(char octect) {
    
26.         return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9);}
    
27.     private static boolean isPad(char octect) {
    
28.         return (octect == PAD);
    
29.     }
    
30.     private static boolean isData(char octect) {
    
31.         return (octect < BASELENGTH && base64Alphabet[octect] != -1);
    
32.     }
    
33.     public static String encode(byte[] binaryData) {
    
34. 
    
35.         if (binaryData == null) {
    
36.             return null;
    
37.         }
    
38.         int lengthDataBits = binaryData.length * EIGHTBIT;
    
39.         if (lengthDataBits == 0) {
    
40.             return "";
    
41.         }
    
42.         int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;
    
43.         int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;
    
44.         int numberQuartet = fewerThan24bits != 0 ? numberTriplets + 1 : numberTriplets;
    
45.         char encodedData[] = null;
    
46.         encodedData = new char[numberQuartet * 4];
    
47.         byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;
    
48.         int encodedIndex = 0;
    
49.         int dataIndex = 0;
    
50.         if (fDebug) {
    
51.             System.out.println("number of triplets = " + numberTriplets);
    
52.         }
    
53.         for (int i = 0; i < numberTriplets; i++) {
    
54.             b1 = binaryData[dataIndex++];
    
55.             b2 = binaryData[dataIndex++];
    
56.             b3 = binaryData[dataIndex++];
    
57.             if (fDebug) {
    
58.                 System.out.println("b1= " + b1 + ", b2= " + b2 + ", b3= " + b3);
    
59.             }
    
60.             l = (byte) (b2 & 0x0f);
    
61.             k = (byte) (b1 & 0x03);
    
62.             byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
    
63.             byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);
    
64.             byte val3 = ((b3 & SIGN) == 0) ? (byte) (b3 >> 6) : (byte) ((b3) >> 6 ^ 0xfc);
    
65.             if (fDebug) {
    
66.                 System.out.println("val2 = " + val2);
    
67.                 System.out.println("k4   = " + (k << 4));
    
68.                 System.out.println("vak  = " + (val2 | (k << 4)));
    
69.             }
    
70.             encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
    
71.             encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];
    
72.             encodedData[encodedIndex++] = lookUpBase64Alphabet[(l << 2) | val3];
    
73.             encodedData[encodedIndex++] = lookUpBase64Alphabet[b3 & 0x3f];
    
74.         }
    
75.         // form integral number of 6-bit groups
    
76.         if (fewerThan24bits == EIGHTBIT) {
    
77.             b1 = binaryData[dataIndex];
    
78.             k = (byte) (b1 & 0x03);
    
79.             if (fDebug) {
    
80.                 System.out.println("b1=" + b1);
    
81.                 System.out.println("b1<<2 = " + (b1 >> 2));
    
82.             }
    
83.             byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
    
84.             encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
    
85.             encodedData[encodedIndex++] = lookUpBase64Alphabet[k << 4];
    
86.             encodedData[encodedIndex++] = PAD;
    
87.             encodedData[encodedIndex++] = PAD;
    
88.         } else if (fewerThan24bits == SIXTEENBIT) {
    
89.             b1 = binaryData[dataIndex];
    
90.             b2 = binaryData[dataIndex + 1];
    
91.             l = (byte) (b2 & 0x0f);
    
92.             k = (byte) (b1 & 0x03);
    
93.             byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
    
94.             byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);
    
95.             encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
    
96.             encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];
    
97.             encodedData[encodedIndex++] = lookUpBase64Alphabet[l << 2];
    
98.             encodedData[encodedIndex++] = PAD;
    
99.         }
    
100.         return new String(encodedData);
     
101.     }
     
102.     public static byte[] decode(String encoded) {
     
103. 
     
104.         if (encoded == null) {
     
105.             return null;
     
106.         }
     
107.         char[] base64Data = encoded.toCharArray();
     
108.         // remove white spaces
     
109.         int len = removeWhiteSpace(base64Data);
     
110.         if (len % FOURBYTE != 0) {
     
111.             return null;//should be divisible by four
     
112.         }
     
113.         int numberQuadruple = (len / FOURBYTE);
     
114.         if (numberQuadruple == 0) {
     
115.             return new byte[0];
     
116.         }
     
117.         byte decodedData[] = null;
     
118.         byte b1 = 0, b2 = 0, b3 = 0, b4 = 0;
     
119.         char d1 = 0, d2 = 0, d3 = 0, d4 = 0;
     
120.         int i = 0;
     
121.         int encodedIndex = 0;
     
122.         int dataIndex = 0;
     
123.         decodedData = new byte[(numberQuadruple) * 3];
     
124.         for (; i < numberQuadruple - 1; i++) {
     
125.             if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))
     
126.                     || !isData((d3 = base64Data[dataIndex++]))
     
127.                     || !isData((d4 = base64Data[dataIndex++]))) {
     
128.                 return null;
     
129.             }//if found "no data" just return null
     
130.             b1 = base64Alphabet[d1];
     
131.             b2 = base64Alphabet[d2];
     
132.             b3 = base64Alphabet[d3];
     
133.             b4 = base64Alphabet[d4];
     
134.             decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
     
135.             decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
     
136.             decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);
     
137.         }
     
138.         if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))) {
     
139.             return null;//if found "no data" just return null
     
140.         }
     
141.         b1 = base64Alphabet[d1];
     
142.         b2 = base64Alphabet[d2];
     
143.         d3 = base64Data[dataIndex++];
     
144.         d4 = base64Data[dataIndex++];
     
145.         if (!isData((d3)) || !isData((d4))) {//Check if they are PAD characters
     
146.             if (isPad(d3) && isPad(d4)) {
     
147.                 if ((b2 & 0xf) != 0)//last 4 bits should be zero
     
148.                 {return null;}
     
149.                 byte[] tmp = new byte[i * 3 + 1];
     
150.                 System.arraycopy(decodedData, 0, tmp, 0, i * 3);
     
151.                 tmp[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
     
152.                 return tmp;} else if (!isPad(d3) && isPad(d4)) {
     
153.                 b3 = base64Alphabet[d3];
     
154.                 if ((b3 & 0x3) != 0)//last 2 bits should be zero
     
155.                 {return null;}
     
156.                 byte[] tmp = new byte[i * 3 + 2];
     
157.                 System.arraycopy(decodedData, 0, tmp, 0, i * 3);
     
158.                 tmp[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
     
159.                 tmp[encodedIndex] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
     
160.                 return tmp;} else {
     
161.                 return null;}
     
162.         } else { //No PAD e.g 3cQl
     
163.             b3 = base64Alphabet[d3];
     
164.             b4 = base64Alphabet[d4];
     
165.             decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
     
166.             decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
     
167.             decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);}
     
168.         return decodedData;}
     
169.     private static int removeWhiteSpace(char[] data) {
     
170.         if (data == null) {
     
171.             return 0;}
     
172.         // count characters that's not whitespace
     
173.         int newSize = 0;
     
174.         int len = data.length;
     
175.         for (int i = 0; i < len; i++) {
     
176.             if (!isWhiteSpace(data[i])) {data[newSize++] = data[i];}}
     
177.         return newSize;}}

复制代码

谢春晖

ECC椭圆曲线上公钥密码算法

一、ECC椭圆曲线上公钥密码简介

椭圆加密算法（ECC）是一种公钥加密体制，最初由Koblitz和Miller两人于1985年提出，其数学基础是利用椭圆曲线上的有理点构成Abel加法群上椭圆离散对数的计算困难性。ECC的主要优势是在某些情况下，它比其他的方法使用更小的密钥，比如RSA加密算法，提供相当的或更高等级的安全。ECC的另一个优势是可以定义群之间的双线性映射，基于Weil对或是Tate对；双线性映射已经在密码学中发现了大量的应用，例如基于身份的加密。不过一个缺点是加密和解密操作的实现比其他机制花费的时间长。

二、ECC椭圆曲线上公钥密码加解密过程

1、服务端生成配对的公钥和私钥

2、私钥保存在服务端，公钥发送给客户端

3、客户端使用公钥加密明文传输给服务端

4、服务端使用私钥解密密文得到明文

三、程序代码

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. #include<string.h>
   
4. #include<math.h>
   
5. #include<time.h>
   
6. #define MAX 100
   
7. typedef struct point{
   
8.         int point_x;
   
9.         int point_y;
   
10. }Point;
    
11. typedef struct ecc{
    
12.         struct point p[MAX];
    
13.         int len;
    
14. }ECCPoint;
    
15. typedef struct generator{
    
16.         Point p;
    
17.         int p_class;
    
18. }GENE_SET;
    
19. void get_all_points();
    
20. int int_sqrt(int s);
    
21. Point timesPiont(int k,Point p);
    
22. Point add_two_points(Point p1,Point p2);
    
23. int inverse(int n,int b);
    
24. void get_generetor_class();
    
25. void encrypt_ecc();
    
26. void decrypt_ecc();
    
27. int mod_p(int s);
    
28. void print();
    
29. int isPrime(int n);
    
30. char alphabet[30]="abcdefghijklmnopqrstuvwxyz";
    
31. int a=-1,b=0,p=89;//椭圆曲线为E89(-1,0)： y2=x3-x (mod 89)
    
32. ECCPoint eccPoint;
    
33. GENE_SET geneSet[MAX];
    
34. int geneLen;
    
35. char plain[]="yes";
    
36. int m[MAX];
    
37. int cipher[MAX];
    
38. int nB;//私钥
    
39. Point P1,P2,Pt,G,PB;
    
40. Point Pm;
    
41. int C[MAX];
    
42. 
    
43. int main()
    
44. {       
    
45.         get_generetor_class();
    
46.         encrypt_ecc();
    
47.         decrypt_ecc();
    
48.         return 0;
    
49. }
    
50. //task4:加密
    
51. void encrypt_ecc()
    
52. {
    
53.         int num,i,j;
    
54.         int gene_class;
    
55.         int num_t;
    
56.         int k;
    
57.         srand(time(NULL));
    
58.         //明文转换过程
    
59.         for(i=0;i<strlen(plain);i++)
    
60.         {
    
61.                 for(j=0;j<26;j++) //for(j=0;j<26;j++)
    
62.                 {
    
63.                         if(plain[i]==alphabet[j])
    
64.                         {
    
65.                                 m[i]=j;//将字符串明文换成数字，并存到整型数组m里面
    
66.                         }
    
67.                 }         
    
68.         }
    
69.         //选择生成元
    
70.         num=rand()%geneLen;
    
71.         gene_class=geneSet[num].p_class;
    
72.         while(isPrime(gene_class)==-1)//不是素数
    
73.         {
    
74.                  num=rand()%(geneLen-3)+3;
    
75.                  gene_class=geneSet[num].p_class;
    
76.         }       
    
77.         //printf("gene_class=%d\n",gene_class);
    
78.         G=geneSet[num].p;
    
79.         //printf("G:(%d,%d)\n",geneSet[num].p.point_x,geneSet[num].p.point_y);
    
80.         nB=rand()%(gene_class-1)+1;//选择私钥
    
81.         PB=timesPiont(nB,G);
    
82.         printf("\n公钥：\n");
    
83.         printf("{y^2=x^3%d*x+%d,%d,(%d,%d),(%d,%d)}\n",a,b,gene_class,G.point_x,G.point_y,PB.point_x,PB.point_y);
    
84.         printf("私钥：\n");
    
85.         printf("nB=%d\n",nB);
    
86.         //加密
    
87.         //
    
88.         k=rand()%(gene_class-2)+1;
    
89.         P1=timesPiont(k,G);
    
90.         //
    
91.         num_t=rand()%eccPoint.len; //选择映射点
    
92.         Pt=eccPoint.p[num_t];
    
93.         //printf("Pt:(%d,%d)\n",Pt.point_x,Pt.point_y);
    
94.         P2=timesPiont(k,PB);
    
95.         Pm=add_two_points(Pt,P2);
    
96.         printf("加密数据：\n");
    
97.         printf("kG=(%d,%d),Pt+kPB=(%d,%d),C={",P1.point_x,P1.point_y,Pm.point_x,Pm.point_y);
    
98.         for(i=0;i<strlen(plain);i++)
    
99.         {
    
100. //                num_t=rand()%eccPoint.len; //选择映射点
     
101. //                Pt=eccPoint.p[num_t];
     
102.                 C[i]=m[i]*Pt.point_x+Pt.point_y;
     
103.                 printf("{%d}",C[i]);
     
104.         }       
     
105.         printf("}\n");
     
106. }
     
107. //task5:解密
     
108. void decrypt_ecc()
     
109. {
     
110.         Point temp,temp1;
     
111.         int m,i;
     
112.         temp=timesPiont(nB,P1);
     
113.         temp.point_y=0-temp.point_y;
     
114.         temp1=add_two_points(Pm,temp);//求解Pt
     
115. //        printf("(%d,%d)\n",temp.point_x,temp.point_y);
     
116. //        printf("(%d,%d)\n",temp1.point_x,temp1.point_y);
     
117.         printf("\n解密结果：\n");
     
118.         for(i=0;i<strlen(plain);i++)
     
119.         {
     
120.                 m=(C[i]-temp1.point_y)/temp1.point_x;
     
121.                 printf("%c",alphabet[m]);//输出密文
     
122.         }
     
123.         printf("\n");
     
124. }
     
125. //判断是否为素数
     
126. int isPrime(int n)
     
127. {
     
128.         int i,k;
     
129.     k = sqrt(n);
     
130.     for (i = 2; i <= k;i++)
     
131.     {
     
132.             if (n%i == 0)
     
133.                         break;
     
134.         }      
     
135.     if (i <=k){
     
136.             return -1;
     
137.         }
     
138.     else {
     
139.              return 0;
     
140.         }
     
141. }
     
142. //task3:求生成元以及阶
     
143. void get_generetor_class()
     
144. {       
     
145.         int i,j=0;
     
146.         int count=1;
     
147.         Point p1,p2;
     
148.         get_all_points();       
     
149. //        p1.point_x=p2.point_x=3;
     
150. //        p1.point_y=p2.point_y=2;
     
151. //        while(1)
     
152. //        {
     
153. //                printf("(%d,%d)+(%d,%d)---%d\n",p1.point_x,p1.point_y,p2.point_x,p2.point_y,count);
     
154. //                p2=add_two_points(p1,p2);
     
155. //                count++;
     
156. //                if(p2.point_x==-1 && p2.point_y==-1)
     
157. //                {
     
158. //                        break;
     
159. //                }
     
160. //        }
     
161. //        printf("\n\n(%d,%d)---%d\n",p1.point_x,p1.point_y,count);
     
162.         //
     
163. //        do{
     
164. //                        printf("(%d,%d)+(%d,%d)---%d\n",p1.point_x,p1.point_y,p2.point_x,p2.point_y,count);
     
165. //                        p2=add_two_points(p1,p2);
     
166. //                        count++;
     
167. //                       
     
168. //        } while(!((p2.point_x==p1.point_x)&&(p2.point_y==p1.point_y)));
     
169. //        printf("(%d,%d)+(%d,%d)---%d\n",p1.point_x,p1.point_y,p2.point_x,p2.point_y,count);
     
170. //        count ++ ;
     
171. //        printf("\n\n(%d,%d)---%d\n",p1.point_x,p1.point_y,count);
     
172.         printf("\n**********************************输出生成元以及阶：*************************************\n");
     
173.         for(i=0;i<eccPoint.len;i++)
     
174.         {
     
175.                 count=1;
     
176.                 p1.point_x=p2.point_x=eccPoint.p[i].point_x;
     
177.                 p1.point_y=p2.point_y=eccPoint.p[i].point_y;               
     
178.                 while(1)
     
179.                 {       
     
180.                         p2=add_two_points(p1,p2);                                       
     
181.                         if(p2.point_x==-1 && p2.point_y==-1)
     
182.                         {
     
183.                                 break;
     
184.                         }
     
185.                         count++;
     
186.                         if(p2.point_x==p1.point_x)
     
187.                         {
     
188.                                 break;
     
189.                         }                                               
     
190.                 }
     
191.                 count++;
     
192.                 if(count<=eccPoint.len+1)
     
193.                 {
     
194.                         geneSet[j].p.point_x=p1.point_x;
     
195.                         geneSet[j].p.point_y=p1.point_y;
     
196.                         geneSet[j].p_class=count;
     
197.                         printf("(%d,%d)--->>%d\t",geneSet[j].p.point_x,geneSet[j].p.point_y,geneSet[j].p_class);
     
198.                         j++;
     
199.                         if(j % 6 ==0){
     
200.                                 printf("\n");
     
201.                         }
     
202.                 }
     
203.                 geneLen=j;       
     
204.         }
     
205. }
     
206. 
     
207. //task2:倍点运算的递归算法
     
208. Point timesPiont(int k,Point p0)
     
209. {
     
210.         if(k==1){
     
211.                 return p0;
     
212.         }                
     
213.         else if(k==2){
     
214.                 return add_two_points(p0,p0);
     
215.         }else{
     
216.                 return add_two_points(p0,timesPiont(k-1,p0));
     
217.         }
     
218. }
     
219. //两点的加法运算
     
220. Point add_two_points(Point p1,Point p2)
     
221. {
     
222.         long t;
     
223.         int x1=p1.point_x;
     
224.         int y1=p1.point_y;
     
225.         int x2=p2.point_x;
     
226.         int y2=p2.point_y;
     
227.         int tx,ty;
     
228.         int x3,y3;
     
229.         int flag=0;
     
230.         //求
     
231.         if((x2==x1)&& (y2==y1) )
     
232.         {
     
233.                 //相同点相加
     
234.                 if(y1==0)
     
235.                 {
     
236.                         flag=1;
     
237.                 }else{
     
238.                         t=(3*x1*x1+a)*inverse(p,2*y1) % p;
     
239.                 }
     
240.                 //printf("inverse(p,2*y1)=%d\n",inverse(p,2*y1));
     
241.         }else{
     
242.                 //不同点相加
     
243.                 ty=y2-y1;
     
244.                 tx=x2-x1;
     
245.                 while(ty<0)
     
246.                 {
     
247.                         ty+=p;
     
248.                 }
     
249.                 while(tx<0)
     
250.                 {
     
251.                         tx+=p;
     
252.                 }
     
253.                 if(tx==0 && ty !=0)
     
254.                 {
     
255.                         flag=1;
     
256.                 }else{
     
257.                         t=ty*inverse(p,tx) % p;
     
258.                 }
     
259.         }
     
260.         if(flag==1)
     
261.         {
     
262.                 p2.point_x=-1;
     
263.                 p2.point_y=-1;
     
264.         }else{
     
265.                 x3=(t*t-x1-x2) % p;
     
266.                 y3=(t*(x1-x3)-y1) % p;
     
267.         //使结果在有限域GF(P)上
     
268.                 while(x3<0)
     
269.                 {
     
270.                         x3+=p;
     
271.                 }
     
272.                 while(y3<0)
     
273.                 {
     
274.                         y3+=p;
     
275.                 }
     
276.                 p2.point_x=x3;
     
277.                 p2.point_y=y3;
     
278.         }       
     
279.         return p2;
     
280. }
     
281. //求b关于n的逆元
     
282. int inverse(int n,int b)
     
283. {
     
284.         int q,r,r1=n,r2=b,t,t1=0,t2=1,i=1;
     
285.         while(r2>0)
     
286.         {
     
287.                 q=r1/r2;
     
288.                 r=r1%r2;
     
289.                 r1=r2;
     
290.                 r2=r;
     
291.                 t=t1-q*t2;
     
292.                 t1=t2;
     
293.                 t2=t;
     
294.         }
     
295.         if(t1>=0)
     
296.                 return t1%n;
     
297.         else{  
     
298.                 while((t1+i*n)<0)
     
299.                         i++;
     
300.                 return t1+i*n;
     
301.         }
     
302. }
     
303. //task1:求出椭圆曲线上所有点
     
304. void get_all_points()
     
305. {
     
306.         int i=0;
     
307.         int j=0;
     
308.         int s,y=0;
     
309.         int n=0,q=0;
     
310.         int modsqrt=0;
     
311.         int flag=0;
     
312.         if (4 * a * a * a + 27 * b * b != 0)
     
313.         {
     
314.                 for(i=0;i<=p-1;i++)
     
315.                 {
     
316.                         flag=0;
     
317.                         n=1;
     
318.                         y=0;
     
319.                         s= i * i * i + a * i + b;
     
320.                         while(s<0)
     
321.                         {
     
322.                                 s+=p;
     
323.                         }
     
324.                         s=mod_p(s);
     
325.                         modsqrt=int_sqrt(s);
     
326.                         if(modsqrt!=-1)
     
327.                         {
     
328.                                 flag=1;
     
329.                                 y=modsqrt;
     
330.                         }else{
     
331.                                 while(n<=p-1)
     
332.                                 {
     
333.                                         q=s+n*p;
     
334.                                         modsqrt=int_sqrt(q);
     
335.                                         if(modsqrt!=-1)
     
336.                                         {
     
337.                                                 y=modsqrt;
     
338.                                                 flag=1;
     
339.                                                 break;
     
340.                                         }
     
341.                                                 flag=0;
     
342.                                                 n++;
     
343.                                 }
     
344.                         }
     
345.                         if(flag==1)
     
346.                         {
     
347.                                 eccPoint.p[j].point_x=i;
     
348.                                 eccPoint.p[j].point_y=y;
     
349.                                 j++;
     
350.                                 if(y!=0)
     
351.                                 {
     
352.                                         eccPoint.p[j].point_x=i;
     
353.                                         eccPoint.p[j].point_y=(p-y) % p;
     
354.                                         j++;
     
355.                                 }                               
     
356.                         }
     
357.                 }
     
358.                 eccPoint.len=j;//点集个数
     
359.                 print(); //打印点集
     
360.         }       
     
361. }
     
362. 
     
363. //取模函数
     
364. int mod_p(int s)
     
365. {
     
366.         int i;        //保存s/p的倍数
     
367.         int result;        //模运算的结果
     
368.         i = s / p;
     
369.         result = s - i * p;
     
370.         if (result >= 0)
     
371.         {
     
372.                 return result;
     
373.         }
     
374.         else
     
375.         {
     
376.                 return result + p;
     
377.         }
     
378. }
     
379. 
     
380. //判断平方根是否为整数
     
381. int int_sqrt(int s)
     
382. {
     
383.         int temp;
     
384.         temp=(int)sqrt(s);//转为整型
     
385.         if(temp*temp==s)
     
386.         {
     
387.                 return temp;
     
388.         }else{
     
389.                 return -1;
     
390.         }
     
391. }
     
392. //打印点集
     
393. void print()
     
394. {
     
395.         int i;
     
396.         int len=eccPoint.len;
     
397.         printf("\n该椭圆曲线上共有%d个点(包含无穷远点)\n",len+1);
     
398.         for(i=0;i<len;i++)
     
399.         {
     
400.                 if(i % 8==0)
     
401.                 {
     
402.                         printf("\n");
     
403.                 }
     
404.                 printf("(%2d,%2d)\t",eccPoint.p[i].point_x,eccPoint.p[i].point_y);
     
405.         }
     
406.         printf("\n");
     
407. }

复制代码

四、运行结果截图