openssl - en to fr translation catalogue (186 entries)

note: type: =head1
en: NAME
fr: NOM

note: type: textblock
en: 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 - extra chain certificate processing
fr: 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

note: type: textblock
en: SSL_CTX_set0_chain() and SSL_CTX_set1_chain() set the certificate chain associated with the current certificate of B<ctx> to B<sk>.
fr: B<SSL_CTX_set0_chain>() et B<SSL_CTX_set1_chain>() définissent la chaîne de certificats associée au certificat actuel de I<ctx> à I<sk>.

note: type: textblock
en: SSL_CTX_add0_chain_cert() and SSL_CTX_add1_chain_cert() append the single certificate B<x509> to the chain associated with the current certificate of B<ctx>.
fr: B<SSL_CTX_add0_chain_cert>() et B<SSL_CTX_add1_chain_cert>() ajoutent le certificat simple I<x509> à la chaîne associée au certificat actuel de I<ctx>.

note: type: textblock
en: SSL_CTX_get0_chain_certs() retrieves the chain associated with the current certificate of B<ctx>.
fr: B<SSL_CTX_get0_chain_certs>() récupère la chaîne associée au certificat actuel de I<ctx>.

note: type: textblock
en: SSL_CTX_clear_chain_certs() clears any existing chain associated with the current certificate of B<ctx>.  (This is implemented by calling SSL_CTX_set0_chain() with B<sk> set to B<NULL>).
fr: B<SSL_CTX_clear_chain_certs>() enlève toute chaîne existante associée au certificat actuel de I<ctx>. (Cela est implémenté en appelant B<SSL_CTX_set0_chain>() avec I<sk> défini à NULL).

note: type: textblock
en: SSL_CTX_build_cert_chain() builds the certificate chain for B<ctx> normally this uses the chain store or the verify store if the chain store is not set.  If the function is successful the built chain will replace any existing chain.  The B<flags> parameter can be set to B<SSL_BUILD_CHAIN_FLAG_UNTRUSTED> to use existing chain certificates as untrusted CAs, B<SSL_BUILD_CHAIN_FLAG_NO_ROOT> to omit the root CA from the built chain, B<SSL_BUILD_CHAIN_FLAG_CHECK> to use all existing chain certificates only to build the chain (effectively sanity checking and rearranging them if necessary), the flag B<SSL_BUILD_CHAIN_FLAG_IGNORE_ERROR> ignores any errors during verification: if flag B<SSL_BUILD_CHAIN_FLAG_CLEAR_ERROR> is also set verification errors are cleared from the error queue.
fr: B<SSL_CTX_build_cert_chain>() construit la chaîne de certificats pour I<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 I<flags> peut être défini à B<SSL_BUILD_CHAIN_FLAG_UNTRUSTED> pour utiliser des certificats de chaîne existants comme autorités de certification non fiables, B<SSL_BUILD_CHAIN_FLAG_NO_ROOT> pour omettre l'autorité de certification racine de la chaîne construite, B<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 B<SSL_BUILD_CHAIN_FLAG_IGNORE_ERROR> ignore toutes les erreurs durant la vérification : si le réglage B<SSL_BUILD_CHAIN_FLAG_CLEAR_ERROR> est également défini, les erreurs de vérification sont retirées de la file d'erreurs.

note: type: textblock
en: Each of these functions operates on the I<current> end entity (i.e. server or client) certificate. This is the last certificate loaded or selected on the corresponding B<ctx> structure.
fr: Chacune de ces fonctions agit sur le certificat B<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 I<ctx> correspondante.

note: type: textblock
en: SSL_CTX_select_current_cert() selects B<x509> as the current end entity certificate, but only if B<x509> has already been loaded into B<ctx> using a function such as SSL_CTX_use_certificate().
fr: B<SSL_CTX_select_current_cert>() sélectionne I<x509> comme certificat de l'entité finale actuelle, mais seulement si I<x509> a déjà été chargé dans I<ctx> en utilisant une fonction telle que B<SSL_CTX_use_certificate>().

note: type: textblock
en: 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() and SSL_set_current_cert()  are similar except they apply to SSL structure B<ssl>.
fr: 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 I<ssl>.

note: type: textblock
en: SSL_CTX_set_current_cert() changes the current certificate to a value based on the B<op> argument. Currently B<op> can be B<SSL_CERT_SET_FIRST> to use the first valid certificate or B<SSL_CERT_SET_NEXT> to set the next valid certificate after the current certificate. These two operations can be used to iterate over all certificates in an B<SSL_CTX> structure.
fr: B<SSL_CTX_set_current_cert>() modifie le certificat actuel pour une valeur basée sur l'argument I<op>. Actuellement I<op>peut être B<SSL_CERT_SET_FIRST> pour utiliser le premier certificat valable ou B<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 B<SSL_CTX>.

note: type: textblock
en: SSL_set_current_cert() also supports the option B<SSL_CERT_SET_SERVER>.  If B<ssl> is a server and has sent a certificate to a connected client this option sets that certificate to the current certificate and returns 1.  If the negotiated ciphersuite is anonymous (and thus no certificate will be sent) 2 is returned and the current certificate is unchanged. If B<ssl> is not a server or a certificate has not been sent 0 is returned and the current certificate is unchanged.
fr: B<SSL_set_current_cert>() prend en charge aussi l'option B<SSL_CERT_SET_SERVER>. Si I<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 B<1>. Si l'ensemble de chiffrements est anonyme (et donc aucun certificat ne sera envoyé) B<2> est renvoyé et le certificat actuel reste inchangé. Si I<ssl> n'est pas un serveur ou si aucun certificat n'a été envoyé, B<0> est renvoyé et le certificat actuel reste inchangé.

note: type: textblock
en: All these functions are implemented as macros. Those containing a B<1> increment the reference count of the supplied certificate or chain so it must be freed at some point after the operation. Those containing a B<0> do not increment reference counts and the supplied certificate or chain B<MUST NOT> be freed after the operation.
fr: Toutes ces fonctions sont implémentées comme des macros. Celles qui contiennent un B<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 B<0> n'incrémentent pas le compteur de références et le certificat ou la chaîne fournis B<NE DOIVENT PAS> être libérés après l'opération.

note: type: textblock
en: The chains associate with an SSL_CTX structure are copied to any SSL structures when SSL_new() is called. SSL structures will not be affected by any chains subsequently changed in the parent SSL_CTX.
fr: Les chaînes associées à une structure B<SSL_CTX> sont copiées dans toutes structures SSL quand B<SSL_new>() est appelée. Les structures SSL ne seront pas affectées par tout changement de chaîne survenu dans le B<SSL_CTX> parent.

note: type: textblock
en: One chain can be set for each key type supported by a server. So, for example, an RSA and a DSA certificate can (and often will) have different chains.
fr: 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.

note: type: textblock
en: The functions SSL_CTX_build_cert_chain() and SSL_build_cert_chain() can be used to check application configuration and to ensure any necessary subordinate CAs are sent in the correct order. Misconfigured applications sending incorrect certificate chains often cause problems with peers.
fr: Les fonctions B<SSL_CTX_build_cert_chain>() et B<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.

note: type: textblock
en: For example an application can add any set of certificates using SSL_CTX_use_certificate_chain_file() then call SSL_CTX_build_cert_chain()  with the option B<SSL_BUILD_CHAIN_FLAG_CHECK> to check and reorder them.
fr: Par exemple, une application peut ajouter n'importe quel ensemble de certificats en utilisant B<SSL_CTX_use_certificate_chain_file>() puis appeler la fonction B<SSL_CTX_build_cert_chain>() avec l'option B<SSL_BUILD_CHAIN_FLAG_CHECK> pour les vérifier et les réordonner.

note: type: textblock
en: Applications can issue non fatal warnings when checking chains by setting the flag B<SSL_BUILD_CHAIN_FLAG_IGNORE_ERRORS> and checking the return value.
fr: Les applications peuvent émettre des avertissements non fatals quand elles vérifient les chaînes en passant le paramètre B<SSL_BUILD_CHAIN_FLAG_IGNORE_ERRORS> et en vérifiant la valeur de retour.

note: type: textblock
en: Calling SSL_CTX_build_cert_chain() or SSL_build_cert_chain() is more efficient than the automatic chain building as it is only performed once.  Automatic chain building is performed on each new session.
fr: L'appel de B<SSL_CTX_build_cert_chain>() ou de B<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.

note: type: textblock
en: If any certificates are added using these functions no certificates added using SSL_CTX_add_extra_chain_cert() will be used.
fr: Si n'importe quels certificats sont ajoutés en utilisant ces fonctions, aucun certificat ajouté en utilisant B<SSL_CTX_add_extra_chain_cert>() ne sera utilisé.

note: type: =head1
en: RETURN VALUES
fr: VALEURS DE RETOUR

note: type: textblock
en: SSL_set_current_cert() with B<SSL_CERT_SET_SERVER> return 1 for success, 2 if no server certificate is used because the ciphersuites is anonymous and 0 for failure.
fr: B<SSL_set_current_cert>() avec B<SSL_CERT_SET_SERVER> renvoie B<1> en cas de réussite, B<2> si aucun certificat n'est utilisé parce que l'ensemble de chiffrements est anonyme, et B<0> en cas d'échec.

note: type: textblock
en: SSL_CTX_build_cert_chain() and SSL_build_cert_chain() return 1 for success and 0 for failure. If the flag B<SSL_BUILD_CHAIN_FLAG_IGNORE_ERROR> and a verification error occurs then 2 is returned.
fr: B<SSL_CTX_build_cert_chain>() et B<SSL_build_cert_chain>() renvoient B<1> en cas de réussite, et B<0> en cas d'échec. Si le paramètre B<SSL_BUILD_CHAIN_FLAG_IGNORE_ERRORS> est passé et si une erreur de vérification survient, alors B<2> est renvoyé.

note: type: textblock
en: All other functions return 1 for success and 0 for failure.
fr: Toutes les autres fonctions renvoient B<1> en cas de réussite et B<0> en cas d'échec.

note: type: =head1
en: SEE ALSO
fr: VOIR AUSSI

note: type: textblock
en: L<SSL_CTX_add_extra_chain_cert(3)|SSL_CTX_add_extra_chain_cert(3)>
fr: L<B<SSL_CTX_add_extra_chain_cert>(3)|SSL_CTX_add_extra_chain_cert(3)>

note: type: =head1
en: HISTORY
fr: HISTORIQUE

note: type: textblock
en: These functions were first added to OpenSSL 1.0.2.
fr: Ces fonctions ont été ajoutées pour la première fois dans OpenSSL 1.0.2.

note: type: textblock
en: SSL_CTX_add_extra_chain_cert - add certificate to chain
fr: SSL_CTX_add_extra_chain_cert - Ajouter un certificat à une chaîne

note: type: textblock
en: SSL_CTX_add_extra_chain_cert() adds the certificate B<x509> to the certificate chain presented together with the certificate. Several certificates can be added one after the other.
fr: B<SSL_CTX_add_extra_chain_cert>() ajoute le certificat I<x509> à la chaîne de certificats présentée avec le certificat. Plusieurs certificats peuvent être ajoutés les uns après les autres.

note: type: textblock
en: When constructing the certificate chain, the chain will be formed from these certificates explicitly specified. If no chain is specified, the library will try to complete the chain from the available CA certificates in the trusted CA storage, see L<SSL_CTX_load_verify_locations(3)|SSL_CTX_load_verify_locations(3)>.
fr: Lors de la construction d'une chaîne de certificats, la chaîne sera formée à partir de ces certificats explicitement indiqués. Si aucune chaîne n'est indiquée, la bibliothèque essaiera de terminer la chaîne à partir des certificats d'autorité dans le stockage d'autorités de certification de confiance, consultez L<B<SSL_CTX_load_verify_locations>(3)|SSL_CTX_load_verify_locations(3)>.

