NOM

       EVP_PKEY_verify_recover_init, EVP_PKEY_verify_recover - Récupérer une signature à l'aide
       d'un algorithme à clef publique

SYNOPSIS

        #include <openssl/evp.h>

        int EVP_PKEY_verify_recover_init(EVP_PKEY_CTX *ctx);
        int EVP_PKEY_verify_recover(EVP_PKEY_CTX *ctx,
                      unsigned char *rout, size_t *routlen,
                      const unsigned char *sig, size_t siglen);

DESCRIPTION

       La fonction EVP_PKEY_verify_recover_init() initialise un contexte d'algorithme à clef
       publique en utilisant la clef pkey pour une opération de vérification et récupération.

       La fonction EVP_PKEY_verify_recover() récupère des données signées en utilisant ctx. La
       signature est indiquée en utilisant les paramètres sig et siglen. Si rout est NULL, alors
       la taille maximale du tampon de sortie est écrite dans le paramètre routlen. Si rout n'est
       pas NULL, alors, avant l'appel, le paramètre routlen devrait contenir la taille du tampon
       rout. Si l'appel réussit, les données récupérées sont écrites dans rout et la quantité de
       données écrites dans routlen.

NOTES

       Normalement, une application ne cherche à savoir que si une opération de vérification de
       signature a réussi. Dans ce cas la fonction EVP_verify() devrait être utilisée.

       Parfois, cependant, il est utile d'obtenir les données d'origine signées en utilisant une
       opération de signature. Seuls certains algorithmes à clef publique peuvent récupérer une
       signature de cette façon (par exemple RSA en mode de remplissage PKCS).

       Après l'appel de EVP_PKEY_verify_recover_init(), les opérations de contrôle spécifique à
       l'algorithme peuvent être réalisée pour définir tous les paramètres nécessaires à
       l'opération.

       La fonction EVP_PKEY_verify_recover() 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_recover_init() et EVP_PKEY_verify_recover() 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

       Récupérer l'algorithme de signature d'origine signé en utilisant PKCS#1 et un algorithme
       de signature SHA256 :

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

        EVP_PKEY_CTX *ctx;
        unsigned char *rout, *sig;
        size_t routlen, siglen;
        EVP_PKEY *verify_key;
        /* Remarque : verify_key, sig et siglen sont supposées déjà
         * être configurées et verify_key une clef publique RSA
         */
        ctx = EVP_PKEY_CTX_new(verify_key);
        if (!ctx)
               /* Une erreur est survenue */
        if (EVP_PKEY_verify_recover_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_verify_recover(ctx, NULL, &routlen, sig, siglen) <= 0)
               /* Erreur */

        rout = OPENSSL_malloc(routlen);

        if (!rout)
               /* Erreur malloc */

        if (EVP_PKEY_verify_recover(ctx, rout, &routlen, sig, siglen) <= 0)
               /* Erreur */

        /* Données récupérées : routlen octets écrits dans le tampon rout */

VOIR AUSSI

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