信息计算2019级1班18号冯雨

冯雨

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

1. import javax.crypto.Cipher;
   
2. import java.security.KeyFactory;
   
3. import java.security.KeyPair;
   
4. import java.security.KeyPairGenerator;
   
5. import java.security.NoSuchAlgorithmException;
   
6. import java.security.PrivateKey;
   
7. import java.security.PublicKey;
   
8. import java.security.SecureRandom;
   
9. import java.security.Signature;
   
10. import java.security.interfaces.RSAPrivateKey;
    
11. import java.security.interfaces.RSAPublicKey;
    
12. import java.security.spec.PKCS8EncodedKeySpec;
    
13. import java.security.spec.X509EncodedKeySpec;
    
14. import java.util.Base64;
    
15. import java.util.HashMap;
    
16. import java.util.Map;
    
17. 
    
18. public class test14 {
    
19.         private static Map<Integer, String> keyMap = new HashMap<Integer, String>();  //用于封装随机产生的公钥与私钥
    
20.         public static void main(String[] args) throws Exception {
    
21.                 //生成公钥和私钥
    
22.                 genKeyPair();
    
23.                 //加密字符串
    
24.                 String message = "df723820";
    
25.                 System.out.println("随机生成的公钥为:" + keyMap.get(0));
    
26.                 System.out.println("随机生成的私钥为:" + keyMap.get(1));
    
27.                 String messageEn = encrypt(message,keyMap.get(0));
    
28.                 System.out.println(message + "\t加密后的字符串为:" + messageEn);
    
29.                 String messageDe = decrypt(messageEn,keyMap.get(1));
    
30.                 System.out.println("还原后的字符串为:" + messageDe);
    
31.                 System.err.println("私钥签名——公钥验证签名");
    
32.         String sign = RSAUtils.sign(encodedData, privateKey);
    
33.         System.err.println("签名:\r" + sign);
    
34.         }
    
35. 
    
36.         /**
    
37.          * 随机生成密钥对
    
38.          * @throws NoSuchAlgorithmException
    
39.          */  
    
40.         public static void genKeyPair() throws NoSuchAlgorithmException {  
    
41.                 // KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象  
    
42.                 KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");  
    
43.                 // 初始化密钥对生成器，密钥大小为96-1024位  
    
44.                 keyPairGen.initialize(1024,new SecureRandom());  
    
45.                 // 生成一个密钥对，保存在keyPair中  
    
46.                 KeyPair keyPair = keyPairGen.generateKeyPair();  
    
47.                 RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();   // 得到私钥  
    
48.                 RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();  // 得到公钥  
    
49.                 String publicKeyString = new String(Base64.getEncoder().encode(publicKey.getEncoded()));  
    
50.                 // 得到私钥字符串  
    
51.                 String privateKeyString = new String(Base64.getEncoder().encode((privateKey.getEncoded())));  
    
52.                 // 将公钥和私钥保存到Map
    
53.                 keyMap.put(0,publicKeyString);  //0表示公钥
    
54.                 keyMap.put(1,privateKeyString);  //1表示私钥
    
55.         }  
    
56.         /**
    
57.          * RSA公钥加密
    
58.          *  
    
59.          * @param str
    
60.          *            加密字符串
    
61.          * @param publicKey
    
62.          *            公钥
    
63.          * @return 密文
    
64.          * @throws Exception
    
65.          *             加密过程中的异常信息
    
66.          */  
    
67.         public static String encrypt( String str, String publicKey ) throws Exception{
    
68.                 //base64编码的公钥
    
69.                 byte[] decoded = Base64.getDecoder().decode(publicKey);
    
70.                 RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(decoded));
    
71.                 //RSA加密
    
72.                 Cipher cipher = Cipher.getInstance("RSA");
    
73.                 cipher.init(Cipher.ENCRYPT_MODE, pubKey);
    
74.                 String outStr = Base64.getEncoder().encodeToString(cipher.doFinal(str.getBytes("UTF-8")));
    
75.                 return outStr;
    
76.         }
    
77. 
    
78.         /**
    
79.          * RSA私钥解密
    
80.          *  
    
81.          * @param str
    
82.          *            加密字符串
    
83.          * @param privateKey
    
84.          *            私钥
    
85.          * @return 铭文
    
86.          * @throws Exception
    
87.          *             解密过程中的异常信息
    
88.          */  
    
89.         public static String decrypt(String str, String privateKey) throws Exception{
    
90.                 //64位解码加密后的字符串
    
91.                 byte[] inputByte = Base64.getDecoder().decode(str.getBytes("UTF-8"));
    
92.                 //base64编码的私钥
    
93.                 byte[] decoded = Base64.getDecoder().decode(privateKey);  
    
94.        RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(decoded));  
    
95.                 //RSA解密
    
96.                 Cipher cipher = Cipher.getInstance("RSA");
    
