1 // Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 //     https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 
15 #include <assert.h>
16 #include <ctype.h>
17 #include <stdio.h>
18 #include <string.h>
19 
20 #include <string_view>
21 
22 #include <openssl/base64.h>
23 #include <openssl/buf.h>
24 #include <openssl/cipher.h>
25 #include <openssl/des.h>
26 #include <openssl/err.h>
27 #include <openssl/evp.h>
28 #include <openssl/mem.h>
29 #include <openssl/obj.h>
30 #include <openssl/pem.h>
31 #include <openssl/rand.h>
32 #include <openssl/x509.h>
33 
34 #include "../internal.h"
35 #include "internal.h"
36 
37 
38 #define MIN_LENGTH 4
39 
40 static int load_iv(const char **fromp, unsigned char *to, size_t num);
41 static int check_pem(const char *nm, const char *name);
42 
43 // PEM_proc_type appends a Proc-Type header to |buf|, determined by |type|.
PEM_proc_type(char buf[PEM_BUFSIZE],int type)44 static void PEM_proc_type(char buf[PEM_BUFSIZE], int type) {
45   const char *str;
46 
47   if (type == PEM_TYPE_ENCRYPTED) {
48     str = "ENCRYPTED";
49   } else if (type == PEM_TYPE_MIC_CLEAR) {
50     str = "MIC-CLEAR";
51   } else if (type == PEM_TYPE_MIC_ONLY) {
52     str = "MIC-ONLY";
53   } else {
54     str = "BAD-TYPE";
55   }
56 
57   OPENSSL_strlcat(buf, "Proc-Type: 4,", PEM_BUFSIZE);
58   OPENSSL_strlcat(buf, str, PEM_BUFSIZE);
59   OPENSSL_strlcat(buf, "\n", PEM_BUFSIZE);
60 }
61 
62 // PEM_dek_info appends a DEK-Info header to |buf|, with an algorithm of |type|
63 // and a single parameter, specified by hex-encoding |len| bytes from |str|.
PEM_dek_info(char buf[PEM_BUFSIZE],const char * type,size_t len,char * str)64 static void PEM_dek_info(char buf[PEM_BUFSIZE], const char *type, size_t len,
65                          char *str) {
66   static const unsigned char map[17] = "0123456789ABCDEF";
67 
68   OPENSSL_strlcat(buf, "DEK-Info: ", PEM_BUFSIZE);
69   OPENSSL_strlcat(buf, type, PEM_BUFSIZE);
70   OPENSSL_strlcat(buf, ",", PEM_BUFSIZE);
71 
72   const size_t used = strlen(buf);
73   const size_t available = PEM_BUFSIZE - used;
74   if (len * 2 < len || len * 2 + 2 < len || available < len * 2 + 2) {
75     return;
76   }
77 
78   for (size_t i = 0; i < len; i++) {
79     buf[used + i * 2] = map[(str[i] >> 4) & 0x0f];
80     buf[used + i * 2 + 1] = map[(str[i]) & 0x0f];
81   }
82   buf[used + len * 2] = '\n';
83   buf[used + len * 2 + 1] = '\0';
84 }
85 
PEM_ASN1_read(d2i_of_void * d2i,const char * name,FILE * fp,void ** x,pem_password_cb * cb,void * u)86 void *PEM_ASN1_read(d2i_of_void *d2i, const char *name, FILE *fp, void **x,
87                     pem_password_cb *cb, void *u) {
88   BIO *b = BIO_new_fp(fp, BIO_NOCLOSE);
89   if (b == NULL) {
90     OPENSSL_PUT_ERROR(PEM, ERR_R_BUF_LIB);
91     return NULL;
92   }
93   void *ret = PEM_ASN1_read_bio(d2i, name, b, x, cb, u);
94   BIO_free(b);
95   return ret;
96 }
97 
check_pem(const char * nm,const char * name)98 static int check_pem(const char *nm, const char *name) {
99   // Normal matching nm and name
100   if (!strcmp(nm, name)) {
101     return 1;
102   }
103 
104   // Make PEM_STRING_EVP_PKEY match any private key
105 
106   if (!strcmp(name, PEM_STRING_EVP_PKEY)) {
107     return !strcmp(nm, PEM_STRING_PKCS8) || !strcmp(nm, PEM_STRING_PKCS8INF) ||
108            !strcmp(nm, PEM_STRING_RSA) || !strcmp(nm, PEM_STRING_EC) ||
109            !strcmp(nm, PEM_STRING_DSA);
110   }
111 
112   // Permit older strings
113 
114   if (!strcmp(nm, PEM_STRING_X509_OLD) && !strcmp(name, PEM_STRING_X509)) {
115     return 1;
116   }
117 
118   if (!strcmp(nm, PEM_STRING_X509_REQ_OLD) &&
119       !strcmp(name, PEM_STRING_X509_REQ)) {
120     return 1;
121   }
122 
123   // Allow normal certs to be read as trusted certs
124   if (!strcmp(nm, PEM_STRING_X509) && !strcmp(name, PEM_STRING_X509_TRUSTED)) {
125     return 1;
126   }
127 
128   if (!strcmp(nm, PEM_STRING_X509_OLD) &&
129       !strcmp(name, PEM_STRING_X509_TRUSTED)) {
130     return 1;
131   }
132 
133   // Some CAs use PKCS#7 with CERTIFICATE headers
134   if (!strcmp(nm, PEM_STRING_X509) && !strcmp(name, PEM_STRING_PKCS7)) {
135     return 1;
136   }
137 
138   if (!strcmp(nm, PEM_STRING_PKCS7_SIGNED) && !strcmp(name, PEM_STRING_PKCS7)) {
139     return 1;
140   }
141 
142 #ifndef OPENSSL_NO_CMS
143   if (!strcmp(nm, PEM_STRING_X509) && !strcmp(name, PEM_STRING_CMS)) {
144     return 1;
145   }
146   // Allow CMS to be read from PKCS#7 headers
147   if (!strcmp(nm, PEM_STRING_PKCS7) && !strcmp(name, PEM_STRING_CMS)) {
148     return 1;
149   }
150 #endif
151 
152   return 0;
153 }
154 
cipher_by_name(std::string_view name)155 static const EVP_CIPHER *cipher_by_name(std::string_view name) {
156   // This is similar to the (deprecated) function |EVP_get_cipherbyname|. Note
157   // the PEM code assumes that ciphers have at least 8 bytes of IV, at most 20
158   // bytes of overhead and generally behave like CBC mode.
159   if (name == SN_des_cbc) {
160     return EVP_des_cbc();
161   } else if (name == SN_des_ede3_cbc) {
162     return EVP_des_ede3_cbc();
163   } else if (name == SN_aes_128_cbc) {
164     return EVP_aes_128_cbc();
165   } else if (name == SN_aes_192_cbc) {
166     return EVP_aes_192_cbc();
167   } else if (name == SN_aes_256_cbc) {
168     return EVP_aes_256_cbc();
169   } else {
170     return NULL;
171   }
172 }
173 
PEM_bytes_read_bio(unsigned char ** pdata,long * plen,char ** pnm,const char * name,BIO * bp,pem_password_cb * cb,void * u)174 int PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm,
175                        const char *name, BIO *bp, pem_password_cb *cb,
176                        void *u) {
177   EVP_CIPHER_INFO cipher;
178   char *nm = NULL, *header = NULL;
179   unsigned char *data = NULL;
180   long len;
181   int ret = 0;
182 
183   for (;;) {
184     if (!PEM_read_bio(bp, &nm, &header, &data, &len)) {
185       uint32_t error = ERR_peek_error();
186       if (ERR_GET_LIB(error) == ERR_LIB_PEM &&
187           ERR_GET_REASON(error) == PEM_R_NO_START_LINE) {
188         ERR_add_error_data(2, "Expecting: ", name);
189       }
190       return 0;
191     }
192     if (check_pem(nm, name)) {
193       break;
194     }
195     OPENSSL_free(nm);
196     OPENSSL_free(header);
197     OPENSSL_free(data);
198   }
199   if (!PEM_get_EVP_CIPHER_INFO(header, &cipher)) {
200     goto err;
201   }
202   if (!PEM_do_header(&cipher, data, &len, cb, u)) {
203     goto err;
204   }
205 
206   *pdata = data;
207   *plen = len;
208 
209   if (pnm) {
210     *pnm = nm;
211   }
212 
213   ret = 1;
214 
215 err:
216   if (!ret || !pnm) {
217     OPENSSL_free(nm);
218   }
219   OPENSSL_free(header);
220   if (!ret) {
221     OPENSSL_free(data);
222   }
223   return ret;
224 }
225 
PEM_ASN1_write(i2d_of_void * i2d,const char * name,FILE * fp,void * x,const EVP_CIPHER * enc,const unsigned char * pass,int pass_len,pem_password_cb * callback,void * u)226 int PEM_ASN1_write(i2d_of_void *i2d, const char *name, FILE *fp, void *x,
227                    const EVP_CIPHER *enc, const unsigned char *pass,
228                    int pass_len, pem_password_cb *callback, void *u) {
229   BIO *b = BIO_new_fp(fp, BIO_NOCLOSE);
230   if (b == NULL) {
231     OPENSSL_PUT_ERROR(PEM, ERR_R_BUF_LIB);
232     return 0;
233   }
234   int ret =
235       PEM_ASN1_write_bio(i2d, name, b, x, enc, pass, pass_len, callback, u);
236   BIO_free(b);
237   return ret;
238 }
239 
PEM_ASN1_write_bio(i2d_of_void * i2d,const char * name,BIO * bp,void * x,const EVP_CIPHER * enc,const unsigned char * pass,int pass_len,pem_password_cb * callback,void * u)240 int PEM_ASN1_write_bio(i2d_of_void *i2d, const char *name, BIO *bp, void *x,
241                        const EVP_CIPHER *enc, const unsigned char *pass,
242                        int pass_len, pem_password_cb *callback, void *u) {
243   bssl::ScopedEVP_CIPHER_CTX ctx;
244   int dsize = 0, i, j, ret = 0;
245   unsigned char *p, *data = NULL;
246   const char *objstr = NULL;
247   char buf[PEM_BUFSIZE];
248   unsigned char key[EVP_MAX_KEY_LENGTH];
249   unsigned char iv[EVP_MAX_IV_LENGTH];
250 
251   if (enc != NULL) {
252     objstr = OBJ_nid2sn(EVP_CIPHER_nid(enc));
253     if (objstr == NULL || cipher_by_name(objstr) == NULL ||
254         EVP_CIPHER_iv_length(enc) < 8) {
255       OPENSSL_PUT_ERROR(PEM, PEM_R_UNSUPPORTED_CIPHER);
256       goto err;
257     }
258   }
259 
260   if ((dsize = i2d(x, NULL)) < 0) {
261     OPENSSL_PUT_ERROR(PEM, ERR_R_ASN1_LIB);
262     dsize = 0;
263     goto err;
264   }
265   // dzise + 8 bytes are needed
266   // actually it needs the cipher block size extra...
267   data = (unsigned char *)OPENSSL_malloc((unsigned int)dsize + 20);
268   if (data == NULL) {
269     goto err;
270   }
271   p = data;
272   i = i2d(x, &p);
273 
274   if (enc != NULL) {
275     const unsigned iv_len = EVP_CIPHER_iv_length(enc);
276 
277     if (pass == NULL) {
278       if (!callback) {
279         callback = PEM_def_callback;
280       }
281       pass_len = (*callback)(buf, PEM_BUFSIZE, 1, u);
282       if (pass_len < 0) {
283         OPENSSL_PUT_ERROR(PEM, PEM_R_READ_KEY);
284         goto err;
285       }
286       pass = (const unsigned char *)buf;
287     }
288     assert(iv_len <= sizeof(iv));
289     if (!RAND_bytes(iv, iv_len)) {  // Generate a salt
290       goto err;
291     }
292     // The 'iv' is used as the iv and as a salt.  It is NOT taken from
293     // the BytesToKey function
294     if (!EVP_BytesToKey(enc, EVP_md5(), iv, pass, pass_len, 1, key, NULL)) {
295       goto err;
296     }
297 
298     if (pass == (const unsigned char *)buf) {
299       OPENSSL_cleanse(buf, PEM_BUFSIZE);
300     }
301 
302     assert(strlen(objstr) + 23 + 2 * iv_len + 13 <= sizeof(buf));
303 
304     buf[0] = '\0';
305     PEM_proc_type(buf, PEM_TYPE_ENCRYPTED);
306     PEM_dek_info(buf, objstr, iv_len, (char *)iv);
307     // k=strlen(buf);
308 
309     ret = 1;
310     if (!EVP_EncryptInit_ex(ctx.get(), enc, NULL, key, iv) ||
311         !EVP_EncryptUpdate(ctx.get(), data, &j, data, i) ||
312         !EVP_EncryptFinal_ex(ctx.get(), &(data[j]), &i)) {
313       ret = 0;
314     } else {
315       i += j;
316     }
317     if (ret == 0) {
318       goto err;
319     }
320   } else {
321     ret = 1;
322     buf[0] = '\0';
323   }
324   i = PEM_write_bio(bp, name, buf, data, i);
325   if (i <= 0) {
326     ret = 0;
327   }
328 err:
329   OPENSSL_cleanse(key, sizeof(key));
330   OPENSSL_cleanse(iv, sizeof(iv));
331   OPENSSL_cleanse(buf, PEM_BUFSIZE);
332   OPENSSL_free(data);
333   return ret;
334 }
335 
PEM_do_header(const EVP_CIPHER_INFO * cipher,unsigned char * data,long * plen,pem_password_cb * callback,void * u)336 int PEM_do_header(const EVP_CIPHER_INFO *cipher, unsigned char *data,
337                   long *plen, pem_password_cb *callback, void *u) {
338   int i = 0, j, o, pass_len;
339   long len;
340   bssl::ScopedEVP_CIPHER_CTX ctx;
341   unsigned char key[EVP_MAX_KEY_LENGTH];
342   char buf[PEM_BUFSIZE];
343 
344   len = *plen;
345 
346   if (cipher->cipher == NULL) {
347     return 1;
348   }
349 
350   pass_len = 0;
351   if (!callback) {
352     callback = PEM_def_callback;
353   }
354   pass_len = callback(buf, PEM_BUFSIZE, 0, u);
355   if (pass_len < 0) {
356     OPENSSL_PUT_ERROR(PEM, PEM_R_BAD_PASSWORD_READ);
357     return 0;
358   }
359 
360   if (!EVP_BytesToKey(cipher->cipher, EVP_md5(), cipher->iv,
361                       (unsigned char *)buf, pass_len, 1, key, NULL)) {
362     return 0;
363   }
364 
365   j = (int)len;
366   o = EVP_DecryptInit_ex(ctx.get(), cipher->cipher, NULL, key, cipher->iv);
367   if (o) {
368     o = EVP_DecryptUpdate(ctx.get(), data, &i, data, j);
369   }
370   if (o) {
371     o = EVP_DecryptFinal_ex(ctx.get(), &(data[i]), &j);
372   }
373   OPENSSL_cleanse((char *)buf, sizeof(buf));
374   OPENSSL_cleanse((char *)key, sizeof(key));
375   if (!o) {
376     OPENSSL_PUT_ERROR(PEM, PEM_R_BAD_DECRYPT);
377     return 0;
378   }
379   j += i;
380   *plen = j;
381   return 1;
382 }
383 
PEM_get_EVP_CIPHER_INFO(const char * header,EVP_CIPHER_INFO * cipher)384 int PEM_get_EVP_CIPHER_INFO(const char *header, EVP_CIPHER_INFO *cipher) {
385   cipher->cipher = NULL;
386   OPENSSL_memset(cipher->iv, 0, sizeof(cipher->iv));
387   if ((header == NULL) || (*header == '\0') || (*header == '\n')) {
388     return 1;
389   }
390   if (strncmp(header, "Proc-Type: ", 11) != 0) {
391     OPENSSL_PUT_ERROR(PEM, PEM_R_NOT_PROC_TYPE);
392     return 0;
393   }
394   header += 11;
395   if (header[0] != '4' || header[1] != ',') {
396     OPENSSL_PUT_ERROR(PEM, PEM_R_UNSUPPORTED_PROC_TYPE_VERSION);
397     return 0;
398   }
399   header += 2;
400   if (strncmp(header, "ENCRYPTED", 9) != 0) {
401     OPENSSL_PUT_ERROR(PEM, PEM_R_NOT_ENCRYPTED);
402     return 0;
403   }
404   for (; (*header != '\n') && (*header != '\0'); header++) {
405     ;
406   }
407   if (*header == '\0') {
408     OPENSSL_PUT_ERROR(PEM, PEM_R_SHORT_HEADER);
409     return 0;
410   }
411   header++;
412   if (strncmp(header, "DEK-Info: ", 10) != 0) {
413     OPENSSL_PUT_ERROR(PEM, PEM_R_NOT_DEK_INFO);
414     return 0;
415   }
416   header += 10;
417 
418   const char *p = header;
419   for (;;) {
420     char c = *header;
421     if (!((c >= 'A' && c <= 'Z') || c == '-' || OPENSSL_isdigit(c))) {
422       break;
423     }
424     header++;
425   }
426   cipher->cipher = cipher_by_name(std::string_view(p, header - p));
427   header++;
428   if (cipher->cipher == NULL) {
429     OPENSSL_PUT_ERROR(PEM, PEM_R_UNSUPPORTED_ENCRYPTION);
430     return 0;
431   }
432   // The IV parameter must be at least 8 bytes long to be used as the salt in
433   // the KDF. (This should not happen given |cipher_by_name|.)
434   if (EVP_CIPHER_iv_length(cipher->cipher) < 8) {
435     assert(0);
436     OPENSSL_PUT_ERROR(PEM, PEM_R_UNSUPPORTED_ENCRYPTION);
437     return 0;
438   }
439   const char **header_pp = &header;
440   if (!load_iv(header_pp, cipher->iv, EVP_CIPHER_iv_length(cipher->cipher))) {
441     return 0;
442   }
443 
444   return 1;
445 }
446 
load_iv(const char ** fromp,unsigned char * to,size_t num)447 static int load_iv(const char **fromp, unsigned char *to, size_t num) {
448   uint8_t v;
449   const char *from;
450 
451   from = *fromp;
452   for (size_t i = 0; i < num; i++) {
453     to[i] = 0;
454   }
455   num *= 2;
456   for (size_t i = 0; i < num; i++) {
457     if (!OPENSSL_fromxdigit(&v, *from)) {
458       OPENSSL_PUT_ERROR(PEM, PEM_R_BAD_IV_CHARS);
459       return 0;
460     }
461     from++;
462     to[i / 2] |= v << (!(i & 1)) * 4;
463   }
464 
465   *fromp = from;
466   return 1;
467 }
468 
PEM_write(FILE * fp,const char * name,const char * header,const unsigned char * data,long len)469 int PEM_write(FILE *fp, const char *name, const char *header,
470               const unsigned char *data, long len) {
471   BIO *b = BIO_new_fp(fp, BIO_NOCLOSE);
472   if (b == NULL) {
473     OPENSSL_PUT_ERROR(PEM, ERR_R_BUF_LIB);
474     return 0;
475   }
476   int ret = PEM_write_bio(b, name, header, data, len);
477   BIO_free(b);
478   return ret;
479 }
480 
PEM_write_bio(BIO * bp,const char * name,const char * header,const unsigned char * data,long len)481 int PEM_write_bio(BIO *bp, const char *name, const char *header,
482                   const unsigned char *data, long len) {
483   int nlen, n, i, j, outl;
484   unsigned char *buf = NULL;
485   EVP_ENCODE_CTX ctx;
486   int reason = ERR_R_BUF_LIB;
487   int retval = 0;
488 
489   EVP_EncodeInit(&ctx);
490   nlen = strlen(name);
491 
492   if ((BIO_write(bp, "-----BEGIN ", 11) != 11) ||
493       (BIO_write(bp, name, nlen) != nlen) ||
494       (BIO_write(bp, "-----\n", 6) != 6)) {
495     goto err;
496   }
497 
498   i = strlen(header);
499   if (i > 0) {
500     if ((BIO_write(bp, header, i) != i) || (BIO_write(bp, "\n", 1) != 1)) {
501       goto err;
502     }
503   }
504 
505   buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(PEM_BUFSIZE * 8));
506   if (buf == NULL) {
507     goto err;
508   }
509 
510   i = j = 0;
511   while (len > 0) {
512     n = (int)((len > (PEM_BUFSIZE * 5)) ? (PEM_BUFSIZE * 5) : len);
513     EVP_EncodeUpdate(&ctx, buf, &outl, &(data[j]), n);
514     if ((outl) && (BIO_write(bp, (char *)buf, outl) != outl)) {
515       goto err;
516     }
517     i += outl;
518     len -= n;
519     j += n;
520   }
521   EVP_EncodeFinal(&ctx, buf, &outl);
522   if ((outl > 0) && (BIO_write(bp, (char *)buf, outl) != outl)) {
523     goto err;
524   }
525   if ((BIO_write(bp, "-----END ", 9) != 9) ||
526       (BIO_write(bp, name, nlen) != nlen) ||
527       (BIO_write(bp, "-----\n", 6) != 6)) {
528     goto err;
529   }
530   retval = i + outl;
531 
532 err:
533   if (retval == 0) {
534     OPENSSL_PUT_ERROR(PEM, reason);
535   }
536   OPENSSL_free(buf);
537   return retval;
538 }
539 
PEM_read(FILE * fp,char ** name,char ** header,unsigned char ** data,long * len)540 int PEM_read(FILE *fp, char **name, char **header, unsigned char **data,
541              long *len) {
542   BIO *b = BIO_new_fp(fp, BIO_NOCLOSE);
543   if (b == NULL) {
544     OPENSSL_PUT_ERROR(PEM, ERR_R_BUF_LIB);
545     return 0;
546   }
547   int ret = PEM_read_bio(b, name, header, data, len);
548   BIO_free(b);
549   return ret;
550 }
551 
PEM_read_bio(BIO * bp,char ** name,char ** header,unsigned char ** data,long * len)552 int PEM_read_bio(BIO *bp, char **name, char **header, unsigned char **data,
553                  long *len) {
554   EVP_ENCODE_CTX ctx;
555   int end = 0, i, k, bl = 0, hl = 0, nohead = 0;
556   char buf[256];
557   BUF_MEM *nameB;
558   BUF_MEM *headerB;
559   BUF_MEM *dataB, *tmpB;
560 
561   nameB = BUF_MEM_new();
562   headerB = BUF_MEM_new();
563   dataB = BUF_MEM_new();
564   if ((nameB == NULL) || (headerB == NULL) || (dataB == NULL)) {
565     BUF_MEM_free(nameB);
566     BUF_MEM_free(headerB);
567     BUF_MEM_free(dataB);
568     return 0;
569   }
570 
571   buf[254] = '\0';
572   for (;;) {
573     i = BIO_gets(bp, buf, 254);
574 
575     if (i <= 0) {
576       OPENSSL_PUT_ERROR(PEM, PEM_R_NO_START_LINE);
577       goto err;
578     }
579 
580     while ((i >= 0) && (buf[i] <= ' ')) {
581       i--;
582     }
583     buf[++i] = '\n';
584     buf[++i] = '\0';
585 
586     if (strncmp(buf, "-----BEGIN ", 11) == 0) {
587       i = strlen(&(buf[11]));
588 
589       if (strncmp(&(buf[11 + i - 6]), "-----\n", 6) != 0) {
590         continue;
591       }
592       if (!BUF_MEM_grow(nameB, i + 9)) {
593         goto err;
594       }
595       OPENSSL_memcpy(nameB->data, &(buf[11]), i - 6);
596       nameB->data[i - 6] = '\0';
597       break;
598     }
599   }
600   hl = 0;
601   if (!BUF_MEM_grow(headerB, 256)) {
602     goto err;
603   }
604   headerB->data[0] = '\0';
605   for (;;) {
606     i = BIO_gets(bp, buf, 254);
607     if (i <= 0) {
608       break;
609     }
610 
611     while ((i >= 0) && (buf[i] <= ' ')) {
612       i--;
613     }
614     buf[++i] = '\n';
615     buf[++i] = '\0';
616 
617     if (buf[0] == '\n') {
618       break;
619     }
620     if (!BUF_MEM_grow(headerB, hl + i + 9)) {
621       goto err;
622     }
623     if (strncmp(buf, "-----END ", 9) == 0) {
624       nohead = 1;
625       break;
626     }
627     OPENSSL_memcpy(&(headerB->data[hl]), buf, i);
628     headerB->data[hl + i] = '\0';
629     hl += i;
630   }
631 
632   bl = 0;
633   if (!BUF_MEM_grow(dataB, 1024)) {
634     goto err;
635   }
636   dataB->data[0] = '\0';
637   if (!nohead) {
638     for (;;) {
639       i = BIO_gets(bp, buf, 254);
640       if (i <= 0) {
641         break;
642       }
643 
644       while ((i >= 0) && (buf[i] <= ' ')) {
645         i--;
646       }
647       buf[++i] = '\n';
648       buf[++i] = '\0';
649 
650       if (i != 65) {
651         end = 1;
652       }
653       if (strncmp(buf, "-----END ", 9) == 0) {
654         break;
655       }
656       if (i > 65) {
657         break;
658       }
659       if (!BUF_MEM_grow_clean(dataB, i + bl + 9)) {
660         goto err;
661       }
662       OPENSSL_memcpy(&(dataB->data[bl]), buf, i);
663       dataB->data[bl + i] = '\0';
664       bl += i;
665       if (end) {
666         buf[0] = '\0';
667         i = BIO_gets(bp, buf, 254);
668         if (i <= 0) {
669           break;
670         }
671 
672         while ((i >= 0) && (buf[i] <= ' ')) {
673           i--;
674         }
675         buf[++i] = '\n';
676         buf[++i] = '\0';
677 
678         break;
679       }
680     }
681   } else {
682     tmpB = headerB;
683     headerB = dataB;
684     dataB = tmpB;
685     bl = hl;
686   }
687   i = strlen(nameB->data);
688   if ((strncmp(buf, "-----END ", 9) != 0) ||
689       (strncmp(nameB->data, &(buf[9]), i) != 0) ||
690       (strncmp(&(buf[9 + i]), "-----\n", 6) != 0)) {
691     OPENSSL_PUT_ERROR(PEM, PEM_R_BAD_END_LINE);
692     goto err;
693   }
694 
695   EVP_DecodeInit(&ctx);
696   i = EVP_DecodeUpdate(&ctx, (unsigned char *)dataB->data, &bl,
697                        (unsigned char *)dataB->data, bl);
698   if (i < 0) {
699     OPENSSL_PUT_ERROR(PEM, PEM_R_BAD_BASE64_DECODE);
700     goto err;
701   }
702   i = EVP_DecodeFinal(&ctx, (unsigned char *)&(dataB->data[bl]), &k);
703   if (i < 0) {
704     OPENSSL_PUT_ERROR(PEM, PEM_R_BAD_BASE64_DECODE);
705     goto err;
706   }
707   bl += k;
708 
709   if (bl == 0) {
710     goto err;
711   }
712   *name = nameB->data;
713   *header = headerB->data;
714   *data = (unsigned char *)dataB->data;
715   *len = bl;
716   OPENSSL_free(nameB);
717   OPENSSL_free(headerB);
718   OPENSSL_free(dataB);
719   return 1;
720 err:
721   BUF_MEM_free(nameB);
722   BUF_MEM_free(headerB);
723   BUF_MEM_free(dataB);
724   return 0;
725 }
726 
PEM_def_callback(char * buf,int size,int rwflag,void * userdata)727 int PEM_def_callback(char *buf, int size, int rwflag, void *userdata) {
728   if (!buf || !userdata || size < 0) {
729     return -1;
730   }
731   size_t len = strlen((char *)userdata);
732   if (len >= (size_t)size) {
733     return -1;
734   }
735   OPENSSL_strlcpy(buf, reinterpret_cast<char *>(userdata), (size_t)size);
736   return (int)len;
737 }
738