Comment puis-je obtenir la clé publique à partir d'un ECDSA clé privée dans OpenSSL?

Je suis en fournissant cet exemple d'application pour montrer mon problème

#include <stdio.h>
#include <stdlib.h>
#include <openssl/ec.h>
#include <openssl/bn.h>

int main()
{
     EC_KEY *pkey = NULL;
     EC_POINT *pub_key = NULL;
     const EC_GROUP *group = NULL;
     BIGNUM start;
     BIGNUM *res;
     BN_CTX *ctx;

     BN_init(&start);
     ctx = BN_CTX_new();

     res = &start;
     BN_hex2bn(&res,"3D79F601620A6D05DB7FED883AB8BCD08A9101B166BC60166869DA5FC08D936E");
     pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
     group = EC_KEY_get0_group(pkey);
     pub_key = EC_POINT_new(group);

     EC_KEY_set_private_key(pkey, res);

     assert(EC_POINT_bn2point(group,res, pub_key, ctx)); //Null here

     EC_KEY_set_public_key(pkey, pub_key);


    return 0;
}

Ce que je suis en train de faire, est d'afficher la clé Publique à partir d'une clé privée(si un elliptique de la clé privée).
Je ne savais pas comment le faire jusqu'à ce que j'ai rencontré un problème similaire

Comment puis-je nourrir OpenSSL aléatoire des données pour les utiliser dans la signature ECDSA?

Qui est où j'ai fait moi-même comment obtenir la clé publique et à l'utilisation EC_POINT_bn2point au lieu de hex2point en interne qui ne BN_hex2bn selon la source OpenSSL.

Alors, pourquoi est EC_POINT_bn2point retourner NULL? Je songe sérieusement à recompiler OpenSSL et à faire quelques routines de débogage de comprendre pourquoi il échoue.

Eh bien, si vous pouvez extraire une clé publique à partir d'une clé privée, qui serait bec de l'essence de RSA...
J'ai trouvé quelques articles qui disent la clé privée a laisser des indices qui permettent de générer de la pub de la clé, mais il n'est pas écrit en anglais. Ainsi puissiez-vous trouver le format de la clé privée, il peut aider.
Un ECDSA clé privée d (un entier) et la clé publique Q (un point) est calculée par Q = dG, où G est un non-secret paramètre de domaine. Voir aussi: nsa.gov/ia/_files/ecdsa.pdf
Oui, j'ai obtenu. J'avais besoin de faire CE multiplication avec la base de générateur de G.

OriginalL'auteur farmdve | 2012-09-18

  1. 7

    Un ECDSA clé privée d (un entier) et la clé publique Q (un point) est calculée par Q = dG, où G est un non-secret paramètre de domaine. Suite B responsable de l'implémentation du Guide de la FIPS 186-3
    (ECDSA)     décrit ECDSA en détail.

    OpenSSL utilise ECDSA_generate_key pour générer une paire de clés. Ce qu'il fait est de générer une clé privée au hasard, et puis il ne le Q = dG multiplication pour calculer la clé publique:

    /* pub_key is a new uninitialized `EC_POINT*`.  priv_key is a `BIGNUM*`. */
if (!EC_POINT_mul(ecdsa->group, pub_key, priv_key, NULL, NULL, ctx)) goto err;

    De sorte que vous pouvez faire la même chose. Si j'avais la clé privée, j'étais comme la clé privée dans un EC_KEY ou ECDSA struct. Ensuite, j'ai configurer les paramètres du domaine. Et enfin, je ferais le EC_POINT_mul pour obtenir la clé publique de point.

    OriginalL'auteur indiv

  2. 4

    De travail exemple: 

    //using figures on: https://en.bitcoin.it/wiki/Technical_background_of_version_1_Bitcoin_addresses
//gcc -Wall ecdsapubkey.c -o ecdsapubkey -lcrypto
#include <stdio.h>
#include <stdlib.h>
#include <openssl/ec.h>
#include <openssl/obj_mac.h>
#include <openssl/bn.h>

int main()
{
     EC_KEY *eckey = NULL;
     EC_POINT *pub_key = NULL;
     const EC_GROUP *group = NULL;
     BIGNUM start;
     BIGNUM *res;
     BN_CTX *ctx;

     BN_init(&start);
     ctx = BN_CTX_new(); //ctx is an optional buffer to save time from allocating and deallocating memory whenever required

     res = &start;
//    BN_hex2bn(&res,"3D79F601620A6D05DB7FED883AB8BCD08A9101B166BC60166869DA5FC08D936E");
     BN_hex2bn(&res,"18E14A7B6A307F426A94F8114701E7C8E774E7F9A47E2C2035DB29A206321725");
     eckey = EC_KEY_new_by_curve_name(NID_secp256k1);
     group = EC_KEY_get0_group(eckey);
     pub_key = EC_POINT_new(group);

     EC_KEY_set_private_key(eckey, res);

     /* pub_key is a new uninitialized `EC_POINT*`.  priv_key res is a `BIGNUM*`. */
     if (!EC_POINT_mul(group, pub_key, res, NULL, NULL, ctx))
       printf("Error at EC_POINT_mul.\n");

//    assert(EC_POINT_bn2point(group, &res, pub_key, ctx)); //Null here

     EC_KEY_set_public_key(eckey, pub_key);

     char *cc = EC_POINT_point2hex(group, pub_key, 4, ctx);

     char *c=cc;

     int i;

     for (i=0; i<130; i++) //1 byte 0x42, 32 bytes for X coordinate, 32 bytes for Y coordinate
     {
       printf("%c", *c++);
     }

     printf("\n");

     BN_CTX_free(ctx);

     free(cc);

     return 0;
}

    Voir aussi http://wiki.openssl.org/index.php/Elliptic_Curve_Cryptography - pour la bibliothèque

    http://www.nsa.gov/ia/_files/ecdsa.pdf - pour l'algorithme

    http://cs.ucsb.edu/~koc/ccs130h/notes/ecdsa-cert.pdf - pour les mathématiques

    OriginalL'auteur Doru Georgescu