AES加密算法原理与C++实现：从基础到实战

AES加密算法原理与C++实现：从基础到实战

引用

CSDN

1.

https://blog.csdn.net/qq_41683953/article/details/141368999

AES（高级加密标准）是一种广泛使用的对称加密算法，主要用于保护数据的安全传输和存储。本文将详细介绍AES算法的原理及其C++实现，并通过一个实际的逆向工程案例展示AES加密的实战应用。

AES简介

AES是一种分组加密算法，明文被分为固定长度的组进行加密。具体来说，AES使用128位（16字节）的分组大小，密钥长度可以是128位、192位或256位。AES加密过程包括密钥扩展、字节替换、行移位、列混合和轮密钥加等步骤。

AES在反编译中的一个明显特征是16字节分组处理，这有助于在实际应用中识别AES加密的存在。

AES加密与解密流程详解

密钥扩展

AES加密过程需要生成多个轮密钥。具体轮数和生成的轮密钥数量取决于密钥长度：

• AES-128：10轮加密，生成11个轮密钥
• AES-192：12轮加密，生成13个轮密钥
• AES-256：14轮加密，生成15个轮密钥

轮密钥生成过程如下：以16字节的密钥为例，首先将其转换为4个4字节的初始密钥，然后通过初始密钥生成剩余的轮密钥。每一轮的轮常量（Rcon）用于增加密钥的复杂性。

int MyAes::KeyExpansion(uint8_t* key, int length)
{
    static const uint32_t rcon[10] = {
        0x01000000UL, 0x02000000UL, 0x04000000UL, 0x08000000UL, 0x10000000UL,
        0x20000000UL, 0x40000000UL, 0x80000000UL, 0x1B000000UL, 0x36000000UL
    };
    uint32_t* w = this->ek;
    for (size_t i = 0; i < 4; i++)
    {
        U8TOU32(w[i], key + 4 * i);
    }
    for (size_t i = 0; i < 10; i++)
    {
        w[4] = w[0] ^ MIX(w[3]) ^ rcon[i];
        w[5] = w[1] ^ w[4];
        w[6] = w[2] ^ w[5];
        w[7] = w[3] ^ w[6];
        w += 4;
    }
    uint32_t* Pimage_dkey = dk;
    for (size_t i = 0; i < 11; i++)
    {
        for (size_t j = 0; j < 4; j++)
        {
            Pimage_dkey[j] = w[j];
        }
        Pimage_dkey += 4;
        w -= 4;
    }
}

字节替换

字节替换使用S盒（字节替换表）进行查表变换。例如，输入0x12时，0x1为行号，0x2为列，查表得到0xc9。解密时使用逆S盒进行字节替换。

int MyAes::TranBytes(uint8_t(*array)[4])
{
    for (size_t i = 0; i < 4; i++)
    {
        for (size_t j = 0; j < 4; j++)
        {
            array[i][j] = S[array[i][j]];
        }
    }
    return 0;
}

行移位

行移位操作将4x4矩阵的每一行循环左移或右移。加密时进行循环左移，解密时进行循环右移。

int MyAes::ShiftRows(uint8_t(*array)[4])
{
    uint32_t temp;
    for (size_t i = 1; i < 4; i++)
    {
        U8TOU32(temp, array[i]);
        temp = ROL32(temp, 8 * i);
        U32TOU8(temp, array[i]);
    }
    return 0;
}

列混合

列混合操作通过将输入的4x4矩阵与一个固定常数矩阵相乘实现。解密时需要使用该矩阵的逆矩阵。

int MyAes::MixCols(uint8_t(*array)[4])
{
    uint8_t M[4][4] = { {0x02, 0x03, 0x01, 0x01},
                       {0x01, 0x02, 0x03, 0x01},
                       {0x01, 0x01, 0x02, 0x03},
                       {0x03, 0x01, 0x01, 0x02} };
    uint8_t src[4][4];
    for (int i = 0; i < 4; ++i) {
        for (int j = 0; j < 4; ++j) {
            src[i][j] = array[i][j];
        }
    }
    for (size_t i = 0; i < 4; i++)
    {
        for (size_t j = 0; j < 4; j++)
        {
            array[i][j] = Gmul(M[i][0], src[0][j]) ^
                          Gmul(M[i][1], src[1][j]) ^
                          Gmul(M[i][2], src[2][j]) ^
                          Gmul(M[i][3], src[3][j]);
        }
    }
    return 0;
}

