通过高级处理器硬件指令集AES-NI实现AES-256-CFB算法并通过OPENSSL加密验证算法正确性。

关联：

通过高级处理器硬件指令集AES-NI实现AES-256-CFB算法。-CSDN博客

代码：

#include <wmmintrin.h>   // AES 指令集
#include <emmintrin.h>   // SSE2 指令集
#include <string.h>
#include <iostream>
#include <iomanip>
#include <ctime>
#include <algorithm>    // std::min
#include <openssl/evp.h> // OpenSSL 加密

// AES-256 密钥扩展
void aes256_key_expansion(const uint8_t *key, __m128i *round_key) {
    // 加载初始密钥 (256位 = 32字节)
    __m128i key1 = _mm_loadu_si128((const __m128i*)key);       // 前128位
    __m128i key2 = _mm_loadu_si128((const __m128i*)(key + 16)); // 后128位
    
    round_key[0] = key1;  // 第0轮密钥
    round_key[1] = key2;  // 第1轮密钥
    
    // 密钥扩展过程 (手动展开所有轮次)
    __m128i temp = _mm_aeskeygenassist_si128(key2, 0x01); // 生成辅助密钥
    temp = _mm_shuffle_epi32(temp, 0xFF);                 // 混洗字节
    key1 = _mm_xor_si128(key1, _mm_slli_si128(key1, 4)); // 移位并异或
    key1 = _mm_xor_si128(key1, _mm_slli_si128(key1, 8));
    key1 = _mm_xor_si128(key1, temp);                    // 添加轮常数
    round_key[2] = key1;  // 第2轮密钥
    
    temp = _mm_aeskeygenassist_si128(key1, 0x00);
    temp = _mm_shuffle_epi32(temp, 0xAA);
    key2 = _mm_xor_si128(key2, _mm_slli_si128(key2, 4));
    key2 = _mm_xor_si128(key2, _mm_slli_si128(key2, 8));
    key2 = _mm_xor_si128(key2, temp);
    round_key[3] = key2;  // 第3轮密钥
    
    temp = _mm_aeskeygenassist_si128(key2, 0x02);
    temp = _mm_shuffle_epi32(temp, 0xFF);
    key1 = _mm_xor_si128(key1, _mm_slli_si128(key1, 4));
    key1 = _mm_xor_si128(key1, _mm_slli_si128(key1, 8));
    key1 = _mm_xor_si128(key1, temp);
    round_key[4] = key1;  // 第4轮密钥
    
    temp = _mm_aeskeygenassist_si128(key1, 0x00);
    temp = _mm_shuffle_epi32(temp, 0xAA);
    key2 = _mm_xor_si128(key2, _mm_slli_si128(key2, 4));
    key2 = _mm_xor_si128(key2, _mm_slli_si128(key2, 8));
    key2 = _mm_xor_si128(key2, temp);
    round_key[5] = key2;  // 第5轮密钥
    
    temp = _mm_aeskeygenassist_si128(key2, 0x04);
    temp = _mm_shuffle_epi32(temp, 0xFF);
    key1 = _mm_xor_si128(key1, _mm_slli_si128(key1, 4));
    key1 = _mm_xor_si128(key1, _mm_slli_si128(key1, 8));
    key1 = _mm_xor_si128(key1, temp);
    round_key[6] = key1;  // 第6轮密钥
    
    temp = _mm_aeskeygenassist_si128(key1, 0x00);
    temp = _mm_shuffle_epi32(temp, 0xAA);
    key2 = _mm_xor_si128(key2, _mm_slli_si128(key2, 4));
    key2 = _mm_xor_si128(key2, _mm_slli_si128(key2, 8));
    key2 = _mm_xor_si128(key2, temp);
    round_key[7] = key2;  // 第7轮密钥
    
    temp = _mm_aeskeygenassist_si128(key2, 0x08);
    temp = _mm_shuffle_epi32(temp, 0xFF);
    key1 = _mm_xor_si128(key1, _mm_slli_si128(key1, 4));
    key1 = _mm_xor_si128(key1, _mm_slli_si128(key1, 8));
    key1 = _mm_xor_si128(key1, temp);
    round_key[8] = key1;  // 第8轮密钥
    
    temp = _mm_aeskeygenassist_si128(key1, 0x00);
    temp = _mm_shuffle_epi32(temp, 0xAA);
    key2 = _mm_xor_si128(key2, _mm_slli_si128(key2, 4));
    key2 = _mm_xor_si128(key2, _mm_slli_si128(key2, 8));
    key2 = _mm_xor_si128(key2, temp);
    round_key[9] = key2;  // 第9轮密钥
    
    temp = _mm_aeskeygenassist_si128(key2, 0x10);
    temp = _mm_shuffle_epi32(temp, 0xFF);
    key1 = _mm_xor_si128(key1, _mm_slli_si128(key1, 4));
    key1 = _mm_xor_si128(key1, _mm_slli_si128(key1, 8));
    key1 = _mm_xor_si128(key1, temp);
    round_key[10] = key1; // 第10轮密钥
    
    temp = _mm_aeskeygenassist_si128(key1, 0x00);
    temp = _mm_shuffle_epi32(temp, 0xAA);
    key2 = _mm_xor_si128(key2, _mm_slli_si128(key2, 4));
    key2 = _mm_xor_si128(key2, _mm_slli_si128(key2, 8));
    key2 = _mm_xor_si128(key2, temp);
    round_key[11] = key2; // 第11轮密钥
    
    temp = _mm_aeskeygenassist_si128(key2, 0x20);
    temp = _mm_shuffle_epi32(temp, 0xFF);
    key1 = _mm_xor_si128(key1, _mm_slli_si128(key1, 4));
    key1 = _mm_xor_si128(key1, _mm_slli_si128(key1, 8));
    key1 = _mm_xor_si128(key1, temp);
    round_key[12] = key1; // 第12轮密钥
    
    temp = _mm_aeskeygenassist_si128(key1, 0x00);
    temp = _mm_shuffle_epi32(temp, 0xAA);
    key2 = _mm_xor_si128(key2, _mm_slli_si128(key2, 4));
    key2 = _mm_xor_si128(key2, _mm_slli_si128(key2, 8));
    key2 = _mm_xor_si128(key2, temp);
    round_key[13] = key2; // 第13轮密钥
    
    temp = _mm_aeskeygenassist_si128(key2, 0x40);
    temp = _mm_shuffle_epi32(temp, 0xFF);
    key1 = _mm_xor_si128(key1, _mm_slli_si128(key1, 4));
    key1 = _mm_xor_si128(key1, _mm_slli_si128(key1, 8));
    key1 = _mm_xor_si128(key1, temp);
    round_key[14] = key1; // 第14轮密钥
}

