[Date Prev][Date Next] [Thread Prev][Thread Next] [Date Index] [Thread Index]

[MAJ]po4a://manpages-fr-extra/openssl/{SSL_CTX,bn}/po4a/po/fr.po 243t5f6u, 786t1f2u



Salut Jean-Pierre,

Une mise à jour des pages de manuel d’openssl est disponible. Merci
d’avance si tu peux t’occuper de ces deux fichiers.

Amicalement

David
# French translations for the openssl package
# Copyright (C) 2008, 2012-2015 Debian French l10n team <debian-l10n-french@lists.debian.org>.
# This file is distributed under the same license as the openssl package.
#
# Nicolas François <nicolas.francois@centraliens.net>, 2008.
# David Prévot <david@tilapin.org>, 2012, 2013, 2015.
# Jean-Pierre Giraud <jean-pierregiraud@neuf.fr>, 2014, 2015.
msgid ""
msgstr ""
"Project-Id-Version: openssl\n"
"POT-Creation-Date: 2015-12-31 16:21-0400\n"
"PO-Revision-Date: 2015-12-31 18:09-0400\n"
"Last-Translator: Jean-Pierre Giraud <jean-pierregiraud@neuf.fr>\n"
"Language-Team: French <debian-l10n-french@lists.debian.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
"X-Generator: Lokalize 2.0\n"

#. type: =head1
#: C/ssl/SSL_CTX_add1_chain_cert.pod:3 C/ssl/SSL_CTX_add_extra_chain_cert.pod:3
#: C/ssl/SSL_CTX_add_session.pod:3 C/ssl/SSL_CTX_ctrl.pod:3
#: C/ssl/SSL_CTX_flush_sessions.pod:3 C/ssl/SSL_CTX_free.pod:3
#: C/ssl/SSL_CTX_get0_param.pod:3 C/ssl/SSL_CTX_get_ex_new_index.pod:3
#: C/ssl/SSL_CTX_get_verify_mode.pod:3
#: C/ssl/SSL_CTX_load_verify_locations.pod:3 C/ssl/SSL_CTX_new.pod:3
#: C/ssl/SSL_CTX_sess_number.pod:3 C/ssl/SSL_CTX_sess_set_cache_size.pod:3
#: C/ssl/SSL_CTX_sess_set_get_cb.pod:3 C/ssl/SSL_CTX_sessions.pod:3
#: C/ssl/SSL_CTX_use_certificate.pod:3
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:32
#: C/ssl/SSL_CTX_use_serverinfo.pod:3
msgid "NAME"
msgstr "NOM"

#. type: textblock
#: C/ssl/SSL_CTX_add1_chain_cert.pod:5
msgid ""
"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"
msgstr ""
"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"

#. type: =head1
#: C/ssl/SSL_CTX_add1_chain_cert.pod:13
#: C/ssl/SSL_CTX_add_extra_chain_cert.pod:8 C/ssl/SSL_CTX_add_session.pod:7
#: C/ssl/SSL_CTX_ctrl.pod:7 C/ssl/SSL_CTX_flush_sessions.pod:7
#: C/ssl/SSL_CTX_free.pod:7 C/ssl/SSL_CTX_get0_param.pod:8
#: C/ssl/SSL_CTX_get_ex_new_index.pod:7 C/ssl/SSL_CTX_get_verify_mode.pod:7
#: C/ssl/SSL_CTX_load_verify_locations.pod:8 C/ssl/SSL_CTX_new.pod:7
#: C/ssl/SSL_CTX_sess_number.pod:7 C/ssl/SSL_CTX_sess_set_cache_size.pod:7
#: C/ssl/SSL_CTX_sess_set_get_cb.pod:7 C/ssl/SSL_CTX_sessions.pod:7
#: C/ssl/SSL_CTX_use_certificate.pod:7
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:39
#: C/ssl/SSL_CTX_use_serverinfo.pod:7
msgid "SYNOPSIS"
msgstr "SYNOPSIS"

#. type: verbatim
#: C/ssl/SSL_CTX_add1_chain_cert.pod:15
#: C/ssl/SSL_CTX_add_extra_chain_cert.pod:10 C/ssl/SSL_CTX_add_session.pod:9
#: C/ssl/SSL_CTX_ctrl.pod:9 C/ssl/SSL_CTX_flush_sessions.pod:9
#: C/ssl/SSL_CTX_free.pod:9 C/ssl/SSL_CTX_get0_param.pod:10
#: C/ssl/SSL_CTX_get_ex_new_index.pod:9 C/ssl/SSL_CTX_get_verify_mode.pod:9
#: C/ssl/SSL_CTX_load_verify_locations.pod:10 C/ssl/SSL_CTX_new.pod:9
#: C/ssl/SSL_CTX_sess_number.pod:9 C/ssl/SSL_CTX_sess_set_cache_size.pod:9
#: C/ssl/SSL_CTX_sess_set_get_cb.pod:9 C/ssl/SSL_CTX_sessions.pod:9
#: C/ssl/SSL_CTX_use_certificate.pod:9
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:41
#: C/ssl/SSL_CTX_use_serverinfo.pod:9
#, no-wrap
msgid ""
" #include <openssl/ssl.h>\n"
"\n"
msgstr ""
" #include <openssl/ssl.h>\n"
"\n"

#. type: verbatim
#: C/ssl/SSL_CTX_add1_chain_cert.pod:17
#, no-wrap
msgid ""
" int SSL_CTX_set0_chain(SSL_CTX *ctx, STACK_OF(X509) *sk);\n"
" int SSL_CTX_set1_chain(SSL_CTX *ctx, STACK_OF(X509) *sk);\n"
" int SSL_CTX_add0_chain_cert(SSL_CTX *ctx, X509 *x509);\n"
" int SSL_CTX_add1_chain_cert(SSL_CTX *ctx, X509 *x509);\n"
" int SSL_CTX_get0_chain_certs(SSL_CTX *ctx, STACK_OF(X509) **sk);\n"
" int SSL_CTX_clear_chain_certs(SSL_CTX *ctx);\n"
"\n"
msgstr ""
" int SSL_CTX_set0_chain(SSL_CTX *ctx, STACK_OF(X509) *sk);\n"
" int SSL_CTX_set1_chain(SSL_CTX *ctx, STACK_OF(X509) *sk);\n"
" int SSL_CTX_add0_chain_cert(SSL_CTX *ctx, X509 *x509);\n"
" int SSL_CTX_add1_chain_cert(SSL_CTX *ctx, X509 *x509);\n"
" int SSL_CTX_get0_chain_certs(SSL_CTX *ctx, STACK_OF(X509) **sk);\n"
" int SSL_CTX_clear_chain_certs(SSL_CTX *ctx);\n"
"\n"

#. type: verbatim
#: C/ssl/SSL_CTX_add1_chain_cert.pod:24
#, no-wrap
msgid ""
" int SSL_set0_chain(SSL *ssl, STACK_OF(X509) *sk);\n"
" int SSL_set1_chain(SSL *ssl, STACK_OF(X509) *sk);\n"
" int SSL_add0_chain_cert(SSL *ssl, X509 *x509);\n"
" int SSL_add1_chain_cert(SSL *ssl, X509 *x509);\n"
" int SSL_get0_chain_certs(SSL *ssl, STACK_OF(X509) **sk);\n"
" int SSL_clear_chain_certs(SSL *ssl);\n"
"\n"
msgstr ""
" int SSL_set0_chain(SSL *ssl, STACK_OF(X509) *sk);\n"
" int SSL_set1_chain(SSL *ssl, STACK_OF(X509) *sk);\n"
" int SSL_add0_chain_cert(SSL *ssl, X509 *x509);\n"
" int SSL_add1_chain_cert(SSL *ssl, X509 *x509);\n"
" int SSL_get0_chain_certs(SSL *ssl, STACK_OF(X509) **sk);\n"
" int SSL_clear_chain_certs(SSL *ssl);\n"
"\n"

#. type: verbatim
#: C/ssl/SSL_CTX_add1_chain_cert.pod:31
#, no-wrap
msgid ""
" int SSL_CTX_build_cert_chain(SSL_CTX *ctx, flags);\n"
" int SSL_build_cert_chain(SSL *ssl, flags);\n"
"\n"
msgstr ""
" int SSL_CTX_build_cert_chain(SSL_CTX *ctx, flags);\n"
" int SSL_build_cert_chain(SSL *ssl, flags);\n"
"\n"

#. type: verbatim
#: C/ssl/SSL_CTX_add1_chain_cert.pod:34
#, no-wrap
msgid ""
" int SSL_CTX_select_current_cert(SSL_CTX *ctx, X509 *x509);\n"
" int SSL_select_current_cert(SSL *ssl, X509 *x509);\n"
" int SSL_CTX_set_current_cert(SSL_CTX *ctx, long op);\n"
" int SSL_set_current_cert(SSL *ssl, long op);\n"
"\n"
msgstr ""
" int SSL_CTX_select_current_cert(SSL_CTX *ctx, X509 *x509);\n"
" int SSL_select_current_cert(SSL *ssl, X509 *x509);\n"
" int SSL_CTX_set_current_cert(SSL_CTX *ctx, long op);\n"
" int SSL_set_current_cert(SSL *ssl, long op);\n"
"\n"

#. type: =head1
#: C/ssl/SSL_CTX_add1_chain_cert.pod:39
#: C/ssl/SSL_CTX_add_extra_chain_cert.pod:15 C/ssl/SSL_CTX_add_session.pod:17
#: C/ssl/SSL_CTX_ctrl.pod:17 C/ssl/SSL_CTX_flush_sessions.pod:14
#: C/ssl/SSL_CTX_free.pod:13 C/ssl/SSL_CTX_get0_param.pod:17
#: C/ssl/SSL_CTX_get_ex_new_index.pod:27 C/ssl/SSL_CTX_get_verify_mode.pod:18
#: C/ssl/SSL_CTX_load_verify_locations.pod:15 C/ssl/SSL_CTX_new.pod:13
#: C/ssl/SSL_CTX_sess_number.pod:24 C/ssl/SSL_CTX_sess_set_cache_size.pod:14
#: C/ssl/SSL_CTX_sess_set_get_cb.pod:27 C/ssl/SSL_CTX_sessions.pod:13
#: C/ssl/SSL_CTX_use_certificate.pod:37
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:54
#: C/ssl/SSL_CTX_use_serverinfo.pod:16
msgid "DESCRIPTION"
msgstr "DESCRIPTION"

#. type: textblock
#: C/ssl/SSL_CTX_add1_chain_cert.pod:41
msgid ""
"SSL_CTX_set0_chain() and SSL_CTX_set1_chain() set the certificate chain "
"associated with the current certificate of B<ctx> to B<sk>."
msgstr ""
"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>."

#. type: textblock
#: C/ssl/SSL_CTX_add1_chain_cert.pod:44
msgid ""
"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>."
msgstr ""
"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>."

#. type: textblock
#: C/ssl/SSL_CTX_add1_chain_cert.pod:48
msgid ""
"SSL_CTX_get0_chain_certs() retrieves the chain associated with the current "
"certificate of B<ctx>."
msgstr ""
"B<SSL_CTX_get0_chain_certs>() récupère la chaîne associée au certificat "
"actuel de I<ctx>."

#. type: textblock
#: C/ssl/SSL_CTX_add1_chain_cert.pod:51
msgid ""
"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>)."
msgstr ""
"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)."

#. type: textblock
#: C/ssl/SSL_CTX_add1_chain_cert.pod:55
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_add1_chain_cert.pod:67
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_add1_chain_cert.pod:71
msgid ""
"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()."
msgstr ""
"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>()."

#. type: textblock
#: C/ssl/SSL_CTX_add1_chain_cert.pod:75
msgid ""
"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>."
msgstr ""
"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>."

#. type: textblock
#: C/ssl/SSL_CTX_add1_chain_cert.pod:80
msgid ""
"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."
msgstr ""
"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>."

#. type: textblock
#: C/ssl/SSL_CTX_add1_chain_cert.pod:86
msgid ""
"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."
msgstr ""
"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é."

#. type: textblock
#: C/ssl/SSL_CTX_add1_chain_cert.pod:94
msgid ""
"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."
msgstr ""
"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."

#. type: =head1
#: C/ssl/SSL_CTX_add1_chain_cert.pod:100
#: C/ssl/SSL_CTX_add_extra_chain_cert.pod:26 C/ssl/SSL_CTX_add_session.pod:30
#: C/ssl/SSL_CTX_flush_sessions.pod:21 C/ssl/SSL_CTX_get0_param.pod:26
#: C/ssl/SSL_CTX_load_verify_locations.pod:21 C/ssl/SSL_CTX_new.pod:18
#: C/ssl/SSL_CTX_sess_set_cache_size.pod:22
#: C/ssl/SSL_CTX_sess_set_get_cb.pod:48 C/ssl/SSL_CTX_sessions.pod:18
#: C/ssl/SSL_CTX_use_certificate.pod:110 C/ssl/SSL_CTX_use_serverinfo.pod:33
msgid "NOTES"
msgstr "NOTES"

#. type: textblock
#: C/ssl/SSL_CTX_add1_chain_cert.pod:102
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_add1_chain_cert.pod:106
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_add1_chain_cert.pod:109
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_add1_chain_cert.pod:114
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_add1_chain_cert.pod:118
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_add1_chain_cert.pod:122
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_add1_chain_cert.pod:126
msgid ""
"If any certificates are added using these functions no certificates added "
"using SSL_CTX_add_extra_chain_cert() will be used."
msgstr ""
"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é."

#. type: =head1
#: C/ssl/SSL_CTX_add1_chain_cert.pod:129
#: C/ssl/SSL_CTX_add_extra_chain_cert.pod:48 C/ssl/SSL_CTX_add_session.pod:49
#: C/ssl/SSL_CTX_ctrl.pod:25 C/ssl/SSL_CTX_flush_sessions.pod:40
#: C/ssl/SSL_CTX_free.pod:32 C/ssl/SSL_CTX_get0_param.pod:39
#: C/ssl/SSL_CTX_get_verify_mode.pod:42
#: C/ssl/SSL_CTX_load_verify_locations.pod:97 C/ssl/SSL_CTX_new.pod:86
#: C/ssl/SSL_CTX_sess_number.pod:66 C/ssl/SSL_CTX_sess_set_cache_size.pod:40
#: C/ssl/SSL_CTX_use_certificate.pod:145
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:77
#: C/ssl/SSL_CTX_use_serverinfo.pod:35
msgid "RETURN VALUES"
msgstr "VALEURS DE RETOUR"

#. type: textblock
#: C/ssl/SSL_CTX_add1_chain_cert.pod:131
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_add1_chain_cert.pod:135
msgid ""
"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."
msgstr ""
"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é."

#. type: textblock
#: C/ssl/SSL_CTX_add1_chain_cert.pod:139
msgid "All other functions return 1 for success and 0 for failure."
msgstr ""
"Toutes les autres fonctions renvoient B<1> en cas de réussite et B<0> en cas "
"d'échec."

#. type: =head1
#: C/ssl/SSL_CTX_add1_chain_cert.pod:142
#: C/ssl/SSL_CTX_add_extra_chain_cert.pod:54 C/ssl/SSL_CTX_add_session.pod:67
#: C/ssl/SSL_CTX_ctrl.pod:30 C/ssl/SSL_CTX_flush_sessions.pod:42
#: C/ssl/SSL_CTX_free.pod:36 C/ssl/SSL_CTX_get0_param.pod:47
#: C/ssl/SSL_CTX_get_ex_new_index.pod:47 C/ssl/SSL_CTX_get_verify_mode.pod:46
#: C/ssl/SSL_CTX_load_verify_locations.pod:115 C/ssl/SSL_CTX_new.pod:103
#: C/ssl/SSL_CTX_sess_number.pod:70 C/ssl/SSL_CTX_sess_set_cache_size.pod:46
#: C/ssl/SSL_CTX_sess_set_get_cb.pod:79 C/ssl/SSL_CTX_sessions.pod:28
#: C/ssl/SSL_CTX_use_certificate.pod:150 C/ssl/SSL_CTX_use_serverinfo.pod:41
msgid "SEE ALSO"
msgstr "VOIR AUSSI"

#. type: textblock
#: C/ssl/SSL_CTX_add1_chain_cert.pod:144
msgid "L<SSL_CTX_add_extra_chain_cert(3)|SSL_CTX_add_extra_chain_cert(3)>"
msgstr "L<B<SSL_CTX_add_extra_chain_cert>(3)|SSL_CTX_add_extra_chain_cert(3)>"

#. type: =head1
#: C/ssl/SSL_CTX_add1_chain_cert.pod:146 C/ssl/SSL_CTX_get0_param.pod:51
#: C/ssl/SSL_CTX_use_certificate.pod:159 C/ssl/SSL_CTX_use_serverinfo.pod:43
msgid "HISTORY"
msgstr "HISTORIQUE"

#. type: textblock
#: C/ssl/SSL_CTX_add1_chain_cert.pod:148 C/ssl/SSL_CTX_get0_param.pod:53
msgid "These functions were first added to OpenSSL 1.0.2."
msgstr ""
"Ces fonctions ont été ajoutées pour la première fois dans OpenSSL 1.0.2."

#. type: textblock
#: C/ssl/SSL_CTX_add_extra_chain_cert.pod:5
msgid ""
"SSL_CTX_add_extra_chain_cert, SSL_CTX_clear_extra_chain_certs - add or clear "
"extra chain certificates"
msgstr ""
"SSL_CTX_add_extra_chain_cert, SSL_CTX_clear_extra_chain_certs - Ajouter ou "
"supprimer des certificats de chaîne supplémentaire"

#. type: verbatim
#: C/ssl/SSL_CTX_add_extra_chain_cert.pod:12
#, no-wrap
msgid ""
" long SSL_CTX_add_extra_chain_cert(SSL_CTX *ctx, X509 *x509);\n"
" long SSL_CTX_clear_extra_chain_certs(SSL_CTX *ctx);\n"
"\n"
msgstr ""
" long SSL_CTX_add_extra_chain_cert(SSL_CTX *ctx, X509 *x509);\n"
" long SSL_CTX_clear_extra_chain_certs(SSL_CTX *ctx);\n"
"\n"

#. type: textblock
#: C/ssl/SSL_CTX_add_extra_chain_cert.pod:17
#, fuzzy
#| msgid ""
#| "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."
msgid ""
"SSL_CTX_add_extra_chain_cert() adds the certificate B<x509> to the extra "
"chain certificates associated with B<ctx>. Several certificates can be added "
"one after another."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_add_extra_chain_cert.pod:21
#, fuzzy
#| msgid ""
#| "SSL_CTX_get0_chain_certs() retrieves the chain associated with the "
#| "current certificate of B<ctx>."
msgid ""
"SSL_CTX_clear_extra_chain_certs() clears all extra chain certificates "
"associated with B<ctx>."
msgstr ""
"B<SSL_CTX_get0_chain_certs>() récupère la chaîne associée au certificat "
"actuel de I<ctx>."

#. type: textblock
#: C/ssl/SSL_CTX_add_extra_chain_cert.pod:24
msgid "These functions are implemented as macros."
msgstr ""

#. type: textblock
#: C/ssl/SSL_CTX_add_extra_chain_cert.pod:28
#, fuzzy
msgid ""
"When sending a certificate chain, extra chain certificates are sent in order "
"following the end entity certificate."
msgstr "Lors de lâ??envoi dâ??une chaîne de certificats, "

#. type: textblock
#: C/ssl/SSL_CTX_add_extra_chain_cert.pod:31
msgid ""
"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)>."
msgstr ""
"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)>."

#. type: textblock
#: C/ssl/SSL_CTX_add_extra_chain_cert.pod:35
msgid ""
"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."
msgstr ""
"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>."

#. type: =head1
#: C/ssl/SSL_CTX_add_extra_chain_cert.pod:39
msgid "RESTRICTIONS"
msgstr "RESTRICTIONS"

#. type: textblock
#: C/ssl/SSL_CTX_add_extra_chain_cert.pod:41
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_add_extra_chain_cert.pod:50
msgid ""
"SSL_CTX_add_extra_chain_cert() and SSL_CTX_clear_extra_chain_certs() return "
"1 on success and 0 for failure. Check out the error stack to find out the "
"reason for failure."
msgstr ""
"B<SSL_CTX_add_extra_chain_cert>() et B<SSL_CTX_clear_extra_chain_certs>() "
"renvoient B<1> en cas de réussite et B<0> en cas dâ??erreur. Vérifiez la pile "
"d'erreur pour découvrir la raison de l'échec."

#. type: textblock
#: C/ssl/SSL_CTX_add_extra_chain_cert.pod:56
msgid ""
"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)>"
msgstr ""
"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)>"

#. type: textblock
#: C/ssl/SSL_CTX_add_session.pod:5
msgid ""
"SSL_CTX_add_session, SSL_add_session, SSL_CTX_remove_session, "
"SSL_remove_session - manipulate session cache"
msgstr ""
"SSL_CTX_add_session, SSL_add_session, SSL_CTX_remove_session, "
"SSL_remove_session - manipuler le cache de sessions"

#. type: verbatim
#: C/ssl/SSL_CTX_add_session.pod:11
#, no-wrap
msgid ""
" int SSL_CTX_add_session(SSL_CTX *ctx, SSL_SESSION *c);\n"
" int SSL_add_session(SSL_CTX *ctx, SSL_SESSION *c);\n"
"\n"
msgstr ""
" int SSL_CTX_add_session(SSL_CTX *ctx, SSL_SESSION *c);\n"
" int SSL_add_session(SSL_CTX *ctx, SSL_SESSION *c);\n"
"\n"

#. type: verbatim
#: C/ssl/SSL_CTX_add_session.pod:14
#, no-wrap
msgid ""
" int SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *c);\n"
" int SSL_remove_session(SSL_CTX *ctx, SSL_SESSION *c);\n"
"\n"
msgstr ""
" int SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *c);\n"
" int SSL_remove_session(SSL_CTX *ctx, SSL_SESSION *c);\n"
"\n"

#. type: textblock
#: C/ssl/SSL_CTX_add_session.pod:19
msgid ""
"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)>."
msgstr ""
"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)>."

#. type: textblock
#: C/ssl/SSL_CTX_add_session.pod:24
msgid ""
"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>."
msgstr ""
"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>."

#. type: textblock
#: C/ssl/SSL_CTX_add_session.pod:27
msgid ""
"SSL_add_session() and SSL_remove_session() are synonyms for their "
"SSL_CTX_*() counterparts."
msgstr ""
"B<SSL_add_session>() et B<SSL_remove_session>() sont synonymes pour leurs "
"équivalents B< SSL_CTX_*>()."

#. type: textblock
#: C/ssl/SSL_CTX_add_session.pod:32
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_add_session.pod:40
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_add_session.pod:51
msgid "The following values are returned by all functions:"
msgstr "Toutes les fonctions peuvent renvoyer les valeurs suivantes :"

#. type: =item
#: C/ssl/SSL_CTX_add_session.pod:55 C/ssl/SSL_CTX_load_verify_locations.pod:103
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:86
msgid "Z<>0"
msgstr "Z<>0"

#. type: verbatim
#: C/ssl/SSL_CTX_add_session.pod:57
#, no-wrap
msgid ""
" The operation failed. In case of the add operation, it was tried to add\n"
" the same (identical) session twice. In case of the remove operation, the\n"
" session was not found in the cache.\n"
"\n"
msgstr ""
" Lâ??opération a échouée. Si câ??est lors dâ??une opération dâ??addition, un essai\n"
" dâ??ajout de la même session (identique) a été fait. Si câ??est lors dâ??une\n"
" opération de suppression, la session nâ??a pas été trouvée dans le cache.\n"
"\n"

#. type: =item
#: C/ssl/SSL_CTX_add_session.pod:61 C/ssl/SSL_CTX_load_verify_locations.pod:109
msgid "Z<>1"
msgstr "Z<>1"

#. type: verbatim
#: C/ssl/SSL_CTX_add_session.pod:63
#, no-wrap
msgid ""
" The operation succeeded.\n"
"\n"
msgstr ""
" Lâ??opération est réussie.\n"
"\n"

#. type: textblock
#: C/ssl/SSL_CTX_add_session.pod:69
msgid ""
"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)>"
msgstr ""
"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)>"

#. type: textblock
#: C/ssl/SSL_CTX_ctrl.pod:5
msgid ""
"SSL_CTX_ctrl, SSL_CTX_callback_ctrl, SSL_ctrl, SSL_callback_ctrl - internal "
"handling functions for SSL_CTX and SSL objects"
msgstr ""
"SSL_CTX_ctrl, SSL_CTX_callback_ctrl, SSL_ctrl, SSL_callback_ctrl - Fonctions "
"de traitement interne pour les objets SSL_CTX et SSL"

#. type: verbatim
#: C/ssl/SSL_CTX_ctrl.pod:11
#, no-wrap
msgid ""
" long SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg);\n"
" long SSL_CTX_callback_ctrl(SSL_CTX *, int cmd, void (*fp)());\n"
"\n"
msgstr ""
" long SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg);\n"
" long SSL_CTX_callback_ctrl(SSL_CTX *, int cmd, void (*fp)());\n"
"\n"

#. type: verbatim
#: C/ssl/SSL_CTX_ctrl.pod:14
#, no-wrap
msgid ""
" long SSL_ctrl(SSL *ssl, int cmd, long larg, void *parg);\n"
" long SSL_callback_ctrl(SSL *, int cmd, void (*fp)());\n"
"\n"
msgstr ""
" long SSL_ctrl(SSL *ssl, int cmd, long larg, void *parg);\n"
" long SSL_callback_ctrl(SSL *, int cmd, void (*fp)());\n"
"\n"

#. type: textblock
#: C/ssl/SSL_CTX_ctrl.pod:19
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_ctrl.pod:27
msgid ""
"The return values of the SSL*_ctrl() functions depend on the command "
"supplied via the B<cmd> parameter."
msgstr ""
"Les valeurs de retour des fonctions B<SSL*_ctrl>() dépendent de la commande "
"fournie par le paramètre I<cmd>."

#. type: textblock
#: C/ssl/SSL_CTX_ctrl.pod:32
msgid "L<ssl(3)|ssl(3)>"
msgstr "L<B<ssl>(3)|ssl(3)>"

#. type: textblock
#: C/ssl/SSL_CTX_flush_sessions.pod:5
msgid "SSL_CTX_flush_sessions, SSL_flush_sessions - remove expired sessions"
msgstr ""
"SSL_CTX_flush_sessions, SSL_flush_sessions - Supprimer les sessions expirées"

#. type: verbatim
#: C/ssl/SSL_CTX_flush_sessions.pod:11
#, no-wrap
msgid ""
" void SSL_CTX_flush_sessions(SSL_CTX *ctx, long tm);\n"
" void SSL_flush_sessions(SSL_CTX *ctx, long tm);\n"
"\n"
msgstr ""
" void SSL_CTX_flush_sessions(SSL_CTX *ctx, long tm);\n"
" void SSL_flush_sessions(SSL_CTX *ctx, long tm);\n"
"\n"

#. type: textblock
#: C/ssl/SSL_CTX_flush_sessions.pod:16
msgid ""
"SSL_CTX_flush_sessions() causes a run through the session cache of B<ctx> to "
"remove sessions expired at time B<tm>."
msgstr ""
"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>."

#. type: textblock
#: C/ssl/SSL_CTX_flush_sessions.pod:19
msgid "SSL_flush_sessions() is a synonym for SSL_CTX_flush_sessions()."
msgstr ""
"B<SSL_flush_sessions>() est un synonyme de B<SSL_CTX_flush_sessions>()."

# NOTE: extra space in the beginning of fifth line breaks the layout.
# NOTE: s/ones/once/
#. type: verbatim
#: C/ssl/SSL_CTX_flush_sessions.pod:23
#, no-wrap
msgid ""
"If enabled, the internal session cache will collect all sessions established\n"
"up to the specified maximum number (see SSL_CTX_sess_set_cache_size()).\n"
"As sessions will not be reused ones they are expired, they should be\n"
"removed from the cache to save resources. This can either be done\n"
" automatically whenever 255 new sessions were established (see\n"
"L<SSL_CTX_set_session_cache_mode(3)|SSL_CTX_set_session_cache_mode(3)>)\n"
"or manually by calling SSL_CTX_flush_sessions(). \n"
"\n"
msgstr ""
"Si activé, le cache de sessions internes collectera toutes les sessions \n"
"établies jusqu'au nombre maximal indiqué (consultez\n"
"B<SSL_CTX_sess_set_cache_size>()). Comme les sessions ne seront pas\n"
"réutilisées une fois expirées, elles devront être supprimées du cache\n"
"pour préserver les ressources. Cela peut être fait soit automatiquement\n"
"à chaque fois que 255 nouvelles sessions ont été établies (consultez\n"
"L<B<SSL_CTX_set_session_cache_mode>(3)|SSL_CTX_set_session_cache_mode(3)>),\n"
"soit directement en appelant B<SSL_CTX_flush_sessions>().\n"
"\n"

