信息计算2019级1班14号钱星一

钱星一

RSA签名和加密

一、Java实现RSA签名和加密
RSA属于非对称加密算法，有两个密钥。区别于共享密钥的对称加密算法，如DES和AES。公钥可以共享给任何人，私钥自己进行保管。公钥用于加密数据，使得该加密数据只能用私钥进行解密；私钥也可用于签名数据，签名和数据一起发送，然后使用公钥验证数据是否被篡改。

二、RSA实现密钥对
在实际做任何形式加密之前，需要有公钥和私钥两个密钥对。幸运的是，Java提供了非常简单的方法，首先获得RSA KeyPairGenerator实例，然后使用2048为长度进行初始化并传入SecureRandom实例。后者用作生成器的熵或随机数据源。第三行生成密钥对，所有内容都就是这样，非常简单。如果需要使用密钥对存储器，需要使用Java KeyStore工具,后面会详细解释。

三、加密和解密
这里使用base64编码，主要是典型的REST API中很常用，我们当然也可以不用base64编码而直接使用字节数组。确保明确地且一致地为字符串指定字节编码。否则字节错位将导致密文和无法解密或验证签名。首先获得RSA密码实例并设置为加密模式，然后使用公钥加密消息。然后一次性传入消息字符串的字节数组并获得加密后的字节数组，最后转码并返回。运维RSA是相当慢，比对称加密算法如AES要慢的多。

四、签名与验证
我们使用公钥进行加密，然后使用私钥解密。理论上反过来也行（私钥加密，公钥解密），但这不安全且大多数库(包括java.security)也不支持。然而，这种方式在构建API时比较有用。使用私钥对消息进行签名，然后使用公钥进行验证签名。这种机制可以确保消息确实来着公钥创建者(私钥持有者)，使得传输过程消息不会被篡改。
五、运行结果

钱星一

程序代码：
Base64.java

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

复制代码

钱星一

maintest.java

1. package com.ihep;
   
2. 
   
