信息计算2019级2班2号胡莘梅

信计19-2胡莘梅

RSA加解密与签名

一、RSA加密
　　RSA密码体制是一种公钥密码体制，加密算法公开，以分配的密钥作为加密解密的关键。一般来说，在一对公私钥中，公钥和私钥都可以用来加密和解密，即公钥加密能且只能被对应的私钥进行解密，私钥加密能且只能被对应的公钥进行解密。但我们一般都用公钥加密，私钥解密，而且生成的私钥往往会比公钥蕴含了更多的信息量。
二、RSA签名
      签名就是在这份资料后面增加一段强而有力的证明，以此证明这段信息的发布者和这段信息的有效性完整性。RSA签名常用的就是将这份信息进行hash，得到一个hash值，再将hash值加密作为签名，后缀在信息的末尾。接收方接到传输的资料后，使用私钥解密这段加密过的hash，得到hash值，然后对信息原文进行hash，对比两次hash是否一致（验签）。签名的过程是不可逆的，因为hash是不可逆的，毕竟那么大的文件被hash成一段字符串还能还原的话那就碉堡了。
      在使用RSA进行通讯的时候，一般是两者结合，即：加密>签名>解密>验签
三、运行截图

信计19-2胡莘梅

四、源代码清单
（1）RSAEncrypt.java（因字数限制，只显示主要类）

1.     public static void genKeyPair(String filePath) {   
   
2.         KeyPairGenerator keyPairGen = null;  
   
3.         try {  
   
4.             keyPairGen = KeyPairGenerator.getInstance("RSA");  
   
5.         } catch (NoSuchAlgorithmException e) {  
   
6.             e.printStackTrace();  
   
7.         }   
   
8.         keyPairGen.initialize(1024,new SecureRandom());
   
9.         KeyPair keyPair = keyPairGen.generateKeyPair();  
   
10.         RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
    
11.         RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();  
    
12.         try {  
    
13.             String publicKeyString = Base64.encode(publicKey.getEncoded());  
    
14.             String privateKeyString = Base64.encode(privateKey.getEncoded());
    
15.             FileWriter pubfw = new FileWriter(filePath + "/publicKey.keystore");  
    
16.             FileWriter prifw = new FileWriter(filePath + "/privateKey.keystore");  
    
17.             BufferedWriter pubbw = new BufferedWriter(pubfw);  
    
18.             BufferedWriter pribw = new BufferedWriter(prifw);  
    
19.             pubbw.write(publicKeyString);  
    
20.             pribw.write(privateKeyString);  
    
21.             pubbw.flush();  
    
22.             pubbw.close();  
    
23.             pubfw.close();  
    
24.             pribw.flush();  
    
25.             pribw.close();  
    
26.             prifw.close();  
    
27.         } catch (Exception e) {  
    
28.             e.printStackTrace();  
    
29.         }  
    
30.     }  
    
31.     public static String loadPublicKeyByFile(String path) throws Exception {  
    
32.         try {  
    
33.             BufferedReader br = new BufferedReader(new FileReader(path  
    
34.                     + "/publicKey.keystore"));  
    
35.             String readLine = null;  
    
36.             StringBuilder sb = new StringBuilder();  
    
37.             while ((readLine = br.readLine()) != null) {  
    
38.                 sb.append(readLine);  
    
39.             }  
    
40.             br.close();  
    
41.             return sb.toString();  
    
42.         } catch (IOException e) {  
    
43.             throw new Exception("公钥数据流读取错误");  
    
44.         } catch (NullPointerException e) {  
    
45.             throw new Exception("公钥输入流为空");  
    
46.         }  
    
47.     }   
    
48.     public static RSAPublicKey loadPublicKeyByStr(String publicKeyStr)  
    
