c++实现ecc完整代码

以下是一个简单的C++代码实现ECC数字签名和验证的过程，以NIST P-256椭圆曲线为例：

#include <iostream>
#include <openssl/ec.h>
#include <openssl/obj_mac.h>
#include <openssl/ecdsa.h>
#include <openssl/evp.h>
#include <openssl/sha.h>

using namespace std;

// 定义椭圆曲线参数
const int curve_nid = NID_X9_62_prime256v1;
const int curve_len = 256;

// 生成公私钥对
void gen_keypair(EC_KEY* &ec_key, const char* prvkey_file, const char* pubkey_file)
{
    // 创建椭圆曲线
    EC_GROUP* ec_group = EC_GROUP_new_by_curve_name(curve_nid);
    if (ec_group == NULL) {
        cout << "Error: EC_GROUP_new_by_curve_name" << endl;
        return;
    }

    // 创建密钥对
    ec_key = EC_KEY_new();
    if (ec_key == NULL) {
        cout << "Error: EC_KEY_new" << endl;
        return;
    }
    if (!EC_KEY_set_group(ec_key, ec_group)) {
        cout << "Error: EC_KEY_set_group" << endl;
        return;
    }
    if (!EC_KEY_generate_key(ec_key)) {
        cout << "Error: EC_KEY_generate_key" << endl;
        return;
    }

    // 保存私钥到文件
    FILE* prvkey_fp = fopen(prvkey_file, "w");
    if (prvkey_fp == NULL) {
        cout << "Error: fopen prvkey" << endl;
        return;
    }
    if (!PEM_write_ECPrivateKey(prvkey_fp, ec_key, NULL, NULL, 0, NULL, NULL)) {
        cout << "Error: PEM_write_ECPrivateKey" << endl;
        return;
    }
    fclose(prvkey_fp);

    // 保存公钥到文件
    FILE* pubkey_fp = fopen(pubkey_file, "w");
    if (pubkey_fp == NULL) {
        cout << "Error: fopen pubkey" << endl;
        return;
    }
    if (!PEM_write_EC_PUBKEY(pubkey_fp, ec_key)) {
        cout << "Error: PEM_write_EC_PUBKEY" << endl;
        return;
    }
    fclose(pubkey_fp);
}

// 读取密钥对
void load_keypair(EC_KEY* &ec_key, const char* prvkey_file, const char* pubkey_file)
{
    // 创建椭圆曲线
    EC_GROUP* ec_group = EC_GROUP_new_by_curve_name(curve_nid);
    if (ec_group == NULL) {
        cout << "Error: EC_GROUP_new_by_curve_name" << endl;
        return;
    }

    // 读取私钥
    FILE* prvkey_fp = fopen(prvkey_file, "r");
    if (prvkey_fp == NULL) {
        cout << "Error: fopen prvkey" << endl;
        return;
    }
    ec_key = PEM_read_ECPrivateKey(prvkey_fp, NULL, NULL, NULL);
    if (ec_key == NULL) {
        cout << "Error: PEM_read_ECPrivateKey" << endl;
        return;
    }
    fclose(prvkey_fp);

    // 读取公钥
    FILE* pubkey_fp = fopen(pubkey_file, "r");
    if (pubkey_fp == NULL) {
        cout << "Error: fopen pubkey" << endl;
        return;
    }
    EC_POINT* ec_point = EC_POINT_new(ec_group);
    if (!PEM_read_EC_PUBKEY(pubkey_fp, &ec_point, NULL, NULL)) {
        cout << "Error: PEM_read_EC_PUBKEY" << endl;
        return;
    }
    if (!EC_KEY_set_public_key(ec_key, ec_point)) {
        cout << "Error: EC_KEY_set_public_key" << endl;
        return;
    }
    fclose(pubkey_fp);
}

// 计算消息哈希值
void calc_hash(const char* data, int data_len, unsigned char* hash)
{
    SHA256_CTX sha_ctx;
    SHA256_Init(&sha_ctx);
    SHA256_Update(&sha_ctx, data, data_len);
    SHA256_Final(hash, &sha_ctx);
}

// 签名
void sign(EC_KEY* ec_key, const unsigned char* hash, int hash_len, unsigned char* sig, int* sig_len)
{
    EVP_MD_CTX* md_ctx = EVP_MD_CTX_new();
    EVP_MD_CTX_init(md_ctx);
    const EVP_MD* md = EVP_sha256();
    if (!ECDSA_sign(0, hash, hash_len, sig, sig_len, ec_key)) {
        cout << "Error: ECDSA_sign" << endl;
        return;
    }
}

// 验证
bool verify(EC_KEY* ec_key, const unsigned char* hash, int hash_len, const unsigned char* sig, int sig_len)
{
    EVP_MD_CTX* md_ctx = EVP_MD_CTX_new();
    EVP_MD_CTX_init(md_ctx);
    const EVP_MD* md = EVP_sha256();
    int ret = ECDSA_verify(0, hash, hash_len, sig, sig_len, ec_key);
    if (ret == 1) {
        return true;
    }
    else if (ret == 0) {
        cout << "Error: verify failed" << endl;
        return false;
    }
    else {
        cout << "Error: ECDSA_verify" << endl;
        return false;
    }
}

int main()
{
    // 生成密钥对
    EC_KEY* ec_key = NULL;
    gen_keypair(ec_key, "prvkey.pem", "pubkey.pem");

    // 读取密钥对
    ec_key = EC_KEY_new();
    load_keypair(ec_key, "prvkey.pem", "pubkey.pem");

    // 签名和验证
    const char* msg = "Hello, ECC!";
    unsigned char hash[32];
    calc_hash(msg, strlen(msg), hash);
    unsigned char sig[128];
    int sig_len = 0;
    sign(ec_key, hash, sizeof(hash), sig, &sig_len);
    bool verify_result = verify(ec_key, hash, sizeof(hash), sig, sig_len);
    cout << "verify result: " << verify_result << endl;

    return 0;
}

在实际应用中，需要考虑更多的安全问题和性能优化，例如随机数生成、密钥管理、哈希算法选取、安全参数调整等。