97.                 cipher.init(Cipher.DECRYPT_MODE, priKey);
    
98.                 String outStr = new String(cipher.doFinal(inputByte));
    
99.                 return outStr;
    
100.         }
     
101.           public static final String KEY_ALGORITHM = "RSA";
     
102.          /**
     
103.      * 签名算法
     
104.      */
     
105.     public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
     
106.     /**
     
107.      * <p>
     
108.      * 用私钥对信息生成数字签名
     
109.      * </p>
     
110.      *
     
111.      * @param data 已加密数据
     
112.      * @param privateKey 私钥(BASE64编码)
     
113.      *
     
114.      * @return
     
115.      * @throws Exception
     
116.      */
     
117.     public static String sign(byte[] data, String privateKey) throws Exception {
     
118.         byte[] keyBytes = Base641.decode(privateKey);
     
119.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
     
120.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
     
121.         PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
     
122.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
     
123.         signature.initSign(privateK);
     
124.         signature.update(data);
     
125.         return Base641.encode(signature.sign());
     
126.     }
     
127. 
     
128.     /**
     
129.      * <p>
     
130.      * 校验数字签名
     
131.      * </p>
     
132.      *
     
133.      * @param data 已加密数据
     
134.      * @param publicKey 公钥(BASE64编码)
     
135.      * @param sign 数字签名
     
136.      *
     
137.      * @return
     
138.      * @throws Exception
     
139.      *
     
140.      */
     
141.     public static boolean verify(byte[] data, String publicKey, String sign)
     
142.             throws Exception {
     
143.         byte[] keyBytes = Base641.decode(publicKey);
     
144.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
     
145.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
     
146.         PublicKey publicK = keyFactory.generatePublic(keySpec);
     
147.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
     
148.         signature.initVerify(publicK);
     
149.         signature.update(data);
     
150.         return signature.verify(Base641.decode(sign));
     
151.     }
     
152. 
     
153. }

复制代码

冯雨

                                                                                                                           

1. import java.math.BigInteger;  
   
2. import java.security.Key;  
   
3. import java.security.KeyFactory;  
   
4. import java.security.interfaces.ECPrivateKey;  
   
5. import java.security.interfaces.ECPublicKey;  
   
6. import java.security.spec.ECFieldF2m;  
   
7. import java.security.spec.ECParameterSpec;  
   
8. import java.security.spec.ECPoint;  
   
9. import java.security.spec.ECPrivateKeySpec;  
   
10. import java.security.spec.ECPublicKeySpec;  
    
11. import java.security.spec.EllipticCurve;  
    
12. import java.security.spec.PKCS8EncodedKeySpec;  
    
13. import java.security.spec.X509EncodedKeySpec;  
    
14. import java.util.HashMap;  
    
15. import java.util.Map;  
    
16.   
    
17. import javax.crypto.Cipher;  
    
18. import javax.crypto.NullCipher;  
    
19.   
    
20. import sun.security.ec.ECKeyFactory;  
    
21. import sun.security.ec.ECPrivateKeyImpl;  
    
22. import sun.security.ec.ECPublicKeyImpl;  
    
23.   
    
24. 
    
25. public abstract class test13 extends Coder {  
    
26.   
    
27.     public static final String ALGORITHM = "EC";  
    
28.     private static final String PUBLIC_KEY = "ECCPublicKey";  
    
29.     private static final String PRIVATE_KEY = "ECCPrivateKey";  
    
30.   
    
31.     /**
    
32.      * 解密<br>
    
33.      * 用私钥解密
    
34.      *  
    
35.      * @param data
    
36.      * @param key
    
37.      * @return
    
38.      * @throws Exception
    
39.      */  
    
40.     public static byte[] decrypt(byte[] data, String key) throws Exception {  
    
41.         // 对密钥解密  
    
42.         byte[] keyBytes = decryptBASE64(key);  
    
43.   
    
44.         // 取得私钥  
    
45.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  
    
46.         KeyFactory keyFactory = ECKeyFactory.INSTANCE;  
    
47.   
    
48.         ECPrivateKey priKey = (ECPrivateKey) keyFactory  
    
49.                 .generatePrivate(pkcs8KeySpec);  
    
50.   
    
51.         ECPrivateKeySpec ecPrivateKeySpec = new ECPrivateKeySpec(priKey.getS(),  
    
52.                 priKey.getParams());  
    
53.   
    
54.         // 对数据解密  
    
55.         // TODO Chipher不支持EC算法 未能实现  
    
56.         Cipher cipher = new NullCipher();  
    
57.         // Cipher.getInstance(ALGORITHM, keyFactory.getProvider());  
    
58.         cipher.init(Cipher.DECRYPT_MODE, priKey, ecPrivateKeySpec.getParams());  
    
59.   
    
60.         return cipher.doFinal(data);  
    
61.     }  
    
62.   
    
63.     /**
    
64.      * 加密<br>
    
65.      * 用公钥加密
    
66.      *  
    
67.      * @param data
    
68.      * @param privateKey
    
69.      * @return
    
70.      * @throws Exception
    
71.      */  
    
72.     public static byte[] encrypt(byte[] data, String privateKey)  
    
73.             throws Exception {  
    
74.         // 对公钥解密  
    
75.         byte[] keyBytes = decryptBASE64(privateKey);  
    
76.   
    
77.         // 取得公钥  
    
78.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);  
    
79.         KeyFactory keyFactory = ECKeyFactory.INSTANCE;  
    
80.   
    
81.         ECPublicKey pubKey = (ECPublicKey) keyFactory  
    
82.                 .generatePublic(x509KeySpec);  
    
83.   
    
84.         ECPublicKeySpec ecPublicKeySpec = new ECPublicKeySpec(pubKey.getW(),  
    
85.                 pubKey.getParams());  
    
86.   
    
87.         // 对数据加密  
    
88.         // TODO Chipher不支持EC算法 未能实现  
    
89.         Cipher cipher = new NullCipher();  
    
90.         // Cipher.getInstance(ALGORITHM, keyFactory.getProvider());  
    
91.         cipher.init(Cipher.ENCRYPT_MODE, pubKey, ecPublicKeySpec.getParams());  
    
92.   
    
93.         return cipher.doFinal(data);  
    
94.     }  
    
