模块 19 - Payload 加密 - AES 加密#

[!IMPORTANT] 本知识库声明

本知识库由本人整理自互联网 MalDev Academy 泄露资源，并由本人手动翻译为中文，过程中增加了大量关键技术提示与实践心得。

内容完整性：并未修改任何核心代码与技术逻辑，仅做汉化与注释加强。

版权归属：原始知识产权归原作者/官方所有。

支持正版：本仓库仅供内部学习交流，如果您有经济能力，请务必支持正版课程。

权利申诉：如相关内容侵犯了您的权益，请联系我，我将立即核实并删除。

Payload 加密 - AES 加密#

高级加密标准 (Advanced Encryption Standard)#

本模块讨论一种更安全的加密算法 —— 高级加密标准 (AES)。它是一种对称密钥算法,意味着加密和解密使用相同的密钥。AES 有几种类型,如 AES128、AES192 和 AES256,它们的区别在于密钥大小。例如,AES128 使用 128 位密钥,而 AES256 使用 256 位密钥。

此外,AES 可以使用不同的分组密码模式 ↗,如 CBC 和 GCM。根据 AES 模式的不同,AES 算法除了加密密钥外,还需要一个称为初始化向量 (Initialization Vector, IV) 的附加组件。提供 IV 为加密过程提供了额外的安全层。

无论选择哪种 AES 类型,AES 始终需要 128 位输入并产生 128 位输出块。需要记住的重要一点是,输入数据应该是 16 字节的倍数 (128 位)。如果要加密的 payload 不是 16 字节的倍数,则需要填充 (padding) 来增加 payload 的大小,使其成为 16 字节的倍数。

本模块提供了两个使用 AES256-CBC 的代码示例。第一个示例通过 bCrypt 库(利用 Windows API)实现,第二个示例使用 Tiny AES Project ↗。请注意,由于使用的是 AES256-CBC,代码使用 32 字节密钥和 16 字节 IV。如果使用不同的 AES 类型或模式,这些参数会有所不同。

💡 初学者提示 - AES 基础知识

什么是 AES?

AES (Advanced Encryption Standard) 是美国联邦政府采用的加密标准
2001 年成为标准,替代了老旧的 DES 算法
被认为是目前最安全的对称加密算法之一
广泛用于 HTTPS、VPN、文件加密等领域

AES 的三种变体:

类型	密钥长度	加密轮数	安全级别	应用场景
AES-128	128 位 (16 字节)	10 轮	高	一般加密
AES-192	192 位 (24 字节)	12 轮	很高	金融系统
AES-256	256 位 (32 字节)	14 轮	极高	军事/政府

密钥越长,安全性越高,但性能稍慢。

什么是分组密码模式?

AES 是分组加密 (Block Cipher),每次处理 16 字节的数据块。但实际数据通常远大于 16 字节,因此需要”模式”来处理多个块:

模式	全称	特点	是否需要 IV
ECB	Electronic Codebook	最简单,但不安全(相同明文产生相同密文)	❌ 否
CBC	Cipher Block Chaining	每个块的加密依赖前一个块,安全	✅ 是
CTR	Counter	将分组密码转为流密码,可并行化	✅ 是
GCM	Galois/Counter Mode	CBC + 认证,最安全	✅ 是

本模块使用 AES-256-CBC (最常见的安全组合)

[!IMPORTANT] 📚 知识扩展 - 为什么需要 IV (初始化向量)?

什么是 IV?

IV 是一个随机的 16 字节值

每次加密都应该使用不同的 IV

IV 不需要保密,但必须是随机的

为什么需要 IV?

假设没有 IV:
情况 1: 加密 "Hello" with key "SecretKey123"
        → 密文: A3F2D1...

情况 2: 再次加密 "Hello" with key "SecretKey123"
        → 密文: A3F2D1... (相同!)
plaintext
问题: 攻击者可以通过重复的密文推断出重复的明文!

使用 IV 后:
情况 1: 加密 "Hello" with key + IV1
        → 密文: A3F2D1...

情况 2: 加密 "Hello" with key + IV2 (不同的 IV)
        → 密文: 7B9C4E... (完全不同!)
plaintext
结论: IV 确保相同的明文每次产生不同的密文,大大提高安全性!

[!WARNING] ⚠️ AES 填充 (Padding) 问题

为什么需要填充?

AES 是分组加密,每次处理固定的 16 字节

如果数据不是 16 的倍数,最后一个块会不够 16 字节

需要”填充”来补齐到 16 字节

