DES/AES加密（可逆）

DES全称为Data Encryption Standard，即数据加密标准，是一种使用密钥加密的算法。该加密算法是一种对称加密方式，其加密运算、解密运算需要使用的是同样的密钥（一组字符串）即可。

注意：

• 现在用AES这个标准来替代原先的DES。

• AES和DES的区别：

  • 加密后密文长度的不同:

    • DES加密后密文长度是8的整数倍

    • AES加密后密文长度是16的整数倍

  • 应用场景的不同:

    • 企业级开发使用DES足够安全

    • 如果要求高使用AES

DES算法的入口参数有三个：

• Key、Data、Mode，padding、iv

  • Key为DES算法的工作密钥；

  • Data为要被加密或被解密的数据；

  • Mode为DES的工作模式。最常用的模式就是 CBC 模式和 ECB模式

    • ECB：是一种基础的加密方式，密文被分割成分组长度相等的块（不足补齐），然后单独一个个加密，一个个输出组成密文。

    • CBC：是一种循环模式，前一个分组的密文和当前分组的明文异或后再加密，这样做的目的是增强破解难度。

  • padding为填充模式，如果加密后密文长度如果达不到指定整数倍（8个字节、16个字节），填充对应字符

  • iv：参数中的iv主要用于CBC模式，确保即使加密相同的明文，每次产生的密文也不相同，增强加密的安全性。iv通常是一个16字节的随机字符串。这个字符串在解密时也需要用到，因此需要妥善保存。

代码实现 - Python版本

环境安装：

pip install pycryptodome

AES-CBC 加密

from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
import base64

# 定义密钥（必须是 16/24/32 字节）
key = '0123456789abcdef'.encode()

# 定义 IV（初始化向量，必须是 16 字节）
iv = 'This is the IV !'.encode()

# 需要加密的明文
plaintext = 'Hello world!'

# PKCS7 填充（AES 要求明文长度是 16 字节的倍数）
padded_plaintext = pad(plaintext.encode(), 16)

# 创建 AES 加密对象（使用 CBC 模式）
aes = AES.new(key, AES.MODE_CBC, iv)

# 进行 AES 加密
ciphertext = aes.encrypt(padded_plaintext)
print("aes加密数据:::", ciphertext)  # 输出原始加密数据（字节流）

# 使用 Base64 编码加密数据（方便存储或传输）
base64_ciphertext = base64.b64encode(ciphertext).decode()
print(base64_ciphertext)  # 输出 Base64 编码后的加密数据: q1kFYJXu9NkgLFejmmmSnA==

AES-CBC 解密

from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad
import base64

key = '0123456789abcdef'.encode()
iv = 'This is the IV !'.encode()

# 密文
base64_ciphertext = 'q1kFYJXu9NkgLFejmmmSnA=='
# Base64 解码密文为字节数据
ciphertext = base64.b64decode(base64_ciphertext)
# 若密文为16进制，则使用如下方式解码
# ciphertext = bytes.fromhex(hex_ciphertext)

# 创建 AES 解密对象
aes = AES.new(key, AES.MODE_CBC, iv)

# 解密数据并去除填充
plaintext = unpad(aes.decrypt(ciphertext), AES.block_size).decode()
print(plaintext)  # 输出 "Hello world!"

AES-ECB 字符串密钥 加密

from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
import base64

# 密钥（16 字节）
key = '0123456789abcdef'.encode()

# 明文
plaintext = 'Hello world!'.encode()

# 填充明文到 16 字节的倍数
padded_plaintext = pad(plaintext, AES.block_size)

# 创建 AES ECB 加密器
cipher = AES.new(key, AES.MODE_ECB)

# 加密
ciphertext = cipher.encrypt(padded_plaintext)
print("密文（字节数据）:", ciphertext)

# 输出密文（16 进制格式）
print("密文（16 进制）:", ciphertext.hex())

# 使用 Base64 编码加密数据（方便存储或传输）
base64_ciphertext = base64.b64encode(ciphertext).decode()
print("密文（Base64）:", base64_ciphertext)

# 输出：
# 密文（字节数据）: b'n\xe1\xbf\x116\xc1\x86\xf1\xdb_6\xc5i\x023\xc3'
# 密文（16 进制）: 6ee1bf1136c186f1db5f36c5690233c3
# 密文（Base64）: buG/ETbBhvHbXzbFaQIzww==