note: type: textblock
en: The B<x509> certificate provided to SSL_CTX_add_extra_chain_cert() will be freed by the library when the B<SSL_CTX> is destroyed. An application B<should not> free the B<x509> object.
fr: Le certificat I<x509> fourni à B<SSL_CTX_add_extra_chain_cert> sera libéré par la bibliothèque quand le B<SSL_CTX> est détruit. Une application ne B<devrait pas> libérer l’objet I<x509>.

note: type: textblock
en: Only one set of extra chain certificates can be specified per SSL_CTX structure. Different chains for different certificates (for example if both RSA and DSA certificates are specified by the same server) or different SSL structures with the same parent SSL_CTX cannot be specified using this function. For more flexibility functions such as SSL_add1_chain_cert() should be used instead.
fr: Un seul jeu de certificats de chaîne supplémentaire peut être indiqué par structure B<SSL_CTX>. Différentes chaînes pour différents certificats (par exemple si à la fois des certificats RSA et DSA sont indiqués par le même serveur) ou différentes structures SSL avec le même B<SSL_CTX> parent ne peuvent pas être indiquées en utilisant cette fonction. Pour plus de flexibilité, des fonctions comme B<SSL_add1_chain_cert>() sont à préférer.

note: type: textblock
en: SSL_CTX_add_extra_chain_cert() returns 1 on success. Check out the error stack to find out the reason for failure otherwise.
fr: B<SSL_CTX_add_extra_chain_cert>() renvoie B<1> en cas de réussite. Vérifiez la pile d'erreur pour découvrir la raison de l'échec sinon.

note: type: textblock
en: L<ssl(3)|ssl(3)>, L<SSL_CTX_use_certificate(3)|SSL_CTX_use_certificate(3)>, L<SSL_CTX_set_client_cert_cb(3)|SSL_CTX_set_client_cert_cb(3)>, L<SSL_CTX_load_verify_locations(3)|SSL_CTX_load_verify_locations(3)> L<SSL_CTX_set0_chain(3)|SSL_CTX_set0_chain(3)> L<SSL_CTX_set1_chain(3)|SSL_CTX_set1_chain(3)> L<SSL_CTX_add0_chain_cert(3)|SSL_CTX_add0_chain_cert(3)> L<SSL_CTX_add1_chain_cert(3)|SSL_CTX_add1_chain_cert(3)> L<SSL_set0_chain(3)|SSL_set0_chain(3)> L<SSL_set1_chain(3)|SSL_set1_chain(3)> L<SSL_add0_chain_cert(3)|SSL_add0_chain_cert(3)> L<SSL_add1_chain_cert(3)|SSL_add1_chain_cert(3)> L<SSL_CTX_build_cert_chain(3)|SSL_CTX_build_cert_chain(3)> L<SSL_build_cert_chain(3)|SSL_build_cert_chain(3)>
fr: L<B<ssl>(3)|ssl(3)>, L<B<SSL_CTX_use_certificate>(3)|SSL_CTX_use_certificate(3)>, L<B<SSL_CTX_set_client_cert_cb>(3)|SSL_CTX_set_client_cert_cb(3)>, L<B<SSL_CTX_load_verify_locations>(3)|SSL_CTX_load_verify_locations(3)>, L<B<SSL_CTX_set0_chain>(3)|SSL_CTX_set0_chain(3)>, L<B<SSL_CTX_set1_chain>(3)|SSL_CTX_set1_chain(3)>, L<B<SSL_CTX_add0_chain_cert>(3)|SSL_CTX_add0_chain_cert(3)>, L<B<SSL_CTX_add1_chain_cert>(3)|SSL_CTX_add1_chain_cert(3)>, L<B<SSL_set0_chain>(3)|SSL_set0_chain(3)>, L<B<SSL_set1_chain>(3)|SSL_set1_chain(3)>, L<B<SSL_add0_chain_cert>(3)|SSL_add0_chain_cert(3)>, L<B<SSL_add1_chain_cert>(3)|SSL_add1_chain_cert(3)>, L<B<SSL_CTX_build_cert_chain>(3)|SSL_CTX_build_cert_chain(3)>, L<B<SSL_build_cert_chain>(3)|SSL_build_cert_chain(3)>

note: type: textblock
en: SSL_CTX_add_session, SSL_add_session, SSL_CTX_remove_session, SSL_remove_session - manipulate session cache
fr: SSL_CTX_add_session, SSL_add_session, SSL_CTX_remove_session, SSL_remove_session - manipuler le cache de sessions

note: type: textblock
en: SSL_CTX_add_session() adds the session B<c> to the context B<ctx>. The reference count for session B<c> is incremented by 1. If a session with the same session id already exists, the old session is removed by calling L<SSL_SESSION_free(3)|SSL_SESSION_free(3)>.
fr: B<SSL_CTX_add_session>() ajoute la session I<c> au contexte I<ctx>. Le compteur de références pour la session I<c> est incrémenté de B<1>. S'il existe déjà une session avec le même identifiant de session, la session ancienne est supprimée en appelant L<B<SSL_SESSION_free>(3)|SSL_SESSION_free(3)>.

note: type: textblock
en: SSL_CTX_remove_session() removes the session B<c> from the context B<ctx>.  L<SSL_SESSION_free(3)|SSL_SESSION_free(3)> is called once for B<c>.
fr: B<SSL_CTX_remove_session>() supprime la session I<c> du contexte I<ctx>. L<B<SSL_SESSION_free>(3)|SSL_SESSION_free(3)> est appelée une fois pour I<c>.

note: type: textblock
en: SSL_add_session() and SSL_remove_session() are synonyms for their SSL_CTX_*() counterparts.
fr: B<SSL_add_session>() et B<SSL_remove_session>() sont synonymes pour leurs équivalents B< SSL_CTX_*>().

note: type: textblock
en: When adding a new session to the internal session cache, it is examined whether a session with the same session id already exists. In this case it is assumed that both sessions are identical. If the same session is stored in a different SSL_SESSION object, The old session is removed and replaced by the new session. If the session is actually identical (the SSL_SESSION object is identical), SSL_CTX_add_session()  is a no-op, and the return value is 0.
fr: Quand on ajoute une nouvelle session au cache des sessions interne, l'existence d'une session portant déjà le même identifiant de session est vérifiée. Si c'est le cas, ces deux sessions sont considérées identiques. Si la même session est conservée dans un objet B<SSL_SESSION> différent, l'ancienne session est supprimée et remplacée par la nouvelle session. Si la session est vraiment identique (l'objet B<SSL_SESSION> est identique), B<SSL_CTX_add_session>() est sans effet et la valeur B<0> est renvoyée.

note: type: textblock
en: If a server SSL_CTX is configured with the SSL_SESS_CACHE_NO_INTERNAL_STORE flag then the internal cache will not be populated automatically by new sessions negotiated by the SSL/TLS implementation, even though the internal cache will be searched automatically for session-resume requests (the latter can be suppressed by SSL_SESS_CACHE_NO_INTERNAL_LOOKUP). So the application can use SSL_CTX_add_session() directly to have full control over the sessions that can be resumed if desired.
fr: Lorsqu'un serveur B<SSL_CTX> est configuré avec le réglage B<SSL_SESS_CACHE_NO_INTERNAL_STORE>, le cache interne n'est pas automatiquement rempli par les nouvelles sessions négociées par l'implémentation de B<SSL/TLS>, même si le cache interne fera automatiquement l'objet d'une recherche lors d'une requête de reprise de session (la dernière peut être supprimée par la fonction B<SSL_SESS_CACHE_NO_INTERNAL_LOOKUP>). Ainsi, l'application peut utiliser directement B<SSL_CTX_add_session>() pour obtenir un contrôle total des sessions qui peuvent être reprises si on le souhaite.

note: type: textblock
en: The following values are returned by all functions:
fr: Toutes les fonctions peuvent renvoyer les valeurs suivantes :

note: type: verbatim
en:  The operation failed. In case of the add operation, it was tried to add
     the same (identical) session twice. In case of the remove operation, the
     session was not found in the cache.
fr:  L’opération a échouée. Si c’est lors d’une opération d’addition, un essai
     d’ajout de la même session (identique) a été fait. Si c’est lors d’une
     opération de suppression, la session n’a pas été trouvée dans le cache.

note: type: verbatim
en:  The operation succeeded.
fr:  L’opération est réussie.

note: type: textblock
en: L<ssl(3)|ssl(3)>, L<SSL_CTX_set_session_cache_mode(3)|SSL_CTX_set_session_cache_mode(3)>, L<SSL_SESSION_free(3)|SSL_SESSION_free(3)>
fr: L<B<ssl>(3)|ssl(3)>, L<B<SSL_CTX_set_session_cache_mode>(3)|SSL_CTX_set_session_cache_mode(3)>, L<B<SSL_SESSION_free>(3)|SSL_SESSION_free(3)>

note: type: textblock
en: SSL_CTX_ctrl, SSL_CTX_callback_ctrl, SSL_ctrl, SSL_callback_ctrl - internal handling functions for SSL_CTX and SSL objects
fr: SSL_CTX_ctrl, SSL_CTX_callback_ctrl, SSL_ctrl, SSL_callback_ctrl - Fonctions de traitement interne pour les objets SSL_CTX et SSL

note: type: textblock
en: The SSL_*_ctrl() family of functions is used to manipulate settings of the SSL_CTX and SSL objects. Depending on the command B<cmd> the arguments B<larg>, B<parg>, or B<fp> are evaluated. These functions should never be called directly. All functionalities needed are made available via other functions or macros.
fr: La famille de fonctions B<SSL*_ctrl>() est utilisée pour manipuler les paramètres des objets B<SSL_CTX> et B<SSL>. En fonction de la commande I<cmd>, les arguments I<larg>, I<parg> et I<fp> sont évalués. Ces fonctions ne devraient jamais être appelées directement. Toutes les fonctionnalités nécessaires sont mises à disposition par l'intermédiaire d'autres fonctions ou macros.

note: type: textblock
en: The return values of the SSL*_ctrl() functions depend on the command supplied via the B<cmd> parameter.
fr: Les valeurs de retour des fonctions B<SSL*_ctrl>() dépendent de la commande fournie par le paramètre I<cmd>.

note: type: textblock
en: L<ssl(3)|ssl(3)>
fr: L<B<ssl>(3)|ssl(3)>

note: type: textblock
en: SSL_CTX_flush_sessions, SSL_flush_sessions - remove expired sessions
fr: SSL_CTX_flush_sessions, SSL_flush_sessions - Supprimer les sessions expirées

note: type: textblock
en: SSL_CTX_flush_sessions() causes a run through the session cache of B<ctx> to remove sessions expired at time B<tm>.
fr: B<SSL_CTX_flush_sessions>() provoque un parcours du cache de sessions de I<ctx> pour supprimer les sessions expirées à l'instant I<tm>.

note: type: textblock
en: SSL_flush_sessions() is a synonym for SSL_CTX_flush_sessions().
fr: B<SSL_flush_sessions>() est un synonyme de B<SSL_CTX_flush_sessions>().

note: type: verbatim
en: If enabled, the internal session cache will collect all sessions established
    up to the specified maximum number (see SSL_CTX_sess_set_cache_size()).
    As sessions will not be reused ones they are expired, they should be
    removed from the cache to save resources. This can either be done
     automatically whenever 255 new sessions were established (see
    L<SSL_CTX_set_session_cache_mode(3)|SSL_CTX_set_session_cache_mode(3)>)
    or manually by calling SSL_CTX_flush_sessions().
fr: Si activé, le cache de sessions internes collectera toutes les sessions 
    établies jusqu'au nombre maximal indiqué (consultez
    B<SSL_CTX_sess_set_cache_size>()). Comme les sessions ne seront pas
    réutilisées une fois expirées, elles devront être supprimées du cache
    pour préserver les ressources. Cela peut être fait soit automatiquement
    à chaque fois que 255 nouvelles sessions ont été établies (consultez
    L<B<SSL_CTX_set_session_cache_mode>(3)|SSL_CTX_set_session_cache_mode(3)>),
    soit directement en appelant B<SSL_CTX_flush_sessions>().

