【算法】【AES】加密算法详解

一、什么是AES？

AES（Advanced Encryption Standard）是一种对称加密算法，广泛应用于数据加密。它在2001年被美国国家标准与技术研究所（NIST）选为数据加密的标准，替代了之前的DES（Data Encryption Standard）。AES具有高效、安全和灵活的特点，适用于多种平台和环境。

二、AES的工作原理

AES是一种对称密钥加密算法，这意味着加密和解密使用同一个密钥。AES算法可以处理128位的块大小，支持128、192和256位的密钥长度。

1. 加密过程

AES的加密过程包括多个步骤，主要分为以下几个阶段：

2. 解密过程

解密过程与加密过程相似，但步骤的顺序和操作的内容会有所不同，具体步骤为：

三、AES的安全性

AES被认为是非常安全的加密标准，主要原因如下：

1. 密钥长度：AES支持多种密钥长度，256位的密钥提供了极高的安全性。
2. 抵抗力：AES设计抵抗多种攻击（如暴力破解、差分攻击、线性攻击等）。
3. 标准化：作为NIST标准，AES得到了广泛的审查和验证。

四、AES的应用

AES被广泛应用于各种领域，包括但不限于：

• 数据保护：用于保护敏感数据，如金融信息、个人身份信息等。
• VPN和TLS：在虚拟私人网络和传输层安全（TLS）协议中用于数据加密。
• 文件加密：用于加密文件和存储设备，保护数据隐私。
• 电子商务：在在线支付和交易中保障数据安全。

Go语言实现

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "encoding/hex"
    "fmt"
    "io"
)

// AES加密
func encrypt(plainText, key []byte) ([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }

    // 填充明文
    plainText = pad(plainText)
    cipherText := make([]byte, len(plainText))
    
    iv := make([]byte, aes.BlockSize)
    if _, err := io.ReadFull(rand.Reader, iv); err != nil {
        return nil, err
    }

    mode := cipher.NewCBCEncrypter(block, iv)
    mode.CryptBlocks(cipherText, plainText)

    // 返回IV + 密文
    return append(iv, cipherText...), nil
}

// AES解密
func decrypt(cipherText, key []byte) ([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }

    // 获取IV
    if len(cipherText) < aes.BlockSize {
        return nil, fmt.Errorf("ciphertext too short")
    }
    iv := cipherText[:aes.BlockSize]
    cipherText = cipherText[aes.BlockSize:]

    mode := cipher.NewCBCDecrypter(block, iv)
    mode.CryptBlocks(cipherText, cipherText)

    // 去除填充
    return unpad(cipherText), nil
}

// 填充
func pad(src []byte) []byte {
    padding := aes.BlockSize - len(src)%aes.BlockSize
    padtext := bytes.Repeat([]byte{byte(padding)}, padding)
    return append(src, padtext...)
}

// 去除填充
func unpad(src []byte) []byte {
    length := len(src)
    unpadding := int(src[length-1])
    return src[:(length - unpadding)]
}

func main() {
    key := []byte("thisisaverystrongkey1234") // 32字节密钥
    plainText := []byte("Hello, AES encryption!")

    // 加密
    cipherText, err := encrypt(plainText, key)
    if err != nil {
        fmt.Println("Encryption error:", err)
        return
    }
    fmt.Println("Cipher Text:", hex.EncodeToString(cipherText))

    // 解密
    decryptedText, err := decrypt(cipherText, key)
    if err != nil {
        fmt.Println("Decryption error:", err)
        return
    }
    fmt.Println("Decrypted Text:", string(decryptedText))
}

Python实现

from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
import os
import binascii

def encrypt(plain_text, key):
    cipher = AES.new(key, AES.MODE_CBC)
    iv = cipher.iv
    cipher_text = cipher.encrypt(pad(plain_text.encode(), AES.block_size))
    return iv + cipher_text

def decrypt(cipher_text, key):
    iv = cipher_text[:AES.block_size]
    cipher = AES.new(key, AES.MODE_CBC, iv)
    decrypted_text = unpad(cipher.decrypt(cipher_text[AES.block_size:]), AES.block_size)
    return decrypted_text.decode()

if __name__ == "__main__":
    key = b'thisisaverystrong'  # 16字节密钥
    plain_text = "Hello, AES encryption!"

    # 加密
    cipher_text = encrypt(plain_text, key)
    print("Cipher Text:", binascii.hexlify(cipher_text).decode())

    # 解密
    decrypted_text = decrypt(cipher_text, key)
    print("Decrypted Text:", decrypted_text)

Java实现

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.util.Arrays;

public class AESExample {
    private static final String ALGORITHM = "AES";
    private static final String TRANSFORMATION = "AES/CBC/PKCS5Padding";

    public static byte[] encrypt(String plainText, byte[] key) throws Exception {
        SecretKeySpec secretKey = new SecretKeySpec(key, ALGORITHM);
        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
        byte[] iv = new byte[cipher.getBlockSize()];
        System.arraycopy(key, 0, iv, 0, iv.length);
        cipher.init(Cipher.ENCRYPT_MODE, secretKey, new IvParameterSpec(iv));
        return cipher.doFinal(plainText.getBytes());
    }

    public static String decrypt(byte[] cipherText, byte[] key) throws Exception {
        SecretKeySpec secretKey = new SecretKeySpec(key, ALGORITHM);
        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
        byte[] iv = new byte[cipher.getBlockSize()];
        System.arraycopy(key, 0, iv, 0, iv.length);
        cipher.init(Cipher.DECRYPT_MODE, secretKey, new IvParameterSpec(iv));
        return new String(cipher.doFinal(cipherText));
    }

    public static void main(String[] args) {
        try {
            byte[] key = "thisisaverystrong".getBytes(); // 16字节密钥
            String plainText = "Hello, AES encryption!";

            // 加密
            byte[] cipherText = encrypt(plainText, key);
            System.out.println("Cipher Text: " + Arrays.toString(cipherText));

            // 解密
            String decryptedText = decrypt(cipherText, key);
            System.out.println("Decrypted Text: " + decryptedText);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}