ssl_lib.c 73.8 KB
Newer Older
1 2 3
/*! \file ssl/ssl_lib.c
 *  \brief Version independent SSL functions.
 */
4
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 * 
 * This library is free for commercial and non-commercial use as long as
 * the following conditions are aheared to.  The following conditions
 * apply to all code found in this distribution, be it the RC4, RSA,
 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
 * included with this distribution is covered by the same copyright terms
 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
 * 
 * Copyright remains Eric Young's, and as such any Copyright notices in
 * the code are not to be removed.
 * If this package is used in a product, Eric Young should be given attribution
 * as the author of the parts of the library used.
 * This can be in the form of a textual message at program startup or
 * in documentation (online or textual) provided with the package.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *    "This product includes cryptographic software written by
 *     Eric Young (eay@cryptsoft.com)"
 *    The word 'cryptographic' can be left out if the rouines from the library
 *    being used are not cryptographic related :-).
 * 4. If you include any Windows specific code (or a derivative thereof) from 
 *    the apps directory (application code) you must include an acknowledgement:
 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
 * 
 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * 
 * The licence and distribution terms for any publically available version or
 * derivative of this code cannot be changed.  i.e. this code cannot simply be
 * copied and put under another distribution licence
 * [including the GNU Public Licence.]
 */
60
/* ====================================================================
61
 * Copyright (c) 1998-2007 The OpenSSL Project.  All rights reserved.
62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer. 
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. All advertising materials mentioning features or use of this
 *    software must display the following acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
 *
 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission. For written permission, please contact
 *    openssl-core@openssl.org.
 *
 * 5. Products derived from this software may not be called "OpenSSL"
 *    nor may "OpenSSL" appear in their names without prior written
 *    permission of the OpenSSL Project.
 *
 * 6. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
 *
 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 * ====================================================================
 *
 * This product includes cryptographic software written by Eric Young
 * (eay@cryptsoft.com).  This product includes software written by Tim
 * Hudson (tjh@cryptsoft.com).
 *
 */
B
Bodo Möller 已提交
113 114 115 116 117
/* ====================================================================
 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
 * ECC cipher suite support in OpenSSL originally developed by 
 * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
 */
118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
/* ====================================================================
 * Copyright 2005 Nokia. All rights reserved.
 *
 * The portions of the attached software ("Contribution") is developed by
 * Nokia Corporation and is licensed pursuant to the OpenSSL open source
 * license.
 *
 * The Contribution, originally written by Mika Kousa and Pasi Eronen of
 * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
 * support (see RFC 4279) to OpenSSL.
 *
 * No patent licenses or other rights except those expressly stated in
 * the OpenSSL open source license shall be deemed granted or received
 * expressly, by implication, estoppel, or otherwise.
 *
 * No assurances are provided by Nokia that the Contribution does not
 * infringe the patent or other intellectual property rights of any third
 * party or that the license provides you with all the necessary rights
 * to make use of the Contribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
 * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
 * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
 * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
 * OTHERWISE.
 */
144

B
Bodo Möller 已提交
145 146 147
#ifdef REF_CHECK
#  include <assert.h>
#endif
148
#include <stdio.h>
149 150
#include "ssl_locl.h"
#include "kssl_lcl.h"
151 152
#include <openssl/objects.h>
#include <openssl/lhash.h>
153
#include <openssl/x509v3.h>
154
#include <openssl/rand.h>
155
#include <openssl/ocsp.h>
N
make  
Nils Larsch 已提交
156
#ifndef OPENSSL_NO_DH
157
#include <openssl/dh.h>
N
make  
Nils Larsch 已提交
158
#endif
159 160 161
#ifndef OPENSSL_NO_ENGINE
#include <openssl/engine.h>
#endif
162

163
const char *SSL_version_str=OPENSSL_VERSION_TEXT;
164

165
SSL3_ENC_METHOD ssl3_undef_enc_method={
D
 
Dr. Stephen Henson 已提交
166
	/* evil casts, but these functions are only called if there's a library bug */
B
Bodo Möller 已提交
167 168
	(int (*)(SSL *,int))ssl_undefined_function,
	(int (*)(SSL *, unsigned char *, int))ssl_undefined_function,
169
	ssl_undefined_function,
B
Bodo Möller 已提交
170 171
	(int (*)(SSL *, unsigned char *, unsigned char *, int))ssl_undefined_function,
	(int (*)(SSL*, int))ssl_undefined_function,
172
	(int (*)(SSL *,  const char*, int, unsigned char *))ssl_undefined_function,
173
	0,	/* finish_mac_length */
174
	(int (*)(SSL *, int, unsigned char *))ssl_undefined_function,
175 176 177 178 179
	NULL,	/* client_finished_label */
	0,	/* client_finished_label_len */
	NULL,	/* server_finished_label */
	0,	/* server_finished_label_len */
	(int (*)(int))ssl_undefined_function
180
	};
181

182
int SSL_clear(SSL *s)
183 184
	{

185 186 187 188 189
	if (s->method == NULL)
		{
		SSLerr(SSL_F_SSL_CLEAR,SSL_R_NO_METHOD_SPECIFIED);
		return(0);
		}
190

L
Lutz Jänicke 已提交
191 192 193 194 195 196
	if (ssl_clear_bad_session(s))
		{
		SSL_SESSION_free(s->session);
		s->session=NULL;
		}

197 198
	s->error=0;
	s->hit=0;
199
	s->shutdown=0;
200

B
Bodo Möller 已提交
201 202
#if 0 /* Disabled since version 1.10 of this file (early return not
       * needed because SSL_clear is not called when doing renegotiation) */
203 204
	/* This is set if we are doing dynamic renegotiation so keep
	 * the old cipher.  It is sort of a SSL_clear_lite :-) */
205
	if (s->new_session) return(1);
B
Bodo Möller 已提交
206 207 208
#else
	if (s->new_session)
		{
B
Bodo Möller 已提交
209
		SSLerr(SSL_F_SSL_CLEAR,ERR_R_INTERNAL_ERROR);
B
Bodo Möller 已提交
210 211
		return 0;
		}
212
#endif
213 214 215

	s->type=0;

216 217
	s->state=SSL_ST_BEFORE|((s->server)?SSL_ST_ACCEPT:SSL_ST_CONNECT);

218
	s->version=s->method->version;
219
	s->client_version=s->version;
220 221
	s->rwstate=SSL_NOTHING;
	s->rstate=SSL_ST_READ_HEADER;
222
#if 0
223
	s->read_ahead=s->ctx->read_ahead;
224
#endif
225 226 227 228 229 230 231 232

	if (s->init_buf != NULL)
		{
		BUF_MEM_free(s->init_buf);
		s->init_buf=NULL;
		}

	ssl_clear_cipher_ctx(s);
233 234
	ssl_clear_hash_ctx(&s->read_hash);
	ssl_clear_hash_ctx(&s->write_hash);
235 236 237

	s->first_packet=0;

238 239 240
#if 1
	/* Check to see if we were changed into a different method, if
	 * so, revert back if we are not doing session-id reuse. */
241
	if (!s->in_handshake && (s->session == NULL) && (s->method != s->ctx->method))
242 243 244 245 246 247 248 249 250 251
		{
		s->method->ssl_free(s);
		s->method=s->ctx->method;
		if (!s->method->ssl_new(s))
			return(0);
		}
	else
#endif
		s->method->ssl_clear(s);
	return(1);
252 253
	}

254
/** Used to change an SSL_CTXs default SSL method type */
255
int SSL_CTX_set_ssl_version(SSL_CTX *ctx,const SSL_METHOD *meth)
256
	{
B
Ben Laurie 已提交
257
	STACK_OF(SSL_CIPHER) *sk;
258 259 260 261

	ctx->method=meth;

	sk=ssl_create_cipher_list(ctx->method,&(ctx->cipher_list),
262 263
		&(ctx->cipher_list_by_id),
		meth->version == SSL2_VERSION ? "SSLv2" : SSL_DEFAULT_CIPHER_LIST);
B
Ben Laurie 已提交
264
	if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= 0))
265 266 267 268 269 270 271
		{
		SSLerr(SSL_F_SSL_CTX_SET_SSL_VERSION,SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS);
		return(0);
		}
	return(1);
	}

272
SSL *SSL_new(SSL_CTX *ctx)
273 274 275 276 277 278 279 280 281 282 283 284 285 286
	{
	SSL *s;

	if (ctx == NULL)
		{
		SSLerr(SSL_F_SSL_NEW,SSL_R_NULL_SSL_CTX);
		return(NULL);
		}
	if (ctx->method == NULL)
		{
		SSLerr(SSL_F_SSL_NEW,SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION);
		return(NULL);
		}

287
	s=(SSL *)OPENSSL_malloc(sizeof(SSL));
288 289 290
	if (s == NULL) goto err;
	memset(s,0,sizeof(SSL));

291
#ifndef	OPENSSL_NO_KRB5
292
	s->kssl_ctx = kssl_ctx_new();
293
#endif	/* OPENSSL_NO_KRB5 */
294

295 296 297 298
	s->options=ctx->options;
	s->mode=ctx->mode;
	s->max_cert_list=ctx->max_cert_list;

299
	if (ctx->cert != NULL)
300
		{
301 302 303 304 305 306 307 308 309 310 311 312 313
		/* Earlier library versions used to copy the pointer to
		 * the CERT, not its contents; only when setting new
		 * parameters for the per-SSL copy, ssl_cert_new would be
		 * called (and the direct reference to the per-SSL_CTX
		 * settings would be lost, but those still were indirectly
		 * accessed for various purposes, and for that reason they
		 * used to be known as s->ctx->default_cert).
		 * Now we don't look at the SSL_CTX's CERT after having
		 * duplicated it once. */

		s->cert = ssl_cert_dup(ctx->cert);
		if (s->cert == NULL)
			goto err;
314 315
		}
	else
316
		s->cert=NULL; /* Cannot really happen (see SSL_CTX_new) */
317 318 319 320

	s->read_ahead=ctx->read_ahead;
	s->msg_callback=ctx->msg_callback;
	s->msg_callback_arg=ctx->msg_callback_arg;
321
	s->verify_mode=ctx->verify_mode;
322
#if 0
323
	s->verify_depth=ctx->verify_depth;
324
#endif
325
	s->sid_ctx_length=ctx->sid_ctx_length;
326
	OPENSSL_assert(s->sid_ctx_length <= sizeof s->sid_ctx);
327
	memcpy(&s->sid_ctx,&ctx->sid_ctx,sizeof(s->sid_ctx));
328
	s->verify_callback=ctx->default_verify_callback;
329
	s->generate_session_id=ctx->generate_session_id;
330 331 332 333 334 335

	s->param = X509_VERIFY_PARAM_new();
	if (!s->param)
		goto err;
	X509_VERIFY_PARAM_inherit(s->param, ctx->param);
#if 0
336 337
	s->purpose = ctx->purpose;
	s->trust = ctx->trust;
338
#endif
339
	s->quiet_shutdown=ctx->quiet_shutdown;
340
	s->max_send_fragment = ctx->max_send_fragment;
341

342 343
	CRYPTO_add(&ctx->references,1,CRYPTO_LOCK_SSL_CTX);
	s->ctx=ctx;
344
#ifndef OPENSSL_NO_TLSEXT
345 346 347
	s->tlsext_debug_cb = 0;
	s->tlsext_debug_arg = NULL;
	s->tlsext_ticket_expected = 0;
348 349 350 351 352 353
	s->tlsext_status_type = -1;
	s->tlsext_status_expected = 0;
	s->tlsext_ocsp_ids = NULL;
	s->tlsext_ocsp_exts = NULL;
	s->tlsext_ocsp_resp = NULL;
	s->tlsext_ocsp_resplen = -1;
354 355 356
	CRYPTO_add(&ctx->references,1,CRYPTO_LOCK_SSL_CTX);
	s->initial_ctx=ctx;
#endif
357 358 359 360 361 362 363 364

	s->verify_result=X509_V_OK;

	s->method=ctx->method;

	if (!s->method->ssl_new(s))
		goto err;

365
	s->references=1;
366
	s->server=(ctx->method->ssl_accept == ssl_undefined_function)?0:1;
367

368
	SSL_clear(s);
369

370
	CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
371

372 373 374 375 376
#ifndef OPENSSL_NO_PSK
	s->psk_client_callback=ctx->psk_client_callback;
	s->psk_server_callback=ctx->psk_server_callback;
#endif

377 378
	return(s);
err:
379 380 381 382 383 384
	if (s != NULL)
		{
		if (s->cert != NULL)
			ssl_cert_free(s->cert);
		if (s->ctx != NULL)
			SSL_CTX_free(s->ctx); /* decrement reference count */
385
		OPENSSL_free(s);
386
		}
387 388 389 390
	SSLerr(SSL_F_SSL_NEW,ERR_R_MALLOC_FAILURE);
	return(NULL);
	}

391 392 393
int SSL_CTX_set_session_id_context(SSL_CTX *ctx,const unsigned char *sid_ctx,
				   unsigned int sid_ctx_len)
    {
394
    if(sid_ctx_len > sizeof ctx->sid_ctx)
395 396 397 398 399 400 401 402 403 404
	{
	SSLerr(SSL_F_SSL_CTX_SET_SESSION_ID_CONTEXT,SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
	return 0;
	}
    ctx->sid_ctx_length=sid_ctx_len;
    memcpy(ctx->sid_ctx,sid_ctx,sid_ctx_len);

    return 1;
    }

B
Ben Laurie 已提交
405 406 407 408 409 410 411 412 413 414 415 416 417 418
int SSL_set_session_id_context(SSL *ssl,const unsigned char *sid_ctx,
			       unsigned int sid_ctx_len)
    {
    if(sid_ctx_len > SSL_MAX_SID_CTX_LENGTH)
	{
	SSLerr(SSL_F_SSL_SET_SESSION_ID_CONTEXT,SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
	return 0;
	}
    ssl->sid_ctx_length=sid_ctx_len;
    memcpy(ssl->sid_ctx,sid_ctx,sid_ctx_len);

    return 1;
    }

419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434
int SSL_CTX_set_generate_session_id(SSL_CTX *ctx, GEN_SESSION_CB cb)
	{
	CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
	ctx->generate_session_id = cb;
	CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
	return 1;
	}

int SSL_set_generate_session_id(SSL *ssl, GEN_SESSION_CB cb)
	{
	CRYPTO_w_lock(CRYPTO_LOCK_SSL);
	ssl->generate_session_id = cb;
	CRYPTO_w_unlock(CRYPTO_LOCK_SSL);
	return 1;
	}

435
int SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id,
436
				unsigned int id_len)
437 438 439 440 441
	{
	/* A quick examination of SSL_SESSION_hash and SSL_SESSION_cmp shows how
	 * we can "construct" a session to give us the desired check - ie. to
	 * find if there's a session in the hash table that would conflict with
	 * any new session built out of this id/id_len and the ssl_version in
442
	 * use by this SSL. */
443
	SSL_SESSION r, *p;
444 445 446 447

	if(id_len > sizeof r.session_id)
		return 0;

448
	r.ssl_version = ssl->version;
449 450
	r.session_id_length = id_len;
	memcpy(r.session_id, id, id_len);
451 452 453 454 455 456 457 458 459 460 461
	/* NB: SSLv2 always uses a fixed 16-byte session ID, so even if a
	 * callback is calling us to check the uniqueness of a shorter ID, it
	 * must be compared as a padded-out ID because that is what it will be
	 * converted to when the callback has finished choosing it. */
	if((r.ssl_version == SSL2_VERSION) &&
			(id_len < SSL2_SSL_SESSION_ID_LENGTH))
		{
		memset(r.session_id + id_len, 0,
			SSL2_SSL_SESSION_ID_LENGTH - id_len);
		r.session_id_length = SSL2_SSL_SESSION_ID_LENGTH;
		}
462 463

	CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);
B
Ben Laurie 已提交
464
	p = lh_SSL_SESSION_retrieve(ssl->ctx->sessions, &r);
465 466 467 468
	CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
	return (p != NULL);
	}