#. type: textblock
#: C/ssl/SSL_CTX_flush_sessions.pod:31
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_flush_sessions.pod:35
msgid ""
"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)>)."
msgstr ""
"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)>)."

#. type: textblock
#: C/ssl/SSL_CTX_flush_sessions.pod:44
msgid ""
"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)>"
msgstr ""
"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)>"

#. type: textblock
#: C/ssl/SSL_CTX_free.pod:5
msgid "SSL_CTX_free - free an allocated SSL_CTX object"
msgstr "SSL_CTX_free - Libérer un objet SSL_CTX alloué"

#. type: verbatim
#: C/ssl/SSL_CTX_free.pod:11
#, no-wrap
msgid ""
" void SSL_CTX_free(SSL_CTX *ctx);\n"
"\n"
msgstr ""
" void SSL_CTX_free(SSL_CTX *ctx);\n"
"\n"

#. type: textblock
#: C/ssl/SSL_CTX_free.pod:15
msgid ""
"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."
msgstr ""
"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>."

#. type: textblock
#: C/ssl/SSL_CTX_free.pod:19
msgid ""
"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."
msgstr ""
"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."

#. type: =head1
#: C/ssl/SSL_CTX_free.pod:23 C/ssl/SSL_CTX_load_verify_locations.pod:71
msgid "WARNINGS"
msgstr "AVERTISSEMENTS"

#. type: textblock
#: C/ssl/SSL_CTX_free.pod:25
msgid ""
"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()."
msgstr ""
"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>()."

#. type: textblock
#: C/ssl/SSL_CTX_free.pod:34
msgid "SSL_CTX_free() does not provide diagnostic information."
msgstr "B<SSL_CTX_free>() ne fournit pas de renseignements de diagnostique."

#. type: textblock
#: C/ssl/SSL_CTX_free.pod:38
msgid ""
"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)>"
msgstr ""
"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)>"

#. type: textblock
#: C/ssl/SSL_CTX_get0_param.pod:5
msgid ""
"SSL_CTX_get0_param, SSL_get0_param, SSL_CTX_set1_param, SSL_set1_param - get "
"and set verification parameters"
msgstr ""
"SSL_CTX_get0_param, SSL_get0_param, SSL_CTX_set1_param, SSL_set1_param - "
"Obtenir et Définir des paramètres de verification"

#. type: verbatim
#: C/ssl/SSL_CTX_get0_param.pod:12
#, no-wrap
msgid ""
" X509_VERIFY_PARAM *SSL_CTX_get0_param(SSL_CTX *ctx)\n"
" X509_VERIFY_PARAM *SSL_get0_param(SSL *ssl)\n"
" int SSL_CTX_set1_param(SSL_CTX *ctx, X509_VERIFY_PARAM *vpm)\n"
" int SSL_set1_param(SSL *ssl, X509_VERIFY_PARAM *vpm)\n"
"\n"
msgstr ""
" X509_VERIFY_PARAM *SSL_CTX_get0_param(SSL_CTX *ctx)\n"
" X509_VERIFY_PARAM *SSL_get0_param(SSL *ssl)\n"
" int SSL_CTX_set1_param(SSL_CTX *ctx, X509_VERIFY_PARAM *vpm)\n"
" int SSL_set1_param(SSL *ssl, X509_VERIFY_PARAM *vpm)\n"
"\n"

#. type: textblock
#: C/ssl/SSL_CTX_get0_param.pod:19
msgid ""
"SSL_CTX_get0_param() and SSL_get0_param() retrieve an internal pointer to "
"the verification parameters for B<ctx> or B<ssl> respectively. The returned "
"pointer must not be freed by the calling application."
msgstr ""

#. type: textblock
#: C/ssl/SSL_CTX_get0_param.pod:23
#, fuzzy
#| msgid ""
#| "SSL_CTX_set0_chain() and SSL_CTX_set1_chain() set the certificate chain "
#| "associated with the current certificate of B<ctx> to B<sk>."
msgid ""
"SSL_CTX_set1_param() and SSL_set1_param() set the verification parameters to "
"B<vpm> for B<ctx> or B<ssl>."
msgstr ""
"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>."

#. type: textblock
#: C/ssl/SSL_CTX_get0_param.pod:28
msgid ""
"Typically parameters are retrieved from an B<SSL_CTX> or B<SSL> structure "
"using SSL_CTX_get0_param() or SSL_get0_param() and an application modifies "
"them to suit its needs: for example to add a hostname check."
msgstr ""

#. type: =head1
#: C/ssl/SSL_CTX_get0_param.pod:32
msgid "EXAMPLE"
msgstr "EXEMPLE"

#. type: textblock
#: C/ssl/SSL_CTX_get0_param.pod:34
msgid "Check hostname matches \"www.foo.com\" in peer certificate:"
msgstr ""

#. type: verbatim
#: C/ssl/SSL_CTX_get0_param.pod:36
#, no-wrap
msgid ""
" X509_VERIFY_PARAM *vpm = SSL_get0_param(ssl);\n"
" X509_VERIFY_PARAM_set1_host(vpm, \"www.foo.com\", 0);\n"
"\n"
msgstr ""

#. type: textblock
#: C/ssl/SSL_CTX_get0_param.pod:41
msgid ""
"SSL_CTX_get0_param() and SSL_get0_param() return a pointer to an "
"B<X509_VERIFY_PARAM> structure."
msgstr ""

#. type: textblock
#: C/ssl/SSL_CTX_get0_param.pod:44
#, fuzzy
#| msgid "All other functions return 1 for success and 0 for failure."
msgid ""
"SSL_CTX_set1_param() and SSL_set1_param() return 1 for success and 0 for "
"failure."
msgstr ""
"Toutes les autres fonctions renvoient B<1> en cas de réussite et B<0> en cas "
"d'échec."

#. type: textblock
#: C/ssl/SSL_CTX_get0_param.pod:49
msgid "L<X509_VERIFY_PARAM_set_flags(3)|X509_VERIFY_PARAM_set_flags(3)>"
msgstr "L<B<X509_VERIFY_PARAM_set_flags>(3)|X509_VERIFY_PARAM_set_flags(3)>"

#. type: textblock
#: C/ssl/SSL_CTX_get_ex_new_index.pod:5
msgid ""
"SSL_CTX_get_ex_new_index, SSL_CTX_set_ex_data, SSL_CTX_get_ex_data - "
"internal application specific data functions"
msgstr ""
"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"

#. type: verbatim
#: C/ssl/SSL_CTX_get_ex_new_index.pod:11
#, no-wrap
msgid ""
" int SSL_CTX_get_ex_new_index(long argl, void *argp,\n"
"                CRYPTO_EX_new *new_func,\n"
"                CRYPTO_EX_dup *dup_func,\n"
"                CRYPTO_EX_free *free_func);\n"
"\n"
msgstr ""
" int SSL_CTX_get_ex_new_index(long argl, void *argp,\n"
"                CRYPTO_EX_new *new_func,\n"
"                CRYPTO_EX_dup *dup_func,\n"
"                CRYPTO_EX_free *free_func);\n"
"\n"

#. type: verbatim
#: C/ssl/SSL_CTX_get_ex_new_index.pod:16
#, no-wrap
msgid ""
" int SSL_CTX_set_ex_data(SSL_CTX *ctx, int idx, void *arg);\n"
"\n"
msgstr ""
" int SSL_CTX_set_ex_data(SSL_CTX *ctx, int idx, void *arg);\n"
"\n"

#. type: verbatim
#: C/ssl/SSL_CTX_get_ex_new_index.pod:18
#, no-wrap
msgid ""
" void *SSL_CTX_get_ex_data(const SSL_CTX *ctx, int idx);\n"
"\n"
msgstr ""
" void *SSL_CTX_get_ex_data(const SSL_CTX *ctx, int idx);\n"
"\n"

#. type: verbatim
#: C/ssl/SSL_CTX_get_ex_new_index.pod:20
#, no-wrap
msgid ""
" typedef int new_func(void *parent, void *ptr, CRYPTO_EX_DATA *ad,\n"
"                int idx, long argl, void *argp);\n"
" typedef void free_func(void *parent, void *ptr, CRYPTO_EX_DATA *ad,\n"
"                int idx, long argl, void *argp);\n"
" typedef int dup_func(CRYPTO_EX_DATA *to, CRYPTO_EX_DATA *from, void *from_d,\n"
"                int idx, long argl, void *argp);\n"
"\n"
msgstr ""
" typedef int new_func(void *parent, void *ptr, CRYPTO_EX_DATA *ad,\n"
"                int idx, long argl, void *argp);\n"
" typedef void free_func(void *parent, void *ptr, CRYPTO_EX_DATA *ad,\n"
"                int idx, long argl, void *argp);\n"
" typedef int dup_func(CRYPTO_EX_DATA *to, CRYPTO_EX_DATA *from, void *from_d,\n"
"                int idx, long argl, void *argp);\n"
"\n"

#. type: textblock
#: C/ssl/SSL_CTX_get_ex_new_index.pod:29
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_get_ex_new_index.pod:33
msgid ""
"SSL_CTX_get_ex_new_index() is used to register a new index for application "
"specific data."
msgstr ""
"B<SSL_CTX_get_ex_new_index>() est utilisée pour enregistrer un nouvel indice "
"de données spécifiques aux applications."

#. type: textblock
#: C/ssl/SSL_CTX_get_ex_new_index.pod:36
msgid ""
"SSL_CTX_set_ex_data() is used to store application data at B<arg> for B<idx> "
"into the B<ctx> object."
msgstr ""
"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>."

#. type: textblock
#: C/ssl/SSL_CTX_get_ex_new_index.pod:39
msgid ""
"SSL_CTX_get_ex_data() is used to retrieve the information for B<idx> from "
"B<ctx>."
msgstr ""
"B<SSL_CTX_get_ex_data>() est utilisée pour récupérer les informations pour "
"I<idx> de I<ctx>."

#. type: textblock
#: C/ssl/SSL_CTX_get_ex_new_index.pod:42
msgid ""
"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)>."
msgstr ""
"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)>."

#. type: textblock
#: C/ssl/SSL_CTX_get_ex_new_index.pod:49
msgid ""
"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)>"
msgstr ""
"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)>"

#. type: textblock
#: C/ssl/SSL_CTX_get_verify_mode.pod:5
msgid ""
"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"
msgstr ""
"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"

#. type: verbatim
#: C/ssl/SSL_CTX_get_verify_mode.pod:11
#, no-wrap
msgid ""
" int SSL_CTX_get_verify_mode(const SSL_CTX *ctx);\n"
" int SSL_get_verify_mode(const SSL *ssl);\n"
" int SSL_CTX_get_verify_depth(const SSL_CTX *ctx);\n"
" int SSL_get_verify_depth(const SSL *ssl);\n"
" int (*SSL_CTX_get_verify_callback(const SSL_CTX *ctx))(int, X509_STORE_CTX *);\n"
" int (*SSL_get_verify_callback(const SSL *ssl))(int, X509_STORE_CTX *);\n"
"\n"
msgstr ""
" int SSL_CTX_get_verify_mode(const SSL_CTX *ctx);\n"
" int SSL_get_verify_mode(const SSL *ssl);\n"
" int SSL_CTX_get_verify_depth(const SSL_CTX *ctx);\n"
" int SSL_get_verify_depth(const SSL *ssl);\n"
" int (*SSL_CTX_get_verify_callback(const SSL_CTX *ctx))(int, X509_STORE_CTX *);\n"
" int (*SSL_get_verify_callback(const SSL *ssl))(int, X509_STORE_CTX *);\n"
"\n"

#. type: textblock
#: C/ssl/SSL_CTX_get_verify_mode.pod:20
msgid ""
"SSL_CTX_get_verify_mode() returns the verification mode currently set in "
"B<ctx>."
msgstr ""
"B<SSL_CTX_get_verify_mode>() renvoie le mode de vérification actuellement "
"défini dans I<ctx>."

#. type: textblock
#: C/ssl/SSL_CTX_get_verify_mode.pod:23
msgid ""
"SSL_get_verify_mode() returns the verification mode currently set in B<ssl>."
msgstr ""
"B<SSL_get_verify_mode>() renvoie le mode de vérification actuellement défini "
"dans I<ssl>."

#. type: textblock
#: C/ssl/SSL_CTX_get_verify_mode.pod:26
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_get_verify_mode.pod:30
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_get_verify_mode.pod:34
msgid ""
"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."
msgstr ""
"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é."

#. type: textblock
#: C/ssl/SSL_CTX_get_verify_mode.pod:38
msgid ""
"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."
msgstr ""
"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é."

#. type: textblock
#: C/ssl/SSL_CTX_get_verify_mode.pod:44
msgid "See DESCRIPTION"
msgstr "Consultez la section B<DESCRIPTION>"

#. type: textblock
#: C/ssl/SSL_CTX_get_verify_mode.pod:48
msgid "L<ssl(3)|ssl(3)>, L<SSL_CTX_set_verify(3)|SSL_CTX_set_verify(3)>"
msgstr "L<B<ssl>(3)|ssl(3)>, L<B<SSL_CTX_set_verify>(3)|SSL_CTX_set_verify(3)>"

#. type: textblock
#: C/ssl/SSL_CTX_load_verify_locations.pod:5
msgid ""
"SSL_CTX_load_verify_locations - set default locations for trusted CA "
"certificates"
msgstr ""
"SSL_CTX_load_verify_locations - Définir l'emplacement par défaut des "
"certificats d'autorité de certification"

#. type: verbatim
#: C/ssl/SSL_CTX_load_verify_locations.pod:12
#, no-wrap
msgid ""
" int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,\n"
"                                   const char *CApath);\n"
"\n"
msgstr ""
" int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,\n"
"                                   const char *CApath);\n"
"\n"

#. type: textblock
#: C/ssl/SSL_CTX_load_verify_locations.pod:17
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_load_verify_locations.pod:23
msgid ""
"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"
msgstr ""
"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"

#. type: verbatim
#: C/ssl/SSL_CTX_load_verify_locations.pod:26
#, no-wrap
msgid ""
" -----BEGIN CERTIFICATE-----\n"
" ... (CA certificate in base64 encoding) ...\n"
" -----END CERTIFICATE-----\n"
"\n"
msgstr ""
" -----BEGIN CERTIFICATE-----\n"
" ... (CA certificate codé en base64) ...\n"
" -----END CERTIFICATE-----\n"
"\n"

#. type: textblock
#: C/ssl/SSL_CTX_load_verify_locations.pod:30
msgid ""
"sequences. Before, between, and after the certificates text is allowed which "
"can be used e.g. for descriptions of the certificates."
msgstr ""
"Avant, entre et après les certificats, il peut y avoir un texte qui peut, "
"par exemple, décrire les certificats."

#. type: textblock
#: C/ssl/SSL_CTX_load_verify_locations.pod:33
msgid ""
"The B<CAfile> is processed on execution of the "
"SSL_CTX_load_verify_locations()  function."
msgstr ""
"B<CAfile> est traité lors de l'exécution de la fonction "
"B<SSL_CTX_load_verify_locations>()"

#. type: textblock
#: C/ssl/SSL_CTX_load_verify_locations.pod:36
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_load_verify_locations.pod:45
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_load_verify_locations.pod:49
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_load_verify_locations.pod:58
msgid ""
"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."
msgstr ""
"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)>."

#. type: textblock
#: C/ssl/SSL_CTX_load_verify_locations.pod:65
msgid ""
"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)>."
msgstr ""
"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)>."

#. type: textblock
#: C/ssl/SSL_CTX_load_verify_locations.pod:73
msgid ""
"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."
msgstr ""
"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."

#. type: =head1
#: C/ssl/SSL_CTX_load_verify_locations.pod:80
msgid "EXAMPLES"
msgstr "EXEMPLES"

#. type: textblock
#: C/ssl/SSL_CTX_load_verify_locations.pod:82
msgid ""
"Generate a CA certificate file with descriptive text from the CA "
"certificates ca1.pem ca2.pem ca3.pem:"
msgstr ""
"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 :"

#. type: verbatim
#: C/ssl/SSL_CTX_load_verify_locations.pod:85
#, no-wrap
msgid ""
" #!/bin/sh\n"
" rm CAfile.pem\n"
" for i in ca1.pem ca2.pem ca3.pem ; do\n"
"   openssl x509 -in $i -text >> CAfile.pem\n"
" done\n"
"\n"
msgstr ""
" #!/bin/sh\n"
" rm CAfile.pem\n"
" for i in ca1.pem ca2.pem ca3.pem ; do\n"
"   openssl x509 -in $i -text >> CAfile.pem\n"
" done\n"
"\n"

#. type: textblock
#: C/ssl/SSL_CTX_load_verify_locations.pod:91
msgid ""
"Prepare the directory /some/where/certs containing several CA certificates "
"for use as B<CApath>:"
msgstr ""
"Préparer le répertoire /quelque/part/certificats contenant plusieurs "
"certificats d'autorité de certification à définir comme B<CApath> :"

#. type: verbatim
#: C/ssl/SSL_CTX_load_verify_locations.pod:94
#, no-wrap
msgid ""
" cd /some/where/certs\n"
" c_rehash .\n"
"\n"
msgstr ""
" cd /quelque/part/certificats\n"
" c_rehash .\n"
"\n"

#. type: textblock
#: C/ssl/SSL_CTX_load_verify_locations.pod:99 C/ssl/SSL_CTX_new.pod:88
msgid "The following return values can occur:"
msgstr "Les valeurs suivantes peuvent être renvoyées :"

#. type: textblock
#: C/ssl/SSL_CTX_load_verify_locations.pod:105
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_load_verify_locations.pod:111
msgid "The operation succeeded."
msgstr "L'opération a réussi."

#. type: textblock
#: C/ssl/SSL_CTX_load_verify_locations.pod:117
msgid ""
"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)>"
msgstr ""
"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)>"

#. type: textblock
#: C/ssl/SSL_CTX_new.pod:5
msgid ""
"SSL_CTX_new - create a new SSL_CTX object as framework for TLS/SSL enabled "
"functions"
msgstr ""
"SSL_CTX_new - Créer un nouvel objet B<SSL_CTX> comme cadre pour les "
"fonctions avec TLS/SSL actif."

#. type: verbatim
#: C/ssl/SSL_CTX_new.pod:11
#, no-wrap
msgid ""
" SSL_CTX *SSL_CTX_new(const SSL_METHOD *method);\n"
"\n"
msgstr ""
" SSL_CTX *SSL_CTX_new(const SSL_METHOD *method);\n"
"\n"

#. type: textblock
#: C/ssl/SSL_CTX_new.pod:15
msgid ""
"SSL_CTX_new() creates a new B<SSL_CTX> object as framework to establish TLS/"
"SSL enabled connections."
msgstr ""
"B<SSL_CTX_new>() crée un nouvel objet B<SSL_CTX> comme cadre pour établir "
"des connexions avec TLS/SSL actif."

#. type: textblock
#: C/ssl/SSL_CTX_new.pod:20
msgid ""
"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:"
msgstr ""
"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 :"

#. type: =item
#: C/ssl/SSL_CTX_new.pod:26
msgid ""
"SSLv2_method(void), SSLv2_server_method(void), SSLv2_client_method(void)"
msgstr ""
"SSLv2_method(void), SSLv2_server_method(void), SSLv2_client_method(void)"

#. type: textblock
#: C/ssl/SSL_CTX_new.pod:28
msgid ""
"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."
msgstr ""
"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."

#. type: =item
#: C/ssl/SSL_CTX_new.pod:33
msgid ""
"SSLv3_method(void), SSLv3_server_method(void), SSLv3_client_method(void)"
msgstr ""
"SSLv3_method(void), SSLv3_server_method(void), SSLv3_client_method(void)"

#. type: textblock
#: C/ssl/SSL_CTX_new.pod:35
msgid ""
"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()."
msgstr ""
"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>()."

#. type: =item
#: C/ssl/SSL_CTX_new.pod:42
msgid ""
"TLSv1_method(void), TLSv1_server_method(void), TLSv1_client_method(void)"
msgstr ""
"TLSv1_method(void), TLSv1_server_method(void), TLSv1_client_method(void)"

#. type: textblock
#: C/ssl/SSL_CTX_new.pod:44
msgid ""
"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."
msgstr ""
"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."

#. type: =item
#: C/ssl/SSL_CTX_new.pod:52
msgid ""
"SSLv23_method(void), SSLv23_server_method(void), SSLv23_client_method(void)"
msgstr ""
"SSLv23_method(void), SSLv23_server_method(void), SSLv23_client_method(void)"

#. type: textblock
#: C/ssl/SSL_CTX_new.pod:54
msgid ""
"A TLS/SSL connection established with these methods may understand the "
"SSLv2, SSLv3, TLSv1, TLSv1.1 and TLSv1.2 protocols."
msgstr ""
"Une connexion TLS/SSL établie avec ces méthodes peut comprendre les "
"protocoles SSLv2, SSLv3, TLSv1, TLSv1.1 et TLSv1.2 "

#. type: textblock
#: C/ssl/SSL_CTX_new.pod:57
msgid ""
"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."
msgstr ""
"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é."

#. type: textblock
#: C/ssl/SSL_CTX_new.pod:64
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_new.pod:72
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_new.pod:79
msgid ""
"Applications which never want to support SSLv2 (even is the cipher string is "
"configured to use SSLv2 ciphersuites) can set SSL_OP_NO_SSLv2."
msgstr ""
"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>."

#. type: textblock
#: C/ssl/SSL_CTX_new.pod:82
msgid ""
"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."
msgstr ""
"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."

#. type: =item
#: C/ssl/SSL_CTX_new.pod:92
msgid "NULL"
msgstr "NULL"

#. type: textblock
#: C/ssl/SSL_CTX_new.pod:94
msgid ""
"The creation of a new SSL_CTX object failed. Check the error stack to find "
"out the reason."
msgstr ""
"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."

#. type: =item
#: C/ssl/SSL_CTX_new.pod:97
msgid "Pointer to an SSL_CTX object"
msgstr "Pointeur vers un objet B<SSL_CTX>"

#. type: textblock
#: C/ssl/SSL_CTX_new.pod:99
msgid "The return value points to an allocated SSL_CTX object."
msgstr "La valeur renvoyée pointe vers un objet B<SSL_CTX> alloué."

#. type: textblock
#: C/ssl/SSL_CTX_new.pod:105
msgid ""
"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)>"
msgstr ""
"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)>"

#. type: textblock
#: C/ssl/SSL_CTX_sess_number.pod:5
msgid ""
"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"
msgstr ""
"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"

#. type: verbatim
#: C/ssl/SSL_CTX_sess_number.pod:11
#, no-wrap
msgid ""
" long SSL_CTX_sess_number(SSL_CTX *ctx);\n"
" long SSL_CTX_sess_connect(SSL_CTX *ctx);\n"
" long SSL_CTX_sess_connect_good(SSL_CTX *ctx);\n"
" long SSL_CTX_sess_connect_renegotiate(SSL_CTX *ctx);\n"
" long SSL_CTX_sess_accept(SSL_CTX *ctx);\n"
" long SSL_CTX_sess_accept_good(SSL_CTX *ctx);\n"
" long SSL_CTX_sess_accept_renegotiate(SSL_CTX *ctx);\n"
" long SSL_CTX_sess_hits(SSL_CTX *ctx);\n"
" long SSL_CTX_sess_cb_hits(SSL_CTX *ctx);\n"
" long SSL_CTX_sess_misses(SSL_CTX *ctx);\n"
" long SSL_CTX_sess_timeouts(SSL_CTX *ctx);\n"
" long SSL_CTX_sess_cache_full(SSL_CTX *ctx);\n"
"\n"
msgstr ""
" long SSL_CTX_sess_number(SSL_CTX *ctx);\n"
" long SSL_CTX_sess_connect(SSL_CTX *ctx);\n"
" long SSL_CTX_sess_connect_good(SSL_CTX *ctx);\n"
" long SSL_CTX_sess_connect_renegotiate(SSL_CTX *ctx);\n"
" long SSL_CTX_sess_accept(SSL_CTX *ctx);\n"
" long SSL_CTX_sess_accept_good(SSL_CTX *ctx);\n"
" long SSL_CTX_sess_accept_renegotiate(SSL_CTX *ctx);\n"
" long SSL_CTX_sess_hits(SSL_CTX *ctx);\n"
" long SSL_CTX_sess_cb_hits(SSL_CTX *ctx);\n"
" long SSL_CTX_sess_misses(SSL_CTX *ctx);\n"
" long SSL_CTX_sess_timeouts(SSL_CTX *ctx);\n"
" long SSL_CTX_sess_cache_full(SSL_CTX *ctx);\n"
"\n"

#. type: textblock
#: C/ssl/SSL_CTX_sess_number.pod:26
msgid ""
"SSL_CTX_sess_number() returns the current number of sessions in the internal "
"session cache."
msgstr ""
"B<SSL_CTX_sess_number>() renvoie le nombre actuel de sessions dans le cache "
"de sessions interne."

#. type: textblock
#: C/ssl/SSL_CTX_sess_number.pod:29
msgid ""
"SSL_CTX_sess_connect() returns the number of started SSL/TLS handshakes in "
"client mode."
msgstr ""
"B<SSL_CTX_sess_connect>() renvoie le nombre actuel d'initialisations de "
"connexion SSL/TLS démarrées en mode client."

#. type: textblock
#: C/ssl/SSL_CTX_sess_number.pod:32
msgid ""
"SSL_CTX_sess_connect_good() returns the number of successfully established "
"SSL/TLS sessions in client mode."
msgstr ""
"B<SSL_CTX_sess_connect_good>() renvoie le nombre de sessions SSL/TLS "
"établies avec succès en mode client."

#. type: textblock
#: C/ssl/SSL_CTX_sess_number.pod:35
msgid ""
"SSL_CTX_sess_connect_renegotiate() returns the number of start "
"renegotiations in client mode."
msgstr ""
"B<SSL_CTX_sess_connect_renegotiate>() renvoie le nombre de renégociations "
"démarrées en mode client."

#. type: textblock
#: C/ssl/SSL_CTX_sess_number.pod:38
msgid ""
"SSL_CTX_sess_accept() returns the number of started SSL/TLS handshakes in "
"server mode."
msgstr ""
"B<SSL_CTX_sess_accept>() renvoie le nombre d'initialisations de connexion "
"SSL/TLS démarrées en mode serveur."

#. type: textblock
#: C/ssl/SSL_CTX_sess_number.pod:41
msgid ""
"SSL_CTX_sess_accept_good() returns the number of successfully established "
"SSL/TLS sessions in server mode."
msgstr ""
"B<SSL_CTX_sess_accept_good>() renvoie le nombre de sessions SSL/TLS établies "
"avec succès en mode serveur."

#. type: textblock
#: C/ssl/SSL_CTX_sess_number.pod:44
msgid ""
"SSL_CTX_sess_accept_renegotiate() returns the number of start renegotiations "
"in server mode."
msgstr ""
"B<SSL_CTX_sess_accept_renegotiate>() renvoie le nombre de renégociations "
"démarrées en mode serveur."

#. type: textblock
#: C/ssl/SSL_CTX_sess_number.pod:47
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_sess_number.pod:52
msgid ""
"SSL_CTX_sess_cb_hits() returns the number of successfully retrieved sessions "
"from the external session cache in server mode."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_sess_number.pod:55
msgid ""
"SSL_CTX_sess_misses() returns the number of sessions proposed by clients "
"that were not found in the internal session cache in server mode."
msgstr ""
"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."

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

#. type: textblock
#: C/ssl/SSL_CTX_sess_number.pod:63
msgid ""
"SSL_CTX_sess_cache_full() returns the number of sessions that were removed "
"because the maximum session cache size was exceeded."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_sess_number.pod:68
msgid "The functions return the values indicated in the DESCRIPTION section."
msgstr ""
"Les fonctions renvoient les valeurs indiquées dans la partie DESCRIPTION."

#. type: textblock
#: C/ssl/SSL_CTX_sess_number.pod:72
msgid ""
"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)>"
msgstr ""
"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)>"

#. type: textblock
#: C/ssl/SSL_CTX_sess_set_cache_size.pod:5
msgid ""
"SSL_CTX_sess_set_cache_size, SSL_CTX_sess_get_cache_size - manipulate "
"session cache size"
msgstr ""
"SSL_CTX_sess_set_cache_size, SSL_CTX_sess_get_cache_size - Manipuler la "
"taille du cache de sessions"

#. type: verbatim
#: C/ssl/SSL_CTX_sess_set_cache_size.pod:11
#, no-wrap
msgid ""
" long SSL_CTX_sess_set_cache_size(SSL_CTX *ctx, long t);\n"
" long SSL_CTX_sess_get_cache_size(SSL_CTX *ctx);\n"
"\n"
msgstr ""
" long SSL_CTX_sess_set_cache_size(SSL_CTX *ctx, long t);\n"
" long SSL_CTX_sess_get_cache_size(SSL_CTX *ctx);\n"
"\n"