3. public class MainTest {
   
4. 
   
5.     public static void main(String[] args) throws Exception {
   
6.         String filepath = "E:/tmp/";
   
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. }

复制代码

钱星一

RSAEncrypt.java

1. package com.ihep;
   
2. 
   
3. import javax.crypto.BadPaddingException;
   
4. import javax.crypto.Cipher;
   
5. import javax.crypto.IllegalBlockSizeException;
   
6. import javax.crypto.NoSuchPaddingException;
   
7. import java.io.*;
   
8. import java.security.*;
   
9. import java.security.interfaces.RSAPrivateKey;
   
10. import java.security.interfaces.RSAPublicKey;
    
11. import java.security.spec.InvalidKeySpecException;
    
12. import java.security.spec.PKCS8EncodedKeySpec;
    
13. import java.security.spec.X509EncodedKeySpec;
    
14. private static final char[] HEX_CHAR = {'0', '1', '2', '3', '4', '5', '6',
    
15. '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
    
16. public static void genKeyPair(String filePath) {
    
17. // 密钥对生成器
    
18. KeyPairGenerator keyPairGen = null;
    
19. try {
    
20. // KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象
    
21. keyPairGen = KeyPairGenerator.getInstance("RSA");
    
22. } catch (NoSuchAlgorithmException e) {
    
23. // TODO Auto-generated catch block
    
24. e.printStackTrace();
    
25. }
    
26. // 初始化密钥对生成器，密钥大小为96-1024位
    
27. keyPairGen.initialize(1024, new SecureRandom());
    
28. // 生成一个密钥对，保存在keyPair中
    
29. KeyPair keyPair = keyPairGen.generateKeyPair();
    
30. // 得到私钥
    
31. RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
    
32. // 得到公钥
    
33. RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
    
34. try {
    
35. // 得到公钥字符串
    
36. String publicKeyString = Base64.encode(publicKey.getEncoded());
    
37. // 得到私钥字符串
    
38. String privateKeyString = Base64.encode(privateKey.getEncoded());
    
39. // 将密钥对写入到文件
    
40. FileWriter pubfw = new FileWriter(filePath + "/publicKey.keystore");
    
41. FileWriter prifw = new FileWriter(filePath + "/privateKey.keystore");
    
42. BufferedWriter pubbw = new BufferedWriter(pubfw);
    
43. BufferedWriter pribw = new BufferedWriter(prifw);
    
44. pubbw.write(publicKeyString);
    
45. pribw.write(privateKeyString);
    
46. pubbw.flush();
    
47. pubbw.close();
    
48. pubfw.close();
    
49. pribw.flush();
    
50. pribw.close();
    
51. prifw.close();
    
52. } catch (Exception e) {
    
53. e.printStackTrace();
    
54. }
    
55. }
    
56. public static String loadPublicKeyByFile(String path) throws Exception {
    
57. try {
    
58. BufferedReader br = new BufferedReader(new FileReader(path
    
59. + "/publicKey.keystore"));
    
60. String readLine = null;
    
61. StringBuilder sb = new StringBuilder();
    
62. while ((readLine = br.readLine()) != null) {
    
63. sb.append(readLine);
    
64. }
    
65. br.close();
    
66. return sb.toString();
    
67. } catch (IOException e) {
    
68. throw new Exception("公钥数据流读取错误");
    
69. } catch (NullPointerException e) {
    
70. throw new Exception("公钥输入流为空");
    
71. }
    
72. }
    
73. public static RSAPublicKey loadPublicKeyByStr(String publicKeyStr)
    
74. throws Exception {
    
75. try {
    
76. byte[] buffer = Base64.decode(publicKeyStr);
    
77. KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    
78. X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
    
79. return (RSAPublicKey) keyFactory.generatePublic(keySpec);
    
80. } catch (NoSuchAlgorithmException e) {
    
81. throw new Exception("无此算法");
    
82. } catch (InvalidKeySpecException e) {
    
83. throw new Exception("公钥非法");
    
84. } catch (NullPointerException e) {
    
85. throw new Exception("公钥数据为空");
    
86. }
    
87. }
    
88. public static String loadPrivateKeyByFile(String path) throws Exception {
    
89. try {
    
90. BufferedReader br = new BufferedReader(new FileReader(path
    
91. + "/privateKey.keystore"));
    
92. String readLine = null;
    
93. StringBuilder sb = new StringBuilder();
    
94. while ((readLine = br.readLine()) != null) {
    
95. sb.append(readLine);
    
96. }
    
97. br.close();
    
98. /** 该字符串从私钥文件中获取，称之为私钥字符串
    
99. * MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBALaIDyyav7J8oD/8sONfP772aa1foDlHmoXRArqe+2po14c1q7nGR8DLk
    
100. * 55J0sgxt/EOvtvxtwo4cPFtoLSBzdKVn/ZmR7uyHQXsMzqcmz7n7DGAzNNqxlu0SLHVjZ4HscWxnC+dGa037Ec9m5DKRT6aMckNmxZp3G
     
101. * xic9wzId6zAgMBAAECgYEAhpOUFH/XvEH0aJjm1gzA1AubaI8rc2/edrDeQTe8B/1agr7IaMTO3E97++VT+fPmOV10zHbPTELGysnYBZ3
     
102. * 6X/wLaKs+GMO/uewNAsyu46u3izwNVCygBiM62mlmhk3Y9J8ZcmoQHzXGV0p0TuGJsIlAofCAN1ielWLPcEVUPckCQQDoQm4GKe2C26oU
     
103. * aXRwLy2WLczfmqLTlJ8QyJs8ruL78JikhDgLWaLPBJ+lHmTxahC4HjJ9LhNxNVcpbyMiHhM1AkEAyTBjkOGwBJTlYMmS1hn6BoqA5xCRF
     
104. * Iv8gZZMxj+xcvSSEfZU9ObVArOBQRUoIO3GdsyaVfG/DNwuP7zGI16/RwJBAMfyIEu4HpsvxeyKmE3Xn5QQ27WHpzMkWAeX22RTXl7r0k
     
105. * yW8rR6txkm7tS0JMxbtgb7IBX564zjEaU+4u0FHR0CQG+v+zYM9Ag3GHd4r5lH5nMHJLQhkEjVxaGy7IAKD9p/Ry/NjjA+jPXo7NJSimp
     
106. * tVYXR48PeZm8fNFWR2HT+PjUCQFu3yN71iiXA0EW35Y1HHIE814gUV/O5T4gpUNzK9NLvHLFQNbzgoZER5yIGgBWDju1keBkojm8P69A7
     
107. * qdtXILU=
     
108. */
     
109. return sb.toString();
     
110. } catch (IOException e) {
     
111. throw new Exception("私钥数据读取错误");
     
112. } catch (NullPointerException e) {
     
113. throw new Exception("私钥输入流为空");
     
114. }
     
115. }
     
116. public static RSAPrivateKey loadPrivateKeyByStr(String privateKeyStr)
     
117. throws Exception {
     
118. try {
     
119. byte[] buffer = Base64.decode(privateKeyStr);
     
120. PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
     
121. KeyFactory keyFactory = KeyFactory.getInstance("RSA");
     
122. return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
     
123. } catch (NoSuchAlgorithmException e) {
     
124. throw new Exception("无此算法");
     
125. } catch (InvalidKeySpecException e) {
     
126. throw new Exception("私钥非法");
     
127. } catch (NullPointerException e) {
     
128. throw new Exception("私钥数据为空");
     
129. }
     
130. }
     
131. public static byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData)
     
132. throws Exception {
     
133. if (publicKey == null) {
     
134. throw new Exception("加密公钥为空, 请设置");
     
135. }
     
136. Cipher cipher = null;
     
137. try {
     
138. // 使用默认RSA
     
139. cipher = Cipher.getInstance("RSA");
     
140. // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
     
141. // 初始化算法:公钥加密
     
142. cipher.init(Cipher.ENCRYPT_MODE, publicKey);
     
143. // 公钥加密后的字节数组
     
144. byte[] output = cipher.doFinal(plainTextData);
     
145. return output;
     
146. } catch (NoSuchAlgorithmException e) {
     
147. throw new Exception("无此加密算法");
     
148. } catch (NoSuchPaddingException e) {
     
149. e.printStackTrace();
     
150. return null;
     
151. } catch (InvalidKeyException e) {
     
152. throw new Exception("加密公钥非法,请检查");
     
153. } catch (IllegalBlockSizeException e) {
     
154. throw new Exception("明文长度非法");
     
155. } catch (BadPaddingException e) {
     
156. throw new Exception("明文数据已损坏");
     
157. }
     
158. }
     
159. 
     
160. public static byte[] encrypt(RSAPrivateKey privateKey, byte[] plainTextData)
     
161. throws Exception {
     
162. if (privateKey == null) {
     
163. throw new Exception("加密私钥为空, 请设置");
     
164. }
     
165. Cipher cipher = null;
     
166. try {
     
167. // 使用默认RSA
     
168. cipher = Cipher.getInstance("RSA");
     
169. // 初始化算法：私钥加密
     
170. cipher.init(Cipher.ENCRYPT_MODE, privateKey);
     
171. // 加密后的密文数据，以字符数组的形式存在
     
172. byte[] output = cipher.doFinal(plainTextData);
     
173. return output;
     
174. } catch (NoSuchAlgorithmException e) {
     
175. throw new Exception("无此加密算法");
     
176. } catch (NoSuchPaddingException e) {
     
177. e.printStackTrace();
     
178. return null;
     
179. } catch (InvalidKeyException e) {
     
180. throw new Exception("加密私钥非法,请检查");
     
181. } catch (IllegalBlockSizeException e) {
     
182. throw new Exception("明文长度非法");
     
183. } catch (BadPaddingException e) {
     
184. throw new Exception("明文数据已损坏");
     
185. }
     
186. }
     
187. 
     
188. public static byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData)
     
