openssl - en to fr translation catalogue (368 entries)

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

note: type: textblock
en: genpkey - generate a private key
fr: genpkey - Générer une clef privée

note: type: textblock
en: B<openssl> B<genpkey> [B<-out filename>] [B<-outform PEM|DER>] [B<-pass arg>] [B<-cipher>] [B<-engine id>] [B<-paramfile file>] [B<-algorithm alg>] [B<-pkeyopt opt:value>] [B<-genparam>] [B<-text>]
fr: B<openssl> B<genpkey> [B<-out> I<fichier>] [B<-outform PEM>|B<DER>] [B<-pass> I<param>] [B<-cipher>] [B<-engine> I<identifiant>] [B<-paramfile> I<fichier>] [B<-algorithm> I<algorithme>] [B<-pkeyopt> I<opt>B<:>I<valeur>] [B<-genparam>] [B<-text>]

note: type: textblock
en: The B<genpkey> command generates a private key.
fr: La commande B<genpkey> génère une clef privée.

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

note: type: textblock
en: the output filename. If this argument is not specified then standard output is used.
fr: Le fichier de sortie. S'il n'est pas indiqué, la sortie standard est utilisée.

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

note: type: textblock
en: This specifies the output format DER or PEM.
fr: Cela indique le format de sortie DER ou PEM.

note: type: =item
en: B<-pass arg>
fr: B<-pass> 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: textblock
en: This option encrypts the private key with the supplied cipher. Any algorithm name accepted by EVP_get_cipherbyname() is acceptable such as B<des3>.
fr: Cette option indique de chiffrer la clef privée avec l’algorithme fourni. N’importe quel nom d’algorithme accepté par B<EVP_get_cipherbyname>() est acceptable, comme par exemple B<des3>.

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

note: type: textblock
en: specifying an engine (by its unique B<id> string) will cause B<genpkey> 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. If used this option should precede all other options.
fr: L’indication d’un moteur (en utilisant son identifiant unique I<identifiant>) forcera B<genpkey> à 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. Si elle est utilisée, cette option devrait être indiquée avant toutes les autres options.

note: type: =item
en: B<-algorithm alg>
fr: B<-algorithm> I<algorithme>

note: type: textblock
en: public key algorithm to use such as RSA, DSA or DH. If used this option must precede any B<-pkeyopt> options. The options B<-paramfile> and B<-algorithm> are mutually exclusive.
fr: L’algorithme à clef publique à utiliser, comme par exemple RSA, DSA ou DH. Si utilisée, cette option doit être indiquée avant toutes les options B<-pkeyopt>. Les options B<-paramfile> et B<-algorithm> s’excluent mutuellement.

note: type: =item
en: B<-pkeyopt opt:value>
fr: B<-pkeyopt> I<opt>B<:>I<valeur>

note: type: textblock
en: set the public key algorithm option B<opt> to B<value>. The precise set of options supported depends on the public key algorithm used and its implementation. See B<KEY GENERATION OPTIONS> below for more details.
fr: Définir l’option d’algorithme à clef publique I<opt> à I<valeur>. L’ensemble exact d’options prises en charge dépend de l’algorithme à clef publique utilisé et de son implémentation. Consultez la section B<OPTIONS DE GÉNÉRATION DE CLEF> ci-dessous pour plus de précisions.

note: type: textblock
en: generate a set of parameters instead of a private key. If used this option must precede and B<-algorithm>, B<-paramfile> or B<-pkeyopt> options.
fr: Générer un ensemble de paramètres au lieu d’une clef privée. Si utilisée, cette option doit être indiquée avant les options B<-algorithm>, B<-paramfile> et B<-pkeyopt>.

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

note: type: textblock
en: Some public key algorithms generate a private key based on a set of parameters.  They can be supplied using this option. If this option is used the public key algorithm used is determined by the parameters. If used this option must precede and B<-pkeyopt> options. The options B<-paramfile> and B<-algorithm> are mutually exclusive.
fr: Certains algorithmes à clef publique génèrent une clef publique à partir d’un ensemble de paramètres. Ils peuvent être fournis en utilisant cette option. Si cette option est utilisée, l’algorithme à clef publique utilisé est déterminé par les paramètres. Si utilisée, cette option doit être indiquée avant les options B<-pkeyopt>. Les options B<-paramfile> et B<-algorithm> s’excluent mutuellement.

note: type: textblock
en: Print an (unencrypted) text representation of private and public keys and parameters along with the PEM or DER structure.
fr: Afficher une représentation au format texte (en clair) des clefs privée et publique et des paramètres avec la structure PEM ou DER.

note: type: =head1
en: KEY GENERATION OPTIONS
fr: OPTIONS DE GÉNÉRATION DE CLEF

note: type: textblock
en: The options supported by each algorith and indeed each implementation of an algorithm can vary. The options for the OpenSSL implementations are detailed below.
fr: Les options prises en charge par un algorithme et même par chaque implémentation d’un algorithme peuvent varier. Les options pour les implémentations d’OpenSSL sont précisées ci-dessous.

note: type: =head1
en: RSA KEY GENERATION OPTIONS
fr: OPTIONS DE GÉNÉRATION DE CLEF RSA

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

note: type: textblock
en: The number of bits in the generated key. If not specified 1024 is used.
fr: Le nombre de bits dans la clef générée. Sans indication, 1024 est utilisé.

note: type: =item
en: B<rsa_keygen_pubexp:value>
fr: B<rsa_keygen_pubexp:>I<valeur>

note: type: textblock
en: The RSA public exponent value. This can be a large decimal or hexadecimal value if preceded by B<0x>. Default value is 65537.
fr: La valeur d’exposant public RSA. Cela peut être une grande valeur décimale ou hexadécimale si précédée de B<0x>. La valeur par défaut est 65537.

note: type: =head1
en: DSA PARAMETER GENERATION OPTIONS
fr: OPTIONS DE GÉNÉRATION DE PARAMÈTRES DSA

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

note: type: textblock
en: The number of bits in the generated parameters. If not specified 1024 is used.
fr: Le nombre de bits dans les paramètres générés. Sans indication, 1024 est utilisé.

note: type: =head1
en: DH PARAMETER GENERATION OPTIONS
fr: OPTIONS DE GÉNÉRATION DE PARAMÈTRES DH

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

note: type: textblock
en: The number of bits in the prime parameter B<p>.
fr: Le nombre de bits dans le paramètre I<p> de nombre premier.

note: type: =item
en: B<dh_paramgen_generator:value>
fr: B<dh_paramgen_generator:>I<valeur>

note: type: textblock
en: The value to use for the generator B<g>.
fr: La valeur à utiliser pour le générateur I<g>.

note: type: =item
en: B<dh_rfc5114:num>
fr: B<dh_rfc5114:>I<num>

note: type: textblock
en: If this option is set then the appropriate RFC5114 parameters are used instead of generating new parameters. The value B<num> can take the values 1, 2 or 3 corresponding to RFC5114 DH parameters consisting of 1024 bit group with 160 bit subgroup, 2048 bit group with 224 bit subgroup and 2048 bit group with 256 bit subgroup as mentioned in RFC5114 sections 2.1, 2.2 and 2.3 respectively.
fr: Si cette option est définie, les paramètres RFC 5114 adéquats sont utilisés au lieu d’en créer de nouveaux. La valeur I<num> peut prendre la valeur B<1>, B<2> ou B<3> correspondant aux paramètres DH RFC 5114 constitués d’un groupe de 1024 bits avec un sous-groupe de 160 bits, d’un groupe de 2048 bits avec un sous-groupe de 224 bits ou d’un groupe de 2048 bits avec un sous-groupe de 256 bits conformément aux sections 2.1, 2.2 et 2.3 de la RFC 5114.

note: type: =head1
en: EC PARAMETER GENERATION OPTIONS
fr: OPTIONS DE GÉNÉRATION DE PARAMÈTRES EC

note: type: =item
en: B<ec_paramgen_curve:curve>
fr: B<ec_paramgen_curve:>I<courbe>

note: type: textblock
en: the EC curve to use.
fr: La courbe EC à utiliser.

note: type: =head1
en: GOST2001 KEY GENERATION AND PARAMETER OPTIONS
fr: OPTIONS DE GÉNÉRATION DE CLEF GOST2001 ET DE PARAMÈTRES

note: type: textblock
en: Gost 2001 support is not enabled by default. To enable this algorithm, one should load the ccgost engine in the OpenSSL configuration file.  See README.gost file in the engines/ccgost directiry of the source distribution for more details.
fr: La prise en charge de Gost 2001 n’est pas activée par défaut. Pour activer cet algorithme, le moteur ccgost devrait être chargé dans le fichier de configuration d’OpenSSL. Consultez README.gost dans le répertoire engines/ccgost de la distribution des sources pour plus de précisions.

note: type: textblock
en: Use of a parameter file for the GOST R 34.10 algorithm is optional.  Parameters can be specified during key generation directly as well as during generation of parameter file.
fr: Utiliser un fichier de paramètres pour l’algorithme GOST R 34.10 est facultatif. Les paramètres peuvent être indiqués directement lors de la génération de clef ainsi que pendant la génération du fichier de paramètres.

note: type: =item
en: B<paramset:name>
fr: B<paramset:>I<nom>

note: type: textblock
en: Specifies GOST R 34.10-2001 parameter set according to RFC 4357.  Parameter set can be specified using abbreviated name, object short name or numeric OID. Following parameter sets are supported:
fr: Indiquer l’ensemble de paramètres GOST R 34.10-2001 d’après la RFC 4357. L’ensemble de paramètres peut être indiqué à l’aide de nom abrégé, nom court d’objet ou OID numérique. Les ensembles de paramètres suivants sont pris en charge :

note: type: verbatim
en:   paramset   OID               Usage
      A          1.2.643.2.2.35.1  Signature
      B          1.2.643.2.2.35.2  Signature
      C          1.2.643.2.2.35.3  Signature
      XA         1.2.643.2.2.36.0  Key exchange
      XB         1.2.643.2.2.36.1  Key exchange
      test       1.2.643.2.2.35.0  Test purposes
fr:   ensemble   OID               Utilisation
      A          1.2.643.2.2.35.1  Signature
      B          1.2.643.2.2.35.2  Signature
      C          1.2.643.2.2.35.3  Signature
      XA         1.2.643.2.2.36.0  Échange de clef
      XB         1.2.643.2.2.36.1  Échange de clef
      test       1.2.643.2.2.35.0  Test

note: type: textblock
en: The use of the genpkey program is encouraged over the algorithm specific utilities because additional algorithm options and ENGINE provided algorithms can be used.
fr: L’utilisation du programme genpkey est préférable aux utilitaires spécifiques à l’algorithme car des options d’algorithme supplémentaires et des algorithmes fournis par ENGINE peuvent être utilisés.

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

note: type: textblock
en: Generate an RSA private key using default parameters:
fr: Générer une clef privée RSA en utilisant les paramètres par défaut :

note: type: verbatim
en:  openssl genpkey -algorithm RSA -out key.pem
fr:  openssl genpkey -algorithm RSA -out clef.pem

note: type: textblock
en: Encrypt output private key using 128 bit AES and the passphrase "hello":
fr: Chiffrer une clef privée en utilisant un AES 128 bits et la phrase secrète « salut » :

note: type: verbatim
en:  openssl genpkey -algorithm RSA -out key.pem -aes-128-cbc -pass pass:hello
fr:  openssl genpkey -algorithm RSA -out clef.pem -aes-128-cbc \
     				-pass pass:salut

note: type: textblock
en: Generate a 2048 bit RSA key using 3 as the public exponent:
fr: Créer une clef RSA de 2048 bits en utilisant 3 comme exposant public :

note: type: verbatim
en:  openssl genpkey -algorithm RSA -out key.pem -pkeyopt rsa_keygen_bits:2048 \
     						-pkeyopt rsa_keygen_pubexp:3
fr:  openssl genpkey -algorithm RSA -out clef.pem \
     				-pkeyopt rsa_keygen_bits:2048 \
     				-pkeyopt rsa_keygen_pubexp:3

note: type: textblock
en: Generate 1024 bit DSA parameters:
fr: Générer des paramètres DSA de 1024 bits :

note: type: verbatim
en:  openssl genpkey -genparam -algorithm DSA -out dsap.pem \
    						-pkeyopt dsa_paramgen_bits:1024
fr:  openssl genpkey -genparam -algorithm DSA -out pdsa.pem \
    			   -pkeyopt dsa_paramgen_bits:1024

note: type: textblock
en: Generate DSA key from parameters:
fr: Créer une clef DSA à partir de paramètres :

note: type: verbatim
en:  openssl genpkey -paramfile dsap.pem -out dsakey.pem
fr:  openssl genpkey -paramfile pdsa.pem -out clefdsa.pem

note: type: textblock
en: Generate 1024 bit DH parameters:
fr: Générer des paramètres DH de 1024 bits :

note: type: verbatim
en:  openssl genpkey -genparam -algorithm DH -out dhp.pem \
    					-pkeyopt dh_paramgen_prime_len:1024
fr:  openssl genpkey -genparam -algorithm DH -out pdh.pem \
    			   -pkeyopt dh_paramgen_prime_len:1024

note: type: textblock
en: Output RFC5114 2048 bit DH parameters with 224 bit subgroup:
fr: Afficher les paramètres DH RFC 5114 sur 2048 bits avec un sous-groupe de 224 bits :

note: type: verbatim
en:  openssl genpkey -genparam -algorithm DH -out dhp.pem -pkeyopt dh_rfc5114:2
fr:  openssl genpkey -genparam -algorithm DH -out pdh.pem \
    			   -pkeyopt dh_rfc5114:2

note: type: textblock
en: Generate DH key from parameters:
fr: Créer une clef DH à partir de paramètres :

note: type: verbatim
en:  openssl genpkey -paramfile dhp.pem -out dhkey.pem
fr:  openssl genpkey -paramfile pdh.pem -out clefdh.pem

note: type: textblock
en: pkey - public or private key processing tool
fr: pkey - Utilitaire de traitement de clefs publique ou privée

note: type: textblock
en: B<openssl> B<pkey> [B<-inform PEM|DER>] [B<-outform PEM|DER>] [B<-in filename>] [B<-passin arg>] [B<-out filename>] [B<-passout arg>] [B<-cipher>] [B<-text>] [B<-text_pub>] [B<-noout>] [B<-pubin>] [B<-pubout>] [B<-engine id>]
fr: B<openssl> B<pkey> [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<-cipher>] [B<-text>] [B<-text_pub>] [B<-noout>] [B<-pubin>] [B<-pubout>] [B<-engine> I<identifiant>]

note: type: textblock
en: The B<pkey> command processes public or private keys. They can be converted between various forms and their components printed out.
fr: La commande B<pkey> traite les clefs publique ou privée. Elles peuvent être converties entre différentes formes et avoir leurs composants affichés.

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 DER or PEM.
fr: Indiquer le format d'entrée, DER ou PEM.

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

note: type: =item
en: B<-in 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: Indiquer le nom du fichier d'entrée à partir duquel la clef sera lue. Par défaut, la clef est lue depuis l'entrée standard si cette option est omise. Si la clef est chiffrée, un mot de passe sera demandé à l'invite de commande.

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: textblock
en: This specifies the output filename to write a key to or standard output if this option 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: Indiquer le nom du fichier de sortie où sera écrite la clef. Par défaut, la clef est écrite sur la sortie standard 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 devra B<pas> être le même que le fichier d'entrée.

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

note: type: textblock
en: These options encrypt the private key with the supplied cipher. Any algorithm name accepted by EVP_get_cipherbyname() is acceptable such as B<des3>.
fr: Ces options indiquent de chiffrer la clef privée avec l’algorithme fourni. N’importe quel nom d’algorithme accepté par B<EVP_get_cipherbyname>() est acceptable comme B<des3>.

note: type: textblock
en: prints out the various public or private key components in plain text in addition to the encoded version.
fr: Afficher les différentes composantes des clefs privée ou publique au format texte en plus de la version encodée.

note: type: textblock
en: print out only public key components even if a private key is being processed.
fr: N'afficher que les composants de clef publique même si une clef privée est traitée.

note: type: textblock
en: do not output the encoded version of the key.
fr: Ne pas produire la version encodée 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 à la place. Cette option est automatiquement activée si l'entrée est une clef publique.