#. type: textblock
#: C/ssl/SSL_CTX_sess_set_cache_size.pod:16
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_sess_set_cache_size.pod:20
msgid ""
"SSL_CTX_sess_get_cache_size() returns the currently valid session cache size."
msgstr ""
"B<SSL_CTX_sess_get_cache_size>() renvoie la taille du cache de sessions "
"valable actuellement."

#. type: textblock
#: C/ssl/SSL_CTX_sess_set_cache_size.pod:24
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_sess_set_cache_size.pod:29
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_sess_set_cache_size.pod:35
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_sess_set_cache_size.pod:42
msgid "SSL_CTX_sess_set_cache_size() returns the previously valid size."
msgstr "B<SSL_CTX_sess_set_cache_size>() renvoie la taille valable précédente."

#. type: textblock
#: C/ssl/SSL_CTX_sess_set_cache_size.pod:44
msgid "SSL_CTX_sess_get_cache_size() returns the currently valid size."
msgstr ""
"B<SSL_CTX_sess_get_cache_size>() renvoie la taille valable actuellement."

#. type: textblock
#: C/ssl/SSL_CTX_sess_set_cache_size.pod:48
msgid ""
"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)>"
msgstr ""
"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)>"

#. type: textblock
#: C/ssl/SSL_CTX_sess_set_get_cb.pod:5
msgid ""
"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"
msgstr ""
"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"

#. type: verbatim
#: C/ssl/SSL_CTX_sess_set_get_cb.pod:11
#, no-wrap
msgid ""
" void SSL_CTX_sess_set_new_cb(SSL_CTX *ctx,\n"
"\t\t\t      int (*new_session_cb)(SSL *, SSL_SESSION *));\n"
" void SSL_CTX_sess_set_remove_cb(SSL_CTX *ctx,\n"
"\t   void (*remove_session_cb)(SSL_CTX *ctx, SSL_SESSION *));\n"
" void SSL_CTX_sess_set_get_cb(SSL_CTX *ctx,\n"
"\t   SSL_SESSION (*get_session_cb)(SSL *, unsigned char *, int, int *));\n"
"\n"
msgstr ""
" void SSL_CTX_sess_set_new_cb(SSL_CTX *ctx,\n"
"\t\t\t      int (*new_session_cb)(SSL *, SSL_SESSION *));\n"
" void SSL_CTX_sess_set_remove_cb(SSL_CTX *ctx,\n"
"\t   void (*remove_session_cb)(SSL_CTX *ctx, SSL_SESSION *));\n"
" void SSL_CTX_sess_set_get_cb(SSL_CTX *ctx,\n"
"\t   SSL_SESSION (*get_session_cb)(SSL *, unsigned char *, int, int *));\n"
"\n"

#. type: verbatim
#: C/ssl/SSL_CTX_sess_set_get_cb.pod:18
#, no-wrap
msgid ""
" int (*SSL_CTX_sess_get_new_cb(SSL_CTX *ctx))(struct ssl_st *ssl, SSL_SESSION *sess);\n"
" void (*SSL_CTX_sess_get_remove_cb(SSL_CTX *ctx))(struct ssl_ctx_st *ctx, SSL_SESSION *sess);\n"
" SSL_SESSION *(*SSL_CTX_sess_get_get_cb(SSL_CTX *ctx))(struct ssl_st *ssl, unsigned char *data, int len, int *copy);\n"
"\n"
msgstr ""
" int (*SSL_CTX_sess_get_new_cb(SSL_CTX *ctx))(struct ssl_st *ssl, SSL_SESSION *sess);\n"
" void (*SSL_CTX_sess_get_remove_cb(SSL_CTX *ctx))(struct ssl_ctx_st *ctx, SSL_SESSION *sess);\n"
" SSL_SESSION *(*SSL_CTX_sess_get_get_cb(SSL_CTX *ctx))(struct ssl_st *ssl, unsigned char *data, int len, int *copy);\n"
"\n"

#. type: verbatim
#: C/ssl/SSL_CTX_sess_set_get_cb.pod:22
#, no-wrap
msgid ""
" int (*new_session_cb)(struct ssl_st *ssl, SSL_SESSION *sess);\n"
" void (*remove_session_cb)(struct ssl_ctx_st *ctx, SSL_SESSION *sess);\n"
" SSL_SESSION *(*get_session_cb)(struct ssl_st *ssl, unsigned char *data,\n"
"\t       int len, int *copy);\n"
"\n"
msgstr ""
" int (*new_session_cb)(struct ssl_st *ssl, SSL_SESSION *sess);\n"
" void (*remove_session_cb)(struct ssl_ctx_st *ctx, SSL_SESSION *sess);\n"
" SSL_SESSION *(*get_session_cb)(struct ssl_st *ssl, unsigned char *data,\n"
"\t       int len, int *copy);\n"
"\n"

#. type: textblock
#: C/ssl/SSL_CTX_sess_set_get_cb.pod:29
msgid ""
"SSL_CTX_sess_set_new_cb() sets the callback function, which is automatically "
"called whenever a new session was negotiated."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_sess_set_get_cb.pod:32
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_sess_set_get_cb.pod:37
msgid ""
"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.)"
msgstr ""
"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)"

#. type: textblock
#: C/ssl/SSL_CTX_sess_set_get_cb.pod:43
msgid ""
"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."
msgstr ""
"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é."

#. type: textblock
#: C/ssl/SSL_CTX_sess_set_get_cb.pod:50
msgid ""
"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."
msgstr ""
"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)>."

#. type: textblock
#: C/ssl/SSL_CTX_sess_set_get_cb.pod:55
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_sess_set_get_cb.pod:62
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_sess_set_get_cb.pod:69
msgid ""
"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)>."
msgstr ""
"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)>."

#. type: textblock
#: C/ssl/SSL_CTX_sess_set_get_cb.pod:81
msgid ""
"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)>"
msgstr ""
"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)>"

#. type: textblock
#: C/ssl/SSL_CTX_sessions.pod:5
msgid "SSL_CTX_sessions - access internal session cache"
msgstr "SSL_CTX_sessions - Accéder au cache interne de sessions"

#. type: verbatim
#: C/ssl/SSL_CTX_sessions.pod:11
#, no-wrap
msgid ""
" struct lhash_st *SSL_CTX_sessions(SSL_CTX *ctx);\n"
"\n"
msgstr ""
" struct lhash_st *SSL_CTX_sessions(SSL_CTX *ctx);\n"
"\n"

#. type: textblock
#: C/ssl/SSL_CTX_sessions.pod:15
msgid ""
"SSL_CTX_sessions() returns a pointer to the lhash databases containing the "
"internal session cache for B<ctx>."
msgstr ""
"B<SSL_CTX_sessions>() renvoie un pointeur vers les bases de données lhash "
"contenant le cache interne de sessions pour I<ctx>."

#. type: textblock
#: C/ssl/SSL_CTX_sessions.pod:20
msgid ""
"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."
msgstr ""
"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)>."

#. type: textblock
#: C/ssl/SSL_CTX_sessions.pod:30
msgid ""
"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)>"
msgstr ""
"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)>"

#. type: textblock
#: C/ssl/SSL_CTX_use_certificate.pod:5
msgid ""
"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"
msgstr ""
"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é"

#. type: verbatim
#: C/ssl/SSL_CTX_use_certificate.pod:11
#, no-wrap
msgid ""
" int SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x);\n"
" int SSL_CTX_use_certificate_ASN1(SSL_CTX *ctx, int len, unsigned char *d);\n"
" int SSL_CTX_use_certificate_file(SSL_CTX *ctx, const char *file, int type);\n"
" int SSL_use_certificate(SSL *ssl, X509 *x);\n"
" int SSL_use_certificate_ASN1(SSL *ssl, unsigned char *d, int len);\n"
" int SSL_use_certificate_file(SSL *ssl, const char *file, int type);\n"
"\n"
msgstr ""
" int SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x);\n"
" int SSL_CTX_use_certificate_ASN1(SSL_CTX *ctx, int len, unsigned char *d);\n"
" int SSL_CTX_use_certificate_file(SSL_CTX *ctx, const char *file, int type);\n"
" int SSL_use_certificate(SSL *ssl, X509 *x);\n"
" int SSL_use_certificate_ASN1(SSL *ssl, unsigned char *d, int len);\n"
" int SSL_use_certificate_file(SSL *ssl, const char *file, int type);\n"
"\n"

#. type: verbatim
#: C/ssl/SSL_CTX_use_certificate.pod:18
#, no-wrap
msgid ""
" int SSL_CTX_use_certificate_chain_file(SSL_CTX *ctx, const char *file);\n"
"\n"
msgstr ""
" int SSL_CTX_use_certificate_chain_file(SSL_CTX *ctx, const char *file);\n"
"\n"

#. type: verbatim
#: C/ssl/SSL_CTX_use_certificate.pod:20
#, no-wrap
msgid ""
" int SSL_CTX_use_PrivateKey(SSL_CTX *ctx, EVP_PKEY *pkey);\n"
" int SSL_CTX_use_PrivateKey_ASN1(int pk, SSL_CTX *ctx, unsigned char *d,\n"
"\t\t\t\t long len);\n"
" int SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, const char *file, int type);\n"
" int SSL_CTX_use_RSAPrivateKey(SSL_CTX *ctx, RSA *rsa);\n"
" int SSL_CTX_use_RSAPrivateKey_ASN1(SSL_CTX *ctx, unsigned char *d, long len);\n"
" int SSL_CTX_use_RSAPrivateKey_file(SSL_CTX *ctx, const char *file, int type);\n"
" int SSL_use_PrivateKey(SSL *ssl, EVP_PKEY *pkey);\n"
" int SSL_use_PrivateKey_ASN1(int pk,SSL *ssl, unsigned char *d, long len);\n"
" int SSL_use_PrivateKey_file(SSL *ssl, const char *file, int type);\n"
" int SSL_use_RSAPrivateKey(SSL *ssl, RSA *rsa);\n"
" int SSL_use_RSAPrivateKey_ASN1(SSL *ssl, unsigned char *d, long len);\n"
" int SSL_use_RSAPrivateKey_file(SSL *ssl, const char *file, int type);\n"
"\n"
msgstr ""
" int SSL_CTX_use_PrivateKey(SSL_CTX *ctx, EVP_PKEY *pkey);\n"
" int SSL_CTX_use_PrivateKey_ASN1(int pk, SSL_CTX *ctx, unsigned char *d,\n"
"\t\t\t\t long len);\n"
" int SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, const char *file, int type);\n"
" int SSL_CTX_use_RSAPrivateKey(SSL_CTX *ctx, RSA *rsa);\n"
" int SSL_CTX_use_RSAPrivateKey_ASN1(SSL_CTX *ctx, unsigned char *d, long len);\n"
" int SSL_CTX_use_RSAPrivateKey_file(SSL_CTX *ctx, const char *file, int type);\n"
" int SSL_use_PrivateKey(SSL *ssl, EVP_PKEY *pkey);\n"
" int SSL_use_PrivateKey_ASN1(int pk,SSL *ssl, unsigned char *d, long len);\n"
" int SSL_use_PrivateKey_file(SSL *ssl, const char *file, int type);\n"
" int SSL_use_RSAPrivateKey(SSL *ssl, RSA *rsa);\n"
" int SSL_use_RSAPrivateKey_ASN1(SSL *ssl, unsigned char *d, long len);\n"
" int SSL_use_RSAPrivateKey_file(SSL *ssl, const char *file, int type);\n"
"\n"

#. type: verbatim
#: C/ssl/SSL_CTX_use_certificate.pod:34
#, no-wrap
msgid ""
" int SSL_CTX_check_private_key(const SSL_CTX *ctx);\n"
" int SSL_check_private_key(const SSL *ssl);\n"
"\n"
msgstr ""
" int SSL_CTX_check_private_key(const SSL_CTX *ctx);\n"
" int SSL_check_private_key(const SSL *ssl);\n"
"\n"

#. type: textblock
#: C/ssl/SSL_CTX_use_certificate.pod:39
msgid ""
"These functions load the certificates and private keys into the SSL_CTX or "
"SSL object, respectively."
msgstr ""
"Ces fonctions chargent les certificats et les clés privés dans l'objet "
"B<SSL_CTX> et l'objet B<SSL>, respectivement."

#. type: textblock
#: C/ssl/SSL_CTX_use_certificate.pod:42
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_use_certificate.pod:47
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_use_certificate.pod:51
msgid ""
"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."
msgstr ""
"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)>."

#. type: textblock
#: C/ssl/SSL_CTX_use_certificate.pod:58
msgid ""
"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>."
msgstr ""
"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>."

#. type: textblock
#: C/ssl/SSL_CTX_use_certificate.pod:62
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_use_certificate.pod:69
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_use_certificate.pod:76
msgid ""
"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()."
msgstr ""
"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>()."

#. type: textblock
#: C/ssl/SSL_CTX_use_certificate.pod:87
msgid ""
"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>."
msgstr ""
"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>."

#. type: textblock
#: C/ssl/SSL_CTX_use_certificate.pod:94
msgid ""
"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>."
msgstr ""
"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>."

#. type: textblock
#: C/ssl/SSL_CTX_use_certificate.pod:102
msgid ""
"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."
msgstr ""
"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é."

#. type: textblock
#: C/ssl/SSL_CTX_use_certificate.pod:112
msgid ""
"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)>."
msgstr ""
"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)>."

#. type: textblock
#: C/ssl/SSL_CTX_use_certificate.pod:116
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_use_certificate.pod:122
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_use_certificate.pod:132
msgid ""
"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)>."
msgstr ""
"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)>."

#. type: textblock
#: C/ssl/SSL_CTX_use_certificate.pod:137
msgid ""
"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.)"
msgstr ""
"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.)"

#. type: textblock
#: C/ssl/SSL_CTX_use_certificate.pod:147
msgid ""
"On success, the functions return 1.  Otherwise check out the error stack to "
"find out the reason."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_use_certificate.pod:152
msgid ""
"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)>"
msgstr ""
"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)>"

#. type: textblock
#: C/ssl/SSL_CTX_use_certificate.pod:161
msgid ""
"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 ."
msgstr ""
"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 ."

#. type: =end
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:3
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:30
msgid "comment"
msgstr "comment"

#. type: textblock
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:5
msgid "Copyright 2005 Nokia. All rights reserved."
msgstr "Copyright 2005 Nokia. All rights reserved."

#. type: textblock
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:7
msgid ""
"The portions of the attached software (\"Contribution\") is developed by "
"Nokia Corporation and is licensed pursuant to the OpenSSL open source "
"license."
msgstr ""
"The portions of the attached software (\"Contribution\") is developed by "
"Nokia Corporation and is licensed pursuant to the OpenSSL open source "
"license."

#. type: textblock
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:11
msgid ""
"The Contribution, originally written by Mika Kousa and Pasi Eronen of Nokia "
"Corporation, consists of the \"PSK\" (Pre-Shared Key) ciphersuites support "
"(see RFC 4279) to OpenSSL."
msgstr ""
"The Contribution, originally written by Mika Kousa and Pasi Eronen of Nokia "
"Corporation, consists of the \"PSK\" (Pre-Shared Key) ciphersuites support "
"(see RFC 4279) to OpenSSL."

#. type: textblock
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:15
msgid ""
"No patent licenses or other rights except those expressly stated in the "
"OpenSSL open source license shall be deemed granted or received expressly, "
"by implication, estoppel, or otherwise."
msgstr ""
"No patent licenses or other rights except those expressly stated in the "
"OpenSSL open source license shall be deemed granted or received expressly, "
"by implication, estoppel, or otherwise."

#. type: textblock
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:19
msgid ""
"No assurances are provided by Nokia that the Contribution does not infringe "
"the patent or other intellectual property rights of any third party or that "
"the license provides you with all the necessary rights to make use of the "
"Contribution."
msgstr ""
"No assurances are provided by Nokia that the Contribution does not infringe "
"the patent or other intellectual property rights of any third party or that "
"the license provides you with all the necessary rights to make use of the "
"Contribution."

#. type: textblock
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:24
msgid ""
"THE SOFTWARE IS PROVIDED \"AS IS\" WITHOUT WARRANTY OF ANY KIND. IN ADDITION "
"TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA SPECIFICALLY DISCLAIMS ANY "
"LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY OTHER ENTITY BASED ON "
"INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR OTHERWISE."
msgstr ""
"THE SOFTWARE IS PROVIDED \"AS IS\" WITHOUT WARRANTY OF ANY KIND. IN ADDITION "
"TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA SPECIFICALLY DISCLAIMS ANY "
"LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY OTHER ENTITY BASED ON "
"INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR OTHERWISE."

#. type: textblock
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:34
msgid ""
"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"
msgstr ""
"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"

#. type: verbatim
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:43
#, no-wrap
msgid ""
" int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx, const char *hint);\n"
" int SSL_use_psk_identity_hint(SSL *ssl, const char *hint);\n"
"\n"
msgstr ""
" int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx, const char *hint);\n"
" int SSL_use_psk_identity_hint(SSL *ssl, const char *hint);\n"
"\n"

#. type: verbatim
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:46
#, no-wrap
msgid ""
" void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx,\n"
"\tunsigned int (*callback)(SSL *ssl, const char *identity,\n"
"\tunsigned char *psk, int max_psk_len));\n"
" void SSL_set_psk_server_callback(SSL *ssl,\n"
"\tunsigned int (*callback)(SSL *ssl, const char *identity,\n"
"\tunsigned char *psk, int max_psk_len));\n"
"\n"
msgstr ""
" void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx,\n"
"\tunsigned int (*callback)(SSL *ssl, const char *identity,\n"
"\tunsigned char *psk, int max_psk_len));\n"
" void SSL_set_psk_server_callback(SSL *ssl,\n"
"\tunsigned int (*callback)(SSL *ssl, const char *identity,\n"
"\tunsigned char *psk, int max_psk_len));\n"
"\n"

#. type: textblock
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:56
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:62
msgid ""
"In the case where PSK identity hint is B<NULL>, the server does not send the "
"ServerKeyExchange message to the client."
msgstr ""
"Dans le cas où l'indice d'identité PSK est NULL, le serveur n'envoie pas le "
"message ServerKeyExchange au client."

#. type: textblock
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:65
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:79
msgid ""
"SSL_CTX_use_psk_identity_hint() and SSL_use_psk_identity_hint() return 1 on "
"success, 0 otherwise."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:82
msgid "Return values from the server callback are interpreted as follows:"
msgstr "Les valeurs de retour du rappel serveur sont interprétées comme suit."

#. type: textblock
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:88
msgid ""
"PSK identity was not found. An \"unknown_psk_identity\" alert message will "
"be sent and the connection setup fails."
msgstr ""
"L'identité PSK n'a pas été trouvée. Un message d'alerte "
"« unknown_psk_identity » sera envoyé et la configuration de connexion échoue."

#. type: =item
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:91
msgid "E<gt>0"
msgstr "E<gt>0"

#. type: textblock
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:93
msgid ""
"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>."
msgstr ""
"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>."

#. type: textblock
#: C/ssl/SSL_CTX_use_psk_identity_hint.pod:98
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_use_serverinfo.pod:5
msgid ""
"SSL_CTX_use_serverinfo, SSL_CTX_use_serverinfo_file - use serverinfo "
"extension"
msgstr ""
"SSL_CTX_use_serverinfo, SSL_CTX_use_serverinfo_file - Utiliser lâ??extension "
"serverinfo"

#. type: verbatim
#: C/ssl/SSL_CTX_use_serverinfo.pod:11
#, no-wrap
msgid ""
" int SSL_CTX_use_serverinfo(SSL_CTX *ctx, const unsigned char *serverinfo,\n"
"                            size_t serverinfo_length);\n"
"\n"
msgstr ""
" int SSL_CTX_use_serverinfo(SSL_CTX *ctx, const unsigned char *serverinfo,\n"
"                            size_t serverinfo_length);\n"
"\n"

#. type: verbatim
#: C/ssl/SSL_CTX_use_serverinfo.pod:14
#, no-wrap
msgid ""
" int SSL_CTX_use_serverinfo_file(SSL_CTX *ctx, const char *file);\n"
"\n"
msgstr ""
" int SSL_CTX_use_serverinfo_file(SSL_CTX *ctx, const char *file);\n"
"\n"

#. type: textblock
#: C/ssl/SSL_CTX_use_serverinfo.pod:18
msgid ""
"These functions load \"serverinfo\" TLS ServerHello Extensions into the "
"SSL_CTX.  A \"serverinfo\" extension is returned in response to an empty "
"ClientHello Extension."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_use_serverinfo.pod:22
msgid ""
"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."
msgstr ""
"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."

#. type: textblock
#: C/ssl/SSL_CTX_use_serverinfo.pod:27
msgid ""
"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 \"."
msgstr ""
"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 »."

#. type: textblock
#: C/ssl/SSL_CTX_use_serverinfo.pod:37
msgid ""
"On success, the functions return 1.  On failure, the functions return 0.  "
"Check out the error stack to find out the reason."
msgstr ""
"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."

#~ msgid "SSL_CTX_add_extra_chain_cert - add certificate to chain"
#~ msgstr "SSL_CTX_add_extra_chain_cert - Ajouter un certificat à une chaîne"

#~ msgid ""
#~ " long SSL_CTX_add_extra_chain_cert(SSL_CTX ctx, X509 *x509)\n"
#~ "\n"
#~ msgstr ""
#~ " long SSL_CTX_add_extra_chain_cert(SSL_CTX ctx, X509 *x509)\n"
#~ "\n"

#~ msgid ""
#~ "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)>"
#~ msgstr ""
#~ "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)>"

#~ msgid "> 0"
#~ msgstr "> 0"

#~ msgid "C<0>"
#~ msgstr "Z<>0"

#~ msgid "C<1>"
#~ msgstr "Z<>1"

#~ msgid "0"
#~ msgstr "0"

#~ msgid "1"
#~ msgstr "1"
# French translations for the openssl package
# Copyright (C) 2008, 2012, 2013, 2015 Debian French l10n team <debian-l10n-french@lists.debian.org>.
# This file is distributed under the same license as the openssl package.
#
# Nicolas François <nicolas.francois@centraliens.net>, 2008.
# David Prévot <david@tilapin.org>, 2012, 2013, 2015.
msgid ""
msgstr ""
"Project-Id-Version: openssl\n"
"POT-Creation-Date: 2015-12-31 16:46-0400\n"
"PO-Revision-Date: 2015-12-31 18:27-0400\n"
"Last-Translator: none yet\n"
"Language-Team: French <debian-l10n-french@lists.debian.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
"X-Generator: Lokalize 2.0\n"

#. type: =head1
#: C/crypto/BN_BLINDING_new.pod:3 C/crypto/BN_CTX_new.pod:3
#: C/crypto/BN_CTX_start.pod:3 C/crypto/BN_add.pod:3 C/crypto/BN_add_word.pod:3
#: C/crypto/BN_bn2bin.pod:3 C/crypto/BN_cmp.pod:3 C/crypto/BN_copy.pod:3
#: C/crypto/BN_generate_prime.pod:3 C/crypto/BN_mod_inverse.pod:3
#: C/crypto/BN_mod_mul_montgomery.pod:3 C/crypto/BN_mod_mul_reciprocal.pod:3
#: C/crypto/BN_new.pod:3 C/crypto/BN_num_bytes.pod:3 C/crypto/BN_rand.pod:3
#: C/crypto/BN_set_bit.pod:3 C/crypto/BN_swap.pod:3 C/crypto/BN_zero.pod:3
#: C/crypto/bn.pod:3 C/crypto/bn_internal.pod:3
msgid "NAME"
msgstr "NOM"

#. type: textblock
#: C/crypto/BN_BLINDING_new.pod:5
msgid ""
"BN_BLINDING_new, BN_BLINDING_free, BN_BLINDING_update, BN_BLINDING_convert, "
"BN_BLINDING_invert, BN_BLINDING_convert_ex, BN_BLINDING_invert_ex, "
"BN_BLINDING_get_thread_id, BN_BLINDING_set_thread_id, BN_BLINDING_thread_id, "
"BN_BLINDING_get_flags, BN_BLINDING_set_flags, BN_BLINDING_create_param - "
"blinding related BIGNUM functions."
msgstr ""

#. type: =head1
#: C/crypto/BN_BLINDING_new.pod:11 C/crypto/BN_CTX_new.pod:7
#: C/crypto/BN_CTX_start.pod:7 C/crypto/BN_add.pod:9 C/crypto/BN_add_word.pod:8
#: C/crypto/BN_bn2bin.pod:8 C/crypto/BN_cmp.pod:7 C/crypto/BN_copy.pod:7
#: C/crypto/BN_generate_prime.pod:9 C/crypto/BN_mod_inverse.pod:7
#: C/crypto/BN_mod_mul_montgomery.pod:9 C/crypto/BN_mod_mul_reciprocal.pod:9
#: C/crypto/BN_new.pod:7 C/crypto/BN_num_bytes.pod:7 C/crypto/BN_rand.pod:7
#: C/crypto/BN_set_bit.pod:8 C/crypto/BN_swap.pod:7 C/crypto/BN_zero.pod:8
#: C/crypto/bn.pod:7 C/crypto/bn_internal.pod:14
msgid "SYNOPSIS"
msgstr "SYNOPSIS"

#. type: verbatim
#: C/crypto/BN_BLINDING_new.pod:13 C/crypto/BN_CTX_new.pod:9
#: C/crypto/BN_CTX_start.pod:9 C/crypto/BN_add.pod:11
#: C/crypto/BN_add_word.pod:10 C/crypto/BN_bn2bin.pod:10 C/crypto/BN_cmp.pod:9
#: C/crypto/BN_copy.pod:9 C/crypto/BN_generate_prime.pod:11
#: C/crypto/BN_mod_inverse.pod:9 C/crypto/BN_mod_mul_montgomery.pod:11
#: C/crypto/BN_mod_mul_reciprocal.pod:11 C/crypto/BN_new.pod:9
#: C/crypto/BN_num_bytes.pod:9 C/crypto/BN_rand.pod:9
#: C/crypto/BN_set_bit.pod:10 C/crypto/BN_swap.pod:9 C/crypto/BN_zero.pod:10
#: C/crypto/bn.pod:9 C/crypto/bn_internal.pod:16
#, no-wrap
msgid ""
" #include <openssl/bn.h>\n"
"\n"
msgstr ""
" #include <openssl/bn.h>\n"
"\n"

#. type: verbatim
#: C/crypto/BN_BLINDING_new.pod:15
#, no-wrap
msgid ""
" BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai,\n"
"\tBIGNUM *mod);\n"
" void BN_BLINDING_free(BN_BLINDING *b);\n"
" int BN_BLINDING_update(BN_BLINDING *b,BN_CTX *ctx);\n"
" int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);\n"
" int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);\n"
" int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b,\n"
"\tBN_CTX *ctx);\n"
" int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b,\n"
"\tBN_CTX *ctx);\n"
" #ifndef OPENSSL_NO_DEPRECATED\n"
" unsigned long BN_BLINDING_get_thread_id(const BN_BLINDING *);\n"
" void BN_BLINDING_set_thread_id(BN_BLINDING *, unsigned long);\n"
" #endif\n"
" CRYPTO_THREADID *BN_BLINDING_thread_id(BN_BLINDING *);\n"
" unsigned long BN_BLINDING_get_flags(const BN_BLINDING *);\n"
" void BN_BLINDING_set_flags(BN_BLINDING *, unsigned long);\n"
" BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b,\n"
"\tconst BIGNUM *e, BIGNUM *m, BN_CTX *ctx,\n"
"\tint (*bn_mod_exp)(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,\n"
"\t\t\t  const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx),\n"
"\tBN_MONT_CTX *m_ctx);\n"
"\n"
msgstr ""
" BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai,\n"
"\tBIGNUM *mod);\n"
" void BN_BLINDING_free(BN_BLINDING *b);\n"
" int BN_BLINDING_update(BN_BLINDING *b,BN_CTX *ctx);\n"
" int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);\n"
" int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);\n"
" int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b,\n"
"\tBN_CTX *ctx);\n"
" int BN_BLINDING_invert_ex(BIGNUM *n,const BIGNUM *r,BN_BLINDING *b,\n"
"\tBN_CTX *ctx);\n"
" #ifndef OPENSSL_NO_DEPRECATED\n"
" unsigned long BN_BLINDING_get_thread_id(const BN_BLINDING *);\n"
" void BN_BLINDING_set_thread_id(BN_BLINDING *, unsigned long);\n"
" #endif\n"
" CRYPTO_THREADID *BN_BLINDING_thread_id(BN_BLINDING *);\n"
" unsigned long BN_BLINDING_get_flags(const BN_BLINDING *);\n"
" void BN_BLINDING_set_flags(BN_BLINDING *, unsigned long);\n"
" BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b,\n"
"\tconst BIGNUM *e, BIGNUM *m, BN_CTX *ctx,\n"
"\tint (*bn_mod_exp)(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,\n"
"\t\t\t  const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx),\n"
"\tBN_MONT_CTX *m_ctx);\n"
"\n"

