【Java】常用加密技术与代码研究总结

总结类文章，把一些常用的Java加密技术和核心代码写在这边，供参考。

首先大家要记住现代密码学最重要的原则柯克霍夫原则：数据的安全基于密钥而不是算法的保密。也就是说即使密码系统的任何细节已为人悉知，只要密匙未洩漏，它也应是安全的。

具体来说：
系统必须可用，非数学上不可译码。
系统不一定要保密，可以轻易落入敌人手中。
密匙必须可以不经书写的资料交换和记忆，且双方可以改变密匙。
系统可以用于电讯。
系统可以转移位置，它的功能必须不用经过几个人之手才可达到。
系统容易使用，不要求使用者的脑力过份操劳或有很多的规则。

一、主要的加密方式代码提供方

JDK：代码在java安装目录下的jre\lib\jce.jar包里;
CC：Apache公司提供的org.apache.commons.codec
主页： http://commons.apache.org/proper/commons-codec/
BC：org.bouncecastle
主页： http://www.bouncycastle.org/java.html
基本常用的使用JDK就够了。

二、Base64算法

1、从现在加密算法的复杂性来看Base64这种都不好意思说自己是加密，不过对于完全不懂计算机的人来说也够用了。采用Base64编码具有不可读性，即所编码的数据不会被人用肉眼所直接看到。
Base64编码一般用于url的处理，或者说任何你不想让普通人一眼就知道是啥的东西都可以用Base64编码处理后再发布在网络上。

[java] view plain copy

 

1. import java.util.Base64;  
2.   
3. import com.amuro.strategy.IStrategy;  
4.   
5. /** 
6.  * Base64算法基于64个基本字符，加密后的string中只包含这64个字符 
7.  * @author Amuro 
8.  * 
9.  */  
10. public class Base64Strategy implements IStrategy  
11. {  
12.     public String encode(String src)  
13.     {  
14.         byte[] encodeBytes = Base64.getEncoder().encode(src.getBytes());  
15.         return new String(encodeBytes);  
16.     }  
17.   
18.     public String decode(String src)  
19.     {  
20.         byte[] decodeBytes = Base64.getDecoder().decode(src.getBytes());  
21.         return new String(decodeBytes);  
22.     }  
23. }  

2、Base64编码对应关系表

三、消息摘要算法（Message Digest）

消息摘要（Message Digest）又称为数字摘要(Digital Digest)。它是一个唯一对应一个消息或文本的固定长度的值，它由一个单向Hash加密函数对消息进行作用而产生。HASH函数的抗冲突性使得如果一段明文稍有变化，哪怕只更改该段落的一个字母，通过哈希算法作用后都将产生不同的值。而HASH算法的单向性使得要找到哈希值相同的两个不同的输入消息，在计算上是不可能的。所以数据的哈希值，即消息摘要，可以检验数据的完整性。
用大白话来说，任何一段数据应该都和人一样是唯一的，唯一的标识是什么，人类的话目前就是指纹，而数据的指纹是什么呢？没错，就是消息摘要算法产生的这一段String。比如我们在注册网站的时候，客户端向服务器传输的，应该是我们输入的密码进行消息摘要处理后的内容，这样就算服务器被攻破，Hack也无法知道用户真实的密码是什么。不过有说现在MD5和SHA已经被攻破了，具体大家可以谷歌。
1、MD5

[java] view plain copy

 

1. import java.security.MessageDigest;  
2. import java.security.NoSuchAlgorithmException;  
3.   
4. import org.apache.commons.codec.binary.Hex;  
5.   
6. import com.amuro.strategy.IStrategy;  
7.   
8. /** 
9.  * 消息摘要算法 
10.  * @author Amuro 
11.  * 
12.  */  
13. public class MD5Strategy implements IStrategy  
14. {  
15.   
16.     public String encode(String src)  
17.     {  
18.         try  
19.         {  
20.             MessageDigest md = MessageDigest.getInstance("MD5");  
21.             byte[] encodeBytes = md.digest(src.getBytes());  
22.   
23.             return Hex.encodeHexString(encodeBytes);  
24.         }  
25.         catch (NoSuchAlgorithmException e)  
26.         {  
27.             e.printStackTrace();  
28.         }  
29.         return null;  
30.     }  
31.   
32.     public String decode(String src)  
33.     {  
34.         throw new RuntimeException("MD5 no decode");  
35.     }  
36.   
37. }  

