ssl_lib.c 79.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
#include <openssl/crypto.h>
150 151
#include "ssl_locl.h"
#include "kssl_lcl.h"
152 153
#include <openssl/objects.h>
#include <openssl/lhash.h>
154
#include <openssl/x509v3.h>
155
#include <openssl/rand.h>
156
#include <openssl/ocsp.h>
N
make  
Nils Larsch 已提交
157
#ifndef OPENSSL_NO_DH
158
#include <openssl/dh.h>
N
make  
Nils Larsch 已提交
159
#endif
160 161 162
#ifndef OPENSSL_NO_ENGINE
#include <openssl/engine.h>
#endif
163

164
const char *SSL_version_str=OPENSSL_VERSION_TEXT;
165

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

183
int SSL_clear(SSL *s)
184 185
	{

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

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

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

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

	s->type=0;

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

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

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

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

	s->first_packet=0;

239 240 241
#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. */
242
	if (!s->in_handshake && (s->session == NULL) && (s->method != s->ctx->method))
243 244 245 246 247 248 249 250 251 252
		{
		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);
253 254
	}

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

	ctx->method=meth;

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

273
SSL *SSL_new(SSL_CTX *ctx)
274 275 276 277 278 279 280 281 282 283 284 285 286 287
	{
	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);
		}

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

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

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

300
	if (ctx->cert != NULL)
301
		{
302 303 304 305 306 307 308 309 310 311 312 313 314
		/* 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;
315 316
		}
	else
317
		s->cert=NULL; /* Cannot really happen (see SSL_CTX_new) */
318 319 320 321

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

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

344 345
	CRYPTO_add(&ctx->references,1,CRYPTO_LOCK_SSL_CTX);
	s->ctx=ctx;
346
#ifndef OPENSSL_NO_TLSEXT
347 348 349
	s->tlsext_debug_cb = 0;
	s->tlsext_debug_arg = NULL;
	s->tlsext_ticket_expected = 0;
350 351 352 353 354 355
	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;
356 357
	CRYPTO_add(&ctx->references,1,CRYPTO_LOCK_SSL_CTX);
	s->initial_ctx=ctx;
B
Ben Laurie 已提交
358
# ifndef OPENSSL_NO_NEXTPROTONEG
B
Ben Laurie 已提交
359 360
	s->next_proto_negotiated = NULL;
# endif
361
#endif
362 363 364 365 366 367 368 369

	s->verify_result=X509_V_OK;

	s->method=ctx->method;

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

370
	s->references=1;
371
	s->server=(ctx->method->ssl_accept == ssl_undefined_function)?0:1;
372

373
	SSL_clear(s);
374

375
	CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
376

377 378 379 380 381
#ifndef OPENSSL_NO_PSK
	s->psk_client_callback=ctx->psk_client_callback;
	s->psk_server_callback=ctx->psk_server_callback;
#endif

382 383
	return(s);
err:
384 385 386 387 388 389
	if (s != NULL)
		{
		if (s->cert != NULL)
			ssl_cert_free(s->cert);
		if (s->ctx != NULL)
			SSL_CTX_free(s->ctx); /* decrement reference count */
390
		OPENSSL_free(s);
391
		}
392 393 394 395
	SSLerr(SSL_F_SSL_NEW,ERR_R_MALLOC_FAILURE);
	return(NULL);
	}

396 397 398
int SSL_CTX_set_session_id_context(SSL_CTX *ctx,const unsigned char *sid_ctx,
				   unsigned int sid_ctx_len)
    {
399
    if(sid_ctx_len > sizeof ctx->sid_ctx)
400 401 402 403 404 405 406 407 408 409
	{
	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 已提交
410 411 412 413 414 415 416 417 418 419 420 421 422 423
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;
    }

424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439
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;
	}

440
int SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id,
441
				unsigned int id_len)
442 443 444 445 446
	{
	/* 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
447
	 * use by this SSL. */
448
	SSL_SESSION r, *p;
449 450 451 452

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

453
	r.ssl_version = ssl->version;
454 455
	r.session_id_length = id_len;
	memcpy(r.session_id, id, id_len);
456 457 458 459 460 461 462 463 464 465 466
	/* 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;
		}
467 468

	CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);
B
Ben Laurie 已提交
469
	p = lh_SSL_SESSION_retrieve(ssl->ctx->sessions, &r);
470 471 472 473
	CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
	return (p != NULL);
	}

474
int SSL_CTX_set_purpose(SSL_CTX *s, int purpose)
475
	{
476
	return X509_VERIFY_PARAM_set_purpose(s->param, purpose);
477
	}
478 479

int SSL_set_purpose(SSL *s, int purpose)
480
	{
481
	return X509_VERIFY_PARAM_set_purpose(s->param, purpose);
482
	}
D
 
Dr. Stephen Henson 已提交
483

484
int SSL_CTX_set_trust(SSL_CTX *s, int trust)
485
	{
486
	return X509_VERIFY_PARAM_set_trust(s->param, trust);
487
	}
488 489

int SSL_set_trust(SSL *s, int trust)
490
	{
491
	return X509_VERIFY_PARAM_set_trust(s->param, trust);
492
	}
493

D
Dr. Stephen Henson 已提交
494 495 496 497 498 499 500 501 502 503
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);
	}

504
void SSL_free(SSL *s)
505
	{
506 507
	int i;

B
Ben Laurie 已提交
508 509 510
	if(s == NULL)
	    return;

511 512 513 514 515 516 517 518 519 520 521 522 523
	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

524 525 526
	if (s->param)
		X509_VERIFY_PARAM_free(s->param);

527
	CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
528

529 530 531 532 533 534 535 536
	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);
537
		s->bbio=NULL;
538 539 540 541 542 543 544 545 546
		}
	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 已提交
547 548
	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);
549 550 551 552 553 554 555 556 557

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

	ssl_clear_cipher_ctx(s);
558 559
	ssl_clear_hash_ctx(&s->read_hash);
	ssl_clear_hash_ctx(&s->write_hash);
560 561 562 563

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

564
#ifndef OPENSSL_NO_TLSEXT
B
Ben Laurie 已提交
565 566
	if (s->tlsext_hostname)
		OPENSSL_free(s->tlsext_hostname);
567
	if (s->initial_ctx) SSL_CTX_free(s->initial_ctx);
B
Bodo Möller 已提交
568 569 570 571
#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 */
572
	if (s->tlsext_opaque_prf_input) OPENSSL_free(s->tlsext_opaque_prf_input);
573 574 575 576 577 578 579
	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);
580
#endif
581 582

	if (s->client_CA != NULL)
B
Ben Laurie 已提交
583
		sk_X509_NAME_pop_free(s->client_CA,X509_NAME_free);
584 585 586

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

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

589 590 591 592 593
#ifndef	OPENSSL_NO_KRB5
	if (s->kssl_ctx != NULL)
		kssl_ctx_free(s->kssl_ctx);
#endif	/* OPENSSL_NO_KRB5 */

B
Ben Laurie 已提交
594
#if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
B
Ben Laurie 已提交
595 596 597 598
	if (s->next_proto_negotiated)
		OPENSSL_free(s->next_proto_negotiated);
#endif

599
	OPENSSL_free(s);
600 601
	}