#. type: =head1
#: C/crypto/BN_BLINDING_new.pod:38 C/crypto/BN_CTX_new.pod:20
#: C/crypto/BN_CTX_start.pod:17 C/crypto/BN_add.pod:46
#: C/crypto/BN_add_word.pod:22 C/crypto/BN_bn2bin.pod:26 C/crypto/BN_cmp.pod:19
#: C/crypto/BN_copy.pod:15 C/crypto/BN_generate_prime.pod:40
#: C/crypto/BN_mod_inverse.pod:14 C/crypto/BN_mod_mul_montgomery.pod:29
#: C/crypto/BN_mod_mul_reciprocal.pod:25 C/crypto/BN_new.pod:21
#: C/crypto/BN_num_bytes.pod:17 C/crypto/BN_rand.pod:19
#: C/crypto/BN_set_bit.pod:25 C/crypto/BN_swap.pod:13 C/crypto/BN_zero.pod:20
#: C/crypto/bn.pod:144 C/crypto/bn_internal.pod:66
msgid "DESCRIPTION"
msgstr "DESCRIPTION"

#. type: textblock
#: C/crypto/BN_BLINDING_new.pod:40
msgid ""
"BN_BLINDING_new() allocates a new B<BN_BLINDING> structure and copies the "
"B<A> and B<Ai> values into the newly created B<BN_BLINDING> object."
msgstr ""

#. type: textblock
#: C/crypto/BN_BLINDING_new.pod:43
msgid "BN_BLINDING_free() frees the B<BN_BLINDING> structure."
msgstr ""

#. type: textblock
#: C/crypto/BN_BLINDING_new.pod:45
msgid ""
"BN_BLINDING_update() updates the B<BN_BLINDING> parameters by squaring the "
"B<A> and B<Ai> or, after specific number of uses and if the necessary "
"parameters are set, by re-creating the blinding parameters."
msgstr ""

#. type: textblock
#: C/crypto/BN_BLINDING_new.pod:49
msgid ""
"BN_BLINDING_convert_ex() multiplies B<n> with the blinding factor B<A>.  If "
"B<r> is not NULL a copy the inverse blinding factor B<Ai> will be returned "
"in B<r> (this is useful if a B<RSA> object is shared among several threads). "
"BN_BLINDING_invert_ex() multiplies B<n> with the inverse blinding factor "
"B<Ai>. If B<r> is not NULL it will be used as the inverse blinding."
msgstr ""

#. type: textblock
#: C/crypto/BN_BLINDING_new.pod:56
msgid ""
"BN_BLINDING_convert() and BN_BLINDING_invert() are wrapper functions for "
"BN_BLINDING_convert_ex() and BN_BLINDING_invert_ex()  with B<r> set to NULL."
msgstr ""

#. type: textblock
#: C/crypto/BN_BLINDING_new.pod:60
msgid ""
"BN_BLINDING_thread_id() provides access to the B<CRYPTO_THREADID> object "
"within the B<BN_BLINDING> structure. This is to help users provide proper "
"locking if needed for multi-threaded use. The \"thread id\" object of a "
"newly allocated B<BN_BLINDING> structure is initialised to the thread id in "
"which BN_BLINDING_new() was called."
msgstr ""

#. type: textblock
#: C/crypto/BN_BLINDING_new.pod:66
msgid ""
"BN_BLINDING_get_flags() returns the BN_BLINDING flags. Currently there are "
"two supported flags: B<BN_BLINDING_NO_UPDATE> and "
"B<BN_BLINDING_NO_RECREATE>. B<BN_BLINDING_NO_UPDATE> inhibits the automatic "
"update of the B<BN_BLINDING> parameters after each use and "
"B<BN_BLINDING_NO_RECREATE> inhibits the automatic re-creation of the "
"B<BN_BLINDING> parameters after a fixed number of uses (currently 32). In "
"newly allocated B<BN_BLINDING> objects no flags are set.  "
"BN_BLINDING_set_flags() sets the B<BN_BLINDING> parameters flags."
msgstr ""

#. type: textblock
#: C/crypto/BN_BLINDING_new.pod:75
msgid ""
"BN_BLINDING_create_param() creates new B<BN_BLINDING> parameters using the "
"exponent B<e> and the modulus B<m>. B<bn_mod_exp> and B<m_ctx> can be used "
"to pass special functions for exponentiation (normally BN_mod_exp_mont() and "
"B<BN_MONT_CTX>)."
msgstr ""

#. type: =head1
#: C/crypto/BN_BLINDING_new.pod:80 C/crypto/BN_CTX_new.pod:39
#: C/crypto/BN_CTX_start.pod:33 C/crypto/BN_add.pod:106
#: C/crypto/BN_add_word.pod:40 C/crypto/BN_bn2bin.pod:65 C/crypto/BN_cmp.pod:29
#: C/crypto/BN_copy.pod:20 C/crypto/BN_generate_prime.pod:124
#: C/crypto/BN_mod_inverse.pod:23 C/crypto/BN_mod_mul_montgomery.pod:73
#: C/crypto/BN_mod_mul_reciprocal.pod:60 C/crypto/BN_new.pod:34
#: C/crypto/BN_num_bytes.pod:30 C/crypto/BN_rand.pod:42
#: C/crypto/BN_set_bit.pod:49 C/crypto/BN_zero.pod:31
msgid "RETURN VALUES"
msgstr "VALEURS DE RETOUR"

#. type: textblock
#: C/crypto/BN_BLINDING_new.pod:82
msgid ""
"BN_BLINDING_new() returns the newly allocated B<BN_BLINDING> structure or "
"NULL in case of an error."
msgstr ""

#. type: textblock
#: C/crypto/BN_BLINDING_new.pod:85
msgid ""
"BN_BLINDING_update(), BN_BLINDING_convert(), BN_BLINDING_invert(), "
"BN_BLINDING_convert_ex() and BN_BLINDING_invert_ex() return 1 on success and "
"0 if an error occurred."
msgstr ""

#. type: textblock
#: C/crypto/BN_BLINDING_new.pod:89
msgid ""
"BN_BLINDING_thread_id() returns a pointer to the thread id object within a "
"B<BN_BLINDING> object."
msgstr ""

#. type: textblock
#: C/crypto/BN_BLINDING_new.pod:92
msgid ""
"BN_BLINDING_get_flags() returns the currently set B<BN_BLINDING> flags (a "
"B<unsigned long> value)."
msgstr ""

#. type: textblock
#: C/crypto/BN_BLINDING_new.pod:95
msgid ""
"BN_BLINDING_create_param() returns the newly created B<BN_BLINDING> "
"parameters or NULL on error."
msgstr ""

#. type: =head1
#: C/crypto/BN_BLINDING_new.pod:98 C/crypto/BN_CTX_new.pod:47
#: C/crypto/BN_CTX_start.pod:44 C/crypto/BN_add.pod:112
#: C/crypto/BN_add_word.pod:48 C/crypto/BN_bn2bin.pod:81 C/crypto/BN_cmp.pod:38
#: C/crypto/BN_copy.pod:26 C/crypto/BN_generate_prime.pod:139
#: C/crypto/BN_mod_inverse.pod:28 C/crypto/BN_mod_mul_montgomery.pod:88
#: C/crypto/BN_mod_mul_reciprocal.pod:70 C/crypto/BN_new.pod:43
#: C/crypto/BN_num_bytes.pod:47 C/crypto/BN_rand.pod:47
#: C/crypto/BN_set_bit.pod:56 C/crypto/BN_zero.pod:46 C/crypto/bn.pod:167
#: C/crypto/bn_internal.pod:234
msgid "SEE ALSO"
msgstr "VOIR AUSSI"

#. type: textblock
#: C/crypto/BN_BLINDING_new.pod:100 C/crypto/BN_cmp.pod:40
#: C/crypto/BN_swap.pod:17 C/crypto/bn_internal.pod:236
msgid "L<bn(3)|bn(3)>"
msgstr "L<bn(3)|bn(3)>"

#. type: =head1
#: C/crypto/BN_BLINDING_new.pod:102 C/crypto/BN_CTX_new.pod:52
#: C/crypto/BN_CTX_start.pod:48 C/crypto/BN_add.pod:117
#: C/crypto/BN_add_word.pod:52 C/crypto/BN_bn2bin.pod:87 C/crypto/BN_cmp.pod:42
#: C/crypto/BN_copy.pod:30 C/crypto/BN_generate_prime.pod:143
#: C/crypto/BN_mod_inverse.pod:32 C/crypto/BN_mod_mul_montgomery.pod:93
#: C/crypto/BN_mod_mul_reciprocal.pod:75 C/crypto/BN_new.pod:47
#: C/crypto/BN_num_bytes.pod:52 C/crypto/BN_rand.pod:52
#: C/crypto/BN_set_bit.pod:60 C/crypto/BN_swap.pod:19 C/crypto/BN_zero.pod:50
msgid "HISTORY"
msgstr "HISTORIQUE"

#. type: textblock
#: C/crypto/BN_BLINDING_new.pod:104
msgid ""
"BN_BLINDING_thread_id was first introduced in OpenSSL 1.0.0, and it "
"deprecates BN_BLINDING_set_thread_id and BN_BLINDING_get_thread_id."
msgstr ""

#. type: textblock
#: C/crypto/BN_BLINDING_new.pod:107
msgid ""
"BN_BLINDING_convert_ex, BN_BLINDIND_invert_ex, BN_BLINDING_get_thread_id, "
"BN_BLINDING_set_thread_id, BN_BLINDING_set_flags, BN_BLINDING_get_flags and "
"BN_BLINDING_create_param were first introduced in OpenSSL 0.9.8"
msgstr ""
"BN_BLINDING_convert_ex, BN_BLINDIND_invert_ex, BN_BLINDING_get_thread_id, "
"BN_BLINDING_set_thread_id, BN_BLINDING_set_flags, BN_BLINDING_get_flags et "
"BN_BLINDING_create_param sont apparues dans OpenSSL 0.9.8"

#. type: =head1
#: C/crypto/BN_BLINDING_new.pod:111
msgid "AUTHOR"
msgstr "AUTEUR"

#. type: textblock
#: C/crypto/BN_BLINDING_new.pod:113
msgid "Nils Larsch for the OpenSSL project (http://www.openssl.org)."
msgstr "Nils Larsch pour le projet OpenSSL (http://www.openssl.org)."

#. type: textblock
#: C/crypto/BN_CTX_new.pod:5
msgid ""
"BN_CTX_new, BN_CTX_init, BN_CTX_free - allocate and free BN_CTX structures"
msgstr ""
"BN_CTX_new, BN_CTX_init, BN_CTX_free - Allouer et libérer des structures "
"BN_CTX"

#. type: verbatim
#: C/crypto/BN_CTX_new.pod:11
#, no-wrap
msgid ""
" BN_CTX *BN_CTX_new(void);\n"
"\n"
msgstr ""
" BN_CTX *BN_CTX_new(void);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_CTX_new.pod:13
#, no-wrap
msgid ""
" void BN_CTX_free(BN_CTX *c);\n"
"\n"
msgstr ""
" void BN_CTX_free(BN_CTX *c);\n"
"\n"

#. type: textblock
#: C/crypto/BN_CTX_new.pod:15 C/crypto/BN_generate_prime.pod:28
msgid "Deprecated:"
msgstr "Obsolète :"

#. type: verbatim
#: C/crypto/BN_CTX_new.pod:17
#, no-wrap
msgid ""
" void BN_CTX_init(BN_CTX *c);\n"
"\n"
msgstr ""
" void BN_CTX_init(BN_CTX *c);\n"
"\n"

#. type: textblock
#: C/crypto/BN_CTX_new.pod:22
msgid ""
"A B<BN_CTX> is a structure that holds B<BIGNUM> temporary variables used by "
"library functions. Since dynamic memory allocation to create B<BIGNUM>s is "
"rather expensive when used in conjunction with repeated subroutine calls, "
"the B<BN_CTX> structure is used."
msgstr ""
"Un B<BN_CTX> est une structure qui détient des variables temporaires "
"B<BIGNUM> utilisées par les fonctions de bibliothèque. Puisque l'allocation "
"de mémoire dynamique pour créer des B<BIGNUM> est plutôt coûteuse, "
"lorsqu'elle est utilisée en conjonction avec des appels répétés de sous-"
"routine, la structure B<BN_CTX> est utilisée."

#. type: textblock
#: C/crypto/BN_CTX_new.pod:27
msgid "BN_CTX_new() allocates and initializes a B<BN_CTX> structure."
msgstr "B<BN_CTX_new>() alloue et initialise une structure B<BN_CTX>."

#. type: textblock
#: C/crypto/BN_CTX_new.pod:30
msgid ""
"BN_CTX_free() frees the components of the B<BN_CTX>, and if it was created "
"by BN_CTX_new(), also the structure itself.  If L<BN_CTX_start(3)|"
"BN_CTX_start(3)> has been used on the B<BN_CTX>, L<BN_CTX_end(3)|"
"BN_CTX_end(3)> must be called before the B<BN_CTX> may be freed by "
"BN_CTX_free()."
msgstr ""
"B<BN_CTX_free>() libère les composants du B<BN_CTX>, et s'il a été créé par "
"B<BN_CTX_new>(), libère aussi la structure elle-même. Si "
"L<B<BN_CTX_start>(3)|BN_CTX_start(3)> a été utilisée sur le B<BN_CTX>, "
"L<B<BN_CTX_end>(3)|BN_CTX_end(3)> doit être appelée avant que le B<BN_CTX> "
"ne puisse être libéré par B<BN_CTX_free>()."

#. type: textblock
#: C/crypto/BN_CTX_new.pod:36
msgid ""
"BN_CTX_init() (deprecated) initializes an existing uninitialized B<BN_CTX>.  "
"This should not be used for new programs. Use BN_CTX_new() instead."
msgstr ""
"B<BN_CTX_init>() (obsolète) initialise un B<BN_CTX> existant mais non "
"initialisé. Elle ne devrait pas être utilisée dans les nouveaux programmes. "
"Utilisez B<BN_CTX_new>() instead."

#. type: textblock
#: C/crypto/BN_CTX_new.pod:41
msgid ""
"BN_CTX_new() returns a pointer to the B<BN_CTX>. If the allocation fails, it "
"returns B<NULL> and sets an error code that can be obtained by "
"L<ERR_get_error(3)|ERR_get_error(3)>."
msgstr ""
"B<BN_CTX_new>() renvoie un pointeur vers le B<BN_CTX>. Si l'allocation "
"échoue, elle renvoie NULL et définit un code d'erreur qui peut être obtenu "
"par L<B<ERR_get_error>(3)|ERR_get_error(3)>."

#. type: textblock
#: C/crypto/BN_CTX_new.pod:45
msgid "BN_CTX_init() and BN_CTX_free() have no return values."
msgstr "B<BN_CTX_init>() et B<BN_CTX_free>() ne renvoient pas de valeur."

#. type: textblock
#: C/crypto/BN_CTX_new.pod:49
msgid ""
"L<bn(3)|bn(3)>, L<ERR_get_error(3)|ERR_get_error(3)>, L<BN_add(3)|"
"BN_add(3)>, L<BN_CTX_start(3)|BN_CTX_start(3)>"
msgstr ""
"L<B<bn>(3)|bn(3)>, L<B<ERR_get_error>(3)|ERR_get_error(3)>, L<B<BN_add>(3)|"
"BN_add(3)>, L<B<BN_CTX_start>(3)|BN_CTX_start(3)>"

#. type: textblock
#: C/crypto/BN_CTX_new.pod:54
msgid ""
"BN_CTX_new() and BN_CTX_free() are available in all versions on SSLeay and "
"OpenSSL. BN_CTX_init() was added in SSLeay 0.9.1b."
msgstr ""
"B<BN_CTX_new>() et B<BN_CTX_free>() sont disponibles dans toutes les "
"versions de SSLeay et d'OpenSSL. B<BN_CTX_init>() a été ajoutée dans "
"SSLeay 0.9.1b."

#. type: textblock
#: C/crypto/BN_CTX_start.pod:5
msgid "BN_CTX_start, BN_CTX_get, BN_CTX_end - use temporary BIGNUM variables"
msgstr ""
"BN_CTX_start, BN_CTX_get, BN_CTX_end - Utiliser des variables BIGNUM "
"temporaires"

#. type: verbatim
#: C/crypto/BN_CTX_start.pod:11
#, no-wrap
msgid ""
" void BN_CTX_start(BN_CTX *ctx);\n"
"\n"
msgstr ""
" void BN_CTX_start(BN_CTX *ctx);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_CTX_start.pod:13
#, no-wrap
msgid ""
" BIGNUM *BN_CTX_get(BN_CTX *ctx);\n"
"\n"
msgstr ""
" BIGNUM *BN_CTX_get(BN_CTX *ctx);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_CTX_start.pod:15
#, no-wrap
msgid ""
" void BN_CTX_end(BN_CTX *ctx);\n"
"\n"
msgstr ""
" void BN_CTX_end(BN_CTX *ctx);\n"
"\n"

#. type: textblock
#: C/crypto/BN_CTX_start.pod:19
msgid ""
"These functions are used to obtain temporary B<BIGNUM> variables from a "
"B<BN_CTX> (which can been created by using L<BN_CTX_new(3)|BN_CTX_new(3)>)  "
"in order to save the overhead of repeatedly creating and freeing B<BIGNUM>s "
"in functions that are called from inside a loop."
msgstr ""
"Ces fonctions sont utilisées pour obtenir des variables B<BIGNUM> "
"temporaires à partir d'un B<BN_CTX> (qui peut avoir été créé en utilisant "
"L<BN_CTX_new(3)|BN_CTX_new(3)>) afin d'économiser les créations et "
"libérations répétitives de B<BIGNUM> dans les fonctions appelées depuis une "
"boucle."

#. type: textblock
#: C/crypto/BN_CTX_start.pod:24
msgid ""
"A function must call BN_CTX_start() first. Then, BN_CTX_get() may be called "
"repeatedly to obtain temporary B<BIGNUM>s. All BN_CTX_get()  calls must be "
"made before calling any other functions that use the B<ctx> as an argument."
msgstr ""
"Une fonction doit d'abord appeler B<BN_CTX_start>(). Ensuite, "
"B<BN_CTX_get>() peut être appelée de façon répétitive pour obtenir des "
"B<BIGNUM> temporaires. Tous les appels B<BN_CTX_get>() doivent être faits "
"avant d'appeler n'importe quelles autres fonctions qui utilisent le I<ctx> "
"comme un argument."

#. type: textblock
#: C/crypto/BN_CTX_start.pod:29
msgid ""
"Finally, BN_CTX_end() must be called before returning from the function.  "
"When BN_CTX_end() is called, the B<BIGNUM> pointers obtained from "
"BN_CTX_get() become invalid."
msgstr ""
"Enfin, B<BN_CTX_end>() doit être appelée avant la fin d'exécution de la "
"fonction. Quand B<BN_CTX_end>() est appelée, les pointeurs B<BIGNUM> obtenus "
"à partir de B<BN_CTX_get>() deviennent non valables."

#. type: textblock
#: C/crypto/BN_CTX_start.pod:35
msgid "BN_CTX_start() and BN_CTX_end() return no values."
msgstr "B<BN_CTX_start>() et B<BN_CTX_end>() ne renvoient aucune valeur."

#. type: textblock
#: C/crypto/BN_CTX_start.pod:37
msgid ""
"BN_CTX_get() returns a pointer to the B<BIGNUM>, or B<NULL> on error.  Once "
"BN_CTX_get() has failed, the subsequent calls will return B<NULL> as well, "
"so it is sufficient to check the return value of the last BN_CTX_get() call. "
"In case of an error, an error code is set, which can be obtained by "
"L<ERR_get_error(3)|ERR_get_error(3)>."
msgstr ""
"B<BN_CTX_get>() renvoie un pointeur vers le B<BIGNUM> ou NULL en cas "
"d'erreur. Une fois que B<BN_CTX_get>() a échouée, les appels suivant "
"renverront NULL aussi, donc il suffit de vérifier la valeur de retour du "
"dernier appel de B<BN_CTX_get>(). En cas d'erreur, un code d'erreur est "
"défini et peut être obtenu avec L<ERR_get_error(3)|ERR_get_error(3)>."

#. type: textblock
#: C/crypto/BN_CTX_start.pod:46
msgid "L<BN_CTX_new(3)|BN_CTX_new(3)>"
msgstr "L<BN_CTX_new(3)|BN_CTX_new(3)>"

#. type: textblock
#: C/crypto/BN_CTX_start.pod:50
msgid ""
"BN_CTX_start(), BN_CTX_get() and BN_CTX_end() were added in OpenSSL 0.9.5."
msgstr ""
"B<BN_CTX_start>(), B<BN_CTX_get>() et B<BN_CTX_end>() ont été ajoutées dans "
"OpenSSL 0.9.5."

#. type: textblock
#: C/crypto/BN_add.pod:5
msgid ""
"BN_add, BN_sub, BN_mul, BN_sqr, BN_div, BN_mod, BN_nnmod, BN_mod_add, "
"BN_mod_sub, BN_mod_mul, BN_mod_sqr, BN_exp, BN_mod_exp, BN_gcd - arithmetic "
"operations on BIGNUMs"
msgstr ""

#. type: verbatim
#: C/crypto/BN_add.pod:13
#, no-wrap
msgid ""
" int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_add.pod:15
#, no-wrap
msgid ""
" int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_add.pod:17
#, no-wrap
msgid ""
" int BN_mul(BIGNUM *r, BIGNUM *a, BIGNUM *b, BN_CTX *ctx);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_add.pod:19
#, no-wrap
msgid ""
" int BN_sqr(BIGNUM *r, BIGNUM *a, BN_CTX *ctx);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_add.pod:21
#, no-wrap
msgid ""
" int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *a, const BIGNUM *d,\n"
"         BN_CTX *ctx);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_add.pod:24
#, no-wrap
msgid ""
" int BN_mod(BIGNUM *rem, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_add.pod:26
#, no-wrap
msgid ""
" int BN_nnmod(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_add.pod:28
#, no-wrap
msgid ""
" int BN_mod_add(BIGNUM *r, BIGNUM *a, BIGNUM *b, const BIGNUM *m,\n"
"         BN_CTX *ctx);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_add.pod:31
#, no-wrap
msgid ""
" int BN_mod_sub(BIGNUM *r, BIGNUM *a, BIGNUM *b, const BIGNUM *m,\n"
"         BN_CTX *ctx);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_add.pod:34
#, no-wrap
msgid ""
" int BN_mod_mul(BIGNUM *r, BIGNUM *a, BIGNUM *b, const BIGNUM *m,\n"
"         BN_CTX *ctx);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_add.pod:37
#, no-wrap
msgid ""
" int BN_mod_sqr(BIGNUM *r, BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_add.pod:39
#, no-wrap
msgid ""
" int BN_exp(BIGNUM *r, BIGNUM *a, BIGNUM *p, BN_CTX *ctx);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_add.pod:41
#, no-wrap
msgid ""
" int BN_mod_exp(BIGNUM *r, BIGNUM *a, const BIGNUM *p,\n"
"         const BIGNUM *m, BN_CTX *ctx);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_add.pod:44
#, no-wrap
msgid ""
" int BN_gcd(BIGNUM *r, BIGNUM *a, BIGNUM *b, BN_CTX *ctx);\n"
"\n"
msgstr ""

#. type: textblock
#: C/crypto/BN_add.pod:48
msgid ""
"BN_add() adds I<a> and I<b> and places the result in I<r> (C<r=a+b>).  I<r> "
"may be the same B<BIGNUM> as I<a> or I<b>."
msgstr ""

#. type: textblock
#: C/crypto/BN_add.pod:51
msgid ""
"BN_sub() subtracts I<b> from I<a> and places the result in I<r> (C<r=a-b>)."
msgstr ""

#. type: textblock
#: C/crypto/BN_add.pod:53
msgid ""
"BN_mul() multiplies I<a> and I<b> and places the result in I<r> (C<r=a*b>).  "
"I<r> may be the same B<BIGNUM> as I<a> or I<b>.  For multiplication by "
"powers of 2, use L<BN_lshift(3)|BN_lshift(3)>."
msgstr ""

#. type: textblock
#: C/crypto/BN_add.pod:57
msgid ""
"BN_sqr() takes the square of I<a> and places the result in I<r> (C<r=a^2>). "
"I<r> and I<a> may be the same B<BIGNUM>.  This function is faster than "
"BN_mul(r,a,a)."
msgstr ""

#. type: textblock
#: C/crypto/BN_add.pod:61
msgid ""
"BN_div() divides I<a> by I<d> and places the result in I<dv> and the "
"remainder in I<rem> (C<dv=a/d, rem=a%d>). Either of I<dv> and I<rem> may be "
"B<NULL>, in which case the respective value is not returned.  The result is "
"rounded towards zero; thus if I<a> is negative, the remainder will be zero "
"or negative.  For division by powers of 2, use BN_rshift(3)."
msgstr ""

#. type: textblock
#: C/crypto/BN_add.pod:68
msgid "BN_mod() corresponds to BN_div() with I<dv> set to B<NULL>."
msgstr ""

#. type: textblock
#: C/crypto/BN_add.pod:70
msgid ""
"BN_nnmod() reduces I<a> modulo I<m> and places the non-negative remainder in "
"I<r>."
msgstr ""

#. type: textblock
#: C/crypto/BN_add.pod:73
msgid ""
"BN_mod_add() adds I<a> to I<b> modulo I<m> and places the non-negative "
"result in I<r>."
msgstr ""

#. type: textblock
#: C/crypto/BN_add.pod:76
msgid ""
"BN_mod_sub() subtracts I<b> from I<a> modulo I<m> and places the non-"
"negative result in I<r>."
msgstr ""

#. type: textblock
#: C/crypto/BN_add.pod:79
msgid ""
"BN_mod_mul() multiplies I<a> by I<b> and finds the non-negative remainder "
"respective to modulus I<m> (C<r=(a*b) mod m>). I<r> may be the same "
"B<BIGNUM> as I<a> or I<b>. For more efficient algorithms for repeated "
"computations using the same modulus, see L<BN_mod_mul_montgomery(3)|"
"BN_mod_mul_montgomery(3)> and L<BN_mod_mul_reciprocal(3)|"
"BN_mod_mul_reciprocal(3)>."
msgstr ""

#. type: textblock
#: C/crypto/BN_add.pod:86
msgid ""
"BN_mod_sqr() takes the square of I<a> modulo B<m> and places the result in "
"I<r>."
msgstr ""

#. type: textblock
#: C/crypto/BN_add.pod:89
msgid ""
"BN_exp() raises I<a> to the I<p>-th power and places the result in I<r> "
"(C<r=a^p>). This function is faster than repeated applications of BN_mul()."
msgstr ""

#. type: textblock
#: C/crypto/BN_add.pod:93
msgid ""
"BN_mod_exp() computes I<a> to the I<p>-th power modulo I<m> (C<r=a^p % m>). "
"This function uses less time and space than BN_exp()."
msgstr ""

#. type: textblock
#: C/crypto/BN_add.pod:96
msgid ""
"BN_gcd() computes the greatest common divisor of I<a> and I<b> and places "
"the result in I<r>. I<r> may be the same B<BIGNUM> as I<a> or I<b>."
msgstr ""

#. type: textblock
#: C/crypto/BN_add.pod:100
msgid ""
"For all functions, I<ctx> is a previously allocated B<BN_CTX> used for "
"temporary variables; see L<BN_CTX_new(3)|BN_CTX_new(3)>."
msgstr ""

#. type: textblock
#: C/crypto/BN_add.pod:103
msgid ""
"Unless noted otherwise, the result B<BIGNUM> must be different from the "
"arguments."
msgstr ""

#. type: textblock
#: C/crypto/BN_add.pod:108
msgid ""
"For all functions, 1 is returned for success, 0 on error. The return value "
"should always be checked (e.g., C<if (!BN_add(r,a,b)) goto err;>).  The "
"error codes can be obtained by L<ERR_get_error(3)|ERR_get_error(3)>."
msgstr ""

#. type: textblock
#: C/crypto/BN_add.pod:114
msgid ""
"L<bn(3)|bn(3)>, L<ERR_get_error(3)|ERR_get_error(3)>, L<BN_CTX_new(3)|"
"BN_CTX_new(3)>, L<BN_add_word(3)|BN_add_word(3)>, L<BN_set_bit(3)|"
"BN_set_bit(3)>"
msgstr ""
"L<bn(3)|bn(3)>, L<ERR_get_error(3)|ERR_get_error(3)>, L<BN_CTX_new(3)|"
"BN_CTX_new(3)>, L<BN_add_word(3)|BN_add_word(3)>, L<BN_set_bit(3)|"
"BN_set_bit(3)>"

#. type: textblock
#: C/crypto/BN_add.pod:119
msgid ""
"BN_add(), BN_sub(), BN_sqr(), BN_div(), BN_mod(), BN_mod_mul(), BN_mod_exp() "
"and BN_gcd() are available in all versions of SSLeay and OpenSSL. The I<ctx> "
"argument to BN_mul() was added in SSLeay 0.9.1b. BN_exp() appeared in SSLeay "
"0.9.0.  BN_nnmod(), BN_mod_add(), BN_mod_sub(), and BN_mod_sqr() were added "
"in OpenSSL 0.9.7."
msgstr ""