49.             throws Exception {  
    
50.         try {  
    
51.             byte[] buffer = Base64.decode(publicKeyStr);  
    
52.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
    
53.             X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);  
    
54.             return (RSAPublicKey) keyFactory.generatePublic(keySpec);  
    
55.         } catch (NoSuchAlgorithmException e) {  
    
56.             throw new Exception("无此算法");  
    
57.         } catch (InvalidKeySpecException e) {  
    
58.             throw new Exception("公钥非法");  
    
59.         } catch (NullPointerException e) {  
    
60.             throw new Exception("公钥数据为空");  
    
61.         }  
    
62.     }   
    
63.     public static String loadPrivateKeyByFile(String path) throws Exception {  
    
64.         try {  
    
65.             BufferedReader br = new BufferedReader(new FileReader(path  
    
66.                     + "/privateKey.keystore"));  
    
67.             String readLine = null;  
    
68.             StringBuilder sb = new StringBuilder();  
    
69.             while ((readLine = br.readLine()) != null) {  
    
70.                 sb.append(readLine);  
    
71.             }  
    
72.             br.close();  
    
73.             return sb.toString();  
    
74.         } catch (IOException e) {  
    
75.             throw new Exception("私钥数据读取错误");  
    
76.         } catch (NullPointerException e) {  
    
77.             throw new Exception("私钥输入流为空");  
    
78.         }  
    
79.     }  
    
80.    
    
81.     public static RSAPrivateKey loadPrivateKeyByStr(String privateKeyStr)  
    
82.             throws Exception {  
    
83.         try {  
    
84.             byte[] buffer = Base64.decode(privateKeyStr);  
    
85.             PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);  
    
86.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
    
87.             return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);  
    
88.         } catch (NoSuchAlgorithmException e) {  
    
89.             throw new Exception("无此算法");  
    
90.         } catch (InvalidKeySpecException e) {  
    
91.             throw new Exception("私钥非法");  
    
92.         } catch (NullPointerException e) {  
    
93.             throw new Exception("私钥数据为空");  
    
94.         }  
    
95.     }
    
96.     public static byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData)  
    
97.             throws Exception {  
    
98.         if (publicKey == null) {  
    
99.             throw new Exception("加密公钥为空, 请设置");  
    
100.         }  
     
101.         Cipher cipher = null;  
     
102.         try {
     
103.             cipher = Cipher.getInstance("RSA");   
     
104.             cipher.init(Cipher.ENCRYPT_MODE, publicKey);  
     
105.             byte[] output = cipher.doFinal(plainTextData);  
     
106.             return output;  
     
107.         } catch (NoSuchAlgorithmException e) {  
     
108.             throw new Exception("无此加密算法");  
     
109.         } catch (NoSuchPaddingException e) {  
     
110.             e.printStackTrace();  
     
111.             return null;  
     
112.         } catch (InvalidKeyException e) {  
     
113.             throw new Exception("加密公钥非法,请检查");  
     
114.         } catch (IllegalBlockSizeException e) {  
     
115.             throw new Exception("明文长度非法");  
     
116.         } catch (BadPaddingException e) {  
     
117.             throw new Exception("明文数据已损坏");  
     
118.         }  
     
119.     }   
     
120.     public static byte[] encrypt(RSAPrivateKey privateKey, byte[] plainTextData)  
     
121.             throws Exception {  
     
122.         if (privateKey == null) {  
     
123.             throw new Exception("加密私钥为空, 请设置");  
     
124.         }  
     
125.         Cipher cipher = null;  
     
126.         try {
     
127.             cipher = Cipher.getInstance("RSA");  
     
128.             cipher.init(Cipher.ENCRYPT_MODE, privateKey);  
     
129.             byte[] output = cipher.doFinal(plainTextData);  
     
130.             return output;  
     
131.         } catch (NoSuchAlgorithmException e) {  
     
132.             throw new Exception("无此加密算法");  
     
133.         } catch (NoSuchPaddingException e) {  
     
134.             e.printStackTrace();  
     
135.             return null;  
     
136.         } catch (InvalidKeyException e) {  
     
137.             throw new Exception("加密私钥非法,请检查");  
     
138.         } catch (IllegalBlockSizeException e) {  
     
139.             throw new Exception("明文长度非法");  
     
140.         } catch (BadPaddingException e) {  
     
141.             throw new Exception("明文数据已损坏");  
     
142.         }  
     
143.     }  
     
