openssl - en to fr translation catalogue (99 entries)

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

note: type: textblock
en: dhparam - DH parameter manipulation and generation
fr: dhparam - Manipulation et génération de paramètres DH

note: type: textblock
en: B<openssl dhparam> [B<-inform DER|PEM>] [B<-outform DER|PEM>] [B<-in> I<filename>] [B<-out> I<filename>] [B<-dsaparam>] [B<-check>] [B<-noout>] [B<-text>] [B<-C>] [B<-2>] [B<-5>] [B<-rand> I<file(s)>] [B<-engine id>] [I<numbits>]
fr: B<openssl dhparam> [B<-inform DER>|B<PEM>] [B<-outform DER>|B<PEM>] [B<-in> I<nom_fichier>] [B<-out> I<nom_fichier>] [B<-dsaparam>] [B<-check>] [B<-noout>] [B<-text>] [B<-C>] [B<-2>] [B<-5>] [B<-rand> I<fichier(s)>] [B<-engine> I<id>] [I<nombrebits>]

note: type: textblock
en: This command is used to manipulate DH parameter files.
fr: Cette commande sert à manipuler des fichiers de paramètres DH.

note: type: =item
en: B<-inform DER|PEM>
fr: B<-inform> B<DER>|B<PEM>

note: type: textblock
en: This specifies the input format. The B<DER> option uses an ASN1 DER encoded form compatible with the PKCS#3 DHparameter structure. The PEM form is the default format: it consists of the B<DER> format base64 encoded with additional header and footer lines.
fr: Indiquer le format d'entrée. L'option B<DER> utilise une forme encodée ASN1 DER compatible avec la structure PKCS#3 des paramètres DH (DHparameter). La forme PEM est le format par défaut : il s'agit d'un format B<DER> encodé en base64 avec des lignes supplémentaires au début et à la fin.

note: type: =item
en: B<-outform DER|PEM>
fr: B<-outform> B<DER>|B<PEM>

note: type: textblock
en: This specifies the output format, the options have the same meaning as the B<-inform> option.
fr: Indiquer le format de sortie. Les options ont la même signification que pour l'option B<-inform>.

note: type: =item
en: B<-in> I<filename>
fr: B<-in> I<nom_fichier>

note: type: textblock
en: This specifies the input filename to read parameters from or standard input if this option is not specified.
fr: Indiquer le nom du fichier d'où seront lus les paramètres. Par défaut, l'entrée standard est utilisée.

note: type: =item
en: B<-out> I<filename>
fr: B<-out> I<nom_fichier>

note: type: textblock
en: This specifies the output filename parameters to. Standard output is used if this option is not present. The output filename should B<not> be the same as the input filename.
fr: Indiquer le nom du fichier de sortie pour les paramètres. La sortie standard est utilisée si cette option n'est pas présente. Le fichier ne doit B<pas> être identique au fichier d'entrée.

note: type: textblock
en: If this option is used, DSA rather than DH parameters are read or created; they are converted to DH format.  Otherwise, "strong" primes (such that (p-1)/2 is also prime) will be used for DH parameter generation.
fr: Avec cette option, des paramètres DSA sont lus ou créés au lieu de paramètres DH ; ils sont convertis vers le format DH. Autrement, des nombres premiers « fort » (tels que (p-1)/2 est également premier) serviront à la génération des paramètres DH.

note: type: textblock
en: DH parameter generation with the B<-dsaparam> option is much faster, and the recommended exponent length is shorter, which makes DH key exchange more efficient.  Beware that with such DSA-style DH parameters, a fresh DH key should be created for each use to avoid small-subgroup attacks that may be possible otherwise.
fr: La génération de paramètres DH avec l'option B<-dsaparam> est nettement plus rapide, et la longueur de l'exposant recommandé est plus courte, ce qui rend l'échange de clef DH plus efficace. Remarquez toutefois que pour tout paramètre DH de style DSA, une nouvelle clef DH devrait être créée pour chaque utilisation afin d'éviter des attaques par petit sous-groupes (« small-subgroup attacks ») qui seraient possibles autrement.

note: type: textblock
en: check if the parameters are valid primes and generator.
fr: Vérifier si les paramètres sont des nombres premiers valables et un générateur.