note: type: textblock
en: specifying an engine (by its unique B<id> string) will cause B<pkey> 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: L’indication d’un moteur (en utilisant son identifiant unique I<identifiant>) forcera B<pkey> à 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: To remove the pass phrase on an RSA private key:
fr: Pour enlever la phrase secrète d'une clef privée RSA :

note: type: verbatim
en:  openssl pkey -in key.pem -out keyout.pem
fr:  openssl pkey -in clef.pem -out clefsortie.pem

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: verbatim
en:  openssl pkey -in key.pem -des3 -out keyout.pem
fr:  openssl pkey -in clef.pem -des3 -out clefsortie.pem

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: verbatim
en:  openssl pkey -in key.pem -outform DER -out keyout.der
fr:  openssl pkey -in clef.pem -outform DER -out clefsortie.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: verbatim
en:  openssl pkey -in key.pem -text -noout
fr:  openssl pkey -in clef.pem -text -noout

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

note: type: verbatim
en:  openssl pkey -in key.pem -text_pub -noout
fr:  openssl pkey -in clef.pem -text_pub -noout

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: verbatim
en:  openssl pkey -in key.pem -pubout -out pubkey.pem
fr:  openssl pkey -in clef.pem -pubout -out clefpub.pem

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

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

note: type: textblock
en: pkeyparam - public key algorithm parameter processing tool
fr: pkeyparam - Outil de traitement de paramètres d'algorithme à clef publique

note: type: textblock
en: B<openssl> B<pkeyparam> [B<-in filename>] [B<-out filename>] [B<-text>] [B<-noout>] [B<-engine id>]
fr: B<openssl> B<pkeyparam> [B<-in> I<fichier>] [B<-out> I<fichier>] [B<-text>] [B<-noout>] [B<-engine> I<identifiant>]

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

note: type: textblock
en: This specifies the output filename to write parameters to or standard output if this option is not specified.
fr: Indiquer le nom du fichier où seront écrits les paramètres. Par défaut, la sortie standard est utilisée.

note: type: textblock
en: prints out the parameters in plain text in addition to the encoded version.
fr: Afficher les paramètres au format texte en plus de la version encodée.

note: type: textblock
en: do not output the encoded version of the parameters.
fr: Ne pas produire la version encodée des paramètres.

note: type: textblock
en: specifying an engine (by its unique B<id> string) will cause B<pkeyparam> 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: L’indication d’un moteur (en utilisant son identifiant unique I<identifiant>) forcera B<pkey> à essayer d'obtenir une référence fonctionnelle pour le moteur indiqué et à l'initialiser si nécessaire. Le moteur sera ensuite utilisé par défaut pour tous les algorithmes disponibles.

note: type: =head1
en: EXAMPLE
fr: EXEMPLE

note: type: textblock
en: Print out text version of parameters:
fr: Afficher la version texte des paramètres :

note: type: textblock
en: There are no B<-inform> or B<-outform> options for this command because only PEM format is supported because the key type is determined by the PEM headers.
fr: Aucune option B<-inform> ou B<-outform> n’existe pour cette commande parce que seul le format PEM est pris en charge car le type de clef est déterminé par les en-têtes PEM.

note: type: textblock
en: pkeyutl - public key algorithm utility
fr: pkeyutl - Utilitaire d’algorithme à clef publique

note: type: textblock
en: B<openssl> B<pkeyutl> [B<-in file>] [B<-out file>] [B<-sigfile file>] [B<-inkey file>] [B<-keyform PEM|DER>] [B<-passin arg>] [B<-peerkey file>] [B<-peerform PEM|DER>] [B<-pubin>] [B<-certin>] [B<-rev>] [B<-sign>] [B<-verify>] [B<-verifyrecover>] [B<-encrypt>] [B<-decrypt>] [B<-derive>] [B<-pkeyopt opt:value>] [B<-hexdump>] [B<-asn1parse>] [B<-engine id>]
fr: B<openssl> B<pkeyutl> [B<-in> I<fichier>] [B<-out> I<fichier>] [B<-sigfile> I<fichier>] [B<-inkey> I<fichier>] [B<-keyform PEM>|B<DER>] [B<-passin> I<param>] [B<-peerkey> I<fichier>] [B<-peerform PEM>|B<DER>] [B<-pubin>] [B<-certin>] [B<-rev>] [B<-sign>] [B<-verify>] [B<-verifyrecover>] [B<-encrypt>] [B<-decrypt>] [B<-derive>] [B<-pkeyopt> I<opt>B<:>I<valeur>] [B<-hexdump>] [B<-asn1parse>] [B<-engine> I<identifiant>]

note: type: textblock
en: The B<pkeyutl> command can be used to perform public key operations using any supported algorithm.
fr: La commande B<pkeyutl> peut être utilisée pour réaliser des opérations de clef publique en utilisant n’importe quel algorithme pris en charge.

note: type: textblock
en: This specifies the input filename to read data from or standard input if this option is not specified.
fr: Cela indique le nom de fichier d'entrée où lire les données. Par défaut, si cette option n'est pas fournie, les données sont lues depuis l'entrée standard.

note: type: textblock
en: specifies the output filename to write to or standard output by default.
fr: Le nom du fichier de sortie. Par défaut, la sortie standard est utilisée.

note: type: =item
en: B<-inkey file>
fr: B<-inkey> I<fichier>

note: type: textblock
en: the input key file, by default it should be a private key.
fr: Le fichier avec la clef d'entrée. Par défaut, ce devrait être une clef privée.

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

note: type: textblock
en: the key format PEM, DER or ENGINE.
fr: Le format de clef PEM, DER ou ENGINE.

note: type: textblock
en: the input key 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<-peerkey file>
fr: B<-peerkey> I<fichier>

note: type: textblock
en: the peer key file, used by key derivation (agreement) operations.
fr: La clef de pair, utilisée par les opérations de dérivation (échange) de clef.

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

note: type: textblock
en: the peer key format PEM, DER or ENGINE.
fr: Le format de clef de pair PEM, DER ou ENGINE.

note: type: textblock
en: specifying an engine (by its unique B<id> string) will cause B<pkeyutl> 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: L’indication d’un moteur (en utilisant son identifiant unique I<identifiant>) forcera B<pkeyutl> à 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 input file is a public key.
fr: Le fichier d'entrée est une clef publique.

note: type: textblock
en: the input is a certificate containing a public key.
fr: Le fichier d'entrée est un certificat contenant une clef publique.

note: type: textblock
en: reverse the order of the input buffer. This is useful for some libraries (such as CryptoAPI) which represent the buffer in little endian format.
fr: Inverser l’ordre du tampon d’entrée. C’est utile pour certaines bibliothèques (comme CryptAPI) qui représentent le tampon au format petit-boutiste.

note: type: textblock
en: sign the input data and output the signed result. This requires a private key.
fr: Signer les données d'entrée et fournir le résultat chiffré. Cela nécessite une clef privée.

note: type: textblock
en: verify the input data against the signature file and indicate if the verification succeeded or failed.
fr: Vérifier les données d’entrée par rapport au fichier de signature et indiquer si la vérification a réussi ou échoué.

note: type: textblock
en: verify the input data and output the recovered data.
fr: Vérifier les données d'entrée et fournir les données récupérées.

note: type: textblock
en: encrypt the input data using a public key.
fr: Chiffrer les données d'entrée en utilisant une clef publique.

note: type: textblock
en: decrypt the input data using a private key.
fr: Déchiffrer les données d'entrée en utilisant une clef privée.

note: type: textblock
en: derive a shared secret using the peer key.
fr: Dériver un secret partagé en utilisant la clef de pair.

note: type: textblock
en: hex dump the output data.
fr: Affichage hexadécimal des données de sortie.

note: type: textblock
en: asn1parse the output data, this is useful when combined with the B<-verifyrecover> option when an ASN1 structure is signed.
fr: Analyser les données de sortie avec asn1parse. C'est utile lorsqu'elle est associée à l'option B<-verifyrecover> quand une structure ASN1 est signée.

note: type: textblock
en: The operations and options supported vary according to the key algorithm and its implementation. The OpenSSL operations and options are indicated below.
fr: Les opérations et options prises en charge varient en fonction de l’algorithme et de son implémentation. Les opérations et options d’OpenSSL sont indiquées ci-dessous.

note: type: textblock
en: Unless otherwise mentioned all algorithms support the B<digest:alg> option which specifies the digest in use for sign, verify and verifyrecover operations.  The value B<alg> should represent a digest name as used in the EVP_get_digestbyname() function for example B<sha1>.
fr: Sauf mention contraire, tous les algorithmes prennent en charge l’option B<digest:>I<alg> qui indique l’algorithme à utiliser pour les opérations de signature, vérification et verifyrecover. La valeur I<alg> devrait représenter un nom d’algorithme tel qu’utilisé dans la fonction B<EVP_get_digestbyname>(), par exemple B<sha1>.

note: type: =head1
en: RSA ALGORITHM
fr: ALGORITHME RSA

note: type: textblock
en: The RSA algorithm supports encrypt, decrypt, sign, verify and verifyrecover operations in general. Some padding modes only support some of these operations however.
fr: L’algorithme RSA prend en charge généralement les opérations de chiffrement, déchiffrement, signature, vérification et verifyrecover. Certains modes de remplissage ne prennent cependant en charge qu’une partie de ces opérations.

note: type: =item
en: -B<rsa_padding_mode:mode>
fr: B<rsa_padding_mode:>I<mode>

note: type: textblock
en: This sets the RSA padding mode. Acceptable values for B<mode> are B<pkcs1> for PKCS#1 padding, B<sslv23> for SSLv23 padding, B<none> for no padding, B<oaep> for B<OAEP> mode, B<x931> for X9.31 mode and B<pss> for PSS.
fr: Cela définit le mode de remplissage RSA. Les valeurs possibles de I<mode> sont B<pkcs1> pour un remplissage PKCS#1, B<sslv23> pour un remplissage SSLv23, B<none> pour une absence de remplissage, B<oaep> pour le mode B<OAEP>, B<x931> pour le mode X9.31 et B<pss> pour PSS.

note: type: textblock
en: In PKCS#1 padding if the message digest is not set then the supplied data is signed or verified directly instead of using a B<DigestInfo> structure. If a digest is set then the a B<DigestInfo> structure is used and its the length must correspond to the digest type.
fr: En remplissage PKCS#1, si l’algorithme de signature de message n’est pas défini, alors les données fournies sont signées ou vérifiées directement au lieu d’utiliser une structure B<DigestInfo>. Si un algorithme de signature est défini, alors une structure B<DigestInfo> est utilisée et sa taille doit correspondre au type d’algorithme de signature.

note: type: textblock
en: For B<oeap> mode only encryption and decryption is supported.
fr: Pour le mode B<oeap>, seul le chiffrement et le déchiffrement sont pris en charge.

note: type: textblock
en: For B<x931> if the digest type is set it is used to format the block data otherwise the first byte is used to specify the X9.31 digest ID. Sign, verify and verifyrecover are can be performed in this mode.
fr: Pour B<x931>, si le type d’algorithme de signature est défini, il est utilisé pour formater les données de bloc, sinon le premier octet est utilisé pour indiquer l’identifiant d’algorithme de signature X9.31. Signature, vérification et verifyrecover peuvent être réalisées dans ce mode.

note: type: textblock
en: For B<pss> mode only sign and verify are supported and the digest type must be specified.
fr: Pour le mode B<oeap>, seules la signature et la vérification sont prises en charge et le type d’algorithme de signature doit être indiqué.

note: type: =item
en: B<rsa_pss_saltlen:len>
fr: B<rsa_pss_saltlen:>I<len>

note: type: textblock
en: For B<pss> mode only this option specifies the salt length. Two special values are supported: -1 sets the salt length to the digest length. When signing -2 sets the salt length to the maximum permissible value. When verifying -2 causes the salt length to be automatically determined based on the B<PSS> block structure.
fr: Pour le mode B<pss>, seule cette option indique la taille de sel. Deux valeurs spéciales sont prises en charge : B<-1> définit la taille de sel à la taille de l’algorithme de signature. Lors de la vérification, B<-2> définit la taille de sel à la valeur maximale permise. Lors de la vérification, B<-2> force la taille de sel à être automatiquement déterminée à partir de la structure de bloc B<PSS>.

note: type: =head1
en: DSA ALGORITHM
fr: ALGORITHME DSA

note: type: textblock
en: The DSA algorithm supports signing and verification operations only. Currently there are no additional options other than B<digest>. Only the SHA1 digest can be used and this digest is assumed by default.
fr: L’algorithme DSA ne permet que les opérations de signature et de vérification. La seule option supplémentaire actuellement est B<digest>. Seul l’algorithme de signature SHA1 peut être utilisé et cet algorithme de signature est considéré par défaut.

note: type: =head1
en: DH ALGORITHM
fr: ALGORITHME DH

note: type: textblock
en: The DH algorithm only supports the derivation operation and no additional options.
fr: L’algorithme DH ne permet que l’opération de dérivation et aucune option supplémentaire.

note: type: =head1
en: EC ALGORITHM
fr: ALGORITHME EC

note: type: textblock
en: The EC algorithm supports sign, verify and derive operations. The sign and verify operations use ECDSA and derive uses ECDH. Currently there are no additional options other than B<digest>. Only the SHA1 digest can be used and this digest is assumed by default.
fr: L’algorithme EC prend en charge les opérations de signature, vérification et dérivation. Les opérations de signature et vérification utilisent ECDSA et la dérivation utilise ECDH. Il n’y a actuellement aucune option supplémentaire à part B<digest>. Seul l’algorithme de signature SHA1 peut être utilisé et cet algorithme de signature est considéré par défaut.

note: type: textblock
en: Sign some data using a private key:
fr: Signer des données en utilisant une clef privée :

note: type: verbatim
en:  openssl pkeyutl -sign -in file -inkey key.pem -out sig
fr:  openssl pkeyutl -sign -in fichier -inkey clef.pem -out sig

note: type: textblock
en: Recover the signed data (e.g. if an RSA key is used):
fr: Récupérer les données signées (par exemple si une clef RSA est utilisée) :

note: type: verbatim
en:  openssl pkeyutl -verifyrecover -in sig -inkey key.pem
fr:  openssl pkeyutl -verifyrecover -in sig -inkey clef.pem

note: type: textblock
en: Verify the signature (e.g. a DSA key):
fr: Vérifier la signature (par exemple d'une clef DSA) :

note: type: verbatim
en:  openssl pkeyutl -verify -in file -sigfile sig -inkey key.pem
fr:  openssl pkeyutl -verify -in fichier -sigfile sig -inkey clef.pem

note: type: textblock
en: Sign data using a message digest value (this is currently only valid for RSA):
fr: Signer des données en utilisant une valeur d’algorithme de signature de message (ce n’est actuellement possible qu’avec RSA) :

note: type: verbatim
en:  openssl pkeyutl -sign -in file -inkey key.pem -out sig -pkeyopt digest:sha256
fr:  openssl pkeyutl -sign -in fichier -inkey clef.pem -out sig 
    				-pkeyopt digest:sha256

note: type: textblock
en: Derive a shared secret value:
fr: Dériver une valeur de secret partagé :

note: type: verbatim
en:  openssl pkeyutl -derive -inkey key.pem -peerkey pubkey.pem -out secret
fr:  openssl pkeyutl -derive -inkey clef.pem -peerkey clefpub.pem -out secret

note: type: textblock
en: L<genpkey(1)|genpkey(1)>, L<pkey(1)|pkey(1)>, L<rsautl(1)|rsautl(1)> L<dgst(1)|dgst(1)>, L<rsa(1)|rsa(1)>, L<genrsa(1)|genrsa(1)>
fr: L<B<genpkey>(1)|genpkey(1)>, L<B<pkey>(1)|pkey(1)>, L<B<rsautl>(1)|rsautl(1)> L<B<dgst>(1)|dgst(1)>, L<B<rsa>(1)|rsa(1)>, L<B<genrsa>(1)|genrsa(1)>

note: type: textblock
en: EVP_PKEY_CTX_ctrl, EVP_PKEY_CTX_ctrl_str, EVP_PKEY_get_default_digest_nid, EVP_PKEY_CTX_set_signature_md, EVP_PKEY_CTX_set_rsa_padding, EVP_PKEY_CTX_set_rsa_pss_saltlen, EVP_PKEY_CTX_set_rsa_rsa_keygen_bits, EVP_PKEY_CTX_set_rsa_keygen_pubexp, EVP_PKEY_CTX_set_dsa_paramgen_bits, EVP_PKEY_CTX_set_dh_paramgen_prime_len, EVP_PKEY_CTX_set_dh_paramgen_generator, EVP_PKEY_CTX_set_ec_paramgen_curve_nid - algorithm specific control operations
fr: EVP_PKEY_CTX_ctrl, EVP_PKEY_CTX_ctrl_str, EVP_PKEY_get_default_digest_nid, EVP_PKEY_CTX_set_signature_md, EVP_PKEY_CTX_set_rsa_padding, EVP_PKEY_CTX_set_rsa_pss_saltlen, EVP_PKEY_CTX_set_rsa_rsa_keygen_bits, EVP_PKEY_CTX_set_rsa_keygen_pubexp, EVP_PKEY_CTX_set_dsa_paramgen_bits, EVP_PKEY_CTX_set_dh_paramgen_prime_len, EVP_PKEY_CTX_set_dh_paramgen_generator, EVP_PKEY_CTX_set_ec_paramgen_curve_nid - Opérations de contrôle spécifiques à l’algorithme

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

note: type: verbatim
en:  int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype,
    				int cmd, int p1, void *p2);
     int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx, const char *type,
    						const char *value);
