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.

1.0.2a 1.0.2c                                      2015-12-31     fr::ssl::SSL_CTX_set_generate_session_id(3SSL)