Windows系统下OpenSSL AES_ecb_encrypt加解密注意事项及跨平台兼容排查

问题背景 #

在Windows系统中使用OpenSSL的AES_ecb_encrypt实现了AES-ECB加解密接口，本地处理数据和文件均正常，但Java、Python等语言开发的网页加密工具生成的密文无法通过该接口解密。已确认密钥、块对齐方式一致，且均使用ECB模式，尝试了明文直接AES加密、加密后Base64编码两种场景，均解密失败。以下是跨语言加解密的核心注意事项及代码修正建议。

原解密代码 #

std::string DecodeAES(std::string szData)
{

std::string szDst;

try
{

    if (szData.empty())
    {
       return "";
    }
const unsigned int uKeySize = static_cast<unsigned int>(m_szAesRecvKey.size());

    AES_KEY key = { 0 };
    AES_set_decrypt_key(reinterpret_cast<const unsigned char*>(m_szAesRecvKey.data()), static_cast<int>(8 * uKeySize), &key);
    std::vector<unsigned char> sRst(szData.size());
    for (size_t i = 0; i < szData.size(); i += AES_BLOCK_SIZE)
    {
        AES_ecb_encrypt(reinterpret_cast<const unsigned char *>(szData.data() + i), &sRst[i], &key, AES_DECRYPT);
    }
    const size_t pads = sRst[sRst.size() - 1];
    if (pads > 0 && pads <= uKeySize && ((sRst.size() - pads) > 0))
    {
        szDst.assign(sRst.begin(), sRst.end() - pads);
    }

}
catch (const std::exception)
{
}
return szDst;

}

跨语言加解密核心注意事项 #

1. 填充规则不匹配 #

你的代码中用密钥长度uKeySize判断填充长度，这是错误的。AES的块大小固定为16字节（AES_BLOCK_SIZE），PKCS#7填充规则要求填充长度为1~16字节（等于需要填充的字节数），与密钥长度无关。Java、Python等主流加密库默认使用PKCS#7填充，你的错误判断会导致正确的填充被误判，最终截断错误的明文。

2. 密文编码未处理 #

网页加密工具返回的密文通常是Base64编码的字符串，而你的代码直接将输入字符串当作二进制密文处理。如果输入是Base64格式，必须先解码为二进制数据再解密，否则解密的是字符串的ASCII字节，必然失败。

3. 密钥编码一致性 #

确保密钥在所有语言中是相同的二进制字节：

• 如果密钥是字符串，需统一编码格式（比如UTF-8），Windows系统默认编码可能是GBK，而Java/Python默认用UTF-8，编码差异会导致密钥二进制不一致。
• 避免直接使用字符串的长度作为密钥长度，需明确密钥是16、24或32字节（对应AES-128、AES-192、AES-256）。

4. 输入长度校验 #

AES_ecb_encrypt要求输入数据长度必须是AES_BLOCK_SIZE的整数倍，你的代码未校验输入长度，若密文长度不符合要求（比如Base64解码后不是16的倍数），会导致内存越界或错误的解密结果。

5. 异常处理不足 #

原代码的异常捕获过于宽泛且无错误日志，无法定位解密过程中的具体问题（如密钥错误、填充无效、长度不合法等），建议添加错误信息输出，方便排查。

修正后的解密代码 #

#include <openssl/bio.h>
#include <openssl/evp.h>
#include <openssl/buffer.h>
#include <stdexcept>
#include <iostream>

// Base64解码函数，处理网页工具返回的Base64格式密文
std::string Base64Decode(const std::string& input) {
    BIO *bio, *b64;
    std::vector<unsigned char> buffer(input.size());
    int len = 0;

    bio = BIO_new_mem_buf(input.data(), input.size());
    b64 = BIO_new(BIO_f_base64());
    bio = BIO_push(b64, bio);
    BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL); // 忽略Base64中的换行符
    len = BIO_read(bio, buffer.data(), input.size());
    BIO_free_all(bio);

    return std::string(buffer.begin(), buffer.begin() + len);
}

std::string DecodeAES(std::string szData)
{
    std::string szDst;

    try
    {
        if (szData.empty())
        {
            return "";
        }

        // 先将Base64编码的密文解码为二进制数据
        std::string binaryCipher = Base64Decode(szData);

        // 校验密文长度是否为AES块大小的整数倍
        if (binaryCipher.size() % AES_BLOCK_SIZE != 0)
        {
            throw std::invalid_argument("Ciphertext length is not a multiple of AES block size");
        }

        const unsigned int uKeySize = static_cast<unsigned int>(m_szAesRecvKey.size());
        // 校验密钥长度是否符合AES标准（16/24/32字节）
        if (uKeySize != 16 && uKeySize != 24 && uKeySize != 32)
        {
            throw std::invalid_argument("Invalid AES key size (must be 16, 24, or 32 bytes)");
        }

        AES_KEY key = { 0 };
        // 检查密钥设置是否成功
        if (AES_set_decrypt_key(reinterpret_cast<const unsigned char*>(m_szAesRecvKey.data()), 
                                static_cast<int>(8 * uKeySize), &key) != 0)
        {
            throw std::runtime_error("Failed to initialize AES decrypt key");
        }

        std::vector<unsigned char> sRst(binaryCipher.size());
        for (size_t i = 0; i < binaryCipher.size(); i += AES_BLOCK_SIZE)
        {
            AES_ecb_encrypt(reinterpret_cast<const unsigned char*>(binaryCipher.data() + i), 
                            &sRst[i], &key, AES_DECRYPT);
        }

        // 按照PKCS#7规则校验并去除填充
        const size_t pads = sRst[sRst.size() - 1];
        if (pads > 0 && pads <= AES_BLOCK_SIZE)
        {
            // 额外校验所有填充字节是否等于填充长度，防止篡改
            bool validPad = true;
            for (size_t i = sRst.size() - pads; i < sRst.size(); ++i)
            {
                if (sRst[i] != pads)
                {
                    validPad = false;
                    break;
                }
            }
            if (validPad)
            {
                szDst.assign(sRst.begin(), sRst.end() - pads);
            }
            else
            {
                throw std::runtime_error("Invalid PKCS#7 padding bytes");
            }
        }
        else
        {
            // 若明文长度正好是块大小的倍数，填充长度为16，直接返回全部数据
            szDst.assign(sRst.begin(), sRst.end());
        }
    }
    catch (const std::exception& e)
    {
        // 输出错误信息，方便排查问题
        std::cerr << "Decryption failed: " << e.what() << std::endl;
        return "";
    }
    return szDst;
}

内容的提问来源于stack exchange，提问作者hahaha1144