144.    
     
145.     public static byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData)  
     
146.             throws Exception {  
     
147.         if (privateKey == null) {  
     
148.             throw new Exception("解密私钥为空, 请设置");  
     
149.         }  
     
150.         Cipher cipher = null;  
     
151.         try {   
     
152.             cipher = Cipher.getInstance("RSA");
     
153.             cipher.init(Cipher.DECRYPT_MODE, privateKey);  
     
154.             byte[] output = cipher.doFinal(cipherData);  
     
155.             return output;  
     
156.         } catch (NoSuchAlgorithmException e) {  
     
157.             throw new Exception("无此解密算法");  
     
158.         } catch (NoSuchPaddingException e) {  
     
159.             e.printStackTrace();  
     
160.             return null;  
     
161.         } catch (InvalidKeyException e) {  
     
162.             throw new Exception("解密私钥非法,请检查");  
     
163.         } catch (IllegalBlockSizeException e) {  
     
164.             throw new Exception("密文长度非法");  
     
165.         } catch (BadPaddingException e) {  
     
166.             throw new Exception("密文数据已损坏");  
     
167.         }  
     
168.     }  
     
169.     public static byte[] decrypt(RSAPublicKey publicKey, byte[] cipherData)  
     
170.             throws Exception {  
     
171.         if (publicKey == null) {  
     
172.             throw new Exception("解密公钥为空, 请设置");  
     
173.         }  
     
174.         Cipher cipher = null;  
     
175.         try {   
     
176.             cipher = Cipher.getInstance("RSA");   
     
177.             cipher.init(Cipher.DECRYPT_MODE, publicKey);  
     
178.             byte[] output = cipher.doFinal(cipherData);  
     
179.             return output;  
     
180.         } catch (NoSuchAlgorithmException e) {  
     
181.             throw new Exception("无此解密算法");  
     
182.         } catch (NoSuchPaddingException e) {  
     
183.             e.printStackTrace();  
     
184.             return null;  
     
185.         } catch (InvalidKeyException e) {  
     
186.             throw new Exception("解密公钥非法,请检查");  
     
187.         } catch (IllegalBlockSizeException e) {  
     
188.             throw new Exception("密文长度非法");  
     
189.         } catch (BadPaddingException e) {  
     
190.             throw new Exception("密文数据已损坏");  
     
191.         }  
     
192.     }  
     
193.     public static String byteArrayToString(byte[] data) {  
     
194.         StringBuilder stringBuilder = new StringBuilder();  
     
195.         for (int i = 0; i < data.length; i++) {
     
196.             stringBuilder.append(HEX_CHAR[(data[i] & 0xf0) >>> 4]);
     
197.             stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);  
     
198.             if (i < data.length - 1) {  
     
199.                 stringBuilder.append(' ');  
     
200.             }  
     
201.         }  
     
202.         return stringBuilder.toString();  
     
203.     }  
     

复制代码

信计19-2胡莘梅

RSAEncrypt.java 引用包：

1. import java.io.BufferedReader;  
   
2. import java.io.BufferedWriter;  
   
3. import java.io.FileReader;  
   
4. import java.io.FileWriter;  
   
5. import java.io.IOException;  
   
6. import java.security.InvalidKeyException;  
   
7. import java.security.KeyFactory;  
   
8. import java.security.KeyPair;  
   
9. import java.security.KeyPairGenerator;  
   
10. import java.security.NoSuchAlgorithmException;  
    
11. import java.security.SecureRandom;  
    
12.    
    
13. import java.security.interfaces.RSAPrivateKey;  
    
14. import java.security.interfaces.RSAPublicKey;  
    