note: type: textblock
en: The generator to use, either 2 or 5. If present then the input file is ignored and parameters are generated instead. If not present but B<numbits> is present, parameters are generated with the default generator 2.
fr: Le générateur à utiliser, soit 2, soit 5. Si présent, le fichier d'entrée est ignoré et les paramètres sont générés à la place. Si non présent, mais que I<nombrebits> est présent, les paramètres sont générés avec le générateur par défaut 2.

note: type: =item
en: B<-rand> I<file(s)>
fr: B<-rand> I<fichier(s)>

note: type: textblock
en: a file or files containing random data used to seed the random number generator, or an EGD socket (see L<RAND_egd(3)|RAND_egd(3)>).  Multiple files can be specified separated by a OS-dependent character.  The separator is B<;> for MS-Windows, B<,> for OpenVMS, and B<:> for all others.
fr: Un ou plusieurs fichiers contenant des données aléatoires utilisées pour initialiser le générateur de nombres pseudoaléatoires, ou une socket EGD (consultez L<RAND_egd(3)|RAND_egd(3)>). Plusieurs fichiers peuvent être indiqués en utilisant le séparateur du système d'exploitation : « B<;> » pour Windows, « B<,> » pour OpenVMS et « B<:> » pour tous les autres.

note: type: =item
en: I<numbits>
fr: I<nombrebits>

note: type: textblock
en: this option specifies that a parameter set should be generated of size I<numbits>. It must be the last option. If this option is present then the input file is ignored and parameters are generated instead. If this option is not present but a generator (B<-2> or B<-5>) is present, parameters are generated with a default length of 2048 bits.
fr: Cette option indique qu'un jeu de paramètres de taille I<nombrebits> doit être généré. Cette option doit être placée en dernier. Si cette option est présente, le fichier d'entrée est ignoré et des paramètres sont générés à la place. Si cette option n’est pas présente, mais qu’un générateur (B<-2> ou B<-5>) est présent, les paramètres sont générés avec une taille par défaut de 2048 bits.

note: type: textblock
en: this option inhibits the output of the encoded version of the parameters.
fr: Cette option empêche la sortie des paramètres en version encodée.

note: type: textblock
en: this option prints out the DH parameters in human readable form.
fr: Cette option affiche les paramètres DH sous forme lisible.

note: type: textblock
en: this option converts the parameters into C code. The parameters can then be loaded by calling the B<get_dh>I<numbits>B<()> function.
fr: Cette option convertit les paramètres en code source C. Ces paramètres peuvent ensuite être chargées en utilisant la fonction B<get_dh>I<nombrebits>B<()>.

note: type: =item
en: B<-engine id>
fr: B<-engine> I<id>

note: type: textblock
en: specifying an engine (by its unique B<id> string) will cause B<dhparam> to attempt to obtain a functional reference to the specified engine, thus initialising it if needed. The engine will then be set as the default for all available algorithms.
fr: Indiquer un moteur (en utilisant son identifiant unique I<id>) qui indique à B<dhparam> d'essayer d'obtenir une référence fonctionnelle pour le moteur indiqué, et l'initialiser si nécessaire. Le moteur sera ensuite utilisé par défaut pour tous les algorithmes disponibles.

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

note: type: textblock
en: The program B<dhparam> combines the functionality of the programs B<dh> and B<gendh> in previous versions of OpenSSL and SSLeay. The B<dh> and B<gendh> programs are retained for now but may have different purposes in future versions of OpenSSL.
fr: Le programme B<dhparam> combine les fonctionnalités des programmes B<dh> et B<gendh> des versions précédentes d'OpenSSL et de SSLeay. Les programmes B<dh> et B<gendh> sont maintenus pour l'instant mais pourraient avoir d'autres fonctions dans des versions à venir d'OpenSSL.

note: type: textblock
en: PEM format DH parameters use the header and footer lines:
fr: Le format PEM des paramètres DH utilise les lignes suivantes au début et à la fin :

note: type: textblock
en: OpenSSL currently only supports the older PKCS#3 DH, not the newer X9.42 DH.
fr: Actuellement, OpenSSL prend seulement en charge le DH PKCS#3, et pas encore le DH X9.42 plus récent.

