典型非对称加密算法RSA
 
    DH算法的诞生为后续非对称加密算法奠定了基础，较为典型的非对称加密算法（如EIGamal、RSA、ECC算法等）都是在DH算法提出后相继提出的，而且其算法核心都源于数学问题。
 
    RSA算法基于大数因子分解难题，而EIGamal算法和ECC算法则是基于离散对数难题。
 
1.简述
 
    1978年，美国麻省理工学院（MIT）的Ron Rivest、Adi Shamir和Leonand Adleman三位学者提出了一种新的非对称加密算法，这种算法以这三位学者的姓氏开头字母命名，被称为RSA算法。
 
    RSA算法是唯一被广泛采用并且实现的通用公开加密算法，目前已经成为通用非对称加密算法国际标准。不仅如此，RSA算法既可用于数据加密也可用于数字签名。
 
    RSA算法把非对称加密算法推向了一个高潮，但它并非没有缺点。相比DES以及其他对称加密算法而言，RSA算法要慢得多。作为加密算法，尤其作为非对称加密算法的典型，针对RSA算法的破解自诞生之日起就从未停止过。
 
    1999年，RSA-155（512位）被成功分解，历时5个月。
 
    2002年，RSA-158也被成功因数分解。
 
    当然，基于大数因子分解数学难题的非对称加密算法仅有RSA算法这一种，但是这不代表RSA算法后继无人。基于离散对数问题的非对称加密算法包括ElGamal和ECC两种算法，他们同样是优秀的非对称加密算法。
 

 
 
2.模型分析
 
    以消息传递模型为例，阐述基于RSA算法的消息传递模型是如何工作的。
 
    RSA算法代表了真正的非对称加密算法，其操作较之DH算法更简单。在构建密钥对方面，RSA算法就相当简单。如图1所示。
 

 
 
    在图1中，以甲乙两方收发信息为例。甲方作为信息的发送方，乙方作为信息的接收方。假设甲乙双方在消息传递之前已将RSA算法作为消息传递的加密算法。为了完成加密消息传递，甲乙双方需要以下操作：
 
    1）由消息发送的一方构建密钥对，这里由甲方完成。
 
    2）由消息发送的一方公布公钥至消息接收方，这里由甲方将公钥公布给乙方。
 
    完成这两步操作后，甲乙双方就可以进行加密消息传递了，如图2和图3所示。
 

 
 
    这里需要注意的：甲方向乙方发送数据时，使用私钥对数据进行加密处理；乙方接收到加密数据后，使用公钥对数据进行解密处理。
 
    需要注意，在非对称加密算法领域中，对于私钥加密的数据，只能使用公钥解密，简言之“私钥加密，公钥解密”。
 
    相对于“私钥加密，公钥解密”的实现，RSA算法提供了另一种加密/解密方式“公钥加密，私钥解密”。这使得乙方可以使用公钥加密数据，如图3所示。
 

 
 

 
 
    甲方可以向乙方发送加密消息，乙方也同样可以向甲方发送加密消息。在图3中，乙方使用公钥加密信息，甲方使用私钥对加密信息进行解密。这是一种“公钥加密，私钥解密”的加密解密方式。
 
    
 
3.实现
 
1）RSA算法实现（RSACoder.java）
 
 
package rsa;

import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;
import javax.security.auth.x500.X500Principal;

import org.bouncycastle.jce.X509KeyUsage;
import org.bouncycastle.x509.X509Attribute;

public abstract class RSACoder {
	//非崔晨加密算法
    private static final String KEY_ALGORITHM = "RSA";
    //公钥
    private static final String PUBLIC_KEY = "RSAPublicKey";
    //私钥
    private static final String PRIVATE_KEY = "RSAPrivateKey";
    //密钥长度
    private static final int KEY_SIZE = 1024;
    
    /**
     * 私钥解密
     * @param data 待解密数据
     * @param key 私钥
     * @return byte[] 解密数据
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] data, byte[] key) throws Exception{
    	//取得私钥
    	PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
    	KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    	//生成私钥
    	PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
    	//对数据解密
    	Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    	cipher.init(Cipher.DECRYPT_MODE, privateKey);
    	return cipher.doFinal(data);
    }
    
    /**
     * 公钥解密
     * @param data 待解密数据
     * @param key 公钥
     * @return byte[] 解密数据
     * @throws Exception
     */
    public static byte[] decryptByPublicKey(byte[] data, byte[] key) throws Exception{
    	//取得公钥
    	X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
    	KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    	//生成公钥
    	PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
    	//对数据解密
    	Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    	cipher.init(Cipher.DECRYPT_MODE, publicKey);
    	return cipher.doFinal(data);
    }
    