469
int SSL_CTX_set_purpose(SSL_CTX *s, int purpose)
470
	{
471
	return X509_VERIFY_PARAM_set_purpose(s->param, purpose);
472
	}
473 474

int SSL_set_purpose(SSL *s, int purpose)
475
	{
476
	return X509_VERIFY_PARAM_set_purpose(s->param, purpose);
477
	}
D
 
Dr. Stephen Henson 已提交
478

479
int SSL_CTX_set_trust(SSL_CTX *s, int trust)
480
	{
481
	return X509_VERIFY_PARAM_set_trust(s->param, trust);
482
	}
483 484

int SSL_set_trust(SSL *s, int trust)
485
	{
486
	return X509_VERIFY_PARAM_set_trust(s->param, trust);
487
	}
488

D
Dr. Stephen Henson 已提交
489 490 491 492 493 494 495 496 497 498
int SSL_CTX_set1_param(SSL_CTX *ctx, X509_VERIFY_PARAM *vpm)
	{
	return X509_VERIFY_PARAM_set1(ctx->param, vpm);
	}

int SSL_set1_param(SSL *ssl, X509_VERIFY_PARAM *vpm)
	{
	return X509_VERIFY_PARAM_set1(ssl->param, vpm);
	}

499
void SSL_free(SSL *s)
500
	{
501 502
	int i;

B
Ben Laurie 已提交
503 504 505
	if(s == NULL)
	    return;

506 507 508 509 510 511 512 513 514 515 516 517 518
	i=CRYPTO_add(&s->references,-1,CRYPTO_LOCK_SSL);
#ifdef REF_PRINT
	REF_PRINT("SSL",s);
#endif
	if (i > 0) return;
#ifdef REF_CHECK
	if (i < 0)
		{
		fprintf(stderr,"SSL_free, bad reference count\n");
		abort(); /* ok */
		}
#endif

519 520 521
	if (s->param)
		X509_VERIFY_PARAM_free(s->param);

522
	CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
523

524 525 526 527 528 529 530 531
	if (s->bbio != NULL)
		{
		/* If the buffering BIO is in place, pop it off */
		if (s->bbio == s->wbio)
			{
			s->wbio=BIO_pop(s->wbio);
			}
		BIO_free(s->bbio);
532
		s->bbio=NULL;
533 534 535 536 537 538 539 540 541
		}
	if (s->rbio != NULL)
		BIO_free_all(s->rbio);
	if ((s->wbio != NULL) && (s->wbio != s->rbio))
		BIO_free_all(s->wbio);

	if (s->init_buf != NULL) BUF_MEM_free(s->init_buf);

	/* add extra stuff */
B
Ben Laurie 已提交
542 543
	if (s->cipher_list != NULL) sk_SSL_CIPHER_free(s->cipher_list);
	if (s->cipher_list_by_id != NULL) sk_SSL_CIPHER_free(s->cipher_list_by_id);
544 545 546 547 548 549 550 551 552

	/* Make the next call work :-) */
	if (s->session != NULL)
		{
		ssl_clear_bad_session(s);
		SSL_SESSION_free(s->session);
		}

	ssl_clear_cipher_ctx(s);
553 554
	ssl_clear_hash_ctx(&s->read_hash);
	ssl_clear_hash_ctx(&s->write_hash);
555 556 557 558

	if (s->cert != NULL) ssl_cert_free(s->cert);
	/* Free up if allocated */

559
#ifndef OPENSSL_NO_TLSEXT
B
Ben Laurie 已提交
560 561
	if (s->tlsext_hostname)
		OPENSSL_free(s->tlsext_hostname);
562
	if (s->initial_ctx) SSL_CTX_free(s->initial_ctx);
B
Bodo Möller 已提交
563 564 565 566
#ifndef OPENSSL_NO_EC
	if (s->tlsext_ecpointformatlist) OPENSSL_free(s->tlsext_ecpointformatlist);
	if (s->tlsext_ellipticcurvelist) OPENSSL_free(s->tlsext_ellipticcurvelist);
#endif /* OPENSSL_NO_EC */
567
	if (s->tlsext_opaque_prf_input) OPENSSL_free(s->tlsext_opaque_prf_input);
568 569 570 571 572 573 574
	if (s->tlsext_ocsp_exts)
		sk_X509_EXTENSION_pop_free(s->tlsext_ocsp_exts,
						X509_EXTENSION_free);
	if (s->tlsext_ocsp_ids)
		sk_OCSP_RESPID_pop_free(s->tlsext_ocsp_ids, OCSP_RESPID_free);
	if (s->tlsext_ocsp_resp)
		OPENSSL_free(s->tlsext_ocsp_resp);
575
#endif
576 577

	if (s->client_CA != NULL)
B
Ben Laurie 已提交
578
		sk_X509_NAME_pop_free(s->client_CA,X509_NAME_free);
579 580 581

	if (s->method != NULL) s->method->ssl_free(s);

D
Dr. Stephen Henson 已提交
582 583
	if (s->ctx) SSL_CTX_free(s->ctx);

584 585 586 587 588
#ifndef	OPENSSL_NO_KRB5
	if (s->kssl_ctx != NULL)
		kssl_ctx_free(s->kssl_ctx);
#endif	/* OPENSSL_NO_KRB5 */

589
	OPENSSL_free(s);
590 591
	}

592
void SSL_set_bio(SSL *s,BIO *rbio,BIO *wbio)
593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611
	{
	/* If the output buffering BIO is still in place, remove it
	 */
	if (s->bbio != NULL)
		{
		if (s->wbio == s->bbio)
			{
			s->wbio=s->wbio->next_bio;
			s->bbio->next_bio=NULL;
			}
		}
	if ((s->rbio != NULL) && (s->rbio != rbio))
		BIO_free_all(s->rbio);
	if ((s->wbio != NULL) && (s->wbio != wbio) && (s->rbio != s->wbio))
		BIO_free_all(s->wbio);
	s->rbio=rbio;
	s->wbio=wbio;
	}

B
Ben Laurie 已提交
612
BIO *SSL_get_rbio(const SSL *s)
613 614
	{ return(s->rbio); }

B
Ben Laurie 已提交
615
BIO *SSL_get_wbio(const SSL *s)
616 617
	{ return(s->wbio); }

B
Ben Laurie 已提交
618
int SSL_get_fd(const SSL *s)
619
	{
620
	return(SSL_get_rfd(s));
621 622
	}

B
Ben Laurie 已提交
623
int SSL_get_rfd(const SSL *s)
624 625 626 627 628 629 630 631 632 633 634
	{
	int ret= -1;
	BIO *b,*r;

	b=SSL_get_rbio(s);
	r=BIO_find_type(b,BIO_TYPE_DESCRIPTOR);
	if (r != NULL)
		BIO_get_fd(r,&ret);
	return(ret);
	}

B
Ben Laurie 已提交
635
int SSL_get_wfd(const SSL *s)
636 637 638 639 640 641 642 643 644 645 646
	{
	int ret= -1;
	BIO *b,*r;

	b=SSL_get_wbio(s);
	r=BIO_find_type(b,BIO_TYPE_DESCRIPTOR);
	if (r != NULL)
		BIO_get_fd(r,&ret);
	return(ret);
	}

647
#ifndef OPENSSL_NO_SOCK
648
int SSL_set_fd(SSL *s,int fd)
649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666
	{
	int ret=0;
	BIO *bio=NULL;

	bio=BIO_new(BIO_s_socket());

	if (bio == NULL)
		{
		SSLerr(SSL_F_SSL_SET_FD,ERR_R_BUF_LIB);
		goto err;
		}
	BIO_set_fd(bio,fd,BIO_NOCLOSE);
	SSL_set_bio(s,bio,bio);
	ret=1;
err:
	return(ret);
	}

667
int SSL_set_wfd(SSL *s,int fd)
668 669 670 671
	{
	int ret=0;
	BIO *bio=NULL;

672 673 674 675
	if ((s->rbio == NULL) || (BIO_method_type(s->rbio) != BIO_TYPE_SOCKET)
		|| ((int)BIO_get_fd(s->rbio,NULL) != fd))
		{
		bio=BIO_new(BIO_s_socket());
676

677 678 679 680 681 682 683
		if (bio == NULL)
			{ SSLerr(SSL_F_SSL_SET_WFD,ERR_R_BUF_LIB); goto err; }
		BIO_set_fd(bio,fd,BIO_NOCLOSE);
		SSL_set_bio(s,SSL_get_rbio(s),bio);
		}
	else
		SSL_set_bio(s,SSL_get_rbio(s),SSL_get_rbio(s));
684 685 686 687 688
	ret=1;
err:
	return(ret);
	}

689
int SSL_set_rfd(SSL *s,int fd)
690 691 692 693
	{
	int ret=0;
	BIO *bio=NULL;

694 695
	if ((s->wbio == NULL) || (BIO_method_type(s->wbio) != BIO_TYPE_SOCKET)
		|| ((int)BIO_get_fd(s->wbio,NULL) != fd))
696
		{
697 698 699 700 701 702 703 704 705
		bio=BIO_new(BIO_s_socket());

		if (bio == NULL)
			{
			SSLerr(SSL_F_SSL_SET_RFD,ERR_R_BUF_LIB);
			goto err;
			}
		BIO_set_fd(bio,fd,BIO_NOCLOSE);
		SSL_set_bio(s,bio,SSL_get_wbio(s));
706
		}
707 708
	else
		SSL_set_bio(s,SSL_get_wbio(s),SSL_get_wbio(s));
709 710 711 712 713 714
	ret=1;
err:
	return(ret);
	}
#endif

715 716

/* return length of latest Finished message we sent, copy to 'buf' */
B
Ben Laurie 已提交
717
size_t SSL_get_finished(const SSL *s, void *buf, size_t count)
718 719 720 721 722 723 724 725 726 727 728 729 730 731
	{
	size_t ret = 0;
	
	if (s->s3 != NULL)
		{
		ret = s->s3->tmp.finish_md_len;
		if (count > ret)
			count = ret;
		memcpy(buf, s->s3->tmp.finish_md, count);
		}
	return ret;
	}

/* return length of latest Finished message we expected, copy to 'buf' */
B
Ben Laurie 已提交
732
size_t SSL_get_peer_finished(const SSL *s, void *buf, size_t count)
733 734 735 736 737 738 739 740 741 742 743 744 745 746
	{
	size_t ret = 0;
	
	if (s->s3 != NULL)
		{
		ret = s->s3->tmp.peer_finish_md_len;
		if (count > ret)
			count = ret;
		memcpy(buf, s->s3->tmp.peer_finish_md, count);
		}
	return ret;
	}


B
Ben Laurie 已提交
747
int SSL_get_verify_mode(const SSL *s)
748 749 750 751
	{
	return(s->verify_mode);
	}

B
Ben Laurie 已提交
752
int SSL_get_verify_depth(const SSL *s)
753
	{
754
	return X509_VERIFY_PARAM_get_depth(s->param);
755 756
	}

B
Ben Laurie 已提交
757
int (*SSL_get_verify_callback(const SSL *s))(int,X509_STORE_CTX *)
758 759 760 761
	{
	return(s->verify_callback);
	}

B
Ben Laurie 已提交
762
int SSL_CTX_get_verify_mode(const SSL_CTX *ctx)
763
	{
764
	return(ctx->verify_mode);
765 766
	}

B
Ben Laurie 已提交
767
int SSL_CTX_get_verify_depth(const SSL_CTX *ctx)
768
	{
769
	return X509_VERIFY_PARAM_get_depth(ctx->param);
770 771
	}

B
Ben Laurie 已提交
772
int (*SSL_CTX_get_verify_callback(const SSL_CTX *ctx))(int,X509_STORE_CTX *)
773 774 775 776
	{
	return(ctx->default_verify_callback);
	}

B
Ben Laurie 已提交
777 778
void SSL_set_verify(SSL *s,int mode,
		    int (*callback)(int ok,X509_STORE_CTX *ctx))
779 780 781 782 783 784
	{
	s->verify_mode=mode;
	if (callback != NULL)
		s->verify_callback=callback;
	}

785 786
void SSL_set_verify_depth(SSL *s,int depth)
	{
787
	X509_VERIFY_PARAM_set_depth(s->param, depth);
788 789
	}

790
void SSL_set_read_ahead(SSL *s,int yes)
791 792 793 794
	{
	s->read_ahead=yes;
	}

B
Ben Laurie 已提交
795
int SSL_get_read_ahead(const SSL *s)
796 797 798 799
	{
	return(s->read_ahead);
	}

B
Ben Laurie 已提交
800
int SSL_pending(const SSL *s)
801
	{
B
Bodo Möller 已提交
802 803 804 805 806 807 808
	/* SSL_pending cannot work properly if read-ahead is enabled
	 * (SSL_[CTX_]ctrl(..., SSL_CTRL_SET_READ_AHEAD, 1, NULL)),
	 * and it is impossible to fix since SSL_pending cannot report
	 * errors that may be observed while scanning the new data.
	 * (Note that SSL_pending() is often used as a boolean value,
	 * so we'd better not return -1.)
	 */
809 810 811
	return(s->method->ssl_pending(s));
	}

B
Ben Laurie 已提交
812
X509 *SSL_get_peer_certificate(const SSL *s)
813 814 815 816 817 818 819 820 821 822 823 824 825 826 827
	{
	X509 *r;
	
	if ((s == NULL) || (s->session == NULL))
		r=NULL;
	else
		r=s->session->peer;

	if (r == NULL) return(r);

	CRYPTO_add(&r->references,1,CRYPTO_LOCK_X509);

	return(r);
	}

B
Ben Laurie 已提交
828
STACK_OF(X509) *SSL_get_peer_cert_chain(const SSL *s)
829
	{
B
Ben Laurie 已提交
830
	STACK_OF(X509) *r;
831
	
832
	if ((s == NULL) || (s->session == NULL) || (s->session->sess_cert == NULL))
833 834
		r=NULL;
	else
835
		r=s->session->sess_cert->cert_chain;
836

837 838 839
	/* If we are a client, cert_chain includes the peer's own
	 * certificate; if we are a server, it does not. */
	
840 841 842 843 844
	return(r);
	}