fr: B< int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *>I<ctx>B<, int> I<keytype>B<, int> I<optype>B<,>
     				B<int> I<cmd>B<, int> I<p1>B<, void *>I<p2>B<);>
     B<int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *>I<ctx>B<, const char *>I<type>B<,>
     						B<const char *>I<value>B<);>

note: type: verbatim
en:  int EVP_PKEY_get_default_digest_nid(EVP_PKEY *pkey, int *pnid);
fr: B< int EVP_PKEY_get_default_digest_nid(EVP_PKEY *>I<pkey>B<, int *>I<pnid>B<);>

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

note: type: verbatim
en:  int EVP_PKEY_CTX_set_signature_md(EVP_PKEY_CTX *ctx, const EVP_MD *md);
fr: B< int EVP_PKEY_CTX_set_signature_md(EVP_PKEY_CTX *>I<ctx>B<, const EVP_MD *>I<md>B<);>

note: type: verbatim
en:  int EVP_PKEY_CTX_set_rsa_padding(EVP_PKEY_CTX *ctx, int pad);
     int EVP_PKEY_CTX_set_rsa_pss_saltlen(EVP_PKEY_CTX *ctx, int len);
     int EVP_PKEY_CTX_set_rsa_rsa_keygen_bits(EVP_PKEY_CTX *ctx, int mbits);
     int EVP_PKEY_CTX_set_rsa_keygen_pubexp(EVP_PKEY_CTX *ctx, BIGNUM *pubexp);
fr: B< int EVP_PKEY_CTX_set_rsa_padding(EVP_PKEY_CTX *>I<ctx>B<, int> I<pad>B<);>
     B<int EVP_PKEY_CTX_set_rsa_pss_saltlen(EVP_PKEY_CTX *>I<ctx>B<, int> I<len>B<);>
     B<int EVP_PKEY_CTX_set_rsa_rsa_keygen_bits(EVP_PKEY_CTX *>I<ctx>B<, int> I<mbits>B<);>
     B<int EVP_PKEY_CTX_set_rsa_keygen_pubexp(EVP_PKEY_CTX *>I<ctx>B<, BIGNUM *>I<pubexp>B<);>

note: type: verbatim
en:  #include <openssl/dsa.h>
     int EVP_PKEY_CTX_set_dsa_paramgen_bits(EVP_PKEY_CTX *ctx, int nbits);
fr: B< #include E<lt>openssl/dsa.hE<gt>>
     B<int EVP_PKEY_CTX_set_dsa_paramgen_bits(EVP_PKEY_CTX *>I<ctx>B<, int> I<nbits>B<);>

note: type: verbatim
en:  #include <openssl/dh.h>
     int EVP_PKEY_CTX_set_dh_paramgen_prime_len(EVP_PKEY_CTX *ctx, int len);
     int EVP_PKEY_CTX_set_dh_paramgen_generator(EVP_PKEY_CTX *ctx, int gen);
fr: B< #include E<lt>openssl/dh.hE<gt>>
     B<int EVP_PKEY_CTX_set_dh_paramgen_prime_len(EVP_PKEY_CTX *>I<ctx>B<, int> I<len>B<);>
     B<int EVP_PKEY_CTX_set_dh_paramgen_generator(EVP_PKEY_CTX *>I<ctx>B<, int> I<gen>B<);>

note: type: verbatim
en:  #include <openssl/ec.h>
     int EVP_PKEY_CTX_set_ec_paramgen_curve_nid(EVP_PKEY_CTX *ctx, int nid);
fr: B< #include E<lt>openssl/ec.hE<gt>>
     B<int EVP_PKEY_CTX_set_ec_paramgen_curve_nid(EVP_PKEY_CTX *>I<ctx>B<, int> I<nid>B<);>

note: type: textblock
en: The function EVP_PKEY_CTX_ctrl() sends a control operation to the context B<ctx>. The key type used must match B<keytype> if it is not -1. The parameter B<optype> is a mask indicating which operations the control can be applied to.  The control command is indicated in B<cmd> and any additional arguments in B<p1> and B<p2>.
fr: La fonction B<EVP_PKEY_CTX_ctrl>() envoie une opération de contrôle au contexte I<ctx>. Le type de clef utilisé doit correspondre à I<keytype> s’il n’est pas B<-1>. Le paramètre I<optype> est un masque indiquant les opérations de contrôle qui peuvent être appliquées. La commande de contrôle est indiquée dans I<cmd> et tous les arguments supplémentaires dans I<p1> et I<p2>.

note: type: textblock
en: Applications will not normally call EVP_PKEY_CTX_ctrl() directly but will instead call one of the algorithm specific macros below.
fr: Les applications n’appelleront normalement pas B<EVP_PKEY_CTX_ctrl>() directement mais appelleront plutôt une des macros spécifiques à l’algorithme ci-dessous.

note: type: textblock
en: The function EVP_PKEY_CTX_ctrl_str() allows an application to send an algorithm specific control operation to a context B<ctx> in string form. This is intended to be used for options specified on the command line or in text files. The commands supported are documented in the openssl utility command line pages for the option B<-pkeyopt> which is supported by the B<pkeyutl>, B<genpkey> and B<req> commands.
fr: La fonction B<EVP_PKEY_CTX_ctrl_str>() permet à une application d’envoyer une opération de contrôle spécifique à l’algorithme vers un contexte I<ctx> sous forme de chaîne. C’est dans le but d’être utilisé pour des options indiquées sur la ligne de commande ou dans des fichiers texte. Les commandes permises sont documentées dans les pages des lignes de commande de l’utilitaire openssl, pour l’option B<-pkeyopt> prise en charge par les commandes B<pkeyutl>, B<genpkey> et B<req>.

note: type: textblock
en: All the remaining "functions" are implemented as macros.
fr: Toutes les « fonctions » restantes sont implémentées comme des macros.

note: type: textblock
en: The EVP_PKEY_CTX_set_signature_md() macro sets the message digest type used in a signature. It can be used with any public key algorithm supporting signature operations.
fr: La macro B<EVP_PKEY_CTX_set_signature_md>() définit le type d’algorithme de message utilisé dans une signature. Il peut être utilisé avec n’importe quel algorithme à clef publique permettant les opérations de signature.

note: type: textblock
en: The macro EVP_PKEY_CTX_set_rsa_padding() sets the RSA padding mode for B<ctx>.  The B<pad> parameter can take the value RSA_PKCS1_PADDING for PKCS#1 padding, RSA_SSLV23_PADDING for SSLv23 padding, RSA_NO_PADDING for no padding, RSA_PKCS1_OAEP_PADDING for OAEP padding (encrypt and decrypt only), RSA_X931_PADDING for X9.31 padding (signature operations only) and RSA_PKCS1_PSS_PADDING (sign and verify only).
fr: La macro B<EVP_PKEY_CTX_set_rsa_padding>() définit le mode de remplissage RSA pour I<ctx>. Le paramètre I<pad> peut prendre la valeur RSA_PKCS1_PADDING pour un remplissage PKCS#1, RSA_SSLV23_PADDING pour un remplissage SSLv23, RSA_NO_PADDING pour une absence de remplissage, RSA_PKCS1_OAEP_PADDING pour un remplissage OAEP (chiffrement et déchiffrement seulement), RSA_X931_PADDING pour un remplissage X9.31 (opérations de signature seulement) et RSA_PKCS1_PSS_PADDING (signature et vérification seulement).

note: type: textblock
en: Two RSA padding modes behave differently if EVP_PKEY_CTX_set_signature_md()  is used. If this macro is called for PKCS#1 padding the plaintext buffer is an actual digest value and is encapsulated in a DigestInfo structure according to PKCS#1 when signing and this structure is expected (and stripped off) when verifying. If this control is not used with RSA and PKCS#1 padding then the supplied data is used directly and not encapsulated. In the case of X9.31 padding for RSA the algorithm identifier byte is added or checked and removed if this control is called. If it is not called then the first byte of the plaintext buffer is expected to be the algorithm identifier byte.
fr: Deux modes de remplissage RSA se comportent différemment si B<EVP_PKEY_CTX_set_signature_md>() est utilisée. Si cette macro est appelée pour un remplissage PKCS#1, le tampon de texte en clair est une véritable valeur d’algorithme de signature encapsulée dans une structure DigestInfo d’après PKCS#1 lors de la signature et cette structure est attendue (et supprimée) lors de la vérification. Si ce contrôle n’est pas utilisé avec RSA et un remplissage PKCS#1, alors les données fournies sont utilisées directement et non encapsulées. Dans le cas de remplissage X9.31 pour RSA, l’octet identifiant l’algorithme est ajouté ou vérifié et supprimé si ce contrôle est appelé. S’il n’est pas appelé, alors le premier octet du tampon de texte en clair est supposé être l’octet identifiant l’algorithme.

note: type: textblock
en: The EVP_PKEY_CTX_set_rsa_pss_saltlen() macro sets the RSA PSS salt length to B<len> as its name implies it is only supported for PSS padding.  Two special values are supported: -1 sets the salt length to the digest length. When signing -2 sets the salt length to the maximum permissible value. When verifying -2 causes the salt length to be automatically determined based on the B<PSS> block structure. If this macro is not called a salt length value of -2 is used by default.
fr: La macro B<EVP_PKEY_CTX_set_rsa_pss_saltlen>() définit la taille de sel PSS RSA à I<len> ; comme son nom l’indique, ce n’est utile que pour le remplissage PSS. Deux valeurs spéciales sont permises : B<-1> définit la taille de sel à la taille de signature. Lors d’une signature, B<-2> définit la taille de sel à la valeur maximale permise. Lors de la vérification, B<-2> force la taille de sel à être déterminée automatiquement à partir de la structure de bloc B<PSS>. Si cette macro n’est pas appelée, une valeur de taille de sel B<-2> est utilisée par défaut.

note: type: textblock
en: The EVP_PKEY_CTX_set_rsa_rsa_keygen_bits() macro sets the RSA key length for RSA key genration to B<bits>. If not specified 1024 bits is used.
fr: La macro B<EVP_PKEY_CTX_set_rsa_rsa_keygen_bits>() définit la taille de clef RSA pour la génération de clef RSA à I<bits>. Si elle n’est pas indiquée, 1024 bits est utilisé.

note: type: textblock
en: The EVP_PKEY_CTX_set_rsa_keygen_pubexp() macro sets the public exponent value for RSA key generation to B<pubexp> currently it should be an odd integer. The B<pubexp> pointer is used internally by this function so it should not be modified or free after the call. If this macro is not called then 65537 is used.
fr: La macro B<EVP_PKEY_CTX_set_rsa_keygen_pubexp>() définit la valeur d’exposant public pour la génération de clef RSA à I<pubexp> ; actuellement, ce devrait être un entier impair. Le pointeur I<pubexp> est utilisé en interne par cette fonction, et ne devrait donc pas être modifié ni libéré après l’appel. Si cette macro n’est pas appelée, alors 65537 est utilisé.

note: type: textblock
en: The macro EVP_PKEY_CTX_set_dsa_paramgen_bits() sets the number of bits used for DSA parameter generation to B<bits>. If not specified 1024 is used.
fr: La macro B<EVP_PKEY_CTX_set_dsa_paramgen_bits>() définit le nombre de bits utilisés pour la génération de paramètres DSA à I<bits>. En absence d’indication, 1024 est utilisé.

note: type: textblock
en: The macro EVP_PKEY_CTX_set_dh_paramgen_prime_len() sets the length of the DH prime parameter B<p> for DH parameter generation. If this macro is not called then 1024 is used.
fr: La macro B<EVP_PKEY_CTX_set_dh_paramgen_prime_len>() définit la taille du paramètre I<p> de nombre premier pour la génération de paramètres DH. Si cette macro n’est pas appelée, alors 1024 est utilisé.

note: type: textblock
en: The EVP_PKEY_CTX_set_dh_paramgen_generator() macro sets DH generator to B<gen> for DH parameter generation. If not specified 2 is used.
fr: La macro B<EVP_PKEY_CTX_set_dh_paramgen_generator>() définit le générateur DH à I<gen> pour la génération de paramètres DH. En absence d’indication, 2 est utilisé.

note: type: textblock
en: The EVP_PKEY_CTX_set_ec_paramgen_curve_nid() sets the EC curve for EC parameter generation to B<nid>. For EC parameter generation this macro must be called or an error occurs because there is no default curve.
fr: La macro B<EVP_PKEY_CTX_set_ec_paramgen_curve_nid>() définit la courbe EC pour la génération de paramètres EC à I<nid>. Pour la génération de paramètres EC, cette macro doit être appelée sinon une erreur survient parce qu’il n’y a pas de courbe par défaut.

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

note: type: textblock
en: EVP_PKEY_CTX_ctrl() and its macros return a positive value for success and 0 or a negative value for failure. In particular a return value of -2 indicates the operation is not supported by the public key algorithm.
fr: B<EVP_PKEY_CTX_ctrl>() et ses macros renvoient une valeur positive en cas de réussite et B<0> ou une valeur négative en cas d’échec. En particulier, une valeur de B<-2> indique que l’opération n’est pas prise en charge par l’algorithme à clef publique.

note: type: textblock
en: L<EVP_PKEY_CTX_new(3)|EVP_PKEY_CTX_new(3)>, L<EVP_PKEY_encrypt(3)|EVP_PKEY_encrypt(3)>, L<EVP_PKEY_decrypt(3)|EVP_PKEY_decrypt(3)>, L<EVP_PKEY_sign(3)|EVP_PKEY_sign(3)>, L<EVP_PKEY_verify(3)|EVP_PKEY_verify(3)>, L<EVP_PKEY_verify_recover(3)|EVP_PKEY_verify_recover(3)>, L<EVP_PKEY_derive(3)|EVP_PKEY_derive(3)> L<EVP_PKEY_keygen(3)|EVP_PKEY_keygen(3)>
fr: L<B<EVP_PKEY_CTX_new>(3)|EVP_PKEY_CTX_new(3)>, L<B<EVP_PKEY_encrypt>(3)|EVP_PKEY_encrypt(3)>, L<B<EVP_PKEY_decrypt>(3)|EVP_PKEY_decrypt(3)>, L<B<BEVP_PKEY_sign>(3)|EVP_PKEY_sign(3)>, L<B<EVP_PKEY_verify>(3)|EVP_PKEY_verify(3)>, L<B<EVP_PKEY_verify_recover>(3)|EVP_PKEY_verify_recover(3)>, L<B<EVP_PKEY_derive>(3)|EVP_PKEY_derive(3)> L<B<EVP_PKEY_keygen>(3)|EVP_PKEY_keygen(3)>

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

note: type: textblock
en: These functions were first added to OpenSSL 1.0.0.
fr: Ces fonctions ont été ajoutées pour la première fois dans OpenSSL 1.0.0.

note: type: textblock
en: EVP_PKEY_CTX_new, EVP_PKEY_CTX_new_id, EVP_PKEY_CTX_dup, EVP_PKEY_CTX_free - public key algorithm context functions.
fr: EVP_PKEY_CTX_new, EVP_PKEY_CTX_new_id, EVP_PKEY_CTX_dup, EVP_PKEY_CTX_free - Fonctions de contexte d'algorithme à clef publique

