SYNOPSIS

#include <openssl/evp.h>

int EVP_PKEY_keygen_init(EVP_PKEY_CTX *ctx);
 int EVP_PKEY_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey);
 int EVP_PKEY_paramgen_init(EVP_PKEY_CTX *ctx);
 int EVP_PKEY_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey);

typedef int EVP_PKEY_gen_cb(EVP_PKEY_CTX *ctx);

void EVP_PKEY_CTX_set_cb(EVP_PKEY_CTX *ctx, EVP_PKEY_gen_cb *cb);
 EVP_PKEY_gen_cb *EVP_PKEY_CTX_get_cb(EVP_PKEY_CTX *ctx);

int EVP_PKEY_CTX_get_keygen_info(EVP_PKEY_CTX *ctx, int idx);

void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data);
 void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx);

DESCRIPTION

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

La fonction EVP_PKEY_keygen() réalise une opération de création de clef, la clef crée est écrite dans ppkey.

Les fonctions EVP_PKEY_paramgen_init() et EVP_PKEY_paramgen() sont similaires à part que les paramètres sont créés.

La fonction EVP_PKEY_set_cb() définit le rappel de génération de clefs ou paramètres à cb. La fonction EVP_PKEY_CTX_get_cb() renvoie le rappel de génération de clefs ou paramètres.

La fonction EVP_PKEY_CTX_get_keygen_info() renvoie les paramètres associés à l'opération de création. Si idx est -1, le nombre total de paramètres disponibles est renvoyé. N'importe quelle valeur non négative renvoie la valeur de ce paramètre. EVP_PKEY_CTX_gen_keygen_info() avec une valeur non négative pour idx ne devrait être appelée que depuis le rappel de création.

Si le rappel renvoie 0, alors l'opération de création de clef est abandonnée et une erreur survient. Cela pourrait arriver pendant une opération particulièrement longue où un utilisateur clique sur un bouton « annuler ».

Les fonctions EVP_PKEY_CTX_set_app_data() et EVP_PKEY_CTX_get_app_data() définissent et récupèrent un pointeur opaque. Cela peut être utilisé pour définir certaines valeurs d'application qui peuvent être récupérées dans le rappel : par exemple un traitement qui est utilisé pour mettre à jour une « boîte de dialogue de progression ».

NOTES

Après l'appel de EVP_PKEY_keygen_init() ou EVP_PKEY_paramgen_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.

Les fonctions EVP_PKEY_keygen() et EVP_PKEY_paramgen() peuvent être appelées plus d'une fois sur le même contexte si plusieurs opérations sont réalisées en utilisant les mêmes paramètres.

La signification des paramètres passés au rappel dépendra de l'algorithme et de l'implémentation spécifique à l'algorithme. Certains pourraient ne donner absolument aucun renseignement utile lors de la création de clefs ou paramètres. Certains pourraient ne même pas appeler le rappel.

L'opération réalisée par la création de clefs ou paramètres dépend de l'algorithme utilisé. Dans certains cas (par exemple EC avec une courbe nommée fournie), l'option « création » définit principalement les champs appropriés dans une structure EVP_PKEY.

Dans OpenSSL, une structure EVP_PKEY contenant une clef privée contient aussi les composants et paramètres (s'il y en a) de clef publique. Une clef privée OpenSSL est équivalente à ce que certaines bibliothèques appellent une « paire de clefs ». Une clef privée peut être utilisée dans des fonctions qui nécessitent l'utilisation d'une clef publique ou de paramètres.

VALEURS DE RETOUR

EVP_PKEY_keygen_init(), EVP_PKEY_paramgen_init(), EVP_PKEY_keygen() et EVP_PKEY_paramgen() 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.

EXEMPLES

Créer une clef RSA de 2048 bits :

 #include <openssl/evp.h>
 #include <openssl/rsa.h>
 EVP_PKEY_CTX *ctx;
 EVP_PKEY *pkey = NULL;
 ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL);
 if (!ctx)
        /* Une erreur est survenue */
 if (EVP_PKEY_keygen_init(ctx) <= 0)
        /* Erreur */
 if (EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, 2048) <= 0)
        /* Erreur */
 /* Créer une clef */
 if (EVP_PKEY_keygen(ctx, &pkey) <= 0)
        /* Erreur */

Créer une clef à partir d'un ensemble de paramètres :

 #include <openssl/evp.h>
 #include <openssl/rsa.h>
 EVP_PKEY_CTX *ctx;
 EVP_PKEY *pkey = NULL, *param;
 /* param est supposé déjà défini */
 ctx = EVP_PKEY_CTX_new(param);
 if (!ctx)
        /* Une erreur est survenue */
 if (EVP_PKEY_keygen_init(ctx) <= 0)
        /* Erreur */
 /* Créer une clef */
 if (EVP_PKEY_keygen(ctx, &pkey) <= 0)
        /* Erreur */

Exemple de rappel de création pour les implémentations à clef publique OpenSSL :

 /* Les données d'application sont un BIO pour y afficher l'état */
 EVP_PKEY_CTX_set_app_data(ctx, status_bio);
 static int genpkey_cb(EVP_PKEY_CTX *ctx)
        {
        char c='*';
        BIO *b = EVP_PKEY_CTX_get_app_data(ctx);
        int p;
        p = EVP_PKEY_CTX_get_keygen_info(ctx, 0);
        if (p == 0) c='.';
        if (p == 1) c='+';
        if (p == 2) c='*';
        if (p == 3) c='\n';
        BIO_write(b,&c,1);
        (void)BIO_flush(b);
        return 1;
        }

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.