openssl - en to fr translation catalogue (247 entries)

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

note: type: textblock
en: dsa - DSA key processing
fr: dsa - Traitement de clefs DSA

note: type: textblock
en: B<openssl> B<dsa> [B<-inform PEM|DER>] [B<-outform PEM|DER>] [B<-in filename>] [B<-passin arg>] [B<-out filename>] [B<-passout arg>] [B<-aes128>] [B<-aes192>] [B<-aes256>] [B<-camellia128>] [B<-camellia192>] [B<-camellia256>] [B<-des>] [B<-des3>] [B<-idea>] [B<-text>] [B<-noout>] [B<-modulus>] [B<-pubin>] [B<-pubout>] [B<-engine id>]
fr: B<openssl> B<dsa> [B<-inform PEM>|B<DER>] [B<-outform PEM>|B<DER>] [B<-in> I<fichier>] [B<-passin> I<param>] [B<-out> I<fichier>] [B<-passout> I<param>] [B<-aes128>] [B<-aes192>] [B<-aes256>] [B<-camellia128>] [B<-camellia192>] [B<-camellia256>] [B<-des>] [B<-des3>] [B<-idea>] [B<-text>] [B<-noout>] [B<-modulus>] [B<-pubin>] [B<-pubout>] [B<-engine> I<id>]

note: type: textblock
en: The B<dsa> command processes DSA keys. They can be converted between various forms and their components printed out. B<Note> This command uses the traditional SSLeay compatible format for private key encryption: newer applications should use the more secure PKCS#8 format using the B<pkcs8>
fr: La commande B<dsa> gère les clefs DSA. Elles peuvent être converties vers et à partir de plusieurs formes et leurs composants peuvent être affichés. B<Remarque> : cette commande utilise le format compatible SSLeay pour le chiffrement des clefs privées. Les applications plus récentes devraient utiliser le format plus sûr PKCS#8 en utilisant la commande B<pkcs8>.

note: type: =head1
en: COMMAND OPTIONS
fr: OPTIONS DE LA COMMANDE

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 with a private key uses an ASN1 DER encoded form of an ASN.1 SEQUENCE consisting of the values of version (currently zero), p, q, g, the public and private key components respectively as ASN.1 INTEGERs. When used with a public key it uses a SubjectPublicKeyInfo structure: it is an error if the key is not DSA.
fr: Indique le format d'entrée. Avec une clef privée, l'option B<DER> utilise une version encodée ASN1 DER d'une SEQUENCE ASN.1 qui contient les informations de version (zéro actuellement), p, q, g, les composants des clefs publiques et privées respectivement comme entiers INTEGER ASN.1. Lors d'une utilisation avec clef publique, c'est une structure SubjectPublicKeyInfo qui est utilisée, et c'est une erreur si la clef n'est pas de type DSA.

note: type: textblock
en: The B<PEM> form is the default format: it consists of the B<DER> format base64 encoded with additional header and footer lines. In the case of a private key PKCS#8 format is also accepted.
fr: Le format B<PEM> est le format par défaut : il s'agit du format B<DER> encodé en base64 avec des lignes supplémentaires au début et à la fin. Dans le cas d'une clef privée, le format PKCS#8 est également accepté.

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: Indique le format de sortie. Les options ont la même signification que pour l'option B<-inform>.

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

note: type: textblock
en: This specifies the input filename to read a key from or standard input if this option is not specified. If the key is encrypted a pass phrase will be prompted for.
fr: Indique le nom du fichier d'entrée d'où sera lue la clef, ou l'entrée standard si cette option est omise. Si la clef est chiffrée, un mot de passe sera demandé.

note: type: =item
en: B<-passin arg>
fr: B<-passin> I<param>

note: type: textblock
en: the input file password source. For more information about the format of B<arg> see the B<PASS PHRASE ARGUMENTS> section in L<openssl(1)|openssl(1)>.
fr: La source de mot de passe d'entrée. Pour plus de renseignements sur le format de I<param>, consultez la section B<PARAMÈTRES DE PHRASE SECRÈTE> d'L<B<openssl>(1)|openssl(1)>.

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

note: type: textblock
en: This specifies the output filename to write a key to or standard output by is not specified. If any encryption options are set then a pass phrase will be prompted for. The output filename should B<not> be the same as the input filename.
fr: Indique le nom du fichier de sortie où sera écrite la clef. La sortie standard est utilisée si cette option est omise. Si des options de chiffrement ont été indiquées, un mot de passe sera demandé. Le fichier de sortie ne doit B<pas> être identique au fichier d'entrée.

note: type: =item
en: B<-passout arg>
fr: B<-passout> I<param>

note: type: textblock
en: the output file password source. For more information about the format of B<arg> see the B<PASS PHRASE ARGUMENTS> section in L<openssl(1)|openssl(1)>.
fr: La source de mot de passe pour le fichier de sortie. Pour plus de renseignements sur le format de I<param>, consultez la section B<PARAMÈTRES DE PHRASE SECRÈTE> d'L<B<openssl>(1)|openssl(1)>.

note: type: =item
en: B<-aes128|-aes192|-aes256|-camellia128|-camellia192|-camellia256|-des|-des3|-idea>
fr: B<-aes128> | B<-aes192> | B<-aes256> | B<-camellia128> | B<-camellia192> | B<-camellia256> | B<-des> | B<-des3> | B<-idea>

note: type: textblock
en: These options encrypt the private key with the specified cipher before outputting it. A pass phrase is prompted for.  If none of these options is specified the key is written in plain text. This means that using the B<dsa> utility to read in an encrypted key with no encryption option can be used to remove the pass phrase from a key, or by setting the encryption options it can be use to add or change the pass phrase.  These options can only be used with PEM format output files.
fr: Ces options chiffrent la clef privée produite avec l'algorithme de chiffrement indiqué avant de l’afficher. Un mot de passe (ou une phrase secrète) sera demandé. Si aucune de ces options n'est indiquée, la clef sera écrite en texte brut. Cela implique qu'une clef chiffrée, sans aucune option, pourra être lue avec l'utilitaire B<dsa> afin de supprimer le mot de passe ou, en indiquant une option, d'ajouter ou modifier un mot de passe.Cette option n'est disponible qu'avec le format PEM pour les fichiers de sortie.

note: type: textblock
en: prints out the public, private key components and parameters.
fr: Affiche les composants et les paramètres des clefs publiques et privées .

note: type: textblock
en: this option prevents output of the encoded version of the key.
fr: Cette option empêche la sortie de la version encodée de la clef.

note: type: textblock
en: this option prints out the value of the public key component of the key.
fr: Cette option affiche la valeur de la composante publique de la clef.

note: type: textblock
en: by default a private key is read from the input file: with this option a public key is read instead.
fr: Par défaut, une clef privée est lue à partir du fichier d'entrée : avec cette option, une clef publique est lue à sa place.

note: type: textblock
en: by default a private key is output. With this option a public key will be output instead. This option is automatically set if the input is a public key.
fr: Par défaut, une clef privée est produite. Avec cette option, une clef publique est produite à sa place. Cette option est automatiquement activée si l'entrée est une clef publique.

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<dsa> 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: Indique un moteur (en utilisant son identifiant unique I<id>), et force B<dsa> à 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: textblock
en: The PEM private key format uses the header and footer lines:
fr: Le format de clef privée PEM utilise les lignes de début et de fin suivantes :

note: type: textblock
en: The PEM public key format uses the header and footer lines:
fr: Le format de clef publique PEM utilise les lignes de début et de fin suivantes :

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

note: type: textblock
en: To remove the pass phrase on a DSA private key:
fr: Pour enlever le mot de passe d'une clef privée DSA :

note: type: textblock
en: To encrypt a private key using triple DES:
fr: Pour chiffrer une clef privée en utilisant l'algorithme DES triple :

note: type: textblock
en: To convert a private key from PEM to DER format:
fr: Pour convertir une clef privée du format PEM vers le format DER :

note: type: textblock
en: To print out the components of a private key to standard output:
fr: Pour afficher les composants d'une clef privée sur la sortie standard :

note: type: textblock
en: To just output the public part of a private key:
fr: Pour afficher uniquement la partie publique d'une clef privée :

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

note: type: textblock
en: L<dsaparam(1)|dsaparam(1)>, L<gendsa(1)|gendsa(1)>, L<rsa(1)|rsa(1)>, L<genrsa(1)|genrsa(1)>
fr: L<B<dsaparam>(1)|dsaparam(1)>, L<B<gendsa>(1)|gendsa(1)>, L<B<genrsa>(1)|genrsa(1)>, L<B<rsa>(1)|rsa(1)>,

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

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

note: type: textblock
en: This command is used to manipulate or generate DSA parameter files.
fr: Cette commande est utilisée pour manipuler ou générer des fichiers de paramètres DSA.

note: type: textblock
en: This specifies the input format. The B<DER> option uses an ASN1 DER encoded form compatible with RFC2459 (PKIX) DSS-Parms that is a SEQUENCE consisting of p, q and g respectively. The PEM form is the default format: it consists of the B<DER> format base64 encoded with additional header and footer lines.
fr: Indique le format d'entrée. L'option B<DER> utilise une forme encodée ASN1 DER compatible avec les paramètres DSS selon la RFC 2459 (PKIX) qui sont une SEQUENCE comprenant p, q, et g respectivement. 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: textblock
en: This specifies the input filename to read parameters from or standard input if this option is not specified. If the B<numbits> parameter is included then this option will be ignored.
fr: Indique le nom du fichier d'où seront lus les paramètres ou l'entrée standard si cette option n'est pas indiquée. Si le paramètre B<nombre_bits> est inclus, alors cette option est ignorée.

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: Indique 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: 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 DSA parameters in human readable form.
fr: Cette option affiche les paramètres DSA 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_dsaXXX()> function.
fr: Cette option convertit les paramètres en code source C. Ces paramètres peuvent ensuite être chargés en utilisant la fonction B<get_dsaXXX()>.

note: type: textblock
en: this option will generate a DSA either using the specified or generated parameters.
fr: Cette option génère une clef DSA en utilisant les paramètres indiqués ou générés.

note: type: =item
en: B<-rand 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<B<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: B<numbits>
fr: B<nombre_bits>

