NOM

       EVP_PKEY_encrypt_init, EVP_PKEY_encrypt - Chiffrer en utilisant un algorithme à clef
       publique

SYNOPSIS

        #include <openssl/evp.h>

        int EVP_PKEY_encrypt_init(EVP_PKEY_CTX *ctx);
        int EVP_PKEY_encrypt(EVP_PKEY_CTX *ctx,
                      unsigned char *out, size_t *outlen,
                      const unsigned char *in, size_t inlen);

DESCRIPTION

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

       La fonction EVP_PKEY_encrypt() réalise une opération de chiffrement à clef publique en
       utilisant ctx. Les données à chiffrer sont indiquées en utilisant les paramètres in et
       inlen. Si out est NULL, alors la taille maximale du tampon de sortie est écrite dans le
       paramètre outlen. Si out n'est pas NULL, alors, avant l'appel, le paramètre outlen devrait
       contenir la taille du tampon out ; si l'appel réussit, les données chiffrées sont écrites
       dans out et la quantité de données écrites dans outlen.

NOTES

       Après l'appel de EVP_PKEY_encrypt_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_encrypt() 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_encrypt_init() et EVP_PKEY_encrypt() 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

       Chiffrer des données en utilisant OAEP (pour les clefs RSA). Consultez également
       PEM_read_PUBKEY(3) ou d2i_X509(3) pour différents moyens de charger une clef publique.
       Simplement définir « eng = NULL; » permet aussi de commencer avec l’implémentation RSA
       d’OpenSSL par défaut :

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

        EVP_PKEY_CTX *ctx;
        ENGINE *eng;
        unsigned char *out, *in;
        size_t outlen, inlen;
        EVP_PKEY *key;
        /* Remarque : eng, key, in et inlen sont supposées
         * déjà définies, avec key une clef publique RSA
         */
        ctx = EVP_PKEY_CTX_new(key,eng);
        if (!ctx)
               /* Une erreur est survenue */
        if (EVP_PKEY_encrypt_init(ctx) <= 0)
               /* Erreur */
        if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_OAEP_PADDING) <= 0)
               /* Erreur */

        /* Déterminer la taille du tampon */
        if (EVP_PKEY_encrypt(ctx, NULL, &outlen, in, inlen) <= 0)
               /* Error */

        out = OPENSSL_malloc(outlen);

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

        if (EVP_PKEY_encrypt(ctx, out, &outlen, in, inlen) <= 0)
               /* Erreur */

        /* Les données chiffrées sont outlen octets écrits dans le tampon out */

VOIR AUSSI

       d2i_X509(3), engine(3), EVP_PKEY_CTX_new(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.