602
void SSL_set_bio(SSL *s,BIO *rbio,BIO *wbio)
603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621
	{
	/* 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 已提交
622
BIO *SSL_get_rbio(const SSL *s)
623 624
	{ return(s->rbio); }

B
Ben Laurie 已提交
625
BIO *SSL_get_wbio(const SSL *s)
626 627
	{ return(s->wbio); }

B
Ben Laurie 已提交
628
int SSL_get_fd(const SSL *s)
629
	{
630
	return(SSL_get_rfd(s));
631 632
	}

B
Ben Laurie 已提交
633
int SSL_get_rfd(const SSL *s)
634 635 636 637 638 639 640 641 642 643 644
	{
	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 已提交
645
int SSL_get_wfd(const SSL *s)
646 647 648 649 650 651 652 653 654 655 656
	{
	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);
	}

657
#ifndef OPENSSL_NO_SOCK
658
int SSL_set_fd(SSL *s,int fd)
659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676
	{
	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);
	}

677
int SSL_set_wfd(SSL *s,int fd)
678 679 680 681
	{
	int ret=0;
	BIO *bio=NULL;

682 683 684 685
	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());
686

687 688 689 690 691 692 693
		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));
694 695 696 697 698
	ret=1;
err:
	return(ret);
	}

699
int SSL_set_rfd(SSL *s,int fd)
700 701 702 703
	{
	int ret=0;
	BIO *bio=NULL;

704 705
	if ((s->wbio == NULL) || (BIO_method_type(s->wbio) != BIO_TYPE_SOCKET)
		|| ((int)BIO_get_fd(s->wbio,NULL) != fd))
706
		{
707 708 709 710 711 712 713 714 715
		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));
716
		}
717 718
	else
		SSL_set_bio(s,SSL_get_wbio(s),SSL_get_wbio(s));
719 720 721 722 723 724
	ret=1;
err:
	return(ret);
	}
#endif

725 726

/* return length of latest Finished message we sent, copy to 'buf' */
B
Ben Laurie 已提交
727
size_t SSL_get_finished(const SSL *s, void *buf, size_t count)
728 729 730 731 732 733 734 735 736 737 738 739 740 741
	{
	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 已提交
742
size_t SSL_get_peer_finished(const SSL *s, void *buf, size_t count)
743 744 745 746 747 748 749 750 751 752 753 754 755 756
	{
	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 已提交
757
int SSL_get_verify_mode(const SSL *s)
758 759 760 761
	{
	return(s->verify_mode);
	}

B
Ben Laurie 已提交
762
int SSL_get_verify_depth(const SSL *s)
763
	{
764
	return X509_VERIFY_PARAM_get_depth(s->param);
765 766
	}

B
Ben Laurie 已提交
767
int (*SSL_get_verify_callback(const SSL *s))(int,X509_STORE_CTX *)
768 769 770 771
	{
	return(s->verify_callback);
	}

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

B
Ben Laurie 已提交
777
int SSL_CTX_get_verify_depth(const SSL_CTX *ctx)
778
	{
779
	return X509_VERIFY_PARAM_get_depth(ctx->param);
780 781
	}

B
Ben Laurie 已提交
782
int (*SSL_CTX_get_verify_callback(const SSL_CTX *ctx))(int,X509_STORE_CTX *)
783 784 785 786
	{
	return(ctx->default_verify_callback);
	}

B
Ben Laurie 已提交
787 788
void SSL_set_verify(SSL *s,int mode,
		    int (*callback)(int ok,X509_STORE_CTX *ctx))
789 790 791 792 793 794
	{
	s->verify_mode=mode;
	if (callback != NULL)
		s->verify_callback=callback;
	}

795 796
void SSL_set_verify_depth(SSL *s,int depth)
	{
797
	X509_VERIFY_PARAM_set_depth(s->param, depth);
798 799
	}

800
void SSL_set_read_ahead(SSL *s,int yes)
801 802 803 804
	{
	s->read_ahead=yes;
	}

B
Ben Laurie 已提交
805
int SSL_get_read_ahead(const SSL *s)
806 807 808 809
	{
	return(s->read_ahead);
	}

B
Ben Laurie 已提交
810
int SSL_pending(const SSL *s)
811
	{
B
Bodo Möller 已提交
812 813 814 815 816 817 818
	/* 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.)
	 */
819 820 821
	return(s->method->ssl_pending(s));
	}

B
Ben Laurie 已提交
822
X509 *SSL_get_peer_certificate(const SSL *s)
823 824 825 826 827 828 829 830 831 832 833 834 835 836 837
	{
	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 已提交
838
STACK_OF(X509) *SSL_get_peer_cert_chain(const SSL *s)
839
	{
B
Ben Laurie 已提交
840
	STACK_OF(X509) *r;
841
	
842
	if ((s == NULL) || (s->session == NULL) || (s->session->sess_cert == NULL))
843 844
		r=NULL;
	else
845
		r=s->session->sess_cert->cert_chain;
846

847 848 849
	/* If we are a client, cert_chain includes the peer's own
	 * certificate; if we are a server, it does not. */
	
850 851 852 853 854
	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 已提交
855
void SSL_copy_session_id(SSL *t,const SSL *f)
856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879
	{
	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 已提交
880
	SSL_set_session_id_context(t,f->sid_ctx,f->sid_ctx_length);
881 882
	}

883
/* Fix this so it checks all the valid key/cert options */
B
Ben Laurie 已提交
884
int SSL_CTX_check_private_key(const SSL_CTX *ctx)
885 886
	{
	if (	(ctx == NULL) ||
887 888
		(ctx->cert == NULL) ||
		(ctx->cert->key->x509 == NULL))
889 890 891 892
		{
		SSLerr(SSL_F_SSL_CTX_CHECK_PRIVATE_KEY,SSL_R_NO_CERTIFICATE_ASSIGNED);
		return(0);
		}
893
	if 	(ctx->cert->key->privatekey == NULL)
894 895 896 897
		{
		SSLerr(SSL_F_SSL_CTX_CHECK_PRIVATE_KEY,SSL_R_NO_PRIVATE_KEY_ASSIGNED);
		return(0);
		}
898
	return(X509_check_private_key(ctx->cert->key->x509, ctx->cert->key->privatekey));
899 900
	}

901
/* Fix this function so that it takes an optional type parameter */
B
Ben Laurie 已提交
902
int SSL_check_private_key(const SSL *ssl)
903 904 905 906 907 908
	{
	if (ssl == NULL)
		{
		SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY,ERR_R_PASSED_NULL_PARAMETER);
		return(0);
		}
909
	if (ssl->cert == NULL)
B
Bodo Möller 已提交
910
		{
911
		SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY,SSL_R_NO_CERTIFICATE_ASSIGNED);
912
		return 0;
B
Bodo Möller 已提交
913
		}
914 915 916 917 918 919 920 921 922 923 924 925 926 927
	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));
	}

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

934 935 936
	return(s->method->ssl_accept(s));
	}

937
int SSL_connect(SSL *s)
938
	{
939 940 941 942
	if (s->handshake_func == 0)
		/* Not properly initialized yet */
		SSL_set_connect_state(s);

943 944 945
	return(s->method->ssl_connect(s));
	}

B
Ben Laurie 已提交
946
long SSL_get_default_timeout(const SSL *s)
947 948 949 950
	{
	return(s->method->get_timeout());
	}

951
int SSL_read(SSL *s,void *buf,int num)
952
	{
953 954
	if (s->handshake_func == 0)
		{
955
		SSLerr(SSL_F_SSL_READ, SSL_R_UNINITIALIZED);
956 957 958
		return -1;
		}

959 960 961 962 963 964 965 966
	if (s->shutdown & SSL_RECEIVED_SHUTDOWN)
		{
		s->rwstate=SSL_NOTHING;
		return(0);
		}
	return(s->method->ssl_read(s,buf,num));
	}

967
int SSL_peek(SSL *s,void *buf,int num)
968
	{
B
Bodo Möller 已提交
969 970
	if (s->handshake_func == 0)
		{
971
		SSLerr(SSL_F_SSL_PEEK, SSL_R_UNINITIALIZED);
B
Bodo Möller 已提交
972 973 974
		return -1;
		}

975 976 977 978 979 980 981
	if (s->shutdown & SSL_RECEIVED_SHUTDOWN)
		{
		return(0);
		}
	return(s->method->ssl_peek(s,buf,num));
	}

982
int SSL_write(SSL *s,const void *buf,int num)
983
	{
984 985
	if (s->handshake_func == 0)
		{
986
		SSLerr(SSL_F_SSL_WRITE, SSL_R_UNINITIALIZED);
987 988 989
		return -1;
		}

990 991 992 993 994 995 996 997 998
	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));
	}

999
int SSL_shutdown(SSL *s)
1000
	{
B
Bodo Möller 已提交
1001
	/* Note that this function behaves differently from what one might
B
Bodo Möller 已提交
1002 1003 1004 1005 1006
	 * 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).
	 */

1007 1008
	if (s->handshake_func == 0)
		{
1009
		SSLerr(SSL_F_SSL_SHUTDOWN, SSL_R_UNINITIALIZED);
1010 1011 1012
		return -1;
		}

1013 1014 1015 1016 1017 1018
	if ((s != NULL) && !SSL_in_init(s))
		return(s->method->ssl_shutdown(s));
	else
		return(1);
	}

1019
int SSL_renegotiate(SSL *s)
1020
	{
D
Dr. Stephen Henson 已提交
1021 1022 1023 1024 1025
	if (s->renegotiate == 0)
		s->renegotiate=1;

	s->new_session=1;

1026 1027 1028
	return(s->method->ssl_renegotiate(s));
	}

D
Dr. Stephen Henson 已提交
1029 1030 1031 1032 1033 1034 1035 1036 1037 1038
int SSL_renegotiate_abbreviated(SSL *s)
{
	if (s->renegotiate == 0)
		s->renegotiate=1;
	
	s->new_session=0;
	
	return(s->method->ssl_renegotiate(s));
}

1039 1040 1041 1042
int SSL_renegotiate_pending(SSL *s)
	{
	/* becomes true when negotiation is requested;
	 * false again once a handshake has finished */
D
Dr. Stephen Henson 已提交
1043
	return (s->renegotiate != 0);
1044 1045
	}

1046
long SSL_ctrl(SSL *s,int cmd,long larg,void *parg)
1047
	{
1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
	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);
1058 1059 1060 1061 1062

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

1063 1064
	case SSL_CTRL_OPTIONS:
		return(s->options|=larg);
1065 1066
	case SSL_CTRL_CLEAR_OPTIONS:
		return(s->options&=~larg);
1067 1068
	case SSL_CTRL_MODE:
		return(s->mode|=larg);
1069 1070
	case SSL_CTRL_CLEAR_MODE:
		return(s->mode &=~larg);
1071 1072 1073 1074 1075 1076
	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 已提交
1077
	case SSL_CTRL_SET_MTU:
1078 1079
		if (SSL_version(s) == DTLS1_VERSION ||
		    SSL_version(s) == DTLS1_BAD_VER)
B
Ben Laurie 已提交
1080 1081 1082 1083 1084
			{
			s->d1->mtu = larg;
			return larg;
			}
		return 0;
1085 1086 1087 1088 1089
	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;
1090 1091 1092 1093
	case SSL_CTRL_GET_RI_SUPPORT:
		if (s->s3)
			return s->s3->send_connection_binding;
		else return 0;
1094 1095 1096
	default:
		return(s->method->ssl_ctrl(s,cmd,larg,parg));
		}
1097 1098
	}

1099
long SSL_callback_ctrl(SSL *s, int cmd, void (*fp)(void))
1100 1101 1102
	{
	switch(cmd)
		{
1103
	case SSL_CTRL_SET_MSG_CALLBACK:
1104
		s->msg_callback = (void (*)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg))(fp);
1105 1106
		return 1;
		
1107 1108 1109 1110 1111
	default:
		return(s->method->ssl_callback_ctrl(s,cmd,fp));
		}
	}

B
Ben Laurie 已提交
1112
LHASH_OF(SSL_SESSION) *SSL_CTX_sessions(SSL_CTX *ctx)
1113 1114 1115 1116
	{
	return ctx->sessions;
	}

1117
long SSL_CTX_ctrl(SSL_CTX *ctx,int cmd,long larg,void *parg)
1118
	{
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128
	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);
1129 1130 1131 1132 1133
		
	case SSL_CTRL_SET_MSG_CALLBACK_ARG:
		ctx->msg_callback_arg = parg;
		return 1;

1134 1135 1136 1137 1138 1139
	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);
1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154

	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 已提交
1155
		return(lh_SSL_SESSION_num_items(ctx->sessions));
1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179
	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);
1180 1181
	case SSL_CTRL_CLEAR_OPTIONS:
		return(ctx->options&=~larg);
1182 1183
	case SSL_CTRL_MODE:
		return(ctx->mode|=larg);
1184 1185
	case SSL_CTRL_CLEAR_MODE:
		return(ctx->mode&=~larg);
1186 1187 1188 1189 1190
	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;
1191 1192 1193
	default:
		return(ctx->method->ssl_ctx_ctrl(ctx,cmd,larg,parg));
		}
1194 1195
	}

1196
long SSL_CTX_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp)(void))
1197 1198 1199
	{
	switch(cmd)
		{
1200
	case SSL_CTRL_SET_MSG_CALLBACK:
1201
		ctx->msg_callback = (void (*)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg))(fp);
1202 1203
		return 1;

1204 1205 1206 1207 1208
	default:
		return(ctx->method->ssl_ctx_callback_ctrl(ctx,cmd,fp));
		}
	}