示例:
原始数据: "Hello" (5 字节)
问题: 5 不是 16 的倍数,无法直接加密!

解决方案: 填充到 16 字节
填充后: "Hello" + 11 个填充字节 = 16 字节 ✓
plaintext
常见填充方案:
PKCS#7 填充 (最常用)
原始: [H][e][l][l][o]                    (5 字节)
填充: [H][e][l][l][o][11][11][11]...[11]  (16 字节)
       ↑原始数据        ↑填充 11 个 0x0B (11 的十六进制)
plaintext
规则: 填充字节的值 = 填充的数量
零填充
原始: [H][e][l][l][o]                    (5 字节)
填充: [H][e][l][l][o][0][0][0]...[0]     (16 字节)
plaintext
问题: 无法区分原始的零和填充的零
本模块使用 BCRYPT_BLOCK_PADDING 标志自动处理填充!

使用 Windows API 的 AES (bCrypt 库)#

有多种方法可以实现 AES 加密算法。本节利用 bCrypt 库 (bcrypt.h ↗) 执行 AES 加密。本节将解释代码,完整代码可在模块框的右上角下载。

AES 结构#

首先,创建一个 AES 结构,其中包含执行加密和解密所需的数据。

typedef struct _AES {

	PBYTE	pPlainText;         // 明文数据的基地址
	DWORD	dwPlainSize;        // 明文数据的大小

	PBYTE	pCipherText;        // 加密数据的基地址
	DWORD	dwCipherSize;       // 加密数据的大小 (如果有填充,可能会与 dwPlainSize 不同)

	PBYTE	pKey;               // 32 字节密钥 (AES-256)
	PBYTE	pIv;                // 16 字节 IV

} AES, *PAES;

💡 初学者提示 - 结构设计说明

这个结构体设计得很巧妙,包含了 AES 加密/解密所需的所有信息:

明文相关:

pPlainText - 指向原始数据
dwPlainSize - 原始数据大小

密文相关:

pCipherText - 指向加密后的数据
dwCipherSize - 加密后的大小 (可能因填充而变大)

密钥相关:

pKey - 32 字节密钥 (AES-256 需要 256 位 = 32 字节)
pIv - 16 字节 IV (AES 的块大小固定为 128 位 = 16 字节)

为什么 dwCipherSize 可能与 dwPlainSize 不同?

例子:
明文: "Hello" = 5 字节
填充后: 5 + 11 = 16 字节
密文大小: 16 字节 (比明文大!)

plaintext

SimpleEncryption 包装函数#

SimpleEncryption 函数有六个参数,用于初始化 AES 结构。结构初始化后,函数将调用 InstallAesEncryption 执行 AES 加密过程。请注意,其中两个参数是 OUT 参数,因此该函数返回以下内容:

pCipherTextData - 指向新分配的堆缓冲区的指针,其中包含密文数据。
sCipherTextSize - 密文缓冲区的大小。

如果 InstallAesEncryption 成功,函数返回 TRUE,否则返回 FALSE。

// InstallAesEncryption 的包装函数,使事情更简单
BOOL SimpleEncryption(IN PVOID pPlainTextData, IN DWORD sPlainTextSize, IN PBYTE pKey, IN PBYTE pIv, OUT PVOID* pCipherTextData, OUT DWORD* sCipherTextSize) {

	if (pPlainTextData == NULL || sPlainTextSize == NULL || pKey == NULL || pIv == NULL)
		return FALSE;
	
	// 初始化结构体
	AES Aes = {
		.pKey        = pKey,            // 设置密钥
		.pIv         = pIv,             // 设置 IV
		.pPlainText  = pPlainTextData,  // 设置明文数据
		.dwPlainSize = sPlainTextSize   // 设置明文大小
	};

	// 调用实际的加密函数
	if (!InstallAesEncryption(&Aes)) {
		return FALSE;
	}

	// 保存输出结果
	*pCipherTextData = Aes.pCipherText;  // 返回密文指针
	*sCipherTextSize = Aes.dwCipherSize; // 返回密文大小

	return TRUE;
}

SimpleDecryption 包装函数#

SimpleDecryption 函数也有六个参数,行为类似于 SimpleEncryption,区别在于它调用 InstallAesDecryption 函数并返回两个不同的值。

pPlainTextData - 指向新分配的堆缓冲区的指针,其中包含明文数据。
sPlainTextSize - 明文缓冲区的大小。

如果 InstallAesDecryption 成功,函数返回 TRUE,否则返回 FALSE。