    /**
     * 私钥加密
     * @param data 待加密数据
     * @param key 私钥
     * @return byte[] 加密数据
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey(byte[] data, byte[] key) throws Exception{
    	//取得私钥
    	PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
    	KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    	//生成私钥
    	PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
    	//对数据加密
    	Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    	cipher.init(Cipher.ENCRYPT_MODE, privateKey);
    	return cipher.doFinal(data);
    }
    
    /**
     * 公钥加密
     * @param data 待加密数据
     * @param key 公钥
     * @return byte[] 加密数据
     * @throws Exception
     */
    public static byte[] encryptByPublicKey(byte[] data, byte[] key) throws Exception{
    	//取得公钥
    	X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
    	KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    	//生成密钥
    	PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
    	//加密数据
    	Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    	cipher.init(Cipher.ENCRYPT_MODE, publicKey);
    	return cipher.doFinal(data);
    }
    
    /**
     * 取得私钥
     * @param keyMap 私钥Map
     * @return byte[] 私钥
     * @throws Exception
     */
    public static byte[] getPrivateKey(Map<String, Object> keyMap) throws Exception{
    	Key key = (Key)keyMap.get(PRIVATE_KEY);
    	return key.getEncoded();
    }
    
    /**
     * 取得公钥
     * @param keyMap 公钥Map
     * @return byte[] 公钥
     * @throws Exception
     */
    public static byte[] getPublicKey(Map<String, Object> keyMap) throws Exception{
    	Key key = (Key)keyMap.get(PUBLIC_KEY);
    	return key.getEncoded();
    }
    
    /**
     * 初始化密钥
     * @return Map 密钥Map
     * @throws Exception
     */
    public static Map<String, Object> initKey() throws Exception{
    	//实例化密钥对生成器
    	KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
    	//初始化密钥对生成器
    	keyPairGenerator.initialize(KEY_SIZE);
    	//生成密钥对
    	KeyPair keyPair = keyPairGenerator.generateKeyPair();
    	//公钥
    	RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
    	//私钥
    	RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
    	//封装密钥
    	Map<String, Object> keyMap = new HashMap<String, Object>(2);
    	keyMap.put(PUBLIC_KEY, publicKey);
    	keyMap.put(PRIVATE_KEY, privateKey);
    	return keyMap;
    }
}


 2)RSA测试（RSATest.java） 
 
 
package rsa;

import java.util.Map;

import org.apache.commons.codec.binary.Base64;


public class RSATest {
    //公钥
	private static byte[] publicKey;
	//私钥
	private static byte[] privateKey;
	
	/**
	 * 初始化密钥
	 * @throws Exception
	 */
	public static void initKey() throws Exception{
		//初始化密钥
		Map<String, Object> keyMap = RSACoder.initKey();
		publicKey = RSACoder.getPublicKey(keyMap);
		privateKey = RSACoder.getPrivateKey(keyMap);
		System.out.println("公钥:\n" + Base64.encodeBase64String(publicKey));
		System.out.println("私钥:\n" + Base64.encodeBase64String(privateKey));
	}
	
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
        initKey();
        System.out.println("\n~~~~~~~~~~~私钥加密，公钥解密~~~~~~~~~~~~~");
        String inputStr = "坚强的意志和决心可以战胜一切困难，执着的信念和无畏的心灵才是最强大的武器。";
        byte[] data1 = inputStr.getBytes();
        System.out.println("原文:\n" + inputStr);
        //私钥加密
        byte[] encodeData1 = RSACoder.encryptByPrivateKey(data1, privateKey);
        System.out.println("加密后:\n" + Base64.encodeBase64String(encodeData1));
        //公钥解密
        byte[] decodeData1 = RSACoder.decryptByPublicKey(encodeData1, publicKey);
        System.out.println("解密后:\n" + new String(decodeData1) + "\n");
        
        initKey();
        System.out.println("\n~~~~~~~~~~~公钥加密，私钥解密~~~~~~~~~~~~~");
        byte[] data2 = inputStr.getBytes();
        System.out.println("原文:\n" + inputStr);
        //公钥加密
        byte[] encodeData2 = RSACoder.encryptByPublicKey(data2, publicKey);
        System.out.println("加密后:\n" + Base64.encodeBase64String(encodeData2));
        //私钥解密
        byte[] decodeData2 = RSACoder.decryptByPrivateKey(encodeData2, privateKey);
        System.out.println("解密后:\n" + new String(decodeData2));
	}

}


 

 
 

 
 
4.运行结果
 

 
 
    
 

 

1、几种对称性加密算法：AES,DES,3DES
 
