Signature d’un message à l’aide d’ECDSA dans OpenSSL

Comment définir la clé privée pour la signature de messages lorsque vous utilisez ECDSA dans OpenSSL par programme? J’ai le code suivant:

static int create_signature(unsigned char* hash) { EC_KEY *eckey=NULL; EC_GROUP *ecgroup=NULL; EVP_PKEY *evpkey=NULL; unsigned char *signature=NULL; point_conversion_form_t form = POINT_CONVERSION_UNCOMPRESSED; int signature_size, block_size; unsigned char * block=NULL; ecgroup = get_ec_group_192(); EC_GROUP_set_asn1_flag(ecgroup, OPENSSL_EC_NAMED_CURVE); EC_GROUP_set_point_conversion_form(ecgroup, form); eckey=EC_KEY_new(); EC_KEY_set_group(eckey,ecgroup); EC_KEY_generate_key(eckey); evpkey=EVP_PKEY_new(); EVP_PKEY_assign_EC_KEY(evpkey,eckey); signature=OPENSSL_malloc(EVP_PKEY_size(evpkey)); ECDSA_sign(0, hash, sizeof(hash), signature, &signature_size, eckey); printf("%s", signature); return 0; } 

La fonction get_ec_group_192() est créée en exécutant openssl ecparam -C -name secp192k1 -genkey qui génère également des openssl ecparam -C -name secp192k1 -genkey EC PARAMETERS et une openssl ecparam -C -name secp192k1 -genkey EC PRIVATE KEY .

Ce que j’essaie de faire est de chiffrer le message contenu dans le hash avec ma clé privée afin que seule la clé publique puisse le déchiffrer. Est-ce possible avec le code ci-dessus ou est-ce que je le fais complètement mal?

    Ce qui suit vérifie avec succès pour moi:

     //comstackd with gcc -g -lssl -UOPENSSL_NO_EC SO2228860.c -lcrypto #include  // 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  // for ECDSA_do_sign, ECDSA_do_verify #include  // for NID_secp192k1 static int create_signature(unsigned char* hash) { int function_status = -1; EC_KEY *eckey=EC_KEY_new(); if (NULL == eckey) { printf("Failed to create new EC Key\n"); function_status = -1; } else { EC_GROUP *ecgroup= EC_GROUP_new_by_curve_name(NID_secp192k1); if (NULL == ecgroup) { printf("Failed to create new EC Group\n"); function_status = -1; } else { int set_group_status = EC_KEY_set_group(eckey,ecgroup); const int set_group_success = 1; if (set_group_success != set_group_status) { printf("Failed to set group for EC Key\n"); function_status = -1; } else { const int gen_success = 1; int gen_status = EC_KEY_generate_key(eckey); if (gen_success != gen_status) { printf("Failed to generate EC Key\n"); function_status = -1; } else { ECDSA_SIG *signature = ECDSA_do_sign(hash, strlen(hash), eckey); if (NULL == signature) { printf("Failed to generate EC Signature\n"); function_status = -1; } else { int verify_status = ECDSA_do_verify(hash, strlen(hash), signature, eckey); const int verify_success = 1; if (verify_success != verify_status) { printf("Failed to verify EC Signature\n"); function_status = -1; } else { printf("Verifed EC Signature\n"); function_status = 1; } } } } EC_GROUP_free(ecgroup); } EC_KEY_free(eckey); } return function_status; } int main( int argc , char * argv[] ) { unsigned char hash[] = "c7fbca202a95a570285e3d700eb04ca2"; int status = create_signature(hash); return(0) ; } 

    Leur est un petit bug dans le code ci-dessus. Le hachage qui est passé est un caractère non signé, ce hachage PEUT contenir des valeurs 0x00! N’utilisez PAS le strlen (hash) pour calculer la longueur, car cela transmettra peut-être une longueur incorrecte à la routine SI le hachage contient un 0x00 n’importe où. Les hachages ont une longueur fixe et doivent être transmis en tant que tels. sha256 par exemple devrait être de longueur 64.