openssl - en to fr translation catalogue (112 entries)

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

note: type: verbatim
en:  BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai,
    	BIGNUM *mod);
     void BN_BLINDING_free(BN_BLINDING *b);
     int BN_BLINDING_update(BN_BLINDING *b,BN_CTX *ctx);
     int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
     int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
     int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b,
    	BN_CTX *ctx);
     int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b,
    	BN_CTX *ctx);
     #ifndef OPENSSL_NO_DEPRECATED
     unsigned long BN_BLINDING_get_thread_id(const BN_BLINDING *);
     void BN_BLINDING_set_thread_id(BN_BLINDING *, unsigned long);
     #endif
     CRYPTO_THREADID *BN_BLINDING_thread_id(BN_BLINDING *);
     unsigned long BN_BLINDING_get_flags(const BN_BLINDING *);
     void BN_BLINDING_set_flags(BN_BLINDING *, unsigned long);
     BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b,
    	const BIGNUM *e, BIGNUM *m, BN_CTX *ctx,
    	int (*bn_mod_exp)(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
    			  const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx),
    	BN_MONT_CTX *m_ctx);
fr:  BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai,
    	BIGNUM *mod);
     void BN_BLINDING_free(BN_BLINDING *b);
     int BN_BLINDING_update(BN_BLINDING *b,BN_CTX *ctx);
     int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
     int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
     int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b,
    	BN_CTX *ctx);
     int BN_BLINDING_invert_ex(BIGNUM *n,const BIGNUM *r,BN_BLINDING *b,
    	BN_CTX *ctx);
     #ifndef OPENSSL_NO_DEPRECATED
     unsigned long BN_BLINDING_get_thread_id(const BN_BLINDING *);
     void BN_BLINDING_set_thread_id(BN_BLINDING *, unsigned long);
     #endif
     CRYPTO_THREADID *BN_BLINDING_thread_id(BN_BLINDING *);
     unsigned long BN_BLINDING_get_flags(const BN_BLINDING *);
     void BN_BLINDING_set_flags(BN_BLINDING *, unsigned long);
     BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b,
    	const BIGNUM *e, BIGNUM *m, BN_CTX *ctx,
    	int (*bn_mod_exp)(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
    			  const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx),
    	BN_MONT_CTX *m_ctx);

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

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

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

note: type: textblock
en: BN_BLINDING_convert_ex, BN_BLINDIND_invert_ex, BN_BLINDING_get_thread_id, BN_BLINDING_set_thread_id, BN_BLINDING_set_flags, BN_BLINDING_get_flags and BN_BLINDING_create_param were first introduced in OpenSSL 0.9.8
fr: BN_BLINDING_convert_ex, BN_BLINDIND_invert_ex, BN_BLINDING_get_thread_id, BN_BLINDING_set_thread_id, BN_BLINDING_set_flags, BN_BLINDING_get_flags et BN_BLINDING_create_param sont apparues dans OpenSSL 0.9.8

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