#. type: textblock
#: C/crypto/BN_add_word.pod:5
msgid ""
"BN_add_word, BN_sub_word, BN_mul_word, BN_div_word, BN_mod_word - arithmetic "
"functions on BIGNUMs with integers"
msgstr ""
"BN_add_word, BN_sub_word, BN_mul_word, BN_div_word, BN_mod_word - Fonctions "
"arithmétiques sur des BIGNUM avec des entiers"

#. type: verbatim
#: C/crypto/BN_add_word.pod:12
#, no-wrap
msgid ""
" int BN_add_word(BIGNUM *a, BN_ULONG w);\n"
"\n"
msgstr ""
" int BN_add_word(BIGNUM *a, BN_ULONG w);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_add_word.pod:14
#, no-wrap
msgid ""
" int BN_sub_word(BIGNUM *a, BN_ULONG w);\n"
"\n"
msgstr ""
" int BN_sub_word(BIGNUM *a, BN_ULONG w);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_add_word.pod:16
#, no-wrap
msgid ""
" int BN_mul_word(BIGNUM *a, BN_ULONG w);\n"
"\n"
msgstr ""
" int BN_mul_word(BIGNUM *a, BN_ULONG w);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_add_word.pod:18
#, no-wrap
msgid ""
" BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w);\n"
"\n"
msgstr ""
" BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_add_word.pod:20
#, no-wrap
msgid ""
" BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w);\n"
"\n"
msgstr ""
" BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w);\n"
"\n"

#. type: textblock
#: C/crypto/BN_add_word.pod:24
msgid ""
"These functions perform arithmetic operations on BIGNUMs with unsigned "
"integers. They are much more efficient than the normal BIGNUM arithmetic "
"operations."
msgstr ""
"Ces fonctions réalisent des opérations arithmétiques sur des BIGNUM avec des "
"entiers positifs. Elles sont bien plus efficaces que les opérations "
"arithmétiques de BIGNUM normales."

#. type: textblock
#: C/crypto/BN_add_word.pod:28
msgid "BN_add_word() adds B<w> to B<a> (C<a+=w>)."
msgstr "B<BN_add_word>() ajoute I<w> à I<a> (C<a+=w>)."

#. type: textblock
#: C/crypto/BN_add_word.pod:30
msgid "BN_sub_word() subtracts B<w> from B<a> (C<a-=w>)."
msgstr "B<BN_sub_word>() soustrait I<w> de I<a> (C<a-=w>)."

#. type: textblock
#: C/crypto/BN_add_word.pod:32
msgid "BN_mul_word() multiplies B<a> and B<w> (C<a*=w>)."
msgstr "B<BN_mul_word>() multiplie I<a> et I<w> (C<a*=w>)."

#. type: textblock
#: C/crypto/BN_add_word.pod:34
msgid "BN_div_word() divides B<a> by B<w> (C<a/=w>) and returns the remainder."
msgstr "B<BN_div_word>()divise I<a> par I<w> (C<a/=w>) et renvoie le reste."

#. type: textblock
#: C/crypto/BN_add_word.pod:36
msgid "BN_mod_word() returns the remainder of B<a> divided by B<w> (C<a%w>)."
msgstr "B<BN_mod_word>()renvoie le reste de I<a> divisé par I<w> (C<a%w>)."

#. type: textblock
#: C/crypto/BN_add_word.pod:38
msgid "For BN_div_word() and BN_mod_word(), B<w> must not be 0."
msgstr "Pour B<BN_div_word>() et B<BN_mod_word>(), I<w> doit être non nul."

#. type: textblock
#: C/crypto/BN_add_word.pod:42
msgid ""
"BN_add_word(), BN_sub_word() and BN_mul_word() return 1 for success, 0 on "
"error. The error codes can be obtained by L<ERR_get_error(3)|"
"ERR_get_error(3)>."
msgstr ""
"B<BN_add_word>(), B<BN_sub_word>() et B<BN_mul_word>() renvoient 1 si elles "
"réussissent et 0 en cas d'erreur. Les codes d'erreur peuvent être obtenu par "
"L<ERR_get_error(3)|ERR_get_error(3)>."

#. type: textblock
#: C/crypto/BN_add_word.pod:45
msgid ""
"BN_mod_word() and BN_div_word() return B<a>%B<w> on success and "
"B<(BN_ULONG)-1> if an error occurred."
msgstr ""
"B<BN_mod_word>() et B<BN_div_word>() renvoient I<a>%I<w> si elles "
"réussissent et B<(BN_ULONG)-1> en cas d'erreur."

#. type: textblock
#: C/crypto/BN_add_word.pod:50 C/crypto/BN_mod_inverse.pod:30
msgid ""
"L<bn(3)|bn(3)>, L<ERR_get_error(3)|ERR_get_error(3)>, L<BN_add(3)|BN_add(3)>"
msgstr ""
"L<bn(3)|bn(3)>, L<ERR_get_error(3)|ERR_get_error(3)>, L<BN_add(3)|BN_add(3)>"

#. type: textblock
#: C/crypto/BN_add_word.pod:54
msgid ""
"BN_add_word() and BN_mod_word() are available in all versions of SSLeay and "
"OpenSSL. BN_div_word() was added in SSLeay 0.8, and BN_sub_word() and "
"BN_mul_word() in SSLeay 0.9.0."
msgstr ""
"B<BN_add_word>() et B<BN_mod_word>() sont disponibles dans toutes les "
"versions de SSLeay et OpenSSL. B<BN_div_word>() a été ajoutée à SSLeay 0.8, "
"et B<BN_sub_word>() et B<BN_mul_word>() dans SSLeay 0.9.0."

#. type: textblock
#: C/crypto/BN_add_word.pod:58
msgid ""
"Before 0.9.8a the return value for BN_div_word() and BN_mod_word()  in case "
"of an error was 0."
msgstr ""
"Avant 0.9.8a la valeur de retour en cas d'erreur de B<BN_div_word>() et "
"B<BN_mod_word>() était 0."

#. type: textblock
#: C/crypto/BN_bn2bin.pod:5
msgid ""
"BN_bn2bin, BN_bin2bn, BN_bn2hex, BN_bn2dec, BN_hex2bn, BN_dec2bn, BN_print, "
"BN_print_fp, BN_bn2mpi, BN_mpi2bn - format conversions"
msgstr ""
"BN_bn2bin, BN_bin2bn, BN_bn2hex, BN_bn2dec, BN_hex2bn, BN_dec2bn, BN_print, "
"BN_print_fp, BN_bn2mpi, BN_mpi2bn - Conversions de format"

#. type: verbatim
#: C/crypto/BN_bn2bin.pod:12
#, no-wrap
msgid ""
" int BN_bn2bin(const BIGNUM *a, unsigned char *to);\n"
" BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret);\n"
"\n"
msgstr ""
" int BN_bn2bin(const BIGNUM *a, unsigned char *to);\n"
" BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_bn2bin.pod:15
#, no-wrap
msgid ""
" char *BN_bn2hex(const BIGNUM *a);\n"
" char *BN_bn2dec(const BIGNUM *a);\n"
" int BN_hex2bn(BIGNUM **a, const char *str);\n"
" int BN_dec2bn(BIGNUM **a, const char *str);\n"
"\n"
msgstr ""
" char *BN_bn2hex(const BIGNUM *a);\n"
" char *BN_bn2dec(const BIGNUM *a);\n"
" int BN_hex2bn(BIGNUM **a, const char *str);\n"
" int BN_dec2bn(BIGNUM **a, const char *str);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_bn2bin.pod:20
#, no-wrap
msgid ""
" int BN_print(BIO *fp, const BIGNUM *a);\n"
" int BN_print_fp(FILE *fp, const BIGNUM *a);\n"
"\n"
msgstr ""
" int BN_print(BIO *fp, const BIGNUM *a);\n"
" int BN_print_fp(FILE *fp, const BIGNUM *a);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_bn2bin.pod:23
#, no-wrap
msgid ""
" int BN_bn2mpi(const BIGNUM *a, unsigned char *to);\n"
" BIGNUM *BN_mpi2bn(unsigned char *s, int len, BIGNUM *ret);\n"
"\n"
msgstr ""
" int BN_bn2mpi(const BIGNUM *a, unsigned char *to);\n"
" BIGNUM *BN_mpi2bn(unsigned char *s, int len, BIGNUM *ret);\n"
"\n"

#. type: textblock
#: C/crypto/BN_bn2bin.pod:28
msgid ""
"BN_bn2bin() converts the absolute value of B<a> into big-endian form and "
"stores it at B<to>. B<to> must point to BN_num_bytes(B<a>) bytes of memory."
msgstr ""
"B<BN_bn2bin>() convertit la valeur absolue de I<a> sous forme grand-boutiste "
"et la stocke à I<to>. I<to> doit pointer vers B<BN_num_bytes(>I<a>B<)> "
"octets de mémoire."

#. type: textblock
#: C/crypto/BN_bn2bin.pod:32
msgid ""
"BN_bin2bn() converts the positive integer in big-endian form of length "
"B<len> at B<s> into a B<BIGNUM> and places it in B<ret>. If B<ret> is NULL, "
"a new B<BIGNUM> is created."
msgstr ""
"B<BN_bin2bn>() convertit l'entier positif sous forme grand-boutiste de "
"taille I<len> à I<s> en un B<BIGNUM> et le place en I<ret>. Si I<ret> est "
"NULL, un nouveau B<BIGNUM> est créé."

#. type: textblock
#: C/crypto/BN_bn2bin.pod:36
msgid ""
"BN_bn2hex() and BN_bn2dec() return printable strings containing the "
"hexadecimal and decimal encoding of B<a> respectively. For negative numbers, "
"the string is prefaced with a leading '-'. The string must be freed later "
"using OPENSSL_free()."
msgstr ""
"B<BN_bn2hex>() et B<BN_bn2dec>() renvoient des chaînes affichables contenant "
"respectivement les encodages hexadécimal et décimal de I<a>. Pour les "
"nombres négatifs, la chaîne est précédée d'un « - ». La chaîne doit être "
"libérée plus tard en utilisant B<OPENSSL_free>()."

#. type: textblock
#: C/crypto/BN_bn2bin.pod:41
msgid ""
"BN_hex2bn() converts the string B<str> containing a hexadecimal number to a "
"B<BIGNUM> and stores it in **B<bn>. If *B<bn> is NULL, a new B<BIGNUM> is "
"created. If B<bn> is NULL, it only computes the number's length in "
"hexadecimal digits. If the string starts with '-', the number is negative. "
"BN_dec2bn() is the same using the decimal system."
msgstr ""
"B<BN_hex2bn>() convertit la chaîne I<str> contenant un nombre hexadécimal en "
"un B<BIGNUM> et le stocke en **I<bn>. Si *I<bn> est NULL, un nouveau "
"B<BIGNUM> est créé. Si I<bn> est NULL, elle ne calcule que sa taille en "
"nombre de chiffres hexadécimaux. Si la chaîne commence par « - », le nombre "
"est négatif. B<BN_dec2bn>() est la même en utilisant le système décimal."

#. type: textblock
#: C/crypto/BN_bn2bin.pod:47
msgid ""
"BN_print() and BN_print_fp() write the hexadecimal encoding of B<a>, with a "
"leading '-' for negative numbers, to the B<BIO> or B<FILE> B<fp>."
msgstr ""
"B<BN_print>() et B<BN_print_fp>() écrivent l'encodage hexadécimal de I<a>, "
"en commençant par « - » si le nombre est négatif, vers les B<BIO> ou B<FILE> "
"B<fp>."

#. type: textblock
#: C/crypto/BN_bn2bin.pod:51
msgid ""
"BN_bn2mpi() and BN_mpi2bn() convert B<BIGNUM>s from and to a format that "
"consists of the number's length in bytes represented as a 4-byte big-endian "
"number, and the number itself in big-endian format, where the most "
"significant bit signals a negative number (the representation of numbers "
"with the MSB set is prefixed with null byte)."
msgstr ""
"B<BN_bn2mpi>() et B<BN_mpi2bn>() convertissent les B<BIGNUM> de et vers un "
"format constitué de la taille du nombre en octet représenté comme un nombre "
"grand-boutiste de 4 octets et du nombre lui-même au format grand-boutiste, "
"où le bit de poids fort indique un nombre négatif (la représentation des "
"nombres avec le bit de poids fort défini est précédée de l'octet NULL)."

#. type: textblock
#: C/crypto/BN_bn2bin.pod:57
msgid ""
"BN_bn2mpi() stores the representation of B<a> at B<to>, where B<to> must be "
"large enough to hold the result. The size can be determined by calling "
"BN_bn2mpi(B<a>, NULL)."
msgstr ""
"B<BN_bn2mpi>() stocke la représentation de I<a> à I<to>, où I<to> doit être "
"assez grand pour faire tenir le résultat. La taille peut être déterminée en "
"appelant B<BN_bn2mpi(>I<a>B<, NULL)>."

#. type: textblock
#: C/crypto/BN_bn2bin.pod:61
msgid ""
"BN_mpi2bn() converts the B<len> bytes long representation at B<s> to a "
"B<BIGNUM> and stores it at B<ret>, or in a newly allocated B<BIGNUM> if "
"B<ret> is NULL."
msgstr ""
"B<BN_mpi2bn>() convertit la représentation de taille I<len> octets à I<s> "
"vers un B<BIGNUM> et le stocke à I<ret> ou dans un B<BIGNUM> nouvellement "
"alloué si I<ret> est NULL."

#. type: textblock
#: C/crypto/BN_bn2bin.pod:67
msgid ""
"BN_bn2bin() returns the length of the big-endian number placed at B<to>.  "
"BN_bin2bn() returns the B<BIGNUM>, NULL on error."
msgstr ""
"B<BN_bn2bin>() renvoie la taille du nombre grand-boutiste placé à I<to>. "
"B<BN_bin2bn>() renvoie le B<BIGNUM> ou NULL en cas d'erreur."

#. type: textblock
#: C/crypto/BN_bn2bin.pod:70
msgid ""
"BN_bn2hex() and BN_bn2dec() return a null-terminated string, or NULL on "
"error. BN_hex2bn() and BN_dec2bn() return the number's length in hexadecimal "
"or decimal digits, and 0 on error."
msgstr ""
"B<BN_bn2hex>() et B<BN_bn2dec>() renvoient une chaîne terminée par NULL ou "
"NULL en cas d'erreur. B<BN_hex2bn>() et B<BN_dec2bn>() renvoient la taille "
"en nombre de chiffres hexadécimaux ou décimaux, ou 0 en cas d'erreur."

#. type: textblock
#: C/crypto/BN_bn2bin.pod:74
msgid "BN_print_fp() and BN_print() return 1 on success, 0 on write errors."
msgstr ""
"B<BN_print_fp>() et B<BN_print>() renvoient 1 si elles réussissent ou 0 en "
"cas d'erreur d'écriture."

#. type: textblock
#: C/crypto/BN_bn2bin.pod:76
msgid ""
"BN_bn2mpi() returns the length of the representation. BN_mpi2bn()  returns "
"the B<BIGNUM>, and NULL on error."
msgstr ""
"B<BN_bn2mpi>() renvoie la taille de la représentation. B<BN_mpi2bn>() "
"renvoie le B<BIGNUM> ou NULL en cas d'erreur."

#. type: textblock
#: C/crypto/BN_bn2bin.pod:79 C/crypto/BN_generate_prime.pod:137
msgid ""
"The error codes can be obtained by L<ERR_get_error(3)|ERR_get_error(3)>."
msgstr ""
"Les codes d'erreur peuvent être obtenus par L<ERR_get_error(3)|"
"ERR_get_error(3)>."

#. type: textblock
#: C/crypto/BN_bn2bin.pod:83
msgid ""
"L<bn(3)|bn(3)>, L<ERR_get_error(3)|ERR_get_error(3)>, L<BN_zero(3)|"
"BN_zero(3)>, L<ASN1_INTEGER_to_BN(3)|ASN1_INTEGER_to_BN(3)>, "
"L<BN_num_bytes(3)|BN_num_bytes(3)>"
msgstr ""
"L<bn(3)|bn(3)>, L<ERR_get_error(3)|ERR_get_error(3)>, L<BN_zero(3)|"
"BN_zero(3)>, L<ASN1_INTEGER_to_BN(3)|ASN1_INTEGER_to_BN(3)>, "
"L<BN_num_bytes(3)|BN_num_bytes(3)>"

#. type: textblock
#: C/crypto/BN_bn2bin.pod:89
msgid ""
"BN_bn2bin(), BN_bin2bn(), BN_print_fp() and BN_print() are available in all "
"versions of SSLeay and OpenSSL."
msgstr ""
"B<BN_bn2bin>(), B<BN_bin2bn>(), B<BN_print_fp>() et B<BN_print>() sont "
"disponibles dans toutes les versions de SSLeay et OpenSSL."

#. type: textblock
#: C/crypto/BN_bn2bin.pod:92
msgid ""
"BN_bn2hex(), BN_bn2dec(), BN_hex2bn(), BN_dec2bn(), BN_bn2mpi() and "
"BN_mpi2bn() were added in SSLeay 0.9.0."
msgstr ""
"B<BN_bn2hex>(), B<BN_bn2dec>(), B<BN_hex2bn>(), B<BN_dec2bn>(), "
"B<BN_bn2mpi>() et B<BN_mpi2bn>() ont été ajoutées dans la version 0.9.0 de "
"SSLeay."

#. type: textblock
#: C/crypto/BN_cmp.pod:5
msgid ""
"BN_cmp, BN_ucmp, BN_is_zero, BN_is_one, BN_is_word, BN_is_odd - BIGNUM "
"comparison and test functions"
msgstr ""
"BN_cmp, BN_ucmp, BN_is_zero, BN_is_one, BN_is_word, BN_is_odd - Fonctions de "
"comparaison et test de BIGNUM"

#. type: verbatim
#: C/crypto/BN_cmp.pod:11
#, no-wrap
msgid ""
" int BN_cmp(BIGNUM *a, BIGNUM *b);\n"
" int BN_ucmp(BIGNUM *a, BIGNUM *b);\n"
"\n"
msgstr ""
" int BN_cmp(BIGNUM *a, BIGNUM *b);\n"
" int BN_ucmp(BIGNUM *a, BIGNUM *b);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_cmp.pod:14
#, no-wrap
msgid ""
" int BN_is_zero(BIGNUM *a);\n"
" int BN_is_one(BIGNUM *a);\n"
" int BN_is_word(BIGNUM *a, BN_ULONG w);\n"
" int BN_is_odd(BIGNUM *a);\n"
"\n"
msgstr ""
" int BN_is_zero(BIGNUM *a);\n"
" int BN_is_one(BIGNUM *a);\n"
" int BN_is_word(BIGNUM *a, BN_ULONG w);\n"
" int BN_is_odd(BIGNUM *a);\n"
"\n"

#. type: textblock
#: C/crypto/BN_cmp.pod:21
msgid ""
"BN_cmp() compares the numbers B<a> and B<b>. BN_ucmp() compares their "
"absolute values."
msgstr ""
"B<BN_cmp>() compare les nombres I<a> et I<b>. B<BN_ucmp>() compare leurs "
"valeurs absolues."

#. type: textblock
#: C/crypto/BN_cmp.pod:24
msgid ""
"BN_is_zero(), BN_is_one() and BN_is_word() test if B<a> equals 0, 1, or B<w> "
"respectively. BN_is_odd() tests if a is odd."
msgstr ""
"B<BN_is_zero>(), B<BN_is_one>() et B<BN_is_word>() testent respectivement si "
"I<a> est égal à B<0>, à B<1> ou à I<w>. B<BN_is_odd>() teste si I<a> est "
"impair."

#. type: textblock
#: C/crypto/BN_cmp.pod:27
msgid "BN_is_zero(), BN_is_one(), BN_is_word() and BN_is_odd() are macros."
msgstr ""
"B<BN_is_zero>(), B<BN_is_one>(), B<BN_is_word>() et B<BN_is_odd>() sont des "
"macros."

#. type: textblock
#: C/crypto/BN_cmp.pod:31
msgid ""
"BN_cmp() returns -1 if B<a> E<lt> B<b>, 0 if B<a> == B<b> and 1 if B<a> "
"E<gt> B<b>. BN_ucmp() is the same using the absolute values of B<a> and B<b>."
msgstr ""
"B<BN_cmp>() renvoie B<-1> si I<a> E<lt> I<b>, B<0> si I<a> == I<b> et B<1> "
"si I<a> E<gt> I<b>. B<BN_ucmp>() fait la même chose en utilisant les valeurs "
"absolues de I<a> et I<b>."

#. type: textblock
#: C/crypto/BN_cmp.pod:35
msgid ""
"BN_is_zero(), BN_is_one() BN_is_word() and BN_is_odd() return 1 if the "
"condition is true, 0 otherwise."
msgstr ""
"B<BN_is_zero>(), B<BN_is_one>(), B<BN_is_word>() et B<BN_is_odd>() renvoient "
"B<1> si la condition est vraie et B<0> sinon."

#. type: textblock
#: C/crypto/BN_cmp.pod:44
msgid ""
"BN_cmp(), BN_ucmp(), BN_is_zero(), BN_is_one() and BN_is_word() are "
"available in all versions of SSLeay and OpenSSL.  BN_is_odd() was added in "
"SSLeay 0.8."
msgstr ""
"B<BN_cmp>(), B<BN_ucmp>(), B<BN_is_zero>(), B<BN_is_one>() et "
"B<BN_is_word>() sont disponibles dans toutes les versions de SSLeay et "
"OpenSSL. B<BN_is_odd>() a été ajoutée dans SSLeay 0.8."

#. type: textblock
#: C/crypto/BN_copy.pod:5
msgid "BN_copy, BN_dup - copy BIGNUMs"
msgstr "BN_copy, BN_dup - Copier des BIGNUM"

#. type: verbatim
#: C/crypto/BN_copy.pod:11
#, no-wrap
msgid ""
" BIGNUM *BN_copy(BIGNUM *to, const BIGNUM *from);\n"
"\n"
msgstr ""
" BIGNUM *BN_copy(BIGNUM *to, const BIGNUM *from);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_copy.pod:13
#, no-wrap
msgid ""
" BIGNUM *BN_dup(const BIGNUM *from);\n"
"\n"
msgstr ""
" BIGNUM *BN_dup(const BIGNUM *from);\n"
"\n"

#. type: textblock
#: C/crypto/BN_copy.pod:17
msgid ""
"BN_copy() copies B<from> to B<to>. BN_dup() creates a new B<BIGNUM> "
"containing the value B<from>."
msgstr ""
"BN_copy() copie B<from> vers B<to>. BN_dup() crée un nouveau B<BIGNUM> "
"contenant la valeur de B<from>."

#. type: textblock
#: C/crypto/BN_copy.pod:22
msgid ""
"BN_copy() returns B<to> on success, NULL on error. BN_dup() returns the new "
"B<BIGNUM>, and NULL on error. The error codes can be obtained by "
"L<ERR_get_error(3)|ERR_get_error(3)>."
msgstr ""
"BN_copy() renvoie B<to> en cas de succès, NULL en cas d'erreur. BN_dup() "
"renvoie le nouveau B<BIGNUM>, et NULL est cas d'erreur. Le code d'erreur "
"peut être obtenu avec L<ERR_get_error(3)|ERR_get_error(3)>."

#. type: textblock
#: C/crypto/BN_copy.pod:28 C/crypto/BN_new.pod:45
msgid "L<bn(3)|bn(3)>, L<ERR_get_error(3)|ERR_get_error(3)>"
msgstr "L<bn(3)|bn(3)>, L<ERR_get_error(3)|ERR_get_error(3)>"

#. type: textblock
#: C/crypto/BN_copy.pod:32
msgid ""
"BN_copy() and BN_dup() are available in all versions of SSLeay and OpenSSL."
msgstr ""
"BN_copy() et BN_dup() sont disponibles dans toutes les versions de SSLeay et "
"OpenSSL."

#. type: textblock
#: C/crypto/BN_generate_prime.pod:5
msgid ""
"BN_generate_prime_ex, BN_is_prime_ex, BN_is_prime_fasttest_ex, "
"BN_GENCB_call, BN_GENCB_set_old, BN_GENCB_set, BN_generate_prime, "
"BN_is_prime, BN_is_prime_fasttest - generate primes and test for primality"
msgstr ""

#. type: verbatim
#: C/crypto/BN_generate_prime.pod:13
#, no-wrap
msgid ""
" int BN_generate_prime_ex(BIGNUM *ret,int bits,int safe, const BIGNUM *add,\n"
"     const BIGNUM *rem, BN_GENCB *cb);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_generate_prime.pod:16
#, no-wrap
msgid ""
" int BN_is_prime_ex(const BIGNUM *p,int nchecks, BN_CTX *ctx, BN_GENCB *cb);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_generate_prime.pod:18
#, no-wrap
msgid ""
" int BN_is_prime_fasttest_ex(const BIGNUM *p,int nchecks, BN_CTX *ctx,\n"
"     int do_trial_division, BN_GENCB *cb);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_generate_prime.pod:21
#, fuzzy, no-wrap
#| msgid ""
#| " int BN_rand(BIGNUM *rnd, int bits, int top, int bottom);\n"
#| "\n"
msgid ""
" int BN_GENCB_call(BN_GENCB *cb, int a, int b);\n"
"\n"
msgstr ""
" int BN_rand(BIGNUM *rnd, int bits, int top, int bottom);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_generate_prime.pod:23
#, no-wrap
msgid ""
" #define BN_GENCB_set_old(gencb, callback, cb_arg) ...\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_generate_prime.pod:25
#, no-wrap
msgid ""
" #define BN_GENCB_set(gencb, callback, cb_arg) ...\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_generate_prime.pod:30
#, no-wrap
msgid ""
" BIGNUM *BN_generate_prime(BIGNUM *ret, int num, int safe, BIGNUM *add,\n"
"     BIGNUM *rem, void (*callback)(int, int, void *), void *cb_arg);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_generate_prime.pod:33
#, no-wrap
msgid ""
" int BN_is_prime(const BIGNUM *a, int checks, void (*callback)(int, int, \n"
"     void *), BN_CTX *ctx, void *cb_arg);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_generate_prime.pod:36
#, no-wrap
msgid ""
" int BN_is_prime_fasttest(const BIGNUM *a, int checks,\n"
"     void (*callback)(int, int, void *), BN_CTX *ctx, void *cb_arg,\n"
"     int do_trial_division);\n"
"\n"
msgstr ""

#. type: textblock
#: C/crypto/BN_generate_prime.pod:42
msgid ""
"BN_generate_prime_ex() generates a pseudo-random prime number of bit length "
"B<bits>.  If B<ret> is not B<NULL>, it will be used to store the number."
msgstr ""

#. type: textblock
#: C/crypto/BN_generate_prime.pod:46
msgid "If B<cb> is not B<NULL>, it is used as follows:"
msgstr ""

#. type: =item
#: C/crypto/BN_generate_prime.pod:50 C/crypto/BN_generate_prime.pod:55
#: C/crypto/BN_generate_prime.pod:60
msgid "*"
msgstr "*"

#. type: textblock
#: C/crypto/BN_generate_prime.pod:52
msgid ""
"B<BN_GENCB_call(cb, 0, i)> is called after generating the i-th potential "
"prime number."
msgstr ""

#. type: textblock
#: C/crypto/BN_generate_prime.pod:57
msgid ""
"While the number is being tested for primality, B<BN_GENCB_call(cb, 1, j)> "
"is called as described below."
msgstr ""

#. type: textblock
#: C/crypto/BN_generate_prime.pod:62
msgid "When a prime has been found, B<BN_GENCB_call(cb, 2, i)> is called."
msgstr ""

#. type: textblock
#: C/crypto/BN_generate_prime.pod:66
msgid ""
"The prime may have to fulfill additional requirements for use in Diffie-"
"Hellman key exchange:"
msgstr ""

#. type: textblock
#: C/crypto/BN_generate_prime.pod:69
msgid ""
"If B<add> is not B<NULL>, the prime will fulfill the condition p % B<add> == "
"B<rem> (p % B<add> == 1 if B<rem> == B<NULL>) in order to suit a given "
"generator."
msgstr ""

#. type: textblock
#: C/crypto/BN_generate_prime.pod:73
msgid ""
"If B<safe> is true, it will be a safe prime (i.e. a prime p so that (p-1)/2 "
"is also prime)."
msgstr ""

#. type: textblock
#: C/crypto/BN_generate_prime.pod:76
msgid ""
"The PRNG must be seeded prior to calling BN_generate_prime_ex().  The prime "
"number generation has a negligible error probability."
msgstr ""

#. type: textblock
#: C/crypto/BN_generate_prime.pod:79
msgid ""
"BN_is_prime_ex() and BN_is_prime_fasttest_ex() test if the number B<p> is "
"prime.  The following tests are performed until one of them shows that B<p> "
"is composite; if B<p> passes all these tests, it is considered prime."
msgstr ""