189. throws Exception {
     
190. if (privateKey == null) {
     
191. throw new Exception("解密私钥为空, 请设置");
     
192. }
     
193. Cipher cipher = null;
     
194. try {
     
195. // 使用默认RSA
     
196. cipher = Cipher.getInstance("RSA");
     
197. // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
     
198. // 初始化解密算法：私钥解密
     
199. cipher.init(Cipher.DECRYPT_MODE, privateKey);
     
200. // 解密，生成以字符数组形式存在的明文数据
     
201. byte[] output = cipher.doFinal(cipherData);
     
202. return output;
     
203. } catch (NoSuchAlgorithmException e) {
     
204. throw new Exception("无此解密算法");
     
205. } catch (NoSuchPaddingException e) {
     
206. e.printStackTrace();
     
207. return null;
     
208. } catch (InvalidKeyException e) {
     
209. throw new Exception("解密私钥非法,请检查");
     
210. } catch (IllegalBlockSizeException e) {
     
211. throw new Exception("密文长度非法");
     
212. } catch (BadPaddingException e) {
     
213. throw new Exception("密文数据已损坏");
     
214. }
     
215. }
     
216. public static byte[] decrypt(RSAPublicKey publicKey, byte[] cipherData)
     
217. throws Exception {
     
218. if (publicKey == null) {
     
219. throw new Exception("解密公钥为空, 请设置");
     
220. }
     
221. Cipher cipher = null;
     
222. try {
     
223. // 使用默认RSA
     
224. cipher = Cipher.getInstance("RSA");
     
225. // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
     
226. // 初始化加密算法：公钥解密
     
227. cipher.init(Cipher.DECRYPT_MODE, publicKey);
     
228. byte[] output = cipher.doFinal(cipherData);
     
229. // 以字符数组形式存在的明文数据
     
230. return output;
     
231. } catch (NoSuchAlgorithmException e) {
     
232. throw new Exception("无此解密算法");
     
233. } catch (NoSuchPaddingException e) {
     
234. e.printStackTrace();
     
235. return null;
     
236. } catch (InvalidKeyException e) {
     
237. throw new Exception("解密公钥非法,请检查");
     
238. } catch (IllegalBlockSizeException e) {
     
239. throw new Exception("密文长度非法");
     
240. } catch (BadPaddingException e) {
     
241. throw new Exception("密文数据已损坏");
     
242. }
     
243. }
     