note: type: textblock
en: This program manipulates DH parameters not keys.
fr: Ce programme manipule les paramètres DH, et non les clefs.

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

note: type: textblock
en: There should be a way to generate and manipulate DH keys.
fr: Il devrait y avoir un moyen de générer et de manipuler des clefs DH.

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

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

note: type: textblock
en: The B<dhparam> command was added in OpenSSL 0.9.5.  The B<-dsaparam> option was added in OpenSSL 0.9.6.
fr: La commande B<dhparam> a été ajouté pour OpenSSL 0.9.5. L'option B<-dsaparam> a été ajouté pour OpenSSL 0.9.6.

note: type: textblock
en: DH_generate_key, DH_compute_key - perform Diffie-Hellman key exchange
fr: DH_generate_key, DH_compute_key - Réaliser un échange de clef Diffie-Hellman

note: type: textblock
en: DH_generate_key() performs the first step of a Diffie-Hellman key exchange by generating private and public DH values. By calling DH_compute_key(), these are combined with the other party's public value to compute the shared key.
fr: B<DH_generate_key>() réalise la première étape d'un échange de clef Diffie-Hellman en générant les valeurs DH privée et publique. En appelant B<DH_compute_key>(), elles sont combinées avec l'autre valeur publique partagée pour calculer la clef partagée.

note: type: textblock
en: DH_generate_key() expects B<dh> to contain the shared parameters B<dh-E<gt>p> and B<dh-E<gt>g>. It generates a random private DH value unless B<dh-E<gt>priv_key> is already set, and computes the corresponding public value B<dh-E<gt>pub_key>, which can then be published.
fr: B<DH_generate_key>() s'attend à ce que I<dh> contienne les paramètres partagés I<dh-E<gt>p> et I<dh-E<gt>g>. Elle génère une valeur privée DH aléatoire à moins que I<dh-E<gt>priv_key> ne soit déjà définie, et calcule la valeur publique I<dh-E<gt>pub_key> correspondante, qui peut alors être publiée.

note: type: textblock
en: DH_compute_key() computes the shared secret from the private DH value in B<dh> and the other party's public value in B<pub_key> and stores it in B<key>. B<key> must point to B<DH_size(dh)> bytes of memory.
fr: B<DH_compute_key>() calcule le secret partagé à partir de la valeur DH privée de I<dh> et l'autre valeur publique partagée de I<pub_key>, et la conserve dans I<key>. I<key> doit pointer vers B<DH_size(>I<dh>B<)> octets de mémoire.

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

note: type: textblock
en: DH_generate_key() returns 1 on success, 0 otherwise.
fr: B<DH_generate_key>() renvoie B<1> en cas de réussite, B<0> sinon.

note: type: textblock
en: DH_compute_key() returns the size of the shared secret on success, -1 on error.
fr: B<DH_compute_key>() renvoie la taille du secret partagé en cas de réussite, B<-1> en cas d'erreur.

note: type: textblock
en: The error codes can be obtained by L<ERR_get_error(3)|ERR_get_error(3)>.
fr: Les codes d'erreur peuvent être obtenus par L<ERR_get_error(3)|ERR_get_error(3)>.

note: type: textblock
en: DH_generate_key() and DH_compute_key() are available in all versions of SSLeay and OpenSSL.
fr: B<DH_generate_key>() et B<DH_compute_key>() sont disponibles dans toutes les versions de SSLeay et OpenSSL.

note: type: textblock
en: DH_generate_parameters_ex, DH_generate_parameters, DH_check - generate and check Diffie-Hellman parameters
fr: DH_generate_parameters_ex, DH_generate_parameters, DH_check - Générer et vérifier les paramètres Diffie-Hellman

note: type: textblock
en: Deprecated:
fr: Obsolète :

note: type: textblock
en: DH_generate_parameters_ex() generates Diffie-Hellman parameters that can be shared among a group of users, and stores them in the provided B<DH> structure. The pseudo-random number generator must be seeded prior to calling DH_generate_parameters().
fr: B<DH_generate_parameters_ex>() génère les paramètres Diffie-Hellman qui peuvent être partagés par un groupe d'utilisateurs, et les conserve dans la structure B<DH> fournie. Le générateur de nombres pseudoaléatoires doit être initialisé avant d'appeler B<DH_generate_parameters>().

