openssl - en to fr translation catalogue (542 entries)

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

note: type: verbatim
en:  CONF_modules_free, CONF_modules_finish, CONF_modules_unload -
     OpenSSL configuration cleanup functions
fr: CONF_modules_free, CONF_modules_finish, CONF_modules_unload -
    Fonctions de nettoyage de la configuration d'OpenSSL

note: type: textblock
en: CONF_modules_free() closes down and frees up all memory allocated by all configuration modules.
fr: CONF_modules_free() ferme et libère la mémoire allouée par les modules de configuration.

note: type: textblock
en: CONF_modules_finish() calls each configuration modules B<finish> handler to free up any configuration that module may have performed.
fr: CONF_modules_finish() appelle le gestionnaire B<finish> de tous les modules de configuration pour libérer toute configuration effectuée par les modules.

note: type: textblock
en: CONF_modules_unload() finishes and unloads configuration modules. If B<all> is set to B<0> only modules loaded from DSOs will be unloads. If B<all> is B<1> all modules, including builtin modules will be unloaded.
fr: CONF_modules_unload() termine et décharge les modules de configuration. Si B<all> vaut B<0>, seuls les modules chargés à partir des objets partagés dynamiques seront déchargés. Si B<all> vaut B<1>, tous les modules, y compris les modules de base, seront déchargés.

note: type: textblock
en: Normally applications will only call CONF_modules_free() at application to tidy up any configuration performed.
fr: Les applications n'appelleront normalement que CONF_modules_free() pour nettoyer les configurations réalisées.

note: type: =head1
en: RETURN VALUE
fr: VALEUR DE RETOUR

note: type: textblock
en: None of the functions return a value.
fr: Aucune des fonctions ne renvoie de valeur.

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

note: type: textblock
en: L<conf(5)|conf(5)>, L<OPENSSL_config(3)|OPENSSL_config(3)>, L<CONF_modules_load_file(3)|CONF_modules_load_file(3)>
fr: L<B<conf>(5)|conf(5)>, L<B<OPENSSL_config>(3)|OPENSSL_config(3)>, L<B<CONF_modules_load_file>(3)|CONF_modules_load_file(3)>,

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

note: type: textblock
en: CONF_modules_free(), CONF_modules_unload(), and CONF_modules_finish()  first appeared in OpenSSL 0.9.7.
fr: CONF_modules_free(), CONF_modules_unload() et CONF_modules_finish() sont apparues dans la version 0.9.7 d'OpenSSL.

note: type: verbatim
en:  CONF_modules_load_file, CONF_modules_load - OpenSSL configuration functions
fr:  CONF_modules_load_file, CONF_modules_load - Fonctions de configuration d'OpenSSL

note: type: verbatim
en:  int CONF_modules_load_file(const char *filename, const char *appname,
    			                unsigned long flags);
     int CONF_modules_load(const CONF *cnf, const char *appname,
    		               unsigned long flags);
fr:  int CONF_modules_load_file(const char *filename, const char *appname,
    			                unsigned long flags);
     int CONF_modules_load(const CONF *cnf, const char *appname,
    		                unsigned long flags);

note: type: textblock
en: The function CONF_modules_load_file() configures OpenSSL using file B<filename> and application name B<appname>. If B<filename> is NULL the standard OpenSSL configuration file is used. If B<appname> is NULL the standard OpenSSL application name B<openssl_conf> is used.  The behaviour can be cutomized using B<flags>.
fr: La fonction CONF_modules_load_file() configure OpenSSL en utilisant le fichier B<filename> et l'application B<appname>. Si B<filename> vaut NULL, le fichier standard de configuration d'OpenSSL est utilisé. Si B<appname> vaut NULL, le nom d'application standard d’OpenSSL, B<openssl_conf>, est utilisé. Le comportement peut être personnalisé en utilisant B<flags>.

note: type: textblock
en: CONF_modules_load() is idential to CONF_modules_load_file() except it reads configuration information from B<cnf>.
fr: CONF_modules_load() est identique à CONF_modules_load_file() sauf qu'il lit l'information de configuration depuis B<cnf>.

note: type: textblock
en: The following B<flags> are currently recognized:
fr: Les B<flags> suivants sont reconnus :

note: type: textblock
en: B<CONF_MFLAGS_IGNORE_ERRORS> if set errors returned by individual configuration modules are ignored. If not set the first module error is considered fatal and no further modules are loaded.
fr: Si B<CONF_MFLAGS_IGNORE_ERRORS> est activé, les erreurs renvoyées individuellement par les modules de configuration sont ignorées. Sinon la première erreur provenant d’un module sera considérée comme fatale et aucun autre module ne sera chargé.

note: type: textblock
en: Normally any modules errors will add error information to the error queue. If B<CONF_MFLAGS_SILENT> is set no error information is added.
fr: Normalement, toutes les erreurs provenant des modules ajouteront des informations à la file d’erreur. Si B<CONF_MFLAGS_SILENT> est activé, il n'y aura pas d'information d'erreur ajoutée.

note: type: textblock
en: If B<CONF_MFLAGS_NO_DSO> is set configuration module loading from DSOs is disabled.
fr: Si B<CONF_MFLAGS_NO_DSO> est activé, le module de configuration chargeant à partir des DSO est désactivé.

note: type: textblock
en: B<CONF_MFLAGS_IGNORE_MISSING_FILE> if set will make CONF_load_modules_file()  ignore missing configuration files. Normally a missing configuration file return an error.
fr: Si B<CONF_MFLAGS_IGNORE_MISSING_FILE> est activé, CONF_load_modules_file() ignorera l'absence de fichiers de configuration. Normalement l'absence d'un fichier de configuration renvoie une erreur.

note: type: textblock
en: B<CONF_MFLAGS_DEFAULT_SECTION> if set and B<appname> is not NULL will use the default section pointed to by B<openssl_conf> if B<appname> does not exist.
fr: Si B<CONF_MFLAGS_DEFAULT_SECTION> est activé, et B<appname> n'est pas NULL, il utilisera la section par défaut pointée par B<openssl_conf> si B<appname> n'existe pas.

