密钥交换算法 - Java加密与安全

密钥交换算法

我们在使用对称加密算法的时候,我们用的是同一个密钥key

我们以AES加密为例,当我们需要加密明文,我们需要一个随机生成的key,作为密钥进行加解密,最后我们的问题是如何传递密钥

因为不给对方密钥,对方就不能解密,而直接传递密钥,就会被黑客监听,所以问题就变成了如何在不安全的信道上

如何安全的传输密钥

密钥算法也就是Diffie-Hellman算法,简称DH算法,他就是为了解决这个问题的,p=509,g=5,A=215,

你收到以后,他也选择一个随机数b,例如456,然后得到g的b次方,然后对p取余数,结果是181,然后计算S等于A的b次方,

除以p的余数,结果是121,乙把计算的B发给甲,甲计算S等于B的a次方,除以p的余数,结果计算的s相同,也是121,

所以最后双方协商的密钥,是121,要注意这个密钥并没有在网络上传输,通过网络传输的是p,g,A,B,但是通过这4个

数,黑客是无法推算出S的,所以更确切的说,DH算法是密钥协商算法,双方最终协商一个共同的密钥

我们把小a看成是甲的密钥,大A看成是甲的公钥,小b看成是乙的私钥,大b看成是公钥,DH的算法本质是各自生成自己的

公钥和私钥,然后交换公钥,并且根据自己的私钥和对方的公钥,生成最终的私钥,DH算法通过数学

package com.learn.securl;

import java.io.IOException;
import java.math.BigInteger;
import java.security.GeneralSecurityException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

import javax.crypto.Cipher;
import javax.crypto.KeyAgreement;
import javax.crypto.SecretKey;

public class DH {
	
	/**
	 * 我们写一个main方法来测试DH协商协议
	 * @param args
	 */
	public static void main(String[] args) {
		// Bob 和 Alice
		/**
		 * 首先我们创建两个Person对象
		 * 一个是Bob,一个是Alice
		 */
		Person bob = new Person("Bob");
		Person alice = new Person("Alice");
		// 各自生成KeyPair：
		/**
		 * 然后Bob和Alice各自生成自己的KeyPair
		 */
		bob.generateKeyPair();
		alice.generateKeyPair();
		// 双方交换各自的PublicKey：
		// Bob根据Alice的PublicKey生成自己的本地密钥：
		/**
		 * 紧接着各自交换publicKey
		 * 由于Bob需要Alice的publicKey生成自己的本地密钥
		 * 所以我们对Bob调用generateSecretKey的时候
		 * 我们需要传入alice.publicKey.getEncoded()
		 */
		bob.generateSecretKey(alice.publicKey.getEncoded());
		// Alice根据Bob的PublicKey生成自己的本地密钥：
		/**
		 * 同样的Alice是通过bob的publicKey来生成自己的本地密钥
		 */
		alice.generateSecretKey(bob.publicKey.getEncoded());
		// 检查双方本地密钥是否相同
		/**
		 * 我们来看一下他们的本地密钥是否相同
		 * 如果双方的SecretKey是相同的
		 * 那么后序的通信就可以使用这个SecretKey
		 * AES加解密
		 * 我们看到Bob的privateKey和publicKey以及Bob生成的secretKey
		 * 我们再来看Alice的privateKey和publicKey以及Alice生成的secretKey
		 * 我们注意到Alice的SecretKey和Bob的SecretKey他们是相同的
		 * 所以在后序的通讯中,
		 * Bob和Alice可以使用这两个相同的key以及AES的加解密
		 */
		bob.printKeys();
		alice.printKeys();
		// 双方的SecretKey相同，后续通信将使用SecretKey作为密钥进行AES加密
		String msgBobToAlice = bob.sendMessage("Hello, Alice!");
		System.out.println("Bob -> Alice: " + msgBobToAlice);
		String aliceDecrypted = alice.receiveMessage(msgBobToAlice);
		System.out.println("Alice decrypted: " + aliceDecrypted);
	}
}

/**
 * 我们首先定义了一个Person类
 * @author Leon.Sun
 *
 */
class Person {
	/**
	 * 我们定义了一个name字段,表示Person名字
	 */
	public final String name;
	/**
	 * publicKey表示public Key
	 */
	public PublicKey publicKey;
	/**
	 * privateKey表示private Key
	 */
	private PrivateKey privateKey;
	/**
	 * 这个把表示最后生成的secretKey
	 */
	private SecretKey secretKey;
	
