La signature d'un message à l'aide de ECDSA dans OpenSSL

Comment puis-je configurer la clé privée de signature de messages lors de l'utilisation de ECDSA dans OpenSSL par programmation? 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éé par l'exécution de openssl ecparam -C -name secp192k1 -genkey qui génère également certains EC PARAMETERS et un EC PRIVATE KEY.

Ce que je suis en train de faire est de chiffrer le message contenu dans hash avec ma clé privée de sorte que seule la clé publique peut le décrypter. Est-ce possible avec le code ci-dessus, ou suis-je le faire complètement tort?

La terminologie est "signature". Le mot "cryptage" est réservé pour autre chose. Vous n'avez pas mentionné ce problème que vous rencontrez.
Ah, désolé à ce sujet. Bien dans le code ci-dessus extrait de la clé privée n'est pas utilisé n'importe où? Ou est-ce seulement nécessaire lors de la signature du message?
Remarque, le Chiffrement à l'aide d'une clé privée est en fait appelé "signature". Quiconque détient le public correspondant de la moitié va décrypter le résultat (qui est en fait appelé "vérification")
En retard mais: hash ici devrait point à une valeur de hachage, typiquement de 20 octets (SHA1) ou de 24 à 64 octets (pour SHA2), mais en C sizeof(hash) est la taille de la pointeur, en général 4 ou 8 octets, et non pas la taille de l'objet pointé. Aussi une signature ECDSA, comme la plupart des autres moderne crypto objets, est arbitraire bits (aka "binary") et peut valablement inclure une-0-bits de l'octet, mais n'est pas toujours suivie par une autre qui la rend invalide à le traiter comme un nul C de la chaîne qui printf %s essaie de faire, comme d'habitude, y compris les octets qui ne sont pas en sécurité imprimable. ...
... Et RSA signer et vérifier sont similaire, mais non en fait "chiffrer avec privatekey" et "décrypter avec publickey", mais dans ECDSA (et DSA), il n'en est rien, même de loin ressemble à de chiffrement et de déchiffrement, il y a signer et vérifier.

OriginalL'auteur Anvar | 2010-02-09

  1. 7

    Le suivant vérifie avec succès pour moi:

    //compiled with gcc -g -lssl -UOPENSSL_NO_EC SO2228860.c -lcrypto
#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_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) ;
}
    Comment vérifiez-vous avec juste la partie publique de la eckey?

    OriginalL'auteur this.josh

  2. 2

    Leur est un petit bug dans le code ci-dessus. La valeur de hachage qui est transmis est un unsigned char, ce mot PEUT avoir 0x00 valeurs! Ne PAS utiliser le strlen(hash) pour calculer la longueur qui va peut-être passer la longueur incorrecte de la routine, SI la valeur de hachage a une 0x00 dans n'importe où. Les hachages sont de longueur fixe, et devrait être adopté en tant que tel. sha256 pour l'exemple doit être de longueur 64.

    OriginalL'auteur donald schleede