2、SHA

[java] view plain copy

 

1. import java.security.MessageDigest;  
2. import java.security.NoSuchAlgorithmException;  
3.   
4. import org.apache.commons.codec.binary.Hex;  
5.   
6. import com.amuro.strategy.IStrategy;  
7.   
8. /** 
9.  * 安全散列算法 
10.  * @author Amuro 
11.  * 
12.  */  
13. public class SHAStrategy implements IStrategy  
14. {  
15.   
16.     public String encode(String src)  
17.     {  
18.         try  
19.         {  
20.             MessageDigest md = MessageDigest.getInstance("SHA");  
21.             md.update(src.getBytes());  
22.             return Hex.encodeHexString(md.digest());  
23.         }  
24.         catch (NoSuchAlgorithmException e)  
25.         {  
26.             e.printStackTrace();  
27.         }  
28.         return null;  
29.     }  
30.   
31.     public String decode(String src)  
32.     {  
33.         throw new RuntimeException("SHA no decode");  
34.     }  
35.   
36. }  

四、对称加密

采用单钥密码系统的加密方法，同一个密钥可以同时用作信息的加密和解密，这种加密方法称为对称加密，也称为单密钥加密。而因为加密和解密都使用同一个密钥，如何把密钥安全地传递到解密者手上就成了必须要解决的问题。当然，安全性较低带来的优点就是优计算量小、加密速度快、加密效率高。
然并卵，现代计算机对这种级别的计算量早就不care了，安全才是最重要的。
1、DES
DES，全称为“Data Encryption Standard”，中文名为“数据加密标准”，是一种使用密钥加密的块算法。DES 算法为密码体制中的对称密码体制，又被称为美国数据加密标准，是 1972 年美国 IBM 公司研制的对称密码体制加密算法。 明文按 64 位进行分组，密钥长 64 位，密钥事实上是 56 位参与 DES 运算（第8、16、24、32、40、48、56、64 位是校验位， 使得每个密钥都有奇数个 1）分组后的明文组和 56 位的密钥按位替代或交换的方法形成密文组的加密方法。

[java] view plain copy

 

1. import javax.crypto.Cipher;  
2. import javax.crypto.KeyGenerator;  
3. import javax.crypto.SecretKey;  
4. import javax.crypto.SecretKeyFactory;  
5. import javax.crypto.spec.DESKeySpec;  
6.   
7. import org.apache.commons.codec.binary.Hex;  
8.   
9. import com.amuro.strategy.IStrategy;  
10.   
11. /** 
12.  *  
13.  * @author Amuro 
14.  * 
15.  */  
16. public class DESStrategy implements IStrategy  
17. {  
18.     private Cipher cipher;  
19.     private SecretKey generateKey;  
20.   
21.     public String encode(String src)  
22.     {  
23.         try  
24.         {  
25.             KeyGenerator keyGenerator = KeyGenerator.getInstance("DES");  
26.             keyGenerator.init(56);//size  
27.             SecretKey secretKey = keyGenerator.generateKey();  
28.             byte[] keyBytes = secretKey.getEncoded();  
29.   
30.             DESKeySpec desKeySpec = new DESKeySpec(keyBytes);  
31.             SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DES");  
32.             generateKey = secretKeyFactory.generateSecret(desKeySpec);  
33.   
34.             cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");  
35.             cipher.init(Cipher.ENCRYPT_MODE, generateKey);  
36.             byte[] resultBytes = cipher.doFinal(src.getBytes());  
37.   
38.             return Hex.encodeHexString(resultBytes);  
39.         }  
40.         catch (Exception e)  
41.         {  
42.             e.printStackTrace();  
43.         }  
44.   
45.         return null;  
46.     }  
47.   
48.     public String decode(String src)  
49.     {  
50.         try  
51.         {  
52.             cipher.init(Cipher.DECRYPT_MODE, generateKey);  
53.             byte[] result = Hex.decodeHex(src.toCharArray());  
54.             return new String(cipher.doFinal(result));  
55.         }  
56.         catch(Exception e)  
57.         {  
58.             e.printStackTrace();  
59.         }  
60.   
61.         return null;  
62.     }  
63.   
64. }  