/* Now in theory, since the calling process own 't' it should be safe to
 * modify.  We need to be able to read f without being hassled */
B
Ben Laurie 已提交
845
void SSL_copy_session_id(SSL *t,const SSL *f)
846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869
	{
	CERT *tmp;

	/* Do we need to to SSL locking? */
	SSL_set_session(t,SSL_get_session(f));

	/* what if we are setup as SSLv2 but want to talk SSLv3 or
	 * vice-versa */
	if (t->method != f->method)
		{
		t->method->ssl_free(t);	/* cleanup current */
		t->method=f->method;	/* change method */
		t->method->ssl_new(t);	/* setup new */
		}

	tmp=t->cert;
	if (f->cert != NULL)
		{
		CRYPTO_add(&f->cert->references,1,CRYPTO_LOCK_SSL_CERT);
		t->cert=f->cert;
		}
	else
		t->cert=NULL;
	if (tmp != NULL) ssl_cert_free(tmp);
B
Ben Laurie 已提交
870
	SSL_set_session_id_context(t,f->sid_ctx,f->sid_ctx_length);
871 872
	}

873
/* Fix this so it checks all the valid key/cert options */
B
Ben Laurie 已提交
874
int SSL_CTX_check_private_key(const SSL_CTX *ctx)
875 876
	{
	if (	(ctx == NULL) ||
877 878
		(ctx->cert == NULL) ||
		(ctx->cert->key->x509 == NULL))
879 880 881 882
		{
		SSLerr(SSL_F_SSL_CTX_CHECK_PRIVATE_KEY,SSL_R_NO_CERTIFICATE_ASSIGNED);
		return(0);
		}
883
	if 	(ctx->cert->key->privatekey == NULL)
884 885 886 887
		{
		SSLerr(SSL_F_SSL_CTX_CHECK_PRIVATE_KEY,SSL_R_NO_PRIVATE_KEY_ASSIGNED);
		return(0);
		}
888
	return(X509_check_private_key(ctx->cert->key->x509, ctx->cert->key->privatekey));
889 890
	}

891
/* Fix this function so that it takes an optional type parameter */
B
Ben Laurie 已提交
892
int SSL_check_private_key(const SSL *ssl)
893 894 895 896 897 898
	{
	if (ssl == NULL)
		{
		SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY,ERR_R_PASSED_NULL_PARAMETER);
		return(0);
		}
899
	if (ssl->cert == NULL)
B
Bodo Möller 已提交
900
		{
901
		SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY,SSL_R_NO_CERTIFICATE_ASSIGNED);
902
		return 0;
B
Bodo Möller 已提交
903
		}
904 905 906 907 908 909 910 911 912 913 914 915 916 917
	if (ssl->cert->key->x509 == NULL)
		{
		SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY,SSL_R_NO_CERTIFICATE_ASSIGNED);
		return(0);
		}
	if (ssl->cert->key->privatekey == NULL)
		{
		SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY,SSL_R_NO_PRIVATE_KEY_ASSIGNED);
		return(0);
		}
	return(X509_check_private_key(ssl->cert->key->x509,
		ssl->cert->key->privatekey));
	}

918
int SSL_accept(SSL *s)
919
	{
920 921 922 923
	if (s->handshake_func == 0)
		/* Not properly initialized yet */
		SSL_set_accept_state(s);

924 925 926
	return(s->method->ssl_accept(s));
	}

927
int SSL_connect(SSL *s)
928
	{
929 930 931 932
	if (s->handshake_func == 0)
		/* Not properly initialized yet */
		SSL_set_connect_state(s);

933 934 935
	return(s->method->ssl_connect(s));
	}

B
Ben Laurie 已提交
936
long SSL_get_default_timeout(const SSL *s)
937 938 939 940
	{
	return(s->method->get_timeout());
	}

941
int SSL_read(SSL *s,void *buf,int num)
942
	{
943 944
	if (s->handshake_func == 0)
		{
945
		SSLerr(SSL_F_SSL_READ, SSL_R_UNINITIALIZED);
946 947 948
		return -1;
		}

949 950 951 952 953 954 955 956
	if (s->shutdown & SSL_RECEIVED_SHUTDOWN)
		{
		s->rwstate=SSL_NOTHING;
		return(0);
		}
	return(s->method->ssl_read(s,buf,num));
	}

957
int SSL_peek(SSL *s,void *buf,int num)
958
	{
B
Bodo Möller 已提交
959 960
	if (s->handshake_func == 0)
		{
961
		SSLerr(SSL_F_SSL_PEEK, SSL_R_UNINITIALIZED);
B
Bodo Möller 已提交
962 963 964
		return -1;
		}

965 966 967 968 969 970 971
	if (s->shutdown & SSL_RECEIVED_SHUTDOWN)
		{
		return(0);
		}
	return(s->method->ssl_peek(s,buf,num));
	}

972
int SSL_write(SSL *s,const void *buf,int num)
973
	{
974 975
	if (s->handshake_func == 0)
		{
976
		SSLerr(SSL_F_SSL_WRITE, SSL_R_UNINITIALIZED);
977 978 979
		return -1;
		}

980 981 982 983 984 985 986 987 988
	if (s->shutdown & SSL_SENT_SHUTDOWN)
		{
		s->rwstate=SSL_NOTHING;
		SSLerr(SSL_F_SSL_WRITE,SSL_R_PROTOCOL_IS_SHUTDOWN);
		return(-1);
		}
	return(s->method->ssl_write(s,buf,num));
	}

989
int SSL_shutdown(SSL *s)
990
	{
B
Bodo Möller 已提交
991
	/* Note that this function behaves differently from what one might
B
Bodo Möller 已提交
992 993 994 995 996
	 * expect.  Return values are 0 for no success (yet),
	 * 1 for success; but calling it once is usually not enough,
	 * even if blocking I/O is used (see ssl3_shutdown).
	 */

997 998
	if (s->handshake_func == 0)
		{
999
		SSLerr(SSL_F_SSL_SHUTDOWN, SSL_R_UNINITIALIZED);
1000 1001 1002
		return -1;
		}

1003 1004 1005 1006 1007 1008
	if ((s != NULL) && !SSL_in_init(s))
		return(s->method->ssl_shutdown(s));
	else
		return(1);
	}

1009
int SSL_renegotiate(SSL *s)
1010
	{
1011 1012 1013 1014
	if (s->new_session == 0)
		{
		s->new_session=1;
		}
1015 1016 1017
	return(s->method->ssl_renegotiate(s));
	}

1018 1019 1020 1021 1022 1023 1024
int SSL_renegotiate_pending(SSL *s)
	{
	/* becomes true when negotiation is requested;
	 * false again once a handshake has finished */
	return (s->new_session != 0);
	}

1025
long SSL_ctrl(SSL *s,int cmd,long larg,void *parg)
1026
	{
1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
	long l;

	switch (cmd)
		{
	case SSL_CTRL_GET_READ_AHEAD:
		return(s->read_ahead);
	case SSL_CTRL_SET_READ_AHEAD:
		l=s->read_ahead;
		s->read_ahead=larg;
		return(l);
1037 1038 1039 1040 1041

	case SSL_CTRL_SET_MSG_CALLBACK_ARG:
		s->msg_callback_arg = parg;
		return 1;

1042 1043
	case SSL_CTRL_OPTIONS:
		return(s->options|=larg);
1044 1045
	case SSL_CTRL_MODE:
		return(s->mode|=larg);
1046 1047 1048 1049 1050 1051
	case SSL_CTRL_GET_MAX_CERT_LIST:
		return(s->max_cert_list);
	case SSL_CTRL_SET_MAX_CERT_LIST:
		l=s->max_cert_list;
		s->max_cert_list=larg;
		return(l);
B
Ben Laurie 已提交
1052
	case SSL_CTRL_SET_MTU:
1053 1054
		if (SSL_version(s) == DTLS1_VERSION ||
		    SSL_version(s) == DTLS1_BAD_VER)
B
Ben Laurie 已提交
1055 1056 1057 1058 1059
			{
			s->d1->mtu = larg;
			return larg;
			}
		return 0;
1060 1061 1062 1063 1064
	case SSL_CTRL_SET_MAX_SEND_FRAGMENT:
		if (larg < 512 || larg > SSL3_RT_MAX_PLAIN_LENGTH)
			return 0;
		s->max_send_fragment = larg;
		return 1;
1065 1066 1067
	default:
		return(s->method->ssl_ctrl(s,cmd,larg,parg));
		}
1068 1069
	}

1070
long SSL_callback_ctrl(SSL *s, int cmd, void (*fp)(void))
1071 1072 1073
	{
	switch(cmd)
		{
1074
	case SSL_CTRL_SET_MSG_CALLBACK:
1075
		s->msg_callback = (void (*)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg))(fp);
1076 1077
		return 1;
		
1078 1079 1080 1081 1082
	default:
		return(s->method->ssl_callback_ctrl(s,cmd,fp));
		}
	}

B
Ben Laurie 已提交
1083
LHASH_OF(SSL_SESSION) *SSL_CTX_sessions(SSL_CTX *ctx)
1084 1085 1086 1087
	{
	return ctx->sessions;
	}

1088
long SSL_CTX_ctrl(SSL_CTX *ctx,int cmd,long larg,void *parg)
1089
	{
1090 1091 1092 1093 1094 1095 1096 1097 1098 1099
	long l;

	switch (cmd)
		{
	case SSL_CTRL_GET_READ_AHEAD:
		return(ctx->read_ahead);
	case SSL_CTRL_SET_READ_AHEAD:
		l=ctx->read_ahead;
		ctx->read_ahead=larg;
		return(l);
1100 1101 1102 1103 1104
		
	case SSL_CTRL_SET_MSG_CALLBACK_ARG:
		ctx->msg_callback_arg = parg;
		return 1;

1105 1106 1107 1108 1109 1110
	case SSL_CTRL_GET_MAX_CERT_LIST:
		return(ctx->max_cert_list);
	case SSL_CTRL_SET_MAX_CERT_LIST:
		l=ctx->max_cert_list;
		ctx->max_cert_list=larg;
		return(l);
1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125

	case SSL_CTRL_SET_SESS_CACHE_SIZE:
		l=ctx->session_cache_size;
		ctx->session_cache_size=larg;
		return(l);
	case SSL_CTRL_GET_SESS_CACHE_SIZE:
		return(ctx->session_cache_size);
	case SSL_CTRL_SET_SESS_CACHE_MODE:
		l=ctx->session_cache_mode;
		ctx->session_cache_mode=larg;
		return(l);
	case SSL_CTRL_GET_SESS_CACHE_MODE:
		return(ctx->session_cache_mode);

	case SSL_CTRL_SESS_NUMBER:
B
Ben Laurie 已提交
1126
		return(lh_SSL_SESSION_num_items(ctx->sessions));
1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150
	case SSL_CTRL_SESS_CONNECT:
		return(ctx->stats.sess_connect);
	case SSL_CTRL_SESS_CONNECT_GOOD:
		return(ctx->stats.sess_connect_good);
	case SSL_CTRL_SESS_CONNECT_RENEGOTIATE:
		return(ctx->stats.sess_connect_renegotiate);
	case SSL_CTRL_SESS_ACCEPT:
		return(ctx->stats.sess_accept);
	case SSL_CTRL_SESS_ACCEPT_GOOD:
		return(ctx->stats.sess_accept_good);
	case SSL_CTRL_SESS_ACCEPT_RENEGOTIATE:
		return(ctx->stats.sess_accept_renegotiate);
	case SSL_CTRL_SESS_HIT:
		return(ctx->stats.sess_hit);
	case SSL_CTRL_SESS_CB_HIT:
		return(ctx->stats.sess_cb_hit);
	case SSL_CTRL_SESS_MISSES:
		return(ctx->stats.sess_miss);
	case SSL_CTRL_SESS_TIMEOUTS:
		return(ctx->stats.sess_timeout);
	case SSL_CTRL_SESS_CACHE_FULL:
		return(ctx->stats.sess_cache_full);
	case SSL_CTRL_OPTIONS:
		return(ctx->options|=larg);
1151 1152
	case SSL_CTRL_MODE:
		return(ctx->mode|=larg);
1153 1154 1155 1156 1157
	case SSL_CTRL_SET_MAX_SEND_FRAGMENT:
		if (larg < 512 || larg > SSL3_RT_MAX_PLAIN_LENGTH)
			return 0;
		ctx->max_send_fragment = larg;
		return 1;
1158 1159 1160
	default:
		return(ctx->method->ssl_ctx_ctrl(ctx,cmd,larg,parg));
		}
1161 1162
	}

1163
long SSL_CTX_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp)(void))
1164 1165 1166
	{
	switch(cmd)
		{
1167
	case SSL_CTRL_SET_MSG_CALLBACK:
1168
		ctx->msg_callback = (void (*)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg))(fp);
1169 1170
		return 1;

1171 1172 1173 1174 1175
	default:
		return(ctx->method->ssl_ctx_callback_ctrl(ctx,cmd,fp));
		}
	}

1176
int ssl_cipher_id_cmp(const SSL_CIPHER *a, const SSL_CIPHER *b)
1177 1178 1179 1180 1181 1182 1183 1184 1185 1186
	{
	long l;

	l=a->id-b->id;
	if (l == 0L)
		return(0);
	else
		return((l > 0)?1:-1);
	}

1187 1188
int ssl_cipher_ptr_id_cmp(const SSL_CIPHER * const *ap,
			const SSL_CIPHER * const *bp)
1189 1190 1191 1192 1193 1194 1195 1196 1197 1198
	{
	long l;

	l=(*ap)->id-(*bp)->id;
	if (l == 0L)
		return(0);
	else
		return((l > 0)?1:-1);
	}

1199
/** return a STACK of the ciphers available for the SSL and in order of
1200
 * preference */
B
Ben Laurie 已提交
1201
STACK_OF(SSL_CIPHER) *SSL_get_ciphers(const SSL *s)
1202
	{
1203
	if (s != NULL)
1204
		{
1205 1206 1207 1208 1209 1210 1211 1212 1213
		if (s->cipher_list != NULL)
			{
			return(s->cipher_list);
			}
		else if ((s->ctx != NULL) &&
			(s->ctx->cipher_list != NULL))
			{
			return(s->ctx->cipher_list);
			}
1214 1215 1216 1217
		}
	return(NULL);
	}

1218
/** return a STACK of the ciphers available for the SSL and in order of
1219
 * algorithm id */
B
Ben Laurie 已提交
1220
STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL *s)
1221
	{
1222
	if (s != NULL)
1223
		{
1224 1225 1226 1227 1228 1229 1230 1231 1232
		if (s->cipher_list_by_id != NULL)
			{
			return(s->cipher_list_by_id);
			}
		else if ((s->ctx != NULL) &&
			(s->ctx->cipher_list_by_id != NULL))
			{
			return(s->ctx->cipher_list_by_id);
			}
1233 1234 1235 1236
		}
	return(NULL);
	}

