fr::ssl::SSL_CTX_set_tmp_rsa_callback(3SSL)

NOM
SSL_CTX_set_tmp_rsa_callback, SSL_CTX_set_tmp_rsa, SSL_CTX_need_tmp_rsa, SSL_set_tmp_rsa_callback, SSL_set_tmp_rsa, SSL_need_tmp_rsa - Gérer les clefs RSA pour l’échange de clefs éphémères

SYNOPSIS
#include <openssl/ssl.h>

void SSL_CTX_set_tmp_rsa_callback(SSL_CTX *ctx,
            RSA *(*tmp_rsa_callback)(SSL *ssl, int is_export,
                        int taille_clef));
 long SSL_CTX_set_tmp_rsa(SSL_CTX *ctx, RSA *rsa);
 long SSL_CTX_need_tmp_rsa(SSL_CTX *ctx);

void SSL_set_tmp_rsa_callback(SSL_CTX *ctx,
            RSA *(*tmp_rsa_callback)(SSL *ssl, int is_export,
                        int taille_clef));
 long SSL_set_tmp_rsa(SSL *ssl, RSA *rsa)
 long SSL_need_tmp_rsa(SSL *ssl)

RSA *(*tmp_rsa_callback)(SSL *ssl, int is_export,
                        int taille_clef);

DESCRIPTION
SSL_CTX_set_tmp_rsa_callback() définit la fonction de rappel pour ctx à utiliser quand une clef RSA temporaire ou éphémère est nécessaire pour tmp_rsa_callback. Tous les objets SSL nouvellement créés à partir de ctx avec SSL_new(3) héritent du rappel. Les objets SSL déjà créés ne sont pas affectés.

SSL_CTX_set_tmp_rsa() définit une clef RSA temporaire/éphémère à utiliser pour rsa. Tous les objets SSL nouvellement créés à partir de ctx avec SSL_new(3) héritent de la clef. Les objets SSL déjà créés ne sont pas affectés.

SSL_CTX_need_tmp_rsa() renvoie 1, si une clef RSA temporaire/éphémère est nécessaire pour les suites de chiffrement — « exportables », de force limitée, basées sur RSA — parce qu’une longueur de clef supérieure à 512 bits est en place.

SSL_set_tmp_rsa_callback() définit le rappel seulement pour ssl.

SSL_set_tmp_rsa3() définit la clef seulement pour ssl.

SSL_need_tmp_rsa() renvoie 1, si une clef RSA temporaire/éphémère est nécessaire pour les suites de chiffrement — « exportables », de force limitée, basées sur RSA — parce qu’une longueur de clef supérieure à 512 bits est en place.

Ces fonctions sont applicables aux serveurs SSL/TLS uniquement.

NOTES
Lors de l’utilisation d’un algorithme de chiffrement avec authentification RSA, un échange de clefs éphémères DH peut survenir. Dans ce cas, les données de session sont négociées en utilisant une clef éphémère/temporaire RSA et la clef fournie et authentifiée par la chaîne de certificats est utilisée uniquement pour la signature.

Sous de précédentes restrictions d’export, des chiffrements avec des clefs plus courtes (512 octets) que la longueur habituelle de 1024 octets ont été créés. Pour utiliser ces chiffrements, un échange de clefs éphémères doit être réalisé, puisque la clef normale (authentifiée) ne peut être directement utilisée.

L’usage de clef éphémère RSA rend la confidentialité persistante, car la connexion ne peut être déchiffrée que lorsque la clef RSA est connue. En créant une clef RSA temporaire uniquement pendant la durée de la mise en œuvre du serveur, un attaquant ne peut absolument pas déchiffrer des sessions terminées même s’il se procure la clef normale (authentifiée), puisque la clef n’a été utilisée que pour la signature. L’inconvénient est que la génération d’une clef RSA est coûteuse en calculs.