DES是一种分组数据加密技术（先将数据分成固定长度的小数据块，之后进行加密），速度较快，适用于大量数据加密，而3DES是一种基于DES的加密算法，使用3个不同密匙对同一个分组数据块进行3次加密，如此以使得密文强度更高。
 
相较于DES和3DES算法而言，AES算法有着更高的速度和资源使用效率，安全级别也较之更高了，被称为下一代加密标准。
 2、几种非对称性加密算法：RSA,DSA,ECC
 
RSA和DSA的安全性及其它各方面性能都差不多，而ECC较之则有着很多的性能优越，包括处理速度，带宽要求，存储空间等等。

 
非对称加密算法
 
1. 密钥交换算法（DH&ECDH)
1.1 DH
1.2 ECDH
  
2. 典型非对称加密算法 - RSA
3. 常用非对称加密算法 - ElGamal

 
密钥管理是对称加密算法系统不容忽视的问题，它成为安全系统中最为薄弱的环节。为了弥补这一弱势，非对称加密算法应运而生。
 
非对称加密算法源于DH算法（Diffie-Hellman，密钥交换算法），由W.Diffie和M.Hellman共同提出。该算法为非对称加密算法奠定了基础，堪称非对称加密算法之鼻祖。
 
DH算法提出后，国际上相继出现了各种实用性更强的非对称加密算法，其构成主要是基于数学问题的求解，主要分为两类：
 
 
基于因子分解难题。RSA算法是最为典型的非对称加密算法，该算法由美国麻省理工学院（MIT）的Ron Rivest、Adi Shamir和Leonard Adleman三位学者提出，并以这三位学者的姓氏开头字母命名，称为RSA算法。RSA算法是当今应用范围最为广泛的非对称加密算法，也是第一个既能用于数据加密也能用于数字签名的算法。
 
 
基于离散对数难题。ElGamal算法由TaherElGamal提出，以自己的名字命名。该算法既可用于加密/解密，也可用于数字签名，并为数字签名算法形成标准提供参考。美国的DSS（Digital Signature Standard，数据签名标准）的DSA（Digital Signature Algorithm，数字签名算法）经ElGamal算法演变而来。
 
 
ECC（Elliptical Curve Cryptography，椭圆曲线加密）算法以椭圆曲线理论为基础，在创建密钥时可做到更快、更小，并且更有效。ECC算法通过椭圆曲线方程式的性质产生密钥，而不是采用传统的方法利用大质数的积来产生。
 
1. 密钥交换算法（DH&ECDH)
 
1.1 DH
 
对称加密算法提高数据安全性的同时带来了密钥管理的复杂性。消息收发双方若想发送加密消息，必须事先约定好加密算法并发放密钥。而如何安全的传递密钥，成为对称加密算法的一个棘手问题。密钥交换算法（Diffie-Hellman算法，简称DH算法）成为解决这一问题的金钥匙！
 

 
 
代码实现
 
public static final String KEY_ALGORITHM = "DH";
public static final String SECRET_ALGORITHM = "AES";
public static final int KEY_SIZE = 512;
public static final String PUBLIC_KEY = "DHPublicKey";
public static final String PRIVATE_KEY = "DHPrivateKey";

/**
 * 生成甲方密钥对（含公钥、私钥）
 *
 * @return map
 * @throws Exception 异常
 */
public Map<String, Object> initKey() throws Exception {
    // 初始化密钥对生成器
    final KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
    keyPairGenerator.initialize(KEY_SIZE);

    // 生成密钥对
    final KeyPair keyPair = keyPairGenerator.generateKeyPair();
    // 获取公钥
    final PublicKey publicKey = keyPair.getPublic();
    // 获取私钥
    final PrivateKey privateKey = keyPair.getPrivate();

    // 构造返回map
    Map<String, Object> keyMap = new HashMap<>();
    keyMap.put(PUBLIC_KEY, publicKey);
    keyMap.put(PRIVATE_KEY, privateKey);

    return keyMap;
}
 
/**
 * 根据甲方公钥生成乙方密钥对（含公钥、私钥）
 *
 * @param key 甲方公钥
 * @return map
 * @throws Exception 异常
 */
public Map<String, Object> initKey(byte[] key) throws Exception {
    // 解析甲方公钥
    final X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(key);
    // 实例化密钥工厂
    final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    // 产生甲方公钥
    final PublicKey aPublicKey = keyFactory.generatePublic(x509EncodedKeySpec);

    // 由甲方公钥构建乙方密钥
    final DHParameterSpec dhParameterSpec = ((DHPublicKey) aPublicKey).getParams();
    // 初始化密钥对生成器
    final KeyPairGenerator dh = KeyPairGenerator.getInstance(keyFactory.getAlgorithm());
    dh.initialize(dhParameterSpec);
    // 生成密钥对
    final KeyPair keyPair = dh.generateKeyPair();
    // 获取公钥
    final PublicKey publicKey = keyPair.getPublic();
    // 获取私钥
    final PrivateKey privateKey = keyPair.getPrivate();

    // 构造返回map
    Map<String, Object> keyMap = new HashMap<>();
    keyMap.put(PUBLIC_KEY, publicKey);
    keyMap.put(PRIVATE_KEY, privateKey);
    return keyMap;
}
 
