对称加密与非对称加密详解
文章主要是对加密算法这一块的梳理，包含了对称加密、非对称加密、DH密钥交换和消息摘要算法的关键参数和代码实现，所有代码经过实际测试，可以正常使用。
1、加密算法分类
一般的对称加密可以从加密算法、加密模式（根据模式不同，可能会有初始化向量，用于第一块明文的加密）、填充方式和密钥长度这四个方面确定，非对称加密从加密算法、填充方式和密钥模长三个方面确定。
如下图，其实加密算法大致分为以下几类，对称加密和非对称加密的
2、加密模式分类
加密模式是指在加密过程中，对数据进行分组和加密的方式，下面按对称加密和非对称加密分开说明：
对称加密的加密模式有：ECB、CBC、CFB、OFB、CTR等等，除了ECB模式，其他的模式都需要初始化向量。
- ECB模式（电子密码本模式）：将明文分割为固定长度的块来进行加密，每个块独立使用相同的密钥进行加密生成密文，不存在数据关联，安全性较低。
- CBC模式（密文分组链接模式）：使用前一块的密文与当前块异或，然后加密生成密文，以此产生关联性，提高数据加密的安全性。
- CFB模式（密码反馈模式）：将前一块的密文作为输入加密后，与当前块进行异或运算，产生新的密文块。
- OFB模式（输出反馈模式）：将初始化向量加密，然后与当前块进行异或运算，产生新的密文块，然后将初始化向量加密后的输出再次加密，与下一块进行异或运算，产生下一个密文快。
- CTR模式（计数器模式）：使用一个计数器和一个随机数初始化向量来加密输入的数据，然后按位与或操作将密钥流与明文数据相位异或，以生成密文数据。
非对称加密没有加密模式，允许加密的数据长度和加密的密钥模长有关系，例如1024位，2048位等等；1024位对应128字节，为了防止数据长度不够，引入了PKCS#1填充方式，固定占据了11个字节，所以真实可用的长度是117位
3、填充方式
加密算法使用块加密的方式对明文进行加密，需要将明文划分为固定大小的块进行加密操作。如果明文的长度不足一个块大小，就需要用填充方式将其扩充至一个完整的块大小，否则加密过程会出错。填充方式的目的是使明文长度能够被块大小整除，同时还可以防止攻击者通过分析加密结果来推断明文的长度和内容，增强了加密算法的可靠性和安全性，下面列举一下常见的填充方式。
3.1、PKCS#1_PADDING
指定了RSA 密码加密和签名算法的标准，其定义了一种填充方式来确保输入长度对于RSA算法适合。
- PKCS1Padding_V1.5是RSA默认的填充方式。
该填充方式会将原数据D（Data）转换为加密块EB（Encryption Block）,其组成如下：EB = 00 + BT + PS + 00 + D。
00：最开头的00为保留位；
BT：表示标志字节，有三个值0x00、0x01、0x02，其中00和01用于私钥的操作，02用于公钥的加密。
PS：表示填充数据，如果BT是00，则填充数据全是0x00，如果BT是01，填充数据全是0xFF，如果BT是02，填充数据为随机生成的非零字节（这意味着相同的公钥和原数据，每次加密出来的数据也不相同）；
00：是原数据开头的字节。
由此可以知道00、BT和00就需要三个字节，而PKCS#1标准建议PS的最小长度为8，所以填充数据至少要占到3+8 = 11个字节，1024模长的密钥一次最多能加密的明文长度为 1024/8 - 11 = 128 - 11 = 117个字节
- RSA_PKCS1_OAEP_PADDING填充模式是PKCS#1推出的新填充方式。
RSA_PKCS1_PADDING（V1.5）的缺点是无法验证解密的结果的正确性，为了解决这个问题，在密文的计算中加入了原文的hash值，在RAS的填充方案中属于安全性最高的一种，代价则是该填充方式最少需要占据41个字节。
3.2、RSA_NO_PADDING
是一种在RSA加密、解密过程中不进行数据填充的方式。仅支持固定长度的原始数据块，建议使用场景较为有限，并且数据长度不够时，加密时需要手动的补充数据，解密时需要手动裁剪掉补充的数据。
3.3、PKCS#7_PADDING
每个填充字节的值都等于填充的字节数，例如，若需要填充5个字节，则填充的字节为0x05。这种填充方式可用于块大小在1-255的加密算法。
3.4、PKCS#5_PADDING
PKCS#5_PADDING与PKCS#7_PADDING是一致的，支持的块大小不一样。v2.0以及更早版本，说明只能填充8字节块大小的数据。但是在PKCS#5_PADDING v2.1中，将AES加入进来了，所以PKCS#5_PADDING与PKCS#7_PADDING在AES中是一致的，没有区别，都是都支持16字节的块填充。
3.5、ZeroPadding
在原始数据后面填充0，保证数据块长度一致，简单易用，但是存在缺点，比如数据块中可能有本来就是0的数据，会导致导致填充异常，无法区分是原始数据还是填充数据，实际中比较少用。
3.6、ISO10126Padding
该填充方式，随机数填充到块长度的整数倍，填充数为需要填充的字节数，最后一个字节填充填充数。因为填充随机数不可预测，提高了数据的安全性，常用于AES和DES加密。
4、对称加密算法-AES
明确：算法名称、加密模式和填充方式即可，部分加密模式有的需要初始化向量，密钥长度按实际情况确定。
java.crypto包下是一些加解密常用的类，Cipher类里面的注释如下。可以看到，java标准库支持部分的加解密算法、加密模式和填充方式。其不支持CFB的加密模式，也不支持PKC7Padding的填充方式，等等。
如果需要扩展，则需要引入额外的第三方jar包，BouncyCastle就是一个提供了很多哈希算法和加密算法的第三方库，它提供了Java标准库没有的一些算法，依赖如下：
4.1、依赖引入
bcprov-jdk18on，此处的18表示支持jdk1.8及其以上版本，如果jdk是低版本可以自行选择对应版本的依赖。
<dependency>
<groupId>org.bouncycastle</groupId>
<artifactId>bcprov-jdk18on</artifactId>
<version>1.75</version>
</dependency>4.2、示例代码
下面是AES/CBC/PKCS7Padding的示例代码，可以根据需要修改算法名称例如AES/CFB/PKCS5Padding等等
package org.example;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import javax.crypto.Cipher;
import javax.crypto.CipherInputStream;
import javax.crypto.CipherOutputStream;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.io.File;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.StandardOpenOption;
import java.security.Security;
public class AESEncryptFile {
private static final String key = "aUIJE89aw3no93jl";
private static final String iv = "1234567890123456";
static {
try {
//增加BouncyCastle
Security.addProvider(new BouncyCastleProvider());
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws Exception {
//测试密钥长度为16位(128bit)
String source = "E:\\testFileEncrypt\\对比测试.zip";
String dest = "E:\\testFileEncrypt\\16_encrypt_file" + ".zip";
//加密
encryptFile(source, dest, key.getBytes(StandardCharsets.UTF_8));
//解密
String s = "E:\\testFileEncrypt\\16_encrypt_file" + ".zip";
String d = "E:\\testFileEncrypt\\16_decrypt_file" + ".zip";
decryptFile(s, d, key.getBytes(StandardCharsets.UTF_8));
}
public static void encryptFile(String sourceFilePath,
String destFilePath,
byte[] key) throws Exception {
File file = new File(sourceFilePath);
if (file.exists() && file.isFile()) {
File dest = new File(destFilePath);
if (dest.exists() || dest.createNewFile()) {
//指定加密算法
SecretKeySpec spec = new SecretKeySpec(key, "AES");
//指定加密模式和填充方式
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding");
byte[] ivBytes = iv.getBytes(StandardCharsets.UTF_8);
cipher.init(Cipher.ENCRYPT_MODE, spec, new IvParameterSpec(ivBytes));
try (InputStream in = Files.newInputStream(file.toPath(), StandardOpenOption.READ);
OutputStream o = Files.newOutputStream(dest.toPath(), StandardOpenOption.WRITE);
CipherInputStream cin = new CipherInputStream(in, cipher)) {
byte[] buffer = new byte[2048];
int readNum;
while ((readNum = cin.read(buffer)) != -1) {
o.write(buffer, 0, readNum);
}
}
}
}
}
public static void decryptFile(String sourceFilePath,
String destFilePath,
byte[] key) throws Exception {
File file = new File(sourceFilePath);
if (file.exists() && file.isFile()) {
File dest = new File(destFilePath);
if (dest.exists() || dest.createNewFile()) {
//指定加密算法
SecretKeySpec spec = new SecretKeySpec(key, "AES");
//指定加密模式和填充方式
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding");
//调用不同的Cipher的init方法，区分是否需要初化向量（初始化向量的字符串长度，需要和密钥长度相同）
byte[] ivBytes = iv.getBytes(StandardCharsets.UTF_8);
cipher.init(Cipher.DECRYPT_MODE, spec, new IvParameterSpec(ivBytes));
try (InputStream in = Files.newInputStream(file.toPath(), StandardOpenOption.READ);
OutputStream o = Files.newOutputStream(dest.toPath(), StandardOpenOption.WRITE);
CipherOutputStream cOut = new CipherOutputStream(o, cipher)) {
byte[] buffer = new byte[2048];
int readNum;
while ((readNum = in.read(buffer)) != -1) {
cOut.write(buffer, 0, readNum);
}
}
}
}
}
}5、非对称加密算法-RSA
RAS属于非对称加密，加解密的密钥不相同，分为公私钥，公私钥是配对的。私钥用来解密和签名，公钥用来加密和验签。一般的使用场景是，自己生成公私钥对，自己保存私钥，给别人提供公钥（可以提供公钥base64编码的字符串），别人公钥加密数据，自己私钥解密数据。签名一般用作身份认证，自己提供出去了公钥，调用别人接口时，需要私钥加密（签名），用户通过公钥解密（验签），解密成功验证身份。
5.1、示例代码
package org.example;
import javax.crypto.Cipher;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
public class SecurityRSA {
private static String src = "hello RAS 1024";
public static void main(String[] args) {
testRSA();
}
public static void testRSA() {
try {
//初始化密钥对
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
//指定模长
keyPairGenerator.initialize(1024);
KeyPair keyPair = keyPairGenerator.generateKeyPair();
RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
//公钥和私钥base64字符串
String publicKeyBase64Str = Base64.getEncoder().encodeToString(rsaPublicKey.getEncoded());
String privateKeyBase64Str = Base64.getEncoder().encodeToString(rsaPrivateKey.getEncoded());
System.out.println("公钥Base64字符串：" + publicKeyBase64Str);
System.out.println("私钥Base64字符串：" + privateKeyBase64Str);
System.out.println("原始数据 : " + src);
byte[] result;
//私钥签名
Key privateKey = getRSAPrivateKey(privateKeyBase64Str);
result = encrypt(privateKey, src);
System.out.println("私钥加密后的Base64字符串 : " + Base64.getEncoder().encodeToString(result));
//公钥验签
Key publicKey = getRASPuplicKey(publicKeyBase64Str);
System.out.println("公钥解密后的数据：" + decrypt(publicKey, result));
//公钥加密
publicKey = getRASPuplicKey(publicKeyBase64Str);
result = encrypt(publicKey, src);
System.out.println("公钥加密后的Base64字符串 : " + Base64.getEncoder().encodeToString(result));
//私钥解密
privateKey = getRSAPrivateKey(privateKeyBase64Str);
System.out.println("私钥解密后的数据：" + decrypt(privateKey, result));
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 获取私钥
*
* @param privateKey 私钥Base64编码字符串
* @return
* @throws Exception
*/
public static Key getRSAPrivateKey(String privateKey) throws Exception {
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
byte[] bytes = Base64.getDecoder().decode(privateKey);
PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(bytes);
return keyFactory.generatePrivate(pkcs8EncodedKeySpec);
}
/**
* 获取公钥
*
* @param publicKey 公钥Base64编码字符串
* @return
* @throws Exception
*/
public static Key getRASPuplicKey(String publicKey) throws Exception {
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
byte[] bytes = Base64.getDecoder().decode(publicKey);
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(bytes);
return keyFactory.generatePublic(x509EncodedKeySpec);
}
/**
* 加密数据
*
* @param key 加密的key
* @param str 原始数据字符串
* @return 加密后的比特数组
* @throws Exception
*/
public static byte[] encrypt(Key key, String str) throws Exception {
Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
cipher.init(Cipher.ENCRYPT_MODE, key);
return cipher.doFinal(str.getBytes());
}
/**
* 解密数据
*
* @param key 解密的key
* @param encryptData 加密后的比特数组
* @return 解密后的字符串
* @throws Exception
*/
public static String decrypt(Key key, byte[] encryptData) throws Exception {
Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
cipher.init(Cipher.DECRYPT_MODE, key);
byte[] decryptData = cipher.doFinal(encryptData);
return new String(decryptData);
}
}6、DH密钥交换
DH密钥交换和RSA是不同的，DH算法的目的是解决在通信安全之前的密钥配送问题，常规的密钥配送有三种方式：1、线下的约定；2、公钥配置方式，例如RSA的公钥加密密钥，然后私钥解密，这样两方就安全的拿到了密钥。3、DH密钥交换算法，通过公开的参数，两边就可以计算得到相同的密钥，密钥不在网络中传输。
6.1、DH密钥交换过程
原理就是通过公开的大素数g和原根p生成自己的公私钥，然后交换彼此的公钥，最后根据对方的公钥和自己的私钥，计算得到相同的密钥。
6.1、示例代码
package org.example;
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.crypto.spec.SecretKeySpec;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
public class SecurityDH {
/**
* 全局变量存储服务端和客户端的公私钥
*/
public static Map<String, Object> keyMap = new HashMap<>(4);
public static void main(String[] args) throws NoSuchAlgorithmException {
//服务端初始化公私钥对
initServiceKey();
//客户端通过服务端生成的公钥获取大素数p和原根g，生成自己的公私钥对
initClientKey(((DHPublicKey) keyMap.get("service_public")).getEncoded());
//服务端根据自身私钥和客户端公钥计算密钥
byte[] ASecretBytes = getSecretKey(
((DHPublicKey) keyMap.get("client_public")).getEncoded(),
((DHPrivateKey) keyMap.get("service_private")).getEncoded()
);
System.out.println("服务端计算出来的密钥（base64字符串）：" + encodeToString(ASecretBytes));
//客户端根据自身私钥和服务端公钥计算密钥
byte[] BSecretBytes = getSecretKey(
((DHPublicKey) keyMap.get("service_public")).getEncoded(),
((DHPrivateKey) keyMap.get("client_private")).getEncoded()
);
System.out.println("客户端计算出来的密钥（base64字符串）：" + encodeToString(BSecretBytes));
//因为协商出来的密钥长度，不一定服务加密算法的要求，此处举例，
//由于SHA-256计算的长度的256位，所以可以利用这点处理成AES算法的密钥（128、256）
MessageDigest sha256 = MessageDigest.getInstance("SHA-256");
byte[] clientAESKeyBytes = sha256.digest(BSecretBytes);
SecretKey clientKey = new SecretKeySpec(clientAESKeyBytes, "AES");
System.out.println("客户端计算出来的AES（base64字符串）：" + encodeToString(clientKey.getEncoded()));
byte[] serviceAESKeyBytes = sha256.digest(ASecretBytes);
SecretKey aesKey = new SecretKeySpec(serviceAESKeyBytes, "AES");
System.out.println("服务端计算出来的AES（base64字符串）：" + encodeToString(aesKey.getEncoded()));
}
/**
* 初始化服务端密钥对
*/
public static void initServiceKey() {
try {
//生成服务端的密钥对
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DH");
keyPairGenerator.initialize(1024, new SecureRandom());
KeyPair keyPair = keyPairGenerator.generateKeyPair();
//公钥和私钥
DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic();
DHPrivateKey privateKey = (DHPrivateKey) keyPair.getPrivate();
//将密钥对存储在Map中
keyMap.put("service_public", publicKey);
keyMap.put("service_private", privateKey);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}
/**
* 根据服务端公钥生成客户端密钥对
*
* @param key 甲方公钥
* @return Map 乙方密钥Map
* @throws Exception
*/
public static void initClientKey(byte[] key) {
try {
//接收到服务端公钥后，解码为PublicKey对象
KeyFactory keyFactory = KeyFactory.getInstance("DH");
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
//从服务端公钥中获取大素数p和原根g
DHParameterSpec dhParameterSpec = ((DHPublicKey) pubKey).getParams();
//生成客户端的密钥对
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DH");
keyPairGenerator.initialize(dhParameterSpec);
KeyPair keyPair = keyPairGenerator.generateKeyPair();
//公钥和私钥
DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic();
DHPrivateKey privateKey = (DHPrivateKey) keyPair.getPrivate();
//将密钥对存储在Map中
keyMap.put("client_public", publicKey);
keyMap.put("client_private", privateKey);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 构建密钥
*
* @param publicKey 别人的公钥
* @param privateKey 自己的私钥
* @return byte[] 本地密钥
* @throws Exception
*/
public static byte[] getSecretKey(byte[] publicKey, byte[] privateKey) {
try {
//实例化密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance("DH");
//初始化公钥,产生公钥
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(publicKey);
PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
//初始化私钥,产生私钥
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(privateKey);
PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);
//生成密钥
KeyAgreement keyAgree = KeyAgreement.getInstance(keyFactory.getAlgorithm());
keyAgree.init(priKey);
keyAgree.doPhase(pubKey, true);
return keyAgree.generateSecret();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
private static String encodeToString(byte[] bytes) {
return Base64.getEncoder().encodeToString(bytes);
}
}
7、哈希算法
哈希算法一般都是单向的，无法逆向解密，所以常用作消息摘要，防止数据篡改，常见的哈希算法有MD5、SHA-1、SHA-256，下面的代码示例为计算字符串和文件的MD5值。
7.1、示例代码
package org.example;
import cn.hutool.core.util.HexUtil;
import javax.validation.constraints.NotNull;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.security.MessageDigest;
public class HashDemo {
public static void main(String[] args) throws Exception {
//计算消息摘要
byte[] buffer = encodeStr("test1234561", "MD5");
byte[] buffer2 = encodeFile("E:\\testFileEncrypt\\对比测试.zip", "MD5");
//比特数组转16进制字符串
System.out.println(HexUtil.encodeHexStr(buffer));
System.out.println(HexUtil.encodeHexStr(buffer2));
}
/**
* 计算字符串的消息摘要
*
* @param inStr 字符串
* @param algorithm 消息摘要算法(MD5、SHA-1、SHA-256)
* @return
* @throws Exception
*/
public static byte[] encodeStr(String inStr, @NotNull String algorithm) throws Exception {
MessageDigest sha = MessageDigest.getInstance(algorithm);
byte[] byteArray = inStr.getBytes("UTF-8");
return sha.digest(byteArray);
}
/**
* 计算文件的消息摘要
*
* @param filePath 文件路径
* @param algorithm 消息摘要算法(MD5、SHA-1、SHA-256)
* @return
* @throws Exception
*/
public static byte[] encodeFile(String filePath, @NotNull String algorithm) throws Exception {
MessageDigest sha = MessageDigest.getInstance(algorithm);
InputStream inputStream = Files.newInputStream(Paths.get(filePath), StandardOpenOption.READ);
byte[] bytes = new byte[2048];
int i;
while ((i = inputStream.read(bytes)) != -1) {
sha.update(bytes, 0, i);
}
return sha.digest();
}
}