note: type: verbatim
en:  EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e);
     EVP_PKEY_CTX *EVP_PKEY_CTX_new_id(int id, ENGINE *e);
     EVP_PKEY_CTX *EVP_PKEY_CTX_dup(EVP_PKEY_CTX *ctx);
     void EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx);
fr: B< EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *>I<pkey>B<, ENGINE *>I<e>B<);>
     B<EVP_PKEY_CTX *EVP_PKEY_CTX_new_id(int> I<id>B<, ENGINE *>I<e>B<);>
     B<EVP_PKEY_CTX *EVP_PKEY_CTX_dup(EVP_PKEY_CTX *>I<ctx>B<);>
     B<void EVP_PKEY_CTX_free(EVP_PKEY_CTX *>I<ctx>B<);>

note: type: textblock
en: The EVP_PKEY_CTX_new() function allocates public key algorithm context using the algorithm specified in B<pkey> and ENGINE B<e>.
fr: La fonction B<EVP_PKEY_CTX_new>() alloue un contexte d'algorithme à clef publique en utilisant l'algorithme indiqué dans I<pkey> et ENGINE I<e>.

note: type: textblock
en: The EVP_PKEY_CTX_new_id() function allocates public key algorithm context using the algorithm specified by B<id> and ENGINE B<e>. It is normally used when no B<EVP_PKEY> structure is associated with the operations, for example during parameter generation of key genration for some algorithms.
fr: La fonction B<EVP_PKEY_CTX_new_id>() alloue un contexte d'algorithme à clef publique en utilisant l'algorithme indiqué par I<id> et ENGINE I<e>. Elle est normalement utilisée quand aucune structure B<EVP_PKEY> n'est associée aux opérations, par exemple pendant la génération de paramètres de génération de clef pour quelques algorithmes.

note: type: textblock
en: EVP_PKEY_CTX_dup() duplicates the context B<ctx>.
fr: B<EVP_PKEY_CTX_dup>() duplique le contexte I<ctx>.

note: type: textblock
en: EVP_PKEY_CTX_free() frees up the context B<ctx>.
fr: B<EVP_PKEY_CTX_free>() libère le contexte I<ctx>.

note: type: textblock
en: The B<EVP_PKEY_CTX> structure is an opaque public key algorithm context used by the OpenSSL high level public key API. Contexts B<MUST NOT> be shared between threads: that is it is not permissible to use the same context simultaneously in two threads.
fr: La structure B<EVP_PKEY_CTX> est un contexte d'algorithme à clef publique opaque utilisé par l'API à clef publique OpenSSL de haut niveau. Les contextes ne B<doivent pas> être partagés entre threads : le même contexte ne peut pas être utilisé simultanément dans deux threads.

note: type: textblock
en: EVP_PKEY_CTX_new(), EVP_PKEY_CTX_new_id(), EVP_PKEY_CTX_dup() returns either the newly allocated B<EVP_PKEY_CTX> structure of B<NULL> if an error occurred.
fr: B<EVP_PKEY_CTX_new>(), B<EVP_PKEY_CTX_new_id>() et B<EVP_PKEY_CTX_dup>() renvoient la structure B<EVP_PKEY_CTX> nouvellement allouée ou NULL si une erreur s'est produite.

note: type: textblock
en: EVP_PKEY_CTX_free() does not return a value.
fr: B<EVP_PKEY_CTX_free>() ne renvoie aucune valeur.

note: type: textblock
en: L<EVP_PKEY_new(3)|EVP_PKEY_new(3)>
fr: L<B<EVP_PKEY_new>(3)|EVP_PKEY_new(3)>

note: type: textblock
en: EVP_PKEY_copy_parameters, EVP_PKEY_missing_parameters, EVP_PKEY_cmp_parameters, EVP_PKEY_cmp - public key parameter and comparison functions
fr: EVP_PKEY_copy_parameters, EVP_PKEY_missing_parameters, EVP_PKEY_cmp_parameters, EVP_PKEY_cmp - Fonctions de paramétrage et comparaison de clef publique

note: type: verbatim
en:  int EVP_PKEY_missing_parameters(const EVP_PKEY *pkey);
     int EVP_PKEY_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from);
fr: B< int EVP_PKEY_missing_parameters(const EVP_PKEY *>I<pkey>B<);>
     B<int EVP_PKEY_copy_parameters(EVP_PKEY *>I<to>B<, const EVP_PKEY *>I<from>B<);>

note: type: verbatim
en:  int EVP_PKEY_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b);
     int EVP_PKEY_cmp(const EVP_PKEY *a, const EVP_PKEY *b);
fr: B< int EVP_PKEY_cmp_parameters(const EVP_PKEY *>I<a>B<, const EVP_PKEY *>I<b>B<);>
     B<int EVP_PKEY_cmp(const EVP_PKEY *>I<a>B<, const EVP_PKEY *>I<b>B<);>

note: type: textblock
en: The function EVP_PKEY_missing_parameters() returns 1 if the public key parameters of B<pkey> are missing and 0 if they are present or the algorithm doesn't use parameters.
fr: La fonction B<EVP_PKEY_missing_parameters>() renvoie B<1> si les paramètres de la clef publique I<pkey> sont manquants et B<0> s'ils sont présents ou que l'algorithme n'utilise pas de paramètre.

note: type: textblock
en: The function EVP_PKEY_copy_parameters() copies the parameters from key B<from> to key B<to>.
fr: La fonction B<EVP_PKEY_copy_parameters>() copie les paramètres de la clef I<from> vers la clef I<to>.

note: type: textblock
en: The function EVP_PKEY_cmp_parameters() compares the parameters of keys B<a> and B<b>.
fr: La fonction B<EVP_PKEY_cmp_parameters>() compare les paramètres des clefs I<a> et I<b>.

note: type: textblock
en: The function EVP_PKEY_cmp() compares the public key components and paramters (if present) of keys B<a> and B<b>.
fr: La fonction B<EVP_PKEY_cmp>() compare les composants et paramètres (s'il y en a) des clefs publiques I<a> et I<b>.

note: type: textblock
en: The main purpose of the functions EVP_PKEY_missing_parameters() and EVP_PKEY_copy_parameters() is to handle public keys in certificates where the parameters are sometimes omitted from a public key if they are inherited from the CA that signed it.
fr: L'objectif principal des fonctions B<EVP_PKEY_missing_parameters>() et B<EVP_PKEY_copy_parameters>() est de manipuler les clefs publiques des certificats où les paramètres sont parfois omis d'une clef publique s'ils sont hérités de l'autorité de certification qui l'a signée.

note: type: textblock
en: Since OpenSSL private keys contain public key components too the function EVP_PKEY_cmp() can also be used to determine if a private key matches a public key.
fr: Puisque les clefs publiques OpenSSL contiennent aussi des composants de clef publique, la fonction B<EVP_PKEY_cmp>() peut aussi être utilisée pour déterminer si une clef privée correspond à une clef publique.

note: type: textblock
en: These functions EVP_PKEY_copy_parameters() returns 1 for success and 0 for failure.
fr: La fonction B<EVP_PKEY_copy_parameters>() renvoie B<1> en cas de réussite et B<0> en cas d'échec.

note: type: textblock
en: The function EVP_PKEY_cmp_parameters() and EVP_PKEY_cmp() return 1 if the keys match, 0 if they don't match, -1 if the key types are different and -2 if the operation is not supported.
fr: Les fonctions B<EVP_PKEY_cmp_parameters>() et B<EVP_PKEY_cmp>() renvoient B<1> si les clefs correspondent, B<0> si elles ne correspondent pas, B<-1> si les types de clef sont différents et B<-2> si l'opération n'est pas permise.

note: type: textblock
en: L<EVP_PKEY_CTX_new(3)|EVP_PKEY_CTX_new(3)>, L<EVP_PKEY_keygen(3)|EVP_PKEY_keygen(3)>
fr: L<B<EVP_PKEY_CTX_new>(3)|EVP_PKEY_CTX_new(3)>, L<B<EVP_PKEY_keygen>(3)|EVP_PKEY_keygen(3)>

note: type: textblock
en: EVP_PKEY_decrypt_init, EVP_PKEY_decrypt - decrypt using a public key algorithm
fr: EVP_PKEY_decrypt_init, EVP_PKEY_decrypt - Déchiffrer en utilisant un algorithme à clef publique

note: type: verbatim
en:  int EVP_PKEY_decrypt_init(EVP_PKEY_CTX *ctx);
     int EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx,
    			unsigned char *out, size_t *outlen,
    			const unsigned char *in, size_t inlen);
fr: B< int EVP_PKEY_decrypt_init(EVP_PKEY_CTX *>I<ctx>B<);>
     B<int EVP_PKEY_decrypt(EVP_PKEY_CTX *>I<ctx>B<,>
     			B<unsigned char *>I<out>B<, size_t *>I<outlen>B<,>
     			B<const unsigned char *>I<in>B<, size_t> I<inlen>B<);>

note: type: textblock
en: The EVP_PKEY_decrypt_init() function initializes a public key algorithm context using key B<pkey> for a decryption operation.
fr: La fonction B<EVP_PKEY_decrypt_init>() initialise un contexte d'algorithme à clef publique en utilisant la clef I<pkey> pour une opération de déchiffrement.

note: type: textblock
en: The EVP_PKEY_decrypt() function performs a public key decryption operation using B<ctx>. The data to be decrypted is specified using the B<in> and B<inlen> parameters. If B<out> is B<NULL> then the maximum size of the output buffer is written to the B<outlen> parameter. If B<out> is not B<NULL> then before the call the B<outlen> parameter should contain the length of the B<out> buffer, if the call is successful the decrypted data is written to B<out> and the amount of data written to B<outlen>.
fr: La fonction B<EVP_PKEY_decrypt>() réalise une opération de déchiffrement à clef publique en utilisant I<ctx>. Les données à déchiffrer sont indiquées en utilisant les paramètres I<in> et I<inlen>. Si I<out> est NULL, alors la taille maximale du tampon de sortie est écrite dans le paramètre I<outlen>. Si I<out> n'est pas NULL, alors, avant l'appel, le paramètre I<outlen> devrait contenir la taille du tampon I<out> ; si l'appel réussit, les données déchiffrées sont écrites dans I<out> et la quantité de données écrites dans I<outlen>.

note: type: textblock
en: After the call to EVP_PKEY_decrypt_init() algorithm specific control operations can be performed to set any appropriate parameters for the operation.
fr: Après l'appel de B<EVP_PKEY_decrypt_init>(), des opérations de contrôle spécifiques à l'algorithme peuvent être réalisées pour définir n'importe quels paramètres appropriés à l'opération.

note: type: textblock
en: The function EVP_PKEY_decrypt() can be called more than once on the same context if several operations are performed using the same parameters.
fr: La fonction B<EVP_PKEY_decrypt>() peut être appelée plus d'une fois sur le même contexte si plusieurs opérations sont réalisées en utilisant les mêmes paramètres.

note: type: textblock
en: EVP_PKEY_decrypt_init() and EVP_PKEY_decrypt() return 1 for success and 0 or a negative value for failure. In particular a return value of -2 indicates the operation is not supported by the public key algorithm.
fr: B<EVP_PKEY_decrypt_init>() et B<EVP_PKEY_decrypt>() renvoient B<1> en cas de réussite et B<0> ou une valeur négative en cas d'échec. En particulier, une valeur de retour de B<-2> indique que l'opération n'est pas permise par l'algorithme à clef publique.

note: type: textblock
en: Decrypt data using OAEP (for RSA keys):
fr: Déchiffrer des données en utilisant OAEP (pour les clefs RSA) :

note: type: verbatim
en:  EVP_PKEY_CTX *ctx;
     unsigned char *out, *in;
     size_t outlen, inlen; 
     EVP_PKEY *key;
     /* NB: assumes key in, inlen are already set up
      * and that key is an RSA private key
      */
     ctx = EVP_PKEY_CTX_new(key);
     if (!ctx)
    	/* Error occurred */
     if (EVP_PKEY_decrypt_init(ctx) <= 0)
    	/* Error */
     if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_OAEP_PADDING) <= 0)
    	/* Error */
fr:  EVP_PKEY_CTX *ctx;
     unsigned char *out, *in;
     size_t outlen, inlen; 
     EVP_PKEY *key;
     /* Remarque : key, in et inlen sont supposées
      * déjà définies, avec key une clef privée RSA
      */
     ctx = EVP_PKEY_CTX_new(key);
     if (!ctx)
    	/* Une erreur est survenue */
     if (EVP_PKEY_decrypt_init(ctx) <= 0)
    	/* Erreur */
     if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_OAEP_PADDING) <= 0)
    	/* Erreur */

note: type: verbatim
en:  /* Determine buffer length */
     if (EVP_PKEY_decrypt(ctx, NULL, &outlen, in, inlen) <= 0)
    	/* Error */
fr:  /* Déterminer la taille du tampon */
     if (EVP_PKEY_decrypt(ctx, NULL, &outlen, in, inlen) <= 0)
    	/* Error */

note: type: verbatim
en:  if (!out)
    	/* malloc failure */
fr:  if (!out)
    	/* échec malloc */

note: type: verbatim
en:  if (EVP_PKEY_decrypt(ctx, out, &outlen, in, inlen) <= 0)
    	/* Error */
fr:  if (EVP_PKEY_decrypt(ctx, out, &outlen, in, inlen) <= 0)
    	/* Erreur */

note: type: verbatim
en:  /* Decrypted data is outlen bytes written to buffer out */
fr:  /* Les données déchiffrées sont outlen octets écrits dans le
      * tampon out
      */

note: type: textblock
en: L<EVP_PKEY_CTX_new(3)|EVP_PKEY_CTX_new(3)>, L<EVP_PKEY_encrypt(3)|EVP_PKEY_encrypt(3)>, L<EVP_PKEY_sign(3)|EVP_PKEY_sign(3)>, L<EVP_PKEY_verify(3)|EVP_PKEY_verify(3)>, L<EVP_PKEY_verify_recover(3)|EVP_PKEY_verify_recover(3)>, L<EVP_PKEY_derive(3)|EVP_PKEY_derive(3)>
fr: L<B<EVP_PKEY_CTX_new>(3)|EVP_PKEY_CTX_new(3)>, L<B<EVP_PKEY_encrypt>(3)|EVP_PKEY_encrypt(3)>, L<B<EVP_PKEY_sign>(3)|EVP_PKEY_sign(3)>, L<B<EVP_PKEY_verify>(3)|EVP_PKEY_verify(3)>, L<B<EVP_PKEY_verify_recover>(3)|EVP_PKEY_verify_recover(3)>, L<B<EVP_PKEY_derive>(3)|EVP_PKEY_derive(3)>

note: type: textblock
en: EVP_PKEY_derive_init, EVP_PKEY_derive_set_peer, EVP_PKEY_derive - derive public key algorithm shared secret.
fr: EVP_PKEY_derive_init, EVP_PKEY_derive_set_peer, EVP_PKEY_derive - Dériver un secret partagé d'algorithme à clef publique

note: type: verbatim
en:  int EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx);
     int EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer);
     int EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen);
fr: B< int EVP_PKEY_derive_init(EVP_PKEY_CTX *>I<ctx>B<);>
     B<int EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *>I<ctx>B<, EVP_PKEY *>I<peer>B<);>
     B<int EVP_PKEY_derive(EVP_PKEY_CTX *>I<ctx>B<, unsigned char *>I<key>B<, size_t *>I<keylen>B<);>

note: type: textblock
en: The EVP_PKEY_derive_init() function initializes a public key algorithm context using key B<pkey> for shared secret derivation.
fr: La fonction B<EVP_PKEY_derive_init>() initialise un contexte d'algorithme à clef publique en utilisant I<pkey> pour une dérivation à secret partagé.

note: type: textblock
en: The EVP_PKEY_derive_set_peer() function sets the peer key: this will normally be a public key.
fr: La fonction B<EVP_PKEY_derive_set_peer>() définit la clef de pair : ce sera normalement une clef publique.