// InstallAesDecryption 的包装函数,使事情更简单
BOOL SimpleDecryption(IN PVOID pCipherTextData, IN DWORD sCipherTextSize, IN PBYTE pKey, IN PBYTE pIv, OUT PVOID* pPlainTextData, OUT DWORD* sPlainTextSize) {

	if (pCipherTextData == NULL || sCipherTextSize == NULL || pKey == NULL || pIv == NULL)
		return FALSE;

	// 初始化结构体
	AES Aes = {
		.pKey          = pKey,             // 设置密钥
		.pIv           = pIv,              // 设置 IV
		.pCipherText   = pCipherTextData,  // 设置密文数据
		.dwCipherSize  = sCipherTextSize   // 设置密文大小
	};

	// 调用实际的解密函数
	if (!InstallAesDecryption(&Aes)) {
		return FALSE;
	}

	// 保存输出结果
	*pPlainTextData = Aes.pPlainText;    // 返回明文指针
	*sPlainTextSize = Aes.dwPlainSize;   // 返回明文大小

	return TRUE;
}

💡 初学者提示 - 包装函数的设计模式

为什么需要包装函数?

这是一种常见的软件设计模式,叫做包装器模式 (Wrapper Pattern):

用户代码
   ↓ 调用简单接口
SimpleEncryption (包装函数)
   ↓ 初始化结构,调用核心函数
InstallAesEncryption (核心实现)
   ↓ 调用 bcrypt API
Windows BCrypt 库

plaintext

优势:

✅ 简化 API - 用户不需要手动创建和初始化 AES 结构
✅ 错误处理 - 集中处理参数验证
✅ 可维护性 - 修改内部实现不影响调用方
✅ 清晰的责任分离 - 包装层处理数据准备,核心层处理加密逻辑

使用示例:

PVOID ciphertext = NULL;
DWORD cipherSize = 0;

// 简单调用,无需手动创建结构
if (SimpleEncryption(data, dataSize, key, iv, &ciphertext, &cipherSize)) {
    printf("加密成功! 密文大小: %d\n", cipherSize);
}

Cryptographic Next Generation (CNG)#

密码学下一代 (Cryptographic Next Generation, CNG) 提供了一组加密函数,供操作系统的应用程序使用。CNG 为加密操作提供了标准化接口,使开发人员更容易在其应用程序中实现安全功能。InstallAesEncryption 和 InstallAesDecryption 函数都使用 CNG。

有关 CNG 的更多信息可在这里 ↗找到。

[!IMPORTANT] 📚 知识扩展 - Windows 加密 API 的演变

Windows 提供了多代加密 API:

API 全称引入时间状态特点
CryptoAPI Cryptographic API Windows 2000 ⚠️ 已弃用老旧,不推荐使用
CNG Cryptographic Next Generation Windows Vista ✅ 当前标准现代,模块化,推荐使用

CNG 的优势:

🔹 模块化设计 - 支持自定义加密提供程序

🔹 更好的性能 - 支持硬件加速

🔹 更安全 - 符合 FIPS 140-2 标准

🔹 更灵活 - 支持更多算法和密钥长度

为什么本模块使用 CNG?

✅ 是 Windows 官方推荐的加密 API

✅ 所有现代 Windows 版本都支持 (Vista 及以后)

✅ 性能优秀,安全性高

✅ 文档完善,社区支持好

API	全称	引入时间	状态	特点
CryptoAPI	Cryptographic API	Windows 2000	⚠️ 已弃用	老旧,不推荐使用
CNG	Cryptographic Next Generation	Windows Vista	✅ 当前标准	现代,模块化,推荐使用

InstallAesEncryption 函数#

InstallAesEncryption 是执行 AES 加密的函数。该函数有一个参数 PAES,它是指向已填充的 AES 结构的指针。函数中使用的 bCrypt 库函数如下所示。

使用的 bCrypt API:

API 函数	功能说明
BCryptOpenAlgorithmProvider ↗	加载 BCRYPT_AES_ALGORITHM ↗ CNG 提供程序以启用加密函数的使用
BCryptGetProperty ↗	第一次调用获取 BCRYPT_OBJECT_LENGTH ↗ 的值,第二次获取 BCRYPT_BLOCK_LENGTH ↗ 属性标识符的值
BCryptSetProperty ↗	用于初始化 `BCRYPT_OBJECT_LENGTH` 属性标识符
BCryptGenerateSymmetricKey ↗	从指定的输入 AES 密钥创建密钥对象
BCryptEncrypt ↗	用于加密指定的数据块。此函数被调用两次,第一次获取加密数据的大小以分配该大小的堆缓冲区。第二次调用加密数据并将密文存储在分配的堆中
BCryptDestroyKey ↗	通过销毁使用 `BCryptGenerateSymmetricKey` 创建的密钥对象来清理
BCryptCloseAlgorithmProvider ↗	通过关闭先前使用 `BCryptOpenAlgorithmProvider` 创建的算法提供程序的对象句柄来清理