15. import java.security.spec.InvalidKeySpecException;  
    
16. import java.security.spec.PKCS8EncodedKeySpec;  
    
17. import java.security.spec.X509EncodedKeySpec;  
    
18.    
    
19. import javax.crypto.BadPaddingException;  
    
20. import javax.crypto.Cipher;  
    
21. import javax.crypto.IllegalBlockSizeException;  
    
22. import javax.crypto.NoSuchPaddingException;

复制代码

（2）RSASignature.java

1. package mmxzy;
   
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. public class RSASignature{  
   
10.     public static final String SIGN_ALGORITHMS = "SHA1WithRSA";  
    
11.     public static String sign(String content, String privateKey, String encode)  
    
12.     {  
    
13.         try   
    
14.         {  
    
15.             PKCS8EncodedKeySpec priPKCS8    = new PKCS8EncodedKeySpec( Base64.decode(privateKey) );  
    
16.             KeyFactory keyf                 = KeyFactory.getInstance("RSA");  
    
17.             PrivateKey priKey               = keyf.generatePrivate(priPKCS8);  
    
18.             java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);  
    
19.             signature.initSign(priKey);  
    
20.             signature.update( content.getBytes(encode));  
    
21.             byte[] signed = signature.sign();
    
22.             return Base64.encode(signed);  
    
23.         }  
    
24.         catch (Exception e)   
    
25.         {  
    
26.             e.printStackTrace();  
    
27.         }  
    
28.         return null;  
    
29.     }  
    
30.     public static String sign(String content, String privateKey)  
    
31.     {  
    
32.         try   
    
33.         {  
    
34.             PKCS8EncodedKeySpec priPKCS8    = new PKCS8EncodedKeySpec( Base64.decode(privateKey) );   
    
35.             KeyFactory keyf = KeyFactory.getInstance("RSA");  
    
36.             PrivateKey priKey = keyf.generatePrivate(priPKCS8);  
    
37.             java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);  
    
38.             signature.initSign(priKey);  
    
39.             signature.update( content.getBytes());  
    
40.             byte[] signed = signature.sign();  
    
41.             return Base64.encode(signed);  
    
42.         }  
    
43.         catch (Exception e)   
    
44.         {  
    
45.             e.printStackTrace();  
    
46.         }  
    
47.         return null;  
    
48.     }  
    
49.     public static boolean doCheck(String content, String sign, String publicKey,String encode)  
    
50.     {  
    
51.         try   
    
52.         {  
    
53.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
    
54.             byte[] encodedKey = Base64.decode(publicKey);  
    
55.             PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));  
    
56.             java.security.Signature signature = java.security.Signature  
    
57.             .getInstance(SIGN_ALGORITHMS);  
    
58.             signature.initVerify(pubKey);  
    
59.             signature.update( content.getBytes(encode) );
    
60.             boolean bverify = signature.verify( Base64.decode(sign) );  
    
61.             return bverify;  
    
62.         }   
    
63.         catch (Exception e)   
    
64.         {  
    
65.             e.printStackTrace();  
    
66.         }  
    
67.         return false;  
    
68.     }  
    
69.     public static boolean doCheck(String content, String sign, String publicKey)  
    
70.     {  
    
71.         try   
    
72.         {  
    
73.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
    
74.             byte[] encodedKey = Base64.decode(publicKey);  
    
75.             PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));  
    
76.             java.security.Signature signature = java.security.Signature  
    
77.             .getInstance(SIGN_ALGORITHMS);  
    
78.             signature.initVerify(pubKey);  
    
79.             signature.update( content.getBytes() );  
    
80.             boolean bverify = signature.verify( Base64.decode(sign) );  
    
81.             return bverify;  
    
82.         }   
    
83.         catch (Exception e)   
    
84.         {
    
85.             e.printStackTrace();  
    
86.         }
    
87.         return false;  
    
88.     }  
    
89. }

复制代码

信计19-2胡莘梅

（3）Base64.java

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