1209
int ssl_cipher_id_cmp(const SSL_CIPHER *a, const SSL_CIPHER *b)
1210 1211 1212 1213 1214 1215 1216 1217 1218 1219
	{
	long l;

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

1220 1221
int ssl_cipher_ptr_id_cmp(const SSL_CIPHER * const *ap,
			const SSL_CIPHER * const *bp)
1222 1223 1224 1225 1226 1227 1228 1229 1230 1231
	{
	long l;

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

1232
/** return a STACK of the ciphers available for the SSL and in order of
1233
 * preference */
B
Ben Laurie 已提交
1234
STACK_OF(SSL_CIPHER) *SSL_get_ciphers(const SSL *s)
1235
	{
1236
	if (s != NULL)
1237
		{
1238 1239 1240 1241 1242 1243 1244 1245 1246
		if (s->cipher_list != NULL)
			{
			return(s->cipher_list);
			}
		else if ((s->ctx != NULL) &&
			(s->ctx->cipher_list != NULL))
			{
			return(s->ctx->cipher_list);
			}
1247 1248 1249 1250
		}
	return(NULL);
	}

1251
/** return a STACK of the ciphers available for the SSL and in order of
1252
 * algorithm id */
B
Ben Laurie 已提交
1253
STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL *s)
1254
	{
1255
	if (s != NULL)
1256
		{
1257 1258 1259 1260 1261 1262 1263 1264 1265
		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);
			}
1266 1267 1268 1269
		}
	return(NULL);
	}

1270
/** The old interface to get the same thing as SSL_get_ciphers() */
B
Ben Laurie 已提交
1271
const char *SSL_get_cipher_list(const SSL *s,int n)
1272 1273
	{
	SSL_CIPHER *c;
B
Ben Laurie 已提交
1274
	STACK_OF(SSL_CIPHER) *sk;
1275 1276 1277

	if (s == NULL) return(NULL);
	sk=SSL_get_ciphers(s);
B
Ben Laurie 已提交
1278
	if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= n))
1279
		return(NULL);
B
Ben Laurie 已提交
1280
	c=sk_SSL_CIPHER_value(sk,n);
1281 1282 1283 1284
	if (c == NULL) return(NULL);
	return(c->name);
	}

1285
/** specify the ciphers to be used by default by the SSL_CTX */
1286
int SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str)
1287
	{
B
Ben Laurie 已提交
1288
	STACK_OF(SSL_CIPHER) *sk;
1289 1290 1291
	
	sk=ssl_create_cipher_list(ctx->method,&ctx->cipher_list,
		&ctx->cipher_list_by_id,str);
1292 1293 1294
	/* 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
1295 1296
	 * has been disabled). This is not an error as far as
	 * ssl_create_cipher_list is concerned, and hence
1297 1298 1299 1300 1301 1302 1303 1304 1305 1306
	 * 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;
1307 1308
	}

1309
/** specify the ciphers to be used by the SSL */
1310
int SSL_set_cipher_list(SSL *s,const char *str)
1311
	{
B
Ben Laurie 已提交
1312
	STACK_OF(SSL_CIPHER) *sk;
1313 1314 1315
	
	sk=ssl_create_cipher_list(s->ctx->method,&s->cipher_list,
		&s->cipher_list_by_id,str);
1316 1317 1318 1319 1320 1321 1322 1323 1324
	/* 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;
1325 1326 1327
	}

/* works well for SSLv2, not so good for SSLv3 */
B
Ben Laurie 已提交
1328
char *SSL_get_shared_ciphers(const SSL *s,char *buf,int len)
1329
	{
B
Ben Laurie 已提交
1330
	char *p;
B
Ben Laurie 已提交
1331
	STACK_OF(SSL_CIPHER) *sk;
1332 1333 1334 1335 1336 1337 1338 1339 1340
	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 已提交
1341
	for (i=0; i<sk_SSL_CIPHER_num(sk); i++)
1342
		{
1343 1344
		int n;

B
Ben Laurie 已提交
1345
		c=sk_SSL_CIPHER_value(sk,i);
1346 1347
		n=strlen(c->name);
		if (n+1 > len)
1348
			{
1349 1350 1351 1352
			if (p != buf)
				--p;
			*p='\0';
			return buf;
1353
			}
1354 1355
		strcpy(p,c->name);
		p+=n;
1356
		*(p++)=':';
1357
		len-=n+1;
1358 1359 1360 1361 1362
		}
	p[-1]='\0';
	return(buf);
	}

1363
int ssl_cipher_list_to_bytes(SSL *s,STACK_OF(SSL_CIPHER) *sk,unsigned char *p,
1364
			     int (*put_cb)(const SSL_CIPHER *, unsigned char *))
1365 1366 1367 1368
	{
	int i,j=0;
	SSL_CIPHER *c;
	unsigned char *q;
1369
#ifndef OPENSSL_NO_KRB5
1370
	int nokrb5 = !kssl_tgt_is_available(s->kssl_ctx);
1371
#endif /* OPENSSL_NO_KRB5 */
1372 1373 1374 1375

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

B
Ben Laurie 已提交
1376
	for (i=0; i<sk_SSL_CIPHER_num(sk); i++)
1377
		{
B
Ben Laurie 已提交
1378
		c=sk_SSL_CIPHER_value(sk,i);
1379
#ifndef OPENSSL_NO_KRB5
1380 1381 1382 1383
		if (((c->algorithm_mkey & SSL_kKRB5) || (c->algorithm_auth & SSL_aKRB5)) &&
		    nokrb5)
		    continue;
#endif /* OPENSSL_NO_KRB5 */
1384 1385
#ifndef OPENSSL_NO_PSK
		/* with PSK there must be client callback set */
1386 1387
		if (((c->algorithm_mkey & SSL_kPSK) || (c->algorithm_auth & SSL_aPSK)) &&
		    s->psk_client_callback == NULL)
1388 1389
			continue;
#endif /* OPENSSL_NO_PSK */
1390
		j = put_cb ? put_cb(c,p) : ssl_put_cipher_by_char(s,c,p);
1391 1392
		p+=j;
		}
1393
	/* If p == q, no ciphers and caller indicates an error. Otherwise
D
Dr. Stephen Henson 已提交
1394
	 * add SCSV if not renegotiating.
1395
	 */
D
Dr. Stephen Henson 已提交
1396
	if (p != q && !s->renegotiate)
1397
		{
D
Typo  
Dr. Stephen Henson 已提交
1398
		static SSL_CIPHER scsv =
1399
			{
1400
			0, NULL, SSL3_CK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0
1401
			};
D
Typo  
Dr. Stephen Henson 已提交
1402
		j = put_cb ? put_cb(&scsv,p) : ssl_put_cipher_by_char(s,&scsv,p);
1403 1404
		p+=j;
#ifdef OPENSSL_RI_DEBUG
1405
		fprintf(stderr, "SCSV sent by client\n");
1406 1407 1408
#endif
		}

1409 1410 1411
	return(p-q);
	}

B
Ben Laurie 已提交
1412 1413
STACK_OF(SSL_CIPHER) *ssl_bytes_to_cipher_list(SSL *s,unsigned char *p,int num,
					       STACK_OF(SSL_CIPHER) **skp)
1414
	{
1415
	const SSL_CIPHER *c;
B
Ben Laurie 已提交
1416
	STACK_OF(SSL_CIPHER) *sk;
1417
	int i,n;
D
Dr. Stephen Henson 已提交
1418 1419
	if (s->s3)
		s->s3->send_connection_binding = 0;
1420

1421 1422 1423 1424 1425 1426 1427
	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))
1428
		sk=sk_SSL_CIPHER_new_null(); /* change perhaps later */
1429 1430 1431
	else
		{
		sk= *skp;
B
Ben Laurie 已提交
1432
		sk_SSL_CIPHER_zero(sk);
1433 1434 1435 1436
		}

	for (i=0; i<num; i+=n)
		{
1437
		/* Check for SCSV */
D
Dr. Stephen Henson 已提交
1438
		if (s->s3 && (n != 3 || !p[0]) &&
1439 1440
			(p[n-2] == ((SSL3_CK_SCSV >> 8) & 0xff)) &&
			(p[n-1] == (SSL3_CK_SCSV & 0xff)))
1441
			{
1442
			/* SCSV fatal if renegotiating */
D
Dr. Stephen Henson 已提交
1443
			if (s->renegotiate)
1444 1445 1446 1447 1448
				{
				SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST,SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING);
				ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_HANDSHAKE_FAILURE); 
				goto err;
				}
1449 1450 1451
			s->s3->send_connection_binding = 1;
			p += n;
#ifdef OPENSSL_RI_DEBUG
1452
			fprintf(stderr, "SCSV received by server\n");
1453 1454 1455 1456
#endif
			continue;
			}

