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.

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