openssl 写入/读取 ecdsa 密钥到 PEM文件

Question

我的程序首先生成了一个ECDSA的密钥对用来签名以及验证。

#include <openssl/ec.h>      // for EC_GROUP_new_by_curve_name, EC_GROUP_free, EC_KEY_new, EC_KEY_set_group, EC_KEY_generate_key, EC_KEY_free
#include <openssl/ecdsa.h>   // for ECDSA_do_sign, ECDSA_do_verify
#include <openssl/obj_mac.h> // for NID_secp256k1

/*
* Function generate_eckey
* -----------------------
*
* This function generates an EC_Key object that stores the ECDSA key pair.
*
* return: ec key pair
*/
EC_KEY * generate_eckey() {
    EC_KEY *eckey=EC_KEY_new();
    EC_GROUP *ecgroup= EC_GROUP_new_by_curve_name(NID_secp256k1);
    EC_KEY_set_group(eckey, ecgroup);
    EC_KEY_generate_key(eckey);

    return eckey;
}


int main() {

    
    // generate a eckey used to produce signatures
    EC_KEY *eckey = generate_eckey();

    return 0;
}

我想存成PEM格式以便下次读取之后可以马上使用。(不用ASN.1/DER)
stackoverflow告诉我openssl的文档里有PEM_read_ECPrivateKey, PEM_write_ECPrivateKey, PEM_read_EC_PUBKEY, 和PEM_write_EC_PUBKEY。但是我没看明白怎么用。

能不能给我一个具体的例子怎么把我的eckey存到一个my.pem的PEM文件里？

Answer 1

#include <stdio.h>
#include <string.h>
#include <openssl/ecdsa.h>
#include <openssl/pem.h>
#include <openssl/err.h>


//公钥验证签名
int my_verify(const char *input, int input_len, ECDSA_SIG *signret, const char *pub_key_fn)
{
        EC_KEY *p_dsa = NULL;
        FILE *file = NULL;
        int ret = 0;

        if((file = fopen(pub_key_fn, "rb")) == NULL)
        {
                ret = -1;
                return ret;
        }

        if((p_dsa = PEM_read_EC_PUBKEY(file, NULL,NULL,NULL )) == NULL)
        {
                ret = -2;
                fclose(file);
                return ret;
        }

        fclose(file);

        ret = ECDSA_do_verify(input, input_len, signret, p_dsa);
        if(ret != 1)
        {
                ret = -3;
                printf("ECDSA_verify err!\n");
                EC_KEY_free(p_dsa);
                return ret;
        }

        printf("verify is ok!\n");

        EC_KEY_free(p_dsa);

        return 0;
}


//私钥签名
int my_sign(const char *input, int input_len, const char *pri_key_fn)
{
        EC_KEY *p_dsa = NULL;
        ECDSA_SIG *s;
        FILE *file = NULL;
        unsigned char *data[2];
        int nid;
        int signlen = 0;
        int i = 0;
        int ret = 0;

        memset(data, 0x00, sizeof(data));

        nid = 0;

        file = fopen(pri_key_fn, "rb");
        if(!file)
        {
                ret = -1;
                return ret;
        }

        if((p_dsa = PEM_read_ECPrivateKey(file, NULL, NULL, NULL)) == NULL)
        {
                ret = -2;
                fclose(file);
                return ret;
        }

        fclose(file);

        s = ECDSA_do_sign(input, input_len, p_dsa);
        if(s == NULL)
        {
                ret = -3;
                EC_KEY_free(p_dsa);
                return ret;
        }

        data[0] = BN_bn2hex(s->r); //二进制转十六进制
        data[1] = BN_bn2hex(s->s);

        EC_KEY_free(p_dsa);
        ECDSA_SIG_free(s);

        printf("%s\n", data[0]);
        printf("%s\n", data[1]);

        free(data[0]);
        free(data[1]);

        return 0;
}

int main(int argc, char**argv)
{
        char src[512+1];
        char dst_str[2][512+1];
        int src_len;
        int ret;
        FILE *f;

        memset(src, 0x00, sizeof(src));
        //memset(dst, 0x00, sizeof(dst));

        if(argv[1][0] == 's')
        {
                strcpy(src, "aedewderdfercfrtvgfrtfgrtgfrtgvtrgtrvgtyebtybytbnybyuyubndrybrfgswdhyewhde");
                src_len = strlen(src) ;

                ret = my_sign(src, src_len, argv[2]);
                if(ret)
                {
                        fprintf(stderr, "Error\n");
                }
        }
        else
        {
                ECDSA_SIG *s = (ECDSA_SIG *)malloc(sizeof(ECDSA_SIG));

                strcpy(src, "aedewderdfercfrtvgfrtfgrtgfrtgvtrgtrvgtyebtybytbnybyuyubndrybrfgswdhyewhde");
                strncpy(dst_str[0], argv[2], 512);
                strncpy(dst_str[1], argv[3], 512);
                src_len = strlen(src);

                s->r = BN_new();
                s->s = BN_new();

                BN_hex2bn(&(s->r), dst_str[0]); //十六进制转二进制
                BN_hex2bn(&(s->s), dst_str[1]);

                ret = my_verify(src, src_len, s, argv[1]);
                if(ret)
                {
                        fprintf(stderr, "Error\n");
                }

                BN_free(s->r);
                BN_free(s->s);

                free(s);
        }

        return 0;
}