note: type: textblock
en: B<prime_len> is the length in bits of the safe prime to be generated.  B<generator> is a small number E<gt> 1, typically 2 or 5.
fr: I<prime_len> est la taille en octet du nombre premier sûr à générer. I<generator> est un petit nombre E<gt> 1, en général 2 ou 5.

note: type: textblock
en: A callback function may be used to provide feedback about the progress of the key generation. If B<cb> is not B<NULL>, it will be called as described in L<BN_generate_prime(3)|BN_generate_prime(3)> while a random prime number is generated, and when a prime has been found, B<BN_GENCB_call(cb, 3, 0)> is called. See L<BN_generate_prime(3)|BN_generate_prime(3)> for information on the BN_GENCB_call() function.
fr: Une fonction de rappel peut être utilisée pour fournir un retour sur l'avancement de la génération de clef. Si I<cb> n'est pas NULL, elle sera appelée conformément à la description de L<BN_generate_prime(3)|BN_generate_prime(3)> pendant qu'un nombre premier aléatoire est généré, et quand un nombre premier a été trouvé. Consultez L<B<BN_generate_prime>(3)|BN_generate_prime(3)> pour des renseignements sur la fonction B<BN_GENCB_call>().

note: type: textblock
en: DH_check() validates Diffie-Hellman parameters. It checks that B<p> is a safe prime, and that B<g> is a suitable generator. In the case of an error, the bit flags DH_CHECK_P_NOT_SAFE_PRIME or DH_NOT_SUITABLE_GENERATOR are set in B<*codes>.  DH_UNABLE_TO_CHECK_GENERATOR is set if the generator cannot be checked, i.e. it does not equal 2 or 5.
fr: B<DH_check>() valide les paramètres Diffie-Hellman. Elle vérifie que I<p> est un nombre premier sûr, et que I<g> est un générateur convenable. En cas d'erreur, les attributs de bit DH_CHECK_P_NOT_SAFE_PRIME ou DH_NOT_SUITABLE_GENERATOR sont définis dans I<*codes>.  DH_UNABLE_TO_CHECK_GENERATOR est défini si le générateur ne peut pas être vérifié, c'est-à-dire s'il est différent de 2 ou 5.

note: type: textblock
en: DH_generate_parameters_ex() and DH_check() return 1 if the check could be performed, 0 otherwise.
fr: B<DH_generate_parameters_ex> et B<DH_check>() renvoient B<1> si la vérification a pu être réalisée, B<0> sinon.

note: type: textblock
en: DH_generate_parameters() (deprecated) returns a pointer to the DH structure, or NULL if the parameter generation fails.
fr: B<DH_generate_parameters>() (obsolète) renvoie un pointeur vers la structure DH ou NULL en cas d'échec de la génération de paramètre.

note: type: textblock
en: DH_generate_parameters_ex() and DH_generate_parameters() may run for several hours before finding a suitable prime.
fr: B<DH_generate_parameters_ex> et B<DH_generate_parameters>() pourraient s’exécuter pendant plusieurs heures avant de trouver un nombre premier convenable.

note: type: textblock
en: The parameters generated by DH_generate_parameters_ex() and DH_generate_parameters()  are not to be used in signature schemes.
fr: Les paramètres générés par B<DH_generate_parameters_ex> et B<DH_generate_parameters>() ne sont pas faits pour être utilisés dans les schémas de signature.

note: type: textblock
en: If B<generator> is not 2 or 5, B<dh-E<gt>g>=B<generator> is not a usable generator.
fr: Si I<generator> n'est ni 2, ni 5, I<dh-E<gt>g>=I<generator> n'est pas un générateur utilisable.

note: type: textblock
en: DH_check() is available in all versions of SSLeay and OpenSSL.  The B<cb_arg> argument to DH_generate_parameters() was added in SSLeay 0.9.0.
fr: B<DH_check>() est disponible dans toutes les versions de SSLeay et OpenSSL. L'argument I<cb_arg> de B<DH_generate_parameters>() a été ajouté dans SSLeay 0.9.0.

