.\" Automatically generated by Pod::Man 2.28 (Pod::Simple 3.29)
.\"
.\" Standard preamble:
.\" ========================================================================
.de Sp \" Vertical space (when we can't use .PP)
.if t .sp .5v
.if n .sp
..
.de Vb \" Begin verbatim text
.ft CW
.nf
.ne \\$1
..
.de Ve \" End verbatim text
.ft R
.fi
..
.\" Set up some character translations and predefined strings.  \*(-- will
.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left
.\" double quote, and \*(R" will give a right double quote.  \*(C+ will
.\" give a nicer C++.  Capital omega is used to do unbreakable dashes and
.\" therefore won't be available.  \*(C` and \*(C' expand to `' in nroff,
.\" nothing in troff, for use with C<>.
.tr \(*W-
.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p'
.ie n \{\
.    ds -- \(*W-
.    ds PI pi
.    if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch
.    if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\"  diablo 12 pitch
.    ds L" ""
.    ds R" ""
.    ds C` ""
.    ds C' ""
'br\}
.el\{\
.    ds -- \|\(em\|
.    ds PI \(*p
.    ds L" ``
.    ds R" ''
.    ds C`
.    ds C'
'br\}
.\"
.\" Escape single quotes in literal strings from groff's Unicode transform.
.ie \n(.g .ds Aq \(aq
.el       .ds Aq '
.\"
.\" If the F register is turned on, we'll generate index entries on stderr for
.\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index
.\" entries marked with X<> in POD.  Of course, you'll have to process the
.\" output yourself in some meaningful fashion.
.\"
.\" Avoid warning from groff about undefined register 'F'.
.de IX
..
.nr rF 0
.if \n(.g .if rF .nr rF 1
.if (\n(rF:(\n(.g==0)) \{
.    if \nF \{
.        de IX
.        tm Index:\\$1\t\\n%\t"\\$2"
..
.        if !\nF==2 \{
.            nr % 0
.            nr F 2
.        \}
.    \}
.\}
.rr rF
.\" ========================================================================
.\"
.IX Title "fr::crypto::pem 3SSL"
.TH fr::crypto::pem 3SSL "2015-12-31" "1.0.2a 1.0.2c" "OpenSSL"
.\" For nroff, turn off justification.  Always turn off hyphenation; it makes
.\" way too many mistakes in technical documents.
.if n .ad l
.nh
.SH "NOM"
.IX Header "NOM"
\&\s-1PEM,\s0 PEM_read_bio_PrivateKey, PEM_read_PrivateKey, PEM_write_bio_PrivateKey,
PEM_write_PrivateKey, PEM_write_bio_PKCS8PrivateKey,
PEM_write_PKCS8PrivateKey, PEM_write_bio_PKCS8PrivateKey_nid,
PEM_write_PKCS8PrivateKey_nid, PEM_read_bio_PUBKEY, PEM_read_PUBKEY,
PEM_write_bio_PUBKEY, PEM_write_PUBKEY, PEM_read_bio_RSAPrivateKey,
PEM_read_RSAPrivateKey, PEM_write_bio_RSAPrivateKey,
PEM_write_RSAPrivateKey, PEM_read_bio_RSAPublicKey, PEM_read_RSAPublicKey,
PEM_write_bio_RSAPublicKey, PEM_write_RSAPublicKey, PEM_read_bio_RSA_PUBKEY,
PEM_read_RSA_PUBKEY, PEM_write_bio_RSA_PUBKEY, PEM_write_RSA_PUBKEY,
PEM_read_bio_DSAPrivateKey, PEM_read_DSAPrivateKey,
PEM_write_bio_DSAPrivateKey, PEM_write_DSAPrivateKey,
PEM_read_bio_DSA_PUBKEY, PEM_read_DSA_PUBKEY, PEM_write_bio_DSA_PUBKEY,
PEM_write_DSA_PUBKEY, PEM_read_bio_DSAparams, PEM_read_DSAparams,
PEM_write_bio_DSAparams, PEM_write_DSAparams, PEM_read_bio_DHparams,
PEM_read_DHparams, PEM_write_bio_DHparams, PEM_write_DHparams,
PEM_read_bio_X509, PEM_read_X509, PEM_write_bio_X509, PEM_write_X509,
PEM_read_bio_X509_AUX, PEM_read_X509_AUX, PEM_write_bio_X509_AUX,
PEM_write_X509_AUX, PEM_read_bio_X509_REQ, PEM_read_X509_REQ,
PEM_write_bio_X509_REQ, PEM_write_X509_REQ, PEM_write_bio_X509_REQ_NEW,
PEM_write_X509_REQ_NEW, PEM_read_bio_X509_CRL, PEM_read_X509_CRL,
PEM_write_bio_X509_CRL, PEM_write_X509_CRL, PEM_read_bio_PKCS7,
PEM_read_PKCS7, PEM_write_bio_PKCS7, PEM_write_PKCS7,
PEM_read_bio_NETSCAPE_CERT_SEQUENCE, PEM_read_NETSCAPE_CERT_SEQUENCE,
PEM_write_bio_NETSCAPE_CERT_SEQUENCE, PEM_write_NETSCAPE_CERT_SEQUENCE \-
routines \s-1PEM\s0
.SH "SYNOPSIS"
.IX Header "SYNOPSIS"
.Vb 1
\& #include <openssl/pem.h>
\&
\& EVP_PKEY *PEM_read_bio_PrivateKey(BIO *bp, EVP_PKEY **x,
\&                                        pem_password_cb *cb, void *u);
\&
\& EVP_PKEY *PEM_read_PrivateKey(FILE *fp, EVP_PKEY **x,
\&                                        pem_password_cb *cb, void *u);
\&
\& int PEM_write_bio_PrivateKey(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc,
\&                                        unsigned char *kstr, int klen,
\&                                        pem_password_cb *cb, void *u);
\&
\& int PEM_write_PrivateKey(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc,
\&                                        unsigned char *kstr, int klen,
\&                                        pem_password_cb *cb, void *u);
\&
\& int PEM_write_bio_PKCS8PrivateKey(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc,
\&                                        char *kstr, int klen,
\&                                        pem_password_cb *cb, void *u);
\&
\& int PEM_write_PKCS8PrivateKey(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc,
\&                                        char *kstr, int klen,
\&                                        pem_password_cb *cb, void *u);
\&
\& int PEM_write_bio_PKCS8PrivateKey_nid(BIO *bp, EVP_PKEY *x, int nid,
\&                                        char *kstr, int klen,
\&                                        pem_password_cb *cb, void *u);
\&
\& int PEM_write_PKCS8PrivateKey_nid(FILE *fp, EVP_PKEY *x, int nid,
\&                                        char *kstr, int klen,
\&                                        pem_password_cb *cb, void *u);
\&
\& EVP_PKEY *PEM_read_bio_PUBKEY(BIO *bp, EVP_PKEY **x,
\&                                        pem_password_cb *cb, void *u);
\&
\& EVP_PKEY *PEM_read_PUBKEY(FILE *fp, EVP_PKEY **x,
\&                                        pem_password_cb *cb, void *u);
\&
\& int PEM_write_bio_PUBKEY(BIO *bp, EVP_PKEY *x);
\& int PEM_write_PUBKEY(FILE *fp, EVP_PKEY *x);
\&
\& RSA *PEM_read_bio_RSAPrivateKey(BIO *bp, RSA **x,
\&                                        pem_password_cb *cb, void *u);
\&
\& RSA *PEM_read_RSAPrivateKey(FILE *fp, RSA **x,
\&                                        pem_password_cb *cb, void *u);
\&
\& int PEM_write_bio_RSAPrivateKey(BIO *bp, RSA *x, const EVP_CIPHER *enc,
\&                                        unsigned char *kstr, int klen,
\&                                        pem_password_cb *cb, void *u);
\&
\& int PEM_write_RSAPrivateKey(FILE *fp, RSA *x, const EVP_CIPHER *enc,
\&                                        unsigned char *kstr, int klen,
\&                                        pem_password_cb *cb, void *u);
\&
\& RSA *PEM_read_bio_RSAPublicKey(BIO *bp, RSA **x,
\&                                        pem_password_cb *cb, void *u);
\&
\& RSA *PEM_read_RSAPublicKey(FILE *fp, RSA **x,
\&                                        pem_password_cb *cb, void *u);
\&
\& int PEM_write_bio_RSAPublicKey(BIO *bp, RSA *x);
\&
\& int PEM_write_RSAPublicKey(FILE *fp, RSA *x);
\&
\& RSA *PEM_read_bio_RSA_PUBKEY(BIO *bp, RSA **x,
\&                                        pem_password_cb *cb, void *u);
\&
\& RSA *PEM_read_RSA_PUBKEY(FILE *fp, RSA **x,
\&                                        pem_password_cb *cb, void *u);
\&
\& int PEM_write_bio_RSA_PUBKEY(BIO *bp, RSA *x);
\&
\& int PEM_write_RSA_PUBKEY(FILE *fp, RSA *x);
\&
\& DSA *PEM_read_bio_DSAPrivateKey(BIO *bp, DSA **x,
\&                                        pem_password_cb *cb, void *u);
\&
\& DSA *PEM_read_DSAPrivateKey(FILE *fp, DSA **x,
\&                                        pem_password_cb *cb, void *u);
\&
\& int PEM_write_bio_DSAPrivateKey(BIO *bp, DSA *x, const EVP_CIPHER *enc,
\&                                        unsigned char *kstr, int klen,
\&                                        pem_password_cb *cb, void *u);
\&
\& int PEM_write_DSAPrivateKey(FILE *fp, DSA *x, const EVP_CIPHER *enc,
\&                                        unsigned char *kstr, int klen,
\&                                        pem_password_cb *cb, void *u);
\&
\& DSA *PEM_read_bio_DSA_PUBKEY(BIO *bp, DSA **x,
\&                                        pem_password_cb *cb, void *u);
\&
\& DSA *PEM_read_DSA_PUBKEY(FILE *fp, DSA **x,
\&                                        pem_password_cb *cb, void *u);
\&
\& int PEM_write_bio_DSA_PUBKEY(BIO *bp, DSA *x);
\&
\& int PEM_write_DSA_PUBKEY(FILE *fp, DSA *x);
\&
\& DSA *PEM_read_bio_DSAparams(BIO *bp, DSA **x, pem_password_cb *cb, void *u);
\&
\& DSA *PEM_read_DSAparams(FILE *fp, DSA **x, pem_password_cb *cb, void *u);
\&
\& int PEM_write_bio_DSAparams(BIO *bp, DSA *x);
\&
\& int PEM_write_DSAparams(FILE *fp, DSA *x);
\&
\& DH *PEM_read_bio_DHparams(BIO *bp, DH **x, pem_password_cb *cb, void *u);
\&
\& DH *PEM_read_DHparams(FILE *fp, DH **x, pem_password_cb *cb, void *u);
\&
\& int PEM_write_bio_DHparams(BIO *bp, DH *x);
\&
\& int PEM_write_DHparams(FILE *fp, DH *x);
\&
\& X509 *PEM_read_bio_X509(BIO *bp, X509 **x, pem_password_cb *cb, void *u);
\&
\& X509 *PEM_read_X509(FILE *fp, X509 **x, pem_password_cb *cb, void *u);
\&
\& int PEM_write_bio_X509(BIO *bp, X509 *x);
\&
\& int PEM_write_X509(FILE *fp, X509 *x);
\&
\& X509 *PEM_read_bio_X509_AUX(BIO *bp, X509 **x, pem_password_cb *cb, void *u);
\&
\& X509 *PEM_read_X509_AUX(FILE *fp, X509 **x, pem_password_cb *cb, void *u);
\&
\& int PEM_write_bio_X509_AUX(BIO *bp, X509 *x);
\&
\& int PEM_write_X509_AUX(FILE *fp, X509 *x);
\&
\& X509_REQ *PEM_read_bio_X509_REQ(BIO *bp, X509_REQ **x,
\&                                        pem_password_cb *cb, void *u);
\&
\& X509_REQ *PEM_read_X509_REQ(FILE *fp, X509_REQ **x,
\&                                        pem_password_cb *cb, void *u);
\&
\& int PEM_write_bio_X509_REQ(BIO *bp, X509_REQ *x);
\&
\& int PEM_write_X509_REQ(FILE *fp, X509_REQ *x);
\&
\& int PEM_write_bio_X509_REQ_NEW(BIO *bp, X509_REQ *x);
\&
\& int PEM_write_X509_REQ_NEW(FILE *fp, X509_REQ *x);
\&
\& X509_CRL *PEM_read_bio_X509_CRL(BIO *bp, X509_CRL **x,
\&                                        pem_password_cb *cb, void *u);
\& X509_CRL *PEM_read_X509_CRL(FILE *fp, X509_CRL **x,
\&                                        pem_password_cb *cb, void *u);
\& int PEM_write_bio_X509_CRL(BIO *bp, X509_CRL *x);
\& int PEM_write_X509_CRL(FILE *fp, X509_CRL *x);
\&
\& PKCS7 *PEM_read_bio_PKCS7(BIO *bp, PKCS7 **x, pem_password_cb *cb, void *u);
\&
\& PKCS7 *PEM_read_PKCS7(FILE *fp, PKCS7 **x, pem_password_cb *cb, void *u);
\&
\& int PEM_write_bio_PKCS7(BIO *bp, PKCS7 *x);
\&
\& int PEM_write_PKCS7(FILE *fp, PKCS7 *x);
\&
\& NETSCAPE_CERT_SEQUENCE *PEM_read_bio_NETSCAPE_CERT_SEQUENCE(BIO *bp,
\&                                                NETSCAPE_CERT_SEQUENCE **x,
\&                                                pem_password_cb *cb, void *u);
\&
\& NETSCAPE_CERT_SEQUENCE *PEM_read_NETSCAPE_CERT_SEQUENCE(FILE *fp,
\&                                                NETSCAPE_CERT_SEQUENCE **x,
\&                                                pem_password_cb *cb, void *u);
\&
\& int PEM_write_bio_NETSCAPE_CERT_SEQUENCE(BIO *bp, NETSCAPE_CERT_SEQUENCE *x);
\&
\& int PEM_write_NETSCAPE_CERT_SEQUENCE(FILE *fp, NETSCAPE_CERT_SEQUENCE *x);
.Ve
.SH "DESCRIPTION"
.IX Header "DESCRIPTION"
Les fonctions \s-1PEM\s0 lisent ou écrivent des structures au format \s-1PEM.\s0 En ce
sens, le format \s-1PEM\s0 est simplement des données chiffrées en base64 entourées
de lignes d'en\-tête.
.PP
Pour plus de détails sur la signification des arguments, voir la partie
\&\fB\s-1ARGUMENTS DES FONCTIONS PEM\s0\fR.
.PP
Chaque opération possède 4 fonctions qui lui sont associées. Pour clarifier
le terme « fonctions \fBfoobar\fR » sera utilisé pour faire collectivement
référence aux fonctions \fIPEM_read_bio_foobar()\fR, \fIPEM_read_foobar()\fR,
\&\fIPEM_write_bio_foobar()\fR et \fIPEM_write_foobar()\fR
.PP
La fonction \fBPrivateKey\fR lit et écrit une clé privée dans le format \s-1PEM\s0 en
utilisant une structure \s-1EVP_PKEY.\s0 Les routines d'écriture utilisent une clé
privée au format « traditionnel » et peuvent gérer les clés privées \s-1RSA\s0 et
\&\s-1DSA.\s0 Les fonctions de lecture peuvent aussi gérer de façon transparente les
clés chiffrées et déchiffrées au format PKCS#8.
.PP
\&\fIPEM_write_bio_PKCS8PrivateKey()\fR et \fIPEM_write_PKCS8PrivateKey()\fR écrivent une
clé privée dans une structure \s-1EVP_PKEY\s0 dans le format PKCS#8
EncryptedPrivateKeyInfo en utilisant un algorithme de mot de passe basé sur
PKCS#5 v2.0. L'argument \fBcipher\fR spécifie l'algorithme de chiffrement à
utiliser : contrairement à toutes les autres routines \s-1PEM,\s0 le chiffrement
est appliqué au niveau du PKCS#8 et pas dans les en\-têtes \s-1PEM.\s0 Si \fBcipher\fR
est \s-1NULL\s0 alors il n'y aura pas de chiffrement utilisé et une structure
PKCS#8 PrivateKeyInfo sera utilisée.
.PP
\&\fIPEM_write_bio_PKCS8PrivateKey_nid()\fR et \fIPEM_write_PKCS8PrivateKey_nid()\fR
écrivent aussi une clé privée comme PKCS#8 EncryptedPrivateKeyInfo cependant
elles utilisent les algorithmes de chiffrement KCS#5 v1.5 ou PKCS#12 à la
place. L'algorithme à utiliser dans le paramètre \fBnid\fR doit être le \s-1NID\s0 de
l'\s-1IDENTIFIANT DE L\s0'\s-1OBJET \s0(voir la section \s-1NOTES\s0).
.PP
Les fonctions \fB\s-1PUBKEY\s0\fR traitent une clé publique en utilisant une structure
\&\s-1EVP_PKEY.\s0 La clé publique est chiffrée comme une structure
SubjectPublicKeyInfo.
.PP
Les fonctions \fBRSAPrivateKey\fR traitent une clé \s-1RSA\s0 privée en utilisant une
structure \s-1RSA.\s0 Elles gèrent le même format que les fonctions \fBPrivateKey\fR
mais une erreur se produit si la clé privée n'est pas une clé \s-1RSA.\s0
.PP
Les fonctions \fBRSAPublicKey\fR traitent une clé \s-1RSA\s0 publique en utilisant une
structure \s-1RSA.\s0 La clé publique est chiffrée en utilisant une structure
PKCS#1 RSAPublicKey
.PP
Les fonctions \fB\s-1RSA_PUBKEY\s0\fR traitent aussi une clé publique en utilisant une
structure \s-1RSA.\s0 Mais la clé publique est chiffrée en utilisant une structure
SubjectPublicKeyInfo et une erreur se produit si la clé publique n'est pas
une clé \s-1RSA.\s0
.PP
Les fonctions \fBDSAPrivateKey\fR traitent une clé \s-1DSA\s0 privée en utilisant une
structure \s-1DSA.\s0 Elles gèrent les mêmes formats que les fonctions
\&\fBPrivateKey\fR mais une erreur se produit si la clé privée n'est pas une clé
\&\s-1DSA.\s0
.PP
Les fonctions \fB\s-1DSA_PUBKEY\s0\fR traitent une clé publique \s-1DSA\s0 en utilisant une
structure \s-1DSA.\s0 La clé publique est chiffrée en utilisant une structure
SubjectPublicKeyInfo et une erreur se produit si la clé publique n'est pas
une clé \s-1DSA.\s0
.PP
Les fonctions \fBDSAparams\fR traitent les paramètres \s-1DSA\s0 en utilisant une
structure \s-1DSA.\s0 Les paramètres sont chiffrés en utilisant une structure
Dss-Parms telle que définie dans la \s-1RFC2459.\s0
.PP
Les fonctions \fBDHparams\fR traitent les paramètres \s-1DH\s0 en utilisant une
structure \s-1DH.\s0 Les paramètres sont chiffrés en utilisant une structure PKCS#3
DHparameter
.PP
Les fonctions \fBX509\fR traitent un certificat X509 en utilisant une structure
X509. Elles traitent aussi les certificats X509 certifiés mais les
paramètres de réglages sont ignorés.
.PP
Les fonctions \fBX509_AUX\fR traitent un certificat X509 certifié en utilisant
une structure X509.
.PP
Les fonctions \fBX509_REQ\fR et \fBX509_REQ_NEW\fR traitent une requête de
certificat PKCS#10 en utilisant une structure X509_REQ. La fonction
d'écriture \fBX509_REQ\fR utilise \fB\s-1CERTIFICATE REQUEST\s0\fR dans l'en\-tête alors
que les fonctions \fBX509_REQ_NEW\fR utilisent \fB\s-1NEW CERTIFICATE REQUEST\s0\fR
(comme requis par des \s-1CA\s0). Les fonctions de lecture \fBX509_REQ\fR peuvent
gérer les deux formes, il n'y a donc pas de fonctions de lecture
\&\fBX509_REQ_NEW\fR.
.PP
Les fonctions \fBX509_CRL\fR traitent un \s-1CRL X509\s0 en utilisant une structure
X509_CRL.
.PP
Les fonctions \fB\s-1PKCS7\s0\fR traitent un PKCS#7 ContentInfo en utilisant une
structure \s-1PKCS7.\s0
.PP
Les fonctions \fB\s-1NETSCAPE_CERT_SEQUENCE\s0\fR traitent une séquence de certificats
Netscape en utilisant une structure \s-1NETSCAPE_CERT_SEQUENCE.\s0
.SH "ARGUMENTS DES FONCTIONS PEM"
.IX Header "ARGUMENTS DES FONCTIONS PEM"
Les fonctions \s-1PEM\s0 ont beaucoup d'arguments en commun.
.PP
Les paramètres \fBbp\fR (si présents) spécifient le \s-1BIO\s0 dans lequel il faut
lire ou écrire.
.PP
Le paramètre de \s-1FILE \s0\fBfp\fR (si présent) spécifie le pointeur de \s-1FILE\s0 dans
lequel il faut lire ou écrire.
.PP
Les fonctions de lecture \s-1PEM\s0 prennent toutes un argument \fB\s-1TYPE\s0 **x\fR et
renvoient toutes un pointeur \fB\s-1TYPE\s0 *\fR, où \fB\s-1TYPE\s0\fR est une structure
quelconque que la fonction utilise. Si \fBx\fR est \s-1NULL,\s0 alors le paramètre est
ignoré. Si \fBx\fR n'est pas \s-1NULL\s0 mais \fB*x\fR est \s-1NULL,\s0 alors la structure
renvoyée sera écrite dans \fB*x\fR. Si ni \fBx\fR et \fB*x\fR ne sont \s-1NULL,\s0 alors une
tentative de réutilisation de la structure sera faite (mais voir la partie
\&\s-1BOGUES\s0 et \s-1EXEMPLES\s0). Quelle que soit la valeur de \fBx\fR, un pointeur vers une
structure est toujours renvoyé (ou \s-1NULL\s0 en cas d'erreur).
.PP
Les fonctions \s-1PEM\s0 qui utilisent des clés privées prennent un paramètre
\&\fBenc\fR qui spécifie l'algorithme de chiffrement à utiliser, le chiffrement
est fait au niveau du \s-1PEM.\s0 Si ce paramètre est mis à \s-1NULL,\s0 alors la clé
privée est écrite de façon non chiffrée.
.PP
L'argument \fBcb\fR est le rappel à utiliser pour les requêtes pour le mot de
passe utilisé pour chiffrer les structures \s-1PEM \s0(que des clés privées
normalement).
.PP
Pour les routines d'écritures \s-1PEM,\s0 si le paramètre \fBkstr\fR n'est pas \s-1NULL,\s0
alors \fBklen\fR octets à \fBkstr\fR sont utilisés comme mot de passe et \fBcb\fR est
ignoré.
.PP
Si les paramètres \fBcb\fR sont initialisés à \s-1NULL\s0 et que le paramètre \fBu\fR
n'est pas \s-1NULL,\s0 alors le paramètre \fBu\fR n'est pas correctement interprété
comme une chaîne de caractère terminée par un null à utiliser comme mot de
passe. Si \fBcb\fR et \fBu\fR sont \s-1NULL,\s0 alors la routine de retour est utilisée,
ce qui affiche généralement une demande d'entrée de texte pour le mot de
passe sur le terminal courant et sans affichage de l'entrée.
.PP
Le rappel du mot de passe par défaut n'est parfois pas approprié (par
exemple dans une application à interface graphique), une alternative peut
donc être fournie. La routine de retour de fonction a la forme suivante :
.PP
.Vb 1
\& int cb(char *buf, int size, int rwflag, void *u);
.Ve
.PP
\&\fBbuf\fR est le tampon d'écriture dans lequel sera écrit le mot de
passe. \fBsize\fR est la taille maximale du mot de passe (c'est\-à\-dire la
taille du tampon). \fBrwflag\fR est un drapeau qui est mis à 0 lors d'une
lecture et à 1 lors d'une écriture. Une routine typique demandera à
l'utilisateur de vérifier le mot de passe (par exemple pour le demander deux
fois) si \fBrwflag\fRest à 1. Le paramètre \fBu\fR a la même valeur que le
paramètre \fBu\fR passé à la routine \s-1PEM.\s0 Il autorise l'application à passer
des données arbitraires à la rétroaction (par exemple un gestionnaire de
fenêtres dans une application à interface graphique). La rétroaction \fBdoit\fR
renvoyer le nombre de caractères dans le mot de passe ou 0 en cas d'erreur.
.SH "EXEMPLES"
.IX Header "EXEMPLES"
Bien que les routines \s-1PEM\s0 prennent plusieurs arguments, dans presque toutes
leurs applications ceux-ci sont mis à 0 ou \s-1NULL.\s0
.PP
Lire un certificat dans le format \s-1PEM\s0 à partir d'un \s-1BIO :\s0
.PP
.Vb 6
\& X509 *x;
\& x = PEM_read_bio_X509(bp, NULL, 0, NULL);
\& if (x == NULL)
\&        {
\&        /* Erreur */
\&        }
.Ve
.PP
Méthodes alternatives :
.PP
.Vb 5
\& X509 *x = NULL;
\& if (!PEM_read_bio_X509(bp, &x, 0, NULL))
\&        {
\&        /* Erreur */
\&        }
.Ve
.PP
Écrire un certificat dans un \s-1BIO :\s0
.PP
.Vb 4
\& if (!PEM_write_bio_X509(bp, x))
\&        {
\&        /* Erreur */
\&        }
.Ve
.PP
Écrire une clé non chiffrée dans un pointeur \s-1FILE :\s0
.PP
.Vb 4
\& if (!PEM_write_PrivateKey(fp, key, NULL, NULL, 0, 0, NULL))
\&        {
\&        /* Erreur */
\&        }
.Ve
.PP
Écrire une clé privée (en utilisant le format traditionnel) dans un \s-1BIO\s0 en
utilisant un chiffrement Triple-DES, le mot de passe est requis :
.PP
.Vb 4
\& if (!PEM_write_bio_PrivateKey(bp, key, EVP_des_ede3_cbc(), NULL, 0, 0, NULL))
\&        {
\&        /* Erreur */
\&        }
.Ve
.PP
Écrire une clé privée (en utilisant le format PKCS#8) dans un \s-1BIO\s0 en
utilisant le chiffrement Triple-DES, en utilisant le mot de passe
« hello » :
.PP
.Vb 4
\& if (!PEM_write_bio_PKCS8PrivateKey(bp, key, EVP_des_ede3_cbc(), NULL, 0, 0, "hello"))
\&        {
\&        /* Erreur */
\&        }
.Ve
.PP
Lire une clé privée d'un \s-1BIO\s0 en utilisant le mot de passe « hello » :
.PP
.Vb 5
\& key = PEM_read_bio_PrivateKey(bp, NULL, 0, "hello");
\& if (key == NULL)
\&        {
\&        /* Erreur */
\&        }
.Ve
.PP
Lire une clé privée d'un \s-1BIO\s0 en utilisant le rappel de phrase secrète :
.PP
.Vb 5
\& key = PEM_read_bio_PrivateKey(bp, NULL, pass_cb, "My Private Key");
\& if (key == NULL)
\&        {
\&        /* Erreur */
\&        }
.Ve
.PP
Squelette de rappel de phrase secrète :
.PP
.Vb 6
\& int pass_cb(char *buf, int size, int rwflag, void *u);
\&        {
\&        int len;
\&        char *tmp;
\&        /* On ferait probablement autre chose si \*(Aqrwflag\*(Aq était à 1 */
\&        printf("Enter pass phrase for \e"%s\e"\en", u);
\&
\&        /* obtenir la phrase chiffrée, longueur \*(Aqlen\*(Aq dans \*(Aqtmp\*(Aq */
\&        tmp = "hello";
\&        len = strlen(tmp);
\&
\&        if (len <= 0) return 0;
\&        /* if too long, truncate */
\&        if (len > size) len = size;
\&        memcpy(buf, tmp, len);
\&        return len;
\&        }
.Ve
.SH "NOTES"
.IX Header "NOTES"
Les anciennes routines d'écriture \fBPrivateKey\fR sont gardées pour raisons de
comptabilité. Les nouvelles applications doivent écrire de nouvelles clés
privées en utilisant les routines \fIPEM_write_bio_PKCS8PrivateKey()\fR ou
\&\fIPEM_write_PKCS8PrivateKey()\fR car elles sont plus sécurisées (elles utilisent
un compteur d'itération sur 2048 alors que les routines traditionnelles
utilisent un compteur de 1) sauf si la compatibilité avec les anciennes
versions d'OpenSSL est importante.
.PP
Les routines de lecture \fBPrivateKey\fR peuvent être utilisées dans toutes les
applications car elles manipulent tous les formats de façon transparente.
.PP
Un cas récurrent de problèmes est la tentative d'utilisation des routines
\&\s-1PEM\s0 de la façon suivante :
.PP
.Vb 2
\& X509 *x;
\& PEM_read_bio_X509(bp, &x, 0, NULL);
.Ve
.PP
cela est un bogue car une tentative de réutilisation des données à \fBx\fR sera
faite alors que c'est un pointeur qui n'est pas initialisé.
.SH "FORMAT DE CHIFFREMENT PEM"
.IX Header "FORMAT DE CHIFFREMENT PEM"
Cette vieille routine \fBPrivateKey\fR utilise une méthode non standard de
chiffrement.
.PP
La clé privée (ou toute autre donnée) prend la forme suivante :
.PP
.Vb 3
\& \-\-\-\-\-DÉBUT CLÉ PRIVÉE RSA\-\-\-\-\-
\& Proc\-Type: 4,ENCRYPTED
\& DEK\-Info: DES\-EDE3\-CBC,3F17F5316E2BAC89
\&
\& ...données encodées en base64...
\& \-\-\-\-\-FIN CLÉ PRIVÉE RSA\-\-\-\-\-
.Ve
.PP
La ligne qui commence DEK-Info contient deux virgules séparées par des
morceaux d'information : le nom de l'algorithme de chiffrement comme utilisé
par \fIEVP_get_cipherbyname()\fR et un \fBsalt\fR de 8 octets chiffré comme un
ensemble de valeurs hexadécimales.
.PP
Après ce sont les données chiffrées en base64.
.PP
La clé de chiffrement est déterminée en utilisant \fIEVP_Bytestokey()\fR, en
utilisant \fBsalt\fR et un compteur d'itération de 1. Le \s-1IV\s0 utilisé est la
valeur de \fBsalt\fR et *pas* le \s-1IV\s0 renvoyé par \fIEVP_Bytestokey()\fR.
.SH "BOGUES"
.IX Header "BOGUES"
Les routines de lecture \s-1PEM,\s0 dans certaines versions d'OpenSSL,
n'utiliseront pas correctement les structures existantes. De ce fait, ce qui
suit :
.PP
.Vb 1
\& PEM_read_bio_X509(bp, &x, 0, NULL);
.Ve
.PP
où \fBx\fR contient déjà un certificat valable, risque de ne pas fonctionner,
alors que :
.PP
.Vb 2
\& X509_free(x);
\& x = PEM_read_bio_X509(bp, NULL, 0, NULL);
.Ve
.PP
est garanti de fonctionner.
.SH "CODES DE RETOUR"
.IX Header "CODES DE RETOUR"
Les routines de lectures renvoient soit un pointeur vers la structure read
ou \s-1NULL\s0 si une erreur s'est produite.
.PP
La routine d'écriture renvoie 1 en cas de succès et 0 en cas d'échec.
.SH "VOIR AUSSI"
.IX Header "VOIR AUSSI"
\&\fBEVP_get_cipherbyname\fR(3),
\&\fBEVP_BytesToKey\fR(3)
.SH "TRADUCTION"
.IX Header "TRADUCTION"
La traduction de cette page de manuel est maintenue par
les membres de la liste <debian\-l10n\-french \s-1AT\s0 lists \s-1DOT\s0 debian \s-1DOT\s0 org>.
Veuillez signaler toute erreur de traduction par un rapport de bogue sur
le paquet manpages-fr-extra.