2、3DES3DES，也就是“Triple DES”，中文名“三重数据加密算法”，它相当于是对每个数据块应用三次 DES 加密算法。由于计算机运算能力的增强，原版 DES 密码的密钥长度变得容易被暴力破解；3DES 即是设计用来提供一种相对简单的方法，即通过增加 DES 的密钥长度来避免类似的攻击，而不是设计一种全新的块密码算法。

[java] view plain copy

 

1. import javax.crypto.Cipher;  
2. import javax.crypto.KeyGenerator;  
3. import javax.crypto.SecretKey;  
4. import javax.crypto.SecretKeyFactory;  
5. import javax.crypto.spec.DESedeKeySpec;  
6.   
7. import org.apache.commons.codec.binary.Hex;  
8.   
9. import com.amuro.strategy.IStrategy;  
10.   
11. public class _3DESStrategy implements IStrategy  
12. {  
13.     private Cipher cipher;  
14.     private SecretKey generateKey;  
15.   
16.     public String encode(String src)  
17.     {  
18.         try  
19.         {  
20.             KeyGenerator keyGenerator = KeyGenerator.getInstance("DESede");  
21.             keyGenerator.init(168);//size  
22.             SecretKey secretKey = keyGenerator.generateKey();  
23.             byte[] keyBytes = secretKey.getEncoded();  
24.   
25.             DESedeKeySpec desKeySpec = new DESedeKeySpec(keyBytes);  
26.             SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DESede");  
27.             generateKey = secretKeyFactory.generateSecret(desKeySpec);  
28.   
29.             cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");  
30.             cipher.init(Cipher.ENCRYPT_MODE, generateKey);  
31.             byte[] resultBytes = cipher.doFinal(src.getBytes());  
32.   
33.             return Hex.encodeHexString(resultBytes);  
34.         }  
35.         catch (Exception e)  
36.         {  
37.             e.printStackTrace();  
38.         }  
39.   
40.         return null;  
41.     }  
42.   
43.     public String decode(String src)  
44.     {  
45.         try  
46.         {  
47.             cipher.init(Cipher.DECRYPT_MODE, generateKey);  
48.             byte[] result = Hex.decodeHex(src.toCharArray());  
49.             return new String(cipher.doFinal(result));  
50.         }  
51.         catch(Exception e)  
52.         {  
53.             e.printStackTrace();  
54.         }  
55.   
56.         return null;  
57.     }  
58. }  

3、AESAES，全称为“Advanced Encryption Standard”，中文名“高级加密标准”，在密码学中又称 Rijndael 加密法，是美国联邦政府采用的一种区块加密标准。AES 加密算法作为新一代的数据加密标准汇聚了强安全性、高性能、高效率、易用和灵活等优点。AES 设计有三个密钥长度：128，192，256 位。相对而言，AES 的 128 密钥比 DES 的 56 密钥强了 1021 倍。

[java] view plain copy

 