1457 1458 1459 1460
		c=ssl_get_cipher_by_char(s,p);
		p+=n;
		if (c != NULL)
			{
B
Ben Laurie 已提交
1461
			if (!sk_SSL_CIPHER_push(sk,c))
1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473
				{
				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 已提交
1474
		sk_SSL_CIPHER_free(sk);
1475 1476 1477
	return(NULL);
	}

1478

D
Typo.  
Dr. Stephen Henson 已提交
1479
#ifndef OPENSSL_NO_TLSEXT
1480
/** return a servername extension value if provided in Client Hello, or NULL.
1481
 * So far, only host_name types are defined (RFC 3546).
1482 1483
 */

1484 1485 1486
const char *SSL_get_servername(const SSL *s, const int type)
	{
	if (type != TLSEXT_NAMETYPE_host_name)
1487
		return NULL;
B
Bodo Möller 已提交
1488 1489

	return s->session && !s->tlsext_hostname ?
1490 1491 1492
		s->session->tlsext_hostname :
		s->tlsext_hostname;
	}
1493

1494 1495
int SSL_get_servername_type(const SSL *s)
	{
1496
	if (s->session && (!s->tlsext_hostname ? s->session->tlsext_hostname : s->tlsext_hostname))
1497
		return TLSEXT_NAMETYPE_host_name;
1498
	return -1;
1499
	}
B
Ben Laurie 已提交
1500

B
Ben Laurie 已提交
1501
# ifndef OPENSSL_NO_NEXTPROTONEG
B
Ben Laurie 已提交
1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617
/* SSL_select_next_proto implements the standard protocol selection. It is
 * expected that this function is called from the callback set by
 * SSL_CTX_set_next_proto_select_cb.
 *
 * The protocol data is assumed to be a vector of 8-bit, length prefixed byte
 * strings. The length byte itself is not included in the length. A byte
 * string of length 0 is invalid. No byte string may be truncated.
 *
 * The current, but experimental algorithm for selecting the protocol is:
 *
 * 1) If the server doesn't support NPN then this is indicated to the
 * callback. In this case, the client application has to abort the connection
 * or have a default application level protocol.
 *
 * 2) If the server supports NPN, but advertises an empty list then the
 * client selects the first protcol in its list, but indicates via the
 * API that this fallback case was enacted.
 *
 * 3) Otherwise, the client finds the first protocol in the server's list
 * that it supports and selects this protocol. This is because it's
 * assumed that the server has better information about which protocol
 * a client should use.
 *
 * 4) If the client doesn't support any of the server's advertised
 * protocols, then this is treated the same as case 2.
 *
 * It returns either
 * OPENSSL_NPN_NEGOTIATED if a common protocol was found, or
 * OPENSSL_NPN_NO_OVERLAP if the fallback case was reached.
 */
int SSL_select_next_proto(unsigned char **out, unsigned char *outlen, const unsigned char *server, unsigned int server_len, const unsigned char *client, unsigned int client_len)
	{
	unsigned int i, j;
	const unsigned char *result;
	int status = OPENSSL_NPN_UNSUPPORTED;

	/* For each protocol in server preference order, see if we support it. */
	for (i = 0; i < server_len; )
		{
		for (j = 0; j < client_len; )
			{
			if (server[i] == client[j] &&
			    memcmp(&server[i+1], &client[j+1], server[i]) == 0)
				{
				/* We found a match */
				result = &server[i];
				status = OPENSSL_NPN_NEGOTIATED;
				goto found;
				}
			j += client[j];
			j++;
			}
		i += server[i];
		i++;
		}

	/* There's no overlap between our protocols and the server's list. */
	result = client;
	status = OPENSSL_NPN_NO_OVERLAP;

	found:
	*out = (unsigned char *) result + 1;
	*outlen = result[0];
	return status;
	}

/* SSL_get0_next_proto_negotiated sets *data and *len to point to the client's
 * requested protocol for this connection and returns 0. If the client didn't
 * request any protocol, then *data is set to NULL.
 *
 * Note that the client can request any protocol it chooses. The value returned
 * from this function need not be a member of the list of supported protocols
 * provided by the callback.
 */
void SSL_get0_next_proto_negotiated(const SSL *s, const unsigned char **data, unsigned *len)
	{
	*data = s->next_proto_negotiated;
	if (!*data) {
		*len = 0;
	} else {
		*len = s->next_proto_negotiated_len;
	}
}

/* SSL_CTX_set_next_protos_advertised_cb sets a callback that is called when a
 * TLS server needs a list of supported protocols for Next Protocol
 * Negotiation. The returned list must be in wire format.  The list is returned
 * by setting |out| to point to it and |outlen| to its length. This memory will
 * not be modified, but one should assume that the SSL* keeps a reference to
 * it.
 *
 * The callback should return SSL_TLSEXT_ERR_OK if it wishes to advertise. Otherwise, no
 * such extension will be included in the ServerHello. */
void SSL_CTX_set_next_protos_advertised_cb(SSL_CTX *ctx, int (*cb) (SSL *ssl, const unsigned char **out, unsigned int *outlen, void *arg), void *arg)
	{
	ctx->next_protos_advertised_cb = cb;
	ctx->next_protos_advertised_cb_arg = arg;
	}

/* SSL_CTX_set_next_proto_select_cb sets a callback that is called when a
 * client needs to select a protocol from the server's provided list. |out|
 * must be set to point to the selected protocol (which may be within |in|).
 * The length of the protocol name must be written into |outlen|. The server's
 * advertised protocols are provided in |in| and |inlen|. The callback can
 * assume that |in| is syntactically valid.
 *
 * The client must select a protocol. It is fatal to the connection if this
 * callback returns a value other than SSL_TLSEXT_ERR_OK.
 */
void SSL_CTX_set_next_proto_select_cb(SSL_CTX *ctx, int (*cb) (SSL *s, unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen, void *arg), void *arg)
	{
	ctx->next_proto_select_cb = cb;
	ctx->next_proto_select_cb_arg = arg;
	}

# endif
1618
#endif
1619

B
Ben Laurie 已提交
1620
static unsigned long ssl_session_hash(const SSL_SESSION *a)
1621 1622 1623
	{
	unsigned long l;

1624 1625 1626 1627 1628
	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);
1629 1630 1631
	return(l);
	}

1632 1633 1634 1635 1636
/* 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 已提交
1637
static int ssl_session_cmp(const SSL_SESSION *a,const SSL_SESSION *b)
1638
	{
1639 1640 1641 1642 1643
	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));
1644 1645
	}

1646 1647 1648 1649
/* 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 已提交
1650 1651
static IMPLEMENT_LHASH_HASH_FN(ssl_session, SSL_SESSION)
static IMPLEMENT_LHASH_COMP_FN(ssl_session, SSL_SESSION)
1652

1653
SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth)
1654
	{
1655
	SSL_CTX *ret=NULL;
B
Ben Laurie 已提交
1656

1657 1658 1659 1660 1661
	if (meth == NULL)
		{
		SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_NULL_SSL_METHOD_PASSED);
		return(NULL);
		}
1662 1663 1664 1665 1666 1667

	if (SSL_get_ex_data_X509_STORE_CTX_idx() < 0)
		{
		SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_X509_VERIFICATION_SETUP_PROBLEMS);
		goto err;
		}
1668
	ret=(SSL_CTX *)OPENSSL_malloc(sizeof(SSL_CTX));
1669 1670 1671 1672 1673 1674 1675 1676 1677
	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;
1678 1679 1680
	ret->session_cache_size=SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;
	ret->session_cache_head=NULL;
	ret->session_cache_tail=NULL;
1681 1682 1683 1684

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

1685 1686 1687 1688
	ret->new_session_cb=0;
	ret->remove_session_cb=0;
	ret->get_session_cb=0;
	ret->generate_session_id=0;
1689

1690
	memset((char *)&ret->stats,0,sizeof(ret->stats));
1691 1692 1693 1694 1695 1696 1697 1698 1699 1700

	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 已提交
1701
	ret->info_callback=NULL;
1702

1703
	ret->app_verify_callback=0;
1704 1705
	ret->app_verify_arg=NULL;

1706
	ret->max_cert_list=SSL_MAX_CERT_LIST_DEFAULT;
1707
	ret->read_ahead=0;
1708 1709
	ret->msg_callback=0;
	ret->msg_callback_arg=NULL;
1710
	ret->verify_mode=SSL_VERIFY_NONE;
1711
#if 0
1712
	ret->verify_depth=-1; /* Don't impose a limit (but x509_lu.c does) */
1713
#endif
1714
	ret->sid_ctx_length=0;
1715
	ret->default_verify_callback=NULL;
1716
	if ((ret->cert=ssl_cert_new()) == NULL)
1717 1718
		goto err;

1719
	ret->default_passwd_callback=0;
1720
	ret->default_passwd_callback_userdata=NULL;
1721
	ret->client_cert_cb=0;
1722 1723
	ret->app_gen_cookie_cb=0;
	ret->app_verify_cookie_cb=0;
1724

B
Ben Laurie 已提交
1725
	ret->sessions=lh_SSL_SESSION_new();
1726 1727 1728 1729 1730 1731
	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,
1732
		meth->version == SSL2_VERSION ? "SSLv2" : SSL_DEFAULT_CIPHER_LIST);
B
Ben Laurie 已提交
1733 1734
	if (ret->cipher_list == NULL
	    || sk_SSL_CIPHER_num(ret->cipher_list) <= 0)
1735 1736 1737 1738 1739
		{
		SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_LIBRARY_HAS_NO_CIPHERS);
		goto err2;
		}

1740 1741 1742 1743
	ret->param = X509_VERIFY_PARAM_new();
	if (!ret->param)
		goto err;

1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759
	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 已提交
1760
	if ((ret->client_CA=sk_X509_NAME_new_null()) == NULL)
1761 1762
		goto err;

1763
	CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ret, &ret->ex_data);
1764

1765
	ret->extra_certs=NULL;
1766
	ret->comp_methods=SSL_COMP_get_compression_methods();
1767

1768 1769
	ret->max_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH;

1770
#ifndef OPENSSL_NO_TLSEXT
1771
	ret->tlsext_servername_callback = 0;
1772
	ret->tlsext_servername_arg = NULL;
1773 1774 1775 1776 1777 1778
	/* 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;

1779 1780 1781
	ret->tlsext_status_cb = 0;
	ret->tlsext_status_arg = NULL;

B
Ben Laurie 已提交
1782
# ifndef OPENSSL_NO_NEXTPROTONEG
B
Ben Laurie 已提交
1783 1784 1785
	ret->next_protos_advertised_cb = 0;
	ret->next_proto_select_cb = 0;
# endif
1786 1787 1788 1789 1790
#endif
#ifndef OPENSSL_NO_PSK
	ret->psk_identity_hint=NULL;
	ret->psk_client_callback=NULL;
	ret->psk_server_callback=NULL;
B
Ben Laurie 已提交
1791
#endif
1792
#ifndef OPENSSL_NO_BUF_FREELISTS
B
Ben Laurie 已提交
1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808
	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;
1809
#endif
1810 1811 1812 1813 1814 1815 1816 1817 1818
#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 已提交
1819 1820 1821 1822 1823 1824
	if (!eng)
		{
		ERR_clear_error();
		ENGINE_load_builtin_engines();
		eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));
		}
1825 1826 1827 1828 1829
	if (!eng || !SSL_CTX_set_client_cert_engine(ret, eng))
		ERR_clear_error();
	}
#endif
#endif
1830 1831 1832
	/* Default is to connect to non-RI servers. When RI is more widely
	 * deployed might change this.
	 */
1833
	ret->options |= SSL_OP_LEGACY_SERVER_CONNECT;
1834

1835 1836 1837 1838 1839 1840 1841 1842
	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 已提交
1843
#if 0
B
Ben Laurie 已提交
1844
static void SSL_COMP_free(SSL_COMP *comp)
1845
    { OPENSSL_free(comp); }
U
Ulf Möller 已提交
1846
#endif
B
Ben Laurie 已提交
1847

1848
#ifndef OPENSSL_NO_BUF_FREELISTS
B
Ben Laurie 已提交
1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861
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