244. public static String byteArrayToString(byte[] data) {
     
245. StringBuilder stringBuilder = new StringBuilder();
     
246. for (int i = 0; i < data.length; i++) {
     
247. // 取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移
     
248. stringBuilder.append(HEX_CHAR[(data[i] & 0xf0) >>> 4]);
     
249. // 取出字节的低四位 作为索引得到相应的十六进制标识符
     
250. stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);
     
251. if (i < data.length - 1) {
     
252. stringBuilder.append(' ');
     
253. }
     
254. }
     
255. return stringBuilder.toString();
     
256. }
     
257. }

复制代码

钱星一

RSASignature.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.     public static String sign(String content, String privateKey, String encode) {
    
20.         try {
    
21.             PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(Base64.decode(privateKey));
    
22. 
    
23.             KeyFactory keyf = KeyFactory.getInstance("RSA");
    
24.             PrivateKey priKey = keyf.generatePrivate(priPKCS8);
    
25. 
    
26.             java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);
    
27. 
    
28.             signature.initSign(priKey);
    
29.             signature.update(content.getBytes(encode));
    
30. 
    
31.             byte[] signed = signature.sign();
    
32. 
    
33.             return Base64.encode(signed);
    
34.         } catch (Exception e) {
    
35.             e.printStackTrace();
    
36.         }
    
37. 
    
38.         return null;
    
39.     }
    
40. 
    
41.     public static String sign(String content, String privateKey) {
    
42.         try {
    
43.             PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(Base64.decode(privateKey));
    
44.             KeyFactory keyf = KeyFactory.getInstance("RSA");
    
45.             PrivateKey priKey = keyf.generatePrivate(priPKCS8);
    
46.             // 这里签名使用的是 SHA1WithRSA
    
47.             java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);
    
48.             // 以私钥字符串初始化签名
    
49.             signature.initSign(priKey);
    
50.             // 将原始串注入签名中
    
51.             signature.update(content.getBytes());
    
52.             // 签名后的结果，以字符数组形式存在
    
53.             byte[] signed = signature.sign();
    
54.             // 签名后的结果,以base64编码形式存在
    
55.             return Base64.encode(signed);
    
56.         } catch (Exception e) {
    
57.             e.printStackTrace();
    
58.         }
    