/**
 * 生成密钥
 * @param publicKey 对方公钥
 * @param privateKey 自己私钥
 * @return 密钥
 * @throws Exception 异常
 */
public byte[] getSecretKey(byte[] publicKey, byte[] privateKey) throws Exception {
    // 初始化密钥工厂
    final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

    // 初始化公钥
    final X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKey);
    final PublicKey pubKey = keyFactory.generatePublic(x509EncodedKeySpec);

    // 初始化私钥
    final PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateKey);
    final PrivateKey priKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);

    // 实例化
    final KeyAgreement keyAgreement = KeyAgreement.getInstance(keyFactory.getAlgorithm());
    keyAgreement.init(priKey);
    keyAgreement.doPhase(pubKey, true);

    // 生成本地密钥
    final SecretKey secretKey = keyAgreement.generateSecret(SECRET_ALGORITHM);
    return secretKey.getEncoded();
}
 
/**
 * 取得公钥
 *
 * @param keyMap 密钥map
 * @return 公钥
 */
public byte[] getPublicKey(Map<String, Object> keyMap) {
    final Key key = (Key) keyMap.get(PUBLIC_KEY);
    return key.getEncoded();
}

/**
 * 取得私钥
 *
 * @param keyMap 密钥map
 * @return 私钥
 */
public byte[] getPrivateKey(Map<String, Object> keyMap) {
    final Key key = (Key) keyMap.get(PRIVATE_KEY);
    return key.getEncoded();
}
 
/**
 * 数据加密
 *
 * @param data 待加密数据
 * @param key  密钥
 * @return 加密后数据
 */
public byte[] encrypt(byte[] data, byte[] key) throws Exception {
    // 生成本地密钥
    final SecretKeySpec secretKeySpec = new SecretKeySpec(key, SECRET_ALGORITHM);
    // 数据加密
    final Cipher cipher = Cipher.getInstance(secretKeySpec.getAlgorithm());
    cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
    return cipher.doFinal(data);
}

/**
 * 数据解密
 *
 * @param data 待解密数据
 * @param key  密钥
 * @return 解密后数据
 */
public byte[] decrypt(byte[] data, byte[] key) throws Exception {
    // 生成本地密钥
    final SecretKeySpec secretKeySpec = new SecretKeySpec(key, SECRET_ALGORITHM);
    // 数据加密
    final Cipher cipher = Cipher.getInstance(secretKeySpec.getAlgorithm());
    cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
    return cipher.doFinal(data);
}
 
测试用例
 
@Test
public void testDH() throws Exception {
    final Map<String, Object> aKeyMap = initKey();
    final byte[] aPublicKey = getPublicKey(aKeyMap);
    final byte[] aPrivateKey = getPrivateKey(aKeyMap);
    System.out.println("甲方公钥：" + Base64.toBase64String(aPublicKey));
    System.out.println("甲方私钥：" + Base64.toBase64String(aPrivateKey));

    final Map<String, Object> bKeyMap = initKey(aPublicKey);
    final byte[] bPublicKey = getPublicKey(bKeyMap);
    final byte[] bPrivateKey = getPrivateKey(bKeyMap);
    System.out.println("乙方公钥：" + Base64.toBase64String(bPublicKey));
    System.out.println("乙方私钥：" + Base64.toBase64String(bPrivateKey));

    final byte[] aSecretKey = getSecretKey(bPublicKey, aPrivateKey);
    final byte[] bSecretKey = getSecretKey(aPublicKey, bPrivateKey);
    System.out.println("甲方密钥：" + Base64.toBase64String(aSecretKey));
    System.out.println("乙方密钥：" + Base64.toBase64String(bSecretKey));

    final byte[] aEncrypt = encrypt("我是阿汤哥".getBytes(), aSecretKey);
    final byte[] bDecrypt = decrypt(aEncrypt, bSecretKey);
    System.out.println("甲方加密消息：" + Base64.toBase64String(aEncrypt));
    System.out.println("乙方解密消息：" + Base64.toBase64String(bDecrypt));

    final byte[] bEncrypt = encrypt("Hello， 阿汤哥".getBytes(), bSecretKey);
    final byte[] aDecrypt = decrypt(bEncrypt, aSecretKey);
    System.out.println("乙方加密消息：" + Base64.toBase64String(bEncrypt));
    System.out.println("甲方解密消息：" + Base64.toBase64String(aDecrypt));
}
 