复制代码

信计19-2胡莘梅

（4）MainTest.java

1. package mmxzy;
   
2. 
   
3. public class MainTest {  
   
4.     public static void main(String[] args) throws Exception {  
   
5.         String filepath="D:/tmp/";  
   
6.         RSAEncrypt.genKeyPair(filepath);
   
7.         System.out.println("--------------公钥加密私钥解密过程-------------------");  
   
8.         String plainText="2022年6月1日儿童节快乐";
   
9.         byte[] cipherData=RSAEncrypt.encrypt(RSAEncrypt.loadPublicKeyByStr(RSAEncrypt.loadPublicKeyByFile(filepath)),plainText.getBytes());  
   
10.         String cipher=Base64.encode(cipherData);  
    
11.         byte[] res=RSAEncrypt.decrypt(RSAEncrypt.loadPrivateKeyByStr(RSAEncrypt.loadPrivateKeyByFile(filepath)), Base64.decode(cipher));  
    
12.         String restr=new String(res);  
    
13.         System.out.println("原文："+plainText);  
    
14.         System.out.println("加密："+cipher);  
    
15.         System.out.println("解密："+restr);  
    
16.         System.out.println();  
    
17.         System.out.println("--------------私钥加密公钥解密过程-------------------");  
    
18.         plainText="2022年6月1日晚安";  
    
19.         cipherData=RSAEncrypt.encrypt(RSAEncrypt.loadPrivateKeyByStr(RSAEncrypt.loadPrivateKeyByFile(filepath)),plainText.getBytes());  
    
20.         cipher=Base64.encode(cipherData);  
    
21.         res=RSAEncrypt.decrypt(RSAEncrypt.loadPublicKeyByStr(RSAEncrypt.loadPublicKeyByFile(filepath)), Base64.decode(cipher));  
    
22.         restr=new String(res);  
    
23.         System.out.println("原文："+plainText);  
    
24.         System.out.println("加密："+cipher);  
    
25.         System.out.println("解密："+restr);  
    
26.         System.out.println();  
    
27.         System.out.println("---------------私钥签名过程------------------");  
    
28.         String content="2022年6月1日写作业";  
    
29.         String signstr=RSASignature.sign(content,RSAEncrypt.loadPrivateKeyByFile(filepath));  
    
30.         System.out.println("签名原串："+content);  
    
31.         System.out.println("签名串："+signstr);  
    
32.         System.out.println();  
    
33.         System.out.println("---------------公钥校验签名------------------");  
    
34.         System.out.println("签名原串："+content);  
    
35.         System.out.println("签名串："+signstr);
    
36.         System.out.println("验签结果："+RSASignature.doCheck(content, signstr, RSAEncrypt.loadPublicKeyByFile(filepath)));  
    
37.         System.out.println();  
    
38.            
    
39.     }  
    
40. }

复制代码

信计19-2胡莘梅

ECC椭圆曲线加密

一、关于ECC
ECC是Elliptic Curve Cryptography（椭圆曲线密码学）的缩写，是一种基于椭圆曲线数学的公开密钥加密算法，其本质是利用离散对数问题实现加密。
ECC的主要优势，是在使用更小的密钥的同时，提供更快的性能和更高等级的安全。
二、关于椭圆曲线
一条椭圆曲线就是一组被 y2 = x3 + ax + b 定义的且满足 4a3 + 27b2 ≠ 0 的点集。
4a3 + 27b2 ≠ 0 这个限定条件是为了保证曲线不包含奇点（在数学中是指曲线上任意一点都存在切线）。
三、加解密过程
　　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都是非常困难的，因此得以保证数据传输的安全。
四、运行截图

信计19-2胡莘梅

五、源代码

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. 
   
8. typedef struct point{
   
9.         int point_x;
   
10.         int point_y;
    
11. }Point;
    
12. typedef struct ecc{
    
13.         struct point p[MAX];
    
14.         int len;
    
15. }ECCPoint;
    