如果成功加密 payload,函数返回 TRUE,否则返回 FALSE。

// 加密实现
BOOL InstallAesEncryption(PAES pAes) {

  BOOL                  bSTATE           = TRUE;
  BCRYPT_ALG_HANDLE     hAlgorithm       = NULL;   // 算法句柄
  BCRYPT_KEY_HANDLE     hKeyHandle       = NULL;   // 密钥句柄

  ULONG       		cbResult         = NULL;
  DWORD       		dwBlockSize      = NULL;   // AES 块大小(应为 16)
  
  DWORD       		cbKeyObject      = NULL;   // 密钥对象大小
  PBYTE       		pbKeyObject      = NULL;   // 密钥对象缓冲区

  PBYTE      		pbCipherText     = NULL;   // 密文缓冲区
  DWORD       		cbCipherText     = NULL;   // 密文大小
  NTSTATUS           STATUS           = NULL;

  // 将 "hAlgorithm" 初始化为 AES 算法句柄
  STATUS = BCryptOpenAlgorithmProvider(&hAlgorithm, BCRYPT_AES_ALGORITHM, NULL, 0);
  if (!NT_SUCCESS(STATUS)) {
    	printf("[!] BCryptOpenAlgorithmProvider Failed With Error: 0x%0.8X \n", STATUS);
    	bSTATE = FALSE; goto _EndOfFunc;
  }

  // 获取密钥对象变量 pbKeyObject 的大小。稍后由 BCryptGenerateSymmetricKey 函数使用
  STATUS = BCryptGetProperty(hAlgorithm, BCRYPT_OBJECT_LENGTH, (PBYTE)&cbKeyObject, sizeof(DWORD), &cbResult, 0);
  if (!NT_SUCCESS(STATUS)) {
    	printf("[!] BCryptGetProperty[1] Failed With Error: 0x%0.8X \n", STATUS);
    	bSTATE = FALSE; goto _EndOfFunc;
  }

  // 获取加密中使用的块的大小。由于这是 AES,它必须是 16 字节。
  STATUS = BCryptGetProperty(hAlgorithm, BCRYPT_BLOCK_LENGTH, (PBYTE)&dwBlockSize, sizeof(DWORD), &cbResult, 0);
  if (!NT_SUCCESS(STATUS)) {
   	printf("[!] BCryptGetProperty[2] Failed With Error: 0x%0.8X \n", STATUS);
    	bSTATE = FALSE; goto _EndOfFunc;
  }

  // 检查块大小是否为 16 字节
  if (dwBlockSize != 16) {
    	bSTATE = FALSE; goto _EndOfFunc;
  }

  // 为密钥对象分配内存
  pbKeyObject = (PBYTE)HeapAlloc(GetProcessHeap(), 0, cbKeyObject);
  if (pbKeyObject == NULL) {
    	bSTATE = FALSE; goto _EndOfFunc;
  }

  // 将分组密码模式设置为 CBC。这使用 32 字节密钥和 16 字节 IV。
  STATUS = BCryptSetProperty(hAlgorithm, BCRYPT_CHAINING_MODE, (PBYTE)BCRYPT_CHAIN_MODE_CBC, sizeof(BCRYPT_CHAIN_MODE_CBC), 0);
  if (!NT_SUCCESS(STATUS)) {
    	printf("[!] BCryptSetProperty Failed With Error: 0x%0.8X \n", STATUS);
    	bSTATE = FALSE; goto _EndOfFunc;
  }

  // 从 AES 密钥 "pAes->pKey" 生成密钥对象。输出将保存在 pbKeyObject 中,大小为 cbKeyObject
  STATUS = BCryptGenerateSymmetricKey(hAlgorithm, &hKeyHandle, pbKeyObject, cbKeyObject, (PBYTE)pAes->pKey, KEYSIZE, 0);
  if (!NT_SUCCESS(STATUS)) {
    	printf("[!] BCryptGenerateSymmetricKey Failed With Error: 0x%0.8X \n", STATUS);
    	bSTATE = FALSE; goto _EndOfFunc;
  }

  // 第一次运行 BCryptEncrypt,输出参数为 NULL,以获取保存在 cbCipherText 中的输出缓冲区的大小
  STATUS = BCryptEncrypt(hKeyHandle, (PUCHAR)pAes->pPlainText, (ULONG)pAes->dwPlainSize, NULL, pAes->pIv, IVSIZE, NULL, 0, &cbCipherText, BCRYPT_BLOCK_PADDING);
  if (!NT_SUCCESS(STATUS)) {
    	printf("[!] BCryptEncrypt[1] Failed With Error: 0x%0.8X \n", STATUS);
    	bSTATE = FALSE; goto _EndOfFunc;
  }

  // 为输出缓冲区分配足够的内存,cbCipherText
  pbCipherText = (PBYTE)HeapAlloc(GetProcessHeap(), 0, cbCipherText);
  if (pbCipherText == NULL) {
    	bSTATE = FALSE; goto _EndOfFunc;
  }

  // 再次运行 BCryptEncrypt,使用 pbCipherText 作为输出缓冲区
  STATUS = BCryptEncrypt(hKeyHandle, (PUCHAR)pAes->pPlainText, (ULONG)pAes->dwPlainSize, NULL, pAes->pIv, IVSIZE, pbCipherText, cbCipherText, &cbResult, BCRYPT_BLOCK_PADDING);
  if (!NT_SUCCESS(STATUS)) {
    	printf("[!] BCryptEncrypt[2] Failed With Error: 0x%0.8X \n", STATUS);
    	bSTATE = FALSE; goto _EndOfFunc;
  }


  // 清理
_EndOfFunc:
  if (hKeyHandle) 
    	BCryptDestroyKey(hKeyHandle);
  if (hAlgorithm) 
    	BCryptCloseAlgorithmProvider(hAlgorithm, 0);
  if (pbKeyObject) 
    	HeapFree(GetProcessHeap(), 0, pbKeyObject);
  if (pbCipherText != NULL && bSTATE) {
        // 如果一切顺利,保存 pbCipherText 和 cbCipherText
        pAes->pCipherText 	= pbCipherText;
        pAes->dwCipherSize 	= cbCipherText;
  }
  return bSTATE;
}