1. import javax.crypto.Cipher;  
2. import javax.crypto.KeyGenerator;  
3. import javax.crypto.SecretKey;  
4. import javax.crypto.spec.SecretKeySpec;  
5.   
6. import org.apache.commons.codec.binary.Hex;  
7.   
8. import com.amuro.strategy.IStrategy;  
9.   
10. public class AESStrategy implements IStrategy  
11. {  
12.     private Cipher cipher;  
13.     private SecretKey generateKey;  
14.   
15.     public String encode(String src)  
16.     {  
17.         try  
18.         {  
19.             KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");  
20.             keyGenerator.init(128);//size  
21.             SecretKey secretKey = keyGenerator.generateKey();  
22.             byte[] keyBytes = secretKey.getEncoded();  
23.   
24.             generateKey = new SecretKeySpec(keyBytes, "AES");  
25.   
26.             cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");  
27.             cipher.init(Cipher.ENCRYPT_MODE, generateKey);  
28.             byte[] resultBytes = cipher.doFinal(src.getBytes());  
29.   
30.             return Hex.encodeHexString(resultBytes);  
31.         }  
32.         catch (Exception e)  
33.         {  
34.             e.printStackTrace();  
35.         }  
36.   
37.         return null;  
38.     }  
39.   
40.     public String decode(String src)  
41.     {  
42.         try  
43.         {  
44.             cipher.init(Cipher.DECRYPT_MODE, generateKey);  
45.             byte[] result = Hex.decodeHex(src.toCharArray());  
46.             return new String(cipher.doFinal(result));  
47.         }  
48.         catch(Exception e)  
49.         {  
50.             e.printStackTrace();  
51.         }  
52.   
53.         return null;  
54.     }  
55. }  

4、PBE
PBE，全称为“Password Base Encryption”，中文名“基于口令加密”，是一种基于密码的加密算法，其特点是使用口令代替了密钥，而口令由用户自己掌管，采用随机数杂凑多重加密等方法保证数据的安全性。
PBE算法没有密钥的概念，把口令当做密钥了。因为密钥长短影响算法安全性，还不方便记忆，这里我们直接换成我们自己常用的口令就大大不同了，便于我们的记忆。但是单纯的口令很容易被字典法给穷举出来，所以我们这里给口令加了点“盐”，这个盐和口令组合，想破解就难了。同时我们将盐和口令合并后用消息摘要算法进行迭代很多次来构建密钥初始化向量的基本材料，使破译更加难了。

[java] view plain copy

 

1. import java.security.SecureRandom;  
2.   
3. import javax.crypto.Cipher;  
4. import javax.crypto.SecretKey;  
5. import javax.crypto.SecretKeyFactory;  
6. import javax.crypto.spec.PBEKeySpec;  
7. import javax.crypto.spec.PBEParameterSpec;  
8.   
9. import org.apache.commons.codec.binary.Hex;  
10.   
11. import com.amuro.strategy.IStrategy;  
12.   
13. /** 
14.  * 基于口令的加密（password），对称 + 消息摘要 
15.  * @author Amuro 
16.  * 
17.  */  
18. public class PBEStrategy implements IStrategy  
19. {  
20.     private Cipher cipher;  
21.     private SecretKey generateKey;  
22.     private PBEParameterSpec pbeParameterSpec;  
23.   
24.     public String encode(String src)  
25.     {  
26.         try  
27.         {  
28.             SecureRandom secureRandom = new SecureRandom();  
29.             byte[] salt = secureRandom.generateSeed(8);  
30.   
31.             String password = "amuro";  
32.             PBEKeySpec pbeKeySpec = new PBEKeySpec(password.toCharArray());  
33.             SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("PBEWITHMD5andDES");  
34.             generateKey = secretKeyFactory.generateSecret(pbeKeySpec);  
35.   
36.             pbeParameterSpec = new PBEParameterSpec(salt, 100);  
37.             cipher = Cipher.getInstance("PBEWITHMD5andDES");  
38.             cipher.init(Cipher.ENCRYPT_MODE, generateKey, pbeParameterSpec);  
39.             byte[] resultBytes = cipher.doFinal(src.getBytes());  
40.             return Hex.encodeHexString(resultBytes);  
41.         }  
42.         catch(Exception e)  
43.         {  
44.             e.printStackTrace();  
45.         }  
46.   
47.         return null;  
48.     }  
49.   
50.     public String decode(String src)  
51.     {  
52.         try  
53.         {  
54.             cipher.init(Cipher.DECRYPT_MODE, generateKey, pbeParameterSpec);  
55.             byte[] result = Hex.decodeHex(src.toCharArray());  
56.             return new String(cipher.doFinal(result));  
57.         }  
58.         catch(Exception e)  
59.         {  
60.             e.printStackTrace();  
61.         }  
62.   
63.         return null;  
64.     }  
65.   
66. }  

