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-12fr::ssl::SSL_CTX_set_generate_session_id(3SSL)