NOM

       EVP_PKEY_derive_init, EVP_PKEY_derive_set_peer, EVP_PKEY_derive - Dériver un secret
       partagé d'algorithme à clef publique

SYNOPSIS

        #include <openssl/evp.h>

        int EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx);
        int EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer);
        int EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen);

DESCRIPTION

       La fonction EVP_PKEY_derive_init() initialise un contexte d'algorithme à clef publique en
       utilisant pkey pour une dérivation à secret partagé.

       La fonction EVP_PKEY_derive_set_peer() définit la clef de pair : ce sera normalement une
       clef publique.

       La fonction EVP_PKEY_derive() dérive un secret partagé en utilisant ctx. Si key est NULL,
       alors la taille maximale du tampon de sortie est écrite dans le paramètre keylen. Si key
       n'est pas NULL, alors, avant l'appel, le paramètre keylen devrait contenir la taille du
       tampon key ; si l'appel réussit, le secret partagé est écrit dans key et la quantité de
       données écrites dans keylen.

NOTES

       Après l'appel de EVP_PKEY_derive_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_derive() 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_derive_init() et EVP_PKEY_derive() 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

       Dériver un secret partagé (par exemple des clefs DH ou EC) :

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

        EVP_PKEY_CTX *ctx;
        unsigned char *skey;
        size_t skeylen;
        EVP_PKEY *pkey, *peerkey;
        /* Remarque : pkey et peerkey sont supposées déjà définies */

        ctx = EVP_PKEY_CTX_new(pkey);
        if (!ctx)
               /* Une erreur est survenue */
        if (EVP_PKEY_derive_init(ctx) <= 0)
               /* Erreur */
        if (EVP_PKEY_derive_set_peer(ctx, peerkey) <= 0)
               /* Erreur */

        /* Déterminer la taille du tampon */
        if (EVP_PKEY_derive(ctx, NULL, &skeylen) <= 0)
               /* Erreur */

        skey = OPENSSL_malloc(skeylen);

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

        if (EVP_PKEY_derive(ctx, skey, &skeylen) <= 0)
               /* Erreur */

        /* Le secret partagé est skey octets écrits dans le tampon skey */

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_verify_recover(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.