note: type: textblock
en: Nils Larsch for the OpenSSL project (http://www.openssl.org).
fr: Nils Larsch pour le projet OpenSSL (http://www.openssl.org).

note: type: textblock
en: BN_CTX_new, BN_CTX_init, BN_CTX_free - allocate and free BN_CTX structures
fr: BN_CTX_new, BN_CTX_init, BN_CTX_free - Allouer et libérer des structures BN_CTX

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

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

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

note: type: textblock
en: BN_CTX_init() and BN_CTX_free() have no return values.
fr: B<BN_CTX_init>() et B<BN_CTX_free>() ne renvoient pas de valeur.

note: type: textblock
en: BN_CTX_new() and BN_CTX_free() are available in all versions on SSLeay and OpenSSL. BN_CTX_init() was added in SSLeay 0.9.1b.
fr: B<BN_CTX_new>() et B<BN_CTX_free>() sont disponibles dans toutes les versions de SSLeay et d'OpenSSL. B<BN_CTX_init>() a été ajoutée dans SSLeay 0.9.1b.

note: type: textblock
en: BN_CTX_start, BN_CTX_get, BN_CTX_end - use temporary BIGNUM variables
fr: BN_CTX_start, BN_CTX_get, BN_CTX_end - Utiliser des variables BIGNUM temporaires

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

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

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

note: type: textblock
en: BN_CTX_start() and BN_CTX_end() return no values.
fr: B<BN_CTX_start>() et B<BN_CTX_end>() ne renvoient aucune valeur.

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

note: type: textblock
en: BN_CTX_start(), BN_CTX_get() and BN_CTX_end() were added in OpenSSL 0.9.5.
fr: B<BN_CTX_start>(), B<BN_CTX_get>() et B<BN_CTX_end>() ont été ajoutées dans OpenSSL 0.9.5.

note: type: textblock
en: BN_add_word, BN_sub_word, BN_mul_word, BN_div_word, BN_mod_word - arithmetic functions on BIGNUMs with integers
fr: BN_add_word, BN_sub_word, BN_mul_word, BN_div_word, BN_mod_word - Fonctions arithmétiques sur des BIGNUM avec des entiers

note: type: textblock
en: These functions perform arithmetic operations on BIGNUMs with unsigned integers. They are much more efficient than the normal BIGNUM arithmetic operations.
fr: Ces fonctions réalisent des opérations arithmétiques sur des BIGNUM avec des entiers positifs. Elles sont bien plus efficaces que les opérations arithmétiques de BIGNUM normales.

note: type: textblock
en: BN_add_word() adds B<w> to B<a> (C<a+=w>).
fr: B<BN_add_word>() ajoute I<w> à I<a> (C<a+=w>).

note: type: textblock
en: BN_sub_word() subtracts B<w> from B<a> (C<a-=w>).
fr: B<BN_sub_word>() soustrait I<w> de I<a> (C<a-=w>).

note: type: textblock
en: BN_mul_word() multiplies B<a> and B<w> (C<a*=w>).
fr: B<BN_mul_word>() multiplie I<a> et I<w> (C<a*=w>).

note: type: textblock
en: BN_div_word() divides B<a> by B<w> (C<a/=w>) and returns the remainder.
fr: B<BN_div_word>()divise I<a> par I<w> (C<a/=w>) et renvoie le reste.

note: type: textblock
en: BN_mod_word() returns the remainder of B<a> divided by B<w> (C<a%w>).
fr: B<BN_mod_word>()renvoie le reste de I<a> divisé par I<w> (C<a%w>).

note: type: textblock
en: For BN_div_word() and BN_mod_word(), B<w> must not be 0.
fr: Pour B<BN_div_word>() et B<BN_mod_word>(), I<w> doit être non nul.

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

note: type: textblock
en: BN_mod_word() and BN_div_word() return B<a>%B<w> on success and B<(BN_ULONG)-1> if an error occurred.
fr: B<BN_mod_word>() et B<BN_div_word>() renvoient I<a>%I<w> si elles réussissent et B<(BN_ULONG)-1> en cas d'erreur.

note: type: textblock
en: BN_add_word() and BN_mod_word() are available in all versions of SSLeay and OpenSSL. BN_div_word() was added in SSLeay 0.8, and BN_sub_word() and BN_mul_word() in SSLeay 0.9.0.
fr: B<BN_add_word>() et B<BN_mod_word>() sont disponibles dans toutes les versions de SSLeay et OpenSSL. B<BN_div_word>() a été ajoutée à SSLeay 0.8, et B<BN_sub_word>() et B<BN_mul_word>() dans SSLeay 0.9.0.

note: type: textblock
en: Before 0.9.8a the return value for BN_div_word() and BN_mod_word()  in case of an error was 0.
fr: Avant 0.9.8a la valeur de retour en cas d'erreur de B<BN_div_word>() et B<BN_mod_word>() était 0.

note: type: textblock
en: BN_bn2bin, BN_bin2bn, BN_bn2hex, BN_bn2dec, BN_hex2bn, BN_dec2bn, BN_print, BN_print_fp, BN_bn2mpi, BN_mpi2bn - format conversions
fr: BN_bn2bin, BN_bin2bn, BN_bn2hex, BN_bn2dec, BN_hex2bn, BN_dec2bn, BN_print, BN_print_fp, BN_bn2mpi, BN_mpi2bn - Conversions de format

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

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

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

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

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

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

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

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

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

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

note: type: textblock
en: BN_print_fp() and BN_print() return 1 on success, 0 on write errors.
fr: B<BN_print_fp>() et B<BN_print>() renvoient 1 si elles réussissent ou 0 en cas d'erreur d'écriture.

note: type: textblock
en: BN_bn2mpi() returns the length of the representation. BN_mpi2bn()  returns the B<BIGNUM>, and NULL on error.
fr: B<BN_bn2mpi>() renvoie la taille de la représentation. B<BN_mpi2bn>() renvoie le B<BIGNUM> ou NULL 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: BN_bn2bin(), BN_bin2bn(), BN_print_fp() and BN_print() are available in all versions of SSLeay and OpenSSL.
fr: B<BN_bn2bin>(), B<BN_bin2bn>(), B<BN_print_fp>() et B<BN_print>() sont disponibles dans toutes les versions de SSLeay et OpenSSL.

note: type: textblock
en: BN_bn2hex(), BN_bn2dec(), BN_hex2bn(), BN_dec2bn(), BN_bn2mpi() and BN_mpi2bn() were added in SSLeay 0.9.0.
fr: B<BN_bn2hex>(), B<BN_bn2dec>(), B<BN_hex2bn>(), B<BN_dec2bn>(), B<BN_bn2mpi>() et B<BN_mpi2bn>() ont été ajoutées dans la version 0.9.0 de SSLeay.

note: type: textblock
en: BN_cmp, BN_ucmp, BN_is_zero, BN_is_one, BN_is_word, BN_is_odd - BIGNUM comparison and test functions
fr: BN_cmp, BN_ucmp, BN_is_zero, BN_is_one, BN_is_word, BN_is_odd - Fonctions de comparaison et test de BIGNUM

note: type: textblock
en: BN_cmp() compares the numbers B<a> and B<b>. BN_ucmp() compares their absolute values.
fr: B<BN_cmp>() compare les nombres I<a> et I<b>. B<BN_ucmp>() compare leurs valeurs absolues.

note: type: textblock
en: BN_is_zero(), BN_is_one() and BN_is_word() test if B<a> equals 0, 1, or B<w> respectively. BN_is_odd() tests if a is odd.
fr: B<BN_is_zero>(), B<BN_is_one>() et B<BN_is_word>() testent respectivement si I<a> est égal à B<0>, à B<1> ou à I<w>. B<BN_is_odd>() teste si I<a> est impair.

note: type: textblock
en: BN_is_zero(), BN_is_one(), BN_is_word() and BN_is_odd() are macros.
fr: B<BN_is_zero>(), B<BN_is_one>(), B<BN_is_word>() et B<BN_is_odd>() sont des macros.

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

note: type: textblock
en: BN_is_zero(), BN_is_one() BN_is_word() and BN_is_odd() return 1 if the condition is true, 0 otherwise.
fr: B<BN_is_zero>(), B<BN_is_one>(), B<BN_is_word>() et B<BN_is_odd>() renvoient B<1> si la condition est vraie et B<0> sinon.

note: type: textblock
en: BN_cmp(), BN_ucmp(), BN_is_zero(), BN_is_one() and BN_is_word() are available in all versions of SSLeay and OpenSSL.  BN_is_odd() was added in SSLeay 0.8.
fr: B<BN_cmp>(), B<BN_ucmp>(), B<BN_is_zero>(), B<BN_is_one>() et B<BN_is_word>() sont disponibles dans toutes les versions de SSLeay et OpenSSL. B<BN_is_odd>() a été ajoutée dans SSLeay 0.8.

note: type: textblock
en: BN_copy, BN_dup - copy BIGNUMs
fr: BN_copy, BN_dup - Copier des BIGNUM

note: type: textblock
en: BN_copy() copies B<from> to B<to>. BN_dup() creates a new B<BIGNUM> containing the value B<from>.
fr: BN_copy() copie B<from> vers B<to>. BN_dup() crée un nouveau B<BIGNUM> contenant la valeur de B<from>.

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

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

note: type: textblock
en: BN_mod_inverse - compute inverse modulo n
fr: BN_mod_inverse - Calculer l'inverse modulo n

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

note: type: textblock
en: B<ctx> is a previously allocated B<BN_CTX> used for temporary variables. B<r> may be the same B<BIGNUM> as B<a> or B<n>.
fr: B<ctx> est un B<BN_CTX> alloué auparavant, utilisé pour les variables temporaires. B<r> peut être le même B<BIGNUM> que B<a> ou B<n>.

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

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

note: type: textblock
en: For the other functions, 1 is returned for success, 0 on error.  The error codes can be obtained by L<ERR_get_error(3)|ERR_get_error(3)>.
fr: Pour les autres fonctions, 1 est renvoyé est cas de succès et 0 en cas d'erreur. Les codes d'erreur peuvent être obtenus avec L<ERR_get_error(3)|ERR_get_error(3)>.

note: type: =head1
en: WARNING
fr: AVERTISSEMENT

note: type: textblock
en: BN_MONT_CTX_new(), BN_MONT_CTX_free(), BN_MONT_CTX_set(), BN_mod_mul_montgomery(), BN_from_montgomery() and BN_to_montgomery()  are available in all versions of SSLeay and OpenSSL.
fr: BN_MONT_CTX_new(), BN_MONT_CTX_free(), BN_MONT_CTX_set(), BN_mod_mul_montgomery(), BN_from_montgomery() and BN_to_montgomery() sont disponibles dans toutes les versions de SSLeay et OpenSSL.

note: type: textblock
en: BN_MONT_CTX_init() and BN_MONT_CTX_copy() were added in SSLeay 0.9.1b.
fr: BN_MONT_CTX_init() and BN_MONT_CTX_copy() ont été ajoutés dans la version 0.9.1b de SSLeay.

note: type: textblock
en: BN_RECP_CTX_init() and BN_RECP_CTX_free() have no return values.
fr: BN_RECP_CTX_init() et BN_RECP_CTX_free() ne renvoient rien.

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

note: type: textblock
en: BN_new, BN_init, BN_clear, BN_free, BN_clear_free - allocate and free BIGNUMs
fr: BN_new, BN_init, BN_clear, BN_free, BN_clear_free - Allouer et libérer des BIGNUM

note: type: textblock
en: BN_new() allocates and initializes a B<BIGNUM> structure. BN_init()  initializes an existing uninitialized B<BIGNUM>.
fr: B<BN_new>() alloue et initialise une structure B<BIGNUM>. B<BN_init>() initialise un B<BIGNUM> existant mais non initialisé.

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

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

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

note: type: textblock
en: BN_init(), BN_clear(), BN_free() and BN_clear_free() have no return values.
fr: B<BN_init>(), B<BN_clear>(), B<BN_free>() et B<BN_clear_free>() ne renvoient rien.

note: type: textblock
en: BN_new(), BN_clear(), BN_free() and BN_clear_free() are available in all versions on SSLeay and OpenSSL.  BN_init() was added in SSLeay 0.9.1b.
fr: B<BN_new>(), B<BN_clear>(), B<BN_free>() et B<BN_clear_free>() sont disponibles dans toutes les versions de SSLeay et d'OpenSSL. B<BN_init>() a été ajoutée dans SSLeay 0.9.1b.

note: type: textblock
en: BN_num_bits, BN_num_bytes, BN_num_bits_word - get BIGNUM size
fr: BN_num_bits, BN_num_bytes, BN_num_bits_word - Obtenir la taille de BIGNUM

note: type: textblock
en: BN_num_bytes() returns the size of a B<BIGNUM> in bytes.
fr: B<BN_num_bytes>() renvoie la taille d'un B<BIGNUM> en octet.

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

note: type: textblock
en: BN_num_bits() returns the number of significant bits in a B<BIGNUM>, following the same principle as BN_num_bits_word().
fr: B<BN_num_bits>() renvoie le nombre de bits significatifs dans un B<BIGNUM>, en suivant le même principe que B<BN_num_bits_word>().

note: type: textblock
en: BN_num_bytes() is a macro.
fr: B<BN_num_bytes>() est une macro.

note: type: textblock
en: The size.
fr: La taille.

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

note: type: textblock
en: BN_num_bytes(), BN_num_bits() and BN_num_bits_word() are available in all versions of SSLeay and OpenSSL.
fr: B<BN_num_bytes>(), B<BN_num_bits>() et B<BN_num_bits_word>() sont disponibles dans toutes les versions de SSLeay et d'OpenSSL.

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

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

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

note: type: textblock
en: The PRNG must be seeded prior to calling BN_rand() or BN_rand_range().
fr: Le générateur de nombres aléatoires doit être initialisé avant d'appeler B<BN_rand>() ou B<BN_rand_range>().

note: type: textblock
en: The functions return 1 on success, 0 on error.  The error codes can be obtained by L<ERR_get_error(3)|ERR_get_error(3)>.
fr: Les fonctions renvoient 1 si elles réussissent et 0 en cas d'erreur. Les codes d'erreur peuvent être obtenu par L<ERR_get_error(3)|ERR_get_error(3)>.

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

note: type: textblock
en: BN_set_bit(), BN_clear_bit(), BN_is_bit_set(), BN_mask_bits(), BN_lshift(), BN_lshift1(), BN_rshift(), and BN_rshift1() are available in all versions of SSLeay and OpenSSL.
fr: BN_set_bit(), BN_clear_bit(), BN_is_bit_set(), BN_mask_bits(), BN_lshift(), BN_lshift1(), BN_rshift() et BN_rshift1() sont disponibles dans toutes les versions de SSLeay et d'OpenSSL.

note: type: textblock
en: BN_swap - exchange BIGNUMs
fr: BN_swap - Échange de BIGNUM

note: type: textblock
en: BN_swap() exchanges the values of I<a> and I<b>.
fr: BN_swap() échange les valeurs de I<a> et I<b>.

note: type: textblock
en: BN_swap was added in OpenSSL 0.9.7.
fr: BN_swap a été ajoutée dans la version 0.9.7 d'OpenSSL.

note: type: textblock
en: BN_zero, BN_one, BN_value_one, BN_set_word, BN_get_word - BIGNUM assignment operations
fr: BN_zero, BN_one, BN_value_one, BN_set_word, BN_get_word - Opérations d'assignation de BIGNUM

note: type: textblock
en: BN_zero(), BN_one() and BN_set_word() set B<a> to the values 0, 1 and B<w> respectively.  BN_zero() and BN_one() are macros.
fr: B<BN_zero>(), B<BN_one>() et B<BN_set_word>() définissent respectivement I<a> aux valeurs 0, 1 et I<w>. B<BN_zero>() et B<BN_one>() sont des macros.

note: type: textblock
en: BN_value_one() returns a B<BIGNUM> constant of value 1. This constant is useful for use in comparisons and assignment.
fr: B<BN_value_one>() renvoie un B<BIGNUM> constant de valeur 1. Cette constante est utile pour les comparaisons et assignations.

note: type: textblock
en: BN_get_word() returns B<a>, if it can be represented as an unsigned long.
fr: B<BN_get_word>() renvoie I<a> si cela peut être représenté comme un entier long non signé.

note: type: textblock
en: BN_get_word() returns the value B<a>, and 0xffffffffL if B<a> cannot be represented as an unsigned long.
fr: B<BN_get_word>() renvoie la valeur I<a> ou 0xffffffffL si I<a> ne peut pas être représenté comme un entier long non signé.

note: type: textblock
en: BN_zero(), BN_one() and BN_set_word() return 1 on success, 0 otherwise.  BN_value_one() returns the constant.
fr: B<BN_zero>(), B<BN_one>() et B<BN_set_word>() renvoient 1 si elles réussissent, 0 sinon. B<BN_value_one>() renvoie la constante.

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

note: type: textblock
en: Someone might change the constant.
fr: Quelqu'un pourrait modifier la constante.

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

note: type: textblock
en: BN_zero(), BN_one() and BN_set_word() are available in all versions of SSLeay and OpenSSL. BN_value_one() and BN_get_word() were added in SSLeay 0.8.
fr: B<BN_zero>(), B<BN_one>() et B<BN_set_word>() sont disponibles dans toutes les versions de SSLeay et OpenSSL. B<BN_value_one>() et B<BN_get_word>() ont été ajoutées dans SSLeay 0.8.

note: type: textblock
en: BN_value_one() was changed to return a true const BIGNUM * in OpenSSL 0.9.7.
fr: B<BN_value_one>() a été modifiée pour renvoyer une vraie const BIGNUM * dans OpenSSL 0.9.7.

note: type: textblock
en: bn - multiprecision integer arithmetics
fr: bn - Arithmétique sur des entiers en précision multiple

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

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

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

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