note: type: textblock
en: this option specifies that a parameter set should be generated of size B<numbits>. It must be the last option. If this option is included then the input file (if any) is ignored.
fr: Cette option indique qu'un ensemble de paramètres de taille B<nombre_bits> doit être généré. Cette option doit être placée en dernier. Si cette option est présente, le fichier d'entrée (s'il y en a un) est ignoré.

note: type: textblock
en: specifying an engine (by its unique B<id> string) will cause B<dsaparam> 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: Indique un moteur (en utilisant son identifiant unique I<id>), et force B<dsaparam> à 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: textblock
en: PEM format DSA parameters use the header and footer lines:
fr: Le format PEM des paramètres DSA utilise les première et dernière lignes suivantes :

note: type: textblock
en: DSA parameter generation is a slow process and as a result the same set of DSA parameters is often used to generate several distinct keys.
fr: La génération de paramètres DSA est un processus lent et ainsi un même ensemble de paramètres DSA est souvent utilisé pour la génération de plusieurs clefs distinctes.

note: type: textblock
en: L<gendsa(1)|gendsa(1)>, L<dsa(1)|dsa(1)>, L<genrsa(1)|genrsa(1)>, L<rsa(1)|rsa(1)>
fr: L<B<dsa>(1)|dsa(1)>, L<B<gendsa>(1)|gendsa(1)>, L<B<genrsa>(1)|genrsa(1)>, L<B<rsa>(1)|rsa(1)>

note: type: textblock
en: gendsa - generate a DSA private key from a set of parameters
fr: gendsa - Générer une clef privée DSA à partir d'un ensemble de paramètres

note: type: textblock
en: B<openssl> B<gendsa> [B<-out filename>] [B<-aes128>] [B<-aes192>] [B<-aes256>] [B<-camellia128>] [B<-camellia192>] [B<-camellia256>] [B<-des>] [B<-des3>] [B<-idea>] [B<-rand file(s)>] [B<-engine id>] [B<paramfile>]
fr: B<openssl> B<gendsa> [B<-out> I<fichier>] [B<-aes128>] [B<-aes192>] [B<-aes256>] [B<-camellia128>] [B<-camellia192>] [B<-camellia256>] [B<-des>] [B<-des3>] [B<-idea>] [B<-rand> I<fichier(s)>] [B<-engine> I<id>] [B<fichier_param>]

note: type: textblock
en: The B<gendsa> command generates a DSA private key from a DSA parameter file (which will be typically generated by the B<openssl dsaparam> command).
fr: La commande B<gendsa> génère une clef privée DSA à partir d'un fichier de paramètres DSA (qui est généré typiquement avec la commande B<openssl dsaparam>).

note: type: textblock
en: These options encrypt the private key with specified cipher before outputting it. A pass phrase is prompted for.  If none of these options is specified no encryption is used.
fr: Ces options chiffrent la clef privée avec l’algorithme de chiffrement indiqué avant de l’afficher. Un mot de passe est demandé. Si aucune de ces options n'est précisée, aucun chiffrement n'est effectué.

note: type: textblock
en: specifying an engine (by its unique B<id> string) will cause B<gendsa> 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: Indique un moteur (en utilisant son identifiant unique I<id>), et force B<gendsa> à 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: =item
en: B<paramfile>
fr: B<fichier_param>

note: type: textblock
en: This option specifies the DSA parameter file to use. The parameters in this file determine the size of the private key. DSA parameters can be generated and examined using the B<openssl dsaparam> command.
fr: Cette option indique le fichier de paramètres DSA à utiliser. Les paramètres dans ce fichier déterminent la taille de la clef privée. Les paramètres DSA peuvent être générés et examinés avec la commande B<openssl dsaparam>.

note: type: textblock
en: DSA key generation is little more than random number generation so it is much quicker that RSA key generation for example.
fr: La génération de clefs DSA consiste essentiellement en la génération de nombres aléatoires et est ainsi nettement plus rapide que la génération de clef RSA par exemple.

note: type: textblock
en: L<dsaparam(1)|dsaparam(1)>, L<dsa(1)|dsa(1)>, L<genrsa(1)|genrsa(1)>, L<rsa(1)|rsa(1)>
fr: L<B<dsaparam>(1)|dsaparam(1)>, L<B<dsa>(1)|dsa(1)>, L<B<genrsa>(1)|genrsa(1)>, L<B<rsa>(1)|rsa(1)>

note: type: textblock
en: DSA_SIG_new, DSA_SIG_free - allocate and free DSA signature objects
fr: DSA_SIG_new, DSA_SIG_free - Allouer et libérer des objets de signature DSA

note: type: verbatim
en:  #include <openssl/dsa.h>
fr: B< #include B<lt>openssl/dsa.hE<gt>>

note: type: verbatim
en:  DSA_SIG *DSA_SIG_new(void);
fr: B< DSA_SIG *DSA_SIG_new(void);>

note: type: verbatim
en:  void	DSA_SIG_free(DSA_SIG *a);
fr: B< void	DSA_SIG_free(DSA_SIG *>I<a>B<);>

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

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

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

note: type: textblock
en: If the allocation fails, DSA_SIG_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<DSA_SIG_new>() renvoie NULL et définit un code d'erreur qui peut être obtenu par L<B<ERR_get_error>(3)|ERR_get_error(3)>. Sinon, elle renvoie un pointeur vers la structure nouvellement allouée.

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

note: type: textblock
en: L<dsa(3)|dsa(3)>, L<ERR_get_error(3)|ERR_get_error(3)>, L<DSA_do_sign(3)|DSA_do_sign(3)>
fr: L<B<dsa>(3)|dsa(3)>, L<B<DSA_do_sign>(3)|DSA_do_sign(3)>, L<B<ERR_get_error>(3)|ERR_get_error(3)>

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

note: type: textblock
en: DSA_SIG_new() and DSA_SIG_free() were added in OpenSSL 0.9.3.
fr: B<DSA_SIG_new>() et B<DSA_SIG_free>() ont été ajoutées dans OpenSSL 0.9.3.

note: type: textblock
en: DSA_do_sign, DSA_do_verify - raw DSA signature operations
fr: DSA_do_sign, DSA_do_verify - Opérations de signature DSA brute

note: type: verbatim
en:  DSA_SIG *DSA_do_sign(const unsigned char *dgst, int dlen, DSA *dsa);
fr: B< DSA_SIG *DSA_do_sign(const unsigned char *>I<dgst>B<, int dlen, DSA *>I<dsa>B<);>

note: type: verbatim
en:  int DSA_do_verify(const unsigned char *dgst, int dgst_len,
    	     DSA_SIG *sig, DSA *dsa);
fr: B< int DSA_do_verify(const unsigned char *>I<dgst>B<, int> I<dgst_len>B<,>
     	     B<DSA_SIG *>I<sig>B<, DSA *>I<dsa>B<);>

note: type: textblock
en: DSA_do_sign() computes a digital signature on the B<len> byte message digest B<dgst> using the private key B<dsa> and returns it in a newly allocated B<DSA_SIG> structure.
fr: B<DSA_do_sign>() calcule une signature numérique sur le condensé de message de I<len> octets, I<dgst>, en utilisant la clef privée I<dsa>, et la renvoie dans une structure B<DSA_SIG> nouvellement allouée.

note: type: textblock
en: L<DSA_sign_setup(3)|DSA_sign_setup(3)> may be used to precompute part of the signing operation in case signature generation is time-critical.
fr: L<B<DSA_sign_setup>(3)|DSA_sign_setup(3)> peut être utilisée pour précalculer un morceau de l'opération de signature lorsque la génération de signature doit absolument être rapide.

note: type: textblock
en: DSA_do_verify() verifies that the signature B<sig> matches a given message digest B<dgst> of size B<len>.  B<dsa> is the signer's public key.
fr: B<DSA_do_verify>() vérifie que la signature I<sig> correspond à un condensé de message donné I<dgst>, de taille I<dgst_len>. I<dsa> est la clef publique du signataire.

note: type: textblock
en: DSA_do_sign() returns the signature, NULL on error.  DSA_do_verify()  returns 1 for a valid signature, 0 for an incorrect signature and -1 on error. The error codes can be obtained by L<ERR_get_error(3)|ERR_get_error(3)>.
fr: B<DSA_do_sign>() renvoie la signature, ou NULL en cas d'erreur. B<DSA_do_verify>() renvoie B<1> pour une signature correcte, B<0> pour une signature incorrecte ou B<-1> en cas d'erreur. Les codes d'erreur peuvent être obtenus par L<B<ERR_get_error>(3)|ERR_get_error(3)>.

note: type: textblock
en: L<dsa(3)|dsa(3)>, L<ERR_get_error(3)|ERR_get_error(3)>, L<rand(3)|rand(3)>, L<DSA_SIG_new(3)|DSA_SIG_new(3)>, L<DSA_sign(3)|DSA_sign(3)>
fr: L<B<dsa>(3)|dsa(3)>, L<B<DSA_SIG_new>(3)|DSA_SIG_new(3)>, L<B<DSA_sign>(3)|DSA_sign(3)>, L<B<ERR_get_error>(3)|ERR_get_error(3)>, L<B<rand>(3)|rand(3)>

note: type: textblock
en: DSA_do_sign() and DSA_do_verify() were added in OpenSSL 0.9.3.
fr: B<DSA_do_sign>() et B<DSA_do_verify>() ont été ajoutées dans OpenSSL 0.9.3.

note: type: textblock
en: DSA_dup_DH - create a DH structure out of DSA structure
fr: DSA_dup_DH - Créer une structure DH à l'aide d'une structure DSA

note: type: verbatim
en:  DH * DSA_dup_DH(const DSA *r);
fr: B< DH * DSA_dup_DH(const DSA *>I<r>B<);>

note: type: textblock
en: DSA_dup_DH() duplicates DSA parameters/keys as DH parameters/keys. q is lost during that conversion, but the resulting DH parameters contain its length.
fr: B<DSA_dup_DH>() duplique les paramètres ou clefs DSA en paramètres ou clefs DH. I<q> est perdu lors de cette conversion, mais les paramètres DH résultants contiennent sa taille.

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

note: type: textblock
en: DSA_dup_DH() returns the new B<DH> structure, and NULL on error. The error codes can be obtained by L<ERR_get_error(3)|ERR_get_error(3)>.
fr: B<DSA_dup_DH>() renvoie la nouvelle structure B<DH> ou NULL en cas d'erreur. Les codes d'erreur peuvent être obtenus à l'aide de L<B<ERR_get_error>(3)|ERR_get_error(3)>.

note: type: textblock
en: Be careful to avoid small subgroup attacks when using this.
fr: Faites attention d'éviter les attaques par petits sous-groupes (« small subgroup ») en utilisant cette fonction.

note: type: textblock
en: L<dh(3)|dh(3)>, L<dsa(3)|dsa(3)>, L<ERR_get_error(3)|ERR_get_error(3)>
fr: L<B<dh>(3)|dh(3)>, L<B<dsa>(3)|dsa(3)>, L<B<ERR_get_error>(3)|ERR_get_error(3)>

note: type: textblock
en: DSA_dup_DH() was added in OpenSSL 0.9.4.
fr: B<DSA_dup_DH>() a été ajoutée dans OpenSSL 0.9.4.

note: type: textblock
en: DSA_generate_key - generate DSA key pair
fr: DSA_generate_key - Créer une paire de clefs DSA

note: type: verbatim
en:  int DSA_generate_key(DSA *a);
fr: B< int DSA_generate_key(DSA *>I<a>B<);>

note: type: textblock
en: DSA_generate_key() expects B<a> to contain DSA parameters. It generates a new key pair and stores it in B<a-E<gt>pub_key> and B<a-E<gt>priv_key>.
fr: B<DSA_generate_key>() attend dans I<a> des paramètres DSA. Elle crée une nouvelle paire de clefs et la stocke dans I<a>B<-E<gt>pub_key> et I<a>B<-E<gt>priv_key>.

note: type: textblock
en: The PRNG must be seeded prior to calling DSA_generate_key().
fr: Le générateur de nombres pseudoaléatoires doit avoir été initialisé avant d'appeler B<DSA_generate_key>().

note: type: textblock
en: DSA_generate_key() returns 1 on success, 0 otherwise.  The error codes can be obtained by L<ERR_get_error(3)|ERR_get_error(3)>.
fr: B<DSA_generate_key>() renvoie B<1> si elle réussit et B<0> sinon. Les codes d'erreur peuvent être obtenus à l'aide de L<B<ERR_get_error>(3)|ERR_get_error(3)>.

note: type: textblock
en: L<dsa(3)|dsa(3)>, L<ERR_get_error(3)|ERR_get_error(3)>, L<rand(3)|rand(3)>, L<DSA_generate_parameters(3)|DSA_generate_parameters(3)>
fr: L<B<dsa>(3)|dsa(3)>, L<B<DSA_generate_parameters>(3)|DSA_generate_parameters(3)>, L<B<ERR_get_error>(3)|ERR_get_error(3)>, L<B<rand>(3)|rand(3)>

note: type: textblock
en: DSA_generate_key() is available since SSLeay 0.8.
fr: B<DSA_generate_key>() a été ajoutée dans SSLeay 0.8.

note: type: textblock
en: DSA_generate_parameters_ex, DSA_generate_parameters - generate DSA parameters
fr: DSA_generate_parameters_ex, DSA_generate_parameters - Créer des paramètres DSA

note: type: verbatim
en:  int DSA_generate_parameters_ex(DSA *dsa, int bits,
    		const unsigned char *seed,int seed_len,
    		int *counter_ret, unsigned long *h_ret, BN_GENCB *cb);
fr: B< int DSA_generate_parameters_ex(DSA *>I<dsa>B<, int> I<bits>B<,>
     		B<const unsigned char *>I<seed>B<, int> I<seed_len>B<,>
     		B<int *>I<counter_ret>B<, unsigned long *>I<h_ret>B<, BN_GENCB *>I<cb>B<);>

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

note: type: verbatim
en:  DSA *DSA_generate_parameters(int bits, unsigned char *seed,
                    int seed_len, int *counter_ret, unsigned long *h_ret,
    		void (*callback)(int, int, void *), void *cb_arg);
fr: B< DSA *DSA_generate_parameters(int> I<bits>B<, unsigned char *>I<seed>B<,>
     		B<int> I<seed_len>B< int *>I<counter_ret>B<, unsigned long *>I<h_ret>B<,>
     		B<void (*>I<callback>B<)(int, int, void *), void *>I<cb_arg>B<);>

note: type: textblock
en: DSA_generate_parameters_ex() generates primes p and q and a generator g for use in the DSA and stores the result in B<dsa>.
fr: B<DSA_generate_parameters_ex>() crée des nombres premiers I<p> et I<q> et un générateur I<g> pour utiliser dans le DSA et conserve le résultat dans I<dsa>.

note: type: textblock
en: B<bits> is the length of the prime to be generated; the DSS allows a maximum of 1024 bits.
fr: I<bits> est la taille du nombre premier à générer ; la DSS permet 1024 bits au maximum.

note: type: textblock
en: If B<seed> is B<NULL> or B<seed_len> E<lt> 20, the primes will be generated at random. Otherwise, the seed is used to generate them. If the given seed does not yield a prime q, a new random seed is chosen and placed at B<seed>.
fr: Si I<seed> est NULL ou I<seed_len> E<lt> 20, les nombres premiers seront créés de façon aléatoire. Sinon, ils seront initialisés avec I<seed>. Si la valeur de départ donnée ne renvoie pas de nombre premier I<q>, une nouvelle initialisation aléatoire est choisie et placée dans I<seed>.

note: type: textblock
en: DSA_generate_parameters_ex() places the iteration count in *B<counter_ret> and a counter used for finding a generator in *B<h_ret>, unless these are B<NULL>.
fr: B<DSA_generate_parameters_ex>() place le décompte d’itérations dans B<*>I<counter_ret> et un compteur utilisé pour trouver un générateur dans B<*>I<h_ret>, sauf s’ils sont NULL.

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 shown below. For information on the BN_GENCB structure and the BN_GENCB_call function discussed below, refer to L<BN_generate_prime(3)|BN_generate_prime(3)>.
fr: Une fonction de rappel pourrait être utilisée pour fournir un retour sur l’avancement de la création de clef. Si I<cb> n’est pas NULL, elle sera appelée comme montré ci-dessous. Pour plus de renseignements sur la structure B<BN_GENCB> et la fonction B<BN_GENCB_call>() évoquées ci-dessous, consultez L<B<BN_generate_prime>(3)|BN_generate_prime(3)>.

note: type: textblock
en: When a candidate for q is generated, B<BN_GENCB_call(cb, 0, m++)> is called (m is 0 for the first candidate).
fr: Quand un candidat pour I<q> est créé, B<BN_GENCB_call(>I<cb>, B<0,> I<m>B<++>B<)> est appelée (I<m> est B<0> pour le premier candidat).

note: type: textblock
en: When a candidate for q has passed a test by trial division, B<BN_GENCB_call(cb, 1, -1)> is called.  While a candidate for q is tested by Miller-Rabin primality tests, B<BN_GENCB_call(cb, 1, i)> is called in the outer loop (once for each witness that confirms that the candidate may be prime); i is the loop counter (starting at 0).
fr: Quand un candidat pour I<q> a passé un test par divisions successives, B<BN_GENCB_call(>I<cb>B<, 1, -1)> est appelée. Alors qu’un candidat pour I<q> est testé par les tests de primalité de Miller-Rabin, B<BN_GENCB_call(>I<cb>B<, 1,> I<i>B<)> est appelée dans la boucle externe (une fois pour chaque témoin confirmant que le candidat pourrait être premier) ; I<i> est le compteur de boucles (commençant à B<0>).

note: type: textblock
en: When a prime q has been found, B<BN_GENCB_call(cb, 2, 0)> and B<BN_GENCB_call(cb, 3, 0)> are called.
fr: Quand un nombre premier I<q> a été trouvé, B<BN_GENCB_call(>I<cb>B<, 2, 0)> et B<BN_GENCB_call(>I<cb>B<, 3, 0)> sont appelées.

note: type: textblock
en: Before a candidate for p (other than the first) is generated and tested, B<BN_GENCB_call(cb, 0, counter)> is called.
fr: Avant qu’un candidat pour I<p> (autre que le premier) ne soit créé et testé, B<BN_GENCB_call(>I<cb>B<, 0,> I<compteur>B<)> est appelée.

note: type: textblock
en: When a candidate for p has passed the test by trial division, B<BN_GENCB_call(cb, 1, -1)> is called.  While it is tested by the Miller-Rabin primality test, B<BN_GENCB_call(cb, 1, i)> is called in the outer loop (once for each witness that confirms that the candidate may be prime).  i is the loop counter (starting at 0).
fr: Quand un candidat pour I<p> a passé un test par divisions successives, B<BN_GENCB_call(>I<cb>B<, 1, -1)> est appelée. Alors qu’il est testé par les tests de primalité de Miller-Rabin, B<BN_GENCB_call(>I<cb>B<, 1,> I<i>B<)> est appelée dans la boucle externe (une fois pour chaque témoin confirmant que le candidat pourrait être premier). I<i> est le compteur de boucle (commençant à B<0>).

note: type: textblock
en: When p has been found, B<BN_GENCB_call(cb, 2, 1)> is called.
fr: Quand I<p> a été trouvé, B<BN_GENCB_call(>I<cb>B<, 2, 1)> est appelée.

note: type: textblock
en: When the generator has been found, B<BN_GENCB_call(cb, 3, 1)> is called.
fr: Quand le générateur a été trouvé, B<BN_GENCB_call(>I<cb>B<, 3, 1)> est appelée.

note: type: textblock
en: DSA_generate_parameters() (deprecated) works in much the same way as for DSA_generate_parameters_ex, except that no B<dsa> parameter is passed and instead a newly allocated B<DSA> structure is returned. Additionally "old style" callbacks are used instead of the newer BN_GENCB based approach.  Refer to L<BN_generate_prime(3)|BN_generate_prime(3)> for further information.
fr: B<DSA_generate_parameters>() (obsolète) fonctionne de façon très similaire à B<DSA_generate_parameters_ex>(), à part qu’aucun paramètre I<dsa> n’est passé et, qu’à la place, une structure B<DSA> nouvellement allouée est renvoyée. De plus, les rappels « à l’ancienne » sont utilisés au lieu de la nouvelle approche basée sur B<BN_GENCB>. Consultez L<B<BN_generate_prime>(3)|BN_generate_prime(3)> pour plus de renseignements.

note: type: textblock
en: DSA_generate_parameters_ex() returns a 1 on success, or 0 otherwise.
fr: B<DSA_generate_parameters_ex>() renvoie B<1> si elle réussit et B<0> sinon.

note: type: textblock
en: DSA_generate_parameters() returns a pointer to the DSA structure, or B<NULL> if the parameter generation fails.
fr: B<DSA_generate_parameters>() renvoie un pointeur vers la structure DSA ou NULL en cas d’échec de création de paramètre.

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 à l'aide de L<B<ERR_get_error>(3)|ERR_get_error(3)>.

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

note: type: textblock
en: Seed lengths E<gt> 20 are not supported.
fr: Les tailles de I<seed> E<gt> 20 ne sont pas prises en charge.

note: type: textblock
en: L<dsa(3)|dsa(3)>, L<ERR_get_error(3)|ERR_get_error(3)>, L<rand(3)|rand(3)>, L<DSA_free(3)|DSA_free(3)>, L<BN_generate_prime(3)|BN_generate_prime(3)>
fr: L<B<dsa>(3)|dsa(3)>, L<B<ERR_get_error>(3)|ERR_get_error(3)>, L<B<rand>(3)|rand(3)>, L<B<DSA_free>(3)|DSA_free(3)>, L<B<BN_generate_prime>(3)|BN_generate_prime(3)>

note: type: textblock
en: DSA_generate_parameters() appeared in SSLeay 0.8. The B<cb_arg> argument was added in SSLeay 0.9.0.  In versions up to OpenSSL 0.9.4, B<callback(1, ...)> was called in the inner loop of the Miller-Rabin test whenever it reached the squaring step (the parameters to B<callback> did not reveal how many witnesses had been tested); since OpenSSL 0.9.5, B<callback(1, ...)> is called as in BN_is_prime(3), i.e. once for each witness.  =cut
fr: B<DSA_generate_parameters>() est apparue dans SSLeay 0.8. L’argument I<cb_arg> a été ajouté dans SSLeay 0.9.0. Dans OpenSSL jusqu’à la version 0.9.4, I<callback>B<(1, ...)> était appelée dans la boucle interne du test de Miller-Rabin à chaque fois qu’elle atteignait l’étape du carré (les paramètres de I<callback> n’indiquaient pas le nombre de témoins qui avaient été essayés) ; depuis OpenSSL 0.9.5, I<callback>B<(1, ...)> est appelée comme dans B<BN_is_prime>(3), c’est-à-dire une fois par témoin.
    
    =cut

note: type: textblock
en: DSA_get_ex_new_index, DSA_set_ex_data, DSA_get_ex_data - add application specific data to DSA structures
fr: DSA_get_ex_new_index, DSA_set_ex_data, DSA_get_ex_data - Ajouter des données spécifiques aux applications dans des structures DSA

note: type: verbatim
en:  int DSA_get_ex_new_index(long argl, void *argp,
    		CRYPTO_EX_new *new_func,
    		CRYPTO_EX_dup *dup_func,
    		CRYPTO_EX_free *free_func);
fr: B< int DSA_get_ex_new_index(long> I<argl>B<, void *>I<argp>B<,>
     		B<CRYPTO_EX_new *>I<new_func>B<,>
     		B<CRYPTO_EX_dup *>I<dup_func>B<,>
     		B<CRYPTO_EX_free *f>I<ree_func>B<);>

note: type: verbatim
en:  int DSA_set_ex_data(DSA *d, int idx, void *arg);
fr: B< int DSA_set_ex_data(DSA *>I<d>B<, int> I<idx>B<, void *>I<arg>B<);>

note: type: verbatim
en:  char *DSA_get_ex_data(DSA *d, int idx);
fr: B< char *DSA_get_ex_data(DSA *>I<d>B<, int> I<idx>B<);>

note: type: textblock
en: These functions handle application specific data in DSA 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 DSA. 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<B<RSA_get_ex_new_index>(3)>.

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

note: type: textblock
en: DSA_get_ex_new_index(), DSA_set_ex_data() and DSA_get_ex_data() are available since OpenSSL 0.9.5.
fr: B<DSA_get_ex_new_index>(), B<DSA_set_ex_data>() et B<DSA_get_ex_data>() sont disponibles depuis OpenSSL 0.9.5.

note: type: textblock
en: DSA_new, DSA_free - allocate and free DSA objects
fr: DSA_new, DSA_free - Allouer et libérer des objets DSA

note: type: verbatim
en:  DSA* DSA_new(void);
fr: B< DSA* DSA_new(void);>

note: type: verbatim
en:  void DSA_free(DSA *dsa);
fr: B< void DSA_free(DSA *>I<dsa>B<);>

note: type: textblock
en: DSA_new() allocates and initializes a B<DSA> structure. It is equivalent to calling DSA_new_method(NULL).
fr: B<DSA_new>() alloue et initialise une structure B<DSA>. Elle équivaut à un appel de B<DSA_new_method>(NULL).

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

note: type: textblock
en: If the allocation fails, DSA_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 de mémoire échoue, B<DSA_new>() renvoie NULL et positionne un code d'erreur qui peut être récupéré avec L<B<ERR_get_error>(3)|ERR_get_error(3)>. Sinon, elle renvoie un pointeur vers la structure nouvellement allouée.

note: type: textblock
en: DSA_free() returns no value.
fr: B<DSA_free>() ne renvoie rien.

note: type: textblock
en: L<dsa(3)|dsa(3)>, L<ERR_get_error(3)|ERR_get_error(3)>, L<DSA_generate_parameters(3)|DSA_generate_parameters(3)>, L<DSA_generate_key(3)|DSA_generate_key(3)>
fr: L<B<dsa>(3)|dsa(3)>, L<B<DSA_generate_parameters>(3)|DSA_generate_parameters(3)>, L<B<DSA_generate_key>(3)|DSA_generate_key(3)>, L<B<ERR_get_error>(3)|ERR_get_error(3)>

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

note: type: textblock
en: DSA_set_default_method, DSA_get_default_method, DSA_set_method, DSA_new_method, DSA_OpenSSL - select DSA method
fr: DSA_set_default_method, DSA_get_default_method, DSA_set_method, DSA_new_method, DSA_OpenSSL - Sélectionner la méthode DSA

note: type: verbatim
en:  #include <openssl/dsa.h>
     #include <openssl/engine.h>
fr: B< #include E<lt>openssl/dsa.hE<gt>>
     B<#include E<lt>openssl/engine.hE<gt>>

note: type: verbatim
en:  void DSA_set_default_method(const DSA_METHOD *meth);
fr: B< void DSA_set_default_method(const DSA_METHOD *>I<meth>B<);>

note: type: verbatim
en:  const DSA_METHOD *DSA_get_default_method(void);
fr: B< const DSA_METHOD *DSA_get_default_method(void);>

note: type: verbatim
en:  int DSA_set_method(DSA *dsa, const DSA_METHOD *meth);
fr: B< int DSA_set_method(DSA *>I<dsa>B<, const DSA_METHOD *>I<meth>B<);>

note: type: verbatim
en:  DSA *DSA_new_method(ENGINE *engine);
fr: B< DSA *DSA_new_method(ENGINE *>I<engine>B<);>

note: type: verbatim
en:  DSA_METHOD *DSA_OpenSSL(void);
fr: B< DSA_METHOD *DSA_OpenSSL(void);>

note: type: textblock
en: A B<DSA_METHOD> specifies the functions that OpenSSL uses for DSA 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 DSA API functions are affected by the use of B<ENGINE> API calls.
fr: Une B<DSA_METHOD> indique les fonctions qu’OpenSSL utilise pour les opérations DSA. En modifiant la méthode, les implémentations alternatives comme les accélérateurs matériels pourraient être utilisés. B<Important> : consultez la section B<NOTES> qui contient des renseignements importants sur la façon dont ces fonctions d’interface de programmation DSA sont concernées par l’utilisation des appels d’interface de programmation B<ENGINE>.

note: type: textblock
en: Initially, the default DSA_METHOD is the OpenSSL internal implementation, as returned by DSA_OpenSSL().
fr: Initialement, la DSA_METHOD par défaut est l’implémentation interne d’OpenSSL, telle que renvoyée par B<DSA_OpenSSL>().

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

note: type: textblock
en: DSA_get_default_method() returns a pointer to the current default DSA_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<DSA_get_default_method>() renvoie un pointeur vers la DSA_METHOD par défaut actuelle. Cependant, la signification de ce résultat dépend de l’utilisation ou non de l’interface de programmation ENGINE, donc cette fonction n’est plus recommandée.

note: type: textblock
en: DSA_set_method() selects B<meth> to perform all operations using the key B<rsa>. This will replace the DSA_METHOD used by the DSA 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 DSA keys that only work with certain DSA_METHOD implementations (eg. from an ENGINE module that supports embedded hardware-protected keys), and in such cases attempting to change the DSA_METHOD for the key can have unexpected results.
fr: B<DSA_set_method>() sélectionne I<meth> pour réaliser toutes les opérations utilisant la clef I<dsa>. Cela remplacera la DSA_METHOD utilisée par la clef DSA et, si la méthode précédente a été fournie par un ENGINE, le traitement par cet ENGINE sera abandonné pendant la modification. Certaines clefs pourraient ne fonctionner qu’avec certaines implémentations de DSA_METHOD (par exemple à partir d’un module ENGINE qui prend en charge les clefs protégées matériellement) et, dans ces cas, essayer de modifier la DSA_METHOD pour la clef peut avoir des résultats inattendus.

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

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

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

note: type: verbatim
en:      /* sign */
    	DSA_SIG *(*dsa_do_sign)(const unsigned char *dgst, int dlen,
                                     DSA *dsa);
fr:      /* signer */
    	DSA_SIG *(*dsa_do_sign)(const unsigned char *dgst, int dlen,
                                     DSA *dsa);

note: type: verbatim
en:      /* pre-compute k^-1 and r */
    	int (*dsa_sign_setup)(DSA *dsa, BN_CTX *ctx_in, BIGNUM **kinvp,
                                     BIGNUM **rp);
fr:      /* précalculer k^-1 et r */
    	int (*dsa_sign_setup)(DSA *dsa, BN_CTX *ctx_in, BIGNUM **kinvp,
                                     BIGNUM **rp);

note: type: verbatim
en:      /* verify */
    	int (*dsa_do_verify)(const unsigned char *dgst, int dgst_len,
                                     DSA_SIG *sig, DSA *dsa);
fr:      /* vérifier */
    	int (*dsa_do_verify)(const unsigned char *dgst, int dgst_len,
                                     DSA_SIG *sig, DSA *dsa);

note: type: verbatim
en:      /* compute rr = a1^p1 * a2^p2 mod m (May be NULL for some
                                              implementations) */
    	int (*dsa_mod_exp)(DSA *dsa, BIGNUM *rr, BIGNUM *a1, BIGNUM *p1,
                                     BIGNUM *a2, BIGNUM *p2, BIGNUM *m,
                                     BN_CTX *ctx, BN_MONT_CTX *in_mont);
fr:      /* calculer rr = a1^p1 * a2^p2 mod m (pourrait être NULL pour
                                               certaines implémentations) */
    	int (*dsa_mod_exp)(DSA *dsa, BIGNUM *rr, BIGNUM *a1, BIGNUM *p1,
                                     BIGNUM *a2, BIGNUM *p2, BIGNUM *m,
                                     BN_CTX *ctx, BN_MONT_CTX *in_mont);

note: type: verbatim
en:      /* compute r = a ^ p mod m (May be NULL for some implementations) */
            int (*bn_mod_exp)(DSA *dsa, 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)(DSA *dsa, BIGNUM *r, BIGNUM *a,
                                     const BIGNUM *p, const BIGNUM *m,
                                     BN_CTX *ctx, BN_MONT_CTX *m_ctx);

note: type: verbatim
en:      /* called at DSA_new */
            int (*init)(DSA *DSA);
fr:      /* appelée à DSA_new */
            int (*init)(DSA *DSA);

note: type: verbatim
en:      /* called at DSA_free */
            int (*finish)(DSA *DSA);
fr:      /* appelée à DSA_free */
            int (*finish)(DSA *DSA);

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

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

note: type: textblock
en: DSA_set_default_method() returns no value.
fr: B<DSA_set_default_method>() ne renvoie rien.

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

note: type: textblock
en: DSA_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<DSA_new_method>() renvoie NULL et positionne un code d'erreur qui peut être récupéré avec L<B<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, DSA_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 DSA functionality using an ENGINE API function, that will override any DSA defaults set using the DSA API (ie.  DSA_set_default_method()). For this reason, the ENGINE API is the recommended way to control default implementations for use in DSA and other cryptographic algorithms.
fr: Depuis la version 0.9.7, les implémentations DSA_METHOD sont regroupées avec d’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 la fonctionnalité DSA utilisant une fonction d’interface de programmation ENGINE, cela remplacera tous les DSA par défaut définis en utilisant l’interface de programmation DSA (c’est-à-dire B<DSA_set_default_method>()). Pour cette raison, l’interface de programmation ENGINE est la façon recommandée de contrôler les implémentations par défaut à utiliser dans les algorithmes cryptographiques DSA et autres.

note: type: textblock
en: L<dsa(3)|dsa(3)>, L<DSA_new(3)|DSA_new(3)>
fr: L<B<dsa>(3)|dsa(3)>, L<B<DSA_new>(3)|DSA_new(3)>

note: type: textblock
en: DSA_set_default_method(), DSA_get_default_method(), DSA_set_method(), DSA_new_method() and DSA_OpenSSL() were added in OpenSSL 0.9.4.
fr: B<DSA_set_default_method>(), B<DSA_get_default_method>(), B<DSA_set_method>(), B<DSA_new_method>() et B<DSA_OpenSSL>() ont été ajoutées dans OpenSSL 0.9.4.

note: type: textblock
en: DSA_set_default_openssl_method() and DSA_get_default_openssl_method() replaced DSA_set_default_method() and DSA_get_default_method() respectively, and DSA_set_method() and DSA_new_method() were altered to use B<ENGINE>s rather than B<DSA_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 DSA API without requiring changing these function prototypes.
fr: B<DSA_set_default_openssl_method>() et B<DSA_get_default_openssl_method>() ont respectivement remplacé B<DSA_set_default_method>() et B<DSA_get_default_method>(), et B<DSA_set_method>() et B<DSA_new_method>() ont été modifiées pour utiliser des B<ENGINE> plutôt que des B<DSA_METHOD> pendant le développement de la version ENGINE d’OpenSSL 0.9.6. Pour 0.9.7, le traitement des valeurs par défaut dans l’interface de programmation ENGINE a été restructuré en revenant sur cette modification, pour que le comportement des autres fonctions ressemble plus au comportement précédent. Le comportement des valeurs par défaut dans l’interface de programmation ENGINE remplace maintenant de façon transparente le comportement des valeurs par défaut dans l’interface de programmation DSA sans modification nécessaire de ces prototypes de fonctions.

note: type: textblock
en: DSA_sign, DSA_sign_setup, DSA_verify - DSA signatures
fr: DSA_sign, DSA_sign_setup, DSA_verify - Signatures DSA

note: type: verbatim
en:  int	DSA_sign(int type, const unsigned char *dgst, int len,
    		unsigned char *sigret, unsigned int *siglen, DSA *dsa);
fr: B< int	DSA_sign(int> I<type>B<, const unsigned char *>I<dgst>B<, int> I<len>B<,>
     		B<unsigned char *>I<sigret>B<, unsigned int *>I<siglen>B<, DSA *>I<dsa>B<);>ZZ

note: type: verbatim
en:  int	DSA_sign_setup(DSA *dsa, BN_CTX *ctx, BIGNUM **kinvp,
                    BIGNUM **rp);
fr: B< int	DSA_sign_setup(DSA *>I<dsa>B<, BN_CTX *>I<ctx>B<, BIGNUM **>I<kinvp>B<,>
                    B<BIGNUM **>I<rp>B<);>

note: type: verbatim
en:  int	DSA_verify(int type, const unsigned char *dgst, int len,
    		unsigned char *sigbuf, int siglen, DSA *dsa);
fr: B< int	DSA_verify(int> I<type>B<, const unsigned char *>I<dgst>B<, int> I<len>B<,>
     		B<unsigned char *>I<sigbuf>B<, int> I<siglen>B<, DSA *>I<dsa>B<);>

note: type: textblock
en: DSA_sign() computes a digital signature on the B<len> byte message digest B<dgst> using the private key B<dsa> and places its ASN.1 DER encoding at B<sigret>. The length of the signature is places in *B<siglen>. B<sigret> must point to DSA_size(B<dsa>) bytes of memory.
fr: B<DSA_sign>() calcule une signature numérique du condensé de message I<dgst> de I<len> octets en utilisant la clef privée I<dsa> et place son encodage DER ASN.1 en I<sigret>. La taille de la signature est placée en B<*>I<siglen>. I<sigret> doit pointer vers B<DSA_size>(I<dsa>) octets de mémoire.

note: type: textblock
en: DSA_sign_setup() may be used to precompute part of the signing operation in case signature generation is time-critical. It expects B<dsa> to contain DSA parameters. It places the precomputed values in newly allocated B<BIGNUM>s at *B<kinvp> and *B<rp>, after freeing the old ones unless *B<kinvp> and *B<rp> are NULL. These values may be passed to DSA_sign() in B<dsa-E<gt>kinv> and B<dsa-E<gt>r>.  B<ctx> is a pre-allocated B<BN_CTX> or NULL.
fr: B<DSA_sign_setup>() pourrait être utilisée pour précalculer une partie de l’opération de signature quand le temps de création de la signature est critique. Elle attend dans I<dsa> les paramètres DSA. Elle place les valeurs précalculées dans les B<BIGNUM> nouvellement alloués en B<*>I<kinvp> et B<*>I<rp>, après la libération des anciens sauf si B<*>I<kinvp> et B<*>I<rp> sont NULL. Ces valeurs pourraient être passées à B<DSA_sign>() dans I<dsa>B<-E<gt>kinv> et I<dsa>B<-E<gt>r>. I<ctx> est un B<BN_CTX> préalloué ou NULL.

note: type: textblock
en: DSA_verify() verifies that the signature B<sigbuf> of size B<siglen> matches a given message digest B<dgst> of size B<len>.  B<dsa> is the signer's public key.
fr: B<DSA_verify>() vérifie que la signature I<sigbuf> de taille I<siglen> correspond à un condensé de message donné I<dgst> de taille I<len>. I<dsa> est la clef publique du signataire.

note: type: textblock
en: The B<type> parameter is ignored.
fr: Le paramètre I<type> est ignoré.

note: type: textblock
en: The PRNG must be seeded before DSA_sign() (or DSA_sign_setup())  is called.
fr: Le générateur de nombres pseudoaléatoires doit être initialisé avant d’appeler B<DSA_sign>() (ou B<DSA_sign_setup>()).

note: type: textblock
en: DSA_sign() and DSA_sign_setup() return 1 on success, 0 on error.  DSA_verify() returns 1 for a valid signature, 0 for an incorrect signature and -1 on error. The error codes can be obtained by L<ERR_get_error(3)|ERR_get_error(3)>.
fr: B<DSA_sign>() et B<DSA_sign_setup>() renvoient B<1> en cas de réussite et B<0> en cas d’erreur.  B<DSA_verify>() renvoie B<1> pour une signature valable, B<0> pour une signature incorrecte ou B<-1> en cas d’erreur. Les codes d’erreur peuvent être obtenus par L<B<ERR_get_error>(3)|ERR_get_error(3)>.

note: type: =head1
en: CONFORMING TO
fr: CONFORMITÉ À

note: type: textblock
en: L<dsa(3)|dsa(3)>, L<ERR_get_error(3)|ERR_get_error(3)>, L<rand(3)|rand(3)>, L<DSA_do_sign(3)|DSA_do_sign(3)>
fr: L<B<dsa>(3)|dsa(3)>, L<B<DSA_do_sign>(3)|DSA_do_sign(3)>, L<B<ERR_get_error>(3)|ERR_get_error(3)>, L<B<rand>(3)|rand(3)>

note: type: textblock
en: DSA_sign() and DSA_verify() are available in all versions of SSLeay.  DSA_sign_setup() was added in SSLeay 0.8.
fr: B<DSA_sign>() et B<DSA_verify>() sont disponibles dans toutes les versions de SSLeay. B<DSA_sign_setup>() a été ajoutée dans SSLeay 0.8.

note: type: textblock
en: DSA_size - get DSA signature size
fr: DSA_size - Obtenir la taille d'une signature DSA

note: type: verbatim
en:  int DSA_size(const DSA *dsa);
fr: B< int DSA_size(const DSA *>I<dsa>B<);>

note: type: textblock
en: This function returns the size of an ASN.1 encoded DSA signature in bytes. It can be used to determine how much memory must be allocated for a DSA signature.
fr: Cette fonction renvoie la taille en octets d'une signature DSA au format ASN.1. Elle peut être utilisée pour déterminer la quantité de mémoire à allouer pour une signature DSA.

note: type: textblock
en: B<dsa-E<gt>q> must not be B<NULL>.
fr: I<dsa>B<-E<gt>q> ne doit pas valoir NULL.

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

note: type: textblock
en: L<dsa(3)|dsa(3)>, L<DSA_sign(3)|DSA_sign(3)>
fr: L<B<dsa>(3)|dsa(3)>, L<B<DSA_sign>(3)|DSA_sign(3)>

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

note: type: textblock
en: dsa - Digital Signature Algorithm
fr: dsa - Algorithme de signature numérique

note: type: verbatim
en:  DSA *	DSA_new(void);
     void	DSA_free(DSA *dsa);
fr: B< DSA *	DSA_new(void);>
     B<void	DSA_free(DSA *>I<dsa>B<);>

note: type: verbatim
en:  int	DSA_size(const DSA *dsa);
fr: B< int	DSA_size(const DSA *>I<dsa>B<);>

note: type: verbatim
en:  DSA *	DSA_generate_parameters(int bits, unsigned char *seed,
                    int seed_len, int *counter_ret, unsigned long *h_ret,
    		void (*callback)(int, int, void *), void *cb_arg);
fr: B< DSA *	DSA_generate_parameters(int> I<bits>B<, unsigned char *>I<seed>B<,>
                    B<int> I<seed_len>B< int *>I<counter_ret>B<, unsigned long *>I<h_ret>B<,>
     		B<void (*>I<callback>B<)(int, int, void *), void *>I<cb_arg>B<);>

note: type: verbatim
en:  DH *	DSA_dup_DH(const DSA *r);
fr: B< DH *	DSA_dup_DH(const DSA *>I<r>B<);>

note: type: verbatim
en:  int	DSA_generate_key(DSA *dsa);
fr: B< int	DSA_generate_key(DSA *>I<dsa>B<);>

note: type: verbatim
en:  int	DSA_sign(int dummy, const unsigned char *dgst, int len,
    		unsigned char *sigret, unsigned int *siglen, DSA *dsa);
     int	DSA_sign_setup(DSA *dsa, BN_CTX *ctx, BIGNUM **kinvp,
                    BIGNUM **rp);
     int	DSA_verify(int dummy, const unsigned char *dgst, int len,
    		const unsigned char *sigbuf, int siglen, DSA *dsa);
fr: B< int	DSA_sign(int> I<dummy>B<, const unsigned char *>I<dgst>B<, int> I<len>B<,>
     		B<unsigned char *>I<sigret>B<, unsigned int *>I<siglen>B<, DSA *>I<dsa>B<);>
     B<int	DSA_sign_setup(DSA *>I<dsa>B<, BN_CTX *>I<ctx>B<, BIGNUM **>I<kinvp>B<,>
     		B<BIGNUM **>I<rp>B<);>
     B<int	DSA_verify(int> I<dummy>B<, const unsigned char *>I<dgst>B<, int> I<len>B<,>
     		B<const unsigned char *>I<sigbuf>B<, int> I<siglen>B<, DSA *>I<dsa>B<);>

note: type: verbatim
en:  void DSA_set_default_method(const DSA_METHOD *meth);
     const DSA_METHOD *DSA_get_default_method(void);
     int DSA_set_method(DSA *dsa, const DSA_METHOD *meth);
     DSA *DSA_new_method(ENGINE *engine);
     const DSA_METHOD *DSA_OpenSSL(void);
fr: B< void DSA_set_default_method(const DSA_METHOD *>I<meth>B<);>
     B<const DSA_METHOD *DSA_get_default_method(void);>
     B<int DSA_set_method(DSA *>I<dsa>B<, const DSA_METHOD *>I<meth>B<);>
     B<DSA *DSA_new_method(ENGINE *>I<engine>B<);>
     B<const DSA_METHOD *DSA_OpenSSL(void);>

note: type: verbatim
en:  int DSA_get_ex_new_index(long argl, char *argp, int (*new_func)(),
    	     int (*dup_func)(), void (*free_func)());
     int DSA_set_ex_data(DSA *d, int idx, char *arg);
     char *DSA_get_ex_data(DSA *d, int idx);
fr: B< int DSA_get_ex_new_index(long> I<argl>B<, char *>I<argp>B<, int (*>I<new_func>B<)(),>
     	     B<int (*>I<dup_func>B<)(), void (*>I<free_func>B<)());>
     B<int DSA_set_ex_data(DSA *>I<d>B<, int> I<idx>B<, char *>I<arg>B<);>
     B<char *DSA_get_ex_data(DSA *>I<d>B<, int> I<idx>B<);>

note: type: verbatim
en:  DSA_SIG *DSA_SIG_new(void);
     void	DSA_SIG_free(DSA_SIG *a);
     int	i2d_DSA_SIG(const DSA_SIG *a, unsigned char **pp);
     DSA_SIG *d2i_DSA_SIG(DSA_SIG **v, unsigned char **pp, long length);
fr: B< DSA_SIG *DSA_SIG_new(void);>
     B<void	DSA_SIG_free(DSA_SIG *>I<a>B<);>
     B<int	i2d_DSA_SIG(const DSA_SIG *>I<a>B<, unsigned char **>I<pp>B<);>
     B<DSA_SIG *d2i_DSA_SIG(DSA_SIG **>I<v>B<, unsigned char **>I<pp>B<, long> I<length>B<);>

note: type: verbatim
en:  DSA_SIG *DSA_do_sign(const unsigned char *dgst, int dlen, DSA *dsa);
     int	DSA_do_verify(const unsigned char *dgst, int dgst_len,
    	     DSA_SIG *sig, DSA *dsa);
fr: B< DSA_SIG *DSA_do_sign(const unsigned char *>I<dgst>B<, int> I<dlen>B<, DSA *>I<dsa>B<);>
     B<int	DSA_do_verify(const unsigned char *>I<dgst>B<, int> I<dgst_len>B<,>
     	     B<DSA_SIG *>I<sig>B<, DSA *>I<dsa>B<);>

note: type: verbatim
en:  DSA *	d2i_DSAPublicKey(DSA **a, unsigned char **pp, long length);
     DSA *	d2i_DSAPrivateKey(DSA **a, unsigned char **pp, long length);
     DSA * 	d2i_DSAparams(DSA **a, unsigned char **pp, long length);
     int	i2d_DSAPublicKey(const DSA *a, unsigned char **pp);
     int 	i2d_DSAPrivateKey(const DSA *a, unsigned char **pp);
     int	i2d_DSAparams(const DSA *a,unsigned char **pp);
fr: B< DSA *	d2i_DSAPublicKey(DSA **>I<a>B<, unsigned char **>I<pp>B<, long> I<length>B<);>
     B<DSA *	d2i_DSAPrivateKey(DSA **>I<a>B<, unsigned char **>I<pp>B<, long> I<length>B<);>
     B<DSA * 	d2i_DSAparams(DSA **>I<a>B<, unsigned char **>I<pp>B<, long> I<length>B<);>
     B<int	i2d_DSAPublicKey(const DSA *>I<a>B<, unsigned char **>I<pp>B<);>
     B<int 	i2d_DSAPrivateKey(const DSA *>I<a>B<, unsigned char **>I<pp>B<);>
     B<int	i2d_DSAparams(const DSA *>I<a>B<,unsigned char **>I<pp>B<);>

note: type: verbatim
en:  int	DSAparams_print(BIO *bp, const DSA *x);
     int	DSAparams_print_fp(FILE *fp, const DSA *x);
     int	DSA_print(BIO *bp, const DSA *x, int off);
     int	DSA_print_fp(FILE *bp, const DSA *x, int off);
fr: B< int	DSAparams_print(BIO *>I<bp>B<, const DSA *>I<x>B<);>
     B<int	DSAparams_print_fp(FILE *>I<fp>B<, const DSA *>I<x>B<);>
     B<int	DSA_print(BIO *>I<bp>B<, const DSA *>I<x>B<, int> I<off>B<);>
     B<int	DSA_print_fp(FILE *>I<bp>B<, const DSA *>I<x>B<, int> I<off>B<);>

note: type: textblock
en: These functions implement the Digital Signature Algorithm (DSA).  The generation of shared DSA parameters is described in L<DSA_generate_parameters(3)|DSA_generate_parameters(3)>; L<DSA_generate_key(3)|DSA_generate_key(3)> describes how to generate a signature key. Signature generation and verification are described in L<DSA_sign(3)|DSA_sign(3)>.
fr: Ces fonctions implémentent l’algorithme de signature numérique (DSA). La création de paramètres DSA partagés est décrite dans L<B<DSA_generate_parameters>(3)|DSA_generate_parameters(3)> ; L<B<DSA_generate_key>(3)|DSA_generate_key(3)> décrit la façon de créer une signature de clef. La création et la vérification de signature sont décrites dans L<B<DSA_sign>(3)|DSA_sign(3)>.

note: type: textblock
en: The B<DSA> structure consists of several BIGNUM components.
fr: La structure B<DSA> est constituée de plusieurs composants BIGNUM.

note: type: verbatim
en:  struct
            {
            BIGNUM *p;		// prime number (public)
            BIGNUM *q;		// 160-bit subprime, q | p-1 (public)
            BIGNUM *g;		// generator of subgroup (public)
            BIGNUM *priv_key;	// private key x
            BIGNUM *pub_key;	// public key y = g^x
            // ...
            }
     DSA;
fr:  struct
            {
            BIGNUM *p;		// nombre premier (public)
            BIGNUM *q;		// sous-premier (p-1) 160 bits,
                      		// q | p-1 (public)
            BIGNUM *g;		// générateur de sous-groupe (public)
            BIGNUM *priv_key;	// clef privée x
            BIGNUM *pub_key;	// clef privée y = g^x
            // ...
            }
     DSA;

note: type: textblock
en: In public keys, B<priv_key> is NULL.
fr: Dans les clefs publiques, I<priv_key> est NULL.

note: type: textblock
en: Note that DSA keys may use non-standard B<DSA_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 DSA structure elements directly and instead use API functions to query or modify keys.
fr: Remarquez que les clefs DSA pourraient utiliser des implémentations de B<DSA_METHOD> non standards, soit directement, soit en utilisant des modules B<ENGINE>. Dans certains cas (par exemple un ENGINE prenant en charge les clefs protégées matériellement), ces valeurs de BIGNUM ne seront pas utilisées par l’implémentation ou pourraient être utilisées pour le stockage de données alternatives. Pour cette raison, les applications devraient normalement éviter d’utiliser directement des éléments de structure DSA et utiliser à la place les fonctions d’interface de programmation pour demander ou modifier des clefs.

note: type: textblock
en: L<bn(3)|bn(3)>, L<dh(3)|dh(3)>, L<err(3)|err(3)>, L<rand(3)|rand(3)>, L<rsa(3)|rsa(3)>, L<sha(3)|sha(3)>, L<engine(3)|engine(3)>, L<DSA_new(3)|DSA_new(3)>, L<DSA_size(3)|DSA_size(3)>, L<DSA_generate_parameters(3)|DSA_generate_parameters(3)>, L<DSA_dup_DH(3)|DSA_dup_DH(3)>, L<DSA_generate_key(3)|DSA_generate_key(3)>, L<DSA_sign(3)|DSA_sign(3)>, L<DSA_set_method(3)|DSA_set_method(3)>, L<DSA_get_ex_new_index(3)|DSA_get_ex_new_index(3)>, L<RSA_print(3)|RSA_print(3)>
fr: L<B<bn>(3)|bn(3)>, L<B<dh>(3)|dh(3)>, L<B<engine>(3)|engine(3)>, L<B<err>(3)|err(3)>, L<B<rand>(3)|rand(3)>, L<B<rsa>(3)|rsa(3)>, L<B<sha>(3)|sha(3)>, L<B<DSA_new>(3)|DSA_new(3)>, L<B<DSA_size>(3)|DSA_size(3)>, L<B<DSA_generate_parameters>(3)|DSA_generate_parameters(3)>, L<B<DSA_dup_DH>(3)|DSA_dup_DH(3)>, L<B<DSA_generate_key>(3)|DSA_generate_key(3)>, L<B<DSA_sign>(3)|DSA_sign(3)>, L<B<DSA_set_method>(3)|DSA_set_method(3)>, L<B<DSA_get_ex_new_index>(3)|DSA_get_ex_new_index(3)>, L<B<RSA_print>(3)|RSA_print(3)>

note: type: textblock
en: ECDSA_SIG_new, ECDSA_SIG_free, i2d_ECDSA_SIG, d2i_ECDSA_SIG, ECDSA_size, ECDSA_sign_setup, ECDSA_sign, ECDSA_sign_ex, ECDSA_verify, ECDSA_do_sign, ECDSA_do_sign_ex, ECDSA_do_verify - Elliptic Curve Digital Signature Algorithm
fr: ECDSA_SIG_new, ECDSA_SIG_free, i2d_ECDSA_SIG, d2i_ECDSA_SIG, ECDSA_size, ECDSA_sign_setup, ECDSA_sign, ECDSA_sign_ex, ECDSA_verify, ECDSA_do_sign, ECDSA_do_sign_ex, ECDSA_do_verify - Algorithme de signature numérique utilisant les courbes elliptiques

note: type: verbatim
en:  #include <openssl/ecdsa.h>
fr: B< #include E<lt>openssl/ecdsa.hE<gt>>

note: type: verbatim
en:  ECDSA_SIG*	ECDSA_SIG_new(void);
     void		ECDSA_SIG_free(ECDSA_SIG *sig);
     int		i2d_ECDSA_SIG(const ECDSA_SIG *sig, unsigned char **pp);
     ECDSA_SIG*	d2i_ECDSA_SIG(ECDSA_SIG **sig, const unsigned char **pp, 
    		long len);
fr: B< ECDSA_SIG*	ECDSA_SIG_new(void);>
     B<void		ECDSA_SIG_free(ECDSA_SIG *>I<sig>B<);>
     B<int		i2d_ECDSA_SIG(const ECDSA_SIG *>I<sig>B<, unsigned char **>I<pp>B<);>
     B<ECDSA_SIG*	d2i_ECDSA_SIG(ECDSA_SIG **>I<sig>B<, const unsigned char **>I<pp>B<,>
     		B<long> I<len>B<);>

note: type: verbatim
en:  ECDSA_SIG*	ECDSA_do_sign(const unsigned char *dgst, int dgst_len,
    			EC_KEY *eckey);
     ECDSA_SIG*	ECDSA_do_sign_ex(const unsigned char *dgst, int dgstlen, 
    			const BIGNUM *kinv, const BIGNUM *rp,
    			EC_KEY *eckey);
     int		ECDSA_do_verify(const unsigned char *dgst, int dgst_len,
    			const ECDSA_SIG *sig, EC_KEY* eckey);
     int		ECDSA_sign_setup(EC_KEY *eckey, BN_CTX *ctx,
    			BIGNUM **kinv, BIGNUM **rp);
     int		ECDSA_sign(int type, const unsigned char *dgst,
    			int dgstlen, unsigned char *sig,
    			unsigned int *siglen, EC_KEY *eckey);
     int		ECDSA_sign_ex(int type, const unsigned char *dgst,
    			int dgstlen, unsigned char *sig,
    			unsigned int *siglen, const BIGNUM *kinv, 
    			const BIGNUM *rp, EC_KEY *eckey);
     int		ECDSA_verify(int type, const unsigned char *dgst,
    			int dgstlen, const unsigned char *sig,
    			int siglen, EC_KEY *eckey);
     int		ECDSA_size(const EC_KEY *eckey);
fr: B< ECDSA_SIG*	ECDSA_do_sign(const unsigned char *>I<dgst>B<, int> I<dgst_len>B<,>
     			B<EC_KEY *>I<eckey>B<);>
     B<ECDSA_SIG*	ECDSA_do_sign_ex(const unsigned char *>I<dgst>B<, int> I<dgstlen>B<,>
     			B<const BIGNUM *>I<kinv>B<, const BIGNUM *>I<rp>B<,>
     			B<EC_KEY *>I<eckey>B<);>
     B<int		ECDSA_do_verify(const unsigned char *>I<dgst>B<, int> I<dgst_len>B<,>
     			B<const ECDSA_SIG *>I<sig>B<, EC_KEY *>I<eckey>B<);>
     B<int		ECDSA_sign_setup(EC_KEY *>I<eckey>B<, BN_CTX *>I<ctx>B<,>
     			B<BIGNUM **>I<kinv>B<, BIGNUM **>I<rp>B<);>
     B<int		ECDSA_sign(int> I<type>B<, const unsigned char *>I<dgst>B<,>
     			B<int> I<dgstlen>B<, unsigned char *>I<sig>B<,>
     			B<unsigned> I<int *>I<siglen>B<, EC_KEY *>I<eckey>B<);>
     B<int		ECDSA_sign_ex(int> I<type>B<, const unsigned char *>I<dgst>B<,>
     			B<int> I<dgstlen>B<, unsigned char *>I<sig>B<,>
     			B<unsigned int *>I<siglen>B<, const BIGNUM *>I<kinv>B<,>
     			B<const BIGNUM *>I<rp>B<, EC_KEY *>I<eckey>B<);>
     B<int		ECDSA_verify(int> I<type>B<, const unsigned char *>I<dgst>B<,>
     			B<int> I<dgstlen>B<, const unsigned char *>I<sig>B<,>
     			B<int> I<siglen>B<, EC_KEY *>I<eckey>B<);>
     B<int		ECDSA_size(const EC_KEY *>I<eckey>B<);>

note: type: verbatim
en:  const ECDSA_METHOD*	ECDSA_OpenSSL(void);
     void		ECDSA_set_default_method(const ECDSA_METHOD *meth);
     const ECDSA_METHOD*	ECDSA_get_default_method(void);
     int		ECDSA_set_method(EC_KEY *eckey,const ECDSA_METHOD *meth);
fr: B< const ECDSA_METHOD*	ECDSA_OpenSSL(void);>
     B<void		ECDSA_set_default_method(const ECDSA_METHOD *>I<meth>B<);>
     B<const ECDSA_METHOD*	ECDSA_get_default_method(void);>
     B<int		ECDSA_set_method(EC_KEY *>I<eckey>B<,const ECDSA_METHOD *>I<meth>B<);>

note: type: verbatim
en:  int		ECDSA_get_ex_new_index(long argl, void *argp,
    			CRYPTO_EX_new *new_func,
    			CRYPTO_EX_dup *dup_func,
    			CRYPTO_EX_free *free_func);
     int		ECDSA_set_ex_data(EC_KEY *d, int idx, void *arg);
     void*		ECDSA_get_ex_data(EC_KEY *d, int idx);
fr: B< int		ECDSA_get_ex_new_index(long argl, void *>I<argp>B<,>
     			B<CRYPTO_EX_new *>I<new_func>B<,>
     			B<CRYPTO_EX_dup *>I<dup_func>B<,>
     			B<CRYPTO_EX_free *>I<free_func>B<);>
     B<int		ECDSA_set_ex_data(EC_KEY *>I<d>B<, int> I<idx>B<, void *>I<arg>B<);>
     B<void*		ECDSA_get_ex_data(EC_KEY *>I<d>B<, int> I<idx>B<);>

note: type: textblock
en: The B<ECDSA_SIG> structure consists of two BIGNUMs for the r and s value of a ECDSA signature (see X9.62 or FIPS 186-2).
fr: La structure B<ECDSA_SIG> est constituée de deux BIGNUM pour les valeurs I<r> et I<s> d’une signature ECDSA (consultez X9.62 ou FIPS 186-2).

note: type: textblock
en: ECDSA_SIG_new() allocates a new B<ECDSA_SIG> structure (note: this function also allocates the BIGNUMs) and initialize it.
fr: B<ECDSA_SIG_new>() alloue une nouvelle structure B<ECDSA_SIG> (remarque : cette fonction alloue aussi les BIGNUM) et l’initialise.

note: type: textblock
en: ECDSA_SIG_free() frees the B<ECDSA_SIG> structure B<sig>.
fr: B<ECDSA_SIG_free>() libère la structure B<ECDSA_SIG> I<sig>.

note: type: textblock
en: i2d_ECDSA_SIG() creates the DER encoding of the ECDSA signature B<sig> and writes the encoded signature to B<*pp> (note: if B<pp> is NULL B<i2d_ECDSA_SIG> returns the expected length in bytes of the DER encoded signature). B<i2d_ECDSA_SIG> returns the length of the DER encoded signature (or 0 on error).
fr: B<i2d_ECDSA_SIG>() crée l’encodage DER de la signature ECDSA I<sig> et écrit la signature encodée dans B<*>I<pp> (remarque : si I<pp> est NULL, B<i2d_ECDSA_SIG> renvoie la taille attendue en octet de la signature encodée DER (ou B<0> en cas d’erreur).

note: type: textblock
en: d2i_ECDSA_SIG() decodes a DER encoded ECDSA signature and returns the decoded signature in a newly allocated B<ECDSA_SIG> structure.  B<*sig> points to the buffer containing the DER encoded signature of size B<len>.
fr: B<d2i_ECDSA_SIG>() décode une signature ECDSA encodée DER et renvoie la signature décodée dans une structure B<ECDSA_SIG> nouvellement allouée. B<*>I<sig> pointe vers le tampon contenant la signature encodée DER de taille I<len>.

note: type: textblock
en: ECDSA_size() returns the maximum length of a DER encoded ECDSA signature created with the private EC key B<eckey>.
fr: B<ECDSA_size>() renvoie la taille maximale d’une signature ECDSA encodée DER créée avec la clef privée I<eckey>.

note: type: textblock
en: ECDSA_sign_setup() may be used to precompute parts of the signing operation. B<eckey> is the private EC key and B<ctx> is a pointer to B<BN_CTX> structure (or NULL). The precomputed values or returned in B<kinv> and B<rp> and can be used in a later call to B<ECDSA_sign_ex> or B<ECDSA_do_sign_ex>.
fr: B<ECDSA_sign_setup>() pourrait être utilisée pour précalculer des parties de l’opération de signature. I<eckey> est la clef privée EC et I<ctx> est un pointeur vers la structure I<BN_CTX> (ou NULL). Les valeurs précalculées ou renvoyées dans I<kinv> et I<rp> peuvent être utilisées dans un appel suivant de B<ECDSA_sign_ex> ou B<ECDSA_do_sign_ex>.

note: type: textblock
en: ECDSA_sign() is wrapper function for ECDSA_sign_ex with B<kinv> and B<rp> set to NULL.
fr: B<ECDSA_sign>() est une fonction enveloppe pour B<ECDSA_sign_ex> avec I<kinv> et I<rp> définies à NULL.

note: type: textblock
en: ECDSA_sign_ex() computes a digital signature of the B<dgstlen> bytes hash value B<dgst> using the private EC key B<eckey> and the optional pre-computed values B<kinv> and B<rp>. The DER encoded signatures is stored in B<sig> and it's length is returned in B<sig_len>. Note: B<sig> must point to B<ECDSA_size> bytes of memory. The parameter B<type> is ignored.
fr: B<ECDSA_sign_ex>() calcule une signature numérique de la valeur de hachage I<dgst>, de I<dgstlen> octets, en utilisant la clef privée EC I<eckey> et les valeurs précalculées facultatives I<kinv> et I<rp>. La signature encodée DER est stockée dans I<sig> et sa taille est renvoyée dans I<sig_len>. Remarque : I<sig> doit pointer vers B<ECDSA_size> octets de mémoire. Le paramètre I<type> est ignoré.

note: type: textblock
en: ECDSA_verify() verifies that the signature in B<sig> of size B<siglen> is a valid ECDSA signature of the hash value B<dgst> of size B<dgstlen> using the public key B<eckey>.  The parameter B<type> is ignored.
fr: B<ECDSA_verify>() vérifie que la signature dans I<sig> de taille I<siglen> est une signature ECDSA valable de la valeur de hachage I<dgst> de taille I<dgstlen> en utilisant la clef publique I<eckey>. Le paramètre I<type> est ignoré.

note: type: textblock
en: ECDSA_do_sign() is wrapper function for ECDSA_do_sign_ex with B<kinv> and B<rp> set to NULL.
fr: B<ECDSA_do_sign>() est une fonction enveloppe pour B<ECDSA_do_sign_ex> avec I<kinv> et I<rp> définies à NULL.

note: type: textblock
en: ECDSA_do_sign_ex() computes a digital signature of the B<dgst_len> bytes hash value B<dgst> using the private key B<eckey> and the optional pre-computed values B<kinv> and B<rp>. The signature is returned in a newly allocated B<ECDSA_SIG> structure (or NULL on error).
fr: B<ECDSA_do_sign_ex>() calcule une signature numérique de la valeur de hachage I<dgst>, de I<dgstlen> octets, en utilisant la clef privée I<eckey> et les valeurs précalculées facultatives I<kinv> et I<rp>. La signature est renvoyée dans une structure B<ECDSA_SIG> nouvellement allouée (ou NULL en cas d’erreur).

note: type: textblock
en: ECDSA_do_verify() verifies that the signature B<sig> is a valid ECDSA signature of the hash value B<dgst> of size B<dgst_len> using the public key B<eckey>.
fr: B<ECDSA_do_verify>() vérifie que la signature I<sig> est une signature ECDSA valable de la valeur de hachage I<dgst> de taille I<dgst_len> en utilisant la clef publique I<eckey>.

note: type: textblock
en: ECDSA_size() returns the maximum length signature or 0 on error.
fr: B<ECDSA_size>() renvoie la taille maximale de signature ou B<0> en cas d’erreur.

note: type: textblock
en: ECDSA_sign_setup() and ECDSA_sign() return 1 if successful or 0 on error.
fr: B<ECDSA_sign_setup>() et B<ECDSA_sign>() renvoient B<1> en cas de réussite ou B<0> en cas d’erreur.

note: type: textblock
en: ECDSA_verify() and ECDSA_do_verify() return 1 for a valid signature, 0 for an invalid signature and -1 on error.  The error codes can be obtained by L<ERR_get_error(3)|ERR_get_error(3)>.
fr: B<ECDSA_verify>() et B<ECDSA_do_verify>() renvoient B<1> pour une signature valable, B<0> pour une signature incorrecte ou B<-1> en cas d’erreur. Les codes d’erreur peuvent être obtenus par L<B<ERR_get_error>(3)|ERR_get_error(3)>.

note: type: textblock
en: Creating a ECDSA signature of given SHA-1 hash value using the named curve secp192k1.
fr: Création d’une signature ECDSA d’une valeur de hachage SHA-1 donnée en utilisant la courbe secp192k1 donnée.

note: type: textblock
en: First step: create a EC_KEY object (note: this part is B<not> ECDSA specific)
fr: Première étape : créer un objet EC_KEY (remarque : cette partie n’est B<pas> spécifique à ECDSA)

note: type: verbatim
en:  int        ret;
     ECDSA_SIG *sig;
     EC_KEY    *eckey;
     eckey = EC_KEY_new_by_curve_name(NID_secp192k1);
     if (eckey == NULL)
    	{
    	/* error */
    	}
     if (!EC_KEY_generate_key(eckey))
    	{
    	/* error */
    	}
fr:  int        ret;
     ECDSA_SIG *sig;
     EC_KEY    *eckey;
     eckey = EC_KEY_new_by_curve_name(NID_secp192k1);
     if (eckey == NULL)
    	{
    	/* erreur */
    	}
     if (!EC_KEY_generate_key(eckey))
    	{
    	/* erreur */
    	}

note: type: textblock
en: Second step: compute the ECDSA signature of a SHA-1 hash value using B<ECDSA_do_sign>
fr: Deuxième étape : calculer la signature ECDSA d’une valeur de hachage SHA-1 en utilisant B<ECDSA_do_sign>

note: type: verbatim
en:  sig = ECDSA_do_sign(digest, 20, eckey);
     if (sig == NULL)
    	{
    	/* error */
    	}
fr:  sig = ECDSA_do_sign(digest, 20, eckey);
     if (sig == NULL)
    	{
    	/* erreur */
    	}

note: type: textblock
en: or using B<ECDSA_sign>
fr: ou en utilisant B<ECDSA_sign>

note: type: verbatim
en:  unsigned char *buffer, *pp;
     int            buf_len;
     buf_len = ECDSA_size(eckey);
     buffer  = OPENSSL_malloc(buf_len);
     pp = buffer;
     if (!ECDSA_sign(0, dgst, dgstlen, pp, &buf_len, eckey);
    	{
    	/* error */
    	}
fr:  unsigned char *buffer, *pp;
     int            buf_len;
     buf_len = ECDSA_size(eckey);
     buffer  = OPENSSL_malloc(buf_len);
     pp = buffer;
     if (!ECDSA_sign(0, dgst, dgstlen, pp, &buf_len, eckey);
    	{
    	/* erreur */
    	}

note: type: textblock
en: Third step: verify the created ECDSA signature using B<ECDSA_do_verify>
fr: Troisième étape : vérifier la signature ECDSA créée en utilisant B<ECDSA_do_verify>

note: type: textblock
en: or using B<ECDSA_verify>
fr: ou en utilisant B<ECDSA_verify>

note: type: textblock
en: and finally evaluate the return value:
fr: et enfin évaluer la valeur de retour :

note: type: verbatim
en:  if (ret == -1)
    	{
    	/* error */
    	}
     else if (ret == 0)
    	{
    	/* incorrect signature */
    	}
     else	/* ret == 1 */
    	{
    	/* signature ok */
    	}
fr:  if (ret == -1)
    	{
    	/* erreur */
    	}
     else if (ret == 0)
    	{
    	/* signature incorrecte */
    	}
     else	/* ret == 1 */
    	{
    	/* signature correcte*/
    	}

note: type: textblock
en: L<dsa(3)|dsa(3)>, L<rsa(3)|rsa(3)>
fr: L<B<dsa>(3)|dsa(3)>, L<B<rsa>(3)|rsa(3)>

note: type: textblock
en: The ecdsa implementation was first introduced in OpenSSL 0.9.8
fr: L’implémentation ecdsa a été introduite pour la première fois 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).