note: type: textblock
en: In versions before OpenSSL 0.9.5, DH_CHECK_P_NOT_STRONG_PRIME is used instead of DH_CHECK_P_NOT_SAFE_PRIME.
fr: Dans les versions antérieures à OpenSSL 0.9.5, DH_CHECK_P_NOT_STRONG_PRIME était utilisé au lieu de DH_CHECK_P_NOT_SAFE_PRIME.

note: type: textblock
en: DH_get_ex_new_index, DH_set_ex_data, DH_get_ex_data - add application specific data to DH structures
fr: DH_get_ex_new_index, DH_set_ex_data, DH_get_ex_data - Ajouter des données spécifiques aux applications dans des structures DH

note: type: textblock
en: These functions handle application specific data in DH structures. Their usage is identical to that of RSA_get_ex_new_index(), RSA_set_ex_data() and RSA_get_ex_data()  as described in L<RSA_get_ex_new_index(3)>.
fr: Ces fonctions prennent en charge des données spécifiques aux applications dans les structures DH. Leur utilisation est identique à celle de B<RSA_get_ex_new_index>(), B<RSA_set_ex_data>() et B<RSA_get_ex_data>(), comme décrit dans L<RSA_get_ex_new_index(3)>.

note: type: textblock
en: DH_get_ex_new_index(), DH_set_ex_data() and DH_get_ex_data() are available since OpenSSL 0.9.5.
fr: DH_get_ex_new_index(), DH_set_ex_data() et DH_get_ex_data() sont disponibles dans OpenSSL depuis la version 0.9.5.

note: type: textblock
en: DH_new, DH_free - allocate and free DH objects
fr: DH_new, DH_free - Allouer et libérer des objets DH

note: type: textblock
en: DH_new() allocates and initializes a B<DH> structure.
fr: B<DH_new>() alloue et initialise une structure B<DH>.

note: type: textblock
en: DH_free() frees the B<DH> structure and its components. The values are erased before the memory is returned to the system.
fr: B<DH_free>() libère la structure B<DH> et ses composants. Les valeurs sont effacées avant que la mémoire ne soit renvoyée au système.

note: type: textblock
en: If the allocation fails, DH_new() returns B<NULL> and sets an error code that can be obtained by L<ERR_get_error(3)|ERR_get_error(3)>. Otherwise it returns a pointer to the newly allocated structure.
fr: Si l'allocation échoue, B<DH_new>() renvoie NULL et définit un code d'erreur qui peut être obtenu par L<ERR_get_error(3)|ERR_get_error(3)>. Sinon, elle renvoie un pointeur vers la structure nouvellement allouée.

note: type: textblock
en: DH_free() returns no value.
fr: B<DH_free>() ne renvoie pas de valeur.

note: type: textblock
en: DH_new() and DH_free() are available in all versions of SSLeay and OpenSSL.
fr: B<DH_new>() et B<DH_free>() sont disponibles dans toutes les versions de SSLeay et OpenSSL.

note: type: textblock
en: DH_set_default_method, DH_get_default_method, DH_set_method, DH_new_method, DH_OpenSSL - select DH method
fr: DH_set_default_method, DH_get_default_method, DH_set_method, DH_new_method, DH_OpenSSL - Sélectionner la méthode DH

note: type: textblock
en: A B<DH_METHOD> specifies the functions that OpenSSL uses for Diffie-Hellman operations. By modifying the method, alternative implementations such as hardware accelerators may be used. IMPORTANT: See the NOTES section for important information about how these DH API functions are affected by the use of B<ENGINE> API calls.
fr: Une B<DH_METHOD> indique les fonctions utilisées par OpenSSL pour les opérations Diffie-Hellman. En modifiant la méthode, les implémentations alternatives comme les accélérateurs matériels peuvent être utilisées. B<Important> : consultez la section B<NOTES> qui contient des renseignements importants sur la façon dont ces fonctions d'interface de programmation de DH sont affectées par l'utilisation des appels d'interfaces de programmation d'B<ENGINE>.

