Provided by: manpages-fr-extra_20151231_all bug

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.

1.0.2a 1.0.2c                                      2015-12-31                            fr::crypto::ecdsa(3SSL)