note: type: textblock
en: The EVP_PKEY_derive() derives a shared secret using B<ctx>.  If B<key> is B<NULL> then the maximum size of the output buffer is written to the B<keylen> parameter. If B<key> is not B<NULL> then before the call the B<keylen> parameter should contain the length of the B<key> buffer, if the call is successful the shared secret is written to B<key> and the amount of data written to B<keylen>.
fr: La fonction B<EVP_PKEY_derive>() dérive un secret partagé en utilisant I<ctx>. Si I<key> est NULL, alors la taille maximale du tampon de sortie est écrite dans le paramètre I<keylen>. Si I<key> n'est pas NULL, alors, avant l'appel, le paramètre I<keylen> devrait contenir la taille du tampon I<key> ; si l'appel réussit, le secret partagé est écrit dans I<key> et la quantité de données écrites dans I<keylen>.

note: type: textblock
en: After the call to EVP_PKEY_derive_init() algorithm specific control operations can be performed to set any appropriate parameters for the operation.
fr: Après l'appel de B<EVP_PKEY_derive_init>(), des opérations de contrôle spécifiques à l'algorithme peuvent être réalisées pour définir n'importe quels paramètres appropriés à l'opération.

note: type: textblock
en: The function EVP_PKEY_derive() can be called more than once on the same context if several operations are performed using the same parameters.
fr: La fonction B<EVP_PKEY_derive>() peut être appelée plus d'une fois sur le même contexte si plusieurs opérations sont réalisées en utilisant les mêmes paramètres.

note: type: textblock
en: EVP_PKEY_derive_init() and EVP_PKEY_derive() return 1 for success and 0 or a negative value for failure. In particular a return value of -2 indicates the operation is not supported by the public key algorithm.
fr: B<EVP_PKEY_derive_init>() et B<EVP_PKEY_derive>() renvoient B<1> en cas de réussite et B<0> ou une valeur négative en cas d'échec. En particulier, une valeur de retour de B<-2> indique que l'opération n'est pas permise par l'algorithme à clef publique.

note: type: textblock
en: Derive shared secret (for example DH or EC keys):
fr: Dériver un secret partagé (par exemple des clefs DH ou EC) :

note: type: verbatim
en:  EVP_PKEY_CTX *ctx;
     unsigned char *skey;
     size_t skeylen;
     EVP_PKEY *pkey, *peerkey;
     /* NB: assumes pkey, peerkey have been already set up */
fr:  EVP_PKEY_CTX *ctx;
     unsigned char *skey;
     size_t skeylen;
     EVP_PKEY *pkey, *peerkey;
     /* Remarque : pkey et peerkey sont supposées déjà définies */

note: type: verbatim
en:  ctx = EVP_PKEY_CTX_new(pkey);
     if (!ctx)
    	/* Error occurred */
     if (EVP_PKEY_derive_init(ctx) <= 0)
    	/* Error */
     if (EVP_PKEY_derive_set_peer(ctx, peerkey) <= 0)
    	/* Error */
fr:  ctx = EVP_PKEY_CTX_new(pkey);
     if (!ctx)
    	/* Une erreur est survenue */
     if (EVP_PKEY_derive_init(ctx) <= 0)
    	/* Erreur */
     if (EVP_PKEY_derive_set_peer(ctx, peerkey) <= 0)
    	/* Erreur */

note: type: verbatim
en:  /* Determine buffer length */
     if (EVP_PKEY_derive(ctx, NULL, &skeylen) <= 0)
    	/* Error */
fr:  /* Déterminer la taille du tampon */
     if (EVP_PKEY_derive(ctx, NULL, &skeylen) <= 0)
    	/* Erreur */

note: type: verbatim
en:  if (!skey)
    	/* malloc failure */
fr:  if (!skey)
    	/* échec malloc */

note: type: verbatim
en:  if (EVP_PKEY_derive(ctx, skey, &skeylen) <= 0)
    	/* Error */
fr:  if (EVP_PKEY_derive(ctx, skey, &skeylen) <= 0)
    	/* Erreur */

note: type: verbatim
en:  /* Shared secret is skey bytes written to buffer skey */
fr:  /* Le secret partagé est skey octets écrits dans le tampon skey */

note: type: textblock
en: L<EVP_PKEY_CTX_new(3)|EVP_PKEY_CTX_new(3)>, L<EVP_PKEY_encrypt(3)|EVP_PKEY_encrypt(3)>, L<EVP_PKEY_decrypt(3)|EVP_PKEY_decrypt(3)>, L<EVP_PKEY_sign(3)|EVP_PKEY_sign(3)>, L<EVP_PKEY_verify(3)|EVP_PKEY_verify(3)>, L<EVP_PKEY_verify_recover(3)|EVP_PKEY_verify_recover(3)>,
fr: L<B<EVP_PKEY_CTX_new>(3)|EVP_PKEY_CTX_new(3)>, L<B<EVP_PKEY_encrypt>(3)|EVP_PKEY_encrypt(3)>, L<B<EVP_PKEY_decrypt>(3)|EVP_PKEY_decrypt(3)>, L<B<EVP_PKEY_sign>(3)|EVP_PKEY_sign(3)>, L<B<EVP_PKEY_verify>(3)|EVP_PKEY_verify(3)>, L<B<EVP_PKEY_verify_recover>(3)|EVP_PKEY_verify_recover(3)>

note: type: textblock
en: EVP_PKEY_encrypt_init, EVP_PKEY_encrypt - encrypt using a public key algorithm
fr: EVP_PKEY_encrypt_init, EVP_PKEY_encrypt - Chiffrer en utilisant un algorithme à clef publique

note: type: verbatim
en:  int EVP_PKEY_encrypt_init(EVP_PKEY_CTX *ctx);
     int EVP_PKEY_encrypt(EVP_PKEY_CTX *ctx,
    			unsigned char *out, size_t *outlen,
    			const unsigned char *in, size_t inlen);
fr: B< int EVP_PKEY_encrypt_init(EVP_PKEY_CTX *>I<ctx>B<);>
     B<int EVP_PKEY_encrypt(EVP_PKEY_CTX *>I<ctx>B<,>
     			B<unsigned char *>I<out>B<, size_t *>I<outlen>B<,>
     			B<const unsigned char *>I<in>B<, size_t> I<inlen>B<);>

note: type: textblock
en: The EVP_PKEY_encrypt_init() function initializes a public key algorithm context using key B<pkey> for an encryption operation.
fr: La fonction B<EVP_PKEY_encrypt_init>() initialise un contexte d'algorithme à clef publique en utilisant I<pkey> pour une opération de chiffrement.

note: type: textblock
en: The EVP_PKEY_encrypt() function performs a public key encryption operation using B<ctx>. The data to be encrypted is specified using the B<in> and B<inlen> parameters. If B<out> is B<NULL> then the maximum size of the output buffer is written to the B<outlen> parameter. If B<out> is not B<NULL> then before the call the B<outlen> parameter should contain the length of the B<out> buffer, if the call is successful the encrypted data is written to B<out> and the amount of data written to B<outlen>.
fr: La fonction B<EVP_PKEY_encrypt>() réalise une opération de chiffrement à clef publique en utilisant I<ctx>. Les données à chiffrer sont indiquées en utilisant les paramètres I<in> et I<inlen>. Si I<out> est NULL, alors la taille maximale du tampon de sortie est écrite dans le paramètre I<outlen>. Si I<out> n'est pas NULL, alors, avant l'appel, le paramètre I<outlen> devrait contenir la taille du tampon I<out> ; si l'appel réussit, les données chiffrées sont écrites dans I<out> et la quantité de données écrites dans I<outlen>.

note: type: textblock
en: After the call to EVP_PKEY_encrypt_init() algorithm specific control operations can be performed to set any appropriate parameters for the operation.
fr: Après l'appel de B<EVP_PKEY_encrypt_init>(), des opérations de contrôle spécifiques à l'algorithme peuvent être réalisées pour définir n'importe quels paramètres appropriés à l'opération.

note: type: textblock
en: The function EVP_PKEY_encrypt() can be called more than once on the same context if several operations are performed using the same parameters.
fr: La fonction B<EVP_PKEY_encrypt>() peut être appelée plus d'une fois sur le même contexte si plusieurs opérations sont réalisées en utilisant les mêmes paramètres.

note: type: textblock
en: EVP_PKEY_encrypt_init() and EVP_PKEY_encrypt() return 1 for success and 0 or a negative value for failure. In particular a return value of -2 indicates the operation is not supported by the public key algorithm.
fr: B<EVP_PKEY_encrypt_init>() et B<EVP_PKEY_encrypt>() renvoient B<1> en cas de réussite et B<0> ou une valeur négative en cas d'échec. En particulier, une valeur de retour de B<-2> indique que l'opération n'est pas permise par l'algorithme à clef publique.

note: type: textblock
en: Encrypt data using OAEP (for RSA keys). See also L<PEM_read_PUBKEY(3)|pem(3)> or L<d2i_X509(3)|d2i_X509(3)> for means to load a public key. You may also simply set 'eng = NULL;' to start with the default OpenSSL RSA implementation:
fr: Chiffrer des données en utilisant OAEP (pour les clefs RSA). Consultez également L<B<PEM_read_PUBKEY>(3)|pem(3)> ou L<B<d2i_X509>(3)|d2i_X509(3)> pour différents moyens de charger une clef publique. Simplement définir « eng = NULL; » permet aussi de commencer avec l’implémentation RSA d’OpenSSL par défaut :

note: type: verbatim
en:  EVP_PKEY_CTX *ctx;
     ENGINE *eng;
     unsigned char *out, *in;
     size_t outlen, inlen; 
     EVP_PKEY *key;
     /* NB: assumes eng, key, in, inlen are already set up,
      * and that key is an RSA public key
      */
     ctx = EVP_PKEY_CTX_new(key,eng);
     if (!ctx)
    	/* Error occurred */
     if (EVP_PKEY_encrypt_init(ctx) <= 0)
    	/* Error */
     if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_OAEP_PADDING) <= 0)
    	/* Error */
fr:  EVP_PKEY_CTX *ctx;
     ENGINE *eng;
     unsigned char *out, *in;
     size_t outlen, inlen; 
     EVP_PKEY *key;
     /* Remarque : eng, key, in et inlen sont supposées
      * déjà définies, avec key une clef publique RSA
      */
     ctx = EVP_PKEY_CTX_new(key,eng);
     if (!ctx)
    	/* Une erreur est survenue */
     if (EVP_PKEY_encrypt_init(ctx) <= 0)
    	/* Erreur */
     if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_OAEP_PADDING) <= 0)
    	/* Erreur */

note: type: verbatim
en:  /* Determine buffer length */
     if (EVP_PKEY_encrypt(ctx, NULL, &outlen, in, inlen) <= 0)
    	/* Error */
fr:  /* Déterminer la taille du tampon */
     if (EVP_PKEY_encrypt(ctx, NULL, &outlen, in, inlen) <= 0)
    	/* Error */

note: type: verbatim
en:  if (EVP_PKEY_encrypt(ctx, out, &outlen, in, inlen) <= 0)
    	/* Error */
fr:  if (EVP_PKEY_encrypt(ctx, out, &outlen, in, inlen) <= 0)
    	/* Erreur */

note: type: verbatim
en:  /* Encrypted data is outlen bytes written to buffer out */
fr:  /* Les données chiffrées sont outlen octets écrits dans le tampon out */

note: type: textblock
en: L<d2i_X509(3)|d2i_X509(3)>, L<engine(3)|engine(3)>, L<EVP_PKEY_CTX_new(3)|EVP_PKEY_CTX_new(3)>, L<EVP_PKEY_decrypt(3)|EVP_PKEY_decrypt(3)>, L<EVP_PKEY_sign(3)|EVP_PKEY_sign(3)>, L<EVP_PKEY_verify(3)|EVP_PKEY_verify(3)>, L<EVP_PKEY_verify_recover(3)|EVP_PKEY_verify_recover(3)>, L<EVP_PKEY_derive(3)|EVP_PKEY_derive(3)>
fr: L<B<d2i_X509>(3)|d2i_X509(3)>, L<B<engine>(3)|engine(3)>, L<B<EVP_PKEY_CTX_new>(3)|EVP_PKEY_CTX_new(3)>, L<B<EVP_PKEY_decrypt>(3)|EVP_PKEY_decrypt(3)>, L<B<EVP_PKEY_sign>(3)|EVP_PKEY_sign(3)>, L<B<EVP_PKEY_verify>(3)|EVP_PKEY_verify(3)>, L<B<EVP_PKEY_verify_recover>(3)|EVP_PKEY_verify_recover(3)>, L<B<EVP_PKEY_derive>(3)|EVP_PKEY_derive(3)>

note: type: textblock
en: EVP_PKEY_get_default_digest_nid - get default signature digest
fr: EVP_PKEY_get_default_digest_nid - Obtenir l'algorithme de signature par défaut

note: type: verbatim
en:  #include <openssl/evp.h>
     int EVP_PKEY_get_default_digest_nid(EVP_PKEY *pkey, int *pnid);
fr: B< #include E<lt>openssl/evp.hE<gt>>
     B<int EVP_PKEY_get_default_digest_nid(EVP_PKEY *>I<pkey>B<, int *>I<pnid>B<);>

note: type: textblock
en: The EVP_PKEY_get_default_digest_nid() function sets B<pnid> to the default message digest NID for the public key signature operations associated with key B<pkey>.
fr: La fonction B<EVP_PKEY_get_default_digest_nid>() définit I<pnid> au NID d'algorithme de message par défaut pour les opérations de signature à clef publique associées à la clef I<pkey>.

note: type: textblock
en: For all current standard OpenSSL public key algorithms SHA1 is returned.
fr: SHA1 est renvoyé pour tous les algorithmes standards actuels à clef publique OpenSSL.

note: type: textblock
en: The EVP_PKEY_get_default_digest_nid() function returns 1 if the message digest is advisory (that is other digests can be used) and 2 if it is mandatory (other digests can not be used).  It returns 0 or a negative value for failure. In particular a return value of -2 indicates the operation is not supported by the public key algorithm.
fr: La fonction B<EVP_PKEY_get_default_digest_nid>() renvoie B<1> si l'algorithme de message est conseillé (c'est-à-dire que d'autres algorithmes peuvent être utilisés) et B<2> s'il est obligatoire (aucun autre algorithme ne peut être utilisé). Elle renvoie B<0> ou une valeur négative en cas d'échec. En particulier, une valeur de retour B<-2> indique que l'opération n'est pas permise par l'algorithme à clef publique.

note: type: textblock
en: L<EVP_PKEY_CTX_new(3)|EVP_PKEY_CTX_new(3)>, L<EVP_PKEY_sign(3)|EVP_PKEY_sign(3)>, L<EVP_PKEY_verify(3)|EVP_PKEY_verify(3)>, L<EVP_PKEY_verify_recover(3)|EVP_PKEY_verify_recover(3)>,
fr: L<B<EVP_PKEY_CTX_new>(3)|EVP_PKEY_CTX_new(3)>, L<B<EVP_PKEY_sign>(3)|EVP_PKEY_sign(3)>, L<B<EVP_PKEY_verify>(3)|EVP_PKEY_verify(3)>, L<B<EVP_PKEY_verify_recover>(3)|EVP_PKEY_verify_recover(3)>,

note: type: textblock
en: This function was first added to OpenSSL 1.0.0.
fr: Cette fonction a été ajoutée pour la première fois dans OpenSSL 1.0.0.

note: type: textblock
en: EVP_PKEY_keygen_init, EVP_PKEY_keygen, EVP_PKEY_paramgen_init, EVP_PKEY_paramgen, EVP_PKEY_CTX_set_cb, EVP_PKEY_CTX_get_cb, EVP_PKEY_CTX_get_keygen_info, EVP_PKEVP_PKEY_CTX_set_app_data, EVP_PKEY_CTX_get_app_data - key and parameter generation functions
fr: EVP_PKEY_keygen_init, EVP_PKEY_keygen, EVP_PKEY_paramgen_init, EVP_PKEY_paramgen, EVP_PKEY_CTX_set_cb, EVP_PKEY_CTX_get_cb, EVP_PKEY_CTX_get_keygen_info, EVP_PKEVP_PKEY_CTX_set_app_data, EVP_PKEY_CTX_get_app_data - Fonctions de création de clefs et paramètres

note: type: verbatim
en:  int EVP_PKEY_keygen_init(EVP_PKEY_CTX *ctx);
     int EVP_PKEY_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey);
     int EVP_PKEY_paramgen_init(EVP_PKEY_CTX *ctx);
     int EVP_PKEY_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey);
