解决C++ OpenSSL低级AES解密乱码：推荐使用EVP API

#include <iostream>
#include <string>
#include <vector>
#include <iomanip>
#include <sstream>
#include <openssl/evp.h>
#include <openssl/rand.h>
#include <openssl/err.h>

// 辅助函数：将二进制数据转换为十六进制字符串
std::string binToHex(const std::vector<unsigned char>& input) {
    std::ostringstream hexStream;
    hexStream << std::hex << std::setfill('0');
    for (unsigned char c : input) {
        hexStream << std::setw(2) << static_cast<int>(c);
    }
    return hexStream.str();
}

// 使用EVP API进行AES-128-CBC加密
std::string evp_aes_encrypt(const std::string& plaintext, const std::string& key_str) {
    // 密钥长度检查，AES-128需要16字节密钥
    if (key_str.length() != 16) {
        std::cerr << "Error: Key must be 16 bytes for AES-128." << std::endl;
        return "";
    }
    const unsigned char* key = reinterpret_cast<const unsigned char*>(key_str.c_str());

    // 初始化EVP上下文
    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
    if (!ctx) {
        ERR_print_errors_fp(stderr);
        return "";
    }

    // 生成随机IV
    unsigned char iv[EVP_MAX_IV_LENGTH]; // EVP_MAX_IV_LENGTH 通常为16
    if (RAND_bytes(iv, EVP_CIPHER_iv_length(EVP_aes_128_cbc())) != 1) {
        ERR_print_errors_fp(stderr);
        EVP_CIPHER_CTX_free(ctx);
        return "";
    }

    // 初始化加密操作
    // EVP_aes_128_cbc() 指定AES-128-CBC模式
    // NULL 表示使用默认的引擎
    // key 和 iv 是加密密钥和初始化向量
    if (1 != EVP_EncryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, key, iv)) {
        ERR_print_errors_fp(stderr);
        EVP_CIPHER_CTX_free(ctx);
        return "";
    }

    // EVP_CIPHER_CTX_set_padding 默认开启PKCS#7填充，这里显式设置确保行为一致
    // 1 表示启用填充，0 表示禁用
    if (1 != EVP_CIPHER_CTX_set_padding(ctx, 1)) {
        ERR_print_errors_fp(stderr);
        EVP_CIPHER_CTX_free(ctx);
        return "";
    }

    // 计算密文最大可能长度：明文长度 + 块大小 - 1 (最多一个块的填充)
    int plaintext_len = plaintext.length();
    int ciphertext_len = 0;
    int final_len = 0;
    std::vector<unsigned char> ciphertext_buffer(plaintext_len + EVP_CIPHER_block_size(EVP_aes_128_cbc()));

    // 加密明文
    if (1 != EVP_EncryptUpdate(ctx, ciphertext_buffer.data(), &ciphertext_len, 
                               reinterpret_cast<const unsigned char*>(plaintext.c_str()), plaintext_len)) {
        ERR_print_errors_fp(stderr);
        EVP_CIPHER_CTX_free(ctx);
        return "";
    }

    // 完成加密操作，处理任何剩余数据和填充
    if (1 != EVP_EncryptFinal_ex(ctx, ciphertext_buffer.data() + ciphertext_len, &final_len)) {
        ERR_print_errors_fp(stderr);
        EVP_CIPHER_CTX_free(ctx);
        return "";
    }
    ciphertext_len += final_len;

    // 清理EVP上下文
    EVP_CIPHER_CTX_free(ctx);

    // 将IV和密文组合成一个输出向量
    std::vector<unsigned char> output_data;
    output_data.insert(output_data.end(), iv, iv + EVP_CIPHER_iv_length(EVP_aes_128_cbc()));
    output_data.insert(output_data.end(), ciphertext_buffer.begin(), ciphertext_buffer.begin() + ciphertext_len);

    // 将组合后的二进制数据转换为十六进制字符串
    return binToHex(output_data);
}

int main() {
    // 假设的明文和密钥
    std::string plaintext = "{\"pass\":\"azertyu\",\"opt\":...}";
    std::string key = "t*H3_B3$t/k$%evr"; // 16字节密钥

    // 执行加密
    std::string encrypted_hex = evp_aes_encrypt(plaintext, key);

    if (!encrypted_hex.empty()) {
        std::cout << "Encrypted (Hex): " << encrypted_hex << std::endl;
    } else {
        std::cerr << "Encryption failed." << std::endl;
    }

    return 0;
}