fr::crypto::ecdsa(3SSL)

NOM
ECDSA_SIG_new, ECDSA_SIG_free, i2d_ECDSA_SIG, d2i_ECDSA_SIG, ECDSA_size, ECDSA_sign_setup, ECDSA_sign, ECDSA_sign_ex, ECDSA_verify, ECDSA_do_sign, ECDSA_do_sign_ex, ECDSA_do_verify - Algorithme de signature numérique utilisant les courbes elliptiques

SYNOPSIS
#include <openssl/ecdsa.h>

 ECDSA_SIG*    ECDSA_SIG_new(void);
 void    ECDSA_SIG_free(ECDSA_SIG *sig);
 int    i2d_ECDSA_SIG(const ECDSA_SIG *sig, unsigned char **pp);
 ECDSA_SIG*    d2i_ECDSA_SIG(ECDSA_SIG **sig, const unsigned char **pp,
         long len);

 ECDSA_SIG*    ECDSA_do_sign(const unsigned char *dgst, int dgst_len,
             EC_KEY *eckey);
 ECDSA_SIG*    ECDSA_do_sign_ex(const unsigned char *dgst, int dgstlen,
             const BIGNUM *kinv, const BIGNUM *rp,
             EC_KEY *eckey);
 int    ECDSA_do_verify(const unsigned char *dgst, int dgst_len,
             const ECDSA_SIG *sig, EC_KEY *eckey);
 int    ECDSA_sign_setup(EC_KEY *eckey, BN_CTX *ctx,
             BIGNUM **kinv, BIGNUM **rp);
 int    ECDSA_sign(int type, const unsigned char *dgst,
             int dgstlen, unsigned char *sig,
             unsigned int *siglen, EC_KEY *eckey);
 int    ECDSA_sign_ex(int type, const unsigned char *dgst,
             int dgstlen, unsigned char *sig,
             unsigned int *siglen, const BIGNUM *kinv,
             const BIGNUM *rp, EC_KEY *eckey);
 int    ECDSA_verify(int type, const unsigned char *dgst,
             int dgstlen, const unsigned char *sig,
             int siglen, EC_KEY *eckey);
 int    ECDSA_size(const EC_KEY *eckey);

 const ECDSA_METHOD*    ECDSA_OpenSSL(void);
 void    ECDSA_set_default_method(const ECDSA_METHOD *meth);
 const ECDSA_METHOD*    ECDSA_get_default_method(void);
 int    ECDSA_set_method(EC_KEY *eckey,const ECDSA_METHOD *meth);

 int    ECDSA_get_ex_new_index(long argl, void *argp,
             CRYPTO_EX_new *new_func,
             CRYPTO_EX_dup *dup_func,
             CRYPTO_EX_free *free_func);
 int    ECDSA_set_ex_data(EC_KEY *d, int idx, void *arg);
 void*    ECDSA_get_ex_data(EC_KEY *d, int idx);

DESCRIPTION
La structure ECDSA_SIG est constituée de deux BIGNUM pour les valeurs r et s d’une signature ECDSA (consultez X9.62 ou FIPS 186-2).

 struct
        {
        BIGNUM *r;
        BIGNUM *s;
 } ECDSA_SIG;

ECDSA_SIG_new() alloue une nouvelle structure ECDSA_SIG (remarque : cette fonction alloue aussi les BIGNUM) et l’initialise.

ECDSA_SIG_free() libère la structure ECDSA_SIG sig.