fr: B< int EVP_PKEY_keygen_init(EVP_PKEY_CTX *>I<ctx>B<);>
     B<int EVP_PKEY_keygen(EVP_PKEY_CTX *>I<ctx>B<, EVP_PKEY **>I<ppkey>B<);>
     B<int EVP_PKEY_paramgen_init(EVP_PKEY_CTX *>I<ctx>B<);>
     B<int EVP_PKEY_paramgen(EVP_PKEY_CTX *>I<ctx>B<, EVP_PKEY **>I<ppkey>B<);>

note: type: verbatim
en:  typedef int EVP_PKEY_gen_cb(EVP_PKEY_CTX *ctx);
fr: B< typedef int EVP_PKEY_gen_cb(EVP_PKEY_CTX *>I<ctx>B<);>

note: type: verbatim
en:  void EVP_PKEY_CTX_set_cb(EVP_PKEY_CTX *ctx, EVP_PKEY_gen_cb *cb);
     EVP_PKEY_gen_cb *EVP_PKEY_CTX_get_cb(EVP_PKEY_CTX *ctx);
fr: B< void EVP_PKEY_CTX_set_cb(EVP_PKEY_CTX *>I<ctx>B<, EVP_PKEY_gen_cb *>I<cb>B<);>
     B<EVP_PKEY_gen_cb *EVP_PKEY_CTX_get_cb(EVP_PKEY_CTX *>I<ctx>B<);>

note: type: verbatim
en:  int EVP_PKEY_CTX_get_keygen_info(EVP_PKEY_CTX *ctx, int idx);
fr: B< int EVP_PKEY_CTX_get_keygen_info(EVP_PKEY_CTX *>I<ctx>B<, int> I<idx>B<);>

note: type: verbatim
en:  void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data);
     void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx);
fr: B< void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *>I<ctx>B<, void *>I<data>B<);>
     B<void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *>I<ctx>B<);>

note: type: textblock
en: The EVP_PKEY_keygen_init() function initializes a public key algorithm context using key B<pkey> for a key genration operation.
fr: La fonction B<EVP_PKEY_keygen_init>() initialise un contexte d'algorithme à clef publique en utilisant I<pkey> pour une opération de création de clef.

note: type: textblock
en: The EVP_PKEY_keygen() function performs a key generation operation, the generated key is written to B<ppkey>.
fr: La fonction B<EVP_PKEY_keygen>() réalise une opération de création de clef, la clef crée est écrite dans I<ppkey>.

note: type: textblock
en: The functions EVP_PKEY_paramgen_init() and EVP_PKEY_paramgen() are similar except parameters are generated.
fr: Les fonctions B<EVP_PKEY_paramgen_init>() et B<EVP_PKEY_paramgen>() sont similaires à part que les paramètres sont créés.

note: type: textblock
en: The function EVP_PKEY_set_cb() sets the key or parameter generation callback to B<cb>. The function EVP_PKEY_CTX_get_cb() returns the key or parameter generation callback.
fr: La fonction B<EVP_PKEY_set_cb>() définit le rappel de génération de clefs ou paramètres à I<cb>. La fonction B<EVP_PKEY_CTX_get_cb>() renvoie le rappel de génération de clefs ou paramètres.

note: type: textblock
en: The function EVP_PKEY_CTX_get_keygen_info() returns parameters associated with the generation operation. If B<idx> is -1 the total number of parameters available is returned. Any non negative value returns the value of that parameter. EVP_PKEY_CTX_gen_keygen_info() with a non-negative value for B<idx> should only be called within the generation callback.
fr: La fonction B<EVP_PKEY_CTX_get_keygen_info>() renvoie les paramètres associés à l'opération de création. Si I<idx> est B<-1>, le nombre total de paramètres disponibles est renvoyé. N'importe quelle valeur non négative renvoie la valeur de ce paramètre. B<EVP_PKEY_CTX_gen_keygen_info>() avec une valeur non négative pour I<idx> ne devrait être appelée que depuis le rappel de création.

note: type: textblock
en: If the callback returns 0 then the key genration operation is aborted and an error occurs. This might occur during a time consuming operation where a user clicks on a "cancel" button.
fr: Si le rappel renvoie B<0>, alors l'opération de création de clef est abandonnée et une erreur survient. Cela pourrait arriver pendant une opération particulièrement longue où un utilisateur clique sur un bouton « annuler ».

note: type: textblock
en: The functions EVP_PKEY_CTX_set_app_data() and EVP_PKEY_CTX_get_app_data() set and retrieve an opaque pointer. This can be used to set some application defined value which can be retrieved in the callback: for example a handle which is used to update a "progress dialog".
fr: Les fonctions B<EVP_PKEY_CTX_set_app_data>() et B<EVP_PKEY_CTX_get_app_data>() définissent et récupèrent un pointeur opaque. Cela peut être utilisé pour définir certaines valeurs d'application qui peuvent être récupérées dans le rappel : par exemple un traitement qui est utilisé pour mettre à jour une « boîte de dialogue de progression ».

note: type: textblock
en: After the call to EVP_PKEY_keygen_init() or EVP_PKEY_paramgen_init() algorithm specific control operations can be performed to set any appropriate parameters for the operation.
fr: Après l'appel de B<EVP_PKEY_keygen_init>() ou B<EVP_PKEY_paramgen_init>(), des opérations de contrôle spécifiques à l'algorithme peuvent être réalisées pour définir n'importe quels paramètres appropriés à l'opération.

note: type: textblock
en: The functions EVP_PKEY_keygen() and EVP_PKEY_paramgen() can be called more than once on the same context if several operations are performed using the same parameters.
fr: Les fonctions B<EVP_PKEY_keygen>() et B<EVP_PKEY_paramgen>() peuvent être appelées plus d'une fois sur le même contexte si plusieurs opérations sont réalisées en utilisant les mêmes paramètres.

note: type: textblock
en: The meaning of the parameters passed to the callback will depend on the algorithm and the specifiic implementation of the algorithm. Some might not give any useful information at all during key or parameter generation. Others might not even call the callback.
fr: La signification des paramètres passés au rappel dépendra de l'algorithme et de l'implémentation spécifique à l'algorithme. Certains pourraient ne donner absolument aucun renseignement utile lors de la création de clefs ou paramètres. Certains pourraient ne même pas appeler le rappel.

note: type: textblock
en: The operation performed by key or parameter generation depends on the algorithm used. In some cases (e.g. EC with a supplied named curve) the "generation" option merely sets the appropriate fields in an EVP_PKEY structure.
fr: L'opération réalisée par la création de clefs ou paramètres dépend de l'algorithme utilisé. Dans certains cas (par exemple EC avec une courbe nommée fournie), l'option « création » définit principalement les champs appropriés dans une structure EVP_PKEY.

note: type: textblock
en: In OpenSSL an EVP_PKEY structure containing a private key also contains the public key components and parameters (if any). An OpenSSL private key is equivalent to what some libraries call a "key pair". A private key can be used in functions which require the use of a public key or parameters.
fr: Dans OpenSSL, une structure EVP_PKEY contenant une clef privée contient aussi les composants et paramètres (s'il y en a) de clef publique. Une clef privée OpenSSL est équivalente à ce que certaines bibliothèques appellent une « paire de clefs ». Une clef privée peut être utilisée dans des fonctions qui nécessitent l'utilisation d'une clef publique ou de paramètres.

note: type: textblock
en: EVP_PKEY_keygen_init(), EVP_PKEY_paramgen_init(), EVP_PKEY_keygen() and EVP_PKEY_paramgen() return 1 for success and 0 or a negative value for failure.  In particular a return value of -2 indicates the operation is not supported by the public key algorithm.
fr: B<EVP_PKEY_keygen_init>(), B<EVP_PKEY_paramgen_init>(), B<EVP_PKEY_keygen>() et B<EVP_PKEY_paramgen>() renvoient B<1> en cas de réussite et B<0> ou une valeur négative en cas d'échec. En particulier, une valeur de retour de B<-2> indique que l'opération n'est pas permise par l'algorithme à clef publique.

note: type: textblock
en: Generate a 2048 bit RSA key:
fr: Créer une clef RSA de 2048 bits :

note: type: verbatim
en:  EVP_PKEY_CTX *ctx;
     EVP_PKEY *pkey = NULL;
     ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL);
     if (!ctx)
    	/* Error occurred */
     if (EVP_PKEY_keygen_init(ctx) <= 0)
    	/* Error */
     if (EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, 2048) <= 0)
    	/* Error */
fr:  EVP_PKEY_CTX *ctx;
     EVP_PKEY *pkey = NULL;
     ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL);
     if (!ctx)
    	/* Une erreur est survenue */
     if (EVP_PKEY_keygen_init(ctx) <= 0)
    	/* Erreur */
     if (EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, 2048) <= 0)
    	/* Erreur */

note: type: verbatim
en:  /* Generate key */
     if (EVP_PKEY_keygen(ctx, &pkey) <= 0)
    	/* Error */
fr:  /* Créer une clef */
     if (EVP_PKEY_keygen(ctx, &pkey) <= 0)
    	/* Erreur */

note: type: textblock
en: Generate a key from a set of parameters:
fr: Créer une clef à partir d'un ensemble de paramètres :

note: type: verbatim
en:  EVP_PKEY_CTX *ctx;
     EVP_PKEY *pkey = NULL, *param;
     /* Assumed param is set up already */
     ctx = EVP_PKEY_CTX_new(param);
     if (!ctx)
    	/* Error occurred */
     if (EVP_PKEY_keygen_init(ctx) <= 0)
    	/* Error */
fr:  EVP_PKEY_CTX *ctx;
     EVP_PKEY *pkey = NULL, *param;
     /* param est supposé déjà défini */
     ctx = EVP_PKEY_CTX_new(param);
     if (!ctx)
    	/* Une erreur est survenue */
     if (EVP_PKEY_keygen_init(ctx) <= 0)
    	/* Erreur */

note: type: textblock
en: Example of generation callback for OpenSSL public key implementations:
fr: Exemple de rappel de création pour les implémentations à clef publique OpenSSL :

note: type: verbatim
en:  /* Application data is a BIO to output status to */
fr:  /* Les données d'application sont un BIO pour y afficher l'état */

note: type: textblock
en: L<EVP_PKEY_CTX_new(3)|EVP_PKEY_CTX_new(3)>, L<EVP_PKEY_encrypt(3)|EVP_PKEY_encrypt(3)>, L<EVP_PKEY_decrypt(3)|EVP_PKEY_decrypt(3)>, L<EVP_PKEY_sign(3)|EVP_PKEY_sign(3)>, L<EVP_PKEY_verify(3)|EVP_PKEY_verify(3)>, L<EVP_PKEY_verify_recover(3)|EVP_PKEY_verify_recover(3)>, L<EVP_PKEY_derive(3)|EVP_PKEY_derive(3)>
fr: L<B<EVP_PKEY_CTX_new>(3)|EVP_PKEY_CTX_new(3)>, L<B<EVP_PKEY_encrypt>(3)|EVP_PKEY_encrypt(3)>, L<B<EVP_PKEY_decrypt>(3)|EVP_PKEY_decrypt(3)>, L<B<EVP_PKEY_sign>(3)|EVP_PKEY_sign(3)>, L<B<EVP_PKEY_verify>(3)|EVP_PKEY_verify(3)>, L<B<EVP_PKEY_verify_recover>(3)|EVP_PKEY_verify_recover(3)>, L<B<EVP_PKEY_derive>(3)|EVP_PKEY_derive(3)>

note: type: textblock
en: EVP_PKEY_new, EVP_PKEY_free - private key allocation functions.
fr: EVP_PKEY_new, EVP_PKEY_free - Fonctions d'allocation de clef privée

note: type: verbatim
en:  EVP_PKEY *EVP_PKEY_new(void);
     void EVP_PKEY_free(EVP_PKEY *key);
fr: B< EVP_PKEY *EVP_PKEY_new(void);>
     B<void EVP_PKEY_free(EVP_PKEY *>I<key>B<);>

note: type: textblock
en: The EVP_PKEY_new() function allocates an empty B<EVP_PKEY> structure which is used by OpenSSL to store private keys.
fr: La fonction B<EVP_PKEY_new>() alloue une structure B<EVP_PKEY> vide qui est utilisée par OpenSSL pour stocker des clefs privées.

note: type: textblock
en: EVP_PKEY_free() frees up the private key B<key>.
fr: B<EVP_PKEY_free>() libère la clef privée I<key>.

note: type: textblock
en: The B<EVP_PKEY> structure is used by various OpenSSL functions which require a general private key without reference to any particular algorithm.
fr: La structure B<EVP_PKEY> est utilisée par plusieurs fonctions OpenSSL qui nécessitent une clef privée générale sans référence à aucun algorithme particulier.

note: type: textblock
en: The structure returned by EVP_PKEY_new() is empty. To add a private key to this empty structure the functions described in L<EVP_PKEY_set1_RSA(3)|EVP_PKEY_set1_RSA(3)> should be used.
fr: La structure renvoyée par B<EVP_PKEY_new>() est vide. Pour ajouter une clef privée à cette structure vide, les fonctions décrites dans L<EVP_PKEY_set1_RSA(3)|EVP_PKEY_set1_RSA(3)> devraient être utilisées.

note: type: textblock
en: EVP_PKEY_new() returns either the newly allocated B<EVP_PKEY> structure of B<NULL> if an error occurred.
fr: B<EVP_PKEY_new>() renvoie la structure B<EVP_PKEY> nouvellement allouée ou NULL si une erreur s'est produite.

note: type: textblock
en: EVP_PKEY_free() does not return a value.
fr: B<EVP_PKEY_free>() ne renvoie aucune valeur.

note: type: textblock
en: L<EVP_PKEY_set1_RSA(3)|EVP_PKEY_set1_RSA(3)>
fr: L<B<EVP_PKEY_set1_RSA>(3)|EVP_PKEY_set1_RSA(3)>

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

note: type: textblock
en: EVP_PKEY_print_public, EVP_PKEY_print_private, EVP_PKEY_print_params - public key algorithm printing routines.
fr: EVP_PKEY_print_public, EVP_PKEY_print_private, EVP_PKEY_print_params - Routines d'affichage d'algorithme à clef publique

note: type: verbatim
en:  int EVP_PKEY_print_public(BIO *out, const EVP_PKEY *pkey,
    				int indent, ASN1_PCTX *pctx);
     int EVP_PKEY_print_private(BIO *out, const EVP_PKEY *pkey,
    				int indent, ASN1_PCTX *pctx);
     int EVP_PKEY_print_params(BIO *out, const EVP_PKEY *pkey,
    				int indent, ASN1_PCTX *pctx);
fr: B< int EVP_PKEY_print_public(BIO *>I<out>B<, const EVP_PKEY *>I<pkey>B<,>
     				B<int indent, ASN1_PCTX *>I<pctx>B<);>
     B<int EVP_PKEY_print_private(BIO *>I<out>B<, const EVP_PKEY *>I<pkey>B<,>
     				B<int indent, ASN1_PCTX *>I<pctx>B<);>
     B<int EVP_PKEY_print_params(BIO *>I<out>B<, const EVP_PKEY *>I<pkey>B<,>
     				B<int indent, ASN1_PCTX *>I<pctx>B<);>

note: type: textblock
en: The functions EVP_PKEY_print_public(), EVP_PKEY_print_private() and EVP_PKEY_print_params() print out the public, private or parameter components of key B<pkey> respectively. The key is sent to BIO B<out> in human readable form. The parameter B<indent> indicated how far the printout should be indented.
fr: Les fonctions B<EVP_PKEY_print_public>(), B<EVP_PKEY_print_private>() et B<EVP_PKEY_print_params>() affichent respectivement les composants publics, privés ou de paramètres de la clef I<pkey>. La clef est envoyée au BIO I<out> dans un format lisible. Le paramètre I<indent> indique la taille d'indentation de l'affichage.

note: type: textblock
en: The B<pctx> parameter allows the print output to be finely tuned by using ASN1 printing options. If B<pctx> is set to NULL then default values will be used.
fr: Le paramètre I<pctx> permet de personnaliser précisément l'affichage en utilisant les options d'affichage ASN1. Si I<pctx> est définit à NULL, alors les valeurs par défaut seront utilisées.

note: type: textblock
en: Currently no public key algorithms include any options in the B<pctx> parameter parameter.
fr: Aucun algorithme à clef publique n'inclut actuellement d'option dans le paramètre I<pctx>.

