非对称加密算法 - Java加密与安全

非对称加密算法

我们从DH算法中可以看到密钥对是一种非常有用的加密算法

密钥对中publicKey是可以公开的,而privateKey则是需要保密的,由此奠定了非对称加密的基础

非对称加密就是加密和解密使用的是不同的密钥,使用非对称加密的时候,使用同一个公钥和私钥对才能够正常的加密解密,

1. 在加密的时候使用自己的私钥加密,然后发送给对方

2. 然后解密的时候使用自己的公钥来解密

另一种方法是

1. 使用对方的公钥加密,然后发送给对方

2. 解密的时候可以用自己的私钥解密

非对称加密的典型算法就是RSA算法,RSA算法是三个发明人的缩写

package com.learn.securl;

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.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

import javax.crypto.Cipher;

/**
 * 在非对称加密的时候,
 * 我们先定义一个RSAKeyPair这个类
 * @author Leon.Sun
 *
 */
public class RSAKeyPair {
	/**
	 * 私钥
	 * 
	 * 他包含了一个私钥privateKey
	 */
	PrivateKey sk;
	/**
	 * 公钥
	 * 
	 * 一个公钥publicKey
	 */
	PublicKey pk;
	
	/**
	 * 生成公钥/私钥对
	 * 
	 * 我们在构造方法中生成一个公钥和私钥对
	 * @throws GeneralSecurityException
	 */
	public RSAKeyPair() throws GeneralSecurityException{
		/**
		 * 创建公钥和私钥对的方法是
		 * 通过KeyPairGenerator.getInstance然后传入算法RSA
		 */
		KeyPairGenerator kpGen = KeyPairGenerator.getInstance("RSA");
		/**
		 * 紧接着我们调用initialize方法
		 * 然后传入1024
		 * 表示我们生成的密钥长度是1024位
		 */
		kpGen.initialize(1024);
		/**
		 * 紧接着我们调用generateKeyPair方法
		 * 就生成了一个KeyPair
		 */
		KeyPair kp = kpGen.generateKeyPair();
		/**
		 * 我们通过getPrivate和getPublic分别获得privateKey和publicKey
		 * 我们通常用pk来表示publicKey
		 * 用sk表示privateKey
		 */
		this.sk = kp.getPrivate();
		this.pk = kp.getPublic();
	}
	/**
	 * 从以保存的字节中（例如：读取文件）恢复公钥/私钥
	 * 
	 * 传入的是字节,
	 * 我们可以从已保存的字节中恢复公钥和私钥
	 * @param pk
	 * @param sk
	 * @throws GeneralSecurityException
	 */
	public RSAKeyPair(byte[] pk, byte[] sk) throws GeneralSecurityException{
		KeyFactory kf = KeyFactory.getInstance("RSA");
		/**
		 * 恢复公钥是构造一个X509EncodedKeySpec对象
		 */
		X509EncodedKeySpec pkSpec = new X509EncodedKeySpec(pk);
		/**
		 * 然后就可以通过generatePublic方法来恢复一个公钥
		 */
		this.pk = kf.generatePublic(pkSpec);
		/**
		 * 而恢复私钥则是通过PKCS8EncodedKeySpec来恢复私钥
		 */
		PKCS8EncodedKeySpec skSpec = new PKCS8EncodedKeySpec(sk);
		this.sk = kf.generatePrivate(skSpec);
	}
	/**
	 * 把私钥导出为字节
	 * 
	 * @return
	 */
	public byte[] getPrivateKey(){
		/**
		 * 我们可以通过getPrivateKey方法可以把私钥导出为一个字节
		 */
		return this.sk.getEncoded();
	}
	/**
	 * 把公钥导出为字节
	 * @return
	 */
	public byte[] getPublicKey(){
		/**
		 * 我们也可以通过getEncoded方法把公钥导出为一个字节
		 */
		return this.pk.getEncoded();
	}
	/**
	 * 用公钥加密
	 * @param message
	 * @return
	 * @throws GeneralSecurityException
	 */
	public byte[] encrypt(byte[] message) throws GeneralSecurityException{
		/**
		 * 我们还是通过看Cipher.getInstance传入RSA
		 * 得到一个Cipher对象
		 */
		Cipher cipher = Cipher.getInstance("RSA");
		/**
		 * 然后我们初始化ENCRYPT_MODE,用于加密
		 * 这个时候我们传入的是公钥
		 * 表示用公钥加密
		 */
		cipher.init(Cipher.ENCRYPT_MODE, this.pk);
		/**
		 * 最后doFinal就可以得到加密以后的密文
		 */
		return cipher.doFinal(message);
	}
	/**
	 * 用私钥解密 
	 * 
	 * 我们再定义一个decrypt方法
	 * @param input
	 * @return
	 * @throws GeneralSecurityException
	 */
	public byte[] decrypt(byte[] input) throws GeneralSecurityException{
		Cipher cipher = Cipher.getInstance("RSA");
		/**
		 * 这个时候我们传入的是DECRYPT_MODE
		 * 并且传入的是私钥,表示用私钥解密
		 */
		cipher.init(Cipher.DECRYPT_MODE, this.sk);
		return cipher.doFinal(input);
	}
	
