DH

DH 算法的介绍

上面介绍的 DES,3DES,AES 算法都是对称密码算法，所谓对称，在上面也解释了，就是加密和解密的过程中使用相同的密钥 。而现在将要介绍的是 DH 算法，属于非对称密码算法，根据对称密码的概念，很容易知道，非对称密码算法就是解密和加密过程中使用不同密钥的算法。

对称密码算法有什么局限呢？由于加密和解密使用相同的数据，所以我们在发送密文的同时，需要将密钥发送给对方，这个时候假如我们的数据和密钥同时被黑客截获了呢？那么我们对数据加密也就失去了意义，唯一保证安全的方法就是，保证密钥不被黑客截取到，怎么才能做到呢？写在纸上亲手交给对方，这样最安全了，但是这往往不可能做到，所以才出现了非对称加密算法。

DH 算法是怎么加密的呢？ 过程比较复杂，首先我们假设发送方是 A，接受方是 B。A 首先生成公钥和密钥，将公钥发送出去，B 接收到 A发送的公钥，然后利用该公钥生成自己的公钥和密钥，再将自己的公钥 发送给 A，这个时候 A 拥有了自己的公钥，密钥和 B 的公钥，B 拥有了自己的公钥密钥和 A 的公钥。

之后， A 就可以使用 A自己的密钥 + B的公钥 获取到本地的密钥，B也是如此，这个时候 A 和 B 生成的本地密钥其实是相同的，这样的话也就变成了用相同的密钥加密，用相同的密钥解密。而且这样的话，我们数据传递过程中传递的是 A 和 B 的公钥，就算被黑客截取了也无济于事，他们不可能凭借着公钥将数据解密，从而保证了数据的安全性。

DH 算法的使用

1 . 首先就是发送方初始化密钥对（公钥 + 密钥）

public static Map initKey() throws Exception{
        // 实例化密钥对生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DH");
        //初始化密钥对生成器  默认是1024  512-1024 & 64的倍数 
        keyPairGenerator.initialize(1024);
        //生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        
        DHPublicKey dhPublicKey = (DHPublicKey) keyPair.getPublic();
        DHPrivateKey dhPrivateKey = (DHPrivateKey) keyPair.getPrivate();
        
        Map map = new HashMap<>();
        map.put(PUBLIC_KEY, dhPublicKey);
        map.put(PRIVATE_KEY, dhPrivateKey);
        
        return map;
        
    }

2 . 发送方有了自己的公钥和密钥之后，将自己的公钥发送出去，然后接收方根据收到的公钥，提取其中的参数，计算得出自己的公钥和密钥

public static Map initKey(byte[] key) throws Exception{
        // 将传进来的公钥数组转化为 PublicKey
        X509EncodedKeySpec encodedKeySpec = new X509EncodedKeySpec(key);
        
        // 实例化密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance("DH");
        
        // 产生公钥
        DHPublicKey dhPublicKey = (DHPublicKey) keyFactory.generatePublic(encodedKeySpec);
        
        // 剖析获取到的公钥，得到其参数
        DHParameterSpec dhParameterSpec = dhPublicKey.getParams();
        
        // 实例化密钥对生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DH");
        keyPairGenerator.initialize(dhParameterSpec);
        
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        DHPublicKey dhPublicKey2 = (DHPublicKey) keyPair.getPublic();
        DHPrivateKey dhPrivateKey = (DHPrivateKey) keyPair.getPrivate();
        
        Map map = new HashMap<>();
        map.put(PUBLIC_KEY, dhPublicKey2);
        map.put(PRIVATE_KEY, dhPrivateKey);
        return map;
    }

3 . 第三步就是根据对方的公钥 + 自己的密钥 计算出本地密钥

public static byte[] getSecretKey(byte[] publickey,byte[] privateKey) throws Exception{
        
        KeyFactory keyFactory = KeyFactory.getInstance("DH");
        X509EncodedKeySpec encodedKeySpec = new X509EncodedKeySpec(publickey);
        DHPublicKey dhPublicKey = (DHPublicKey) keyFactory.generatePublic(encodedKeySpec);
        
        PKCS8EncodedKeySpec encodedKeySpec2 = new PKCS8EncodedKeySpec(privateKey);
        DHPrivateKey dhPrivateKey = (DHPrivateKey) keyFactory.generatePrivate(encodedKeySpec2);
        
        KeyAgreement keyAgreement = KeyAgreement.getInstance("DH");
        keyAgreement.init(dhPrivateKey);
        keyAgreement.doPhase(dhPublicKey, true);
        
        SecretKey secretKey = keyAgreement.generateSecret("AES");
        return secretKey.getEncoded();
    }

4 . 测试，根据如上算法，我们看看 发送方计算得出的公钥和密钥以及接收方计算出的公钥和密钥，还有双方的本地密钥

public static void main(String[] args) throws Exception {

        byte[] aPublicKey;
        byte[] aPrivateKey;
        byte[] aSecretKey;
        
        byte[] bPublicKey;
        byte[] bPrivateKey;
        byte[] bSecretKey;
        
        Map aMap = DHUtil.initKey();
        aPublicKey = DHUtil.getPublic(aMap);
        System.out.println("A Public Key : " + Helper.fromByteToHex(aPublicKey));
        aPrivateKey = DHUtil.getPrivate(aMap);
        System.out.println("A Private Key : " + Helper.fromByteToHex(aPrivateKey));
        
        Map bMap = DHUtil.initKey(aPublicKey);
        bPublicKey = DHUtil.getPublic(bMap);
        System.out.println("B Public Key : " + Helper.fromByteToHex(bPublicKey));
        bPrivateKey = DHUtil.getPrivate(bMap);
        System.out.println("B Private Key : " + Helper.fromByteToHex(bPrivateKey));
        
        aSecretKey = DHUtil.getSecretKey(bPublicKey, aPrivateKey);
        System.out.println("A SecretKey : " + Helper.fromByteToHex(aSecretKey));
        bSecretKey = DHUtil.getSecretKey(aPublicKey, bPrivateKey);
        System.out.println("B SecretKey : " + Helper.fromByteToHex(bSecretKey));
        
    }

查看结果如下

这里写图片描述

根据生成的本地密钥，发送方和接收方就可以实现数据传输了，和对称密码算法中介绍的 DES，3DES,AES 相同。

也可以看到，DH 算法中公钥和密钥的长度是非常长的，所以这种方式的加密效率就没有对称算法高，这也是一种牺牲效率去换取安全性的做法。