非对称加密算法

个人博客网：https://wushaopei.github.io/    (你想要这里多有)

一、概述

因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法.

非对称加密算法需要两个密钥：公开密钥和私有密钥. 公开密钥与私有密钥是一对的，这两个共同组成一个解钥，才能实现解密。

特点： 高级、双保险

种类：

1. DH(Diffie-Hellman)密钥交换算法
2. RSA——基于因子分解  ，RSA是可以双向加密的：私钥加密，公钥解密；公钥加密，私钥解密。
3. EIGamal——基于离散对数
4. ECC(Elliptical Curve Cryptography)——椭圆曲线加密

说明：如果用公开密钥对数据进行加密,只有用对应的私有密钥才能解密. 如果用私有密钥对数据进行加密,那么只有用对应的公开密钥才能解密(某些算法有提供). 非对称加密算法实现机密信息交换的基本过程是: 甲方生成一对密钥并将其中的一把作为公用密钥向其它方公开,得到该公用密钥的乙方使用该密钥对信息进行加密后再发送给甲方. 甲方再用自己保存的另一把专用密钥对加密后的信息进行解密. 另一方面,甲方可以使用乙方提供的公钥对信息进行加密后再发送给乙方,乙方再用自己的私匙对数据进行解密.

二、密钥交换算法DH

1、DH算法概述

DH 对称加密算法：数据安全、密钥管理复杂、密钥传递过程复杂（存在密钥泄露问题）

​

非对称加密算法的特点:

算法强度复杂、安全性依赖于算法与密钥.但是由于算法复杂,使得非对称算法加解密速度没有对称算法加解密的速度快.

对称密钥体制中只有一种密钥,并且是非公开的,如果要解密就得让对方知道密钥.所以保证其安全性就是保证密钥的安全.

非对称密钥体制有两种密钥,其中一个是公开的,这样就可以不需要像对称密码那样向对方传输密钥了.因此安全性就大了很多.

对称密钥与非对称密钥比较:

• 算法复杂度:对称密钥<非对称密钥
• 加解密速度:对称密钥>非对称密钥
• 安全性:对称密钥<非对称密钥

2、DH算法实现过程及相关类详解

【1】DH加密算法 密钥交换：

初始化发送方密钥，如：

• KeyPairGenerator
• KeyPair
• PublicKey

//创建KeyPairGenerator对象  通过KeyPairGenerator来得到KeyPair类的对象，

KeyPairGenerator senderKeyPairGenerator = KeyPairGenerator.getInstance("DH");

初始化接收方密钥，如：

• KeyFactory
• X509EncodedKeySpec
• DHPublicKey
• DHParameterSpec
• KeyPairGenerator
• PrivateKey

【2】密钥构建

• KeyAgreement
• SecreKey
• Keyactory
• X509EncodedKeySpec
• PublicKey

static KeyAgreement getInstance(String algorithm)

生成实现指定密钥一致算法的KeyAgreement对象

【3】加密、解密

• Cipher

Cipher cipher = Cipher.getInstance( " DES " );

3、DH算法实现

package com.webcode.cn.des;

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.HashMap;
import java.util.Map;
import java.util.Objects;

import javax.crypto.Cipher;
import javax.crypto.KeyAgreement;
import javax.crypto.SecretKey;
import javax.crypto.interfaces.DHPrivateKey;
import javax.crypto.interfaces.DHPublicKey;
import javax.crypto.spec.DHParameterSpec;
import javax.sound.midi.Soundbank;

import org.apache.commons.codec.binary.Base64;
import org.bouncycastle.crypto.agreement.srp.SRP6Client;
import org.bouncycastle.jcajce.provider.asymmetric.X509;
import org.omg.CORBA.PUBLIC_MEMBER;

public class DH {

	static String string = "wen-min";
	public static void main(String[] args) {
		DH.jdkDH();
	}
	
	public  static void jdkDH() {
		try {
			
			//1.初始化发送方密钥
			KeyPairGenerator senderKeyPairGenerator = KeyPairGenerator.getInstance("DH");
			senderKeyPairGenerator.initialize(512);
			KeyPair senderKeyPair = senderKeyPairGenerator.generateKeyPair();
			byte[] senderPublicKeyEnc = senderKeyPair.getPublic().getEncoded();//发送方公钥，发送给接收方
			
			//2.初始化接收方密钥
			KeyFactory receiverKeyFactory = KeyFactory.getInstance("DH");
			X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(senderPublicKeyEnc);
			PublicKey receiverPublicKey = receiverKeyFactory.generatePublic(x509EncodedKeySpec);
			DHParameterSpec dhParameterSpec = ((DHPublicKey)receiverPublicKey).getParams();
			KeyPairGenerator receiverKeyPairGenerator = KeyPairGenerator.getInstance("DH");
			receiverKeyPairGenerator.initialize(dhParameterSpec);
			KeyPair receiverKeypair = receiverKeyPairGenerator.generateKeyPair();
			PrivateKey receiverPrivateKey = receiverKeypair.getPrivate();
			byte[] receiverPublicKeyEnc = receiverKeypair.getPublic().getEncoded();

			//3.密钥构建
			KeyAgreement receiverKeyAgreement = KeyAgreement.getInstance("DH");
			receiverKeyAgreement.init(receiverPrivateKey);
			receiverKeyAgreement.doPhase(receiverPublicKey,true);
			SecretKey receiverDesKey = receiverKeyAgreement.generateSecret("DES");
			
			KeyFactory senderKeyFactory = KeyFactory.getInstance("DH");
			x509EncodedKeySpec = new X509EncodedKeySpec(receiverPublicKeyEnc);
			PublicKey senderPublicKey = senderKeyFactory.generatePublic(x509EncodedKeySpec);
			KeyAgreement senderKeyAgreement =  KeyAgreement.getInstance("DH");
			senderKeyAgreement.init(senderKeyPair.getPrivate());
			senderKeyAgreement.doPhase(senderPublicKey, true);
			SecretKey senderDesKey = senderKeyAgreement.generateSecret("DES");
			if(Objects.equals(receiverDesKey, senderDesKey)) {
				System.out.println("双方密钥相同");
			}
			
			//4.加密
			Cipher cipher = Cipher.getInstance("DES");
			cipher.init(Cipher.ENCRYPT_MODE, senderDesKey);
			byte[] result = cipher.doFinal(string.getBytes());
			System.out.println("jdk dh eccrypt :" + Base64.encodeBase64String(result));
			
			//5.解密
			cipher.init(Cipher.DECRYPT_MODE, senderDesKey);
			result = cipher.doFinal(result);
			System.out.println("jdk dh decrypt : " + new String(result));
			
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}
}

执行结果：

双方密钥相同
jdk dh eccrypt :Ra+RRytG7xw=
jdk dh decrypt : wen-min

4、DH加密算法的消息传递机制：

​

1.甲方构建密钥对儿，将公钥公布给乙方，将私钥保留；双方约定数据加密算法；乙方通过甲方公钥构建密钥对儿，将公钥公布给甲方，将私钥保留。
2.甲方使用私钥、乙方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥加密数据，发送给乙方加密后的数据；乙方使用私钥、甲方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥对数据解密。
3.乙方使用私钥、甲方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥加密数据，发送给甲方加密后的数据；甲方使用私钥、乙方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥对数据解密。