1237
/** The old interface to get the same thing as SSL_get_ciphers() */
B
Ben Laurie 已提交
1238
const char *SSL_get_cipher_list(const SSL *s,int n)
1239 1240
	{
	SSL_CIPHER *c;
B
Ben Laurie 已提交
1241
	STACK_OF(SSL_CIPHER) *sk;
1242 1243 1244

	if (s == NULL) return(NULL);
	sk=SSL_get_ciphers(s);
B
Ben Laurie 已提交
1245
	if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= n))
1246
		return(NULL);
B
Ben Laurie 已提交
1247
	c=sk_SSL_CIPHER_value(sk,n);
1248 1249 1250 1251
	if (c == NULL) return(NULL);
	return(c->name);
	}

1252
/** specify the ciphers to be used by default by the SSL_CTX */
1253
int SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str)
1254
	{
B
Ben Laurie 已提交
1255
	STACK_OF(SSL_CIPHER) *sk;
1256 1257 1258
	
	sk=ssl_create_cipher_list(ctx->method,&ctx->cipher_list,
		&ctx->cipher_list_by_id,str);
1259 1260 1261
	/* ssl_create_cipher_list may return an empty stack if it
	 * was unable to find a cipher matching the given rule string
	 * (for example if the rule string specifies a cipher which
1262 1263
	 * has been disabled). This is not an error as far as
	 * ssl_create_cipher_list is concerned, and hence
1264 1265 1266 1267 1268 1269 1270 1271 1272 1273
	 * ctx->cipher_list and ctx->cipher_list_by_id has been
	 * updated. */
	if (sk == NULL)
		return 0;
	else if (sk_SSL_CIPHER_num(sk) == 0)
		{
		SSLerr(SSL_F_SSL_CTX_SET_CIPHER_LIST, SSL_R_NO_CIPHER_MATCH);
		return 0;
		}
	return 1;
1274 1275
	}

1276
/** specify the ciphers to be used by the SSL */
1277
int SSL_set_cipher_list(SSL *s,const char *str)
1278
	{
B
Ben Laurie 已提交
1279
	STACK_OF(SSL_CIPHER) *sk;
1280 1281 1282
	
	sk=ssl_create_cipher_list(s->ctx->method,&s->cipher_list,
		&s->cipher_list_by_id,str);
1283 1284 1285 1286 1287 1288 1289 1290 1291
	/* see comment in SSL_CTX_set_cipher_list */
	if (sk == NULL)
		return 0;
	else if (sk_SSL_CIPHER_num(sk) == 0)
		{
		SSLerr(SSL_F_SSL_SET_CIPHER_LIST, SSL_R_NO_CIPHER_MATCH);
		return 0;
		}
	return 1;
1292 1293 1294
	}

/* works well for SSLv2, not so good for SSLv3 */
B
Ben Laurie 已提交
1295
char *SSL_get_shared_ciphers(const SSL *s,char *buf,int len)
1296
	{
B
Ben Laurie 已提交
1297
	char *p;
B
Ben Laurie 已提交
1298
	STACK_OF(SSL_CIPHER) *sk;
1299 1300 1301 1302 1303 1304 1305 1306 1307
	SSL_CIPHER *c;
	int i;

	if ((s->session == NULL) || (s->session->ciphers == NULL) ||
		(len < 2))
		return(NULL);

	p=buf;
	sk=s->session->ciphers;
B
Ben Laurie 已提交
1308
	for (i=0; i<sk_SSL_CIPHER_num(sk); i++)
1309
		{
1310 1311
		int n;

B
Ben Laurie 已提交
1312
		c=sk_SSL_CIPHER_value(sk,i);
1313 1314
		n=strlen(c->name);
		if (n+1 > len)
1315
			{
1316 1317 1318 1319
			if (p != buf)
				--p;
			*p='\0';
			return buf;
1320
			}
1321 1322
		strcpy(p,c->name);
		p+=n;
1323
		*(p++)=':';
1324
		len-=n+1;
1325 1326 1327 1328 1329
		}
	p[-1]='\0';
	return(buf);
	}

1330
int ssl_cipher_list_to_bytes(SSL *s,STACK_OF(SSL_CIPHER) *sk,unsigned char *p,
1331
			     int (*put_cb)(const SSL_CIPHER *, unsigned char *))
1332 1333 1334 1335
	{
	int i,j=0;
	SSL_CIPHER *c;
	unsigned char *q;
1336
#ifndef OPENSSL_NO_KRB5
1337
	int nokrb5 = !kssl_tgt_is_available(s->kssl_ctx);
1338
#endif /* OPENSSL_NO_KRB5 */
1339 1340 1341 1342

	if (sk == NULL) return(0);
	q=p;

B
Ben Laurie 已提交
1343
	for (i=0; i<sk_SSL_CIPHER_num(sk); i++)
1344
		{
B
Ben Laurie 已提交
1345
		c=sk_SSL_CIPHER_value(sk,i);
1346
#ifndef OPENSSL_NO_KRB5
1347 1348 1349 1350
		if (((c->algorithm_mkey & SSL_kKRB5) || (c->algorithm_auth & SSL_aKRB5)) &&
		    nokrb5)
		    continue;
#endif /* OPENSSL_NO_KRB5 */
1351 1352
#ifndef OPENSSL_NO_PSK
		/* with PSK there must be client callback set */
1353 1354
		if (((c->algorithm_mkey & SSL_kPSK) || (c->algorithm_auth & SSL_aPSK)) &&
		    s->psk_client_callback == NULL)
1355 1356
			continue;
#endif /* OPENSSL_NO_PSK */
1357
		j = put_cb ? put_cb(c,p) : ssl_put_cipher_by_char(s,c,p);
1358 1359
		p+=j;
		}
1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375
	/* If p == q, no ciphers and caller indicates an error, otherwise
	 * add MCSV
	 */
	if (p != q)
		{
		static SSL_CIPHER msvc =
			{
			0, NULL, SSL3_CK_MCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0
			};
		j = put_cb ? put_cb(&msvc,p) : ssl_put_cipher_by_char(s,&msvc,p);
		p+=j;
#ifdef OPENSSL_RI_DEBUG
		fprintf(stderr, "MCSV sent by client\n");
#endif
		}

1376 1377 1378
	return(p-q);
	}

B
Ben Laurie 已提交
1379 1380
STACK_OF(SSL_CIPHER) *ssl_bytes_to_cipher_list(SSL *s,unsigned char *p,int num,
					       STACK_OF(SSL_CIPHER) **skp)
1381
	{
1382
	const SSL_CIPHER *c;
B
Ben Laurie 已提交
1383
	STACK_OF(SSL_CIPHER) *sk;
1384 1385
	int i,n;

1386 1387
	s->s3->send_connection_binding = 0;

1388 1389 1390 1391 1392 1393 1394
	n=ssl_put_cipher_by_char(s,NULL,NULL);
	if ((num%n) != 0)
		{
		SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST,SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST);
		return(NULL);
		}
	if ((skp == NULL) || (*skp == NULL))
1395
		sk=sk_SSL_CIPHER_new_null(); /* change perhaps later */
1396 1397 1398
	else
		{
		sk= *skp;
B
Ben Laurie 已提交
1399
		sk_SSL_CIPHER_zero(sk);
1400 1401 1402 1403
		}

	for (i=0; i<num; i+=n)
		{
1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416
		/* Check for MCSV */
		if ((n != 3 || !p[0]) &&
			(p[n-2] == ((SSL3_CK_MCSV >> 8) & 0xff)) &&
			(p[n-1] == (SSL3_CK_MCSV & 0xff)))
			{
			s->s3->send_connection_binding = 1;
			p += n;
#ifdef OPENSSL_RI_DEBUG
			fprintf(stderr, "MCSV received by server\n");
#endif
			continue;
			}

1417 1418 1419 1420
		c=ssl_get_cipher_by_char(s,p);
		p+=n;
		if (c != NULL)
			{
B
Ben Laurie 已提交
1421
			if (!sk_SSL_CIPHER_push(sk,c))
1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433
				{
				SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST,ERR_R_MALLOC_FAILURE);
				goto err;
				}
			}
		}

	if (skp != NULL)
		*skp=sk;
	return(sk);
err:
	if ((skp == NULL) || (*skp == NULL))
B
Ben Laurie 已提交
1434
		sk_SSL_CIPHER_free(sk);
1435 1436 1437
	return(NULL);
	}

1438

D
Typo.  
Dr. Stephen Henson 已提交
1439
#ifndef OPENSSL_NO_TLSEXT
1440
/** return a servername extension value if provided in Client Hello, or NULL.
1441
 * So far, only host_name types are defined (RFC 3546).
1442 1443
 */

1444 1445 1446
const char *SSL_get_servername(const SSL *s, const int type)
	{
	if (type != TLSEXT_NAMETYPE_host_name)
1447
		return NULL;
B
Bodo Möller 已提交
1448 1449

	return s->session && !s->tlsext_hostname ?
1450 1451 1452
		s->session->tlsext_hostname :
		s->tlsext_hostname;
	}
1453

1454 1455
int SSL_get_servername_type(const SSL *s)
	{
1456
	if (s->session && (!s->tlsext_hostname ? s->session->tlsext_hostname : s->tlsext_hostname))
1457
		return TLSEXT_NAMETYPE_host_name;
1458
	return -1;
1459
	}
1460
#endif
1461

B
Ben Laurie 已提交
1462
static unsigned long ssl_session_hash(const SSL_SESSION *a)
1463 1464 1465
	{
	unsigned long l;

1466 1467 1468 1469 1470
	l=(unsigned long)
		((unsigned int) a->session_id[0]     )|
		((unsigned int) a->session_id[1]<< 8L)|
		((unsigned long)a->session_id[2]<<16L)|
		((unsigned long)a->session_id[3]<<24L);
1471 1472 1473
	return(l);
	}

1474 1475 1476 1477 1478
/* NB: If this function (or indeed the hash function which uses a sort of
 * coarser function than this one) is changed, ensure
 * SSL_CTX_has_matching_session_id() is checked accordingly. It relies on being
 * able to construct an SSL_SESSION that will collide with any existing session
 * with a matching session ID. */
B
Ben Laurie 已提交
1479
static int ssl_session_cmp(const SSL_SESSION *a,const SSL_SESSION *b)
1480
	{
1481 1482 1483 1484 1485
	if (a->ssl_version != b->ssl_version)
		return(1);
	if (a->session_id_length != b->session_id_length)
		return(1);
	return(memcmp(a->session_id,b->session_id,a->session_id_length));
1486 1487
	}

1488 1489 1490 1491
/* These wrapper functions should remain rather than redeclaring
 * SSL_SESSION_hash and SSL_SESSION_cmp for void* types and casting each
 * variable. The reason is that the functions aren't static, they're exposed via
 * ssl.h. */
B
Ben Laurie 已提交
1492 1493
static IMPLEMENT_LHASH_HASH_FN(ssl_session, SSL_SESSION)
static IMPLEMENT_LHASH_COMP_FN(ssl_session, SSL_SESSION)
1494

1495
SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth)
1496
	{
1497
	SSL_CTX *ret=NULL;
B
Ben Laurie 已提交
1498

1499 1500 1501 1502 1503
	if (meth == NULL)
		{
		SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_NULL_SSL_METHOD_PASSED);
		return(NULL);
		}
1504 1505 1506 1507 1508 1509

	if (SSL_get_ex_data_X509_STORE_CTX_idx() < 0)
		{
		SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_X509_VERIFICATION_SETUP_PROBLEMS);
		goto err;
		}
1510
	ret=(SSL_CTX *)OPENSSL_malloc(sizeof(SSL_CTX));
1511 1512 1513 1514 1515 1516 1517 1518 1519
	if (ret == NULL)
		goto err;

	memset(ret,0,sizeof(SSL_CTX));

	ret->method=meth;

	ret->cert_store=NULL;
	ret->session_cache_mode=SSL_SESS_CACHE_SERVER;
1520 1521 1522
	ret->session_cache_size=SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;
	ret->session_cache_head=NULL;
	ret->session_cache_tail=NULL;
1523 1524 1525 1526

	/* We take the system default */
	ret->session_timeout=meth->get_timeout();

1527 1528 1529 1530
	ret->new_session_cb=0;
	ret->remove_session_cb=0;
	ret->get_session_cb=0;
	ret->generate_session_id=0;
1531

1532
	memset((char *)&ret->stats,0,sizeof(ret->stats));
1533 1534 1535 1536 1537 1538 1539 1540 1541 1542

	ret->references=1;
	ret->quiet_shutdown=0;

/*	ret->cipher=NULL;*/
/*	ret->s2->challenge=NULL;
	ret->master_key=NULL;
	ret->key_arg=NULL;
	ret->s2->conn_id=NULL; */

B
Ben Laurie 已提交
1543
	ret->info_callback=NULL;
1544

1545
	ret->app_verify_callback=0;
1546 1547
	ret->app_verify_arg=NULL;

1548
	ret->max_cert_list=SSL_MAX_CERT_LIST_DEFAULT;
1549
	ret->read_ahead=0;
1550 1551
	ret->msg_callback=0;
	ret->msg_callback_arg=NULL;
1552
	ret->verify_mode=SSL_VERIFY_NONE;
1553
#if 0
1554
	ret->verify_depth=-1; /* Don't impose a limit (but x509_lu.c does) */
1555
#endif
1556
	ret->sid_ctx_length=0;
1557
	ret->default_verify_callback=NULL;
1558
	if ((ret->cert=ssl_cert_new()) == NULL)
1559 1560
		goto err;

1561
	ret->default_passwd_callback=0;
1562
	ret->default_passwd_callback_userdata=NULL;
1563
	ret->client_cert_cb=0;
1564 1565
	ret->app_gen_cookie_cb=0;
	ret->app_verify_cookie_cb=0;
1566

B
Ben Laurie 已提交
1567
	ret->sessions=lh_SSL_SESSION_new();
1568 1569 1570 1571 1572 1573
	if (ret->sessions == NULL) goto err;
	ret->cert_store=X509_STORE_new();
	if (ret->cert_store == NULL) goto err;

	ssl_create_cipher_list(ret->method,
		&ret->cipher_list,&ret->cipher_list_by_id,
1574
		meth->version == SSL2_VERSION ? "SSLv2" : SSL_DEFAULT_CIPHER_LIST);
B
Ben Laurie 已提交
1575 1576
	if (ret->cipher_list == NULL
	    || sk_SSL_CIPHER_num(ret->cipher_list) <= 0)
1577 1578 1579 1580 1581
		{
		SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_LIBRARY_HAS_NO_CIPHERS);
		goto err2;
		}

1582 1583 1584 1585
	ret->param = X509_VERIFY_PARAM_new();
	if (!ret->param)
		goto err;

1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601
	if ((ret->rsa_md5=EVP_get_digestbyname("ssl2-md5")) == NULL)
		{
		SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_UNABLE_TO_LOAD_SSL2_MD5_ROUTINES);
		goto err2;
		}
	if ((ret->md5=EVP_get_digestbyname("ssl3-md5")) == NULL)
		{
		SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES);
		goto err2;
		}
	if ((ret->sha1=EVP_get_digestbyname("ssl3-sha1")) == NULL)
		{
		SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES);
		goto err2;
		}

B
Ben Laurie 已提交
1602
	if ((ret->client_CA=sk_X509_NAME_new_null()) == NULL)
