开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 其他游戏 > 查看源码
pem_lib.c
资源名称：wow-313-source.rar　[点击查看]
上传用户：yisoukefu
上传日期：2020-08-09
资源大小：39506k
文件大小：19k
源码类别：

其他游戏

开发平台：

Visual C++

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