常见对称加密原理以及应用
加密算法
所谓对称加密算法，通过密钥将明文加密成密文，并且再通过同一个密钥将密文解密成明文，相对于非对称加密算法速度快效率高，对于明文文本越长效率优势越大。
常见的对称加密算法有AES、DES、3DES等，其中DES由于密钥长度低容易被暴力破解，因此安全性相对较低已经不推荐使用。而3DES则是DES的升级版，安全性有所提升，但依然不如AES，因此推荐安全性更高的AES加密算法。
| 算法 | 算法类型 | 密钥长度 | 分组长度 | 安全性 |
|---|---|---|---|---|
| AES | 块密码算法 | 128/192/256比特 | 128比特 | 安全 |
| DES | 块密码算法 | 56比特 | 64比特 | 不安全 |
| 3DES | 块密码算法 | 128/168比特 | 64比特 | 安全 |
分组模式
AES、DES、3DES都是块密码算法，即运算加密解密时不是一次性将整个明文/密文文本进行运算，而是拆成固定长度的数据块后对每个数据块进行运算。
由于文本被拆分成若干个数据块，对于超过一个数据块的场景需要定义数据块之间的拆分和组装方式，即分组模式，场景的分组模式如下表：
| 分组 | 是否需要填充 | 安全性 |
|---|---|---|
| ECB | 否 | 不安全 |
| CBC | 是 | 安全 |
| CTR | 是 | 安全 |
ECB
ECB是最简单的一种分组模式，简单地将明文拆成数据块后，每个数据块单独加密解密。如果两个数据块内容相同，那么这两个数据块加密后的密文段也是完全一样，容易受到重放攻击以及密文篡改，因此安全度不高。
CBC
CBC引入了一个新的变量初始向量IV，一般是一个随机数，用于在第一块明文数据块加密前对数据块做XOR运算，之后每一块明文数据块加密前都与前一块的密文数据块做XOR运算。
由于每一块数据块的计算结果都与上一块数据块有关联，因此即使有两个相同的数据块，计算出的密文段也不同，解决了ECB的安全问题。但因此，CBC计算只能串行处理，效率不如ECB。
CTR
CTR同样引入了一个新的变量初始随机数，每一个数据块计算时先对随机数+1，然后再参与加密解密运算，因此即使有两个相同的数据块，计算出的密文段也不同，解决了ECB的安全问题。并且每个数据块仅与随机数有联系，因此可以并行处理。
填充算法
对于块加密算法来说，不是对一次性对整个明文进行加密计算，而是拆分成若干个固定长度（加密算法的分组长度）的数据块，然后对各个数据块进行加密计算，因此明文的字节长度必须是分组长度的整数倍数。如果明文的字节长度不是分组长度的整数倍数，则需要一种填充的机制，在加密前将明文字节长度填充成分组长度的整数倍数，并且在解密后正确移除填充的字节。
常见的填充算法有PKCS#7和PKCS#5，而实际上两者的处理逻辑是相同的，只是PKCS#5只能处理分组长度为8字节的数据，而PKCS#7可以处理分组长度是1-255任意长度字节的数据。从这个角度看，PKCS#5是PKCS#7的子集。
PKCS#7很简单，实现代码如下：
/**
* PKCS#7填充实现
* @param src 明文
* @param cipherBlockSize 加密算法分组长度
*/
public static byte[] padding7(byte[] src, int cipherBlockSize) {
// PKCS#7的分组最大为255字节
int blockSize = Math.min(255, cipherBlockSize);
int padNum = blockSize - src.length % blockSize;
byte[] dst = new byte[src.length + padNum];
System.arraycopy(src, 0, dst, 0, src.length);
for (int i = 0; i < padNum; i++) {
dst[src.length + i] = (byte) padNum;
}
return dst;
}
/**
* PKCS#5填充实现
* @param src 明文
* @param cipherBlockSize 加密算法分组长度
*/
public static byte[] padding5(byte[] src, int cipherBlockSize) {
// PKCS#5的分组固定为8字节
final int blockSize = 8;
if (cipherBlockSize != blockSize) {
throw new RuntimeException("block length not support");
}
int padNum = blockSize - src.length % blockSize;
byte[] dst = new byte[src.length + padNum];
System.arraycopy(src, 0, dst, 0, src.length);
for (int i = 0; i < padNum; i++) {
dst[src.length + i] = (byte) padNum;
}
return dst;
}
如果数据需要填充n个字节，则在数据后添加n个字节长度的字节，并且填充的每个字节的值为n。另外，如果数据长度刚好是分组长度的整数倍时，依然还需要填充，填充长度为分组长度。
0x01
0x02 0x02
0x03 0x03 0x03
0x04 0x04 0x04 0x04
- 分组长度8字节时数据5字节，需要填充3个字节：
Hello
0x48 0x65 0x6c 0x6c 0x6f
0x48 0x65 0x6c 0x6c 0x6f 0x03 0x03 0x03
- 分组长度8字节时数据8字节，本应不需要填充，但实际上再额外填充8字节：
EchoEcho
0x45 0x63 0x68 0x6f 0x45 0x63 0x68 0x6f
0x45 0x63 0x68 0x6f 0x45 0x63 0x68 0x6f 0x08 0x08 0x08 0x08 0x08 0x08 0x08 0x08
AES算法的分组长度超过8字节，因此不能使用PKCS#5，但有些程序使用AES算法时若指定PKCS#5时并未报错，实际内部依然使用了PCKS#7。
代码实现
常见的填充算法有PCKS#5和PKCS#7，但JDK的语法中存在PKCS5Padding却不存在PKCS7Padding。查阅官方文档Cipher以及Cipher Algorithm Padding后确认语法中确实不存在PKCS7Padding。
JDK中PKCS#7命名问题无从考证，但可以确定的是，JDK中语法上的PKCS5Padding实际上就是PKCS#7的实现，而官方文档Cipher也显示了这一点：
Every implementation of the Java platform is required to support the following standard Cipher transformations with the keysizes in parentheses:
- AES/CBC/NoPadding (128)
- AES/CBC/PKCS5Padding (128)
- AES/ECB/NoPadding (128)
- AES/ECB/PKCS5Padding (128)
- DES/CBC/NoPadding (56)
- DES/CBC/PKCS5Padding (56)
- DES/ECB/NoPadding (56)
- DES/ECB/PKCS5Padding (56)
- DESede/CBC/NoPadding (168)
- DESede/CBC/PKCS5Padding (168)
- DESede/ECB/NoPadding (168)
- DESede/ECB/PKCS5Padding (168)
- RSA/ECB/PKCS1Padding (1024, 2048)
- RSA/ECB/OAEPWithSHA-1AndMGF1Padding (1024, 2048)
- RSA/ECB/OAEPWithSHA-256AndMGF1Padding (1024, 2048)
DES-ECB
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.codec.binary.Hex;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
public class DESECBUtils {
public static String encrypt(String key, String data) throws Exception {
Cipher cipher = initCipher(key, Cipher.ENCRYPT_MODE);
byte[] encryptedByte = cipher.doFinal(data.getBytes());
return Base64.encodeBase64String(encryptedByte);
}
public static String decrypt(String key, String data) throws Exception {
Cipher cipher = initCipher(key, Cipher.DECRYPT_MODE);
byte[] decryptedByte = cipher.doFinal(Base64.decodeBase64(data));
return new String(decryptedByte);
}
private static Cipher initCipher(String key, int encryptMode) throws Exception {
Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
cipher.init(encryptMode, new SecretKeySpec(key.getBytes(), "DES"));
return cipher;
}
public static void main(String[] args) throws Exception {
String key = "12345678";
String value = "HelloWorld";
// 16进制的加密参数key
System.out.println("key hex: " + Hex.encodeHexString(key.getBytes()));
// 加密
String encrypt = encrypt(key, value);
System.out.println("encrypt: " + encrypt);
// 解密
String decrypt = decrypt(key, encrypt);
System.out.println("decrypt: " + decrypt);
}
}
key hex: 3132333435363738
encrypt: 8SBfruuCs9qh0WiTqhkSbg==
decrypt: HelloWorld
OpenSSL命令行调用：
[root@VM_0_10_centos ~]# echo -n HelloWorld > in.txt
[root@VM_0_10_centos ~]# openssl enc -des-ecb -in in.txt -out encrypt.txt -K 3132333435363738 -a
[root@VM_0_10_centos ~]# cat encrypt.txt
8SBfruuCs9qh0WiTqhkSbg==
[root@VM_0_10_centos ~]# openssl enc -des-ecb -in encrypt.txt -out decrypt.txt -K 3132333435363738 -a -d
[root@VM_0_10_centos ~]# cat decrypt.txt
HelloWorld
DES-CBC
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.codec.binary.Hex;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
public class DESCBCUtils {
public static String encrypt(String key, String iv, String data) throws Exception {
Cipher cipher = initCipher(key, iv, Cipher.ENCRYPT_MODE);
byte[] encryptedByte = cipher.doFinal(data.getBytes());
return Base64.encodeBase64String(encryptedByte);
}
public static String decrypt(String key, String iv, String data) throws Exception {
Cipher cipher = initCipher(key, iv, Cipher.DECRYPT_MODE);
byte[] decryptedByte = cipher.doFinal(Base64.decodeBase64(data));
return new String(decryptedByte);
}
private static Cipher initCipher(String key, String iv, int encryptMode) throws Exception {
Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
SecretKeySpec keySpec = new SecretKeySpec(key.getBytes(), "DES");
IvParameterSpec ivSpec = new IvParameterSpec(iv.getBytes());
cipher.init(encryptMode, keySpec, ivSpec);
return cipher;
}
public static void main(String[] args) throws Exception {
String key = "12345678";
String iv = "87654321";
String value = "HelloWorld";
// 16进制的加密参数key,iv
System.out.println("key hex: " + Hex.encodeHexString(key.getBytes()));
System.out.println("iv hex: " + Hex.encodeHexString(iv.getBytes()));
// 加密
String encrypt = encrypt(key, iv, value);
System.out.println("encrypt: " + encrypt);
// 解密
String decrypt = decrypt(key, iv, encrypt);
System.out.println("decrypt: " + decrypt);
}
}
key hex: 3132333435363738
iv hex: 3837363534333231
encrypt: 9r2UI+JnSrVP+WqsrFUqsg==
decrypt: HelloWorld
OpenSSL命令行调用：
[root@VM_0_10_centos ~]# echo -n HelloWorld > in.txt
[root@VM_0_10_centos ~]# openssl enc -des-cbc -in in.txt -out encrypt.txt -K 3132333435363738 -iv 3837363534333231 -a
[root@VM_0_10_centos ~]# cat encrypt.txt
9r2UI+JnSrVP+WqsrFUqsg==
[root@VM_0_10_centos ~]# openssl enc -des-cbc -in encrypt.txt -out decrypt.txt -K 3132333435363738 -iv 3837363534333231 -a -d
[root@VM_0_10_centos ~]# cat decrypt.txt
HelloWorld
AES-ECB
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.codec.binary.Hex;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
public class AESECBUtils {
public static String encrypt(String key, String data) throws Exception {
Cipher cipher = initCipher(key, Cipher.ENCRYPT_MODE);
byte[] encryptedByte = cipher.doFinal(data.getBytes());
return Base64.encodeBase64String(encryptedByte);
}
public static String decrypt(String key, String data) throws Exception {
Cipher cipher = initCipher(key, Cipher.DECRYPT_MODE);
byte[] decryptedByte = cipher.doFinal(Base64.decodeBase64(data));
return new String(decryptedByte);
}
private static Cipher initCipher(String key, int encryptMode) throws Exception {
Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
cipher.init(encryptMode, new SecretKeySpec(key.getBytes(), "AES"));
return cipher;
}
public static void main(String[] args) throws Exception {
// 16字节秘钥即128比特
String key = "1234567890123456";
String value = "HelloWorld";
// 16进制的加密参数key
System.out.println("key hex: " + Hex.encodeHexString(key.getBytes()));
// 加密
String encrypt = encrypt(key, value);
System.out.println("encrypt: " + encrypt);
// 解密
String decrypt = decrypt(key, encrypt);
System.out.println("decrypt: " + decrypt);
}
}
key hex: 31323334353637383930313233343536
encrypt: VfqXvdGjzea0rgvXO56j5g==
decrypt: HelloWorld
OpenSSL命令行调用：
[root@VM_0_10_centos ~]# echo -n HelloWorld > in.txt
[root@VM_0_10_centos ~]# openssl enc -aes-128-ecb -in in.txt -out encrypt.txt -K 31323334353637383930313233343536 -a
[root@VM_0_10_centos ~]# cat encrypt.txt
VfqXvdGjzea0rgvXO56j5g==
[root@VM_0_10_centos ~]# openssl enc -aes-128-ecb -in encrypt.txt -out decrypt.txt -K 31323334353637383930313233343536 -a -d
[root@VM_0_10_centos ~]# cat decrypt.txt
HelloWorld
AES-CBC
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.codec.binary.Hex;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
public class AESCBCUtils {
public static String encrypt(String key, String iv, String data) throws Exception {
Cipher cipher = initCipher(key, iv, Cipher.ENCRYPT_MODE);
byte[] encryptedByte = cipher.doFinal(data.getBytes());
return Base64.encodeBase64String(encryptedByte);
}
public static String decrypt(String key, String iv, String data) throws Exception {
Cipher cipher = initCipher(key, iv, Cipher.DECRYPT_MODE);
byte[] decryptedByte = cipher.doFinal(Base64.decodeBase64(data));
return new String(decryptedByte);
}
private static Cipher initCipher(String key, String iv, int encryptMode) throws Exception {
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
SecretKeySpec keySpec = new SecretKeySpec(key.getBytes(), "AES");
IvParameterSpec ivSpec = new IvParameterSpec(iv.getBytes());
cipher.init(encryptMode, keySpec, ivSpec);
return cipher;
}
public static void main(String[] args) throws Exception {
// 16字节秘钥即128比特
String key = "1234567890123456";
String iv = "9876543210987654";
String value = "HelloWorld";
// 16进制的加密参数key,iv
System.out.println("key hex: " + Hex.encodeHexString(key.getBytes()));
System.out.println("iv hex: " + Hex.encodeHexString(iv.getBytes()));
// 加密
String encrypt = encrypt(key, iv, value);
System.out.println("encrypt: " + encrypt);
// 解密
String decrypt = decrypt(key, iv, encrypt);
System.out.println("decrypt: " + decrypt);
}
}
key hex: 31323334353637383930313233343536
iv hex: 39383736353433323130393837363534
encrypt: 5febt2VH5eaKXn/nrQj/aQ==
decrypt: HelloWorld
OpenSSL命令行调用：
[root@VM_0_10_centos ~]# echo -n HelloWorld > in.txt
[root@VM_0_10_centos ~]# openssl enc -aes-128-cbc -in in.txt -out encrypt.txt -K 31323334353637383930313233343536 -iv 39383736353433323130393837363534 -a
[root@VM_0_10_centos ~]# cat encrypt.txt
5febt2VH5eaKXn/nrQj/aQ==
[root@VM_0_10_centos ~]# openssl enc -aes-128-cbc -in encrypt.txt -out decrypt.txt -K 31323334353637383930313233343536 -iv 39383736353433323130393837363534 -a -d
[root@VM_0_10_centos ~]# cat decrypt.txt
HelloWorld
AES-CTR
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.codec.binary.Hex;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
public class AESCTRUtils {
public static String encrypt(String key, String iv, String data) throws Exception {
Cipher cipher = initCipher(key, iv, Cipher.ENCRYPT_MODE);
byte[] encryptedByte = cipher.doFinal(data.getBytes());
return Base64.encodeBase64String(encryptedByte);
}
public static String decrypt(String key, String iv, String data) throws Exception {
Cipher cipher = initCipher(key, iv, Cipher.DECRYPT_MODE);
byte[] decryptedByte = cipher.doFinal(Base64.decodeBase64(data));
return new String(decryptedByte);
}
private static Cipher initCipher(String key, String iv, int encryptMode) throws Exception {
Cipher cipher = Cipher.getInstance("AES/CTR/NoPadding");
SecretKeySpec keySpec = new SecretKeySpec(key.getBytes(), "AES");
IvParameterSpec ivSpec = new IvParameterSpec(iv.getBytes());
cipher.init(encryptMode, keySpec, ivSpec);
return cipher;
}
public static void main(String[] args) throws Exception {
// 16字节秘钥即128比特
String key = "1234567890123456";
String iv = "9876543210987654";
String value = "HelloWorld";
// 16进制的加密参数key,iv
System.out.println("key hex: " + Hex.encodeHexString(key.getBytes()));
System.out.println("iv hex: " + Hex.encodeHexString(iv.getBytes()));
// 加密
String encrypt = encrypt(key, iv, value);
System.out.println("encrypt: " + encrypt);
// 解密
String decrypt = decrypt(key, iv, encrypt);
System.out.println("decrypt: " + decrypt);
}
}
key hex: 31323334353637383930313233343536
iv hex: 39383736353433323130393837363534
encrypt: Zjh8leeiqcWH0w==
decrypt: HelloWorld
OpenSSL命令行调用：
[root@VM_0_10_centos ~]# echo -n HelloWorld > in.txt
[root@VM_0_10_centos ~]# openssl enc -aes-128-ctr -in in.txt -out encrypt.txt -K 31323334353637383930313233343536 -iv 39383736353433323130393837363534 -a
[root@VM_0_10_centos ~]# cat encrypt.txt
Zjh8leeiqcWH0w==
[root@VM_0_10_centos ~]# openssl enc -aes-128-ctr -in encrypt.txt -out decrypt.txt -K 31323334353637383930313233343536 -iv 39383736353433323130393837363534 -a -d
[root@VM_0_10_centos ~]# cat decrypt.txt
HelloWorld
随机密钥
阅读一些java的加解密代码实现时可能会看到如下代码，这实际上是一个密码学的随机数生成，通过指定一个随机种子后生成一个随机数，最后以随机数作为对称加密算法的密钥。
因此随后参与对称加密运算的密钥并不是最开始的程序输入值，而是随机数生成器生成的随机数secretKey.getEncoded()。
KeyGenerator generator = KeyGenerator.getInstance("AES");
SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
secureRandom.setSeed("1234567890123456".getBytes());
generator.init(secureRandom);
SecretKey secretKey = generator.generateKey();
System.out.println(Hex.encodeHexString(secretKey.getEncoded()));