#. type: textblock
#: C/crypto/BN_generate_prime.pod:84
msgid ""
"BN_is_prime_fasttest_ex(), when called with B<do_trial_division == 1>, first "
"attempts trial division by a number of small primes; if no divisors are "
"found by this test and B<cb> is not B<NULL>, B<BN_GENCB_call(cb, 1, -1)> is "
"called.  If B<do_trial_division == 0>, this test is skipped."
msgstr ""

#. type: textblock
#: C/crypto/BN_generate_prime.pod:90
msgid ""
"Both BN_is_prime_ex() and BN_is_prime_fasttest_ex() perform a Miller-Rabin "
"probabilistic primality test with B<nchecks> iterations. If B<nchecks == "
"BN_prime_checks>, a number of iterations is used that yields a false "
"positive rate of at most 2^-80 for random input."
msgstr ""

#. type: textblock
#: C/crypto/BN_generate_prime.pod:95
msgid ""
"If B<cb> is not B<NULL>, B<BN_GENCB_call(cb, 1, j)> is called after the j-th "
"iteration (j = 0, 1, ...). B<ctx> is a pre-allocated B<BN_CTX> (to save the "
"overhead of allocating and freeing the structure in a loop), or B<NULL>."
msgstr ""

#. type: textblock
#: C/crypto/BN_generate_prime.pod:100
msgid ""
"BN_GENCB_call calls the callback function held in the B<BN_GENCB> structure "
"and passes the ints B<a> and B<b> as arguments. There are two types of "
"B<BN_GENCB> structure that are supported: \"new\" style and \"old\" style. "
"New programs should prefer the \"new\" style, whilst the \"old\" style is "
"provided for backwards compatibility purposes."
msgstr ""

#. type: textblock
#: C/crypto/BN_generate_prime.pod:106
msgid ""
"For \"new\" style callbacks a BN_GENCB structure should be initialised with "
"a call to BN_GENCB_set, where B<gencb> is a B<BN_GENCB *>, B<callback> is of "
"type B<int (*callback)(int, int, BN_GENCB *)> and B<cb_arg> is a B<void *>.  "
"\"Old\" style callbacks are the same except they are initialised with a call "
"to BN_GENCB_set_old and B<callback> is of type B<void (*callback)(int, int, "
"void *)>."
msgstr ""

#. type: textblock
#: C/crypto/BN_generate_prime.pod:113
msgid ""
"A callback is invoked through a call to B<BN_GENCB_call>. This will check "
"the type of the callback and will invoke B<callback(a, b, gencb)> for new "
"style callbacks or B<callback(a, b, cb_arg)> for old style."
msgstr ""

#. type: textblock
#: C/crypto/BN_generate_prime.pod:117
msgid ""
"BN_generate_prime (deprecated) works in the same way as BN_generate_prime_ex "
"but expects an old style callback function directly in the B<callback> "
"parameter, and an argument to pass to it in the B<cb_arg>. Similarly "
"BN_is_prime and BN_is_prime_fasttest are deprecated and can be compared to "
"BN_is_prime_ex and BN_is_prime_fasttest_ex respectively."
msgstr ""

#. type: textblock
#: C/crypto/BN_generate_prime.pod:126
#, fuzzy
#| msgid "BN_print_fp() and BN_print() return 1 on success, 0 on write errors."
msgid "BN_generate_prime_ex() return 1 on success or 0 on error."
msgstr ""
"B<BN_print_fp>() et B<BN_print>() renvoient 1 si elles réussissent ou 0 en "
"cas d'erreur d'écriture."

#. type: textblock
#: C/crypto/BN_generate_prime.pod:128
msgid ""
"BN_is_prime_ex(), BN_is_prime_fasttest_ex(), BN_is_prime() and "
"BN_is_prime_fasttest() return 0 if the number is composite, 1 if it is prime "
"with an error probability of less than 0.25^B<nchecks>, and -1 on error."
msgstr ""

#. type: textblock
#: C/crypto/BN_generate_prime.pod:133
msgid ""
"BN_generate_prime() returns the prime number on success, B<NULL> otherwise."
msgstr ""

#. type: textblock
#: C/crypto/BN_generate_prime.pod:135
msgid "Callback functions should return 1 on success or 0 on error."
msgstr ""

#. type: textblock
#: C/crypto/BN_generate_prime.pod:141
msgid ""
"L<bn(3)|bn(3)>, L<ERR_get_error(3)|ERR_get_error(3)>, L<rand(3)|rand(3)>"
msgstr ""
"L<bn(3)|bn(3)>, L<ERR_get_error(3)|ERR_get_error(3)>, L<rand(3)|rand(3)>"

#. type: textblock
#: C/crypto/BN_generate_prime.pod:145
msgid ""
"The B<cb_arg> arguments to BN_generate_prime() and to BN_is_prime()  were "
"added in SSLeay 0.9.0. The B<ret> argument to BN_generate_prime()  was added "
"in SSLeay 0.9.1.  BN_is_prime_fasttest() was added in OpenSSL 0.9.5."
msgstr ""

#. type: textblock
#: C/crypto/BN_mod_inverse.pod:5
msgid "BN_mod_inverse - compute inverse modulo n"
msgstr "BN_mod_inverse - Calculer l'inverse modulo n"

#. type: verbatim
#: C/crypto/BN_mod_inverse.pod:11
#, no-wrap
msgid ""
" BIGNUM *BN_mod_inverse(BIGNUM *r, BIGNUM *a, const BIGNUM *n,\n"
"           BN_CTX *ctx);\n"
"\n"
msgstr ""
" BIGNUM *BN_mod_inverse(BIGNUM *r, BIGNUM *a, const BIGNUM *n,\n"
"           BN_CTX *ctx);\n"
"\n"

#. type: textblock
#: C/crypto/BN_mod_inverse.pod:16
msgid ""
"BN_mod_inverse() computes the inverse of B<a> modulo B<n> places the result "
"in B<r> (C<(a*r)%n==1>). If B<r> is NULL, a new B<BIGNUM> is created."
msgstr ""
"BN_mod_inverse() calcule l'inverse modulo B<n> de B<a>, et place le résultat "
"dans B<r> (C<(a*r)%n==1>). Si B<r> est NULL, un nouveau B<BIGNUM> est créé."

#. type: textblock
#: C/crypto/BN_mod_inverse.pod:20
msgid ""
"B<ctx> is a previously allocated B<BN_CTX> used for temporary variables. "
"B<r> may be the same B<BIGNUM> as B<a> or B<n>."
msgstr ""
"B<ctx> est un B<BN_CTX> alloué auparavant, utilisé pour les variables "
"temporaires. B<r> peut être le même B<BIGNUM> que B<a> ou B<n>."

#. type: textblock
#: C/crypto/BN_mod_inverse.pod:25
msgid ""
"BN_mod_inverse() returns the B<BIGNUM> containing the inverse, and NULL on "
"error. The error codes can be obtained by L<ERR_get_error(3)|"
"ERR_get_error(3)>."
msgstr ""
"BN_mod_inverse() renvoie le B<BIGNUM> contenant l'inverse, ou NULL en cas "
"d'erreur. Les codes d'erreur peuvent être obtenus avec L<ERR_get_error(3)|"
"ERR_get_error(3)>."

#. type: textblock
#: C/crypto/BN_mod_inverse.pod:34
msgid "BN_mod_inverse() is available in all versions of SSLeay and OpenSSL."
msgstr ""
"BN_mod_inverse() est disponible dans toutes les versions de SSLeay et "
"OpenSSL."

#. type: textblock
#: C/crypto/BN_mod_mul_montgomery.pod:5
msgid ""
"BN_mod_mul_montgomery, BN_MONT_CTX_new, BN_MONT_CTX_init, BN_MONT_CTX_free, "
"BN_MONT_CTX_set, BN_MONT_CTX_copy, BN_from_montgomery, BN_to_montgomery - "
"Montgomery multiplication"
msgstr ""

#. type: verbatim
#: C/crypto/BN_mod_mul_montgomery.pod:13
#, no-wrap
msgid ""
" BN_MONT_CTX *BN_MONT_CTX_new(void);\n"
" void BN_MONT_CTX_init(BN_MONT_CTX *ctx);\n"
" void BN_MONT_CTX_free(BN_MONT_CTX *mont);\n"
"\n"
msgstr ""
" BN_MONT_CTX *BN_MONT_CTX_new(void);\n"
" void BN_MONT_CTX_init(BN_MONT_CTX *ctx);\n"
" void BN_MONT_CTX_free(BN_MONT_CTX *mont);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_mod_mul_montgomery.pod:17
#, no-wrap
msgid ""
" int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *m, BN_CTX *ctx);\n"
" BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to, BN_MONT_CTX *from);\n"
"\n"
msgstr ""
" int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *m, BN_CTX *ctx);\n"
" BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to, BN_MONT_CTX *from);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_mod_mul_montgomery.pod:20
#, no-wrap
msgid ""
" int BN_mod_mul_montgomery(BIGNUM *r, BIGNUM *a, BIGNUM *b,\n"
"         BN_MONT_CTX *mont, BN_CTX *ctx);\n"
"\n"
msgstr ""
" int BN_mod_mul_montgomery(BIGNUM *r, BIGNUM *a, BIGNUM *b,\n"
"         BN_MONT_CTX *mont, BN_CTX *ctx);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_mod_mul_montgomery.pod:23
#, no-wrap
msgid ""
" int BN_from_montgomery(BIGNUM *r, BIGNUM *a, BN_MONT_CTX *mont,\n"
"         BN_CTX *ctx);\n"
"\n"
msgstr ""
" int BN_from_montgomery(BIGNUM *r, BIGNUM *a, BN_MONT_CTX *mont,\n"
"         BN_CTX *ctx);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_mod_mul_montgomery.pod:26
#, no-wrap
msgid ""
" int BN_to_montgomery(BIGNUM *r, BIGNUM *a, BN_MONT_CTX *mont,\n"
"         BN_CTX *ctx);\n"
"\n"
msgstr ""
" int BN_to_montgomery(BIGNUM *r, BIGNUM *a, BN_MONT_CTX *mont,\n"
"         BN_CTX *ctx);\n"
"\n"

#. type: textblock
#: C/crypto/BN_mod_mul_montgomery.pod:31
msgid ""
"These functions implement Montgomery multiplication. They are used "
"automatically when L<BN_mod_exp(3)|BN_mod_exp(3)> is called with suitable "
"input, but they may be useful when several operations are to be performed "
"using the same modulus."
msgstr ""

#. type: textblock
#: C/crypto/BN_mod_mul_montgomery.pod:36
msgid ""
"BN_MONT_CTX_new() allocates and initializes a B<BN_MONT_CTX> structure.  "
"BN_MONT_CTX_init() initializes an existing uninitialized B<BN_MONT_CTX>."
msgstr ""

#. type: textblock
#: C/crypto/BN_mod_mul_montgomery.pod:39
msgid ""
"BN_MONT_CTX_set() sets up the I<mont> structure from the modulus I<m> by "
"precomputing its inverse and a value R."
msgstr ""

#. type: textblock
#: C/crypto/BN_mod_mul_montgomery.pod:42
msgid "BN_MONT_CTX_copy() copies the B<BN_MONT_CTX> I<from> to I<to>."
msgstr ""

#. type: textblock
#: C/crypto/BN_mod_mul_montgomery.pod:44
msgid ""
"BN_MONT_CTX_free() frees the components of the B<BN_MONT_CTX>, and, if it "
"was created by BN_MONT_CTX_new(), also the structure itself."
msgstr ""

#. type: textblock
#: C/crypto/BN_mod_mul_montgomery.pod:47
msgid ""
"BN_mod_mul_montgomery() computes Mont(I<a>,I<b>):=I<a>*I<b>*R^-1 and places "
"the result in I<r>."
msgstr ""

#. type: textblock
#: C/crypto/BN_mod_mul_montgomery.pod:50
msgid ""
"BN_from_montgomery() performs the Montgomery reduction I<r> = I<a>*R^-1."
msgstr ""

#. type: textblock
#: C/crypto/BN_mod_mul_montgomery.pod:52
msgid ""
"BN_to_montgomery() computes Mont(I<a>,R^2), i.e. I<a>*R.  Note that I<a> "
"must be non-negative and smaller than the modulus."
msgstr ""

#. type: textblock
#: C/crypto/BN_mod_mul_montgomery.pod:55
msgid ""
"For all functions, I<ctx> is a previously allocated B<BN_CTX> used for "
"temporary variables."
msgstr ""

#. type: textblock
#: C/crypto/BN_mod_mul_montgomery.pod:58
msgid "The B<BN_MONT_CTX> structure is defined as follows:"
msgstr ""

#. type: verbatim
#: C/crypto/BN_mod_mul_montgomery.pod:60
#, no-wrap
msgid ""
" typedef struct bn_mont_ctx_st\n"
"        {\n"
"        int ri;         /* number of bits in R */\n"
"        BIGNUM RR;      /* R^2 (used to convert to Montgomery form) */\n"
"        BIGNUM N;       /* The modulus */\n"
"        BIGNUM Ni;      /* R*(1/R mod N) - N*Ni = 1\n"
"                         * (Ni is only stored for bignum algorithm) */\n"
"        BN_ULONG n0;    /* least significant word of Ni */\n"
"        int flags;\n"
"        } BN_MONT_CTX;\n"
"\n"
msgstr ""

#. type: textblock
#: C/crypto/BN_mod_mul_montgomery.pod:71
msgid "BN_to_montgomery() is a macro."
msgstr ""

#. type: textblock
#: C/crypto/BN_mod_mul_montgomery.pod:75
msgid ""
"BN_MONT_CTX_new() returns the newly allocated B<BN_MONT_CTX>, and NULL on "
"error."
msgstr ""

#. type: textblock
#: C/crypto/BN_mod_mul_montgomery.pod:78
msgid "BN_MONT_CTX_init() and BN_MONT_CTX_free() have no return values."
msgstr ""

#. type: textblock
#: C/crypto/BN_mod_mul_montgomery.pod:80 C/crypto/BN_mod_mul_reciprocal.pod:67
msgid ""
"For the other functions, 1 is returned for success, 0 on error.  The error "
"codes can be obtained by L<ERR_get_error(3)|ERR_get_error(3)>."
msgstr ""
"Pour les autres fonctions, 1 est renvoyé est cas de succès et 0 en cas "
"d'erreur. Les codes d'erreur peuvent être obtenus avec L<ERR_get_error(3)|"
"ERR_get_error(3)>."

#. type: =head1
#: C/crypto/BN_mod_mul_montgomery.pod:83
msgid "WARNING"
msgstr "AVERTISSEMENT"

#. type: textblock
#: C/crypto/BN_mod_mul_montgomery.pod:85
msgid ""
"The inputs must be reduced modulo B<m>, otherwise the result will be outside "
"the expected range."
msgstr ""

#. type: textblock
#: C/crypto/BN_mod_mul_montgomery.pod:90 C/crypto/BN_mod_mul_reciprocal.pod:72
msgid ""
"L<bn(3)|bn(3)>, L<ERR_get_error(3)|ERR_get_error(3)>, L<BN_add(3)|"
"BN_add(3)>, L<BN_CTX_new(3)|BN_CTX_new(3)>"
msgstr ""
"L<bn(3)|bn(3)>, L<ERR_get_error(3)|ERR_get_error(3)>, L<BN_add(3)|"
"BN_add(3)>, L<BN_CTX_new(3)|BN_CTX_new(3)>"

#. type: textblock
#: C/crypto/BN_mod_mul_montgomery.pod:95
msgid ""
"BN_MONT_CTX_new(), BN_MONT_CTX_free(), BN_MONT_CTX_set(), "
"BN_mod_mul_montgomery(), BN_from_montgomery() and BN_to_montgomery()  are "
"available in all versions of SSLeay and OpenSSL."
msgstr ""
"BN_MONT_CTX_new(), BN_MONT_CTX_free(), BN_MONT_CTX_set(), "
"BN_mod_mul_montgomery(), BN_from_montgomery() and BN_to_montgomery() sont "
"disponibles dans toutes les versions de SSLeay et OpenSSL."

#. type: textblock
#: C/crypto/BN_mod_mul_montgomery.pod:99
msgid "BN_MONT_CTX_init() and BN_MONT_CTX_copy() were added in SSLeay 0.9.1b."
msgstr ""
"BN_MONT_CTX_init() and BN_MONT_CTX_copy() ont été ajoutés dans la version "
"0.9.1b de SSLeay."

#. type: textblock
#: C/crypto/BN_mod_mul_reciprocal.pod:5
msgid ""
"BN_mod_mul_reciprocal, BN_div_recp, BN_RECP_CTX_new, BN_RECP_CTX_init, "
"BN_RECP_CTX_free, BN_RECP_CTX_set - modular multiplication using reciprocal"
msgstr ""

#. type: verbatim
#: C/crypto/BN_mod_mul_reciprocal.pod:13
#, no-wrap
msgid ""
" BN_RECP_CTX *BN_RECP_CTX_new(void);\n"
" void BN_RECP_CTX_init(BN_RECP_CTX *recp);\n"
" void BN_RECP_CTX_free(BN_RECP_CTX *recp);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_mod_mul_reciprocal.pod:17
#, no-wrap
msgid ""
" int BN_RECP_CTX_set(BN_RECP_CTX *recp, const BIGNUM *m, BN_CTX *ctx);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_mod_mul_reciprocal.pod:19
#, no-wrap
msgid ""
" int BN_div_recp(BIGNUM *dv, BIGNUM *rem, BIGNUM *a, BN_RECP_CTX *recp,\n"
"        BN_CTX *ctx);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_mod_mul_reciprocal.pod:22
#, no-wrap
msgid ""
" int BN_mod_mul_reciprocal(BIGNUM *r, BIGNUM *a, BIGNUM *b,\n"
"        BN_RECP_CTX *recp, BN_CTX *ctx);\n"
"\n"
msgstr ""

#. type: textblock
#: C/crypto/BN_mod_mul_reciprocal.pod:27
msgid ""
"BN_mod_mul_reciprocal() can be used to perform an efficient L<BN_mod_mul(3)|"
"BN_mod_mul(3)> operation when the operation will be performed repeatedly "
"with the same modulus. It computes B<r>=(B<a>*B<b>)%B<m> using B<recp>=1/"
"B<m>, which is set as described below.  B<ctx> is a previously allocated "
"B<BN_CTX> used for temporary variables."
msgstr ""

#. type: textblock
#: C/crypto/BN_mod_mul_reciprocal.pod:33
msgid ""
"BN_RECP_CTX_new() allocates and initializes a B<BN_RECP> structure.  "
"BN_RECP_CTX_init() initializes an existing uninitialized B<BN_RECP>."
msgstr ""

#. type: textblock
#: C/crypto/BN_mod_mul_reciprocal.pod:36
msgid ""
"BN_RECP_CTX_free() frees the components of the B<BN_RECP>, and, if it was "
"created by BN_RECP_CTX_new(), also the structure itself."
msgstr ""

#. type: textblock
#: C/crypto/BN_mod_mul_reciprocal.pod:39
msgid ""
"BN_RECP_CTX_set() stores B<m> in B<recp> and sets it up for computing 1/B<m> "
"and shifting it left by BN_num_bits(B<m>)+1 to make it an integer. The "
"result and the number of bits it was shifted left will later be stored in "
"B<recp>."
msgstr ""

#. type: textblock
#: C/crypto/BN_mod_mul_reciprocal.pod:44
msgid ""
"BN_div_recp() divides B<a> by B<m> using B<recp>. It places the quotient in "
"B<dv> and the remainder in B<rem>."
msgstr ""

#. type: textblock
#: C/crypto/BN_mod_mul_reciprocal.pod:47
msgid "The B<BN_RECP_CTX> structure is defined as follows:"
msgstr ""

#. type: verbatim
#: C/crypto/BN_mod_mul_reciprocal.pod:49
#, no-wrap
msgid ""
" typedef struct bn_recp_ctx_st\n"
"\t{\n"
"\tBIGNUM N;\t/* the divisor */\n"
"\tBIGNUM Nr;\t/* the reciprocal */\n"
"\tint num_bits;\n"
"\tint shift;\n"
"\tint flags;\n"
"\t} BN_RECP_CTX;\n"
"\n"
msgstr ""

#. type: textblock
#: C/crypto/BN_mod_mul_reciprocal.pod:58
msgid "It cannot be shared between threads."
msgstr ""

#. type: textblock
#: C/crypto/BN_mod_mul_reciprocal.pod:62
msgid ""
"BN_RECP_CTX_new() returns the newly allocated B<BN_RECP_CTX>, and NULL on "
"error."
msgstr ""

#. type: textblock
#: C/crypto/BN_mod_mul_reciprocal.pod:65
msgid "BN_RECP_CTX_init() and BN_RECP_CTX_free() have no return values."
msgstr "BN_RECP_CTX_init() et BN_RECP_CTX_free() ne renvoient rien."

#. type: textblock
#: C/crypto/BN_mod_mul_reciprocal.pod:77
msgid ""
"B<BN_RECP_CTX> was added in SSLeay 0.9.0. Before that, the function "
"BN_reciprocal() was used instead, and the BN_mod_mul_reciprocal()  arguments "
"were different."
msgstr ""
"B<BN_RECP_CTX> a été ajoutée dans SSLeay 0.9.0. Auparavant, la fonction "
"BN_reciprocal() était utilisée à la place et les paramètres de "
"BN_mod_mul_reciprocal() étaient différents."

#. type: textblock
#: C/crypto/BN_new.pod:5
msgid ""
"BN_new, BN_init, BN_clear, BN_free, BN_clear_free - allocate and free BIGNUMs"
msgstr ""
"BN_new, BN_init, BN_clear, BN_free, BN_clear_free - Allouer et libérer des "
"BIGNUM"

#. type: verbatim
#: C/crypto/BN_new.pod:11
#, no-wrap
msgid ""
" BIGNUM *BN_new(void);\n"
"\n"
msgstr ""
" BIGNUM *BN_new(void);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_new.pod:13
#, no-wrap
msgid ""
" void BN_init(BIGNUM *);\n"
"\n"
msgstr ""
" void BN_init(BIGNUM *);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_new.pod:15
#, no-wrap
msgid ""
" void BN_clear(BIGNUM *a);\n"
"\n"
msgstr ""
" void BN_clear(BIGNUM *a);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_new.pod:17
#, no-wrap
msgid ""
" void BN_free(BIGNUM *a);\n"
"\n"
msgstr ""
" void BN_free(BIGNUM *a);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_new.pod:19
#, no-wrap
msgid ""
" void BN_clear_free(BIGNUM *a);\n"
"\n"
msgstr ""
" void BN_clear_free(BIGNUM *a);\n"
"\n"

#. type: textblock
#: C/crypto/BN_new.pod:23
msgid ""
"BN_new() allocates and initializes a B<BIGNUM> structure. BN_init()  "
"initializes an existing uninitialized B<BIGNUM>."
msgstr ""
"B<BN_new>() alloue et initialise une structure B<BIGNUM>. B<BN_init>() "
"initialise un B<BIGNUM> existant mais non initialisé."

#. type: textblock
#: C/crypto/BN_new.pod:26
msgid ""
"BN_clear() is used to destroy sensitive data such as keys when they are no "
"longer needed. It erases the memory used by B<a> and sets it to the value 0."
msgstr ""
"B<BN_clear>() est utilisée pour détruire des données sensibles comme les "
"clefs quand elles ne sont plus nécessaires. Elle efface la mémoire utilisée "
"par I<a> et la définit à la valeur B<0>."

#. type: textblock
#: C/crypto/BN_new.pod:30
msgid ""
"BN_free() frees the components of the B<BIGNUM>, and if it was created by "
"BN_new(), also the structure itself. BN_clear_free() additionally overwrites "
"the data before the memory is returned to the system."
msgstr ""
"B<BN_free>() libère les composants de B<BIGNUM> et, s'il a été créé par "
"B<BN_new>(), la structure elle-même. B<BN_clear_free>() écrase de plus les "
"données avant que la mémoire ne soit rendue au système."

#. type: textblock
#: C/crypto/BN_new.pod:36
msgid ""
"BN_new() returns a pointer to the B<BIGNUM>. If the allocation fails, it "
"returns B<NULL> and sets an error code that can be obtained by "
"L<ERR_get_error(3)|ERR_get_error(3)>."
msgstr ""
"B<BN_new>() renvoie un pointeur vers le B<BIGNUM>. Si l'allocation échoue, "
"elle renvoie NULL et définit un code d'erreur qui peut être obtenu par "
"L<ERR_get_error(3)|ERR_get_error(3)>."

#. type: textblock
#: C/crypto/BN_new.pod:40
msgid ""
"BN_init(), BN_clear(), BN_free() and BN_clear_free() have no return values."
msgstr ""
"B<BN_init>(), B<BN_clear>(), B<BN_free>() et B<BN_clear_free>() ne renvoient "
"rien."

#. type: textblock
#: C/crypto/BN_new.pod:49
msgid ""
"BN_new(), BN_clear(), BN_free() and BN_clear_free() are available in all "
"versions on SSLeay and OpenSSL.  BN_init() was added in SSLeay 0.9.1b."
msgstr ""
"B<BN_new>(), B<BN_clear>(), B<BN_free>() et B<BN_clear_free>() sont "
"disponibles dans toutes les versions de SSLeay et d'OpenSSL. B<BN_init>() a "
"été ajoutée dans SSLeay 0.9.1b."

#. type: textblock
#: C/crypto/BN_num_bytes.pod:5
msgid "BN_num_bits, BN_num_bytes, BN_num_bits_word - get BIGNUM size"
msgstr ""
"BN_num_bits, BN_num_bytes, BN_num_bits_word - Obtenir la taille de BIGNUM"

#. type: verbatim
#: C/crypto/BN_num_bytes.pod:11
#, no-wrap
msgid ""
" int BN_num_bytes(const BIGNUM *a);\n"
"\n"
msgstr ""
" int BN_num_bytes(const BIGNUM *a);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_num_bytes.pod:13
#, no-wrap
msgid ""
" int BN_num_bits(const BIGNUM *a);\n"
"\n"
msgstr ""
" int BN_num_bits(const BIGNUM *a);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_num_bytes.pod:15
#, no-wrap
msgid ""
" int BN_num_bits_word(BN_ULONG w);\n"
"\n"
msgstr ""
" int BN_num_bits_word(BN_ULONG w);\n"
"\n"

#. type: textblock
#: C/crypto/BN_num_bytes.pod:19
msgid "BN_num_bytes() returns the size of a B<BIGNUM> in bytes."
msgstr "B<BN_num_bytes>() renvoie la taille d'un B<BIGNUM> en octet."

#. type: textblock
#: C/crypto/BN_num_bytes.pod:21
msgid ""
"BN_num_bits_word() returns the number of significant bits in a word.  If we "
"take 0x00000432 as an example, it returns 11, not 16, not 32.  Basically, "
"except for a zero, it returns I<floor(log2(w))+1>."
msgstr ""
"B<BN_num_bits_word>() renvoie le nombre de bits significatifs dans un mot. "
"Avec 0x00000432 par exemple, 11 est renvoyé, pas 16 ni 32. � part pour zéro, "
"c'est à peu près I<floor(log2(w))+1> qui est renvoyé."

#. type: textblock
#: C/crypto/BN_num_bytes.pod:25
msgid ""
"BN_num_bits() returns the number of significant bits in a B<BIGNUM>, "
"following the same principle as BN_num_bits_word()."
msgstr ""
"B<BN_num_bits>() renvoie le nombre de bits significatifs dans un B<BIGNUM>, "
"en suivant le même principe que B<BN_num_bits_word>()."

#. type: textblock
#: C/crypto/BN_num_bytes.pod:28
msgid "BN_num_bytes() is a macro."
msgstr "B<BN_num_bytes>() est une macro."

#. type: textblock
#: C/crypto/BN_num_bytes.pod:32
msgid "The size."
msgstr "La taille."

#. type: =head1
#: C/crypto/BN_num_bytes.pod:34
msgid "NOTES"
msgstr "NOTES"

#. type: textblock
#: C/crypto/BN_num_bytes.pod:36
msgid ""
"Some have tried using BN_num_bits() on individual numbers in RSA keys, DH "
"keys and DSA keys, and found that they don't always come up with the number "
"of bits they expected (something like 512, 1024, 2048, ...).  This is "
"because generating a number with some specific number of bits doesn't always "
"set the highest bits, thereby making the number of I<significant> bits a "
"little lower.  If you want to know the \"key size\" of such a key, either "
"use functions like RSA_size(), DH_size()  and DSA_size(), or use "
"BN_num_bytes() and multiply with 8 (although there's no real guarantee that "
"will match the \"key size\", just a lot more probability)."
msgstr ""
"Certaines personnes ont essayé d'utiliser B<BN_num_bits>() sur des nombres "
"indivisibles dans des clefs RSA, clefs DH et clefs DSA, et ont trouvé "
"qu'elle ne renvoyait pas toujours le nombre de bits attendus (quelque chose "
"comme 512, 1024, 2048, etc.) C'est parce que la génération d'un nombre avec "
"certains nombres particuliers de bits ne définit pas toujours les bits les "
"plus élevés, rendant ainsi le nombre de bits I<significatifs> un peu "
"inférieur. Si vous voulez connaître la « taille de clef » d'une telle clef, "
"utilisez des fonctions comme B<RSA_size>(), B<DH_size>() et B<DSA_size>(), "
"ou utilisez B<BN_num_bytes>() et multipliez par 8 (bien qu'il n'y ait aucune "
"véritable garantie que cela corresponde à la « taille de clef », c'est "
"simplement beaucoup plus probable)."