1603 1604
		goto err;

1605
	CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ret, &ret->ex_data);
1606

1607
	ret->extra_certs=NULL;
1608
	ret->comp_methods=SSL_COMP_get_compression_methods();
1609

1610 1611
	ret->max_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH;

1612
#ifndef OPENSSL_NO_TLSEXT
1613
	ret->tlsext_servername_callback = 0;
1614
	ret->tlsext_servername_arg = NULL;
1615 1616 1617 1618 1619 1620
	/* Setup RFC4507 ticket keys */
	if ((RAND_pseudo_bytes(ret->tlsext_tick_key_name, 16) <= 0)
		|| (RAND_bytes(ret->tlsext_tick_hmac_key, 16) <= 0)
		|| (RAND_bytes(ret->tlsext_tick_aes_key, 16) <= 0))
		ret->options |= SSL_OP_NO_TICKET;

1621 1622 1623
	ret->tlsext_status_cb = 0;
	ret->tlsext_status_arg = NULL;

1624 1625 1626 1627 1628
#endif
#ifndef OPENSSL_NO_PSK
	ret->psk_identity_hint=NULL;
	ret->psk_client_callback=NULL;
	ret->psk_server_callback=NULL;
B
Ben Laurie 已提交
1629
#endif
1630
#ifndef OPENSSL_NO_BUF_FREELISTS
B
Ben Laurie 已提交
1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646
	ret->freelist_max_len = SSL_MAX_BUF_FREELIST_LEN_DEFAULT;
	ret->rbuf_freelist = OPENSSL_malloc(sizeof(SSL3_BUF_FREELIST));
	if (!ret->rbuf_freelist)
		goto err;
	ret->rbuf_freelist->chunklen = 0;
	ret->rbuf_freelist->len = 0;
	ret->rbuf_freelist->head = NULL;
	ret->wbuf_freelist = OPENSSL_malloc(sizeof(SSL3_BUF_FREELIST));
	if (!ret->wbuf_freelist)
		{
		OPENSSL_free(ret->rbuf_freelist);
		goto err;
		}
	ret->wbuf_freelist->chunklen = 0;
	ret->wbuf_freelist->len = 0;
	ret->wbuf_freelist->head = NULL;
1647
#endif
1648 1649 1650 1651 1652 1653 1654 1655 1656
#ifndef OPENSSL_NO_ENGINE
	ret->client_cert_engine = NULL;
#ifdef OPENSSL_SSL_CLIENT_ENGINE_AUTO
#define eng_strx(x)	#x
#define eng_str(x)	eng_strx(x)
	/* Use specific client engine automatically... ignore errors */
	{
	ENGINE *eng;
	eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));
D
Dr. Stephen Henson 已提交
1657 1658 1659 1660 1661 1662
	if (!eng)
		{
		ERR_clear_error();
		ENGINE_load_builtin_engines();
		eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));
		}
1663 1664 1665 1666 1667 1668
	if (!eng || !SSL_CTX_set_client_cert_engine(ret, eng))
		ERR_clear_error();
	}
#endif
#endif

1669 1670 1671 1672 1673 1674 1675 1676
	return(ret);
err:
	SSLerr(SSL_F_SSL_CTX_NEW,ERR_R_MALLOC_FAILURE);
err2:
	if (ret != NULL) SSL_CTX_free(ret);
	return(NULL);
	}

U
Ulf Möller 已提交
1677
#if 0
B
Ben Laurie 已提交
1678
static void SSL_COMP_free(SSL_COMP *comp)
1679
    { OPENSSL_free(comp); }
U
Ulf Möller 已提交
1680
#endif
B
Ben Laurie 已提交
1681

1682
#ifndef OPENSSL_NO_BUF_FREELISTS
B
Ben Laurie 已提交
1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695
static void
ssl_buf_freelist_free(SSL3_BUF_FREELIST *list)
	{
	SSL3_BUF_FREELIST_ENTRY *ent, *next;
	for (ent = list->head; ent; ent = next)
		{
		next = ent->next;
		OPENSSL_free(ent);
		}
	OPENSSL_free(list);
	}
#endif

1696
void SSL_CTX_free(SSL_CTX *a)
1697 1698 1699 1700 1701 1702
	{
	int i;

	if (a == NULL) return;

	i=CRYPTO_add(&a->references,-1,CRYPTO_LOCK_SSL_CTX);
1703 1704 1705
#ifdef REF_PRINT
	REF_PRINT("SSL_CTX",a);
#endif
1706 1707 1708 1709 1710 1711 1712 1713 1714
	if (i > 0) return;
#ifdef REF_CHECK
	if (i < 0)
		{
		fprintf(stderr,"SSL_CTX_free, bad reference count\n");
		abort(); /* ok */
		}
#endif

1715 1716 1717
	if (a->param)
		X509_VERIFY_PARAM_free(a->param);

1718 1719 1720 1721 1722 1723 1724 1725 1726
	/*
	 * Free internal session cache. However: the remove_cb() may reference
	 * the ex_data of SSL_CTX, thus the ex_data store can only be removed
	 * after the sessions were flushed.
	 * As the ex_data handling routines might also touch the session cache,
	 * the most secure solution seems to be: empty (flush) the cache, then
	 * free ex_data, then finally free the cache.
	 * (See ticket [openssl.org #212].)
	 */
1727 1728
	if (a->sessions != NULL)
		SSL_CTX_flush_sessions(a,0);
1729 1730 1731 1732

	CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL_CTX, a, &a->ex_data);

	if (a->sessions != NULL)
B
Ben Laurie 已提交
1733
		lh_SSL_SESSION_free(a->sessions);
1734

1735 1736 1737
	if (a->cert_store != NULL)
		X509_STORE_free(a->cert_store);
	if (a->cipher_list != NULL)
B
Ben Laurie 已提交
1738
		sk_SSL_CIPHER_free(a->cipher_list);
1739
	if (a->cipher_list_by_id != NULL)
B
Ben Laurie 已提交
1740
		sk_SSL_CIPHER_free(a->cipher_list_by_id);
1741 1742
	if (a->cert != NULL)
		ssl_cert_free(a->cert);
1743
	if (a->client_CA != NULL)
B
Ben Laurie 已提交
1744
		sk_X509_NAME_pop_free(a->client_CA,X509_NAME_free);
1745
	if (a->extra_certs != NULL)
B
Ben Laurie 已提交
1746
		sk_X509_pop_free(a->extra_certs,X509_free);
1747
#if 0 /* This should never be done, since it removes a global database */
1748
	if (a->comp_methods != NULL)
B
Ben Laurie 已提交
1749
		sk_SSL_COMP_pop_free(a->comp_methods,SSL_COMP_free);
1750 1751 1752
#else
	a->comp_methods = NULL;
#endif
1753 1754 1755 1756

#ifndef OPENSSL_NO_PSK
	if (a->psk_identity_hint)
		OPENSSL_free(a->psk_identity_hint);
1757 1758 1759 1760
#endif
#ifndef OPENSSL_NO_ENGINE
	if (a->client_cert_engine)
		ENGINE_finish(a->client_cert_engine);
1761
#endif
B
Ben Laurie 已提交
1762

1763
#ifndef OPENSSL_NO_BUF_FREELISTS
B
Ben Laurie 已提交
1764 1765 1766 1767 1768 1769
	if (a->wbuf_freelist)
		ssl_buf_freelist_free(a->wbuf_freelist);
	if (a->rbuf_freelist)
		ssl_buf_freelist_free(a->rbuf_freelist);
#endif

1770
	OPENSSL_free(a);
1771 1772
	}

1773
void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb)
1774 1775 1776 1777
	{
	ctx->default_passwd_callback=cb;
	}

1778 1779 1780 1781 1782
void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx,void *u)
	{
	ctx->default_passwd_callback_userdata=u;
	}

1783
void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx, int (*cb)(X509_STORE_CTX *,void *), void *arg)
1784 1785
	{
	ctx->app_verify_callback=cb;
1786
	ctx->app_verify_arg=arg;
1787 1788
	}

1789
void SSL_CTX_set_verify(SSL_CTX *ctx,int mode,int (*cb)(int, X509_STORE_CTX *))
1790
	{
1791
	ctx->verify_mode=mode;
1792 1793 1794
	ctx->default_verify_callback=cb;
	}

1795 1796
void SSL_CTX_set_verify_depth(SSL_CTX *ctx,int depth)
	{
1797
	X509_VERIFY_PARAM_set_depth(ctx->param, depth);
1798 1799
	}

1800
void ssl_set_cert_masks(CERT *c, const SSL_CIPHER *cipher)
1801 1802 1803 1804
	{
	CERT_PKEY *cpk;
	int rsa_enc,rsa_tmp,rsa_sign,dh_tmp,dh_rsa,dh_dsa,dsa_sign;
	int rsa_enc_export,dh_rsa_export,dh_dsa_export;
1805
	int rsa_tmp_export,dh_tmp_export,kl;
1806
	unsigned long mask_k,mask_a,emask_k,emask_a;
N
make  
Nils Larsch 已提交
1807 1808 1809 1810
	int have_ecc_cert, ecdh_ok, ecdsa_ok, ecc_pkey_size;
#ifndef OPENSSL_NO_ECDH
	int have_ecdh_tmp;
#endif
B
Bodo Möller 已提交
1811 1812 1813
	X509 *x = NULL;
	EVP_PKEY *ecc_pkey = NULL;
	int signature_nid = 0;
1814

B
Ben Laurie 已提交
1815
	if (c == NULL) return;
1816

1817 1818
	kl=SSL_C_EXPORT_PKEYLENGTH(cipher);

1819
#ifndef OPENSSL_NO_RSA
1820 1821
	rsa_tmp=(c->rsa_tmp != NULL || c->rsa_tmp_cb != NULL);
	rsa_tmp_export=(c->rsa_tmp_cb != NULL ||
1822
		(rsa_tmp && RSA_size(c->rsa_tmp)*8 <= kl));
1823 1824 1825
#else
	rsa_tmp=rsa_tmp_export=0;
#endif
1826
#ifndef OPENSSL_NO_DH
1827 1828
	dh_tmp=(c->dh_tmp != NULL || c->dh_tmp_cb != NULL);
	dh_tmp_export=(c->dh_tmp_cb != NULL ||
1829
		(dh_tmp && DH_size(c->dh_tmp)*8 <= kl));
1830 1831 1832 1833
#else
	dh_tmp=dh_tmp_export=0;
#endif

B
Bodo Möller 已提交
1834 1835 1836
#ifndef OPENSSL_NO_ECDH
	have_ecdh_tmp=(c->ecdh_tmp != NULL || c->ecdh_tmp_cb != NULL);
#endif
1837
	cpk= &(c->pkeys[SSL_PKEY_RSA_ENC]);
1838 1839
	rsa_enc= (cpk->x509 != NULL && cpk->privatekey != NULL);
	rsa_enc_export=(rsa_enc && EVP_PKEY_size(cpk->privatekey)*8 <= kl);
1840
	cpk= &(c->pkeys[SSL_PKEY_RSA_SIGN]);
1841
	rsa_sign=(cpk->x509 != NULL && cpk->privatekey != NULL);
1842
	cpk= &(c->pkeys[SSL_PKEY_DSA_SIGN]);
1843
	dsa_sign=(cpk->x509 != NULL && cpk->privatekey != NULL);
1844
	cpk= &(c->pkeys[SSL_PKEY_DH_RSA]);
1845 1846
	dh_rsa=  (cpk->x509 != NULL && cpk->privatekey != NULL);
	dh_rsa_export=(dh_rsa && EVP_PKEY_size(cpk->privatekey)*8 <= kl);
1847 1848
	cpk= &(c->pkeys[SSL_PKEY_DH_DSA]);
/* FIX THIS EAY EAY EAY */
1849 1850
	dh_dsa=  (cpk->x509 != NULL && cpk->privatekey != NULL);
	dh_dsa_export=(dh_dsa && EVP_PKEY_size(cpk->privatekey)*8 <= kl);
B
Bodo Möller 已提交
1851 1852
	cpk= &(c->pkeys[SSL_PKEY_ECC]);
	have_ecc_cert= (cpk->x509 != NULL && cpk->privatekey != NULL);
1853 1854 1855 1856
	mask_k=0;
	mask_a=0;
	emask_k=0;
	emask_a=0;
1857

1858 1859
	

1860
#ifdef CIPHER_DEBUG
1861
	printf("rt=%d rte=%d dht=%d ecdht=%d re=%d ree=%d rs=%d ds=%d dhr=%d dhd=%d\n",
1862
	        rsa_tmp,rsa_tmp_export,dh_tmp,have_ecdh_tmp,
B
Ben Laurie 已提交
1863
		rsa_enc,rsa_enc_export,rsa_sign,dsa_sign,dh_rsa,dh_dsa);
1864
#endif
1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875
	
	cpk = &(c->pkeys[SSL_PKEY_GOST01]);
	if (cpk->x509 != NULL && cpk->privatekey !=NULL) {
		mask_k |= SSL_kGOST;
		mask_a |= SSL_aGOST01;
	}
	cpk = &(c->pkeys[SSL_PKEY_GOST94]);
	if (cpk->x509 != NULL && cpk->privatekey !=NULL) {
		mask_k |= SSL_kGOST;
		mask_a |= SSL_aGOST94;
	}
1876 1877

	if (rsa_enc || (rsa_tmp && rsa_sign))
1878
		mask_k|=SSL_kRSA;
B
Ben Laurie 已提交
1879
	if (rsa_enc_export || (rsa_tmp_export && (rsa_sign || rsa_enc)))
1880
		emask_k|=SSL_kRSA;
1881 1882 1883

#if 0
	/* The match needs to be both kEDH and aRSA or aDSA, so don't worry */
1884
	if (	(dh_tmp || dh_rsa || dh_dsa) &&
1885
		(rsa_enc || rsa_sign || dsa_sign))
1886
		mask_k|=SSL_kEDH;
1887 1888
	if ((dh_tmp_export || dh_rsa_export || dh_dsa_export) &&
		(rsa_enc || rsa_sign || dsa_sign))
1889
		emask_k|=SSL_kEDH;
1890 1891
#endif

1892 1893
	if (dh_tmp_export)
		emask_k|=SSL_kEDH;
1894 1895

	if (dh_tmp)
1896
		mask_k|=SSL_kEDH;
1897

1898 1899
	if (dh_rsa) mask_k|=SSL_kDHr;
	if (dh_rsa_export) emask_k|=SSL_kDHr;
1900

1901 1902
	if (dh_dsa) mask_k|=SSL_kDHd;
	if (dh_dsa_export) emask_k|=SSL_kDHd;
1903 1904 1905

	if (rsa_enc || rsa_sign)
		{
1906 1907
		mask_a|=SSL_aRSA;
		emask_a|=SSL_aRSA;
1908 1909 1910 1911
		}

	if (dsa_sign)
		{
1912 1913
		mask_a|=SSL_aDSS;
		emask_a|=SSL_aDSS;
1914 1915
		}

1916 1917
	mask_a|=SSL_aNULL;
	emask_a|=SSL_aNULL;
1918

1919
#ifndef OPENSSL_NO_KRB5
1920 1921 1922 1923
	mask_k|=SSL_kKRB5;
	mask_a|=SSL_aKRB5;
	emask_k|=SSL_kKRB5;
	emask_a|=SSL_aKRB5;
1924 1925
#endif

B
Bodo Möller 已提交
1926 1927 1928 1929 1930
	/* An ECC certificate may be usable for ECDH and/or
	 * ECDSA cipher suites depending on the key usage extension.
	 */
	if (have_ecc_cert)
		{
1931
		/* This call populates extension flags (ex_flags) */
B
Bodo Möller 已提交
1932 1933 1934 1935 1936 1937 1938
		x = (c->pkeys[SSL_PKEY_ECC]).x509;
		X509_check_purpose(x, -1, 0);
		ecdh_ok = (x->ex_flags & EXFLAG_KUSAGE) ?
		    (x->ex_kusage & X509v3_KU_KEY_AGREEMENT) : 1;
		ecdsa_ok = (x->ex_flags & EXFLAG_KUSAGE) ?
		    (x->ex_kusage & X509v3_KU_DIGITAL_SIGNATURE) : 1;
		ecc_pkey = X509_get_pubkey(x);
1939
		ecc_pkey_size = (ecc_pkey != NULL) ?
B
Bodo Möller 已提交
1940 1941 1942 1943 1944 1945 1946
		    EVP_PKEY_bits(ecc_pkey) : 0;
		EVP_PKEY_free(ecc_pkey);
		if ((x->sig_alg) && (x->sig_alg->algorithm))
			signature_nid = OBJ_obj2nid(x->sig_alg->algorithm);
#ifndef OPENSSL_NO_ECDH
		if (ecdh_ok)
			{
1947 1948 1949 1950 1951 1952 1953 1954
			const char *sig = OBJ_nid2ln(signature_nid);
			if (sig == NULL)
				{
				ERR_clear_error();
				sig = "unknown";
				}
				
			if (strstr(sig, "WithRSA"))
B
Bodo Möller 已提交
1955
				{
1956 1957
				mask_k|=SSL_kECDHr;
				mask_a|=SSL_aECDH;
B
Bodo Möller 已提交
1958
				if (ecc_pkey_size <= 163)
1959 1960 1961 1962
					{
					emask_k|=SSL_kECDHr;
					emask_a|=SSL_aECDH;
					}
B
Bodo Möller 已提交
1963
				}
1964

B
Bodo Möller 已提交
1965 1966
			if (signature_nid == NID_ecdsa_with_SHA1)
				{
1967 1968
				mask_k|=SSL_kECDHe;
				mask_a|=SSL_aECDH;
B
Bodo Möller 已提交
1969
				if (ecc_pkey_size <= 163)
1970 1971 1972 1973
					{
					emask_k|=SSL_kECDHe;
					emask_a|=SSL_aECDH;
					}
B
Bodo Möller 已提交
1974 1975 1976 1977 1978 1979
				}
			}
#endif
#ifndef OPENSSL_NO_ECDSA
		if (ecdsa_ok)
			{
1980 1981
			mask_a|=SSL_aECDSA;
			emask_a|=SSL_aECDSA;
B
Bodo Möller 已提交
1982 1983 1984 1985 1986 1987 1988
			}
#endif
		}

#ifndef OPENSSL_NO_ECDH
	if (have_ecdh_tmp)
		{
1989 1990
		mask_k|=SSL_kEECDH;
		emask_k|=SSL_kEECDH;
B
Bodo Möller 已提交
1991 1992
		}
#endif
1993 1994

#ifndef OPENSSL_NO_PSK
1995 1996 1997 1998
	mask_k |= SSL_kPSK;
	mask_a |= SSL_aPSK;
	emask_k |= SSL_kPSK;
	emask_a |= SSL_aPSK;
1999 2000
#endif

2001 2002 2003 2004
	c->mask_k=mask_k;
	c->mask_a=mask_a;
	c->export_mask_k=emask_k;
	c->export_mask_a=emask_a;
2005 2006 2007
	c->valid=1;
	}

