NOM

       EVP_PKEY_sign_init, EVP_PKEY_sign - Signer en utilisant un algorithme à clef publique

SYNOPSIS

        #include <openssl/evp.h>

        int EVP_PKEY_sign_init(EVP_PKEY_CTX *ctx);
        int EVP_PKEY_sign(EVP_PKEY_CTX *ctx,
                      unsigned char *sig, size_t *siglen,
                      const unsigned char *tbs, size_t tbslen);

DESCRIPTION

       La fonction EVP_PKEY_sign_init() initialise un contexte d'algorithme à clef publique en
       utilisant pkey pour une opération de signature.

       La fonction EVP_PKEY_sign() réalise une opération de signature à clef publique en
       utilisant ctx. Les données à signer sont indiquées en utilisant les paramètres tbs et
       tbslen. Si sig est NULL, alors la taille maximale du tampon de sortie est écrite dans le
       paramètre siglen. Si sig n'est pas NULL, alors, avant l'appel, le paramètre siglen devrait
       contenir la taille du tampon sig ; si l'appel réussit, la signature est écrite dans sig et
       la quantité de données écrites dans siglen.

NOTES

       EVP_PKEY_sign() ne hache pas les données à signer, et par conséquent est normalement
       utilisé pour signer des condensés. Pour signer des messages arbitraires, consultez plutôt
       les interfaces de signature EVP_DigestSignInit(3) et EVP_SignInit(3).

       Après l'appel de EVP_PKEY_sign_init(), des opérations de contrôle spécifiques à
       l'algorithme peuvent être réalisées pour définir n'importe quels paramètres appropriés à
       l'opération (consultez EVP_PKEY_CTX_ctrl(3)).

       La fonction EVP_PKEY_sign() peut être appelée plus d'une fois sur le même contexte si
       plusieurs opérations sont réalisées en utilisant les mêmes paramètres.

VALEURS DE RETOUR

       EVP_PKEY_sign_init() et EVP_PKEY_sign() renvoient 1 en cas de réussite et 0 ou une valeur
       négative en cas d'échec. En particulier, une valeur de retour de -2 indique que
       l'opération n'est pas permise par l'algorithme à clef publique.

EXEMPLE

       Signer les données en utilisant RSA avec remplissage PKCS#1 et un algorithme de signature
       SHA256 :

        #include <openssl/evp.h>
        #include <openssl/rsa.h>

        EVP_PKEY_CTX *ctx;
        /* md est un condensé SHA-256 dans cet exemple. */
        unsigned char *md, *sig;
        size_t mdlen = 32, siglen;
        EVP_PKEY *signing_key;

        /*
         * Remarque : signing_key et md sont supposées définies avant la
         * prochaine étape, signing_key doit être une clef privée RSA et
         * md doit pointer vers un condensé SHA-256 à signer.
         */
        ctx = EVP_PKEY_CTX_new(signing_key, NULL /* pas de moteur */);
        if (!ctx)
               /* Une erreur est survenue */
        if (EVP_PKEY_sign_init(ctx) <= 0)
               /* Erreur */
        if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) <= 0)
               /* Erreur */
        if (EVP_PKEY_CTX_set_signature_md(ctx, EVP_sha256()) <= 0)
               /* Erreur */

        /* Déterminer la taille du tampon */
        if (EVP_PKEY_sign(ctx, NULL, &siglen, md, mdlen) <= 0)
               /* Erreur */

        sig = OPENSSL_malloc(siglen);

        if (!sig)
               /* échec malloc */

        if (EVP_PKEY_sign(ctx, sig, &siglen, md, mdlen) <= 0)
               /* Erreur */

        /* La signature est siglen octets écrits dans le tampon sig */

VOIR AUSSI

       EVP_PKEY_CTX_new(3), EVP_PKEY_CTX_ctrl(3), EVP_PKEY_encrypt(3), EVP_PKEY_decrypt(3),
       EVP_PKEY_sign(3), EVP_PKEY_verify(3), EVP_PKEY_verify_recover(3), EVP_PKEY_derive(3)

HISTORIQUE

       Ces fonctions ont été ajoutées pour la première fois dans OpenSSL 1.0.0.

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.