常见对称加密原理以及应用

祈雨的博客

2020-07-08

java

所谓对称加密算法，通过密钥将明文加密成密文，并且再通过同一个密钥将密文解密成明文，相对于非对称加密算法速度快效率高，对于明文文本越长效率优势越大。

常见的对称加密算法有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是最简单的一种分组模式，简单地将明文拆成数据块后，每个数据块单独加密解密。如果两个数据块内容相同，那么这两个数据块加密后的密文段也是完全一样，容易受到重放攻击以及密文篡改，因此安全度不高。

CBC引入了一个新的变量初始向量IV，一般是一个随机数，用于在第一块明文数据块加密前对数据块做XOR运算，之后每一块明文数据块加密前都与前一块的密文数据块做XOR运算。

由于每一块数据块的计算结果都与上一块数据块有关联，因此即使有两个相同的数据块，计算出的密文段也不同，解决了ECB的安全问题。但因此，CBC计算只能串行处理，效率不如ECB。

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()));

常见对称加密原理以及应用

常见对称加密原理以及应用

DES-ECB

DES-CBC

AES-ECB

AES-CBC

AES-CTR

Recommend

Need Something Sorted? Sleep on It!

ReactiveCocoa2实战

互联网曾经有另一种可能

Animation Night 99 - LDR

(译)如何辨别优秀的程序员

服饰行业每周上新？其实爆款密码藏在「内容」里

腾讯云与凯文教育、科诚数科达成战略合作，将在河南落地校企合作、智慧教育等项目

关于选择

Google鼓励区分您的网站

What I Wish I Knew When I Was 20

About Joyk