轮密钥加

轮密钥加操作将输入的每个字节与扩展后的密钥进行异或运算。

int MyAes::AddRoundKey(uint8_t(*array)[4], uint32_t* key)
{
    for (size_t i = 0; i < 4; i++)
    {
        for (size_t j = 0; j < 4; j++)
        {
            uint8_t temp = (uint8_t)BYTE(key[j], 3 - i);
            array[i][j] ^= temp;
        }
    }
    return 0;
}

AES算法总体实现

完整的AES加密和解密实现包括头文件定义、密钥扩展、字符串转换、轮密钥加、字节替换、行移位、列混合等核心函数。以下是关键代码片段：

class MyAes
{
public:
    MyAes();
    MyAes(unsigned char *box, unsigned char* inv_box);
    ~MyAes();
    int AesEncode(uint8_t* input, int input_length, uint8_t* key, int key_length);
    int AesDecode(uint8_t* input, int input_length, uint8_t* key, int key_length);
    std::shared_ptr<uint8_t[]> encode = nullptr;
    std::shared_ptr<uint8_t[]> decode = nullptr;
private:
    int KeyExpansion(uint8_t* key, int length);
    uint8_t Mix(uint8_t t);
    int TranSTRtoArray(uint8_t* input, uint8_t (*array)[4]);
    int TranArraytoSTR(uint8_t* output, uint8_t(*array)[4]);
    int AddRoundKey(uint8_t(*array)[4], uint32_t* key);
    int TranBytes(uint8_t (*array)[4]);
    int InvTranBytes(uint8_t(*array)[4]);
    int ShiftRows(uint8_t(*array)[4]);
    int InvShiftRows(uint8_t(*array)[4]);
    int MixCols(uint8_t(*array)[4]);
    int InvMixCols(uint8_t(*array)[4]);
    uint8_t Gmul(uint8_t, uint8_t);
    uint32_t ek[44], dk[44];
    unsigned char S[256];
    unsigned char Inv_S[256];
};

实战案例：OLLVM+AES+BASE64+XOR组合加密

在实际应用中，AES加密往往与其他加密方式组合使用，以增强安全性。以下是一个结合ARM OLLVM混淆技术的AES加密案例分析：

1. 识别AES特征：通过Findcrypt插件发现AES的16字节分组特征。
2. 分析加密流程：发现加密过程包括XOR预处理、AES加密和Base64编码。
3. 破解方法：通过分析初始化数组中的异或操作，逆向解密Base64码表、AES密钥和IV向量。

void test()
{
    unsigned char base_table[] =
    {
        0x8B, 0x8F, 0x95, 0x92, 0x90, 0x91, 0x93, 0x94, 0x96, 0x97,
        0x98, 0x99, 0x9C, 0x9D, 0x9E, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5,
        0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
        0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9,
        0xFA, 0xFB, 0x86, 0xFD, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC,
        0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6,
        0xD7, 0xD8, 0xD9, 0xDA, 0
    };
    for (size_t i = 0; i < 64; i++)
    {
        base_table[i] ^= 0xa0;
    }
    unsigned char key[] =
    {
        0x43, 0x5F, 0x5E, 0x44, 0x17, 0x5E, 0x44, 0x17, 0x56, 0x17,
        0x5C, 0x52, 0x4E, 0x16, 0x16, 0x16, 0
    };
    unsigned char iv[] =
    {
        0xD4, 0xC8, 0xC9, 0xD3, 0x80, 0xC9, 0xD3, 0x80, 0xC1, 0xCE,
        0x80, 0xC9, 0xD6, 0x81, 0x81, 0x81, 0
    };
    for (size_t i = 0; i < 16; i++)
    {
        key[i] ^= 0x37;
        iv[i] ^= 0xa0;
    }
    printf("table: %s\n", base_table);
    printf("key: %s\n", key);
    printf("iv: %s\n", iv);
}

通过上述分析和代码实现，可以成功破解AES加密并恢复原始数据。

总结

AES算法作为现代密码学中的重要组成部分，其原理和实现细节对于理解数据加密技术至关重要。本文通过详细的理论讲解和代码实现，帮助读者全面掌握AES算法，并通过实际案例展示了AES在逆向工程中的应用。对于开发者和安全研究人员来说，这些知识不仅有助于开发更安全的加密系统，还能提升对加密数据的分析和破解能力。