非对称密码之DH密钥交换算法

最新推荐文章于 2023-07-11 22:51:17 发布
最新推荐文章于 2023-07-11 22:51:17 发布
阅读量1.7w 收藏 56
点赞数 9
分类专栏： Encryption&Decryption 文章标签： DH
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zbw18297786698/article/details/53609794
版权

1、DH算法的简介

DH，全称为“Diffie-Hellman”，他是一种确保共享KEY安全穿越不安全网络的方法，也就是常说的密钥一致协议。由公开密钥密码体制的奠基人Diffie和Hellman所提出的一种思想。
简单的说就是允许两名用户在公开媒体上交换信息以生成“一致”的、可以共享的密钥。也就是由甲方产出一对密钥（公钥、私钥），乙方依照甲方公钥产生乙方密钥对（公钥、私钥）。

 以此为基线，作为数据传输保密基础，同时双方使用同一种对称加密算法构建本地密钥（SecretKey）对数据加密。这样，在互通了本地密钥（SecretKey）算法后，甲乙双方公开自己的公钥，使用对方的公钥和刚才产生的私钥加密数据，同时可以使用对方的公钥和自己的私钥对数据解密。不单单是甲乙双方两方，可以扩展为多方共享数据通讯，这样就完成了网络交互数据的安全通讯！

2、DH算法的通信模型
    2.1  甲方将自己的公钥发给乙方
   
    2.2  乙方根据甲方发来的公钥，生成自己的公钥和私钥
   
    2.3  乙方将自己的公钥发送给甲方
    
    2.4  甲方和乙方，生成一样的秘钥。用于加密数据
 
3、DH算法的数学原理
      
4、JDK实现
      
5、DH算法的编程步骤
     5.1  生成密钥对
        
     5.2  使用公钥私钥生成本地密钥
      
6、DH算法的实现
DHUtil.java 
import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyAgreement;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.interfaces.DHPrivateKey;
import javax.crypto.interfaces.DHPublicKey;
import javax.crypto.spec.DHParameterSpec;

public class DHUtil {
	/**
	 * 定义加密方式
	 */
	private static final String KEY_DH = "DH";
	public static final String PUBLIC_KEY = "DHPublicKey";
	public static final String PRIVATE_KEY = "DHPrivateKey";
	// 开始生成本地密钥SecretKey 密钥算法为对称密码算法
	// 可以为 DES DES AES
	public static final String KEY_DH_DES = "DES";

	/**
	 * 甲方初始化并返回密钥对
	 * 
	 * @return
	 */
	public static Map<String, Object> initKey() {
		try {
			// 实例化密钥对生成器
			KeyPairGenerator keyPairGenerator = KeyPairGenerator
					.getInstance(KEY_DH);
			// 初始化密钥对生成器 默认是1024 512-1024 & 64的倍数
			keyPairGenerator.initialize(1024);
			// 生成密钥对
			KeyPair keyPair = keyPairGenerator.generateKeyPair();
			// 得到甲方公钥
			DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic();
			// 得到甲方私钥
			DHPrivateKey privateKey = (DHPrivateKey) keyPair.getPrivate();
			// 将公钥和私钥封装在Map中， 方便之后使用
			Map<String, Object> keyMap = new HashMap<String, Object>();
			keyMap.put(PUBLIC_KEY, publicKey);
			keyMap.put(PRIVATE_KEY, privateKey);
			return keyMap;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}

	}

	/**
	 * 乙方根据甲方公钥初始化并返回密钥对
	 * 
	 * @param key
	 *            甲方的公钥
	 * @return
	 */
	public static Map<String, Object> initKey(byte[] key) {
		try {
			// 将甲方公钥从字节数组转换为PublicKey
			X509EncodedKeySpec keySpec = new X509EncodedKeySpec(key);
			// 实例化密钥工厂
			KeyFactory keyFactory = KeyFactory.getInstance(KEY_DH);
			// 产生甲方公钥pubKey
			DHPublicKey dhPublicKey = (DHPublicKey) keyFactory
					.generatePublic(keySpec);
			// 剖析甲方公钥，得到其参数
			DHParameterSpec dhParameterSpec = dhPublicKey.getParams();
			// 实例化密钥对生成器
			KeyPairGenerator keyPairGenerator = KeyPairGenerator
					.getInstance(KEY_DH);
			// 用甲方公钥初始化密钥对生成器
			keyPairGenerator.initialize(dhParameterSpec);
			// 产生密钥对
			KeyPair keyPair = keyPairGenerator.generateKeyPair();
			// 得到乙方公钥
			DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic();
			// 得到乙方私钥
			DHPrivateKey privateKey = (DHPrivateKey) keyPair.getPrivate();
			// 将公钥和私钥封装在Map中， 方便之后使用
			Map<String, Object> keyMap = new HashMap<String, Object>();
			keyMap.put(PUBLIC_KEY, publicKey);
			keyMap.put(PRIVATE_KEY, privateKey);
			return keyMap;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}

	}

