Bootstrap

DH&ECDH密钥交互算法

1. 引言

在现代通信中，数据的安全性至关重要。无论是网络浏览、电子邮件，还是移动支付，保护数据不被窃听和篡改都是首要任务。密钥交换是保障通信安全的关键技术之一，其中最著名的两个算法是 Diffie-Hellman (DH) 和 椭圆曲线 Diffie-Hellman (ECDH)。本文将详细探讨这两种密钥交换算法的原理、实现以及它们的优缺点。

2. 背景知识
密钥交互算法的应用场景

非对称加密算法很多，而且较为安全，为什么还需要密钥交互算法呢？其主要原因就是效率问题。在实际应用中，尽管非对称加密算法具有强大的安全性，但其效率较低，不适合加密大数据。因此，密钥交换算法与非对称加密算法结合使用，能够在保证安全的同时，提供高效的数据加密方案。下面给出实际应用只使用的两个场景

TLS/SSL：在 HTTPS 通信中，TLS 协议使用密钥交换算法（如 ECDHE）来生成共享的会话密钥，然后使用该密钥对数据进行对称加密。这样既保证了加密的效率，又确保了密钥交换的安全性。

VPN：虚拟专用网络（VPN）中使用的 IPSec 协议也广泛采用密钥交换算法来生成加密通信所需的共享密钥。

对称加密与非对称加密

对称加密和非对称加密是密码学的两大基础。对称加密使用单一密钥加密和解密数据，密钥必须保密并且仅为通信双方所知。而非对称加密使用一对密钥：公钥和私钥。公钥加密数据，私钥解密数据。

在实际应用中，对称加密因其效率高而常用于大数据量的加密，而非对称加密则用于安全地交换对称加密所需的密钥。密钥交换协议（如 DH 和 ECDH）解决了在不安全的网络环境中，如何安全地交换对称加密密钥的问题。

基础数学知识

理解 DH 和 ECDH 的关键在于一些基础的数学概念：

  • 模运算（Modulo）：是除法运算后的余数计算，常用在循环计数和密码学中。
  • 离散对数问题：在模运算环境下，给定 g^x mod p = h，找到 x 是一个公认困难的问题，这为 DH 算法的安全性提供了数学保障。
3. Diffie-Hellman 密钥交换（DH）
原理介绍

Diffie-Hellman 密钥交换协议由 Whitfield Diffie 和 Martin Hellman 在 1976 年提出，是第一种实际可用的公钥协议，用于安全地交换密钥。DH 协议允许两个没有事先共享密钥的通信方通过不安全的通道生成一个共享的加密密钥。

数学解释

Diffie-Hellman 算法基于以下数学步骤：

  1. 公开参数：双方选择一个大素数 p 和一个生成元 g，这些参数是公开的。
  2. 私钥：每一方生成一个随机私钥 a 和 b，这些私钥必须保密。
  3. 公钥：双方分别计算各自的公钥 A = g^a mod p 和 B = g^b mod p，然后交换公钥。
  4. 共享密钥：双方用对方的公钥和自己的私钥计算共享密钥 K = B^a mod p = A^b mod p。由于数学性质，双方计算出的共享密钥 K 是相同的。

这里对于为什么使用一个大素数以及为什么最后可以生成一个相同的共享密钥，可以去详细了解下费马小定理和欧拉定理。

示例演示

假设：

  • p = 23
  • g = 5
  • A 选择的私钥 a = 6，计算得公钥 A = 5^6 mod 23 = 8
  • B 选择的私钥 b = 15，计算得公钥 B = 5^15 mod 23 = 19

A 和 B 交换公钥后：

  • A 计算共享密钥 K = 19^6 mod 23 = 2
  • B 计算共享密钥 K = 8^15 mod 23 = 2

因此，双方得到相同的共享密钥 K = 2，可以用于加密通信。

安全性分析

Diffie-Hellman 的安全性依赖于离散对数问题的困难性，即从 g^x mod p 推导 x 是非常困难的。因此，即使攻击者截获了公开的 p、g、A 和 B，也无法轻易计算出共享密钥 K。

4. 椭圆曲线 Diffie-Hellman 密钥交换（ECDH）
椭圆曲线密码学概述

椭圆曲线密码学 (ECC) 是一种基于椭圆曲线数学结构的公钥加密技术。与传统的基于整数和模运算的加密算法相比，ECC 在提供相同安全性的情况下，能够使用更短的密钥长度，从而提高效率。

ECDH 的工作原理

ECDH 是 DH 算法的椭圆曲线变种。它利用椭圆曲线上的点乘运算来实现密钥交换。基本步骤与 DH 类似，但操作在椭圆曲线上进行：

  1. 选择椭圆曲线参数：选择一个椭圆曲线 E 以及定义在这条曲线上的基点 G。
  2. 私钥与公钥：每一方选择一个随机私钥 d_A 和 d_B，并计算公钥 Q_A = d_A * G 和 Q_B = d_B * G，然后交换公钥。
  3. 共享密钥：双方计算共享密钥 K = d_A * Q_B = d_B * Q_A，最终的结果是相同的椭圆曲线点 K。
示例演示