1862
void SSL_CTX_free(SSL_CTX *a)
1863 1864 1865 1866 1867 1868
	{
	int i;

	if (a == NULL) return;

	i=CRYPTO_add(&a->references,-1,CRYPTO_LOCK_SSL_CTX);
1869 1870 1871
#ifdef REF_PRINT
	REF_PRINT("SSL_CTX",a);
#endif
1872 1873 1874 1875 1876 1877 1878 1879 1880
	if (i > 0) return;
#ifdef REF_CHECK
	if (i < 0)
		{
		fprintf(stderr,"SSL_CTX_free, bad reference count\n");
		abort(); /* ok */
		}
#endif

1881 1882 1883
	if (a->param)
		X509_VERIFY_PARAM_free(a->param);

1884 1885 1886 1887 1888 1889 1890 1891 1892
	/*
	 * 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].)
	 */
1893 1894
	if (a->sessions != NULL)
		SSL_CTX_flush_sessions(a,0);
1895 1896 1897 1898

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

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

1901 1902 1903
	if (a->cert_store != NULL)
		X509_STORE_free(a->cert_store);
	if (a->cipher_list != NULL)
B
Ben Laurie 已提交
1904
		sk_SSL_CIPHER_free(a->cipher_list);
1905
	if (a->cipher_list_by_id != NULL)
B
Ben Laurie 已提交
1906
		sk_SSL_CIPHER_free(a->cipher_list_by_id);
1907 1908
	if (a->cert != NULL)
		ssl_cert_free(a->cert);
1909
	if (a->client_CA != NULL)
B
Ben Laurie 已提交
1910
		sk_X509_NAME_pop_free(a->client_CA,X509_NAME_free);
1911
	if (a->extra_certs != NULL)
B
Ben Laurie 已提交
1912
		sk_X509_pop_free(a->extra_certs,X509_free);
1913
#if 0 /* This should never be done, since it removes a global database */
1914
	if (a->comp_methods != NULL)
B
Ben Laurie 已提交
1915
		sk_SSL_COMP_pop_free(a->comp_methods,SSL_COMP_free);
1916 1917 1918
#else
	a->comp_methods = NULL;
#endif
1919 1920 1921 1922

#ifndef OPENSSL_NO_PSK
	if (a->psk_identity_hint)
		OPENSSL_free(a->psk_identity_hint);
1923 1924 1925 1926
#endif
#ifndef OPENSSL_NO_ENGINE
	if (a->client_cert_engine)
		ENGINE_finish(a->client_cert_engine);
1927
#endif
B
Ben Laurie 已提交
1928

1929
#ifndef OPENSSL_NO_BUF_FREELISTS
B
Ben Laurie 已提交
1930 1931 1932 1933 1934 1935
	if (a->wbuf_freelist)
		ssl_buf_freelist_free(a->wbuf_freelist);
	if (a->rbuf_freelist)
		ssl_buf_freelist_free(a->rbuf_freelist);
#endif

1936
	OPENSSL_free(a);
1937 1938
	}

1939
void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb)
1940 1941 1942 1943
	{
	ctx->default_passwd_callback=cb;
	}

1944 1945 1946 1947 1948
void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx,void *u)
	{
	ctx->default_passwd_callback_userdata=u;
	}

1949
void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx, int (*cb)(X509_STORE_CTX *,void *), void *arg)
1950 1951
	{
	ctx->app_verify_callback=cb;
1952
	ctx->app_verify_arg=arg;
1953 1954
	}

1955
void SSL_CTX_set_verify(SSL_CTX *ctx,int mode,int (*cb)(int, X509_STORE_CTX *))
1956
	{
1957
	ctx->verify_mode=mode;
1958 1959 1960
	ctx->default_verify_callback=cb;
	}

1961 1962
void SSL_CTX_set_verify_depth(SSL_CTX *ctx,int depth)
	{
1963
	X509_VERIFY_PARAM_set_depth(ctx->param, depth);
1964 1965
	}

1966
void ssl_set_cert_masks(CERT *c, const SSL_CIPHER *cipher)
1967 1968 1969 1970
	{
	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;
1971
	int rsa_tmp_export,dh_tmp_export,kl;
1972
	unsigned long mask_k,mask_a,emask_k,emask_a;
N
make  
Nils Larsch 已提交
1973 1974 1975 1976
	int have_ecc_cert, ecdh_ok, ecdsa_ok, ecc_pkey_size;
#ifndef OPENSSL_NO_ECDH
	int have_ecdh_tmp;
#endif
B
Bodo Möller 已提交
1977 1978 1979
	X509 *x = NULL;
	EVP_PKEY *ecc_pkey = NULL;
	int signature_nid = 0;
1980

B
Ben Laurie 已提交
1981
	if (c == NULL) return;
1982

1983 1984
	kl=SSL_C_EXPORT_PKEYLENGTH(cipher);

1985
#ifndef OPENSSL_NO_RSA
1986 1987
	rsa_tmp=(c->rsa_tmp != NULL || c->rsa_tmp_cb != NULL);
	rsa_tmp_export=(c->rsa_tmp_cb != NULL ||
1988
		(rsa_tmp && RSA_size(c->rsa_tmp)*8 <= kl));
1989 1990 1991
#else
	rsa_tmp=rsa_tmp_export=0;
#endif
1992
#ifndef OPENSSL_NO_DH
1993 1994
	dh_tmp=(c->dh_tmp != NULL || c->dh_tmp_cb != NULL);
	dh_tmp_export=(c->dh_tmp_cb != NULL ||
1995
		(dh_tmp && DH_size(c->dh_tmp)*8 <= kl));
1996 1997 1998 1999
#else
	dh_tmp=dh_tmp_export=0;
#endif

B
Bodo Möller 已提交
2000 2001 2002
#ifndef OPENSSL_NO_ECDH
	have_ecdh_tmp=(c->ecdh_tmp != NULL || c->ecdh_tmp_cb != NULL);
#endif
2003
	cpk= &(c->pkeys[SSL_PKEY_RSA_ENC]);
2004 2005
	rsa_enc= (cpk->x509 != NULL && cpk->privatekey != NULL);
	rsa_enc_export=(rsa_enc && EVP_PKEY_size(cpk->privatekey)*8 <= kl);
2006
	cpk= &(c->pkeys[SSL_PKEY_RSA_SIGN]);
2007
	rsa_sign=(cpk->x509 != NULL && cpk->privatekey != NULL);
2008
	cpk= &(c->pkeys[SSL_PKEY_DSA_SIGN]);
2009
	dsa_sign=(cpk->x509 != NULL && cpk->privatekey != NULL);
2010
	cpk= &(c->pkeys[SSL_PKEY_DH_RSA]);
2011 2012
	dh_rsa=  (cpk->x509 != NULL && cpk->privatekey != NULL);
	dh_rsa_export=(dh_rsa && EVP_PKEY_size(cpk->privatekey)*8 <= kl);
2013 2014
	cpk= &(c->pkeys[SSL_PKEY_DH_DSA]);
/* FIX THIS EAY EAY EAY */
2015 2016
	dh_dsa=  (cpk->x509 != NULL && cpk->privatekey != NULL);
	dh_dsa_export=(dh_dsa && EVP_PKEY_size(cpk->privatekey)*8 <= kl);
B
Bodo Möller 已提交
2017 2018
	cpk= &(c->pkeys[SSL_PKEY_ECC]);
	have_ecc_cert= (cpk->x509 != NULL && cpk->privatekey != NULL);
2019 2020 2021 2022
	mask_k=0;
	mask_a=0;
	emask_k=0;
	emask_a=0;
2023

2024 2025
	

2026
#ifdef CIPHER_DEBUG
2027
	printf("rt=%d rte=%d dht=%d ecdht=%d re=%d ree=%d rs=%d ds=%d dhr=%d dhd=%d\n",
2028
	        rsa_tmp,rsa_tmp_export,dh_tmp,have_ecdh_tmp,
B
Ben Laurie 已提交
2029
		rsa_enc,rsa_enc_export,rsa_sign,dsa_sign,dh_rsa,dh_dsa);
2030
#endif
2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041
	
	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;
	}
2042 2043

	if (rsa_enc || (rsa_tmp && rsa_sign))
2044
		mask_k|=SSL_kRSA;
B
Ben Laurie 已提交
2045
	if (rsa_enc_export || (rsa_tmp_export && (rsa_sign || rsa_enc)))
2046
		emask_k|=SSL_kRSA;
2047 2048 2049

#if 0
	/* The match needs to be both kEDH and aRSA or aDSA, so don't worry */
2050
	if (	(dh_tmp || dh_rsa || dh_dsa) &&
2051
		(rsa_enc || rsa_sign || dsa_sign))
2052
		mask_k|=SSL_kEDH;
2053 2054
	if ((dh_tmp_export || dh_rsa_export || dh_dsa_export) &&
		(rsa_enc || rsa_sign || dsa_sign))
2055
		emask_k|=SSL_kEDH;
2056 2057
#endif

2058 2059
	if (dh_tmp_export)
		emask_k|=SSL_kEDH;
2060 2061

	if (dh_tmp)
2062
		mask_k|=SSL_kEDH;
2063

2064 2065
	if (dh_rsa) mask_k|=SSL_kDHr;
	if (dh_rsa_export) emask_k|=SSL_kDHr;
2066

2067 2068
	if (dh_dsa) mask_k|=SSL_kDHd;
	if (dh_dsa_export) emask_k|=SSL_kDHd;
2069 2070 2071

	if (rsa_enc || rsa_sign)
		{
2072 2073
		mask_a|=SSL_aRSA;
		emask_a|=SSL_aRSA;
2074 2075 2076 2077
		}

	if (dsa_sign)
		{
2078 2079
		mask_a|=SSL_aDSS;
		emask_a|=SSL_aDSS;
2080 2081
		}

2082 2083
	mask_a|=SSL_aNULL;
	emask_a|=SSL_aNULL;
2084

2085
#ifndef OPENSSL_NO_KRB5
2086 2087 2088 2089
	mask_k|=SSL_kKRB5;
	mask_a|=SSL_aKRB5;
	emask_k|=SSL_kKRB5;
	emask_a|=SSL_aKRB5;
2090 2091
#endif

B
Bodo Möller 已提交
2092 2093 2094 2095 2096
	/* An ECC certificate may be usable for ECDH and/or
	 * ECDSA cipher suites depending on the key usage extension.
	 */
	if (have_ecc_cert)
		{
2097
		/* This call populates extension flags (ex_flags) */
B
Bodo Möller 已提交
2098 2099 2100 2101 2102 2103 2104
		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);
2105
		ecc_pkey_size = (ecc_pkey != NULL) ?