// AES-256 加密单个128位块
__m128i aes256_encrypt_block(__m128i block, const __m128i *round_key) {
    block = _mm_xor_si128(block, round_key[0]); // 初始轮密钥加
    
    // 执行13轮完整AES轮函数
    for (int i = 1; i < 14; i++) {
        block = _mm_aesenc_si128(block, round_key[i]); // AES加密指令
    }
    
    // 最后一轮（无MixColumns）
    block = _mm_aesenclast_si128(block, round_key[14]);
    return block;
}

// AES-256-CFB 加密
void aes256_cfb_encrypt(uint8_t *ciphertext, const uint8_t *plaintext, size_t len,
                       const uint8_t *iv, const __m128i *round_key) {
    __m128i feedback = _mm_loadu_si128((const __m128i*)iv); // 初始化反馈寄存器
    size_t blocks = len / 16;    // 完整块数量
    size_t remaining = len % 16; // 剩余字节数
    
    // 处理完整块
    for (size_t i = 0; i < blocks; i++) {
        // 生成密钥流
        __m128i keystream = aes256_encrypt_block(feedback, round_key);
        // 加载当前明文块
        __m128i plain_block = _mm_loadu_si128((const __m128i*)(plaintext + i * 16));
        // 异或生成密文块
        __m128i cipher_block = _mm_xor_si128(plain_block, keystream);
        
        // 存储密文块
        _mm_storeu_si128((__m128i*)(ciphertext + i * 16), cipher_block);
        
        // 更新反馈寄存器（使用新生成的密文）
        feedback = cipher_block;
    }
    
    // 处理部分块
    if (remaining > 0) {
        // 生成部分密钥流
        __m128i keystream = aes256_encrypt_block(feedback, round_key);
        const uint8_t* src = plaintext + blocks * 16;
        uint8_t* dst = ciphertext + blocks * 16;
        
        // 逐字节异或处理剩余数据
        for (size_t i = 0; i < remaining; i++) {
            dst[i] = src[i] ^ ((uint8_t*)&keystream)[i];
        }
    }
}

