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 */

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.