59.         return null;
    
60.     }
    
61. 
    
62.     public static boolean doCheck(String content, String sign, String publicKey, String encode) {
    
63.         try {
    
64.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    
65.             byte[] encodedKey = Base64.decode(publicKey);
    
66.             PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));
    
67. 
    
68. 
    
69.             java.security.Signature signature = java.security.Signature
    
70.                     .getInstance(SIGN_ALGORITHMS);
    
71. 
    
72.             signature.initVerify(pubKey);
    
73.             signature.update(content.getBytes(encode));
    
74. 
    
75.             boolean bverify = signature.verify(Base64.decode(sign));
    
76.             return bverify;
    
77. 
    
78.         } catch (Exception e) {
    
79.             e.printStackTrace();
    
80.         }
    
81. 
    
82.         return false;
    
83.     }
    
84. 
    
85.     public static boolean doCheck(String content, String sign, String publicKey) {
    
86.         try {
    
87.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    
88.             byte[] encodedKey = Base64.decode(publicKey);
    
89.             PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));
    
90.             // 使用 SHA1WithRSA 签名算法
    
91.             java.security.Signature signature = java.security.Signature
    
92.                     .getInstance(SIGN_ALGORITHMS);
    
93.             // 用公钥初始化签名校验
    
94.             signature.initVerify(pubKey);
    
95.             // 原始串注入签名校验中
    
96.             signature.update(content.getBytes());
    
97.             // 验证签名结果
    
98.             boolean bverify = signature.verify(Base64.decode(sign));
    
99.             // 返回签名是否成功
    
100.             return bverify;
     
101.         } catch (Exception e) {
     
102.             e.printStackTrace();
     
103.         }
     
104.         return false;
     
105.     }
     
106. }
     

复制代码

钱星一

椭圆曲线加密算法（ECC）

一、算法介绍

椭圆曲线密码体制来源于对椭圆曲线的研究，所谓椭圆曲线指的是由韦尔斯特拉斯（Weierstrass）方程：y2+a1xy+a3y=x3+a2x2+a4x+a6 (1)
所确定的平面曲线。其中系数ai(I=1,2,…,6)定义在某个域上，可以是有理数域、实数域、复数域，还可以是有限域GF（pr），椭圆曲线密码体制中用到的椭圆曲线都是定义在有限域上的。椭圆曲线上所有的点外加一个叫做无穷远点的特殊点构成的集合连同一个定义的加法运算构成一个Abel群。在等式
mP=P+P+…+P=Q (2)中，已知m和点P求点Q比较容易，反之已知点Q和点P求m却是相当困难的，这个问题称为椭圆曲线上点群的离散对数问题。椭圆曲线密码体制正是利用这个困难问题设计而来。公钥算法是基于数学函数（如单向陷门函数），公钥密码体制根据其所依据的难题一般分为三类：大整数分解问题类、离散对数问题类、椭圆曲线类。本文是在素域Zp上的，以Menezes-Vanstone形式的椭圆加密算法。
二、算法原理
在素域上的曲线函数为：y^2 = x ^ 3 +a*  x+ b， 其中a，b为小于p的非负数，且 4*a^3+ 27*b^2 != 0
对于在素域上的加法中，对于所有的点P,Q 属于E(Zp),有加法规则：
1。P + O = O + P = P ,P + (-P) = O;  O为椭圆曲线上的零点或者称为无限远的点，但是O在椭圆曲线的加法域上。
2.加法的分配率和结合律，对于s,t 属于Zp,有（s + t ）* P = s * P + t* P;
3.对于 P = (x1,y1),Q = (x2,y2) ,并且 P != - Q,则P + Q=（x3，y3），
x3 = k^2 - x1 -x2;
y3 = k*(x1-x3) - y1;
k = (y2-y1)/(x2-x1)   if P != Q;
k = (3x1^2 + a)/(2*y1) if P == Q;
椭圆曲线在素域上的运算用到除法，而在除法的规则是a / b = c mod p 即计算 a x b^-1 = c mod p ，其中 b^-1为b的乘法逆元， 即 b x b^-1 = 1 mod p。对于乘法逆元，当b与p互素时，存在唯一解，而这里p是一个素数，且b不可能为1，则肯定有解。对于求乘法逆元，一般使用欧几里德算法，如下：

