OPENSSL 3.3.1 решить проблему с подписью и созданием ключа

#include <openssl/err.h> 
#include <openssl/evp.h> 
#include <openssl/ec.h> 
#include <openssl/ecdsa.h> 
#include <openssl/pem.h> 
#include <fstream>
#include <vector>
#include <iostream>
#include <openssl/bio.h> // Добавьте заголовок для BIO
 
// Функция для хеширования сообщения
std::vector<unsigned char> hashMessage(const std::string& message) {
    EVP_MD_CTX* mdctx = EVP_MD_CTX_new();
    if (!mdctx) {
        ERR_print_errors_fp(stderr);
        return {};
    }
 
    const EVP_MD* md = EVP_sha256();
    std::vector<unsigned char> digest(EVP_MD_size(md));
 
    if (EVP_DigestInit_ex(mdctx, md, nullptr) != 1 ||
        EVP_DigestUpdate(mdctx, message.c_str(), message.size()) != 1) {
        ERR_print_errors_fp(stderr);
        EVP_MD_CTX_free(mdctx);
        return {};
    }
 
    unsigned int digest_len;
    if (EVP_DigestFinal_ex(mdctx, digest.data(), &digest_len) != 1) {
        ERR_print_errors_fp(stderr);
        EVP_MD_CTX_free(mdctx);
        return {};
    }
 
    EVP_MD_CTX_free(mdctx);
    digest.resize(digest_len);
    return digest;
}
 
// Функция для подписи сообщения
std::vector<unsigned char> signMessage(EVP_PKEY* pkey, const std::vector<unsigned char>& hash) {
    EVP_MD_CTX* mdctx = EVP_MD_CTX_new();
    if (!mdctx) {
        ERR_print_errors_fp(stderr);
        return {};
    }
 
    EVP_PKEY_CTX* pctx = EVP_PKEY_CTX_new(pkey, nullptr);
    if (!pctx) {
        ERR_print_errors_fp(stderr);
        EVP_MD_CTX_free(mdctx);
        return {};
    }
 
    if (EVP_PKEY_sign_init(pctx) <= 0 ||
        EVP_PKEY_CTX_set_signature_md(pctx, EVP_sha256()) <= 0) {
        ERR_print_errors_fp(stderr);
        EVP_PKEY_CTX_free(pctx);
        EVP_MD_CTX_free(mdctx);
        return {};
    }
 
    // Определить точный размер подписи
    size_t siglen = EVP_PKEY_CTX_get_signature_length(pctx);
    std::vector<unsigned char> signature(siglen);
 
    if (EVP_PKEY_sign(pctx, signature.data(), &siglen, hash.data(), hash.size()) <= 0) {
        ERR_print_errors_fp(stderr);
        EVP_PKEY_CTX_free(pctx);
        EVP_MD_CTX_free(mdctx);
        return {};
    }
 
    EVP_PKEY_CTX_free(pctx);
    EVP_MD_CTX_free(mdctx);
    signature.resize(siglen);
    return signature;
}
 
int main() {
    // Инициализация обработки ошибок OpenSSL
    ERR_load_crypto_strings();
    OpenSSL_add_all_algorithms();
    OpenSSL_add_all_ciphers();
    OpenSSL_add_all_digests();
 
    // Генерация нового EC приватного ключа
    EVP_PKEY_CTX* kctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, nullptr);
    if (!kctx) {
        ERR_print_errors_fp(stderr);
        return 1;
    }
 
    if (EVP_PKEY_keygen_init(kctx) <= 0 ||
        EVP_PKEY_CTX_set_ec_paramgen_curve_nid(kctx, NID_X9_62_prime256v1) <= 0) {
        ERR_print_errors_fp(stderr);
        EVP_PKEY_CTX_free(kctx);
        return 1;
    }
 
    EVP_PKEY* pkey = nullptr;
    if (EVP_PKEY_keygen(kctx, &pkey) <= 0) {
        ERR_print_errors_fp(stderr);
        EVP_PKEY_CTX_free(kctx);
        return 1;
    }
 
    EVP_PKEY_CTX_free(kctx);
 
    // Запись приватного ключа в PEM файл
    FILE* fp;
    if (fopen_s(&fp, "private_key.pem", "w") != 0) {
        std::cerr << "Error opening file: private_key.pem" << std::endl;
        EVP_PKEY_free(pkey);
        return 1;
    }
 
    BIO* bio_out = BIO_new_fp(fp, BIO_NOCLOSE);
    if (!bio_out) {
        ERR_print_errors_fp(stderr);
        fclose(fp);
        EVP_PKEY_free(pkey);
        return 1;
    }
 
    if (!PEM_write_bio_PrivateKey(bio_out, pkey, nullptr, nullptr, 0, nullptr, nullptr)) {
        ERR_print_errors_fp(stderr);
        BIO_free(bio_out);
        fclose(fp);
        EVP_PKEY_free(pkey);
        return 1;
    }
 
    BIO_free(bio_out);
    fclose(fp);
 
    // Вытягивание публичного ключа и запись в PEM файл
    if (fopen_s(&fp, "public_key.pem", "w") != 0) {
        std::cerr << "Error opening file: public_key.pem" << std::endl;
        EVP_PKEY_free(pkey);
        return 1;
    }
 
    bio_out = BIO_new_fp(fp, BIO_NOCLOSE);
    if (!bio_out) {
        ERR_print_errors_fp(stderr);
        fclose(fp);
        EVP_PKEY_free(pkey);
        return 1;
    }
 
    if (!PEM_write_bio_PUBKEY(bio_out, pkey)) {
        ERR_print_errors_fp(stderr);
        BIO_free(bio_out);
        fclose(fp);
        EVP_PKEY_free(pkey);
        return 1;
    }
 
    BIO_free(bio_out);
    fclose(fp);
 
    // Сообщение для подписи
    std::string message = "Hello, ECDSA with OpenSSL in C++!";
    std::vector<unsigned char> hash = hashMessage(message);
    std::vector<unsigned char> signature = signMessage(pkey, hash);
 
    // Сохранение подписи в файл
    std::ofstream sigFile("signature.bin", std::ios::binary);
    sigFile.write(reinterpret_cast<const char*>(signature.data()), signature.size());
    sigFile.close();
 
    EVP_PKEY_free(pkey);
    EVP_cleanup();
    CRYPTO_cleanup_all_ex_data();
    ERR_free_strings();
    return 0;
}