#. type: textblock
#: C/crypto/BN_num_bytes.pod:49
msgid ""
"L<bn(3)|bn(3)>, L<DH_size(3)|DH_size(3)>, L<DSA_size(3)|DSA_size(3)>, "
"L<RSA_size(3)|RSA_size(3)>"
msgstr ""
"L<bn(3)|bn(3)>, L<DH_size(3)|DH_size(3)>, L<DSA_size(3)|DSA_size(3)>, "
"L<RSA_size(3)|RSA_size(3)>"

#. type: textblock
#: C/crypto/BN_num_bytes.pod:54
msgid ""
"BN_num_bytes(), BN_num_bits() and BN_num_bits_word() are available in all "
"versions of SSLeay and OpenSSL."
msgstr ""
"B<BN_num_bytes>(), B<BN_num_bits>() et B<BN_num_bits_word>() sont "
"disponibles dans toutes les versions de SSLeay et d'OpenSSL."

#. type: textblock
#: C/crypto/BN_rand.pod:5
#, fuzzy
#| msgid "BN_rand, BN_pseudo_rand - generate pseudo-random number"
msgid ""
"BN_rand, BN_pseudo_rand, BN_rand_range, BN_pseudo_rand_range - generate "
"pseudo-random number"
msgstr "BN_rand, BN_pseudo_rand - Produire un nombre pseudoaléatoire"

#. type: verbatim
#: C/crypto/BN_rand.pod:11
#, no-wrap
msgid ""
" int BN_rand(BIGNUM *rnd, int bits, int top, int bottom);\n"
"\n"
msgstr ""
" int BN_rand(BIGNUM *rnd, int bits, int top, int bottom);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_rand.pod:13
#, no-wrap
msgid ""
" int BN_pseudo_rand(BIGNUM *rnd, int bits, int top, int bottom);\n"
"\n"
msgstr ""
" int BN_pseudo_rand(BIGNUM *rnd, int bits, int top, int bottom);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_rand.pod:15
#, no-wrap
msgid ""
" int BN_rand_range(BIGNUM *rnd, BIGNUM *range);\n"
"\n"
msgstr ""
" int BN_rand_range(BIGNUM *rnd, BIGNUM *range);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_rand.pod:17
#, no-wrap
msgid ""
" int BN_pseudo_rand_range(BIGNUM *rnd, BIGNUM *range);\n"
"\n"
msgstr ""
" int BN_pseudo_rand_range(BIGNUM *rnd, BIGNUM *range);\n"
"\n"

#. type: textblock
#: C/crypto/BN_rand.pod:21
msgid ""
"BN_rand() generates a cryptographically strong pseudo-random number of "
"B<bits> in length and stores it in B<rnd>. If B<top> is -1, the most "
"significant bit of the random number can be zero. If B<top> is 0, it is set "
"to 1, and if B<top> is 1, the two most significant bits of the number will "
"be set to 1, so that the product of two such random numbers will always have "
"2*B<bits> length.  If B<bottom> is true, the number will be odd. The value "
"of B<bits> must be zero or greater. If B<bits> is 1 then B<top> cannot also "
"be 1."
msgstr ""
"B<BN_rand>() produit un nombre pseudoaléatoire cryptographiquement fort de "
"taille I<bits> bits et le stocke dans I<rnd>. Si I<top> est -1, le bit de "
"poids fort du nombre aléatoire peut être zéro. Si I<top> est 0, il est "
"défini à 1 et si I<top> est 1, les deux bits de poids fort du nombre seront "
"définis à 1, de telle sorte que le produit de ces deux nombres aura toujours "
"une taille de 2*I<bits>. Si I<bottom> est vrai, le nombre sera impair. La "
"valeur de I<bits> doit être au moins nulle. Si I<bits> est 1, alors I<top> "
"ne peut pas être aussi 1."

#. type: textblock
#: C/crypto/BN_rand.pod:30
msgid ""
"BN_pseudo_rand() does the same, but pseudo-random numbers generated by this "
"function are not necessarily unpredictable. They can be used for non-"
"cryptographic purposes and for certain purposes in cryptographic protocols, "
"but usually not for key generation etc."
msgstr ""
"B<BN_pseudo_rand>() fait la même chose, sauf que les nombres "
"pseudoaléatoires produits par cette fonction ne sont pas nécessairement "
"imprévisibles. Ils peuvent servir à des utilisations non cryptographiques et "
"à certaines utilisations dans des protocoles cryptographiques, mais "
"normalement pas à la génération de clef, etc."

#. type: textblock
#: C/crypto/BN_rand.pod:35
#, fuzzy
#| msgid ""
#| "BN_rand_range() generates a cryptographically strong pseudo-random number "
#| "B<rnd> in the range 0 <lt>= B<rnd> E<lt> B<range>.  "
#| "BN_pseudo_rand_range() does the same, but is based on BN_pseudo_rand(), "
#| "and hence numbers generated by it are not necessarily unpredictable."
msgid ""
"BN_rand_range() generates a cryptographically strong pseudo-random number "
"B<rnd> in the range 0 E<lt>= B<rnd> E<lt> B<range>.  BN_pseudo_rand_range() "
"does the same, but is based on BN_pseudo_rand(), and hence numbers generated "
"by it are not necessarily unpredictable."
msgstr ""
"B<BN_rand_range>() produit un nombre pseudoaléatoire cryptographiquement "
"fort I<rnd> dans l'intervalle 0 E<lt>= I<rnd> E<lt> I<range>. "
"B<BN_pseudo_rand_range>() fait la même chose, mais est basée sur "
"B<BN_pseudo_rand>(), donc les nombres pseudoaléatoires produits par cette "
"fonction ne sont pas nécessairement imprévisibles."

#. type: textblock
#: C/crypto/BN_rand.pod:40
msgid "The PRNG must be seeded prior to calling BN_rand() or BN_rand_range()."
msgstr ""
"Le générateur de nombres aléatoires doit être initialisé avant d'appeler "
"B<BN_rand>() ou B<BN_rand_range>()."

#. type: textblock
#: C/crypto/BN_rand.pod:44
msgid ""
"The functions return 1 on success, 0 on error.  The error codes can be "
"obtained by L<ERR_get_error(3)|ERR_get_error(3)>."
msgstr ""
"Les fonctions renvoient 1 si elles réussissent et 0 en cas d'erreur. Les "
"codes d'erreur peuvent être obtenu par L<ERR_get_error(3)|ERR_get_error(3)>."

#. type: textblock
#: C/crypto/BN_rand.pod:49
msgid ""
"L<bn(3)|bn(3)>, L<ERR_get_error(3)|ERR_get_error(3)>, L<rand(3)|rand(3)>, "
"L<RAND_add(3)|RAND_add(3)>, L<RAND_bytes(3)|RAND_bytes(3)>"
msgstr ""
"L<bn(3)|bn(3)>, L<ERR_get_error(3)|ERR_get_error(3)>, L<rand(3)|rand(3)>, "
"L<RAND_add(3)|RAND_add(3)>, L<RAND_bytes(3)|RAND_bytes(3)>"

#. type: textblock
#: C/crypto/BN_rand.pod:54
msgid ""
"BN_rand() is available in all versions of SSLeay and OpenSSL.  "
"BN_pseudo_rand() was added in OpenSSL 0.9.5. The B<top> == -1 case and the "
"function BN_rand_range() were added in OpenSSL 0.9.6a.  "
"BN_pseudo_rand_range() was added in OpenSSL 0.9.6c."
msgstr ""
"B<BN_rand>() est disponible dans toutes les versions de SSLeay et OpenSSL. "
"B<BN_pseudo_rand>() a été ajoutée dans OpenSSL 0.9.5. Le cas I<top> == -1 et "
"la fonction B<BN_rand_range>() ont été ajoutés dans OpenSSL 0.9.6a. "
"B<BN_pseudo_rand_range>() a été ajoutée dans OpenSSL 0.9.6c."

#. type: textblock
#: C/crypto/BN_set_bit.pod:5
msgid ""
"BN_set_bit, BN_clear_bit, BN_is_bit_set, BN_mask_bits, BN_lshift, "
"BN_lshift1, BN_rshift, BN_rshift1 - bit operations on BIGNUMs"
msgstr ""

#. type: verbatim
#: C/crypto/BN_set_bit.pod:12
#, no-wrap
msgid ""
" int BN_set_bit(BIGNUM *a, int n);\n"
" int BN_clear_bit(BIGNUM *a, int n);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_set_bit.pod:15
#, no-wrap
msgid ""
" int BN_is_bit_set(const BIGNUM *a, int n);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_set_bit.pod:17
#, no-wrap
msgid ""
" int BN_mask_bits(BIGNUM *a, int n);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_set_bit.pod:19
#, no-wrap
msgid ""
" int BN_lshift(BIGNUM *r, const BIGNUM *a, int n);\n"
" int BN_lshift1(BIGNUM *r, BIGNUM *a);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/BN_set_bit.pod:22
#, no-wrap
msgid ""
" int BN_rshift(BIGNUM *r, BIGNUM *a, int n);\n"
" int BN_rshift1(BIGNUM *r, BIGNUM *a);\n"
"\n"
msgstr ""

#. type: textblock
#: C/crypto/BN_set_bit.pod:27
msgid ""
"BN_set_bit() sets bit B<n> in B<a> to 1 (C<a|=(1E<lt>E<lt>n)>). The number "
"is expanded if necessary."
msgstr ""

#. type: textblock
#: C/crypto/BN_set_bit.pod:30
msgid ""
"BN_clear_bit() sets bit B<n> in B<a> to 0 (C<a&=~(1E<lt>E<lt>n)>). An error "
"occurs if B<a> is shorter than B<n> bits."
msgstr ""

#. type: textblock
#: C/crypto/BN_set_bit.pod:33
msgid "BN_is_bit_set() tests if bit B<n> in B<a> is set."
msgstr ""

#. type: textblock
#: C/crypto/BN_set_bit.pod:35
msgid ""
"BN_mask_bits() truncates B<a> to an B<n> bit number "
"(C<a&=~((~0)E<gt>E<gt>n)>).  An error occurs if B<a> already is shorter than "
"B<n> bits."
msgstr ""

#. type: textblock
#: C/crypto/BN_set_bit.pod:39
msgid ""
"BN_lshift() shifts B<a> left by B<n> bits and places the result in B<r> "
"(C<r=a*2^n>). Note that B<n> must be non-negative. BN_lshift1() shifts B<a> "
"left by one and places the result in B<r> (C<r=2*a>)."
msgstr ""

#. type: textblock
#: C/crypto/BN_set_bit.pod:43
msgid ""
"BN_rshift() shifts B<a> right by B<n> bits and places the result in B<r> "
"(C<r=a/2^n>). Note that B<n> must be non-negative. BN_rshift1() shifts B<a> "
"right by one and places the result in B<r> (C<r=a/2>)."
msgstr ""

#. type: textblock
#: C/crypto/BN_set_bit.pod:47
msgid "For the shift functions, B<r> and B<a> may be the same variable."
msgstr ""

#. type: textblock
#: C/crypto/BN_set_bit.pod:51
msgid "BN_is_bit_set() returns 1 if the bit is set, 0 otherwise."
msgstr ""

#. type: textblock
#: C/crypto/BN_set_bit.pod:53
msgid ""
"All other functions return 1 for success, 0 on error. The error codes can be "
"obtained by L<ERR_get_error(3)|ERR_get_error(3)>."
msgstr ""

#. type: textblock
#: C/crypto/BN_set_bit.pod:58
msgid ""
"L<bn(3)|bn(3)>, L<BN_num_bytes(3)|BN_num_bytes(3)>, L<BN_add(3)|BN_add(3)>"
msgstr ""
"L<bn(3)|bn(3)>, L<BN_num_bytes(3)|BN_num_bytes(3)>, L<BN_add(3)|BN_add(3)>"

#. type: textblock
#: C/crypto/BN_set_bit.pod:62
msgid ""
"BN_set_bit(), BN_clear_bit(), BN_is_bit_set(), BN_mask_bits(), BN_lshift(), "
"BN_lshift1(), BN_rshift(), and BN_rshift1() are available in all versions of "
"SSLeay and OpenSSL."
msgstr ""
"BN_set_bit(), BN_clear_bit(), BN_is_bit_set(), BN_mask_bits(), BN_lshift(), "
"BN_lshift1(), BN_rshift() et BN_rshift1() sont disponibles dans toutes les "
"versions de SSLeay et d'OpenSSL."

#. type: textblock
#: C/crypto/BN_swap.pod:5
msgid "BN_swap - exchange BIGNUMs"
msgstr "BN_swap - Ã?change de BIGNUM"

#. type: verbatim
#: C/crypto/BN_swap.pod:11
#, no-wrap
msgid ""
" void BN_swap(BIGNUM *a, BIGNUM *b);\n"
"\n"
msgstr ""
" void BN_swap(BIGNUM *a, BIGNUM *b);\n"
"\n"

#. type: textblock
#: C/crypto/BN_swap.pod:15
msgid "BN_swap() exchanges the values of I<a> and I<b>."
msgstr "BN_swap() échange les valeurs de I<a> et I<b>."

#. type: textblock
#: C/crypto/BN_swap.pod:21
msgid "BN_swap was added in OpenSSL 0.9.7."
msgstr "BN_swap a été ajoutée dans la version 0.9.7 d'OpenSSL."

#. type: textblock
#: C/crypto/BN_zero.pod:5
msgid ""
"BN_zero, BN_one, BN_value_one, BN_set_word, BN_get_word - BIGNUM assignment "
"operations"
msgstr ""
"BN_zero, BN_one, BN_value_one, BN_set_word, BN_get_word - Opérations "
"d'assignation de BIGNUM"

#. type: verbatim
#: C/crypto/BN_zero.pod:12
#, no-wrap
msgid ""
" int BN_zero(BIGNUM *a);\n"
" int BN_one(BIGNUM *a);\n"
"\n"
msgstr ""
" int BN_zero(BIGNUM *a);\n"
" int BN_one(BIGNUM *a);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_zero.pod:15
#, no-wrap
msgid ""
" const BIGNUM *BN_value_one(void);\n"
"\n"
msgstr ""
" const BIGNUM *BN_value_one(void);\n"
"\n"

#. type: verbatim
#: C/crypto/BN_zero.pod:17
#, no-wrap
msgid ""
" int BN_set_word(BIGNUM *a, unsigned long w);\n"
" unsigned long BN_get_word(BIGNUM *a);\n"
"\n"
msgstr ""
" int BN_set_word(BIGNUM *a, unsigned long w);\n"
" unsigned long BN_get_word(BIGNUM *a);\n"
"\n"

#. type: textblock
#: C/crypto/BN_zero.pod:22
msgid ""
"BN_zero(), BN_one() and BN_set_word() set B<a> to the values 0, 1 and B<w> "
"respectively.  BN_zero() and BN_one() are macros."
msgstr ""
"B<BN_zero>(), B<BN_one>() et B<BN_set_word>() définissent respectivement "
"I<a> aux valeurs 0, 1 et I<w>. B<BN_zero>() et B<BN_one>() sont des macros."

#. type: textblock
#: C/crypto/BN_zero.pod:25
msgid ""
"BN_value_one() returns a B<BIGNUM> constant of value 1. This constant is "
"useful for use in comparisons and assignment."
msgstr ""
"B<BN_value_one>() renvoie un B<BIGNUM> constant de valeur 1. Cette constante "
"est utile pour les comparaisons et assignations."

#. type: textblock
#: C/crypto/BN_zero.pod:28
msgid ""
"BN_get_word() returns B<a>, if it can be represented as an unsigned long."
msgstr ""
"B<BN_get_word>() renvoie I<a> si cela peut être représenté comme un entier "
"long non signé."

#. type: textblock
#: C/crypto/BN_zero.pod:33
msgid ""
"BN_get_word() returns the value B<a>, and 0xffffffffL if B<a> cannot be "
"represented as an unsigned long."
msgstr ""
"B<BN_get_word>() renvoie la valeur I<a> ou 0xffffffffL si I<a> ne peut pas "
"être représenté comme un entier long non signé."

#. type: textblock
#: C/crypto/BN_zero.pod:36
msgid ""
"BN_zero(), BN_one() and BN_set_word() return 1 on success, 0 otherwise.  "
"BN_value_one() returns the constant."
msgstr ""
"B<BN_zero>(), B<BN_one>() et B<BN_set_word>() renvoient 1 si elles "
"réussissent, 0 sinon. B<BN_value_one>() renvoie la constante."

#. type: =head1
#: C/crypto/BN_zero.pod:39
msgid "BUGS"
msgstr "BOGUES"

#. type: textblock
#: C/crypto/BN_zero.pod:41
msgid "Someone might change the constant."
msgstr "Quelqu'un pourrait modifier la constante."

#. type: textblock
#: C/crypto/BN_zero.pod:43
msgid ""
"If a B<BIGNUM> is equal to 0xffffffffL it can be represented as an unsigned "
"long but this value is also returned on error."
msgstr ""
"Si un B<BIGNUM> est égal à 0xffffffffL, il peut être représenté comme un "
"entier long non signé mais cette valeur est aussi renvoyée en cas d'erreur."

#. type: textblock
#: C/crypto/BN_zero.pod:48
msgid "L<bn(3)|bn(3)>, L<BN_bn2bin(3)|BN_bn2bin(3)>"
msgstr "L<bn(3)|bn(3)>, L<BN_bn2bin(3)|BN_bn2bin(3)>"

#. type: textblock
#: C/crypto/BN_zero.pod:52
msgid ""
"BN_zero(), BN_one() and BN_set_word() are available in all versions of "
"SSLeay and OpenSSL. BN_value_one() and BN_get_word() were added in SSLeay "
"0.8."
msgstr ""
"B<BN_zero>(), B<BN_one>() et B<BN_set_word>() sont disponibles dans toutes "
"les versions de SSLeay et OpenSSL. B<BN_value_one>() et B<BN_get_word>() ont "
"été ajoutées dans SSLeay 0.8."

#. type: textblock
#: C/crypto/BN_zero.pod:56
msgid ""
"BN_value_one() was changed to return a true const BIGNUM * in OpenSSL 0.9.7."
msgstr ""
"B<BN_value_one>() a été modifiée pour renvoyer une vraie const BIGNUM * dans "
"OpenSSL 0.9.7."

#. type: textblock
#: C/crypto/bn.pod:5
msgid "bn - multiprecision integer arithmetics"
msgstr "bn - Arithmétique sur des entiers en précision multiple"

#. type: verbatim
#: C/crypto/bn.pod:11
#, no-wrap
msgid ""
" BIGNUM *BN_new(void);\n"
" void BN_free(BIGNUM *a);\n"
" void BN_init(BIGNUM *);\n"
" void BN_clear(BIGNUM *a);\n"
" void BN_clear_free(BIGNUM *a);\n"
"\n"
msgstr ""
" BIGNUM *BN_new(void);\n"
" void BN_free(BIGNUM *a);\n"
" void BN_init(BIGNUM *);\n"
" void BN_clear(BIGNUM *a);\n"
" void BN_clear_free(BIGNUM *a);\n"
"\n"

#. type: verbatim
#: C/crypto/bn.pod:17
#, no-wrap
msgid ""
" BN_CTX *BN_CTX_new(void);\n"
" void BN_CTX_init(BN_CTX *c);\n"
" void BN_CTX_free(BN_CTX *c);\n"
"\n"
msgstr ""
" BN_CTX *BN_CTX_new(void);\n"
" void BN_CTX_init(BN_CTX *c);\n"
" void BN_CTX_free(BN_CTX *c);\n"
"\n"

#. type: verbatim
#: C/crypto/bn.pod:21
#, no-wrap
msgid ""
" BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b);\n"
" BIGNUM *BN_dup(const BIGNUM *a);\n"
"\n"
msgstr ""
" BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b);\n"
" BIGNUM *BN_dup(const BIGNUM *a);\n"
"\n"

#. type: verbatim
#: C/crypto/bn.pod:24
#, no-wrap
msgid ""
" BIGNUM *BN_swap(BIGNUM *a, BIGNUM *b);\n"
"\n"
msgstr ""
" BIGNUM *BN_swap(BIGNUM *a, BIGNUM *b);\n"
"\n"

#. type: verbatim
#: C/crypto/bn.pod:26
#, no-wrap
msgid ""
" int BN_num_bytes(const BIGNUM *a);\n"
" int BN_num_bits(const BIGNUM *a);\n"
" int BN_num_bits_word(BN_ULONG w);\n"
"\n"
msgstr ""
" int BN_num_bytes(const BIGNUM *a);\n"
" int BN_num_bits(const BIGNUM *a);\n"
" int BN_num_bits_word(BN_ULONG w);\n"
"\n"

#. type: verbatim
#: C/crypto/bn.pod:30
#, no-wrap
msgid ""
" void BN_set_negative(BIGNUM *a, int n);\n"
" int  BN_is_negative(const BIGNUM *a);\n"
"\n"
msgstr ""
" void BN_set_negative(BIGNUM *a, int n);\n"
" int  BN_is_negative(const BIGNUM *a);\n"
"\n"

#. type: verbatim
#: C/crypto/bn.pod:33
#, no-wrap
msgid ""
" int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);\n"
" int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);\n"
" int BN_mul(BIGNUM *r, BIGNUM *a, BIGNUM *b, BN_CTX *ctx);\n"
" int BN_sqr(BIGNUM *r, BIGNUM *a, BN_CTX *ctx);\n"
" int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *a, const BIGNUM *d,\n"
"         BN_CTX *ctx);\n"
" int BN_mod(BIGNUM *rem, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);\n"
" int BN_nnmod(BIGNUM *rem, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);\n"
" int BN_mod_add(BIGNUM *ret, BIGNUM *a, BIGNUM *b, const BIGNUM *m,\n"
"         BN_CTX *ctx);\n"
" int BN_mod_sub(BIGNUM *ret, BIGNUM *a, BIGNUM *b, const BIGNUM *m,\n"
"         BN_CTX *ctx);\n"
" int BN_mod_mul(BIGNUM *ret, BIGNUM *a, BIGNUM *b, const BIGNUM *m,\n"
"         BN_CTX *ctx);\n"
" int BN_mod_sqr(BIGNUM *ret, BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);\n"
" int BN_exp(BIGNUM *r, BIGNUM *a, BIGNUM *p, BN_CTX *ctx);\n"
" int BN_mod_exp(BIGNUM *r, BIGNUM *a, const BIGNUM *p,\n"
"         const BIGNUM *m, BN_CTX *ctx);\n"
" int BN_gcd(BIGNUM *r, BIGNUM *a, BIGNUM *b, BN_CTX *ctx);\n"
"\n"
msgstr ""
" int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);\n"
" int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);\n"
" int BN_mul(BIGNUM *r, BIGNUM *a, BIGNUM *b, BN_CTX *ctx);\n"
" int BN_sqr(BIGNUM *r, BIGNUM *a, BN_CTX *ctx);\n"
" int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *a, const BIGNUM *d,\n"
"         BN_CTX *ctx);\n"
" int BN_mod(BIGNUM *rem, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);\n"
" int BN_nnmod(BIGNUM *rem, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);\n"
" int BN_mod_add(BIGNUM *ret, BIGNUM *a, BIGNUM *b, const BIGNUM *m,\n"
"         BN_CTX *ctx);\n"
" int BN_mod_sub(BIGNUM *ret, BIGNUM *a, BIGNUM *b, const BIGNUM *m,\n"
"         BN_CTX *ctx);\n"
" int BN_mod_mul(BIGNUM *ret, BIGNUM *a, BIGNUM *b, const BIGNUM *m,\n"
"         BN_CTX *ctx);\n"
" int BN_mod_sqr(BIGNUM *ret, BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);\n"
" int BN_exp(BIGNUM *r, BIGNUM *a, BIGNUM *p, BN_CTX *ctx);\n"
" int BN_mod_exp(BIGNUM *r, BIGNUM *a, const BIGNUM *p,\n"
"         const BIGNUM *m, BN_CTX *ctx);\n"
" int BN_gcd(BIGNUM *r, BIGNUM *a, BIGNUM *b, BN_CTX *ctx);\n"
"\n"

#. type: verbatim
#: C/crypto/bn.pod:53
#, no-wrap
msgid ""
" int BN_add_word(BIGNUM *a, BN_ULONG w);\n"
" int BN_sub_word(BIGNUM *a, BN_ULONG w);\n"
" int BN_mul_word(BIGNUM *a, BN_ULONG w);\n"
" BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w);\n"
" BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w);\n"
"\n"
msgstr ""
" int BN_add_word(BIGNUM *a, BN_ULONG w);\n"
" int BN_sub_word(BIGNUM *a, BN_ULONG w);\n"
" int BN_mul_word(BIGNUM *a, BN_ULONG w);\n"
" BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w);\n"
" BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w);\n"
"\n"

#. type: verbatim
#: C/crypto/bn.pod:59
#, no-wrap
msgid ""
" int BN_cmp(BIGNUM *a, BIGNUM *b);\n"
" int BN_ucmp(BIGNUM *a, BIGNUM *b);\n"
" int BN_is_zero(BIGNUM *a);\n"
" int BN_is_one(BIGNUM *a);\n"
" int BN_is_word(BIGNUM *a, BN_ULONG w);\n"
" int BN_is_odd(BIGNUM *a);\n"
"\n"
msgstr ""
" int BN_cmp(BIGNUM *a, BIGNUM *b);\n"
" int BN_ucmp(BIGNUM *a, BIGNUM *b);\n"
" int BN_is_zero(BIGNUM *a);\n"
" int BN_is_one(BIGNUM *a);\n"
" int BN_is_word(BIGNUM *a, BN_ULONG w);\n"
" int BN_is_odd(BIGNUM *a);\n"
"\n"

#. type: verbatim
#: C/crypto/bn.pod:66
#, no-wrap
msgid ""
" int BN_zero(BIGNUM *a);\n"
" int BN_one(BIGNUM *a);\n"
" const BIGNUM *BN_value_one(void);\n"
" int BN_set_word(BIGNUM *a, unsigned long w);\n"
" unsigned long BN_get_word(BIGNUM *a);\n"
"\n"
msgstr ""
" int BN_zero(BIGNUM *a);\n"
" int BN_one(BIGNUM *a);\n"
" const BIGNUM *BN_value_one(void);\n"
" int BN_set_word(BIGNUM *a, unsigned long w);\n"
" unsigned long BN_get_word(BIGNUM *a);\n"
"\n"

#. type: verbatim
#: C/crypto/bn.pod:72
#, no-wrap
msgid ""
" int BN_rand(BIGNUM *rnd, int bits, int top, int bottom);\n"
" int BN_pseudo_rand(BIGNUM *rnd, int bits, int top, int bottom);\n"
" int BN_rand_range(BIGNUM *rnd, BIGNUM *range);\n"
" int BN_pseudo_rand_range(BIGNUM *rnd, BIGNUM *range);\n"
"\n"
msgstr ""
" int BN_rand(BIGNUM *rnd, int bits, int top, int bottom);\n"
" int BN_pseudo_rand(BIGNUM *rnd, int bits, int top, int bottom);\n"
" int BN_rand_range(BIGNUM *rnd, BIGNUM *range);\n"
" int BN_pseudo_rand_range(BIGNUM *rnd, BIGNUM *range);\n"
"\n"

#. type: verbatim
#: C/crypto/bn.pod:77
#, no-wrap
msgid ""
" BIGNUM *BN_generate_prime(BIGNUM *ret, int bits,int safe, BIGNUM *add,\n"
"         BIGNUM *rem, void (*callback)(int, int, void *), void *cb_arg);\n"
" int BN_is_prime(const BIGNUM *p, int nchecks,\n"
"         void (*callback)(int, int, void *), BN_CTX *ctx, void *cb_arg);\n"
"\n"
msgstr ""
" BIGNUM *BN_generate_prime(BIGNUM *ret, int bits,int safe, BIGNUM *add,\n"
"         BIGNUM *rem, void (*callback)(int, int, void *), void *cb_arg);\n"
" int BN_is_prime(const BIGNUM *p, int nchecks,\n"
"         void (*callback)(int, int, void *), BN_CTX *ctx, void *cb_arg);\n"
"\n"