16. typedef struct generator{
    
17.         Point p;
    
18.         int p_class;
    
19. }GENE_SET;
    
20. 
    
21. void get_all_points();
    
22. int int_sqrt(int s);
    
23. Point timesPiont(int k,Point p);
    
24. Point add_two_points(Point p1,Point p2);
    
25. int inverse(int n,int b);
    
26. void get_generetor_class();
    
27. void encrypt_ecc();
    
28. void decrypt_ecc();
    
29. int mod_p(int s);
    
30. void print();
    
31. int isPrime(int n);
    
32. char alphabet[26]="abcdefghijklmnopqrstuvwxyz";
    
33. int a=-1,b=0,p=89;
    
34. ECCPoint eccPoint;
    
35. GENE_SET geneSet[MAX];
    
36. int geneLen;
    
37. char plain[]="yes";
    
38. int m[MAX];
    
39. int cipher[MAX];
    
40. int nB;
    
41. Point P1,P2,Pt,G,PB;
    
42. Point Pm;
    
43. int C[MAX];
    
44. int main()
    
45. {       
    
46.         get_generetor_class();
    
47.         encrypt_ecc();
    
48.         decrypt_ecc();
    
49.         return 0;
    
50. }
    
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.         for(i=0;i<strlen(plain);i++)
    
59.         {
    
60.                 for(j=0;j<26;j++)
    
61.                 {
    
62.                         if(plain[i]==alphabet[j])
    
63.                         {
    
64.                                 m[i]=j;
    
65.                         }
    
66.                 }         
    
67.         }
    
68.         num=rand()%geneLen;
    
69.         gene_class=geneSet[num].p_class;
    
70.         while(isPrime(gene_class)==-1)
    
71.         {
    
72.                  num=rand()%(geneLen-3)+3;
    
73.                  gene_class=geneSet[num].p_class;
    
74.         }
    
75.         G=geneSet[num].p;
    
76.         nB=rand()%(gene_class-1)+1;
    
77.         PB=timesPiont(nB,G);
    
78.         printf("\n公钥：\n");
    
79.         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);
    
80.         printf("私钥：\n");
    
81.         printf("nB=%d\n",nB);
    
82.         k=rand()%(gene_class-2)+1;
    
83.         P1=timesPiont(k,G);
    
84.         num_t=rand()%eccPoint.len;
    
85.         Pt=eccPoint.p[num_t];
    
86.         P2=timesPiont(k,PB);
    
87.         Pm=add_two_points(Pt,P2);
    
88.         printf("加密数据：\n");
    
89.         printf("kG=(%d,%d),Pt+kPB=(%d,%d),C={",P1.point_x,P1.point_y,Pm.point_x,Pm.point_y);
    
90.         for(i=0;i<strlen(plain);i++)
    
91.         {
    
92.                 C[i]=m[i]*Pt.point_x+Pt.point_y;
    
93.                 printf("{%d}",C[i]);
    
94.         }       
    
95.         printf("}\n");
    
96. }
    
97. void decrypt_ecc()
    
98. {
    
99.         Point temp,temp1;
    
100.         int m,i;
     
101.         temp=timesPiont(nB,P1);
     
102.         temp.point_y=0-temp.point_y;
     
103.         temp1=add_two_points(Pm,temp);
     
104.         printf("\n解密结果：\n");
     
105.         for(i=0;i<strlen(plain);i++)
     
106.         {
     
107.                 m=(C[i]-temp1.point_y)/temp1.point_x;
     
108.                 printf("%c",alphabet[m]);
     
109.         }
     
110.         printf("\n");
     
111. }
     
112. int isPrime(int n)
     
113. {
     
114.         int i,k;
     
115.     k = sqrt(n);
     
116.     for (i = 2; i <= k;i++)
     
117.     {
     
118.             if (n%i == 0)
     
119.                         break;
     
120.         }      
     
121.     if (i <=k){
     
122.             return -1;
     
123.         }
     
124.     else {
     
125.              return 0;
     
126.         }
     
127. }
     