使用jdk8执行本用例时如果报错
 
java.security.NoSuchAlgorithmException: Unsupported secret key algorithm: AES

	at com.sun.crypto.provider.DHKeyAgreement.engineGenerateSecret(DHKeyAgreement.java:387)
	at javax.crypto.KeyAgreement.generateSecret(KeyAgreement.java:648)
	at com.jd.eps.eis.product.core.config.DHTest.getSecretKey(DHTest.java:110)
	at com.jd.eps.eis.product.core.config.DHTest.testDH(DHTest.java:183)
 
可以通过增加vm参数 -Djdk.crypto.KeyAgreement.legacyKDF=true 解决。
 
执行结果
 
甲方公钥：MIHgMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANEAAJBAMCeFF4M4gFXNabyak7DplZnTVPJCNpw9eOao4BWNrdu8ptUiTg4kwmP8bxjot873vQ7QDg4cPyTFJGZ/c3HApE=
甲方私钥：MIHSAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQzAjEA1f2vYbDfzWpVlX8ib4ftWD5q24Mzh74C0L+ze8ienkfwv41dErOl0HqZOmmf18HN
乙方公钥：MIHgMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANEAAJBAJ3BzkiX8n6RurBasjqLYwCbewwX0ZkWykCzyQj6y/4uBgNX0m+0bgPX1emxlFt/N3ueC8803OhNcprcHRxschY=
乙方私钥：MIHSAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQzAjEAqi55vmMEF5pfS4//fvfqELLlo817cCRlRMOZ+sQ9HLtroIJ16x7RWusDpK75dqxA
甲方密钥：sSVOKIBcVtQ5h806csVXzmkPZWUhC75Xp9glwAjFWhY=
乙方密钥：sSVOKIBcVtQ5h806csVXzmkPZWUhC75Xp9glwAjFWhY=
甲方加密消息：DPftIVbpAGj7dkF73QB4zw==
乙方解密消息：我是阿汤哥
乙方加密消息：FTZnyPN+ZAzdqU4vEKjkMCo6U0TLlKPDyL3zoBSGvvQ=
甲方解密消息：Hello， 阿汤哥
 
1.2 ECDH
 
JDK8没有ECDH的实现，需要添加Provider。
 
Security.addProvider(new BouncyCastleProvider());
 
根据甲方公钥生成乙方密钥对时需对ParameterSpec进行调整。
 
/**
 * 根据甲方公钥生成乙方密钥对（含公钥、私钥）
 *
 * @param key 甲方公钥
 * @return map
 * @throws Exception 异常
 */
public Map<String, Object> initKey(byte[] key) throws Exception {
    // 解析甲方公钥
    final X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(key);
    // 实例化密钥工厂
    final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    // 产生甲方公钥
    final PublicKey aPublicKey = keyFactory.generatePublic(x509EncodedKeySpec);

    // 由甲方公钥构建乙方密钥
    final ECParameterSpec ecParameterSpec = ((ECPublicKey) aPublicKey).getParams();
    // 初始化密钥对生成器
    final KeyPairGenerator dh = KeyPairGenerator.getInstance(keyFactory.getAlgorithm());
    dh.initialize(ecParameterSpec);
    // 生成密钥对
    final KeyPair keyPair = dh.generateKeyPair();
    // 获取公钥
    final PublicKey publicKey = keyPair.getPublic();
    // 获取私钥
    final PrivateKey privateKey = keyPair.getPrivate();

    // 构造返回map
    Map<String, Object> keyMap = new HashMap<>();
    keyMap.put(PUBLIC_KEY, publicKey);
    keyMap.put(PRIVATE_KEY, privateKey);
    return keyMap;
}
 
2. 典型非对称加密算法 - RSA
 

 
 
代码实现
 
public static final String KEY_ALGORITHM = "RSA";
public static final int KEY_SIZE = 512;
public static final String PUBLIC_KEY = "DHPublicKey";
public static final String PRIVATE_KEY = "DHPrivateKey";

/**
 * 生成甲方密钥对（含公钥、私钥）
 *
 * @return map
 * @throws Exception 异常
 */
public Map<String, Object> initKey() throws Exception {
    // 初始化密钥对生成器
    final KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
    keyPairGenerator.initialize(KEY_SIZE);

    // 生成密钥对
    final KeyPair keyPair = keyPairGenerator.generateKeyPair();
    // 获取公钥
    final PublicKey publicKey = keyPair.getPublic();
    // 获取私钥
    final PrivateKey privateKey = keyPair.getPrivate();

    // 构造返回map
    Map<String, Object> keyMap = new HashMap<>();
    keyMap.put(PUBLIC_KEY, publicKey);
    keyMap.put(PRIVATE_KEY, privateKey);

    return keyMap;
}

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