	/**
	 * 最后我们定义一个main方法来测试
	 * @param args
	 * @throws Exception
	 */
	public static void main(String[] args) throws Exception{
		// 明文：
		byte[] plain = "Hello，使用RSA非对称加密算法对数据进行加密！".getBytes();
		// 创建公钥/私钥对：
		/**
		 * 我们首先创建一个RSAKeyPair对象
		 */
		RSAKeyPair rsa = new RSAKeyPair();
		// 加密：
		/**
		 * 然后调用encrypt方法进行加密
		 */
		byte[] encrypted = rsa.encrypt(plain);
		System.out.println("encrypted: " + Base64.getEncoder().encodeToString(encrypted));
		// 解密：
		/**
		 * 然后调用decrypt方法进行解密
		 */
		byte[] decrypted = rsa.decrypt(encrypted);
		System.out.println("decrypted: " + new String(decrypted, "UTF-8"));
		// 保存公钥/私钥：
		/**
		 * 我们还把RSA的publicKey和privateKey导出为byte数组
		 */
		byte[] pk = rsa.getPublicKey();
		byte[] sk = rsa.getPrivateKey();
		System.out.println("pk: " + Base64.getEncoder().encodeToString(pk));
		System.out.println("sk: " + Base64.getEncoder().encodeToString(sk));
		// 重新恢复公钥/私钥：
		/**
		 * 然后我们把byte数组重新恢复为公钥和私钥
		 */
		RSAKeyPair rsa2 = new RSAKeyPair(pk, sk);
		// 加密：
		byte[] encrypted2 = rsa2.encrypt(plain);
		System.out.println("encrypted: " + Base64.getEncoder().encodeToString(encrypted2));
		// 解密：
		byte[] decrypted2 = rsa2.decrypt(encrypted2);
		System.out.println("decrypted: " + new String(decrypted2, "UTF-8"));
	}
}

非对称加密有以下的优点:

1. 对称加密需要协商密钥,而非对称加密可以安全的公开各自的公钥

2. 如果N个人之间需要通信的话,使用非对称加密只需要每个人管理各自的密钥对,总共需要N个密钥对

3. 而使用对称加密需要N*(N-1)/密钥,每个人需要管理N-1个密钥

非对称的缺点是运算速度慢

如果只使用非对称加密,不能防止中间人的攻击


最后我们总结一下:

1. 非对称加密是加密和解密使用的是不同的密钥

2. 只有同一个公钥和私钥才能够正常的加密和解密

3. 只使用非对称加密是不能够防止中间人的攻击