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