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<String,Object> 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<String,Object> map = new HashMap<>();
map.put(PUBLIC_KEY, dhPublicKey);
map.put(PRIVATE_KEY, dhPrivateKey);

return map;

}

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

public static Map<String,Object> 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<String,Object> 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<String, Object> 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<String, Object> 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 算法中公钥和密钥的长度是非常长的，所以这种方式的加密效率就没有对称算法高，这也是一种牺牲效率去换取安全性的做法。