B
Bodo Möller 已提交
2008 2009 2010 2011
/* This handy macro borrowed from crypto/x509v3/v3_purp.c */
#define ku_reject(x, usage) \
	(((x)->ex_flags & EXFLAG_KUSAGE) && !((x)->ex_kusage & (usage)))

2012 2013
#ifndef OPENSSL_NO_EC

2014
int ssl_check_srvr_ecc_cert_and_alg(X509 *x, const SSL_CIPHER *cs)
B
Bodo Möller 已提交
2015
	{
2016
	unsigned long alg_k, alg_a;
B
Bodo Möller 已提交
2017 2018 2019 2020
	EVP_PKEY *pkey = NULL;
	int keysize = 0;
	int signature_nid = 0;

2021 2022 2023
	alg_k = cs->algorithm_mkey;
	alg_a = cs->algorithm_auth;

B
Bodo Möller 已提交
2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037
	if (SSL_C_IS_EXPORT(cs))
		{
		/* ECDH key length in export ciphers must be <= 163 bits */
		pkey = X509_get_pubkey(x);
		if (pkey == NULL) return 0;
		keysize = EVP_PKEY_bits(pkey);
		EVP_PKEY_free(pkey);
		if (keysize > 163) return 0;
		}

	/* This call populates the ex_flags field correctly */
	X509_check_purpose(x, -1, 0);
	if ((x->sig_alg) && (x->sig_alg->algorithm))
		signature_nid = OBJ_obj2nid(x->sig_alg->algorithm);
2038
	if (alg_k & SSL_kECDHe || alg_k & SSL_kECDHr)
B
Bodo Möller 已提交
2039 2040 2041 2042
		{
		/* key usage, if present, must allow key agreement */
		if (ku_reject(x, X509v3_KU_KEY_AGREEMENT))
			{
2043
			SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG, SSL_R_ECC_CERT_NOT_FOR_KEY_AGREEMENT);
B
Bodo Möller 已提交
2044 2045
			return 0;
			}
2046
		if (alg_k & SSL_kECDHe)
B
Bodo Möller 已提交
2047 2048 2049 2050
			{
			/* signature alg must be ECDSA */
			if (signature_nid != NID_ecdsa_with_SHA1)
				{
2051
				SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG, SSL_R_ECC_CERT_SHOULD_HAVE_SHA1_SIGNATURE);
B
Bodo Möller 已提交
2052 2053 2054
				return 0;
				}
			}
2055
		if (alg_k & SSL_kECDHr)
B
Bodo Möller 已提交
2056 2057
			{
			/* signature alg must be RSA */
2058 2059 2060

			const char *sig = OBJ_nid2ln(signature_nid);
			if (sig == NULL)
B
Bodo Möller 已提交
2061
				{
2062 2063
				ERR_clear_error();
				sig = "unknown";
B
Bodo Möller 已提交
2064
				}
2065
			if (strstr(sig, "WithRSA") == NULL)
2066 2067
				{
				SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG, SSL_R_ECC_CERT_SHOULD_HAVE_RSA_SIGNATURE);
2068
				return 0;
2069
				}
B
Bodo Möller 已提交
2070
			}
2071 2072
		}
	if (alg_a & SSL_aECDSA)
B
Bodo Möller 已提交
2073 2074 2075 2076
		{
		/* key usage, if present, must allow signing */
		if (ku_reject(x, X509v3_KU_DIGITAL_SIGNATURE))
			{
2077
			SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG, SSL_R_ECC_CERT_NOT_FOR_SIGNING);
B
Bodo Möller 已提交
2078 2079 2080 2081 2082 2083 2084
			return 0;
			}
		}

	return 1;  /* all checks are ok */
	}

2085 2086
#endif

2087
/* THIS NEEDS CLEANING UP */
2088
X509 *ssl_get_server_send_cert(SSL *s)
2089
	{
2090
	unsigned long alg_k,alg_a,mask_k,mask_a;
2091
	CERT *c;
U
Ulf Möller 已提交
2092
	int i,is_export;
2093 2094

	c=s->cert;
2095
	ssl_set_cert_masks(c, s->s3->tmp.new_cipher);
2096
	is_export=SSL_C_IS_EXPORT(s->s3->tmp.new_cipher);
2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109
	if (is_export)
		{
		mask_k = c->export_mask_k;
		mask_a = c->export_mask_a;
		}
	else
		{
		mask_k = c->mask_k;
		mask_a = c->mask_a;
		}
	
	alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
	alg_a = s->s3->tmp.new_cipher->algorithm_auth;
2110

2111
	if (alg_k & (SSL_kECDHr|SSL_kECDHe))
B
Bodo Möller 已提交
2112
		{
2113
		/* we don't need to look at SSL_kEECDH
B
Bodo Möller 已提交
2114 2115
		 * since no certificate is needed for
		 * anon ECDH and for authenticated
2116
		 * EECDH, the check for the auth
B
Bodo Möller 已提交
2117 2118
		 * algorithm will set i correctly
		 * NOTE: For ECDH-RSA, we need an ECC
2119
		 * not an RSA cert but for EECDH-RSA
B
Bodo Möller 已提交
2120 2121 2122 2123 2124 2125
		 * we need an RSA cert. Placing the
		 * checks for SSL_kECDH before RSA
		 * checks ensures the correct cert is chosen.
		 */
		i=SSL_PKEY_ECC;
		}
2126
	else if (alg_a & SSL_aECDSA)
B
Bodo Möller 已提交
2127 2128 2129
		{
		i=SSL_PKEY_ECC;
		}
2130
	else if (alg_k & SSL_kDHr)
2131
		i=SSL_PKEY_DH_RSA;
2132
	else if (alg_k & SSL_kDHd)
2133
		i=SSL_PKEY_DH_DSA;
2134
	else if (alg_a & SSL_aDSS)
2135
		i=SSL_PKEY_DSA_SIGN;
2136
	else if (alg_a & SSL_aRSA)
2137 2138 2139 2140 2141 2142
		{
		if (c->pkeys[SSL_PKEY_RSA_ENC].x509 == NULL)
			i=SSL_PKEY_RSA_SIGN;
		else
			i=SSL_PKEY_RSA_ENC;
		}
2143
	else if (alg_a & SSL_aKRB5)
2144 2145 2146 2147
		{
		/* VRS something else here? */
		return(NULL);
		}
2148 2149 2150 2151
	else if (alg_a & SSL_aGOST94) 
		i=SSL_PKEY_GOST94;
	else if (alg_a & SSL_aGOST01)
		i=SSL_PKEY_GOST01;
2152
	else /* if (alg_a & SSL_aNULL) */
2153
		{
B
Bodo Möller 已提交
2154
		SSLerr(SSL_F_SSL_GET_SERVER_SEND_CERT,ERR_R_INTERNAL_ERROR);
2155 2156 2157
		return(NULL);
		}
	if (c->pkeys[i].x509 == NULL) return(NULL);
B
Bodo Möller 已提交
2158

2159 2160 2161
	return(c->pkeys[i].x509);
	}

2162
EVP_PKEY *ssl_get_sign_pkey(SSL *s,const SSL_CIPHER *cipher)
2163
	{
2164
	unsigned long alg_a;
2165 2166
	CERT *c;

2167
	alg_a = cipher->algorithm_auth;
2168 2169
	c=s->cert;

2170
	if ((alg_a & SSL_aDSS) &&
2171 2172
		(c->pkeys[SSL_PKEY_DSA_SIGN].privatekey != NULL))
		return(c->pkeys[SSL_PKEY_DSA_SIGN].privatekey);
2173
	else if (alg_a & SSL_aRSA)
2174 2175 2176 2177 2178 2179 2180 2181
		{
		if (c->pkeys[SSL_PKEY_RSA_SIGN].privatekey != NULL)
			return(c->pkeys[SSL_PKEY_RSA_SIGN].privatekey);
		else if (c->pkeys[SSL_PKEY_RSA_ENC].privatekey != NULL)
			return(c->pkeys[SSL_PKEY_RSA_ENC].privatekey);
		else
			return(NULL);
		}
2182
	else if ((alg_a & SSL_aECDSA) &&
B
Bodo Möller 已提交
2183 2184
	         (c->pkeys[SSL_PKEY_ECC].privatekey != NULL))
		return(c->pkeys[SSL_PKEY_ECC].privatekey);
2185
	else /* if (alg_a & SSL_aNULL) */
2186
		{
B
Bodo Möller 已提交
2187
		SSLerr(SSL_F_SSL_GET_SIGN_PKEY,ERR_R_INTERNAL_ERROR);
2188 2189 2190 2191
		return(NULL);
		}
	}

2192
void ssl_update_cache(SSL *s,int mode)
2193
	{
2194 2195 2196 2197 2198 2199
	int i;

	/* If the session_id_length is 0, we are not supposed to cache it,
	 * and it would be rather hard to do anyway :-) */
	if (s->session->session_id_length == 0) return;

B
Bodo Möller 已提交
2200
	i=s->session_ctx->session_cache_mode;
L
Lutz Jänicke 已提交
2201
	if ((i & mode) && (!s->hit)
2202
		&& ((i & SSL_SESS_CACHE_NO_INTERNAL_STORE)
B
Bodo Möller 已提交
2203 2204
		    || SSL_CTX_add_session(s->session_ctx,s->session))
		&& (s->session_ctx->new_session_cb != NULL))
2205
		{
2206
		CRYPTO_add(&s->session->references,1,CRYPTO_LOCK_SSL_SESSION);
B
Bodo Möller 已提交
2207
		if (!s->session_ctx->new_session_cb(s,s->session))
2208 2209 2210 2211
			SSL_SESSION_free(s->session);
		}

	/* auto flush every 255 connections */
2212 2213 2214 2215
	if ((!(i & SSL_SESS_CACHE_NO_AUTO_CLEAR)) &&
		((i & mode) == mode))
		{
		if (  (((mode & SSL_SESS_CACHE_CLIENT)
B
Bodo Möller 已提交
2216 2217
			?s->session_ctx->stats.sess_connect_good
			:s->session_ctx->stats.sess_accept_good) & 0xff) == 0xff)
2218
			{
B
Bodo Möller 已提交
2219
			SSL_CTX_flush_sessions(s->session_ctx,(unsigned long)time(NULL));
2220 2221
			}
		}
2222 2223
	}

2224
const SSL_METHOD *SSL_get_ssl_method(SSL *s)
2225 2226 2227 2228
	{
	return(s->method);
	}

2229
int SSL_set_ssl_method(SSL *s, const SSL_METHOD *meth)
2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255
	{
	int conn= -1;
	int ret=1;

	if (s->method != meth)
		{
		if (s->handshake_func != NULL)
			conn=(s->handshake_func == s->method->ssl_connect);

		if (s->method->version == meth->version)
			s->method=meth;
		else
			{
			s->method->ssl_free(s);
			s->method=meth;
			ret=s->method->ssl_new(s);
			}

		if (conn == 1)
			s->handshake_func=meth->ssl_connect;
		else if (conn == 0)
			s->handshake_func=meth->ssl_accept;
		}
	return(ret);
	}

