fr::ssl::SSL_CTX_set_generate_session_id(3SSL)

NOM
SSL_CTX_set_generate_session_id, SSL_set_generate_session_id, SSL_has_matching_session_id - Contrôler la création d’identifiant de session SSL (serveur uniquement)

SYNOPSIS
#include <openssl/ssl.h>

typedef int (*GEN_SESSION_CB)(const SSL *ssl, unsigned char *id,
                        unsigned int *id_long);

int SSL_CTX_set_generate_session_id(SSL_CTX *ctx, GEN_SESSION_CB cb);
 int SSL_set_generate_session_id(SSL *ssl, GEN_SESSION_CB, cb);
 int SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id,
                  unsigned int id_long);

DESCRIPTION
SSL_CTX_set_generate_session_id() définit la fonction de rappel pour la création d’identifiants de nouvelles sessions SSL/TLS pour ctx à cb.

SSL_CTX_set_generate_session_id() définit la fonction de rappel pour la création d’identifiants de nouvelles sessions SSL/TLS pour ssl à cb.

SSL_has_matching_session_id() vérifie si une session d’identifiant id (de longueur id_long) est déjà contenue dans le cache interne de session du contexte parent de ssl.

NOTES
Quand une nouvelle session est établie entre client et serveur, le serveur crée un identifiant de session. Celui-ci est une séquence arbitraire d’octets. La longueur de l’identifiant est de 16 octets pour les sessions SSLv2 et entre 1 et 32 octets pour celles SSLv3/TLSv1. L’identifiant n’est pas critique pour la sécurité mais doit être unique pour le serveur. De plus l’identifiant est transmis en clair, aussi ne doit-il pas contenir d’informations sensibles.

Sans rappel défini, un serveur OpenSSL créera un seul identifiant de session à partir de nombres pseudo-aléatoires de la longueur la plus grande possible. En utilisant la fonction de rappel, l’identifiant peut être changé et contenir des informations supplémentaires, comme par exemple un identifiant d’hôte pour améliorer la répartition de charge ou les techniques de cache externe.

La fonction de rappel reçoit un pointeur vers l’emplacement mémoire où mettre id et un autre vers la longueur maximale admise id_long. Le tampon à l’emplacement id est seulement sûr d’avoir la taille de id_long. Le rappel est seulement autorisé à créer un identifiant plus petit et à réduire id_long ; le rappel ne doit jamais augmenter id_long ou écrire dans l’emplacement id en dépassant la limite donnée.

Si un identifiant de session SSLv2 est créé et id_long réduit, il sera restauré après la fin du rappel et l’identifiant empli avec des 0x00. Changer id_long n’est pas recommandé pour des sessions SSLv2. Le rappel peut utiliser la fonction SSL_get_version(3) pour vérifier si la fonction est de type SSLv2.

L’emplacement id est empli avec des 0x00 avant l’appel du rappel, aussi le rappel peut seulement remplir une partie de la longueur possible et laisse id_long inchangé tout en maintenant la reproductibilité.

Puisque les sessions doivent pouvoir être distinguées, les identifiants de session doivent être uniques. En dehors du rappel, un nombre aléatoire est utilisé, aussi la possibilité de créer un même identifiant est extrêmement faible (2^128 identifiants possibles pour une session SSLv2 , 2^256 pour SSLv3/TLSv1). Dans le but d’assurer l’unicité de l’identifiant créé, le rappel doit appeler SSL_has_matching_session_id() et créer un autre identifiant si un conflit se produit. Si un conflit d’identifiant apparait, l’initiation de connexion échouera. Si l’application code par exemple un identifiant unique d’hôte, un numéro unique de processus et un numéro unique de suite dans l’identifiant de session, l’unicité peut facilement être parachevée sans caractères aléatoires ajoutés (en prenant soin qu’aucune information confidentielle ne puisse être divulguée). Si l’application ne peut garantir l’unicité, l’utilisation du maximum de id_long est recommandée ainsi que remplir les octets, non utilisés pour coder une information particulière, avec des données aléatoires pour éviter un conflit.

SSL_has_matching_session_id() interrogera le cache interne de session mais pas celui externe. Puisque l’identifiant de session est créé avant que l’initiation ne soit terminée, il n’est pas ajouté immédiatement au cache. Si un autre processus utilise le même cache interne de session, une situation de compétition peut survenir si cet autre processus crée le même identifiant. Des conflits peuvent survenir lors de l’utilisation du cache de session externe puisque celui-ci n’est pas vérifié avec SSL_has_matching_session_id(), et la même situation de compétition existe.

Lors de l’appel de SSL_has_matching_session_id()pour une session SSLv2 avec id_long réduit, la correspondance sera réalisée en utilisant la longueur demandée et l’identifiant emplit de 0x00.

Le rappel doit renvoyer 0 si un identifiant ne peut être créé pour n’importe quelle raison et 1 en cas de réussite.

EXEMPLES
La fonction de rappel doit créé un identifiant de session avec l’identifiant de serveur fourni, et compléter le reste avec des octets pseudo-aléatoires.

 const char session_id_prefix = "www-18";

 #define MAX_SESSION_ID_ATTEMPTS 10
 static int generate_session_id(const SSL *ssl, unsigned char *id,
                              unsigned int *id_long)
      {
      unsigned int count = 0;
      const char *version;

      version = SSL_get_version(ssl);
      if (!strcmp(version, "SSLv2"))
          /* ne pas changer id_long */;

      do      {
              RAND_pseudo_bytes(id, *id_len);
              /* Préfixer le session_id avec le préfixe demandé.
               * Avertissement : si le préfixe est trop long, rognez-le
               * — des effets pervers sont possibles, par exemple,
               * le serveur peut créer un identifiant de session
               * (c’est-à-dire le préfixe) de telle sorte que toutes
               * les négociations de sessions suivante échoueront à
               * cause des conflits. */
              memcpy(id, session_id_prefix,
                      (strlen(session_id_prefix) < *id_long) ?
                      strlen(session_id_prefix) : *id_long);
              }
      while(SSL_has_matching_session_id(ssl, id, *id_long) &&
              (++count < MAX_SESSION_ID_ATTEMPTS));
      if(count >= MAX_SESSION_ID_ATTEMPTS)
              return 0;
      return 1;
      }

VALEURS DE RETOUR
SSL_CTX_set_generate_session_id() et SSL_set_generate_session_id() renvoient 1.

SSL_has_matching_session_id() renvoie 1 si une autre session avec le même identifiant est déjà dans le cache.

VOIR AUSSI
ssl(3), SSL_get_version(3)

HISTORIQUE
SSL_CTX_set_generate_session_id(), SSL_set_generate_session_id() et SSL_has_matching_session_id() ont été introduits dans OpenSSL 0.9.7.

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.