note: type: textblock
en: The parameter B<tm> specifies the time which should be used for the expiration test, in most cases the actual time given by time(0)  will be used.
fr: Le paramètre I<tm> indique l'instant qui devrait être utilisé pour le test d'expiration, dans la plupart des cas le temps réel donné par time(0) sera utilisée.

note: type: textblock
en: SSL_CTX_flush_sessions() will only check sessions stored in the internal cache. When a session is found and removed, the remove_session_cb is however called to synchronize with the external cache (see L<SSL_CTX_sess_set_get_cb(3)|SSL_CTX_sess_set_get_cb(3)>).
fr: B<SSL_CTX_flush_sessions>() ne vérifie que les sessions stockées dans le cache interne. Quand une session est trouvée et supprimée, le remove_session_cb est tout de même appelé pour synchronisation avec le cache externe (consultez L<B<SSL_CTX_sess_set_get_cb>(3)|SSL_CTX_sess_set_get_cb(3)>).

note: type: textblock
en: L<ssl(3)|ssl(3)>, L<SSL_CTX_set_session_cache_mode(3)|SSL_CTX_set_session_cache_mode(3)>, L<SSL_CTX_set_timeout(3)|SSL_CTX_set_timeout(3)>, L<SSL_CTX_sess_set_get_cb(3)|SSL_CTX_sess_set_get_cb(3)>
fr: L<B<ssl>(3)|ssl(3)>, L<B<SSL_CTX_set_session_cache_mode>(3)|SSL_CTX_set_session_cache_mode(3)>, L<B<SSL_CTX_set_timeout>(3)|SSL_CTX_set_timeout(3)>, L<B<SSL_CTX_sess_set_get_cb>(3)|SSL_CTX_sess_set_get_cb(3)>

note: type: textblock
en: SSL_CTX_free - free an allocated SSL_CTX object
fr: SSL_CTX_free - Libérer un objet SSL_CTX alloué

note: type: textblock
en: SSL_CTX_free() decrements the reference count of B<ctx>, and removes the SSL_CTX object pointed to by B<ctx> and frees up the allocated memory if the the reference count has reached 0.
fr: B<SSL_CTX_free>() décrémente le compteur de références de I<ctx>, supprime l'objet B<SSL_CTX> pointé par I<ctx> et libère la mémoire allouée si le compteur de références a atteint B<0>.

note: type: textblock
en: It also calls the free()ing procedures for indirectly affected items, if applicable: the session cache, the list of ciphers, the list of Client CAs, the certificates and keys.
fr: Elle appelle aussi les procédures de libération (B<free>()) pour les éléments affectés indirectement, le cas échéant : le cache de sessions, la liste d'algorithmes, la liste des autorités de certification clientes, les certificats et les clefs.

note: type: =head1
en: WARNINGS
fr: AVERTISSEMENTS

note: type: textblock
en: If a session-remove callback is set (SSL_CTX_sess_set_remove_cb()), this callback will be called for each session being freed from B<ctx>'s session cache. This implies, that all corresponding sessions from an external session cache are removed as well. If this is not desired, the user should explicitly unset the callback by calling SSL_CTX_sess_set_remove_cb(B<ctx>, NULL) prior to calling SSL_CTX_free().
fr: Si un rappel de suppression de session est défini (B<SSL_CTX_sess_set_remove_cb>()), ce rappel sera appelé pour chaque session en train d'être libérée du cache de sessions de I<ctx>. Cela implique que toutes les sessions correspondantes d'un cache de sessions externes sont aussi supprimées. Si ce n'est pas voulu, l'utilisateur devrait libérer explicitement le rappel en appelant B<SSL_CTX_sess_set_remove_cb(>I<ctx>B<, NULL)> avant d'appeler B<SSL_CTX_free>().

note: type: textblock
en: SSL_CTX_free() does not provide diagnostic information.
fr: B<SSL_CTX_free>() ne fournit pas de renseignements de diagnostique.

note: type: textblock
en: L<SSL_CTX_new(3)|SSL_CTX_new(3)>, L<ssl(3)|ssl(3)>, L<SSL_CTX_sess_set_get_cb(3)|SSL_CTX_sess_set_get_cb(3)>
fr: L<B<SSL_CTX_new>(3)|SSL_CTX_new(3)>, L<B<ssl>(3)|ssl(3)>, L<B<SSL_CTX_sess_set_get_cb>(3)|SSL_CTX_sess_set_get_cb(3)>

note: type: textblock
en: SSL_CTX_get_ex_new_index, SSL_CTX_set_ex_data, SSL_CTX_get_ex_data - internal application specific data functions
fr: SSL_CTX_get_ex_new_index, SSL_CTX_set_ex_data, SSL_CTX_get_ex_data - Fonctions internes pour données spécifiques aux applications

note: type: textblock
en: Several OpenSSL structures can have application specific data attached to them.  These functions are used internally by OpenSSL to manipulate application specific data attached to a specific structure.
fr: Plusieurs structures OpenSSL peuvent avoir des données spécifiques aux applications attachées. Ces fonctions sont utilisées en interne par OpenSSL pour manipuler des données spécifiques aux applications attachées aux structures.

note: type: textblock
en: SSL_CTX_get_ex_new_index() is used to register a new index for application specific data.
fr: B<SSL_CTX_get_ex_new_index>() est utilisée pour enregistrer un nouvel indice de données spécifiques aux applications.

note: type: textblock
en: SSL_CTX_set_ex_data() is used to store application data at B<arg> for B<idx> into the B<ctx> object.
fr: B<SSL_CTX_set_ex_data>() est utilisée pour enregistrer des données d'applications en I<arg> pour I<idx> dans l'objet I<ctx>.

note: type: textblock
en: SSL_CTX_get_ex_data() is used to retrieve the information for B<idx> from B<ctx>.
fr: B<SSL_CTX_get_ex_data>() est utilisée pour récupérer les informations pour I<idx> de I<ctx>.

note: type: textblock
en: A detailed description for the B<*_get_ex_new_index()> functionality can be found in L<RSA_get_ex_new_index(3)|RSA_get_ex_new_index(3)>.  The B<*_get_ex_data()> and B<*_set_ex_data()> functionality is described in L<CRYPTO_set_ex_data(3)|CRYPTO_set_ex_data(3)>.
fr: Une description détaillée de la fonctionnalité B<*_get_ex_new_index>() est disponible dans L<B<RSA_get_ex_new_index>(3)|RSA_get_ex_new_index(3)>. Les fonctionnalités B<*_get_ex_data>() et B<*_set_ex_data>() sont décrites dans L<B<CRYPTO_set_ex_data>(3)|CRYPTO_set_ex_data(3)>.

note: type: textblock
en: L<ssl(3)|ssl(3)>, L<RSA_get_ex_new_index(3)|RSA_get_ex_new_index(3)>, L<CRYPTO_set_ex_data(3)|CRYPTO_set_ex_data(3)>
fr: L<B<ssl>(3)|ssl(3)>, L<B<RSA_get_ex_new_index>(3)|RSA_get_ex_new_index(3)>, L<B<CRYPTO_set_ex_data>(3)|CRYPTO_set_ex_data(3)>

note: type: textblock
en: SSL_CTX_get_verify_mode, SSL_get_verify_mode, SSL_CTX_get_verify_depth, SSL_get_verify_depth, SSL_get_verify_callback, SSL_CTX_get_verify_callback - get currently set verification parameters
fr: SSL_CTX_get_verify_mode, SSL_get_verify_mode, SSL_CTX_get_verify_depth, SSL_get_verify_depth, SSL_get_verify_callback, SSL_CTX_get_verify_callback - Obtenir les paramètres de vérification actuellement définis

note: type: textblock
en: SSL_CTX_get_verify_mode() returns the verification mode currently set in B<ctx>.
fr: B<SSL_CTX_get_verify_mode>() renvoie le mode de vérification actuellement défini dans I<ctx>.

note: type: textblock
en: SSL_get_verify_mode() returns the verification mode currently set in B<ssl>.
fr: B<SSL_get_verify_mode>() renvoie le mode de vérification actuellement défini dans I<ssl>.

note: type: textblock
en: SSL_CTX_get_verify_depth() returns the verification depth limit currently set in B<ctx>. If no limit has been explicitly set, -1 is returned and the default value will be used.
fr: B<SSL_CTX_get_verify_depth>() renvoie la limite de profondeur de vérification actuellement définie dans I<ctx>. Si aucune limite n'a été définie explicitement, B<-1> est renvoyé et la valeur par défaut sera utilisée.

note: type: textblock
en: SSL_get_verify_depth() returns the verification depth limit currently set in B<ssl>. If no limit has been explicitly set, -1 is returned and the default value will be used.
fr: B<SSL_get_verify_depth>() renvoie la limite de profondeur de vérification actuellement définie dans I<ssl>. Si aucune limite n'a été définie explicitement, B<-1> est renvoyé et la valeur par défaut sera utilisée.

note: type: textblock
en: SSL_CTX_get_verify_callback() returns a function pointer to the verification callback currently set in B<ctx>. If no callback was explicitly set, the NULL pointer is returned and the default callback will be used.
fr: B<SSL_CTX_get_verify_callback>() renvoie un pointeur de fonction vers le rappel de vérification actuellement défini dans I<ctx>. Si aucun rappel n'a été défini explicitement, le pointeur NULL est renvoyé et le rappel par défaut sera utilisé.

note: type: textblock
en: SSL_get_verify_callback() returns a function pointer to the verification callback currently set in B<ssl>. If no callback was explicitly set, the NULL pointer is returned and the default callback will be used.
fr: B<SSL_get_verify_callback>() renvoie un pointeur de fonction vers le rappel de vérification actuellement défini dans I<ssl>. Si aucun rappel n'a été défini explicitement, le pointeur NULL est renvoyé et le rappel par défaut sera utilisé.

note: type: textblock
en: See DESCRIPTION
fr: Consultez la section B<DESCRIPTION>

note: type: textblock
en: L<ssl(3)|ssl(3)>, L<SSL_CTX_set_verify(3)|SSL_CTX_set_verify(3)>
fr: L<B<ssl>(3)|ssl(3)>, L<B<SSL_CTX_set_verify>(3)|SSL_CTX_set_verify(3)>

note: type: textblock
en: SSL_CTX_load_verify_locations - set default locations for trusted CA certificates
fr: SSL_CTX_load_verify_locations - Définir l'emplacement par défaut des certificats d'autorité de certification

note: type: textblock
en: SSL_CTX_load_verify_locations() specifies the locations for B<ctx>, at which CA certificates for verification purposes are located. The certificates available via B<CAfile> and B<CApath> are trusted.
fr: B<SSL_CTX_load_verify_locations>() précise l'emplacement pour I<ctx> où les certificats d'autorité, aux fins de vérifications, sont situés. Les certificats disponibles par B<CAfile> et B<CApath> sont considérés de confiance.

note: type: textblock
en: If B<CAfile> is not NULL, it points to a file of CA certificates in PEM format. The file can contain several CA certificates identified by
fr: Si B<CAfile> n'est pas NULL, il pointe vers un fichier de certificats d'autorité de certification au format PEM. Le fichier peut contenir plusieurs certificats d'autorité de certification identifiés par des séquences

note: type: verbatim
en:  -----BEGIN CERTIFICATE-----
     ... (CA certificate in base64 encoding) ...
     -----END CERTIFICATE-----