五、非对称加密

非对称加密算法需要两个密钥来进行加密和解密，分别是公钥和私钥。需要注意的一点，这个公钥和私钥必须是一对的，如果用公钥对数据进行加密，那么只有使用对应的私钥才能解密，反之亦然。由于加密和解密使用的是两个不同的密钥，因此，这种算法叫做非对称加密算法。
1、RSA
其实，在早在 1978 年的时候，RSA就已经出现了，它是第一个既能用于数据加密也能用于数字签名的算法。它易于理解和操作，也很流行。其原理就如上面的工作过程所述。RSA 算法基于一个十分简单的数论事实：将两个大素数相乘十分容易，但是想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。

[java] view plain copy

 

1. import java.security.KeyFactory;  
2. import java.security.KeyPair;  
3. import java.security.KeyPairGenerator;  
4. import java.security.PrivateKey;  
5. import java.security.PublicKey;  
6. import java.security.interfaces.RSAPrivateKey;  
7. import java.security.interfaces.RSAPublicKey;  
8. import java.security.spec.PKCS8EncodedKeySpec;  
9. import java.security.spec.X509EncodedKeySpec;  
10.   
11. import javax.crypto.Cipher;  
12.   
13. import org.apache.commons.codec.binary.Hex;  
14.   
15. import com.amuro.strategy.IStrategy;  
16.   
17. public class RSAStrategy implements IStrategy  
18. {  
19.     private RSAPublicKey rsaPublicKey;  
20.     private RSAPrivateKey rsaPrivateKey;  
21.   
22.     public String encode(String src)  
23.     {  
24.         try  
25.         {  
26.             //初始化密钥  
27.             KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");  
28.             keyPairGenerator.initialize(512);  
29.             KeyPair keyPair = keyPairGenerator.generateKeyPair();  
30.             rsaPublicKey = (RSAPublicKey)keyPair.getPublic();  
31.             rsaPrivateKey = (RSAPrivateKey)keyPair.getPrivate();  
32.   
33.             //私钥加密 公钥解密  
34.             PKCS8EncodedKeySpec pkcs8EncodedKeySpec   
35.                 = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());  
36.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
37.             PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);  
38.             Cipher cipher = Cipher.getInstance("RSA");  
39.             cipher.init(Cipher.ENCRYPT_MODE, privateKey);  
40.             byte[] resultBytes = cipher.doFinal(src.getBytes());  
41.   
42.             //私钥解密 公钥加密  
43. //          X509EncodedKeySpec x509EncodedKeySpec =  
44. //                  new X509EncodedKeySpec(rsaPublicKey.getEncoded());  
45. //          KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
46. //          PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);  
47. //          Cipher cipher = Cipher.getInstance("RSA");  
48. //          cipher.init(Cipher.ENCRYPT_MODE, publicKey);  
49. //          byte[] resultBytes = cipher.doFinal(src.getBytes());  
50.   
51.             return Hex.encodeHexString(resultBytes);  
52.         }  
53.         catch(Exception e)  
54.         {  
55.             e.printStackTrace();  
56.         }  
57.   
58.         return null;  
59.     }  
60.   
61.     public String decode(String src)  
62.     {  
63.         try  
64.         {  
65.             //私钥加密 公钥解密  
66.             X509EncodedKeySpec x509EncodedKeySpec =  
67.                     new X509EncodedKeySpec(rsaPublicKey.getEncoded());  
68.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
69.             PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);  
70.             Cipher cipher = Cipher.getInstance("RSA");  
71.             cipher.init(Cipher.DECRYPT_MODE, publicKey);  
72.             byte[] resultBytes = cipher.doFinal(Hex.decodeHex(src.toCharArray()));  
73.   
74.             //私钥解密 公钥加密  
75. //          PKCS8EncodedKeySpec pkcs8EncodedKeySpec   
76. //              = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());  
77. //          KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
78. //          PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);  
79. //          Cipher cipher = Cipher.getInstance("RSA");  
80. //          cipher.init(Cipher.DECRYPT_MODE, privateKey);  
81. //          byte[] resultBytes = cipher.doFinal(Hex.decodeHex(src.toCharArray()));  
82.   
83.             return new String(resultBytes);  
84.         }  
85.         catch(Exception e)  
86.         {  
87.             e.printStackTrace();  
88.         }  
89.         return null;  
90.     }  
91.   
92. }  

2、DH算法
DH，全称为“Diffie-Hellman”，他是一种确保共享KEY安全穿越不安全网络的方法，也就是常说的密钥一致协议。由公开密钥密码体制的奠基人Diffie和Hellman所提出的一种思想。简单的说就是允许两名用户在公开媒体上交换信息以生成“一致”的、可以共享的密钥。也就是由甲方产出一对密钥（公钥、私钥），乙方依照甲方公钥产生乙方密钥对（公钥、私钥）。
以此为基线，作为数据传输保密基础，同时双方使用同一种对称加密算法构建本地密钥（SecretKey）对数据加密。这样，在互通了本地密钥（SecretKey）算法后，甲乙双方公开自己的公钥，使用对方的公钥和刚才产生的私钥加密数据，同时可以使用对方的公钥和自己的私钥对数据解密。不单单是甲乙双方两方，可以扩展为多方共享数据通讯，这样就完成了网络交互数据的安全通讯！

[java] view plain copy

 

1. import java.security.KeyFactory;  
2. import java.security.KeyPair;  
3. import java.security.KeyPairGenerator;  
4. import java.security.PrivateKey;  
5. import java.security.PublicKey;  
6. import java.security.spec.X509EncodedKeySpec;  
7. import java.util.Objects;  
8.   
9. import javax.crypto.Cipher;  
10. import javax.crypto.KeyAgreement;  
11. import javax.crypto.SecretKey;  
12. import javax.crypto.interfaces.DHPublicKey;  
13. import javax.crypto.spec.DHParameterSpec;  
14.   
15. import org.apache.commons.codec.binary.Hex;  
16.   
17. import com.amuro.strategy.IStrategy;  
18.   
19. public class DHStrategy implements IStrategy  
20. {  
21.     private Cipher cipher;  
22.     private SecretKey receiverSecretKey;  
23.   
24.     public String encode(String src)  
25.     {  
26.         try  
27.         {  
28.             //初始化发送方密钥  
29.             KeyPairGenerator senderKeyPairGenerator = KeyPairGenerator.getInstance("DH");  
30.             senderKeyPairGenerator.initialize(512);  
31.             KeyPair senderkeyPair = senderKeyPairGenerator.generateKeyPair();  
32.             PrivateKey senderPrivateKey = senderkeyPair.getPrivate();  
33.             byte[] senderPublicKeyBytes = senderkeyPair.getPublic().getEncoded();//发送方的公钥  
34.   
35.             //初始化接收方密钥,用发送方的公钥  
36.             KeyFactory receiverKeyFactory = KeyFactory.getInstance("DH");  
37.             X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(senderPublicKeyBytes);  
38.             PublicKey receiverPublicKey = receiverKeyFactory.generatePublic(x509EncodedKeySpec);  
39.             DHParameterSpec dhParameterSpec =   
40.                     ((DHPublicKey)receiverPublicKey).getParams();  
41.             KeyPairGenerator receiverKeyPairGenerator = KeyPairGenerator.getInstance("DH");  
42.             receiverKeyPairGenerator.initialize(dhParameterSpec);  
43.             KeyPair receiverKeyPair = receiverKeyPairGenerator.generateKeyPair();  
44.             PrivateKey receiverPrivateKey = receiverKeyPair.getPrivate();  
45.             byte[] receiverPublicKeyBytes = receiverKeyPair.getPublic().getEncoded();  
46.   
47.             KeyAgreement receiverKeyAgreement = KeyAgreement.getInstance("DH");  
48.             receiverKeyAgreement.init(receiverPrivateKey);  
49.             receiverKeyAgreement.doPhase(receiverPublicKey, true);  
50.             receiverSecretKey = receiverKeyAgreement.generateSecret("DES");  
51.   
52.             //发送方拿到接收方的public key就可以做加密了  
53.             KeyFactory senderKeyFactory = KeyFactory.getInstance("DH");  
54.             x509EncodedKeySpec = new X509EncodedKeySpec(receiverPublicKeyBytes);  
55.             PublicKey senderPublicKey = senderKeyFactory.generatePublic(x509EncodedKeySpec);  
56.             KeyAgreement senderKeyAgreement = KeyAgreement.getInstance("DH");  
57.             senderKeyAgreement.init(senderPrivateKey);  
58.             senderKeyAgreement.doPhase(senderPublicKey, true);  
59.             SecretKey senderSecretKey = senderKeyAgreement.generateSecret("DES");  
60.   
61.             if(Objects.equals(receiverSecretKey, senderSecretKey))  
62.             {  
63.                 cipher = Cipher.getInstance("DES");  
64.                 cipher.init(Cipher.ENCRYPT_MODE, senderSecretKey);  
65.                 byte[] result = cipher.doFinal(src.getBytes());  
66.                 return Hex.encodeHexString(result);  
67.             }  
68.   
69.         }  
70.         catch(Exception e)  
71.         {  
72.             e.printStackTrace();  
73.         }  
74.   
75.         return null;  
76.     }  
77.   
78.     public String decode(String src)  
79.     {  
80.         try  
81.         {  
82.             cipher.init(Cipher.DECRYPT_MODE, receiverSecretKey);  
83.             byte[] result = Hex.decodeHex(src.toCharArray());  
84.             return new String(cipher.doFinal(result));  
85.         }  
86.         catch(Exception e)  
87.         {  
88.             e.printStackTrace();  
89.         }  
90.   
91.         return null;  
92.     }  
93.   
94. }  

六、数字签名证书

非对称加密已经灰常安全了，但是还有一个破绽：
服务器A公布了自己的公钥，我的电脑是用服务器A的公钥加密数据后再发给服务器A的；这时候服务器B侵入了我的电脑，把我用来加密的公钥换成了它的公钥，于是我发出去的数据就会被服务器B的私钥破解了。肿么防止公钥被篡改呢？
对，我们想到了前面的消息摘要，服务器A把公钥丢给我的时候，同时去CA申请一份数字证书，其实主要就是公钥的消息摘要，有了这份证书，当我再用公钥加密的时候，我就可以先验证一下当前的公钥是否确定是服务器A发送给我的。
这里就贴一种RSA的：

[java] view plain copy

 

1. import java.security.KeyFactory;  
2. import java.security.KeyPair;  
3. import java.security.KeyPairGenerator;  
4. import java.security.PrivateKey;  
5. import java.security.PublicKey;  
6. import java.security.Signature;  
7. import java.security.interfaces.RSAPrivateKey;  
8. import java.security.interfaces.RSAPublicKey;  
9. import java.security.spec.PKCS8EncodedKeySpec;  
10. import java.security.spec.X509EncodedKeySpec;  
11.   
12. public class RSASign  
13. {  
14.     public static boolean verifySign(String src)  
15.     {  
16.         try  
17.         {  
18.             KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");  
19.             keyPairGenerator.initialize(512);  
20.             KeyPair keyPair = keyPairGenerator.generateKeyPair();  
21.             PublicKey rsaPublicKey = (RSAPublicKey)keyPair.getPublic();  
22.             PrivateKey rsaPrivateKey = (RSAPrivateKey)keyPair.getPrivate();  
23.   
24.             PKCS8EncodedKeySpec pkcs8EncodedKeySpec   
25.                 = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());  
26.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
27.             PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);  
28.             Signature signature = Signature.getInstance("MD5withRSA");  
29.             signature.initSign(privateKey);  
30.             signature.update(src.getBytes());  
31.             //生成签名bytes  
32.             byte[] signBytes = signature.sign();  
33.   
34.             X509EncodedKeySpec x509EncodedKeySpec =  
35.                     new X509EncodedKeySpec(rsaPublicKey.getEncoded());  
36.             keyFactory = KeyFactory.getInstance("RSA");  
37.             PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);  
38.             signature = Signature.getInstance("MD5withRSA");  
39.             signature.initVerify(publicKey);  
40.             signature.update(src.getBytes());  
41.             boolean isVerified = signature.verify(signBytes);  
42.   
43.             return isVerified;  
44.         }  
45.         catch(Exception e)  
46.         {  
47.             e.printStackTrace();  
48.         }  
49.   
50.         return false;  
51.     }  
52.   
53. }  

关于数字签名和非对称加密算法的使用，还看到一个非常棒的例子，分享给大家：
唉，这个月买了太多的书，到月底揭不开锅了。正巧在QQ上遇到了Clark：
1-2-3：“Clark，我需要200两纹银，能否借给我？”
Clark：“没问题。我这就给你转账。请给我一张借条。”
1-2-3：“太谢谢了，我这就用Word写一个借条给你。”
然后，我新建一个Word文档，写好借条，存盘。然后，然后怎么办呢？我不能直接把借条发送给Clark，原因有：
1. 我无法保证Clark不会在收到借条后将“纹银200两”改为“纹银2000两”。
2. 如果我赖账，Clark无法证明这个借条就是我写的。
3. 普通的Word文档不能作为打官司的证据。
好在我早就申请了数字证书。我先用我的私钥对借条进行加密，然后将加密后的密文用QQ发送给Clark。Clark收到了借条的密文后，在数字证书认证中心的网站上下载我的公钥，然后使用我的公钥将密文解密，发现确实写的是“借纹银200两”，Clark就可以把银子放心的借给我了，我也不会担心Clark会篡改我的借条，原因是：
1. 由于我发给Clark的是密文，Clark无法进行修改。Clark倒是可以修改解密后的借条，但是Clark没有我的私钥，没法模仿我对借条进行加密。这就叫防篡改。
2. 由于用我的私钥进行加密的借条，有且只有我的公钥可以解密。反过来讲，能用我的公钥解密的借条，一定是使用我的私钥加密的，而只有我才拥有我的私钥，这样Clark就可以证明这个借条就是我写的。这就叫防抵赖。
3. 如果我一直赖着不还钱，Clark把我告上了法庭，这个用我的私钥加密过的Word文档就可以当作程堂证供。因为我国已经出台了《中华人民共和国电子签名法》，使数字签名具有了法律效力。

您一定已经注意到了，这个使用我的私钥进行了加密的借条，具有了防篡改、防抵赖的特性，并且可以作为程堂证供，就跟我对这个借条进行了“签名”的效果是一样的。对了，“使用我的私钥对借条进行加密”的过程就叫做数字签名。

原文：http://blog.csdn.net/hj7jay/article/details/51921522?locationNum=7&fps=1