// AES-256-CFB 解密
void aes256_cfb_decrypt(uint8_t *plaintext, const uint8_t *ciphertext, size_t len,
                       const uint8_t *iv, const __m128i *round_key) {
    __m128i feedback = _mm_loadu_si128((const __m128i*)iv); // 初始化反馈寄存器
    size_t blocks = len / 16;    // 完整块数量
    size_t remaining = len % 16; // 剩余字节数
    
    // 处理完整块
    for (size_t i = 0; i < blocks; i++) {
        // 生成密钥流
        __m128i keystream = aes256_encrypt_block(feedback, round_key);
        // 加载当前密文块
        __m128i cipher_block = _mm_loadu_si128((const __m128i*)(ciphertext + i * 16));
        // 异或生成明文块
        __m128i plain_block = _mm_xor_si128(cipher_block, keystream);
        
        // 存储明文块
        _mm_storeu_si128((__m128i*)(plaintext + i * 16), plain_block);
        
        // 更新反馈寄存器（使用当前密文）
        feedback = cipher_block;
    }
    
    // 处理部分块
    if (remaining > 0) {
        // 生成部分密钥流
        __m128i keystream = aes256_encrypt_block(feedback, round_key);
        const uint8_t* src = ciphertext + blocks * 16;
        uint8_t* dst = plaintext + blocks * 16;
        
        // 逐字节异或处理剩余数据
        for (size_t i = 0; i < remaining; i++) {
            dst[i] = src[i] ^ ((uint8_t*)&keystream)[i];
        }
    }
}

// 打印十六进制数据
void print_hex(const char* label, const uint8_t* data, size_t len, size_t max_display = 128) {
    std::cout << label << " (显示前" << std::min(len, max_display) << "字节): ";
    size_t display_len = std::min(len, max_display);
    for (size_t i = 0; i < display_len; i++) {
        std::cout << std::hex << std::setw(2) << std::setfill('0') 
                  << static_cast<int>(data[i]) << " ";
    }
    std::cout << (len > max_display ? "..." : "") << std::dec << "\n";
}

// 使用OpenSSL进行AES-256-CFB加密
bool openssl_aes256_cfb_encrypt(uint8_t *ciphertext, const uint8_t *plaintext, size_t len,
                               const uint8_t *key, const uint8_t *iv) {
    EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
    if (!ctx) return false;
    
    // 初始化加密上下文
    if (1 != EVP_EncryptInit_ex(ctx, EVP_aes_256_cfb128(), NULL, key, iv)) {
        EVP_CIPHER_CTX_free(ctx);
        return false;
    }
    
    // 禁用填充 (CFB模式不需要填充)
    EVP_CIPHER_CTX_set_padding(ctx, 0);
    
    int out_len;
    // 执行加密
    if (1 != EVP_EncryptUpdate(ctx, ciphertext, &out_len, plaintext, len)) {
        EVP_CIPHER_CTX_free(ctx);
        return false;
    }
    
    // 结束加密流
    int final_len;
    if (1 != EVP_EncryptFinal_ex(ctx, ciphertext + out_len, &final_len)) {
        EVP_CIPHER_CTX_free(ctx);
        return false;
    }
    
    EVP_CIPHER_CTX_free(ctx);
    return true;
}

