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