B
Bodo Möller 已提交
2106 2107 2108 2109 2110 2111 2112
		    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)
			{
2113 2114 2115 2116 2117 2118 2119 2120
			const char *sig = OBJ_nid2ln(signature_nid);
			if (sig == NULL)
				{
				ERR_clear_error();
				sig = "unknown";
				}
				
			if (strstr(sig, "WithRSA"))
B
Bodo Möller 已提交
2121
				{
2122 2123
				mask_k|=SSL_kECDHr;
				mask_a|=SSL_aECDH;
B
Bodo Möller 已提交
2124
				if (ecc_pkey_size <= 163)
2125 2126 2127 2128
					{
					emask_k|=SSL_kECDHr;
					emask_a|=SSL_aECDH;
					}
B
Bodo Möller 已提交
2129
				}
2130

B
Bodo Möller 已提交
2131 2132
			if (signature_nid == NID_ecdsa_with_SHA1)
				{
2133 2134
				mask_k|=SSL_kECDHe;
				mask_a|=SSL_aECDH;
B
Bodo Möller 已提交
2135
				if (ecc_pkey_size <= 163)
2136 2137 2138 2139
					{
					emask_k|=SSL_kECDHe;
					emask_a|=SSL_aECDH;
					}
B
Bodo Möller 已提交
2140 2141 2142 2143 2144 2145
				}
			}
#endif
#ifndef OPENSSL_NO_ECDSA
		if (ecdsa_ok)
			{
2146 2147
			mask_a|=SSL_aECDSA;
			emask_a|=SSL_aECDSA;
B
Bodo Möller 已提交
2148 2149 2150 2151 2152 2153 2154
			}
#endif
		}

#ifndef OPENSSL_NO_ECDH
	if (have_ecdh_tmp)
		{
2155 2156
		mask_k|=SSL_kEECDH;
		emask_k|=SSL_kEECDH;
B
Bodo Möller 已提交
2157 2158
		}
#endif
2159 2160

#ifndef OPENSSL_NO_PSK
2161 2162 2163 2164
	mask_k |= SSL_kPSK;
	mask_a |= SSL_aPSK;
	emask_k |= SSL_kPSK;
	emask_a |= SSL_aPSK;
2165 2166
#endif

2167 2168 2169 2170
	c->mask_k=mask_k;
	c->mask_a=mask_a;
	c->export_mask_k=emask_k;
	c->export_mask_a=emask_a;
2171 2172 2173
	c->valid=1;
	}

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

2178 2179
#ifndef OPENSSL_NO_EC

2180
int ssl_check_srvr_ecc_cert_and_alg(X509 *x, const SSL_CIPHER *cs)
B
Bodo Möller 已提交
2181
	{
2182
	unsigned long alg_k, alg_a;
B
Bodo Möller 已提交
2183 2184 2185 2186
	EVP_PKEY *pkey = NULL;
	int keysize = 0;
	int signature_nid = 0;

2187 2188 2189
	alg_k = cs->algorithm_mkey;
	alg_a = cs->algorithm_auth;

B
Bodo Möller 已提交
2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203
	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);
2204
	if (alg_k & SSL_kECDHe || alg_k & SSL_kECDHr)
B
Bodo Möller 已提交
2205 2206 2207 2208
		{
		/* key usage, if present, must allow key agreement */
		if (ku_reject(x, X509v3_KU_KEY_AGREEMENT))
			{
2209
			SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG, SSL_R_ECC_CERT_NOT_FOR_KEY_AGREEMENT);
B
Bodo Möller 已提交
2210 2211
			return 0;
			}
2212
		if (alg_k & SSL_kECDHe)
B
Bodo Möller 已提交
2213 2214 2215 2216
			{
			/* signature alg must be ECDSA */
			if (signature_nid != NID_ecdsa_with_SHA1)
				{
2217
				SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG, SSL_R_ECC_CERT_SHOULD_HAVE_SHA1_SIGNATURE);
B
Bodo Möller 已提交
2218 2219 2220
				return 0;
				}
			}
2221
		if (alg_k & SSL_kECDHr)
B
Bodo Möller 已提交
2222 2223
			{
			/* signature alg must be RSA */
2224 2225 2226

			const char *sig = OBJ_nid2ln(signature_nid);
			if (sig == NULL)
B
Bodo Möller 已提交
2227
				{
2228 2229
				ERR_clear_error();
				sig = "unknown";
B
Bodo Möller 已提交
2230
				}
2231
			if (strstr(sig, "WithRSA") == NULL)
2232 2233
				{
				SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG, SSL_R_ECC_CERT_SHOULD_HAVE_RSA_SIGNATURE);
2234
				return 0;
2235
				}
B
Bodo Möller 已提交
2236
			}
2237 2238
		}
	if (alg_a & SSL_aECDSA)
B
Bodo Möller 已提交
2239 2240 2241 2242
		{
		/* key usage, if present, must allow signing */
		if (ku_reject(x, X509v3_KU_DIGITAL_SIGNATURE))
			{
2243
			SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG, SSL_R_ECC_CERT_NOT_FOR_SIGNING);
B
Bodo Möller 已提交
2244 2245 2246 2247 2248 2249 2250
			return 0;
			}
		}

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

2251 2252
#endif

2253
/* THIS NEEDS CLEANING UP */
2254
X509 *ssl_get_server_send_cert(SSL *s)
2255
	{
B
Ben Laurie 已提交
2256
	unsigned long alg_k,alg_a;
2257
	CERT *c;
B
Ben Laurie 已提交
2258
	int i;
2259 2260

	c=s->cert;
2261
	ssl_set_cert_masks(c, s->s3->tmp.new_cipher);
2262 2263 2264
	
	alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
	alg_a = s->s3->tmp.new_cipher->algorithm_auth;
2265

2266
	if (alg_k & (SSL_kECDHr|SSL_kECDHe))
B
Bodo Möller 已提交
2267
		{
2268
		/* we don't need to look at SSL_kEECDH
B
Bodo Möller 已提交
2269 2270
		 * since no certificate is needed for
		 * anon ECDH and for authenticated
2271
		 * EECDH, the check for the auth
B
Bodo Möller 已提交
2272 2273
		 * algorithm will set i correctly
		 * NOTE: For ECDH-RSA, we need an ECC
2274
		 * not an RSA cert but for EECDH-RSA
B
Bodo Möller 已提交
2275 2276 2277 2278 2279 2280
		 * we need an RSA cert. Placing the
		 * checks for SSL_kECDH before RSA
		 * checks ensures the correct cert is chosen.
		 */
		i=SSL_PKEY_ECC;
		}
2281
	else if (alg_a & SSL_aECDSA)
B
Bodo Möller 已提交
2282 2283 2284
		{
		i=SSL_PKEY_ECC;
		}
2285
	else if (alg_k & SSL_kDHr)
2286
		i=SSL_PKEY_DH_RSA;
2287
	else if (alg_k & SSL_kDHd)
2288
		i=SSL_PKEY_DH_DSA;
2289
	else if (alg_a & SSL_aDSS)
2290
		i=SSL_PKEY_DSA_SIGN;
2291
	else if (alg_a & SSL_aRSA)
2292 2293 2294 2295 2296 2297
		{
		if (c->pkeys[SSL_PKEY_RSA_ENC].x509 == NULL)
			i=SSL_PKEY_RSA_SIGN;
		else
			i=SSL_PKEY_RSA_ENC;
		}
2298
	else if (alg_a & SSL_aKRB5)
2299 2300 2301 2302
		{
		/* VRS something else here? */
		return(NULL);
		}
2303 2304 2305 2306
	else if (alg_a & SSL_aGOST94) 
		i=SSL_PKEY_GOST94;
	else if (alg_a & SSL_aGOST01)
		i=SSL_PKEY_GOST01;
2307
	else /* if (alg_a & SSL_aNULL) */
2308
		{
B
Bodo Möller 已提交
2309
		SSLerr(SSL_F_SSL_GET_SERVER_SEND_CERT,ERR_R_INTERNAL_ERROR);
2310 2311 2312
		return(NULL);
		}
	if (c->pkeys[i].x509 == NULL) return(NULL);
B
Bodo Möller 已提交
2313

2314 2315 2316
	return(c->pkeys[i].x509);
	}

2317
EVP_PKEY *ssl_get_sign_pkey(SSL *s,const SSL_CIPHER *cipher)
2318
	{
2319
	unsigned long alg_a;
2320 2321
	CERT *c;

2322
	alg_a = cipher->algorithm_auth;
2323 2324
	c=s->cert;

2325
	if ((alg_a & SSL_aDSS) &&
2326 2327
		(c->pkeys[SSL_PKEY_DSA_SIGN].privatekey != NULL))
		return(c->pkeys[SSL_PKEY_DSA_SIGN].privatekey);
2328
	else if (alg_a & SSL_aRSA)
2329 2330 2331 2332 2333 2334 2335 2336
		{
		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);
		}
2337
	else if ((alg_a & SSL_aECDSA) &&
B
Bodo Möller 已提交
2338 2339
	         (c->pkeys[SSL_PKEY_ECC].privatekey != NULL))
		return(c->pkeys[SSL_PKEY_ECC].privatekey);
2340
	else /* if (alg_a & SSL_aNULL) */
2341
		{
B
Bodo Möller 已提交
2342
		SSLerr(SSL_F_SSL_GET_SIGN_PKEY,ERR_R_INTERNAL_ERROR);
2343 2344 2345 2346
		return(NULL);
		}
	}

2347
void ssl_update_cache(SSL *s,int mode)
2348
	{
2349 2350 2351 2352 2353 2354
	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 已提交
2355
	i=s->session_ctx->session_cache_mode;
L
Lutz Jänicke 已提交
2356
	if ((i & mode) && (!s->hit)
2357
		&& ((i & SSL_SESS_CACHE_NO_INTERNAL_STORE)
B
Bodo Möller 已提交
2358 2359
		    || SSL_CTX_add_session(s->session_ctx,s->session))
		&& (s->session_ctx->new_session_cb != NULL))
2360
		{
2361
		CRYPTO_add(&s->session->references,1,CRYPTO_LOCK_SSL_SESSION);
B
Bodo Möller 已提交
2362
		if (!s->session_ctx->new_session_cb(s,s->session))
2363 2364 2365 2366
			SSL_SESSION_free(s->session);
		}

	/* auto flush every 255 connections */
2367 2368 2369 2370
	if ((!(i & SSL_SESS_CACHE_NO_AUTO_CLEAR)) &&
		((i & mode) == mode))
		{
		if (  (((mode & SSL_SESS_CACHE_CLIENT)
B
Bodo Möller 已提交
2371 2372
			?s->session_ctx->stats.sess_connect_good
			:s->session_ctx->stats.sess_accept_good) & 0xff) == 0xff)
2373
			{
B
Bodo Möller 已提交
2374
			SSL_CTX_flush_sessions(s->session_ctx,(unsigned long)time(NULL));
2375 2376
			}
		}
2377 2378
	}

2379
const SSL_METHOD *SSL_get_ssl_method(SSL *s)
2380 2381 2382 2383
	{
	return(s->method);
	}