// 验证实现正确性（包括与OpenSSL对比）
bool test_aes256_cfb() {
    // 测试向量
    uint8_t key[32] = {
        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
        0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
        0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
        0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
    };
    
    uint8_t iv[16] = {
        0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
        0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff
    };
    
    const char* plaintext = "Hello, AES-256-CFB! This is a test.";
    size_t len = strlen(plaintext);
    
    // 扩展密钥存储
    __m128i round_key[15];
    aes256_key_expansion(key, round_key);
    
    // 分配内存
    uint8_t* ciphertext = new uint8_t[len];
    uint8_t* openssl_ciphertext = new uint8_t[len];
    uint8_t* decrypted = new uint8_t[len + 1];
    
    // 使用自定义实现加密
    aes256_cfb_encrypt(ciphertext, (const uint8_t*)plaintext, len, iv, round_key);
    
    // 使用OpenSSL加密
    if (!openssl_aes256_cfb_encrypt(openssl_ciphertext, (const uint8_t*)plaintext, len, key, iv)) {
        std::cerr << "OpenSSL加密失败!\n";
        delete[] ciphertext;
        delete[] openssl_ciphertext;
        delete[] decrypted;
        return false;
    }
    
    // 对比加密结果
    bool encryption_match = memcmp(ciphertext, openssl_ciphertext, len) == 0;
    
    std::cout << "\n=== 加密结果对比 ===\n";
    print_hex("自定义实现加密", ciphertext, len);
    print_hex("OpenSSL 加密   ", openssl_ciphertext, len);
    std::cout << "加密结果匹配: " << (encryption_match ? "是" : "否") << "\n";
    
    // 使用自定义实现解密
    aes256_cfb_decrypt(decrypted, ciphertext, len, iv, round_key);
    decrypted[len] = '\0'; // 添加终止符
    
    // 验证解密结果
    bool decryption_match = memcmp(plaintext, decrypted, len) == 0;
    
    if (!encryption_match || !decryption_match) {
        std::cerr << "\n测试失败!\n";
        if (!encryption_match) {
            std::cerr << "错误: 加密结果与OpenSSL不一致!\n";
        }
        if (!decryption_match) {
            std::cerr << "错误: 解密结果与原始文本不匹配!\n";
            std::cerr << "原始文本: " << plaintext << "\n";
            std::cerr << "解密文本: " << decrypted << "\n";
        }
        
        // 打印详细数据
        print_hex("原始数据", (const uint8_t*)plaintext, len);
        print_hex("解密数据", decrypted, len);
        
        delete[] ciphertext;
        delete[] openssl_ciphertext;
        delete[] decrypted;
        return false;
    }
    
    delete[] ciphertext;
    delete[] openssl_ciphertext;
    delete[] decrypted;
    
    std::cout << "\n测试通过: 所有结果匹配!\n";
    return true;
}

int main() {
    std::cout << "=== AES-256-CFB 实现验证 ===\n";
    
    // 首先运行自测试（包含与OpenSSL的对比）
    if (!test_aes256_cfb()) {
        std::cerr << "\n实现验证失败，请检查代码!\n";
        return 1;
    }
    
    // 示例密钥（256位 = 32字节）
    uint8_t key[32] = {
        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
        0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
        0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
        0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
    };
    
    // 示例IV（128位 = 16字节）
    uint8_t iv[16] = {
        0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
        0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff
    };
    
    // 测试数据
    const char* plaintext = "Hello, AES-256-CFB! This is a test message for encryption and decryption.";
    size_t len = strlen(plaintext);
    
    // 输出缓冲区
    uint8_t* ciphertext = new uint8_t[len];
    uint8_t* decrypted = new uint8_t[len + 1]; // +1 用于终止符
    
    // 扩展密钥存储
    __m128i round_key[15];
    aes256_key_expansion(key, round_key);
    
    std::cout << "\n=== AES-256-CFB 演示 ===\n";
    std::cout << "原始长度: " << len << " 字节\n";
    std::cout << "原始文本: " << plaintext << "\n\n";
    
    // 记录开始时间
    std::clock_t start = std::clock();
    
    // 加密
    aes256_cfb_encrypt(ciphertext, (const uint8_t*)plaintext, len, iv, round_key);
    
    // 计算加密耗时
    double encrypt_time = (std::clock() - start) / (double)CLOCKS_PER_SEC;
    
    print_hex("加密结果", ciphertext, len);
    
    // 解密
    start = std::clock();
    aes256_cfb_decrypt(decrypted, ciphertext, len, iv, round_key);
    double decrypt_time = (std::clock() - start) / (double)CLOCKS_PER_SEC;
    
    decrypted[len] = '\0'; // 添加字符串结束符
    std::cout << "解密文本: " << decrypted << "\n";
    
    // 性能统计
    std::cout << "\n性能统计:\n";
    std::cout << "加密时间: " << std::fixed << std::setprecision(5) 
              << encrypt_time * 1000 << " ms" << std::endl;
    std::cout << "解密时间: " << std::fixed << std::setprecision(5) 
              << decrypt_time * 1000 << " ms" << std::endl;
    std::cout << "吞吐量: " << std::setprecision(2) 
              << (len / (1024.0 * 1024.0)) / encrypt_time << " MB/s (加密)" << std::endl;
    
    // 验证结果
    if (memcmp(plaintext, decrypted, len) == 0) {
        std::cout << "\n验证成功: 解密文本与原始文本匹配!\n";
    } else {
        std::cout << "\n错误: 解密文本与原始文本不匹配!\n";
        std::cout << "原始长度: " << len << "\n";
        std::cout << "解密长度: " << strlen((const char*)decrypted) << "\n";
        print_hex("原始数据", (const uint8_t*)plaintext, len);
        print_hex("解密数据", decrypted, len);
    }
    
    // 清理
    delete[] ciphertext;
    delete[] decrypted;
    
    return 0;
}