fr:  -----BEGIN CERTIFICATE-----
     ... (CA certificate codé en base64) ...
     -----END CERTIFICATE-----

note: type: textblock
en: sequences. Before, between, and after the certificates text is allowed which can be used e.g. for descriptions of the certificates.
fr: Avant, entre et après les certificats, il peut y avoir un texte qui peut, par exemple, décrire les certificats.

note: type: textblock
en: The B<CAfile> is processed on execution of the SSL_CTX_load_verify_locations()  function.
fr: B<CAfile> est traité lors de l'exécution de la fonction B<SSL_CTX_load_verify_locations>()

note: type: textblock
en: If B<CApath> is not NULL, it points to a directory containing CA certificates in PEM format. The files each contain one CA certificate. The files are looked up by the CA subject name hash value, which must hence be available.  If more than one CA certificate with the same name hash value exist, the extension must be different (e.g. 9d66eef0.0, 9d66eef0.1 etc). The search is performed in the ordering of the extension number, regardless of other properties of the certificates.  Use the B<c_rehash> utility to create the necessary links.
fr: Si B<CApath> n'est pas NULL, il pointe vers un répertoire contenant des certificats d'autorité de certification au format PEM. Chaque fichier contient un certificat d'autorité de certification. La recherche de ces fichiers s'effectue par la valeur de hachage de nom du sujet de l'autorité de certification, qui doit donc être disponible. Si plusieurs certificats d'autorité de certification ont la même valeur de hachage de nom, leur extension peut être différente (par exemple 9d66eef0.0, 9d66eef0.1, etc.). La recherche est faite dans l'ordre des numéros d'extension, indépendamment des autres propriétés des certificats. Utilisez l'utilitaire B<c_rehash> pour créer les liens nécessaires.

note: type: textblock
en: The certificates in B<CApath> are only looked up when required, e.g. when building the certificate chain or when actually performing the verification of a peer certificate.
fr: Les certificats dans B<CApath> ne sont consultés que lorsqu'il le faut, par exemple lors de la construction d'une chaîne de certificats ou lorsque l'on vérifie effectivement le certificat d'un interlocuteur.

note: type: textblock
en: When looking up CA certificates, the OpenSSL library will first search the certificates in B<CAfile>, then those in B<CApath>. Certificate matching is done based on the subject name, the key identifier (if present), and the serial number as taken from the certificate to be verified. If these data do not match, the next certificate will be tried. If a first certificate matching the parameters is found, the verification process will be performed; no other certificates for the same parameters will be searched in case of failure.
fr: Quand on recherche des certificats d'autorité de certification, la bibliothèque OpenSSL cherchera les certificats d’abord dans B<CAfile> puis dans B<CApath>. La correspondance du certificat est établie sur la base du nom du sujet, de la clef d’identification (si elle existe) et du numéro de série du certificat à vérifier. Si ces données ne correspondent pas, le certificat suivant est testé. Si un premier certificat dont les paramètres correspondent est trouvé, le processus de vérification est exécuté et aucun autre certificat avec les mêmes paramètres ne sera recherché en cas d'échec.

note: type: textblock
en: In server mode, when requesting a client certificate, the server must send the list of CAs of which it will accept client certificates. This list is not influenced by the contents of B<CAfile> or B<CApath> and must explicitly be set using the L<SSL_CTX_set_client_CA_list(3)|SSL_CTX_set_client_CA_list(3)> family of functions.
fr: En mode serveur, quand un certificat client est demandé, le serveur doit envoyer la liste des autorités de certification dont il accepte les certificats. Cette liste n'est pas déterminée par le contenu de B<CAfile> ou B<CApath> et doit être être configurée avec la famille de fonctions L<B<SSL_CTX_set_client_CA_list>(3)|SSL_CTX_set_client_CA_list(3)>.