B
Ben Laurie 已提交
2256
int SSL_get_error(const SSL *s,int i)
2257 2258
	{
	int reason;
2259
	unsigned long l;
2260 2261 2262 2263
	BIO *bio;

	if (i > 0) return(SSL_ERROR_NONE);

2264 2265 2266 2267 2268 2269 2270 2271 2272
	/* Make things return SSL_ERROR_SYSCALL when doing SSL_do_handshake
	 * etc, where we do encode the error */
	if ((l=ERR_peek_error()) != 0)
		{
		if (ERR_GET_LIB(l) == ERR_LIB_SYS)
			return(SSL_ERROR_SYSCALL);
		else
			return(SSL_ERROR_SSL);
		}
2273 2274 2275 2276 2277 2278 2279

	if ((i < 0) && SSL_want_read(s))
		{
		bio=SSL_get_rbio(s);
		if (BIO_should_read(bio))
			return(SSL_ERROR_WANT_READ);
		else if (BIO_should_write(bio))
B
Bodo Möller 已提交
2280 2281 2282 2283 2284 2285 2286 2287 2288
			/* This one doesn't make too much sense ... We never try
			 * to write to the rbio, and an application program where
			 * rbio and wbio are separate couldn't even know what it
			 * should wait for.
			 * However if we ever set s->rwstate incorrectly
			 * (so that we have SSL_want_read(s) instead of
			 * SSL_want_write(s)) and rbio and wbio *are* the same,
			 * this test works around that bug; so it might be safer
			 * to keep it. */
2289 2290 2291 2292 2293 2294
			return(SSL_ERROR_WANT_WRITE);
		else if (BIO_should_io_special(bio))
			{
			reason=BIO_get_retry_reason(bio);
			if (reason == BIO_RR_CONNECT)
				return(SSL_ERROR_WANT_CONNECT);
2295 2296
			else if (reason == BIO_RR_ACCEPT)
				return(SSL_ERROR_WANT_ACCEPT);
2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307
			else
				return(SSL_ERROR_SYSCALL); /* unknown */
			}
		}

	if ((i < 0) && SSL_want_write(s))
		{
		bio=SSL_get_wbio(s);
		if (BIO_should_write(bio))
			return(SSL_ERROR_WANT_WRITE);
		else if (BIO_should_read(bio))
B
Bodo Möller 已提交
2308
			/* See above (SSL_want_read(s) with BIO_should_write(bio)) */
2309 2310 2311 2312 2313 2314
			return(SSL_ERROR_WANT_READ);
		else if (BIO_should_io_special(bio))
			{
			reason=BIO_get_retry_reason(bio);
			if (reason == BIO_RR_CONNECT)
				return(SSL_ERROR_WANT_CONNECT);
2315 2316
			else if (reason == BIO_RR_ACCEPT)
				return(SSL_ERROR_WANT_ACCEPT);
2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327
			else
				return(SSL_ERROR_SYSCALL);
			}
		}
	if ((i < 0) && SSL_want_x509_lookup(s))
		{
		return(SSL_ERROR_WANT_X509_LOOKUP);
		}

	if (i == 0)
		{
2328
		if (s->version == SSL2_VERSION)
2329 2330 2331 2332 2333 2334 2335
			{
			/* assume it is the socket being closed */
			return(SSL_ERROR_ZERO_RETURN);
			}
		else
			{
			if ((s->shutdown & SSL_RECEIVED_SHUTDOWN) &&
2336
				(s->s3->warn_alert == SSL_AD_CLOSE_NOTIFY))
2337 2338 2339 2340 2341 2342
				return(SSL_ERROR_ZERO_RETURN);
			}
		}
	return(SSL_ERROR_SYSCALL);
	}

2343
int SSL_do_handshake(SSL *s)
2344
	{
2345 2346
	int ret=1;

2347 2348
	if (s->handshake_func == NULL)
		{
2349
		SSLerr(SSL_F_SSL_DO_HANDSHAKE,SSL_R_CONNECTION_TYPE_NOT_SET);
2350 2351
		return(-1);
		}
2352 2353 2354

	s->method->ssl_renegotiate_check(s);

2355
	if (SSL_in_init(s) || SSL_in_before(s))
2356 2357 2358 2359
		{
		ret=s->handshake_func(s);
		}
	return(ret);
2360 2361 2362 2363
	}

/* For the next 2 functions, SSL_clear() sets shutdown and so
 * one of these calls will reset it */
2364
void SSL_set_accept_state(SSL *s)
2365
	{
2366
	s->server=1;
2367 2368 2369 2370 2371
	s->shutdown=0;
	s->state=SSL_ST_ACCEPT|SSL_ST_BEFORE;
	s->handshake_func=s->method->ssl_accept;
	/* clear the current cipher */
	ssl_clear_cipher_ctx(s);
2372 2373
	ssl_clear_hash_ctx(&s->read_hash);
	ssl_clear_hash_ctx(&s->write_hash);
2374 2375
	}

2376
void SSL_set_connect_state(SSL *s)
2377
	{
2378
	s->server=0;
2379 2380 2381 2382 2383
	s->shutdown=0;
	s->state=SSL_ST_CONNECT|SSL_ST_BEFORE;
	s->handshake_func=s->method->ssl_connect;
	/* clear the current cipher */
	ssl_clear_cipher_ctx(s);
2384 2385
	ssl_clear_hash_ctx(&s->read_hash);
	ssl_clear_hash_ctx(&s->write_hash);
2386 2387
	}

2388
int ssl_undefined_function(SSL *s)
2389 2390 2391 2392 2393
	{
	SSLerr(SSL_F_SSL_UNDEFINED_FUNCTION,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	return(0);
	}

2394 2395 2396 2397 2398 2399
int ssl_undefined_void_function(void)
	{
	SSLerr(SSL_F_SSL_UNDEFINED_VOID_FUNCTION,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	return(0);
	}

B
Ben Laurie 已提交
2400 2401 2402 2403 2404 2405
int ssl_undefined_const_function(const SSL *s)
	{
	SSLerr(SSL_F_SSL_UNDEFINED_CONST_FUNCTION,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	return(0);
	}

2406
SSL_METHOD *ssl_bad_method(int ver)
2407 2408 2409 2410 2411
	{
	SSLerr(SSL_F_SSL_BAD_METHOD,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	return(NULL);
	}

B
Ben Laurie 已提交
2412
const char *SSL_get_version(const SSL *s)
2413
	{
2414 2415 2416 2417
	if (s->version == TLS1_1_VERSION)
		return("TLSv1.1");
	else if (s->version == SSL3_VERSION)
		return("SSLv3");
2418
	else if (s->version == SSL3_VERSION)
2419
		return("SSLv3");
2420
	else if (s->version == SSL2_VERSION)
2421 2422 2423 2424 2425
		return("SSLv2");
	else
		return("unknown");
	}

2426
SSL *SSL_dup(SSL *s)
2427
	{
B
Ben Laurie 已提交
2428
	STACK_OF(X509_NAME) *sk;
2429
	X509_NAME *xn;
2430
	SSL *ret;
2431
	int i;
2432
	
B
Ben Laurie 已提交
2433 2434
	if ((ret=SSL_new(SSL_get_SSL_CTX(s))) == NULL)
	    return(NULL);
2435 2436 2437 2438 2439

	ret->version = s->version;
	ret->type = s->type;
	ret->method = s->method;

2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451
	if (s->session != NULL)
		{
		/* This copies session-id, SSL_METHOD, sid_ctx, and 'cert' */
		SSL_copy_session_id(ret,s);
		}
	else
		{
		/* No session has been established yet, so we have to expect
		 * that s->cert or ret->cert will be changed later --
		 * they should not both point to the same object,
		 * and thus we can't use SSL_copy_session_id. */

R
Richard Levitte 已提交
2452
		ret->method->ssl_free(ret);
2453 2454 2455 2456 2457
		ret->method = s->method;
		ret->method->ssl_new(ret);

		if (s->cert != NULL)
			{
2458 2459 2460 2461
			if (ret->cert != NULL)
				{
				ssl_cert_free(ret->cert);
				}
2462 2463 2464 2465 2466 2467 2468 2469
			ret->cert = ssl_cert_dup(s->cert);
			if (ret->cert == NULL)
				goto err;
			}
				
		SSL_set_session_id_context(ret,
			s->sid_ctx, s->sid_ctx_length);
		}
2470

2471 2472
	ret->options=s->options;
	ret->mode=s->mode;
2473
	SSL_set_max_cert_list(ret,SSL_get_max_cert_list(s));
2474
	SSL_set_read_ahead(ret,SSL_get_read_ahead(s));
2475 2476
	ret->msg_callback = s->msg_callback;
	ret->msg_callback_arg = s->msg_callback_arg;
2477 2478
	SSL_set_verify(ret,SSL_get_verify_mode(s),
		SSL_get_verify_callback(s));
2479
	SSL_set_verify_depth(ret,SSL_get_verify_depth(s));
2480
	ret->generate_session_id = s->generate_session_id;
2481 2482 2483 2484 2485 2486

	SSL_set_info_callback(ret,SSL_get_info_callback(s));
	
	ret->debug=s->debug;

	/* copy app data, a little dangerous perhaps */
2487
	if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_SSL, &ret->ex_data, &s->ex_data))
2488
		goto err;
2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499

	/* setup rbio, and wbio */
	if (s->rbio != NULL)
		{
		if (!BIO_dup_state(s->rbio,(char *)&ret->rbio))
			goto err;
		}
	if (s->wbio != NULL)
		{
		if (s->wbio != s->rbio)
			{
2500
			if (!BIO_dup_state(s->wbio,(char *)&ret->wbio))
2501 2502 2503 2504 2505
				goto err;
			}
		else
			ret->wbio=ret->rbio;
		}
2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516
	ret->rwstate = s->rwstate;
	ret->in_handshake = s->in_handshake;
	ret->handshake_func = s->handshake_func;
	ret->server = s->server;
	ret->new_session = s->new_session;
	ret->quiet_shutdown = s->quiet_shutdown;
	ret->shutdown=s->shutdown;
	ret->state=s->state; /* SSL_dup does not really work at any state, though */
	ret->rstate=s->rstate;
	ret->init_num = 0; /* would have to copy ret->init_buf, ret->init_msg, ret->init_num, ret->init_off */
	ret->hit=s->hit;
2517 2518

	X509_VERIFY_PARAM_inherit(ret->param, s->param);
2519 2520 2521 2522

	/* dup the cipher_list and cipher_list_by_id stacks */
	if (s->cipher_list != NULL)
		{
B
Ben Laurie 已提交
2523
		if ((ret->cipher_list=sk_SSL_CIPHER_dup(s->cipher_list)) == NULL)
2524 2525 2526
			goto err;
		}
	if (s->cipher_list_by_id != NULL)
B
Ben Laurie 已提交
2527
		if ((ret->cipher_list_by_id=sk_SSL_CIPHER_dup(s->cipher_list_by_id))
2528 2529 2530 2531 2532 2533
			== NULL)
			goto err;

	/* Dup the client_CA list */
	if (s->client_CA != NULL)
		{
B
Ben Laurie 已提交
2534
		if ((sk=sk_X509_NAME_dup(s->client_CA)) == NULL) goto err;
2535
		ret->client_CA=sk;
B
Ben Laurie 已提交
2536
		for (i=0; i<sk_X509_NAME_num(sk); i++)
2537
			{
B
Ben Laurie 已提交
2538 2539
			xn=sk_X509_NAME_value(sk,i);
			if (sk_X509_NAME_set(sk,i,X509_NAME_dup(xn)) == NULL)
2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555
				{
				X509_NAME_free(xn);
				goto err;
				}
			}
		}

	if (0)
		{
err:
		if (ret != NULL) SSL_free(ret);
		ret=NULL;
		}
	return(ret);
	}

2556
void ssl_clear_cipher_ctx(SSL *s)
2557
	{
2558 2559 2560
	if (s->enc_read_ctx != NULL)
		{
		EVP_CIPHER_CTX_cleanup(s->enc_read_ctx);
2561
		OPENSSL_free(s->enc_read_ctx);
2562 2563 2564 2565 2566
		s->enc_read_ctx=NULL;
		}
	if (s->enc_write_ctx != NULL)
		{
		EVP_CIPHER_CTX_cleanup(s->enc_write_ctx);
2567
		OPENSSL_free(s->enc_write_ctx);
2568 2569
		s->enc_write_ctx=NULL;
		}
2570
#ifndef OPENSSL_NO_COMP
2571 2572 2573 2574 2575 2576 2577 2578 2579 2580
	if (s->expand != NULL)
		{
		COMP_CTX_free(s->expand);
		s->expand=NULL;
		}
	if (s->compress != NULL)
		{
		COMP_CTX_free(s->compress);
		s->compress=NULL;
		}
2581
#endif
2582 2583
	}

2584
/* Fix this function so that it takes an optional type parameter */
B
Ben Laurie 已提交
2585
X509 *SSL_get_certificate(const SSL *s)
2586 2587 2588 2589 2590 2591 2592
	{
	if (s->cert != NULL)
		return(s->cert->key->x509);
	else
		return(NULL);
	}

2593
/* Fix this function so that it takes an optional type parameter */
2594
EVP_PKEY *SSL_get_privatekey(SSL *s)
2595 2596 2597 2598 2599 2600 2601
	{
	if (s->cert != NULL)
		return(s->cert->key->privatekey);
	else
		return(NULL);
	}

2602
const SSL_CIPHER *SSL_get_current_cipher(const SSL *s)
2603
	{
2604 2605 2606
	if ((s->session != NULL) && (s->session->cipher != NULL))
		return(s->session->cipher);
	return(NULL);
2607
	}
2608 2609 2610 2611 2612 2613 2614 2615 2616 2617
#ifdef OPENSSL_NO_COMP
const void *SSL_get_current_compression(SSL *s)
	{
	return NULL;
	}
const void *SSL_get_current_expansion(SSL *s)
	{
	return NULL;
	}
#else
2618

2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631
const COMP_METHOD *SSL_get_current_compression(SSL *s)
	{
	if (s->compress != NULL)
		return(s->compress->meth);
	return(NULL);
	}

const COMP_METHOD *SSL_get_current_expansion(SSL *s)
	{
	if (s->expand != NULL)
		return(s->expand->meth);
	return(NULL);
	}
2632
#endif
2633

2634
int ssl_init_wbio_buffer(SSL *s,int push)
2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649
	{
	BIO *bbio;

	if (s->bbio == NULL)
		{
		bbio=BIO_new(BIO_f_buffer());
		if (bbio == NULL) return(0);
		s->bbio=bbio;
		}
	else
		{
		bbio=s->bbio;
		if (s->bbio == s->wbio)
			s->wbio=BIO_pop(s->wbio);
		}
B
Bodo Möller 已提交
2650
	(void)BIO_reset(bbio);
2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668
/*	if (!BIO_set_write_buffer_size(bbio,16*1024)) */
	if (!BIO_set_read_buffer_size(bbio,1))
		{
		SSLerr(SSL_F_SSL_INIT_WBIO_BUFFER,ERR_R_BUF_LIB);
		return(0);
		}
	if (push)
		{
		if (s->wbio != bbio)
			s->wbio=BIO_push(bbio,s->wbio);
		}
	else
		{
		if (s->wbio == bbio)
			s->wbio=BIO_pop(bbio);
		}
	return(1);
	}
2669

2670
void ssl_free_wbio_buffer(SSL *s)
2671 2672 2673 2674 2675 2676
	{
	if (s->bbio == NULL) return;

	if (s->bbio == s->wbio)
		{
		/* remove buffering */
2677 2678 2679
		s->wbio=BIO_pop(s->wbio);
#ifdef REF_CHECK /* not the usual REF_CHECK, but this avoids adding one more preprocessor symbol */
		assert(s->wbio != NULL);
2680
#endif
2681
	}
2682 2683 2684
	BIO_free(s->bbio);
	s->bbio=NULL;
	}
2685
	
2686
void SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx,int mode)
2687 2688 2689 2690
	{
	ctx->quiet_shutdown=mode;
	}

B
Ben Laurie 已提交
2691
int SSL_CTX_get_quiet_shutdown(const SSL_CTX *ctx)
2692 2693 2694 2695
	{
	return(ctx->quiet_shutdown);
	}

2696
void SSL_set_quiet_shutdown(SSL *s,int mode)
2697 2698 2699 2700
	{
	s->quiet_shutdown=mode;
	}

B
Ben Laurie 已提交
2701
int SSL_get_quiet_shutdown(const SSL *s)
2702 2703 2704 2705
	{
	return(s->quiet_shutdown);
	}

2706
void SSL_set_shutdown(SSL *s,int mode)
2707 2708 2709 2710
	{
	s->shutdown=mode;
	}

B
Ben Laurie 已提交
2711
int SSL_get_shutdown(const SSL *s)
2712 2713 2714 2715
	{
	return(s->shutdown);
	}

B
Ben Laurie 已提交
2716
int SSL_version(const SSL *s)
2717 2718 2719 2720
	{
	return(s->version);
	}

B
Ben Laurie 已提交
2721
SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl)
2722 2723 2724 2725
	{
	return(ssl->ctx);
	}