2384
int SSL_set_ssl_method(SSL *s, const SSL_METHOD *meth)
2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410
	{
	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 已提交
2411
int SSL_get_error(const SSL *s,int i)
2412 2413
	{
	int reason;
2414
	unsigned long l;
2415 2416 2417 2418
	BIO *bio;

	if (i > 0) return(SSL_ERROR_NONE);

2419 2420 2421 2422 2423 2424 2425 2426 2427
	/* 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);
		}
2428 2429 2430 2431 2432 2433 2434

	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 已提交
2435 2436 2437 2438 2439 2440 2441 2442 2443
			/* 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. */
2444 2445 2446 2447 2448 2449
			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);
2450 2451
			else if (reason == BIO_RR_ACCEPT)
				return(SSL_ERROR_WANT_ACCEPT);
2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462
			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 已提交
2463
			/* See above (SSL_want_read(s) with BIO_should_write(bio)) */
2464 2465 2466 2467 2468 2469
			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);
2470 2471
			else if (reason == BIO_RR_ACCEPT)
				return(SSL_ERROR_WANT_ACCEPT);
2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482
			else
				return(SSL_ERROR_SYSCALL);
			}
		}
	if ((i < 0) && SSL_want_x509_lookup(s))
		{
		return(SSL_ERROR_WANT_X509_LOOKUP);
		}

	if (i == 0)
		{
2483
		if (s->version == SSL2_VERSION)
2484 2485 2486 2487 2488 2489 2490
			{
			/* assume it is the socket being closed */
			return(SSL_ERROR_ZERO_RETURN);
			}
		else
			{
			if ((s->shutdown & SSL_RECEIVED_SHUTDOWN) &&
2491
				(s->s3->warn_alert == SSL_AD_CLOSE_NOTIFY))
2492 2493 2494 2495 2496 2497
				return(SSL_ERROR_ZERO_RETURN);
			}
		}
	return(SSL_ERROR_SYSCALL);
	}

2498
int SSL_do_handshake(SSL *s)
2499
	{
2500 2501
	int ret=1;

2502 2503
	if (s->handshake_func == NULL)
		{
2504
		SSLerr(SSL_F_SSL_DO_HANDSHAKE,SSL_R_CONNECTION_TYPE_NOT_SET);
2505 2506
		return(-1);
		}
2507 2508 2509

	s->method->ssl_renegotiate_check(s);

2510
	if (SSL_in_init(s) || SSL_in_before(s))
2511 2512 2513 2514
		{
		ret=s->handshake_func(s);
		}
	return(ret);
2515 2516 2517 2518
	}

/* For the next 2 functions, SSL_clear() sets shutdown and so
 * one of these calls will reset it */
2519
void SSL_set_accept_state(SSL *s)
2520
	{
2521
	s->server=1;
2522 2523 2524 2525 2526
	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);
2527 2528
	ssl_clear_hash_ctx(&s->read_hash);
	ssl_clear_hash_ctx(&s->write_hash);
2529 2530
	}

2531
void SSL_set_connect_state(SSL *s)
2532
	{
2533
	s->server=0;
2534 2535 2536 2537 2538
	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);
2539 2540
	ssl_clear_hash_ctx(&s->read_hash);
	ssl_clear_hash_ctx(&s->write_hash);
2541 2542
	}

2543
int ssl_undefined_function(SSL *s)
2544 2545 2546 2547 2548
	{
	SSLerr(SSL_F_SSL_UNDEFINED_FUNCTION,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	return(0);
	}

2549 2550 2551 2552 2553 2554
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 已提交
2555 2556 2557 2558 2559 2560
int ssl_undefined_const_function(const SSL *s)
	{
	SSLerr(SSL_F_SSL_UNDEFINED_CONST_FUNCTION,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	return(0);
	}

2561
SSL_METHOD *ssl_bad_method(int ver)
2562 2563 2564 2565 2566
	{
	SSLerr(SSL_F_SSL_BAD_METHOD,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
	return(NULL);
	}

B
Ben Laurie 已提交
2567
const char *SSL_get_version(const SSL *s)
2568
	{
2569 2570
	if (s->version == TLS1_1_VERSION)
		return("TLSv1.1");
D
Dr. Stephen Henson 已提交
2571 2572
	else if (s->version == TLS1_VERSION)
		return("TLSv1");
2573 2574
	else if (s->version == SSL3_VERSION)
		return("SSLv3");
2575
	else if (s->version == SSL2_VERSION)
2576 2577 2578 2579 2580
		return("SSLv2");
	else
		return("unknown");
	}

2581
SSL *SSL_dup(SSL *s)
2582
	{
B
Ben Laurie 已提交
2583
	STACK_OF(X509_NAME) *sk;
2584
	X509_NAME *xn;
2585
	SSL *ret;
2586
	int i;
2587
	
B
Ben Laurie 已提交
2588 2589
	if ((ret=SSL_new(SSL_get_SSL_CTX(s))) == NULL)
	    return(NULL);
2590 2591 2592 2593 2594

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

2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606
	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 已提交
2607
		ret->method->ssl_free(ret);
2608 2609 2610 2611 2612
		ret->method = s->method;
		ret->method->ssl_new(ret);

		if (s->cert != NULL)
			{
2613 2614 2615 2616
			if (ret->cert != NULL)
				{
				ssl_cert_free(ret->cert);
				}
2617 2618 2619 2620 2621 2622 2623 2624
			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);
		}
2625

2626 2627
	ret->options=s->options;
	ret->mode=s->mode;
2628
	SSL_set_max_cert_list(ret,SSL_get_max_cert_list(s));
2629
	SSL_set_read_ahead(ret,SSL_get_read_ahead(s));
2630 2631
	ret->msg_callback = s->msg_callback;
	ret->msg_callback_arg = s->msg_callback_arg;
2632 2633
	SSL_set_verify(ret,SSL_get_verify_mode(s),
		SSL_get_verify_callback(s));
2634
	SSL_set_verify_depth(ret,SSL_get_verify_depth(s));
2635
	ret->generate_session_id = s->generate_session_id;
2636 2637 2638 2639 2640 2641

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

	/* copy app data, a little dangerous perhaps */
2642
	if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_SSL, &ret->ex_data, &s->ex_data))
2643
		goto err;
2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654

	/* 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)
			{
2655
			if (!BIO_dup_state(s->wbio,(char *)&ret->wbio))
2656 2657 2658 2659 2660
				goto err;
			}
		else
			ret->wbio=ret->rbio;
		}
2661 2662 2663 2664
	ret->rwstate = s->rwstate;
	ret->in_handshake = s->in_handshake;
	ret->handshake_func = s->handshake_func;
	ret->server = s->server;
D
Dr. Stephen Henson 已提交
2665
	ret->renegotiate = s->renegotiate;
2666 2667 2668 2669 2670 2671 2672
	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;
2673 2674

	X509_VERIFY_PARAM_inherit(ret->param, s->param);
2675 2676 2677 2678

	/* dup the cipher_list and cipher_list_by_id stacks */
	if (s->cipher_list != NULL)
		{
B
Ben Laurie 已提交
2679
		if ((ret->cipher_list=sk_SSL_CIPHER_dup(s->cipher_list)) == NULL)
2680 2681 2682
			goto err;
		}
	if (s->cipher_list_by_id != NULL)
B
Ben Laurie 已提交
2683
		if ((ret->cipher_list_by_id=sk_SSL_CIPHER_dup(s->cipher_list_by_id))
2684 2685 2686 2687 2688 2689
			== NULL)
			goto err;

	/* Dup the client_CA list */
	if (s->client_CA != NULL)
		{
B
Ben Laurie 已提交
2690
		if ((sk=sk_X509_NAME_dup(s->client_CA)) == NULL) goto err;
2691
		ret->client_CA=sk;
B
Ben Laurie 已提交
2692
		for (i=0; i<sk_X509_NAME_num(sk); i++)
2693
			{
B
Ben Laurie 已提交
2694 2695
			xn=sk_X509_NAME_value(sk,i);
			if (sk_X509_NAME_set(sk,i,X509_NAME_dup(xn)) == NULL)
2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711
				{
				X509_NAME_free(xn);
				goto err;
				}
			}
		}

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

2712
void ssl_clear_cipher_ctx(SSL *s)
2713
	{
2714 2715 2716
	if (s->enc_read_ctx != NULL)
		{
		EVP_CIPHER_CTX_cleanup(s->enc_read_ctx);
2717
		OPENSSL_free(s->enc_read_ctx);
2718 2719 2720 2721 2722
		s->enc_read_ctx=NULL;
		}
	if (s->enc_write_ctx != NULL)
		{
		EVP_CIPHER_CTX_cleanup(s->enc_write_ctx);
2723
		OPENSSL_free(s->enc_write_ctx);
2724 2725
		s->enc_write_ctx=NULL;
		}
2726
#ifndef OPENSSL_NO_COMP
2727 2728 2729 2730 2731 2732 2733 2734 2735 2736
	if (s->expand != NULL)
		{
		COMP_CTX_free(s->expand);
		s->expand=NULL;
		}
	if (s->compress != NULL)
		{
		COMP_CTX_free(s->compress);
		s->compress=NULL;
		}
2737
#endif
2738 2739
	}

2740
/* Fix this function so that it takes an optional type parameter */
B
Ben Laurie 已提交
2741
X509 *SSL_get_certificate(const SSL *s)
2742 2743 2744 2745 2746 2747 2748
	{
	if (s->cert != NULL)
		return(s->cert->key->x509);
	else
		return(NULL);
	}

2749
/* Fix this function so that it takes an optional type parameter */
2750
EVP_PKEY *SSL_get_privatekey(SSL *s)
2751 2752 2753 2754 2755 2756 2757
	{
	if (s->cert != NULL)
		return(s->cert->key->privatekey);
	else
		return(NULL);
	}

2758
const SSL_CIPHER *SSL_get_current_cipher(const SSL *s)
2759
	{
2760 2761 2762
	if ((s->session != NULL) && (s->session->cipher != NULL))
		return(s->session->cipher);
	return(NULL);
2763
	}
2764 2765 2766 2767 2768 2769 2770 2771 2772 2773
#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
2774

2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787
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);
	}
2788
#endif
2789

2790
int ssl_init_wbio_buffer(SSL *s,int push)
2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805
	{
	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 已提交
2806
	(void)BIO_reset(bbio);
2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824
/*	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);
	}
2825

2826
void ssl_free_wbio_buffer(SSL *s)
2827 2828 2829 2830 2831 2832
	{
	if (s->bbio == NULL) return;

	if (s->bbio == s->wbio)
		{
		/* remove buffering */
2833 2834 2835
		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);
2836
#endif
2837
	}