/**
 * 取得私钥
 *
 * @param keyMap 密钥map
 * @return 私钥
 */
public byte[] getPrivateKey(Map<String, Object> keyMap) {
    final Key key = (Key) keyMap.get(PRIVATE_KEY);
    return key.getEncoded();
}
 
/**
 * 使用私钥加密数据
 *
 * @param data       待加密数据
 * @param privateKey 私钥
 * @return 加密后数据
 */
public byte[] encryptByPrivateKey(byte[] data, byte[] privateKey) throws Exception {
    // 获取私钥
    final PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateKey);
    final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    // 生成私钥
    final PrivateKey priKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
    // 数据加密
    final Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.ENCRYPT_MODE, priKey);
    return cipher.doFinal(data);
}

/**
 * 使用公钥解密数据
 *
 * @param data      待解密数据
 * @param publicKey 公钥
 * @return 解密后数据
 */
public byte[] decryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {
    // 获取公钥
    final X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKey);
    final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    // 生成公钥
    final PublicKey pubKey = keyFactory.generatePublic(x509EncodedKeySpec);
    // 数据加密
    final Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.DECRYPT_MODE, pubKey);
    return cipher.doFinal(data);
}
 
/**
 * 使用公钥加密数据
 *
 * @param data      待解密数据
 * @param publicKey 公钥
 * @return 解密后数据
 */
public byte[] encryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {
    // 获取公钥
    final X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKey);
    final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    // 生成公钥
    final PublicKey pubKey = keyFactory.generatePublic(x509EncodedKeySpec);
    // 数据加密
    final Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.ENCRYPT_MODE, pubKey);
    return cipher.doFinal(data);
}

/**
 * 使用私钥解密数据
 *
 * @param data       待加密数据
 * @param privateKey 私钥
 * @return 加密后数据
 */
public byte[] decryptByPrivateKey(byte[] data, byte[] privateKey) throws Exception {
    // 获取私钥
    final PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateKey);
    final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    // 生成私钥
    final PrivateKey priKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
    // 数据加密
    final Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.DECRYPT_MODE, priKey);
    return cipher.doFinal(data);
}
 
@Test
public void testRSA() throws Exception {
    Security.addProvider(new BouncyCastleProvider());

    final Map<String, Object> aKeyMap = initKey();
    final byte[] aPublicKey = getPublicKey(aKeyMap);
    final byte[] aPrivateKey = getPrivateKey(aKeyMap);
    System.out.println("甲方公钥：" + Base64.toBase64String(aPublicKey));
    System.out.println("甲方私钥：" + Base64.toBase64String(aPrivateKey));


    final byte[] aEncrypt = encryptByPrivateKey("我是阿汤哥".getBytes(), aPrivateKey);
    final byte[] bDecrypt = decryptByPublicKey(aEncrypt, aPublicKey);
    System.out.println("甲方：使用甲方私钥加密消息：" + Base64.toBase64String(aEncrypt));
    System.out.println("乙方：使用甲方公钥解密消息：" + new String(bDecrypt));

    final byte[] bEncrypt = encryptByPublicKey("Hello， 阿汤哥".getBytes(), aPublicKey);
    final byte[] aDecrypt = decryptByPrivateKey(bEncrypt, aPrivateKey);
    System.out.println("乙方：使用甲方公钥加密消息：" + Base64.toBase64String(bEncrypt));
    System.out.println("甲方：使用甲方私钥解密消息：" + new String(aDecrypt));
}
 
执行结果
 