note: type: textblock
en: Applications should call these functions after loading builtin modules using OPENSSL_load_builtin_modules(), any ENGINEs for example using ENGINE_load_builtin_engines(), any algorithms for example OPENSSL_add_all_algorithms() and (if the application uses libssl)  SSL_library_init().
fr: Les applications devraient appeler ces fonctions après le chargement des modules intégrés en utilisant B<OPENSSL_load_builtin_modules>(), par exemple, tous les ENGINES en utilisant B<ENGINE_load_builtin_engines>(), tous les algorithmes en utilisant B<OPENSSL_add_all_algorithms>() et (si l'application utilise libssl) B<SSL_library_init>().

note: type: textblock
en: By using CONF_modules_load_file() with appropriate flags an application can customise application configuration to best suit its needs. In some cases the use of a configuration file is optional and its absence is not an error: in this case B<CONF_MFLAGS_IGNORE_MISSING_FILE> would be set.
fr: En utilisant B<CONF_modules_load_file>() avec les réglages appropriés, une application peut personnaliser sa configuration pour mieux répondre à ses besoins. Dans certains cas, l'utilisation d'un fichier de configuration est facultatif et son absence n'est pas une erreur : dans ce cas B<CONF_MFLAGS_IGNORE_MISSING_FILE> devrait être activé.

note: type: textblock
en: Errors during configuration may also be handled differently by different applications. For example in some cases an error may simply print out a warning message and the application continue. In other cases an application might consider a configuration file error as fatal and exit immediately.
fr: Les erreurs lors de la  configuration peuvent aussi être traitées autrement par différentes applications. Par exemple, dans certains cas, une erreur peut seulement afficher un message d'avertissement et l'application continue. Dans d'autres cas, l'application peut considérer comme fatale une erreur de ficher de configuration et se terminer immédiatement.

note: type: textblock
en: Applications can use the CONF_modules_load() function if they wish to load a configuration file themselves and have finer control over how errors are treated.
fr: Des applications peuvent utiliser la fonction B<CONF_modules_load>() si elles souhaitent charger elles-mêmes un fichier de configuration et avoir un contrôle plus fin sur la manière dont les erreurs sont traitées.

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

note: type: textblock
en: Load a configuration file and print out any errors and exit (missing file considered fatal):
fr: Charger un fichier de configuration, afficher toutes les erreurs et terminer l'application (absence de fichier considérée comme fatale) :

note: type: textblock
en: Load default configuration file using the section indicated by "myapp", tolerate missing files, but exit on other errors:
fr: Charger le ficher de configuration par défaut en utilisant la section indiquée par « myapp », tolérer les fichiers manquants, mais terminer l'application si d'autres erreurs surviennent :

note: type: textblock
en: Load custom configuration file and section, only print warnings on error, missing configuration file ignored:
fr: Charger la section et le fichier de configuration personnalisés, afficher seulement des avertissements en cas d'erreur, l'absence de fichier de configuration est ignorée :

note: type: textblock
en: Load and parse configuration file manually, custom error handling:
fr: Charger et analyser soi-même le fichier de configuration, traitement d'erreur personnalisé :

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

note: type: textblock
en: These functions return 1 for success and a zero or negative value for failure. If module errors are not ignored the return code will reflect the return value of the failing module (this will always be zero or negative).
fr: Ces fonctions renvoient 1 pour un succès et 0 ou une valeur négative pour un échec. Si les erreurs des modules ne sont pas ignorées, le code de retour représentera la valeur de retour du module défaillant (cette valeur sera toujours inférieure ou égale à 0).

note: type: textblock
en: L<conf(5)|conf(5)>, L<OPENSSL_config(3)|OPENSSL_config(3)>, L<CONF_free(3)|CONF_free(3)>, L<err(3)|err(3)>
fr: L<B<err>(3),err(3)>, L<B<OPENSSL_config>(3)|OPENSSL_config(3)>, L<B<CONF_free>(3)|CONF_free(3)>, L<B<conf>(5)|conf(5)>

note: type: textblock
en: CONF_modules_load_file and CONF_modules_load first appeared in OpenSSL 0.9.7.
fr: CONF_modules_load_file et CONF_modules_load sont apparues dans la version 0.9.7 d'OpenSSL.

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

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

note: type: textblock
en: These functions should only be used by applications to manipulate B<CRYPTO_EX_DATA> structures passed to the B<new_func()>, B<free_func()> and B<dup_func()> callbacks: as passed to B<RSA_get_ex_new_index()> for example.
fr: Ces fonctions ne devraient être utilisées par les applications que pour manipuler les structures B<CRYPTO_EX_DATA> passées aux fonctions de rappel B<new_func>(), B<free_func>() et B<dup_func>() : comme passées à B<RSA_get_ex_new_index>() par exemple.

note: type: textblock
en: B<CRYPTO_set_ex_data()> is used to set application specific data, the data is supplied in the B<arg> parameter and its precise meaning is up to the application.
fr: B<CRYPTO_set_ex_data>() est utilisée pour définir les données spécifiques aux applications, les données sont fournies par le paramètre I<arg> et sa signification précise dépend de l'application.

note: type: textblock
en: B<CRYPTO_get_ex_data()> is used to retrieve application specific data. The data is returned to the application, this will be the same value as supplied to a previous B<CRYPTO_set_ex_data()> call.
fr: B<CRYPTO_get_ex_data>() est utilisée pour récupérer les données spécifiques aux applications. Les données sont renvoyées à l'application, ce seront les mêmes que celles fournies à un précédent appel B<CRYPTO_set_ex_data>().

note: type: textblock
en: B<CRYPTO_set_ex_data()> returns 1 on success or 0 on failure.
fr: B<CRYPTO_set_ex_data>() renvoie 1 en cas de succès et 0 en cas d'échec.

note: type: textblock
en: B<CRYPTO_get_ex_data()> returns the application data or 0 on failure. 0 may also be valid application data but currently it can only fail if given an invalid B<idx> parameter.
fr: B<CRYPTO_get_ex_data>() renvoie les données de l'application en cas de succès et B<0> en cas d'échec. B<0> peut aussi être une donnée d'application valable, mais pour l'instant un échec n’est possible que si un paramètre I<idx> incorrect est donné.

note: type: textblock
en: On failure an error code can be obtained from L<ERR_get_error(3)|ERR_get_error(3)>.
fr: En cas d'erreur, le code d'erreur peut être obtenu avec L<ERR_get_error(3)|ERR_get_error(3)>.

note: type: textblock
en: L<RSA_get_ex_new_index(3)|RSA_get_ex_new_index(3)>, L<DSA_get_ex_new_index(3)|DSA_get_ex_new_index(3)>, L<DH_get_ex_new_index(3)|DH_get_ex_new_index(3)>
fr: L<DH_get_ex_new_index(3)|DH_get_ex_new_index(3)>, L<DSA_get_ex_new_index(3)|DSA_get_ex_new_index(3)>, L<RSA_get_ex_new_index(3)|RSA_get_ex_new_index(3)>

note: type: textblock
en: CRYPTO_set_ex_data() and CRYPTO_get_ex_data() have been available since SSLeay 0.9.0.
fr: B<CRYPTO_set_ex_data>() et B<CRYPTO_get_ex_data>() sont apparues dans la version 0.9.0 de SSLeay.

note: type: textblock
en: OBJ_nid2obj, OBJ_nid2ln, OBJ_nid2sn, OBJ_obj2nid, OBJ_txt2nid, OBJ_ln2nid, OBJ_sn2nid, OBJ_cmp, OBJ_dup, OBJ_txt2obj, OBJ_obj2txt, OBJ_create, OBJ_cleanup - ASN1 object utility functions
fr: OBJ_nid2obj, OBJ_nid2ln, OBJ_nid2sn, OBJ_obj2nid, OBJ_txt2nid, OBJ_ln2nid, OBJ_sn2nid, OBJ_cmp, OBJ_dup, OBJ_txt2obj, OBJ_obj2txt, OBJ_create, OBJ_cleanup - Fonctions utilitaires de l'objet ASN1.

note: type: textblock
en: The ASN1 object utility functions process ASN1_OBJECT structures which are a representation of the ASN1 OBJECT IDENTIFIER (OID) type.
fr: Les fonctions utilitaires de l'objet ASN1 traitent les structures ASN1_OBJECT qui sont une représentation du type ASN1 OBJECT IDENTIFIER (OID).

note: type: textblock
en: OBJ_nid2obj(), OBJ_nid2ln() and OBJ_nid2sn() convert the NID B<n> to an ASN1_OBJECT structure, its long name and its short name respectively, or B<NULL> is an error occurred.
fr: OBJ_nid2obj(), OBJ_nid2ln() et OBJ_nid2sn() convertissent le NID B<n> en une structure ASN1_OBJECT, son nom long et son nom court respectivement, ou NULL s'il y a eu une erreur.

note: type: textblock
en: OBJ_obj2nid(), OBJ_ln2nid(), OBJ_sn2nid() return the corresponding NID for the object B<o>, the long name <ln> or the short name <sn> respectively or NID_undef if an error occurred.
fr: OBJ_obj2nid(), OBJ_ln2nid() et OBJ_sn2nid() renvoient le NID correspondant à l'objet B<o>, le nom long <ln> ou le nom court <sn> respectivement, ou NID_undef s'il y a eu une erreur.

note: type: textblock
en: OBJ_txt2nid() returns NID corresponding to text string <s>. B<s> can be a long name, a short name or the numerical respresentation of an object.
fr: OBJ_txt2nid() renvoie NID correspondant à la chaîne de caractères <s>. B<s> peut être un nom long, un nom court ou une représentation numérique d'un objet.

note: type: textblock
en: OBJ_txt2obj() converts the text string B<s> into an ASN1_OBJECT structure.  If B<no_name> is 0 then long names and short names will be interpreted as well as numerical forms. If B<no_name> is 1 only the numerical form is acceptable.
fr: OBJ_txt2obj() convertit la chaîne de caractères B<s> en une structure ASN1_OBJECT. Si B<no_name> vaut 0, alors les noms longs et courts ainsi que les formes numériques seront interprétés. Si B<no_name> vaut 1, seule la forme numérique est acceptée.

note: type: textblock
en: OBJ_obj2txt() converts the B<ASN1_OBJECT> B<a> into a textual representation.  The representation is written as a null terminated string to B<buf> at most B<buf_len> bytes are written, truncating the result if necessary.  The total amount of space required is returned. If B<no_name> is 0 then if the object has a long or short name then that will be used, otherwise the numerical form will be used. If B<no_name> is 1 then the numerical form will always be used.
fr: OBJ_obj2txt() convertit le B<ASN1_OBJECT> B<a> en une représentation textuelle. La représentation est écrite sous forme de chaîne, terminée par null, dans B<buf> avec une taille maximale de B<buf_len>, le résultat est tronqué si nécessaire. La taille de l'espace nécessaire est renvoyée. Si B<no_name> vaut 0 et si l'objet a un nom long ou court alors ce nom sera utilisé, sinon la valeur numérique sera utilisée. Si B<no_name> vaut 1 alors la forme numérique sera toujours utilisée.

note: type: textblock
en: OBJ_cmp() compares B<a> to B<b>. If the two are identical 0 is returned.
fr: OBJ_cmp() compare B<a> et B<b>. Si les deux sont identiques, le code de retour sera 0.

note: type: textblock
en: OBJ_dup() returns a copy of B<o>.
fr: OBJ_dup() renvoie une copie de B<o>.

note: type: textblock
en: OBJ_create() adds a new object to the internal table. B<oid> is the numerical form of the object, B<sn> the short name and B<ln> the long name. A new NID is returned for the created object.
fr: OBJ_create() ajoute un nouvel objet à la table interne. B<oid> est la forme numérique provenant de l'objet, B<sn> le nom court et B<ln> le nom long. Un nouvel NID est renvoyé pour l'objet créé.

note: type: textblock
en: OBJ_cleanup() cleans up OpenSSLs internal object table: this should be called before an application exits if any new objects were added using OBJ_create().
fr: OBJ_cleanup() nettoie la table d'objets interne d'OpenSSL : celle-ci devrait être appelée avant qu'une application se termine si un objet a été ajouté en utilisant OBJ_create().

note: type: textblock
en: Objects in OpenSSL can have a short name, a long name and a numerical identifier (NID) associated with them. A standard set of objects is represented in an internal table. The appropriate values are defined in the header file B<objects.h>.
fr: Dans OpenSSL, les objets peuvent avoir un nom court, un nom long et un identifiant numérique (NID) qui leur sont associés. Un ensemble d'objets est représenté comme une table interne. Les valeurs appropriées sont définies dans le fichier d'en-tête B<objects.h>.

note: type: textblock
en: For example the OID for commonName has the following definitions:
fr: Par exemple, l'OID pour commonName a les définitions suivantes :

note: type: textblock
en: New objects can be added by calling OBJ_create().
fr: De nouveaux objets peuvent être ajoutés en appelant OBJ_create().

note: type: textblock
en: Table objects have certain advantages over other objects: for example their NIDs can be used in a C language switch statement. They are also static constant structures which are shared: that is there is only a single constant structure for each table object.
fr: Les tables ont un certain avantage par rapport aux autres objets : par exemple, leurs NID peuvent être utilisés dans une déclaration de switch en C. Ce sont aussi des objets statiques constants qui sont échangés : il n'y a qu'une unique structure constante pour chaque table.

note: type: textblock
en: Objects which are not in the table have the NID value NID_undef.
fr: Les objets n'étant pas dans la table ont NID_undef comme valeur de NID.

note: type: textblock
en: Objects do not need to be in the internal tables to be processed, the functions OBJ_txt2obj() and OBJ_obj2txt() can process the numerical form of an OID.
fr: Les objets n'ont pas besoin de tables internes pour être traités, les fonctions OBJ_txt2obj() et OBJ_obj2txt() peuvent traiter la forme numérique d'un OID.

note: type: textblock
en: Create an object for B<commonName>:
fr: Créer un objet pour B<commonName>:

note: type: textblock
en: Check if an object is B<commonName>
fr: Vérifier si un objet est B<commonName>

note: type: verbatim
en:  if (OBJ_obj2nid(obj) == NID_commonName)
    	/* Do something */
fr:  if (OBJ_obj2nid(obj) == NID_commonName)
    	/* Faire quelque chose */

note: type: textblock
en: Create a new NID and initialize an object from it:
fr: Créer un nouveau NID et initialiser un objet à partir de celui-ci :

note: type: textblock
en: Create a new object directly:
fr: Créer directement un nouvel objet :

note: type: =head1
en: BUGS
fr: BOGUES

note: type: textblock
en: OBJ_obj2txt() is awkward and messy to use: it doesn't follow the convention of other OpenSSL functions where the buffer can be set to B<NULL> to determine the amount of data that should be written.  Instead B<buf> must point to a valid buffer and B<buf_len> should be set to a positive value. A buffer length of 80 should be more than enough to handle any OID encountered in practice.
fr: OBJ_obj2txt() est délicate et compliquée à utiliser : elle ne suit pas les conventions des autres fonctions d'OpenSSL où le tampon peut être mis à NULL pour déterminer la quantité de données qui devraient être écrites. Au lieu de cela B<buf> doit pointer vers un tampon valide et B<buf_len> doit être une valeur positive. Un tampon ayant une longueur de 80 devrait être suffisant pour traiter n'importe quel OID rencontré.

note: type: textblock
en: OBJ_nid2obj() returns an B<ASN1_OBJECT> structure or B<NULL> is an error occurred.
fr: OBJ_nid2obj() renvoie une structure B<ASN1_OBJECT> ou NULL en cas d'erreur.

note: type: textblock
en: OBJ_nid2ln() and OBJ_nid2sn() returns a valid string or B<NULL> on error.
fr: OBJ_nid2ln() et OBJ_nid2sn() renvoient une chaîne de caractères valide ou NULL en cas d'erreur.

note: type: textblock
en: OBJ_obj2nid(), OBJ_ln2nid(), OBJ_sn2nid() and OBJ_txt2nid() return a NID or B<NID_undef> on error.
fr: OBJ_obj2nid(), OBJ_ln2nid(), OBJ_sn2nid() et OBJ_txt2nid() renvoient un NID ou B<NID_undef> en cas d'erreur.

note: type: textblock
en: TBA
fr: À préciser

note: type: verbatim
en:  PEM_write_bio_CMS_stream - output CMS_ContentInfo structure in PEM format.
fr:  PEM_write_bio_CMS_stream - Afficher une structure CMS_ContentInfo au format PEM

note: type: textblock
en: PEM_write_bio_CMS_stream() outputs a CMS_ContentInfo structure in PEM format.
fr: B<PEM_write_bio_CMS_stream>() produit une structure CMS_ContentInfo au format PEM.

note: type: textblock
en: It is otherwise identical to the function SMIME_write_CMS().
fr: Sinon, elle est identique à la fonction B<SMIME_write_CMS>().

note: type: textblock
en: This function is effectively a version of the PEM_write_bio_CMS() supporting streaming.
fr: Cette fonction est effectivement une version de B<PEM_write_bio_CMS>() gérant les flux.

note: type: textblock
en: PEM_write_bio_CMS_stream() returns 1 for success or 0 for failure.
fr: B<PEM_write_bio_CMS_stream>() renvoie B<1> en cas de réussite et B<0> en cas d'échec.

note: type: textblock
en: PEM_write_bio_CMS_stream() was added to OpenSSL 1.0.0
fr: B<PEM_write_bio_CMS_stream>() a été ajoutée dans OpenSSL 1.0.0

note: type: textblock
en: PEM_write_bio_PKCS7_stream - output PKCS7 structure in PEM format.
fr: PEM_write_bio_PKCS7_stream - Générer une structure PKCS7 au format PEM

note: type: textblock
en: PEM_write_bio_PKCS7_stream() outputs a PKCS7 structure in PEM format.
fr: B<PEM_write_bio_PKCS7_stream>() génère une structure PKCS7 au format PEM.

note: type: textblock
en: It is otherwise identical to the function SMIME_write_PKCS7().
fr: Sinon, elle est identique à la fonction B<SMIME_write_PKCS7>().

note: type: textblock
en: This function is effectively a version of the PEM_write_bio_PKCS7() supporting streaming.
fr: Cette fonction est effectivement une version de B<PEM_write_bio_PKCS7>() gérant les flux.

note: type: textblock
en: PEM_write_bio_PKCS7_stream() returns 1 for success or 0 for failure.
fr: B<PEM_write_bio_PKCS7_stream>() renvoie B<1> en cas de réussite et B<0> en cas d'échec.

note: type: textblock
en: PEM_write_bio_PKCS7_stream() was added to OpenSSL 1.0.0
fr: B<PEM_write_bio_PKCS7_stream>() a été ajoutée dans OpenSSL 1.0.0

note: type: textblock
en: SSLeay_version - retrieve version/build information about OpenSSL library
fr: SSLeay_version - Récupère les informations de version et de construction sur la bibliothèque OpenSSL

note: type: textblock
en: SSLeay_version() returns a pointer to a constant string describing the version of the OpenSSL library or giving information about the library build.
fr: B<SSLeay_version>() renvoie un pointeur vers une chaîne constante décrivant la version de la bibliothèque OpenSSL ou donnant des informations sur la construction de la bibliothèque.

note: type: textblock
en: The following B<type> values are supported:
fr: Les valeurs de B<type> suivantes sont prises en charge :

note: type: textblock
en: The version of the OpenSSL library including the release date.
fr: La version de la bibliothèque OpenSSL y compris la date de publication.

note: type: textblock
en: The compiler flags set for the compilation process in the form "compiler: ..." if available or "compiler: information not available" otherwise.
fr: Les drapeaux du compilateur activés pour le processus de compilation sous la forme « compiler: ... » si l'information est disponible ou « compiler: information not available » autrement.

note: type: textblock
en: The date of the build process in the form "built on: ..." if available or "built on: date not available" otherwise.
fr: La date du processus de construction sous la forme « built on: .... » si l'information est disponible ou « built on: date not available » autrement.

note: type: textblock
en: The "Configure" target of the library build in the form "platform: ..." if available or "platform: information not available" otherwise.
fr: La cible de « Configure » de la bibliothèque construite sous la forme « platform: .... » si l'information est disponible ou « platform: information not available » autrement.

note: type: textblock
en: The "OPENSSLDIR" setting of the library build in the form "OPENSSLDIR: "..."" if available or "OPENSSLDIR: N/A" otherwise.
fr: Le paramètre de « OPENSSLDIR » de la bibliothèque construite sous la forme « OPENSSLDIR: ... » si l'information est disponible ou « OPENSSLDIR: N/A » autrement.

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

note: type: =item
en: "not available"
fr: « not available »

note: type: textblock
en: An invalid value for B<type> was given.
fr: Une valeur incorrecte pour B<type> a été donnée.

note: type: =item
en: Pointer to constant string
fr: Pointeur vers une chaîne constante

note: type: textblock
en: Textual description.
fr: Description textuelle

note: type: textblock
en: B<SSLEAY_DIR> was added in OpenSSL 0.9.7.
fr: B<SSLEAY_DIR> a été ajoutée dans OpenSSL 0.9.7.

note: type: textblock
en: blowfish, BF_set_key, BF_encrypt, BF_decrypt, BF_ecb_encrypt, BF_cbc_encrypt, BF_cfb64_encrypt, BF_ofb64_encrypt, BF_options - Blowfish encryption
fr: blowfish, BF_set_key, BF_encrypt, BF_decrypt, BF_ecb_encrypt, BF_cbc_encrypt, BF_cfb64_encrypt, BF_ofb64_encrypt, BF_options - Chiffrement avec Blowfish.

note: type: textblock
en: This library implements the Blowfish cipher, which was invented and described by Counterpane (see http://www.counterpane.com/blowfish.html ).
fr: Cette bibliothèque implémente l'algorithme de chiffrement Blowfish, qui a été créé et décrit par Counterpane (voir http://www.counterpane.com/blowfish.html).

note: type: textblock
en: Blowfish is a block cipher that operates on 64 bit (8 byte) blocks of data.  It uses a variable size key, but typically, 128 bit (16 byte) keys are considered good for strong encryption.  Blowfish can be used in the same modes as DES (see L<des_modes(7)|des_modes(7)>).  Blowfish is currently one of the faster block ciphers.  It is quite a bit faster than DES, and much faster than IDEA or RC2.
fr: Blowfish est un algorithme de chiffrement par blocs qui opère sur des blocs de données de 64 bits (8 octets). Blowfish utilise une clé de taille variable, mais en général, les clés de longueur 128 bits (16 octets) sont considérées comme bonnes pour un chiffrement puissant. Blowfish peut être utilisé de la même façon que l'algorithme DES (voir L<des_modes(7)|des_modes(7)>). Blowfish est actuellement un des algorithmes de chiffrement par blocs les plus rapides. Il est un peu plus rapide que DES, et bien plus rapide qu'IDEA ou RC2.

note: type: textblock
en: Blowfish consists of a key setup phase and the actual encryption or decryption phase.
fr: Blowfish consiste en une phase de mise en place de clés, puis une phase deréel chiffrement ou déchiffrement.

note: type: textblock
en: BF_set_key() sets up the B<BF_KEY> B<key> using the B<len> bytes long key at B<data>.
fr: BF_set_key() mets en place B<BF_KEY> B<key> en utilisant la clé de B<len> octets dans B<data>.

note: type: textblock
en: BF_ecb_encrypt() is the basic Blowfish encryption and decryption function.  It encrypts or decrypts the first 64 bits of B<in> using the key B<key>, putting the result in B<out>.  B<enc> decides if encryption (B<BF_ENCRYPT>)  or decryption (B<BF_DECRYPT>) shall be performed.  The vector pointed at by B<in> and B<out> must be 64 bits in length, no less.  If they are larger, everything after the first 64 bits is ignored.
fr: BF_ecb_encrypt() est la fonction de chiffrement et de déchiffrement de base de Blowfish. Celle-ci chiffre et déchiffre les premiers 64 bits de B<in> en utilisant la clé B<key>, et met le résultat dans B<out>. B<enc> décide si un chiffrement (B<BF_ENCRYPT>) ou un déchiffrement (B<BF_DECRYPT>) doit être appliqué. Le vecteur pointé par B<in> et B<out> doit avoir une longueur de 64 bits, pas moins. S'ils sont plus grands, tout ce qu'il y a après le 64ème bit est ignoré.

note: type: textblock
en: The mode functions BF_cbc_encrypt(), BF_cfb64_encrypt() and BF_ofb64_encrypt()  all operate on variable length data.  They all take an initialization vector B<ivec> which needs to be passed along into the next call of the same function for the same message.  B<ivec> may be initialized with anything, but the recipient needs to know what it was initialized with, or it won't be able to decrypt.  Some programs and protocols simplify this, like SSH, where B<ivec> is simply initialized to zero.  BF_cbc_encrypt() operates on data that is a multiple of 8 bytes long, while BF_cfb64_encrypt() and BF_ofb64_encrypt() are used to encrypt an variable number of bytes (the amount does not have to be an exact multiple of 8).  The purpose of the latter two is to simulate stream ciphers, and therefore, they need the parameter B<num>, which is a pointer to an integer where the current offset in B<ivec> is stored between calls.  This integer must be initialized to zero when B<ivec> is initialized.
fr: Les fonctions de mode BF_cbc_encrypt(), BF_cfb64_encrypt() et BF_ofb64_encrypt() opèrent toutes sur des données de tailles variables. Elles prennent toutes un vecteur d'initialisation B<ivec> qui nécessite d'être passé au prochain appel de la même fonction pour le même message. B<ivec> peut être initialisé avec n'importe quoi mais le destinataire a besoin de savoir avec quoi il a été initialisé, ou il ne pourra pas déchiffrer. Certains programmes et protocoles simplifient cela, comme SSH, où B<ivec> est simplement initialisé à 0. BF_cbc_encrypt() opère sur des données qui sont des multiples de 8 octets en longueur, alors que BF_cfb64_encrypt() et BF_ofb64_encrypt() sont utilisées pour chiffrer un nombre d'octets variable (le montant peut ne pas être un multiple de 8). Le but des deux dernières fonctions est de pouvoir simuler des chiffrements de flux, et de ce fait, elles ont besoin d'un paramètre B<num>, qui est un pointeur vers un entier dans lequel est stocké la position courante de lecture B<ivec> entre chaque appel. Cet entier doit être initialisé à 0 quand B<ivec> est initialisé.

note: type: textblock
en: BF_cbc_encrypt() is the Cipher Block Chaining function for Blowfish.  It encrypts or decrypts the 64 bits chunks of B<in> using the key B<schedule>, putting the result in B<out>.  B<enc> decides if encryption (BF_ENCRYPT) or decryption (BF_DECRYPT) shall be performed.  B<ivec> must point at an 8 byte long initialization vector.
fr: BF_cbc_encrypt() est la fonction d'enchaînement pour le chiffrement par blocs de Blowfish. Elle chiffre et déchiffre les morceaux de 64 bits de B<in> en utilisant la clé B<schedule>, puis met le résultat dans B<out>. B<enc> décide si un chiffrement (BF_ENCRYPT) ou un déchiffrement (BF_DECRYPT) doit être exécuté. B<ivec> doit pointer vers un vecteur d'initialisation de 8 octets.

note: type: textblock
en: BF_cfb64_encrypt() is the CFB mode for Blowfish with 64 bit feedback.  It encrypts or decrypts the bytes in B<in> using the key B<schedule>, putting the result in B<out>.  B<enc> decides if encryption (B<BF_ENCRYPT>)  or decryption (B<BF_DECRYPT>) shall be performed.  B<ivec> must point at an 8 byte long initialization vector. B<num> must point at an integer which must be initially zero.
fr: BF_cfb64_encrypt() est le mode CFB de Blowfish avec un retour de 64 bits. Elle chiffre et déchiffre les octets de B<in> en utilisant la clé B<schedule>, et met le résultat dans B<out>. B<enc> décide si un chiffrement (B<BF_ENCRYPT>) ou un déchiffrement (B<BF_DECRYPT>) doit être exécuté. B<ivec> doit pointer vers un vecteur d'initialisation de 8 octets. B<num> doit pointer vers un entier qui doit être initialisé à 0.

note: type: textblock
en: BF_ofb64_encrypt() is the OFB mode for Blowfish with 64 bit feedback.  It uses the same parameters as BF_cfb64_encrypt(), which must be initialized the same way.
fr: BF_ofb64_encrypt() est le mode OFB de Blowfish avec un retour de 64 bits. Elle utilise les mêmes paramètres que BF_cfb64_encrypt(), et ceux-ci doivent être initialisés de la même façon.

note: type: textblock
en: BF_encrypt() and BF_decrypt() are the lowest level functions for Blowfish encryption.  They encrypt/decrypt the first 64 bits of the vector pointed by B<data>, using the key B<key>.  These functions should not be used unless you implement 'modes' of Blowfish.  The alternative is to use BF_ecb_encrypt().  If you still want to use these functions, you should be aware that they take each 32-bit chunk in host-byte order, which is little-endian on little-endian platforms and big-endian on big-endian ones.
fr: BF_encrypt() et BF_decrypt() sont les fonctions de bas niveau du chiffrement Blowfish. Elles chiffrent ou déchiffrent les premiers 64 bits du vecteur pointé par B<data>, en utilisant la clé B<key>. Ces fonctions ne doivent pas être utilisées sauf si vous implémentez « modes » pour Blowfish. L'alternative est d'utiliser BF_ecb_encrypt(). Si vous voulez utiliser ces fonctions, sachez qu'elles prennent des blocs de 32 bits dans l'ordre de l'hôte, c'est-à-dire petit-boutiste pour les plateformes petit-boutistes et gros-boutiste pour celles gros-boutistes.

note: type: textblock
en: None of the functions presented here return any value.
fr: Aucune des fonctions présentées ici n'a de valeur de retour.

note: type: textblock
en: Applications should use the higher level functions L<EVP_EncryptInit(3)|EVP_EncryptInit(3)> etc. instead of calling the blowfish functions directly.
fr: Les applications devraient utiliser les fonctions de haut niveau telles L<EVP_EncryptInit(3)|EVP_EncryptInit(3)>, etc., au lieu d'appeler les fonctions de Blowfish directement.

note: type: textblock
en: The Blowfish functions are available in all versions of SSLeay and OpenSSL.
fr: Les fonctions Blowfish sont disponibles dans toutes les versions de SSLeay et d'OpenSSL.

note: type: textblock
en: BUF_MEM_new, BUF_MEM_free, BUF_MEM_grow, BUF_strdup - simple character arrays structure
fr: BUF_MEM_new, BUF_MEM_free, BUF_MEM_grow, BUF_strdup - Structure de tableaux de caractères simples

note: type: textblock
en: The buffer library handles simple character arrays. Buffers are used for various purposes in the library, most notably memory BIOs.
fr: La bibliothèque de tampon utilise des tableaux de caractères simples. Les tampons sont utilisés à des fins diverses dans la bibliothèque, notamment pour les BIO mémoires.

note: type: textblock
en: The library uses the BUF_MEM structure defined in buffer.h:
fr: La bibliothèque utilise la structure BUF_MEM définie dans buffer.h

note: type: verbatim
en:  typedef struct buf_mem_st
     {
            int length;     /* current number of bytes */
            char *data;
            int max;        /* size of buffer */
     } BUF_MEM;
fr:  typedef struct buf_mem_st
     {
            int length;     /* nombre actuel d'octets */
            char *data;
            int max;        /* taille du tampon */
     } BUF_MEM;

note: type: textblock
en: B<length> is the current size of the buffer in bytes, B<max> is the amount of memory allocated to the buffer. There are three functions which handle these and one "miscellaneous" function.
fr: B<length> est la taille actuelle du tampon en octets, B<max> est la quantité de mémoire allouée au tampon. Il y a trois fonctions qui gèrent celles-ci, ainsi qu'une fonction « divers ».

note: type: textblock
en: BUF_MEM_new() allocates a new buffer of zero size.
fr: BUF_MEM_new() alloue un nouveau tampon de taille 0.

note: type: textblock
en: BUF_MEM_free() frees up an already existing buffer. The data is zeroed before freeing up in case the buffer contains sensitive data.
fr: BUF_MEM_free() libère un tampon préexistant. Les données sont mises à 0 avant d'être libérées au cas où le tampon contiendrait des données sensibles.

note: type: textblock
en: BUF_MEM_grow() changes the size of an already existing buffer to B<len>. Any data already in the buffer is preserved if it increases in size.
fr: BUF_MEM_grow() change la taille d'un tampon déjà existant à la taille B<len>. Les données présentes dans le tampon sont préservées si celui-ci est agrandi.

note: type: textblock
en: BUF_strdup() copies a null terminated string into a block of allocated memory and returns a pointer to the allocated block.  Unlike the standard C library strdup() this function uses OPENSSL_malloc() and so should be used in preference to the standard library strdup() because it can be used for memory leak checking or replacing the malloc() function.
fr: BUF_strdup() copie une chaîne terminée par null dans un bloc de mémoire alloué et renvoie un pointeur vers ce bloc. À la différence de la fonction strdup() de la bibliothèque standard de C, cette fonction utilise OPENSSL_malloc() et donc devrait être préférée à strdup() car elle peut être utilisée pour détecter des fuites de mémoire ou pour remplacer la fonction malloc().

note: type: textblock
en: The memory allocated from BUF_strdup() should be freed up using the OPENSSL_free()  function.
fr: La mémoire allouée par BUF_strdup() doit être libérée en utilisant la fonction OPENSSL_free().

note: type: textblock
en: BUF_MEM_new() returns the buffer or NULL on error.
fr: BUF_MEM_new() renvoie le tampon ou NULL en cas d'erreur.

note: type: textblock
en: BUF_MEM_free() has no return value.
fr: BUF_MEM_free() n'a pas de valeur de retour.

note: type: textblock
en: BUF_MEM_grow() returns zero on error or the new size (i.e. B<len>).
fr: BUF_MEM_grow() renvoie la nouvelle taille (c'est-à-dire B<len>), ou 0 en cas d'erreur.

note: type: textblock
en: BUF_MEM_new(), BUF_MEM_free() and BUF_MEM_grow() are available in all versions of SSLeay and OpenSSL. BUF_strdup() was added in SSLeay 0.8.
fr: BUF_MEM_new(), BUF_MEM_free() et BUF_MEM_grow() sont disponibles dans toutes les versions de SSLeay et d'OpenSSL. BUF_strdup() a été ajouté dans SSLeay 0.8.

note: type: textblock
en: crypto - OpenSSL cryptographic library
fr: crypto - Bibliothèque cryptographique d'OpenSSL

note: type: textblock
en: The OpenSSL B<crypto> library implements a wide range of cryptographic algorithms used in various Internet standards. The services provided by this library are used by the OpenSSL implementations of SSL, TLS and S/MIME, and they have also been used to implement SSH, OpenPGP, and other cryptographic standards.
fr: La bibliothèque B<crypto> d'OpenSSL implémente une large gamme d'algorithmes cryptographiques utilisés dans divers standards Internet. Les services offerts par cette bibliothèque sont utilisés par OpenSSL dans l'implémentation de SSL, TLS et S/MIME, et ils ont aussi été utilisés pour implémenter SSH, OpenPGP et d'autres standards cryptographiques.

note: type: =head1
en: OVERVIEW
fr: VUE D'ENSEMBLE

note: type: textblock
en: B<libcrypto> consists of a number of sub-libraries that implement the individual algorithms.
fr: B<libcrypto> est composée de sous-bibliothèques qui implémentent les différents algorithmes.

note: type: textblock
en: The functionality includes symmetric encryption, public key cryptography and key agreement, certificate handling, cryptographic hash functions and a cryptographic pseudo-random number generator.
fr: La fonctionnalité inclut le chiffrement symétrique, la cryptographie à clé publique et l'accord de clé, le traitement de certificat, les fonctions de hachage cryptographique et un générateur de nombres pseudo-aléatoires.

note: type: =item
en: SYMMETRIC CIPHERS
fr: CHIFFREMENT SYMÉTRIQUE

note: type: =item
en: PUBLIC KEY CRYPTOGRAPHY AND KEY AGREEMENT
fr: CLÉ PUBLIQUE ET ACCORD DE CLÉ

note: type: =item
en: CERTIFICATES
fr: CERTIFICATS

note: type: =item
en: AUTHENTICATION CODES, HASH FUNCTIONS
fr: CODES D'AUTHENTIFICATION, FONCTIONS DE HACHAGE

note: type: =item
en: AUXILIARY FUNCTIONS
fr: FONCTIONS ANNEXES

note: type: =item
en: INPUT/OUTPUT, DATA ENCODING
fr: ENTRÉE/SORTIE, CHIFFREMENT DE DONNÉE

note: type: =item
en: INTERNAL FUNCTIONS
fr: FONCTIONS INTERNES

note: type: textblock
en: L<bn(3)|bn(3)>, L<buffer(3)|buffer(3)>, L<ec(3)|ec(3)>, L<lhash(3)|lhash(3)>, L<objects(3)|objects(3)>, L<stack(3)|stack(3)>, L<txt_db(3)|txt_db(3)>
fr: L<B<bn>(3)|bn(3)>, L<B<buffer>(3)|buffer(3)>, L<B<ec>(3)|ec(3)>, L<B<lhash>(3)|lhash(3)>, L<B<objects>(3)|objects(3)>, L<B<stack>(3)|stack(3)>, L<B<txt_db>(3)|txt_db(3)>

note: type: textblock
en: Some of the newer functions follow a naming convention using the numbers B<0> and B<1>. For example the functions:
fr: Certaines nouvelles fonctions suivent une convention de nom qui utilise les nombres B<0> et B<1>, par exemple les fonctions :

note: type: textblock
en: The B<0> version uses the supplied structure pointer directly in the parent and it will be freed up when the parent is freed.  In the above example B<crl> would be freed but B<rev> would not.
fr: La version B<0> utilise le pointeur de structure fourni, directement dans le parent, et il sera libéré quand le parent sera libéré. Dans l'exemple ci-dessus B<ctrl> serait libéré, mais B<rev> ne le serait pas.

note: type: textblock
en: The B<1> function uses a copy of the supplied structure pointer (or in some cases increases its link count) in the parent and so both (B<x> and B<obj> above) should be freed up.
fr: La fonction B<1> utilise une copie du pointeur de structure fourni (ou dans certains cas augmente son compteur de liens), dans le parent, et donc ils (B<x> et B<obj> ci-dessus) doivent être libérés.

note: type: textblock
en: DES_random_key, DES_set_key, DES_key_sched, DES_set_key_checked, DES_set_key_unchecked, DES_set_odd_parity, DES_is_weak_key, DES_ecb_encrypt, DES_ecb2_encrypt, DES_ecb3_encrypt, DES_ncbc_encrypt, DES_cfb_encrypt, DES_ofb_encrypt, DES_pcbc_encrypt, DES_cfb64_encrypt, DES_ofb64_encrypt, DES_xcbc_encrypt, DES_ede2_cbc_encrypt, DES_ede2_cfb64_encrypt, DES_ede2_ofb64_encrypt, DES_ede3_cbc_encrypt, DES_ede3_cbcm_encrypt, DES_ede3_cfb64_encrypt, DES_ede3_ofb64_encrypt, DES_cbc_cksum, DES_quad_cksum, DES_string_to_key, DES_string_to_2keys, DES_fcrypt, DES_crypt, DES_enc_read, DES_enc_write - DES encryption
fr: DES_random_key, DES_set_key, DES_key_sched, DES_set_key_checked, DES_set_key_unchecked, DES_set_odd_parity, DES_is_weak_key, DES_ecb_encrypt, DES_ecb2_encrypt, DES_ecb3_encrypt, DES_ncbc_encrypt, DES_cfb_encrypt, DES_ofb_encrypt, DES_pcbc_encrypt, DES_cfb64_encrypt, DES_ofb64_encrypt, DES_xcbc_encrypt, DES_ede2_cbc_encrypt, DES_ede2_cfb64_encrypt, DES_ede2_ofb64_encrypt, DES_ede3_cbc_encrypt, DES_ede3_cbcm_encrypt, DES_ede3_cfb64_encrypt, DES_ede3_ofb64_encrypt, DES_cbc_cksum, DES_quad_cksum, DES_string_to_key, DES_string_to_2keys, DES_fcrypt, DES_crypt, DES_enc_read, DES_enc_write - Chiffrement DES

note: type: textblock
en: This library contains a fast implementation of the DES encryption algorithm.
fr: Cette bibliothèque contient une implémentation rapide de l'algorithme de chiffrement DES.

note: type: textblock
en: There are two phases to the use of DES encryption.  The first is the generation of a I<DES_key_schedule> from a key, the second is the actual encryption.  A DES key is of type I<DES_cblock>. This type is consists of 8 bytes with odd parity.  The least significant bit in each byte is the parity bit.  The key schedule is an expanded form of the key; it is used to speed the encryption process.
fr: Il y a deux phases dans l'utilisation du chiffrement DES. La première consiste à générer un I<DES_key_schedule> à partir d'une clé, la seconde est le chiffrement réel. Une clé DES est du type I<DES_cblock>. Ce type consiste en 8 octets de parité impaire. Le bit de poids le plus faible dans chaque octet est le bit de parité. La préparation de clés « key schedule » est une forme étendue de la clé ; elle est utilisée pour accélérer le processus.

note: type: textblock
en: DES_random_key() generates a random key.  The PRNG must be seeded prior to using this function (see L<rand(3)|rand(3)>).  If the PRNG could not generate a secure key, 0 is returned.
fr: DES_random_key() génère une clé aléatoire. Le PRNG doit être initialisé avant d'utiliser cette fonction (voir L<rand(3)|rand(3)>). Si le PRNG n'a pu générer une clé sécurisée, le code de retour est 0.

note: type: textblock
en: Before a DES key can be used, it must be converted into the architecture dependent I<DES_key_schedule> via the DES_set_key_checked() or DES_set_key_unchecked() function.
fr: Avant qu'une clé DES puisse être utilisée, elle doit être convertie en une I<DES_key_schedule> dépendant de l’architecture à l’aide de la fonction DES_set_key_checked() ou DES_set_key_unchecked().

note: type: textblock
en: DES_set_key_checked() will check that the key passed is of odd parity and is not a week or semi-weak key.  If the parity is wrong, then -1 is returned.  If the key is a weak key, then -2 is returned.  If an error is returned, the key schedule is not generated.
fr: DES_set_key_checked() vérifiera que la clé est de parité impaire et n'est pas une clé faible ou partiellement faible. Si la parité est mauvaise, alors -1 sera renvoyé. Si la clé est faible, alors -2 sera renvoyé. Si une erreur est renvoyée, alors la préparation de clés ne sera pas faite.

note: type: textblock
en: DES_set_key() works like DES_set_key_checked() if the I<DES_check_key> flag is non-zero, otherwise like DES_set_key_unchecked().  These functions are available for compatibility; it is recommended to use a function that does not depend on a global variable.
fr: DES_set_key() fonctionne comme DES_set_key_checked() si le drapeau I<DES_check_key> n'est pas 0, sinon elle fonctionne comme DES_set_key_unchecked(). Ces fonctions sont disponibles pour la compatibilité ; il est recommandé d'utiliser une fonction qui ne dépend pas d'une variable globale.

note: type: textblock
en: DES_set_odd_parity() sets the parity of the passed I<key> to odd.
fr: DES_set_odd_parity() change la parité de I<key> à impaire.

note: type: textblock
en: DES_is_weak_key() returns 1 if the passed key is a weak key, 0 if it is ok.
fr: DES_is_weak_key() renvoie 1 si la clé passée est faible, 0 si elle est forte.

note: type: textblock
en: The following routines mostly operate on an input and output stream of I<DES_cblock>s.
fr: Les routines suivantes opèrent sur un flux d'entrée ou de sortie des I<DES_cblock>.

note: type: textblock
en: DES_ecb_encrypt() is the basic DES encryption routine that encrypts or decrypts a single 8-byte I<DES_cblock> in I<electronic code book> (ECB) mode.  It always transforms the input data, pointed to by I<input>, into the output data, pointed to by the I<output> argument.  If the I<encrypt> argument is non-zero (DES_ENCRYPT), the I<input> (cleartext) is encrypted in to the I<output> (ciphertext) using the key_schedule specified by the I<schedule> argument, previously set via I<DES_set_key>. If I<encrypt> is zero (DES_DECRYPT), the I<input> (now ciphertext) is decrypted into the I<output> (now cleartext).  Input and output may overlap.  DES_ecb_encrypt() does not return a value.
fr: DES_ecb_encrypt() est la routine DES de base qui chiffre ou déchiffre séparément des I<DES_cblock> de 8 octets dans le mode I<electronic code book> (ECB). Elle transforme toujours les données d’entrée, pointées par I<input>, dans les données de sortie, pointées par l'argument I<output>. Si l'argument I<encrypt> est différent de 0 (DES_ENCRYPT), I<input> (texte clair) est chiffré dans I<output> (texte chiffré) en utilisant le key_schedule spécifié par l'argument I<schedule>, préalablement initialisé par I<DES_set_key>. Si I<encrypt> est 0 (DES_DECRYPT), I<input> (maintenant texte chiffré) est déchiffré dans I<output> (maintenant texte clair). L'entrée et la sortie peuvent se recouvrir. DES_ecb_encrypt() ne renvoie pas de valeur.

note: type: textblock
en: DES_ecb3_encrypt() encrypts/decrypts the I<input> block by using three-key Triple-DES encryption in ECB mode.  This involves encrypting the input with I<ks1>, decrypting with the key schedule I<ks2>, and then encrypting with I<ks3>.  This routine greatly reduces the chances of brute force breaking of DES and has the advantage of if I<ks1>, I<ks2> and I<ks3> are the same, it is equivalent to just encryption using ECB mode and I<ks1> as the key.
fr: DES_ecb3_encrypt() chiffre ou déchiffre le bloc I<input> en utilisant un chiffrement Triple-DES à trois clés dans le mode ECB. Cela implique de chiffrer l'entrée avec I<ks1>, de déchiffrer avec I<ks2> et ensuite de chiffrer avec I<ks3>. Cette routine réduit grandement les risques de cassede DES par force brute et elle a l’avantage que si I<ks1>, I<ks2> et I<ks3> sont les mêmes, cela est équivalent au mode de chiffrement ECB avec I<ks1> comme clé.

note: type: textblock
en: The macro DES_ecb2_encrypt() is provided to perform two-key Triple-DES encryption by using I<ks1> for the final encryption.
fr: La macro DES_ecb2_encrypt() permet d'exécuter un chiffrement Triple-DES à deux clés à l'aide de I<ks1> pour le chiffrement final.

note: type: textblock
en: DES_ncbc_encrypt() encrypts/decrypts using the I<cipher-block-chaining> (CBC) mode of DES.  If the I<encrypt> argument is non-zero, the routine cipher-block-chain encrypts the cleartext data pointed to by the I<input> argument into the ciphertext pointed to by the I<output> argument, using the key schedule provided by the I<schedule> argument, and initialization vector provided by the I<ivec> argument.  If the I<length> argument is not an integral multiple of eight bytes, the last block is copied to a temporary area and zero filled.  The output is always an integral multiple of eight bytes.
fr: DES_ncbc_encrypt() chiffre ou déchiffre en utilisant le mode I<cipher-block-chaining> (CBC) de DES. Si l'argument I<encrypt> est différent de 0, la routine CBC chiffre les données pointées par l'argument I<input> dans le texte chiffré pointé par l'argument I<output>, en utilisant la préparation des clés fournie par l'argument I<schedule> et le vecteur d'initialisation fourni par l'argument I<ivec>. Si la longueur I<length> de l'argument n'est pas un entier multiple de 8 octets, le dernier bloc est copié dans une zone temporaire et rempli de 0. La sortie est toujours un entier multiple de 8 octets.

note: type: textblock
en: DES_xcbc_encrypt() is RSA's DESX mode of DES.  It uses I<inw> and I<outw> to 'whiten' the encryption.  I<inw> and I<outw> are secret (unlike the iv) and are as such, part of the key.  So the key is sort of 24 bytes.  This is much better than CBC DES.
fr: DES_xcbc_encrypt() est le mode DESX de RSA de DES. Elle utilise I<inw> et I<outw> pour durcir le chiffrement. I<inw> et I<outw> sont secrets (à l'opposé de iv) et font, de ce fait, partie de la clé. Donc, la clé est une sorte de clé de 24 octets. Cela est bien mieux que CBC DES.

note: type: textblock
en: DES_ede3_cbc_encrypt() implements outer triple CBC DES encryption with three keys. This means that each DES operation inside the CBC mode is an C<C=E(ks3,D(ks2,E(ks1,M)))>.  This mode is used by SSL.
fr: DES_ede3_cbc_encrypt() implémente le chiffrement CBC DES triple externe avec trois clés. Cela veut dire que chaque opération DES à l'intérieur du mode CBC est un C<C=E(ks3,D(ks2,E(ks1,M)))>. Ce mode est utilisé par SSL.

note: type: textblock
en: The DES_ede2_cbc_encrypt() macro implements two-key Triple-DES by reusing I<ks1> for the final encryption.  C<C=E(ks1,D(ks2,E(ks1,M)))>.  This form of Triple-DES is used by the RSAREF library.
fr: La macro DES_ede2_cbc_encrypt() implémente Triple-DES avec deux clés en réutilisant I<ks1> pour le chiffrement final C<C=E(ks1,D(ks2,E(ks1,M)))> Cette forme de Triple-DES est utilisée par la bibliothèque RSAREF.

note: type: textblock
en: DES_pcbc_encrypt() encrypt/decrypts using the propagating cipher block chaining mode used by Kerberos v4. Its parameters are the same as DES_ncbc_encrypt().
fr: DES_pcbc_encrypt() chiffre ou déchiffre en utilisant le mode de propagation CBC utilisé par Kerberos v4. Ses paramètres sont identiques à DES_ncbc_encrypt().

note: type: textblock
en: DES_cfb_encrypt() encrypt/decrypts using cipher feedback mode.  This method takes an array of characters as input and outputs and array of characters.  It does not require any padding to 8 character groups.  Note: the I<ivec> variable is changed and the new changed value needs to be passed to the next call to this function.  Since this function runs a complete DES ECB encryption per I<numbits>, this function is only suggested for use when sending small numbers of characters.
fr: DES_cfb_encrypt() chiffre ou déchiffre en utilisant un mode de chiffrement à rétroaction. Cette méthode prend un tableau de caractères comme entrée et produit un tableau de caractères. Elle ne nécessite pas de formatage pour les groupes de 8 caractères. Note : la variable I<ivec> est modifiée et la nouvelle valeur à besoin d'être passée au prochain appel de cette fonction. Comme cette fonction utilise un chiffrement DES ECB complet par I<numbits>, cette fonction est suggérée uniquement lors de l'envoi de petits nombres de caractères.

note: type: textblock
en: DES_cfb64_encrypt()  implements CFB mode of DES with 64bit feedback.  Why is this useful you ask? Because this routine will allow you to encrypt an arbitrary number of bytes, no 8 byte padding.  Each call to this routine will encrypt the input bytes to output and then update ivec and num.  num contains 'how far' we are though ivec.  If this does not make much sense, read more about cfb mode of DES :-).
fr: DES_cfb64_encrypt() implémente le mode CFB de DES avec une rétroaction de 64 bits. Pourquoi est-ce que cela est utile dites-vous ? Parce que cette routine autorise à chiffrer un nombre arbitraire d'octets, sans formatage à 8 octets. Chaque appel à cette routine chiffrera les octets d'entrée vers la sortie puis mettra à jour ivec et num. num contient « la distance » par rapport à ivec. Si cela n'a aucun sens, référez-vous à la documentation du mode CFB de DES :-).

note: type: textblock
en: DES_ede3_cfb64_encrypt() and DES_ede2_cfb64_encrypt() is the same as DES_cfb64_encrypt() except that Triple-DES is used.
fr: DES_ede3_cfb64_encrypt() et DES_ede2_cfb64_encrypt() sont identiques à DES_cfb64_encrypt() sauf que Triple-DES est utilisé.

note: type: textblock
en: DES_ofb_encrypt() encrypts using output feedback mode.  This method takes an array of characters as input and outputs and array of characters.  It does not require any padding to 8 character groups.  Note: the I<ivec> variable is changed and the new changed value needs to be passed to the next call to this function.  Since this function runs a complete DES ECB encryption per numbits, this function is only suggested for use when sending small numbers of characters.
fr: DES_ofb_encrypt() chiffre en utilisant le mode de chiffrement à rétroaction. Cette méthode prend un tableau de caractères comme entrée et produit un tableau de caractères. Elle ne nécessite pas de formatage pour les groupes de 8 caractères. Note : la variable I<ivec> est modifiée et la nouvelle valeur a besoin d'être passée au prochain appel de cette fonction. Comme cette fonction utilise un chiffrement DES ECB complet par I<numbits>, cette fonction est suggérée uniquement lors de l'envoi de petits nombres de caractères.

note: type: textblock
en: DES_ofb64_encrypt() is the same as DES_cfb64_encrypt() using Output Feed Back mode.
fr: DES_ofb64_encrypt() est identique à DES_cfb64_encrypt() en utilisant le mode de chiffrement à rétroaction de sortie.

note: type: textblock
en: DES_ede3_ofb64_encrypt() and DES_ede2_ofb64_encrypt() is the same as DES_ofb64_encrypt(), using Triple-DES.
fr: DES_ede3_ofb64_encrypt() et DES_ede2_ofb64_encrypt() sont identiques à DES_ofb64_encrypt(), en utilisant Triple-DES.

note: type: textblock
en: The following functions are included in the DES library for compatibility with the MIT Kerberos library.
fr: Les instructions suivantes sont incluses dans la bibliothèque DES pour compatibilité avec la bibliothèque Kerberos du MIT.

note: type: textblock
en: DES_cbc_cksum() produces an 8 byte checksum based on the input stream (via CBC encryption).  The last 4 bytes of the checksum are returned and the complete 8 bytes are placed in I<output>. This function is used by Kerberos v4.  Other applications should use L<EVP_DigestInit(3)|EVP_DigestInit(3)> etc. instead.
fr: DES_cbc_cksum() produit une empreinte de 8 octets en se basant sur le flux d'entrée (avec un chiffrement CBC). Les 4 derniers octets de l'empreinte sont renvoyés et les 8 octets totaux sont placés dans I<output>. Cette fonction est utilisée par Kerberos v4. Les autres applications devraient à la place utiliser L<EVP_DigestInit(3)|EVP_DigestInit(3)>, etc.

note: type: textblock
en: DES_quad_cksum() is a Kerberos v4 function.  It returns a 4 byte checksum from the input bytes.  The algorithm can be iterated over the input, depending on I<out_count>, 1, 2, 3 or 4 times.  If I<output> is non-NULL, the 8 bytes generated by each pass are written into I<output>.
fr: DES_quad_cksum() est une fonction de Kerberos v4. Elle renvoie une empreinte de 4 octets à partir des octets d'entrée. Il est possible d'itérer sur l’entrée, selon I<out_count>, 1, 2, 3 ou 4 fois. Si I<output> n'est pas NULL, les 8 octets générés par chaque passage sont écrits dans I<output>.

note: type: textblock
en: The following are DES-based transformations:
fr: Les transformations suivantes sont basées sur DES :

note: type: textblock
en: DES_fcrypt() is a fast version of the Unix crypt(3) function.  This version takes only a small amount of space relative to other fast crypt() implementations.  This is different to the normal crypt in that the third parameter is the buffer that the return value is written into.  It needs to be at least 14 bytes long.  This function is thread safe, unlike the normal crypt.
fr: DES_fcrypt() est une version plus rapide de la fonction Unix crypt(3). Cette version n’utilise qu'une petite quantité d'espace par rapport aux autres implémentations crypt() rapides. Cela est différent du crypt normal dans le fait que le troisième paramètre est le tampon dans lequel la valeur de retour est écrite. Elle a besoin d'avoir au moins 14 octets de long. Cette fonction est à fil sécurisé (« thread-safe ») contrairement à la fonction crypt normale.

note: type: textblock
en: DES_crypt() is a faster replacement for the normal system crypt().  This function calls DES_fcrypt() with a static array passed as the third parameter.  This emulates the normal non-thread safe semantics of crypt(3).
fr: DES_crypt() est un remplacement plus rapide pour le système normal crypt(). Cette fonction appelle DES_fcrypt() avec un tableau statique passé comme troisième paramètre. Cela émule les sémantiques normales, pour les fils non sécurisés, de crypt(3).

note: type: textblock
en: DES_enc_write() writes I<len> bytes to file descriptor I<fd> from buffer I<buf>. The data is encrypted via I<pcbc_encrypt> (default)  using I<sched> for the key and I<iv> as a starting vector.  The actual data send down I<fd> consists of 4 bytes (in network byte order)  containing the length of the following encrypted data.  The encrypted data then follows, padded with random data out to a multiple of 8 bytes.
fr: DES_enc_write() écrit I<len> octets dans un descripteur de fichier I<fd> provenant du tampon I<buf>. Les données sont chiffrées à l’aide de I<pcbc_encrypt> (par défaut) utilisant I<sched> comme clé et I<iv> comme vecteur de début. Les données envoyées à I<fd> consistent en 4 octets (en ordre d'octets du réseau) contenant la longueur des données chiffrées suivantes. Les données chiffrées suivent, formatées avec des données aléatoires basées sur un multiple de 8 octets.

note: type: textblock
en: DES_enc_read() is used to read I<len> bytes from file descriptor I<fd> into buffer I<buf>. The data being read from I<fd> is assumed to have come from DES_enc_write() and is decrypted using I<sched> for the key schedule and I<iv> for the initial vector.
fr: DES_enc_read() est utilisé pour lire I<len> octets d'un descripteur de fichier I<fd> dans un tampon I<buf>. On suppose que les données lues dans I<fd> proviennent de DES_enc_write() et sont déchiffrées en utilisant I<sched> comme préparation de clés et I<iv> comme vecteur initial.

note: type: textblock
en: B<Warning:> The data format used by DES_enc_write() and DES_enc_read()  has a cryptographic weakness: When asked to write more than MAXWRITE bytes, DES_enc_write() will split the data into several chunks that are all encrypted using the same IV.  So don't use these functions unless you are sure you know what you do (in which case you might not want to use them anyway).  They cannot handle non-blocking sockets.  DES_enc_read() uses an internal state and thus cannot be used on multiple files.
fr: B<Attention :> Le format des données utilisées par DES_enc_write() et DES_enc_read() a une faiblesse cryptographique : lorsqu'il y a une demande d'écriture de plus de MAXWRITE octets, DES_enc_write() découpera les données en plusieurs morceaux qui utilisent tous le même IV (vecteur d’initialisation). N'utilisez donc pas ces fonctions sauf si vous êtes sûr de savoir ce que vous faites (et même dans ce cas il n'est pas recommandé de s'en servir). Elles ne peuvent pas gérer les sockets non bloquantes. DES_enc_read() utilise un état interne, et de ce fait ne peut être utilisé sur de multiples fichiers.

note: type: textblock
en: I<DES_rw_mode> is used to specify the encryption mode to use with DES_enc_read() and DES_end_write().  If set to I<DES_PCBC_MODE> (the default), DES_pcbc_encrypt is used.  If set to I<DES_CBC_MODE> DES_cbc_encrypt is used.
fr: I<DES_rw_mode> est utilisé pour spécifier le mode de chiffrement à utiliser avec DES_enc_read() et DES_end_write(). Si défini à I<DES_PCBC_MODE> (mode par défaut), DES_pcbc_encrypt est utilisé. Si défini à I<DES_CBC_MODE> alors DES_cbc_encrypt est utilisé.

note: type: textblock
en: Single-key DES is insecure due to its short key size.  ECB mode is not suitable for most applications; see L<des_modes(7)|des_modes(7)>.
fr: DES avec une seule clé n'est pas sécurisé à cause de la taille de la clé qui est trop courte. Le mode ECB n'est pas approprié pour la plupart des applications ; voir L<des_modes(7)|des_modes(7)>.

note: type: textblock
en: The L<evp(3)|evp(3)> library provides higher-level encryption functions.
fr: La bibliothèque L<evp(3)|evp(3)> fournit des fonctions de chiffrement de plus haut niveau.

note: type: textblock
en: DES_3cbc_encrypt() is flawed and must not be used in applications.
fr: DES_3cbc_encrypt() présente des défauts et ne doit pas être utilisée dans une application.

note: type: textblock
en: DES_cbc_encrypt() does not modify B<ivec>; use DES_ncbc_encrypt()  instead.
fr: DES_cbc_encrypt() ne modifie pas B<ivec> ; à la place utilisez DES_ncbc_encrypt().

note: type: textblock
en: DES_cfb_encrypt() and DES_ofb_encrypt() operates on input of 8 bits.  What this means is that if you set numbits to 12, and length to 2, the first 12 bits will come from the 1st input byte and the low half of the second input byte.  The second 12 bits will have the low 8 bits taken from the 3rd input byte and the top 4 bits taken from the 4th input byte.  The same holds for output.  This function has been implemented this way because most people will be using a multiple of 8 and because once you get into pulling bytes input bytes apart things get ugly!
fr: DES_cfb_encrypt() et DES_ofb_encrypt() opèrent sur une entrée de 8 bits. Cela veut dire que si vous mettez numbits à 12, et la longueur à 2, les premiers 12 bits viendront du premier octet d'entrée et la deuxième moitié du deuxième octet d’entrée. Les 12 bits de la deuxième moitié auront leurs 8 derniers bits pris du 3ème octet d’entrée et leurs 4 premiers bits pris du 4ème octet d'entrée. De même pour la sortie. Cette fonction a été implémentée de cette façon parce que la plupart des gens utilisent un multiple de 8 et parce que lorsque qu’il faut séparer récupération et envoi des octets, les choses deviennent délicates !

note: type: textblock
en: DES_string_to_key() is available for backward compatibility with the MIT library.  New applications should use a cryptographic hash function.  The same applies for DES_string_to_2key().
fr: DES_string_to_key() est disponible pour une compatibilité ascendante avec la bibliothèque du MIT. Les nouvelles applications devraient utiliser une fonction de hachage cryptographique. Il en va de même pour DES_string_to_2key().

note: type: =head1
en: CONFORMING TO
fr: MISE EN CONFORMITÉ

note: type: textblock
en: The B<des> library was written to be source code compatible with the MIT Kerberos library.
fr: La bibliothèque B<des> a été écrite pour être compatible d'un point de vue du code source avec la bibliothèque Kerberos du MIT.

note: type: textblock
en: In OpenSSL 0.9.7, all des_ functions were renamed to DES_ to avoid clashes with older versions of libdes.  Compatibility des_ functions are provided for a short while, as well as crypt().  Declarations for these are in <openssl/des_old.h>. There is no DES_ variant for des_random_seed().  This will happen to other functions as well if they are deemed redundant (des_random_seed() just calls RAND_seed() and is present for backward compatibility only), buggy or already scheduled for removal.
fr: Dans OpenSSL 0.9.7, toutes les fonctions des_ ont été renommées en DES_ pour éviter tous conflits avec les anciennes versions de libdes. La compatibilité des fonctions des_ est fournie pendant une courte période, il en va de même pour crypt(). Les déclarations pour celles-ci sont dans <openssl/des_old.h>. Il n'y a pas de variante DES_ pour des_random_seed(). La même chose se produira si d'autres fonctions sont jugées redondantes (des_random_seed() fait juste un appel à RAND_seed() et est uniquement présente pour raisons de compatibilité), boguées ou prévues d'être retirées.

note: type: textblock
en: des_cbc_cksum(), des_cbc_encrypt(), des_ecb_encrypt(), des_is_weak_key(), des_key_sched(), des_pcbc_encrypt(), des_quad_cksum(), des_random_key() and des_string_to_key()  are available in the MIT Kerberos library; des_check_key_parity(), des_fixup_key_parity() and des_is_weak_key()  are available in newer versions of that library.
fr: des_cbc_cksum(), des_cbc_encrypt(), des_ecb_encrypt(), des_is_weak_key(), des_key_sched(), des_pcbc_encrypt(), des_quad_cksum(), des_random_key() et des_string_to_key() sont disponibles dans la bibliothèque Kerberos du MIT ; des_check_key_parity(), des_fixup_key_parity() et des_is_weak_key() sont disponibles dans les versions plus récentes de cette bibliothèque.

note: type: textblock
en: des_set_key_checked() and des_set_key_unchecked() were added in OpenSSL 0.9.5.
fr: des_set_key_checked() et des_set_key_unchecked() ont été ajoutées dans OpenSSL 0.9.5.

note: type: textblock
en: des_generate_random_block(), des_init_random_number_generator(), des_new_random_key(), des_set_random_generator_seed() and des_set_sequence_number() and des_rand_data() are used in newer versions of Kerberos but are not implemented here.
fr: des_generate_random_block(), des_init_random_number_generator(), des_new_random_key(), des_set_random_generator_seed(), des_set_sequence_number() et des_rand_data() sont utilisées dans les versions plus récentes de Kerberos mais ne sont pas implémentées ici.

note: type: textblock
en: des_random_key() generated cryptographically weak random data in SSLeay and in OpenSSL prior version 0.9.5, as well as in the original MIT library.
fr: des_random_key() générait des données aléatoires cryptographiquement faibles dans SSLeay et dans OpenSSL avant la version 0.9.5, de même pour la bibliothèque MIT d'origine.

note: type: =head1
en: AUTHOR
fr: AUTEUR

note: type: textblock
en: Eric Young (eay@cryptsoft.com). Modified for the OpenSSL project (http://www.openssl.org).
fr: Eric Young (eay@cryptsoft.com). Modifications pour le projet OpenSSL (http://www.openssl.org).

note: type: textblock
en: des_modes - the variants of DES and other crypto algorithms of OpenSSL
fr: des_modes - Variantes de DES et autres algorithmes cryptographiques d'OpenSSL

note: type: textblock
en: Several crypto algorithms for OpenSSL can be used in a number of modes.  Those are used for using block ciphers in a way similar to stream ciphers, among other things.
fr: Plusieurs algorithmes cryptographiques d'OpenSSL peuvent être utilisés dans de nombreux modes. Ils permettent entre autres d'utiliser les chiffrements de bloc de la même façon que les chiffrements de flux.

note: type: =head2
en: Electronic Codebook Mode (ECB)
fr: Mode dictionnaire de codes (Electronic Code Book, ECB)

note: type: textblock
en: Normally, this is found as the function I<algorithm>_ecb_encrypt().
fr: Normalement disponible en tant que fonction I<algorithme>B<_ecb_encrypt>().

note: type: textblock
en: 64 bits are enciphered at a time.
fr: 64 bits sont chiffrés par opération.

note: type: textblock
en: The order of the blocks can be rearranged without detection.
fr: L'ordre des blocs peut être permuté sans détection.

note: type: textblock
en: The same plaintext block always produces the same ciphertext block (for the same key) making it vulnerable to a 'dictionary attack'.
fr: Deux blocs de même texte clair sont toujours chiffrés de la même manière (pour une même clef), rendant le mode vulnérable à une « attaque par dictionnaire ».

note: type: textblock
en: An error will only affect one ciphertext block.
fr: Une erreur n'affectera qu'un seul bloc de texte chiffré.

note: type: =head2
en: Cipher Block Chaining Mode (CBC)
fr: Mode enchaînement des blocs (Cipher Block Chaining, CBC)

note: type: textblock
en: Normally, this is found as the function I<algorithm>_cbc_encrypt().  Be aware that des_cbc_encrypt() is not really DES CBC (it does not update the IV); use des_ncbc_encrypt() instead.
fr: Normalement disponible en tant que fonction I<algorithme>B<_cbc_encrypt>(). Attention au fait que B<des_cbc_encrypt>() n'est pas vraiment CBC DES (il ne met pas à jour le vecteur d'initialisation). Utilisez plutôt B<des_ncbc_encrypt>().

note: type: textblock
en: a multiple of 64 bits are enciphered at a time.
fr: Un multiple de 64 bits est chiffré par opération.

note: type: textblock
en: The CBC mode produces the same ciphertext whenever the same plaintext is encrypted using the same key and starting variable.
fr: Le mode CBC produit le même texte chiffré à chaque fois que le même texte clair est chiffré avec la même clef et le même vecteur d'initialisation.

note: type: textblock
en: The chaining operation makes the ciphertext blocks dependent on the current and all preceding plaintext blocks and therefore blocks can not be rearranged.
fr: L'opération de chaînage rend les blocs de texte chiffré dépendants du bloc de texte clair en cours et de tous les précédents, et par conséquent les blocs ne peuvent pas être permutés.

note: type: textblock
en: The use of different starting variables prevents the same plaintext enciphering to the same ciphertext.
fr: L'utilisation de différents vecteurs d'initialisation empêche le même texte clair de produire le même texte chiffré.

note: type: textblock
en: An error will affect the current and the following ciphertext blocks.
fr: Une erreur affectera le bloc de texte chiffré en cours et tous les suivants.

note: type: =head2
en: Cipher Feedback Mode (CFB)
fr: Mode chiffrement à rétroaction (Cipher Feedback, CFB)

note: type: textblock
en: Normally, this is found as the function I<algorithm>_cfb_encrypt().
fr: Normalement disponible en tant que fonction I<algorithme>B<_cfb_encrypt>().

note: type: textblock
en: a number of bits (j) <= 64 are enciphered at a time.
fr: Un nombre de bits (j) inférieur ou égal à 64 est chiffré par opération.

note: type: textblock
en: The CFB mode produces the same ciphertext whenever the same plaintext is encrypted using the same key and starting variable.
fr: Le mode CFB produit le même texte chiffré à chaque fois que le même texte clair est chiffré avec la même clef et le même vecteur d'initialisation.

note: type: textblock
en: The chaining operation makes the ciphertext variables dependent on the current and all preceding variables and therefore j-bit variables are chained together and can not be rearranged.
fr: L'opération de chaînage rend les variables du texte chiffré dépendantes des variables du texte clair en cours et de toutes les précédentes, et par conséquent les variables de j bits sont chaînées et ne peuvent pas être permutées.

note: type: textblock
en: The strength of the CFB mode depends on the size of k (maximal if j == k).  In my implementation this is always the case.
fr: La force du mode CFB dépend de la taille de k (maximale si j == k). Dans cette implémentation, c'est toujours le cas.

note: type: textblock
en: Selection of a small value for j will require more cycles through the encipherment algorithm per unit of plaintext and thus cause greater processing overheads.
fr: Le choix d'une petite valeur pour j nécessitera plus de cycles d'algorithme de chiffrement par unité de texte clair, et entraînera donc un coût de traitement plus important.

note: type: textblock
en: Only multiples of j bits can be enciphered.
fr: Seuls des multiples de j bits peuvent être chiffrés.

note: type: textblock
en: An error will affect the current and the following ciphertext variables.
fr: Une erreur affectera la variable de texte chiffré en cours et toutes les suivantes.

note: type: =head2
en: Output Feedback Mode (OFB)
fr: Mode chiffrement à rétroaction de sortie (Output Feedback, OFB)

note: type: textblock
en: Normally, this is found as the function I<algorithm>_ofb_encrypt().
fr: Normalement disponible en tant que fonction I<algorithme>B<_ofb_encrypt>().

note: type: textblock
en: The OFB mode produces the same ciphertext whenever the same plaintext enciphered using the same key and starting variable.  More over, in the OFB mode the same key stream is produced when the same key and start variable are used.  Consequently, for security reasons a specific start variable should be used only once for a given key.
fr: Le mode OFB produit le même texte chiffré à chaque fois que le même texte clair est chiffré avec la même clef et le même vecteur d'initialisation. De plus, en mode OFB, le même flux de clef est produit quand la même clef et le même vecteur d'initialisation sont utilisés. Par conséquent, pour des raisons de sécurité, un vecteur d'initialisation particulier ne devrait être utilisé qu'une seule fois pour une clef donnée.

note: type: textblock
en: The absence of chaining makes the OFB more vulnerable to specific attacks.
fr: L'absence de chaînage rend le mode OFB plus vulnérable à certaines attaques.

note: type: textblock
en: The use of different start variables values prevents the same plaintext enciphering to the same ciphertext, by producing different key streams.
fr: L'utilisation de différentes valeurs du vecteur d'initialisation empêche le même texte clair de produire le même texte chiffré, en produisant différents flux de clefs.

note: type: textblock
en: OFB mode of operation does not extend ciphertext errors in the resultant plaintext output.  Every bit error in the ciphertext causes only one bit to be in error in the deciphered plaintext.
fr: Le mode d'opération OFB n'étend pas les erreurs de texte chiffré dans la sortie en texte clair correspondante. Toutes les erreurs d'un bit dans le texte clair ne provoquent qu'un bit d'erreur dans le texte clair déchiffré.

note: type: textblock
en: OFB mode is not self-synchronizing.  If the two operation of encipherment and decipherment get out of synchronism, the system needs to be re-initialized.
fr: Le mode OFB n'est pas autosynchrone. Si les deux opérations de chiffrement et déchiffrement se désynchronisent, le système doit être réinitialisé.

note: type: textblock
en: Each re-initialization should use a value of the start variable different from the start variable values used before with the same key.  The reason for this is that an identical bit stream would be produced each time from the same parameters.  This would be susceptible to a 'known plaintext' attack.
fr: Chaque réinitialisation devrait utiliser une valeur de vecteur d'initialisation différente des valeurs de vecteur d'initialisation utilisées auparavant avec la même clef. Dans le cas contraire, un flux de bits identique serait produit à chaque fois à partir des mêmes paramètres. Cela le rendrait fragile vis-à-vis d'une « attaque à texte clair connu ».

note: type: =head2
en: Triple ECB Mode
fr: Mode Triple ECB

note: type: textblock
en: Normally, this is found as the function I<algorithm>_ecb3_encrypt().
fr: Normalement disponible en tant que fonction I<algorithme>B<_ecb3_encrypt>().

note: type: textblock
en: Encrypt with key1, decrypt with key2 and encrypt with key3 again.
fr: Chiffrer avec clef1, déchiffrer avec clef2 et chiffrer de nouveau avec clef3.

note: type: textblock
en: As for ECB encryption but increases the key length to 168 bits.  There are theoretic attacks that can be used that make the effective key length 112 bits, but this attack also requires 2^56 blocks of memory, not very likely, even for the NSA.
fr: Comme pour le chiffrement ECB, mais augmente la taille de clef à 168 bits. Des attaques théoriques existent qui réduisent la longueur de clef effective à 112 bits, mais cette attaque nécessite aussi 2^56 blocs de mémoire, ce qui est peu probable, même pour la NSA.

note: type: textblock
en: If both keys are the same it is equivalent to encrypting once with just one key.
fr: Si deux clefs sont identiques, cela est équivalent à ne chiffrer qu'une fois avec une seule clef.

note: type: textblock
en: If the first and last key are the same, the key length is 112 bits.  There are attacks that could reduce the effective key strength to only slightly more than 56 bits, but these require a lot of memory.
fr: Si les première et dernière clefs sont identiques, la longueur de clef est de 112 bits. Des attaques permettent de réduire la force de clef effective à juste un peu plus de 56 bits, mais cela nécessite beaucoup de mémoire.

note: type: textblock
en: If all 3 keys are the same, this is effectively the same as normal ecb mode.
fr: Si les trois clefs sont les mêmes, c'est effectivement identique au mode ECB normal.

note: type: =head2
en: Triple CBC Mode
fr: Mode Triple CBC

note: type: textblock
en: Normally, this is found as the function I<algorithm>_ede3_cbc_encrypt().
fr: Normalement disponible en tant que fonction I<algorithme>B<_ede3_cbc_encrypt>().

note: type: textblock
en: Encrypt with key1, decrypt with key2 and then encrypt with key3.
fr: Chiffrer avec clef1, déchiffrer avec clef2 et ensuite chiffrer avec clef3.

note: type: textblock
en: As for CBC encryption but increases the key length to 168 bits with the same restrictions as for triple ecb mode.
fr: Comme pour le chiffrement CBC, mais augmente la taille de clef à 168 bits avec les mêmes restrictions que pour le mode triple ECB.

note: type: textblock
en: This text was been written in large parts by Eric Young in his original documentation for SSLeay, the predecessor of OpenSSL.  In turn, he attributed it to:
fr: Ce texte a été écrit en grande partie par Eric Young dans sa documentation d'origine pour SSLeay, le prédécesseur d'OpenSSL. À son tour, il l'a attribué à :

note: type: textblock
en: engine - ENGINE cryptographic module support
fr: moteur - ENGINE module de support cryptographique

note: type: textblock
en: These functions create, manipulate, and use cryptographic modules in the form of B<ENGINE> objects. These objects act as containers for implementations of cryptographic algorithms, and support a reference-counted mechanism to allow them to be dynamically loaded in and out of the running application.
fr: Ces fonctions créent, manipulent et utilisent des modules cryptographiques sous la forme d'objets B<ENGINE>. Ces objets servent de conteneurs pour les implémentations d'algorithmes cryptographiques, et ils gèrent un mécanisme de comptage de référence qui les autorisent à être chargés de façon dynamique dans l'application exécutée et en dehors.

note: type: textblock
en: The cryptographic functionality that can be provided by an B<ENGINE> implementation includes the following abstractions;
fr: La fonctionnalité cryptographique qui peut être fournie par l'implémentation d'un B<ENGINE> inclut les abstractions suivantes :

note: type: verbatim
en:  RSA_METHOD - for providing alternative RSA implementations
     DSA_METHOD, DH_METHOD, RAND_METHOD, ECDH_METHOD, ECDSA_METHOD,
           STORE_METHOD - similarly for other OpenSSL APIs
     EVP_CIPHER - potentially multiple cipher algorithms (indexed by 'nid')
     EVP_DIGEST - potentially multiple hash algorithms (indexed by 'nid')
     key-loading - loading public and/or private EVP_PKEY keys
fr:  RSA_METHOD - pour fournir une implémentation RSA alternative
     DSA_METHOD, DH_METHOD, RAND_METHOD, ECDH_METHOD, ECDSA_METHOD,
           STORE_METHOD - identique pour d'autres API d'OpenSSL
     EVP_CIPHER - potentiellement plusieurs algorithmes de chiffrement (indexé par 'nid')
     EVP_DIGEST - potentiellement plusieurs algorithmes de hachage (indexé par 'nid')
     key-loading - chargement des clés EVP_PKEY publiques/privées

note: type: =head2
en: Reference counting and handles
fr: Référence de calculs et traitements

note: type: textblock
en: Due to the modular nature of the ENGINE API, pointers to ENGINEs need to be treated as handles - ie. not only as pointers, but also as references to the underlying ENGINE object. Ie. one should obtain a new reference when making copies of an ENGINE pointer if the copies will be used (and released) independently.
fr: À cause de la nature modulaire de l'API ENGINE, les pointeurs vers les ENGINE doivent être traités comme des références abstraites vers des ressources — c'est-à-dire pas seulement comme des pointeurs, mais aussi comme des références vers l'objet ENGINE sous-jacent. C'est-à-dire que l'on doit obtenir une nouvelle référence lors de la copie d'un pointeur vers un ENGINE si la copie doit être utilisée (et libérée) de façon indépendante.

note: type: textblock
en: ENGINE objects have two levels of reference-counting to match the way in which the objects are used. At the most basic level, each ENGINE pointer is inherently a B<structural> reference - a structural reference is required to use the pointer value at all, as this kind of reference is a guarantee that the structure can not be deallocated until the reference is released.
fr: Les objets ENGINE ont deux niveaux de comptage de références pour correspondre à la façon dont les objets sont utilisés. À plus bas niveau, chaque pointeur ENGINE est intrinsèquement une référence B<structurelle> - une référence structurelle est nécessaire pour utiliser toute valeur de pointeur, car ce type de référence garantit que la structure ne peut pas être désallouée avant que sa référence ne soit libérée.

note: type: textblock
en: However, a structural reference provides no guarantee that the ENGINE is initiliased and able to use any of its cryptographic implementations. Indeed it's quite possible that most ENGINEs will not initialise at all in typical environments, as ENGINEs are typically used to support specialised hardware. To use an ENGINE's functionality, you need a B<functional> reference. This kind of reference can be considered a specialised form of structural reference, because each functional reference implicitly contains a structural reference as well - however to avoid difficult-to-find programming bugs, it is recommended to treat the two kinds of reference independently. If you have a functional reference to an ENGINE, you have a guarantee that the ENGINE has been initialised ready to perform cryptographic operations and will remain uninitialised until after you have released your reference.
fr: Mais, une référence structurelle n'offre aucune garantie que l'ENGINE soit initialisé et capable d'utiliser n'importe laquelle de ses implémentations cryptographiques. En effet, il est fort probable que la plupart des ENGINE ne puissent pas s'initialiser dans des environnements typiques, car les ENGINES sont généralement utilisés pour gérer du matériel spécialisé. Pour utiliser une fonctionnalité d'ENGINE, il est nécessaire d'avoir une référence B<fonctionnelle>. Cette référence peut être considérée comme une forme spécialisée de référence structurelle, car chaque référence fonctionnelle contient de façon implicite une référence structurelle. Par contre, pour éviter d'avoir des programmes durs à déboguer, il est recommandé de traiter ces deux types de référence indépendamment l'une de l'autre. Si une référence fonctionnelle est disponible pour un ENGINE, il est garanti que cet ENGINE a été initialisé et est prêt à faire des opérations cryptographiques et restera non-initialisable jusqu’à la libération de la référence.

note: type: textblock
en: This basic type of reference is used for instantiating new ENGINEs, iterating across OpenSSL's internal linked-list of loaded ENGINEs, reading information about an ENGINE, etc. Essentially a structural reference is sufficient if you only need to query or manipulate the data of an ENGINE implementation rather than use its functionality.
fr: Ce type de référence de base est utilisé pour instancier de nouveaux ENGINE, itérer sur les listes liées d'ENGINE chargés d'OpenSSL, lire les informations d'un ENGINE, etc. Une référence structurelle est essentiellement suffisante pour des requêtes ou pour manipuler les données d'implémentation d'un ENGINE au lieu d'utiliser ses fonctionnalités.

note: type: textblock
en: The ENGINE_new() function returns a structural reference to a new (empty)  ENGINE object. There are other ENGINE API functions that return structural references such as; ENGINE_by_id(), ENGINE_get_first(), ENGINE_get_last(), ENGINE_get_next(), ENGINE_get_prev(). All structural references should be released by a corresponding to call to the ENGINE_free() function - the ENGINE object itself will only actually be cleaned up and deallocated when the last structural reference is released.
fr: La fonction ENGINE_new() renvoie une référence structurelle vers un objet ENGINE vide. Il y a d'autres fonctions d'API dans ENGINE qui renvoient une référence structurelle comme : ENGINE_by_id(), ENGINE_get_first(), ENGINE_get_last(), ENGINE_get_next(), ENGINE_get_prev(). Toute référence structurelle devrait être libérée par un appel correspondant à la fonction ENGINE_free() — l'objet ENGINE lui-même ne sera nettoyé et désalloué que lorsque la dernière référence structurelle sera libérée.

note: type: textblock
en: It should also be noted that many ENGINE API function calls that accept a structural reference will internally obtain another reference - typically this happens whenever the supplied ENGINE will be needed by OpenSSL after the function has returned. Eg. the function to add a new ENGINE to OpenSSL's internal list is ENGINE_add() - if this function returns success, then OpenSSL will have stored a new structural reference internally so the caller is still responsible for freeing their own reference with ENGINE_free() when they are finished with it. In a similar way, some functions will automatically release the structural reference passed to it if part of the function's job is to do so. Eg. the ENGINE_get_next() and ENGINE_get_prev() functions are used for iterating across the internal ENGINE list - they will return a new structural reference to the next (or previous) ENGINE in the list or NULL if at the end (or beginning) of the list, but in either case the structural reference passed to the function is released on behalf of the caller.
fr: On doit aussi remarquer que beaucoup d'appels de fonctions d'API d'ENGINE qui acceptent une référence structurelle obtiendront de façon interne une autre référence — en général cela ce produira lorsque l'ENGINE sera nécessaire à OpenSSL après le retour de la fonction. Exemple : la fonction d'ajout d'un nouvel ENGINE à la liste interne d'OpenSSL est B<ENGINE_add>() — si cette actionse termine avec succès, alors OpenSSL aura stocké une nouvelle référence structurelle en interne, aussi l'appelant est toujours responsable de la libération de ses propres références avec ENGINE_free() quand les fonctions n'en ont plus besoin. D'une façon similaire, certaines fonctions libéreront automatiquement la référence structurelle qui leur est donnée si une partie du travail de la fonction est de faire cela. Exemple : les fonctions B<ENGINE_get_next>() et B<ENGINE_get_prev>() sont utilisées pour itérer à travers la liste interne d'ENGINE — elles renverront une nouvelle référence structurelle au prochain (ou précédent) ENGINE dans la liste ou NULL si elles sont à la fin (ou au début) de la liste, mais, dans tous les cas, la référence structurelle passée à la fonction est libérée au nom de l'appelant.

note: type: textblock
en: To clarify a particular function's handling of references, one should always consult that function's documentation "man" page, or failing that the openssl/engine.h header file includes some hints.
fr: Pour éclaircir la façon dont une fonction traite les références, on doit toujours consulter la documentation en utilisant la page man de cette fonction, ou à défaut l’en-tête openssl/engine.h qui contient des indices.

note: type: textblock
en: I<Functional references>
fr: I<Références fonctionnelles>

note: type: textblock
en: As mentioned, functional references exist when the cryptographic functionality of an ENGINE is required to be available. A functional reference can be obtained in one of two ways; from an existing structural reference to the required ENGINE, or by asking OpenSSL for the default operational ENGINE for a given cryptographic purpose.
fr: Comme mentionné, les références fonctionnelles existent lorsque la fonctionnalité cryptographique d'un ENGINE doit être disponible. Une référence fonctionnelle peut être obtenue de plusieurs façons : d'une référence structurelle pré-existante demandée par l'ENGINE, ou en demandant à l'ENGINE par défaut d'OpenSSL pour une tâche cryptographique donnée.

note: type: textblock
en: To obtain a functional reference from an existing structural reference, call the ENGINE_init() function. This returns zero if the ENGINE was not already operational and couldn't be successfully initialised (eg. lack of system drivers, no special hardware attached, etc), otherwise it will return non-zero to indicate that the ENGINE is now operational and will have allocated a new B<functional> reference to the ENGINE. All functional references are released by calling ENGINE_finish() (which removes the implicit structural reference as well).
fr: Pour obtenir une référence fonctionnelle à partir d'une référence structurelle, appelez la fonction ENGINE_init(). Cela renvoie 0 si l'ENGINE n'était pas déjà opérationnel et ne pouvait donc pas être initialisé (ex : le manque de pilotes dans le système, pas de matériel spécifique attaché, etc), sinon elle renverra autre chose que 0 pour indiquer que l'ENGINE est maintenant opérationnel et a alloué une référence B<fonctionnelle> à l'ENGINE. Toutes les références fonctionnelles sont libérées en appelant ENGINE_finish() (ce qui supprime les références structurelles implicites aussi).

note: type: textblock
en: The second way to get a functional reference is by asking OpenSSL for a default implementation for a given task, eg. by ENGINE_get_default_RSA(), ENGINE_get_default_cipher_engine(), etc. These are discussed in the next section, though they are not usually required by application programmers as they are used automatically when creating and using the relevant algorithm-specific types in OpenSSL, such as RSA, DSA, EVP_CIPHER_CTX, etc.
fr: La deuxième façon de récupérer des références fonctionnelles est de demander à OpenSSL une implémentation par défaut pour la tâche voulue, ex : avec ENGINE_get_default_RSA(), ENGINE_get_default_cipher_engine(), etc. Celles-ci sont expliquées dans la prochaine partie, mais elles ne sont d'habitude pas requises par les programmeurs d'application car elles sont utilisées automatiquement quand les spécificités de types de l'algorithme dans OpenSSL sont créées et utilisées, comme RSA, DSA, EVP_CIPHER_CTX, etc.

note: type: =head2
en: Default implementations
fr: Implémentations par défaut

note: type: textblock
en: For each supported abstraction, the ENGINE code maintains an internal table of state to control which implementations are available for a given abstraction and which should be used by default. These implementations are registered in the tables and indexed by an 'nid' value, because abstractions like EVP_CIPHER and EVP_DIGEST support many distinct algorithms and modes, and ENGINEs can support arbitrarily many of them.  In the case of other abstractions like RSA, DSA, etc, there is only one "algorithm" so all implementations implicitly register using the same 'nid' index.
fr: Pour chaque abstraction gérée, le code d'ENGINE maintient une table d'état de contrôle interne dans laquelle les implémentations sont disponibles pour une abstraction donnée et qui devrait être utilisée par défaut. Ces implémentations sont enregistrées dans les tables et indexées par une valeur « nid », parce que les abstractions comme EVP_CIPHER et EVP_DIGEST gèrent énormément d'algorithmes et de modes distincts, et les ENGINE peuvent arbitrairement tous les prendre en charge. Dans le cas d'autres abstractions comme RSA, DSA, etc, il n'y a qu'un seul « algorithme » donc toutes les implémentations sont enregistrées de façon implicite en utilisant le même index « nid ».

note: type: textblock
en: When a default ENGINE is requested for a given abstraction/algorithm/mode, (eg.  when calling RSA_new_method(NULL)), a "get_default" call will be made to the ENGINE subsystem to process the corresponding state table and return a functional reference to an initialised ENGINE whose implementation should be used. If no ENGINE should (or can) be used, it will return NULL and the caller will operate with a NULL ENGINE handle - this usually equates to using the conventional software implementation. In the latter case, OpenSSL will from then on behave the way it used to before the ENGINE API existed.
fr: Quand une requête d'un ENGINE par défaut pour une abstraction/algorithme/mode est faite (par ex. en appelant RSA_new_method(NULL)), un appel « get_default » peut être fait au sous-système de l'ENGINE pour traiter l'état de la table correspondante et renvoyer une référence fonctionnelle vers un ENGINE initialisé dont l'implémentation devrait être utilisée. Si aucun ENGINE ne doit (ou ne peut) être utilisé, elle renverra NULL et l'appelant opérera avec un identificateur d'ENGINE NULL — cela correspond à utiliser l'implémentation conventionnelle d'un programme. Dans ce cas, OpenSSL fonctionnera de la même façon qu'avant que l'API ENGINE n'existe.

note: type: textblock
en: Each state table has a flag to note whether it has processed this "get_default" query since the table was last modified, because to process this question it must iterate across all the registered ENGINEs in the table trying to initialise each of them in turn, in case one of them is operational. If it returns a functional reference to an ENGINE, it will also cache another reference to speed up processing future queries (without needing to iterate across the table). Likewise, it will cache a NULL response if no ENGINE was available so that future queries won't repeat the same iteration unless the state table changes. This behaviour can also be changed; if the ENGINE_TABLE_FLAG_NOINIT flag is set (using ENGINE_set_table_flags()), no attempted initialisations will take place, instead the only way for the state table to return a non-NULL ENGINE to the "get_default" query will be if one is expressly set in the table. Eg.  ENGINE_set_default_RSA() does the same job as ENGINE_register_RSA() except that it also sets the state table's cached response for the "get_default" query. In the case of abstractions like EVP_CIPHER, where implementations are indexed by 'nid', these flags and cached-responses are distinct for each 'nid' value.
fr: Chaque table d'état a un drapeau pour indiquer si elle a traité cette requête « get_default » depuis que la table a été modifiée, car pour traiter cette question elle doit itérer à travers tous les ENGINE enregistrés dans la table en essayant de les initialiser les uns après les autres, au cas où l'un d'entre eux soit opérationnel. Si elle renvoie une référence fonctionnelle vers un ENGINE, elle mettra en cache une autre référence pour accélérer le processus en cas de futures requêtes (plus besoin d'avoir à itérer sur toute la table). De même, elle mettra en cache une réponse NULL si aucun ENGINE n'est disponible pour que les futures requêtes ne fassent pas la même itération, sauf si l'état de la table change. Ce comportement peut aussi être changé ; si le drapeau ENGINE_TABLE_FLAG_NOINIT est défini (en utilisant ENGINE_set_table_flags()), il n'y aura pas de tentatives d'initialisation, et la seule façon pour une table d'état de renvoyer à un ENGINE non NULL pour la requête « get_default » sera celle qui sera indiquée de façon explicite dans la table. Exemple : ENGINE_set_default_RSA() fait la même chose qu'ENGINE_register_RSA() sauf qu'elle définit aussi le cache de réponses de la table pour la requête « get_default ». Dans ce cas, les abstractions comme EVP_CIPHER, où les implémentations sont indexées par un « nid », ces drapeaux et réponses cachés sont différents des valeurs « nid ».

note: type: =head2
en: Application requirements
fr: Exigences de l'application

note: type: textblock
en: This section will explain the basic things an application programmer should support to make the most useful elements of the ENGINE functionality available to the user. The first thing to consider is whether the programmer wishes to make alternative ENGINE modules available to the application and user. OpenSSL maintains an internal linked list of "visible" ENGINEs from which it has to operate - at start-up, this list is empty and in fact if an application does not call any ENGINE API calls and it uses static linking against openssl, then the resulting application binary will not contain any alternative ENGINE code at all. So the first consideration is whether any/all available ENGINE implementations should be made visible to OpenSSL - this is controlled by calling the various "load" functions, eg.
fr: Cette partie expliquera les choses de base qu'un programmeur d'applications doit connaître pour rendre disponibles les éléments les plus utiles de la fonctionnalité d'ENGINE à l'utilisateur. La première chose à considérer est si le programmeur veut fournir un module alternatif d'ENGINE disponible à l'application et à l'utilisateur. OpenSSL maintient une liste liée interne d'ENGINE « visibles » qu'il a besoin d'opérer — au démarrage, cette liste est vide et d'ailleurs si une application n'utilise pas d'appel de l'API d'ENGINE et qu'elle utilise un lien statique envers openssl, alors le binaire de l'application résultante ne contiendra aucun code d'ENGINE alternatif. La première considération est donc de savoir si toute implémentation d'ENGINE doit être rendue visible à OpenSSL — cela est contrôlé en appelant les différentes fonctions de « chargement », exemple :

note: type: verbatim
en:  /* Make the "dynamic" ENGINE available */
     void ENGINE_load_dynamic(void);
     /* Make the CryptoSwift hardware acceleration support available */
     void ENGINE_load_cswift(void);
     /* Make support for nCipher's "CHIL" hardware available */
     void ENGINE_load_chil(void);
     ...
     /* Make ALL ENGINE implementations bundled with OpenSSL available */
     void ENGINE_load_builtin_engines(void);
fr:  /* Rendre l'ENGINE « dynamique » disponible */
     void ENGINE_load_dynamic(void);
     /* Rendre le support d'accélération matériel CryptoSwift disponible */
     void ENGINE_load_cswift(void);
     /* Rendre le support de matériel « CHIL » de nCipher disponible */
     void ENGINE_load_chil(void);
     ...
     /* Rendre toutes les implémentations du paquet OpenSSL disponibles. */
     void ENGINE_load_builtin_engines(void);

note: type: textblock
en: Having called any of these functions, ENGINE objects would have been dynamically allocated and populated with these implementations and linked into OpenSSL's internal linked list. At this point it is important to mention an important API function;
fr: Après avoir appelé n'importe laquelle de ces fonctions, les objets ENGINE ont été alloués de façon dynamique, peuplés avec ces implémentations et liés à la liste chaînée interne d'OpenSSL. À partir de ce moment il est nécessaire de mentionner une fonction de l'API importante ;

note: type: textblock
en: If no ENGINE API functions are called at all in an application, then there are no inherent memory leaks to worry about from the ENGINE functionality, however if any ENGINEs are loaded, even if they are never registered or used, it is necessary to use the ENGINE_cleanup() function to correspondingly cleanup before program exit, if the caller wishes to avoid memory leaks. This mechanism uses an internal callback registration table so that any ENGINE API functionality that knows it requires cleanup can register its cleanup details to be called during ENGINE_cleanup(). This approach allows ENGINE_cleanup() to clean up after any ENGINE functionality at all that your program uses, yet doesn't automatically create linker dependencies to all possible ENGINE functionality - only the cleanup callbacks required by the functionality you do use will be required by the linker.
fr: Si aucune fonction d'API ENGINE n'est appelée dans une application, alors il n'y a pas de fuite mémoire dont il faut s'inquiéter dans les fonctionnalités d'ENGINE ; néanmoins, si n'importe quel ENGINE est chargé, même s'il n'est jamais enregistré ou utilisé, il est nécessaire d'utiliser la fonction ENGINE_cleanup() pour le nettoyer de façon correcte avant la fermeture du programme, si l'utilisateur veut éviter les fuites mémoires. Ce mécanisme utilise une table enregistrant les rétroactions internes pour qu'une fonctionnalité d'API ENGINE, qui sait qu'elle a besoin d'être nettoyée, puisse enregistrer les détails du nettoyage à appeler pendant l'appel deENGINE_cleanup(). Cette approche permet à ENGINE_cleanup() de nettoyer après n'importe quelle utilisation par un programme d'une fonctionnalité d'ENGINE, mais cela ne crée pas de lien de dépendance à toutes les fonctionnalités possibles d'ENGINE — seules les rétroactions de nettoyage nécessaires aux fonctionnalités utilisées, seront requises par le lieur.

note: type: textblock
en: The fact that ENGINEs are made visible to OpenSSL (and thus are linked into the program and loaded into memory at run-time) does not mean they are "registered" or called into use by OpenSSL automatically - that behaviour is something for the application to control. Some applications will want to allow the user to specify exactly which ENGINE they want used if any is to be used at all. Others may prefer to load all support and have OpenSSL automatically use at run-time any ENGINE that is able to successfully initialise - ie. to assume that this corresponds to acceleration hardware attached to the machine or some such thing. There are probably numerous other ways in which applications may prefer to handle things, so we will simply illustrate the consequences as they apply to a couple of simple cases and leave developers to consider these and the source code to openssl's builtin utilities as guides.
fr: Le fait que les ENGINES sont rendus visibles à OpenSSL (et de ce fait sont liés au programme et chargés en mémoire lors de l'exécution) ne veut pas dire qu'ils sont « enregistrés » ou appelés et utilisés par OpenSSL automatiquement — ce comportement est quelque chose qui doit être contrôlé par l'application. Certaines applications auront besoin d'autoriser l'utilisateur à spécifier exactement quel ENGINE il voudra utiliser si il y en a un qui doit être utilisé. D'autres préféreront tout charger pour que OpenSSL utilise automatiquement le premier ENGINE qui peut s'initialiser correctement — c'est-à-dire, qui puisse correspondre à une accélération matérielle attachée à la machine, ou quelque chose comme cela. Il y a probablement énormément d'autres façons par lesquelles l'application peut préférer gérer les choses, nous illustrerons donc simplement les conséquences telles qu'elles s'appliquent à des cas simples et laisserons les développeurs considérer ces cas et le code source de fonctions utilitaires d'OpenSSL comme guide.

note: type: textblock
en: I<Using a specific ENGINE implementation>
fr: I<Utiliser une implémentation spécifique d'ENGINE>

note: type: textblock
en: Here we'll assume an application has been configured by its user or admin to want to use the "ACME" ENGINE if it is available in the version of OpenSSL the application was compiled with. If it is available, it should be used by default for all RSA, DSA, and symmetric cipher operation, otherwise OpenSSL should use its builtin software as per usual. The following code illustrates how to approach this;
fr: Ici, nous allons supposer qu'une application a été configurée par son utilisateur ou administrateur pour utiliser l'ENGINE « ACME » s'il est disponible dans la version d'OpenSSL avec laquelle l'application a été compilée. S'il est disponible, il devra être utilisé par défaut pour tous les chiffrements RSA, DSA et les opérations par chiffrement symétrique, sinon OpenSSL devrait utiliser ses fonctionnalités internes comme d'habitude. Le code suivant illustre comment faire cela :

note: type: verbatim
en:  ENGINE *e;
     const char *engine_id = "ACME";
     ENGINE_load_builtin_engines();
     e = ENGINE_by_id(engine_id);
     if(!e)
         /* the engine isn't available */
         return;
     if(!ENGINE_init(e)) {
         /* the engine couldn't initialise, release 'e' */
         ENGINE_free(e);
         return;
     }
     if(!ENGINE_set_default_RSA(e))
         /* This should only happen when 'e' can't initialise, but the previous
          * statement suggests it did. */
         abort();
     ENGINE_set_default_DSA(e);
     ENGINE_set_default_ciphers(e);
     /* Release the functional reference from ENGINE_init() */
     ENGINE_finish(e);
     /* Release the structural reference from ENGINE_by_id() */
     ENGINE_free(e);
fr:  ENGINE *e;
     const char *engine_id = "ACME";
     ENGINE_load_builtin_engines();
     e = ENGINE_by_id(engine_id);
     if(!e)
         /* le moteur n'est pas disponible */
         return;
     if(!ENGINE_init(e)) {
         /* le moteur n'a pas pu être initialisé, libérer « e » */
         ENGINE_free(e);
         return;
     }
     if(!ENGINE_set_default_RSA(e))
         /* Ceci devrait uniquement se produire quand « e » ne peut être
          * initialisé, mais la déclaration précédente suggère qu'il l'a été. */
         abort();
     ENGINE_set_default_DSA(e);
     ENGINE_set_default_ciphers(e);
     /* Libère la référence fonctionnelle d'ENGINE_init() */
     ENGINE_finish(e);
     /* Libère la référence structurelle d'ENGINE_by_id() */
     ENGINE_free(e);

note: type: textblock
en: I<Automatically using builtin ENGINE implementations>
fr: I<Utiliser automatiquement les implémentations intégrées d'ENGINE>

note: type: textblock
en: Here we'll assume we want to load and register all ENGINE implementations bundled with OpenSSL, such that for any cryptographic algorithm required by OpenSSL - if there is an ENGINE that implements it and can be initialise, it should be used. The following code illustrates how this can work;
fr: Ici, nous allons supposer que l'on veut charger et enregistrer toutes les implémentations d'ENGINE fournies avec OpenSSL, de façon à ce que n'importe quel algorithme de cryptographie qui est utilisé par OpenSSL — s'il y a un ENGINE qui l'implémente et peut être initialisé — alors il sera utilisé. Le code suivant montre un exemple d'utilisation :

note: type: verbatim
en:  /* Load all bundled ENGINEs into memory and make them visible */
     ENGINE_load_builtin_engines();
     /* Register all of them for every algorithm they collectively implement */
     ENGINE_register_all_complete();
fr:  /* Charger et rendre visible tous les paquets ENGINE dans la mémoire. */
     ENGINE_load_builtin_engines();
     /* Enregistrer tous les paquets pour tous les algorithmes qu'ils implémentent collectivement */
     ENGINE_register_all_complete();

note: type: textblock
en: That's all that's required. Eg. the next time OpenSSL tries to set up an RSA key, any bundled ENGINEs that implement RSA_METHOD will be passed to ENGINE_init() and if any of those succeed, that ENGINE will be set as the default for RSA use from then on.
fr: Cela est tout ce qui est requis. Par exemple, la prochaine fois qu'OpenSSL essaye de mettre en place une clé RSA, n'importe quel ENGINE fourni qui implémente RSA_METHOD sera passé à ENGINE_init() et si l'un d'entre eux réussit, cet ENGINE sera choisi par défaut pour l'utilisation de RSA.

note: type: =head2
en: Advanced configuration support
fr: Support de configuration avancé

note: type: textblock
en: There is a mechanism supported by the ENGINE framework that allows each ENGINE implementation to define an arbitrary set of configuration "commands" and expose them to OpenSSL and any applications based on OpenSSL. This mechanism is entirely based on the use of name-value pairs and assumes ASCII input (no unicode or UTF for now!), so it is ideal if applications want to provide a transparent way for users to provide arbitrary configuration "directives" directly to such ENGINEs. It is also possible for the application to dynamically interrogate the loaded ENGINE implementations for the names, descriptions, and input flags of their available "control commands", providing a more flexible configuration scheme. However, if the user is expected to know which ENGINE device he/she is using (in the case of specialised hardware, this goes without saying)  then applications may not need to concern themselves with discovering the supported control commands and simply prefer to pass settings into ENGINEs exactly as they are provided by the user.
fr: Il y a un mécanisme géré par le framework de l'ENGINE qui autorise chaque implémentation d'ENGINE de définir un nombre arbitraire d'ensembles de « commandes » de configuration, de les révéler à OpenSSL et toute application basée sur OpenSSL. Ce mécanisme est entièrement basé sur l'utilisation de couple noms-valeurs et suppose que l'entrée est au format ASCII (pas d'unicode ou d'UTF pour l'instant !), c'est donc idéal si l'application veut fournir une possibilité de fournir, d'une façon transparente aux utilisateurs, des « directives » de configuration arbitraires directement à ces ENGINE. Il permet aussi à l'application de demander de façon dynamique à l'implémentation de l'ENGINE des noms, descriptions et drapeaux d'entrée des « commandes de contrôle » disponibles, ce qui fournit un programme plus flexible. Or, si l'utilisateur s'attend à connaitre quel ENGINE il utilise (dans le cas de matériel spécialisé, cela va sans dire) alors l'application peut ne pas s'intéresser à la découverte des commandes de contrôle gérées et plus simplement préférer passer des réglages directement à l'ENGINE tels qu'ils sont fournis par l'utilisateur.

note: type: textblock
en: Before illustrating how control commands work, it is worth mentioning what they are typically used for. Broadly speaking there are two uses for control commands; the first is to provide the necessary details to the implementation (which may know nothing at all specific to the host system)  so that it can be initialised for use. This could include the path to any driver or config files it needs to load, required network addresses, smart-card identifiers, passwords to initialise protected devices, logging information, etc etc. This class of commands typically needs to be passed to an ENGINE B<before> attempting to initialise it, ie. before calling ENGINE_init(). The other class of commands consist of settings or operations that tweak certain behaviour or cause certain operations to take place, and these commands may work either before or after ENGINE_init(), or in some cases both. ENGINE implementations should provide indications of this in the descriptions attached to builtin control commands and/or in external product documentation.
fr: Avant d'illustrer les commandes de contrôle, il est raisonnable de mentionner ce pour quoi elles sont utilisées. De façon générale, il y a deux utilisations de commandes de contrôle ; la première consiste à fournir les détails nécessaires à l'implémentation (qui peut ne rien connaître du système hôte) pour que l'initialisation se fasse. Cela peut inclure n'importe quel chemin de pilote ou de fichier config qui doit être chargé, des adresses réseau requises, des identifiants de cartes à puce, des mots de passe pour initialiser des dispositifs sécurisés, des informations de connexion, etc. Cette classe de commandes a généralement besoin d'être passée à un ENGINE B<avant> d'essayer de l'initialiser, c'est-à-dire avant d'appeler ENGINE_init(). L'autre classe de commande consiste en des réglages ou des opérations qui modifient certains comportements ou déclenchent la réalisation de certaines opérations, et ces commandes peuvent fonctionner avant ou après ENGINE_init(), ou dans certains cas avant et après. L'implémentation d'ENGINE doit fournir des indications de cela dans la description des commandes de contrôle intégrées et/ou dans la documentation externe finale.

note: type: textblock
en: I<Issuing control commands to an ENGINE>
fr: I<Envoyer des commandes de contrôle à un ENGINE>

note: type: textblock
en: Let's illustrate by example; a function for which the caller supplies the name of the ENGINE it wishes to use, a table of string-pairs for use before initialisation, and another table for use after initialisation. Note that the string-pairs used for control commands consist of a command "name" followed by the command "parameter" - the parameter could be NULL in some cases but the name can not. This function should initialise the ENGINE (issuing the "pre" commands beforehand and the "post" commands afterwards)  and set it as the default for everything except RAND and then return a boolean success or failure.
fr: Illustrons cela grâce à un exemple : une fonction pour laquelle l'appelant fournit le nom de l'ENGINE qu'il veut utiliser, une table de paires de chaînes de caractères à utiliser avant l'initialisation, et d'autres tables après l'initialisation. Notez que les paires de chaînes de caractères utilisées pour les commandes de contrôles consistent en un « nom » de commande suivit du « paramètre » de la commande — le paramètre pourrait être NULL dans certains cas mais le nom ne peut pas l'être. Cette fonction devrait initialiser l'ENGINE (en envoyant les « pré » commandes avant et les « post » commandes après) et le régler comme défaut pour tout sauf RAND, puis renvoyer un booléen pour un succès ou un échec.

note: type: verbatim
en:  int generic_load_engine_fn(const char *engine_id,
                                const char **pre_cmds, int pre_num,
                                const char **post_cmds, int post_num)
     {
         ENGINE *e = ENGINE_by_id(engine_id);
         if(!e) return 0;
         while(pre_num--) {
             if(!ENGINE_ctrl_cmd_string(e, pre_cmds[0], pre_cmds[1], 0)) {
                 fprintf(stderr, "Failed command (%s - %s:%s)\n", engine_id,
                     pre_cmds[0], pre_cmds[1] ? pre_cmds[1] : "(NULL)");
                 ENGINE_free(e);
                 return 0;
             }
    	 pre_cmds += 2;
         }
         if(!ENGINE_init(e)) {
             fprintf(stderr, "Failed initialisation\n");
             ENGINE_free(e);
             return 0;
         }
         /* ENGINE_init() returned a functional reference, so free the structural
          * reference from ENGINE_by_id(). */
         ENGINE_free(e);
         while(post_num--) {
             if(!ENGINE_ctrl_cmd_string(e, post_cmds[0], post_cmds[1], 0)) {
                 fprintf(stderr, "Failed command (%s - %s:%s)\n", engine_id,
                     post_cmds[0], post_cmds[1] ? post_cmds[1] : "(NULL)");
                 ENGINE_finish(e);
                 return 0;
             }
    	 post_cmds += 2;
         }
         ENGINE_set_default(e, ENGINE_METHOD_ALL & ~ENGINE_METHOD_RAND);
         /* Success */
         return 1;
     }
fr:  int generic_load_engine_fn(const char *engine_id,
                                const char **pre_cmds, int pre_num,
                                const char **post_cmds, int post_num)
     {
         ENGINE *e = ENGINE_by_id(engine_id);
         if(!e) return 0;
         while(pre_num--) {
             if(!ENGINE_ctrl_cmd_string(e, pre_cmds[0], pre_cmds[1], 0)) {
                 fprintf(stderr, "Failed command (%s - %s:%s)\n", engine_id,
                     pre_cmds[0], pre_cmds[1] ? pre_cmds[1] : "(NULL)");
                 ENGINE_free(e);
                 return 0;
             }
    	 pre_cmds += 2;
         }
         if(!ENGINE_init(e)) {
             fprintf(stderr, "Failed initialisation\n");
             ENGINE_free(e);
             return 0;
         }
         /* ENGINE_init() a renvoyé une référence fonctionnelle, il faut donc libérer la référence structurelle d'ENGINE_by_id(). */
         ENGINE_free(e);
         while(post_num--) {
             if(!ENGINE_ctrl_cmd_string(e, post_cmds[0], post_cmds[1], 0)) {
                 fprintf(stderr, "Failed command (%s - %s:%s)\n", engine_id,
                     post_cmds[0], post_cmds[1] ? post_cmds[1] : "(NULL)");
                 ENGINE_finish(e);
                 return 0;
             }
    	 post_cmds += 2;
         }
         ENGINE_set_default(e, ENGINE_METHOD_ALL & ~ENGINE_METHOD_RAND);
         /* Succès */
         return 1;
     }

note: type: textblock
en: Note that ENGINE_ctrl_cmd_string() accepts a boolean argument that can relax the semantics of the function - if set non-zero it will only return failure if the ENGINE supported the given command name but failed while executing it, if the ENGINE doesn't support the command name it will simply return success without doing anything. In this case we assume the user is only supplying commands specific to the given ENGINE so we set this to FALSE.
fr: Notez qu'ENGINE_ctrl_cmd_string() accepte un argument booléen qui peut assouplir les sémantiques de la fonction — s'il est différent de 0, elle ne renverra un échec que si l'ENGINE prend en charge le nom de la commande mais a échoué lors de son exécution ; si l'ENGINE ne prend pas en charge le nom de la commande, elle renverra simplement succès sans rien faire. Dans ce cas, on suppose que l'utilisateur apporte des commandes spécifiques à l'ENGINE donné, on règle donc cela à FALSE.

note: type: textblock
en: I<Discovering supported control commands>
fr: I<Découverte de commandes de contrôle gérées>

note: type: textblock
en: It is possible to discover at run-time the names, numerical-ids, descriptions and input parameters of the control commands supported by an ENGINE using a structural reference. Note that some control commands are defined by OpenSSL itself and it will intercept and handle these control commands on behalf of the ENGINE, ie. the ENGINE's ctrl() handler is not used for the control command.  openssl/engine.h defines an index, ENGINE_CMD_BASE, that all control commands implemented by ENGINEs should be numbered from. Any command value lower than this symbol is considered a "generic" command is handled directly by the OpenSSL core routines.
fr: Il est possible de découvrir les noms, id numériques, descriptions et paramètres d'entrée des commandes de contrôle prises en charge par un ENGINE au moment de l'exécution en utilisant une référence structurelle. Notez que certaines commandes de contrôle définies dans OpenSSL intercepteront et géreront ces appels au nom d'ENGINE, c'est-à-dire le gestionnaire ctrl() d'ENGINE n'est pas utilisé pour les commandes de contrôle. openssl/engine.h définit un index, ENGINE_CMD_BASE, à partir duquel toutes les commandes de contrôle implémentées par ENGINE doivent être numérotées. Toute valeur de commande plus basse que ce symbole est considérée comme « générique » et est gérée directement par les routines noyau d'OpenSSL.

note: type: textblock
en: It is using these "core" control commands that one can discover the the control commands implemented by a given ENGINE, specifically the commands;
fr: C'est en utilisant ces contrôles « essentiels » que l'on peut découvrir les commandes de contrôle implémentées par un ENGINE donné, plus spécifiquement ces commandes :

note: type: textblock
en: Whilst these commands are automatically processed by the OpenSSL framework code, they use various properties exposed by each ENGINE to process these queries. An ENGINE has 3 properties it exposes that can affect how this behaves; it can supply a ctrl() handler, it can specify ENGINE_FLAGS_MANUAL_CMD_CTRL in the ENGINE's flags, and it can expose an array of control command descriptions.  If an ENGINE specifies the ENGINE_FLAGS_MANUAL_CMD_CTRL flag, then it will simply pass all these "core" control commands directly to the ENGINE's ctrl()  handler (and thus, it must have supplied one), so it is up to the ENGINE to reply to these "discovery" commands itself. If that flag is not set, then the OpenSSL framework code will work with the following rules;
fr: Alors que ces commandes sont traitées de façon automatique par le code du framework d'OpenSSL, elles utilisent diverses propriétés exposées par chaque ENGINE pour traiter ces requêtes. Un ENGINE a 3 propriétés qu'il expose qui peuvent affecter comment celles-ci se comportent ; il peut fournir un contrôleur ctrl(), il peut spécifier ENGINE_FLAGS_MANUAL_CMD_CTRL dans les drapeaux de l'ENGINE, et il peut exposer un tableau de descriptions de commandes de contrôle. Si un ENGINE spécifie le drapeau ENGINE_FLAGS_MANUAL_CMD_CTRL, alors les commandes essentielles de contrôle seront simplement passées directement au gestionnaire ctrl() de l'ENGINE (et de ce fait, il doit y en avoir un de fourni), c'est donc le rôle de l'ENGINE de répondre à ces commandes « découvertes ». Si un drapeau n'est pas déterminé, alors le code du framework d'OpenSSL fonctionnera avec les règles suivantes :

note: type: verbatim
en:  if no ctrl() handler supplied;
         ENGINE_HAS_CTRL_FUNCTION returns FALSE (zero),
         all other commands fail.
     if a ctrl() handler was supplied but no array of control commands;
         ENGINE_HAS_CTRL_FUNCTION returns TRUE,
         all other commands fail.
     if a ctrl() handler and array of control commands was supplied;
         ENGINE_HAS_CTRL_FUNCTION returns TRUE,
         all other commands proceed processing ...
fr:  si aucun gestionnaire ctrl() n'est fourni ;
         ENGINE_HAS_CTRL_FUNCTION renvoie FALSE (zero),
         toutes les autres commandes échouent.
     si un gestionnaire ctrl() a été fourni mais aucun tableau de commandes de contrôle n'a été fourni ;
         ENGINE_HAS_CTRL_FUNCTION renvoie TRUE,
         toutes les autres commandes échouent.
     si un gestionnaire ctrl() et un tableau de commandes ont été fournis ;
         ENGINE_HAS_CTRL_FUNCTION renvoie TRUE,
         toutes les autres commandes continuent leurs traitements ...

note: type: textblock
en: If the ENGINE's array of control commands is empty then all other commands will fail, otherwise; ENGINE_CTRL_GET_FIRST_CMD_TYPE returns the identifier of the first command supported by the ENGINE, ENGINE_GET_NEXT_CMD_TYPE takes the identifier of a command supported by the ENGINE and returns the next command identifier or fails if there are no more, ENGINE_CMD_FROM_NAME takes a string name for a command and returns the corresponding identifier or fails if no such command name exists, and the remaining commands take a command identifier and return properties of the corresponding commands. All except ENGINE_CTRL_GET_FLAGS return the string length of a command name or description, or populate a supplied character buffer with a copy of the command name or description. ENGINE_CTRL_GET_FLAGS returns a bitwise-OR'd mask of the following possible values;
fr: Si le tableau de commandes de contrôle d'ENGINE est vide alors toutes les autres commandes échoueront, sinon ENGINE_CTRL_GET_FIRST_CMD_TYPE renvoie l'identifiant de la première commande prise en charge par l'ENGINE, ENGINE_GET_NEXT_CMD_TYPE prend l'identifiant d'une commande prise en charge par l'ENGINE et renvoie le prochain identifiant de commande, ou échoue s'il n'y en a plus, ENGINE_CMD_FROM_NAME prend un nom sous forme de chaîne de caractères pour une commande et renvoie l'identifiant correspondant ou échoue si la commande correspondante n'existe pas. Les commandes restantes prennent un identifiant de commande et renvoient les propriétés de la commande correspondante. Toutes, sauf ENGINE_CTRL_GET_FLAGS, renvoient la longueur de la chaîne de caractères du nom de la commande ou de la description, ou remplissent un tampon de caractères fourni avec la copie du nom ou de la description de la commande. ENGINE_CTRL_GET_FLAGS renvoie un masque OR bit à bit ayant les valeurs possibles suivantes :

note: type: textblock
en: If the ENGINE_CMD_FLAG_INTERNAL flag is set, then any other flags are purely informational to the caller - this flag will prevent the command being usable for any higher-level ENGINE functions such as ENGINE_ctrl_cmd_string().  "INTERNAL" commands are not intended to be exposed to text-based configuration by applications, administrations, users, etc. These can support arbitrary operations via ENGINE_ctrl(), including passing to and/or from the control commands data of any arbitrary type. These commands are supported in the discovery mechanisms simply to allow applications determinie if an ENGINE supports certain specific commands it might want to use (eg. application "foo" might query various ENGINEs to see if they implement "FOO_GET_VENDOR_LOGO_GIF" - and ENGINE could therefore decide whether or not to support this "foo"-specific extension).
fr: Si le drapeau ENGINE_CMD_FLAG_INTERNAL est défini, alors n'importe quels autres drapeaux sont purement informationnels pour l'appelant — ce drapeau empêchera la commande d'être exécutée par les fonctions haut niveau d'un ENGINE comme ENGINE_ctrl_cmd_string(). Les commandes « INTERNES » ne sont pas supposées être exposées à des configurations basées sur du texte par les applications, administrations, utilisateurs, etc. Celles-ci peuvent gérer des opérations arbitraires à l’aide d'ENGINE_ctrl(), y compris le passage de ou vers les données des commandes de contrôle de n'importe quel type arbitraire. Ces commandes sont gérées dans le mécanisme de découverte pour simplement autoriser les applications à déterminer si un ENGINE gère certaines commandes spécifiques qu'il veut utiliser (par exemple : l'application « foo » veut faire une requête à différents ENGINE pour voir s'ils implémentent « FOO_GET_VENDOR_LOGO_GIF », et ENGINE peut de ce fait décider s'il prend en charge ou non cette extension spécifique à « foo »).

note: type: =head2
en: Future developments
fr: Développements futurs

note: type: textblock
en: The ENGINE API and internal architecture is currently being reviewed. Slated for possible release in 0.9.8 is support for transparent loading of "dynamic" ENGINEs (built as self-contained shared-libraries). This would allow ENGINE implementations to be provided independently of OpenSSL libraries and/or OpenSSL-based applications, and would also remove any requirement for applications to explicitly use the "dynamic" ENGINE to bind to shared-library implementations.
fr: L'API d'ENGINE et sa structure architecturale interne sont en cours de révision. Il est prévu d'avoir de nouvelles modifications dans la version 0.9.8 pour une prise en charge du chargement transparent d'ENGINE « dynamiques » (implémentés comme bibliothèques partagées autonomes). Cela devrait autoriser de fournir des implémentations ENGINE indépendamment des bibliothèques d'OpenSSL ou des applications basées sur OpenSSL, et supprimera aussi toute obligation pour les applications d'utiliser explicitement l'ENGINE « dynamique » pour se lier à des implémentations de bibliothèques partagées.

note: type: textblock
en: HMAC, HMAC_CTX_init, HMAC_Init, HMAC_Init_ex, HMAC_Update, HMAC_Final, HMAC_CTX_cleanup, HMAC_cleanup - HMAC message authentication code
fr: HMAC, HMAC_CTX_init, HMAC_Init, HMAC_Update, HMAC_Init_ex, HMAC_Final, HMAC_CTX_cleanup, HMAC_cleanup - message d'authentification de message HMAC

note: type: textblock
en: HMAC is a MAC (message authentication code), i.e. a keyed hash function used for message authentication, which is based on a hash function.
fr: HMAC est un MAC (code d'authentification de message), c'est-à-dire une fonction de hachage à clé utilisée pour l'authentification des messages, qui est basé sur une fonction de hachage.

note: type: textblock
en: HMAC() computes the message authentication code of the B<n> bytes at B<d> using the hash function B<evp_md> and the key B<key> which is B<key_len> bytes long.
fr: B<HMAC>() calcule le code d'authentification du message faisant I<n> octets à I<d>en utilisant la fonction de hachage I<evp_md> et la clé I<key> qui a une longueur de I<key_len> octets.

note: type: textblock
en: It places the result in B<md> (which must have space for the output of the hash function, which is no more than B<EVP_MAX_MD_SIZE> bytes).  If B<md> is NULL, the digest is placed in a static array.  The size of the output is placed in B<md_len>, unless it is B<NULL>.
fr: Elle place le résultat dans I<md> (qui doit avoir de l'espace pour la sortie de la fonction de hachage, qui n'est pas plus de B<EVP_MAX_MD_SIZE> octets). Si I<md> est NULL, le condensé est placé dans un tableau statique. La taille de la sortie est placée dans I<md_len>, sauf si elle est NULL.

note: type: textblock
en: B<evp_md> can be EVP_sha1(), EVP_ripemd160() etc.
fr: I<evp_md> peut être B<EVP_sha1>(), B<EVP_ripemd160>(), etc.

note: type: textblock
en: HMAC_CTX_init() initialises a B<HMAC_CTX> before first use. It must be called.
fr: B<HMAC_CTX_init>() initialise un B<HMAC_CTX> avant sa première utilisation. Elle doit être appelée.

note: type: textblock
en: HMAC_CTX_cleanup() erases the key and other data from the B<HMAC_CTX> and releases any associated resources. It must be called when an B<HMAC_CTX> is no longer required.
fr: B<HMAC_CTX_cleanup>() efface la clé et toutes autres données de B<HMAC_CTX> et libère toutes ressources associées. Elle doit être appelée quand B<HMAC_CTX> n'est plus utilisée.

note: type: textblock
en: HMAC_cleanup() is an alias for HMAC_CTX_cleanup() included for back compatibility with 0.9.6b, it is deprecated.
fr: B<HMAC_cleanup>() est un alias pour B<HMAC_CTX_cleanup>() qui est incluse pour être compatible avec la version 0.9.6b, elle est obsolète.

note: type: textblock
en: The following functions may be used if the message is not completely stored in memory:
fr: Les fonctions suivantes peuvent être utiles si le message n'est pas stocké en entier dans la mémoire :

note: type: textblock
en: HMAC_Init() initializes a B<HMAC_CTX> structure to use the hash function B<evp_md> and the key B<key> which is B<key_len> bytes long. It is deprecated and only included for backward compatibility with OpenSSL 0.9.6b.
fr: B<HMAC_Init>() initialise une structure B<HMAC_CTX> pour utiliser une fonction de hachage I<evp_md> et sa clé I<key> qui est de longueur I<key_len> octets. Elle est obsolète et est uniquement incluse pour une compatibilité avec OpenSSL 0.9.6b.

note: type: textblock
en: HMAC_Init_ex() initializes or reuses a B<HMAC_CTX> structure to use the function B<evp_md> and key B<key>. Either can be NULL, in which case the existing one will be reused. HMAC_CTX_init() must have been called before the first use of an B<HMAC_CTX> in this function. B<N.B. HMAC_Init() had this undocumented behaviour in previous versions of OpenSSL - failure to switch to HMAC_Init_ex() in programs that expect it will cause them to stop working>.
fr: B<HMAC_Init_ex>() initialise ou réutilise une structure B<HMAC_CTX> pour utiliser la fonction I<evp_md> et la clé I<key>. Elles peuvent toutes les deux être NULL, dans ce cas, celle existante sera réutilisée. B<HMAC_CTX_init>() aurait dû être appelée avant la première utilisation d'un B<HMAC_CTX> dans cette fonction. B<N.B> : B<HMAC_Init>() avait un comportement indéfini dans les versions précédentes d'OpenSSL — l'échec de passage à B<HMAC_Init_ex>() dans les programmes qui l'attendent les fera s'arrêter.

note: type: textblock
en: HMAC_Update() can be called repeatedly with chunks of the message to be authenticated (B<len> bytes at B<data>).
fr: B<HMAC_Update>() peut être appelée de façon répétée avec des morceaux du message qui doit être authentifié (I<len> octets à I<data>).

note: type: textblock
en: HMAC_Final() places the message authentication code in B<md>, which must have space for the hash function output.
fr: B<HMAC_Final>() place le code du message d'authentification dans I<md>, qui doit avoir de l'espace pour la sortie de la fonction de hachage.

note: type: textblock
en: HMAC() returns a pointer to the message authentication code or NULL if an error occurred.
fr: B<HMAC>() renvoie un pointeur vers le code d'authentification du message ou NULL si une erreur se produit.

note: type: textblock
en: HMAC_Init_ex(), HMAC_Update() and HMAC_Final() return 1 for success or 0 if an error occurred.
fr: B<HMAC_Init_ex>(), B<HMAC_Update>() et B<HMAC_Final>() renvoient 1 en cas de succès, 0 en cas d'échec.

note: type: textblock
en: HMAC_CTX_init() and HMAC_CTX_cleanup() do not return values.
fr: B<HMAC_CTX_init>() et B<HMAC_CTX_cleanup>() ne renvoient pas de valeurs.

note: type: textblock
en: RFC 2104
fr: RFC 2104

note: type: textblock
en: L<sha(3)|sha(3)>, L<evp(3)|evp(3)>
fr: L<B<evp>(3)|evp(3)>, L<B<sha>(3)|sha(3)>

note: type: textblock
en: HMAC(), HMAC_Init(), HMAC_Update(), HMAC_Final() and HMAC_cleanup()  are available since SSLeay 0.9.0.
fr: B<HMAC_CTX_init>(), B<HMAC_Init_ex>() et B<HMAC_CTX_cleanup>() sont disponibles depuis la version 0.9.7 d'OpenSSL.

note: type: textblock
en: HMAC_CTX_init(), HMAC_Init_ex() and HMAC_CTX_cleanup() are available since OpenSSL 0.9.7.
fr: B<HMAC_CTX_init>(), B<HMAC_Init_ex>() et B<HMAC_CTX_cleanup>() sont disponibles depuis la version 0.9.7 d'OpenSSL.

note: type: textblock
en: HMAC_Init_ex(), HMAC_Update() and HMAC_Final() did not return values in versions of OpenSSL before 1.0.0.
fr: B<HMAC_Init_ex>(), B<HMAC_Update>() et B<HMAC_Final>() ne renvoyaient pas de valeurs dans les versions antérieures à OpenSSL 1.0.0.

note: type: textblock
en: lh_stats, lh_node_stats, lh_node_usage_stats, lh_stats_bio, lh_node_stats_bio, lh_node_usage_stats_bio - LHASH statistics
fr: lh_stats, lh_node_stats, lh_node_usage_stats, lh_stats_bio, lh_node_stats_bio, lh_node_usage_stats_bio - statistiques LHASH

note: type: textblock
en: The B<LHASH> structure records statistics about most aspects of accessing the hash table.  This is mostly a legacy of Eric Young writing this library for the reasons of implementing what looked like a nice algorithm rather than for a particular software product.
fr: La structure B<LHASH> enregistre des statistiques sur la plupart des fonctionnalités qui permettent d'accéder à la table de hachage. Cela est un legs d'Eric Young quand il a écrit cette bibliothèque pour implémenter quelque chose qui ressemble à un joli algorithme plutôt qu'un produit pour une application particulière.

note: type: textblock
en: lh_stats() prints out statistics on the size of the hash table, how many entries are in it, and the number and result of calls to the routines in this library.
fr: lh_stats() affiche les statistiques sur la taille de la table de hachage, combien d'entrées sont dedans, et les nombre et résultat d'appels aux routines de cette bibliothèque.

note: type: textblock
en: lh_node_stats() prints the number of entries for each 'bucket' in the hash table.
fr: lh_node_stats() affiche le nombre d'entrées pour chaque « compartiment » dans la table de hachage.

note: type: textblock
en: lh_node_usage_stats() prints out a short summary of the state of the hash table.  It prints the 'load' and the 'actual load'.  The load is the average number of data items per 'bucket' in the hash table.  The 'actual load' is the average number of items per 'bucket', but only for buckets which contain entries.  So the 'actual load' is the average number of searches that will need to find an item in the hash table, while the 'load' is the average number that will be done to record a miss.
fr: lh_node_usage_stats() affiche un court résumé de l'état de la table de hachage. Elle affiche la « charge » et l'état de « charge actuelle ». La charge est la moyenne d'objets par « compartiment » dans la table de hachage. La « charge actuelle » est la moyenne d'objets par « compartiment » mais uniquement pour ceux qui ont des objets. La « charge actuelle » est donc la moyenne du nombre de recherches nécessaires pour trouver un objet dans la table de hachage, alors que la « charge » est la moyenne qui sera faite pour enregistrer un manque.

note: type: textblock
en: lh_stats_bio(), lh_node_stats_bio() and lh_node_usage_stats_bio()  are the same as the above, except that the output goes to a B<BIO>.
fr: lh_stats_bio(), lh_node_stats_bio() et lh_node_usage_stats_bio() sont les mêmes que précédemment, sauf que la sortie va dans un B<BIO>.

note: type: textblock
en: These functions do not return values.
fr: Ces fonctions ne renvoient pas de valeurs.

note: type: textblock
en: These functions are available in all versions of SSLeay and OpenSSL.
fr: Ces fonctions sont disponibles dans toutes les versions de SSLeay et d'OpenSSL.

note: type: textblock
en: This manpage is derived from the SSLeay documentation.
fr: Cette page man est dérivée de la documentation de SSLeay

note: type: textblock
en: lh_new, lh_free, lh_insert, lh_delete, lh_retrieve, lh_doall, lh_doall_arg, lh_error - dynamic hash table
fr: lh_new, lh_free, lh_insert, lh_delete, lh_retrieve, lh_doall, lh_doall_arg, lh_error - table de hachage dynamique

note: type: textblock
en: This library implements type-checked dynamic hash tables. The hash table entries can be arbitrary structures. Usually they consist of key and value fields.
fr: Cette bibliothèque implémente des tables de hachage dynamiques qui ont une vérification de type. Les entrées de la table de hachage peuvent être des structures arbitraires. En général, elles consistent en des champs de clés et de valeurs.

note: type: textblock
en: lh_<type>_new() creates a new B<LHASH_OF(<type>> structure to store arbitrary data entries, and provides the 'hash' and 'compare' callbacks to be used in organising the table's entries.  The B<hash> callback takes a pointer to a table entry as its argument and returns an unsigned long hash value for its key field.  The hash value is normally truncated to a power of 2, so make sure that your hash function returns well mixed low order bits.  The B<compare> callback takes two arguments (pointers to two hash table entries), and returns 0 if their keys are equal, non-zero otherwise.  If your hash table will contain items of some particular type and the B<hash> and B<compare> callbacks hash/compare these types, then the B<DECLARE_LHASH_HASH_FN> and B<IMPLEMENT_LHASH_COMP_FN> macros can be used to create callback wrappers of the prototypes required by lh_<type>_new().  These provide per-variable casts before calling the type-specific callbacks written by the application author.  These macros, as well as those used for the "doall" callbacks, are defined as;
fr: h_<type>_new() crée une nouvelle structure B<LHASH_OF(<type>)> pour stocker des données arbitraires et offre les rétroactions « hachage » et « comparer » pour organiser les entrées de la table. La rétroaction B<hash> prend un pointeur vers une entrée de la table comme argument et renvoie un unsigned long haché comme champ clé. La valeur de hachage est normalement tronquée à une puissance de 2, faites donc attention à ce que la fonction de hachage renvoie des bits de poids faibles mélangés. L'appel B<compare> prends deux arguments (deux pointeurs vers deux entrées de la table de hachage), et renvoie 0 si leurs clés sont différentes, une valeur différente de 0 sinon. Si la table de hachage contient des valeurs d'un type particulier et que B<hash> et B<compare> hache/compare ces types, alors les macros B<DECLARE_LHASH_HASH_FN> et B<IMPLEMENT_LHASH_COMP_FN> peuvent être utilisées pour créer des emballages de rétroaction d'un prototype requis par lh_<type>_new(). Elles offrent un typage par variable avant d'appeler une rétroaction spécifique à un type écrite par l'auteur de l'application. Ces macros, ainsi que celles utilisées pour les appels « doall », sont définies comme suit :

note: type: verbatim
en:  An example of a hash table storing (pointers to) structures of type 'STUFF'
     could be defined as follows;
fr:  Un exemple de table de hachage qui stocke (des pointeurs vers) des 
     structures du type « STUFF » pourrait être défini comme suit :

note: type: verbatim
en:  /* Calculates the hash value of 'tohash' (implemented elsewhere) */
     unsigned long STUFF_hash(const STUFF *tohash);
     /* Orders 'arg1' and 'arg2' (implemented elsewhere) */
     int stuff_cmp(const STUFF *arg1, const STUFF *arg2);
     /* Create the type-safe wrapper functions for use in the LHASH internals */
     static IMPLEMENT_LHASH_HASH_FN(stuff, STUFF);
     static IMPLEMENT_LHASH_COMP_FN(stuff, STUFF);
     /* ... */
     int main(int argc, char *argv[]) {
             /* Create the new hash table using the hash/compare wrappers */
             LHASH_OF(STUFF) *hashtable = lh_STUFF_new(LHASH_HASH_FN(STUFF_hash),
                                       LHASH_COMP_FN(STUFF_cmp));
    	 /* ... */
     }
fr:  /* Calcule la valeur de hachage de « tohash » (implémenté ailleurs) */
     unsigned long STUFF_hash(const STUFF *tohash);
     /* Ordonne « arg1 » et « arg2 » (implémenté ailleurs) */
     int stuff_cmp(const STUFF *arg1, const STUFF *arg2);
     /* Crée un emballage de fonction ayant un type sûr pour utilisation interne dans LHASH */
     static IMPLEMENT_LHASH_HASH_FN(stuff, STUFF);
     static IMPLEMENT_LHASH_COMP_FN(stuff, STUFF);
     /* ... */
     int main(int argc, char *argv[]) {
             /* Crée une nouvelle table de hachage en utilisant les emballages de hachage/comparaison */
             LHASH_OF(STUFF) *hashtable = lh_STUFF_new(LHASH_HASH_FN(STUFF_hash),
                                       LHASH_COMP_FN(STUFF_cmp));
    	 /* ... */
     }

note: type: textblock
en: lh_<type>_free() frees the B<LHASH_OF(<type>> structure B<table>. Allocated hash table entries will not be freed; consider using lh_<type>_doall() to deallocate any remaining entries in the hash table (see below).
fr: lh_<type>_free() libère la structure B<LHASH_OF(<type>)> de B<table>. Les entrées de la table de hachage allouées ne seront pas libérées ; pensez à utiliser lh_<type>_doall() pour désallouer les entrées restantes dans la table de hachage (voir ci-dessous).

note: type: textblock
en: lh_<type>_insert() inserts the structure pointed to by B<data> into B<table>.  If there already is an entry with the same key, the old value is replaced. Note that lh_<type>_insert() stores pointers, the data are not copied.
fr: lh_<type>_insert() insère la structure pointée par B<data> dans B<table>. S'il y a déjà une entrée avec la même clé, l'ancienne valeur est remplacée. Notez que lh_<type>_insert() stocke le pointeur, les données ne sont pas copiées.

note: type: textblock
en: lh_<type>_delete() deletes an entry from B<table>.
fr: lh_<type>_delete() supprime une entrée de B<table>.

note: type: textblock
en: lh_<type>_retrieve() looks up an entry in B<table>. Normally, B<data> is a structure with the key field(s) set; the function will return a pointer to a fully populated structure.
fr: lh_<type>_retrieve() cherche une entée dans B<table>. Normalement, B<data> est une structure avec de(s) champ(s) clé(s) initialisés ; la fonction renverra un pointeur vers une structure entièrement peuplée.

note: type: textblock
en: lh_<type>_doall() will, for every entry in the hash table, call B<func> with the data item as its parameter.  For lh_<type>_doall()  and lh_<type>_doall_arg(), function pointer casting should be avoided in the callbacks (see B<NOTE>) - instead use the declare/implement macros to create type-checked wrappers that cast variables prior to calling your type-specific callbacks.  An example of this is illustrated here where the callback is used to cleanup resources for items in the hash table prior to the hashtable itself being deallocated:
fr: lh_<type>_doall() fera, pour toutes les entrées de la table de hachage, appel à B<func> avec en paramètre l'objet contenant les données. Pour lh_<type>_doall() et lh_<type>_doall_arg(), le forçage de type du pointeur doit être évité dans les rétroactions (voir B<NOTE>) —  au lieu de cela il faut utiliser les macros de déclaration ou implémentation pour créer des emballages avec un type vérifié qui typent les variables avant d'appeler les rétroactions spécifiques aux types. Un exemple de cela est illustré ici avec une rétroaction qui est utilisée pour nettoyer les ressources pour les objets contenus dans la table de hachage avant que la table elle-même soit désallouée.

note: type: verbatim
en:  /* Cleans up resources belonging to 'a' (this is implemented elsewhere) */
     void STUFF_cleanup_doall(STUFF *a);
     /* Implement a prototype-compatible wrapper for "STUFF_cleanup" */
     IMPLEMENT_LHASH_DOALL_FN(STUFF_cleanup, STUFF)
             /* ... then later in the code ... */
     /* So to run "STUFF_cleanup" against all items in a hash table ... */
     lh_STUFF_doall(hashtable, LHASH_DOALL_FN(STUFF_cleanup));
     /* Then the hash table itself can be deallocated */
     lh_STUFF_free(hashtable);
fr:  /* Nettoie les resources qui appartiennent à « a » (ceci est implémenté ailleurs) */
     void STUFF_cleanup_doall(STUFF *a);
     /* implémentation d'un prototype compatible d'emballage pour "STUFF_cleanup » */
     IMPLEMENT_LHASH_DOALL_FN(STUFF_cleanup, STUFF)
             /* ... puis plus tard dans le code ... */
     /* pour lancer « STUFF_cleanup » sur toutes les entrées dans la table de hachage ... */
     lh_STUFF_doall(hashtable, LHASH_DOALL_FN(STUFF_cleanup));
     /* Puis le hachage de la table peut être désalloué */
     lh_STUFF_free(hashtable);

note: type: textblock
en: When doing this, be careful if you delete entries from the hash table in your callbacks: the table may decrease in size, moving the item that you are currently on down lower in the hash table - this could cause some entries to be skipped during the iteration.  The second best solution to this problem is to set hash-E<gt>down_load=0 before you start (which will stop the hash table ever decreasing in size).  The best solution is probably to avoid deleting items from the hash table inside a "doall" callback!
fr: Quand vous faites cela, faites attention si vous supprimez des entrées dans la table de hachage dans vos retours de fonction : la table peut rétrécir, ce qui fera changer de place dans la table de hachage l'objet sur lequel vous travaillez en ce moment, — cela peut causer un saut de certaines entrées pendant l'itération. La deuxième meilleure solution est de régler hash-E<gt>down_load=0 avant de commencer (ce qui empêchera la table de hachage de se raccourcir). La meilleure solution est probablement d'éviter de supprimer des objets de la table de hachage dans un retour « doall ».

note: type: textblock
en: lh_<type>_doall_arg() is the same as lh_<type>_doall() except that B<func> will be called with B<arg> as the second argument and B<func> should be of type B<LHASH_DOALL_ARG_FN_TYPE> (a callback prototype that is passed both the table entry and an extra argument).  As with lh_doall(), you can instead choose to declare your callback with a prototype matching the types you are dealing with and use the declare/implement macros to create compatible wrappers that cast variables before calling your type-specific callbacks.  An example of this is demonstrated here (printing all hash table entries to a BIO that is provided by the caller):
fr: lh_<type>_doall_arg() est identique à lh_<type>_doall() sauf que B<func> sera appelé avec B<arg> comme second argument et B<func> devrait être du type B<LHASH_DOALL_ARG_FN_TYPE> (un prototype de rétroaction qui est passé à la table d'entrée comme un argument supplémentaire). Pour lh_doall(), il est possible de choisir de déclarer une rétroaction personnelle avec un prototype correspondant aux types présents et déclarer ou implémenter des macros pour créer des emballages qui forcent le type des variables avant d'appeler les rétroactions spécifiques à un type. Un exemple de cela est expliqué ici (affichage de toutes les entrées de la table de hachage vers un BIO qui est fourni par l'appelant) :

note: type: verbatim
en:  /* Prints item 'a' to 'output_bio' (this is implemented elsewhere) */
     void STUFF_print_doall_arg(const STUFF *a, BIO *output_bio);
     /* Implement a prototype-compatible wrapper for "STUFF_print" */
     static IMPLEMENT_LHASH_DOALL_ARG_FN(STUFF, const STUFF, BIO)
             /* ... then later in the code ... */
     /* Print out the entire hashtable to a particular BIO */
     lh_STUFF_doall_arg(hashtable, LHASH_DOALL_ARG_FN(STUFF_print), BIO,
                        logging_bio);
fr:  /* Imprime l'objet « a » dans « output bit » (cela est implémenté ailleurs) */
     void STUFF_print_doall_arg(const STUFF *a, BIO *output_bio);
     /* implémentation d'un prototype compatible d'emballage pour « STUFF_print » */
     static IMPLEMENT_LHASH_DOALL_ARG_FN(STUFF, const STUFF, BIO)
             /* ... puis plus tard dans le code ... */
     /* Imprimer toute la table de hachage dans un BIO particulier */
     lh_STUFF_doall_arg(hashtable, LHASH_DOALL_ARG_FN(STUFF_print), BIO,
                        logging_bio);

note: type: textblock
en: lh_<type>_error() can be used to determine if an error occurred in the last operation. lh_<type>_error() is a macro.
fr: lh_<type>_error() peut être utilisée pour déterminer si une erreur s'est produite dans la dernière opération. lh_<type>_error() est une macro.

note: type: textblock
en: lh_<type>_new() returns B<NULL> on error, otherwise a pointer to the new B<LHASH> structure.
fr: lh_<type>_new() renvoie NULL en cas d'erreur, sinon elle renvoie un pointeur vers la nouvelle structure B<LHASH>.

note: type: textblock
en: When a hash table entry is replaced, lh_<type>_insert() returns the value being replaced. B<NULL> is returned on normal operation and on error.
fr: Quand une entrée d'une table de hachage est remplacée, lh_<type>_insert() renvoie la valeur remplacée. NULL est renvoyée lors d'une opération normale et en cas d'erreur.

note: type: textblock
en: lh_<type>_delete() returns the entry being deleted.  B<NULL> is returned if there is no such value in the hash table.
fr: lh_<type>_delete() renvoie l’entrée qui est supprimée. NULL est renvoyée si cette valeur n'existe pas dans la table de hachage.

note: type: textblock
en: lh_<type>_retrieve() returns the hash table entry if it has been found, B<NULL> otherwise.
fr: lh_<type>_retrieve() renvoie l'entrée de la table de hachage si elle a été trouvée, NULL sinon.

note: type: textblock
en: lh_<type>_error() returns 1 if an error occurred in the last operation, 0 otherwise.
fr: lh_<type>_error() renvoie 1 si une erreur s'est produite dans la dernière opération, 0 sinon.

note: type: textblock
en: lh_<type>_free(), lh_<type>_doall() and lh_<type>_doall_arg() return no values.
fr: lh_<type>_free(), lh_<type>_doall() et lh_<type>_doall_arg() ne renvoient pas de valeurs.

note: type: textblock
en: The various LHASH macros and callback types exist to make it possible to write type-checked code without resorting to function-prototype casting - an evil that makes application code much harder to audit/verify and also opens the window of opportunity for stack corruption and other hard-to-find bugs.  It also, apparently, violates ANSI-C.
fr: Les différentes macros et les types retour de fonction LHASH existent pour faire en sorte de rendre la vérification de type du code possible sans forcer une conversion de type — un mal qui rend l'application du code plus difficile à vérifier et qui offre une fenêtre vers les corruptions de pile et d'autres bogues difficiles à trouver. Cela, apparemment, viole la convention ANSI-C.

note: type: textblock
en: The LHASH code regards table entries as constant data.  As such, it internally represents lh_insert()'d items with a "const void *" pointer type.  This is why callbacks such as those used by lh_doall()  and lh_doall_arg() declare their prototypes with "const", even for the parameters that pass back the table items' data pointers - for consistency, user-provided data is "const" at all times as far as the LHASH code is concerned.  However, as callers are themselves providing these pointers, they can choose whether they too should be treating all such parameters as constant.
fr: Le code LHASH voit les entrées de la table comme des données constantes. De ce fait, il représente les objets insérés avec lh_insert() avec un type de pointeur « const void * ». C'est pour cela que les rétroactions comme celles utilisées par lh_doall() et lh_doall_arg() déclarent leurs prototypes avec « const », même pour les paramètres qui renvoient les pointeurs vers les objets de table — par esprit de cohérence, les données fournies par l'utilisateur sont toujours considérées « const » pour le code de LHASH. Mais, comme les appelants fournissent eux-mêmes ces pointeurs, ils peuvent choisir si tous les paramètres doivent être traités comme constants.

note: type: textblock
en: As an example, a hash table may be maintained by code that, for reasons of encapsulation, has only "const" access to the data being indexed in the hash table (ie. it is returned as "const" from elsewhere in their code) - in this case the LHASH prototypes are appropriate as-is.  Conversely, if the caller is responsible for the life-time of the data in question, then they may well wish to make modifications to table item passed back in the lh_doall() or lh_doall_arg() callbacks (see the "STUFF_cleanup" example above).  If so, the caller can either cast the "const" away (if they're providing the raw callbacks themselves) or use the macros to declare/implement the wrapper functions without "const" types.
fr: Comme exemple, une table de hachage peut être maintenue par du code qui, pour des raisons d'encapsulation, a uniquement un accès « const » aux données qui sont indexées dans la table de hachage (c'est-à-dire, il est renvoyé comme « const » dans une autre partie du code) — dans ce cas les prototypes LHASH sont corrects tels quels. Inversement, si l'appelant est responsable de la durée de vie des données en question, alors il souhaitera probablement faire des modifications des objets de la table, envoyés dans lh_doall() ou lh_doall_arg() de façon rétroactive (voir l'exemple « STUFF_cleanup » ci-dessus). Si c'est le cas, l'appelant peut soit forcer le type (s'il fournit les rétroactions elles-mêmes) ou utiliser les macros pour déclarer ou implémenter les emballages des fonctions sans les types « const ».

note: type: textblock
en: Callers that only have "const" access to data they're indexing in a table, yet declare callbacks without constant types (or cast the "const" away themselves), are therefore creating their own risks/bugs without being encouraged to do so by the API.  On a related note, those auditing code should pay special attention to any instances of DECLARE/IMPLEMENT_LHASH_DOALL_[ARG_]_FN macros that provide types without any "const" qualifiers.
fr: Les appelants qui ont seulement un accès à des données « const » dans leurs tables d'indexation, mais qui déclarent des retours sans types constants (ou forcent la suppression de type), créent de ce fait leurs propres risques ou bogues sans y être encouragés par l'API. Dans le même ordre d'idées, lespersonnes vérifiant le code doivent porter une attention toute particulière à une quelconque instance des macros DECLARE/IMPLEMENT_LHASH_DOALL_[ARG_]_FN qui fournissent un type sans qualificatif « const ».

note: type: textblock
en: lh_<type>_insert() returns B<NULL> both for success and error.
fr: lh_<type>_insert() renvoie NULL pour une réussite ou un échec.

note: type: =head1
en: INTERNALS
fr: FONCTIONNEMENT INTERNE

note: type: textblock
en: The following description is based on the SSLeay documentation:
fr: La description suivante est basée sur la documentation de SSLeay :

note: type: textblock
en: The B<lhash> library implements a hash table described in the I<Communications of the ACM> in 1991.  What makes this hash table different is that as the table fills, the hash table is increased (or decreased) in size via OPENSSL_realloc().  When a 'resize' is done, instead of all hashes being redistributed over twice as many 'buckets', one bucket is split.  So when an 'expand' is done, there is only a minimal cost to redistribute some values.  Subsequent inserts will cause more single 'bucket' redistributions but there will never be a sudden large cost due to redistributing all the 'buckets'.
fr: La bibliothèque B<lhash> implémente une table de hachage décrite dans I<Communications of the ACM> en 1991. Ce qui rend cette table de hachage différente est que lors du remplissage de cette table de hachage, sa taille augmente (ou décroît) grâce à OPENSSL_realloc(). Quand un redimensionnement est terminé, au lieu d'avoir une redistribution sur deux fois plus de « compartiments », un compartiment est découpé. De ce fait lorsqu'une « expansion » est faite, le coût de redistribution de certaines valeurs reste minimal. Les insertions suivantes auront pour effet de faire des redistributions sur un seul « compartiment » mais il n'y aura jamais de coût élevé à cause d'une redistribution sur tous les « compartiments ».

note: type: textblock
en: The state for a particular hash table is kept in the B<LHASH> structure.  The decision to increase or decrease the hash table size is made depending on the 'load' of the hash table.  The load is the number of items in the hash table divided by the size of the hash table.  The default values are as follows.  If (hash->up_load E<lt> load) =E<gt> expand.  if (hash-E<gt>down_load E<gt> load) =E<gt> contract.  The B<up_load> has a default value of 1 and B<down_load> has a default value of 2.  These numbers can be modified by the application by just playing with the B<up_load> and B<down_load> variables.  The 'load' is kept in a form which is multiplied by 256.  So hash-E<gt>up_load=8*256; will cause a load of 8 to be set.
fr: L'état d'une table de hachage en particulier est gardé dans une structure B<LHASH>. La décision d'agrandir ou de rapetisser la taille de la table de hachage est faite selon la « charge » de cette table de hachage. La charge est le nombre d'objets divisé par la taille de la table de hachage. Les valeurs par défaut sont les suivantes. Si (hash->up_load E<lt> load) =E<gt>, agrandir. Si (hash-E<gt>down_load E<gt> load) =E<gt>, rapetisser. La valeur par défaut de B<up_load> est 1 et la valeur par défaut de B<down_load> est 2. Ces nombres peuvent être modifiés par l'application en jouant sur la valeur des variables B<up_load> et B<down_load>. La « charge » est gardée sous une forme qui est multipliée par 256. Donc hash-E<gt>up_load=8*256; mettra une charge de 8.

note: type: textblock
en: If you are interested in performance the field to watch is num_comp_calls.  The hash library keeps track of the 'hash' value for each item so when a lookup is done, the 'hashes' are compared, if there is a match, then a full compare is done, and hash-E<gt>num_comp_calls is incremented.  If num_comp_calls is not equal to num_delete plus num_retrieve it means that your hash function is generating hashes that are the same for different values.  It is probably worth changing your hash function if this is the case because even if your hash table has 10 items in a 'bucket', it can be searched with 10 B<unsigned long> compares and 10 linked list traverses.  This will be much less expensive that 10 calls to your compare function.
fr: Si les performances vous intéressent, le champ à regarder est num_comp_calls. La bibliothèque de hachage garde en mémoire toutes les valeurs de hachage pour chaque objet, donc quand une recherche est terminée, les « hachages » sont comparés, s'il y a une correspondance, alors une comparaison entière est faite, et hash-E<gt>num_comp_calls est incrémenté. Si num_comp_calls n'est pas égal à num_delete plus num_retrieve, cela veux dire que les fonctions de hachage génèrent des hachages identiques pour des valeurs différentes. Il est probablement préférable de changer vos fonctions de hachage si c'est le cas car si votre table de hachage a 10 objets dans un « compartiment », il peut être recherché avec 10 comparaisons de B<unsigned long> et des traversées de 10 listes chaînées. Le coût sera bien moins élevé que 10 appels à la fonction de comparaison.

note: type: textblock
en: lh_strhash() is a demo string hashing function:
fr: lh_strhash() est un exemple de fonction de hachage de chaîne.

note: type: textblock
en: Since the B<LHASH> routines would normally be passed structures, this routine would not normally be passed to lh_<type>_new(), rather it would be used in the function passed to lh_<type>_new().
fr: Puisque les routines B<LHASH> sont normalement passées comme structure, cette routine ne serait normalement pas passée à lh_<type>_new(), au lieu de cela elle devrait être utilisée dans la fonction passée à lh_<type>_new(),

note: type: textblock
en: The B<lhash> library is available in all versions of SSLeay and OpenSSL.  lh_error() was added in SSLeay 0.9.1b.
fr: La bibliothèque B<lhash> est disponible dans toutes les versions de SSLeay et d'OpenSSL. lh_error() a été ajoutée dans SSLeay 0.9.1b.

note: type: textblock
en: In OpenSSL 0.9.7, all lhash functions that were passed function pointers were changed for better type safety, and the function types LHASH_COMP_FN_TYPE, LHASH_HASH_FN_TYPE, LHASH_DOALL_FN_TYPE and LHASH_DOALL_ARG_FN_TYPE became available.
fr: Dans OpenSSL 0.9.7, toutes les fonctions de hachage qui étaient passées comme pointeurs de fonction ont été modifiées pour une meilleure sécurité de type, et les types de fonction LHASH_COMP_FN_TYPE, LHASH_HASH_FN_TYPE, LHASH_DOALL_FN_TYPE et LHASH_DOALL_ARG_FN_TYPE sont devenus disponibles.

note: type: textblock
en: In OpenSSL 1.0.0, the lhash interface was revamped for even better type checking.
fr: Dans OpenSSL 1.0.0 l'interface lhash a été remaniée pour une meilleure vérification de types.

note: type: textblock
en: MD2, MD4, MD5, MD2_Init, MD2_Update, MD2_Final, MD4_Init, MD4_Update, MD4_Final, MD5_Init, MD5_Update, MD5_Final - MD2, MD4, and MD5 hash functions
fr: MD2, MD4, MD5, MD2_Init, MD2_Update, MD2_Final, MD4_Init, MD4_Update, MD4_Final, MD5_Init, MD5_Update, MD5_Final - Fonctions de hachage MD2, MD4 et MD5

note: type: textblock
en: MD2, MD4, and MD5 are cryptographic hash functions with a 128 bit output.
fr: MD2, MD4 et MD5 sont des fonctions de hachage cryptographiques avec une sortie de 128 bits.

note: type: textblock
en: MD2(), MD4(), and MD5() compute the MD2, MD4, and MD5 message digest of the B<n> bytes at B<d> and place it in B<md> (which must have space for MD2_DIGEST_LENGTH == MD4_DIGEST_LENGTH == MD5_DIGEST_LENGTH == 16 bytes of output). If B<md> is NULL, the digest is placed in a static array.
fr: MD2(), MD4() et MD5() calculent le condensé de message MD2, MD4 et MD5 des B<n> octets de B<d> et le place dans B<md> (qui doit avoir de la place pour MD2_DIGEST_LENGTH == MD4_DIGEST_LENGTH == MD5_DIGEST_LENGTH == 16 octets de sortie). Si B<md> est NULL, le condensé est placé dans un tableau statique.

note: type: textblock
en: MD2_Init() initializes a B<MD2_CTX> structure.
fr: MD2_Init() initialise une structure B<MD2_CTX>.

note: type: textblock
en: MD2_Update() can be called repeatedly with chunks of the message to be hashed (B<len> bytes at B<data>).
fr: MD2_Update() peut être appelée de façon répétée avec des bouts du message dont il faut calculer le hachage (B<len> octets de B<data>).

note: type: textblock
en: MD2_Final() places the message digest in B<md>, which must have space for MD2_DIGEST_LENGTH == 16 bytes of output, and erases the B<MD2_CTX>.
fr: MD2_Final() place le condensé du message dans B<md>, qui doit avoir de la place pour MD2_DIGEST_LENGTH == 16 octets de données, et efface B<MD2_CTX>.

note: type: textblock
en: MD4_Init(), MD4_Update(), MD4_Final(), MD5_Init(), MD5_Update(), and MD5_Final() are analogous using an B<MD4_CTX> and B<MD5_CTX> structure.
fr: MD4_Init(), MD4_Update(), MD4_Final(), MD5_Init(), MD5_Update() et MD5_Final() sont similaires mais utilisent des structures B<MD4_CTX> et B<MD5_CTX>.

note: type: textblock
en: Applications should use the higher level functions L<EVP_DigestInit(3)|EVP_DigestInit(3)> etc. instead of calling the hash functions directly.
fr: Les applications devraient utiliser les fonctions de haut niveau L<EVP_DigestInit(3)|EVP_DigestInit(3)>, etc. plutôt que d'appeler les fonctions de hachage directement.

note: type: textblock
en: MD2, MD4, and MD5 are recommended only for compatibility with existing applications. In new applications, SHA-1 or RIPEMD-160 should be preferred.
fr: MD2, MD4 et MD5 ne sont recommandés que pour la compatibilité avec des applications existantes. Les nouvelles applications devraient utiliser SHA-1 ou RIPEMD-160.

note: type: textblock
en: MD2(), MD4(), and MD5() return pointers to the hash value.
fr: MD2(), MD4() et MD5 () renvoient un pointeur vers la valeur de hachage.

note: type: textblock
en: MD2_Init(), MD2_Update(), MD2_Final(), MD4_Init(), MD4_Update(), MD4_Final(), MD5_Init(), MD5_Update(), and MD5_Final() return 1 for success, 0 otherwise.
fr: MD2_Init(), MD2_Update(), MD2_Final(), MD4_Init(), MD4_Update(), MD4_Final(), MD5_Init(), MD5_Update() et MD5_Final() renvoient 1 en cas de succès et 0 sinon.

note: type: textblock
en: MD2(), MD2_Init(), MD2_Update() MD2_Final(), MD5(), MD5_Init(), MD5_Update() and MD5_Final() are available in all versions of SSLeay and OpenSSL.
fr: MD2(), MD2_Init(), MD2_Update(), MD2_Final(), MD5(), MD5_Init(), MD5_Update() et MD5_Final() sont disponibles dans toutes les versions de SSLeay et d'OpenSSL.

note: type: textblock
en: MD4(), MD4_Init(), and MD4_Update() are available in OpenSSL 0.9.6 and above.
fr: MD4(), MD4_Init() et MD4_Update() sont disponibles dans OpenSSL à partir de la version 0.9.6.

note: type: textblock
en: MDC2, MDC2_Init, MDC2_Update, MDC2_Final - MDC2 hash function
fr: MDC2, MDC2_Init, MDC2_Update, MDC2_Final - Fonction de hachage MDC2

note: type: textblock
en: MDC2 is a method to construct hash functions with 128 bit output from block ciphers.  These functions are an implementation of MDC2 with DES.
fr: MDC2 est une méthode pour construire des fonctions de hachage avec une sortie de 128 bits à partir d'algorithmes de chiffrement par blocs. Ces fonctions sont une implémentation de MDC2 basée sur DES.

note: type: textblock
en: MDC2() computes the MDC2 message digest of the B<n> bytes at B<d> and places it in B<md> (which must have space for MDC2_DIGEST_LENGTH == 16 bytes of output). If B<md> is NULL, the digest is placed in a static array.
fr: MDC2() calcule le condensé de message MDC2 des B<n> octets de B<d> et le place dans B<md> (qui doit avoir de la place pour MDC2_DIGEST_LENGTH == 16 octets de sortie). Si B<md> est NULL, le condensé est placé dans un tableau statique.

note: type: textblock
en: MDC2_Init() initializes a B<MDC2_CTX> structure.
fr: MDC2_Init() initialise une structure B<MDC2_CTX>.

note: type: textblock
en: MDC2_Update() can be called repeatedly with chunks of the message to be hashed (B<len> bytes at B<data>).
fr: MDC2_Update() peut être appelée de façon répétée avec des bouts du message dont il faut calculer le hachage (B<len> octets de B<data>).

note: type: textblock
en: MDC2_Final() places the message digest in B<md>, which must have space for MDC2_DIGEST_LENGTH == 16 bytes of output, and erases the B<MDC2_CTX>.
fr: MDC2_Final() place le condensé du message dans B<md>, qui doit avoir de la place pour MDC2_DIGEST_LENGTH == 16 octets de données, et efface B<MDC2_CTX>.

note: type: textblock
en: MDC2() returns a pointer to the hash value.
fr: MDC2() renvoie un pointeur vers la valeur du hachage.

note: type: textblock
en: MDC2_Init(), MDC2_Update() and MDC2_Final() return 1 for success, 0 otherwise.
fr: MDC2_Init(), MDC2_Update() et MDC2_Final() renvoient 1 en cas de succès et 0 sinon.

note: type: textblock
en: ISO/IEC 10118-2, with DES
fr: ISO/IEC 10118-2, avec DES

note: type: textblock
en: MDC2(), MDC2_Init(), MDC2_Update() and MDC2_Final() are available since SSLeay 0.8.
fr: MDC2(), MDC2_Init(), MDC2_Update() et MDC2_Final() sont disponibles depuis SSLeay 0.8.

note: type: textblock
en: PEM, PEM_read_bio_PrivateKey, PEM_read_PrivateKey, PEM_write_bio_PrivateKey, PEM_write_PrivateKey, PEM_write_bio_PKCS8PrivateKey, PEM_write_PKCS8PrivateKey, PEM_write_bio_PKCS8PrivateKey_nid, PEM_write_PKCS8PrivateKey_nid, PEM_read_bio_PUBKEY, PEM_read_PUBKEY, PEM_write_bio_PUBKEY, PEM_write_PUBKEY, PEM_read_bio_RSAPrivateKey, PEM_read_RSAPrivateKey, PEM_write_bio_RSAPrivateKey, PEM_write_RSAPrivateKey, PEM_read_bio_RSAPublicKey, PEM_read_RSAPublicKey, PEM_write_bio_RSAPublicKey, PEM_write_RSAPublicKey, PEM_read_bio_RSA_PUBKEY, PEM_read_RSA_PUBKEY, PEM_write_bio_RSA_PUBKEY, PEM_write_RSA_PUBKEY, PEM_read_bio_DSAPrivateKey, PEM_read_DSAPrivateKey, PEM_write_bio_DSAPrivateKey, PEM_write_DSAPrivateKey, PEM_read_bio_DSA_PUBKEY, PEM_read_DSA_PUBKEY, PEM_write_bio_DSA_PUBKEY, PEM_write_DSA_PUBKEY, PEM_read_bio_DSAparams, PEM_read_DSAparams, PEM_write_bio_DSAparams, PEM_write_DSAparams, PEM_read_bio_DHparams, PEM_read_DHparams, PEM_write_bio_DHparams, PEM_write_DHparams, PEM_read_bio_X509, PEM_read_X509, PEM_write_bio_X509, PEM_write_X509, PEM_read_bio_X509_AUX, PEM_read_X509_AUX, PEM_write_bio_X509_AUX, PEM_write_X509_AUX, PEM_read_bio_X509_REQ, PEM_read_X509_REQ, PEM_write_bio_X509_REQ, PEM_write_X509_REQ, PEM_write_bio_X509_REQ_NEW, PEM_write_X509_REQ_NEW, PEM_read_bio_X509_CRL, PEM_read_X509_CRL, PEM_write_bio_X509_CRL, PEM_write_X509_CRL, PEM_read_bio_PKCS7, PEM_read_PKCS7, PEM_write_bio_PKCS7, PEM_write_PKCS7, PEM_read_bio_NETSCAPE_CERT_SEQUENCE, PEM_read_NETSCAPE_CERT_SEQUENCE, PEM_write_bio_NETSCAPE_CERT_SEQUENCE, PEM_write_NETSCAPE_CERT_SEQUENCE - PEM routines
fr: PEM, PEM_read_bio_PrivateKey, PEM_read_PrivateKey, PEM_write_bio_PrivateKey, PEM_write_PrivateKey, PEM_write_bio_PKCS8PrivateKey, PEM_write_PKCS8PrivateKey, PEM_write_bio_PKCS8PrivateKey_nid, PEM_write_PKCS8PrivateKey_nid, PEM_read_bio_PUBKEY, PEM_read_PUBKEY, PEM_write_bio_PUBKEY, PEM_write_PUBKEY, PEM_read_bio_RSAPrivateKey, PEM_read_RSAPrivateKey, PEM_write_bio_RSAPrivateKey, PEM_write_RSAPrivateKey, PEM_read_bio_RSAPublicKey, PEM_read_RSAPublicKey, PEM_write_bio_RSAPublicKey, PEM_write_RSAPublicKey, PEM_read_bio_RSA_PUBKEY, PEM_read_RSA_PUBKEY, PEM_write_bio_RSA_PUBKEY, PEM_write_RSA_PUBKEY, PEM_read_bio_DSAPrivateKey, PEM_read_DSAPrivateKey, PEM_write_bio_DSAPrivateKey, PEM_write_DSAPrivateKey, PEM_read_bio_DSA_PUBKEY, PEM_read_DSA_PUBKEY, PEM_write_bio_DSA_PUBKEY, PEM_write_DSA_PUBKEY, PEM_read_bio_DSAparams, PEM_read_DSAparams, PEM_write_bio_DSAparams, PEM_write_DSAparams, PEM_read_bio_DHparams, PEM_read_DHparams, PEM_write_bio_DHparams, PEM_write_DHparams, PEM_read_bio_X509, PEM_read_X509, PEM_write_bio_X509, PEM_write_X509, PEM_read_bio_X509_AUX, PEM_read_X509_AUX, PEM_write_bio_X509_AUX, PEM_write_X509_AUX, PEM_read_bio_X509_REQ, PEM_read_X509_REQ, PEM_write_bio_X509_REQ, PEM_write_X509_REQ, PEM_write_bio_X509_REQ_NEW, PEM_write_X509_REQ_NEW, PEM_read_bio_X509_CRL, PEM_read_X509_CRL, PEM_write_bio_X509_CRL, PEM_write_X509_CRL, PEM_read_bio_PKCS7, PEM_read_PKCS7, PEM_write_bio_PKCS7, PEM_write_PKCS7, PEM_read_bio_NETSCAPE_CERT_SEQUENCE, PEM_read_NETSCAPE_CERT_SEQUENCE, PEM_write_bio_NETSCAPE_CERT_SEQUENCE, PEM_write_NETSCAPE_CERT_SEQUENCE - routines PEM

note: type: textblock
en: The PEM functions read or write structures in PEM format. In this sense PEM format is simply base64 encoded data surrounded by header lines.
fr: Les fonctions PEM lisent ou écrivent des structures au format PEM. En ce sens, le format PEM est simplement des données chiffrées en base64 entourées de lignes d'en-tête.

note: type: textblock
en: For more details about the meaning of arguments see the B<PEM FUNCTION ARGUMENTS> section.
fr: Pour plus de détails sur la signification des arguments, voir la partie B<ARGUMENTS DES FONCTIONS PEM>.

note: type: textblock
en: Each operation has four functions associated with it. For clarity the term "B<foobar> functions" will be used to collectively refer to the PEM_read_bio_foobar(), PEM_read_foobar(), PEM_write_bio_foobar() and PEM_write_foobar() functions.
fr: Chaque opération possède 4 fonctions qui lui sont associées. Pour clarifier le terme « fonctions B<foobar> » sera utilisé pour faire collectivement référence aux fonctions PEM_read_bio_foobar(), PEM_read_foobar(), PEM_write_bio_foobar() et PEM_write_foobar()

note: type: textblock
en: The B<PrivateKey> functions read or write a private key in PEM format using an EVP_PKEY structure. The write routines use "traditional" private key format and can handle both RSA and DSA private keys. The read functions can additionally transparently handle PKCS#8 format encrypted and unencrypted keys too.
fr: La fonction B<PrivateKey> lit et écrit une clé privée dans le format PEM en utilisant une structure EVP_PKEY. Les routines d'écriture utilisent une clé privée au format « traditionnel » et peuvent gérer les clés privées RSA et DSA. Les fonctions de lecture peuvent aussi gérer de façon transparente les clés chiffrées et déchiffrées au format PKCS#8.

note: type: textblock
en: PEM_write_bio_PKCS8PrivateKey() and PEM_write_PKCS8PrivateKey()  write a private key in an EVP_PKEY structure in PKCS#8 EncryptedPrivateKeyInfo format using PKCS#5 v2.0 password based encryption algorithms. The B<cipher> argument specifies the encryption algorithm to use: unlike all other PEM routines the encryption is applied at the PKCS#8 level and not in the PEM headers. If B<cipher> is NULL then no encryption is used and a PKCS#8 PrivateKeyInfo structure is used instead.
fr: PEM_write_bio_PKCS8PrivateKey() et PEM_write_PKCS8PrivateKey() écrivent une clé privée dans une structure EVP_PKEY dans le format PKCS#8 EncryptedPrivateKeyInfo en utilisant un algorithme de mot de passe basé sur PKCS#5 v2.0. L'argument B<cipher> spécifie l'algorithme de chiffrement à utiliser : contrairement à toutes les autres routines PEM, le chiffrement est appliqué au niveau du PKCS#8 et pas dans les en-têtes PEM. Si B<cipher> est NULL alors il n'y aura pas de chiffrement utilisé et une structure PKCS#8 PrivateKeyInfo sera utilisée.

note: type: textblock
en: PEM_write_bio_PKCS8PrivateKey_nid() and PEM_write_PKCS8PrivateKey_nid()  also write out a private key as a PKCS#8 EncryptedPrivateKeyInfo however it uses PKCS#5 v1.5 or PKCS#12 encryption algorithms instead. The algorithm to use is specified in the B<nid> parameter and should be the NID of the corresponding OBJECT IDENTIFIER (see NOTES section).
fr: PEM_write_bio_PKCS8PrivateKey_nid() et PEM_write_PKCS8PrivateKey_nid() écrivent aussi une clé privée comme PKCS#8 EncryptedPrivateKeyInfo cependant elles utilisent les algorithmes de chiffrement KCS#5 v1.5 ou PKCS#12 à la place. L'algorithme à utiliser dans le paramètre B<nid> doit être le NID de l'IDENTIFIANT DE L'OBJET (voir la section NOTES).

note: type: textblock
en: The B<PUBKEY> functions process a public key using an EVP_PKEY structure. The public key is encoded as a SubjectPublicKeyInfo structure.
fr: Les fonctions B<PUBKEY> traitent une clé publique en utilisant une structure EVP_PKEY. La clé publique est chiffrée comme une structure SubjectPublicKeyInfo.

note: type: textblock
en: The B<RSAPrivateKey> functions process an RSA private key using an RSA structure. It handles the same formats as the B<PrivateKey> functions but an error occurs if the private key is not RSA.
fr: Les fonctions B<RSAPrivateKey> traitent une clé RSA privée en utilisant une structure RSA. Elles gèrent le même format que les fonctions B<PrivateKey> mais une erreur se produit si la clé privée n'est pas une clé RSA.

note: type: textblock
en: The B<RSAPublicKey> functions process an RSA public key using an RSA structure. The public key is encoded using a PKCS#1 RSAPublicKey structure.
fr: Les fonctions B<RSAPublicKey> traitent une clé RSA publique en utilisant une structure RSA. La clé publique est chiffrée en utilisant une structure PKCS#1 RSAPublicKey

note: type: textblock
en: The B<RSA_PUBKEY> functions also process an RSA public key using an RSA structure. However the public key is encoded using a SubjectPublicKeyInfo structure and an error occurs if the public key is not RSA.
fr: Les fonctions B<RSA_PUBKEY> traitent aussi une clé publique en utilisant une structure RSA. Mais la clé publique est chiffrée en utilisant une structure SubjectPublicKeyInfo et une erreur se produit si la clé publique n'est pas une clé RSA.

note: type: textblock
en: The B<DSAPrivateKey> functions process a DSA private key using a DSA structure. It handles the same formats as the B<PrivateKey> functions but an error occurs if the private key is not DSA.
fr: Les fonctions B<DSAPrivateKey> traitent une clé DSA privée en utilisant une structure DSA. Elles gèrent les mêmes formats que les fonctions B<PrivateKey> mais une erreur se produit si la clé privée n'est pas une clé DSA.

note: type: textblock
en: The B<DSA_PUBKEY> functions process a DSA public key using a DSA structure. The public key is encoded using a SubjectPublicKeyInfo structure and an error occurs if the public key is not DSA.
fr: Les fonctions B<DSA_PUBKEY> traitent une clé publique DSA en utilisant une structure DSA. La clé publique est chiffrée en utilisant une structure SubjectPublicKeyInfo et une erreur se produit si la clé publique n'est pas une clé DSA.

note: type: textblock
en: The B<DSAparams> functions process DSA parameters using a DSA structure. The parameters are encoded using a Dss-Parms structure as defined in RFC2459.
fr: Les fonctions B<DSAparams> traitent les paramètres DSA en utilisant une structure DSA. Les paramètres sont chiffrés en utilisant une structure Dss-Parms telle que définie dans la RFC2459.

note: type: textblock
en: The B<DHparams> functions process DH parameters using a DH structure. The parameters are encoded using a PKCS#3 DHparameter structure.
fr: Les fonctions B<DHparams> traitent les paramètres DH en utilisant une structure DH. Les paramètres sont chiffrés en utilisant une structure PKCS#3 DHparameter

note: type: textblock
en: The B<X509> functions process an X509 certificate using an X509 structure. They will also process a trusted X509 certificate but any trust settings are discarded.
fr: Les fonctions B<X509> traitent un certificat X509 en utilisant une structure X509. Elles traitent aussi les certificats X509 certifiés mais les paramètres de réglages sont ignorés.

note: type: textblock
en: The B<X509_AUX> functions process a trusted X509 certificate using an X509 structure.
fr: Les fonctions B<X509_AUX> traitent un certificat X509 certifié en utilisant une structure X509.

note: type: textblock
en: The B<X509_REQ> and B<X509_REQ_NEW> functions process a PKCS#10 certificate request using an X509_REQ structure. The B<X509_REQ> write functions use B<CERTIFICATE REQUEST> in the header whereas the B<X509_REQ_NEW> functions use B<NEW CERTIFICATE REQUEST> (as required by some CAs). The B<X509_REQ> read functions will handle either form so there are no B<X509_REQ_NEW> read functions.
fr: Les fonctions B<X509_REQ> et B<X509_REQ_NEW> traitent une requête de certificat PKCS#10 en utilisant une structure X509_REQ. La fonction d'écriture B<X509_REQ> utilise B<CERTIFICATE REQUEST> dans l'en-tête alors que les fonctions B<X509_REQ_NEW> utilisent B<NEW CERTIFICATE REQUEST> (comme requis par des CA). Les fonctions de lecture B<X509_REQ> peuvent gérer les deux formes, il n'y a donc pas de fonctions de lecture B<X509_REQ_NEW>.

note: type: textblock
en: The B<X509_CRL> functions process an X509 CRL using an X509_CRL structure.
fr: Les fonctions B<X509_CRL> traitent un CRL X509 en utilisant une structure X509_CRL.

note: type: textblock
en: The B<PKCS7> functions process a PKCS#7 ContentInfo using a PKCS7 structure.
fr: Les fonctions B<PKCS7> traitent un PKCS#7 ContentInfo en utilisant une structure PKCS7.

note: type: textblock
en: The B<NETSCAPE_CERT_SEQUENCE> functions process a Netscape Certificate Sequence using a NETSCAPE_CERT_SEQUENCE structure.
fr: Les fonctions B<NETSCAPE_CERT_SEQUENCE> traitent une séquence de certificats Netscape en utilisant une structure NETSCAPE_CERT_SEQUENCE.

note: type: =head1
en: PEM FUNCTION ARGUMENTS
fr: ARGUMENTS DES FONCTIONS PEM

note: type: textblock
en: The PEM functions have many common arguments.
fr: Les fonctions PEM ont beaucoup d'arguments en commun.

note: type: textblock
en: The B<bp> BIO parameter (if present) specifies the BIO to read from or write to.
fr: Les paramètres B<bp> (si présents) spécifient le BIO dans lequel il faut lire ou écrire.

note: type: textblock
en: The B<fp> FILE parameter (if present) specifies the FILE pointer to read from or write to.
fr: Le paramètre de FILE B<fp> (si présent) spécifie le pointeur de FILE dans lequel il faut lire ou écrire.

note: type: textblock
en: The PEM read functions all take an argument B<TYPE **x> and return a B<TYPE *> pointer. Where B<TYPE> is whatever structure the function uses. If B<x> is NULL then the parameter is ignored. If B<x> is not NULL but B<*x> is NULL then the structure returned will be written to B<*x>. If neither B<x> nor B<*x> is NULL then an attempt is made to reuse the structure at B<*x> (but see BUGS and EXAMPLES sections).  Irrespective of the value of B<x> a pointer to the structure is always returned (or NULL if an error occurred).
fr: Les fonctions de lecture PEM prennent toutes un argument B<TYPE **x> et renvoient toutes un pointeur B<TYPE *>, où B<TYPE> est une structure quelconque que la fonction utilise. Si B<x> est NULL, alors le paramètre est ignoré. Si B<x> n'est pas NULL mais B<*x> est NULL, alors la structure renvoyée sera écrite dans B<*x>. Si ni B<x> et B<*x> ne sont NULL, alors une tentative de réutilisation de la structure sera faite (mais voir la partie BOGUES et EXEMPLES). Quelle que soit la valeur de B<x>, un pointeur vers une structure est toujours renvoyé (ou NULL en cas d'erreur).

note: type: textblock
en: The PEM functions which write private keys take an B<enc> parameter which specifies the encryption algorithm to use, encryption is done at the PEM level. If this parameter is set to NULL then the private key is written in unencrypted form.
fr: Les fonctions PEM qui utilisent des clés privées prennent un paramètre B<enc> qui spécifie l'algorithme de chiffrement à utiliser, le chiffrement est fait au niveau du PEM. Si ce paramètre est mis à NULL, alors la clé privée est écrite de façon non chiffrée.

note: type: textblock
en: The B<cb> argument is the callback to use when querying for the pass phrase used for encrypted PEM structures (normally only private keys).
fr: L'argument B<cb> est le rappel à utiliser pour les requêtes pour le mot de passe utilisé pour chiffrer les structures PEM (que des clés privées normalement).

note: type: textblock
en: For the PEM write routines if the B<kstr> parameter is not NULL then B<klen> bytes at B<kstr> are used as the passphrase and B<cb> is ignored.
fr: Pour les routines d'écritures PEM, si le paramètre B<kstr> n'est pas NULL, alors B<klen> octets à B<kstr> sont utilisés comme mot de passe et B<cb> est ignoré.

note: type: textblock
en: If the B<cb> parameters is set to NULL and the B<u> parameter is not NULL then the B<u> parameter is interpreted as a null terminated string to use as the passphrase. If both B<cb> and B<u> are NULL then the default callback routine is used which will typically prompt for the passphrase on the current terminal with echoing turned off.
fr: Si les paramètres B<cb> sont initialisés à NULL et que le paramètre B<u> n'est pas NULL, alors le paramètre B<u> n'est pas correctement interprété comme une chaîne de caractère terminée par un null à utiliser comme mot de passe. Si B<cb> et B<u> sont NULL, alors la routine de retour est utilisée, ce qui affiche généralement une demande d'entrée de texte pour le mot de passe sur le terminal courant et sans affichage de l'entrée.

note: type: textblock
en: The default passphrase callback is sometimes inappropriate (for example in a GUI application) so an alternative can be supplied. The callback routine has the following form:
fr: Le rappel du mot de passe par défaut n'est parfois pas approprié (par exemple dans une application à interface graphique), une alternative peut donc être fournie. La routine de retour de fonction a la forme suivante :

note: type: textblock
en: B<buf> is the buffer to write the passphrase to. B<size> is the maximum length of the passphrase (i.e. the size of buf). B<rwflag> is a flag which is set to 0 when reading and 1 when writing. A typical routine will ask the user to verify the passphrase (for example by prompting for it twice) if B<rwflag> is 1. The B<u> parameter has the same value as the B<u> parameter passed to the PEM routine. It allows arbitrary data to be passed to the callback by the application (for example a window handle in a GUI application). The callback B<must> return the number of characters in the passphrase or 0 if an error occurred.
fr: B<buf> est le tampon d'écriture dans lequel sera écrit le mot de passe. B<size> est la taille maximale du mot de passe (c'est-à-dire la taille du tampon). B<rwflag> est un drapeau qui est mis à 0 lors d'une lecture et à 1 lors d'une écriture. Une routine typique demandera à l'utilisateur de vérifier le mot de passe (par exemple pour le demander deux fois) si B<rwflag>est à 1. Le paramètre B<u> a la même valeur que le paramètre B<u> passé à la routine PEM. Il autorise l'application à passer des données arbitraires à la rétroaction (par exemple un gestionnaire de fenêtres dans une application à interface graphique). La rétroaction B<doit> renvoyer le nombre de caractères dans le mot de passe ou 0 en cas d'erreur.

note: type: textblock
en: Although the PEM routines take several arguments in almost all applications most of them are set to 0 or NULL.
fr: Bien que les routines PEM prennent plusieurs arguments, dans presque toutes leurs applications ceux-ci sont mis à 0 ou NULL.

note: type: textblock
en: Read a certificate in PEM format from a BIO:
fr: Lire un certificat dans le format PEM à partir d'un BIO :

note: type: verbatim
en:  X509 *x;
     x = PEM_read_bio_X509(bp, NULL, 0, NULL);
     if (x == NULL)
    	{
    	/* Error */
    	}
fr:  X509 *x;
     x = PEM_read_bio_X509(bp, NULL, 0, NULL);
     if (x == NULL)
    	{
    	/* Erreur */
    	}

note: type: textblock
en: Alternative method:
fr: Méthodes alternatives :

note: type: verbatim
en:  X509 *x = NULL;
     if (!PEM_read_bio_X509(bp, &x, 0, NULL))
    	{
    	/* Error */
    	}
fr:  X509 *x = NULL;
     if (!PEM_read_bio_X509(bp, &x, 0, NULL))
    	{
    	/* Erreur */
    	}

note: type: textblock
en: Write a certificate to a BIO:
fr: Écrire un certificat dans un BIO :

note: type: verbatim
en:  if (!PEM_write_bio_X509(bp, x))
    	{
    	/* Error */
    	}
fr:  if (!PEM_write_bio_X509(bp, x))
    	{
    	/* Erreur */
    	}

note: type: textblock
en: Write an unencrypted private key to a FILE pointer:
fr: Écrire une clé non chiffrée dans un pointeur FILE :

note: type: verbatim
en:  if (!PEM_write_PrivateKey(fp, key, NULL, NULL, 0, 0, NULL))
    	{
    	/* Error */
    	}
fr:  if (!PEM_write_PrivateKey(fp, key, NULL, NULL, 0, 0, NULL))
    	{
    	/* Erreur */
    	}

note: type: textblock
en: Write a private key (using traditional format) to a BIO using triple DES encryption, the pass phrase is prompted for:
fr: Écrire une clé privée (en utilisant le format traditionnel) dans un BIO en utilisant un chiffrement Triple-DES, le mot de passe est requis :

note: type: verbatim
en:  if (!PEM_write_bio_PrivateKey(bp, key, EVP_des_ede3_cbc(), NULL, 0, 0, NULL))
    	{
    	/* Error */
    	}
fr:  if (!PEM_write_bio_PrivateKey(bp, key, EVP_des_ede3_cbc(), NULL, 0, 0, NULL))
    	{
    	/* Erreur */
    	}

note: type: textblock
en: Write a private key (using PKCS#8 format) to a BIO using triple DES encryption, using the pass phrase "hello":
fr: Écrire une clé privée (en utilisant le format PKCS#8) dans un BIO en utilisant le chiffrement Triple-DES, en utilisant le mot de passe « hello » :

note: type: verbatim
en:  if (!PEM_write_bio_PKCS8PrivateKey(bp, key, EVP_des_ede3_cbc(), NULL, 0, 0, "hello"))
    	{
    	/* Error */
    	}
fr:  if (!PEM_write_bio_PKCS8PrivateKey(bp, key, EVP_des_ede3_cbc(), NULL, 0, 0, "hello"))
    	{
    	/* Erreur */
    	}

note: type: textblock
en: Read a private key from a BIO using the pass phrase "hello":
fr: Lire une clé privée d'un BIO en utilisant le mot de passe « hello » :

note: type: verbatim
en:  key = PEM_read_bio_PrivateKey(bp, NULL, 0, "hello");
     if (key == NULL)
    	{
    	/* Error */
    	}
fr:  key = PEM_read_bio_PrivateKey(bp, NULL, 0, "hello");
     if (key == NULL)
    	{
    	/* Erreur */
    	}

note: type: textblock
en: Read a private key from a BIO using a pass phrase callback:
fr: Lire une clé privée d'un BIO en utilisant le rappel de phrase secrète :

note: type: verbatim
en:  key = PEM_read_bio_PrivateKey(bp, NULL, pass_cb, "My Private Key");
     if (key == NULL)
    	{
    	/* Error */
    	}
fr:  key = PEM_read_bio_PrivateKey(bp, NULL, pass_cb, "My Private Key");
     if (key == NULL)
    	{
    	/* Erreur */
    	}

note: type: textblock
en: Skeleton pass phrase callback:
fr: Squelette de rappel de phrase secrète :

note: type: verbatim
en:  int pass_cb(char *buf, int size, int rwflag, void *u);
    	{
    	int len;
    	char *tmp;
    	/* We'd probably do something else if 'rwflag' is 1 */
    	printf("Enter pass phrase for \"%s\"\n", u);
fr:  int pass_cb(char *buf, int size, int rwflag, void *u);
    	{
    	int len;
    	char *tmp;
    	/* On ferait probablement autre chose si 'rwflag' était à 1 */
    	printf("Enter pass phrase for \"%s\"\n", u);

note: type: verbatim
en: 	/* get pass phrase, length 'len' into 'tmp' */
    	tmp = "hello";
    	len = strlen(tmp);
fr: 	/* obtenir la phrase chiffrée, longueur 'len' dans 'tmp' */
    	tmp = "hello";
    	len = strlen(tmp);

note: type: textblock
en: The old B<PrivateKey> write routines are retained for compatibility.  New applications should write private keys using the PEM_write_bio_PKCS8PrivateKey() or PEM_write_PKCS8PrivateKey() routines because they are more secure (they use an iteration count of 2048 whereas the traditional routines use a count of 1) unless compatibility with older versions of OpenSSL is important.
fr: Les anciennes routines d'écriture B<PrivateKey> sont gardées pour raisons de comptabilité. Les nouvelles applications doivent écrire de nouvelles clés privées en utilisant les routines PEM_write_bio_PKCS8PrivateKey() ou PEM_write_PKCS8PrivateKey() car elles sont plus sécurisées (elles utilisent un compteur d'itération sur 2048 alors que les routines traditionnelles utilisent un compteur de 1) sauf si la compatibilité avec les anciennes versions d'OpenSSL est importante.

note: type: textblock
en: The B<PrivateKey> read routines can be used in all applications because they handle all formats transparently.
fr: Les routines de lecture B<PrivateKey> peuvent être utilisées dans toutes les applications car elles manipulent tous les formats de façon transparente.

note: type: textblock
en: A frequent cause of problems is attempting to use the PEM routines like this:
fr: Un cas récurrent de problèmes est la tentative d'utilisation des routines PEM de la façon suivante :

note: type: textblock
en: this is a bug because an attempt will be made to reuse the data at B<x> which is an uninitialised pointer.
fr: cela est un bogue car une tentative de réutilisation des données à B<x> sera faite alors que c'est un pointeur qui n'est pas initialisé.

note: type: =head1
en: PEM ENCRYPTION FORMAT
fr: FORMAT DE CHIFFREMENT PEM

note: type: textblock
en: This old B<PrivateKey> routines use a non standard technique for encryption.
fr: Cette vieille routine B<PrivateKey> utilise une méthode non standard de chiffrement.

note: type: textblock
en: The private key (or other data) takes the following form:
fr: La clé privée (ou toute autre donnée) prend la forme suivante :

note: type: verbatim
en:  -----BEGIN RSA PRIVATE KEY-----
     Proc-Type: 4,ENCRYPTED
     DEK-Info: DES-EDE3-CBC,3F17F5316E2BAC89
fr:  -----DÉBUT CLÉ PRIVÉE RSA-----
     Proc-Type: 4,ENCRYPTED
     DEK-Info: DES-EDE3-CBC,3F17F5316E2BAC89

note: type: verbatim
en:  ...base64 encoded data...
     -----END RSA PRIVATE KEY-----
fr:  ...données encodées en base64...
     -----FIN CLÉ PRIVÉE RSA-----

note: type: textblock
en: The line beginning DEK-Info contains two comma separated pieces of information: the encryption algorithm name as used by EVP_get_cipherbyname() and an 8 byte B<salt> encoded as a set of hexadecimal digits.
fr: La ligne qui commence DEK-Info contient deux virgules séparées par des morceaux d'information : le nom de l'algorithme de chiffrement comme utilisé par EVP_get_cipherbyname() et un B<salt> de 8 octets chiffré comme un ensemble de valeurs hexadécimales.

note: type: textblock
en: After this is the base64 encoded encrypted data.
fr: Après ce sont les données chiffrées en base64.

note: type: textblock
en: The encryption key is determined using EVP_BytesToKey(), using B<salt> and an iteration count of 1. The IV used is the value of B<salt> and *not* the IV returned by EVP_BytesToKey().
fr: La clé de chiffrement est déterminée en utilisant EVP_Bytestokey(), en utilisant B<salt> et un compteur d'itération de 1. Le IV utilisé est la valeur de B<salt> et *pas* le IV renvoyé par EVP_Bytestokey().

note: type: textblock
en: The PEM read routines in some versions of OpenSSL will not correctly reuse an existing structure. Therefore the following:
fr: Les routines de lecture PEM, dans certaines versions d'OpenSSL, n'utiliseront pas correctement les structures existantes. De ce fait, ce qui suit :

note: type: textblock
en: where B<x> already contains a valid certificate, may not work, whereas:
fr: où B<x> contient déjà un certificat valable, risque de ne pas fonctionner, alors que :

note: type: textblock
en: is guaranteed to work.
fr: est garanti de fonctionner.

note: type: =head1
en: RETURN CODES
fr: CODES DE RETOUR

note: type: textblock
en: The read routines return either a pointer to the structure read or NULL if an error occurred.
fr: Les routines de lectures renvoient soit un pointeur vers la structure read ou NULL si une erreur s'est produite.

note: type: textblock
en: The write routines return 1 for success or 0 for failure.
fr: La routine d'écriture renvoie 1 en cas de succès et 0 en cas d'échec.

note: type: textblock
en: L<EVP_get_cipherbyname(3)|EVP_get_cipherbyname>, L<EVP_BytesToKey(3)|EVP_BytesToKey(3)>
fr: L<B<EVP_get_cipherbyname>(3)|EVP_get_cipherbyname>, L<B<EVP_BytesToKey>(3)|EVP_BytesToKey(3)>

note: type: textblock
en: RC4_set_key, RC4 - RC4 encryption
fr: RC4_set_key, RC4 - chiffrement RC4

note: type: textblock
en: This library implements the Alleged RC4 cipher, which is described for example in I<Applied Cryptography>.  It is believed to be compatible with RC4[TM], a proprietary cipher of RSA Security Inc.
fr: La bibliothèque implémente le chiffrement « Alleged RC4 », qui est décrit par exemple dans I<Cryptographie appliquée>. Il est supposé être compatible avec RC4[TM], un chiffrement propriétaire de RSA Security Inc.

note: type: textblock
en: RC4 is a stream cipher with variable key length.  Typically, 128 bit (16 byte) keys are used for strong encryption, but shorter insecure key sizes have been widely used due to export restrictions.
fr: RC4 est un chiffrement de flux avec une clé de taille variable. En général, des clés de 128 bits (16 octets) sont utilisées pour un chiffrement fort, mais des clés plus courtes, moins sécurisées, ont été utilisées pour des raisons de restrictions à l'export.

note: type: textblock
en: RC4 consists of a key setup phase and the actual encryption or decryption phase.
fr: RC4 consiste en une phase d'initialisation de clé puis en une phase de chiffrement ou de déchiffrement.

note: type: textblock
en: RC4_set_key() sets up the B<RC4_KEY> B<key> using the B<len> bytes long key at B<data>.
fr: RC4_set_key() initialise la B<RC4_KEY> B<key> en utilisant la clé de B<len> octets à B<data>.

note: type: textblock
en: RC4() encrypts or decrypts the B<len> bytes of data at B<indata> using B<key> and places the result at B<outdata>.  Repeated RC4() calls with the same B<key> yield a continuous key stream.
fr: RC4() chiffre ou déchiffre les B<len> octets de données à B<indata> en utilisant B<key> et place le résultat dans B<outdata>. Des appels répétés à RC4() avec la même clé B<key> produisent un flux continu de clés.

note: type: textblock
en: Since RC4 is a stream cipher (the input is XORed with a pseudo-random key stream to produce the output), decryption uses the same function calls as encryption.
fr: Comme RC4 est un chiffrement de flux (l'entrée est XORée avec un flux de clés pseudo-aléatoire pour produire la sortie), le déchiffrement utilise les mêmes appels de fonctions que le chiffrement.

note: type: textblock
en: Applications should use the higher level functions L<EVP_EncryptInit(3)|EVP_EncryptInit(3)> etc. instead of calling the RC4 functions directly.
fr: Les applications devraient utiliser les fonctions de haut niveau comme L<EVP_EncryptInit(3)|EVP_EncryptInit(3)>, etc., au lieu d'appeler les fonctions RC4 directement.

note: type: textblock
en: RC4_set_key() and RC4() do not return values.
fr: RC4_set_key() et RC4() ne renvoient pas de valeur.

note: type: textblock
en: Certain conditions have to be observed to securely use stream ciphers.  It is not permissible to perform multiple encryptions using the same key stream.
fr: Certaines conditions doivent être respectées pour utiliser les chiffrements de flux. Il n'est pas possible de faire plusieurs chiffrements en utilisant le même flux de clés.

note: type: textblock
en: RC4_set_key() and RC4() are available in all versions of SSLeay and OpenSSL.
fr: RC4_set_key() et RC4() sont disponibles dans toutes les versions de SSLeay et d'OpenSSL.

note: type: textblock
en: RIPEMD160, RIPEMD160_Init, RIPEMD160_Update, RIPEMD160_Final - RIPEMD-160 hash function
fr: RIPEMD160, RIPEMD160_Init, RIPEMD160_Update, RIPEMD160_Final - Fonction de hachage RIPEMD-160

note: type: textblock
en: RIPEMD-160 is a cryptographic hash function with a 160 bit output.
fr: RIPEMD-160 est une fonction de hachage cryptographique avec une sortie de 160 bits.

note: type: textblock
en: RIPEMD160() computes the RIPEMD-160 message digest of the B<n> bytes at B<d> and places it in B<md> (which must have space for RIPEMD160_DIGEST_LENGTH == 20 bytes of output). If B<md> is NULL, the digest is placed in a static array.
fr: RIPEMD160() calcule le condensé de message RIPEMD-160 des B<n> octets de B<d> et le place dans B<md> (qui doit avoir de la place pour RIPEMD160_DIGEST_LENGTH == 20 octets de sortie). Si B<md> est NULL, le condensé est placé dans un tableau statique.

note: type: textblock
en: RIPEMD160_Init() initializes a B<RIPEMD160_CTX> structure.
fr: RIPEMD160_Init() initialise une structure B<RIPEMD160_CTX>.

note: type: textblock
en: RIPEMD160_Update() can be called repeatedly with chunks of the message to be hashed (B<len> bytes at B<data>).
fr: RIPEMD160_Update() peut être appelée de façon répétée avec des bouts du message dont il faut calculer le hachage (B<len> octets de B<data>).

note: type: textblock
en: RIPEMD160_Final() places the message digest in B<md>, which must have space for RIPEMD160_DIGEST_LENGTH == 20 bytes of output, and erases the B<RIPEMD160_CTX>.
fr: RIPEMD160_Final() place le condensé de message dans B<md>, qui doit avoir de la place pour RIPEMD160_DIGEST_LENGTH == 20 octets de données, et efface B<RIPEMD160_CTX>.

note: type: textblock
en: RIPEMD160() returns a pointer to the hash value.
fr: RIPEMD160() renvoie un pointeur vers la valeur de hachage.

note: type: textblock
en: RIPEMD160_Init(), RIPEMD160_Update() and RIPEMD160_Final() return 1 for success, 0 otherwise.
fr: RIPEMD160_Init(), RIPEMD160_Update() et RIPEMD160_Final() renvoient 1 en cas de succès et 0 sinon.

note: type: textblock
en: RIPEMD160(), RIPEMD160_Init(), RIPEMD160_Update() and RIPEMD160_Final() are available since SSLeay 0.9.0.
fr: RIPEMD160(), RIPEMD160_Init(), RIPEMD160_Update() et RIPEMD160_Final() sont disponibles depuis SSLeay 0.9.0.

note: type: textblock
en: SHA1, SHA1_Init, SHA1_Update, SHA1_Final, SHA224, SHA224_Init, SHA224_Update, SHA224_Final, SHA256, SHA256_Init, SHA256_Update, SHA256_Final, SHA384, SHA384_Init, SHA384_Update, SHA384_Final, SHA512, SHA512_Init, SHA512_Update, SHA512_Final - Secure Hash Algorithm
fr: SHA1, SHA1_Init, SHA1_Update, SHA1_Final, SHA224, SHA224_Init, SHA224_Update, SHA224_Final, SHA256, SHA256_Init, SHA256_Update, SHA256_Final, SHA384, SHA384_Init, SHA384_Update, SHA384_Final, SHA512, SHA512_Init, SHA512_Update, SHA512_Final - Algorithme de hachage sécurisé (« Secure Hash Algorithm »)

note: type: textblock
en: SHA-1 (Secure Hash Algorithm) is a cryptographic hash function with a 160 bit output.
fr: SHA-1 (« Secure Hash Algorithm ») est une fonction de hachage cryptographique avec une sortie de 160 bits.

note: type: textblock
en: SHA1() computes the SHA-1 message digest of the B<n> bytes at B<d> and places it in B<md> (which must have space for SHA_DIGEST_LENGTH == 20 bytes of output). If B<md> is NULL, the digest is placed in a static array. Note: setting B<md> to NULL is B<not thread safe>.
fr: SHA1() calcule le condensé de message SHA-1 des B<n> octets de B<d> et le place dans B<md> (qui doit avoir de la place pour SHA_DIGEST_LENGTH == 20 octets de sortie). Si B<md> est NULL, le condensé est placé dans un tableau statique. Note : le réglage de B<md> à NULL n'est B<pas à fil sécurisé>.

note: type: textblock
en: SHA1_Init() initializes a B<SHA_CTX> structure.
fr: SHA1_Init() initialise une structure B<SHA_CTX>.

note: type: textblock
en: SHA1_Update() can be called repeatedly with chunks of the message to be hashed (B<len> bytes at B<data>).
fr: SHA1_Update() peut être appelée de façon répétée avec des bouts du message dont il faut calculer le hachage (B<len> octets de B<data>).

note: type: textblock
en: SHA1_Final() places the message digest in B<md>, which must have space for SHA_DIGEST_LENGTH == 20 bytes of output, and erases the B<SHA_CTX>.
fr: SHA1_Final() place le condensé de message dans B<md>, qui doit avoir de la place pour SHA_DIGEST_LENGTH == 20 octets de données, et efface B<SHA_CTX>.

note: type: textblock
en: The SHA224, SHA256, SHA384 and SHA512 families of functions operate in the same way as for the SHA1 functions. Note that SHA224 and SHA256 use a B<SHA256_CTX> object instead of B<SHA_CTX>. SHA384 and SHA512 use B<SHA512_CTX>.  The buffer B<md> must have space for the output from the SHA variant being used (defined by SHA224_DIGEST_LENGTH, SHA256_DIGEST_LENGTH, SHA384_DIGEST_LENGTH and SHA512_DIGEST_LENGTH). Also note that, as for the SHA1() function above, the SHA224(), SHA256(), SHA384() and SHA512() functions are not thread safe if B<md> is NULL.
fr: Les familles de fonctions SHA224, SHA256, SHA384 et SHA512 opèrent de la même façon que les fonctions SHA1. Notez que SHA224 et SHA256 utilisent un objet B<SHA256_CTX> à la place de B<SHA_CTX>. SHA384 et SHA512 utilisent B<SHA512_CTX>. Le tampon B<md> doit avoir de la place pour la sortie de la variante de SHA utilisée (définie par SHA224_DIGEST_LENGTH, SHA256_DIGEST_LENGTH, SHA384_DIGEST_LENGTH et SHA512_DIGEST_LENGTH). Notez aussi que, comme pour la fonction SHA1() vue plus haut, les fonctions SHA224(), SHA256(), SHA384() et SHA512() ne sont pas à fil sécurisé si B<md> est NULL.

note: type: textblock
en: The predecessor of SHA-1, SHA, is also implemented, but it should be used only when backward compatibility is required.
fr: Le prédécesseur de SHA-1, SHA, est aussi implémenté, mais ne devrait être utilisé que si nécessaire pour des raisons de compatibilité.

note: type: textblock
en: SHA1(), SHA224(), SHA256(), SHA384() and SHA512() return a pointer to the hash value.
fr: SHA1(), SHA224(), SHA256(), SHA384() et SHA512() renvoient un pointeur vers la valeur de hachage.

note: type: textblock
en: SHA1_Init(), SHA1_Update() and SHA1_Final() and equivalent SHA224, SHA256, SHA384 and SHA512 functions return 1 for success, 0 otherwise.
fr: B<SHA1_Init>(), B<SHA1_Update>() et B<SHA1_Final>() et les fonctions équivalentes SHA224, SHA256, SHA384 et SHA512 renvoient B<1> en cas de succès et B<0> sinon.

note: type: textblock
en: US Federal Information Processing Standard FIPS PUB 180-4 (Secure Hash Standard), ANSI X9.30
fr: US Federal Information Processing Standard FIPS PUB 180-1 (Secure Hash Standard), ANSI X9.30

note: type: textblock
en: SHA1(), SHA1_Init(), SHA1_Update() and SHA1_Final() are available in all versions of SSLeay and OpenSSL.
fr: SHA1(), SHA1_Init(), SHA1_Update() et SHA1_Final() sont disponibles dans toutes les versions de SSLeay et d'OpenSSL.

note: type: textblock
en: CRYPTO_THREADID_set_callback, CRYPTO_THREADID_get_callback, CRYPTO_THREADID_current, CRYPTO_THREADID_cmp, CRYPTO_THREADID_cpy, CRYPTO_THREADID_hash, CRYPTO_set_locking_callback, CRYPTO_num_locks, CRYPTO_set_dynlock_create_callback, CRYPTO_set_dynlock_lock_callback, CRYPTO_set_dynlock_destroy_callback, CRYPTO_get_new_dynlockid, CRYPTO_destroy_dynlockid, CRYPTO_lock - OpenSSL thread support
fr: CRYPTO_THREADID_set_callback, CRYPTO_THREADID_get_callback, CRYPTO_THREADID_current, CRYPTO_THREADID_cmp, CRYPTO_THREADID_cpy, CRYPTO_THREADID_hash, CRYPTO_set_locking_callback, CRYPTO_num_locks, CRYPTO_set_dynlock_create_callback, CRYPTO_set_dynlock_lock_callback, CRYPTO_set_dynlock_destroy_callback, CRYPTO_get_new_dynlockid, CRYPTO_destroy_dynlockid, CRYPTO_lock - support de thread d'OpenSSL

note: type: verbatim
en:  /* Don't use this structure directly. */
     typedef struct crypto_threadid_st
             {
             void *ptr;
             unsigned long val;
             } CRYPTO_THREADID;
     /* Only use CRYPTO_THREADID_set_[numeric|pointer]() within callbacks */
     void CRYPTO_THREADID_set_numeric(CRYPTO_THREADID *id, unsigned long val);
     void CRYPTO_THREADID_set_pointer(CRYPTO_THREADID *id, void *ptr);
     int CRYPTO_THREADID_set_callback(void (*threadid_func)(CRYPTO_THREADID *));
     void (*CRYPTO_THREADID_get_callback(void))(CRYPTO_THREADID *);
     void CRYPTO_THREADID_current(CRYPTO_THREADID *id);
     int CRYPTO_THREADID_cmp(const CRYPTO_THREADID *a,
                             const CRYPTO_THREADID *b);
     void CRYPTO_THREADID_cpy(CRYPTO_THREADID *dest,
                              const CRYPTO_THREADID *src);
     unsigned long CRYPTO_THREADID_hash(const CRYPTO_THREADID *id);
fr:  /* N'utilisez pas cette structure directement. */
     typedef struct crypto_threadid_st
             {
             void *ptr;
             unsigned long val;
             } CRYPTO_THREADID;
     /* Utilisez seulement CRYPTO_THREADID_set_[numeric|pointer]() à l'intérieur des rétroactions */
     void CRYPTO_THREADID_set_numeric(CRYPTO_THREADID *id, unsigned long val);
     void CRYPTO_THREADID_set_pointer(CRYPTO_THREADID *id, void *ptr);
     int CRYPTO_THREADID_set_callback(void (*threadid_func)(CRYPTO_THREADID *));
     void (*CRYPTO_THREADID_get_callback(void))(CRYPTO_THREADID *);
     void CRYPTO_THREADID_current(CRYPTO_THREADID *id);
     int CRYPTO_THREADID_cmp(const CRYPTO_THREADID *a,
                             const CRYPTO_THREADID *b);
     void CRYPTO_THREADID_cpy(CRYPTO_THREADID *dest,
                              const CRYPTO_THREADID *src);
     unsigned long CRYPTO_THREADID_hash(const CRYPTO_THREADID *id);

note: type: verbatim
en:  /* struct CRYPTO_dynlock_value needs to be defined by the user */
     struct CRYPTO_dynlock_value;
fr:  /* struct CRYPTO_dynlock_value doit être défini par l'utilisateur */
     struct CRYPTO_dynlock_value;

note: type: textblock
en: OpenSSL can safely be used in multi-threaded applications provided that at least two callback functions are set, locking_function and threadid_func.
fr: OpenSSL peut être utilisé de façon sûre dans des applications multithreadées si deux fonctions rétroactives locking_function et threadid_func sont initialisées.

note: type: textblock
en: locking_function(int mode, int n, const char *file, int line) is needed to perform locking on shared data structures.  (Note that OpenSSL uses a number of global data structures that will be implicitly shared whenever multiple threads use OpenSSL.)  Multi-threaded applications will crash at random if it is not set.
fr: locking_function(int mode, int n, const char *file, int line) est nécessaire pour verrouiller des structures de données partagées. (Notez qu'OpenSSL utilise un certain nombre de structures de données globales qui seront partagées de façon implicite à chaque fois que plusieurs threads utiliseront OpenSSL). Les applications multithreadées peuvent planter de façon aléatoire si elle n'est pas initialisée.

note: type: textblock
en: locking_function() must be able to handle up to CRYPTO_num_locks()  different mutex locks. It sets the B<n>-th lock if B<mode> & B<CRYPTO_LOCK>, and releases it otherwise.
fr: locking_function() doit être capable de gérer jusqu'à CRYPTO_num_locks() mutex de verrous différents. Elle règle le B<n>ème verrou si B<mode> & B<CRYPTO_LOCK>, et le libère dans le cas contraire.

note: type: textblock
en: B<file> and B<line> are the file number of the function setting the lock. They can be useful for debugging.
fr: B<file> et B<line> sont le numéro du fichier de la fonction qui pose le verrou. Ils peuvent être utilisés pour déboguer.

note: type: textblock
en: threadid_func(CRYPTO_THREADID *id) is needed to record the currently-executing thread's identifier into B<id>. The implementation of this callback should not fill in B<id> directly, but should use CRYPTO_THREADID_set_numeric() if thread IDs are numeric, or CRYPTO_THREADID_set_pointer() if they are pointer-based.  If the application does not register such a callback using CRYPTO_THREADID_set_callback(), then a default implementation is used - on Windows and BeOS this uses the system's default thread identifying APIs, and on all other platforms it uses the address of B<errno>. The latter is satisfactory for thread-safety if and only if the platform has a thread-local error number facility.
fr: threadid_func(CRYPTO_THREADID *id) est nécessaire pour enregistrer les identifiants des threads en cours d'exécution dans B<id>. L'implémentation de cette rétroaction ne doit pas remplir B<id> directement, mais doit utiliser CRYPTO_THREADID_set_numeric() si les ID des threads sont numériques, ou CRYPTO_THREADID_set_pointer() si ce sont des pointeurs. Si l'application n'enregistre pas ce genre de rétroactions en utilisant CRYPTO_THREADID_set_callback(), alors une implémentation par défaut est utilisée — sur Windows et BeOS cela utilise les API d'identification de threads par défaut, sur toutes les autres plateformes, cela utilise l'adresse de B<errno>. Cette dernière est satisfaisante pour la sécurité des threads si et seulement si la plateforme dispose d'un identifiant numérique d'erreur pour les threads locaux.

note: type: textblock
en: Once threadid_func() is registered, or if the built-in default implementation is to be used;
fr: Une fois que threadid_func() est enregistrée, ou si l'implémentation par défaut doit être utilisée ;

note: type: =item
en: * CRYPTO_THREADID_current() records the currently-executing thread ID into the given B<id> object.
fr: * CRYPTO_THREADID_current() enregistre les ID des threads en cours d'exécution dans l'objet B<id> donné.

note: type: =item
en: * CRYPTO_THREADID_cmp() compares two thread IDs (returning zero for equality, ie.  the same semantics as memcmp()).
fr: * CRYPTO_THREADID_cmp() compare deux ID de threads (renvoyant 0 pour égalité, c'est-à-dire avec la même sémantique que memcmp()).

note: type: =item
en: * CRYPTO_THREADID_cpy() duplicates a thread ID value,
fr: * CRYPTO_THREADID_cpy() duplique la valeur d'ID d'un thread.

note: type: =item
en: * CRYPTO_THREADID_hash() returns a numeric value usable as a hash-table key. This is usually the exact numeric or pointer-based thread ID used internally, however this also handles the unusual case where pointers are larger than 'long' variables and the platform's thread IDs are pointer-based - in this case, mixing is done to attempt to produce a unique numeric value even though it is not as wide as the platform's true thread IDs.
fr: * CRYPTO_THREADID_hash() renvoie une valeur numérique utilisable comme une clé de table de hachage. Celle-ci est en général la valeur numérique exacte ou un pointeur vers l'ID du thread utilisé en interne, mais cela gère aussi les cas peu courants où les pointeurs sont plus longs que les variables « long » et les ID des pointeurs dans la plateforme sont basés sur des pointeurs — dans ce cas, un mélange est fait pour essayer de produire une valeur unique même si elle n'est pas aussi grande que l'ID réel du thread dans la plateforme.

note: type: textblock
en: Additionally, OpenSSL supports dynamic locks, and sometimes, some parts of OpenSSL need it for better performance.  To enable this, the following is required:
fr: De plus, OpenSSL supporte les verrous dynamiques, et parfois, certaines parties d'OpenSSL en ont besoin pour de meilleures performances. Pour activer cela, les choses suivantes sont nécessaires :

note: type: =item
en: * Three additional callback function, dyn_create_function, dyn_lock_function and dyn_destroy_function.
fr: * Trois fonctions rétroactives en plus, dyn_create_function, dyn_lock_function et dyn_destroy_function.

note: type: =item
en: * A structure defined with the data that each lock needs to handle.
fr: * Une structure définie à partir des données que chaque verrou doit manipuler.

note: type: textblock
en: struct CRYPTO_dynlock_value has to be defined to contain whatever structure is needed to handle locks.
fr: struct CRYPTO_dynlock_value doit être défini de façon à pouvoir contenir n'importe quelle structure nécessaire à la gestion des verrous.

note: type: textblock
en: dyn_create_function(const char *file, int line) is needed to create a lock.  Multi-threaded applications might crash at random if it is not set.
fr: dyn_create_function(const char *file, int line) est nécessaire pour créer un verrou. Les applications multithreadées peuvent planter de façon aléatoire si elle n'est pas initialisée.

note: type: textblock
en: dyn_lock_function(int mode, CRYPTO_dynlock *l, const char *file, int line)  is needed to perform locking off dynamic lock numbered n. Multi-threaded applications might crash at random if it is not set.
fr: dyn_lock_function(int mode, CRYPTO_dynlock *l, const char *file, int line) est nécessaire pour verrouiller le verrou dynamique numéro n. Les applications multithreadées peuvent planter de façon aléatoire si elle n'est pas initialisée.

note: type: textblock
en: dyn_destroy_function(CRYPTO_dynlock *l, const char *file, int line) is needed to destroy the lock l. Multi-threaded applications might crash at random if it is not set.
fr: dyn_destroy_function(CRYPTO_dynlock *l, const char *file, int line) est nécessaire pour détruire le verrou I. Les applications multithreadées peuvent planter de façon aléatoire si elle n'est pas initialisée.

note: type: textblock
en: CRYPTO_get_new_dynlockid() is used to create locks.  It will call dyn_create_function for the actual creation.
fr: CRYPTO_get_new_dynlockid() est utilisée pour créer les verrous. Elle appellera dyn_create_function pour la création.

note: type: textblock
en: CRYPTO_destroy_dynlockid() is used to destroy locks.  It will call dyn_destroy_function for the actual destruction.
fr: CRYPTO_destroy_dynlockid() est utilisée pour détruire les verrous. Elle appellera dyn_destroy_function pour la destruction.

note: type: textblock
en: CRYPTO_lock() is used to lock and unlock the locks.  mode is a bitfield describing what should be done with the lock.  n is the number of the lock as returned from CRYPTO_get_new_dynlockid().  mode can be combined from the following values.  These values are pairwise exclusive, with undefined behaviour if misused (for example, CRYPTO_READ and CRYPTO_WRITE should not be used together):
fr: CRYPTO_lock() est utilisée pour verrouiller et déverrouiller les verrous. Mode est un champ de bits décrivant ce qui doit être fait avec le verrou. I<n> est le nombre de verrous comme renvoyé par CRYPTO_get_new_dynlockid(). I<m>ode peut être combiné à partir des valeurs suivantes. Ces valeurs sont mutuellement exclusives, avec un comportement indéfini si elles sont mal utilisées (par exemple, CRYPTO_READ et CRYPTO_WRITE ne doivent pas être utilisées ensemble).

note: type: textblock
en: CRYPTO_num_locks() returns the required number of locks.
fr: CRYPTO_num_locks() renvoie le nombre nécessaire de verrous.

note: type: textblock
en: CRYPTO_get_new_dynlockid() returns the index to the newly created lock.
fr: CRYPTO_get_new_dynlockid() renvoie l'index vers le verrou nouvellement créé.

note: type: textblock
en: The other functions return no values.
fr: Les autres fonctions ne renvoient pas de valeur.

note: type: textblock
en: You can find out if OpenSSL was configured with thread support:
fr: Vous pouvez savoir si la gestion des threads d'OpenSSL a été activée avec :

note: type: verbatim
en:  #define OPENSSL_THREAD_DEFINES
     #include <openssl/opensslconf.h>
     #if defined(OPENSSL_THREADS)
       // thread support enabled
     #else
       // no thread support
     #endif
fr:  #define OPENSSL_THREAD_DEFINES
     #include <openssl/opensslconf.h>
     #if defined(OPENSSL_THREADS)
       // support de thread activé
     #else
       // pas de support de thread
     #endif

note: type: textblock
en: Also, dynamic locks are currently not used internally by OpenSSL, but may do so in the future.
fr: Aussi, les verrous dynamiques ne sont actuellement pas utilisés en interne par OpenSSL, mais cela peut changer dans le futur.

note: type: textblock
en: B<crypto/threads/mttest.c> shows examples of the callback functions on Solaris, Irix and Win32.
fr: B<crypto/threads/mttest.c> montre des exemples d'utilisation des fonctions rétroactives sur Solaris, Irix et Win32.

note: type: textblock
en: CRYPTO_set_locking_callback() is available in all versions of SSLeay and OpenSSL.  CRYPTO_num_locks() was added in OpenSSL 0.9.4.  All functions dealing with dynamic locks were added in OpenSSL 0.9.5b-dev.  B<CRYPTO_THREADID> and associated functions were introduced in OpenSSL 1.0.0 to replace (actually, deprecate) the previous CRYPTO_set_id_callback(), CRYPTO_get_id_callback(), and CRYPTO_thread_id() functions which assumed thread IDs to always be represented by 'unsigned long'.
fr: CRYPTO_set_locking_callback() est disponible dans toutes les versions de SSLeay et d'OpenSSL. CRYPTO_num_locks() a été ajoutée dans OpenSSL 0.9.4. Toutes les fonctions traitant des verrous dynamiques ont été ajoutées dans OpenSSL 0.9.5b-dev. B<CRYPTO_THREADID> et les fonctions qui lui sont associées ont été introduites dans OpenSSL 1.0.0 pour remplacer (en fait, pour rendre obsolète) les anciennes fonctions CRYPTO_set_id_callback(), CRYPTO_get_id_callback() et CRYPTO_thread_id() qui supposaient que les ID des threads étaient toujours représentés par un « unsigned long ».

note: type: textblock
en: UI_new, UI_new_method, UI_free, UI_add_input_string, UI_dup_input_string, UI_add_verify_string, UI_dup_verify_string, UI_add_input_boolean, UI_dup_input_boolean, UI_add_info_string, UI_dup_info_string, UI_add_error_string, UI_dup_error_string, UI_construct_prompt, UI_add_user_data, UI_get0_user_data, UI_get0_result, UI_process, UI_ctrl, UI_set_default_method, UI_get_default_method, UI_get_method, UI_set_method, UI_OpenSSL, ERR_load_UI_strings - New User Interface
fr: UI_new, UI_new_method, UI_free, UI_add_input_string, UI_dup_input_string, UI_add_verify_string, UI_dup_verify_string, UI_add_input_boolean, UI_dup_input_boolean, UI_add_info_string, UI_dup_info_string, UI_add_error_string, UI_dup_error_string, UI_construct_prompt, UI_add_user_data, UI_get0_user_data, UI_get0_result, UI_process, UI_ctrl, UI_set_default_method, UI_get_default_method, UI_get_method, UI_set_method, UI_OpenSSL, ERR_load_UI_strings - Nouvelle interface utilisateur.

note: type: verbatim
en:  /* These are the possible flags.  They can be or'ed together. */
     #define UI_INPUT_FLAG_ECHO		0x01
     #define UI_INPUT_FLAG_DEFAULT_PWD	0x02
fr:  /* Voici les drapeaux disponibles. Ils peuvent être ajoutés ensemble avec OR */
     #define UI_INPUT_FLAG_ECHO		0x01
     #define UI_INPUT_FLAG_DEFAULT_PWD	0x02

note: type: textblock
en: UI stands for User Interface, and is general purpose set of routines to prompt the user for text-based information.  Through user-written methods (see L<ui_create(3)|ui_create(3)>), prompting can be done in any way imaginable, be it plain text prompting, through dialog boxes or from a cell phone.
fr: UI signifie Interface utilisateur, et est un ensemble général de routines qui demandent une saisie à l'utilisateur pour des informations qui sont basées sur du texte. À travers des méthodes écrites par l'utilisateur (voir L<ui_create(3)|ui_create(3)>), les demandes peuvent être faites de n'importe quelle façon imaginable, en texte brut, à travers des boites de dialogue ou sur un téléphone portable.

note: type: textblock
en: All the functions work through a context of the type UI.  This context contains all the information needed to prompt correctly as well as a reference to a UI_METHOD, which is an ordered vector of functions that carry out the actual prompting.
fr: Toutes les fonctions fonctionnent dans un contexte du type d'UI. Ce contexte contient toutes les informations nécessaires pour faire une demande de saisie de façon correcte, ainsi qu'une référence vers un UI_METHOD qui est un vecteur de fonctions ordonné qui transporte les demandes de saisies.

note: type: textblock
en: The first thing to do is to create a UI with UI_new() or UI_new_method(), then add information to it with the UI_add or UI_dup functions.  Also, user-defined random data can be passed down to the underlying method through calls to UI_add_user_data.  The default UI method doesn't care about these data, but other methods might.  Finally, use UI_process()  to actually perform the prompting and UI_get0_result() to find the result to the prompt.
fr: La première chose à faire est de créer une UI avec UI_new() ou UI_new_method(), puis d'ajouter des informations avec les fonctions UI_add ou UI_dup. Les données définies comme aléatoires par l'utilisateur peuvent aussi être passées aux méthodes sous-jacentes à travers des appels à UI_add_user_data. L'UI par défaut ne prend pas en compte ces données, mais d'autres méthodes pourraient. Finalement, utilisez UI_process() pour faire la demande d'entrée et UI_get0_result() pour avoir le résultat de cette demande.

note: type: textblock
en: A UI can contain more than one prompt, which are performed in the given sequence.  Each prompt gets an index number which is returned by the UI_add and UI_dup functions, and has to be used to get the corresponding result with UI_get0_result().
fr: Une UI peut contenir plusieurs demandes de saisie qui sont effectuées dans chaque séquence. Chaque demande reçoit un numéro d'indexation, qui est renvoyé par les fonctions UI_add et UI_dup, et qui doit être utilisé par UI_get0_result() pour obtenir le résultat correspondant.

note: type: textblock
en: The functions are as follows:
fr: Les fonctions sont comme suit :

note: type: textblock
en: UI_new() creates a new UI using the default UI method.  When done with this UI, it should be freed using UI_free().
fr: UI_new() crée une nouvelle méthode d'UI. Quand l'utilisation de cette UI est terminée, elle doit être libérée avec UI_free().

note: type: textblock
en: UI_new_method() creates a new UI using the given UI method.  When done with this UI, it should be freed using UI_free().
fr: UI_new_method() crée une nouvelle UI en utilisant la méthode UI donnée. Quand celle-ci a fini avec cette UI, elle doit être libérée en utilisant UI_free().

note: type: textblock
en: UI_OpenSSL() returns the built-in UI method (note: not the default one, since the default can be changed.  See further on).  This method is the most machine/OS dependent part of OpenSSL and normally generates the most problems when porting.
fr: UI_OpenSSL() renvoie la méthode construite dans l'UI (note : pas celle par défaut puisque celle-ci peut être modifiée. Voir plus loin). Cette méthode est la plus dépendante de la machine et de l'OS d'OpenSSL et génère normalement le plus de problèmes de portabilité.

note: type: textblock
en: UI_free() removes a UI from memory, along with all other pieces of memory that's connected to it, like duplicated input strings, results and others.
fr: UI_free() supprime une UI de la mémoire, ainsi que tous morceaux de mémoire qui sont connectés à celle-ci, comme des copies de chaînes de caractères d'entrées, des résultats et autres.

note: type: textblock
en: UI_add_input_string() and UI_add_verify_string() add a prompt to the UI, as well as flags and a result buffer and the desired minimum and maximum sizes of the result.  The given information is used to prompt for information, for example a password, and to verify a password (i.e. having the user enter it twice and check that the same string was entered twice).  UI_add_verify_string() takes and extra argument that should be a pointer to the result buffer of the input string that it's supposed to verify, or verification will fail.
fr: UI_add_input_string() et UI_add_verify_string() ajoutent une demande à l'UI, ainsi que des drapeaux, un tampon de résultat et les tailles minimales et maximales désirées pour le résultat. Les informations fournies sont utilisées pour demander des informations, par exemple un mot de passe, et pour vérifier le mot de passe (c'est-à-dire l'utilisateur rentre deux fois le mot de passe et l'égalité est vérifiée). UI_add_verify_string() prend un argument en plus, qui devrait être un pointeur vers le tampon de retour de la chaîne de caractères de sortie qu'il est supposé vérifier, ou la vérification échouera.

note: type: textblock
en: UI_add_input_boolean() adds a prompt to the UI that's supposed to be answered in a boolean way, with a single character for yes and a different character for no.  A set of characters that can be used to cancel the prompt is given as well.  The prompt itself is divided in two, one part being the descriptive text (given through the I<prompt> argument) and one describing the possible answers (given through the I<action_desc> argument).
fr: UI_add_input_boolean() ajoute une demande d'entrée à l'UI qui doit avoir une réponse sous forme d'un booléen, avec un seul caractère pour oui et un caractère différent pour non. Un ensemble de caractères qui peuvent être utilisés pour annuler cette demande est aussi donné. La demande elle-même est divisée en deux parties, la première étant la description textuelle (donnée par l'argument I<prompt>) et la seconde décrivant les réponses possibles (données par l'argument I<action_desc>).

note: type: textblock
en: UI_add_info_string() and UI_add_error_string() add strings that are shown at the same time as the prompt for extra information or to show an error string.  The difference between the two is only conceptual.  With the builtin method, there's no technical difference between them.  Other methods may make a difference between them, however.
fr: UI_add_info_string() et UI_add_error_string() ajoutent les chaînes de caractères qui sont affichées au même moment que la demande de saisie dans le cas de demande d'information supplémentaire ou pour afficher un message d'erreur. La différence entre les deux n'est que conceptuelle. Avec la méthode interne, il n'y a pas de différence technique entres elles. Mais il se peut que d'autres méthodes puissent produire une différence.

note: type: textblock
en: The flags currently supported are UI_INPUT_FLAG_ECHO, which is relevant for UI_add_input_string() and will have the users response be echoed (when prompting for a password, this flag should obviously not be used, and UI_INPUT_FLAG_DEFAULT_PWD, which means that a default password of some sort will be used (completely depending on the application and the UI method).
fr: Les drapeaux gérés actuellement sont UI_INPUT_FLAG_ECHO, qui est applicable à UI_add_input_string() et qui fera s'afficher les réponses de l'utilisateur (quand un mot de passe est demandé, ce drapeau ne doit évidemment pas être utilisé), et UI_INPUT_FLAG_DEFAULT_PWD, qui indique qu'un mot de passe par défaut va être utilisé (cela dépend entièrement de l'application et de la méthode d'UI).

note: type: textblock
en: UI_dup_input_string(), UI_dup_verify_string(), UI_dup_input_boolean(), UI_dup_info_string() and UI_dup_error_string() are basically the same as their UI_add counterparts, except that they make their own copies of all strings.
fr: UI_dup_input_string(), UI_dup_verify_string(), UI_dup_input_boolean(), UI_dup_info_string() et UI_dup_error_string() sont identiques à leurs contreparties UI_add, sauf qu'ils font leurs propres copies des chaînes.

note: type: textblock
en: UI_construct_prompt() is a helper function that can be used to create a prompt from two pieces of information: an description and a name.  The default constructor (if there is none provided by the method used)  creates a string "Enter I<description> for I<name>:".  With the description "pass phrase" and the file name "foo.key", that becomes "Enter pass phrase for foo.key:".  Other methods may create whatever string and may include encodings that will be processed by the other method functions.
fr: UI_construct_prompt() est une fonction d'aide qui est utilisée pour créer une demande d'entrée de texte pour deux morceaux d'information : une description et un nom. Le constructeur par défaut (s'il n'y en a aucun de fourni par la méthode utilisée) crée une chaîne de caractères « Enter I<description> for I<name> : ». Avec la description « pass phrase » et le nom de fichier « foo.key », qui devient « Enter pass phrase for foo.key : ». D'autres méthodes peuvent créer n'importe quelle chaîne de caractères et peuvent inclure des encodages qui seront traités par d'autres fonctions de méthodes.

note: type: textblock
en: UI_add_user_data() adds a piece of memory for the method to use at any time.  The builtin UI method doesn't care about this info.  Note that several calls to this function doesn't add data, it replaces the previous blob with the one given as argument.
fr: UI_add_user_data() ajoute un morceau de mémoire pour la méthode à utiliser à chaque instant. La méthode de l'UI intégrée ne prend pas cette information en compte. Notez que plusieurs appels à cette fonction n'ajoutent pas de données, elle remplace le blob précédent par celui donné comme argument.

note: type: textblock
en: UI_get0_user_data() retrieves the data that has last been given to the UI with UI_add_user_data().
fr: UI_get0_user_data() récupère les données qui ont été données à l'UI avec UI_add_user_data().

note: type: textblock
en: UI_get0_result() returns a pointer to the result buffer associated with the information indexed by I<i>.
fr: UI_get0_result() renvoie un pointeur vers le résultat du tampon associé à l'information indexée par I<i>.

note: type: textblock
en: UI_process() goes through the information given so far, does all the printing and prompting and returns.
fr: UI_process() parcourt l'information donnée jusque-là, fait tout les affichages et requêtes et renvoie.

note: type: textblock
en: UI_ctrl() adds extra control for the application author.  For now, it understands two commands: UI_CTRL_PRINT_ERRORS, which makes UI_process()  print the OpenSSL error stack as part of processing the UI, and UI_CTRL_IS_REDOABLE, which returns a flag saying if the used UI can be used again or not.
fr: UI_ctrl() ajoute un contrôle supplémentaire pour l'auteur de l'application. Pour l'instant, elle comprend deux commandes : UI_CTRL_PRINT_ERRORS, qui demande à UI_process() d'afficher la pile d'erreurs d'OpenSSL comme partie du traitement de l'UI, et UI_CTRL_IS_REDOABLE qui renvoie un drapeau exprimant la réutilisabilité de l'UI.

note: type: textblock
en: UI_set_default_method() changes the default UI method to the one given.
fr: UI_set_default_method() change la méthode par défaut de l'UI pour celle donnée.

note: type: textblock
en: UI_get_default_method() returns a pointer to the current default UI method.
fr: UI_get_default_method() renvoie un pointeur vers la méthode par défaut actuelle de l'UI.

note: type: textblock
en: UI_get_method() returns the UI method associated with a given UI.
fr: UI_get_method() renvoie la méthode d'UI associée à une UI donnée.

note: type: textblock
en: UI_set_method() changes the UI method associated with a given UI.
fr: UI_set_method() change la méthode d'UI associée à une UI donnée.

note: type: textblock
en: The UI section was first introduced in OpenSSL 0.9.7.
fr: La partie UI a été introduite dans la version 0.9.7 d'OpenSSL.

note: type: textblock
en: Richard Levitte (richard@levitte.org) for the OpenSSL project (http://www.openssl.org).
fr: Richard Levitte <richard@levitte.org> pour le projet OpenSSL <http://www.openssl.org>.

note: type: textblock
en: des_read_password, des_read_2passwords, des_read_pw_string, des_read_pw - Compatibility user interface functions
fr: des_read_password, des_read_2passwords, des_read_pw_string, des_read_pw - Fonctions de compatibilité d'interface utilisateur

note: type: textblock
en: The DES library contained a few routines to prompt for passwords.  These aren't necessarely dependent on DES, and have therefore become part of the UI compatibility library.
fr: La bibliothèque DES contenait quelques routines pour demander les mots de passe. Elles ne sont pas forcément dépendantes de DES, et ont par conséquent été intégrées à la bibliothèque de compatibilité d'interface utilisateur.

note: type: textblock
en: des_read_pw() writes the string specified by I<prompt> to standard output turns echo off and reads an input string from the terminal.  The string is returned in I<buf>, which must have spac for at least I<size> bytes.  If I<verify> is set, the user is asked for the password twice and unless the two copies match, an error is returned.  The second password is stored in I<buff>, which must therefore also be at least I<size> bytes.  A return code of -1 indicates a system error, 1 failure due to use interaction, and 0 is success.  All other functions described here use des_read_pw() to do the work.
fr: B<des_read_pw>() écrit la chaîne indiquée par I<prompt> sur la sortie standard, désactive l'écho, et lit la chaîne d'entrée du terminal. La chaîne est renvoyée dans I<buf>, qui doit avoir suffisamment de place pour I<size> octets. Si I<verify> est définie, il est demandé à l'utilisateur de saisir le mot de passe deux fois, et une erreur est renvoyée si les deux copies ne correspondent pas. Le deuxième mot de passe est gardé dans I<buff>, qui doit donc être au moins de taille I<size> octets. Un code de retour de -1 indique une erreur système, 1 une erreur à cause de l'utilisation interactive, et 0 une réussite. Toutes les autres fonctions décrites ici utilisent B<des_read_pw>() pour faire le travail.

note: type: textblock
en: des_read_pw_string() is a variant of des_read_pw() that provides a buffer for you if I<verify> is set.
fr: B<des_read_pw_string>() est une variante de B<des_read_pw>() qui fournit un tampon si I<verify> est définie.

note: type: textblock
en: des_read_password() calls des_read_pw() and converts the password to a DES key by calling DES_string_to_key(); des_read_2password() operates in the same way as des_read_password() except that it generates two keys by using the DES_string_to_2key() function.
fr: B<des_read_password>() appelle B<des_read_pw>() et convertit le mot de passe en clef DES en appelant S<B<DES_string_to_key>()> ; B<des_read_2password>() opère de la même façon que B<des_read_password>() à part qu'elle génère deux clefs en utilisant la fonction B<DES_string_to_2key>().

note: type: textblock
en: des_read_pw_string() is available in the MIT Kerberos library as well, and is also available under the name EVP_read_pw_string().
fr: B<des_read_pw_string>() est aussi disponible dans la bibliothèque de Kerberos du MIT, ainsi que sous le nom B<EVP_read_pw_string>().
