`
liuguofeng
  • 浏览: 435092 次
  • 性别: Icon_minigender_1
  • 来自: 成都
社区版块
存档分类
最新评论

非对称加密算法-DH算法

    博客分类:
  • Java
 
阅读更多

http://blog.csdn.net/kongqz/article/category/800296

 

一、概述

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

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

  3、非对称加密算法主要用于 交换对称加密算法的密钥,而非数据交换

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

 

二、模型分析

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

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

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

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

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

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

三、代码分析

 

[java] view plaincopy
 
  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这些对称加密算法进行数据的传送了

分享到:
评论

相关推荐

    java加密算法:Base64加密\数字签名\对称加密算法\非对称加密算法\消息摘要算法

    java关于加密的算法demo代码(Base64加密\数字签名\对称加密算法\非对称加密算法\消息摘要算法) JAVA安全实现三种方式: 1.JDK 2.Commons Codec 3.Bouncy Castle 一。非对称加密算法: 1.DH 2.RSA 3.ELGamal 二。...

    JAVA加密算法- 非对称加密算法(DH,RSA)的详细介绍

    主要介绍了JAVA加密算法- 非对称加密算法(DH,RSA),详细介绍了DH,RSA的用法和示例,需要的朋友可以了解一下。

    java 非对称加密算法DH实现详解

    主要介绍了java 非对称加密算法DH实现详解 ,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

    独孤密码-非对称加密算法RSA解析

    非对称加密算法家族包含了鼻祖DH算法,基于因子分解难题的RSA算法,基于离散对数难题的ElGamal算法和ECC算法等.在本人对接过的多家银行和第三方支付接口中,RSA算法是非对称加密中的网红花旦,今天就浅谈下RSA算法. 二....

    Java加密技术介绍.docx

    Java加密技术(五)——非对称加密算法的由来DH Java加密技术(六)——数字签名算法DSA Java加密技术(七)——非对称加密算法最高级ECC Java加密技术(八)——数字证书 Java加密技术(九)——初探SSL Java加密...

    Java十大加密算法(对称与非对称)

    加密算法包含:AES、DES、DH、ECDSA、MD5、PBE、RC4、RSA、ThreeDES等

    JavaSecurity:java 摘要算法,对称加密,非对称加密算法

    JavaSecurity 使用摘要算法 Base64 MD SHA MAC对称加密 DES AES PBE非对称加密算法 DH RSA ElGamal

    Java常见加密技术全景展示_附Java代码实现

    复杂的对称加密(DES、PBE)、非对称加密算法: ● DES(Data Encryption Standard,数据加密算法) ● PBE(Password-based encryption,基于密码验证) ● RSA(算法的名字以发明者的名字命名:Ron Rivest, ...

    Java加密与解密的艺术配书源代码

    对称加密网络应用242 7.8 小结254 第8章高等数据加密—非对称加密算法256 8.1 非对称加密算法简述256 8.2 密钥交换算法—DH 258 8.3 典型非对称加密算法—RSA 269 8.4 常用非对称加密算法—ElGamal277 8.5 实例:非...

    Java加密与解密的艺术

    对称加密网络应用2427.8 小结254第8章高等数据加密—非对称加密算法2568.1 非对称加密算法简述2568.2 密钥交换算法—DH 2588.3 典型非对称加密算法—RSA 2698.4 常用非对称加密算法—ElGamal2778.5 实例:非对称加密...

    java 加解密算法,摘要算法和数字签名算法

    包含对称加密算法:DH,RAS,ElGamal 包含摘要算法:MD2,MD4,MD5,SHA1,SHA2(SHA-224,SHA-256,SHA-384,SHA-512) 数字签名算法:RSA,DSA,ECDSA 详情请查看:...

    Java_security:Java加密算法(Base64、MD5、AES、DES)

    非对称加密算法:com.timliu.security.asymmetric_encryption 1.DH 2.RSA 3.ElGamal 二。Base64:com.timliu.security.base64 1.JDK实现 2.common codes实现 3.bouncy castle实现 三。消息摘要算法:...

    java实现的简易版网络聊天加密通信程序

    3. 为防止中间人攻击,采用RSA非对称加密算法协助DH算法完成密钥交换。具体过程如下: a. 接收者与发送者双方各自利用RSA算法生成自己的公私钥,并生成数字证书,并在一个CA进行认证。 b. 在DH密钥交换阶段,A生成A...

    DH_DH密钥交换_

    (1)编程实现两个程序(c/s模式),两个程序之间可通过DH协议...(2)在共享密钥建立后,两个程序之间的消息交换要保证机密性(用对称加密算法和共享密钥加密)。(3)接收方能验证消息的真实性(消息完整和来源可性)

    Chat-Application-Using-AES-DH

    如果服务器和客户端都选择了完整性,机密性或两者都选择,则客户端和服务器之间将开始建立一个对称密钥对,以用于AES加密/解密以及消息身份验证代码的生成。 Diffie Hellman密钥建立协议,使用Java Crypto库实现。 ...

    Diffie–Hellman密钥交换算法.zip

    这个密钥可以在后续的通讯中作为对称密钥来加密通讯内容。 假如用户g和用户B希望交换一个密钥。 取素数p和整数g,g是p的一个原根,公开g和p。 g选择随机数Xg,并计算Yg=g^Xg mod p。 B选择随机数XB,并计算YB=g^XB ...

    mycrypto:各种加密

    HmacSHA1,HmacSHA256,HmacSHA384,HmacSHA512,CRC对称加密DES、3DES、AES、IDEA, PBE目前AES加密未被破解,为有效算法非对称加密RSA、ElGamal、椭圆曲线系列算法,DH算法DH算法:需要在%JRE_HOME%\lib\security ...

    openssl-1.0.0a

     OpenSSL一共实现了4种非对称加密算法,包括DH算法、RSA算法、DSA算法和椭圆曲线算法(EC)。DH算法一般用户密钥交换。RSA算法既可以用于密钥交换,也可以用于数字签名,当然,如果你能够忍受其缓慢的速度,那么也...

    面试:复习资料汇总

    对称加密算法:AES,DES非对称加密算法:RSA哈希算法:SHA MD5保证公钥的真实性:CA(证书颁发机构)A和B都各有一个公钥和一个私有密钥,这些密钥根据相应的算法已经生成好了。。私有密钥只保留在各自的本地,公共...

    OpenSSL-1_0_0d_Win32

    非对称加密算法 OpenSSL一共实现了4种非对称加密算法,包括DH算法、RSA算法、DSA算法和椭圆曲线算法(EC)。DH算法一般用户密钥交换。RSA算法既可以用于密钥交换,也可以用于数字签名,当然,如果你能够忍受其缓慢的...

Global site tag (gtag.js) - Google Analytics