1b0c8a0aa522f6012c45b586dc557c77f143f60d
[openssl.git] / crypto / pem / pem.h
1 /* crypto/pem/pem.h */
2 /* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
3  * All rights reserved.
4  *
5  * This package is an SSL implementation written
6  * by Eric Young (eay@cryptsoft.com).
7  * The implementation was written so as to conform with Netscapes SSL.
8  * 
9  * This library is free for commercial and non-commercial use as long as
10  * the following conditions are aheared to.  The following conditions
11  * apply to all code found in this distribution, be it the RC4, RSA,
12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13  * included with this distribution is covered by the same copyright terms
14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15  * 
16  * Copyright remains Eric Young's, and as such any Copyright notices in
17  * the code are not to be removed.
18  * If this package is used in a product, Eric Young should be given attribution
19  * as the author of the parts of the library used.
20  * This can be in the form of a textual message at program startup or
21  * in documentation (online or textual) provided with the package.
22  * 
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions
25  * are met:
26  * 1. Redistributions of source code must retain the copyright
27  *    notice, this list of conditions and the following disclaimer.
28  * 2. Redistributions in binary form must reproduce the above copyright
29  *    notice, this list of conditions and the following disclaimer in the
30  *    documentation and/or other materials provided with the distribution.
31  * 3. All advertising materials mentioning features or use of this software
32  *    must display the following acknowledgement:
33  *    "This product includes cryptographic software written by
34  *     Eric Young (eay@cryptsoft.com)"
35  *    The word 'cryptographic' can be left out if the rouines from the library
36  *    being used are not cryptographic related :-).
37  * 4. If you include any Windows specific code (or a derivative thereof) from 
38  *    the apps directory (application code) you must include an acknowledgement:
39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40  * 
41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  * 
53  * The licence and distribution terms for any publically available version or
54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
55  * copied and put under another distribution licence
56  * [including the GNU Public Licence.]
57  */
58
59 #ifndef HEADER_PEM_H
60 #define HEADER_PEM_H
61
62 #ifdef  __cplusplus
63 extern "C" {
64 #endif
65
66 #include <openssl/evp.h>
67 #include <openssl/x509.h>
68 #include <openssl/pem2.h>
69
70 #define PEM_BUFSIZE             1024
71
72 #define PEM_OBJ_UNDEF           0
73 #define PEM_OBJ_X509            1
74 #define PEM_OBJ_X509_REQ        2
75 #define PEM_OBJ_CRL             3
76 #define PEM_OBJ_SSL_SESSION     4
77 #define PEM_OBJ_PRIV_KEY        10
78 #define PEM_OBJ_PRIV_RSA        11
79 #define PEM_OBJ_PRIV_DSA        12
80 #define PEM_OBJ_PRIV_DH         13
81 #define PEM_OBJ_PUB_RSA         14
82 #define PEM_OBJ_PUB_DSA         15
83 #define PEM_OBJ_PUB_DH          16
84 #define PEM_OBJ_DHPARAMS        17
85 #define PEM_OBJ_DSAPARAMS       18
86 #define PEM_OBJ_PRIV_RSA_PUBLIC 19
87
88 #define PEM_ERROR               30
89 #define PEM_DEK_DES_CBC         40
90 #define PEM_DEK_IDEA_CBC        45
91 #define PEM_DEK_DES_EDE         50
92 #define PEM_DEK_DES_ECB         60
93 #define PEM_DEK_RSA             70
94 #define PEM_DEK_RSA_MD2         80
95 #define PEM_DEK_RSA_MD5         90
96
97 #define PEM_MD_MD2              NID_md2
98 #define PEM_MD_MD5              NID_md5
99 #define PEM_MD_SHA              NID_sha
100 #define PEM_MD_MD2_RSA          NID_md2WithRSAEncryption
101 #define PEM_MD_MD5_RSA          NID_md5WithRSAEncryption
102 #define PEM_MD_SHA_RSA          NID_sha1WithRSAEncryption
103
104 #define PEM_STRING_X509_OLD     "X509 CERTIFICATE"
105 #define PEM_STRING_X509         "CERTIFICATE"
106 #define PEM_STRING_X509_REQ_OLD "NEW CERTIFICATE REQUEST"
107 #define PEM_STRING_X509_REQ     "CERTIFICATE REQUEST"
108 #define PEM_STRING_X509_CRL     "X509 CRL"
109 #define PEM_STRING_EVP_PKEY     "ANY PRIVATE KEY"
110 #define PEM_STRING_RSA          "RSA PRIVATE KEY"
111 #define PEM_STRING_RSA_PUBLIC   "RSA PUBLIC KEY"
112 #define PEM_STRING_DSA          "DSA PRIVATE KEY"
113 #define PEM_STRING_DSA_PUBLIC   "DSA PUBLIC KEY"
114 #define PEM_STRING_PKCS7        "PKCS7"
115 #define PEM_STRING_PKCS8        "ENCRYPTED PRIVATE KEY"
116 #define PEM_STRING_PKCS8INF     "PRIVATE KEY"
117 #define PEM_STRING_DHPARAMS     "DH PARAMETERS"
118 #define PEM_STRING_SSL_SESSION  "SSL SESSION PARAMETERS"
119 #define PEM_STRING_DSAPARAMS    "DSA PARAMETERS"
120
121
122 typedef struct PEM_Encode_Seal_st
123         {
124         EVP_ENCODE_CTX encode;
125         EVP_MD_CTX md;
126         EVP_CIPHER_CTX cipher;
127         } PEM_ENCODE_SEAL_CTX;
128
129 /* enc_type is one off */
130 #define PEM_TYPE_ENCRYPTED      10
131 #define PEM_TYPE_MIC_ONLY       20
132 #define PEM_TYPE_MIC_CLEAR      30
133 #define PEM_TYPE_CLEAR          40
134
135 typedef struct pem_recip_st
136         {
137         char *name;
138         X509_NAME *dn;
139
140         int cipher;
141         int key_enc;
142         char iv[8];
143         } PEM_USER;
144
145 typedef struct pem_ctx_st
146         {
147         int type;               /* what type of object */
148
149         struct  {
150                 int version;    
151                 int mode;               
152                 } proc_type;
153
154         char *domain;
155
156         struct  {
157                 int cipher;
158                 unsigned char iv[8];
159                 } DEK_info;
160                 
161         PEM_USER *originator;
162
163         int num_recipient;
164         PEM_USER **recipient;
165
166 #ifdef HEADER_STACK_H
167         STACK *x509_chain;      /* certificate chain */
168 #else
169         char *x509_chain;       /* certificate chain */
170 #endif
171         EVP_MD *md;             /* signature type */
172
173         int md_enc;             /* is the md encrypted or not? */
174         int md_len;             /* length of md_data */
175         char *md_data;          /* message digest, could be pkey encrypted */
176
177         EVP_CIPHER *dec;        /* date encryption cipher */
178         int key_len;            /* key length */
179         unsigned char *key;     /* key */
180         unsigned char iv[8];    /* the iv */
181
182         
183         int  data_enc;          /* is the data encrypted */
184         int data_len;
185         unsigned char *data;
186         } PEM_CTX;
187
188 /* These macros make the PEM_read/PEM_write functions easier to maintain and
189  * write. Now they are all implemented with either:
190  * IMPLEMENT_PEM_rw(...) or IMPLEMENT_PEM_rw_cb(...)
191  */
192
193 #ifdef NO_FP_API
194
195 #define IMPLEMENT_PEM_read_fp(name, type, str, asn1) /**/
196 #define IMPLEMENT_PEM_write_fp(name, type, str, asn1) /**/
197 #define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) /**/
198
199 #else
200
201 #define IMPLEMENT_PEM_read_fp(name, type, str, asn1) \
202 type *PEM_read_##name(FILE *fp, type **x, pem_password_cb *cb, void *u)\
203 { \
204 return((type *)PEM_ASN1_read((char *(*)())d2i_##asn1, str,fp,(char **)x,\
205         cb,u)); \
206 } \
207
208 #define IMPLEMENT_PEM_write_fp(name, type, str, asn1) \
209 int PEM_write_##name(FILE *fp, type *x) \
210 { \
211 return(PEM_ASN1_write((int (*)())i2d_##asn1,str,fp, (char *)x, \
212                                                          NULL,NULL,0,NULL,NULL)); \
213
214
215 #define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) \
216 int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \
217              unsigned char *kstr, int klen, pem_password_cb *cb, \
218                   void *u) \
219         { \
220         return(PEM_ASN1_write((int (*)())i2d_##asn1,str,fp, \
221                 (char *)x,enc,kstr,klen,cb,u)); \
222         }
223
224 #endif
225
226 #define IMPLEMENT_PEM_read_bio(name, type, str, asn1) \
227 type *PEM_read_bio_##name(BIO *bp, type **x, pem_password_cb *cb, void *u)\
228 { \
229 return((type *)PEM_ASN1_read_bio((char *(*)())d2i_##asn1, str,bp,\
230                                                         (char **)x,cb,u)); \
231 }
232
233 #define IMPLEMENT_PEM_write_bio(name, type, str, asn1) \
234 int PEM_write_bio_##name(BIO *bp, type *x) \
235 { \
236 return(PEM_ASN1_write_bio((int (*)())i2d_##asn1,str,bp, (char *)x, \
237                                                          NULL,NULL,0,NULL,NULL)); \
238 }
239
240 #define IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \
241 int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \
242              unsigned char *kstr, int klen, pem_password_cb *cb, void *u) \
243         { \
244         return(PEM_ASN1_write_bio((int (*)())i2d_##asn1,str,bp, \
245                 (char *)x,enc,kstr,klen,cb,u)); \
246         }
247
248 #define IMPLEMENT_PEM_write(name, type, str, asn1) \
249         IMPLEMENT_PEM_write_bio(name, type, str, asn1) \
250         IMPLEMENT_PEM_write_fp(name, type, str, asn1) 
251
252 #define IMPLEMENT_PEM_write_cb(name, type, str, asn1) \
253         IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \
254         IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) 
255
256 #define IMPLEMENT_PEM_read(name, type, str, asn1) \
257         IMPLEMENT_PEM_read_bio(name, type, str, asn1) \
258         IMPLEMENT_PEM_read_fp(name, type, str, asn1) 
259
260 #define IMPLEMENT_PEM_rw(name, type, str, asn1) \
261         IMPLEMENT_PEM_read(name, type, str, asn1) \
262         IMPLEMENT_PEM_write(name, type, str, asn1)
263
264 #define IMPLEMENT_PEM_rw_cb(name, type, str, asn1) \
265         IMPLEMENT_PEM_read(name, type, str, asn1) \
266         IMPLEMENT_PEM_write_cb(name, type, str, asn1)
267
268 /* These are the same except they are for the declarations */
269
270 #if defined(WIN16) || defined(NO_FP_API)
271
272 #define DECLARE_PEM_read_fp(name, type) /**/
273 #define DECLARE_PEM_write_fp(name, type) /**/
274 #define DECLARE_PEM_write_cb_fp(name, type) /**/
275
276 #else
277
278 #define DECLARE_PEM_read_fp(name, type) \
279         type *PEM_read_##name(FILE *fp, type **x, pem_password_cb *cb, void *u);
280
281 #define DECLARE_PEM_write_fp(name, type) \
282         int PEM_write_##name(FILE *fp, type *x);
283
284 #define DECLARE_PEM_write_cb_fp(name, type) \
285         int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \
286              unsigned char *kstr, int klen, pem_password_cb *cb, void *u);
287
288 #endif
289
290 #ifdef HEADER_BIO_H
291 #define DECLARE_PEM_read_bio(name, type) \
292         type *PEM_read_bio_##name(BIO *bp, type **x, pem_password_cb *cb, void *u);
293
294 #define DECLARE_PEM_write_bio(name, type) \
295         int PEM_write_bio_##name(BIO *bp, type *x);
296
297 #define DECLARE_PEM_write_cb_bio(name, type) \
298         int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \
299              unsigned char *kstr, int klen, pem_password_cb *cb, void *u);
300
301 #else
302
303 #define DECLARE_PEM_read_bio(name, type) /**/
304 #define DECLARE_PEM_write_bio(name, type) /**/
305 #define DECLARE_PEM_write_cb_bio(name, type) /**/
306
307 #endif
308
309 #define DECLARE_PEM_write(name, type) \
310         DECLARE_PEM_write_bio(name, type) \
311         DECLARE_PEM_write_fp(name, type) 
312
313 #define DECLARE_PEM_write_cb(name, type) \
314         DECLARE_PEM_write_cb_bio(name, type) \
315         DECLARE_PEM_write_cb_fp(name, type) 
316
317 #define DECLARE_PEM_read(name, type) \
318         DECLARE_PEM_read_bio(name, type) \
319         DECLARE_PEM_read_fp(name, type)
320
321 #define DECLARE_PEM_rw(name, type) \
322         DECLARE_PEM_read(name, type) \
323         DECLARE_PEM_write(name, type)
324
325 #define DECLARE_PEM_rw_cb(name, type) \
326         DECLARE_PEM_read(name, type) \
327         DECLARE_PEM_write_cb(name, type)
328
329 #ifdef SSLEAY_MACROS
330
331 #define PEM_write_SSL_SESSION(fp,x) \
332                 PEM_ASN1_write((int (*)())i2d_SSL_SESSION, \
333                         PEM_STRING_SSL_SESSION,fp, (char *)x, NULL,NULL,0,NULL,NULL)
334 #define PEM_write_X509(fp,x) \
335                 PEM_ASN1_write((int (*)())i2d_X509,PEM_STRING_X509,fp, \
336                         (char *)x, NULL,NULL,0,NULL,NULL)
337 #define PEM_write_X509_REQ(fp,x) PEM_ASN1_write( \
338                 (int (*)())i2d_X509_REQ,PEM_STRING_X509_REQ,fp,(char *)x, \
339                         NULL,NULL,0,NULL,NULL)
340 #define PEM_write_X509_CRL(fp,x) \
341                 PEM_ASN1_write((int (*)())i2d_X509_CRL,PEM_STRING_X509_CRL, \
342                         fp,(char *)x, NULL,NULL,0,NULL,NULL)
343 #define PEM_write_RSAPrivateKey(fp,x,enc,kstr,klen,cb,u) \
344                 PEM_ASN1_write((int (*)())i2d_RSAPrivateKey,PEM_STRING_RSA,fp,\
345                         (char *)x,enc,kstr,klen,cb,u)
346 #define PEM_write_RSAPublicKey(fp,x) \
347                 PEM_ASN1_write((int (*)())i2d_RSAPublicKey,\
348                         PEM_STRING_RSA_PUBLIC,fp,(char *)x,NULL,NULL,0,NULL,NULL)
349 #define PEM_write_DSAPrivateKey(fp,x,enc,kstr,klen,cb,u) \
350                 PEM_ASN1_write((int (*)())i2d_DSAPrivateKey,PEM_STRING_DSA,fp,\
351                         (char *)x,enc,kstr,klen,cb,u)
352 #define PEM_write_PrivateKey(bp,x,enc,kstr,klen,cb,u) \
353                 PEM_ASN1_write((int (*)())i2d_PrivateKey,\
354                 (((x)->type == EVP_PKEY_DSA)?PEM_STRING_DSA:PEM_STRING_RSA),\
355                         bp,(char *)x,enc,kstr,klen,cb,u)
356 #define PEM_write_PKCS7(fp,x) \
357                 PEM_ASN1_write((int (*)())i2d_PKCS7,PEM_STRING_PKCS7,fp, \
358                         (char *)x, NULL,NULL,0,NULL,NULL)
359 #define PEM_write_DHparams(fp,x) \
360                 PEM_ASN1_write((int (*)())i2d_DHparams,PEM_STRING_DHPARAMS,fp,\
361                         (char *)x,NULL,NULL,0,NULL,NULL)
362
363 #define PEM_write_NETSCAPE_CERT_SEQUENCE(fp,x) \
364                 PEM_ASN1_write((int (*)())i2d_NETSCAPE_CERT_SEQUENCE, \
365                         PEM_STRING_X509,fp, \
366                         (char *)x, NULL,NULL,0,NULL,NULL)
367
368 #define PEM_read_SSL_SESSION(fp,x,cb,u) (SSL_SESSION *)PEM_ASN1_read( \
369         (char *(*)())d2i_SSL_SESSION,PEM_STRING_SSL_SESSION,fp,(char **)x,cb,u)
370 #define PEM_read_X509(fp,x,cb,u) (X509 *)PEM_ASN1_read( \
371         (char *(*)())d2i_X509,PEM_STRING_X509,fp,(char **)x,cb,u)
372 #define PEM_read_X509_REQ(fp,x,cb,u) (X509_REQ *)PEM_ASN1_read( \
373         (char *(*)())d2i_X509_REQ,PEM_STRING_X509_REQ,fp,(char **)x,cb,u)
374 #define PEM_read_X509_CRL(fp,x,cb,u) (X509_CRL *)PEM_ASN1_read( \
375         (char *(*)())d2i_X509_CRL,PEM_STRING_X509_CRL,fp,(char **)x,cb,u)
376 #define PEM_read_RSAPrivateKey(fp,x,cb,u) (RSA *)PEM_ASN1_read( \
377         (char *(*)())d2i_RSAPrivateKey,PEM_STRING_RSA,fp,(char **)x,cb,u)
378 #define PEM_read_RSAPublicKey(fp,x,cb,u) (RSA *)PEM_ASN1_read( \
379         (char *(*)())d2i_RSAPublicKey,PEM_STRING_RSA_PUBLIC,fp,(char **)x,cb,u)
380 #define PEM_read_DSAPrivateKey(fp,x,cb,u) (DSA *)PEM_ASN1_read( \
381         (char *(*)())d2i_DSAPrivateKey,PEM_STRING_DSA,fp,(char **)x,cb,u)
382 #define PEM_read_PrivateKey(fp,x,cb,u) (EVP_PKEY *)PEM_ASN1_read( \
383         (char *(*)())d2i_PrivateKey,PEM_STRING_EVP_PKEY,fp,(char **)x,cb,u)
384 #define PEM_read_PKCS7(fp,x,cb,u) (PKCS7 *)PEM_ASN1_read( \
385         (char *(*)())d2i_PKCS7,PEM_STRING_PKCS7,fp,(char **)x,cb,u)
386 #define PEM_read_DHparams(fp,x,cb,u) (DH *)PEM_ASN1_read( \
387         (char *(*)())d2i_DHparams,PEM_STRING_DHPARAMS,fp,(char **)x,cb,u)
388
389 #define PEM_read_NETSCAPE_CERT_SEQUENCE(fp,x,cb,u) \
390                 (NETSCAPE_CERT_SEQUENCE *)PEM_ASN1_read( \
391         (char *(*)())d2i_NETSCAPE_CERT_SEQUENCE,PEM_STRING_X509,fp,\
392                                                         (char **)x,cb,u)
393
394 #define PEM_write_bio_SSL_SESSION(bp,x) \
395                 PEM_ASN1_write_bio((int (*)())i2d_SSL_SESSION, \
396                         PEM_STRING_SSL_SESSION,bp, (char *)x, NULL,NULL,0,NULL,NULL)
397 #define PEM_write_bio_X509(bp,x) \
398                 PEM_ASN1_write_bio((int (*)())i2d_X509,PEM_STRING_X509,bp, \
399                         (char *)x, NULL,NULL,0,NULL,NULL)
400 #define PEM_write_bio_X509_REQ(bp,x) PEM_ASN1_write_bio( \
401                 (int (*)())i2d_X509_REQ,PEM_STRING_X509_REQ,bp,(char *)x, \
402                         NULL,NULL,0,NULL,NULL)
403 #define PEM_write_bio_X509_CRL(bp,x) \
404                 PEM_ASN1_write_bio((int (*)())i2d_X509_CRL,PEM_STRING_X509_CRL,\
405                         bp,(char *)x, NULL,NULL,0,NULL,NULL)
406 #define PEM_write_bio_RSAPrivateKey(bp,x,enc,kstr,klen,cb,u) \
407                 PEM_ASN1_write_bio((int (*)())i2d_RSAPrivateKey,PEM_STRING_RSA,\
408                         bp,(char *)x,enc,kstr,klen,cb,u)
409 #define PEM_write_bio_RSAPublicKey(bp,x) \
410                 PEM_ASN1_write_bio((int (*)())i2d_RSAPublicKey, \
411                         PEM_STRING_RSA_PUBLIC,\
412                         bp,(char *)x,NULL,NULL,0,NULL,NULL)
413 #define PEM_write_bio_DSAPrivateKey(bp,x,enc,kstr,klen,cb,u) \
414                 PEM_ASN1_write_bio((int (*)())i2d_DSAPrivateKey,PEM_STRING_DSA,\
415                         bp,(char *)x,enc,kstr,klen,cb,u)
416 #define PEM_write_bio_PrivateKey(bp,x,enc,kstr,klen,cb,u) \
417                 PEM_ASN1_write_bio((int (*)())i2d_PrivateKey,\
418                 (((x)->type == EVP_PKEY_DSA)?PEM_STRING_DSA:PEM_STRING_RSA),\
419                         bp,(char *)x,enc,kstr,klen,cb,u)
420 #define PEM_write_bio_PKCS7(bp,x) \
421                 PEM_ASN1_write_bio((int (*)())i2d_PKCS7,PEM_STRING_PKCS7,bp, \
422                         (char *)x, NULL,NULL,0,NULL,NULL)
423 #define PEM_write_bio_DHparams(bp,x) \
424                 PEM_ASN1_write_bio((int (*)())i2d_DHparams,PEM_STRING_DHPARAMS,\
425                         bp,(char *)x,NULL,NULL,0,NULL,NULL)
426 #define PEM_write_bio_DSAparams(bp,x) \
427                 PEM_ASN1_write_bio((int (*)())i2d_DSAparams, \
428                         PEM_STRING_DSAPARAMS,bp,(char *)x,NULL,NULL,0,NULL,NULL)
429
430 #define PEM_write_bio_NETSCAPE_CERT_SEQUENCE(bp,x) \
431                 PEM_ASN1_write_bio((int (*)())i2d_NETSCAPE_CERT_SEQUENCE, \
432                         PEM_STRING_X509,bp, \
433                         (char *)x, NULL,NULL,0,NULL,NULL)
434
435 #define PEM_read_bio_SSL_SESSION(bp,x,cb,u) (SSL_SESSION *)PEM_ASN1_read_bio( \
436         (char *(*)())d2i_SSL_SESSION,PEM_STRING_SSL_SESSION,bp,(char **)x,cb,u)
437 #define PEM_read_bio_X509(bp,x,cb,u) (X509 *)PEM_ASN1_read_bio( \
438         (char *(*)())d2i_X509,PEM_STRING_X509,bp,(char **)x,cb,u)
439 #define PEM_read_bio_X509_REQ(bp,x,cb,u) (X509_REQ *)PEM_ASN1_read_bio( \
440         (char *(*)())d2i_X509_REQ,PEM_STRING_X509_REQ,bp,(char **)x,cb,u)
441 #define PEM_read_bio_X509_CRL(bp,x,cb,u) (X509_CRL *)PEM_ASN1_read_bio( \
442         (char *(*)())d2i_X509_CRL,PEM_STRING_X509_CRL,bp,(char **)x,cb,u)
443 #define PEM_read_bio_RSAPrivateKey(bp,x,cb,u) (RSA *)PEM_ASN1_read_bio( \
444         (char *(*)())d2i_RSAPrivateKey,PEM_STRING_RSA,bp,(char **)x,cb,u)
445 #define PEM_read_bio_RSAPublicKey(bp,x,cb,u) (RSA *)PEM_ASN1_read_bio( \
446         (char *(*)())d2i_RSAPublicKey,PEM_STRING_RSA_PUBLIC,bp,(char **)x,cb,u)
447 #define PEM_read_bio_DSAPrivateKey(bp,x,cb,u) (DSA *)PEM_ASN1_read_bio( \
448         (char *(*)())d2i_DSAPrivateKey,PEM_STRING_DSA,bp,(char **)x,cb,u)
449 #define PEM_read_bio_PrivateKey(bp,x,cb,u) (EVP_PKEY *)PEM_ASN1_read_bio( \
450         (char *(*)())d2i_PrivateKey,PEM_STRING_EVP_PKEY,bp,(char **)x,cb,u)
451
452 #define PEM_read_bio_PKCS7(bp,x,cb,u) (PKCS7 *)PEM_ASN1_read_bio( \
453         (char *(*)())d2i_PKCS7,PEM_STRING_PKCS7,bp,(char **)x,cb,u)
454 #define PEM_read_bio_DHparams(bp,x,cb,u) (DH *)PEM_ASN1_read_bio( \
455         (char *(*)())d2i_DHparams,PEM_STRING_DHPARAMS,bp,(char **)x,cb,u)
456 #define PEM_read_bio_DSAparams(bp,x,cb,u) (DSA *)PEM_ASN1_read_bio( \
457         (char *(*)())d2i_DSAparams,PEM_STRING_DSAPARAMS,bp,(char **)x,cb,u)
458
459 #define PEM_read_bio_NETSCAPE_CERT_SEQUENCE(bp,x,cb,u) \
460                 (NETSCAPE_CERT_SEQUENCE *)PEM_ASN1_read_bio( \
461         (char *(*)())d2i_NETSCAPE_CERT_SEQUENCE,PEM_STRING_X509,bp,\
462                                                         (char **)x,cb,u)
463
464 #endif
465
466 #if 1
467 /* "userdata": new with OpenSSL 0.9.4 */
468 typedef int pem_password_cb(char *buf, int size, int rwflag, void *userdata);
469 #else
470 /* OpenSSL 0.9.3, 0.9.3a */
471 typedef int pem_password_cb(char *buf, int size, int rwflag);
472 #endif
473
474 int     PEM_get_EVP_CIPHER_INFO(char *header, EVP_CIPHER_INFO *cipher);
475 int     PEM_do_header (EVP_CIPHER_INFO *cipher, unsigned char *data,long *len,
476         pem_password_cb *callback,void *u);
477
478 #ifdef HEADER_BIO_H
479 int     PEM_read_bio(BIO *bp, char **name, char **header,
480                 unsigned char **data,long *len);
481 int     PEM_write_bio(BIO *bp,const char *name,char *hdr,unsigned char *data,
482                 long len);
483 char *  PEM_ASN1_read_bio(char *(*d2i)(),const char *name,BIO *bp,char **x,
484                 pem_password_cb *cb, void *u);
485 int     PEM_ASN1_write_bio(int (*i2d)(),const char *name,BIO *bp,char *x,
486                            const EVP_CIPHER *enc,unsigned char *kstr,int klen,
487                            pem_password_cb *cb, void *u);
488 STACK_OF(X509_INFO) *   PEM_X509_INFO_read_bio(BIO *bp, STACK_OF(X509_INFO) *sk, pem_password_cb *cb, void *u);
489 int     PEM_X509_INFO_write_bio(BIO *bp,X509_INFO *xi, EVP_CIPHER *enc,
490                 unsigned char *kstr, int klen, pem_password_cb *cd, void *u);
491 #endif
492
493 #ifndef WIN16
494 int     PEM_read(FILE *fp, char **name, char **header,
495                 unsigned char **data,long *len);
496 int     PEM_write(FILE *fp,char *name,char *hdr,unsigned char *data,long len);
497 char *  PEM_ASN1_read(char *(*d2i)(),const char *name,FILE *fp,char **x,
498         pem_password_cb *cb, void *u);
499 int     PEM_ASN1_write(int (*i2d)(),const char *name,FILE *fp,char *x,
500                        const EVP_CIPHER *enc,unsigned char *kstr,int klen,
501                        pem_password_cb *callback, void *u);
502 STACK_OF(X509_INFO) *   PEM_X509_INFO_read(FILE *fp, STACK_OF(X509_INFO) *sk,
503         pem_password_cb *cb, void *u);
504 #endif
505
506 int     PEM_SealInit(PEM_ENCODE_SEAL_CTX *ctx, EVP_CIPHER *type,
507                 EVP_MD *md_type, unsigned char **ek, int *ekl,
508                 unsigned char *iv, EVP_PKEY **pubk, int npubk);
509 void    PEM_SealUpdate(PEM_ENCODE_SEAL_CTX *ctx, unsigned char *out, int *outl,
510                 unsigned char *in, int inl);
511 int     PEM_SealFinal(PEM_ENCODE_SEAL_CTX *ctx, unsigned char *sig,int *sigl,
512                 unsigned char *out, int *outl, EVP_PKEY *priv);
513
514 void    PEM_SignInit(EVP_MD_CTX *ctx, EVP_MD *type);
515 void    PEM_SignUpdate(EVP_MD_CTX *ctx,unsigned char *d,unsigned int cnt);
516 int     PEM_SignFinal(EVP_MD_CTX *ctx, unsigned char *sigret,
517                 unsigned int *siglen, EVP_PKEY *pkey);
518
519 void    ERR_load_PEM_strings(void);
520
521 void    PEM_proc_type(char *buf, int type);
522 void    PEM_dek_info(char *buf, const char *type, int len, char *str);
523
524 #ifndef SSLEAY_MACROS
525
526 #ifdef VMS
527 #include <openssl/vms_idhacks.h>
528 #endif
529
530 DECLARE_PEM_rw(X509, X509)
531
532 DECLARE_PEM_rw(X509_REQ, X509_REQ)
533
534 DECLARE_PEM_rw(X509_CRL, X509_CRL)
535
536 DECLARE_PEM_rw(PKCS7, PKCS7)
537
538 DECLARE_PEM_rw(NETSCAPE_CERT_SEQUENCE, NETSCAPE_CERT_SEQUENCE)
539
540 DECLARE_PEM_rw(PKCS8, X509_SIG)
541
542 DECLARE_PEM_rw(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO)
543
544 #ifndef NO_RSA
545
546 DECLARE_PEM_rw_cb(RSAPrivateKey, RSA)
547
548 DECLARE_PEM_rw(RSAPublicKey, RSA)
549
550 #endif
551
552 #ifndef NO_DSA
553
554 DECLARE_PEM_rw_cb(DSAPrivateKey, DSA)
555
556 DECLARE_PEM_rw(DSAPublicKey, DSA)
557
558 DECLARE_PEM_rw(DSAparams, DSA)
559
560 #endif
561
562 #ifndef NO_DH
563
564 DECLARE_PEM_rw(DHparams, DH)
565
566 #endif
567
568 DECLARE_PEM_rw_cb(PrivateKey, EVP_PKEY)
569
570 int PEM_write_bio_PKCS8PrivateKey(BIO *, EVP_PKEY *, const EVP_CIPHER *,
571                                   char *, int, pem_password_cb *, void *);
572 int PEM_write_PKCS8PrivateKey(FILE *fp,EVP_PKEY *x,const EVP_CIPHER *enc,
573                               char *kstr,int klen, pem_password_cb *cd, void *u);
574 #endif /* SSLEAY_MACROS */
575
576
577 /* BEGIN ERROR CODES */
578 /* The following lines are auto generated by the script mkerr.pl. Any changes
579  * made after this point may be overwritten when the script is next run.
580  */
581
582 /* Error codes for the PEM functions. */
583
584 /* Function codes. */
585 #define PEM_F_DEF_CALLBACK                               100
586 #define PEM_F_LOAD_IV                                    101
587 #define PEM_F_PEM_ASN1_READ                              102
588 #define PEM_F_PEM_ASN1_READ_BIO                          103
589 #define PEM_F_PEM_ASN1_WRITE                             104
590 #define PEM_F_PEM_ASN1_WRITE_BIO                         105
591 #define PEM_F_PEM_DO_HEADER                              106
592 #define PEM_F_PEM_F_PEM_WRITE_PKCS8PRIVATEKEY            118
593 #define PEM_F_PEM_GET_EVP_CIPHER_INFO                    107
594 #define PEM_F_PEM_READ                                   108
595 #define PEM_F_PEM_READ_BIO                               109
596 #define PEM_F_PEM_SEALFINAL                              110
597 #define PEM_F_PEM_SEALINIT                               111
598 #define PEM_F_PEM_SIGNFINAL                              112
599 #define PEM_F_PEM_WRITE                                  113
600 #define PEM_F_PEM_WRITE_BIO                              114
601 #define PEM_F_PEM_WRITE_BIO_PKCS8PRIVATEKEY              119
602 #define PEM_F_PEM_X509_INFO_READ                         115
603 #define PEM_F_PEM_X509_INFO_READ_BIO                     116
604 #define PEM_F_PEM_X509_INFO_WRITE_BIO                    117
605
606 /* Reason codes. */
607 #define PEM_R_BAD_BASE64_DECODE                          100
608 #define PEM_R_BAD_DECRYPT                                101
609 #define PEM_R_BAD_END_LINE                               102
610 #define PEM_R_BAD_IV_CHARS                               103
611 #define PEM_R_BAD_PASSWORD_READ                          104
612 #define PEM_R_ERROR_CONVERTING_PRIVATE_KEY               115
613 #define PEM_R_NOT_DEK_INFO                               105
614 #define PEM_R_NOT_ENCRYPTED                              106
615 #define PEM_R_NOT_PROC_TYPE                              107
616 #define PEM_R_NO_START_LINE                              108
617 #define PEM_R_PROBLEMS_GETTING_PASSWORD                  109
618 #define PEM_R_PUBLIC_KEY_NO_RSA                          110
619 #define PEM_R_READ_KEY                                   111
620 #define PEM_R_SHORT_HEADER                               112
621 #define PEM_R_UNSUPPORTED_CIPHER                         113
622 #define PEM_R_UNSUPPORTED_ENCRYPTION                     114
623
624 #ifdef  __cplusplus
625 }
626 #endif
627 #endif
628