非对称加密算法
我们从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. 只使用非对称加密是不能够防止中间人的攻击