note: type: textblock
en: Initially, the default DH_METHOD is the OpenSSL internal implementation, as returned by DH_OpenSSL().
fr: Au début, la DH_METHOD par défaut est l'implémentation interne d'OpenSSL, comme renvoyée par B<DH_OpenSSL>().

note: type: textblock
en: DH_set_default_method() makes B<meth> the default method for all DH structures created later. B<NB>: This is true only whilst no ENGINE has been set as a default for DH, so this function is no longer recommended.
fr: B<DH_set_default_method>() fait de I<meth> la méthode par défaut pour toutes les structures DH créées ensuite. B<Remarque> : c'est seulement vrai tant qu'aucun ENGINE n'a été défini par défaut pour DH, donc cette fonction n'est plus recommandée.

note: type: textblock
en: DH_get_default_method() returns a pointer to the current default DH_METHOD.  However, the meaningfulness of this result is dependent on whether the ENGINE API is being used, so this function is no longer recommended.
fr: B<DH_get_default_method>() renvoie un pointeur vers la DH_METHOD actuelle par défaut. Cependant, ce résultat n'a de signification que si l'interface de programmation d'ENGINE n'est pas utilisée, donc cette fonction n'est plus recommandée.

note: type: textblock
en: DH_set_method() selects B<meth> to perform all operations using the key B<dh>.  This will replace the DH_METHOD used by the DH key and if the previous method was supplied by an ENGINE, the handle to that ENGINE will be released during the change. It is possible to have DH keys that only work with certain DH_METHOD implementations (eg. from an ENGINE module that supports embedded hardware-protected keys), and in such cases attempting to change the DH_METHOD for the key can have unexpected results.
fr: B<DH_set_method>() sélectionne I<meth> pour réaliser toutes les opérations en utilisant la clef I<dh>. Cela remplacera la DH_METHOD utilisée par la clef DH et, si la méthode précédente était fournie par un ENGINE, le traitement de cet ENGINE sera libéré pendant la modification. Des clefs DH pourraient ne fonctionner qu'avec certaines implémentations de DH_METHOD (par exemple à partir d'un module ENGINE qui autorise les clefs embarquées protégées matériellement), et dans ce cas, tenter de modifier la DH_METHOD pour la clef peut avoir des résultats imprévisibles.

note: type: textblock
en: DH_new_method() allocates and initializes a DH structure so that B<engine> will be used for the DH operations. If B<engine> is NULL, the default ENGINE for DH operations is used, and if no default ENGINE is set, the DH_METHOD controlled by DH_set_default_method() is used.
fr: B<DH_new_method>() alloue et initialise une structure DH de telle sorte que I<engine> sera utilisé pour les opérations DH. Si I<engine> est NULL, l'ENGINE par défaut pour les opérations DH est utilisé, et si aucun ENGINE par défaut n'est défini, la DH_METHOD contrôlée par B<DH_set_default_method>() est utilisée.

note: type: =head1
en: THE DH_METHOD STRUCTURE
fr: LA STRUCTURE DH_METHOD