note: type: textblock
en: If the key does not include all the components indicated by the function then only those contained in the key will be printed. For example passing a public key to EVP_PKEY_print_private() will only print the public components.
fr: Si la clef n'inclut pas tous les composants indiqués par la fonction, alors seuls ceux contenus dans la clef seront affichés. Par exemple passer une clef publique à B<EVP_PKEY_print_private>() n'affichera que les composants publics.

note: type: textblock
en: These functions all return 1 for success and 0 or a negative value for failure.  In particular a return value of -2 indicates the operation is not supported by the public key algorithm.
fr: Ces fonctions renvoient toutes B<1> en cas de réussite et B<0> ou une valeur négative en cas d'échec. En particulier, une valeur de retour de B<-2> indique que l'opération n'est pas permise par l'algorithme à clef publique.

note: type: textblock
en: EVP_PKEY_set1_RSA, EVP_PKEY_set1_DSA, EVP_PKEY_set1_DH, EVP_PKEY_set1_EC_KEY, EVP_PKEY_get1_RSA, EVP_PKEY_get1_DSA, EVP_PKEY_get1_DH, EVP_PKEY_get1_EC_KEY, EVP_PKEY_assign_RSA, EVP_PKEY_assign_DSA, EVP_PKEY_assign_DH, EVP_PKEY_assign_EC_KEY, EVP_PKEY_type - EVP_PKEY assignment functions.
fr: EVP_PKEY_set1_RSA, EVP_PKEY_set1_DSA, EVP_PKEY_set1_DH, EVP_PKEY_set1_EC_KEY, EVP_PKEY_get1_RSA, EVP_PKEY_get1_DSA, EVP_PKEY_get1_DH, EVP_PKEY_get1_EC_KEY, EVP_PKEY_assign_RSA, EVP_PKEY_assign_DSA, EVP_PKEY_assign_DH, EVP_PKEY_assign_EC_KEY, EVP_PKEY_type - Fonctions d’assignation EVP_PKEY

note: type: verbatim
en:  int EVP_PKEY_set1_RSA(EVP_PKEY *pkey,RSA *key);
     int EVP_PKEY_set1_DSA(EVP_PKEY *pkey,DSA *key);
     int EVP_PKEY_set1_DH(EVP_PKEY *pkey,DH *key);
     int EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey,EC_KEY *key);
fr: B< int EVP_PKEY_set1_RSA(EVP_PKEY *>I<pkey>B<,RSA *>I<key>B<);>
     B<int EVP_PKEY_set1_DSA(EVP_PKEY *>I<pkey>B<,DSA *>I<key>B<);>
     B<int EVP_PKEY_set1_DH(EVP_PKEY *>I<pkey>B<,DH *>I<key>B<);>
     B<int EVP_PKEY_set1_EC_KEY(EVP_PKEY *>I<pkey>B<,EC_KEY *>I<key>B<);>

note: type: verbatim
en:  RSA *EVP_PKEY_get1_RSA(EVP_PKEY *pkey);
     DSA *EVP_PKEY_get1_DSA(EVP_PKEY *pkey);
     DH *EVP_PKEY_get1_DH(EVP_PKEY *pkey);
     EC_KEY *EVP_PKEY_get1_EC_KEY(EVP_PKEY *pkey);
fr: B< RSA *EVP_PKEY_get1_RSA(EVP_PKEY *>I<pkey>B<);>
     B<DSA *EVP_PKEY_get1_DSA(EVP_PKEY *>I<pkey>B<);>
     B<DH *EVP_PKEY_get1_DH(EVP_PKEY *>I<pkey>B<);>
     B<EC_KEY *EVP_PKEY_get1_EC_KEY(EVP_PKEY *>I<pkey>B<);>

note: type: verbatim
en:  int EVP_PKEY_assign_RSA(EVP_PKEY *pkey,RSA *key);
     int EVP_PKEY_assign_DSA(EVP_PKEY *pkey,DSA *key);
     int EVP_PKEY_assign_DH(EVP_PKEY *pkey,DH *key);
     int EVP_PKEY_assign_EC_KEY(EVP_PKEY *pkey,EC_KEY *key);
fr: B< int EVP_PKEY_assign_RSA(EVP_PKEY *>I<pkey>B<,RSA *>I<key>B<);>
     B<int EVP_PKEY_assign_DSA(EVP_PKEY *>I<pkey>B<,DSA *>I<key>B<);>
     B<int EVP_PKEY_assign_DH(EVP_PKEY *>I<pkey>,B<DH *>I<key>B<);>
     B<int EVP_PKEY_assign_EC_KEY(EVP_PKEY *>I<pkey>B<,EC_KEY *>I<key>B<);>

note: type: verbatim
en:  int EVP_PKEY_type(int type);
fr: B< int EVP_PKEY_type(int> I<type>B<);>

note: type: textblock
en: EVP_PKEY_set1_RSA(), EVP_PKEY_set1_DSA(), EVP_PKEY_set1_DH() and EVP_PKEY_set1_EC_KEY() set the key referenced by B<pkey> to B<key>.
fr: B<EVP_PKEY_set1_RSA>(), B<EVP_PKEY_set1_DSA>(), B<EVP_PKEY_set1_DH>() et B<EVP_PKEY_set1_EC_KEY>() définissent la clef référencée par I<pkey> à I<key>.

note: type: textblock
en: EVP_PKEY_get1_RSA(), EVP_PKEY_get1_DSA(), EVP_PKEY_get1_DH() and EVP_PKEY_get1_EC_KEY() return the referenced key in B<pkey> or B<NULL> if the key is not of the correct type.
fr: B<EVP_PKEY_get1_RSA>(), B<EVP_PKEY_get1_DSA>(), B<EVP_PKEY_get1_DH>() et B<EVP_PKEY_get1_EC_KEY>() renvoient la clef référencée par I<pkey> ou NULL si la clef n’est pas du type adéquat.

note: type: textblock
en: EVP_PKEY_assign_RSA(), EVP_PKEY_assign_DSA(), EVP_PKEY_assign_DH()  and EVP_PKEY_assign_EC_KEY() also set the referenced key to B<key> however these use the supplied B<key> internally and so B<key> will be freed when the parent B<pkey> is freed.
fr: B<EVP_PKEY_assign_RSA>(), B<EVP_PKEY_assign_DSA>(), B<EVP_PKEY_assign_DH>() et B<EVP_PKEY_assign_EC_KEY>() définissent aussi la clef référencée à I<key>, cependant, elles utilisent I<key> fournie en interne et donc I<key> sera libérée quand la I<pkey> mère est libérée.

note: type: textblock
en: EVP_PKEY_type() returns the type of key corresponding to the value B<type>. The type of a key can be obtained with EVP_PKEY_type(pkey->type). The return value will be EVP_PKEY_RSA, EVP_PKEY_DSA, EVP_PKEY_DH or EVP_PKEY_EC for the corresponding key types or NID_undef if the key type is unassigned.
fr: B<EVP_PKEY_type>() renvoie le type de clef correspondant à la valeur I<type>. Le type d’une clef peut être obtenu avec B<EVP_PKEY_type(pkey-E<gt>type)>. La valeur renvoyée sera B<EVP_PKEY_RSA>, B<EVP_PKEY_DSA>, B<EVP_PKEY_DH> ou B<EVP_PKEY_EC> pour les types de clef correspondants ou B<NID_undef> si le type de clef n’est pas assigné.

note: type: textblock
en: In accordance with the OpenSSL naming convention the key obtained from or assigned to the B<pkey> using the B<1> functions must be freed as well as B<pkey>.
fr: En accord avec la convention de nommage d’OpenSSL, la clef obtenue de – ou assignée à – la I<pkey> en utilisant les fonctions B<1> doit être libérée comme I<pkey>.

note: type: textblock
en: EVP_PKEY_assign_RSA(), EVP_PKEY_assign_DSA(), EVP_PKEY_assign_DH()  and EVP_PKEY_assign_EC_KEY() are implemented as macros.
fr: B<EVP_PKEY_assign_RSA>(), B<EVP_PKEY_assign_DSA>(), B<EVP_PKEY_assign_DH>() et B<EVP_PKEY_assign_EC_KEY>() sont implémentées comme des macros.

note: type: textblock
en: EVP_PKEY_set1_RSA(), EVP_PKEY_set1_DSA(), EVP_PKEY_set1_DH() and EVP_PKEY_set1_EC_KEY() return 1 for success or 0 for failure.
fr: B<EVP_PKEY_set1_RSA>(), B<EVP_PKEY_set1_DSA>(), B<EVP_PKEY_set1_DH>() et B<EVP_PKEY_set1_EC_KEY>() renvoient B<1> en cas de réussite ou B<0> en cas d’échec.

note: type: textblock
en: EVP_PKEY_get1_RSA(), EVP_PKEY_get1_DSA(), EVP_PKEY_get1_DH() and EVP_PKEY_get1_EC_KEY() return the referenced key or B<NULL> if an error occurred.
fr: B<EVP_PKEY_get1_RSA>(), B<EVP_PKEY_get1_DSA>(), B<EVP_PKEY_get1_DH>() et B<EVP_PKEY_get1_EC_KEY>() renvoient la clef référencée ou NULL si une erreur survient.

note: type: textblock
en: EVP_PKEY_assign_RSA(), EVP_PKEY_assign_DSA(), EVP_PKEY_assign_DH()  and EVP_PKEY_assign_EC_KEY() return 1 for success and 0 for failure.
fr: B<EVP_PKEY_assign_RSA>(), B<EVP_PKEY_assign_DSA>(), B<EVP_PKEY_assign_DH>() et B<EVP_PKEY_assign_EC_KEY>() renvoient B<1> en cas de réussite ou B<0> en cas d’échec.

note: type: textblock
en: EVP_PKEY_sign_init, EVP_PKEY_sign - sign using a public key algorithm
fr: EVP_PKEY_sign_init, EVP_PKEY_sign - Signer en utilisant un algorithme à clef publique

note: type: verbatim
en:  int EVP_PKEY_sign_init(EVP_PKEY_CTX *ctx);
     int EVP_PKEY_sign(EVP_PKEY_CTX *ctx,
    			unsigned char *sig, size_t *siglen,
    			const unsigned char *tbs, size_t tbslen);
fr: B< int EVP_PKEY_sign_init(EVP_PKEY_CTX *>I<ctx>B<);>
     B<int EVP_PKEY_sign(EVP_PKEY_CTX *>I<ctx>B<,>
     			B<unsigned char *>I<sig>B<, size_t *>I<siglen>B<,>
     			B<const unsigned char *>I<tbs>B<, size_t> I<tbslen>B<);>

note: type: textblock
en: The EVP_PKEY_sign_init() function initializes a public key algorithm context using key B<pkey> for a signing operation.
fr: La fonction B<EVP_PKEY_sign_init>() initialise un contexte d'algorithme à clef publique en utilisant I<pkey> pour une opération de signature.

note: type: textblock
en: The EVP_PKEY_sign() function performs a public key signing operation using B<ctx>. The data to be signed is specified using the B<tbs> and B<tbslen> parameters. If B<sig> is B<NULL> then the maximum size of the output buffer is written to the B<siglen> parameter. If B<sig> is not B<NULL> then before the call the B<siglen> parameter should contain the length of the B<sig> buffer, if the call is successful the signature is written to B<sig> and the amount of data written to B<siglen>.
fr: La fonction B<EVP_PKEY_sign>() réalise une opération de signature à clef publique en utilisant I<ctx>. Les données à signer sont indiquées en utilisant les paramètres I<tbs> et I<tbslen>. Si I<sig> est NULL, alors la taille maximale du tampon de sortie est écrite dans le paramètre I<siglen>. Si I<sig> n'est pas NULL, alors, avant l'appel, le paramètre I<siglen> devrait contenir la taille du tampon I<sig> ; si l'appel réussit, la signature est écrite dans I<sig> et la quantité de données écrites dans I<siglen>.

note: type: textblock
en: EVP_PKEY_sign() does not hash the data to be signed, and therefore is normally used to sign digests. For signing arbitrary messages, see the L<EVP_DigestSignInit(3)|EVP_DigestSignInit(3)> and L<EVP_SignInit(3)|EVP_SignInit(3)> signing interfaces instead.
fr: B<EVP_PKEY_sign>() ne hache pas les données à signer, et par conséquent est normalement utilisé pour signer des condensés. Pour signer des messages arbitraires, consultez plutôt les interfaces de signature L<B<EVP_DigestSignInit>(3)|EVP_DigestSignInit(3)> et L<B<EVP_SignInit>(3)|EVP_SignInit(3)>.

note: type: textblock
en: After the call to EVP_PKEY_sign_init() algorithm specific control operations can be performed to set any appropriate parameters for the operation (see L<EVP_PKEY_CTX_ctrl(3)|EVP_PKEY_CTX_ctrl(3)>).
fr: Après l'appel de B<EVP_PKEY_sign_init>(), des opérations de contrôle spécifiques à l'algorithme peuvent être réalisées pour définir n'importe quels paramètres appropriés à l'opération (consultez L<B<EVP_PKEY_CTX_ctrl>(3)|EVP_PKEY_CTX_ctrl(3)>).

note: type: textblock
en: The function EVP_PKEY_sign() can be called more than once on the same context if several operations are performed using the same parameters.
fr: La fonction B<EVP_PKEY_sign>() peut être appelée plus d'une fois sur le même contexte si plusieurs opérations sont réalisées en utilisant les mêmes paramètres.

note: type: textblock
en: EVP_PKEY_sign_init() and EVP_PKEY_sign() return 1 for success and 0 or a negative value for failure. In particular a return value of -2 indicates the operation is not supported by the public key algorithm.
fr: B<EVP_PKEY_sign_init>() et B<EVP_PKEY_sign>() renvoient B<1> en cas de réussite et B<0> ou une valeur négative en cas d'échec. En particulier, une valeur de retour de B<-2> indique que l'opération n'est pas permise par l'algorithme à clef publique.

note: type: textblock
en: Sign data using RSA with PKCS#1 padding and SHA256 digest:
fr: Signer les données en utilisant RSA avec remplissage PKCS#1 et un algorithme de signature SHA256 :

note: type: verbatim
en:  EVP_PKEY_CTX *ctx;
     /* md is a SHA-256 digest in this example. */
     unsigned char *md, *sig;
     size_t mdlen = 32, siglen;
     EVP_PKEY *signing_key;
fr:  EVP_PKEY_CTX *ctx;
     /* md est un condensé SHA-256 dans cet exemple. */
     unsigned char *md, *sig;
     size_t mdlen = 32, siglen;
     EVP_PKEY *signing_key;

note: type: verbatim
en:  /*
      * NB: assumes signing_key and md are set up before the next
      * step. signing_key must be an RSA private key and md must
      * point to the SHA-256 digest to be signed.
      */
     ctx = EVP_PKEY_CTX_new(signing_key, NULL /* no engine */);
     if (!ctx)
    	/* Error occurred */
     if (EVP_PKEY_sign_init(ctx) <= 0)
    	/* Error */
     if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) <= 0)
    	/* Error */
     if (EVP_PKEY_CTX_set_signature_md(ctx, EVP_sha256()) <= 0)
    	/* Error */
fr:  /*
      * Remarque : signing_key et md sont supposées définies avant la
      * prochaine étape, signing_key doit être une clef privée RSA et
      * md doit pointer vers un condensé SHA-256 à signer.
      */
     ctx = EVP_PKEY_CTX_new(signing_key, NULL /* pas de moteur */);
     if (!ctx)
    	/* Une erreur est survenue */
     if (EVP_PKEY_sign_init(ctx) <= 0)
    	/* Erreur */
     if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) <= 0)
    	/* Erreur */
     if (EVP_PKEY_CTX_set_signature_md(ctx, EVP_sha256()) <= 0)
    	/* Erreur */

note: type: verbatim
en:  /* Determine buffer length */
     if (EVP_PKEY_sign(ctx, NULL, &siglen, md, mdlen) <= 0)
    	/* Error */
fr:  /* Déterminer la taille du tampon */
     if (EVP_PKEY_sign(ctx, NULL, &siglen, md, mdlen) <= 0)
    	/* Erreur */

note: type: verbatim
en:  if (!sig)
    	/* malloc failure */
fr:  if (!sig)
    	/* échec malloc */

note: type: verbatim
en:  if (EVP_PKEY_sign(ctx, sig, &siglen, md, mdlen) <= 0)
    	/* Error */
