博客园  :: 首页  :: 新随笔  :: 联系 :: 订阅 订阅  :: 管理

非对称加密算法-DH算法

Posted on 2016-06-17 16:33  bw_0927  阅读(796)  评论(0编辑  收藏  举报

http://blog.csdn.net/kongqz/article/details/6302913

 

一、概述

  1、与对称加密算法的主要差别在于,加密和解密的密钥不相同,一个公开(公钥),一个保密(私钥)。非对称加密算法主要解决了对称加密算法密钥分配管理的问题,提高了算法安全性。

  2、非对称加密算法的加密、解密的效率比较低。在算法设计上,非对称加密算法对待加密的数据长度有着苛刻的要求。例如RSA算法要求待加密的数据不得大于53个字节。

  3、非对称加密算法主要用于交换对称加密算法的密钥,而非数据交换(而非为了加密数据本身,用交换得来的对称加密算法来进行数据加密)

  4、java6提供实现了DH和RSA两种算法。Bouncy Castle提供了E1Gamal算法支持。除了上述三种算法还有一个ECC算法,目前没有相关的开源组件提供支持

 

二、模型分析

我们还是以甲乙双方发送数据为模型进行分析

1、甲方(消息发送方,下同)构建密钥对(公钥+私钥),甲方公布公钥给乙方(消息接收方,下同)

2、乙方以甲方发送过来的公钥作为参数构造密钥对(公钥+私钥),将构造出来的公钥公布给甲方

3、甲方用“甲方的私钥+乙方的公钥”构造本地密钥

4、乙方用“乙方的私钥+甲方的公钥”构造本地的密钥

5、这个时候,甲乙两方本地新构造出来的密钥应该一样。然后就可以使用AES这类对称加密算法结合密钥进行数据的安全传送了。传送过程参考AES的相关算法

三、代码分析

 

[java] view plain copy
 
  1. package com.ca.test;  
  2. import java.security.Key;  
  3. import java.security.KeyFactory;  
  4. import java.security.KeyPair;  
  5. import java.security.KeyPairGenerator;  
  6. import java.security.PrivateKey;  
  7. import java.security.PublicKey;  
  8. import java.security.spec.PKCS8EncodedKeySpec;  
  9. import java.security.spec.X509EncodedKeySpec;  
  10. import java.util.HashMap;  
  11. import java.util.Map;  
  12. import javax.crypto.Cipher;  
  13. import javax.crypto.KeyAgreement;  
  14. import javax.crypto.SecretKey;  
  15. import javax.crypto.interfaces.DHPrivateKey;  
  16. import javax.crypto.interfaces.DHPublicKey;  
  17. import javax.crypto.spec.DHParameterSpec;  
  18. import javax.crypto.spec.SecretKeySpec;  
  19. import org.apache.commons.codec.binary.Base64;  
  20. /** 
  21.  * 非对称加密算法DH算法组件 
  22.  * 非对称算法一般是用来传送对称加密算法的密钥来使用的,所以这里我们用DH算法模拟密钥传送 
  23.  * 对称加密AES算法继续做我们的数据加解密 
  24.  * @author kongqz 
  25.  * */  
  26. public class DHCoder {  
  27.     //非对称密钥算法  
  28.     public static final String KEY_ALGORITHM="DH";  
  29.       
  30.     //本地密钥算法,即对称加密算法。可选des,aes,desede  
  31.     public static final String SECRET_ALGORITHM="AES";  
  32.       
  33.     /** 
  34.      * 密钥长度,DH算法的默认密钥长度是1024 
  35.      * 密钥长度必须是64的倍数,在512到1024位之间 
  36.      * */  
  37.     private static final int KEY_SIZE=512;  
  38.     //公钥  
  39.     private static final String PUBLIC_KEY="DHPublicKey";  
  40.       
  41.     //私钥  
  42.     private static final String PRIVATE_KEY="DHPrivateKey";  
  43.       
  44.     /** 
  45.      * 初始化甲方密钥 
  46.      * @return Map 甲方密钥的Map 
  47.      * */  
  48.     public static Map<String,Object> initKey() throws Exception{  
  49.         //实例化密钥生成器  
  50.         KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance(KEY_ALGORITHM);  
  51.         //初始化密钥生成器  
  52.         keyPairGenerator.initialize(KEY_SIZE);  
  53.         //生成密钥对  
  54.         KeyPair keyPair=keyPairGenerator.generateKeyPair();  
  55.         //甲方公钥  
  56.         DHPublicKey publicKey=(DHPublicKey) keyPair.getPublic();  
  57.         //甲方私钥  
  58.         DHPrivateKey privateKey=(DHPrivateKey) keyPair.getPrivate();  
  59.         //将密钥存储在map中  
  60.         Map<String,Object> keyMap=new HashMap<String,Object>();  
  61.         keyMap.put(PUBLIC_KEY, publicKey);  
  62.         keyMap.put(PRIVATE_KEY, privateKey);  
  63.         return keyMap;  
  64.           
  65.     }  
  66.       
  67.     /** 
  68.      * 初始化乙方密钥 
  69.      * @param key 甲方密钥(这个密钥是通过第三方途径传递的) 
  70.      * @return Map 乙方密钥的Map 
  71.      * */  
  72.     public static Map<String,Object> initKey(byte[] key) throws Exception{  
  73.         //解析甲方的公钥  
  74.         //转换公钥的材料  
  75.         X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(key);  
  76.         //实例化密钥工厂  
  77.         KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);  
  78.         //产生公钥  
  79.         PublicKey pubKey=keyFactory.generatePublic(x509KeySpec);  
  80.         //由甲方的公钥构造乙方密钥  
  81.         DHParameterSpec dhParamSpec=((DHPublicKey)pubKey).getParams();  
  82.         //实例化密钥生成器  
  83.         KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance(keyFactory.getAlgorithm());  
  84.         //初始化密钥生成器  
  85.         keyPairGenerator.initialize(dhParamSpec);  
  86.         //产生密钥对  
  87.         KeyPair keyPair=keyPairGenerator.genKeyPair();  
  88.         //乙方公钥  
  89.         DHPublicKey publicKey=(DHPublicKey)keyPair.getPublic();  
  90.         //乙方私钥  
  91.         DHPrivateKey privateKey=(DHPrivateKey)keyPair.getPrivate();  
  92.         //将密钥存储在Map中  
  93.         Map<String,Object> keyMap=new HashMap<String,Object>();  
  94.         keyMap.put(PUBLIC_KEY, publicKey);  
  95.         keyMap.put(PRIVATE_KEY, privateKey);  
  96.         return keyMap;  
  97.     }  
  98.     /** 
  99.      * 加密 
  100.      * @param data待加密数据 
  101.      * @param key 密钥 
  102.      * @return byte[] 加密数据 
  103.      * */  
  104.     public static byte[] encrypt(byte[] data,byte[] key) throws Exception{  
  105.         //生成本地密钥  
  106.         SecretKey secretKey=new SecretKeySpec(key,SECRET_ALGORITHM);  
  107.         //数据加密  
  108.         Cipher cipher=Cipher.getInstance(secretKey.getAlgorithm());  
  109.         cipher.init(Cipher.ENCRYPT_MODE, secretKey);  
  110.         return cipher.doFinal(data);  
  111.     }  
  112.     /** 
  113.      * 解密 
  114.      * @param data 待解密数据 
  115.      * @param key 密钥 
  116.      * @return byte[] 解密数据 
  117.      * */  
  118.     public static byte[] decrypt(byte[] data,byte[] key) throws Exception{  
  119.         //生成本地密钥  
  120.         SecretKey secretKey=new SecretKeySpec(key,SECRET_ALGORITHM);  
  121.         //数据解密  
  122.         Cipher cipher=Cipher.getInstance(secretKey.getAlgorithm());  
  123.         cipher.init(Cipher.DECRYPT_MODE, secretKey);  
  124.         return cipher.doFinal(data);  
  125.     }  
  126.     /** 
  127.      * 构建密钥 
  128.      * @param publicKey 公钥 
  129.      * @param privateKey 私钥 
  130.      * @return byte[] 本地密钥 
  131.      * */  
  132.     public static byte[] getSecretKey(byte[] publicKey,byte[] privateKey) throws Exception{  
  133.         //实例化密钥工厂  
  134.         KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);  
  135.         //初始化公钥  
  136.         //密钥材料转换  
  137.         X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(publicKey);  
  138.         //产生公钥  
  139.         PublicKey pubKey=keyFactory.generatePublic(x509KeySpec);  
  140.         //初始化私钥  
  141.         //密钥材料转换  
  142.         PKCS8EncodedKeySpec pkcs8KeySpec=new PKCS8EncodedKeySpec(privateKey);  
  143.         //产生私钥  
  144.         PrivateKey priKey=keyFactory.generatePrivate(pkcs8KeySpec);  
  145.         //实例化  
  146.         KeyAgreement keyAgree=KeyAgreement.getInstance(keyFactory.getAlgorithm());  
  147.         //初始化  
  148.         keyAgree.init(priKey);  
  149.         keyAgree.doPhase(pubKey, true);  
  150.         //生成本地密钥  
  151.         SecretKey secretKey=keyAgree.generateSecret(SECRET_ALGORITHM);  
  152.         return secretKey.getEncoded();  
  153.     }  
  154.     /** 
  155.      * 取得私钥 
  156.      * @param keyMap 密钥map 
  157.      * @return byte[] 私钥 
  158.      * */  
  159.     public static byte[] getPrivateKey(Map<String,Object> keyMap){  
  160.         Key key=(Key)keyMap.get(PRIVATE_KEY);  
  161.         return key.getEncoded();  
  162.     }  
  163.     /** 
  164.      * 取得公钥 
  165.      * @param keyMap 密钥map 
  166.      * @return byte[] 公钥 
  167.      * */  
  168.     public static byte[] getPublicKey(Map<String,Object> keyMap) throws Exception{  
  169.         Key key=(Key) keyMap.get(PUBLIC_KEY);  
  170.         return key.getEncoded();  
  171.     }  
  172.     /** 
  173.      * @param args 
  174.      * @throws Exception  
  175.      */  
  176.     public static void main(String[] args) throws Exception {  
  177.         //生成甲方的密钥对  
  178.         Map<String,Object> keyMap1=DHCoder.initKey();  
  179.         //甲方的公钥  
  180.         byte[] publicKey1=DHCoder.getPublicKey(keyMap1);  
  181.           
  182.         //甲方的私钥  
  183.         byte[] privateKey1=DHCoder.getPrivateKey(keyMap1);  
  184.         System.out.println("甲方公钥:/n"+Base64.encodeBase64String(publicKey1));  
  185.         System.out.println("甲方私钥:/n"+Base64.encodeBase64String(privateKey1));  
  186.           
  187.         //由甲方的公钥产生的密钥对  
  188.         Map<String,Object> keyMap2=DHCoder.initKey(publicKey1);  
  189.         byte[] publicKey2=DHCoder.getPublicKey(keyMap2);  
  190.         byte[] privateKey2=DHCoder.getPrivateKey(keyMap2);  
  191.         System.out.println("乙方公钥:/n"+Base64.encodeBase64String(publicKey2));  
  192.         System.out.println("乙方私钥:/n"+Base64.encodeBase64String(privateKey2));  
  193.           
  194.         //组装甲方的本地加密密钥,由乙方的公钥和甲方的私钥组合而成  
  195.         byte[] key1=DHCoder.getSecretKey(publicKey2, privateKey1);  
  196.         System.out.println("甲方的本地密钥:/n"+Base64.encodeBase64String(key1));  
  197.           
  198.         //组装乙方的本地加密密钥,由甲方的公钥和乙方的私钥组合而成  
  199.         byte[] key2=DHCoder.getSecretKey(publicKey1, privateKey2);  
  200.         System.out.println("乙方的本地密钥:/n"+Base64.encodeBase64String(key2));  
  201.           
  202.         System.out.println("================密钥对构造完毕,开始进行加密数据的传输=============");  
  203.         String str="密码交换算法";  
  204.         System.out.println("/n===========甲方向乙方发送加密数据==============");  
  205.         System.out.println("原文:"+str);  
  206.         System.out.println("===========使用甲方本地密钥对进行数据加密==============");  
  207.         //甲方进行数据的加密  
  208.         byte[] code1=DHCoder.encrypt(str.getBytes(), key1);  
  209.         System.out.println("加密后的数据:"+Base64.encodeBase64String(code1));  
  210.           
  211.         System.out.println("===========使用乙方本地密钥对数据进行解密==============");  
  212.         //乙方进行数据的解密  
  213.         byte[] decode1=DHCoder.decrypt(code1, key2);  
  214.         System.out.println("乙方解密后的数据:"+new String(decode1)+"/n/n");  
  215.           
  216.         System.out.println("===========反向进行操作,乙方向甲方发送数据==============/n/n");  
  217.           
  218.         str="乙方向甲方发送数据DH";  
  219.           
  220.         System.out.println("原文:"+str);  
  221.           
  222.         //使用乙方本地密钥对数据进行加密  
  223.         byte[] code2=DHCoder.encrypt(str.getBytes(), key2);  
  224.         System.out.println("===========使用乙方本地密钥对进行数据加密==============");  
  225.         System.out.println("加密后的数据:"+Base64.encodeBase64String(code2));  
  226.           
  227.         System.out.println("=============乙方将数据传送给甲方======================");  
  228.         System.out.println("===========使用甲方本地密钥对数据进行解密==============");  
  229.           
  230.         //甲方使用本地密钥对数据进行解密  
  231.         byte[] decode2=DHCoder.decrypt(code2, key1);  
  232.           
  233.         System.out.println("甲方解密后的数据:"+new String(decode2));  
  234.     }  
  235. }  
  236.   
  237. 控制台输出结果:  
  238. 甲方公钥:  
  239. MIHgMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHz  
  240. W5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSG  
  241. kx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANEAAJBALk1l11UT5Y1  
  242. evJv1sLQAXo7Yj/olsPMVJ/7zOx503CRcovA5Q+k2OyIZsl5H2qGCnqi+Da0/9zZx0go8Y/j5B4=  
  243. 甲方私钥:  
  244. MIHRAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYX  
  245. rgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpD  
  246. TWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQyAjB0haXhPoDW  
  247. gLMF79N1ZZGu1dtHWAObe9obKAh4hGH0HsAsSY8qy17ZE0IyiOwYPXA=  
  248. 乙方公钥:  
  249. MIHgMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHz  
  250. W5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSG  
  251. kx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANEAAJBAOWqgUur2jDR  
  252. 057ohEH4eb3KwOdmcbsv4GnvIlCVzwpBKVlUk0MMIeV8APLz/xIjjoOnNZx3rNknaO/+v85tG3g=  
  253. 乙方私钥:  
  254. MIHRAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYX  
  255. rgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpD  
  256. TWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQyAjB+/HgBYVlO  
  257. e2eAeU0HoWQyYsHt0tSPUZUqCyY9mWEK/7soxsR/6pfAb1npaaI1NO0=  
  258. 甲方的本地密钥:  
  259. +E068E5KSWvLYrB5o1ryIY1VFt6WcUnBrXvlBYN++/M=  
  260. 乙方的本地密钥:  
  261. +E068E5KSWvLYrB5o1ryIY1VFt6WcUnBrXvlBYN++/M=  
  262. ================密钥对构造完毕,开始进行加密数据的传输=============  
  263. ===========甲方向乙方发送加密数据==============  
  264. 原文:密码交换算法  
  265. ===========使用甲方本地密钥对进行数据加密==============  
  266. 加密后的数据:1PUMKnkyfKauO6kTG5UDtA==  
  267. ===========使用乙方本地密钥对数据进行解密==============  
  268. 乙方解密后的数据:密码交换算法  
  269.   
  270. ===========反向进行操作,乙方向甲方发送数据==============  
  271.   
  272. 原文:乙方向甲方发送数据DH  
  273. ===========使用乙方本地密钥对进行数据加密==============  
  274. 加密后的数据:VGLdXmtGyBaE87NiSoHX+yvwyUkAx/qYKYWv+jEwkBY=  
  275. =============乙方将数据传送给甲方======================  
  276. ===========使用甲方本地密钥对数据进行解密==============  
  277. 甲方解密后的数据:乙方向甲方发送数据DH  

 

 

 

四、总结

1、非对称加密算法主要用来传递密钥的,而且性能较低。但是安全性超强。非对称加密算法能加密的数据长度也受限

2、用非对称加密算法算出甲乙双方本地的密钥后,可以选择DES/AES/DESede这些对称加密算法进行数据的传送了