note: type: textblock
en: When building its own certificate chain, an OpenSSL client/server will try to fill in missing certificates from B<CAfile>/B<CApath>, if the certificate chain was not explicitly specified (see L<SSL_CTX_add_extra_chain_cert(3)|SSL_CTX_add_extra_chain_cert(3)>, L<SSL_CTX_use_certificate(3)|SSL_CTX_use_certificate(3)>.
fr: Lors de la construction de sa chaîne de certificats, un client ou serveur OpenSSL essaiera de combler les certificats manquants à partir de B<CAfile> ou de B<CApath>, si la chaîne de certificats n'est pas précisée (voir L<B<SSL_CTX_add_extra_chain_cert>(3)|SSL_CTX_add_extra_chain_cert(3)>, L<B<SSL_CTX_use_certificate>(3)|SSL_CTX_use_certificate(3)>.

note: type: textblock
en: If several CA certificates matching the name, key identifier, and serial number condition are available, only the first one will be examined. This may lead to unexpected results if the same CA certificate is available with different expiration dates. If a "certificate expired" verification error occurs, no other certificate will be searched. Make sure to not have expired certificates mixed with valid ones.
fr: Si plusieurs certificats d'autorité de certification correspondant au nom, à la clef d’identification et au numéro de série sont disponibles, seul le premier sera examiné. Cela peut entraîner des résultats inattendus si le même certificat d'autorité de certification est disponible avec plusieurs dates d'expiration différentes. Si une erreur de vérification « certificate expired » survient, aucun autre certificat ne sera recherché. Assurez-vous de ne pas avoir de certificats expirés mêlés à des certificats valides.

note: type: =head1
en: EXAMPLES
fr: EXEMPLES

note: type: textblock
en: Generate a CA certificate file with descriptive text from the CA certificates ca1.pem ca2.pem ca3.pem:
fr: Générer un fichier de certificat d'autorité de certification avec un texte descriptif à partir des certificats d'autorité de certification ca1.pem ca2.pem ca3.pem :

note: type: textblock
en: Prepare the directory /some/where/certs containing several CA certificates for use as B<CApath>:
fr: Préparer le répertoire /quelque/part/certificats contenant plusieurs certificats d'autorité de certification à définir comme B<CApath> :

note: type: verbatim
en:  cd /some/where/certs
     c_rehash .
fr:  cd /quelque/part/certificats
     c_rehash .

note: type: textblock
en: The following return values can occur:
fr: Les valeurs suivantes peuvent être renvoyées :

note: type: textblock
en: The operation failed because B<CAfile> and B<CApath> are NULL or the processing at one of the locations specified failed. Check the error stack to find out the reason.
fr: L'opération a échoué parce que B<CAfile> et B<CApath> sont NULL ou le traitement d'un des emplacements spécifié a échoué. Vérifiez la pile d'erreur pour découvrir la raison.

note: type: textblock
en: The operation succeeded.
fr: L'opération a réussi.

note: type: textblock
en: L<ssl(3)|ssl(3)>, L<SSL_CTX_set_client_CA_list(3)|SSL_CTX_set_client_CA_list(3)>, L<SSL_get_client_CA_list(3)|SSL_get_client_CA_list(3)>, L<SSL_CTX_use_certificate(3)|SSL_CTX_use_certificate(3)>, L<SSL_CTX_add_extra_chain_cert(3)|SSL_CTX_add_extra_chain_cert(3)>, L<SSL_CTX_set_cert_store(3)|SSL_CTX_set_cert_store(3)>
fr: L<B<ssl>(3)|ssl(3)>, L<B<SSL_CTX_set_client_CA_list>(3)|SSL_CTX_set_client_CA_list(3)>, L<B<SSL_get_client_CA_list>(3)|SSL_get_client_CA_list(3)>, L<B<SSL_CTX_use_certificate>(3)|SSL_CTX_use_certificate(3)>, L<B<SSL_CTX_add_extra_chain_cert>(3)|SSL_CTX_add_extra_chain_cert(3)>, L<B<SSL_CTX_set_cert_store>(3)|SSL_CTX_set_cert_store(3)>

note: type: textblock
en: SSL_CTX_new - create a new SSL_CTX object as framework for TLS/SSL enabled functions
fr: SSL_CTX_new - Créer un nouvel objet B<SSL_CTX> comme cadre pour les fonctions avec TLS/SSL actif.

note: type: textblock
en: SSL_CTX_new() creates a new B<SSL_CTX> object as framework to establish TLS/SSL enabled connections.
fr: B<SSL_CTX_new>() crée un nouvel objet B<SSL_CTX> comme cadre pour établir des connexions avec TLS/SSL actif.

note: type: textblock
en: The SSL_CTX object uses B<method> as connection method. The methods exist in a generic type (for client and server use), a server only type, and a client only type. B<method> can be of the following types:
fr: L'objet B<SSL_CTX> utilise I<method> comme méthode de connexion. Il existe des méthodes de type générique (pour utilisation client et serveur), un type uniquement serveur et un type uniquement client.I<method> peut appartenir aux types suivants :

note: type: textblock
en: A TLS/SSL connection established with these methods will only understand the SSLv2 protocol. A client will send out SSLv2 client hello messages and will also indicate that it only understand SSLv2. A server will only understand SSLv2 client hello messages.
fr: Une connexion TLS/SSL établie avec ces méthodes ne comprendra que le protocole SSLv2. Un client enverra des messages hello client SSLv2 et indiquera qu'il ne comprend que SSLv2. Un serveur ne comprendra que les messages hello du client SSLv2.

note: type: textblock
en: A TLS/SSL connection established with these methods will only understand the SSLv3 protocol. A client will send out SSLv3 client hello messages and will indicate that it only understands SSLv3. A server will only understand SSLv3 client hello messages. This especially means, that it will not understand SSLv2 client hello messages which are widely used for compatibility reasons, see SSLv23_*_method().
fr: Un connexion TLS/SSL établie avec ces méthodes ne comprendra que le protocole SSLv3. Un client enverra des messages hello client SSLv3 et indiquera qu'il ne comprend que SSLv3. Un serveur ne comprendra que les messages hello client SSLv3. Cela veut surtout dire qu'il ne comprendra pas les messages hello client SSLv2 qui sont couramment utilisés pour des raisons de compatibilité. Voir B<SSLv23_*_method>().

note: type: textblock
en: A TLS/SSL connection established with these methods will only understand the TLSv1 protocol. A client will send out TLSv1 client hello messages and will indicate that it only understands TLSv1. A server will only understand TLSv1 client hello messages. This especially means, that it will not understand SSLv2 client hello messages which are widely used for compatibility reasons, see SSLv23_*_method(). It will also not understand SSLv3 client hello messages.
fr: Une connexion  TLS/SSL établie avec ces méthodes ne comprendra que le protocole TLSv1. Un client enverra des messages hello TLSv1 et indiquera qu'il ne comprend que TLSv1. Un serveur ne comprendra que les messages hello client TLSv1. Cela veut surtout dire qu'il ne comprendra pas les messages hello client SSLv2 qui sont couramment utilisés pour des raisons de compatibilité. Voir B<SSLv23_*_method>(). Il ne comprendra pas non plus les messages hello client SSLv3.

note: type: textblock
en: A TLS/SSL connection established with these methods may understand the SSLv2, SSLv3, TLSv1, TLSv1.1 and TLSv1.2 protocols.
fr: Une connexion TLS/SSL établie avec ces méthodes peut comprendre les protocoles SSLv2, SSLv3, TLSv1, TLSv1.1 et TLSv1.2

note: type: textblock
en: If the cipher list does not contain any SSLv2 ciphersuites (the default cipher list does not) or extensions are required (for example server name)  a client will send out TLSv1 client hello messages including extensions and will indicate that it also understands TLSv1.1, TLSv1.2 and permits a fallback to SSLv3. A server will support SSLv3, TLSv1, TLSv1.1 and TLSv1.2 protocols. This is the best choice when compatibility is a concern.
fr: Si la liste de chiffrements ne contient pas d’ensemble de chiffrements SSLv2 (la liste par défaut de chiffrements n'existe pas), ou si des extensions sont nécessaires (par exemple le nom de serveur), un client enverra des messages hello client TLSv1 incluant des extensions et indiquera qu'il comprend aussi TLSv1.1, TLSv1.2 et permettra de se rabattre sur SSLv3. Un serveur gérera les protocoles SSLv3, TLSv1, TLSv1.1 et TLSv1.2. C'est le meilleur choix s'il y a un souci de compatibilité.

note: type: textblock
en: If any SSLv2 ciphersuites are included in the cipher list and no extensions are required then SSLv2 compatible client hellos will be used by clients and SSLv2 will be accepted by servers. This is B<not> recommended due to the insecurity of SSLv2 and the limited nature of the SSLv2 client hello prohibiting the use of extensions.
fr: S'il existe des ensembles de chiffrement SSLv2 dans la liste de chiffrements, et si aucune extension n'est nécessaire, les clients utiliseront des hellos compatibles SSLv2, et SSLv2 sera accepté par les serveurs. Cela n'est B<pas> recommandé en raison du caractère non sécurisé de SSLv2 et de la nature limitée du hello client SSLv2 qui interdit l'utilisation d'extensions.

note: type: textblock
en: The list of protocols available can later be limited using the SSL_OP_NO_SSLv2, SSL_OP_NO_SSLv3, SSL_OP_NO_TLSv1, SSL_OP_NO_TLSv1_1 and SSL_OP_NO_TLSv1_2 options of the SSL_CTX_set_options() or SSL_set_options() functions.  Using these options it is possible to choose e.g. SSLv23_server_method() and be able to negotiate with all possible clients, but to only allow newer protocols like TLSv1, TLSv1.1 or TLS v1.2.
fr: La liste des protocoles disponibles peut être ultérieurement limitée en utilisant les options B<SSL_OP_NO_SSLv2>, B<SSL_OP_NO_SSLv3>, B<SSL_OP_NO_TLSv1>, B<SSL_OP_NO_TLSv1_1> et B<SSL_OP_NO_TLSv1_2> des fonctions B<SSL_CTX_set_options>() ou B<SSL_set_options>(). Avec ces options, il est possible de choisir B<SSLv23_server_method>() par exemple et de pouvoir négocier avec tous les clients possibles, mais de n'autoriser que les protocoles les plus récents comme TLSv1, TLSv1.1 ou TLS v1.2.

note: type: textblock
en: Applications which never want to support SSLv2 (even is the cipher string is configured to use SSLv2 ciphersuites) can set SSL_OP_NO_SSLv2.
fr: Des applications qui ne veulent jamais prendre en charge SSLv2 (même si la chaîne de chiffrements est configurée pour utiliser les ensembles de chiffrement SSLv2) peuvent utiliser l'option B<SSL_OP_NO_SSLv2>.

note: type: textblock
en: SSL_CTX_new() initializes the list of ciphers, the session cache setting, the callbacks, the keys and certificates and the options to its default values.
fr: B<SSL_CTX_new>() initialise la liste de chiffrements, la configuration du cache de sessions, le rappel, les clés et les certificats, ainsi que les options de ses valeurs par défaut.

note: type: textblock
en: The creation of a new SSL_CTX object failed. Check the error stack to find out the reason.
fr: La création d'un nouvel objet B<SSL_CTX> a échoué. Vérifiez la pile d'erreur pour découvrir la raison de l'échec.

note: type: =item
en: Pointer to an SSL_CTX object
fr: Pointeur vers un objet B<SSL_CTX>

note: type: textblock
en: The return value points to an allocated SSL_CTX object.
fr: La valeur renvoyée pointe vers un objet B<SSL_CTX> alloué.

note: type: textblock
en: L<SSL_CTX_free(3)|SSL_CTX_free(3)>, L<SSL_accept(3)|SSL_accept(3)>, L<ssl(3)|ssl(3)>, L<SSL_set_connect_state(3)|SSL_set_connect_state(3)>
fr: L<B<SSL_CTX_free>(3)|SSL_CTX_free(3)>, L<B<SSL_accept>(3)|SSL_accept(3)>,L<B<ssl>(3)|ssl(3)>, L<B<SSL_set_connect_state>(3)|SSL_set_connect_state(3)>

note: type: textblock
en: SSL_CTX_sess_number, SSL_CTX_sess_connect, SSL_CTX_sess_connect_good, SSL_CTX_sess_connect_renegotiate, SSL_CTX_sess_accept, SSL_CTX_sess_accept_good, SSL_CTX_sess_accept_renegotiate, SSL_CTX_sess_hits, SSL_CTX_sess_cb_hits, SSL_CTX_sess_misses, SSL_CTX_sess_timeouts, SSL_CTX_sess_cache_full - obtain session cache statistics
fr: SSL_CTX_sess_number, SSL_CTX_sess_connect, SSL_CTX_sess_connect_good, SSL_CTX_sess_connect_renegotiate, SSL_CTX_sess_accept, SSL_CTX_sess_accept_good, SSL_CTX_sess_accept_renegotiate, SSL_CTX_sess_hits, SSL_CTX_sess_cb_hits, SSL_CTX_sess_misses, SSL_CTX_sess_timeouts, SSL_CTX_sess_cache_full - Obtenir des statistiques du cache de sessions

note: type: textblock
en: SSL_CTX_sess_number() returns the current number of sessions in the internal session cache.
fr: B<SSL_CTX_sess_number>() renvoie le nombre actuel de sessions dans le cache de sessions interne.

note: type: textblock
en: SSL_CTX_sess_connect() returns the number of started SSL/TLS handshakes in client mode.
fr: B<SSL_CTX_sess_connect>() renvoie le nombre actuel d'initialisations de connexion SSL/TLS démarrées en mode client.

note: type: textblock
en: SSL_CTX_sess_connect_good() returns the number of successfully established SSL/TLS sessions in client mode.
fr: B<SSL_CTX_sess_connect_good>() renvoie le nombre de sessions SSL/TLS établies avec succès en mode client.

note: type: textblock
en: SSL_CTX_sess_connect_renegotiate() returns the number of start renegotiations in client mode.
fr: B<SSL_CTX_sess_connect_renegotiate>() renvoie le nombre de renégociations démarrées en mode client.

note: type: textblock
en: SSL_CTX_sess_accept() returns the number of started SSL/TLS handshakes in server mode.
fr: B<SSL_CTX_sess_accept>() renvoie le nombre d'initialisations de connexion SSL/TLS démarrées en mode serveur.

note: type: textblock
en: SSL_CTX_sess_accept_good() returns the number of successfully established SSL/TLS sessions in server mode.
fr: B<SSL_CTX_sess_accept_good>() renvoie le nombre de sessions SSL/TLS établies avec succès en mode serveur.

note: type: textblock
en: SSL_CTX_sess_accept_renegotiate() returns the number of start renegotiations in server mode.
fr: B<SSL_CTX_sess_accept_renegotiate>() renvoie le nombre de renégociations démarrées en mode serveur.

note: type: textblock
en: SSL_CTX_sess_hits() returns the number of successfully reused sessions.  In client mode a session set with L<SSL_set_session(3)|SSL_set_session(3)> successfully reused is counted as a hit. In server mode a session successfully retrieved from internal or external cache is counted as a hit.
fr: B<SSL_CTX_sess_hits>() renvoie le nombre de sessions réutilisées avec succès. En mode client, une session configurée avec L<B<SSL_set_session>(3)|SSL_set_session(3)>, réutilisée, est comptée. En mode serveur, une session récupérée du cache externe ou interne est comptée.

note: type: textblock
en: SSL_CTX_sess_cb_hits() returns the number of successfully retrieved sessions from the external session cache in server mode.
fr: B<SSL_CTX_sess_cb_hits>() renvoie le nombre des sessions récupérées avec succès à partir du cache de sessions externe en mode serveur.

note: type: textblock
en: SSL_CTX_sess_misses() returns the number of sessions proposed by clients that were not found in the internal session cache in server mode.
fr: B<SSL_CTX_sess_misses>() renvoie le nombre de sessions proposées par les clients qui n'ont pas été trouvées dans le cache de sessions interne en mode serveur.

note: type: verbatim
en: SSL_CTX_sess_timeouts() returns the number of sessions proposed by clients
    and either found in the internal or external session cache in server mode,
     but that were invalid due to timeout. These sessions are not included in
    the SSL_CTX_sess_hits() count.
fr: B<SSL_CTX_sess_timeouts>() renvoie le nombre de sessions proposées par des
    clients et trouvées dans le cache de sessions interne ou externe en mode
    serveur, mais invalidées à cause du délai d'expiration. Ces sessions ne sont
    pas incluses dans le compte de B<SSL_CTX_sess_hits>().

note: type: textblock
en: SSL_CTX_sess_cache_full() returns the number of sessions that were removed because the maximum session cache size was exceeded.
fr: B<SSL_CTX_sess_cache_full>() renvoie le nombre de sessions qui ont été supprimées parce que la taille maximale du cache de sessions a été dépassée.

note: type: textblock
en: The functions return the values indicated in the DESCRIPTION section.
fr: Les fonctions renvoient les valeurs indiquées dans la partie DESCRIPTION.

note: type: textblock
en: L<ssl(3)|ssl(3)>, L<SSL_set_session(3)|SSL_set_session(3)>, L<SSL_CTX_set_session_cache_mode(3)|SSL_CTX_set_session_cache_mode(3)> L<SSL_CTX_sess_set_cache_size(3)|SSL_CTX_sess_set_cache_size(3)>
fr: L<B<ssl>(3)|ssl(3)>, L<B<SSL_set_session>(3)|SSL_set_session(3)>, L<B<SSL_CTX_set_session_cache_mode>(3)|SSL_CTX_set_session_cache_mode(3)> L<B<SSL_CTX_sess_set_cache_size>(3)|SSL_CTX_sess_set_cache_size(3)>

note: type: textblock
en: SSL_CTX_sess_set_cache_size, SSL_CTX_sess_get_cache_size - manipulate session cache size
fr: SSL_CTX_sess_set_cache_size, SSL_CTX_sess_get_cache_size - Manipuler la taille du cache de sessions

note: type: textblock
en: SSL_CTX_sess_set_cache_size() sets the size of the internal session cache of context B<ctx> to B<t>.  This value is a hint and not an absolute; see the notes below.
fr: B<SSL_CTX_sess_set_cache_size>() définit la taille du cache de sessions interne du contexte I<ctx> à I<t>. Cette valeur est un indice et non un nombre absolu ; voir la note ci-dessous.

note: type: textblock
en: SSL_CTX_sess_get_cache_size() returns the currently valid session cache size.
fr: B<SSL_CTX_sess_get_cache_size>() renvoie la taille du cache de sessions valable actuellement.

note: type: textblock
en: The internal session cache size is SSL_SESSION_CACHE_MAX_SIZE_DEFAULT, currently 1024*20, so that up to 20000 sessions can be held. This size can be modified using the SSL_CTX_sess_set_cache_size() call. A special case is the size 0, which is used for unlimited size.
fr: La taille du cache de sessions interne est SSL_SESSION_CACHE_MAX_SIZE_DEFAULT, soit 1024*20 en ce moment, de telle sorte que 20 000 sessions puissent être gérées. Cette taille peut être modifiée en utilisant l'appel B<SSL_CTX_sess_set_cache_size>(). Un cas particulier est la taille B<0>, qui est utilisée pour une taille illimitée.

note: type: textblock
en: If adding the session makes the cache exceed its size, then unused sessions are dropped from the end of the cache.  Cache space may also be reclaimed by calling L<SSL_CTX_flush_sessions(3)|SSL_CTX_flush_sessions(3)> to remove expired sessions.
fr: Si l'ajout d'une session fait que le cache dépasse sa taille, alors les sessions inutilisées sont supprimées à la fin du cache. De l'espace de cache peut être récupéré en appelant L<B<SSL_CTX_flush_sessions>(3)|SSL_CTX_flush_sessions(3)> pour supprimer des sessions expirées.

note: type: textblock
en: If the size of the session cache is reduced and more sessions are already in the session cache, old session will be removed at the next time a session shall be added. This removal is not synchronized with the expiration of sessions.
fr: Si la taille du cache de sessions est réduite alors que trop de sessions sont déjà dans le cache de sessions, une ancienne session sera supprimée la prochaine fois qu'une session sera ajoutée. Cette suppression n'est pas synchronisée avec l'expiration des sessions.

note: type: textblock
en: SSL_CTX_sess_set_cache_size() returns the previously valid size.
fr: B<SSL_CTX_sess_set_cache_size>() renvoie la taille valable précédente.

note: type: textblock
en: SSL_CTX_sess_get_cache_size() returns the currently valid size.
fr: B<SSL_CTX_sess_get_cache_size>() renvoie la taille valable actuellement.

note: type: textblock
en: L<ssl(3)|ssl(3)>, L<SSL_CTX_set_session_cache_mode(3)|SSL_CTX_set_session_cache_mode(3)>, L<SSL_CTX_sess_number(3)|SSL_CTX_sess_number(3)>, L<SSL_CTX_flush_sessions(3)|SSL_CTX_flush_sessions(3)>
fr: L<B<ssl>(3)|ssl(3)>, L<B<SSL_CTX_set_session_cache_mode>(3)|SSL_CTX_set_session_cache_mode(3)>, L<B<SSL_CTX_sess_number>(3)|SSL_CTX_sess_number(3)>, L<B<SSL_CTX_flush_sessions>(3)|SSL_CTX_flush_sessions(3)>

note: type: textblock
en: SSL_CTX_sess_set_new_cb, SSL_CTX_sess_set_remove_cb, SSL_CTX_sess_set_get_cb, SSL_CTX_sess_get_new_cb, SSL_CTX_sess_get_remove_cb, SSL_CTX_sess_get_get_cb - provide callback functions for server side external session caching
fr: SSL_CTX_sess_set_new_cb, SSL_CTX_sess_set_remove_cb, SSL_CTX_sess_set_get_cb, SSL_CTX_sess_get_new_cb, SSL_CTX_sess_get_remove_cb, SSL_CTX_sess_get_get_cb - Fournir des fonctions de rappel pour la mise en cache de sessions externe du côté serveur

note: type: textblock
en: SSL_CTX_sess_set_new_cb() sets the callback function, which is automatically called whenever a new session was negotiated.
fr: B<SSL_CTX_sess_set_new_cb>() configure la fonction de rappel qui est automatiquement appelée chaque fois qu'une nouvelle session a été négociée.

note: type: textblock
en: SSL_CTX_sess_set_remove_cb() sets the callback function, which is automatically called whenever a session is removed by the SSL engine, because it is considered faulty or the session has become obsolete because of exceeding the timeout value.
fr: B<SSL_CTX_sess_set_remove_cb>() configure la fonction de rappel qui est automatiquement appelée chaque fois qu'une session a été supprimée par le moteur SSL, parce qu'elle est considérée fautive ou parce que la session est devenue obsolète par dépassement de la valeur du délai d'expiration.

note: type: textblock
en: SSL_CTX_sess_set_get_cb() sets the callback function which is called, whenever a SSL/TLS client proposed to resume a session but the session could not be found in the internal session cache (see L<SSL_CTX_set_session_cache_mode(3)|SSL_CTX_set_session_cache_mode(3)>).  (SSL/TLS server only.)
fr: B<SSL_CTX_sess_set_get_cb>() configure la fonction de rappel qui est appelée chaque fois qu'un client SSL/TLS a proposé de reprendre une session mais qu'elle ne peut pas être trouvée dans le cache de sessions interne (voir L<B<SSL_CTX_set_session_cache_mode>(3)|SSL_CTX_set_session_cache_mode(3)>), (seulement pour les serveurs SSL/TLS)

note: type: textblock
en: SSL_CTX_sess_get_new_cb(), SSL_CTX_sess_get_remove_cb(), and SSL_CTX_sess_get_get_cb() allow to retrieve the function pointers of the provided callback functions. If a callback function has not been set, the NULL pointer is returned.
fr: B<SSL_CTX_sess_get_new_cb>(), B<SSL_CTX_sess_get_remove_cb>(), et B<SSL_CTX_sess_get_get_cb>() permettent de récupérer les pointeurs de fonction des fonctions de rappel fournies. Si une fonction de rappel n'a pas été configurée, le pointeur NULL est renvoyé.

note: type: textblock
en: In order to allow external session caching, synchronization with the internal session cache is realized via callback functions. Inside these callback functions, session can be saved to disk or put into a database using the L<d2i_SSL_SESSION(3)|d2i_SSL_SESSION(3)> interface.
fr: Afin de permettre la mise en cache externe de session, la synchronisation avec le cache interne de session est réalisée par les fonctions de rappel.Dans les fonctions de rappel, la session peut être sauvegardée sur le disque ou mise dans une base de données en utilisant l'interface L<B<d2i_SSL_SESSION>(3)|d2i_SSL_SESSION(3)>.

note: type: textblock
en: The new_session_cb() is called, whenever a new session has been negotiated and session caching is enabled (see L<SSL_CTX_set_session_cache_mode(3)|SSL_CTX_set_session_cache_mode(3)>).  The new_session_cb() is passed the B<ssl> connection and the ssl session B<sess>. If the callback returns B<0>, the session will be immediately removed again.
fr: La fonction B<new_session_cb>() est appelée chaque fois qu'une nouvelle session a été négociée et que la mise en cache de sessions est activée (voir L<B<SSL_CTX_set_session_cache_mode>(3)|SSL_CTX_set_session_cache_mode(3)>). La fonction B<new_session_cb>() est passée à la connexion I<ssl> et à la session SSL I<sess>. Si le rappel renvoie B<0>, la session sera à nouveau immédiatement supprimée.

note: type: textblock
en: The remove_session_cb() is called, whenever the SSL engine removes a session from the internal cache. This happens when the session is removed because it is expired or when a connection was not shutdown cleanly. It also happens for all sessions in the internal session cache when L<SSL_CTX_free(3)|SSL_CTX_free(3)> is called. The remove_session_cb() is passed the B<ctx> and the ssl session B<sess>. It does not provide any feedback.
fr: La fonction B<remove_session_cb>() est appelée chaque fois que le moteur SSL supprime une session du cache interne. Cela se produit quand la session est supprimée parce qu'elle est expirée ou quand une connexion n'a pas été fermée proprement. Cela arrive aussi pour toutes les sessions dans le cache de sessions interne lorsque L<B<SSL_CTX_free>(3)|SSL_CTX_free(3)> est appelée. La fonction B<remove_session_cb>() est passée à I<ctx> et à la session SSL I<sess>. Elle ne renvoie aucun message.

note: type: textblock
en: The get_session_cb() is only called on SSL/TLS servers with the session id proposed by the client. The get_session_cb() is always called, also when session caching was disabled. The get_session_cb() is passed the B<ssl> connection, the session id of length B<length> at the memory location B<data>. With the parameter B<copy> the callback can require the SSL engine to increment the reference count of the SSL_SESSION object, Normally the reference count is not incremented and therefore the session must not be explicitly freed with L<SSL_SESSION_free(3)|SSL_SESSION_free(3)>.
fr: La fonction B<get_session_cb>() est seulement appelée sur les serveurs SSL/TLS avec l'identifiant de session proposé par le client. La fonction B<get_session_cb>() est toujours appelée, même si la mise en cache de session a été désactivée. La fonction B<get_session_cb>() est passée à la connexion I<ssl>, l'identifiant de session de longueur I<length> à l'emplacement mémoire I<data>. Avec le paramètre I<copy> le rappel peut nécessiter que le moteur SSL incrémente le compteur de références de l'objet B<SSL_SESSION>. Normalement, le compteur de références n'est pas incrémenté et ainsi la session ne doit pas être explicitement libérée avec L<B<SSL_SESSION_free>(3)|SSL_SESSION_free(3)>.

note: type: textblock
en: L<ssl(3)|ssl(3)>, L<d2i_SSL_SESSION(3)|d2i_SSL_SESSION(3)>, L<SSL_CTX_set_session_cache_mode(3)|SSL_CTX_set_session_cache_mode(3)>, L<SSL_CTX_flush_sessions(3)|SSL_CTX_flush_sessions(3)>, L<SSL_SESSION_free(3)|SSL_SESSION_free(3)>, L<SSL_CTX_free(3)|SSL_CTX_free(3)>
fr: L<B<ssl>(3)|ssl(3)>, L<B<d2i_SSL_SESSION>(3)|d2i_SSL_SESSION(3)>, L<B<SSL_CTX_set_session_cache_mode>(3)|SSL_CTX_set_session_cache_mode(3)>, L<B<SSL_CTX_flush_sessions>(3)|SSL_CTX_flush_sessions(3)>, L<B<SSL_SESSION_free>(3)|SSL_SESSION_free(3)>, L<B<SSL_CTX_free>(3)|SSL_CTX_free(3)>

note: type: textblock
en: SSL_CTX_sessions - access internal session cache
fr: SSL_CTX_sessions - Accéder au cache interne de sessions

note: type: textblock
en: SSL_CTX_sessions() returns a pointer to the lhash databases containing the internal session cache for B<ctx>.
fr: B<SSL_CTX_sessions>() renvoie un pointeur vers les bases de données lhash contenant le cache interne de sessions pour I<ctx>.

note: type: textblock
en: The sessions in the internal session cache are kept in an L<lhash(3)|lhash(3)> type database. It is possible to directly access this database e.g. for searching. In parallel, the sessions form a linked list which is maintained separately from the L<lhash(3)|lhash(3)> operations, so that the database must not be modified directly but by using the L<SSL_CTX_add_session(3)|SSL_CTX_add_session(3)> family of functions.
fr: Les sessions du cache interne de sessions sont conservées dans une base de données de type L<B<lhash>(3)|lhash(3)>. Il est possible d'accéder directement à cette base de données, par exemple pour faire des recherches. En parallèle, les sessions forment une liste chaînée qui est maintenue indépendamment des opérations L<B<lhash>(3)|lhash(3)>, de telle sorte que la base de données n'a pas à être modifiée directement, mais en utilisant la famille de fonctions L<B<SSL_CTX_add_session>(3)|SSL_CTX_add_session(3)>.

note: type: textblock
en: L<ssl(3)|ssl(3)>, L<lhash(3)|lhash(3)>, L<SSL_CTX_add_session(3)|SSL_CTX_add_session(3)>, L<SSL_CTX_set_session_cache_mode(3)|SSL_CTX_set_session_cache_mode(3)>
fr: L<B<ssl>(3)|ssl(3)>, L<B<lhash>(3)|lhash(3)>, L<B<SSL_CTX_add_session>(3)|SSL_CTX_add_session(3)>, L<B<SSL_CTX_set_session_cache_mode>(3)|SSL_CTX_set_session_cache_mode(3)>

note: type: textblock
en: SSL_CTX_use_certificate, SSL_CTX_use_certificate_ASN1, SSL_CTX_use_certificate_file, SSL_use_certificate, SSL_use_certificate_ASN1, SSL_use_certificate_file, SSL_CTX_use_certificate_chain_file, SSL_CTX_use_PrivateKey, SSL_CTX_use_PrivateKey_ASN1, SSL_CTX_use_PrivateKey_file, SSL_CTX_use_RSAPrivateKey, SSL_CTX_use_RSAPrivateKey_ASN1, SSL_CTX_use_RSAPrivateKey_file, SSL_use_PrivateKey_file, SSL_use_PrivateKey_ASN1, SSL_use_PrivateKey, SSL_use_RSAPrivateKey, SSL_use_RSAPrivateKey_ASN1, SSL_use_RSAPrivateKey_file, SSL_CTX_check_private_key, SSL_check_private_key - load certificate and key data
fr: SSL_CTX_use_certificate, SSL_CTX_use_certificate_ASN1, SSL_CTX_use_certificate_file, SSL_use_certificate, SSL_use_certificate_ASN1, SSL_use_certificate_file, SSL_CTX_use_certificate_chain_file, SSL_CTX_use_PrivateKey, SSL_CTX_use_PrivateKey_ASN1, SSL_CTX_use_PrivateKey_file, SSL_CTX_use_RSAPrivateKey, SSL_CTX_use_RSAPrivateKey_ASN1, SSL_CTX_use_RSAPrivateKey_file, SSL_use_PrivateKey_file, SSL_use_PrivateKey_ASN1, SSL_use_PrivateKey, SSL_use_RSAPrivateKey, SSL_use_RSAPrivateKey_ASN1, SSL_use_RSAPrivateKey_file, SSL_CTX_check_private_key, SSL_check_private_key - Charger les données de certificat et de clé

note: type: textblock
en: These functions load the certificates and private keys into the SSL_CTX or SSL object, respectively.
fr: Ces fonctions chargent les certificats et les clés privés dans l'objet B<SSL_CTX> et l'objet B<SSL>, respectivement.

note: type: textblock
en: The SSL_CTX_* class of functions loads the certificates and keys into the SSL_CTX object B<ctx>. The information is passed to SSL objects B<ssl> created from B<ctx> with L<SSL_new(3)|SSL_new(3)> by copying, so that changes applied to B<ctx> do not propagate to already existing SSL objects.
fr: La classe de fonctions B<SSL_CTX_*> charge les certificats et les clés dans l'objet B<SSL_CTX>, I<ctx>. L'information est passée aux objets SSL I<ssl> créés à partir de I<ctx> avec L<B<SSL_new>(3)|SSL_new(3)> par copie, ainsi les changements portés à I<ctx> ne se propagent pas à des objets B<SSL> déjà existants.

note: type: textblock
en: The SSL_* class of functions only loads certificates and keys into a specific SSL object. The specific information is kept, when L<SSL_clear(3)|SSL_clear(3)> is called for this SSL object.
fr: La classe de fonctions B<SSL_*> charge seulement les certificats et les clés dans un objet SSL particulier. L'information particulière est conservée lorsque L<B<SSL_clear>(3)|SSL_clear(3)> est appelée pour cet objet SSL.

note: type: textblock
en: SSL_CTX_use_certificate() loads the certificate B<x> into B<ctx>, SSL_use_certificate() loads B<x> into B<ssl>. The rest of the certificates needed to form the complete certificate chain can be specified using the L<SSL_CTX_add_extra_chain_cert(3)|SSL_CTX_add_extra_chain_cert(3)> function.
fr: B<SSL_CTX_use_certificate>() charge le certificat I<x> dans I<ctx>, B<SSL_use_certificate>() charge I<x> dans I<ssl>. Le reste des certificats nécessaires pour former la chaîne complète de certificats peut être spécifié avec la fonction L<B<SSL_CTX_add_extra_chain_cert>(3)|SSL_CTX_add_extra_chain_cert(3)>.

note: type: textblock
en: SSL_CTX_use_certificate_ASN1() loads the ASN1 encoded certificate from the memory location B<d> (with length B<len>) into B<ctx>, SSL_use_certificate_ASN1() loads the ASN1 encoded certificate into B<ssl>.
fr: B<SSL_CTX_use_certificate_ASN1>() charge le certificat codé en ASN1 à partir de l'emplacement de mémoire I<d> (de longueur I<len>) dans I<ctx>, B<SSL_use_certificate_ASN1>() charge le certificat codé en ASN1 dans I<ssl>.

note: type: textblock
en: SSL_CTX_use_certificate_file() loads the first certificate stored in B<file> into B<ctx>. The formatting B<type> of the certificate must be specified from the known types SSL_FILETYPE_PEM, SSL_FILETYPE_ASN1.  SSL_use_certificate_file() loads the certificate from B<file> into B<ssl>.  See the NOTES section on why SSL_CTX_use_certificate_chain_file()  should be preferred.
fr: B<SSL_CTX_use_certificate_file>() charge le premier certificat stocké dans I<file> dans I<ctx>. Le format I<type> du certificat peut être précisé à partir des types connus SSL_FILETYPE_PEM, SSL_FILETYPE_ASN1. B<SSL_use_certificate_file>() charge le certificat de I<file> dans I<ssl>. Voir dans la partie NOTES pourquoi B<SSL_CTX_use_certificate_chain_file>() devrait être préférée.

note: type: textblock
en: SSL_CTX_use_certificate_chain_file() loads a certificate chain from B<file> into B<ctx>. The certificates must be in PEM format and must be sorted starting with the subject's certificate (actual client or server certificate), followed by intermediate CA certificates if applicable, and ending at the highest level (root) CA.  There is no corresponding function working on a single SSL object.
fr: B<SSL_CTX_use_certificate_chain_file>() charge une chaîne de certificats de I<file> dans I<ctx>. Les certificats peuvent être au format PEM et peuvent être triés d'abord en certificat du sujet (certificat du client ou du serveur réel), puis en certificats d'autorité de certification intermédiaires, le cas échéant, et pour finir en autorité de certification de plus haut niveau (racine). Il n'y a pas de fonction correspondante fonctionnant avec un objet SSL simple.

note: type: textblock
en: SSL_CTX_use_PrivateKey() adds B<pkey> as private key to B<ctx>.  SSL_CTX_use_RSAPrivateKey() adds the private key B<rsa> of type RSA to B<ctx>. SSL_use_PrivateKey() adds B<pkey> as private key to B<ssl>; SSL_use_RSAPrivateKey() adds B<rsa> as private key of type RSA to B<ssl>.  If a certificate has already been set and the private does not belong to the certificate an error is returned. To change a certificate, private key pair the new certificate needs to be set with SSL_use_certificate()  or SSL_CTX_use_certificate() before setting the private key with SSL_CTX_use_PrivateKey() or SSL_use_PrivateKey().
fr: B<SSL_CTX_use_PrivateKey>() ajoute I<pkey> comme clé privée à I<ctx>. B<SSL_CTX_use_RSAPrivateKey>() ajoute la clé privée I<rsa> de type RSA à I<ctx>. B<SSL_use_PrivateKey>() ajoute I<pkey> comme clé privée à I<ssl> ; B<SSL_use_RSAPrivateKey>() ajoute I<rsa> comme clé privée de type RSA à I<ssl>. Si un certificat a déjà été configuré et que la clé privée n'appartient pas au certificat, une erreur est renvoyée. Pour changer un certificat, apparier la clé privée, le nouveau certificat doit être configuré avec B<SSL_use_certificate>() ou B<SSL_CTX_use_certificate>() avant de configurer la clé privée avec B<SSL_CTX_use_PrivateKey>() ou B<SSL_use_PrivateKey>().

note: type: textblock
en: SSL_CTX_use_PrivateKey_ASN1() adds the private key of type B<pk> stored at memory location B<d> (length B<len>) to B<ctx>.  SSL_CTX_use_RSAPrivateKey_ASN1() adds the private key of type RSA stored at memory location B<d> (length B<len>) to B<ctx>.  SSL_use_PrivateKey_ASN1() and SSL_use_RSAPrivateKey_ASN1() add the private key to B<ssl>.
fr: B<SSL_CTX_use_PrivateKey_ASN1>() ajoute la clé privée de type I<pk> stockée à l'emplacement de mémoire I<d> (de longueur I<len>) à I<ctx>. B<SSL_CTX_use_RSAPrivateKey_ASN1>() ajoute la clé privée de type RSA stockée à l'emplacement de mémoire I<d> (de longueur I<len>) à I<ctx>. B<SSL_use_PrivateKey_ASN1>() et B<SSL_use_RSAPrivateKey_ASN1>() ajoute la clé privée à I<ssl>.

note: type: textblock
en: SSL_CTX_use_PrivateKey_file() adds the first private key found in B<file> to B<ctx>. The formatting B<type> of the certificate must be specified from the known types SSL_FILETYPE_PEM, SSL_FILETYPE_ASN1.  SSL_CTX_use_RSAPrivateKey_file() adds the first private RSA key found in B<file> to B<ctx>. SSL_use_PrivateKey_file() adds the first private key found in B<file> to B<ssl>; SSL_use_RSAPrivateKey_file() adds the first private RSA key found to B<ssl>.
fr: B<SSL_CTX_use_PrivateKey_file>() ajoute la première clé privée trouvée dans I<file> à I<ctx>. Le I<type> du format du certificat doit être indiqué à partir des types connus B<SSL_FILETYPE_PEM>, B<SSL_FILETYPE_ASN1>.B<SSL_CTX_use_RSAPrivateKey_file>() ajoute la première clé privée RSA trouvée dans I<file> à I<ctx>. B<SSL_use_PrivateKey_file>() ajoute la première clé privée trouvée dans I<file> à I<ssl> ; B<SSL_use_RSAPrivateKey_file>() ajoute la première clé privée RSA trouvée à I<ssl>.

note: type: textblock
en: SSL_CTX_check_private_key() checks the consistency of a private key with the corresponding certificate loaded into B<ctx>. If more than one key/certificate pair (RSA/DSA) is installed, the last item installed will be checked. If e.g. the last item was a RSA certificate or key, the RSA key/certificate pair will be checked. SSL_check_private_key() performs the same check for B<ssl>. If no key/certificate was explicitly added for this B<ssl>, the last item added into B<ctx> will be checked.
fr: B<SSL_CTX_check_private_key>() vérifie la cohérence d'une clé privée avec le certificat correspondant chargé dans I<ctx>. Si plus d'une paire clé/certificat (RSA/DSA) est installée, le dernier objet installé sera vérifié. Si, par exemple, le dernier objet est un certificat ou une clé RSA, la paire clé/certificat RSA sera vérifiée. B<SSL_check_private_key>() exécute la même vérification pour I<ssl>. Si aucune clé ou certificat n'ont été explicitement ajoutés pour ce I<ssl>, le dernier objet ajouté dans I<ctx> sera vérifié.

note: type: textblock
en: The internal certificate store of OpenSSL can hold several private key/certificate pairs at a time. The certificate used depends on the cipher selected, see also L<SSL_CTX_set_cipher_list(3)|SSL_CTX_set_cipher_list(3)>.
fr: Le stockage de certificats interne d'OpenSSL peut garder plusieurs paires de clefs ou de certificats à la fois. Le certificat utilisé dépend du chiffrement choisi, Consultez aussi L<B<SSL_CTX_set_cipher_list>(3)|SSL_CTX_set_cipher_list(3)>.

note: type: textblock
en: When reading certificates and private keys from file, files of type SSL_FILETYPE_ASN1 (also known as B<DER>, binary encoding) can only contain one certificate or private key, consequently SSL_CTX_use_certificate_chain_file() is only applicable to PEM formatting.  Files of type SSL_FILETYPE_PEM can contain more than one item.
fr: Lors de la lecture des certificats et des clés privés à partir d'un fichier, les fichiers de type B<SSL_FILETYPE_ASN1> (connu aussi sous le nom B<DER>, codé en binaire) peuvent seulement contenir un certificat ou une clé privée, en conséquence B<SSL_CTX_use_certificate_chain_file>() est seulement applicable au format PEM. Les fichiers de type B<SSL_FILETYPE_PEM> peuvent contenir plus d'un objet.

note: type: textblock
en: SSL_CTX_use_certificate_chain_file() adds the first certificate found in the file to the certificate store. The other certificates are added to the store of chain certificates using L<SSL_CTX_add1_chain_cert(3)|SSL_CTX_add1_chain_cert(3)>. Note: versions of OpenSSL before 1.0.2 only had a single certificate chain store for all certificate types, OpenSSL 1.0.2 and later have a separate chain store for each type. SSL_CTX_use_certificate_chain_file()  should be used instead of the SSL_CTX_use_certificate_file() function in order to allow the use of complete certificate chains even when no trusted CA storage is used or when the CA issuing the certificate shall not be added to the trusted CA storage.
fr: B<SSL_CTX_use_certificate_chain_file>() ajoute le premier certificat trouvé dans le fichier au stockage de certificats. Les autres certificats sont ajoutés au stockage de certificats de chaîne utilisant L<B<SSL_CTX_add_extra_chain_cert>(3)|SSL_CTX_add_extra_chain_cert(3)>. Note : les versions d'OpenSSL antérieures à 1.0.2 ont seulement un seul stockage de chaînes de certificats pour tous les types de certificat. OpenSSL 1.0.2 et suivantes ont un stockage de chaînes séparé pour chaque type. B<SSL_CTX_use_certificate_chain_file>() devrait être utilisée plutôt que la fonction B<SSL_CTX_use_certificate_file>() afin de permettre l'utilisation de chaînes complètes de certificats même quand un stockage d'autorités de certification non sûr est utilisé ou quand l'autorité de certification qui émet le certificat ne pourra pas être ajoutée au stockage d'autorités de certification de confiance.

note: type: textblock
en: If additional certificates are needed to complete the chain during the TLS negotiation, CA certificates are additionally looked up in the locations of trusted CA certificates, see L<SSL_CTX_load_verify_locations(3)|SSL_CTX_load_verify_locations(3)>.
fr: Si des certificats supplémentaires sont nécessaires pour terminer la chaîne complète de certificats lors de la négociation TLS, des certificats d'autorité de certification sont aussi recherchés dans les emplacements des certificats d'autorité de certification de confiance, voir L<B<SSL_CTX_load_verify_locations>(3)|SSL_CTX_load_verify_locations(3)>.

note: type: textblock
en: The private keys loaded from file can be encrypted. In order to successfully load encrypted keys, a function returning the passphrase must have been supplied, see L<SSL_CTX_set_default_passwd_cb(3)|SSL_CTX_set_default_passwd_cb(3)>.  (Certificate files might be encrypted as well from the technical point of view, it however does not make sense as the data in the certificate is considered public anyway.)
fr: Les clés privées chargées d'un fichier peuvent être chiffrées. Afin de charger avec succès des clés chiffrées, une fonction qui renvoie la phrase secrète peut avoir été fournie, voir L<B<SSL_CTX_set_default_passwd_cb>(3)|SSL_CTX_set_default_passwd_cb(3)>. (Les fichiers de certificats pourraient aussi bien être chiffrés d'un point de vue technique, toutefois, ce n'est pas logique dans la mesure où les données contenues par le certificat sont considérées comme publiques de toute façon.)

note: type: textblock
en: On success, the functions return 1.  Otherwise check out the error stack to find out the reason.
fr: En cas de réussite, les fonctions renvoient B<1>. Vérifiez la pile d'erreur pour découvrir la raison de l'échec sinon.

note: type: textblock
en: L<ssl(3)|ssl(3)>, L<SSL_new(3)|SSL_new(3)>, L<SSL_clear(3)|SSL_clear(3)>, L<SSL_CTX_load_verify_locations(3)|SSL_CTX_load_verify_locations(3)>, L<SSL_CTX_set_default_passwd_cb(3)|SSL_CTX_set_default_passwd_cb(3)>, L<SSL_CTX_set_cipher_list(3)|SSL_CTX_set_cipher_list(3)>, L<SSL_CTX_set_client_cert_cb(3)|SSL_CTX_set_client_cert_cb(3)>, L<SSL_CTX_add_extra_chain_cert(3)|SSL_CTX_add_extra_chain_cert(3)>
fr: L<B<ssl>(3)|ssl(3)>, L<B<SSL_new>(3)|SSL_new(3)>, L<B<SSL_clear>(3)|SSL_clear(3)>, L<B<SSL_CTX_load_verify_locations>(3)|SSL_CTX_load_verify_locations(3)>, L<B<SSL_CTX_set_default_passwd_cb>(3)|SSL_CTX_set_default_passwd_cb(3)>, L<B<SSL_CTX_set_cipher_list>(3)|SSL_CTX_set_cipher_list(3)>, L<B<SSL_CTX_set_client_cert_cb>(3)|SSL_CTX_set_client_cert_cb(3)>, L<B<SSL_CTX_add_extra_chain_cert>(3)|SSL_CTX_add_extra_chain_cert(3)>

note: type: textblock
en: Support for DER encoded private keys (SSL_FILETYPE_ASN1) in SSL_CTX_use_PrivateKey_file() and SSL_use_PrivateKey_file() was added in 0.9.8 .
fr: La gestion des clés privées à chiffrement DER (B<SSL_FILETYPE_ASN1>) dans B<SL_CTX_use_PrivateKey_file>() et B<SSL_use_PrivateKey_file>() a été ajoutée dans la version 0.9.8 .

note: type: textblock
en: SSL_CTX_use_psk_identity_hint, SSL_use_psk_identity_hint, SSL_CTX_set_psk_server_callback, SSL_set_psk_server_callback - set PSK identity hint to use
fr: SSL_CTX_use_psk_identity_hint, SSL_use_psk_identity_hint, SSL_CTX_set_psk_server_callback, SSL_set_psk_server_callback - Définir un indice d'identité PSK à utiliser

note: type: textblock
en: SSL_CTX_use_psk_identity_hint() sets the given B<NULL>-terminated PSK identity hint B<hint> to SSL context object B<ctx>. SSL_use_psk_identity_hint() sets the given B<NULL>-terminated PSK identity hint B<hint> to SSL connection object B<ssl>. If B<hint> is B<NULL> the current hint from B<ctx> or B<ssl> is deleted.
fr: B<SSL_CTX_use_psk_identity_hint>() définit l'indice d'identité PSK I<hint> terminé par NULL à l'objet de contexte SSL I<ctx>. B<SSL_use_psk_identity_hint>() définit l'indice d'identité PSK I<hint> terminé par NULL à l'objet de connexion SSL I<ssl>. Si I<hint> est NULL, les indices actuels de I<ctx> ou I<ssl> sont supprimés.

note: type: textblock
en: In the case where PSK identity hint is B<NULL>, the server does not send the ServerKeyExchange message to the client.
fr: Dans le cas où l'indice d'identité PSK est NULL, le serveur n'envoie pas le message ServerKeyExchange au client.

note: type: textblock
en: A server application must provide a callback function which is called when the server receives the ClientKeyExchange message from the client. The purpose of the callback function is to validate the received PSK identity and to fetch the pre-shared key used during the connection setup phase. The callback is set using functions SSL_CTX_set_psk_server_callback() or SSL_set_psk_server_callback(). The callback function is given the connection in parameter B<ssl>, B<NULL>-terminated PSK identity sent by the client in parameter B<identity>, and a buffer B<psk> of length B<max_psk_len> bytes where the pre-shared key is to be stored.
fr: Une application serveur doit fournir une fonction de rappel qui est appelée quand le serveur reçoit le message ClientKeyExchange du client. Le but de cette fonction de rappel est de valider l'identité PSK reçue et de récupérer la clef prépartagée utilisée pendant la phase de configuration de connexion. Le rappel est défini en utilisant les fonctions B<SSL_CTX_set_psk_server_callback>() ou B<SSL_set_psk_server_callback>(). À la fonction de rappel, sont fournis : la connexion dans le paramètre I<ssl>, l'identité PSK terminée par NULL envoyée par le client dans le paramètre I<identity>, et un tampon I<psk> de taille I<max_psk_len> octets où la clef prépartagée sera stockée.

note: type: textblock
en: SSL_CTX_use_psk_identity_hint() and SSL_use_psk_identity_hint() return 1 on success, 0 otherwise.
fr: B<SSL_CTX_use_psk_identity_hint>() et B<SSL_use_psk_identity_hint>() renvoient B<1> en cas de réussite et B<0> sinon.

note: type: textblock
en: Return values from the server callback are interpreted as follows:
fr: Les valeurs de retour du rappel serveur sont interprétées comme suit.

note: type: textblock
en: PSK identity was not found. An "unknown_psk_identity" alert message will be sent and the connection setup fails.
fr: L'identité PSK n'a pas été trouvée. Un message d'alerte « unknown_psk_identity » sera envoyé et la configuration de connexion échoue.

note: type: textblock
en: PSK identity was found and the server callback has provided the PSK successfully in parameter B<psk>. Return value is the length of B<psk> in bytes. It is an error to return a value greater than B<max_psk_len>.
fr: Une identité PSK a été trouvée et le rappel serveur a bien fourni le PSK dans le paramètre I<psk>. La valeur de retour est la taille de I<psk> en octet. C'est une erreur de renvoyer une valeur plus grande que I<max_psk_len>.

note: type: textblock
en: If the PSK identity was not found but the callback instructs the protocol to continue anyway, the callback must provide some random data to B<psk> and return the length of the random data, so the connection will fail with decryption_error before it will be finished completely.
fr: Si l'identité PSK n'a pas été trouvée mais que le rappel demande tout de même au protocole de continuer, le rappel doit fournir quelques données aléatoires à I<psk> et renvoyer la taille des données aléatoires, de telle sorte que la connexion échoue avec decryption_error avant de se terminer complètement.

note: type: textblock
en: These functions load "serverinfo" TLS ServerHello Extensions into the SSL_CTX.  A "serverinfo" extension is returned in response to an empty ClientHello Extension.
fr: Ces fonctions chargent les extensions ServerHello TLS « serverinfo » dans le B<SSL_CTX>. Une extension « serverinfo » est renvoyée en réponse à une extension HelloClient vide.

note: type: textblock
en: SSL_CTX_use_serverinfo() loads one or more serverinfo extensions from a byte array into B<ctx>.  The extensions must be concatenated into a sequence of bytes.  Each extension must consist of a 2-byte Extension Type, a 2-byte length, and then length bytes of extension_data.
fr: SSL_CTX_use_serverinfo() charge une ou plusieurs extensions serverinfo à partir d'un tableau d'octets dans I<ctx>. Les extensions doivent être concaténées dans une séquence d'octets. Chaque extension doit consister en un type d'extension de 2 octets, une taille de 2 octets et ensuite des octets de longueur des données d'extension.

note: type: textblock
en: SSL_CTX_use_serverinfo_file() loads one or more serverinfo extensions from B<file> into B<ctx>.  The extensions must be in PEM format.  Each extension must consist of a 2-byte Extension Type, a 2-byte length, and then length bytes of extension_data.  Each PEM extension name must begin with the phrase "BEGIN SERVERINFO FOR ".
fr: SSL_CTX_use_serverinfo_file() charge une ou plusieurs extensions serverinfo de I<file> à I<ctx>. Les extensions doivent être au format PEM. Chaque extension doit consister en un type d'extension de 2 octets, une taille de 2 octets et ensuite des octets de longueur des données d’extension. Chaque nom d'extension PEM doit débuter par la phrase « BEGIN SERVERINFO FOR ».

note: type: textblock
en: On success, the functions return 1.  On failure, the functions return 0.  Check out the error stack to find out the reason.
fr: En cas de réussite, les fonctions renvoient B<1>. En cas d'échec, les fonctions renvoient B<0>. Vérifiez la pile d'erreur pour découvrir la raison de l'échec.