i2d_ECDSA_SIG() crée l’encodage DER de la signature ECDSA sig et écrit la signature encodée dans *pp (remarque : si pp est NULL, i2d_ECDSA_SIG renvoie la taille attendue en octet de la signature encodée DER (ou 0 en cas d’erreur).

d2i_ECDSA_SIG() décode une signature ECDSA encodée DER et renvoie la signature décodée dans une structure ECDSA_SIG nouvellement allouée. *sig pointe vers le tampon contenant la signature encodée DER de taille len.

ECDSA_size() renvoie la taille maximale d’une signature ECDSA encodée DER créée avec la clef privée eckey.

ECDSA_sign_setup() pourrait être utilisée pour précalculer des parties de l’opération de signature. eckey est la clef privée EC et ctx est un pointeur vers la structure BN_CTX (ou NULL). Les valeurs précalculées ou renvoyées dans kinv et rp peuvent être utilisées dans un appel suivant de ECDSA_sign_ex ou ECDSA_do_sign_ex.

ECDSA_sign() est une fonction enveloppe pour ECDSA_sign_ex avec kinv et rp définies à NULL.

ECDSA_sign_ex() calcule une signature numérique de la valeur de hachage dgst, de dgstlen octets, en utilisant la clef privée EC eckey et les valeurs précalculées facultatives kinv et rp. La signature encodée DER est stockée dans sig et sa taille est renvoyée dans sig_len. Remarque : sig doit pointer vers ECDSA_size octets de mémoire. Le paramètre type est ignoré.

ECDSA_verify() vérifie que la signature dans sig de taille siglen est une signature ECDSA valable de la valeur de hachage dgst de taille dgstlen en utilisant la clef publique eckey. Le paramètre type est ignoré.

ECDSA_do_sign() est une fonction enveloppe pour ECDSA_do_sign_ex avec kinv et rp définies à NULL.

ECDSA_do_sign_ex() calcule une signature numérique de la valeur de hachage dgst, de dgstlen octets, en utilisant la clef privée eckey et les valeurs précalculées facultatives kinv et rp. La signature est renvoyée dans une structure ECDSA_SIG nouvellement allouée (ou NULL en cas d’erreur).

ECDSA_do_verify() vérifie que la signature sig est une signature ECDSA valable de la valeur de hachage dgst de taille dgst_len en utilisant la clef publique eckey.

VALEURS DE RETOUR
ECDSA_size() renvoie la taille maximale de signature ou 0 en cas d’erreur.

ECDSA_sign_setup() et ECDSA_sign() renvoient 1 en cas de réussite ou 0 en cas d’erreur.

ECDSA_verify() et ECDSA_do_verify() renvoient 1 pour une signature valable, 0 pour une signature incorrecte ou -1 en cas d’erreur. Les codes d’erreur peuvent être obtenus par ERR_get_error(3).

EXEMPLES
Création d’une signature ECDSA d’une valeur de hachage SHA-1 donnée en utilisant la courbe secp192k1 donnée.

Première étape : créer un objet EC_KEY (remarque : cette partie n’est pas spécifique à ECDSA)

 int        ret;
 ECDSA_SIG *sig;
 EC_KEY    *eckey;
 eckey = EC_KEY_new_by_curve_name(NID_secp192k1);
 if (eckey == NULL)
        {
        /* erreur */
        }
 if (!EC_KEY_generate_key(eckey))
        {
        /* erreur */
        }

Deuxième étape : calculer la signature ECDSA d’une valeur de hachage SHA-1 en utilisant ECDSA_do_sign

 sig = ECDSA_do_sign(digest, 20, eckey);
 if (sig == NULL)
        {
        /* erreur */
        }

ou en utilisant ECDSA_sign

 unsigned char *buffer, *pp;
 int            buf_len;
 buf_len = ECDSA_size(eckey);
 buffer  = OPENSSL_malloc(buf_len);
 pp = buffer;
 if (!ECDSA_sign(0, dgst, dgstlen, pp, &buf_len, eckey);
        {
        /* erreur */
        }

Troisième étape : vérifier la signature ECDSA créée en utilisant ECDSA_do_verify

 ret = ECDSA_do_verify(digest, 20, sig, eckey);

ou en utilisant ECDSA_verify

 ret = ECDSA_verify(0, digest, 20, buffer, buf_len, eckey);

et enfin évaluer la valeur de retour :

 if (ret == -1)
        {
        /* erreur */
        }
 else if (ret == 0)
        {
        /* signature incorrecte */
        }
 else   /* ret == 1 */
        {
        /* signature correcte*/
        }

CONFORMITÉ À
ANSI X9.62, US Federal Information Processing Standard FIPS 186-2 (Digital Signature Standard, DSS)

VOIR AUSSI
dsa(3), rsa(3)

HISTORIQUE
L’implémentation ecdsa a été introduite pour la première fois dans OpenSSL 0.9.8

AUTEUR
Nils Larsch pour le projet OpenSSL (http://www.openssl.org).

TRADUCTION
La traduction de cette page de manuel est maintenue par les membres de la liste <debian-l10n-french AT lists DOT debian DOT org>. Veuillez signaler toute erreur de traduction par un rapport de bogue sur le paquet manpages-fr-extra.