9e551d1795f913e1afe65bcce4b50af809d27c9f
[openssl.git] / crypto / pem / pem_lib.c
1 /* crypto/pem/pem_lib.c */
2 /* Copyright (C) 1995-1998 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 #include <stdio.h>
60 #include <ctype.h>
61 #include "cryptlib.h"
62 #include <openssl/buffer.h>
63 #include <openssl/objects.h>
64 #include <openssl/evp.h>
65 #include <openssl/rand.h>
66 #include <openssl/x509.h>
67 #include <openssl/pem.h>
68 #include <openssl/pkcs12.h>
69 #include "asn1_locl.h"
70 #ifndef OPENSSL_NO_DES
71 #include <openssl/des.h>
72 #endif
73 #ifndef OPENSSL_NO_ENGINE
74 #include <openssl/engine.h>
75 #endif
76
77 const char PEM_version[]="PEM" OPENSSL_VERSION_PTEXT;
78
79 #define MIN_LENGTH      4
80
81 static int load_iv(char **fromp,unsigned char *to, int num);
82 static int check_pem(const char *nm, const char *name);
83 int pem_check_suffix(const char *pem_str, const char *suffix);
84
85 int PEM_def_callback(char *buf, int num, int w, void *key)
86         {
87 #ifdef OPENSSL_NO_FP_API
88         /* We should not ever call the default callback routine from
89          * windows. */
90         PEMerr(PEM_F_PEM_DEF_CALLBACK,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
91         return(-1);
92 #else
93         int i,j;
94         const char *prompt;
95         if(key) {
96                 i=strlen(key);
97                 i=(i > num)?num:i;
98                 memcpy(buf,key,i);
99                 return(i);
100         }
101
102         prompt=EVP_get_pw_prompt();
103         if (prompt == NULL)
104                 prompt="Enter PEM pass phrase:";
105
106         for (;;)
107                 {
108                 i=EVP_read_pw_string_min(buf,MIN_LENGTH,num,prompt,w);
109                 if (i != 0)
110                         {
111                         PEMerr(PEM_F_PEM_DEF_CALLBACK,PEM_R_PROBLEMS_GETTING_PASSWORD);
112                         memset(buf,0,(unsigned int)num);
113                         return(-1);
114                         }
115                 j=strlen(buf);
116                 if (j < MIN_LENGTH)
117                         {
118                         fprintf(stderr,"phrase is too short, needs to be at least %d chars\n",MIN_LENGTH);
119                         }
120                 else
121                         break;
122                 }
123         return(j);
124 #endif
125         }
126
127 void PEM_proc_type(char *buf, int type)
128         {
129         const char *str;
130
131         if (type == PEM_TYPE_ENCRYPTED)
132                 str="ENCRYPTED";
133         else if (type == PEM_TYPE_MIC_CLEAR)
134                 str="MIC-CLEAR";
135         else if (type == PEM_TYPE_MIC_ONLY)
136                 str="MIC-ONLY";
137         else
138                 str="BAD-TYPE";
139                 
140         BUF_strlcat(buf,"Proc-Type: 4,",PEM_BUFSIZE);
141         BUF_strlcat(buf,str,PEM_BUFSIZE);
142         BUF_strlcat(buf,"\n",PEM_BUFSIZE);
143         }
144
145 void PEM_dek_info(char *buf, const char *type, int len, char *str)
146         {
147         static const unsigned char map[17]="0123456789ABCDEF";
148         long i;
149         int j;
150
151         BUF_strlcat(buf,"DEK-Info: ",PEM_BUFSIZE);
152         BUF_strlcat(buf,type,PEM_BUFSIZE);
153         BUF_strlcat(buf,",",PEM_BUFSIZE);
154         j=strlen(buf);
155         if (j + (len * 2) + 1 > PEM_BUFSIZE)
156                 return;
157         for (i=0; i<len; i++)
158                 {
159                 buf[j+i*2]  =map[(str[i]>>4)&0x0f];
160                 buf[j+i*2+1]=map[(str[i]   )&0x0f];
161                 }
162         buf[j+i*2]='\n';
163         buf[j+i*2+1]='\0';
164         }
165
166 #ifndef OPENSSL_NO_FP_API
167 void *PEM_ASN1_read(d2i_of_void *d2i, const char *name, FILE *fp, void **x,
168                     pem_password_cb *cb, void *u)
169         {
170         BIO *b;
171         void *ret;
172
173         if ((b=BIO_new(BIO_s_file())) == NULL)
174                 {
175                 PEMerr(PEM_F_PEM_ASN1_READ,ERR_R_BUF_LIB);
176                 return(0);
177                 }
178         BIO_set_fp(b,fp,BIO_NOCLOSE);
179         ret=PEM_ASN1_read_bio(d2i,name,b,x,cb,u);
180         BIO_free(b);
181         return(ret);
182         }
183 #endif
184
185 static int check_pem(const char *nm, const char *name)
186 {
187         /* Normal matching nm and name */
188         if (!strcmp(nm,name)) return 1;
189
190         /* Make PEM_STRING_EVP_PKEY match any private key */
191
192         if(!strcmp(name,PEM_STRING_EVP_PKEY))
193                 {
194                 int slen;
195                 const EVP_PKEY_ASN1_METHOD *ameth;
196                 if(!strcmp(nm,PEM_STRING_PKCS8))
197                         return 1;
198                 if(!strcmp(nm,PEM_STRING_PKCS8INF))
199                         return 1;
200                 slen = pem_check_suffix(nm, "PRIVATE KEY"); 
201                 if (slen > 0)
202                         {
203                         /* NB: ENGINE implementations wont contain
204                          * a deprecated old private key decode function
205                          * so don't look for them.
206                          */
207                         ameth = EVP_PKEY_asn1_find_str(NULL, nm, slen);
208                         if (ameth && ameth->old_priv_decode)
209                                 return 1;
210                         }
211                 return 0;
212                 }
213
214         if(!strcmp(name,PEM_STRING_PARAMETERS))
215                 {
216                 int slen;
217                 const EVP_PKEY_ASN1_METHOD *ameth;
218                 slen = pem_check_suffix(nm, "PARAMETERS"); 
219                 if (slen > 0)
220                         {
221                         ENGINE *e;
222                         ameth = EVP_PKEY_asn1_find_str(&e, nm, slen);
223                         if (ameth)
224                                 {
225                                 int r;
226                                 if (ameth->param_decode)
227                                         r = 1;
228                                 else
229                                         r = 0;
230 #ifndef OPENSSL_NO_ENGINE
231                                 if (e)
232                                         ENGINE_finish(e);
233 #endif
234                                 return r;
235                                 }
236                         }
237                 return 0;
238                 }
239         /* If reading DH parameters handle X9.42 DH format too */
240         if(!strcmp(nm,PEM_STRING_DHXPARAMS) &&
241                 !strcmp(name,PEM_STRING_DHPARAMS)) return 1;
242
243         /* Permit older strings */
244
245         if(!strcmp(nm,PEM_STRING_X509_OLD) &&
246                 !strcmp(name,PEM_STRING_X509)) return 1;
247
248         if(!strcmp(nm,PEM_STRING_X509_REQ_OLD) &&
249                 !strcmp(name,PEM_STRING_X509_REQ)) return 1;
250
251         /* Allow normal certs to be read as trusted certs */
252         if(!strcmp(nm,PEM_STRING_X509) &&
253                 !strcmp(name,PEM_STRING_X509_TRUSTED)) return 1;
254
255         if(!strcmp(nm,PEM_STRING_X509_OLD) &&
256                 !strcmp(name,PEM_STRING_X509_TRUSTED)) return 1;
257
258         /* Some CAs use PKCS#7 with CERTIFICATE headers */
259         if(!strcmp(nm, PEM_STRING_X509) &&
260                 !strcmp(name, PEM_STRING_PKCS7)) return 1;
261
262         if(!strcmp(nm, PEM_STRING_PKCS7_SIGNED) &&
263                 !strcmp(name, PEM_STRING_PKCS7)) return 1;
264
265 #ifndef OPENSSL_NO_CMS
266         if(!strcmp(nm, PEM_STRING_X509) &&
267                 !strcmp(name, PEM_STRING_CMS)) return 1;
268         /* Allow CMS to be read from PKCS#7 headers */
269         if(!strcmp(nm, PEM_STRING_PKCS7) &&
270                 !strcmp(name, PEM_STRING_CMS)) return 1;
271 #endif
272
273         return 0;
274 }
275
276 int PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm, const char *name, BIO *bp,
277              pem_password_cb *cb, void *u)
278         {
279         EVP_CIPHER_INFO cipher;
280         char *nm=NULL,*header=NULL;
281         unsigned char *data=NULL;
282         long len;
283         int ret = 0;
284
285         for (;;)
286                 {
287                 if (!PEM_read_bio(bp,&nm,&header,&data,&len)) {
288                         if(ERR_GET_REASON(ERR_peek_error()) ==
289                                 PEM_R_NO_START_LINE)
290                                 ERR_add_error_data(2, "Expecting: ", name);
291                         return 0;
292                 }
293                 if(check_pem(nm, name)) break;
294                 OPENSSL_free(nm);
295                 OPENSSL_free(header);
296                 OPENSSL_free(data);
297                 }
298         if (!PEM_get_EVP_CIPHER_INFO(header,&cipher)) goto err;
299         if (!PEM_do_header(&cipher,data,&len,cb,u)) goto err;
300
301         *pdata = data;
302         *plen = len;
303
304         if (pnm)
305                 *pnm = nm;
306
307         ret = 1;
308
309 err:
310         if (!ret || !pnm) OPENSSL_free(nm);
311         OPENSSL_free(header);
312         if (!ret) OPENSSL_free(data);
313         return ret;
314         }
315
316 #ifndef OPENSSL_NO_FP_API
317 int PEM_ASN1_write(i2d_of_void *i2d, const char *name, FILE *fp,
318                    void *x, const EVP_CIPHER *enc, unsigned char *kstr,
319                    int klen, pem_password_cb *callback, void *u)
320         {
321         BIO *b;
322         int ret;
323
324         if ((b=BIO_new(BIO_s_file())) == NULL)
325                 {
326                 PEMerr(PEM_F_PEM_ASN1_WRITE,ERR_R_BUF_LIB);
327                 return(0);
328                 }
329         BIO_set_fp(b,fp,BIO_NOCLOSE);
330         ret=PEM_ASN1_write_bio(i2d,name,b,x,enc,kstr,klen,callback,u);
331         BIO_free(b);
332         return(ret);
333         }
334 #endif
335
336 int PEM_ASN1_write_bio(i2d_of_void *i2d, const char *name, BIO *bp,
337                        void *x, const EVP_CIPHER *enc, unsigned char *kstr,
338                        int klen, pem_password_cb *callback, void *u)
339         {
340         EVP_CIPHER_CTX ctx;
341         int dsize=0,i,j,ret=0;
342         unsigned char *p,*data=NULL;
343         const char *objstr=NULL;
344         char buf[PEM_BUFSIZE];
345         unsigned char key[EVP_MAX_KEY_LENGTH];
346         unsigned char iv[EVP_MAX_IV_LENGTH];
347         
348         if (enc != NULL)
349                 {
350                 objstr=OBJ_nid2sn(EVP_CIPHER_nid(enc));
351                 if (objstr == NULL)
352                         {
353                         PEMerr(PEM_F_PEM_ASN1_WRITE_BIO,PEM_R_UNSUPPORTED_CIPHER);
354                         goto err;
355                         }
356                 }
357
358         if ((dsize=i2d(x,NULL)) < 0)
359                 {
360                 PEMerr(PEM_F_PEM_ASN1_WRITE_BIO,ERR_R_ASN1_LIB);
361                 dsize=0;
362                 goto err;
363                 }
364         /* dzise + 8 bytes are needed */
365         /* actually it needs the cipher block size extra... */
366         data=(unsigned char *)OPENSSL_malloc((unsigned int)dsize+20);
367         if (data == NULL)
368                 {
369                 PEMerr(PEM_F_PEM_ASN1_WRITE_BIO,ERR_R_MALLOC_FAILURE);
370                 goto err;
371                 }
372         p=data;
373         i=i2d(x,&p);
374
375         if (enc != NULL)
376                 {
377                 if (kstr == NULL)
378                         {
379                         if (callback == NULL)
380                                 klen=PEM_def_callback(buf,PEM_BUFSIZE,1,u);
381                         else
382                                 klen=(*callback)(buf,PEM_BUFSIZE,1,u);
383                         if (klen <= 0)
384                                 {
385                                 PEMerr(PEM_F_PEM_ASN1_WRITE_BIO,PEM_R_READ_KEY);
386                                 goto err;
387                                 }
388 #ifdef CHARSET_EBCDIC
389                         /* Convert the pass phrase from EBCDIC */
390                         ebcdic2ascii(buf, buf, klen);
391 #endif
392                         kstr=(unsigned char *)buf;
393                         }
394                 RAND_add(data,i,0);/* put in the RSA key. */
395                 OPENSSL_assert(enc->iv_len <= (int)sizeof(iv));
396                 if (RAND_pseudo_bytes(iv,enc->iv_len) < 0) /* Generate a salt */
397                         goto err;
398                 /* The 'iv' is used as the iv and as a salt.  It is
399                  * NOT taken from the BytesToKey function */
400                 if (!EVP_BytesToKey(enc,EVP_md5(),iv,kstr,klen,1,key,NULL))
401                         goto err;
402
403                 if (kstr == (unsigned char *)buf) OPENSSL_cleanse(buf,PEM_BUFSIZE);
404
405                 OPENSSL_assert(strlen(objstr)+23+2*enc->iv_len+13 <= sizeof buf);
406
407                 buf[0]='\0';
408                 PEM_proc_type(buf,PEM_TYPE_ENCRYPTED);
409                 PEM_dek_info(buf,objstr,enc->iv_len,(char *)iv);
410                 /* k=strlen(buf); */
411
412                 EVP_CIPHER_CTX_init(&ctx);
413                 ret = 1;
414                 if (!EVP_EncryptInit_ex(&ctx,enc,NULL,key,iv)
415                         || !EVP_EncryptUpdate(&ctx,data,&j,data,i)
416                         || !EVP_EncryptFinal_ex(&ctx,&(data[j]),&i))
417                         ret = 0;
418                 EVP_CIPHER_CTX_cleanup(&ctx);
419                 if (ret == 0)
420                         goto err;
421                 i+=j;
422                 }
423         else
424                 {
425                 ret=1;
426                 buf[0]='\0';
427                 }
428         i=PEM_write_bio(bp,name,buf,data,i);
429         if (i <= 0) ret=0;
430 err:
431         OPENSSL_cleanse(key,sizeof(key));
432         OPENSSL_cleanse(iv,sizeof(iv));
433         OPENSSL_cleanse((char *)&ctx,sizeof(ctx));
434         OPENSSL_cleanse(buf,PEM_BUFSIZE);
435         if (data != NULL)
436                 {
437                 OPENSSL_cleanse(data,(unsigned int)dsize);
438                 OPENSSL_free(data);
439                 }
440         return(ret);
441         }
442
443 int PEM_do_header(EVP_CIPHER_INFO *cipher, unsigned char *data, long *plen,
444              pem_password_cb *callback,void *u)
445         {
446         int i,j,o,klen;
447         long len;
448         EVP_CIPHER_CTX ctx;
449         unsigned char key[EVP_MAX_KEY_LENGTH];
450         char buf[PEM_BUFSIZE];
451
452         len= *plen;
453
454         if (cipher->cipher == NULL) return(1);
455         if (callback == NULL)
456                 klen=PEM_def_callback(buf,PEM_BUFSIZE,0,u);
457         else
458                 klen=callback(buf,PEM_BUFSIZE,0,u);
459         if (klen <= 0)
460                 {
461                 PEMerr(PEM_F_PEM_DO_HEADER,PEM_R_BAD_PASSWORD_READ);
462                 return(0);
463                 }
464 #ifdef CHARSET_EBCDIC
465         /* Convert the pass phrase from EBCDIC */
466         ebcdic2ascii(buf, buf, klen);
467 #endif
468
469         if (!EVP_BytesToKey(cipher->cipher,EVP_md5(),&(cipher->iv[0]),
470                 (unsigned char *)buf,klen,1,key,NULL))
471                 return 0;
472
473         j=(int)len;
474         EVP_CIPHER_CTX_init(&ctx);
475         o = EVP_DecryptInit_ex(&ctx,cipher->cipher,NULL, key,&(cipher->iv[0]));
476         if (o)
477                 o = EVP_DecryptUpdate(&ctx,data,&i,data,j);
478         if (o)
479                 o = EVP_DecryptFinal_ex(&ctx,&(data[i]),&j);
480         EVP_CIPHER_CTX_cleanup(&ctx);
481         OPENSSL_cleanse((char *)buf,sizeof(buf));
482         OPENSSL_cleanse((char *)key,sizeof(key));
483         j+=i;
484         if (!o)
485                 {
486                 PEMerr(PEM_F_PEM_DO_HEADER,PEM_R_BAD_DECRYPT);
487                 return(0);
488                 }
489         *plen=j;
490         return(1);
491         }
492
493 int PEM_get_EVP_CIPHER_INFO(char *header, EVP_CIPHER_INFO *cipher)
494         {
495         const EVP_CIPHER *enc=NULL;
496         char *p,c;
497         char **header_pp = &header;
498
499         cipher->cipher=NULL;
500         if ((header == NULL) || (*header == '\0') || (*header == '\n'))
501                 return(1);
502         if (strncmp(header,"Proc-Type: ",11) != 0)
503                 { PEMerr(PEM_F_PEM_GET_EVP_CIPHER_INFO,PEM_R_NOT_PROC_TYPE); return(0); }
504         header+=11;
505         if (*header != '4') return(0); header++;
506         if (*header != ',') return(0); header++;
507         if (strncmp(header,"ENCRYPTED",9) != 0)
508                 { PEMerr(PEM_F_PEM_GET_EVP_CIPHER_INFO,PEM_R_NOT_ENCRYPTED); return(0); }
509         for (; (*header != '\n') && (*header != '\0'); header++)
510                 ;
511         if (*header == '\0')
512                 { PEMerr(PEM_F_PEM_GET_EVP_CIPHER_INFO,PEM_R_SHORT_HEADER); return(0); }
513         header++;
514         if (strncmp(header,"DEK-Info: ",10) != 0)
515                 { PEMerr(PEM_F_PEM_GET_EVP_CIPHER_INFO,PEM_R_NOT_DEK_INFO); return(0); }
516         header+=10;
517
518         p=header;
519         for (;;)
520                 {
521                 c= *header;
522 #ifndef CHARSET_EBCDIC
523                 if (!(  ((c >= 'A') && (c <= 'Z')) || (c == '-') ||
524                         ((c >= '0') && (c <= '9'))))
525                         break;
526 #else
527                 if (!(  isupper(c) || (c == '-') ||
528                         isdigit(c)))
529                         break;
530 #endif
531                 header++;
532                 }
533         *header='\0';
534         cipher->cipher=enc=EVP_get_cipherbyname(p);
535         *header=c;
536         header++;
537
538         if (enc == NULL)
539                 {
540                 PEMerr(PEM_F_PEM_GET_EVP_CIPHER_INFO,PEM_R_UNSUPPORTED_ENCRYPTION);
541                 return(0);
542                 }
543         if (!load_iv(header_pp,&(cipher->iv[0]),enc->iv_len))
544                 return(0);
545
546         return(1);
547         }
548
549 static int load_iv(char **fromp, unsigned char *to, int num)
550         {
551         int v,i;
552         char *from;
553
554         from= *fromp;
555         for (i=0; i<num; i++) to[i]=0;
556         num*=2;
557         for (i=0; i<num; i++)
558                 {
559                 if ((*from >= '0') && (*from <= '9'))
560                         v= *from-'0';
561                 else if ((*from >= 'A') && (*from <= 'F'))
562                         v= *from-'A'+10;
563                 else if ((*from >= 'a') && (*from <= 'f'))
564                         v= *from-'a'+10;
565                 else
566                         {
567                         PEMerr(PEM_F_LOAD_IV,PEM_R_BAD_IV_CHARS);
568                         return(0);
569                         }
570                 from++;
571                 to[i/2]|=v<<(long)((!(i&1))*4);
572                 }
573
574         *fromp=from;
575         return(1);
576         }
577
578 #ifndef OPENSSL_NO_FP_API
579 int PEM_write(FILE *fp, char *name, char *header, unsigned char *data,
580              long len)
581         {
582         BIO *b;
583         int ret;
584
585         if ((b=BIO_new(BIO_s_file())) == NULL)
586                 {
587                 PEMerr(PEM_F_PEM_WRITE,ERR_R_BUF_LIB);
588                 return(0);
589                 }
590         BIO_set_fp(b,fp,BIO_NOCLOSE);
591         ret=PEM_write_bio(b, name, header, data,len);
592         BIO_free(b);
593         return(ret);
594         }
595 #endif
596
597 int PEM_write_bio(BIO *bp, const char *name, char *header, unsigned char *data,
598              long len)
599         {
600         int nlen,n,i,j,outl;
601         unsigned char *buf = NULL;
602         EVP_ENCODE_CTX ctx;
603         int reason=ERR_R_BUF_LIB;
604         
605         EVP_EncodeInit(&ctx);
606         nlen=strlen(name);
607
608         if (    (BIO_write(bp,"-----BEGIN ",11) != 11) ||
609                 (BIO_write(bp,name,nlen) != nlen) ||
610                 (BIO_write(bp,"-----\n",6) != 6))
611                 goto err;
612                 
613         i=strlen(header);
614         if (i > 0)
615                 {
616                 if (    (BIO_write(bp,header,i) != i) ||
617                         (BIO_write(bp,"\n",1) != 1))
618                         goto err;
619                 }
620
621         buf = OPENSSL_malloc(PEM_BUFSIZE*8);
622         if (buf == NULL)
623                 {
624                 reason=ERR_R_MALLOC_FAILURE;
625                 goto err;
626                 }
627
628         i=j=0;
629         while (len > 0)
630                 {
631                 n=(int)((len>(PEM_BUFSIZE*5))?(PEM_BUFSIZE*5):len);
632                 EVP_EncodeUpdate(&ctx,buf,&outl,&(data[j]),n);
633                 if ((outl) && (BIO_write(bp,(char *)buf,outl) != outl))
634                         goto err;
635                 i+=outl;
636                 len-=n;
637                 j+=n;
638                 }
639         EVP_EncodeFinal(&ctx,buf,&outl);
640         if ((outl > 0) && (BIO_write(bp,(char *)buf,outl) != outl)) goto err;
641         OPENSSL_cleanse(buf, PEM_BUFSIZE*8);
642         OPENSSL_free(buf);
643         buf = NULL;
644         if (    (BIO_write(bp,"-----END ",9) != 9) ||
645                 (BIO_write(bp,name,nlen) != nlen) ||
646                 (BIO_write(bp,"-----\n",6) != 6))
647                 goto err;
648         return(i+outl);
649 err:
650         if (buf) {
651                 OPENSSL_cleanse(buf, PEM_BUFSIZE*8);
652                 OPENSSL_free(buf);
653         }
654         PEMerr(PEM_F_PEM_WRITE_BIO,reason);
655         return(0);
656         }
657
658 #ifndef OPENSSL_NO_FP_API
659 int PEM_read(FILE *fp, char **name, char **header, unsigned char **data,
660              long *len)
661         {
662         BIO *b;
663         int ret;
664
665         if ((b=BIO_new(BIO_s_file())) == NULL)
666                 {
667                 PEMerr(PEM_F_PEM_READ,ERR_R_BUF_LIB);
668                 return(0);
669                 }
670         BIO_set_fp(b,fp,BIO_NOCLOSE);
671         ret=PEM_read_bio(b, name, header, data,len);
672         BIO_free(b);
673         return(ret);
674         }
675 #endif
676
677 int PEM_read_bio(BIO *bp, char **name, char **header, unsigned char **data,
678              long *len)
679         {
680         EVP_ENCODE_CTX ctx;
681         int end=0,i,k,bl=0,hl=0,nohead=0;
682         char buf[256];
683         BUF_MEM *nameB;
684         BUF_MEM *headerB;
685         BUF_MEM *dataB,*tmpB;
686         
687         nameB=BUF_MEM_new();
688         headerB=BUF_MEM_new();
689         dataB=BUF_MEM_new();
690         if ((nameB == NULL) || (headerB == NULL) || (dataB == NULL))
691                 {
692                 BUF_MEM_free(nameB);
693                 BUF_MEM_free(headerB);
694                 BUF_MEM_free(dataB);
695                 PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE);
696                 return(0);
697                 }
698
699         buf[254]='\0';
700         for (;;)
701                 {
702                 i=BIO_gets(bp,buf,254);
703
704                 if (i <= 0)
705                         {
706                         PEMerr(PEM_F_PEM_READ_BIO,PEM_R_NO_START_LINE);
707                         goto err;
708                         }
709
710                 while ((i >= 0) && (buf[i] <= ' ')) i--;
711                 buf[++i]='\n'; buf[++i]='\0';
712
713                 if (strncmp(buf,"-----BEGIN ",11) == 0)
714                         {
715                         i=strlen(&(buf[11]));
716
717                         if (strncmp(&(buf[11+i-6]),"-----\n",6) != 0)
718                                 continue;
719                         if (!BUF_MEM_grow(nameB,i+9))
720                                 {
721                                 PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE);
722                                 goto err;
723                                 }
724                         memcpy(nameB->data,&(buf[11]),i-6);
725                         nameB->data[i-6]='\0';
726                         break;
727                         }
728                 }
729         hl=0;
730         if (!BUF_MEM_grow(headerB,256))
731                 { PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE); goto err; }
732         headerB->data[0]='\0';
733         for (;;)
734                 {
735                 i=BIO_gets(bp,buf,254);
736                 if (i <= 0) break;
737
738                 while ((i >= 0) && (buf[i] <= ' ')) i--;
739                 buf[++i]='\n'; buf[++i]='\0';
740
741                 if (buf[0] == '\n') break;
742                 if (!BUF_MEM_grow(headerB,hl+i+9))
743                         { PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE); goto err; }
744                 if (strncmp(buf,"-----END ",9) == 0)
745                         {
746                         nohead=1;
747                         break;
748                         }
749                 memcpy(&(headerB->data[hl]),buf,i);
750                 headerB->data[hl+i]='\0';
751                 hl+=i;
752                 }
753
754         bl=0;
755         if (!BUF_MEM_grow(dataB,1024))
756                 { PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE); goto err; }
757         dataB->data[0]='\0';
758         if (!nohead)
759                 {
760                 for (;;)
761                         {
762                         i=BIO_gets(bp,buf,254);
763                         if (i <= 0) break;
764
765                         while ((i >= 0) && (buf[i] <= ' ')) i--;
766                         buf[++i]='\n'; buf[++i]='\0';
767
768                         if (i != 65) end=1;
769                         if (strncmp(buf,"-----END ",9) == 0)
770                                 break;
771                         if (i > 65) break;
772                         if (!BUF_MEM_grow_clean(dataB,i+bl+9))
773                                 {
774                                 PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE);
775                                 goto err;
776                                 }
777                         memcpy(&(dataB->data[bl]),buf,i);
778                         dataB->data[bl+i]='\0';
779                         bl+=i;
780                         if (end)
781                                 {
782                                 buf[0]='\0';
783                                 i=BIO_gets(bp,buf,254);
784                                 if (i <= 0) break;
785
786                                 while ((i >= 0) && (buf[i] <= ' ')) i--;
787                                 buf[++i]='\n'; buf[++i]='\0';
788
789                                 break;
790                                 }
791                         }
792                 }
793         else
794                 {
795                 tmpB=headerB;
796                 headerB=dataB;
797                 dataB=tmpB;
798                 bl=hl;
799                 }
800         i=strlen(nameB->data);
801         if (    (strncmp(buf,"-----END ",9) != 0) ||
802                 (strncmp(nameB->data,&(buf[9]),i) != 0) ||
803                 (strncmp(&(buf[9+i]),"-----\n",6) != 0))
804                 {
805                 PEMerr(PEM_F_PEM_READ_BIO,PEM_R_BAD_END_LINE);
806                 goto err;
807                 }
808
809         EVP_DecodeInit(&ctx);
810         i=EVP_DecodeUpdate(&ctx,
811                 (unsigned char *)dataB->data,&bl,
812                 (unsigned char *)dataB->data,bl);
813         if (i < 0)
814                 {
815                 PEMerr(PEM_F_PEM_READ_BIO,PEM_R_BAD_BASE64_DECODE);
816                 goto err;
817                 }
818         i=EVP_DecodeFinal(&ctx,(unsigned char *)&(dataB->data[bl]),&k);
819         if (i < 0)
820                 {
821                 PEMerr(PEM_F_PEM_READ_BIO,PEM_R_BAD_BASE64_DECODE);
822                 goto err;
823                 }
824         bl+=k;
825
826         if (bl == 0) goto err;
827         *name=nameB->data;
828         *header=headerB->data;
829         *data=(unsigned char *)dataB->data;
830         *len=bl;
831         OPENSSL_free(nameB);
832         OPENSSL_free(headerB);
833         OPENSSL_free(dataB);
834         return(1);
835 err:
836         BUF_MEM_free(nameB);
837         BUF_MEM_free(headerB);
838         BUF_MEM_free(dataB);
839         return(0);
840         }
841
842 /* Check pem string and return prefix length.
843  * If for example the pem_str == "RSA PRIVATE KEY" and suffix = "PRIVATE KEY"
844  * the return value is 3 for the string "RSA".
845  */
846
847 int pem_check_suffix(const char *pem_str, const char *suffix)
848         {
849         int pem_len = strlen(pem_str);
850         int suffix_len = strlen(suffix);
851         const char *p;
852         if (suffix_len + 1 >= pem_len)
853                 return 0;
854         p = pem_str + pem_len - suffix_len;
855         if (strcmp(p, suffix))
856                 return 0;
857         p--;
858         if (*p != ' ')
859                 return 0;
860         return p - pem_str;
861         }
862