1. int getX_1(int x,int mod){
   
2.         int Q,X1,X2,X3,Y1,Y2,Y3,T1,T2,T3;
   
3.         X1 = 1;
   
4.         X2 = 0;
   
5.         X3 = mod;
   
6.         Y1 = 0;
   
7.         Y2 = 1;
   
8.         Y3 = (x%mod + mod) %mod;//获得正整数
   
9.         while(Y3 != 1){
   
10.                 Q = X3 / Y3;
    
11.                 T1 = X1 - Q * Y1;
    
12.                 T2 = X2 - Q * Y2;
    
13.                 T3 = X3 - Q * Y3;
    
14.                 X1 = Y1;
    
15.                 X2 = Y2;
    
16.                 X3 = Y3;
    
17.                 Y1 = T1;
    
18.                 Y2 = T2;
    
19.                 Y3 = T3;
    
20.         }
    
21.         return Y2;
    
22. }

复制代码

乘法运算规则：
1. 对于任意 k 属于 Zp，有 k * P = P + ..... + P (k个P相加）
2. 对于任意 s,t 属于 Zp，有 s *(t *P) = (s*t)*P
对于Menezes-Vanstone的椭圆加密算法：
1. 产生密钥，
任选一个整数k ,0<k<p ,为私钥，在曲线上任选一点 A ，并计算 B = k*A ，公钥为（A,，B）。其中又可称A为基钥，对于最小整数n以使 n* A = O ，则n称为周期，要是周期为素数，且为一个较大值才合理。
2.加密过程：
令明文为 M = (m1,m2),M可以不是曲线E上的点。计算得到密文(C1,C2),其中任选一个数属于Zp：
C1 = r * A;；
Y= （y1,y2) = r * B;
C2 = (C21,C22) = (y1 * m1 mod p,y2* m2 mod p)
3 解密过程；
计算Z = (z1,z2) = k*C1;计算明文 M = (C21 * z1^-1 mod p, C22 * z2 ^ -1 mod p).
c++中的模运算，当有负数存在时无法达到正确结果，简直是坑，如 -1 % 2，在使用vs2012进行测试，会返回-1，而不是1. c++中模运算结果的符号和被除数的符号一致。
参数选取：选取 p = 127,曲线函数为: y^2 = x^3 + 5* x + 37， a = 5 ,b= 37， r = 7.选取私钥 k = 9选取一个点A为（11,4)则 B = k*A = (120,41)
三、源代码

1. #include "stdafx.h"
   
2. #include <string>
   
3. #include <iostream>
   
4. using namespace std;
   
5. const int k = 9;
   
6. const int a = 5;
   
7. const int b = 37;
   
8. const int p = 127;
   
9. const int r =7;
   
10. 
    
11. int getX_1(int x,int mod){
    
12.         int Q,X1,X2,X3,Y1,Y2,Y3,T1,T2,T3;
    
13.         X1 = 1;
    
14.         X2 = 0;
    
15.         X3 = mod;
    
16.         Y1 = 0;
    
17.         Y2 = 1;
    
18.         Y3 = (x%mod + mod) %mod;//获得正整数
    
19.         while(Y3 != 1){
    
20.                 Q = X3 / Y3;
    
21.                 T1 = X1 - Q * Y1;
    
22.                 T2 = X2 - Q * Y2;
    
23.                 T3 = X3 - Q * Y3;
    
24.                 X1 = Y1;
    
25.                 X2 = Y2;
    
26.                 X3 = Y3;
    
27.                 Y1 = T1;
    
28.                 Y2 = T2;
    
29.                 Y3 = T3;
    
30.         }
    
31.         return Y2;
    
32. }//获得其乘法逆元
    