📚 知识扩展 - BCrypt API 调用流程详解

完整的 AES 加密流程:

flowchart TD
    A[1. BCryptOpenAlgorithmProvider<br/>打开 AES 算法提供程序] --> B[2. BCryptGetProperty<br/>获取密钥对象大小]
    B --> C[3. BCryptGetProperty<br/>获取块大小 应为16字节]
    C --> D[4. HeapAlloc<br/>分配密钥对象内存]
    D --> E[5. BCryptSetProperty<br/>设置 CBC 模式]
    E --> F[6. BCryptGenerateSymmetricKey<br/>从密钥生成密钥对象]
    F --> G[7. BCryptEncrypt 第1次<br/>NULL输出,获取密文大小]
    G --> H[8. HeapAlloc<br/>分配密文缓冲区]
    H --> I[9. BCryptEncrypt 第2次<br/>实际加密,输出密文]
    I --> J[10. 清理资源<br/>BCryptDestroyKey + BCryptCloseAlgorithmProvider]
    
    style A fill:#e1f5ff
    style F fill:#fff4e1
    style I fill:#e8f5e9
    style J fill:#ffebee

mermaid

为什么 BCryptEncrypt 要调用两次?

这是 Windows API 的常见设计模式:

第一次调用 (获取大小):

BCryptEncrypt(hKey, input, inputSize, NULL, iv, ivSize,
              NULL,  // ← 输出缓冲区为 NULL
              0,     // ← 输出大小为 0
              &cbCipherText,  // ← 函数填充所需大小
              BCRYPT_BLOCK_PADDING);

第二次调用 (实际加密):

pbCipherText = HeapAlloc(..., cbCipherText);  // 分配合适大小

BCryptEncrypt(hKey, input, inputSize, NULL, iv, ivSize,
              pbCipherText,  // ← 提供输出缓冲区
              cbCipherText,  // ←提供缓冲区大小
              &cbResult,     // ← 实际写入的大小
              BCRYPT_BLOCK_PADDING);

为什么这样设计?

✅ 避免缓冲区溢出
✅ 允许动态大小的输出 (因为填充,密文可能比明文大)
✅ 调用者不需要猜测输出大小