More linker bloat reorganisation:
[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         /* Permit older strings */
197
198         if(!strcmp(nm,PEM_STRING_X509_OLD) &&
199                 !strcmp(name,PEM_STRING_X509)) return 1;
200
201         if(!strcmp(nm,PEM_STRING_X509_REQ_OLD) &&
202                 !strcmp(name,PEM_STRING_X509_REQ)) return 1;
203
204         /* Allow normal certs to be read as trusted certs */
205         if(!strcmp(nm,PEM_STRING_X509) &&
206                 !strcmp(name,PEM_STRING_X509_TRUSTED)) return 1;
207
208         if(!strcmp(nm,PEM_STRING_X509_OLD) &&
209                 !strcmp(name,PEM_STRING_X509_TRUSTED)) return 1;
210
211         /* Some CAs use PKCS#7 with CERTIFICATE headers */
212         if(!strcmp(nm, PEM_STRING_X509) &&
213                 !strcmp(name, PEM_STRING_PKCS7)) return 1;
214
215         return 0;
216 }
217
218 int PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm, const char *name, BIO *bp,
219              pem_password_cb *cb, void *u)
220         {
221         EVP_CIPHER_INFO cipher;
222         char *nm=NULL,*header=NULL;
223         unsigned char *data=NULL;
224         long len;
225         int ret = 0;
226
227         for (;;)
228                 {
229                 if (!PEM_read_bio(bp,&nm,&header,&data,&len)) {
230                         if(ERR_GET_REASON(ERR_peek_error()) ==
231                                 PEM_R_NO_START_LINE)
232                                 ERR_add_error_data(2, "Expecting: ", name);
233                         return 0;
234                 }
235                 if(check_pem(nm, name)) break;
236                 OPENSSL_free(nm);
237                 OPENSSL_free(header);
238                 OPENSSL_free(data);
239                 }
240         if (!PEM_get_EVP_CIPHER_INFO(header,&cipher)) goto err;
241         if (!PEM_do_header(&cipher,data,&len,cb,u)) goto err;
242
243         *pdata = data;
244         *plen = len;
245
246         if (pnm)
247                 *pnm = nm;
248
249         ret = 1;
250
251 err:
252         if (!pnm) OPENSSL_free(nm);
253         OPENSSL_free(header);
254         if (!ret) OPENSSL_free(data);
255         return ret;
256         }
257
258 #ifndef OPENSSL_NO_FP_API
259 int PEM_ASN1_write(int (*i2d)(), const char *name, FILE *fp, char *x,
260              const EVP_CIPHER *enc, unsigned char *kstr, int klen,
261              pem_password_cb *callback, void *u)
262         {
263         BIO *b;
264         int ret;
265
266         if ((b=BIO_new(BIO_s_file())) == NULL)
267                 {
268                 PEMerr(PEM_F_PEM_ASN1_WRITE,ERR_R_BUF_LIB);
269                 return(0);
270                 }
271         BIO_set_fp(b,fp,BIO_NOCLOSE);
272         ret=PEM_ASN1_write_bio(i2d,name,b,x,enc,kstr,klen,callback,u);
273         BIO_free(b);
274         return(ret);
275         }
276 #endif
277
278 int PEM_ASN1_write_bio(int (*i2d)(), const char *name, BIO *bp, char *x,
279              const EVP_CIPHER *enc, unsigned char *kstr, int klen,
280              pem_password_cb *callback, void *u)
281         {
282         EVP_CIPHER_CTX ctx;
283         int dsize=0,i,j,ret=0;
284         unsigned char *p,*data=NULL;
285         const char *objstr=NULL;
286         char buf[PEM_BUFSIZE];
287         unsigned char key[EVP_MAX_KEY_LENGTH];
288         unsigned char iv[EVP_MAX_IV_LENGTH];
289         
290         if (enc != NULL)
291                 {
292                 objstr=OBJ_nid2sn(EVP_CIPHER_nid(enc));
293                 if (objstr == NULL)
294                         {
295                         PEMerr(PEM_F_PEM_ASN1_WRITE_BIO,PEM_R_UNSUPPORTED_CIPHER);
296                         goto err;
297                         }
298                 }
299
300         if ((dsize=i2d(x,NULL)) < 0)
301                 {
302                 PEMerr(PEM_F_PEM_ASN1_WRITE_BIO,ERR_R_MALLOC_FAILURE);
303                 dsize=0;
304                 goto err;
305                 }
306         /* dzise + 8 bytes are needed */
307         data=(unsigned char *)OPENSSL_malloc((unsigned int)dsize+20);
308         if (data == NULL)
309                 {
310                 PEMerr(PEM_F_PEM_ASN1_WRITE_BIO,ERR_R_MALLOC_FAILURE);
311                 goto err;
312                 }
313         p=data;
314         i=i2d(x,&p);
315
316         if (enc != NULL)
317                 {
318                 if (kstr == NULL)
319                         {
320                         if (callback == NULL)
321                                 klen=PEM_def_callback(buf,PEM_BUFSIZE,1,u);
322                         else
323                                 klen=(*callback)(buf,PEM_BUFSIZE,1,u);
324                         if (klen <= 0)
325                                 {
326                                 PEMerr(PEM_F_PEM_ASN1_WRITE_BIO,PEM_R_READ_KEY);
327                                 goto err;
328                                 }
329 #ifdef CHARSET_EBCDIC
330                         /* Convert the pass phrase from EBCDIC */
331                         ebcdic2ascii(buf, buf, klen);
332 #endif
333                         kstr=(unsigned char *)buf;
334                         }
335                 RAND_add(data,i,0);/* put in the RSA key. */
336                 if (RAND_pseudo_bytes(iv,8) < 0)        /* Generate a salt */
337                         goto err;
338                 /* The 'iv' is used as the iv and as a salt.  It is
339                  * NOT taken from the BytesToKey function */
340                 EVP_BytesToKey(enc,EVP_md5(),iv,kstr,klen,1,key,NULL);
341
342                 if (kstr == (unsigned char *)buf) memset(buf,0,PEM_BUFSIZE);
343
344                 buf[0]='\0';
345                 PEM_proc_type(buf,PEM_TYPE_ENCRYPTED);
346                 PEM_dek_info(buf,objstr,8,(char *)iv);
347                 /* k=strlen(buf); */
348         
349                 EVP_EncryptInit(&ctx,enc,key,iv);
350                 EVP_EncryptUpdate(&ctx,data,&j,data,i);
351                 EVP_EncryptFinal(&ctx,&(data[j]),&i);
352                 i+=j;
353                 ret=1;
354                 }
355         else
356                 {
357                 ret=1;
358                 buf[0]='\0';
359                 }
360         i=PEM_write_bio(bp,name,buf,data,i);
361         if (i <= 0) ret=0;
362 err:
363         memset(key,0,sizeof(key));
364         memset(iv,0,sizeof(iv));
365         memset((char *)&ctx,0,sizeof(ctx));
366         memset(buf,0,PEM_BUFSIZE);
367         memset(data,0,(unsigned int)dsize);
368         OPENSSL_free(data);
369         return(ret);
370         }
371
372 int PEM_do_header(EVP_CIPHER_INFO *cipher, unsigned char *data, long *plen,
373              pem_password_cb *callback,void *u)
374         {
375         int i,j,o,klen;
376         long len;
377         EVP_CIPHER_CTX ctx;
378         unsigned char key[EVP_MAX_KEY_LENGTH];
379         char buf[PEM_BUFSIZE];
380
381         len= *plen;
382
383         if (cipher->cipher == NULL) return(1);
384         if (callback == NULL)
385                 klen=PEM_def_callback(buf,PEM_BUFSIZE,0,u);
386         else
387                 klen=callback(buf,PEM_BUFSIZE,0,u);
388         if (klen <= 0)
389                 {
390                 PEMerr(PEM_F_PEM_DO_HEADER,PEM_R_BAD_PASSWORD_READ);
391                 return(0);
392                 }
393 #ifdef CHARSET_EBCDIC
394         /* Convert the pass phrase from EBCDIC */
395         ebcdic2ascii(buf, buf, klen);
396 #endif
397
398         EVP_BytesToKey(cipher->cipher,EVP_md5(),&(cipher->iv[0]),
399                 (unsigned char *)buf,klen,1,key,NULL);
400
401         j=(int)len;
402         EVP_DecryptInit(&ctx,cipher->cipher,key,&(cipher->iv[0]));
403         EVP_DecryptUpdate(&ctx,data,&i,data,j);
404         o=EVP_DecryptFinal(&ctx,&(data[i]),&j);
405         EVP_CIPHER_CTX_cleanup(&ctx);
406         memset((char *)buf,0,sizeof(buf));
407         memset((char *)key,0,sizeof(key));
408         j+=i;
409         if (!o)
410                 {
411                 PEMerr(PEM_F_PEM_DO_HEADER,PEM_R_BAD_DECRYPT);
412                 return(0);
413                 }
414         *plen=j;
415         return(1);
416         }
417
418 int PEM_get_EVP_CIPHER_INFO(char *header, EVP_CIPHER_INFO *cipher)
419         {
420         int o;
421         const EVP_CIPHER *enc=NULL;
422         char *p,c;
423
424         cipher->cipher=NULL;
425         if ((header == NULL) || (*header == '\0') || (*header == '\n'))
426                 return(1);
427         if (strncmp(header,"Proc-Type: ",11) != 0)
428                 { PEMerr(PEM_F_PEM_GET_EVP_CIPHER_INFO,PEM_R_NOT_PROC_TYPE); return(0); }
429         header+=11;
430         if (*header != '4') return(0); header++;
431         if (*header != ',') return(0); header++;
432         if (strncmp(header,"ENCRYPTED",9) != 0)
433                 { PEMerr(PEM_F_PEM_GET_EVP_CIPHER_INFO,PEM_R_NOT_ENCRYPTED); return(0); }
434         for (; (*header != '\n') && (*header != '\0'); header++)
435                 ;
436         if (*header == '\0')
437                 { PEMerr(PEM_F_PEM_GET_EVP_CIPHER_INFO,PEM_R_SHORT_HEADER); return(0); }
438         header++;
439         if (strncmp(header,"DEK-Info: ",10) != 0)
440                 { PEMerr(PEM_F_PEM_GET_EVP_CIPHER_INFO,PEM_R_NOT_DEK_INFO); return(0); }
441         header+=10;
442
443         p=header;
444         for (;;)
445                 {
446                 c= *header;
447 #ifndef CHARSET_EBCDIC
448                 if (!(  ((c >= 'A') && (c <= 'Z')) || (c == '-') ||
449                         ((c >= '0') && (c <= '9'))))
450                         break;
451 #else
452                 if (!(  isupper(c) || (c == '-') ||
453                         isdigit(c)))
454                         break;
455 #endif
456                 header++;
457                 }
458         *header='\0';
459         o=OBJ_sn2nid(p);
460         cipher->cipher=enc=EVP_get_cipherbyname(p);
461         *header=c;
462         header++;
463
464         if (enc == NULL)
465                 {
466                 PEMerr(PEM_F_PEM_GET_EVP_CIPHER_INFO,PEM_R_UNSUPPORTED_ENCRYPTION);
467                 return(0);
468                 }
469         if (!load_iv((unsigned char **)&header,&(cipher->iv[0]),8)) return(0);
470
471         return(1);
472         }
473
474 static int load_iv(unsigned char **fromp, unsigned char *to, int num)
475         {
476         int v,i;
477         unsigned char *from;
478
479         from= *fromp;
480         for (i=0; i<num; i++) to[i]=0;
481         num*=2;
482         for (i=0; i<num; i++)
483                 {
484                 if ((*from >= '0') && (*from <= '9'))
485                         v= *from-'0';
486                 else if ((*from >= 'A') && (*from <= 'F'))
487                         v= *from-'A'+10;
488                 else if ((*from >= 'a') && (*from <= 'f'))
489                         v= *from-'a'+10;
490                 else
491                         {
492                         PEMerr(PEM_F_LOAD_IV,PEM_R_BAD_IV_CHARS);
493                         return(0);
494                         }
495                 from++;
496                 to[i/2]|=v<<(long)((!(i&1))*4);
497                 }
498
499         *fromp=from;
500         return(1);
501         }
502
503 #ifndef OPENSSL_NO_FP_API
504 int PEM_write(FILE *fp, char *name, char *header, unsigned char *data,
505              long len)
506         {
507         BIO *b;
508         int ret;
509
510         if ((b=BIO_new(BIO_s_file())) == NULL)
511                 {
512                 PEMerr(PEM_F_PEM_WRITE,ERR_R_BUF_LIB);
513                 return(0);
514                 }
515         BIO_set_fp(b,fp,BIO_NOCLOSE);
516         ret=PEM_write_bio(b, name, header, data,len);
517         BIO_free(b);
518         return(ret);
519         }
520 #endif
521
522 int PEM_write_bio(BIO *bp, const char *name, char *header, unsigned char *data,
523              long len)
524         {
525         int nlen,n,i,j,outl;
526         unsigned char *buf;
527         EVP_ENCODE_CTX ctx;
528         int reason=ERR_R_BUF_LIB;
529         
530         EVP_EncodeInit(&ctx);
531         nlen=strlen(name);
532
533         if (    (BIO_write(bp,"-----BEGIN ",11) != 11) ||
534                 (BIO_write(bp,name,nlen) != nlen) ||
535                 (BIO_write(bp,"-----\n",6) != 6))
536                 goto err;
537                 
538         i=strlen(header);
539         if (i > 0)
540                 {
541                 if (    (BIO_write(bp,header,i) != i) ||
542                         (BIO_write(bp,"\n",1) != 1))
543                         goto err;
544                 }
545
546         buf=(unsigned char *)OPENSSL_malloc(PEM_BUFSIZE*8);
547         if (buf == NULL)
548                 {
549                 reason=ERR_R_MALLOC_FAILURE;
550                 goto err;
551                 }
552
553         i=j=0;
554         while (len > 0)
555                 {
556                 n=(int)((len>(PEM_BUFSIZE*5))?(PEM_BUFSIZE*5):len);
557                 EVP_EncodeUpdate(&ctx,buf,&outl,&(data[j]),n);
558                 if ((outl) && (BIO_write(bp,(char *)buf,outl) != outl))
559                         goto err;
560                 i+=outl;
561                 len-=n;
562                 j+=n;
563                 }
564         EVP_EncodeFinal(&ctx,buf,&outl);
565         if ((outl > 0) && (BIO_write(bp,(char *)buf,outl) != outl)) goto err;
566         OPENSSL_free(buf);
567         if (    (BIO_write(bp,"-----END ",9) != 9) ||
568                 (BIO_write(bp,name,nlen) != nlen) ||
569                 (BIO_write(bp,"-----\n",6) != 6))
570                 goto err;
571         return(i+outl);
572 err:
573         PEMerr(PEM_F_PEM_WRITE_BIO,reason);
574         return(0);
575         }
576
577 #ifndef OPENSSL_NO_FP_API
578 int PEM_read(FILE *fp, char **name, char **header, unsigned char **data,
579              long *len)
580         {
581         BIO *b;
582         int ret;
583
584         if ((b=BIO_new(BIO_s_file())) == NULL)
585                 {
586                 PEMerr(PEM_F_PEM_READ,ERR_R_BUF_LIB);
587                 return(0);
588                 }
589         BIO_set_fp(b,fp,BIO_NOCLOSE);
590         ret=PEM_read_bio(b, name, header, data,len);
591         BIO_free(b);
592         return(ret);
593         }
594 #endif
595
596 int PEM_read_bio(BIO *bp, char **name, char **header, unsigned char **data,
597              long *len)
598         {
599         EVP_ENCODE_CTX ctx;
600         int end=0,i,k,bl=0,hl=0,nohead=0;
601         char buf[256];
602         BUF_MEM *nameB;
603         BUF_MEM *headerB;
604         BUF_MEM *dataB,*tmpB;
605         
606         nameB=BUF_MEM_new();
607         headerB=BUF_MEM_new();
608         dataB=BUF_MEM_new();
609         if ((nameB == NULL) || (headerB == NULL) || (dataB == NULL))
610                 {
611                 PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE);
612                 return(0);
613                 }
614
615         buf[254]='\0';
616         for (;;)
617                 {
618                 i=BIO_gets(bp,buf,254);
619
620                 if (i <= 0)
621                         {
622                         PEMerr(PEM_F_PEM_READ_BIO,PEM_R_NO_START_LINE);
623                         goto err;
624                         }
625
626                 while ((i >= 0) && (buf[i] <= ' ')) i--;
627                 buf[++i]='\n'; buf[++i]='\0';
628
629                 if (strncmp(buf,"-----BEGIN ",11) == 0)
630                         {
631                         i=strlen(&(buf[11]));
632
633                         if (strncmp(&(buf[11+i-6]),"-----\n",6) != 0)
634                                 continue;
635                         if (!BUF_MEM_grow(nameB,i+9))
636                                 {
637                                 PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE);
638                                 goto err;
639                                 }
640                         memcpy(nameB->data,&(buf[11]),i-6);
641                         nameB->data[i-6]='\0';
642                         break;
643                         }
644                 }
645         hl=0;
646         if (!BUF_MEM_grow(headerB,256))
647                 { PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE); goto err; }
648         headerB->data[0]='\0';
649         for (;;)
650                 {
651                 i=BIO_gets(bp,buf,254);
652                 if (i <= 0) break;
653
654                 while ((i >= 0) && (buf[i] <= ' ')) i--;
655                 buf[++i]='\n'; buf[++i]='\0';
656
657                 if (buf[0] == '\n') break;
658                 if (!BUF_MEM_grow(headerB,hl+i+9))
659                         { PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE); goto err; }
660                 if (strncmp(buf,"-----END ",9) == 0)
661                         {
662                         nohead=1;
663                         break;
664                         }
665                 memcpy(&(headerB->data[hl]),buf,i);
666                 headerB->data[hl+i]='\0';
667                 hl+=i;
668                 }
669
670         bl=0;
671         if (!BUF_MEM_grow(dataB,1024))
672                 { PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE); goto err; }
673         dataB->data[0]='\0';
674         if (!nohead)
675                 {
676                 for (;;)
677                         {
678                         i=BIO_gets(bp,buf,254);
679                         if (i <= 0) break;
680
681                         while ((i >= 0) && (buf[i] <= ' ')) i--;
682                         buf[++i]='\n'; buf[++i]='\0';
683
684                         if (i != 65) end=1;
685                         if (strncmp(buf,"-----END ",9) == 0)
686                                 break;
687                         if (i > 65) break;
688                         if (!BUF_MEM_grow(dataB,i+bl+9))
689                                 {
690                                 PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE);
691                                 goto err;
692                                 }
693                         memcpy(&(dataB->data[bl]),buf,i);
694                         dataB->data[bl+i]='\0';
695                         bl+=i;
696                         if (end)
697                                 {
698                                 buf[0]='\0';
699                                 i=BIO_gets(bp,buf,254);
700                                 if (i <= 0) break;
701
702                                 while ((i >= 0) && (buf[i] <= ' ')) i--;
703                                 buf[++i]='\n'; buf[++i]='\0';
704
705                                 break;
706                                 }
707                         }
708                 }
709         else
710                 {
711                 tmpB=headerB;
712                 headerB=dataB;
713                 dataB=tmpB;
714                 bl=hl;
715                 }
716         i=strlen(nameB->data);
717         if (    (strncmp(buf,"-----END ",9) != 0) ||
718                 (strncmp(nameB->data,&(buf[9]),i) != 0) ||
719                 (strncmp(&(buf[9+i]),"-----\n",6) != 0))
720                 {
721                 PEMerr(PEM_F_PEM_READ_BIO,PEM_R_BAD_END_LINE);
722                 goto err;
723                 }
724
725         EVP_DecodeInit(&ctx);
726         i=EVP_DecodeUpdate(&ctx,
727                 (unsigned char *)dataB->data,&bl,
728                 (unsigned char *)dataB->data,bl);
729         if (i < 0)
730                 {
731                 PEMerr(PEM_F_PEM_READ_BIO,PEM_R_BAD_BASE64_DECODE);
732                 goto err;
733                 }
734         i=EVP_DecodeFinal(&ctx,(unsigned char *)&(dataB->data[bl]),&k);
735         if (i < 0)
736                 {
737                 PEMerr(PEM_F_PEM_READ_BIO,PEM_R_BAD_BASE64_DECODE);
738                 goto err;
739                 }
740         bl+=k;
741
742         if (bl == 0) goto err;
743         *name=nameB->data;
744         *header=headerB->data;
745         *data=(unsigned char *)dataB->data;
746         *len=bl;
747         OPENSSL_free(nameB);
748         OPENSSL_free(headerB);
749         OPENSSL_free(dataB);
750         return(1);
751 err:
752         BUF_MEM_free(nameB);
753         BUF_MEM_free(headerB);
754         BUF_MEM_free(dataB);
755         return(0);
756         }