甲方公钥：MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAJ7vEoMQFnSZq8tIKydTxeZQZbg3EzZ+uoqMB6xYUz0bJKTLBE2VdT8SKmhCFjyBLzRla8bCl5EtLB/S3F/isD0CAwEAAQ==
甲方私钥：MIIBUwIBADANBgkqhkiG9w0BAQEFAASCAT0wggE5AgEAAkEAnu8SgxAWdJmry0grJ1PF5lBluDcTNn66iowHrFhTPRskpMsETZV1PxIqaEIWPIEvNGVrxsKXkS0sH9LcX+KwPQIDAQABAkAePbMyCP+c1BiiJ2s+omwHdMjGEoSvW9G2xwo2ut+rwo+UiKX/OXtjggNL32sOG/VBpmwQnCzhHXlM3Uf/AyLBAiEA0j02vlbqrkb4eLLTX/K1ZXk05xFMaxjCfqIdv9VwqykCIQDBhxD/jP48lN/I/cNQjg4710e46gL5U3TvDfmpXZYS9QIgYAHkRfebJAr03OmM7XwAql43cm3L3/xmlT2jKD9oPEECIBAgRh1VTVYU/bTM2Hqc67i2zqYs8cR+3M6StowTXU8FAiAp+LnIyULp1obJN9ZnLRv5RldROa9Evj94cfDq3gu+QQ==
甲方：使用甲方私钥加密消息：lK3A3bNyxV1xc34st8fOtIy5vyjTL1zm7wbU9v5mV21t0hxf1ZLTdvN5+vZPSylF3th0c0KqSdGNLpaazvEYSg==
乙方：使用甲方公钥解密消息：我是阿汤哥
乙方：使用甲方公钥加密消息：msiUhALltZYWQdpDWpp6X4wmDCR3ZVGw4d3AqYBnnwDloNDBivpBhT4LgWseX7x74GpgKFA1g/mpsKCIoXqOiw==
甲方：使用甲方私钥解密消息：Hello， 阿汤哥
 
3. 常用非对称加密算法 - ElGamal
 

 
 
代码实现
 
public static final String KEY_ALGORITHM = "ElGamal";
public static final int KEY_SIZE = 256;
public static final String PUBLIC_KEY = "ElGamalPublicKey";
public static final String PRIVATE_KEY = "ElGamalPrivateKey";

/**
 * 生成甲方密钥对（含公钥、私钥）
 *
 * @return map
 * @throws Exception 异常
 */
public Map<String, Object> initKey() throws Exception {
    // 加入BouncyCastleProvider支持
    Security.addProvider(new BouncyCastleProvider());
    // 实例化算法参数生成器
    final AlgorithmParameterGenerator apg = AlgorithmParameterGenerator.getInstance(KEY_ALGORITHM);
    // 初始化算法生成器
    apg.init(KEY_SIZE);
    // 生成算法参数
    final AlgorithmParameters parameters = apg.generateParameters();
    // 构建参数材料
    final DHParameterSpec dhParameterSpec = parameters.getParameterSpec(DHParameterSpec.class);
    // 实例化密钥对生成器
    final KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
    keyPairGenerator.initialize(dhParameterSpec, new SecureRandom());

    // 生成密钥对
    final KeyPair keyPair = keyPairGenerator.generateKeyPair();
    // 获取公钥
    final PublicKey publicKey = keyPair.getPublic();
    // 获取私钥
    final PrivateKey privateKey = keyPair.getPrivate();

    // 构造返回map
    Map<String, Object> keyMap = new HashMap<>();
    keyMap.put(PUBLIC_KEY, publicKey);
    keyMap.put(PRIVATE_KEY, privateKey);

    return keyMap;
}

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

/**
 * 取得私钥
 *
 * @param keyMap 密钥map
 * @return 私钥
 */
public byte[] getPrivateKey(Map<String, Object> keyMap) {
    final Key key = (Key) keyMap.get(PRIVATE_KEY);
    return key.getEncoded();
}
 
/**
 * 使用公钥加密数据
 *
 * @param data      待解密数据
 * @param publicKey 公钥
 * @return 解密后数据
 */
public byte[] encryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {
    Security.addProvider(new BouncyCastleProvider());
    // 获取公钥
    final X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKey);
    final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    // 生成公钥
    final PublicKey pubKey = keyFactory.generatePublic(x509EncodedKeySpec);
    // 数据加密
    final Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.ENCRYPT_MODE, pubKey);
    return cipher.doFinal(data);
}

/**
 * 使用私钥解密数据
 *
 * @param data       待加密数据
 * @param privateKey 私钥
 * @return 加密后数据
 */
public byte[] decryptByPrivateKey(byte[] data, byte[] privateKey) throws Exception {
    Security.addProvider(new BouncyCastleProvider());
    // 获取私钥
    final PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateKey);
    final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    // 生成私钥
    final PrivateKey priKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
    // 数据加密
    final Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.DECRYPT_MODE, priKey);
    return cipher.doFinal(data);
}
 
@Test
public void testRSA() throws Exception {
    Security.addProvider(new BouncyCastleProvider());

    final Map<String, Object> bKeyMap = initKey();
    final byte[] bPublicKey = getPublicKey(bKeyMap);
    final byte[] bPrivateKey = getPrivateKey(bKeyMap);
    System.out.println("乙方公钥：" + Base64.toBase64String(bPublicKey));
    System.out.println("乙方私钥：" + Base64.toBase64String(bPrivateKey));

    final byte[] aEncrypt = encryptByPublicKey("我是阿汤哥".getBytes(), bPublicKey);
    final byte[] bDecrypt = decryptByPrivateKey(aEncrypt, bPrivateKey);
    System.out.println("甲方：使用乙方公钥加密消息：" + Base64.toBase64String(aEncrypt));
    System.out.println("乙方：使用乙方私钥解密消息：" + new String(bDecrypt));
}
 