128. void get_generetor_class()
     
129. {       
     
130.         int i,j=0;
     
131.         int count=1;
     
132.         Point p1,p2;
     
133.         get_all_points();
     
134.         printf("\n**********************************输出生成元以及阶：*************************************\n");
     
135.         for(i=0;i<eccPoint.len;i++)
     
136.         {
     
137.                 count=1;
     
138.                 p1.point_x=p2.point_x=eccPoint.p[i].point_x;
     
139.                 p1.point_y=p2.point_y=eccPoint.p[i].point_y;               
     
140.                 while(1)
     
141.                 {       
     
142.                         p2=add_two_points(p1,p2);                                       
     
143.                         if(p2.point_x==-1 && p2.point_y==-1)
     
144.                         {
     
145.                                 break;
     
146.                         }
     
147.                         count++;
     
148.                         if(p2.point_x==p1.point_x)
     
149.                         {
     
150.                                 break;
     
151.                         }                                               
     
152.                 }
     
153.                 count++;
     
154.                 if(count<=eccPoint.len+1)
     
155.                 {
     
156.                         geneSet[j].p.point_x=p1.point_x;
     
157.                         geneSet[j].p.point_y=p1.point_y;
     
158.                         geneSet[j].p_class=count;
     
159.                         printf("(%d,%d)--->>%d\t",geneSet[j].p.point_x,geneSet[j].p.point_y,geneSet[j].p_class);
     
160.                         j++;
     
161.                         if(j % 6 ==0){
     
162.                                 printf("\n");
     
163.                         }
     
164.                 }
     
165.                 geneLen=j;       
     
166.         }
     
167. }
     
168. Point timesPiont(int k,Point p0)
     
169. {
     
170.         if(k==1){
     
171.                 return p0;
     
172.         }                
     
173.         else if(k==2){
     
174.                 return add_two_points(p0,p0);
     
175.         }else{
     
176.                 return add_two_points(p0,timesPiont(k-1,p0));
     
177.         }
     
178. }
     
179. Point add_two_points(Point p1,Point p2)
     
180. {
     
181.         long t;
     
182.         int x1=p1.point_x;
     
183.         int y1=p1.point_y;
     
184.         int x2=p2.point_x;
     
185.         int y2=p2.point_y;
     
186.         int tx,ty;
     
187.         int x3,y3;
     
188.         int flag=0;
     
189.         if((x2==x1)&& (y2==y1) )
     
190.         {
     
191.                 if(y1==0)
     
192.                 {
     
193.                         flag=1;
     
194.                 }else{
     
195.                         t=(3*x1*x1+a)*inverse(p,2*y1) % p;
     
196.                 }
     
197.         }else{
     
198.                 ty=y2-y1;
     
199.                 tx=x2-x1;
     
200.                 while(ty<0)
     
201.                 {
     
202.                         ty+=p;
     
203.                 }
     
204.                 while(tx<0)
     
205.                 {
     
206.                         tx+=p;
     
207.                 }
     
208.                 if(tx==0 && ty !=0)
     
209.                 {
     
210.                         flag=1;
     
211.                 }else{
     
212.                         t=ty*inverse(p,tx) % p;
     
213.                 }
     
214.         }
     
215.         if(flag==1)
     
216.         {
     
217.                 p2.point_x=-1;
     
218.                 p2.point_y=-1;
     
219.         }else{
     
220.                 x3=(t*t-x1-x2) % p;
     
221.                 y3=(t*(x1-x3)-y1) % p;
     
222.                 while(x3<0)
     
223.                 {
     
224.                         x3+=p;
     
225.                 }
     
226.                 while(y3<0)
     
227.                 {
     
228.                         y3+=p;
     
229.                 }
     
230.                 p2.point_x=x3;
     
231.                 p2.point_y=y3;
     
232.         }       
     
233.         return p2;
     
234. }
     