#. type: verbatim
#: C/crypto/bn.pod:82
#, no-wrap
msgid ""
" int BN_set_bit(BIGNUM *a, int n);\n"
" int BN_clear_bit(BIGNUM *a, int n);\n"
" int BN_is_bit_set(const BIGNUM *a, int n);\n"
" int BN_mask_bits(BIGNUM *a, int n);\n"
" int BN_lshift(BIGNUM *r, const BIGNUM *a, int n);\n"
" int BN_lshift1(BIGNUM *r, BIGNUM *a);\n"
" int BN_rshift(BIGNUM *r, BIGNUM *a, int n);\n"
" int BN_rshift1(BIGNUM *r, BIGNUM *a);\n"
"\n"
msgstr ""
" int BN_set_bit(BIGNUM *a, int n);\n"
" int BN_clear_bit(BIGNUM *a, int n);\n"
" int BN_is_bit_set(const BIGNUM *a, int n);\n"
" int BN_mask_bits(BIGNUM *a, int n);\n"
" int BN_lshift(BIGNUM *r, const BIGNUM *a, int n);\n"
" int BN_lshift1(BIGNUM *r, BIGNUM *a);\n"
" int BN_rshift(BIGNUM *r, BIGNUM *a, int n);\n"
" int BN_rshift1(BIGNUM *r, BIGNUM *a);\n"
"\n"

#. type: verbatim
#: C/crypto/bn.pod:91
#, no-wrap
msgid ""
" int BN_bn2bin(const BIGNUM *a, unsigned char *to);\n"
" BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret);\n"
" char *BN_bn2hex(const BIGNUM *a);\n"
" char *BN_bn2dec(const BIGNUM *a);\n"
" int BN_hex2bn(BIGNUM **a, const char *str);\n"
" int BN_dec2bn(BIGNUM **a, const char *str);\n"
" int BN_print(BIO *fp, const BIGNUM *a);\n"
" int BN_print_fp(FILE *fp, const BIGNUM *a);\n"
" int BN_bn2mpi(const BIGNUM *a, unsigned char *to);\n"
" BIGNUM *BN_mpi2bn(unsigned char *s, int len, BIGNUM *ret);\n"
"\n"
msgstr ""
" int BN_bn2bin(const BIGNUM *a, unsigned char *to);\n"
" BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret);\n"
" char *BN_bn2hex(const BIGNUM *a);\n"
" char *BN_bn2dec(const BIGNUM *a);\n"
" int BN_hex2bn(BIGNUM **a, const char *str);\n"
" int BN_dec2bn(BIGNUM **a, const char *str);\n"
" int BN_print(BIO *fp, const BIGNUM *a);\n"
" int BN_print_fp(FILE *fp, const BIGNUM *a);\n"
" int BN_bn2mpi(const BIGNUM *a, unsigned char *to);\n"
" BIGNUM *BN_mpi2bn(unsigned char *s, int len, BIGNUM *ret);\n"
"\n"

#. type: verbatim
#: C/crypto/bn.pod:102
#, no-wrap
msgid ""
" BIGNUM *BN_mod_inverse(BIGNUM *r, BIGNUM *a, const BIGNUM *n,\n"
"     BN_CTX *ctx);\n"
"\n"
msgstr ""
" BIGNUM *BN_mod_inverse(BIGNUM *r, BIGNUM *a, const BIGNUM *n,\n"
"     BN_CTX *ctx);\n"
"\n"

#. type: verbatim
#: C/crypto/bn.pod:105
#, no-wrap
msgid ""
" BN_RECP_CTX *BN_RECP_CTX_new(void);\n"
" void BN_RECP_CTX_init(BN_RECP_CTX *recp);\n"
" void BN_RECP_CTX_free(BN_RECP_CTX *recp);\n"
" int BN_RECP_CTX_set(BN_RECP_CTX *recp, const BIGNUM *m, BN_CTX *ctx);\n"
" int BN_mod_mul_reciprocal(BIGNUM *r, BIGNUM *a, BIGNUM *b,\n"
"        BN_RECP_CTX *recp, BN_CTX *ctx);\n"
"\n"
msgstr ""
" BN_RECP_CTX *BN_RECP_CTX_new(void);\n"
" void BN_RECP_CTX_init(BN_RECP_CTX *recp);\n"
" void BN_RECP_CTX_free(BN_RECP_CTX *recp);\n"
" int BN_RECP_CTX_set(BN_RECP_CTX *recp, const BIGNUM *m, BN_CTX *ctx);\n"
" int BN_mod_mul_reciprocal(BIGNUM *r, BIGNUM *a, BIGNUM *b,\n"
"        BN_RECP_CTX *recp, BN_CTX *ctx);\n"
"\n"

#. type: verbatim
#: C/crypto/bn.pod:112
#, no-wrap
msgid ""
" BN_MONT_CTX *BN_MONT_CTX_new(void);\n"
" void BN_MONT_CTX_init(BN_MONT_CTX *ctx);\n"
" void BN_MONT_CTX_free(BN_MONT_CTX *mont);\n"
" int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *m, BN_CTX *ctx);\n"
" BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to, BN_MONT_CTX *from);\n"
" int BN_mod_mul_montgomery(BIGNUM *r, BIGNUM *a, BIGNUM *b,\n"
"         BN_MONT_CTX *mont, BN_CTX *ctx);\n"
" int BN_from_montgomery(BIGNUM *r, BIGNUM *a, BN_MONT_CTX *mont,\n"
"         BN_CTX *ctx);\n"
" int BN_to_montgomery(BIGNUM *r, BIGNUM *a, BN_MONT_CTX *mont,\n"
"         BN_CTX *ctx);\n"
"\n"
msgstr ""
" BN_MONT_CTX *BN_MONT_CTX_new(void);\n"
" void BN_MONT_CTX_init(BN_MONT_CTX *ctx);\n"
" void BN_MONT_CTX_free(BN_MONT_CTX *mont);\n"
" int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *m, BN_CTX *ctx);\n"
" BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to, BN_MONT_CTX *from);\n"
" int BN_mod_mul_montgomery(BIGNUM *r, BIGNUM *a, BIGNUM *b,\n"
"         BN_MONT_CTX *mont, BN_CTX *ctx);\n"
" int BN_from_montgomery(BIGNUM *r, BIGNUM *a, BN_MONT_CTX *mont,\n"
"         BN_CTX *ctx);\n"
" int BN_to_montgomery(BIGNUM *r, BIGNUM *a, BN_MONT_CTX *mont,\n"
"         BN_CTX *ctx);\n"
"\n"

#. type: verbatim
#: C/crypto/bn.pod:124
#, no-wrap
msgid ""
" BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai,\n"
"\tBIGNUM *mod);\n"
" void BN_BLINDING_free(BN_BLINDING *b);\n"
" int BN_BLINDING_update(BN_BLINDING *b,BN_CTX *ctx);\n"
" int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);\n"
" int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);\n"
" int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b,\n"
"\tBN_CTX *ctx);\n"
" int BN_BLINDING_invert_ex(BIGNUM *n,const BIGNUM *r,BN_BLINDING *b,\n"
"\tBN_CTX *ctx);\n"
" unsigned long BN_BLINDING_get_thread_id(const BN_BLINDING *);\n"
" void BN_BLINDING_set_thread_id(BN_BLINDING *, unsigned long);\n"
" unsigned long BN_BLINDING_get_flags(const BN_BLINDING *);\n"
" void BN_BLINDING_set_flags(BN_BLINDING *, unsigned long);\n"
" BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b,\n"
"\tconst BIGNUM *e, BIGNUM *m, BN_CTX *ctx,\n"
"\tint (*bn_mod_exp)(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,\n"
"\t\t\t  const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx),\n"
"\tBN_MONT_CTX *m_ctx);\n"
"\n"
msgstr ""
" BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai,\n"
"\tBIGNUM *mod);\n"
" void BN_BLINDING_free(BN_BLINDING *b);\n"
" int BN_BLINDING_update(BN_BLINDING *b,BN_CTX *ctx);\n"
" int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);\n"
" int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);\n"
" int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b,\n"
"\tBN_CTX *ctx);\n"
" int BN_BLINDING_invert_ex(BIGNUM *n,const BIGNUM *r,BN_BLINDING *b,\n"
"\tBN_CTX *ctx);\n"
" unsigned long BN_BLINDING_get_thread_id(const BN_BLINDING *);\n"
" void BN_BLINDING_set_thread_id(BN_BLINDING *, unsigned long);\n"
" unsigned long BN_BLINDING_get_flags(const BN_BLINDING *);\n"
" void BN_BLINDING_set_flags(BN_BLINDING *, unsigned long);\n"
" BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b,\n"
"\tconst BIGNUM *e, BIGNUM *m, BN_CTX *ctx,\n"
"\tint (*bn_mod_exp)(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,\n"
"\t\t\t  const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx),\n"
"\tBN_MONT_CTX *m_ctx);\n"
"\n"

#. type: textblock
#: C/crypto/bn.pod:146
msgid ""
"This library performs arithmetic operations on integers of arbitrary size. "
"It was written for use in public key cryptography, such as RSA and Diffie-"
"Hellman."
msgstr ""
"Cette bibliothèque effectue des opérations arithmétiques sur des entiers de "
"taille arbitraire. Elle a été écrite pour une utilisation dans des "
"algorithmes de cryptographie à clés publiques, comme RSA et Diffie-Hellman."

#. type: textblock
#: C/crypto/bn.pod:150
msgid ""
"It uses dynamic memory allocation for storing its data structures.  That "
"means that there is no limit on the size of the numbers manipulated by these "
"functions, but return values must always be checked in case a memory "
"allocation error has occurred."
msgstr ""
"Elle alloue dynamiquement de la mémoire pour stocker ses structures de "
"données. Ceci signifie qu'il n'y a pas de limite de taille pour les entiers "
"manipulés par ces fonctions, mais les valeurs de retour doivent toujours "
"être vérifiées au cas où une erreur d'allocation de mémoire est survenue."

#. type: textblock
#: C/crypto/bn.pod:155
msgid ""
"The basic object in this library is a B<BIGNUM>. It is used to hold a single "
"large integer. This type should be considered opaque and fields should not "
"be modified or accessed directly."
msgstr ""
"L'objet de base de cette bibliothèque est un B<BIGNUM>. Il est utilisé pour "
"conserver la valeur d'un entier. Ce type doit être considéré comme opaque et "
"ses champs ne devraient pas être modifiés ou accédés directement."

#. type: textblock
#: C/crypto/bn.pod:159
msgid ""
"The creation of B<BIGNUM> objects is described in L<BN_new(3)|BN_new(3)>; "
"L<BN_add(3)|BN_add(3)> describes most of the arithmetic operations.  "
"Comparison is described in L<BN_cmp(3)|BN_cmp(3)>; L<BN_zero(3)|BN_zero(3)> "
"describes certain assignments, L<BN_rand(3)|BN_rand(3)> the generation of "
"random numbers, L<BN_generate_prime(3)|BN_generate_prime(3)> deals with "
"prime numbers and L<BN_set_bit(3)|BN_set_bit(3)> with bit operations. The "
"conversion of B<BIGNUM>s to external formats is described in L<BN_bn2bin(3)|"
"BN_bn2bin(3)>."
msgstr ""
"La création des objets B<BIGNUM> est décrite dans L<BN_new(3)|BN_new(3)> ; "
"L<BN_add(3)|BN_add(3)> décrit la plupart des opérations arithmétiques. La "
"comparaison est décrite dans L<BN_cmp(3)|BN_cmp(3)> ; L<BN_zero(3)|"
"BN_zero(3)> décrit certaines formes d'assignations, L<BN_rand(3)|BN_rand(3)> "
"décrit la génération de nombres aléatoires, L<BN_generate_prime(3)|"
"BN_generate_prime(3)> concerne les nombres premiers et L<BN_set_bit(3)|"
"BN_set_bit(3)> les opérations sur les bits. La conversion d'un B<BIGNUM> "
"dans un autre format est décrite dans L<BN_bn2bin(3)|BN_bn2bin(3)>."

#. type: textblock
#: C/crypto/bn.pod:169
msgid ""
"L<bn_internal(3)|bn_internal(3)>, L<dh(3)|dh(3)>, L<err(3)|err(3)>, "
"L<rand(3)|rand(3)>, L<rsa(3)|rsa(3)>, L<BN_new(3)|BN_new(3)>, "
"L<BN_CTX_new(3)|BN_CTX_new(3)>, L<BN_copy(3)|BN_copy(3)>, L<BN_swap(3)|"
"BN_swap(3)>, L<BN_num_bytes(3)|BN_num_bytes(3)>, L<BN_add(3)|BN_add(3)>, "
"L<BN_add_word(3)|BN_add_word(3)>, L<BN_cmp(3)|BN_cmp(3)>, L<BN_zero(3)|"
"BN_zero(3)>, L<BN_rand(3)|BN_rand(3)>, L<BN_generate_prime(3)|"
"BN_generate_prime(3)>, L<BN_set_bit(3)|BN_set_bit(3)>, L<BN_bn2bin(3)|"
"BN_bn2bin(3)>, L<BN_mod_inverse(3)|BN_mod_inverse(3)>, "
"L<BN_mod_mul_reciprocal(3)|BN_mod_mul_reciprocal(3)>, "
"L<BN_mod_mul_montgomery(3)|BN_mod_mul_montgomery(3)>, L<BN_BLINDING_new(3)|"
"BN_BLINDING_new(3)>"
msgstr ""
"L<bn_internal(3)|bn_internal(3)>, L<dh(3)|dh(3)>, L<err(3)|err(3)>, "
"L<rand(3)|rand(3)>, L<rsa(3)|rsa(3)>, L<BN_new(3)|BN_new(3)>, "
"L<BN_CTX_new(3)|BN_CTX_new(3)>, L<BN_copy(3)|BN_copy(3)>, L<BN_swap(3)|"
"BN_swap(3)>, L<BN_num_bytes(3)|BN_num_bytes(3)>, L<BN_add(3)|BN_add(3)>, "
"L<BN_add_word(3)|BN_add_word(3)>, L<BN_cmp(3)|BN_cmp(3)>, L<BN_zero(3)|"
"BN_zero(3)>, L<BN_rand(3)|BN_rand(3)>, L<BN_generate_prime(3)|"
"BN_generate_prime(3)>, L<BN_set_bit(3)|BN_set_bit(3)>, L<BN_bn2bin(3)|"
"BN_bn2bin(3)>, L<BN_mod_inverse(3)|BN_mod_inverse(3)>, "
"L<BN_mod_mul_reciprocal(3)|BN_mod_mul_reciprocal(3)>, "
"L<BN_mod_mul_montgomery(3)|BN_mod_mul_montgomery(3)>, L<BN_BLINDING_new(3)|"
"BN_BLINDING_new(3)>"

#. type: textblock
#: C/crypto/bn_internal.pod:5
msgid ""
"bn_mul_words, bn_mul_add_words, bn_sqr_words, bn_div_words, bn_add_words, "
"bn_sub_words, bn_mul_comba4, bn_mul_comba8, bn_sqr_comba4, bn_sqr_comba8, "
"bn_cmp_words, bn_mul_normal, bn_mul_low_normal, bn_mul_recursive, "
"bn_mul_part_recursive, bn_mul_low_recursive, bn_mul_high, bn_sqr_normal, "
"bn_sqr_recursive, bn_expand, bn_wexpand, bn_expand2, bn_fix_top, "
"bn_check_top, bn_print, bn_dump, bn_set_max, bn_set_high, bn_set_low - "
"BIGNUM library internal functions"
msgstr ""

#. type: verbatim
#: C/crypto/bn_internal.pod:18
#, no-wrap
msgid ""
" BN_ULONG bn_mul_words(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w);\n"
" BN_ULONG bn_mul_add_words(BN_ULONG *rp, BN_ULONG *ap, int num,\n"
"   BN_ULONG w);\n"
" void     bn_sqr_words(BN_ULONG *rp, BN_ULONG *ap, int num);\n"
" BN_ULONG bn_div_words(BN_ULONG h, BN_ULONG l, BN_ULONG d);\n"
" BN_ULONG bn_add_words(BN_ULONG *rp, BN_ULONG *ap, BN_ULONG *bp,\n"
"   int num);\n"
" BN_ULONG bn_sub_words(BN_ULONG *rp, BN_ULONG *ap, BN_ULONG *bp,\n"
"   int num);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/bn_internal.pod:28
#, no-wrap
msgid ""
" void bn_mul_comba4(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b);\n"
" void bn_mul_comba8(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b);\n"
" void bn_sqr_comba4(BN_ULONG *r, BN_ULONG *a);\n"
" void bn_sqr_comba8(BN_ULONG *r, BN_ULONG *a);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/bn_internal.pod:33
#, no-wrap
msgid ""
" int bn_cmp_words(BN_ULONG *a, BN_ULONG *b, int n);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/bn_internal.pod:35
#, no-wrap
msgid ""
" void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b,\n"
"   int nb);\n"
" void bn_mul_low_normal(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n);\n"
" void bn_mul_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n2,\n"
"   int dna,int dnb,BN_ULONG *tmp);\n"
" void bn_mul_part_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b,\n"
"   int n, int tna,int tnb, BN_ULONG *tmp);\n"
" void bn_mul_low_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b,\n"
"   int n2, BN_ULONG *tmp);\n"
" void bn_mul_high(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, BN_ULONG *l,\n"
"   int n2, BN_ULONG *tmp);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/bn_internal.pod:47
#, no-wrap
msgid ""
" void bn_sqr_normal(BN_ULONG *r, BN_ULONG *a, int n, BN_ULONG *tmp);\n"
" void bn_sqr_recursive(BN_ULONG *r, BN_ULONG *a, int n2, BN_ULONG *tmp);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/bn_internal.pod:50
#, no-wrap
msgid ""
" void mul(BN_ULONG r, BN_ULONG a, BN_ULONG w, BN_ULONG c);\n"
" void mul_add(BN_ULONG r, BN_ULONG a, BN_ULONG w, BN_ULONG c);\n"
" void sqr(BN_ULONG r0, BN_ULONG r1, BN_ULONG a);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/bn_internal.pod:54
#, no-wrap
msgid ""
" BIGNUM *bn_expand(BIGNUM *a, int bits);\n"
" BIGNUM *bn_wexpand(BIGNUM *a, int n);\n"
" BIGNUM *bn_expand2(BIGNUM *a, int n);\n"
" void bn_fix_top(BIGNUM *a);\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/bn_internal.pod:59
#, no-wrap
msgid ""
" void bn_check_top(BIGNUM *a);\n"
" void bn_print(BIGNUM *a);\n"
" void bn_dump(BN_ULONG *d, int n);\n"
" void bn_set_max(BIGNUM *a);\n"
" void bn_set_high(BIGNUM *r, BIGNUM *a, int n);\n"
" void bn_set_low(BIGNUM *r, BIGNUM *a, int n);\n"
"\n"
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:68
msgid ""
"This page documents the internal functions used by the OpenSSL B<BIGNUM> "
"implementation. They are described here to facilitate debugging and "
"extending the library. They are I<not> to be used by applications."
msgstr ""

#. type: =head2
#: C/crypto/bn_internal.pod:73
msgid "The BIGNUM structure"
msgstr ""

#. type: verbatim
#: C/crypto/bn_internal.pod:75
#, no-wrap
msgid ""
" typedef struct bignum_st BIGNUM;\n"
"\n"
msgstr ""

#. type: verbatim
#: C/crypto/bn_internal.pod:77
#, no-wrap
msgid ""
" struct bignum_st\n"
"        {\n"
"        BN_ULONG *d;    /* Pointer to an array of 'BN_BITS2' bit chunks. */\n"
"        int top;        /* Index of last used d +1. */\n"
"        /* The next are internal book keeping for bn_expand. */\n"
"        int dmax;       /* Size of the d array. */\n"
"        int neg;        /* one if the number is negative */\n"
"        int flags;\n"
"        };\n"
"\n"
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:88
msgid ""
"The integer value is stored in B<d>, a malloc()ed array of words "
"(B<BN_ULONG>), least significant word first. A B<BN_ULONG> can be either 16, "
"32 or 64 bits in size, depending on the 'number of bits' (B<BITS2>) "
"specified in C<openssl/bn.h>."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:93
msgid ""
"B<dmax> is the size of the B<d> array that has been allocated.  B<top> is "
"the number of words being used, so for a value of 4, bn.d[0]=4 and bn."
"top=1.  B<neg> is 1 if the number is negative.  When a B<BIGNUM> is B<0>, "
"the B<d> field can be B<NULL> and B<top> == B<0>."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:98
msgid ""
"B<flags> is a bit field of flags which are defined in C<openssl/bn.h>. The "
"flags begin with B<BN_FLG_>. The macros BN_set_flags(b,n) and BN_get_flags(b,"
"n) exist to enable or fetch flag(s) B<n> from B<BIGNUM> structure B<b>."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:103
msgid ""
"Various routines in this library require the use of temporary B<BIGNUM> "
"variables during their execution.  Since dynamic memory allocation to create "
"B<BIGNUM>s is rather expensive when used in conjunction with repeated "
"subroutine calls, the B<BN_CTX> structure is used.  This structure contains "
"B<BN_CTX_NUM> B<BIGNUM>s, see L<BN_CTX_start(3)|BN_CTX_start(3)>."
msgstr ""

#. type: =head2
#: C/crypto/bn_internal.pod:110
msgid "Low-level arithmetic operations"
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:112
msgid ""
"These functions are implemented in C and for several platforms in assembly "
"language:"
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:115
msgid ""
"bn_mul_words(B<rp>, B<ap>, B<num>, B<w>) operates on the B<num> word arrays "
"B<rp> and B<ap>.  It computes B<ap> * B<w>, places the result in B<rp>, and "
"returns the high word (carry)."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:119
msgid ""
"bn_mul_add_words(B<rp>, B<ap>, B<num>, B<w>) operates on the B<num> word "
"arrays B<rp> and B<ap>.  It computes B<ap> * B<w> + B<rp>, places the result "
"in B<rp>, and returns the high word (carry)."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:123
msgid ""
"bn_sqr_words(B<rp>, B<ap>, B<n>) operates on the B<num> word array B<ap> and "
"the 2*B<num> word array B<ap>.  It computes B<ap> * B<ap> word-wise, and "
"places the low and high bytes of the result in B<rp>."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:127
msgid ""
"bn_div_words(B<h>, B<l>, B<d>) divides the two word number (B<h>,B<l>)  by "
"B<d> and returns the result."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:130
msgid ""
"bn_add_words(B<rp>, B<ap>, B<bp>, B<num>) operates on the B<num> word arrays "
"B<ap>, B<bp> and B<rp>.  It computes B<ap> + B<bp>, places the result in "
"B<rp>, and returns the high word (carry)."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:134
msgid ""
"bn_sub_words(B<rp>, B<ap>, B<bp>, B<num>) operates on the B<num> word arrays "
"B<ap>, B<bp> and B<rp>.  It computes B<ap> - B<bp>, places the result in "
"B<rp>, and returns the carry (1 if B<bp> E<gt> B<ap>, 0 otherwise)."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:139
msgid ""
"bn_mul_comba4(B<r>, B<a>, B<b>) operates on the 4 word arrays B<a> and B<b> "
"and the 8 word array B<r>.  It computes B<a>*B<b> and places the result in "
"B<r>."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:143
msgid ""
"bn_mul_comba8(B<r>, B<a>, B<b>) operates on the 8 word arrays B<a> and B<b> "
"and the 16 word array B<r>.  It computes B<a>*B<b> and places the result in "
"B<r>."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:147
msgid ""
"bn_sqr_comba4(B<r>, B<a>, B<b>) operates on the 4 word arrays B<a> and B<b> "
"and the 8 word array B<r>."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:150
msgid ""
"bn_sqr_comba8(B<r>, B<a>, B<b>) operates on the 8 word arrays B<a> and B<b> "
"and the 16 word array B<r>."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:153
msgid "The following functions are implemented in C:"
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:155
msgid ""
"bn_cmp_words(B<a>, B<b>, B<n>) operates on the B<n> word arrays B<a> and "
"B<b>.  It returns 1, 0 and -1 if B<a> is greater than, equal and less than "
"B<b>."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:159
msgid ""
"bn_mul_normal(B<r>, B<a>, B<na>, B<b>, B<nb>) operates on the B<na> word "
"array B<a>, the B<nb> word array B<b> and the B<na>+B<nb> word array B<r>.  "
"It computes B<a>*B<b> and places the result in B<r>."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:163
msgid ""
"bn_mul_low_normal(B<r>, B<a>, B<b>, B<n>) operates on the B<n> word arrays "
"B<r>, B<a> and B<b>.  It computes the B<n> low words of B<a>*B<b> and places "
"the result in B<r>."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:167
msgid ""
"bn_mul_recursive(B<r>, B<a>, B<b>, B<n2>, B<dna>, B<dnb>, B<t>) operates on "
"the word arrays B<a> and B<b> of length B<n2>+B<dna> and B<n2>+B<dnb> "
"(B<dna> and B<dnb> are currently allowed to be 0 or negative) and the "
"2*B<n2> word arrays B<r> and B<t>.  B<n2> must be a power of 2.  It computes "
"B<a>*B<b> and places the result in B<r>."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:173
msgid ""
"bn_mul_part_recursive(B<r>, B<a>, B<b>, B<n>, B<tna>, B<tnb>, B<tmp>)  "
"operates on the word arrays B<a> and B<b> of length B<n>+B<tna> and B<n>"
"+B<tnb> and the 4*B<n> word arrays B<r> and B<tmp>."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:177
msgid ""
"bn_mul_low_recursive(B<r>, B<a>, B<b>, B<n2>, B<tmp>) operates on the B<n2> "
"word arrays B<r> and B<tmp> and the B<n2>/2 word arrays B<a> and B<b>."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:181
msgid ""
"bn_mul_high(B<r>, B<a>, B<b>, B<l>, B<n2>, B<tmp>) operates on the B<n2> "
"word arrays B<r>, B<a>, B<b> and B<l> (?) and the 3*B<n2> word array B<tmp>."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:185
msgid ""
"BN_mul() calls bn_mul_normal(), or an optimized implementation if the "
"factors have the same size: bn_mul_comba8() is used if they are 8 words "
"long, bn_mul_recursive() if they are larger than B<BN_MULL_SIZE_NORMAL> and "
"the size is an exact multiple of the word size, and bn_mul_part_recursive() "
"for others that are larger than B<BN_MULL_SIZE_NORMAL>."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:192
msgid ""
"bn_sqr_normal(B<r>, B<a>, B<n>, B<tmp>) operates on the B<n> word array B<a> "
"and the 2*B<n> word arrays B<tmp> and B<r>."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:195
msgid ""
"The implementations use the following macros which, depending on the "
"architecture, may use \"long long\" C operations or inline assembler.  They "
"are defined in C<bn_lcl.h>."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:199
msgid ""
"mul(B<r>, B<a>, B<w>, B<c>) computes B<w>*B<a>+B<c> and places the low word "
"of the result in B<r> and the high word in B<c>."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:202
msgid ""
"mul_add(B<r>, B<a>, B<w>, B<c>) computes B<w>*B<a>+B<r>+B<c> and places the "
"low word of the result in B<r> and the high word in B<c>."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:205
msgid ""
"sqr(B<r0>, B<r1>, B<a>) computes B<a>*B<a> and places the low word of the "
"result in B<r0> and the high word in B<r1>."
msgstr ""

#. type: =head2
#: C/crypto/bn_internal.pod:208
msgid "Size changes"
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:210
msgid ""
"bn_expand() ensures that B<b> has enough space for a B<bits> bit number.  "
"bn_wexpand() ensures that B<b> has enough space for an B<n> word number.  If "
"the number has to be expanded, both macros call bn_expand2(), which "
"allocates a new B<d> array and copies the data.  They return B<NULL> on "
"error, B<b> otherwise."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:216
msgid ""
"The bn_fix_top() macro reduces B<a-E<gt>top> to point to the most "
"significant non-zero word plus one when B<a> has shrunk."
msgstr ""

#. type: =head2
#: C/crypto/bn_internal.pod:219
msgid "Debugging"
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:221
msgid ""
"bn_check_top() verifies that C<((a)-E<gt>top E<gt>= 0 && (a)-E<gt>top E<lt>= "
"(a)-E<gt>dmax)>.  A violation will cause the program to abort."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:224
msgid ""
"bn_print() prints B<a> to stderr. bn_dump() prints B<n> words at B<d> (in "
"reverse order, i.e. most significant word first) to stderr."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:227
msgid ""
"bn_set_max() makes B<a> a static number with a B<dmax> of its current size.  "
"This is used by bn_set_low() and bn_set_high() to make B<r> a read-only "
"B<BIGNUM> that contains the B<n> low or high words of B<a>."
msgstr ""

#. type: textblock
#: C/crypto/bn_internal.pod:231
msgid ""
"If B<BN_DEBUG> is not defined, bn_check_top(), bn_print(), bn_dump()  and "
"bn_set_max() are defined as empty macros."
msgstr ""

Attachment: signature.asc
Description: OpenPGP digital signature


Reply to: