Java加密技術（五）——非對稱加密算法的由來DH

Java加密技術（五）——非對稱加密算法的由來DH

博客分類：

•  

• Java／Security

Java非對稱加密算法dh 

    接下來咱們分析DH加密算法，一種適基於密鑰一致協議的加密算法。 
DH 
Diffie-Hellman算法(D-H算法)，密鑰一致協議。是由公開密鑰密碼體制的奠定人Diffie和Hellman所提出的一種思想。簡單的說就是容許兩名用戶在公開媒體上交換信息以生成"一致"的、能夠共享的密鑰。換句話說，就是由甲方產出一對密鑰（公鑰、私鑰），乙方依照甲方公鑰產生乙方密鑰對（公鑰、私鑰）。以此爲基線，做爲數據傳輸保密基礎，同時雙方使用同一種對稱加密算法構建本地密鑰（SecretKey）對數據加密。這樣，在互通了本地密鑰（SecretKey）算法後，甲乙雙方公開本身的公鑰，使用對方的公鑰和剛纔產生的私鑰加密數據，同時能夠使用對方的公鑰和本身的私鑰對數據解密。不僅僅是甲乙雙方兩方，能夠擴展爲多方共享數據通信，這樣就完成了網絡交互數據的安全通信！該算法源於中國的同餘定理——中國餘數定理。  

流程分析： 

1.甲方構建密鑰對兒，將公鑰公佈給乙方，將私鑰保留；雙方約定數據加密算法；乙方經過甲方公鑰構建密鑰對兒，將公鑰公佈給甲方，將私鑰保留。 
2.甲方使用私鑰、乙方公鑰、約定數據加密算法構建本地密鑰，而後經過本地密鑰加密數據，發送給乙方加密後的數據；乙方使用私鑰、甲方公鑰、約定數據加密算法構建本地密鑰，而後經過本地密鑰對數據解密。 
3.乙方使用私鑰、甲方公鑰、約定數據加密算法構建本地密鑰，而後經過本地密鑰加密數據，發送給甲方加密後的數據；甲方使用私鑰、乙方公鑰、約定數據加密算法構建本地密鑰，而後經過本地密鑰對數據解密。 

經過java代碼實現以下：Coder類見 Java加密技術（一） 

Java代碼  

1. import java.security.Key;  

2. import java.security.KeyFactory;  

3. import java.security.KeyPair;  

4. import java.security.KeyPairGenerator;  

5. import java.security.PublicKey;  

6. import java.security.spec.PKCS8EncodedKeySpec;  

7. import java.security.spec.X509EncodedKeySpec;  

8. import java.util.HashMap;  

9. import java.util.Map;  

10.   

11. import javax.crypto.Cipher;  

12. import javax.crypto.KeyAgreement;  

13. import javax.crypto.SecretKey;  

14. import javax.crypto.interfaces.DHPrivateKey;  

15. import javax.crypto.interfaces.DHPublicKey;  

16. import javax.crypto.spec.DHParameterSpec;  

17.   

18. /** 

19.  * DH安全編碼組件 

20.  *  

21.  * @author 樑棟 

22.  * @version 1.0 

23.  * @since 1.0 

24.  */  

25. public abstract class DHCoder extends Coder {  

26.     public static final String ALGORITHM = "DH";  

27.   

28.     /** 

29.      * 默認密鑰字節數 

30.      *  

31.      * <pre> 

32.      * DH 

33.      * Default Keysize 1024   

34.      * Keysize must be a multiple of 64, ranging from 512 to 1024 (inclusive). 

35.      * </pre> 

36.      */  

37.     private static final int KEY_SIZE = 1024;  

38.   

39.     /** 

40.      * DH加密下須要一種對稱加密算法對數據加密，這裏咱們使用DES，也能夠使用其餘對稱加密算法。 

41.      */  

42.     public static final String SECRET_ALGORITHM = "DES";  

43.     private static final String PUBLIC_KEY = "DHPublicKey";  

44.     private static final String PRIVATE_KEY = "DHPrivateKey";  

45.   

46.     /** 

47.      * 初始化甲方密鑰 

48.      *  

49.      * @return  

50.      * @throws Exception 

51.      */  

52.     public static Map<String, Object> initKey() throws Exception {  

53.         KeyPairGenerator keyPairGenerator = KeyPairGenerator  

54.                 .getInstance(ALGORITHM);  

55.         keyPairGenerator.initialize(KEY_SIZE);  

56.   

57.         KeyPair keyPair = keyPairGenerator.generateKeyPair();  

58.   

59.         // 甲方公鑰  

60.         DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic();  

61.   

62.         // 甲方私鑰  

63.         DHPrivateKey privateKey = (DHPrivateKey) keyPair.getPrivate();  

64.   

65.         Map<String, Object> keyMap = new HashMap<String, Object>(2);  

66.   

67.         keyMap.put(PUBLIC_KEY, publicKey);  

68.         keyMap.put(PRIVATE_KEY, privateKey);  

69.         return keyMap;  

70.     }  

71.   

72.     /** 

73.      * 初始化乙方密鑰 

74.      *  

75.      * @param key 

76.      *            甲方公鑰 

77.      * @return 

78.      * @throws Exception 

79.      */  

80.     public static Map<String, Object> initKey(String key) throws Exception {  

81.         // 解析甲方公鑰  

82.         byte[] keyBytes = decryptBASE64(key);  

83.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);  

84.         KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);  

85.         PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);  

86.   

87.         // 由甲方公鑰構建乙方密鑰  

88.         DHParameterSpec dhParamSpec = ((DHPublicKey) pubKey).getParams();  

89.   

90.         KeyPairGenerator keyPairGenerator = KeyPairGenerator  

91.                 .getInstance(keyFactory.getAlgorithm());  

92.         keyPairGenerator.initialize(dhParamSpec);  

93.   

94.         KeyPair keyPair = keyPairGenerator.generateKeyPair();  

95.   

96.         // 乙方公鑰  

97.         DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic();  

98.   

99.         // 乙方私鑰  

100.         DHPrivateKey privateKey = (DHPrivateKey) keyPair.getPrivate();  

101.   

102.         Map<String, Object> keyMap = new HashMap<String, Object>(2);  

103.   

104.         keyMap.put(PUBLIC_KEY, publicKey);  

105.         keyMap.put(PRIVATE_KEY, privateKey);  

106.   

107.         return keyMap;  

108.     }  

109.   

110.     /** 

111.      * 加密<br> 

112.      *  

113.      * @param data 

114.      *            待加密數據 

115.      * @param publicKey 

116.      *            甲方公鑰 

117.      * @param privateKey 

118.      *            乙方私鑰 

119.      * @return 

120.      * @throws Exception 

121.      */  

122.     public static byte[] encrypt(byte[] data, String publicKey,  

123.             String privateKey) throws Exception {  

124.   

125.         // 生成本地密鑰  

126.         SecretKey secretKey = getSecretKey(publicKey, privateKey);  

127.   

128.         // 數據加密  

129.         Cipher cipher = Cipher.getInstance(secretKey.getAlgorithm());  

130.         cipher.init(Cipher.ENCRYPT_MODE, secretKey);  

131.   

132.         return cipher.doFinal(data);  

133.     }  

134.   

135.     /** 

136.      * 解密<br> 

137.      *  

138.      * @param data 

139.      *            待解密數據 

140.      * @param publicKey 

141.      *            乙方公鑰 

142.      * @param privateKey 

143.      *            乙方私鑰 

144.      * @return 

145.      * @throws Exception 

146.      */  

147.     public static byte[] decrypt(byte[] data, String publicKey,  

148.             String privateKey) throws Exception {  

149.   

150.         // 生成本地密鑰  

151.         SecretKey secretKey = getSecretKey(publicKey, privateKey);  

152.         // 數據解密  

153.         Cipher cipher = Cipher.getInstance(secretKey.getAlgorithm());  

154.         cipher.init(Cipher.DECRYPT_MODE, secretKey);  

155.   

156.         return cipher.doFinal(data);  

157.     }  

158.   

159.     /** 

160.      * 構建密鑰 

161.      *  

162.      * @param publicKey 

163.      *            公鑰 

164.      * @param privateKey 

165.      *            私鑰 

166.      * @return 

167.      * @throws Exception 

168.      */  

169.     private static SecretKey getSecretKey(String publicKey, String privateKey)  

170.             throws Exception {  

171.         // 初始化公鑰  

172.         byte[] pubKeyBytes = decryptBASE64(publicKey);  

173.   

174.         KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);  

175.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(pubKeyBytes);  

176.         PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);  

177.   

178.         // 初始化私鑰  

179.         byte[] priKeyBytes = decryptBASE64(privateKey);  

180.   

181.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(priKeyBytes);  

182.         Key priKey = keyFactory.generatePrivate(pkcs8KeySpec);  

183.   

184.         KeyAgreement keyAgree = KeyAgreement.getInstance(keyFactory  

185.                 .getAlgorithm());  

186.         keyAgree.init(priKey);  

187.         keyAgree.doPhase(pubKey, true);  

188.   

189.         // 生成本地密鑰  

190.         SecretKey secretKey = keyAgree.generateSecret(SECRET_ALGORITHM);  

191.   

192.         return secretKey;  

193.     }  

194.   

195.     /** 

196.      * 取得私鑰 

197.      *  

198.      * @param keyMap 

199.      * @return 

200.      * @throws Exception 

201.      */  

202.     public static String getPrivateKey(Map<String, Object> keyMap)  

203.             throws Exception {  

204.         Key key = (Key) keyMap.get(PRIVATE_KEY);  

205.   

206.         return encryptBASE64(key.getEncoded());  

207.     }  

208.   

209.     /** 

210.      * 取得公鑰 

211.      *  

212.      * @param keyMap 

213.      * @return 

214.      * @throws Exception 

215.      */  

216.     public static String getPublicKey(Map<String, Object> keyMap)  

217.             throws Exception {  

218.         Key key = (Key) keyMap.get(PUBLIC_KEY);  

219.   

220.         return encryptBASE64(key.getEncoded());  

221.     }  

222. }  

再給出一個測試類： 

Java代碼  

1. import static org.junit.Assert.*;  

2.   

3. import java.util.Map;  

4.   

5. import org.junit.Test;  

6.   

7. /** 

8.  *  

9.  * @author 樑棟 

10.  * @version 1.0 

11.  * @since 1.0 

12.  */  

13. public class DHCoderTest {  

14.   

15.     @Test  

16.     public void test() throws Exception {  

17.         // 生成甲方密鑰對兒  

18.         Map<String, Object> aKeyMap = DHCoder.initKey();  

19.         String aPublicKey = DHCoder.getPublicKey(aKeyMap);  

20.         String aPrivateKey = DHCoder.getPrivateKey(aKeyMap);  

21.   

22.         System.err.println("甲方公鑰:\r" + aPublicKey);  

23.         System.err.println("甲方私鑰:\r" + aPrivateKey);  

24.           

25.         // 由甲方公鑰產生本地密鑰對兒  

26.         Map<String, Object> bKeyMap = DHCoder.initKey(aPublicKey);  

27.         String bPublicKey = DHCoder.getPublicKey(bKeyMap);  

28.         String bPrivateKey = DHCoder.getPrivateKey(bKeyMap);  

29.           

30.         System.err.println("乙方公鑰:\r" + bPublicKey);  

31.         System.err.println("乙方私鑰:\r" + bPrivateKey);  

32.           

33.         String aInput = "abc ";  

34.         System.err.println("原文: " + aInput);  

35.   

36.         // 由甲方公鑰，乙方私鑰構建密文  

37.         byte[] aCode = DHCoder.encrypt(aInput.getBytes(), aPublicKey,  

38.                 bPrivateKey);  

39.   

40.         // 由乙方公鑰，甲方私鑰解密  

41.         byte[] aDecode = DHCoder.decrypt(aCode, bPublicKey, aPrivateKey);  

42.         String aOutput = (new String(aDecode));  

43.   

44.         System.err.println("解密: " + aOutput);  

45.   

46.         assertEquals(aInput, aOutput);  

47.   

48.         System.err.println(" ===============反過來加密解密================== ");  

49.         String bInput = "def ";  

50.         System.err.println("原文: " + bInput);  

51.   

52.         // 由乙方公鑰，甲方私鑰構建密文  

53.         byte[] bCode = DHCoder.encrypt(bInput.getBytes(), bPublicKey,  

54.                 aPrivateKey);  

55.   

56.         // 由甲方公鑰，乙方私鑰解密  

57.         byte[] bDecode = DHCoder.decrypt(bCode, aPublicKey, bPrivateKey);  

58.         String bOutput = (new String(bDecode));  

59.   

60.         System.err.println("解密: " + bOutput);  

61.   

62.         assertEquals(bInput, bOutput);  

63.     }  

64.   

65. }  

控制檯輸出： 

Console代碼  

1. 甲方公鑰:  

2. MIHfMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHz  

3. W5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSG  

4. kx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANDAAJAdAWBVmIzqcko  

5. Ej6qFjLDL2+Y3FPq1iRbnOyOpDj71yKaK1K+FhTv04B0zy4DKcvAASV7/Gv0W+bgqdmffRkqrQ==  

6.   

7. 甲方私鑰:  

8. MIHRAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYX  

9. rgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpD  

10. TWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQyAjACJRfy1LyR  

11. eHyD+4Hfb+xR0uoIGR1oL9i9Nk6g2AAuaDPgEVWHn+QXID13yL/uDos=  

12.   

13. 乙方公鑰:  

14. MIHfMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHz  

15. W5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSG  

16. kx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANDAAJAVEYSfBA+I9nr  

17. dWw3OBv475C+eBrWBBYqt0m6/eu4ptuDQHwV4MmUtKAC2wc2nNrdb1wmBhY1X8RnWkJ1XmdDbQ==  

18.   

19. 乙方私鑰:  

20. MIHSAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYX  

21. rgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpD  

22. TWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQzAjEAqaZiCdXp  

23. 2iNpdBlHRaO9ir70wo2n32xNlIzIX19VLSPCDdeUWkgRv4CEj/8k+/yd  

24.   

25. 原文: abc   

26. 解密: abc   

27.  ===============反過來加密解密==================   

28. 原文: def   

29. 解密: def