235. int inverse(int n,int b)
     
236. {
     
237.         int q,r,r1=n,r2=b,t,t1=0,t2=1,i=1;
     
238.         while(r2>0)
     
239.         {
     
240.                 q=r1/r2;
     
241.                 r=r1%r2;
     
242.                 r1=r2;
     
243.                 r2=r;
     
244.                 t=t1-q*t2;
     
245.                 t1=t2;
     
246.                 t2=t;
     
247.         }
     
248.         if(t1>=0)
     
249.                 return t1%n;
     
250.         else{  
     
251.                 while((t1+i*n)<0)
     
252.                         i++;
     
253.                 return t1+i*n;
     
254.         }
     
255. }
     
256. void get_all_points()
     
257. {
     
258.         int i=0;
     
259.         int j=0;
     
260.         int s,y=0;
     
261.         int n=0,q=0;
     
262.         int modsqrt=0;
     
263.         int flag=0;
     
264.         if (4 * a * a * a + 27 * b * b != 0)
     
265.         {
     
266.                 for(i=0;i<=p-1;i++)
     
267.                 {
     
268.                         flag=0;
     
269.                         n=1;
     
270.                         y=0;
     
271.                         s= i * i * i + a * i + b;
     
272.                         while(s<0)
     
273.                         {
     
274.                                 s+=p;
     
275.                         }
     
276.                         s=mod_p(s);
     
277.                         modsqrt=int_sqrt(s);
     
278.                         if(modsqrt!=-1)
     
279.                         {
     
280.                                 flag=1;
     
281.                                 y=modsqrt;
     
282.                         }else{
     
283.                                 while(n<=p-1)
     
284.                                 {
     
285.                                         q=s+n*p;
     
286.                                         modsqrt=int_sqrt(q);
     
287.                                         if(modsqrt!=-1)
     
288.                                         {
     
289.                                                 y=modsqrt;
     
290.                                                 flag=1;
     
291.                                                 break;
     
292.                                         }
     
293.                                                 flag=0;
     
294.                                                 n++;
     
295.                                 }
     
296.                         }
     
297.                         if(flag==1)
     
298.                         {
     
299.                                 eccPoint.p[j].point_x=i;
     
300.                                 eccPoint.p[j].point_y=y;
     
301.                                 j++;
     
302.                                 if(y!=0)
     
303.                                 {
     
304.                                         eccPoint.p[j].point_x=i;
     
305.                                         eccPoint.p[j].point_y=(p-y) % p;
     
306.                                         j++;
     
307.                                 }                               
     
308.                         }
     
309.                 }
     
310.                 eccPoint.len=j;
     
311.                 print();
     
312.         }       
     
313. }
     
314. int mod_p(int s)
     
315. {
     
316.         int i;
     
317.         int result;
     
318.         i = s / p;
     
319.         result = s - i * p;
     
320.         if (result >= 0)
     
321.         {
     
322.                 return result;
     
323.         }
     
324.         else
     
325.         {
     
326.                 return result + p;
     
327.         }
     
328. }
     
329. 
     
330. int int_sqrt(int s)
     
331. {
     
332.         int temp;
     
333.         temp=(int)sqrt(s);
     
334.         if(temp*temp==s)
     
335.         {
     
336.                 return temp;
     
337.         }else{
     
338.                 return -1;
     
339.         }
     
340. }
     
341. void print()
     
342. {
     
343.         int i;
     
344.         int len=eccPoint.len;
     
345.         printf("\n该椭圆曲线上共有%d个点(包含无穷远点)\n",len+1);
     
346.         for(i=0;i<len;i++)
     
347.         {
     
348.                 if(i % 8==0)
     
349.                 {
     
350.                         printf("\n");
     
351.                 }
     
352.                 printf("(%2d,%2d)\t",eccPoint.p[i].point_x,eccPoint.p[i].point_y);
     
353.         }
     
354.         printf("\n");
     
355. }

复制代码