执行结果
 
乙方公钥：MHYwTwYGKw4HAgEBMEUCIQD3Tow0iMrSnqcab/qk3sixGNZsFqerw5TZS8AthdG9/wIgVwGItAIOERVrOUQuvYUf4iBgNedVcIVEMpmCAAF67GsDIwACICuSrF+jA6g2XGfFjtP8zmZWA0LstwQQgsMBB6AYuA1/
乙方私钥：MHgCAQAwTwYGKw4HAgEBMEUCIQD3Tow0iMrSnqcab/qk3sixGNZsFqerw5TZS8AthdG9/wIgVwGItAIOERVrOUQuvYUf4iBgNedVcIVEMpmCAAF67GsEIgIgS99qTF3QgAjIKNcpPaA5jnTSp6AUOqb1XhOGGtr75iw=
甲方：使用乙方公钥加密消息：3sdh+pOViDQWU8aDO/LC1SnK427qrFc8PHrMVyE+k7MbL7tQHbq+5I7MZ0vz7WAc6ysAvVZU9pg8YcQvoYWoEw==
乙方：使用乙方私钥解密消息：我是阿汤哥

        比如说我们去银行存钱取钱，用到密码，密码是基于数学的，我们来讨论下关于密码学的问题：
         有一种加密算法叫做对称加密，对称加密是以前比较常见的一种加密方式。所谓对称加密的意思是说假如有一个人A，他想把一个信号m传递给B，他不能直接将这个信息传递给B，否则会有人可能会窃听。于是通过一些算法，比如通过加一个数字e变成了一个新的数字C，他把C传递给B，B接收到C之后再减去那个e就会得到原来的数字m。
 
 

        比如想要传递2  e=1 2+1=3    B接收到3之后3-1=2    ，于是我们就知道m了
 在这个过程中，我们将
 
m称为明文，就是我们希望表达的含义
C我们称之为密文，就是我们可以公开传递的一个信息
e就是密钥，密钥是要保密的，我们不可以告诉其他人
        算法其实可以比较复杂，不一定是加一个数字，他可能是m乘以e得到一个数字得到C，我们得到C之后可以除以e。也可以是m的e次方，得到一个数字，我们再开e次根号就可以了。算法可以非常复杂，但是再复杂也存在被窃听的可能，因为可以穷举，比如他一次又一次的尝试以前的算法，他还可以通过数字的频率，比如在英文的26个字母中，在一段话中出现的频率不一样，他只要截取到足够多的密文，一次又一次的尝试，他就可以把你的密钥给试出来，所以密钥是不保险的。
 
        于是人们就想能不能我们发一段文字之后就换一个密钥。再发一段文字，我再换一个密钥，这样别人就不知道我说的是什么了。但是问题是密钥的分发又成为了一个问题，你怎么才可以把这个e安全的传给B，你派一个人去传这样 的效率很低，你打电话给B，B有可能会被监听。所以密钥分发是一件非常麻烦的事情，那么现在的量子保密通信就可以实现密钥分发的保密性。
 
        那么除了这种对称加密以外，现在比较流行的一种算法叫做非对称加密。A想把一个信息m传递给B。首先B先干这么一件事情。B生成两个有相互关系的数字，这两个有相关性的数字，一个叫做e，一个叫做d。那么这个e就叫做公钥，公共的钥匙，而这个d就叫做私钥，私人的钥匙。然后B先把这个e公钥传递给A，可以通过公开的方式传递，这样的话我不怕你窃听。我告诉你公钥是什么，然后这个A通过这种公钥e的某一个算法得到一个密文C。然后再通过公开的方式将这个密文传递给B，那么这个不对称性就体现在这个地方了。通过密文求解原文的过程，不是减去e，而是要减去d，通过减去一个d我们就可以得到明文m。也就是说，这个d和e是有一定的关系的，我经过加密的时候，我是用的e对数字进行加密，我解密的时候呢，需要用到d数字进行解密
         我传递公钥的过程的我不怕你窃听。因为就算是你窃听了，你也不会知道这个密钥是什么。所以你窃听了我的公钥和密文之后，你依然无法得到明文，这个就是非对称加密的方式。
 
 
        那么非对称加密是基于什么样的一个数学原理呢？我们接下来的时间会来介绍一种典型的非对称加密方式，叫做RSA加密算法。敬请期待！
 
        撒花✿✿ヽ(°▽°)ノ✿！！！