2726 2727
SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX* ctx)
	{
2728
	if (ssl->ctx == ctx)
B
Bodo Möller 已提交
2729
		return ssl->ctx;
2730
#ifndef OPENSSL_NO_TLSEXT
B
Bodo Möller 已提交
2731 2732
	if (ctx == NULL)
		ctx = ssl->initial_ctx;
2733
#endif
2734 2735 2736 2737 2738 2739 2740 2741 2742 2743
	if (ssl->cert != NULL)
		ssl_cert_free(ssl->cert);
	ssl->cert = ssl_cert_dup(ctx->cert);
	CRYPTO_add(&ctx->references,1,CRYPTO_LOCK_SSL_CTX);
	if (ssl->ctx != NULL)
		SSL_CTX_free(ssl->ctx); /* decrement reference count */
	ssl->ctx = ctx;
	return(ssl->ctx);
	}

2744
#ifndef OPENSSL_NO_STDIO
2745
int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx)
2746 2747 2748 2749
	{
	return(X509_STORE_set_default_paths(ctx->cert_store));
	}

2750 2751
int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,
		const char *CApath)
2752 2753 2754
	{
	return(X509_STORE_load_locations(ctx->cert_store,CAfile,CApath));
	}
2755
#endif
2756

B
Ben Laurie 已提交
2757
void SSL_set_info_callback(SSL *ssl,
N
Nils Larsch 已提交
2758
	void (*cb)(const SSL *ssl,int type,int val))
2759 2760 2761 2762
	{
	ssl->info_callback=cb;
	}

2763 2764
/* One compiler (Diab DCC) doesn't like argument names in returned
   function pointer.  */
2765
void (*SSL_get_info_callback(const SSL *ssl))(const SSL * /*ssl*/,int /*type*/,int /*val*/)
2766
	{
B
Ben Laurie 已提交
2767
	return ssl->info_callback;
2768 2769
	}

B
Ben Laurie 已提交
2770
int SSL_state(const SSL *ssl)
2771 2772 2773 2774
	{
	return(ssl->state);
	}

2775
void SSL_set_verify_result(SSL *ssl,long arg)
2776 2777 2778 2779
	{
	ssl->verify_result=arg;
	}

B
Ben Laurie 已提交
2780
long SSL_get_verify_result(const SSL *ssl)
2781 2782 2783 2784
	{
	return(ssl->verify_result);
	}

D
 
Dr. Stephen Henson 已提交
2785 2786
int SSL_get_ex_new_index(long argl,void *argp,CRYPTO_EX_new *new_func,
			 CRYPTO_EX_dup *dup_func,CRYPTO_EX_free *free_func)
2787
	{
2788 2789
	return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL, argl, argp,
				new_func, dup_func, free_func);
2790
	}
2791

2792
int SSL_set_ex_data(SSL *s,int idx,void *arg)
2793 2794 2795 2796
	{
	return(CRYPTO_set_ex_data(&s->ex_data,idx,arg));
	}

B
Ben Laurie 已提交
2797
void *SSL_get_ex_data(const SSL *s,int idx)
2798 2799 2800 2801
	{
	return(CRYPTO_get_ex_data(&s->ex_data,idx));
	}

D
 
Dr. Stephen Henson 已提交
2802 2803
int SSL_CTX_get_ex_new_index(long argl,void *argp,CRYPTO_EX_new *new_func,
			     CRYPTO_EX_dup *dup_func,CRYPTO_EX_free *free_func)
2804
	{
2805 2806
	return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL_CTX, argl, argp,
				new_func, dup_func, free_func);
2807
	}
2808

2809
int SSL_CTX_set_ex_data(SSL_CTX *s,int idx,void *arg)
2810 2811 2812 2813
	{
	return(CRYPTO_set_ex_data(&s->ex_data,idx,arg));
	}

B
Ben Laurie 已提交
2814
void *SSL_CTX_get_ex_data(const SSL_CTX *s,int idx)
2815 2816 2817 2818
	{
	return(CRYPTO_get_ex_data(&s->ex_data,idx));
	}

2819
int ssl_ok(SSL *s)
2820 2821 2822 2823
	{
	return(1);
	}

B
Ben Laurie 已提交
2824
X509_STORE *SSL_CTX_get_cert_store(const SSL_CTX *ctx)
2825 2826 2827 2828
	{
	return(ctx->cert_store);
	}

2829
void SSL_CTX_set_cert_store(SSL_CTX *ctx,X509_STORE *store)
2830 2831 2832 2833 2834 2835
	{
	if (ctx->cert_store != NULL)
		X509_STORE_free(ctx->cert_store);
	ctx->cert_store=store;
	}

B
Ben Laurie 已提交
2836
int SSL_want(const SSL *s)
2837 2838 2839 2840
	{
	return(s->rwstate);
	}

2841 2842 2843 2844 2845 2846
/*!
 * \brief Set the callback for generating temporary RSA keys.
 * \param ctx the SSL context.
 * \param cb the callback
 */

2847
#ifndef OPENSSL_NO_RSA
U
Ulf Möller 已提交
2848 2849
void SSL_CTX_set_tmp_rsa_callback(SSL_CTX *ctx,RSA *(*cb)(SSL *ssl,
							  int is_export,
2850
							  int keylength))
2851
    {
2852
    SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TMP_RSA_CB,(void (*)(void))cb);
2853
    }
2854

2855 2856 2857
void SSL_set_tmp_rsa_callback(SSL *ssl,RSA *(*cb)(SSL *ssl,
						  int is_export,
						  int keylength))
2858
    {
2859
    SSL_callback_ctrl(ssl,SSL_CTRL_SET_TMP_RSA_CB,(void (*)(void))cb);
2860
    }
2861
#endif
2862

2863 2864 2865 2866
#ifdef DOXYGEN
/*!
 * \brief The RSA temporary key callback function.
 * \param ssl the SSL session.
U
Ulf Möller 已提交
2867 2868 2869
 * \param is_export \c TRUE if the temp RSA key is for an export ciphersuite.
 * \param keylength if \c is_export is \c TRUE, then \c keylength is the size
 * of the required key in bits.
2870 2871 2872 2873
 * \return the temporary RSA key.
 * \sa SSL_CTX_set_tmp_rsa_callback, SSL_set_tmp_rsa_callback
 */

U
Ulf Möller 已提交
2874
RSA *cb(SSL *ssl,int is_export,int keylength)
2875 2876 2877 2878 2879 2880 2881 2882 2883
    {}
#endif

/*!
 * \brief Set the callback for generating temporary DH keys.
 * \param ctx the SSL context.
 * \param dh the callback
 */

2884
#ifndef OPENSSL_NO_DH
U
Ulf Möller 已提交
2885
void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,DH *(*dh)(SSL *ssl,int is_export,
2886
                                                        int keylength))
2887
	{
2888
	SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TMP_DH_CB,(void (*)(void))dh);
2889
	}
2890

U
Ulf Möller 已提交
2891
void SSL_set_tmp_dh_callback(SSL *ssl,DH *(*dh)(SSL *ssl,int is_export,
2892
                                                int keylength))
2893
	{
2894
	SSL_callback_ctrl(ssl,SSL_CTRL_SET_TMP_DH_CB,(void (*)(void))dh);
2895
	}
2896
#endif
2897

B
Bodo Möller 已提交
2898 2899
#ifndef OPENSSL_NO_ECDH
void SSL_CTX_set_tmp_ecdh_callback(SSL_CTX *ctx,EC_KEY *(*ecdh)(SSL *ssl,int is_export,
2900
                                                                int keylength))
B
Bodo Möller 已提交
2901
	{
2902
	SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TMP_ECDH_CB,(void (*)(void))ecdh);
B
Bodo Möller 已提交
2903 2904 2905
	}

void SSL_set_tmp_ecdh_callback(SSL *ssl,EC_KEY *(*ecdh)(SSL *ssl,int is_export,
2906
                                                        int keylength))
B
Bodo Möller 已提交
2907
	{
2908
	SSL_callback_ctrl(ssl,SSL_CTRL_SET_TMP_ECDH_CB,(void (*)(void))ecdh);
B
Bodo Möller 已提交
2909 2910 2911
	}
#endif

2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971
#ifndef OPENSSL_NO_PSK
int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx, const char *identity_hint)
	{
	if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN)
		{
		SSLerr(SSL_F_SSL_CTX_USE_PSK_IDENTITY_HINT, SSL_R_DATA_LENGTH_TOO_LONG);
		return 0;
		}
	if (ctx->psk_identity_hint != NULL)
		OPENSSL_free(ctx->psk_identity_hint);
	if (identity_hint != NULL)
		{
		ctx->psk_identity_hint = BUF_strdup(identity_hint);
		if (ctx->psk_identity_hint == NULL)
			return 0;
		}
	else
		ctx->psk_identity_hint = NULL;
	return 1;
	}

int SSL_use_psk_identity_hint(SSL *s, const char *identity_hint)
	{
	if (s == NULL)
		return 0;

	if (s->session == NULL)
		return 1; /* session not created yet, ignored */

	if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN)
		{
		SSLerr(SSL_F_SSL_USE_PSK_IDENTITY_HINT, SSL_R_DATA_LENGTH_TOO_LONG);
		return 0;
		}
	if (s->session->psk_identity_hint != NULL)
		OPENSSL_free(s->session->psk_identity_hint);
	if (identity_hint != NULL)
		{
		s->session->psk_identity_hint = BUF_strdup(identity_hint);
		if (s->session->psk_identity_hint == NULL)
			return 0;
		}
	else
		s->session->psk_identity_hint = NULL;
	return 1;
	}

const char *SSL_get_psk_identity_hint(const SSL *s)
	{
	if (s == NULL || s->session == NULL)
		return NULL;
	return(s->session->psk_identity_hint);
	}

const char *SSL_get_psk_identity(const SSL *s)
	{
	if (s == NULL || s->session == NULL)
		return NULL;
	return(s->session->psk_identity);
	}
N
Nils Larsch 已提交
2972

2973 2974 2975 2976
void SSL_set_psk_client_callback(SSL *s,
    unsigned int (*cb)(SSL *ssl, const char *hint,
                       char *identity, unsigned int max_identity_len, unsigned char *psk,
                       unsigned int max_psk_len))
N
Nils Larsch 已提交
2977
	{
2978
	s->psk_client_callback = cb;
N
Nils Larsch 已提交
2979 2980 2981
	}

void SSL_CTX_set_psk_client_callback(SSL_CTX *ctx,
2982 2983 2984
    unsigned int (*cb)(SSL *ssl, const char *hint,
                       char *identity, unsigned int max_identity_len, unsigned char *psk,
                       unsigned int max_psk_len))
N
Nils Larsch 已提交
2985
	{
2986
	ctx->psk_client_callback = cb;
N
Nils Larsch 已提交
2987 2988
	}

2989 2990 2991
void SSL_set_psk_server_callback(SSL *s,
    unsigned int (*cb)(SSL *ssl, const char *identity,
                       unsigned char *psk, unsigned int max_psk_len))
N
Nils Larsch 已提交
2992
	{
2993
	s->psk_server_callback = cb;
N
Nils Larsch 已提交
2994 2995 2996
	}

void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx,
2997 2998
    unsigned int (*cb)(SSL *ssl, const char *identity,
                       unsigned char *psk, unsigned int max_psk_len))
N
Nils Larsch 已提交
2999
	{
3000
	ctx->psk_server_callback = cb;
N
Nils Larsch 已提交
3001
	}
3002
#endif
3003 3004 3005

void SSL_CTX_set_msg_callback(SSL_CTX *ctx, void (*cb)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg))
	{
3006
	SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
3007 3008 3009
	}
void SSL_set_msg_callback(SSL *ssl, void (*cb)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg))
	{
3010
	SSL_callback_ctrl(ssl, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
3011 3012
	}

3013 3014 3015 3016
/* Allocates new EVP_MD_CTX and sets pointer to it into given pointer
 * vairable, freeing  EVP_MD_CTX previously stored in that variable, if
 * any. If EVP_MD pointer is passed, initializes ctx with this md
 * Returns newly allocated ctx;
B
Ben Laurie 已提交
3017
 */
3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031

EVP_MD_CTX *ssl_replace_hash(EVP_MD_CTX **hash,const EVP_MD *md) 
{
	ssl_clear_hash_ctx(hash);
	*hash = EVP_MD_CTX_create();
	if (md) EVP_DigestInit_ex(*hash,md,NULL);
	return *hash;
}
void ssl_clear_hash_ctx(EVP_MD_CTX **hash) 
{

	if (*hash) EVP_MD_CTX_destroy(*hash);
	*hash=NULL;
}
3032

3033
#if defined(_WINDLL) && defined(OPENSSL_SYS_WIN16)
3034 3035
#include "../crypto/bio/bss_file.c"
#endif
B
Ben Laurie 已提交
3036 3037 3038

IMPLEMENT_STACK_OF(SSL_CIPHER)
IMPLEMENT_STACK_OF(SSL_COMP)
D
Dr. Stephen Henson 已提交
3039 3040 3041
IMPLEMENT_OBJ_BSEARCH_GLOBAL_CMP_FN(SSL_CIPHER, SSL_CIPHER,
				    ssl_cipher_id);