NOM

       EVP_PKEY_verify_init, EVP_PKEY_verify - Vérification de signature en utilisant un
       algorithme à clef publique

SYNOPSIS

        #include <openssl/evp.h>

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

DESCRIPTION

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

       La fonction EVP_PKEY_verify() réalise une opération de vérification de signature à clef
       publique en utilisant ctx. La signature est indiquée en utilisant les paramètres sig et
       siglen. Les données vérifiées (c'est-à-dire les données censées être correctement signées)
       sont indiquées en utilisant les paramètres tbs et tbslen

NOTES

       Après l'appel de EVP_PKEY_verify_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.

       La fonction EVP_PKEY_verify() 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_verify_init() et EVP_PKEY_verify() renvoient 1 si la vérification a réussi et 0
       en cas d'échec. Contrairement aux autres fonctions, la valeur de retour 0 de
       EVP_PKEY_verify() indique seulement que la signature n'a pas été vérifiée correctement
       (c'est-à-dire que tbs ne correspondait pas aux données d'origine ou que la signature
       n'était pas de la forme adéquate), ce n'est pas une indication d'une erreur plus sérieuse.

       Une valeur négative indique une autre erreur qu'un échec de vérification de signature. En
       particulier, une valeur de retour de -2 indique que l'opération n'est pas permise par
       l'algorithme à clef publique.

EXEMPLE

       Vérifier une signature en utilisant PKCS#1 et un algorithme de signature SHA256 :

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

        EVP_PKEY_CTX *ctx;
        unsigned char *md, *sig;
        size_t mdlen, siglen;
        EVP_PKEY *verify_key;
        /* Remarque : verify_key, sig, siglen, md et mdlen sont supposées
         * déjà définies, avec verify_key une clef publique RSA
         */
        ctx = EVP_PKEY_CTX_new(verify_key);
        if (!ctx)
               /* Une erreur est survenue */
        if (EVP_PKEY_verify_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 */

        /* Réaliser l'opération */
        ret = EVP_PKEY_verify(ctx, sig, siglen, md, mdlen);

        /* ret == 1 indique une réussite, 0 une erreur de vérification
         * et < 0 un autre type d'erreur.
         */

VOIR AUSSI

       EVP_PKEY_CTX_new(3), EVP_PKEY_encrypt(3), EVP_PKEY_decrypt(3), EVP_PKEY_sign(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.