En outre, l’utilisation d’échange de clefs éphémères est seulement permise par la norme TLS, quand la clef RSA peut être utilisée seulement pour signer, c’est-à-dire pour les chiffrements exportés. L’utilisation de l’échange de clefs RSA éphémères pour d’autres buts transgresse la norme et peut rompre l’interopérabilité entre clients. Donc, il est fortement recommandé de ne pas utiliser l’échange de clefs éphémères RSA et d’utiliser DHE (Diffie-Hellman éphémère) pour permettre la confidentialité persistante (consultez SSL_CTX_set_tmp_dh_callback(3)).

Une application peut soit indiquer la clef directement ou la fournir par une fonction de rappel. La méthode par le rappel a l’avantage que le rappel peut générer la clef que lorsque nécessaire. Comme cette génération est coûteuse, la durée de procédure de connexion augmentera de manière significative. Un autre avantage de la fonction de rappel est qu’elle peut fournir des clefs de différentes longueurs, tandis que le réglage direct de la clef est seulement utile pour des longueurs de clef de 512 bits pour les algorithmes de chiffrement limité pour l’export et qui ne communiquent pas la longueur de clef si une clef plus importante est autorisée.

tmp_rsa_callback est appelée avec la taille_clef désirée et l’information is_export. L’attribut is_export est activé lorsque l’échange de clefs éphémères RSA est réalisé avec un algorithme de chiffrement pour l’export.

EXEMPLES
Générer des clefs RSA temporaires pour préparer un échange de clefs éphémères. Comme cette génération coûte beaucoup de temps de calcul, elles sont stockées pour une utilisation ultérieure. À des fins de démonstrations, deux clefs pour 512 bits et 1024 bits respectivement sont créées.

 ...
 /* Définir ce qui concerne RSA éphémère */
 RSA *rsa_512 = NULL;
 RSA *rsa_1024 = NULL;

 rsa_512 = RSA_generate_key(512,RSA_F4,NULL,NULL);
 if (rsa_512 == NULL)
     evaluate_error_queue();

 rsa_1024 = RSA_generate_key(1024,RSA_F4,NULL,NULL);
 if (rsa_1024 == NULL)
   evaluate_error_queue();

 ...

 RSA *tmp_rsa_callback(SSL *s, int is_export, int taille_clef)
 {
    RSA *rsa_tmp=NULL;

    switch (taille_clef) {
    case 512:
      if (rsa_512)
        rsa_tmp = rsa_512;
      else { /* générer à la volée, ce qui n’est
                pas le cas dans cet exemple */
        rsa_tmp = RSA_generate_key(taille_clef,RSA_F4,NULL,NULL);
        rsa_512 = rsa_tmp; /* mémorisation pour un usage ultérieur */
      }
      break;
    case 1024:
      if (rsa_1024)
        rsa_tmp=rsa_1024;
      else
        should_not_happen_in_this_example();
      break;
    default:
      /* générer une clef à la volée est très coûteux,
         aussi utilisez ceci */
      if (rsa_1024)
        rsa_tmp=rsa_1024;
      else
        rsa_tmp=rsa_512; /* utiliser au moins une clef plus courte */
    }
    return(rsa_tmp);
 }

VALEURS DE RETOUR
SSL_CTX_set_tmp_rsa_callback() et SSL_set_tmp_rsa_callback() ne renvoient pas de sortie de diagnostic.

SSL_CTX_set_tmp_rsa() et SSL_set_tmp_rsa() doivent renvoyer 1 lors d’une réussite et 0 pour un échec. Consultez la file d’erreurs pour trouver la raison de l’échec.

SSL_CTX_need_tmp_rsa() et SSL_need_tmp_rsa() renvoient 1 si une clef est nécessaire et 0 autrement.

VOIR AUSSI
ssl(3), SSL_CTX_set_cipher_list(3), SSL_CTX_set_options(3), SSL_CTX_set_tmp_dh_callback(3), SSL_new(3), ciphers(1)

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.