	/**
	 * 根据对方的公钥和自己的私钥生成 本地密钥,返回的是SecretKey对象的字节数组
	 * 
	 * @param publicKey
	 *            公钥
	 * @param privateKey
	 *            私钥
	 * @return
	 */
	public static byte[] getSecretKeyBytes(byte[] publicKey, byte[] privateKey) {
		try {
			// 实例化密钥工厂
			KeyFactory keyFactory = KeyFactory.getInstance(KEY_DH);
			// 将公钥从字节数组转换为PublicKey
			X509EncodedKeySpec pubKeySpec = new X509EncodedKeySpec(publicKey);
			PublicKey pubKey = keyFactory.generatePublic(pubKeySpec);
			// 将私钥从字节数组转换为PrivateKey
			PKCS8EncodedKeySpec priKeySpec = new PKCS8EncodedKeySpec(privateKey);
			PrivateKey priKey = keyFactory.generatePrivate(priKeySpec);

			// 准备根据以上公钥和私钥生成本地密钥SecretKey
			// 先实例化KeyAgreement
			KeyAgreement keyAgreement = KeyAgreement.getInstance(KEY_DH);
			// 用自己的私钥初始化keyAgreement
			keyAgreement.init(priKey);
			// 结合对方的公钥进行运算
			keyAgreement.doPhase(pubKey, true);
			// 开始生成本地密钥SecretKey 密钥算法为对称密码算法
			SecretKey secretKey = keyAgreement.generateSecret(KEY_DH_DES);
			return secretKey.getEncoded();
		} catch (Exception e) {
			throw new RuntimeException(e);
		}

	}

	/**
	 * 根据对方的公钥和自己的私钥生成 本地密钥,返回的是SecretKey对象
	 * 
	 * @param publicKey
	 *            公钥
	 * @param privateKey
	 *            私钥
	 * @return
	 */
	public static SecretKey getSecretKey(byte[] publicKey, byte[] privateKey) {
		try {
			// 实例化密钥工厂
			KeyFactory keyFactory = KeyFactory.getInstance(KEY_DH);
			// 将公钥从字节数组转换为PublicKey
			X509EncodedKeySpec pubKeySpec = new X509EncodedKeySpec(publicKey);
			PublicKey pubKey = keyFactory.generatePublic(pubKeySpec);
			// 将私钥从字节数组转换为PrivateKey
			PKCS8EncodedKeySpec priKeySpec = new PKCS8EncodedKeySpec(privateKey);
			PrivateKey priKey = keyFactory.generatePrivate(priKeySpec);

			// 准备根据以上公钥和私钥生成本地密钥SecretKey
			// 先实例化KeyAgreement
			KeyAgreement keyAgreement = KeyAgreement.getInstance(KEY_DH);
			// 用自己的私钥初始化keyAgreement
			keyAgreement.init(priKey);
			// 结合对方的公钥进行运算
			keyAgreement.doPhase(pubKey, true);
			// 开始生成本地密钥SecretKey 密钥算法为对称密码算法
			SecretKey secretKey = keyAgreement.generateSecret(KEY_DH_DES);
			return secretKey;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}

	}

	/**
	 * 从 Map 中取得公钥
	 * 
	 * @param keyMap
	 * @return
	 */
	public static byte[] getPublicKey(Map<String, Object> keyMap) {
		DHPublicKey key = (DHPublicKey) keyMap.get(PUBLIC_KEY);
		return key.getEncoded();
	}

