Home | History | Annotate | Download | only in ssl
      1 /* ssl/ssl_rsa.c */
      2 /* Copyright (C) 1995-1998 Eric Young (eay (at) cryptsoft.com)
      3  * All rights reserved.
      4  *
      5  * This package is an SSL implementation written
      6  * by Eric Young (eay (at) 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 (at) 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 (at) 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 (at) 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 "ssl_locl.h"
     61 #include <openssl/bio.h>
     62 #include <openssl/objects.h>
     63 #include <openssl/evp.h>
     64 #include <openssl/x509.h>
     65 #include <openssl/pem.h>
     66 
     67 static int ssl_set_cert(CERT *c, X509 *x509);
     68 static int ssl_set_pkey(CERT *c, EVP_PKEY *pkey);
     69 int SSL_use_certificate(SSL *ssl, X509 *x)
     70 	{
     71 	if (x == NULL)
     72 		{
     73 		SSLerr(SSL_F_SSL_USE_CERTIFICATE,ERR_R_PASSED_NULL_PARAMETER);
     74 		return(0);
     75 		}
     76 	if (!ssl_cert_inst(&ssl->cert))
     77 		{
     78 		SSLerr(SSL_F_SSL_USE_CERTIFICATE,ERR_R_MALLOC_FAILURE);
     79 		return(0);
     80 		}
     81 	return(ssl_set_cert(ssl->cert,x));
     82 	}
     83 
     84 #ifndef OPENSSL_NO_STDIO
     85 int SSL_use_certificate_file(SSL *ssl, const char *file, int type)
     86 	{
     87 	int j;
     88 	BIO *in;
     89 	int ret=0;
     90 	X509 *x=NULL;
     91 
     92 	in=BIO_new(BIO_s_file_internal());
     93 	if (in == NULL)
     94 		{
     95 		SSLerr(SSL_F_SSL_USE_CERTIFICATE_FILE,ERR_R_BUF_LIB);
     96 		goto end;
     97 		}
     98 
     99 	if (BIO_read_filename(in,file) <= 0)
    100 		{
    101 		SSLerr(SSL_F_SSL_USE_CERTIFICATE_FILE,ERR_R_SYS_LIB);
    102 		goto end;
    103 		}
    104 	if (type == SSL_FILETYPE_ASN1)
    105 		{
    106 		j=ERR_R_ASN1_LIB;
    107 		x=d2i_X509_bio(in,NULL);
    108 		}
    109 	else if (type == SSL_FILETYPE_PEM)
    110 		{
    111 		j=ERR_R_PEM_LIB;
    112 		x=PEM_read_bio_X509(in,NULL,ssl->ctx->default_passwd_callback,ssl->ctx->default_passwd_callback_userdata);
    113 		}
    114 	else
    115 		{
    116 		SSLerr(SSL_F_SSL_USE_CERTIFICATE_FILE,SSL_R_BAD_SSL_FILETYPE);
    117 		goto end;
    118 		}
    119 
    120 	if (x == NULL)
    121 		{
    122 		SSLerr(SSL_F_SSL_USE_CERTIFICATE_FILE,j);
    123 		goto end;
    124 		}
    125 
    126 	ret=SSL_use_certificate(ssl,x);
    127 end:
    128 	if (x != NULL) X509_free(x);
    129 	if (in != NULL) BIO_free(in);
    130 	return(ret);
    131 	}
    132 #endif
    133 
    134 int SSL_use_certificate_ASN1(SSL *ssl, const unsigned char *d, int len)
    135 	{
    136 	X509 *x;
    137 	int ret;
    138 
    139 	x=d2i_X509(NULL,&d,(long)len);
    140 	if (x == NULL)
    141 		{
    142 		SSLerr(SSL_F_SSL_USE_CERTIFICATE_ASN1,ERR_R_ASN1_LIB);
    143 		return(0);
    144 		}
    145 
    146 	ret=SSL_use_certificate(ssl,x);
    147 	X509_free(x);
    148 	return(ret);
    149 	}
    150 
    151 #ifndef OPENSSL_NO_RSA
    152 int SSL_use_RSAPrivateKey(SSL *ssl, RSA *rsa)
    153 	{
    154 	EVP_PKEY *pkey;
    155 	int ret;
    156 
    157 	if (rsa == NULL)
    158 		{
    159 		SSLerr(SSL_F_SSL_USE_RSAPRIVATEKEY,ERR_R_PASSED_NULL_PARAMETER);
    160 		return(0);
    161 		}
    162 	if (!ssl_cert_inst(&ssl->cert))
    163 		{
    164 		SSLerr(SSL_F_SSL_USE_RSAPRIVATEKEY,ERR_R_MALLOC_FAILURE);
    165 		return(0);
    166 		}
    167 	if ((pkey=EVP_PKEY_new()) == NULL)
    168 		{
    169 		SSLerr(SSL_F_SSL_USE_RSAPRIVATEKEY,ERR_R_EVP_LIB);
    170 		return(0);
    171 		}
    172 
    173 	RSA_up_ref(rsa);
    174 	EVP_PKEY_assign_RSA(pkey,rsa);
    175 
    176 	ret=ssl_set_pkey(ssl->cert,pkey);
    177 	EVP_PKEY_free(pkey);
    178 	return(ret);
    179 	}
    180 #endif
    181 
    182 static int ssl_set_pkey(CERT *c, EVP_PKEY *pkey)
    183 	{
    184 	int i;
    185 
    186 	i=ssl_cert_type(NULL,pkey);
    187 	if (i < 0)
    188 		{
    189 		SSLerr(SSL_F_SSL_SET_PKEY,SSL_R_UNKNOWN_CERTIFICATE_TYPE);
    190 		return(0);
    191 		}
    192 
    193 	if (c->pkeys[i].x509 != NULL)
    194 		{
    195 		EVP_PKEY *pktmp;
    196 		pktmp =	X509_get_pubkey(c->pkeys[i].x509);
    197 		EVP_PKEY_copy_parameters(pktmp,pkey);
    198 		EVP_PKEY_free(pktmp);
    199 		ERR_clear_error();
    200 
    201 #ifndef OPENSSL_NO_RSA
    202 		/* Don't check the public/private key, this is mostly
    203 		 * for smart cards. */
    204 		if ((pkey->type == EVP_PKEY_RSA) &&
    205 			(RSA_flags(pkey->pkey.rsa) & RSA_METHOD_FLAG_NO_CHECK))
    206 			;
    207 		else
    208 #endif
    209 		if (!X509_check_private_key(c->pkeys[i].x509,pkey))
    210 			{
    211 			X509_free(c->pkeys[i].x509);
    212 			c->pkeys[i].x509 = NULL;
    213 			return 0;
    214 			}
    215 		}
    216 
    217 	if (c->pkeys[i].privatekey != NULL)
    218 		EVP_PKEY_free(c->pkeys[i].privatekey);
    219 	CRYPTO_add(&pkey->references,1,CRYPTO_LOCK_EVP_PKEY);
    220 	c->pkeys[i].privatekey=pkey;
    221 	c->key= &(c->pkeys[i]);
    222 
    223 	c->valid=0;
    224 	return(1);
    225 	}
    226 
    227 #ifndef OPENSSL_NO_RSA
    228 #ifndef OPENSSL_NO_STDIO
    229 int SSL_use_RSAPrivateKey_file(SSL *ssl, const char *file, int type)
    230 	{
    231 	int j,ret=0;
    232 	BIO *in;
    233 	RSA *rsa=NULL;
    234 
    235 	in=BIO_new(BIO_s_file_internal());
    236 	if (in == NULL)
    237 		{
    238 		SSLerr(SSL_F_SSL_USE_RSAPRIVATEKEY_FILE,ERR_R_BUF_LIB);
    239 		goto end;
    240 		}
    241 
    242 	if (BIO_read_filename(in,file) <= 0)
    243 		{
    244 		SSLerr(SSL_F_SSL_USE_RSAPRIVATEKEY_FILE,ERR_R_SYS_LIB);
    245 		goto end;
    246 		}
    247 	if	(type == SSL_FILETYPE_ASN1)
    248 		{
    249 		j=ERR_R_ASN1_LIB;
    250 		rsa=d2i_RSAPrivateKey_bio(in,NULL);
    251 		}
    252 	else if (type == SSL_FILETYPE_PEM)
    253 		{
    254 		j=ERR_R_PEM_LIB;
    255 		rsa=PEM_read_bio_RSAPrivateKey(in,NULL,
    256 			ssl->ctx->default_passwd_callback,ssl->ctx->default_passwd_callback_userdata);
    257 		}
    258 	else
    259 		{
    260 		SSLerr(SSL_F_SSL_USE_RSAPRIVATEKEY_FILE,SSL_R_BAD_SSL_FILETYPE);
    261 		goto end;
    262 		}
    263 	if (rsa == NULL)
    264 		{
    265 		SSLerr(SSL_F_SSL_USE_RSAPRIVATEKEY_FILE,j);
    266 		goto end;
    267 		}
    268 	ret=SSL_use_RSAPrivateKey(ssl,rsa);
    269 	RSA_free(rsa);
    270 end:
    271 	if (in != NULL) BIO_free(in);
    272 	return(ret);
    273 	}
    274 #endif
    275 
    276 int SSL_use_RSAPrivateKey_ASN1(SSL *ssl, unsigned char *d, long len)
    277 	{
    278 	int ret;
    279 	const unsigned char *p;
    280 	RSA *rsa;
    281 
    282 	p=d;
    283 	if ((rsa=d2i_RSAPrivateKey(NULL,&p,(long)len)) == NULL)
    284 		{
    285 		SSLerr(SSL_F_SSL_USE_RSAPRIVATEKEY_ASN1,ERR_R_ASN1_LIB);
    286 		return(0);
    287 		}
    288 
    289 	ret=SSL_use_RSAPrivateKey(ssl,rsa);
    290 	RSA_free(rsa);
    291 	return(ret);
    292 	}
    293 #endif /* !OPENSSL_NO_RSA */
    294 
    295 int SSL_use_PrivateKey(SSL *ssl, EVP_PKEY *pkey)
    296 	{
    297 	int ret;
    298 
    299 	if (pkey == NULL)
    300 		{
    301 		SSLerr(SSL_F_SSL_USE_PRIVATEKEY,ERR_R_PASSED_NULL_PARAMETER);
    302 		return(0);
    303 		}
    304 	if (!ssl_cert_inst(&ssl->cert))
    305 		{
    306 		SSLerr(SSL_F_SSL_USE_PRIVATEKEY,ERR_R_MALLOC_FAILURE);
    307 		return(0);
    308 		}
    309 	ret=ssl_set_pkey(ssl->cert,pkey);
    310 	return(ret);
    311 	}
    312 
    313 #ifndef OPENSSL_NO_STDIO
    314 int SSL_use_PrivateKey_file(SSL *ssl, const char *file, int type)
    315 	{
    316 	int j,ret=0;
    317 	BIO *in;
    318 	EVP_PKEY *pkey=NULL;
    319 
    320 	in=BIO_new(BIO_s_file_internal());
    321 	if (in == NULL)
    322 		{
    323 		SSLerr(SSL_F_SSL_USE_PRIVATEKEY_FILE,ERR_R_BUF_LIB);
    324 		goto end;
    325 		}
    326 
    327 	if (BIO_read_filename(in,file) <= 0)
    328 		{
    329 		SSLerr(SSL_F_SSL_USE_PRIVATEKEY_FILE,ERR_R_SYS_LIB);
    330 		goto end;
    331 		}
    332 	if (type == SSL_FILETYPE_PEM)
    333 		{
    334 		j=ERR_R_PEM_LIB;
    335 		pkey=PEM_read_bio_PrivateKey(in,NULL,
    336 			ssl->ctx->default_passwd_callback,ssl->ctx->default_passwd_callback_userdata);
    337 		}
    338 	else if (type == SSL_FILETYPE_ASN1)
    339 		{
    340 		j = ERR_R_ASN1_LIB;
    341 		pkey = d2i_PrivateKey_bio(in,NULL);
    342 		}
    343 	else
    344 		{
    345 		SSLerr(SSL_F_SSL_USE_PRIVATEKEY_FILE,SSL_R_BAD_SSL_FILETYPE);
    346 		goto end;
    347 		}
    348 	if (pkey == NULL)
    349 		{
    350 		SSLerr(SSL_F_SSL_USE_PRIVATEKEY_FILE,j);
    351 		goto end;
    352 		}
    353 	ret=SSL_use_PrivateKey(ssl,pkey);
    354 	EVP_PKEY_free(pkey);
    355 end:
    356 	if (in != NULL) BIO_free(in);
    357 	return(ret);
    358 	}
    359 #endif
    360 
    361 int SSL_use_PrivateKey_ASN1(int type, SSL *ssl, const unsigned char *d, long len)
    362 	{
    363 	int ret;
    364 	const unsigned char *p;
    365 	EVP_PKEY *pkey;
    366 
    367 	p=d;
    368 	if ((pkey=d2i_PrivateKey(type,NULL,&p,(long)len)) == NULL)
    369 		{
    370 		SSLerr(SSL_F_SSL_USE_PRIVATEKEY_ASN1,ERR_R_ASN1_LIB);
    371 		return(0);
    372 		}
    373 
    374 	ret=SSL_use_PrivateKey(ssl,pkey);
    375 	EVP_PKEY_free(pkey);
    376 	return(ret);
    377 	}
    378 
    379 int SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x)
    380 	{
    381 	if (x == NULL)
    382 		{
    383 		SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE,ERR_R_PASSED_NULL_PARAMETER);
    384 		return(0);
    385 		}
    386 	if (!ssl_cert_inst(&ctx->cert))
    387 		{
    388 		SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE,ERR_R_MALLOC_FAILURE);
    389 		return(0);
    390 		}
    391 	return(ssl_set_cert(ctx->cert, x));
    392 	}
    393 
    394 static int ssl_set_cert(CERT *c, X509 *x)
    395 	{
    396 	EVP_PKEY *pkey;
    397 	int i;
    398 
    399 	pkey=X509_get_pubkey(x);
    400 	if (pkey == NULL)
    401 		{
    402 		SSLerr(SSL_F_SSL_SET_CERT,SSL_R_X509_LIB);
    403 		return(0);
    404 		}
    405 
    406 	i=ssl_cert_type(x,pkey);
    407 	if (i < 0)
    408 		{
    409 		SSLerr(SSL_F_SSL_SET_CERT,SSL_R_UNKNOWN_CERTIFICATE_TYPE);
    410 		EVP_PKEY_free(pkey);
    411 		return(0);
    412 		}
    413 
    414 	if (c->pkeys[i].privatekey != NULL)
    415 		{
    416 		EVP_PKEY_copy_parameters(pkey,c->pkeys[i].privatekey);
    417 		ERR_clear_error();
    418 
    419 #ifndef OPENSSL_NO_RSA
    420 		/* Don't check the public/private key, this is mostly
    421 		 * for smart cards. */
    422 		if ((c->pkeys[i].privatekey->type == EVP_PKEY_RSA) &&
    423 			(RSA_flags(c->pkeys[i].privatekey->pkey.rsa) &
    424 			 RSA_METHOD_FLAG_NO_CHECK))
    425 			 ;
    426 		else
    427 #endif /* OPENSSL_NO_RSA */
    428 		if (!X509_check_private_key(x,c->pkeys[i].privatekey))
    429 			{
    430 			/* don't fail for a cert/key mismatch, just free
    431 			 * current private key (when switching to a different
    432 			 * cert & key, first this function should be used,
    433 			 * then ssl_set_pkey */
    434 			EVP_PKEY_free(c->pkeys[i].privatekey);
    435 			c->pkeys[i].privatekey=NULL;
    436 			/* clear error queue */
    437 			ERR_clear_error();
    438 			}
    439 		}
    440 
    441 	EVP_PKEY_free(pkey);
    442 
    443 	if (c->pkeys[i].x509 != NULL)
    444 		X509_free(c->pkeys[i].x509);
    445 	CRYPTO_add(&x->references,1,CRYPTO_LOCK_X509);
    446 	c->pkeys[i].x509=x;
    447 	c->key= &(c->pkeys[i]);
    448 
    449 	c->valid=0;
    450 	return(1);
    451 	}
    452 
    453 #ifndef OPENSSL_NO_STDIO
    454 int SSL_CTX_use_certificate_file(SSL_CTX *ctx, const char *file, int type)
    455 	{
    456 	int j;
    457 	BIO *in;
    458 	int ret=0;
    459 	X509 *x=NULL;
    460 
    461 	in=BIO_new(BIO_s_file_internal());
    462 	if (in == NULL)
    463 		{
    464 		SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_FILE,ERR_R_BUF_LIB);
    465 		goto end;
    466 		}
    467 
    468 	if (BIO_read_filename(in,file) <= 0)
    469 		{
    470 		SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_FILE,ERR_R_SYS_LIB);
    471 		goto end;
    472 		}
    473 	if (type == SSL_FILETYPE_ASN1)
    474 		{
    475 		j=ERR_R_ASN1_LIB;
    476 		x=d2i_X509_bio(in,NULL);
    477 		}
    478 	else if (type == SSL_FILETYPE_PEM)
    479 		{
    480 		j=ERR_R_PEM_LIB;
    481 		x=PEM_read_bio_X509(in,NULL,ctx->default_passwd_callback,ctx->default_passwd_callback_userdata);
    482 		}
    483 	else
    484 		{
    485 		SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_FILE,SSL_R_BAD_SSL_FILETYPE);
    486 		goto end;
    487 		}
    488 
    489 	if (x == NULL)
    490 		{
    491 		SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_FILE,j);
    492 		goto end;
    493 		}
    494 
    495 	ret=SSL_CTX_use_certificate(ctx,x);
    496 end:
    497 	if (x != NULL) X509_free(x);
    498 	if (in != NULL) BIO_free(in);
    499 	return(ret);
    500 	}
    501 #endif
    502 
    503 int SSL_CTX_use_certificate_ASN1(SSL_CTX *ctx, int len, const unsigned char *d)
    504 	{
    505 	X509 *x;
    506 	int ret;
    507 
    508 	x=d2i_X509(NULL,&d,(long)len);
    509 	if (x == NULL)
    510 		{
    511 		SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_ASN1,ERR_R_ASN1_LIB);
    512 		return(0);
    513 		}
    514 
    515 	ret=SSL_CTX_use_certificate(ctx,x);
    516 	X509_free(x);
    517 	return(ret);
    518 	}
    519 
    520 #ifndef OPENSSL_NO_RSA
    521 int SSL_CTX_use_RSAPrivateKey(SSL_CTX *ctx, RSA *rsa)
    522 	{
    523 	int ret;
    524 	EVP_PKEY *pkey;
    525 
    526 	if (rsa == NULL)
    527 		{
    528 		SSLerr(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY,ERR_R_PASSED_NULL_PARAMETER);
    529 		return(0);
    530 		}
    531 	if (!ssl_cert_inst(&ctx->cert))
    532 		{
    533 		SSLerr(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY,ERR_R_MALLOC_FAILURE);
    534 		return(0);
    535 		}
    536 	if ((pkey=EVP_PKEY_new()) == NULL)
    537 		{
    538 		SSLerr(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY,ERR_R_EVP_LIB);
    539 		return(0);
    540 		}
    541 
    542 	RSA_up_ref(rsa);
    543 	EVP_PKEY_assign_RSA(pkey,rsa);
    544 
    545 	ret=ssl_set_pkey(ctx->cert, pkey);
    546 	EVP_PKEY_free(pkey);
    547 	return(ret);
    548 	}
    549 
    550 #ifndef OPENSSL_NO_STDIO
    551 int SSL_CTX_use_RSAPrivateKey_file(SSL_CTX *ctx, const char *file, int type)
    552 	{
    553 	int j,ret=0;
    554 	BIO *in;
    555 	RSA *rsa=NULL;
    556 
    557 	in=BIO_new(BIO_s_file_internal());
    558 	if (in == NULL)
    559 		{
    560 		SSLerr(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_FILE,ERR_R_BUF_LIB);
    561 		goto end;
    562 		}
    563 
    564 	if (BIO_read_filename(in,file) <= 0)
    565 		{
    566 		SSLerr(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_FILE,ERR_R_SYS_LIB);
    567 		goto end;
    568 		}
    569 	if	(type == SSL_FILETYPE_ASN1)
    570 		{
    571 		j=ERR_R_ASN1_LIB;
    572 		rsa=d2i_RSAPrivateKey_bio(in,NULL);
    573 		}
    574 	else if (type == SSL_FILETYPE_PEM)
    575 		{
    576 		j=ERR_R_PEM_LIB;
    577 		rsa=PEM_read_bio_RSAPrivateKey(in,NULL,
    578 			ctx->default_passwd_callback,ctx->default_passwd_callback_userdata);
    579 		}
    580 	else
    581 		{
    582 		SSLerr(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_FILE,SSL_R_BAD_SSL_FILETYPE);
    583 		goto end;
    584 		}
    585 	if (rsa == NULL)
    586 		{
    587 		SSLerr(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_FILE,j);
    588 		goto end;
    589 		}
    590 	ret=SSL_CTX_use_RSAPrivateKey(ctx,rsa);
    591 	RSA_free(rsa);
    592 end:
    593 	if (in != NULL) BIO_free(in);
    594 	return(ret);
    595 	}
    596 #endif
    597 
    598 int SSL_CTX_use_RSAPrivateKey_ASN1(SSL_CTX *ctx, const unsigned char *d, long len)
    599 	{
    600 	int ret;
    601 	const unsigned char *p;
    602 	RSA *rsa;
    603 
    604 	p=d;
    605 	if ((rsa=d2i_RSAPrivateKey(NULL,&p,(long)len)) == NULL)
    606 		{
    607 		SSLerr(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_ASN1,ERR_R_ASN1_LIB);
    608 		return(0);
    609 		}
    610 
    611 	ret=SSL_CTX_use_RSAPrivateKey(ctx,rsa);
    612 	RSA_free(rsa);
    613 	return(ret);
    614 	}
    615 #endif /* !OPENSSL_NO_RSA */
    616 
    617 int SSL_CTX_use_PrivateKey(SSL_CTX *ctx, EVP_PKEY *pkey)
    618 	{
    619 	if (pkey == NULL)
    620 		{
    621 		SSLerr(SSL_F_SSL_CTX_USE_PRIVATEKEY,ERR_R_PASSED_NULL_PARAMETER);
    622 		return(0);
    623 		}
    624 	if (!ssl_cert_inst(&ctx->cert))
    625 		{
    626 		SSLerr(SSL_F_SSL_CTX_USE_PRIVATEKEY,ERR_R_MALLOC_FAILURE);
    627 		return(0);
    628 		}
    629 	return(ssl_set_pkey(ctx->cert,pkey));
    630 	}
    631 
    632 #ifndef OPENSSL_NO_STDIO
    633 int SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, const char *file, int type)
    634 	{
    635 	int j,ret=0;
    636 	BIO *in;
    637 	EVP_PKEY *pkey=NULL;
    638 
    639 	in=BIO_new(BIO_s_file_internal());
    640 	if (in == NULL)
    641 		{
    642 		SSLerr(SSL_F_SSL_CTX_USE_PRIVATEKEY_FILE,ERR_R_BUF_LIB);
    643 		goto end;
    644 		}
    645 
    646 	if (BIO_read_filename(in,file) <= 0)
    647 		{
    648 		SSLerr(SSL_F_SSL_CTX_USE_PRIVATEKEY_FILE,ERR_R_SYS_LIB);
    649 		goto end;
    650 		}
    651 	if (type == SSL_FILETYPE_PEM)
    652 		{
    653 		j=ERR_R_PEM_LIB;
    654 		pkey=PEM_read_bio_PrivateKey(in,NULL,
    655 			ctx->default_passwd_callback,ctx->default_passwd_callback_userdata);
    656 		}
    657 	else if (type == SSL_FILETYPE_ASN1)
    658 		{
    659 		j = ERR_R_ASN1_LIB;
    660 		pkey = d2i_PrivateKey_bio(in,NULL);
    661 		}
    662 	else
    663 		{
    664 		SSLerr(SSL_F_SSL_CTX_USE_PRIVATEKEY_FILE,SSL_R_BAD_SSL_FILETYPE);
    665 		goto end;
    666 		}
    667 	if (pkey == NULL)
    668 		{
    669 		SSLerr(SSL_F_SSL_CTX_USE_PRIVATEKEY_FILE,j);
    670 		goto end;
    671 		}
    672 	ret=SSL_CTX_use_PrivateKey(ctx,pkey);
    673 	EVP_PKEY_free(pkey);
    674 end:
    675 	if (in != NULL) BIO_free(in);
    676 	return(ret);
    677 	}
    678 #endif
    679 
    680 int SSL_CTX_use_PrivateKey_ASN1(int type, SSL_CTX *ctx, const unsigned char *d,
    681 	     long len)
    682 	{
    683 	int ret;
    684 	const unsigned char *p;
    685 	EVP_PKEY *pkey;
    686 
    687 	p=d;
    688 	if ((pkey=d2i_PrivateKey(type,NULL,&p,(long)len)) == NULL)
    689 		{
    690 		SSLerr(SSL_F_SSL_CTX_USE_PRIVATEKEY_ASN1,ERR_R_ASN1_LIB);
    691 		return(0);
    692 		}
    693 
    694 	ret=SSL_CTX_use_PrivateKey(ctx,pkey);
    695 	EVP_PKEY_free(pkey);
    696 	return(ret);
    697 	}
    698 
    699 
    700 #ifndef OPENSSL_NO_STDIO
    701 /* Read a file that contains our certificate in "PEM" format,
    702  * possibly followed by a sequence of CA certificates that should be
    703  * sent to the peer in the Certificate message.
    704  */
    705 int SSL_CTX_use_certificate_chain_file(SSL_CTX *ctx, const char *file)
    706 	{
    707 	BIO *in;
    708 	int ret=0;
    709 	X509 *x=NULL;
    710 
    711 	ERR_clear_error(); /* clear error stack for SSL_CTX_use_certificate() */
    712 
    713 	in=BIO_new(BIO_s_file_internal());
    714 	if (in == NULL)
    715 		{
    716 		SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_CHAIN_FILE,ERR_R_BUF_LIB);
    717 		goto end;
    718 		}
    719 
    720 	if (BIO_read_filename(in,file) <= 0)
    721 		{
    722 		SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_CHAIN_FILE,ERR_R_SYS_LIB);
    723 		goto end;
    724 		}
    725 
    726 	x=PEM_read_bio_X509_AUX(in,NULL,ctx->default_passwd_callback,ctx->default_passwd_callback_userdata);
    727 	if (x == NULL)
    728 		{
    729 		SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_CHAIN_FILE,ERR_R_PEM_LIB);
    730 		goto end;
    731 		}
    732 
    733 	ret=SSL_CTX_use_certificate(ctx,x);
    734 	if (ERR_peek_error() != 0)
    735 		ret = 0;  /* Key/certificate mismatch doesn't imply ret==0 ... */
    736 	if (ret)
    737 		{
    738 		/* If we could set up our certificate, now proceed to
    739 		 * the CA certificates.
    740 		 */
    741 		X509 *ca;
    742 		int r;
    743 		unsigned long err;
    744 
    745 		if (ctx->extra_certs != NULL)
    746 			{
    747 			sk_X509_pop_free(ctx->extra_certs, X509_free);
    748 			ctx->extra_certs = NULL;
    749 			}
    750 
    751 		while ((ca = PEM_read_bio_X509(in,NULL,ctx->default_passwd_callback,ctx->default_passwd_callback_userdata))
    752 			!= NULL)
    753 			{
    754 			r = SSL_CTX_add_extra_chain_cert(ctx, ca);
    755 			if (!r)
    756 				{
    757 				X509_free(ca);
    758 				ret = 0;
    759 				goto end;
    760 				}
    761 			/* Note that we must not free r if it was successfully
    762 			 * added to the chain (while we must free the main
    763 			 * certificate, since its reference count is increased
    764 			 * by SSL_CTX_use_certificate). */
    765 			}
    766 		/* When the while loop ends, it's usually just EOF. */
    767 		err = ERR_peek_last_error();
    768 		if (ERR_GET_LIB(err) == ERR_LIB_PEM && ERR_GET_REASON(err) == PEM_R_NO_START_LINE)
    769 			ERR_clear_error();
    770 		else
    771 			ret = 0; /* some real error */
    772 		}
    773 
    774 end:
    775 	if (x != NULL) X509_free(x);
    776 	if (in != NULL) BIO_free(in);
    777 	return(ret);
    778 	}
    779 #endif
    780