AES-ECB 字符串密钥 解密

import base64

from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad

# 密钥必须是16字节（128位）、24字节（192位）或32字节（256位）
key = '0123456789abcdef'.encode()

# 密文
base64_ciphertext = "buG/ETbBhvHbXzbFaQIzww=="
ciphertext = base64.b64decode(base64_ciphertext)
print("解码后的密文:", ciphertext)

# 创建AES ECB模式的解密器
cipher = AES.new(key, AES.MODE_ECB)

# 解密
unpad_plaintext = cipher.decrypt(ciphertext)

# 如果加密时使用了填充，需要去除填充
plaintext = unpad(unpad_plaintext, AES.block_size)

print("解密后的明文:", plaintext.decode('utf-8'))

# 输出：
# 解码后的密文: b'n\xe1\xbf\x116\xc1\x86\xf1\xdb_6\xc5i\x023\xc3'
# 解密后的明文: Hello world!

AES-ECB 对象密钥 解密

import base64
from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad

# # 给定的 key 对象
key_obj = {
    "words": [
        1364603238,
        862865518,
        846294327,
        1764980850,
        1781750073,
        1262053741,
        1147422548,
        1783919929
    ],
    "sigBytes": 32
}

# 将 words 转换为字节
def words_to_bytes(words):
    byte_array = bytearray()
    for word in words:
        byte_array.extend(word.to_bytes(4, byteorder='big'))
    return bytes(byte_array)

# 转换为字节形式的密钥
key = words_to_bytes(key_obj["words"])

# Base64 编码的密文
base64_encrypted_text = "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"

# Base64 解码密文
encrypted_text = base64.b64decode(base64_encrypted_text)
print('encrypted_text:', encrypted_text)

# 创建 AES 解密对象
aes = AES.new(key, AES.MODE_ECB)

# 解密数据并去除填充
plaintext = unpad(aes.decrypt(encrypted_text), AES.block_size).decode()
print(plaintext)

简单的方式是直接把key对象转成字符串

# 浏览器console中执行
u.enc.Utf8.stringify(n)

#'QV1f3nHn2qm7i3xrj3Y9K9imDdGTjTu9'

代码实现 - JS版本

AES-CBC 加密：

const CryptoJS = require("crypto-js");

// 1. 设置密钥（必须是 16/24/32 字节）
var key = CryptoJS.enc.Utf8.parse('0123456789abcdef');

// 2. 设置 IV（初始化向量，必须是 16 字节）
var iv = CryptoJS.enc.Utf8.parse('This is the IV !');

// 3. 待加密数据明文
var plaintext = 'Hello world!';

// 4. 使用 AES-CBC 模式进行加密
var encrypted = CryptoJS.AES.encrypt(plaintext, key, {
    iv: iv,                      // 指定 IV
    mode: CryptoJS.mode.CBC,     // 选择 CBC 模式
    padding: CryptoJS.pad.Pkcs7  // 使用 PKCS7 填充
});

// 5. 转换为 Base64 格式的密文字符串
var ciphertext = encrypted.toString();

// 6. 打印加密后的密文
console.log(ciphertext);

AES-CBC 解密：

const CryptoJS = require("crypto-js")

// 1. 设置密钥（必须是 16/24/32 字节）
var key = CryptoJS.enc.Utf8.parse('0123456789abcdef');

// 2. 设置 IV（初始化向量，必须是 16 字节）
var iv = CryptoJS.enc.Utf8.parse('This is the IV !');

// 3. 待解密密文数据
ciphertext = 'q1kFYJXu9NkgLFejmmmSnA=='

// 4. 使用 AES-CBC 模式进行解密
var decrypted = CryptoJS.AES.decrypt(ciphertext, key, {
    iv: iv,
    mode: CryptoJS.mode.CBC,
    padding: CryptoJS.pad.Pkcs7
});

// 5. 转换为 UTF-8 字符串
var originalText = decrypted.toString(CryptoJS.enc.Utf8);

// 6. 打印解密后的明文
console.log(originalText);  // "Hello world!"

上述代码的关键字：

• AES，DES

• encrypt(用于加密的函数名)，decrypt(用于解密的函数名)

• xxxkey：秘钥一般是单独生成的，一定不会傻到明文的写在代码中！