假设我们使用一个简单的椭圆曲线：

  • A 选择的私钥 d_A = 5，公钥 Q_A = 5 * G
  • B 选择的私钥 d_B = 7，公钥 Q_B = 7 * G

交换公钥后：

  • A 计算共享密钥 K = 5 * Q_B
  • B 计算共享密钥 K = 7 * Q_A

最终，双方得出的共享密钥 K 是相同的椭圆曲线点。

安全性与性能分析

与传统的 DH 算法相比，ECDH 在相同的安全性下使用更短的密钥。这使得 ECDH 更适合资源受限的环境，如移动设备或嵌入式系统。此外，ECC 的计算效率更高，适用于需要快速加密操作的场景。

5. DH 与 ECDH 的比较
算法效率
  • DH：通常使用较长的密钥长度（如 2048 位或更长）以确保安全性，计算复杂度较高。
  • ECDH：使用较短的密钥长度（如 256 位）即可达到相同的安全性，计算效率更高。
应用场景
  • DH：常用于传统的加密协议如 VPN、TLS 等，需要较高安全性的场景。
  • ECDH：广泛应用于现代加密场景，如移动通信、物联网设备以及 TLS 协议中的强制性密钥交换。
优缺点总结
  • DH：安全性高，但计算复杂度较高，密钥长度较大。
  • ECDH：安全性高且计算效率高，适合资源受限环境，但实现和理解相对复杂。
6. 实践与实现
代码示例

目前可以基于很多安全库去实现这个密钥交换算法，并进行加密数据传输，这里使用最基本的java安全库来实现一个基于DH的demo示例，如果是C的开发环境也可以基于OpenSSL库来进行实现，或者基于公司内部安全库进行实现。

import javax.crypto.Cipher;
import javax.crypto.KeyAgreement;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PublicKey;
import java.util.Base64;

public class DHClient {

    private KeyPair keyPair;
    private KeyAgreement keyAgreement;

    public DHClient() throws Exception {
        // 初始化 DH 密钥对生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DH");
        keyPairGenerator.initialize(2048);
        keyPair = keyPairGenerator.generateKeyPair();

        // 初始化密钥协商
        keyAgreement = KeyAgreement.getInstance("DH");
        keyAgreement.init(keyPair.getPrivate());
    }

    public PublicKey getPublicKey() {
        return keyPair.getPublic();
    }

    public SecretKey generateSharedSecret(PublicKey serverPublicKey) throws Exception {
        keyAgreement.doPhase(serverPublicKey, true);
        byte[] sharedSecret = keyAgreement.generateSecret();
        return new SecretKeySpec(sharedSecret, 0, 16, "AES");
    }

    public static void main(String[] args) throws Exception {
        Socket socket = new Socket("localhost", 5000);
        System.out.println("客户端已连接到服务器！");

        // 创建输入输出流
        ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());
        ObjectInputStream in = new ObjectInputStream(socket.getInputStream());

        // 初始化客户端的 DH 密钥对
        DHClient client = new DHClient();

        // 接收服务器的公钥
        PublicKey serverPublicKey = (PublicKey) in.readObject();

        // 发送客户端的公钥给服务器
        out.writeObject(client.getPublicKey());
        out.flush();

        // 生成共享密钥
        SecretKey sharedSecret = client.generateSharedSecret(serverPublicKey);
        System.out.println("客户端共享密钥: " + Base64.getEncoder().encodeToString(sharedSecret.getEncoded()));

        // 接收并解密来自服务器的消息
        String encryptedMessage = (String) in.readObject();
        String decryptedMessage = decrypt(encryptedMessage, sharedSecret);
        System.out.println("客户端解密服务器消息: " + decryptedMessage);

        // 发送加密的消息给服务器
        String responseMessage = "请求用户Frank的密码";
        String encryptedResponse = encrypt(responseMessage, sharedSecret);
        out.writeObject(encryptedResponse);
        out.flush();
        System.out.println("客户端发送加密消息: " + encryptedResponse);

        // 关闭连接
        socket.close();
    }

    public static String encrypt(String data, SecretKey key) throws Exception {
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, key, new javax.crypto.spec.IvParameterSpec(new byte[16]));
        byte[] encrypted = cipher.doFinal(data.getBytes("UTF-8"));
        return Base64.getEncoder().encodeToString(encrypted);
    }

    public static String decrypt(String encryptedData, SecretKey key) throws Exception {
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(Cipher.DECRYPT_MODE, key, new javax.crypto.spec.IvParameterSpec(new byte[16]));
        byte[] original = cipher.doFinal(Base64.getDecoder().decode(encryptedData));
        return new String(original, "UTF-8");
    }
}


import javax.crypto.Cipher;
import javax.crypto.KeyAgreement;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PublicKey;
import java.util.Base64;

public class DHServer {

    private KeyPair keyPair;
    private KeyAgreement keyAgreement;

    public DHServer() throws Exception {
        // 初始化 DH 密钥对生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DH");
        keyPairGenerator.initialize(2048);
        keyPair = keyPairGenerator.generateKeyPair();

        // 初始化密钥协商
        keyAgreement = KeyAgreement.getInstance("DH");
        keyAgreement.init(keyPair.getPrivate());
    }

