NOM

       SSL_CTX_set0_chain, SSL_CTX_set1_chain, SSL_CTX_add0_chain_cert, SSL_CTX_add1_chain_cert,
       SSL_CTX_get0_chain_certs, SSL_CTX_clear_chain_certs, SSL_set0_chain, SSL_set1_chain, SSL_add0_chain_cert,
       SSL_add1_chain_cert, SSL_get0_chain_certs, SSL_clear_chain_certs, SSL_CTX_build_cert_chain,
       SSL_build_cert_chain, SSL_CTX_select_current_cert, SSL_select_current_cert, SSL_CTX_set_current_cert,
       SSL_set_current_cert - Traitement d'un certificat de chaîne supplémentaire

SYNOPSIS

        #include <openssl/ssl.h>

        int SSL_CTX_set0_chain(SSL_CTX *ctx, STACK_OF(X509) *sk);
        int SSL_CTX_set1_chain(SSL_CTX *ctx, STACK_OF(X509) *sk);
        int SSL_CTX_add0_chain_cert(SSL_CTX *ctx, X509 *x509);
        int SSL_CTX_add1_chain_cert(SSL_CTX *ctx, X509 *x509);
        int SSL_CTX_get0_chain_certs(SSL_CTX *ctx, STACK_OF(X509) **sk);
        int SSL_CTX_clear_chain_certs(SSL_CTX *ctx);

        int SSL_set0_chain(SSL *ssl, STACK_OF(X509) *sk);
        int SSL_set1_chain(SSL *ssl, STACK_OF(X509) *sk);
        int SSL_add0_chain_cert(SSL *ssl, X509 *x509);
        int SSL_add1_chain_cert(SSL *ssl, X509 *x509);
        int SSL_get0_chain_certs(SSL *ssl, STACK_OF(X509) **sk);
        int SSL_clear_chain_certs(SSL *ssl);

        int SSL_CTX_build_cert_chain(SSL_CTX *ctx, flags);
        int SSL_build_cert_chain(SSL *ssl, flags);

        int SSL_CTX_select_current_cert(SSL_CTX *ctx, X509 *x509);
        int SSL_select_current_cert(SSL *ssl, X509 *x509);
        int SSL_CTX_set_current_cert(SSL_CTX *ctx, long op);
        int SSL_set_current_cert(SSL *ssl, long op);

DESCRIPTION

       SSL_CTX_set0_chain() et SSL_CTX_set1_chain() définissent la chaîne de certificats associée au certificat
       actuel de ctx à sk.

       SSL_CTX_add0_chain_cert() et SSL_CTX_add1_chain_cert() ajoutent le certificat simple x509 à la chaîne
       associée au certificat actuel de ctx.

       SSL_CTX_get0_chain_certs() récupère la chaîne associée au certificat actuel de ctx.

       SSL_CTX_clear_chain_certs() enlève toute chaîne existante associée au certificat actuel de ctx. (Cela est
       implémenté en appelant SSL_CTX_set0_chain() avec sk défini à NULL).

       SSL_CTX_build_cert_chain() construit la chaîne de certificats pour ctx ; normalement, c'est le stockage
       de chaîne qui est utilisé ou le magasin de vérification si le stockage de chaîne n'est pas défini. Si la
       fonction réussit, la chaîne construite remplacera toute chaîne existante. Le paramètre flags peut être
       défini à SSL_BUILD_CHAIN_FLAG_UNTRUSTED pour utiliser des certificats de chaîne existants comme autorités
       de certification non fiables, SSL_BUILD_CHAIN_FLAG_NO_ROOT pour omettre l'autorité de certification
       racine de la chaîne construite, SSL_BUILD_CHAIN_FLAG_CHECK pour utiliser tous les certificats de chaîne
       existants seulement pour construire la chaîne (avec une vérification effective et en les réarrangeant si
       nécessaire), le réglage SSL_BUILD_CHAIN_FLAG_IGNORE_ERROR ignore toutes les erreurs durant la
       vérification : si le réglage SSL_BUILD_CHAIN_FLAG_CLEAR_ERROR est également défini, les erreurs de
       vérification sont retirées de la file d'erreurs.

       Chacune de ces fonctions agit sur le certificat actuel de l'entité finale (c'est-à-dire le serveur ou le
       client). C'est le dernier certificat chargé ou sélectionné de la structure ctx correspondante.

       SSL_CTX_select_current_cert() sélectionne x509 comme certificat de l'entité finale actuelle, mais
       seulement si x509 a déjà été chargé dans ctx en utilisant une fonction telle que
       SSL_CTX_use_certificate().

       SSL_set0_chain(), SSL_set1_chain(), SSL_add0_chain_cert(), SSL_add1_chain_cert(), SSL_get0_chain_certs(),
       SSL_clear_chain_certs(), SSL_build_cert_chain(), SSL_select_current_cert() et SSL_set_current_cert() sont
       similaires sauf qu'elles s'appliquent à une structure SSL ssl.

       SSL_CTX_set_current_cert() modifie le certificat actuel pour une valeur basée sur l'argument op.
       Actuellement oppeut être SSL_CERT_SET_FIRST pour utiliser le premier certificat valable ou
       SSL_CERT_SET_NEXT pour indiquer le premier certificat valable après le certificat actuel. Ces deux
       opérations peuvent être utilisées pour être exécutées sur tous les certificats d'une structure SSL_CTX.

       SSL_set_current_cert() prend en charge aussi l'option SSL_CERT_SET_SERVER. Si ssl est un serveur et qu'il
       a envoyé un certificat à un client connecté, cette option définit ce certificat au certificat actuel et
       renvoie 1. Si l'ensemble de chiffrements est anonyme (et donc aucun certificat ne sera envoyé) 2 est
       renvoyé et le certificat actuel reste inchangé. Si ssl n'est pas un serveur ou si aucun certificat n'a
       été envoyé, 0 est renvoyé et le certificat actuel reste inchangé.

       Toutes ces fonctions sont implémentées comme des macros. Celles qui contiennent un 1 incrémentent le
       compteur de références du certificat ou de la chaîne fournis ; ils doivent être libérés à un certain
       moment après l'opération. Ceux qui contiennent un 0 n'incrémentent pas le compteur de références et le
       certificat ou la chaîne fournis NE DOIVENT PAS être libérés après l'opération.

