CryptoUtil.cpp

#include "CryptoUtil.h"
#include "Protocol.h"

#include <openssl/evp.h>
#include <openssl/sha.h>
#include <spdlog/spdlog.h>
#include <sstream>
#include <iomanip>
#include <cstring>

bool CryptoUtil::Encrypt(const std::vector<uint8_t> &plaintext, std::vector<uint8_t> &ciphertext) {
    // 1. EVP_CIPHER_CTX 是 OpenSSL 的加密操作上下文，必须显式创建和释放
    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
    if(!ctx) {
        spdlog::error("[Crypto] EVP_CIPHER_CTX_new 失败，OpenSSL 可能未正确初始化");
        return false;
    }

    // 2. 初始化 AES-256-CBC 加密
    // 参数: ctx, 算法, ENGINE(nullptr=默认), 密钥, IV
    if (EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), nullptr,
                           GetAESKey(), GetAESIV()) != 1)
    {
        spdlog::error("[Crypto] EVP_EncryptInit_ex 失败");
        EVP_CIPHER_CTX_free(ctx);
        return false;
    }

    // 3. 预分配输出缓冲区：AES-CBC 输出最多比输入多一个块 (16 字节)
    // 公式: output_len_max = input_len + AES_BLOCK_SIZE
    const int block_size = EVP_CIPHER_CTX_get_block_size(ctx);
    ciphertext.resize(plaintext.size() + block_size);

    int out_len1 = 0;
    // 4. EVP_EncryptUpdate: 将 plaintext 分块加密，结果写入 ciphertext
    // 注意: 不一定产生与输入等长的输出（CBC 需要等到块满才输出）
    if (EVP_EncryptUpdate(ctx,
                          ciphertext.data(), &out_len1,
                          plaintext.empty() ? nullptr : plaintext.data(),
                          static_cast<int>(plaintext.size())) != 1)
    {
        spdlog::error("[Crypto] EVP_EncryptUpdate 失败");
        EVP_CIPHER_CTX_free(ctx);
        return false;
    }

    int out_len2 = 0;
    // 5. EVP_EncryptFinal_ex: 处理最后一块并添加 PKCS#7 填充
    // 即使明文长度是块大小的整数倍，也会额外添加一整块填充（全为 0x10）
    // 这样解密方可以无歧义地识别填充边界
    if (EVP_EncryptFinal_ex(ctx, ciphertext.data() + out_len1, &out_len2) != 1) {
        spdlog::error("[Crypto] EVP_EncryptFinal_ex 失败，可能是填充错误");
        EVP_CIPHER_CTX_free(ctx);
        return false;
    }

    // 调整为实际输出大小
    ciphertext.resize(out_len1 + out_len2);

    // 释放上下文
    EVP_CIPHER_CTX_free(ctx);
    return true;
}

bool CryptoUtil::Decrypt(const std::vector<uint8_t> &ciphertext, std::vector<uint8_t> &plaintext) {

    if (ciphertext.empty()) {
        plaintext.clear();
        return true;
    }

    // 1. 创建上下文
    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
    if (!ctx) {
        spdlog::error("[Crypto] EVP_CIPHER_CTX_new 失败 (Decrypt)");
        return false;
    }

    // 2. 初始化 AES-256-CBC 解密，使用相同的密钥和 IV
    if (EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), nullptr,
                           GetAESKey(), GetAESIV()) != 1)
    {
        spdlog::error("[Crypto] EVP_DecryptInit_ex 失败");
        EVP_CIPHER_CTX_free(ctx);
        return false;
    }

    // 3. 预分配解密输出缓冲区（解密后长度 <= 密文长度）
    plaintext.resize(ciphertext.size());

    int out_len1 = 0;
    if (EVP_DecryptUpdate(ctx,
                          plaintext.data(), &out_len1,
                          ciphertext.data(),
                          static_cast<int>(ciphertext.size())) != 1)
    {
        spdlog::error("[Crypto] EVP_DecryptUpdate 失败");
        EVP_CIPHER_CTX_free(ctx);
        return false;
    }

    int out_len2 = 0;
    // 4. EVP_DecryptFinal_ex: 去除 PKCS#7 填充，返回实际明文
    // 若密文损坏（填充不合法），此函数返回 0 并报错
    if (EVP_DecryptFinal_ex(ctx, plaintext.data() + out_len1, &out_len2) != 1) {
        spdlog::error("[Crypto] EVP_DecryptFinal_ex 失败：密文损坏或填充错误");
        EVP_CIPHER_CTX_free(ctx);
        return false;
    }

    // 调整到去除填充后的实际明文长度
    plaintext.resize(out_len1 + out_len2);

    // 释放上下文
    EVP_CIPHER_CTX_free(ctx);
    return true;
}

bool CryptoUtil::EncryptString(const std::string& plaintext, std::vector<uint8_t>& ciphertext) {
    std::vector<uint8_t> bytes(plaintext.begin(), plaintext.end());
    return Encrypt(bytes, ciphertext);
}

bool CryptoUtil::DecryptToString(const std::vector<uint8_t>& ciphertext, std::string& plaintext) {
    std::vector<uint8_t> bytes;
    if (!Decrypt(ciphertext, bytes)) return false;
    plaintext.assign(bytes.begin(), bytes.end());
    return true;
}

// =========================================================
// SHA-256 密码哈希
//
// 加密策略: hash(username + ":" + password)
//   - 不同用户即使使用相同密码，哈希值也不同
//   - 防止攻击者使用彩虹表（预计算哈希表）批量破解
//
// 使用 OpenSSL EVP_DigestX 接口
// =========================================================
std::string CryptoUtil::HashPassword(const std::string& username, const std::string& password) {
    // 1. 拼接加密输入
    std::string salted = username + ":" + password;

    // 2. 生成加密操作上下文
    EVP_MD_CTX* ctx = EVP_MD_CTX_new();
    unsigned char hash[EVP_MAX_MD_SIZE];
    unsigned int  hash_len = 0;

    // 3. 初始哈希计算
    EVP_DigestInit_ex(ctx, EVP_sha256(), nullptr);

    // 4. 追加哈希数据
    EVP_DigestUpdate(ctx, salted.c_str(), salted.size());

    // 5. 完成哈希计算
    EVP_DigestFinal_ex(ctx, hash, &hash_len);

    // 6. 释放上下文
    EVP_MD_CTX_free(ctx);

    // 将二进制哈希转换为十六进制字符串
    std::ostringstream oss;
    for (unsigned int i = 0; i < hash_len; ++i) {
        oss << std::hex << std::setw(2) << std::setfill('0')
        << static_cast<int>(hash[i]);
    }
    return oss.str();
}