	/**
	 * 从 Map 中取得私钥
	 * 
	 * @param keyMap
	 * @return
	 */
	public static byte[] getPrivateKey(Map<String, Object> keyMap) {
		DHPrivateKey key = (DHPrivateKey) keyMap.get(PRIVATE_KEY);
		return key.getEncoded();
	}

	/**
	 * DH 加密
	 * 
	 * @param data
	 *            带加密数据
	 * @param publicKey
	 *            甲方公钥
	 * @param privateKey
	 *            乙方私钥
	 * @return
	 */
	public static byte[] encryptDH(byte[] data, byte[] publicKey,
			byte[] privateKey) {
		byte[] bytes = null;
		try {
			//
			SecretKey secretKey = getSecretKey(publicKey, privateKey);
			// 数据加密
			Cipher cipher = Cipher.getInstance(secretKey.getAlgorithm());
			cipher.init(Cipher.ENCRYPT_MODE, secretKey);
			bytes = cipher.doFinal(data);
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (BadPaddingException e) {
			e.printStackTrace();
		} catch (IllegalBlockSizeException e) {
			e.printStackTrace();
		}
		return bytes;
	}

	/**
	 * DH 解密
	 * 
	 * @param data
	 *            待解密数据
	 * @param publicKey
	 *            乙方公钥
	 * @param privateKey
	 *            甲方私钥
	 * @return
	 */
	public static byte[] decryptDH(byte[] data, byte[] publicKey,
			byte[] privateKey) {
		byte[] bytes = null;
		try {
			//
			SecretKey secretKey = getSecretKey(publicKey, privateKey);
			// 数据加密
			Cipher cipher = Cipher.getInstance(secretKey.getAlgorithm());
			cipher.init(Cipher.DECRYPT_MODE, secretKey);
			bytes = cipher.doFinal(data);
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (BadPaddingException e) {
			e.printStackTrace();
		} catch (IllegalBlockSizeException e) {
			e.printStackTrace();
		}
		return bytes;
	}

}
字节数组转16进制 
public class BytesToHex {

	public static String fromBytesToHex(byte[] resultBytes) {
		StringBuilder builder = new StringBuilder();
		for (int i = 0; i < resultBytes.length; i++) {
			if (Integer.toHexString(0xFF & resultBytes[i]).length() == 1) {
				builder.append("0").append(
						Integer.toHexString(0xFF & resultBytes[i]));
			} else {
				builder.append(Integer.toHexString(0xFF & resultBytes[i]));
			}
		}
		return builder.toString();
	}

}
测试代码 
import java.util.Map;

public class Test {
	// 待加密的明文
	public static final String DATA = "test";

	public static void main(String[] args) throws Exception {
		/* Test DH */
		// 甲方公钥
		byte[] publicKey1;
		// 甲方私钥
		byte[] privateKey1;
		// 甲方本地密钥
		byte[] secretKey1;
		// 乙方公钥
		byte[] publicKey2;
		// 乙方私钥
		byte[] privateKey2;
		// 乙方本地密钥
		byte[] secretKey2;

		// 初始化密钥 并生成甲方密钥对
		Map<String, Object> keyMap1 = DHUtil.initKey();
		publicKey1 = DHUtil.getPublicKey(keyMap1);
		privateKey1 = DHUtil.getPrivateKey(keyMap1);
		System.out
				.println("DH 甲方公钥 : " + BytesToHex.fromBytesToHex(publicKey1));
		System.out.println("DH 甲方私钥 : "
				+ BytesToHex.fromBytesToHex(privateKey1));

		// 乙方根据甲方公钥产生乙方密钥对
		Map<String, Object> keyMap2 = DHUtil.initKey(publicKey1);
		publicKey2 = DHUtil.getPublicKey(keyMap2);
		privateKey2 = DHUtil.getPrivateKey(keyMap2);
		System.out
				.println("DH 乙方公钥 : " + BytesToHex.fromBytesToHex(publicKey2));
		System.out.println("DH 乙方私钥 : "
				+ BytesToHex.fromBytesToHex(privateKey2));

		// 对于甲方， 根据其私钥和乙方发过来的公钥， 生成其本地密钥secretKey1
		secretKey1 = DHUtil.getSecretKeyBytes(publicKey2, privateKey1);
		System.out.println("DH 甲方 本地密钥 : "
				+ BytesToHex.fromBytesToHex(secretKey1));

		// 对于乙方， 根据其私钥和甲方发过来的公钥， 生成其本地密钥secretKey2
		secretKey2 = DHUtil.getSecretKeyBytes(publicKey1, privateKey2);
		System.out.println("DH 乙方 本地密钥 : "
				+ BytesToHex.fromBytesToHex(secretKey2));
		// ---------------------------
		// 测试数据加密和解密
		System.out.println("加密前的数据" + DATA);
		// 甲方进行数据的加密
		// 用的是甲方的私钥和乙方的公钥
		byte[] encryptDH = DHUtil.encryptDH(DATA.getBytes(), publicKey2,
				privateKey1);
		System.out.println("加密后的数据 字节数组转16进制显示"
				+ BytesToHex.fromBytesToHex(encryptDH));
		// 乙方进行数据的解密
		// 用的是乙方的私钥和甲方的公钥
		byte[] decryptDH = DHUtil.decryptDH(encryptDH, publicKey1, privateKey2);
		System.out.println("解密后数据:" + new String(decryptDH));
	}
}

Bwz_Learning
关注
专栏目录
【通俗易懂+案例】DH密钥交换算法
计算机视觉之光
06-25 178
(1)Alice和Bob交换掩盖了他们各自私钥的公钥；(2)双方均使用对方的公钥和己方的私钥计算出共享密钥；(3)敌手通过观察公钥不能获得私钥的任何信息，更不能计算出共享密钥。
一文读懂密钥交换（DH、ECDH）算法（附密码国标下载）
最新发布
所有成功的背后，都是痛苦的坚持，所有的痛苦，都是傻瓜般的不放弃!
09-17 1542
密钥交换算法的核心在于通过数学难题（如离散对数问题）来确保密钥交换的安全性。Diffie-Hellman密钥交换算法和椭圆曲线密钥交换算法是目前广泛使用的两种密钥交换算法，它们分别基于有限域上的离散对数问题和椭圆曲线上的离散对数问题，确保了密钥交换的安全性和可靠性。若大家对密码算法感兴趣，推荐阅读密码算法/技术相关的国标，关注博主微信公众号并发送消息『20240917』获取所有网络安全相关高清PDF国标文档。
DH秘钥交换算法
05-15
基于NTL算法库C++实现 &里面包含NTL算法库的静态库文件
DH密钥交换算法
热门推荐
NowOrNever
01-04 6万+
迪菲－赫尔曼密钥交换（Diffie–Hellman key exchange，简称“D–H”） 是一种安全协议。 它可以让双方在完全没有对方任何预先信息的条件下通过不安全信道建立起一个密钥。这个密钥可以在后续的通讯中作为对称密钥来加密通讯内容。 (1)、算法描述 离散对数的概念： 原根：如果a是素数p的一个原根，那么数值：             a mod p，a^2 mod
密钥交换算法
记录个人学习、笔记
11-15 3606
DH 密钥交换，全称 Diffie-Hellman key exchange，它可以让双方在完全没有对方任何预先信息的条件下通过不安全信道创建起一个密钥，这个密钥可以在后续的通讯中作为对称密钥来加密通讯内容。其原理使用了数论中的一个简单的推论，从理论上保证了其加密的可靠性。虽然如此，DH 密钥交换并不是完全安全的，攻击人可能会通过中间人通讯进行攻击，可以说用心险恶虽然 DH 密钥交换算法的雏形是 Hellman 和 Diffie 两个人先在一篇论文中先提出的，但是该算法的概念是 Merkle 提出的。所以当
密钥交换算法——DH算法
HSQdePYZ的博客
07-11 679
在之前的对称加密算法中，基于"密钥"解决了数据加密和解密的问题，但在实际案例开发中，密钥该如何传递呢？在不安全的信道上传递加密文件是没有问题的,因为黑客拿到加密文件没有用。但是,如何在不安全的信道上安全地传输密钥?DH算法(Diffie-Hellman算法)。DH算法解决了密钥在双方不直接传递密钥的情况下完成密钥交换,这个神奇的交换原理完全由数学理论的支持。DH算法是一种密钥交换协议,通信双方通过不安全的信道协商密钥,然后进行对称加密传输。
DH密钥交换算法Java实现
01-06
DH密钥交换算法这个机制的巧妙在于它可以让双方在完全没有对方任何预先信息的条件下通过不安全信道确定对称密钥。 我用Java写了两个例子，有需要的可以看看。
DH_DH密钥交换_
09-30
（1）编程实现两个程序（c/s模式），两个程序之间可通过DH协议...（2）在共享密钥建立后，两个程序之间的消息交换要保证机密性（用对称加密算法和共享密钥加密）。（3）接收方能验证消息的真实性（消息完整和来源可性）
java密钥交换算法DH定义与应用实例分析
08-25
DH密钥交换算法可以解决对称加密中的密钥传递问题。DH算法的主要特点是： 1. 安全性高：DH算法基于大数理论，具有很高的安全性。 2. 算法复杂度低：DH算法的计算复杂度相对较低，适合大多数应用场景。 3. 可扩展性...
DH密钥交换，C++代码
09-16
DH密钥交换的代码，别人写的，拿来给大家分享。
密码学——Diffie-Hellman密钥交换协议
12-06
密码学课程设计 用MFC做的关于Diffie-Hellman密钥交换协议
c语言实现DH算法加密
01-06
c语言编写的DH算法，借鉴学习 A系统构建密钥：构建一对公私密钥Private Key1和Public Key1； A系统向B系统公布自己的公钥（Public Key1）； B系统使用A公布的公钥（Public Key1）建立一对密钥：Private Key2和Public Key2； B系统向A系统公布自己的公钥Public Key2； A系统使用自己的私钥Private Key1和B系统的公钥Public Key2构建本地密钥； B系统使用自己的私钥Private Key2和A系统的公钥Public Key1构建本地密钥；
DH密钥交换协议c语言,eclipse实现可认证的DH密钥交换协议
weixin_33653182的博客
05-22 1710
可认证的DH密钥交换协议，供大家参考，具体内容如下一、实验目的通过使用密码学库实现可认证的DH密钥交换协议(简化STS协议)，能够编写简单的实验代码进行正确的协议实现和验证。二、实验要求1、熟悉DH密钥交换算法基本原理；2、理解原始DH密钥交换算法存在的中间人攻击；3、理解简化STS协议抗中间人攻击的原理。4、掌握使用java编写实验代码进行正确的简化STS协议实现和验证。三、 开发环境JDK 1...
DH 密钥交换算法
MichaelAn的博客
03-30 1046
DH 算法(Diffie-Hellman) 是一种密钥交换协议，它可以让双方在不泄漏密钥的情况下协商出一个密钥来。
dh密钥协商算法c语言实现
06-06
DH密钥协商算法可以用于双方安全地生成对称密钥，实现加密通信。C语言的实现需要以下步骤： 1、选择两个质数p和g，其中p是一个足够大的素数，g是一个原根。 2、Alice和Bob各自生成一个私钥a和b，并计算公钥A和B：A = g^a mod p，B = g^b mod p。 3、Alice接收到Bob的公钥B后，计算共享密钥K：K = B^a mod p。 4、Bob接收到Alice的公钥A后，同样计算共享密钥K：K = A^b mod p。 5、最后得到的K就是双方安全地共享的对称密钥。 以下是DH密钥协商算法的C语言实现： ```c #include<stdio.h> #include<stdlib.h> #include<math.h> int power(int g, int a, int p) { int res = 1; while(a) { if(a & 1) res = res*g % p; g = g*g % p; a >>= 1; } return res; } int main() { int p = 23, g = 5; //选择质数p和原根g int a = 4, b = 3; //生成Alice和Bob的私钥 int A = power(g, a, p), B = power(g, b, p); //计算公钥A和B int K1 = power(B, a, p), K2 = power(A, b, p); //双方计算共享密钥K printf("双方共享的对称密钥：K = %d\n", K1); return 0; } ``` 以上C代码实现了DH密钥协商算法，其中的power函数用于计算g的a次方对p取模的结果。对于不同的p和g，只需改变代码中的参数即可得到不同的共享密钥。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值