NOTES

       Les chaînes associées à une structure SSL_CTX sont copiées dans toutes structures SSL quand SSL_new() est
       appelée. Les structures SSL ne seront pas affectées par tout changement de chaîne survenu dans le SSL_CTX
       parent.

       Une chaîne peut être définie pour chaque type de clé pris en charge par un serveur. Donc, par exemple,
       des certificats RSA et DSA pourront avoir (et souvent auront) des chaînes différentes.

       Les fonctions SSL_CTX_build_cert_chain() et SSL_build_cert_chain() peuvent être utilisées pour vérifier
       la configuration d'applications et pour s'assurer que toutes les autorités de certification subordonnées
       nécessaires sont envoyées dans le bon ordre. Les applications mal configurées envoyant des chaînes de
       certificats incorrectes provoquent souvent des problèmes avec les pairs.

       Par exemple, une application peut ajouter n'importe quel ensemble de certificats en utilisant
       SSL_CTX_use_certificate_chain_file() puis appeler la fonction SSL_CTX_build_cert_chain() avec l'option
       SSL_BUILD_CHAIN_FLAG_CHECK pour les vérifier et les réordonner.

       Les applications peuvent émettre des avertissements non fatals quand elles vérifient les chaînes en
       passant le paramètre SSL_BUILD_CHAIN_FLAG_IGNORE_ERRORS et en vérifiant la valeur de retour.

       L'appel de SSL_CTX_build_cert_chain() ou de SSL_build_cert_chain() est plus efficace que la construction
       de chaîne automatique dans la mesure où il est effectué une seule fois. La construction de chaîne
       automatique est réalisée à chaque nouvelle session.

       Si n'importe quels certificats sont ajoutés en utilisant ces fonctions, aucun certificat ajouté en
       utilisant SSL_CTX_add_extra_chain_cert() ne sera utilisé.

VALEURS DE RETOUR

       SSL_set_current_cert() avec SSL_CERT_SET_SERVER renvoie 1 en cas de réussite, 2 si aucun certificat n'est
       utilisé parce que l'ensemble de chiffrements est anonyme, et 0 en cas d'échec.

       SSL_CTX_build_cert_chain() et SSL_build_cert_chain() renvoient 1 en cas de réussite, et 0 en cas d'échec.
       Si le paramètre SSL_BUILD_CHAIN_FLAG_IGNORE_ERRORS est passé et si une erreur de vérification survient,
       alors 2 est renvoyé.

       Toutes les autres fonctions renvoient 1 en cas de réussite et 0 en cas d'échec.

VOIR AUSSI

       SSL_CTX_add_extra_chain_cert(3)

HISTORIQUE

       Ces fonctions ont été ajoutées pour la première fois dans OpenSSL 1.0.2.

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_add1_chain_cert(3SSL)