95.   
    
96.     /**
    
97.      * 取得私钥
    
98.      *  
    
99.      * @param keyMap
    
100.      * @return
     
101.      * @throws Exception
     
102.      */  
     
103.     public static String getPrivateKey(Map<String, Object> keyMap)  
     
104.             throws Exception {  
     
105.         Key key = (Key) keyMap.get(PRIVATE_KEY);  
     
106.   
     
107.         return encryptBASE64(key.getEncoded());  
     
108.     }  
     
109.   
     
110.     /**
     
111.      * 取得公钥
     
112.      *  
     
113.      * @param keyMap
     
114.      * @return
     
115.      * @throws Exception
     
116.      */  
     
117.     public static String getPublicKey(Map<String, Object> keyMap)  
     
118.             throws Exception {  
     
119.         Key key = (Key) keyMap.get(PUBLIC_KEY);  
     
120.   
     
121.         return encryptBASE64(key.getEncoded());  
     
122.     }  
     
123.   
     
124.     /**
     
125.      * 初始化密钥
     
126.      *  
     
127.      * @return
     
128.      * @throws Exception
     
129.      */  
     
130.     public static Map<String, Object> initKey() throws Exception {  
     
131.         BigInteger x1 = new BigInteger(  
     
132.                 "2fe13c0537bbc11acaa07d793de4e6d5e5c94eee8", 16);  
     
133.         BigInteger x2 = new BigInteger(  
     
134.                 "289070fb05d38ff58321f2e800536d538ccdaa3d9", 16);  
     
135.   
     
136.         ECPoint g = new ECPoint(x1, x2);  
     
137.   
     
138.         // the order of generator  
     
139.         BigInteger n = new BigInteger(  
     
140.                 "584600654932361167281474175359844834832911063", 10);  
     
141.         // the cofactor  
     
142.         int h = 2;  
     
143.         int m = 163;  
     
144.         int[] ks = { 7, 6, 3 };  
     
145.         ECFieldF2m ecField = new ECFieldF2m(m, ks);  
     
146.         // y^2+xy=x^3+x^2+1  
     
147.         BigInteger a = new BigInteger("1", 2);  
     
148.         BigInteger b = new BigInteger("1", 2);  
     
149.   
     
150.         EllipticCurve ellipticCurve = new EllipticCurve(ecField, a, b);  
     
151.   
     
152.         ECParameterSpec ecParameterSpec = new ECParameterSpec(ellipticCurve, g,  
     
153.                 n, h);  
     
154.         // 公钥  
     
155.         ECPublicKey publicKey = new ECPublicKeyImpl(g, ecParameterSpec);  
     
156.   
     
157.         BigInteger s = new BigInteger(  
     
158.                 "123400654932361167281474175359844834832914063", 10);  
     
159.         // 私钥  
     
160.         ECPrivateKey privateKey = new ECPrivateKeyImpl(s, ecParameterSpec);  
     
161.   
     
162.         Map<String, Object> keyMap = new HashMap<String, Object>(2);  
     
163.   
     
164.         keyMap.put(PUBLIC_KEY, publicKey);  
     
165.         keyMap.put(PRIVATE_KEY, privateKey);  
     
166.   
     
167.         return keyMap;  
     
168.     }  
     
169.   
     
170. }  
     

复制代码

ECC椭圆曲线加解密