2838 2839 2840
	BIO_free(s->bbio);
	s->bbio=NULL;
	}
2841
	
2842
void SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx,int mode)
2843 2844 2845 2846
	{
	ctx->quiet_shutdown=mode;
	}

B
Ben Laurie 已提交
2847
int SSL_CTX_get_quiet_shutdown(const SSL_CTX *ctx)
2848 2849 2850 2851
	{
	return(ctx->quiet_shutdown);
	}

2852
void SSL_set_quiet_shutdown(SSL *s,int mode)
2853 2854 2855 2856
	{
	s->quiet_shutdown=mode;
	}

B
Ben Laurie 已提交
2857
int SSL_get_quiet_shutdown(const SSL *s)
2858 2859 2860 2861
	{
	return(s->quiet_shutdown);
	}

2862
void SSL_set_shutdown(SSL *s,int mode)
2863 2864 2865 2866
	{
	s->shutdown=mode;
	}

B
Ben Laurie 已提交
2867
int SSL_get_shutdown(const SSL *s)
2868 2869 2870 2871
	{
	return(s->shutdown);
	}

B
Ben Laurie 已提交
2872
int SSL_version(const SSL *s)
2873 2874 2875 2876
	{
	return(s->version);
	}

B
Ben Laurie 已提交
2877
SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl)
2878 2879 2880 2881
	{
	return(ssl->ctx);
	}

2882 2883
SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX* ctx)
	{
2884
	if (ssl->ctx == ctx)
B
Bodo Möller 已提交
2885
		return ssl->ctx;
2886
#ifndef OPENSSL_NO_TLSEXT
B
Bodo Möller 已提交
2887 2888
	if (ctx == NULL)
		ctx = ssl->initial_ctx;
2889
#endif
2890 2891 2892 2893 2894 2895 2896 2897 2898 2899
	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);
	}

2900
#ifndef OPENSSL_NO_STDIO
2901
int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx)
2902 2903 2904 2905
	{
	return(X509_STORE_set_default_paths(ctx->cert_store));
	}

2906 2907
int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,
		const char *CApath)
2908 2909 2910
	{
	return(X509_STORE_load_locations(ctx->cert_store,CAfile,CApath));
	}
2911
#endif
2912

B
Ben Laurie 已提交
2913
void SSL_set_info_callback(SSL *ssl,
N
Nils Larsch 已提交
2914
	void (*cb)(const SSL *ssl,int type,int val))
2915 2916 2917 2918
	{
	ssl->info_callback=cb;
	}

2919 2920
/* One compiler (Diab DCC) doesn't like argument names in returned
   function pointer.  */
2921
void (*SSL_get_info_callback(const SSL *ssl))(const SSL * /*ssl*/,int /*type*/,int /*val*/)
2922
	{
B
Ben Laurie 已提交
2923
	return ssl->info_callback;
2924 2925
	}

B
Ben Laurie 已提交
2926
int SSL_state(const SSL *ssl)
2927 2928 2929 2930
	{
	return(ssl->state);
	}

2931
void SSL_set_verify_result(SSL *ssl,long arg)
2932 2933 2934 2935
	{
	ssl->verify_result=arg;
	}

B
Ben Laurie 已提交
2936
long SSL_get_verify_result(const SSL *ssl)
2937 2938 2939 2940
	{
	return(ssl->verify_result);
	}

D
 
Dr. Stephen Henson 已提交
2941 2942
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)
2943
	{
2944 2945
	return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL, argl, argp,
				new_func, dup_func, free_func);
2946
	}
2947

2948
int SSL_set_ex_data(SSL *s,int idx,void *arg)
2949 2950 2951 2952
	{
	return(CRYPTO_set_ex_data(&s->ex_data,idx,arg));
	}

B
Ben Laurie 已提交
2953
void *SSL_get_ex_data(const SSL *s,int idx)
2954 2955 2956 2957
	{
	return(CRYPTO_get_ex_data(&s->ex_data,idx));
	}

D
 
Dr. Stephen Henson 已提交
2958 2959
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)
2960
	{
2961 2962
	return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL_CTX, argl, argp,
				new_func, dup_func, free_func);
2963
	}
2964

2965
int SSL_CTX_set_ex_data(SSL_CTX *s,int idx,void *arg)
2966 2967 2968 2969
	{
	return(CRYPTO_set_ex_data(&s->ex_data,idx,arg));
	}

B
Ben Laurie 已提交
2970
void *SSL_CTX_get_ex_data(const SSL_CTX *s,int idx)
2971 2972 2973 2974
	{
	return(CRYPTO_get_ex_data(&s->ex_data,idx));
	}

2975
int ssl_ok(SSL *s)
2976 2977 2978 2979
	{
	return(1);
	}

B
Ben Laurie 已提交
2980
X509_STORE *SSL_CTX_get_cert_store(const SSL_CTX *ctx)
2981 2982 2983 2984
	{
	return(ctx->cert_store);
	}

2985
void SSL_CTX_set_cert_store(SSL_CTX *ctx,X509_STORE *store)
2986 2987 2988 2989 2990 2991
	{
	if (ctx->cert_store != NULL)
		X509_STORE_free(ctx->cert_store);
	ctx->cert_store=store;
	}

B
Ben Laurie 已提交
2992
int SSL_want(const SSL *s)
2993 2994 2995 2996
	{
	return(s->rwstate);
	}

2997 2998 2999 3000 3001 3002
/*!
 * \brief Set the callback for generating temporary RSA keys.
 * \param ctx the SSL context.
 * \param cb the callback
 */

3003
#ifndef OPENSSL_NO_RSA
U
Ulf Möller 已提交
3004 3005
void SSL_CTX_set_tmp_rsa_callback(SSL_CTX *ctx,RSA *(*cb)(SSL *ssl,
							  int is_export,
3006
							  int keylength))
3007
    {
3008
    SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TMP_RSA_CB,(void (*)(void))cb);
3009
    }
3010

3011 3012 3013
void SSL_set_tmp_rsa_callback(SSL *ssl,RSA *(*cb)(SSL *ssl,
						  int is_export,
						  int keylength))
3014
    {
3015
    SSL_callback_ctrl(ssl,SSL_CTRL_SET_TMP_RSA_CB,(void (*)(void))cb);
3016
    }
3017
#endif
3018

3019 3020 3021 3022
#ifdef DOXYGEN
/*!
 * \brief The RSA temporary key callback function.
 * \param ssl the SSL session.
U
Ulf Möller 已提交
3023 3024 3025
 * \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.
3026 3027 3028 3029
 * \return the temporary RSA key.
 * \sa SSL_CTX_set_tmp_rsa_callback, SSL_set_tmp_rsa_callback
 */

U
Ulf Möller 已提交
3030
RSA *cb(SSL *ssl,int is_export,int keylength)
3031 3032 3033 3034 3035 3036 3037 3038 3039
    {}
#endif

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

3040
#ifndef OPENSSL_NO_DH
U
Ulf Möller 已提交
3041
void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,DH *(*dh)(SSL *ssl,int is_export,
3042
                                                        int keylength))
3043
	{
3044
	SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TMP_DH_CB,(void (*)(void))dh);
3045
	}
3046

U
Ulf Möller 已提交
3047
void SSL_set_tmp_dh_callback(SSL *ssl,DH *(*dh)(SSL *ssl,int is_export,
3048
                                                int keylength))
3049
	{
3050
	SSL_callback_ctrl(ssl,SSL_CTRL_SET_TMP_DH_CB,(void (*)(void))dh);
3051
	}
3052
#endif
3053

B
Bodo Möller 已提交
3054 3055
#ifndef OPENSSL_NO_ECDH
void SSL_CTX_set_tmp_ecdh_callback(SSL_CTX *ctx,EC_KEY *(*ecdh)(SSL *ssl,int is_export,
3056
                                                                int keylength))
B
Bodo Möller 已提交
3057
	{
3058
	SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TMP_ECDH_CB,(void (*)(void))ecdh);
B
Bodo Möller 已提交
3059 3060 3061
	}

void SSL_set_tmp_ecdh_callback(SSL *ssl,EC_KEY *(*ecdh)(SSL *ssl,int is_export,
3062
                                                        int keylength))
B
Bodo Möller 已提交
3063
	{
3064
	SSL_callback_ctrl(ssl,SSL_CTRL_SET_TMP_ECDH_CB,(void (*)(void))ecdh);
B
Bodo Möller 已提交
3065 3066 3067
	}
#endif

3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127
#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 已提交
3128

3129 3130 3131 3132
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 已提交
3133
	{
3134
	s->psk_client_callback = cb;
N
Nils Larsch 已提交
3135 3136 3137
	}

void SSL_CTX_set_psk_client_callback(SSL_CTX *ctx,
3138 3139 3140
    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 已提交
3141
	{
3142
	ctx->psk_client_callback = cb;
N
Nils Larsch 已提交
3143 3144
	}

3145 3146 3147
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 已提交
3148
	{
3149
	s->psk_server_callback = cb;
N
Nils Larsch 已提交
3150 3151 3152
	}

void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx,
3153 3154
    unsigned int (*cb)(SSL *ssl, const char *identity,
                       unsigned char *psk, unsigned int max_psk_len))
N
Nils Larsch 已提交
3155
	{
3156
	ctx->psk_server_callback = cb;
N
Nils Larsch 已提交
3157
	}
3158
#endif
3159 3160 3161

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))
	{
3162
	SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
3163 3164 3165
	}
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))
	{
3166
	SSL_callback_ctrl(ssl, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
3167 3168
	}

3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181
void SSL_CTX_set_not_resumable_session_callback(SSL_CTX *ctx,
	int (*cb)(SSL *ssl, int is_forward_secure))
	{
	SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB,
		(void (*)(void))cb);
	}
void SSL_set_not_resumable_session_callback(SSL *ssl,
	int (*cb)(SSL *ssl, int is_forward_secure))
	{
	SSL_callback_ctrl(ssl, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB,
		(void (*)(void))cb);
	}

3182 3183 3184 3185
/* 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 已提交
3186
 */
3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200

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;
}
3201

3202
#if defined(_WINDLL) && defined(OPENSSL_SYS_WIN16)
3203 3204
#include "../crypto/bio/bss_file.c"
#endif
B
Ben Laurie 已提交
3205 3206 3207

IMPLEMENT_STACK_OF(SSL_CIPHER)
IMPLEMENT_STACK_OF(SSL_COMP)
D
Dr. Stephen Henson 已提交
3208 3209 3210
IMPLEMENT_OBJ_BSEARCH_GLOBAL_CMP_FN(SSL_CIPHER, SSL_CIPHER,
				    ssl_cipher_id);