Use SEC1 format for EC private keys.
[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         memset(data,0,(unsigned int)dsize);
372         OPENSSL_free(data);
373         return(ret);
374         }
375
376 int PEM_do_header(EVP_CIPHER_INFO *cipher, unsigned char *data, long *plen,
377              pem_password_cb *callback,void *u)
378         {
379         int i,j,o,klen;
380         long len;
381         EVP_CIPHER_CTX ctx;
382         unsigned char key[EVP_MAX_KEY_LENGTH];
383         char buf[PEM_BUFSIZE];
384
385         len= *plen;
386
387         if (cipher->cipher == NULL) return(1);
388         if (callback == NULL)
389                 klen=PEM_def_callback(buf,PEM_BUFSIZE,0,u);
390         else
391                 klen=callback(buf,PEM_BUFSIZE,0,u);
392         if (klen <= 0)
393                 {
394                 PEMerr(PEM_F_PEM_DO_HEADER,PEM_R_BAD_PASSWORD_READ);
395                 return(0);
396                 }
397 #ifdef CHARSET_EBCDIC
398         /* Convert the pass phrase from EBCDIC */
399         ebcdic2ascii(buf, buf, klen);
400 #endif
401
402         EVP_BytesToKey(cipher->cipher,EVP_md5(),&(cipher->iv[0]),
403                 (unsigned char *)buf,klen,1,key,NULL);
404
405         j=(int)len;
406         EVP_CIPHER_CTX_init(&ctx);
407         EVP_DecryptInit_ex(&ctx,cipher->cipher,NULL, key,&(cipher->iv[0]));
408         EVP_DecryptUpdate(&ctx,data,&i,data,j);
409         o=EVP_DecryptFinal_ex(&ctx,&(data[i]),&j);
410         EVP_CIPHER_CTX_cleanup(&ctx);
411         memset((char *)buf,0,sizeof(buf));
412         memset((char *)key,0,sizeof(key));
413         j+=i;
414         if (!o)
415                 {
416                 PEMerr(PEM_F_PEM_DO_HEADER,PEM_R_BAD_DECRYPT);
417                 return(0);
418                 }
419         *plen=j;
420         return(1);
421         }
422
423 int PEM_get_EVP_CIPHER_INFO(char *header, EVP_CIPHER_INFO *cipher)
424         {
425         int o;
426         const EVP_CIPHER *enc=NULL;
427         char *p,c;
428
429         cipher->cipher=NULL;
430         if ((header == NULL) || (*header == '\0') || (*header == '\n'))
431                 return(1);
432         if (strncmp(header,"Proc-Type: ",11) != 0)
433                 { PEMerr(PEM_F_PEM_GET_EVP_CIPHER_INFO,PEM_R_NOT_PROC_TYPE); return(0); }
434         header+=11;
435         if (*header != '4') return(0); header++;
436         if (*header != ',') return(0); header++;
437         if (strncmp(header,"ENCRYPTED",9) != 0)
438                 { PEMerr(PEM_F_PEM_GET_EVP_CIPHER_INFO,PEM_R_NOT_ENCRYPTED); return(0); }
439         for (; (*header != '\n') && (*header != '\0'); header++)
440                 ;
441         if (*header == '\0')
442                 { PEMerr(PEM_F_PEM_GET_EVP_CIPHER_INFO,PEM_R_SHORT_HEADER); return(0); }
443         header++;
444         if (strncmp(header,"DEK-Info: ",10) != 0)
445                 { PEMerr(PEM_F_PEM_GET_EVP_CIPHER_INFO,PEM_R_NOT_DEK_INFO); return(0); }
446         header+=10;
447
448         p=header;
449         for (;;)
450                 {
451                 c= *header;
452 #ifndef CHARSET_EBCDIC
453                 if (!(  ((c >= 'A') && (c <= 'Z')) || (c == '-') ||
454                         ((c >= '0') && (c <= '9'))))
455                         break;
456 #else
457                 if (!(  isupper(c) || (c == '-') ||
458                         isdigit(c)))
459                         break;
460 #endif
461                 header++;
462                 }
463         *header='\0';
464         o=OBJ_sn2nid(p);
465         cipher->cipher=enc=EVP_get_cipherbyname(p);
466         *header=c;
467         header++;
468
469         if (enc == NULL)
470                 {
471                 PEMerr(PEM_F_PEM_GET_EVP_CIPHER_INFO,PEM_R_UNSUPPORTED_ENCRYPTION);
472                 return(0);
473                 }
474         if (!load_iv((unsigned char **)&header,&(cipher->iv[0]),enc->iv_len)) return(0);
475
476         return(1);
477         }
478
479 static int load_iv(unsigned char **fromp, unsigned char *to, int num)
480         {
481         int v,i;
482         unsigned char *from;
483
484         from= *fromp;
485         for (i=0; i<num; i++) to[i]=0;
486         num*=2;
487         for (i=0; i<num; i++)
488                 {
489                 if ((*from >= '0') && (*from <= '9'))
490                         v= *from-'0';
491                 else if ((*from >= 'A') && (*from <= 'F'))
492                         v= *from-'A'+10;
493                 else if ((*from >= 'a') && (*from <= 'f'))
494                         v= *from-'a'+10;
495                 else
496                         {
497                         PEMerr(PEM_F_LOAD_IV,PEM_R_BAD_IV_CHARS);
498                         return(0);
499                         }
500                 from++;
501                 to[i/2]|=v<<(long)((!(i&1))*4);
502                 }
503
504         *fromp=from;
505         return(1);
506         }
507
508 #ifndef OPENSSL_NO_FP_API
509 int PEM_write(FILE *fp, char *name, char *header, unsigned char *data,
510              long len)
511         {
512         BIO *b;
513         int ret;
514
515         if ((b=BIO_new(BIO_s_file())) == NULL)
516                 {
517                 PEMerr(PEM_F_PEM_WRITE,ERR_R_BUF_LIB);
518                 return(0);
519                 }
520         BIO_set_fp(b,fp,BIO_NOCLOSE);
521         ret=PEM_write_bio(b, name, header, data,len);
522         BIO_free(b);
523         return(ret);
524         }
525 #endif
526
527 int PEM_write_bio(BIO *bp, const char *name, char *header, unsigned char *data,
528              long len)
529         {
530         int nlen,n,i,j,outl;
531         unsigned char *buf;
532         EVP_ENCODE_CTX ctx;
533         int reason=ERR_R_BUF_LIB;
534         
535         EVP_EncodeInit(&ctx);
536         nlen=strlen(name);
537
538         if (    (BIO_write(bp,"-----BEGIN ",11) != 11) ||
539                 (BIO_write(bp,name,nlen) != nlen) ||
540                 (BIO_write(bp,"-----\n",6) != 6))
541                 goto err;
542                 
543         i=strlen(header);
544         if (i > 0)
545                 {
546                 if (    (BIO_write(bp,header,i) != i) ||
547                         (BIO_write(bp,"\n",1) != 1))
548                         goto err;
549                 }
550
551         buf=(unsigned char *)OPENSSL_malloc(PEM_BUFSIZE*8);
552         if (buf == NULL)
553                 {
554                 reason=ERR_R_MALLOC_FAILURE;
555                 goto err;
556                 }
557
558         i=j=0;
559         while (len > 0)
560                 {
561                 n=(int)((len>(PEM_BUFSIZE*5))?(PEM_BUFSIZE*5):len);
562                 EVP_EncodeUpdate(&ctx,buf,&outl,&(data[j]),n);
563                 if ((outl) && (BIO_write(bp,(char *)buf,outl) != outl))
564                         goto err;
565                 i+=outl;
566                 len-=n;
567                 j+=n;
568                 }
569         EVP_EncodeFinal(&ctx,buf,&outl);
570         if ((outl > 0) && (BIO_write(bp,(char *)buf,outl) != outl)) goto err;
571         OPENSSL_free(buf);
572         if (    (BIO_write(bp,"-----END ",9) != 9) ||
573                 (BIO_write(bp,name,nlen) != nlen) ||
574                 (BIO_write(bp,"-----\n",6) != 6))
575                 goto err;
576         return(i+outl);
577 err:
578         PEMerr(PEM_F_PEM_WRITE_BIO,reason);
579         return(0);
580         }
581
582 #ifndef OPENSSL_NO_FP_API
583 int PEM_read(FILE *fp, char **name, char **header, unsigned char **data,
584              long *len)
585         {
586         BIO *b;
587         int ret;
588
589         if ((b=BIO_new(BIO_s_file())) == NULL)
590                 {
591                 PEMerr(PEM_F_PEM_READ,ERR_R_BUF_LIB);
592                 return(0);
593                 }
594         BIO_set_fp(b,fp,BIO_NOCLOSE);
595         ret=PEM_read_bio(b, name, header, data,len);
596         BIO_free(b);
597         return(ret);
598         }
599 #endif
600
601 int PEM_read_bio(BIO *bp, char **name, char **header, unsigned char **data,
602              long *len)
603         {
604         EVP_ENCODE_CTX ctx;
605         int end=0,i,k,bl=0,hl=0,nohead=0;
606         char buf[256];
607         BUF_MEM *nameB;
608         BUF_MEM *headerB;
609         BUF_MEM *dataB,*tmpB;
610         
611         nameB=BUF_MEM_new();
612         headerB=BUF_MEM_new();
613         dataB=BUF_MEM_new();
614         if ((nameB == NULL) || (headerB == NULL) || (dataB == NULL))
615                 {
616                 PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE);
617                 return(0);
618                 }
619
620         buf[254]='\0';
621         for (;;)
622                 {
623                 i=BIO_gets(bp,buf,254);
624
625                 if (i <= 0)
626                         {
627                         PEMerr(PEM_F_PEM_READ_BIO,PEM_R_NO_START_LINE);
628                         goto err;
629                         }
630
631                 while ((i >= 0) && (buf[i] <= ' ')) i--;
632                 buf[++i]='\n'; buf[++i]='\0';
633
634                 if (strncmp(buf,"-----BEGIN ",11) == 0)
635                         {
636                         i=strlen(&(buf[11]));
637
638                         if (strncmp(&(buf[11+i-6]),"-----\n",6) != 0)
639                                 continue;
640                         if (!BUF_MEM_grow(nameB,i+9))
641                                 {
642                                 PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE);
643                                 goto err;
644                                 }
645                         memcpy(nameB->data,&(buf[11]),i-6);
646                         nameB->data[i-6]='\0';
647                         break;
648                         }
649                 }
650         hl=0;
651         if (!BUF_MEM_grow(headerB,256))
652                 { PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE); goto err; }
653         headerB->data[0]='\0';
654         for (;;)
655                 {
656                 i=BIO_gets(bp,buf,254);
657                 if (i <= 0) break;
658
659                 while ((i >= 0) && (buf[i] <= ' ')) i--;
660                 buf[++i]='\n'; buf[++i]='\0';
661
662                 if (buf[0] == '\n') break;
663                 if (!BUF_MEM_grow(headerB,hl+i+9))
664                         { PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE); goto err; }
665                 if (strncmp(buf,"-----END ",9) == 0)
666                         {
667                         nohead=1;
668                         break;
669                         }
670                 memcpy(&(headerB->data[hl]),buf,i);
671                 headerB->data[hl+i]='\0';
672                 hl+=i;
673                 }
674
675         bl=0;
676         if (!BUF_MEM_grow(dataB,1024))
677                 { PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE); goto err; }
678         dataB->data[0]='\0';
679         if (!nohead)
680                 {
681                 for (;;)
682                         {
683                         i=BIO_gets(bp,buf,254);
684                         if (i <= 0) break;
685
686                         while ((i >= 0) && (buf[i] <= ' ')) i--;
687                         buf[++i]='\n'; buf[++i]='\0';
688
689                         if (i != 65) end=1;
690                         if (strncmp(buf,"-----END ",9) == 0)
691                                 break;
692                         if (i > 65) break;
693                         if (!BUF_MEM_grow(dataB,i+bl+9))
694                                 {
695                                 PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE);
696                                 goto err;
697                                 }
698                         memcpy(&(dataB->data[bl]),buf,i);
699                         dataB->data[bl+i]='\0';
700                         bl+=i;
701                         if (end)
702                                 {
703                                 buf[0]='\0';
704                                 i=BIO_gets(bp,buf,254);
705                                 if (i <= 0) break;
706
707                                 while ((i >= 0) && (buf[i] <= ' ')) i--;
708                                 buf[++i]='\n'; buf[++i]='\0';
709
710                                 break;
711                                 }
712                         }
713                 }
714         else
715                 {
716                 tmpB=headerB;
717                 headerB=dataB;
718                 dataB=tmpB;
719                 bl=hl;
720                 }
721         i=strlen(nameB->data);
722         if (    (strncmp(buf,"-----END ",9) != 0) ||
723                 (strncmp(nameB->data,&(buf[9]),i) != 0) ||
724                 (strncmp(&(buf[9+i]),"-----\n",6) != 0))
725                 {
726                 PEMerr(PEM_F_PEM_READ_BIO,PEM_R_BAD_END_LINE);
727                 goto err;
728                 }
729
730         EVP_DecodeInit(&ctx);
731         i=EVP_DecodeUpdate(&ctx,
732                 (unsigned char *)dataB->data,&bl,
733                 (unsigned char *)dataB->data,bl);
734         if (i < 0)
735                 {
736                 PEMerr(PEM_F_PEM_READ_BIO,PEM_R_BAD_BASE64_DECODE);
737                 goto err;
738                 }
739         i=EVP_DecodeFinal(&ctx,(unsigned char *)&(dataB->data[bl]),&k);
740         if (i < 0)
741                 {
742                 PEMerr(PEM_F_PEM_READ_BIO,PEM_R_BAD_BASE64_DECODE);
743                 goto err;
744                 }
745         bl+=k;
746
747         if (bl == 0) goto err;
748         *name=nameB->data;
749         *header=headerB->data;
750         *data=(unsigned char *)dataB->data;
751         *len=bl;
752         OPENSSL_free(nameB);
753         OPENSSL_free(headerB);
754         OPENSSL_free(dataB);
755         return(1);
756 err:
757         BUF_MEM_free(nameB);
758         BUF_MEM_free(headerB);
759         BUF_MEM_free(dataB);
760         return(0);
761         }