fr:  if (EVP_PKEY_sign(ctx, sig, &siglen, md, mdlen) <= 0)
    	/* Erreur */

note: type: verbatim
en:  /* Signature is siglen bytes written to buffer sig */
fr:  /* La signature est siglen octets écrits dans le tampon sig */

note: type: textblock
en: L<EVP_PKEY_CTX_new(3)|EVP_PKEY_CTX_new(3)>, L<EVP_PKEY_CTX_ctrl(3)|EVP_PKEY_CTX_ctrl(3)>, L<EVP_PKEY_encrypt(3)|EVP_PKEY_encrypt(3)>, L<EVP_PKEY_decrypt(3)|EVP_PKEY_decrypt(3)>, L<EVP_PKEY_verify(3)|EVP_PKEY_verify(3)>, L<EVP_PKEY_verify_recover(3)|EVP_PKEY_verify_recover(3)>, L<EVP_PKEY_derive(3)|EVP_PKEY_derive(3)>
fr: L<B<EVP_PKEY_CTX_new>(3)|EVP_PKEY_CTX_new(3)>, L<B<EVP_PKEY_CTX_ctrl>(3)|EVP_PKEY_CTX_ctrl(3)>, L<B<EVP_PKEY_encrypt>(3)|EVP_PKEY_encrypt(3)>, L<B<EVP_PKEY_decrypt>(3)|EVP_PKEY_decrypt(3)>, L<B<EVP_PKEY_sign>(3)|EVP_PKEY_sign(3)>, L<B<EVP_PKEY_verify>(3)|EVP_PKEY_verify(3)>, L<B<EVP_PKEY_verify_recover>(3)|EVP_PKEY_verify_recover(3)>, L<B<EVP_PKEY_derive>(3)|EVP_PKEY_derive(3)>

note: type: textblock
en: EVP_PKEY_verify_init, EVP_PKEY_verify - signature verification using a public key algorithm
fr: EVP_PKEY_verify_init, EVP_PKEY_verify - Vérification de signature en utilisant un algorithme à clef publique

note: type: verbatim
en:  int EVP_PKEY_verify_init(EVP_PKEY_CTX *ctx);
     int EVP_PKEY_verify(EVP_PKEY_CTX *ctx,
    			const unsigned char *sig, size_t siglen,
    			const unsigned char *tbs, size_t tbslen);
fr: B< int EVP_PKEY_verify_init(EVP_PKEY_CTX *>I<ctx>B<);>
     B<int EVP_PKEY_verify(EVP_PKEY_CTX *>I<ctx>B<,>
     			B<const unsigned char *>I<sig>B<, size_t> I<siglen>B<,>
     			B<const unsigned char *>I<tbs>B<, size_t> I<tbslen>B<);>

note: type: textblock
en: The EVP_PKEY_verify_init() function initializes a public key algorithm context using key B<pkey> for a signature verification operation.
fr: La fonction B<EVP_PKEY_verify_init>() initialise un contexte d'algorithme à clef publique en utilisant I<pkey> pour une opération de vérification de signature.

note: type: textblock
en: The EVP_PKEY_verify() function performs a public key verification operation using B<ctx>. The signature is specified using the B<sig> and B<siglen> parameters. The verified data (i.e. the data believed originally signed) is specified using the B<tbs> and B<tbslen> parameters.
fr: La fonction B<EVP_PKEY_verify>() réalise une opération de vérification de signature à clef publique en utilisant I<ctx>. La signature est indiquée en utilisant les paramètres I<sig> et I<siglen>. Les données vérifiées (c'est-à-dire les données censées être correctement signées) sont indiquées en utilisant les paramètres I<tbs> et I<tbslen>

note: type: textblock
en: After the call to EVP_PKEY_verify_init() algorithm specific control operations can be performed to set any appropriate parameters for the operation.
fr: Après l'appel de B<EVP_PKEY_verify_init>(), des opérations de contrôle spécifiques à l'algorithme peuvent être réalisées pour définir n'importe quels paramètres appropriés à l'opération.

note: type: textblock
en: The function EVP_PKEY_verify() can be called more than once on the same context if several operations are performed using the same parameters.
fr: La fonction B<EVP_PKEY_verify>() peut être appelée plus d'une fois sur le même contexte si plusieurs opérations sont réalisées en utilisant les mêmes paramètres.

note: type: textblock
en: EVP_PKEY_verify_init() and EVP_PKEY_verify() return 1 if the verification was successful and 0 if it failed. Unlike other functions the return value 0 from EVP_PKEY_verify() only indicates that the signature did not not verify successfully (that is tbs did not match the original data or the signature was of invalid form) it is not an indication of a more serious error.
fr: B<EVP_PKEY_verify_init>() et B<EVP_PKEY_verify>() renvoient B<1> si la vérification a réussi et B<0> en cas d'échec. Contrairement aux autres fonctions, la valeur de retour B<0> de B<EVP_PKEY_verify>() indique seulement que la signature n'a pas été vérifiée correctement (c'est-à-dire que I<tbs> ne correspondait pas aux données d'origine ou que la signature n'était pas de la forme adéquate), ce n'est pas une indication d'une erreur plus sérieuse.

note: type: textblock
en: A negative value indicates an error other that signature verification failure.  In particular a return value of -2 indicates the operation is not supported by the public key algorithm.
fr: Une valeur négative indique une autre erreur qu'un échec de vérification de signature. En particulier, une valeur de retour de B<-2> indique que l'opération n'est pas permise par l'algorithme à clef publique.

note: type: textblock
en: Verify signature using PKCS#1 and SHA256 digest:
fr: Vérifier une signature en utilisant PKCS#1 et un algorithme de signature SHA256 :

note: type: verbatim
en:  EVP_PKEY_CTX *ctx;
     unsigned char *md, *sig;
     size_t mdlen, siglen; 
     EVP_PKEY *verify_key;
     /* NB: assumes verify_key, sig, siglen md and mdlen are already set up
      * and that verify_key is an RSA public key
      */
     ctx = EVP_PKEY_CTX_new(verify_key);
     if (!ctx)
    	/* Error occurred */
     if (EVP_PKEY_verify_init(ctx) <= 0)
    	/* Error */
     if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) <= 0)
    	/* Error */
     if (EVP_PKEY_CTX_set_signature_md(ctx, EVP_sha256()) <= 0)
    	/* Error */
fr:  EVP_PKEY_CTX *ctx;
     unsigned char *md, *sig;
     size_t mdlen, siglen; 
     EVP_PKEY *verify_key;
     /* Remarque : verify_key, sig, siglen, md et mdlen sont supposées
      * déjà définies, avec verify_key une clef publique RSA
      */
     ctx = EVP_PKEY_CTX_new(verify_key);
     if (!ctx)
    	/* Une erreur est survenue */
     if (EVP_PKEY_verify_init(ctx) <= 0)
    	/* Erreur */
     if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) <= 0)
    	/* Erreur */
     if (EVP_PKEY_CTX_set_signature_md(ctx, EVP_sha256()) <= 0)
    	/* Erreur */

note: type: verbatim
en:  /* Perform operation */
     ret = EVP_PKEY_verify(ctx, sig, siglen, md, mdlen);
fr:  /* Réaliser l'opération */
     ret = EVP_PKEY_verify(ctx, sig, siglen, md, mdlen);

note: type: verbatim
en:  /* ret == 1 indicates success, 0 verify failure and < 0 for some
      * other error.
      */
fr:  /* ret == 1 indique une réussite, 0 une erreur de vérification
      * et < 0 un autre type d'erreur.
      */

note: type: textblock
en: L<EVP_PKEY_CTX_new(3)|EVP_PKEY_CTX_new(3)>, L<EVP_PKEY_encrypt(3)|EVP_PKEY_encrypt(3)>, L<EVP_PKEY_decrypt(3)|EVP_PKEY_decrypt(3)>, L<EVP_PKEY_sign(3)|EVP_PKEY_sign(3)>, L<EVP_PKEY_verify_recover(3)|EVP_PKEY_verify_recover(3)>, L<EVP_PKEY_derive(3)|EVP_PKEY_derive(3)>
fr: L<B<EVP_PKEY_CTX_new>(3)|EVP_PKEY_CTX_new(3)>, L<B<EVP_PKEY_encrypt>(3)|EVP_PKEY_encrypt(3)>, L<B<EVP_PKEY_decrypt>(3)|EVP_PKEY_decrypt(3)>, L<B<EVP_PKEY_sign>(3)|EVP_PKEY_sign(3)>, L<B<EVP_PKEY_verify_recover>(3)|EVP_PKEY_verify_recover(3)>, L<B<EVP_PKEY_derive>(3)|EVP_PKEY_derive(3)>

note: type: textblock
en: EVP_PKEY_verify_recover_init, EVP_PKEY_verify_recover - recover signature using a public key algorithm
fr: EVP_PKEY_verify_recover_init, EVP_PKEY_verify_recover - Récupérer une signature à l'aide d'un algorithme à clef publique

note: type: verbatim
en:  int EVP_PKEY_verify_recover_init(EVP_PKEY_CTX *ctx);
     int EVP_PKEY_verify_recover(EVP_PKEY_CTX *ctx,
    			unsigned char *rout, size_t *routlen,
    			const unsigned char *sig, size_t siglen);
fr: B< int EVP_PKEY_verify_recover_init(EVP_PKEY_CTX *>I<ctx>B<);>
     B<int EVP_PKEY_verify_recover(EVP_PKEY_CTX *>I<ctx>B<,>
     			B<unsigned char *>I<rout>B<, size_t *>I<routlen>B<,>
     			B<const unsigned char *>I<sig>B<, size_t> I<siglen>B<);>

note: type: textblock
en: The EVP_PKEY_verify_recover_init() function initializes a public key algorithm context using key B<pkey> for a verify recover operation.
fr: La fonction B<EVP_PKEY_verify_recover_init>() initialise un contexte d'algorithme à clef publique en utilisant la clef I<pkey> pour une opération de vérification et récupération.

note: type: textblock
en: The EVP_PKEY_verify_recover() function recovers signed data using B<ctx>. The signature is specified using the B<sig> and B<siglen> parameters. If B<rout> is B<NULL> then the maximum size of the output buffer is written to the B<routlen> parameter. If B<rout> is not B<NULL> then before the call the B<routlen> parameter should contain the length of the B<rout> buffer, if the call is successful recovered data is written to B<rout> and the amount of data written to B<routlen>.
fr: La fonction B<EVP_PKEY_verify_recover>() récupère des données signées en utilisant I<ctx>. La signature est indiquée en utilisant les paramètres I<sig> et I<siglen>. Si I<rout> est NULL, alors la taille maximale du tampon de sortie est écrite dans le paramètre I<routlen>. Si I<rout> n'est pas NULL, alors, avant l'appel, le paramètre I<routlen> devrait contenir la taille du tampon I<rout>. Si l'appel réussit, les données récupérées sont écrites dans I<rout> et la quantité de données écrites dans I<routlen>.

note: type: textblock
en: Normally an application is only interested in whether a signature verification operation is successful in those cases the EVP_verify() function should be used.
fr: Normalement, une application ne cherche à savoir que si une opération de vérification de signature a réussi. Dans ce cas la fonction B<EVP_verify>() devrait être utilisée.

note: type: textblock
en: Sometimes however it is useful to obtain the data originally signed using a signing operation. Only certain public key algorithms can recover a signature in this way (for example RSA in PKCS padding mode).
fr: Parfois, cependant, il est utile d'obtenir les données d'origine signées en utilisant une opération de signature. Seuls certains algorithmes à clef publique peuvent récupérer une signature de cette façon (par exemple RSA en mode de remplissage PKCS).

note: type: textblock
en: After the call to EVP_PKEY_verify_recover_init() algorithm specific control operations can be performed to set any appropriate parameters for the operation.
fr: Après l'appel de B<EVP_PKEY_verify_recover_init>(), les opérations de contrôle spécifique à l'algorithme peuvent être réalisée pour définir tous les paramètres nécessaires à l'opération.

note: type: textblock
en: The function EVP_PKEY_verify_recover() can be called more than once on the same context if several operations are performed using the same parameters.
fr: La fonction B<EVP_PKEY_verify_recover>() peut être appelée plus d'une fois sur le même contexte si plusieurs opérations sont réalisées en utilisant les mêmes paramètres.

note: type: textblock
en: EVP_PKEY_verify_recover_init() and EVP_PKEY_verify_recover() return 1 for success and 0 or a negative value for failure. In particular a return value of -2 indicates the operation is not supported by the public key algorithm.
fr: B<EVP_PKEY_verify_recover_init>() et B<EVP_PKEY_verify_recover>() renvoient B<1> en cas de réussite et B<0> ou une valeur négative en cas d'échec. En particulier, une valeur de retour de B<-2> indique que l'opération n'est pas permise par l'algorithme à clef publique.

note: type: textblock
en: Recover digest originally signed using PKCS#1 and SHA256 digest:
fr: Récupérer l'algorithme de signature d'origine signé en utilisant PKCS#1 et un algorithme de signature SHA256 :

note: type: verbatim
en:  EVP_PKEY_CTX *ctx;
     unsigned char *rout, *sig;
     size_t routlen, siglen; 
     EVP_PKEY *verify_key;
     /* NB: assumes verify_key, sig and siglen are already set up
      * and that verify_key is an RSA public key
      */
     ctx = EVP_PKEY_CTX_new(verify_key);
     if (!ctx)
    	/* Error occurred */
     if (EVP_PKEY_verify_recover_init(ctx) <= 0)
    	/* Error */
     if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) <= 0)
    	/* Error */
     if (EVP_PKEY_CTX_set_signature_md(ctx, EVP_sha256()) <= 0)
    	/* Error */
fr:  EVP_PKEY_CTX *ctx;
     unsigned char *rout, *sig;
     size_t routlen, siglen; 
     EVP_PKEY *verify_key;
     /* Remarque : verify_key, sig et siglen sont supposées déjà
      * être configurées et verify_key une clef publique RSA
      */
     ctx = EVP_PKEY_CTX_new(verify_key);
     if (!ctx)
    	/* Une erreur est survenue */
     if (EVP_PKEY_verify_recover_init(ctx) <= 0)
    	/* Erreur */
     if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) <= 0)
    	/* Erreur */
     if (EVP_PKEY_CTX_set_signature_md(ctx, EVP_sha256()) <= 0)
    	/* Erreur */

note: type: verbatim
en:  /* Determine buffer length */
     if (EVP_PKEY_verify_recover(ctx, NULL, &routlen, sig, siglen) <= 0)
    	/* Error */
fr:  /* Déterminer la taille du tampon */
     if (EVP_PKEY_verify_recover(ctx, NULL, &routlen, sig, siglen) <= 0)
    	/* Erreur */

note: type: verbatim
en:  if (!rout)
    	/* malloc failure */
fr:  if (!rout)
    	/* Erreur malloc */

note: type: verbatim
en:  if (EVP_PKEY_verify_recover(ctx, rout, &routlen, sig, siglen) <= 0)
    	/* Error */
fr:  if (EVP_PKEY_verify_recover(ctx, rout, &routlen, sig, siglen) <= 0)
    	/* Erreur */

note: type: verbatim
en:  /* Recovered data is routlen bytes written to buffer rout */
fr:  /* Données récupérées : routlen octets écrits dans le tampon rout */

note: type: textblock
en: L<EVP_PKEY_CTX_new(3)|EVP_PKEY_CTX_new(3)>, L<EVP_PKEY_encrypt(3)|EVP_PKEY_encrypt(3)>, L<EVP_PKEY_decrypt(3)|EVP_PKEY_decrypt(3)>, L<EVP_PKEY_sign(3)|EVP_PKEY_sign(3)>, L<EVP_PKEY_verify(3)|EVP_PKEY_verify(3)>, L<EVP_PKEY_derive(3)|EVP_PKEY_derive(3)>
fr: L<B<EVP_PKEY_CTX_new>(3)|EVP_PKEY_CTX_new(3)>, L<B<EVP_PKEY_encrypt>(3)|EVP_PKEY_encrypt(3)>, L<B<EVP_PKEY_decrypt>(3)|EVP_PKEY_decrypt(3)>, L<B<EVP_PKEY_sign>(3)|EVP_PKEY_sign(3)>, L<B<EVP_PKEY_verify>(3)|EVP_PKEY_verify(3)>, L<B<EVP_PKEY_derive>(3)|EVP_PKEY_derive(3)>
