fr::ssl::SSL_CTX_add1_chain_cert(3SSL)

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.