note: type: verbatim
en:  typedef struct dh_meth_st
     {
         /* name of the implementation */
    	const char *name;
fr:  typedef struct dh_meth_st
     {
         /* nom de l'implémentation */
    	const char *name;

note: type: verbatim
en:      /* generate private and public DH values for key agreement */
            int (*generate_key)(DH *dh);
fr:      /* générer des valeurs DH publique et privée pour l'échange
            de clef */
            int (*generate_key)(DH *dh);

note: type: verbatim
en:      /* compute shared secret */
            int (*compute_key)(unsigned char *key, BIGNUM *pub_key, DH *dh);
fr:      /* calculer le secret partagé */
            int (*compute_key)(unsigned char *key, BIGNUM *pub_key, DH *dh);

note: type: verbatim
en:      /* compute r = a ^ p mod m (May be NULL for some implementations) */
            int (*bn_mod_exp)(DH *dh, BIGNUM *r, BIGNUM *a, const BIGNUM *p,
                                    const BIGNUM *m, BN_CTX *ctx,
                                    BN_MONT_CTX *m_ctx);
fr:      /* calculer r = a ^ p mod m
            (pourrait être NULL pour certaines implémentations) */
            int (*bn_mod_exp)(DH *dh, BIGNUM *r, BIGNUM *a, const BIGNUM *p,
                                    const BIGNUM *m, BN_CTX *ctx,
                                    BN_MONT_CTX *m_ctx);

note: type: verbatim
en:      /* called at DH_new */
            int (*init)(DH *dh);
fr:      /* appelé à DH_new */
            int (*init)(DH *dh);

note: type: verbatim
en:      /* called at DH_free */
            int (*finish)(DH *dh);
fr:      /* appelé à DH_free */
            int (*finish)(DH *dh);

note: type: verbatim
en:         char *app_data; /* ?? */
fr:         char *app_data; /* ? */

note: type: textblock
en: DH_OpenSSL() and DH_get_default_method() return pointers to the respective B<DH_METHOD>s.
fr: B<DH_OpenSSL>() et B<DH_get_default_method>() renvoient des pointeurs vers les B<DH_METHOD>s respectives.

note: type: textblock
en: DH_set_default_method() returns no value.
fr: B<DH_set_default_method>() ne renvoie pas de valeur.

note: type: textblock
en: DH_set_method() returns non-zero if the provided B<meth> was successfully set as the method for B<dh> (including unloading the ENGINE handle if the previous method was supplied by an ENGINE).
fr: B<DH_set_method>() renvoie une valeur non nulle si la I<meth> fournie a été correctement définie comme méthode pour I<dh> (y compris le déchargement du traitement ENGINE si la méthode précédente a été fournie par un ENGINE).

note: type: textblock
en: DH_new_method() returns NULL and sets an error code that can be obtained by L<ERR_get_error(3)|ERR_get_error(3)> if the allocation fails. Otherwise it returns a pointer to the newly allocated structure.
fr: B<DH_new_method>() renvoie NULL et définit un code d'erreur qui peut être obtenu par L<ERR_get_error(3)|ERR_get_error(3)> si l'allocation échoue. Sinon, elle renvoie un pointeur vers la structure nouvellement allouée.

note: type: textblock
en: As of version 0.9.7, DH_METHOD implementations are grouped together with other algorithmic APIs (eg. RSA_METHOD, EVP_CIPHER, etc) in B<ENGINE> modules. If a default ENGINE is specified for DH functionality using an ENGINE API function, that will override any DH defaults set using the DH API (ie.  DH_set_default_method()). For this reason, the ENGINE API is the recommended way to control default implementations for use in DH and other cryptographic algorithms.
fr: Depuis la version 0.9.7, les implémentations DH_METHOD sont groupées avec les autres interfaces de programmation algorithmiques (par exemple RSA_METHOD, EVP_CIPHER, etc.) dans les modules B<ENGINE>. Si un ENGINE par défaut est indiqué pour les fonctionnalités DH en utilisant une fonction d'interface de programmation d'ENGINE, il écrasera toutes les valeurs DH par défaut définies en utilisant une interface de programmation de DH (c'est-à-dire B<DH_set_default_method>()). Par conséquent, l'interface de programmation d'ENGINE est la façon recommandée pour contrôler les implémentations par défaut à utiliser dans DH et les autres algorithmes cryptographiques.

note: type: textblock
en: DH_set_default_method(), DH_get_default_method(), DH_set_method(), DH_new_method() and DH_OpenSSL() were added in OpenSSL 0.9.4.
fr: B<DH_set_default_method>(), B<DH_get_default_method>(), B<DH_set_method>(), B<DH_new_method>() et B<DH_OpenSSL>() ont été ajoutées dans OpenSSL 0.9.4.

note: type: textblock
en: DH_set_default_openssl_method() and DH_get_default_openssl_method() replaced DH_set_default_method() and DH_get_default_method() respectively, and DH_set_method() and DH_new_method() were altered to use B<ENGINE>s rather than B<DH_METHOD>s during development of the engine version of OpenSSL 0.9.6. For 0.9.7, the handling of defaults in the ENGINE API was restructured so that this change was reversed, and behaviour of the other functions resembled more closely the previous behaviour. The behaviour of defaults in the ENGINE API now transparently overrides the behaviour of defaults in the DH API without requiring changing these function prototypes.
fr: B<DH_set_default_openssl_method>() et B<DH_get_default_openssl_method>() ont remplacé respectivement B<DH_set_default_method>() et B<DH_get_default_method>(), et B<DH_set_method>() et B<DH_new_method>() ont été modifiées pour utiliser des B<ENGINE> plutôt que des B<DH_METHOD> lors du développement de la version d'engine d'OpenSSL 0.9.6. Pour 0.9.7, le traitement des valeurs par défaut dans l'interface de programmation d'ENGINE a été restructuré pour que cette modification soit inversée, et que le comportement des autres fonctions ressemble plus au comportement précédent. Le comportement des valeurs par défaut de l'interface de programmation d'ENGINE écrase maintenant de façon transparente le comportement des valeurs par défaut de l'interface de programmation de DH sans nécessiter de modification de ces prototypes de fonction.

note: type: textblock
en: DH_size - get Diffie-Hellman prime size
fr: DH_size - Obtenir la taille d'un nombre premier de Diffie-Hellman

note: type: textblock
en: This function returns the Diffie-Hellman size in bytes. It can be used to determine how much memory must be allocated for the shared secret computed by DH_compute_key().
fr: Cette fonction renvoie la taille d'un nombre premier Diffie-Hellman en octets. Elle peut être utilisée pour déterminer combien de mémoire va être allouée pour le secret partagé calculé par DH_compute_key().

note: type: textblock
en: B<dh-E<gt>p> must not be B<NULL>.
fr: B<dh-E<gt>p> ne doit pas être NULL.

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

note: type: textblock
en: The size in bytes.
fr: La taille en octets.

note: type: textblock
en: DH_size() is available in all versions of SSLeay and OpenSSL.
fr: DH_size() est disponible dans toutes les versions de SSLeay et d'OpenSSL.

note: type: textblock
en: dh - Diffie-Hellman key agreement
fr: dh - Échange de clés Diffie-Hellman

note: type: textblock
en: These functions implement the Diffie-Hellman key agreement protocol.  The generation of shared DH parameters is described in L<DH_generate_parameters(3)|DH_generate_parameters(3)>; L<DH_generate_key(3)|DH_generate_key(3)> describes how to perform a key agreement.
fr: Ces fonctions implémentent le protocol d'échange de clés Diffie-Hellman. La génération de paramètres DH partagés est décrite dans L<DH_generate_parameters(3)|DH_generate_parameters(3)> ; L<DH_generate_key(3)|DH_generate_key(3)> décrit comment effectuer l'échange des clés.

note: type: textblock
en: The B<DH> structure consists of several BIGNUM components.
fr: La structure B<DH> consiste en plusieurs composants BIGNUM.

note: type: verbatim
en:  struct
            {
            BIGNUM *p;		// prime number (shared)
            BIGNUM *g;		// generator of Z_p (shared)
            BIGNUM *priv_key;	// private DH value x
            BIGNUM *pub_key;	// public DH value g^x
            // ...
            };
     DH
fr:  struct
            {
            BIGNUM *p;		// nombre premier (partagé)
            BIGNUM *g;		// générateur de Z_p (partagé)
            BIGNUM *priv_key;	// valeur DH privée x
            BIGNUM *pub_key;	// valeur DH publique g^x
            // ...
            };
     DH

note: type: textblock
en: Note that DH keys may use non-standard B<DH_METHOD> implementations, either directly or by the use of B<ENGINE> modules. In some cases (eg. an ENGINE providing support for hardware-embedded keys), these BIGNUM values will not be used by the implementation or may be used for alternative data storage. For this reason, applications should generally avoid using DH structure elements directly and instead use API functions to query or modify keys.
fr: Notez que les clés DH peuvent utiliser des implémentation B<DH_METHOD> non standard, soit directement, soit en utilisant des modules B<ENGINE>. Dans certains cas (par exemple un ENGINE fournissant la gestion de clés matérielle embarquées), ces valeurs BIGNUM ne seront pas utilisées par l'implémentation ou peuvent être utilisées pour le stockage de d'autres données. Pour cette raison, les applications devraient généralement éviter d'utiliser les éléments de la structure DH directement et devraient à la place utiliser les fonctions de l'API pour demander ou modifier les clés.