	/**
	 * 我们定义个方法来初始化Person的名字
	 * @param name
	 */
	public Person(String name) {
		this.name = name;
	}
	/**
	 * 生成本地KeyPair
	 * 
	 * 紧接着我们定义一个generateKeyPair
	 */
	public void generateKeyPair() {
		try {
			/**
			 * 我们通过KeyPairGenerator.getInstance传入DH表示我们要生成KeyPairGenerator
			 * 用于DH算法
			 */
			KeyPairGenerator kpGen = KeyPairGenerator.getInstance("DH");
			/**
			 * 表示我们要生成512位的keyPair
			 */
			kpGen.initialize(512);
			/**
			 * 我们通过generateKeyPair所获得一个KeyPair对象
			 */
			KeyPair kp = kpGen.generateKeyPair();
			/**
			 * 紧接着我们通过getPrivate和getPublic分别获得了privateKey和publicKey
			 */
			this.privateKey = kp.getPrivate();
			this.publicKey = kp.getPublic();
		} catch (GeneralSecurityException e) {
			throw new RuntimeException(e);
		}
	}
	/**
	 * 生成密钥
	 * 
	 * 当通信的双方把publicKey交给双方的时候,
	 * 我们都可以从对方接收到public key这个字节中回复public key对象
	 * 
	 * @param receivedPubKeyBytes
	 */
	public void generateSecretKey(byte[] receivedPubKeyBytes) {
		try {
			// 从byte[]恢复PublicKey
			/**
			 * 我们通过X509EncodedKeySpec这个类传入收到的字节数组
			 * 就可以恢复公钥
			 */
			X509EncodedKeySpec keySpec = new X509EncodedKeySpec(
					receivedPubKeyBytes);
			KeyFactory kf = KeyFactory.getInstance("DH");
			/**
			 * 我们可以通过generatePublic
			 */
			PublicKey receivedPublicKey = kf.generatePublic(keySpec);
			// 生成本地密钥：
			/**
			 * 我们通过KeyAgreement.getInstance传入DH得到一个KeyAgreement对象
			 */
			KeyAgreement keyAgreement = KeyAgreement.getInstance("DH");
			/**
			 * 然后我们通过init方法传入自己的private key
			 */
			keyAgreement.init(this.privateKey); // 自己的PrivateKey
			/**
			 * 然后我们通过doPhase传入对方的publicKey,
			 */
			keyAgreement.doPhase(receivedPublicKey, true);// 对方的PublicKey
			// 生成AES密钥：
			/**
			 * 这个时候我们通过generateSecret传入AES表示我们要生成一个AES的密钥
			 * 这个SecretKey就是我们将来要用的密钥
			 */
			this.secretKey = keyAgreement.generateSecret("AES");
		} catch (GeneralSecurityException e) {
			throw new RuntimeException(e);
		}
	}
	/**
	 * 打印密钥
	 * 
	 * 我们用printKeys打印privateKey,publicKey,secretKey
	 */
	public void printKeys() {
		System.out.printf("Name: %s\n", this.name);
		System.out.printf("Private key: %x\n", new BigInteger(1,
				this.privateKey.getEncoded()));
		System.out.printf("Public key: %x\n",
				new BigInteger(1, this.publicKey.getEncoded()));
		System.out.printf("Secret key: %x\n",
				new BigInteger(1, this.secretKey.getEncoded()));
	}
	/**
	 * 发送加密消息
	 * 
	 * 我们用sendMessage方法用来测试AES加密
	 * 
	 * @param message
	 * @return
	 */
	public String sendMessage(String message) {
		try {
			Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
			cipher.init(Cipher.ENCRYPT_MODE, this.secretKey);
			byte[] data = cipher.doFinal(message.getBytes("UTF-8"));
			return Base64.getEncoder().encodeToString(data);
		} catch (GeneralSecurityException | IOException e) {
			throw new RuntimeException(e);
		}
	}
	/**
	 * 接收加密消息并解密
	 * 
	 * 我们用receiveMessage来测试收到的信息,
	 * 并且用AES解密
	 * 
	 * @param message
	 * @return
	 */
	public String receiveMessage(String message) {
		try {
			Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
			cipher.init(Cipher.DECRYPT_MODE, this.secretKey);
			byte[] data = cipher.doFinal(Base64.getDecoder().decode(message));
			return new String(data, "UTF-8");
		} catch (GeneralSecurityException | IOException e) {
			throw new RuntimeException(e);
		}
	}
}

DH算法不能避免中间人攻击,如果黑客假冒乙和甲交互密钥,同时又假冒乙和甲交互密钥,他就可以成功的进行攻击


最后我们总结一下:

1. DH算法是一种密钥交换协议,通信双方通过一个不安全的信道协商密钥,然后进行对称加密传输

2. DH算法并没有解决中间人攻击的问题