    public PublicKey getPublicKey() {
        return keyPair.getPublic();
    }

    public SecretKey generateSharedSecret(PublicKey clientPublicKey) throws Exception {
        keyAgreement.doPhase(clientPublicKey, true);
        byte[] sharedSecret = keyAgreement.generateSecret();
        return new SecretKeySpec(sharedSecret, 0, 16, "AES");
    }

    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(5000);
        System.out.println("服务器已启动，等待客户端连接...");

        Socket clientSocket = serverSocket.accept();
        System.out.println("客户端已连接！");

        // 创建输入输出流
        ObjectOutputStream out = new ObjectOutputStream(clientSocket.getOutputStream());
        ObjectInputStream in = new ObjectInputStream(clientSocket.getInputStream());

        // 初始化服务器的 DH 密钥对
        DHServer server = new DHServer();

        // 发送服务器的公钥给客户端
        out.writeObject(server.getPublicKey());
        out.flush();

        // 接收客户端的公钥
        PublicKey clientPublicKey = (PublicKey) in.readObject();

        // 生成共享密钥
        SecretKey sharedSecret = server.generateSharedSecret(clientPublicKey);
        System.out.println("服务器共享密钥: " + Base64.getEncoder().encodeToString(sharedSecret.getEncoded()));

        // 发送加密的消息给客户端
        String originalMessage = "用户Frank的密码是：DHTEST0808";
        String encryptedMessage = encrypt(originalMessage, sharedSecret);
        out.writeObject(encryptedMessage);
        out.flush();
        System.out.println("服务器发送加密消息: " + encryptedMessage);

        // 接收并解密来自客户端的消息
        String encryptedResponse = (String) in.readObject();
        String decryptedResponse = decrypt(encryptedResponse, sharedSecret);
        System.out.println("服务器解密客户端消息: " + decryptedResponse);

        // 关闭连接
        clientSocket.close();
        serverSocket.close();
    }

    public static String encrypt(String data, SecretKey key) throws Exception {
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, key, new javax.crypto.spec.IvParameterSpec(new byte[16]));
        byte[] encrypted = cipher.doFinal(data.getBytes("UTF-8"));
        return Base64.getEncoder().encodeToString(encrypted);
    }

    public static String decrypt(String encryptedData, SecretKey key) throws Exception {
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(Cipher.DECRYPT_MODE, key, new javax.crypto.spec.IvParameterSpec(new byte[16]));
        byte[] original = cipher.doFinal(Base64.getDecoder().decode(encryptedData));
        return new String(original, "UTF-8");
    }
}

在这里插入图片描述
在这里插入图片描述

  • 常见库和工具

    OpenSSL：一个支持 DH 和 ECDH 的开源加密库，广泛应用于各种加密协议中。

    Bouncy Castle：Java 中支持 ECC 的加密库，适合进行 ECDH 实现。

7. 常见问题与最佳实践

  • 常见问题

    密钥大小选择：选择合适的密钥长度以平衡安全性和性能。

    曲线参数选择：使用 NIST 推荐的曲线参数，以确保安全性和兼容性。

  • 安全实践

    公钥认证：结合公钥认证机制（如证书），防止中间人攻击。

    定期更新密钥：定期更新密钥交换参数，以提升安全性，如给密钥设置过期时间。

8. 总结

Diffie-Hellman 和 椭圆曲线 Diffie-Hellman 是现代加密协议中的两种重要的密钥交换算法。它们在保证通信安全方面发挥了重要作用。通过理解它们的工作原理和实现方法，可以更好地应用这些算法来保护数据安全。

9.展望

随着量子计算技术的进步，传统的密钥交换算法（如 DH 和 ECDH）可能会被量子计算机攻破。为应对这一威胁，目前也已经产生了较新的几种交互算法，如：量子安全密钥交互算法、基于 Diffie-Hellman 改进的算法（Curve25519、X25519）、基于属性的加密 (ABE)，其次在协议层面也可以进行改进，如使用 TLS 1.3、Noise Protocol Framework等等。

目前，Curve25519 和 X25519 是经典密码学中的先进密钥交换算法，广泛应用于现代安全协议。对于未来，量子安全密码学（如基于格的 Kyber 和基于编码的 McEliece）正在成为研究的焦点，旨在抵御量子计算的威胁。在考虑未来的加密需求时，逐渐过渡到量子安全密码学是必要的，而在现阶段，使用 Curve25519/X25519 或 TLS 1.3 是确保通信安全的最佳实践。

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
数据结构与算法基础篇--递归
Android低功耗蓝牙开发总结
VBD T38 T30传真的区别
Java网络编程（JavaWeb的基础）
使用 Caffeine 缓存并在业务方法上通过注解实现每3到5秒更新缓存
hive常用的inputformat
C++的正则表达式
嵌入式MCU面经（突击版）
Java技术与ZigBee短距离无线通信技术成功应用在物联网环境数据监测中心项目
【弱监督时间动作定位】A Hybrid Attention Mechanism for Weakly-Supervised Temporal Action Localization 论文阅读
;