33. 
    
34. struct point{
    
35.         int x;
    
36.         int y;
    
37. };
    
38. point A,B;//公钥
    
39. typedef pair<point,point> twopoint;
    
40. bool operator == (point pa,point pb){
    
41.         return pa.x == pb.x && pa.y == pb.y;
    
42. }
    
43. point operator + (point pa , point pb){
    
44.         int k;
    
45.         
    
46.         if(pa == pb)
    
47.                 k = ((3 * pa.x * pa.x + a) * getX_1(2* pa.y ,p)) % p ;
    
48.         else
    
49.                 k = (pb.y - pa.y) * getX_1(pb.x - pa.x , p) %p;
    
50.                 point c;
    
51.                 c.x = (k*k - pa.x -pb.x) %p;
    
52.                 c.y = (k * (pa.x - c.x) - pa.y)%p ;
    
53.                 c.x = (c.x + p) %p;
    
54.                 c.y = (c.y + p) %p;
    
55.                
    
56.                 return c;
    
57. }
    
58. point operator * (point &b,int n){
    
59.                 point q = b;
    
60.                 n = n -1;
    
61.                 for(int i = 1 ; i < n;i++){
    
62.                         q = q + b ;
    
63.                 }
    
64.                 return q;
    
65. }
    
66. twopoint ECodePoint(point m){
    
67.         point c1,c2;
    
68.         c1 = A * r ;
    
69.         point Y = B * r ;
    
70.         c2.x = Y.x * m.x % p ;
    
71.         c2.y = Y.y * m.y % p ;
    
72.         return twopoint(c1,c2);
    
73. }
    
74. point DCodePoint(twopoint t){
    
75.         point Z = t.first * k;
    
76.         point m;
    
77.         m.x = t.second.x * getX_1(Z.x,p) % p ;
    
78.         m.y = t.second.y * getX_1(Z.y,p) % p ;
    
79.         return m;
    
80. }
    
81. string ECode(string input){
    
82.         string output = "";
    
83.         point M;
    
84.         twopoint C;
    
85.         for(int i =0; i < input.length();i++){
    
86.                 M.x = i;
    
87.                 M.y = input[i];
    
88.                 C = ECodePoint(M);
    
89.                 output += (char)C.first.x ;
    
90.                 output += (char)C.first.y ;
    
91.                 output += (char)C.second.x ;
    
92.                 output += (char)C.second.y ;
    
93.         }
    
94.         return output;
    
95. }
    
96. string DCode(string input){
    
97.         string output = "";
    
98.         point M;
    
99.         twopoint C;
    
100.         if(input.length()%4 != 0)
     
101.                 return "错误输入";
     
102.         for(int i = 0;i < input.length();){
     
103.                 C.first.x = input[i++];
     
104.                 C.first.y = input[i++];
     
105.                 C.second.x = input[i++];
     
106.                 C.second.y = input[i++];
     
107.                 M = DCodePoint(C);
     
108.                 output += (char)M.y;
     
109.         }
     
110.         return output;
     
111. }
     
112. int main()
     
113. {
     
114.         A.x = 11;
     
115.         A.y = 4;
     
116.         B = A*k;
     
117.         string s = "";
     
118.         cout<<"使用在素域上的曲线 y^2 = x^3 + 5*x +37   ，使用Menezes-Vanstone的算法："<<endl;
     
119.         cout<<"在素域p=127上，私钥为k=9,公钥A(11,4),B(120,41),对明文字符串直接转换为int进行加密"<<endl;
     
120.         cout<<"请输入要加密的内容："<<endl;
     
121.         cin>>s;
     
122.         cout<<"密文如下："<<"\r\n";
     
123.         s = ECode(s);
     
124.         cout<<s<<endl;
     
125.         cout<<"对之前密文解密，得到明文如下（由于输入密文不正确绝对会使这个程序出错，所以只能解密绝对安全的密文）："<<"\r\n";
     
126.         s = DCode(s);
     
127.         cout<<s<<"\r\n"<<"完成"<<endl;
     
128.         cin>>s;
     
129.         return 0;
     
130. }

复制代码