2015-01-22 11:40:55 +08:00
|
|
|
/*
|
|
|
|
* ! \file ssl/ssl_lib.c \brief Version independent SSL functions.
|
1999-02-28 20:41:50 +08:00
|
|
|
*/
|
1998-12-21 18:56:39 +08:00
|
|
|
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
1998-12-21 18:52:47 +08:00
|
|
|
* 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.
|
2015-01-22 11:40:55 +08:00
|
|
|
*
|
1998-12-21 18:52:47 +08:00
|
|
|
* 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).
|
2015-01-22 11:40:55 +08:00
|
|
|
*
|
1998-12-21 18:52:47 +08:00
|
|
|
* 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.
|
2015-01-22 11:40:55 +08:00
|
|
|
*
|
1998-12-21 18:52:47 +08:00
|
|
|
* 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 :-).
|
2015-01-22 11:40:55 +08:00
|
|
|
* 4. If you include any Windows specific code (or a derivative thereof) from
|
1998-12-21 18:52:47 +08:00
|
|
|
* the apps directory (application code) you must include an acknowledgement:
|
|
|
|
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
|
2015-01-22 11:40:55 +08:00
|
|
|
*
|
1998-12-21 18:52:47 +08:00
|
|
|
* 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.
|
2015-01-22 11:40:55 +08:00
|
|
|
*
|
1998-12-21 18:52:47 +08:00
|
|
|
* 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.]
|
|
|
|
*/
|
2001-10-16 21:09:24 +08:00
|
|
|
/* ====================================================================
|
2007-02-17 14:45:38 +08:00
|
|
|
* Copyright (c) 1998-2007 The OpenSSL Project. All rights reserved.
|
2001-10-16 21:09:24 +08:00
|
|
|
*
|
|
|
|
* 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
|
2015-01-22 11:40:55 +08:00
|
|
|
* notice, this list of conditions and the following disclaimer.
|
2001-10-16 21:09:24 +08:00
|
|
|
*
|
|
|
|
* 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).
|
|
|
|
*
|
|
|
|
*/
|
2002-08-09 16:56:08 +08:00
|
|
|
/* ====================================================================
|
|
|
|
* Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
|
2015-01-22 11:40:55 +08:00
|
|
|
* ECC cipher suite support in OpenSSL originally developed by
|
2002-08-09 16:56:08 +08:00
|
|
|
* SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
|
|
|
|
*/
|
2006-03-11 07:06:27 +08:00
|
|
|
/* ====================================================================
|
|
|
|
* 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.
|
|
|
|
*/
|
2000-09-04 23:34:43 +08:00
|
|
|
|
2001-04-08 21:47:51 +08:00
|
|
|
#ifdef REF_CHECK
|
2015-01-22 11:40:55 +08:00
|
|
|
# include <assert.h>
|
2001-04-08 21:47:51 +08:00
|
|
|
#endif
|
1998-12-21 18:52:47 +08:00
|
|
|
#include <stdio.h>
|
2002-07-10 15:01:54 +08:00
|
|
|
#include "ssl_locl.h"
|
1999-04-24 06:13:45 +08:00
|
|
|
#include <openssl/objects.h>
|
|
|
|
#include <openssl/lhash.h>
|
1999-11-30 06:35:00 +08:00
|
|
|
#include <openssl/x509v3.h>
|
2007-08-12 07:18:29 +08:00
|
|
|
#include <openssl/rand.h>
|
2007-09-27 05:56:59 +08:00
|
|
|
#include <openssl/ocsp.h>
|
2005-07-16 20:37:36 +08:00
|
|
|
#ifndef OPENSSL_NO_DH
|
2015-01-22 11:40:55 +08:00
|
|
|
# include <openssl/dh.h>
|
2005-07-16 20:37:36 +08:00
|
|
|
#endif
|
2008-06-02 07:06:48 +08:00
|
|
|
#ifndef OPENSSL_NO_ENGINE
|
2015-01-22 11:40:55 +08:00
|
|
|
# include <openssl/engine.h>
|
|
|
|
#endif
|
2015-02-14 07:28:49 +08:00
|
|
|
#include <openssl/async.h>
|
2015-01-22 11:40:55 +08:00
|
|
|
|
2015-09-05 20:32:58 +08:00
|
|
|
const char SSL_version_str[] = OPENSSL_VERSION_TEXT;
|
2015-01-22 11:40:55 +08:00
|
|
|
|
|
|
|
SSL3_ENC_METHOD ssl3_undef_enc_method = {
|
|
|
|
/*
|
|
|
|
* evil casts, but these functions are only called if there's a library
|
|
|
|
* bug
|
|
|
|
*/
|
|
|
|
(int (*)(SSL *, int))ssl_undefined_function,
|
|
|
|
(int (*)(SSL *, unsigned char *, int))ssl_undefined_function,
|
|
|
|
ssl_undefined_function,
|
|
|
|
(int (*)(SSL *, unsigned char *, unsigned char *, int))
|
|
|
|
ssl_undefined_function,
|
|
|
|
(int (*)(SSL *, int))ssl_undefined_function,
|
|
|
|
(int (*)(SSL *, const char *, int, unsigned char *))
|
|
|
|
ssl_undefined_function,
|
|
|
|
0, /* finish_mac_length */
|
|
|
|
NULL, /* client_finished_label */
|
|
|
|
0, /* client_finished_label_len */
|
|
|
|
NULL, /* server_finished_label */
|
|
|
|
0, /* server_finished_label_len */
|
|
|
|
(int (*)(int))ssl_undefined_function,
|
|
|
|
(int (*)(SSL *, unsigned char *, size_t, const char *,
|
|
|
|
size_t, const unsigned char *, size_t,
|
|
|
|
int use_context))ssl_undefined_function,
|
|
|
|
};
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-02-14 07:28:49 +08:00
|
|
|
struct ssl_async_args {
|
|
|
|
SSL *s;
|
|
|
|
void *buf;
|
|
|
|
int num;
|
2015-10-06 22:57:50 +08:00
|
|
|
int type;
|
|
|
|
union {
|
|
|
|
int (*func1)(SSL *, void *, int);
|
|
|
|
int (*func2)(SSL *, const void *, int);
|
|
|
|
} f;
|
2015-02-14 07:28:49 +08:00
|
|
|
};
|
|
|
|
|
2015-06-13 22:50:00 +08:00
|
|
|
static void clear_ciphers(SSL *s)
|
|
|
|
{
|
|
|
|
/* clear the current cipher */
|
|
|
|
ssl_clear_cipher_ctx(s);
|
|
|
|
ssl_clear_hash_ctx(&s->read_hash);
|
|
|
|
ssl_clear_hash_ctx(&s->write_hash);
|
|
|
|
}
|
|
|
|
|
1999-02-28 20:41:50 +08:00
|
|
|
int SSL_clear(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
if (s->method == NULL) {
|
|
|
|
SSLerr(SSL_F_SSL_CLEAR, SSL_R_NO_METHOD_SPECIFIED);
|
|
|
|
return (0);
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
if (ssl_clear_bad_session(s)) {
|
|
|
|
SSL_SESSION_free(s->session);
|
|
|
|
s->session = NULL;
|
|
|
|
}
|
2002-02-27 19:23:05 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
s->error = 0;
|
|
|
|
s->hit = 0;
|
|
|
|
s->shutdown = 0;
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
if (s->renegotiate) {
|
|
|
|
SSLerr(SSL_F_SSL_CLEAR, ERR_R_INTERNAL_ERROR);
|
|
|
|
return 0;
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-10-05 17:39:54 +08:00
|
|
|
ossl_statem_clear(s);
|
Updates to the new SSL compression code
[Eric A. Young, (from changes to C2Net SSLeay, integrated by Mark Cox)]
Fix so that the version number in the master secret, when passed
via RSA, checks that if TLS was proposed, but we roll back to SSLv3
(because the server will not accept higher), that the version number
is 0x03,0x01, not 0x03,0x00
[Eric A. Young, (from changes to C2Net SSLeay, integrated by Mark Cox)]
Submitted by:
Reviewed by:
PR:
1999-02-16 17:22:21 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
s->version = s->method->version;
|
|
|
|
s->client_version = s->version;
|
|
|
|
s->rwstate = SSL_NOTHING;
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-05-02 02:37:16 +08:00
|
|
|
BUF_MEM_free(s->init_buf);
|
|
|
|
s->init_buf = NULL;
|
2015-06-13 22:50:00 +08:00
|
|
|
clear_ciphers(s);
|
2015-01-22 11:40:55 +08:00
|
|
|
s->first_packet = 0;
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
/*
|
|
|
|
* Check to see if we were changed into a different method, if so, revert
|
|
|
|
* back if we are not doing session-id reuse.
|
|
|
|
*/
|
2015-10-22 20:57:18 +08:00
|
|
|
if (!ossl_statem_get_in_handshake(s) && (s->session == NULL)
|
2015-01-22 11:40:55 +08:00
|
|
|
&& (s->method != s->ctx->method)) {
|
|
|
|
s->method->ssl_free(s);
|
|
|
|
s->method = s->ctx->method;
|
|
|
|
if (!s->method->ssl_new(s))
|
|
|
|
return (0);
|
|
|
|
} else
|
|
|
|
s->method->ssl_clear(s);
|
2015-01-30 23:38:10 +08:00
|
|
|
|
2015-02-02 19:53:20 +08:00
|
|
|
RECORD_LAYER_clear(&s->rlayer);
|
2015-01-30 23:38:10 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
return (1);
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
1999-02-28 20:41:50 +08:00
|
|
|
/** Used to change an SSL_CTXs default SSL method type */
|
2015-01-22 11:40:55 +08:00
|
|
|
int SSL_CTX_set_ssl_version(SSL_CTX *ctx, const SSL_METHOD *meth)
|
|
|
|
{
|
|
|
|
STACK_OF(SSL_CIPHER) *sk;
|
|
|
|
|
|
|
|
ctx->method = meth;
|
|
|
|
|
|
|
|
sk = ssl_create_cipher_list(ctx->method, &(ctx->cipher_list),
|
|
|
|
&(ctx->cipher_list_by_id),
|
|
|
|
SSL_DEFAULT_CIPHER_LIST, ctx->cert);
|
|
|
|
if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= 0)) {
|
|
|
|
SSLerr(SSL_F_SSL_CTX_SET_SSL_VERSION,
|
|
|
|
SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
return (1);
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
1999-02-28 20:41:50 +08:00
|
|
|
SSL *SSL_new(SSL_CTX *ctx)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2015-08-26 01:25:58 +08:00
|
|
|
s = OPENSSL_zalloc(sizeof(*s));
|
2015-01-22 11:40:55 +08:00
|
|
|
if (s == NULL)
|
|
|
|
goto err;
|
|
|
|
|
2015-02-02 21:57:12 +08:00
|
|
|
RECORD_LAYER_init(&s->rlayer, s);
|
2015-01-30 22:57:54 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
s->options = ctx->options;
|
|
|
|
s->mode = ctx->mode;
|
|
|
|
s->max_cert_list = ctx->max_cert_list;
|
2015-09-17 10:25:31 +08:00
|
|
|
s->references = 1;
|
2015-01-22 11:40:55 +08:00
|
|
|
|
2015-03-15 01:09:44 +08:00
|
|
|
/*
|
|
|
|
* 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;
|
2015-01-22 11:40:55 +08:00
|
|
|
|
2015-01-30 21:46:43 +08:00
|
|
|
RECORD_LAYER_set_read_ahead(&s->rlayer, ctx->read_ahead);
|
2015-01-22 11:40:55 +08:00
|
|
|
s->msg_callback = ctx->msg_callback;
|
|
|
|
s->msg_callback_arg = ctx->msg_callback_arg;
|
|
|
|
s->verify_mode = ctx->verify_mode;
|
|
|
|
s->not_resumable_session_cb = ctx->not_resumable_session_cb;
|
|
|
|
s->sid_ctx_length = ctx->sid_ctx_length;
|
|
|
|
OPENSSL_assert(s->sid_ctx_length <= sizeof s->sid_ctx);
|
|
|
|
memcpy(&s->sid_ctx, &ctx->sid_ctx, sizeof(s->sid_ctx));
|
|
|
|
s->verify_callback = ctx->default_verify_callback;
|
|
|
|
s->generate_session_id = ctx->generate_session_id;
|
|
|
|
|
|
|
|
s->param = X509_VERIFY_PARAM_new();
|
2015-10-30 18:05:53 +08:00
|
|
|
if (s->param == NULL)
|
2015-01-22 11:40:55 +08:00
|
|
|
goto err;
|
|
|
|
X509_VERIFY_PARAM_inherit(s->param, ctx->param);
|
|
|
|
s->quiet_shutdown = ctx->quiet_shutdown;
|
|
|
|
s->max_send_fragment = ctx->max_send_fragment;
|
2001-10-16 21:09:24 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
CRYPTO_add(&ctx->references, 1, CRYPTO_LOCK_SSL_CTX);
|
|
|
|
s->ctx = ctx;
|
|
|
|
s->tlsext_debug_cb = 0;
|
|
|
|
s->tlsext_debug_arg = NULL;
|
|
|
|
s->tlsext_ticket_expected = 0;
|
|
|
|
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;
|
|
|
|
CRYPTO_add(&ctx->references, 1, CRYPTO_LOCK_SSL_CTX);
|
|
|
|
s->initial_ctx = ctx;
|
|
|
|
# ifndef OPENSSL_NO_EC
|
|
|
|
if (ctx->tlsext_ecpointformatlist) {
|
|
|
|
s->tlsext_ecpointformatlist =
|
|
|
|
BUF_memdup(ctx->tlsext_ecpointformatlist,
|
|
|
|
ctx->tlsext_ecpointformatlist_length);
|
|
|
|
if (!s->tlsext_ecpointformatlist)
|
|
|
|
goto err;
|
|
|
|
s->tlsext_ecpointformatlist_length =
|
|
|
|
ctx->tlsext_ecpointformatlist_length;
|
|
|
|
}
|
|
|
|
if (ctx->tlsext_ellipticcurvelist) {
|
|
|
|
s->tlsext_ellipticcurvelist =
|
|
|
|
BUF_memdup(ctx->tlsext_ellipticcurvelist,
|
|
|
|
ctx->tlsext_ellipticcurvelist_length);
|
|
|
|
if (!s->tlsext_ellipticcurvelist)
|
|
|
|
goto err;
|
|
|
|
s->tlsext_ellipticcurvelist_length =
|
|
|
|
ctx->tlsext_ellipticcurvelist_length;
|
|
|
|
}
|
|
|
|
# endif
|
2010-09-06 01:14:01 +08:00
|
|
|
# ifndef OPENSSL_NO_NEXTPROTONEG
|
2015-01-22 11:40:55 +08:00
|
|
|
s->next_proto_negotiated = NULL;
|
2010-07-28 18:06:55 +08:00
|
|
|
# endif
|
2013-04-16 06:07:47 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
if (s->ctx->alpn_client_proto_list) {
|
|
|
|
s->alpn_client_proto_list =
|
|
|
|
OPENSSL_malloc(s->ctx->alpn_client_proto_list_len);
|
|
|
|
if (s->alpn_client_proto_list == NULL)
|
|
|
|
goto err;
|
|
|
|
memcpy(s->alpn_client_proto_list, s->ctx->alpn_client_proto_list,
|
|
|
|
s->ctx->alpn_client_proto_list_len);
|
|
|
|
s->alpn_client_proto_list_len = s->ctx->alpn_client_proto_list_len;
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
s->verify_result = X509_V_OK;
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-11-09 22:38:59 +08:00
|
|
|
s->default_passwd_callback = ctx->default_passwd_callback;
|
|
|
|
s->default_passwd_callback_userdata = ctx->default_passwd_callback_userdata;
|
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
s->method = ctx->method;
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
if (!s->method->ssl_new(s))
|
|
|
|
goto err;
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
s->server = (ctx->method->ssl_accept == ssl_undefined_function) ? 0 : 1;
|
2001-10-16 21:09:24 +08:00
|
|
|
|
2015-04-16 13:50:03 +08:00
|
|
|
if (!SSL_clear(s))
|
2015-03-06 22:37:17 +08:00
|
|
|
goto err;
|
1998-12-21 18:56:39 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
|
1998-12-21 18:56:39 +08:00
|
|
|
|
2006-03-11 07:06:27 +08:00
|
|
|
#ifndef OPENSSL_NO_PSK
|
2015-01-22 11:40:55 +08:00
|
|
|
s->psk_client_callback = ctx->psk_client_callback;
|
|
|
|
s->psk_server_callback = ctx->psk_server_callback;
|
2006-03-11 07:06:27 +08:00
|
|
|
#endif
|
|
|
|
|
2015-02-14 07:28:49 +08:00
|
|
|
s->job = NULL;
|
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
return (s);
|
|
|
|
err:
|
2015-04-11 22:22:36 +08:00
|
|
|
SSL_free(s);
|
2015-01-22 11:40:55 +08:00
|
|
|
SSLerr(SSL_F_SSL_NEW, ERR_R_MALLOC_FAILURE);
|
|
|
|
return (NULL);
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
int SSL_CTX_set_session_id_context(SSL_CTX *ctx, const unsigned char *sid_ctx,
|
|
|
|
unsigned int sid_ctx_len)
|
|
|
|
{
|
|
|
|
if (sid_ctx_len > sizeof ctx->sid_ctx) {
|
|
|
|
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);
|
1999-05-01 01:15:56 +08:00
|
|
|
|
|
|
|
return 1;
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
1999-05-01 01:15:56 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
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);
|
1999-03-22 20:22:14 +08:00
|
|
|
|
|
|
|
return 1;
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
1999-03-22 20:22:14 +08:00
|
|
|
|
2001-02-22 02:06:26 +08:00
|
|
|
int SSL_CTX_set_generate_session_id(SSL_CTX *ctx, GEN_SESSION_CB cb)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
|
|
|
|
ctx->generate_session_id = cb;
|
|
|
|
CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
|
|
|
|
return 1;
|
|
|
|
}
|
2001-02-22 02:06:26 +08:00
|
|
|
|
|
|
|
int SSL_set_generate_session_id(SSL *ssl, GEN_SESSION_CB cb)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
CRYPTO_w_lock(CRYPTO_LOCK_SSL);
|
|
|
|
ssl->generate_session_id = cb;
|
|
|
|
CRYPTO_w_unlock(CRYPTO_LOCK_SSL);
|
|
|
|
return 1;
|
|
|
|
}
|
2001-02-22 02:06:26 +08:00
|
|
|
|
2001-02-23 08:02:56 +08:00
|
|
|
int SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id,
|
2015-01-22 11:40:55 +08:00
|
|
|
unsigned int id_len)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* 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 use
|
|
|
|
* by this SSL.
|
|
|
|
*/
|
|
|
|
SSL_SESSION r, *p;
|
|
|
|
|
|
|
|
if (id_len > sizeof r.session_id)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
r.ssl_version = ssl->version;
|
|
|
|
r.session_id_length = id_len;
|
|
|
|
memcpy(r.session_id, id, id_len);
|
|
|
|
|
|
|
|
CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);
|
|
|
|
p = lh_SSL_SESSION_retrieve(ssl->ctx->sessions, &r);
|
|
|
|
CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
|
|
|
|
return (p != NULL);
|
|
|
|
}
|
2001-02-22 02:06:26 +08:00
|
|
|
|
1999-11-30 06:35:00 +08:00
|
|
|
int SSL_CTX_set_purpose(SSL_CTX *s, int purpose)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return X509_VERIFY_PARAM_set_purpose(s->param, purpose);
|
|
|
|
}
|
1999-11-30 06:35:00 +08:00
|
|
|
|
|
|
|
int SSL_set_purpose(SSL *s, int purpose)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return X509_VERIFY_PARAM_set_purpose(s->param, purpose);
|
|
|
|
}
|
2001-05-10 08:13:59 +08:00
|
|
|
|
1999-11-30 06:35:00 +08:00
|
|
|
int SSL_CTX_set_trust(SSL_CTX *s, int trust)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return X509_VERIFY_PARAM_set_trust(s->param, trust);
|
|
|
|
}
|
1999-11-30 06:35:00 +08:00
|
|
|
|
|
|
|
int SSL_set_trust(SSL *s, int trust)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return X509_VERIFY_PARAM_set_trust(s->param, trust);
|
|
|
|
}
|
1999-11-30 06:35:00 +08:00
|
|
|
|
2009-06-30 19:58:10 +08:00
|
|
|
int SSL_CTX_set1_param(SSL_CTX *ctx, X509_VERIFY_PARAM *vpm)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return X509_VERIFY_PARAM_set1(ctx->param, vpm);
|
|
|
|
}
|
2009-06-30 19:58:10 +08:00
|
|
|
|
|
|
|
int SSL_set1_param(SSL *ssl, X509_VERIFY_PARAM *vpm)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return X509_VERIFY_PARAM_set1(ssl->param, vpm);
|
|
|
|
}
|
2009-06-30 19:58:10 +08:00
|
|
|
|
2013-12-13 21:59:53 +08:00
|
|
|
X509_VERIFY_PARAM *SSL_CTX_get0_param(SSL_CTX *ctx)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return ctx->param;
|
|
|
|
}
|
2013-12-13 21:59:53 +08:00
|
|
|
|
|
|
|
X509_VERIFY_PARAM *SSL_get0_param(SSL *ssl)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return ssl->param;
|
|
|
|
}
|
2013-12-13 21:59:53 +08:00
|
|
|
|
2012-06-18 20:56:59 +08:00
|
|
|
void SSL_certs_clear(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
ssl_cert_clear_certs(s->cert);
|
|
|
|
}
|
2012-06-18 20:56:59 +08:00
|
|
|
|
1999-02-28 20:41:50 +08:00
|
|
|
void SSL_free(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
int i;
|
1998-12-21 18:56:39 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
if (s == NULL)
|
|
|
|
return;
|
1999-01-08 03:15:59 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
i = CRYPTO_add(&s->references, -1, CRYPTO_LOCK_SSL);
|
1998-12-21 18:56:39 +08:00
|
|
|
#ifdef REF_PRINT
|
2015-01-22 11:40:55 +08:00
|
|
|
REF_PRINT("SSL", s);
|
1998-12-21 18:56:39 +08:00
|
|
|
#endif
|
2015-01-22 11:40:55 +08:00
|
|
|
if (i > 0)
|
|
|
|
return;
|
1998-12-21 18:56:39 +08:00
|
|
|
#ifdef REF_CHECK
|
2015-01-22 11:40:55 +08:00
|
|
|
if (i < 0) {
|
|
|
|
fprintf(stderr, "SSL_free, bad reference count\n");
|
|
|
|
abort(); /* ok */
|
|
|
|
}
|
2006-01-06 17:08:59 +08:00
|
|
|
#endif
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-05-01 05:33:59 +08:00
|
|
|
X509_VERIFY_PARAM_free(s->param);
|
2015-01-22 11:40:55 +08:00
|
|
|
CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
|
|
|
|
|
|
|
|
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);
|
|
|
|
s->bbio = NULL;
|
|
|
|
}
|
2015-03-25 23:31:18 +08:00
|
|
|
BIO_free_all(s->rbio);
|
|
|
|
if (s->wbio != s->rbio)
|
2015-01-22 11:40:55 +08:00
|
|
|
BIO_free_all(s->wbio);
|
|
|
|
|
2015-05-02 02:37:16 +08:00
|
|
|
BUF_MEM_free(s->init_buf);
|
2015-01-22 11:40:55 +08:00
|
|
|
|
|
|
|
/* add extra stuff */
|
2015-05-02 02:37:16 +08:00
|
|
|
sk_SSL_CIPHER_free(s->cipher_list);
|
|
|
|
sk_SSL_CIPHER_free(s->cipher_list_by_id);
|
2015-01-22 11:40:55 +08:00
|
|
|
|
|
|
|
/* Make the next call work :-) */
|
|
|
|
if (s->session != NULL) {
|
|
|
|
ssl_clear_bad_session(s);
|
|
|
|
SSL_SESSION_free(s->session);
|
|
|
|
}
|
|
|
|
|
2015-06-13 22:50:00 +08:00
|
|
|
clear_ciphers(s);
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-04-12 04:32:54 +08:00
|
|
|
ssl_cert_free(s->cert);
|
2015-01-22 11:40:55 +08:00
|
|
|
/* Free up if allocated */
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-05-01 22:02:07 +08:00
|
|
|
OPENSSL_free(s->tlsext_hostname);
|
2015-04-12 04:32:54 +08:00
|
|
|
SSL_CTX_free(s->initial_ctx);
|
2015-05-15 17:49:56 +08:00
|
|
|
#ifndef OPENSSL_NO_EC
|
2015-05-01 22:02:07 +08:00
|
|
|
OPENSSL_free(s->tlsext_ecpointformatlist);
|
|
|
|
OPENSSL_free(s->tlsext_ellipticcurvelist);
|
2015-05-15 17:49:56 +08:00
|
|
|
#endif /* OPENSSL_NO_EC */
|
2015-05-01 05:33:59 +08:00
|
|
|
sk_X509_EXTENSION_pop_free(s->tlsext_ocsp_exts, X509_EXTENSION_free);
|
2015-05-02 02:37:16 +08:00
|
|
|
sk_OCSP_RESPID_pop_free(s->tlsext_ocsp_ids, OCSP_RESPID_free);
|
2015-05-01 22:02:07 +08:00
|
|
|
OPENSSL_free(s->tlsext_ocsp_resp);
|
|
|
|
OPENSSL_free(s->alpn_client_proto_list);
|
2015-01-22 11:40:55 +08:00
|
|
|
|
2015-05-01 05:33:59 +08:00
|
|
|
sk_X509_NAME_pop_free(s->client_CA, X509_NAME_free);
|
2015-01-22 11:40:55 +08:00
|
|
|
|
|
|
|
if (s->method != NULL)
|
|
|
|
s->method->ssl_free(s);
|
|
|
|
|
2015-02-02 20:18:03 +08:00
|
|
|
RECORD_LAYER_release(&s->rlayer);
|
2015-01-30 23:38:10 +08:00
|
|
|
|
2015-04-12 04:32:54 +08:00
|
|
|
SSL_CTX_free(s->ctx);
|
2009-10-16 21:41:39 +08:00
|
|
|
|
2015-05-15 17:49:56 +08:00
|
|
|
#if !defined(OPENSSL_NO_NEXTPROTONEG)
|
2015-05-01 22:02:07 +08:00
|
|
|
OPENSSL_free(s->next_proto_negotiated);
|
2010-07-28 18:06:55 +08:00
|
|
|
#endif
|
|
|
|
|
2014-12-22 19:15:51 +08:00
|
|
|
#ifndef OPENSSL_NO_SRTP
|
2015-05-02 02:37:16 +08:00
|
|
|
sk_SRTP_PROTECTION_PROFILE_free(s->srtp_profiles);
|
2015-01-22 11:40:55 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
OPENSSL_free(s);
|
|
|
|
}
|
|
|
|
|
2015-02-07 08:08:59 +08:00
|
|
|
void SSL_set_rbio(SSL *s, BIO *rbio)
|
|
|
|
{
|
2015-03-25 23:31:18 +08:00
|
|
|
if (s->rbio != rbio)
|
2015-02-07 08:08:59 +08:00
|
|
|
BIO_free_all(s->rbio);
|
|
|
|
s->rbio = rbio;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SSL_set_wbio(SSL *s, BIO *wbio)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
}
|
2015-03-25 23:31:18 +08:00
|
|
|
if (s->wbio != wbio && s->rbio != s->wbio)
|
2015-01-22 11:40:55 +08:00
|
|
|
BIO_free_all(s->wbio);
|
|
|
|
s->wbio = wbio;
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-02-07 08:08:59 +08:00
|
|
|
void SSL_set_bio(SSL *s, BIO *rbio, BIO *wbio)
|
|
|
|
{
|
|
|
|
SSL_set_wbio(s, wbio);
|
|
|
|
SSL_set_rbio(s, rbio);
|
|
|
|
}
|
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
BIO *SSL_get_rbio(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return (s->rbio);
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
BIO *SSL_get_wbio(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return (s->wbio);
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
int SSL_get_fd(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return (SSL_get_rfd(s));
|
|
|
|
}
|
2001-07-16 04:11:57 +08:00
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
int SSL_get_rfd(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
int SSL_get_wfd(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
2001-07-16 04:11:57 +08:00
|
|
|
|
2001-02-20 16:13:47 +08:00
|
|
|
#ifndef OPENSSL_NO_SOCK
|
2015-01-22 11:40:55 +08:00
|
|
|
int SSL_set_fd(SSL *s, int fd)
|
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
int SSL_set_wfd(SSL *s, int fd)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
BIO *bio = NULL;
|
|
|
|
|
|
|
|
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());
|
|
|
|
|
|
|
|
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));
|
|
|
|
ret = 1;
|
|
|
|
err:
|
|
|
|
return (ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
int SSL_set_rfd(SSL *s, int fd)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
BIO *bio = NULL;
|
|
|
|
|
|
|
|
if ((s->wbio == NULL) || (BIO_method_type(s->wbio) != BIO_TYPE_SOCKET)
|
|
|
|
|| ((int)BIO_get_fd(s->wbio, NULL) != fd)) {
|
|
|
|
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));
|
|
|
|
} else
|
|
|
|
SSL_set_bio(s, SSL_get_wbio(s), SSL_get_wbio(s));
|
|
|
|
ret = 1;
|
|
|
|
err:
|
|
|
|
return (ret);
|
|
|
|
}
|
|
|
|
#endif
|
2000-01-06 09:19:17 +08:00
|
|
|
|
|
|
|
/* return length of latest Finished message we sent, copy to 'buf' */
|
2005-03-30 18:26:02 +08:00
|
|
|
size_t SSL_get_finished(const SSL *s, void *buf, size_t count)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
2000-01-06 09:19:17 +08:00
|
|
|
|
|
|
|
/* return length of latest Finished message we expected, copy to 'buf' */
|
2005-03-30 18:26:02 +08:00
|
|
|
size_t SSL_get_peer_finished(const SSL *s, void *buf, size_t count)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
size_t ret = 0;
|
2000-01-06 09:19:17 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
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;
|
|
|
|
}
|
2000-01-06 09:19:17 +08:00
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
int SSL_get_verify_mode(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return (s->verify_mode);
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
int SSL_get_verify_depth(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return X509_VERIFY_PARAM_get_depth(s->param);
|
|
|
|
}
|
1999-05-01 11:20:40 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
int (*SSL_get_verify_callback(const SSL *s)) (int, X509_STORE_CTX *) {
|
|
|
|
return (s->verify_callback);
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
int SSL_CTX_get_verify_mode(const SSL_CTX *ctx)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return (ctx->verify_mode);
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
int SSL_CTX_get_verify_depth(const SSL_CTX *ctx)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return X509_VERIFY_PARAM_get_depth(ctx->param);
|
|
|
|
}
|
|
|
|
|
|
|
|
int (*SSL_CTX_get_verify_callback(const SSL_CTX *ctx)) (int, X509_STORE_CTX *) {
|
|
|
|
return (ctx->default_verify_callback);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SSL_set_verify(SSL *s, int mode,
|
|
|
|
int (*callback) (int ok, X509_STORE_CTX *ctx))
|
|
|
|
{
|
|
|
|
s->verify_mode = mode;
|
|
|
|
if (callback != NULL)
|
|
|
|
s->verify_callback = callback;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SSL_set_verify_depth(SSL *s, int depth)
|
|
|
|
{
|
|
|
|
X509_VERIFY_PARAM_set_depth(s->param, depth);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SSL_set_read_ahead(SSL *s, int yes)
|
|
|
|
{
|
2015-01-30 21:46:43 +08:00
|
|
|
RECORD_LAYER_set_read_ahead(&s->rlayer, yes);
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
int SSL_get_read_ahead(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
2015-01-30 21:46:43 +08:00
|
|
|
return RECORD_LAYER_get_read_ahead(&s->rlayer);
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
int SSL_pending(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* 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.)
|
|
|
|
*/
|
|
|
|
return (s->method->ssl_pending(s));
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
X509 *SSL_get_peer_certificate(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
X509 *r;
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
if ((s == NULL) || (s->session == NULL))
|
|
|
|
r = NULL;
|
|
|
|
else
|
|
|
|
r = s->session->peer;
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
if (r == NULL)
|
|
|
|
return (r);
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-09-01 03:29:57 +08:00
|
|
|
X509_up_ref(r);
|
2015-01-22 11:40:55 +08:00
|
|
|
|
|
|
|
return (r);
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
STACK_OF(X509) *SSL_get_peer_cert_chain(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
STACK_OF(X509) *r;
|
|
|
|
|
2015-06-22 02:34:33 +08:00
|
|
|
if ((s == NULL) || (s->session == NULL))
|
2015-01-22 11:40:55 +08:00
|
|
|
r = NULL;
|
|
|
|
else
|
2015-06-22 02:34:33 +08:00
|
|
|
r = s->session->peer_chain;
|
2015-01-22 11:40:55 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we are a client, cert_chain includes the peer's own certificate; if
|
|
|
|
* we are a server, it does not.
|
|
|
|
*/
|
|
|
|
|
|
|
|
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
|
|
|
|
*/
|
2015-03-24 23:10:15 +08:00
|
|
|
int SSL_copy_session_id(SSL *t, const SSL *f)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
/* Do we need to to SSL locking? */
|
2015-04-16 13:50:03 +08:00
|
|
|
if (!SSL_set_session(t, SSL_get_session(f))) {
|
2015-03-24 23:10:15 +08:00
|
|
|
return 0;
|
2015-03-06 22:37:17 +08:00
|
|
|
}
|
2015-01-22 11:40:55 +08:00
|
|
|
|
|
|
|
/*
|
2015-10-29 22:50:40 +08:00
|
|
|
* what if we are setup for one protocol version but want to talk another
|
2015-01-22 11:40:55 +08:00
|
|
|
*/
|
|
|
|
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 */
|
|
|
|
}
|
|
|
|
|
2015-03-19 02:02:50 +08:00
|
|
|
CRYPTO_add(&f->cert->references, 1, CRYPTO_LOCK_SSL_CERT);
|
|
|
|
ssl_cert_free(t->cert);
|
|
|
|
t->cert = f->cert;
|
2015-04-16 13:50:03 +08:00
|
|
|
if (!SSL_set_session_id_context(t, f->sid_ctx, f->sid_ctx_length)) {
|
2015-03-24 23:10:15 +08:00
|
|
|
return 0;
|
2015-03-06 22:37:17 +08:00
|
|
|
}
|
2015-03-24 23:10:15 +08:00
|
|
|
|
|
|
|
return 1;
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
1998-12-21 18:56:39 +08:00
|
|
|
/* Fix this so it checks all the valid key/cert options */
|
2005-03-30 18:26:02 +08:00
|
|
|
int SSL_CTX_check_private_key(const SSL_CTX *ctx)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
if ((ctx == NULL) ||
|
2015-03-19 02:02:50 +08:00
|
|
|
(ctx->cert->key->x509 == NULL)) {
|
2015-01-22 11:40:55 +08:00
|
|
|
SSLerr(SSL_F_SSL_CTX_CHECK_PRIVATE_KEY,
|
|
|
|
SSL_R_NO_CERTIFICATE_ASSIGNED);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
if (ctx->cert->key->privatekey == NULL) {
|
|
|
|
SSLerr(SSL_F_SSL_CTX_CHECK_PRIVATE_KEY,
|
|
|
|
SSL_R_NO_PRIVATE_KEY_ASSIGNED);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
return (X509_check_private_key
|
|
|
|
(ctx->cert->key->x509, ctx->cert->key->privatekey));
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
1998-12-21 18:56:39 +08:00
|
|
|
/* Fix this function so that it takes an optional type parameter */
|
2005-03-30 18:26:02 +08:00
|
|
|
int SSL_check_private_key(const SSL *ssl)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
if (ssl == NULL) {
|
|
|
|
SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY, ERR_R_PASSED_NULL_PARAMETER);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
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));
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-02-14 07:28:49 +08:00
|
|
|
int SSL_waiting_for_async(SSL *s)
|
|
|
|
{
|
2015-03-26 18:15:59 +08:00
|
|
|
if(s->job)
|
|
|
|
return 1;
|
|
|
|
|
2015-02-14 07:28:49 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-07-24 15:15:31 +08:00
|
|
|
int SSL_get_async_wait_fd(SSL *s)
|
|
|
|
{
|
|
|
|
if (!s->job)
|
2015-10-06 20:49:16 +08:00
|
|
|
return -1;
|
2015-07-24 15:15:31 +08:00
|
|
|
|
|
|
|
return ASYNC_get_wait_fd(s->job);
|
|
|
|
}
|
|
|
|
|
1999-02-28 20:41:50 +08:00
|
|
|
int SSL_accept(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
2015-10-06 22:57:50 +08:00
|
|
|
if (s->handshake_func == 0) {
|
2015-01-22 11:40:55 +08:00
|
|
|
/* Not properly initialized yet */
|
|
|
|
SSL_set_accept_state(s);
|
2015-02-14 07:28:49 +08:00
|
|
|
}
|
2015-10-06 22:57:50 +08:00
|
|
|
|
|
|
|
return SSL_do_handshake(s);
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
1999-02-28 20:41:50 +08:00
|
|
|
int SSL_connect(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
2015-10-06 22:57:50 +08:00
|
|
|
if (s->handshake_func == 0) {
|
2015-01-22 11:40:55 +08:00
|
|
|
/* Not properly initialized yet */
|
|
|
|
SSL_set_connect_state(s);
|
2015-10-06 22:57:50 +08:00
|
|
|
}
|
1999-05-11 15:43:16 +08:00
|
|
|
|
2015-10-06 22:57:50 +08:00
|
|
|
return SSL_do_handshake(s);
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
long SSL_get_default_timeout(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return (s->method->get_timeout());
|
|
|
|
}
|
|
|
|
|
2015-10-09 23:47:43 +08:00
|
|
|
static int ssl_start_async_job(SSL *s, struct ssl_async_args *args,
|
2015-10-06 22:57:50 +08:00
|
|
|
int (*func)(void *)) {
|
|
|
|
int ret;
|
|
|
|
switch(ASYNC_start_job(&s->job, &ret, func, args,
|
|
|
|
sizeof(struct ssl_async_args))) {
|
|
|
|
case ASYNC_ERR:
|
|
|
|
s->rwstate = SSL_NOTHING;
|
2015-10-09 23:47:43 +08:00
|
|
|
SSLerr(SSL_F_SSL_START_ASYNC_JOB, SSL_R_FAILED_TO_INIT_ASYNC);
|
2015-10-06 22:57:50 +08:00
|
|
|
return -1;
|
|
|
|
case ASYNC_PAUSE:
|
|
|
|
s->rwstate = SSL_ASYNC_PAUSED;
|
|
|
|
return -1;
|
|
|
|
case ASYNC_FINISH:
|
|
|
|
s->job = NULL;
|
|
|
|
return ret;
|
|
|
|
default:
|
|
|
|
s->rwstate = SSL_NOTHING;
|
2015-10-09 23:47:43 +08:00
|
|
|
SSLerr(SSL_F_SSL_START_ASYNC_JOB, ERR_R_INTERNAL_ERROR);
|
2015-10-06 22:57:50 +08:00
|
|
|
/* Shouldn't happen */
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
2015-02-14 07:28:49 +08:00
|
|
|
|
2015-10-06 22:57:50 +08:00
|
|
|
static int ssl_io_intern(void *vargs)
|
2015-02-14 07:28:49 +08:00
|
|
|
{
|
|
|
|
struct ssl_async_args *args;
|
|
|
|
SSL *s;
|
|
|
|
void *buf;
|
|
|
|
int num;
|
|
|
|
|
|
|
|
args = (struct ssl_async_args *)vargs;
|
|
|
|
s = args->s;
|
|
|
|
buf = args->buf;
|
|
|
|
num = args->num;
|
2015-10-06 22:57:50 +08:00
|
|
|
if (args->type == 1)
|
|
|
|
return args->f.func1(s, buf, num);
|
|
|
|
else
|
|
|
|
return args->f.func2(s, buf, num);
|
2015-02-14 07:28:49 +08:00
|
|
|
}
|
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
int SSL_read(SSL *s, void *buf, int num)
|
|
|
|
{
|
|
|
|
if (s->handshake_func == 0) {
|
|
|
|
SSLerr(SSL_F_SSL_READ, SSL_R_UNINITIALIZED);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
|
|
|
|
s->rwstate = SSL_NOTHING;
|
|
|
|
return (0);
|
|
|
|
}
|
2015-02-14 07:28:49 +08:00
|
|
|
|
2015-09-24 06:12:36 +08:00
|
|
|
if((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
|
2015-10-06 22:57:50 +08:00
|
|
|
struct ssl_async_args args;
|
|
|
|
|
|
|
|
args.s = s;
|
|
|
|
args.buf = buf;
|
|
|
|
args.num = num;
|
|
|
|
args.type = 1;
|
|
|
|
args.f.func1 = s->method->ssl_read;
|
|
|
|
|
2015-10-09 23:47:43 +08:00
|
|
|
return ssl_start_async_job(s, &args, ssl_io_intern);
|
2015-02-14 07:28:49 +08:00
|
|
|
} else {
|
|
|
|
return s->method->ssl_read(s, buf, num);
|
|
|
|
}
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
int SSL_peek(SSL *s, void *buf, int num)
|
|
|
|
{
|
|
|
|
if (s->handshake_func == 0) {
|
|
|
|
SSLerr(SSL_F_SSL_PEEK, SSL_R_UNINITIALIZED);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
|
|
|
|
return (0);
|
|
|
|
}
|
2015-10-06 22:57:50 +08:00
|
|
|
if((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
|
|
|
|
struct ssl_async_args args;
|
2015-01-22 11:40:55 +08:00
|
|
|
|
2015-10-06 22:57:50 +08:00
|
|
|
args.s = s;
|
|
|
|
args.buf = buf;
|
|
|
|
args.num = num;
|
|
|
|
args.type = 1;
|
|
|
|
args.f.func1 = s->method->ssl_peek;
|
2015-02-14 07:28:49 +08:00
|
|
|
|
2015-10-09 23:47:43 +08:00
|
|
|
return ssl_start_async_job(s, &args, ssl_io_intern);
|
2015-10-06 22:57:50 +08:00
|
|
|
} else {
|
|
|
|
return s->method->ssl_peek(s, buf, num);
|
|
|
|
}
|
2015-02-14 07:28:49 +08:00
|
|
|
}
|
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
int SSL_write(SSL *s, const void *buf, int num)
|
|
|
|
{
|
|
|
|
if (s->handshake_func == 0) {
|
|
|
|
SSLerr(SSL_F_SSL_WRITE, SSL_R_UNINITIALIZED);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s->shutdown & SSL_SENT_SHUTDOWN) {
|
|
|
|
s->rwstate = SSL_NOTHING;
|
|
|
|
SSLerr(SSL_F_SSL_WRITE, SSL_R_PROTOCOL_IS_SHUTDOWN);
|
|
|
|
return (-1);
|
|
|
|
}
|
2015-02-14 07:28:49 +08:00
|
|
|
|
2015-09-24 06:12:36 +08:00
|
|
|
if((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
|
2015-10-06 22:57:50 +08:00
|
|
|
struct ssl_async_args args;
|
|
|
|
|
|
|
|
args.s = s;
|
|
|
|
args.buf = (void *)buf;
|
|
|
|
args.num = num;
|
|
|
|
args.type = 2;
|
|
|
|
args.f.func2 = s->method->ssl_write;
|
|
|
|
|
2015-10-09 23:47:43 +08:00
|
|
|
return ssl_start_async_job(s, &args, ssl_io_intern);
|
2015-02-14 07:28:49 +08:00
|
|
|
} else {
|
|
|
|
return s->method->ssl_write(s, buf, num);
|
|
|
|
}
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
1999-02-28 20:41:50 +08:00
|
|
|
int SSL_shutdown(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Note that this function behaves differently from what one might
|
|
|
|
* 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).
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (s->handshake_func == 0) {
|
|
|
|
SSLerr(SSL_F_SSL_SHUTDOWN, SSL_R_UNINITIALIZED);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2015-11-09 23:31:27 +08:00
|
|
|
if (!SSL_in_init(s))
|
2015-01-22 11:40:55 +08:00
|
|
|
return (s->method->ssl_shutdown(s));
|
|
|
|
else
|
|
|
|
return (1);
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
1999-02-28 20:41:50 +08:00
|
|
|
int SSL_renegotiate(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
if (s->renegotiate == 0)
|
|
|
|
s->renegotiate = 1;
|
2010-08-26 22:23:52 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
s->new_session = 1;
|
2010-08-26 22:23:52 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
return (s->method->ssl_renegotiate(s));
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2010-08-26 22:23:52 +08:00
|
|
|
int SSL_renegotiate_abbreviated(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
if (s->renegotiate == 0)
|
|
|
|
s->renegotiate = 1;
|
2011-09-05 21:36:23 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
s->new_session = 0;
|
2011-09-05 21:36:23 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
return (s->method->ssl_renegotiate(s));
|
|
|
|
}
|
2010-08-26 22:23:52 +08:00
|
|
|
|
2001-09-21 06:54:09 +08:00
|
|
|
int SSL_renegotiate_pending(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* becomes true when negotiation is requested; false again once a
|
|
|
|
* handshake has finished
|
|
|
|
*/
|
|
|
|
return (s->renegotiate != 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
long SSL_ctrl(SSL *s, int cmd, long larg, void *parg)
|
|
|
|
{
|
|
|
|
long l;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case SSL_CTRL_GET_READ_AHEAD:
|
2015-01-30 21:46:43 +08:00
|
|
|
return (RECORD_LAYER_get_read_ahead(&s->rlayer));
|
2015-01-22 11:40:55 +08:00
|
|
|
case SSL_CTRL_SET_READ_AHEAD:
|
2015-01-30 21:46:43 +08:00
|
|
|
l = RECORD_LAYER_get_read_ahead(&s->rlayer);
|
|
|
|
RECORD_LAYER_set_read_ahead(&s->rlayer, larg);
|
2015-01-22 11:40:55 +08:00
|
|
|
return (l);
|
|
|
|
|
|
|
|
case SSL_CTRL_SET_MSG_CALLBACK_ARG:
|
|
|
|
s->msg_callback_arg = parg;
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
case SSL_CTRL_OPTIONS:
|
|
|
|
return (s->options |= larg);
|
|
|
|
case SSL_CTRL_CLEAR_OPTIONS:
|
|
|
|
return (s->options &= ~larg);
|
|
|
|
case SSL_CTRL_MODE:
|
|
|
|
return (s->mode |= larg);
|
|
|
|
case SSL_CTRL_CLEAR_MODE:
|
|
|
|
return (s->mode &= ~larg);
|
|
|
|
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);
|
|
|
|
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;
|
|
|
|
case SSL_CTRL_GET_RI_SUPPORT:
|
|
|
|
if (s->s3)
|
|
|
|
return s->s3->send_connection_binding;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
case SSL_CTRL_CERT_FLAGS:
|
|
|
|
return (s->cert->cert_flags |= larg);
|
|
|
|
case SSL_CTRL_CLEAR_CERT_FLAGS:
|
|
|
|
return (s->cert->cert_flags &= ~larg);
|
|
|
|
|
|
|
|
case SSL_CTRL_GET_RAW_CIPHERLIST:
|
|
|
|
if (parg) {
|
2015-05-13 00:17:37 +08:00
|
|
|
if (s->s3->tmp.ciphers_raw == NULL)
|
2015-01-22 11:40:55 +08:00
|
|
|
return 0;
|
2015-05-13 00:17:37 +08:00
|
|
|
*(unsigned char **)parg = s->s3->tmp.ciphers_raw;
|
|
|
|
return (int)s->s3->tmp.ciphers_rawlen;
|
2015-09-18 21:00:37 +08:00
|
|
|
} else {
|
|
|
|
return TLS_CIPHER_LEN;
|
|
|
|
}
|
2015-01-23 10:52:20 +08:00
|
|
|
case SSL_CTRL_GET_EXTMS_SUPPORT:
|
2015-10-22 20:57:18 +08:00
|
|
|
if (!s->session || SSL_in_init(s) || ossl_statem_get_in_handshake(s))
|
2015-01-25 01:09:55 +08:00
|
|
|
return -1;
|
|
|
|
if (s->session->flags & SSL_SESS_FLAG_EXTMS)
|
2015-01-23 10:52:20 +08:00
|
|
|
return 1;
|
|
|
|
else
|
|
|
|
return 0;
|
2015-01-22 11:40:55 +08:00
|
|
|
default:
|
|
|
|
return (s->method->ssl_ctrl(s, cmd, larg, parg));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
long SSL_callback_ctrl(SSL *s, int cmd, void (*fp) (void))
|
|
|
|
{
|
|
|
|
switch (cmd) {
|
|
|
|
case SSL_CTRL_SET_MSG_CALLBACK:
|
|
|
|
s->msg_callback = (void (*)
|
|
|
|
(int write_p, int version, int content_type,
|
|
|
|
const void *buf, size_t len, SSL *ssl,
|
|
|
|
void *arg))(fp);
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return (s->method->ssl_callback_ctrl(s, cmd, fp));
|
|
|
|
}
|
|
|
|
}
|
2000-02-21 07:43:02 +08:00
|
|
|
|
2008-05-26 19:24:29 +08:00
|
|
|
LHASH_OF(SSL_SESSION) *SSL_CTX_sessions(SSL_CTX *ctx)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return ctx->sessions;
|
|
|
|
}
|
|
|
|
|
|
|
|
long SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg)
|
|
|
|
{
|
|
|
|
long l;
|
|
|
|
/* For some cases with ctx == NULL perform syntax checks */
|
|
|
|
if (ctx == NULL) {
|
|
|
|
switch (cmd) {
|
2013-08-18 00:40:08 +08:00
|
|
|
#ifndef OPENSSL_NO_EC
|
2015-01-22 11:40:55 +08:00
|
|
|
case SSL_CTRL_SET_CURVES_LIST:
|
|
|
|
return tls1_set_curves_list(NULL, NULL, parg);
|
|
|
|
#endif
|
|
|
|
case SSL_CTRL_SET_SIGALGS_LIST:
|
|
|
|
case SSL_CTRL_SET_CLIENT_SIGALGS_LIST:
|
|
|
|
return tls1_set_sigalgs_list(NULL, parg, 0);
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
case SSL_CTRL_SET_MSG_CALLBACK_ARG:
|
|
|
|
ctx->msg_callback_arg = parg;
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
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:
|
|
|
|
return (lh_SSL_SESSION_num_items(ctx->sessions));
|
|
|
|
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);
|
|
|
|
case SSL_CTRL_CLEAR_OPTIONS:
|
|
|
|
return (ctx->options &= ~larg);
|
|
|
|
case SSL_CTRL_MODE:
|
|
|
|
return (ctx->mode |= larg);
|
|
|
|
case SSL_CTRL_CLEAR_MODE:
|
|
|
|
return (ctx->mode &= ~larg);
|
|
|
|
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;
|
|
|
|
case SSL_CTRL_CERT_FLAGS:
|
|
|
|
return (ctx->cert->cert_flags |= larg);
|
|
|
|
case SSL_CTRL_CLEAR_CERT_FLAGS:
|
|
|
|
return (ctx->cert->cert_flags &= ~larg);
|
|
|
|
default:
|
|
|
|
return (ctx->method->ssl_ctx_ctrl(ctx, cmd, larg, parg));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
long SSL_CTX_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp) (void))
|
|
|
|
{
|
|
|
|
switch (cmd) {
|
|
|
|
case SSL_CTRL_SET_MSG_CALLBACK:
|
|
|
|
ctx->msg_callback = (void (*)
|
|
|
|
(int write_p, int version, int content_type,
|
|
|
|
const void *buf, size_t len, SSL *ssl,
|
|
|
|
void *arg))(fp);
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return (ctx->method->ssl_ctx_callback_ctrl(ctx, cmd, fp));
|
|
|
|
}
|
|
|
|
}
|
2000-02-21 07:43:02 +08:00
|
|
|
|
2000-06-01 10:36:58 +08:00
|
|
|
int ssl_cipher_id_cmp(const SSL_CIPHER *a, const SSL_CIPHER *b)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
2015-11-06 00:14:17 +08:00
|
|
|
if (a->id > b->id)
|
|
|
|
return 1;
|
|
|
|
if (a->id < b->id)
|
|
|
|
return -1;
|
|
|
|
return 0;
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
int ssl_cipher_ptr_id_cmp(const SSL_CIPHER *const *ap,
|
|
|
|
const SSL_CIPHER *const *bp)
|
|
|
|
{
|
2015-11-06 00:14:17 +08:00
|
|
|
if ((*ap)->id > (*bp)->id)
|
|
|
|
return 1;
|
|
|
|
if ((*ap)->id < (*bp)->id)
|
|
|
|
return -1;
|
|
|
|
return 0;
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
1999-02-28 20:41:50 +08:00
|
|
|
/** return a STACK of the ciphers available for the SSL and in order of
|
1998-12-21 18:52:47 +08:00
|
|
|
* preference */
|
2005-03-30 18:26:02 +08:00
|
|
|
STACK_OF(SSL_CIPHER) *SSL_get_ciphers(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
if (s != NULL) {
|
|
|
|
if (s->cipher_list != NULL) {
|
|
|
|
return (s->cipher_list);
|
|
|
|
} else if ((s->ctx != NULL) && (s->ctx->cipher_list != NULL)) {
|
|
|
|
return (s->ctx->cipher_list);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
2015-05-26 09:16:53 +08:00
|
|
|
STACK_OF(SSL_CIPHER) *SSL_get_client_ciphers(const SSL *s)
|
|
|
|
{
|
|
|
|
if ((s == NULL) || (s->session == NULL) || !s->server)
|
|
|
|
return NULL;
|
|
|
|
return s->session->ciphers;
|
|
|
|
}
|
|
|
|
|
2014-01-14 22:55:21 +08:00
|
|
|
STACK_OF(SSL_CIPHER) *SSL_get1_supported_ciphers(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
STACK_OF(SSL_CIPHER) *sk = NULL, *ciphers;
|
|
|
|
int i;
|
|
|
|
ciphers = SSL_get_ciphers(s);
|
|
|
|
if (!ciphers)
|
|
|
|
return NULL;
|
|
|
|
ssl_set_client_disabled(s);
|
|
|
|
for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
|
|
|
|
const SSL_CIPHER *c = sk_SSL_CIPHER_value(ciphers, i);
|
|
|
|
if (!ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_SUPPORTED)) {
|
|
|
|
if (!sk)
|
|
|
|
sk = sk_SSL_CIPHER_new_null();
|
|
|
|
if (!sk)
|
|
|
|
return NULL;
|
|
|
|
if (!sk_SSL_CIPHER_push(sk, c)) {
|
|
|
|
sk_SSL_CIPHER_free(sk);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return sk;
|
|
|
|
}
|
2014-01-14 22:55:21 +08:00
|
|
|
|
1999-02-28 20:41:50 +08:00
|
|
|
/** return a STACK of the ciphers available for the SSL and in order of
|
1998-12-21 18:52:47 +08:00
|
|
|
* algorithm id */
|
1999-04-13 01:23:57 +08:00
|
|
|
STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
if (s != NULL) {
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return (NULL);
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
1999-02-28 20:41:50 +08:00
|
|
|
/** The old interface to get the same thing as SSL_get_ciphers() */
|
2015-01-22 11:40:55 +08:00
|
|
|
const char *SSL_get_cipher_list(const SSL *s, int n)
|
|
|
|
{
|
|
|
|
SSL_CIPHER *c;
|
|
|
|
STACK_OF(SSL_CIPHER) *sk;
|
|
|
|
|
|
|
|
if (s == NULL)
|
|
|
|
return (NULL);
|
|
|
|
sk = SSL_get_ciphers(s);
|
|
|
|
if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= n))
|
|
|
|
return (NULL);
|
|
|
|
c = sk_SSL_CIPHER_value(sk, n);
|
|
|
|
if (c == NULL)
|
|
|
|
return (NULL);
|
|
|
|
return (c->name);
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2000-01-09 22:21:40 +08:00
|
|
|
/** specify the ciphers to be used by default by the SSL_CTX */
|
2000-01-22 11:17:06 +08:00
|
|
|
int SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
STACK_OF(SSL_CIPHER) *sk;
|
|
|
|
|
|
|
|
sk = ssl_create_cipher_list(ctx->method, &ctx->cipher_list,
|
|
|
|
&ctx->cipher_list_by_id, str, ctx->cert);
|
|
|
|
/*
|
|
|
|
* 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 has been disabled). This is not an
|
|
|
|
* error as far as ssl_create_cipher_list is concerned, and hence
|
|
|
|
* 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;
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
1999-02-28 20:41:50 +08:00
|
|
|
/** specify the ciphers to be used by the SSL */
|
2015-01-22 11:40:55 +08:00
|
|
|
int SSL_set_cipher_list(SSL *s, const char *str)
|
|
|
|
{
|
|
|
|
STACK_OF(SSL_CIPHER) *sk;
|
|
|
|
|
|
|
|
sk = ssl_create_cipher_list(s->ctx->method, &s->cipher_list,
|
|
|
|
&s->cipher_list_by_id, str, s->cert);
|
|
|
|
/* 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;
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
char *SSL_get_shared_ciphers(const SSL *s, char *buf, int len)
|
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
STACK_OF(SSL_CIPHER) *sk;
|
|
|
|
SSL_CIPHER *c;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if ((s->session == NULL) || (s->session->ciphers == NULL) || (len < 2))
|
|
|
|
return (NULL);
|
|
|
|
|
|
|
|
p = buf;
|
|
|
|
sk = s->session->ciphers;
|
|
|
|
|
|
|
|
if (sk_SSL_CIPHER_num(sk) == 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
for (i = 0; i < sk_SSL_CIPHER_num(sk); i++) {
|
|
|
|
int n;
|
|
|
|
|
|
|
|
c = sk_SSL_CIPHER_value(sk, i);
|
|
|
|
n = strlen(c->name);
|
|
|
|
if (n + 1 > len) {
|
|
|
|
if (p != buf)
|
|
|
|
--p;
|
|
|
|
*p = '\0';
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
strcpy(p, c->name);
|
|
|
|
p += n;
|
|
|
|
*(p++) = ':';
|
|
|
|
len -= n + 1;
|
|
|
|
}
|
|
|
|
p[-1] = '\0';
|
|
|
|
return (buf);
|
|
|
|
}
|
|
|
|
|
2007-02-17 14:45:38 +08:00
|
|
|
/** return a servername extension value if provided in Client Hello, or NULL.
|
2006-01-03 11:27:19 +08:00
|
|
|
* So far, only host_name types are defined (RFC 3546).
|
2006-01-03 07:14:37 +08:00
|
|
|
*/
|
|
|
|
|
2006-01-03 11:27:19 +08:00
|
|
|
const char *SSL_get_servername(const SSL *s, const int type)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
if (type != TLSEXT_NAMETYPE_host_name)
|
|
|
|
return NULL;
|
2006-01-10 03:49:05 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
return s->session && !s->tlsext_hostname ?
|
|
|
|
s->session->tlsext_hostname : s->tlsext_hostname;
|
|
|
|
}
|
2006-01-03 07:14:37 +08:00
|
|
|
|
2006-01-03 11:27:19 +08:00
|
|
|
int SSL_get_servername_type(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
if (s->session
|
|
|
|
&& (!s->tlsext_hostname ? s->session->
|
|
|
|
tlsext_hostname : s->tlsext_hostname))
|
|
|
|
return TLSEXT_NAMETYPE_host_name;
|
|
|
|
return -1;
|
|
|
|
}
|
2010-07-28 18:06:55 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
/*
|
|
|
|
* SSL_select_next_proto implements the standard protocol selection. It is
|
2010-07-28 18:06:55 +08:00
|
|
|
* expected that this function is called from the callback set by
|
2015-01-22 11:40:55 +08:00
|
|
|
* 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.
|
2010-07-28 18:06:55 +08:00
|
|
|
*/
|
2015-01-22 11:40:55 +08:00
|
|
|
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;
|
|
|
|
}
|
2010-07-28 18:06:55 +08:00
|
|
|
|
2015-05-15 17:49:56 +08:00
|
|
|
#ifndef OPENSSL_NO_NEXTPROTONEG
|
2015-01-22 11:40:55 +08:00
|
|
|
/*
|
|
|
|
* 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
|
2010-07-28 18:06:55 +08:00
|
|
|
* provided by the callback.
|
|
|
|
*/
|
2015-01-22 11:40:55 +08:00
|
|
|
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
|
2010-07-28 18:06:55 +08:00
|
|
|
* 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|).
|
2015-01-22 11:40:55 +08:00
|
|
|
* 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.
|
2010-07-28 18:06:55 +08:00
|
|
|
*/
|
2015-01-22 11:40:55 +08:00
|
|
|
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;
|
|
|
|
}
|
2015-05-15 17:49:56 +08:00
|
|
|
#endif
|
2013-05-13 09:55:27 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
/*
|
|
|
|
* SSL_CTX_set_alpn_protos sets the ALPN protocol list on |ctx| to |protos|.
|
2013-04-16 06:07:47 +08:00
|
|
|
* |protos| must be in wire-format (i.e. a series of non-empty, 8-bit
|
2015-01-22 11:40:55 +08:00
|
|
|
* length-prefixed strings). Returns 0 on success.
|
|
|
|
*/
|
|
|
|
int SSL_CTX_set_alpn_protos(SSL_CTX *ctx, const unsigned char *protos,
|
|
|
|
unsigned protos_len)
|
|
|
|
{
|
2015-05-02 02:37:16 +08:00
|
|
|
OPENSSL_free(ctx->alpn_client_proto_list);
|
2015-01-22 11:40:55 +08:00
|
|
|
ctx->alpn_client_proto_list = OPENSSL_malloc(protos_len);
|
2015-10-30 18:05:53 +08:00
|
|
|
if (ctx->alpn_client_proto_list == NULL)
|
2015-01-22 11:40:55 +08:00
|
|
|
return 1;
|
|
|
|
memcpy(ctx->alpn_client_proto_list, protos, protos_len);
|
|
|
|
ctx->alpn_client_proto_list_len = protos_len;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* SSL_set_alpn_protos sets the ALPN protocol list on |ssl| to |protos|.
|
2013-04-16 06:07:47 +08:00
|
|
|
* |protos| must be in wire-format (i.e. a series of non-empty, 8-bit
|
2015-01-22 11:40:55 +08:00
|
|
|
* length-prefixed strings). Returns 0 on success.
|
|
|
|
*/
|
|
|
|
int SSL_set_alpn_protos(SSL *ssl, const unsigned char *protos,
|
|
|
|
unsigned protos_len)
|
|
|
|
{
|
2015-05-02 02:37:16 +08:00
|
|
|
OPENSSL_free(ssl->alpn_client_proto_list);
|
2015-01-22 11:40:55 +08:00
|
|
|
ssl->alpn_client_proto_list = OPENSSL_malloc(protos_len);
|
2015-10-30 18:05:53 +08:00
|
|
|
if (ssl->alpn_client_proto_list == NULL)
|
2015-01-22 11:40:55 +08:00
|
|
|
return 1;
|
|
|
|
memcpy(ssl->alpn_client_proto_list, protos, protos_len);
|
|
|
|
ssl->alpn_client_proto_list_len = protos_len;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* SSL_CTX_set_alpn_select_cb sets a callback function on |ctx| that is
|
|
|
|
* called during ClientHello processing in order to select an ALPN protocol
|
|
|
|
* from the client's list of offered protocols.
|
|
|
|
*/
|
|
|
|
void SSL_CTX_set_alpn_select_cb(SSL_CTX *ctx,
|
|
|
|
int (*cb) (SSL *ssl,
|
|
|
|
const unsigned char **out,
|
|
|
|
unsigned char *outlen,
|
|
|
|
const unsigned char *in,
|
|
|
|
unsigned int inlen,
|
|
|
|
void *arg), void *arg)
|
|
|
|
{
|
|
|
|
ctx->alpn_select_cb = cb;
|
|
|
|
ctx->alpn_select_cb_arg = arg;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* SSL_get0_alpn_selected gets the selected ALPN protocol (if any) from
|
|
|
|
* |ssl|. On return it sets |*data| to point to |*len| bytes of protocol name
|
|
|
|
* (not including the leading length-prefix byte). If the server didn't
|
|
|
|
* respond with a negotiated protocol then |*len| will be zero.
|
|
|
|
*/
|
2013-04-16 06:07:47 +08:00
|
|
|
void SSL_get0_alpn_selected(const SSL *ssl, const unsigned char **data,
|
2015-01-22 11:40:55 +08:00
|
|
|
unsigned *len)
|
|
|
|
{
|
|
|
|
*data = NULL;
|
|
|
|
if (ssl->s3)
|
|
|
|
*data = ssl->s3->alpn_selected;
|
|
|
|
if (*data == NULL)
|
|
|
|
*len = 0;
|
|
|
|
else
|
|
|
|
*len = ssl->s3->alpn_selected_len;
|
|
|
|
}
|
|
|
|
|
2006-01-03 11:27:19 +08:00
|
|
|
|
2012-02-22 23:06:56 +08:00
|
|
|
int SSL_export_keying_material(SSL *s, unsigned char *out, size_t olen,
|
2015-01-22 11:40:55 +08:00
|
|
|
const char *label, size_t llen,
|
|
|
|
const unsigned char *p, size_t plen,
|
|
|
|
int use_context)
|
|
|
|
{
|
|
|
|
if (s->version < TLS1_VERSION)
|
|
|
|
return -1;
|
2011-11-16 07:50:52 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
return s->method->ssl3_enc->export_keying_material(s, out, olen, label,
|
|
|
|
llen, p, plen,
|
|
|
|
use_context);
|
|
|
|
}
|
2011-11-16 07:50:52 +08:00
|
|
|
|
2008-05-26 19:24:29 +08:00
|
|
|
static unsigned long ssl_session_hash(const SSL_SESSION *a)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
unsigned long l;
|
|
|
|
|
|
|
|
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);
|
|
|
|
return (l);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* NB: If this function (or indeed the hash function which uses a sort of
|
2001-02-22 02:06:26 +08:00
|
|
|
* coarser function than this one) is changed, ensure
|
2015-01-22 11:40:55 +08:00
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
static int ssl_session_cmp(const SSL_SESSION *a, const SSL_SESSION *b)
|
|
|
|
{
|
|
|
|
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));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* These wrapper functions should remain rather than redeclaring
|
2000-12-09 04:02:01 +08:00
|
|
|
* SSL_SESSION_hash and SSL_SESSION_cmp for void* types and casting each
|
2015-01-22 11:40:55 +08:00
|
|
|
* variable. The reason is that the functions aren't static, they're exposed
|
|
|
|
* via ssl.h.
|
|
|
|
*/
|
2008-05-26 19:24:29 +08:00
|
|
|
static IMPLEMENT_LHASH_HASH_FN(ssl_session, SSL_SESSION)
|
|
|
|
static IMPLEMENT_LHASH_COMP_FN(ssl_session, SSL_SESSION)
|
2000-12-04 11:02:44 +08:00
|
|
|
|
2005-08-15 05:48:33 +08:00
|
|
|
SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
SSL_CTX *ret = NULL;
|
|
|
|
|
|
|
|
if (meth == NULL) {
|
|
|
|
SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_NULL_SSL_METHOD_PASSED);
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (FIPS_mode() && (meth->version < TLS1_VERSION)) {
|
|
|
|
SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (SSL_get_ex_data_X509_STORE_CTX_idx() < 0) {
|
|
|
|
SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_X509_VERIFICATION_SETUP_PROBLEMS);
|
|
|
|
goto err;
|
|
|
|
}
|
2015-08-26 01:25:58 +08:00
|
|
|
ret = OPENSSL_zalloc(sizeof(*ret));
|
2015-01-22 11:40:55 +08:00
|
|
|
if (ret == NULL)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
ret->method = meth;
|
|
|
|
ret->session_cache_mode = SSL_SESS_CACHE_SERVER;
|
|
|
|
ret->session_cache_size = SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;
|
2015-09-03 21:15:26 +08:00
|
|
|
/* We take the system default. */
|
2015-01-22 11:40:55 +08:00
|
|
|
ret->session_timeout = meth->get_timeout();
|
|
|
|
ret->references = 1;
|
|
|
|
ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;
|
|
|
|
ret->verify_mode = SSL_VERIFY_NONE;
|
|
|
|
if ((ret->cert = ssl_cert_new()) == NULL)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
ret->sessions = lh_SSL_SESSION_new();
|
|
|
|
if (ret->sessions == NULL)
|
|
|
|
goto err;
|
|
|
|
ret->cert_store = X509_STORE_new();
|
|
|
|
if (ret->cert_store == NULL)
|
|
|
|
goto err;
|
|
|
|
|
2015-04-16 13:50:03 +08:00
|
|
|
if (!ssl_create_cipher_list(ret->method,
|
2015-01-22 11:40:55 +08:00
|
|
|
&ret->cipher_list, &ret->cipher_list_by_id,
|
2015-03-06 22:37:17 +08:00
|
|
|
SSL_DEFAULT_CIPHER_LIST, ret->cert)
|
|
|
|
|| sk_SSL_CIPHER_num(ret->cipher_list) <= 0) {
|
2015-01-22 11:40:55 +08:00
|
|
|
SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_LIBRARY_HAS_NO_CIPHERS);
|
|
|
|
goto err2;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret->param = X509_VERIFY_PARAM_new();
|
2015-10-30 18:05:53 +08:00
|
|
|
if (ret->param == NULL)
|
2015-01-22 11:40:55 +08:00
|
|
|
goto err;
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((ret->client_CA = sk_X509_NAME_new_null()) == NULL)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ret, &ret->ex_data);
|
|
|
|
|
|
|
|
/* No compression for DTLS */
|
|
|
|
if (!(meth->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS))
|
|
|
|
ret->comp_methods = SSL_COMP_get_compression_methods();
|
|
|
|
|
|
|
|
ret->max_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH;
|
2005-10-08 08:18:53 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
/* Setup RFC4507 ticket keys */
|
2015-02-26 19:57:37 +08:00
|
|
|
if ((RAND_bytes(ret->tlsext_tick_key_name, 16) <= 0)
|
2015-01-22 11:40:55 +08:00
|
|
|
|| (RAND_bytes(ret->tlsext_tick_hmac_key, 16) <= 0)
|
|
|
|
|| (RAND_bytes(ret->tlsext_tick_aes_key, 16) <= 0))
|
|
|
|
ret->options |= SSL_OP_NO_TICKET;
|
2007-08-12 07:18:29 +08:00
|
|
|
|
2011-03-13 01:01:19 +08:00
|
|
|
#ifndef OPENSSL_NO_SRP
|
2015-04-16 13:50:03 +08:00
|
|
|
if (!SSL_CTX_SRP_CTX_init(ret))
|
2015-03-06 22:37:17 +08:00
|
|
|
goto err;
|
2011-03-13 01:01:19 +08:00
|
|
|
#endif
|
2008-06-05 06:34:38 +08:00
|
|
|
#ifndef OPENSSL_NO_ENGINE
|
2015-01-22 11:40:55 +08:00
|
|
|
# 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));
|
|
|
|
if (!eng) {
|
|
|
|
ERR_clear_error();
|
|
|
|
ENGINE_load_builtin_engines();
|
|
|
|
eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));
|
|
|
|
}
|
|
|
|
if (!eng || !SSL_CTX_set_client_cert_engine(ret, eng))
|
|
|
|
ERR_clear_error();
|
|
|
|
}
|
|
|
|
# endif
|
|
|
|
#endif
|
|
|
|
/*
|
|
|
|
* Default is to connect to non-RI servers. When RI is more widely
|
|
|
|
* deployed might change this.
|
|
|
|
*/
|
|
|
|
ret->options |= SSL_OP_LEGACY_SERVER_CONNECT;
|
|
|
|
|
|
|
|
return (ret);
|
|
|
|
err:
|
|
|
|
SSLerr(SSL_F_SSL_CTX_NEW, ERR_R_MALLOC_FAILURE);
|
|
|
|
err2:
|
2015-04-12 04:32:54 +08:00
|
|
|
SSL_CTX_free(ret);
|
2015-01-22 11:40:55 +08:00
|
|
|
return (NULL);
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
1999-02-28 20:41:50 +08:00
|
|
|
void SSL_CTX_free(SSL_CTX *a)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
int i;
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
if (a == NULL)
|
|
|
|
return;
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
i = CRYPTO_add(&a->references, -1, CRYPTO_LOCK_SSL_CTX);
|
1998-12-21 18:56:39 +08:00
|
|
|
#ifdef REF_PRINT
|
2015-01-22 11:40:55 +08:00
|
|
|
REF_PRINT("SSL_CTX", a);
|
1998-12-21 18:56:39 +08:00
|
|
|
#endif
|
2015-01-22 11:40:55 +08:00
|
|
|
if (i > 0)
|
|
|
|
return;
|
1998-12-21 18:52:47 +08:00
|
|
|
#ifdef REF_CHECK
|
2015-01-22 11:40:55 +08:00
|
|
|
if (i < 0) {
|
|
|
|
fprintf(stderr, "SSL_CTX_free, bad reference count\n");
|
|
|
|
abort(); /* ok */
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2015-05-01 05:33:59 +08:00
|
|
|
X509_VERIFY_PARAM_free(a->param);
|
2015-01-22 11:40:55 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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].)
|
|
|
|
*/
|
|
|
|
if (a->sessions != NULL)
|
|
|
|
SSL_CTX_flush_sessions(a, 0);
|
|
|
|
|
|
|
|
CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL_CTX, a, &a->ex_data);
|
2015-05-02 02:37:16 +08:00
|
|
|
lh_SSL_SESSION_free(a->sessions);
|
2015-05-01 05:33:59 +08:00
|
|
|
X509_STORE_free(a->cert_store);
|
2015-05-02 02:37:16 +08:00
|
|
|
sk_SSL_CIPHER_free(a->cipher_list);
|
|
|
|
sk_SSL_CIPHER_free(a->cipher_list_by_id);
|
2015-04-12 04:32:54 +08:00
|
|
|
ssl_cert_free(a->cert);
|
2015-05-01 05:33:59 +08:00
|
|
|
sk_X509_NAME_pop_free(a->client_CA, X509_NAME_free);
|
|
|
|
sk_X509_pop_free(a->extra_certs, X509_free);
|
2015-01-22 11:40:55 +08:00
|
|
|
a->comp_methods = NULL;
|
2014-12-22 19:15:51 +08:00
|
|
|
#ifndef OPENSSL_NO_SRTP
|
2015-05-02 02:37:16 +08:00
|
|
|
sk_SRTP_PROTECTION_PROFILE_free(a->srtp_profiles);
|
2014-12-22 19:15:51 +08:00
|
|
|
#endif
|
2011-03-13 01:01:19 +08:00
|
|
|
#ifndef OPENSSL_NO_SRP
|
2015-01-22 11:40:55 +08:00
|
|
|
SSL_CTX_SRP_CTX_free(a);
|
2011-03-13 01:01:19 +08:00
|
|
|
#endif
|
2008-06-02 07:06:48 +08:00
|
|
|
#ifndef OPENSSL_NO_ENGINE
|
2015-01-22 11:40:55 +08:00
|
|
|
if (a->client_cert_engine)
|
|
|
|
ENGINE_finish(a->client_cert_engine);
|
2006-03-11 07:06:27 +08:00
|
|
|
#endif
|
2008-06-03 10:48:34 +08:00
|
|
|
|
2015-05-15 17:49:56 +08:00
|
|
|
#ifndef OPENSSL_NO_EC
|
2015-05-02 02:37:16 +08:00
|
|
|
OPENSSL_free(a->tlsext_ecpointformatlist);
|
|
|
|
OPENSSL_free(a->tlsext_ellipticcurvelist);
|
2008-06-03 10:48:34 +08:00
|
|
|
#endif
|
2015-05-15 17:49:56 +08:00
|
|
|
OPENSSL_free(a->alpn_client_proto_list);
|
2008-06-03 10:48:34 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
OPENSSL_free(a);
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
1999-05-14 19:52:49 +08:00
|
|
|
void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
ctx->default_passwd_callback = cb;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx, void *u)
|
|
|
|
{
|
|
|
|
ctx->default_passwd_callback_userdata = u;
|
|
|
|
}
|
|
|
|
|
2015-11-09 22:38:59 +08:00
|
|
|
void SSL_set_default_passwd_cb(SSL *s, pem_password_cb *cb)
|
|
|
|
{
|
|
|
|
s->default_passwd_callback = cb;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SSL_set_default_passwd_cb_userdata(SSL *s, void *u)
|
|
|
|
{
|
|
|
|
s->default_passwd_callback_userdata = u;
|
|
|
|
}
|
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx,
|
|
|
|
int (*cb) (X509_STORE_CTX *, void *),
|
|
|
|
void *arg)
|
|
|
|
{
|
|
|
|
ctx->app_verify_callback = cb;
|
|
|
|
ctx->app_verify_arg = arg;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SSL_CTX_set_verify(SSL_CTX *ctx, int mode,
|
|
|
|
int (*cb) (int, X509_STORE_CTX *))
|
|
|
|
{
|
|
|
|
ctx->verify_mode = mode;
|
|
|
|
ctx->default_verify_callback = cb;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SSL_CTX_set_verify_depth(SSL_CTX *ctx, int depth)
|
|
|
|
{
|
|
|
|
X509_VERIFY_PARAM_set_depth(ctx->param, depth);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SSL_CTX_set_cert_cb(SSL_CTX *c, int (*cb) (SSL *ssl, void *arg),
|
|
|
|
void *arg)
|
|
|
|
{
|
|
|
|
ssl_cert_set_cert_cb(c->cert, cb, arg);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SSL_set_cert_cb(SSL *s, int (*cb) (SSL *ssl, void *arg), void *arg)
|
|
|
|
{
|
|
|
|
ssl_cert_set_cert_cb(s->cert, cb, arg);
|
|
|
|
}
|
2012-06-29 22:24:42 +08:00
|
|
|
|
2015-05-13 05:17:34 +08:00
|
|
|
void ssl_set_masks(SSL *s, const SSL_CIPHER *cipher)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
CERT_PKEY *cpk;
|
2015-05-13 05:17:34 +08:00
|
|
|
CERT *c = s->cert;
|
2015-07-15 06:19:11 +08:00
|
|
|
uint32_t *pvalid = s->s3->tmp.valid_flags;
|
2015-12-05 09:04:41 +08:00
|
|
|
int rsa_enc, rsa_sign, dh_tmp, dh_rsa, dh_dsa, dsa_sign;
|
|
|
|
unsigned long mask_k, mask_a;
|
2015-03-11 07:09:27 +08:00
|
|
|
#ifndef OPENSSL_NO_EC
|
2015-12-05 09:04:41 +08:00
|
|
|
int have_ecc_cert, ecdsa_ok;
|
2015-12-05 05:30:36 +08:00
|
|
|
int ecdh_ok;
|
2015-01-22 11:40:55 +08:00
|
|
|
X509 *x = NULL;
|
2015-09-03 05:01:18 +08:00
|
|
|
int pk_nid = 0, md_nid = 0;
|
2013-08-18 00:40:08 +08:00
|
|
|
#endif
|
2015-01-22 11:40:55 +08:00
|
|
|
if (c == NULL)
|
|
|
|
return;
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2001-02-20 16:13:47 +08:00
|
|
|
#ifndef OPENSSL_NO_DH
|
2015-01-22 11:40:55 +08:00
|
|
|
dh_tmp = (c->dh_tmp != NULL || c->dh_tmp_cb != NULL || c->dh_tmp_auto);
|
1998-12-21 18:52:47 +08:00
|
|
|
#else
|
2015-12-05 09:04:41 +08:00
|
|
|
dh_tmp = 0;
|
1998-12-21 18:52:47 +08:00
|
|
|
#endif
|
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
cpk = &(c->pkeys[SSL_PKEY_RSA_ENC]);
|
2015-05-13 05:17:34 +08:00
|
|
|
rsa_enc = pvalid[SSL_PKEY_RSA_ENC] & CERT_PKEY_VALID;
|
2015-01-22 11:40:55 +08:00
|
|
|
cpk = &(c->pkeys[SSL_PKEY_RSA_SIGN]);
|
2015-05-13 05:17:34 +08:00
|
|
|
rsa_sign = pvalid[SSL_PKEY_RSA_SIGN] & CERT_PKEY_SIGN;
|
2015-01-22 11:40:55 +08:00
|
|
|
cpk = &(c->pkeys[SSL_PKEY_DSA_SIGN]);
|
2015-05-13 05:17:34 +08:00
|
|
|
dsa_sign = pvalid[SSL_PKEY_DSA_SIGN] & CERT_PKEY_SIGN;
|
2015-01-22 11:40:55 +08:00
|
|
|
cpk = &(c->pkeys[SSL_PKEY_DH_RSA]);
|
2015-05-13 05:17:34 +08:00
|
|
|
dh_rsa = pvalid[SSL_PKEY_DH_RSA] & CERT_PKEY_VALID;
|
2015-01-22 11:40:55 +08:00
|
|
|
cpk = &(c->pkeys[SSL_PKEY_DH_DSA]);
|
2015-05-13 05:17:34 +08:00
|
|
|
dh_dsa = pvalid[SSL_PKEY_DH_DSA] & CERT_PKEY_VALID;
|
2015-01-22 11:40:55 +08:00
|
|
|
cpk = &(c->pkeys[SSL_PKEY_ECC]);
|
2013-08-18 00:40:08 +08:00
|
|
|
#ifndef OPENSSL_NO_EC
|
2015-05-13 05:17:34 +08:00
|
|
|
have_ecc_cert = pvalid[SSL_PKEY_ECC] & CERT_PKEY_VALID;
|
2013-08-18 00:40:08 +08:00
|
|
|
#endif
|
2015-01-22 11:40:55 +08:00
|
|
|
mask_k = 0;
|
|
|
|
mask_a = 0;
|
1. Changes for s_client.c to make it return non-zero exit code in case
of handshake failure
2. Changes to x509_certificate_type function (crypto/x509/x509type.c) to
make it recognize GOST certificates as EVP_PKT_SIGN|EVP_PKT_EXCH
(required for s3_srvr to accept GOST client certificates).
3. Changes to EVP
- adding of function EVP_PKEY_CTX_get0_peerkey
- Make function EVP_PKEY_derive_set_peerkey work for context with
ENCRYPT operation, because we use peerkey field in the context to
pass non-ephemeral secret key to GOST encrypt operation.
- added EVP_PKEY_CTRL_SET_IV control command. It is really
GOST-specific, but it is used in SSL code, so it has to go
in some header file, available during libssl compilation
4. Fix to HMAC to avoid call of OPENSSL_cleanse on undefined data
5. Include des.h if KSSL_DEBUG is defined into some libssl files, to
make debugging output which depends on constants defined there, work
and other KSSL_DEBUG output fixes
6. Declaration of real GOST ciphersuites, two authentication methods
SSL_aGOST94 and SSL_aGOST2001 and one key exchange method SSL_kGOST
7. Implementation of these methods.
8. Support for sending unsolicited serverhello extension if GOST
ciphersuite is selected. It is require for interoperability with
CryptoPro CSP 3.0 and 3.6 and controlled by
SSL_OP_CRYPTOPRO_TLSEXT_BUG constant.
This constant is added to SSL_OP_ALL, because it does nothing, if
non-GOST ciphersuite is selected, and all implementation of GOST
include compatibility with CryptoPro.
9. Support for CertificateVerify message without length field. It is
another CryptoPro bug, but support is made unconditional, because it
does no harm for draft-conforming implementation.
10. In tls1_mac extra copy of stream mac context is no more done.
When I've written currently commited code I haven't read
EVP_DigestSignFinal manual carefully enough and haven't noticed that
it does an internal digest ctx copying.
This implementation was tested against
1. CryptoPro CSP 3.6 client and server
2. Cryptopro CSP 3.0 server
2007-10-26 20:06:36 +08:00
|
|
|
|
1998-12-21 18:52:47 +08:00
|
|
|
#ifdef CIPHER_DEBUG
|
2015-01-22 11:40:55 +08:00
|
|
|
fprintf(stderr,
|
2015-12-05 09:04:41 +08:00
|
|
|
"dht=%d re=%d rs=%d ds=%d dhr=%d dhd=%d\n",
|
|
|
|
dh_tmp, rsa_enc, rsa_sign, dsa_sign, dh_rsa, dh_dsa);
|
2015-01-22 11:40:55 +08:00
|
|
|
#endif
|
|
|
|
|
2015-11-24 21:52:07 +08:00
|
|
|
#ifndef OPENSSL_NO_GOST
|
2015-11-17 23:32:30 +08:00
|
|
|
cpk = &(c->pkeys[SSL_PKEY_GOST12_512]);
|
|
|
|
if (cpk->x509 != NULL && cpk->privatekey != NULL) {
|
|
|
|
mask_k |= SSL_kGOST;
|
|
|
|
mask_a |= SSL_aGOST12;
|
|
|
|
}
|
|
|
|
cpk = &(c->pkeys[SSL_PKEY_GOST12_256]);
|
|
|
|
if (cpk->x509 != NULL && cpk->privatekey != NULL) {
|
|
|
|
mask_k |= SSL_kGOST;
|
|
|
|
mask_a |= SSL_aGOST12;
|
|
|
|
}
|
2015-01-22 11:40:55 +08:00
|
|
|
cpk = &(c->pkeys[SSL_PKEY_GOST01]);
|
|
|
|
if (cpk->x509 != NULL && cpk->privatekey != NULL) {
|
|
|
|
mask_k |= SSL_kGOST;
|
|
|
|
mask_a |= SSL_aGOST01;
|
|
|
|
}
|
2015-11-24 21:52:07 +08:00
|
|
|
#endif
|
2015-01-22 11:40:55 +08:00
|
|
|
|
2015-12-05 09:04:41 +08:00
|
|
|
if (rsa_enc)
|
2015-01-22 11:40:55 +08:00
|
|
|
mask_k |= SSL_kRSA;
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
if (dh_tmp)
|
|
|
|
mask_k |= SSL_kDHE;
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
if (dh_rsa)
|
|
|
|
mask_k |= SSL_kDHr;
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
if (dh_dsa)
|
|
|
|
mask_k |= SSL_kDHd;
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-05-22 20:48:49 +08:00
|
|
|
if (mask_k & (SSL_kDHr | SSL_kDHd))
|
2015-01-22 11:40:55 +08:00
|
|
|
mask_a |= SSL_aDH;
|
2012-01-17 02:19:14 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
if (rsa_enc || rsa_sign) {
|
|
|
|
mask_a |= SSL_aRSA;
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
if (dsa_sign) {
|
|
|
|
mask_a |= SSL_aDSS;
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
mask_a |= SSL_aNULL;
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
/*
|
|
|
|
* An ECC certificate may be usable for ECDH and/or ECDSA cipher suites
|
|
|
|
* depending on the key usage extension.
|
|
|
|
*/
|
2013-08-18 00:40:08 +08:00
|
|
|
#ifndef OPENSSL_NO_EC
|
2015-01-22 11:40:55 +08:00
|
|
|
if (have_ecc_cert) {
|
2015-09-03 05:01:18 +08:00
|
|
|
uint32_t ex_kusage;
|
2015-01-22 11:40:55 +08:00
|
|
|
cpk = &c->pkeys[SSL_PKEY_ECC];
|
|
|
|
x = cpk->x509;
|
2015-09-03 05:01:18 +08:00
|
|
|
ex_kusage = X509_get_key_usage(x);
|
|
|
|
ecdh_ok = ex_kusage & X509v3_KU_KEY_AGREEMENT;
|
|
|
|
ecdsa_ok = ex_kusage & X509v3_KU_DIGITAL_SIGNATURE;
|
2015-05-13 05:17:34 +08:00
|
|
|
if (!(pvalid[SSL_PKEY_ECC] & CERT_PKEY_SIGN))
|
2015-01-22 11:40:55 +08:00
|
|
|
ecdsa_ok = 0;
|
2015-09-03 05:01:18 +08:00
|
|
|
OBJ_find_sigid_algs(X509_get_signature_nid(x), &md_nid, &pk_nid);
|
2015-01-22 11:40:55 +08:00
|
|
|
if (ecdh_ok) {
|
|
|
|
|
|
|
|
if (pk_nid == NID_rsaEncryption || pk_nid == NID_rsa) {
|
|
|
|
mask_k |= SSL_kECDHr;
|
|
|
|
mask_a |= SSL_aECDH;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pk_nid == NID_X9_62_id_ecPublicKey) {
|
|
|
|
mask_k |= SSL_kECDHe;
|
|
|
|
mask_a |= SSL_aECDH;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (ecdsa_ok) {
|
|
|
|
mask_a |= SSL_aECDSA;
|
|
|
|
}
|
|
|
|
}
|
2013-08-18 00:40:08 +08:00
|
|
|
#endif
|
2002-08-09 16:56:08 +08:00
|
|
|
|
2015-03-11 07:09:27 +08:00
|
|
|
#ifndef OPENSSL_NO_EC
|
2015-12-05 05:30:36 +08:00
|
|
|
mask_k |= SSL_kECDHE;
|
2002-08-09 16:56:08 +08:00
|
|
|
#endif
|
2006-03-11 07:06:27 +08:00
|
|
|
|
|
|
|
#ifndef OPENSSL_NO_PSK
|
2015-01-22 11:40:55 +08:00
|
|
|
mask_k |= SSL_kPSK;
|
|
|
|
mask_a |= SSL_aPSK;
|
2015-06-29 00:02:56 +08:00
|
|
|
if (mask_k & SSL_kRSA)
|
|
|
|
mask_k |= SSL_kRSAPSK;
|
|
|
|
if (mask_k & SSL_kDHE)
|
|
|
|
mask_k |= SSL_kDHEPSK;
|
|
|
|
if (mask_k & SSL_kECDHE)
|
|
|
|
mask_k |= SSL_kECDHEPSK;
|
2006-03-11 07:06:27 +08:00
|
|
|
#endif
|
|
|
|
|
2015-05-19 06:29:57 +08:00
|
|
|
s->s3->tmp.mask_k = mask_k;
|
|
|
|
s->s3->tmp.mask_a = mask_a;
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2009-04-24 00:32:42 +08:00
|
|
|
#ifndef OPENSSL_NO_EC
|
|
|
|
|
2011-05-09 23:44:01 +08:00
|
|
|
int ssl_check_srvr_ecc_cert_and_alg(X509 *x, SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
unsigned long alg_k, alg_a;
|
2015-09-03 05:01:18 +08:00
|
|
|
int md_nid = 0, pk_nid = 0;
|
2015-01-22 11:40:55 +08:00
|
|
|
const SSL_CIPHER *cs = s->s3->tmp.new_cipher;
|
2015-09-03 05:01:18 +08:00
|
|
|
uint32_t ex_kusage = X509_get_key_usage(x);
|
2015-01-22 11:40:55 +08:00
|
|
|
|
|
|
|
alg_k = cs->algorithm_mkey;
|
|
|
|
alg_a = cs->algorithm_auth;
|
|
|
|
|
2015-09-03 05:01:18 +08:00
|
|
|
OBJ_find_sigid_algs(X509_get_signature_nid(x), &md_nid, &pk_nid);
|
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
if (alg_k & SSL_kECDHe || alg_k & SSL_kECDHr) {
|
|
|
|
/* key usage, if present, must allow key agreement */
|
2015-09-03 05:01:18 +08:00
|
|
|
if (!(ex_kusage & X509v3_KU_KEY_AGREEMENT)) {
|
2015-01-22 11:40:55 +08:00
|
|
|
SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG,
|
|
|
|
SSL_R_ECC_CERT_NOT_FOR_KEY_AGREEMENT);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if ((alg_k & SSL_kECDHe) && TLS1_get_version(s) < TLS1_2_VERSION) {
|
|
|
|
/* signature alg must be ECDSA */
|
|
|
|
if (pk_nid != NID_X9_62_id_ecPublicKey) {
|
|
|
|
SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG,
|
|
|
|
SSL_R_ECC_CERT_SHOULD_HAVE_SHA1_SIGNATURE);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ((alg_k & SSL_kECDHr) && TLS1_get_version(s) < TLS1_2_VERSION) {
|
|
|
|
/* signature alg must be RSA */
|
|
|
|
|
|
|
|
if (pk_nid != NID_rsaEncryption && pk_nid != NID_rsa) {
|
|
|
|
SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG,
|
|
|
|
SSL_R_ECC_CERT_SHOULD_HAVE_RSA_SIGNATURE);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (alg_a & SSL_aECDSA) {
|
|
|
|
/* key usage, if present, must allow signing */
|
2015-09-03 05:01:18 +08:00
|
|
|
if (!(ex_kusage & X509v3_KU_DIGITAL_SIGNATURE)) {
|
2015-01-22 11:40:55 +08:00
|
|
|
SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG,
|
|
|
|
SSL_R_ECC_CERT_NOT_FOR_SIGNING);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1; /* all checks are ok */
|
|
|
|
}
|
2002-08-09 16:56:08 +08:00
|
|
|
|
2009-04-24 00:32:42 +08:00
|
|
|
#endif
|
|
|
|
|
2012-09-11 20:57:46 +08:00
|
|
|
static int ssl_get_server_cert_index(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
int idx;
|
|
|
|
idx = ssl_cipher_get_cert_index(s->s3->tmp.new_cipher);
|
|
|
|
if (idx == SSL_PKEY_RSA_ENC && !s->cert->pkeys[SSL_PKEY_RSA_ENC].x509)
|
|
|
|
idx = SSL_PKEY_RSA_SIGN;
|
2015-11-17 23:32:30 +08:00
|
|
|
if (idx == SSL_PKEY_GOST_EC) {
|
|
|
|
if (s->cert->pkeys[SSL_PKEY_GOST12_512].x509)
|
|
|
|
idx = SSL_PKEY_GOST12_512;
|
|
|
|
else if (s->cert->pkeys[SSL_PKEY_GOST12_256].x509)
|
|
|
|
idx = SSL_PKEY_GOST12_256;
|
|
|
|
else if (s->cert->pkeys[SSL_PKEY_GOST01].x509)
|
|
|
|
idx = SSL_PKEY_GOST01;
|
|
|
|
else
|
|
|
|
idx = -1;
|
|
|
|
}
|
2015-01-22 11:40:55 +08:00
|
|
|
if (idx == -1)
|
|
|
|
SSLerr(SSL_F_SSL_GET_SERVER_CERT_INDEX, ERR_R_INTERNAL_ERROR);
|
|
|
|
return idx;
|
|
|
|
}
|
2012-05-30 18:10:58 +08:00
|
|
|
|
2015-05-13 05:17:34 +08:00
|
|
|
CERT_PKEY *ssl_get_server_send_pkey(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
CERT *c;
|
|
|
|
int i;
|
2002-08-09 16:56:08 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
c = s->cert;
|
|
|
|
if (!s->s3 || !s->s3->tmp.new_cipher)
|
|
|
|
return NULL;
|
2015-05-13 05:17:34 +08:00
|
|
|
ssl_set_masks(s, s->s3->tmp.new_cipher);
|
2012-05-30 18:10:58 +08:00
|
|
|
|
2012-08-29 21:18:34 +08:00
|
|
|
#ifdef OPENSSL_SSL_DEBUG_BROKEN_PROTOCOL
|
2015-01-22 11:40:55 +08:00
|
|
|
/*
|
|
|
|
* Broken protocol test: return last used certificate: which may mismatch
|
|
|
|
* the one expected.
|
|
|
|
*/
|
|
|
|
if (c->cert_flags & SSL_CERT_FLAG_BROKEN_PROTOCOL)
|
|
|
|
return c->key;
|
2012-08-29 21:18:34 +08:00
|
|
|
#endif
|
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
i = ssl_get_server_cert_index(s);
|
2012-05-30 18:10:58 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
/* This may or may not be an error. */
|
|
|
|
if (i < 0)
|
|
|
|
return NULL;
|
2012-05-30 18:10:58 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
/* May be NULL. */
|
|
|
|
return &c->pkeys[i];
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
EVP_PKEY *ssl_get_sign_pkey(SSL *s, const SSL_CIPHER *cipher,
|
|
|
|
const EVP_MD **pmd)
|
|
|
|
{
|
|
|
|
unsigned long alg_a;
|
|
|
|
CERT *c;
|
|
|
|
int idx = -1;
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
alg_a = cipher->algorithm_auth;
|
|
|
|
c = s->cert;
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2012-08-29 21:18:34 +08:00
|
|
|
#ifdef OPENSSL_SSL_DEBUG_BROKEN_PROTOCOL
|
2015-01-22 11:40:55 +08:00
|
|
|
/*
|
|
|
|
* Broken protocol test: use last key: which may mismatch the one
|
|
|
|
* expected.
|
|
|
|
*/
|
|
|
|
if (c->cert_flags & SSL_CERT_FLAG_BROKEN_PROTOCOL)
|
|
|
|
idx = c->key - c->pkeys;
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if ((alg_a & SSL_aDSS) &&
|
|
|
|
(c->pkeys[SSL_PKEY_DSA_SIGN].privatekey != NULL))
|
|
|
|
idx = SSL_PKEY_DSA_SIGN;
|
|
|
|
else if (alg_a & SSL_aRSA) {
|
|
|
|
if (c->pkeys[SSL_PKEY_RSA_SIGN].privatekey != NULL)
|
|
|
|
idx = SSL_PKEY_RSA_SIGN;
|
|
|
|
else if (c->pkeys[SSL_PKEY_RSA_ENC].privatekey != NULL)
|
|
|
|
idx = SSL_PKEY_RSA_ENC;
|
|
|
|
} else if ((alg_a & SSL_aECDSA) &&
|
|
|
|
(c->pkeys[SSL_PKEY_ECC].privatekey != NULL))
|
|
|
|
idx = SSL_PKEY_ECC;
|
|
|
|
if (idx == -1) {
|
|
|
|
SSLerr(SSL_F_SSL_GET_SIGN_PKEY, ERR_R_INTERNAL_ERROR);
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
if (pmd)
|
2015-05-13 01:56:39 +08:00
|
|
|
*pmd = s->s3->tmp.md[idx];
|
2015-01-22 11:40:55 +08:00
|
|
|
return c->pkeys[idx].privatekey;
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2013-05-13 09:55:27 +08:00
|
|
|
int ssl_get_server_cert_serverinfo(SSL *s, const unsigned char **serverinfo,
|
2015-01-22 11:40:55 +08:00
|
|
|
size_t *serverinfo_length)
|
|
|
|
{
|
|
|
|
CERT *c = NULL;
|
|
|
|
int i = 0;
|
|
|
|
*serverinfo_length = 0;
|
|
|
|
|
|
|
|
c = s->cert;
|
|
|
|
i = ssl_get_server_cert_index(s);
|
|
|
|
|
|
|
|
if (i == -1)
|
|
|
|
return 0;
|
|
|
|
if (c->pkeys[i].serverinfo == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
*serverinfo = c->pkeys[i].serverinfo;
|
|
|
|
*serverinfo_length = c->pkeys[i].serverinfo_length;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ssl_update_cache(SSL *s, int mode)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
|
|
|
i = s->session_ctx->session_cache_mode;
|
|
|
|
if ((i & mode) && (!s->hit)
|
|
|
|
&& ((i & SSL_SESS_CACHE_NO_INTERNAL_STORE)
|
|
|
|
|| SSL_CTX_add_session(s->session_ctx, s->session))
|
|
|
|
&& (s->session_ctx->new_session_cb != NULL)) {
|
|
|
|
CRYPTO_add(&s->session->references, 1, CRYPTO_LOCK_SSL_SESSION);
|
|
|
|
if (!s->session_ctx->new_session_cb(s, s->session))
|
|
|
|
SSL_SESSION_free(s->session);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* auto flush every 255 connections */
|
|
|
|
if ((!(i & SSL_SESS_CACHE_NO_AUTO_CLEAR)) && ((i & mode) == mode)) {
|
|
|
|
if ((((mode & SSL_SESS_CACHE_CLIENT)
|
|
|
|
? s->session_ctx->stats.sess_connect_good
|
|
|
|
: s->session_ctx->stats.sess_accept_good) & 0xff) == 0xff) {
|
|
|
|
SSL_CTX_flush_sessions(s->session_ctx, (unsigned long)time(NULL));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2014-01-16 22:06:19 +08:00
|
|
|
const SSL_METHOD *SSL_CTX_get_ssl_method(SSL_CTX *ctx)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return ctx->method;
|
|
|
|
}
|
2014-01-16 22:06:19 +08:00
|
|
|
|
2005-08-15 05:48:33 +08:00
|
|
|
const SSL_METHOD *SSL_get_ssl_method(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return (s->method);
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2005-08-15 05:48:33 +08:00
|
|
|
int SSL_set_ssl_method(SSL *s, const SSL_METHOD *meth)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
int SSL_get_error(const SSL *s, int i)
|
|
|
|
{
|
|
|
|
int reason;
|
|
|
|
unsigned long l;
|
|
|
|
BIO *bio;
|
|
|
|
|
|
|
|
if (i > 0)
|
|
|
|
return (SSL_ERROR_NONE);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
}
|
|
|
|
|
|
|
|
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))
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
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);
|
|
|
|
else if (reason == BIO_RR_ACCEPT)
|
|
|
|
return (SSL_ERROR_WANT_ACCEPT);
|
|
|
|
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))
|
|
|
|
/*
|
|
|
|
* See above (SSL_want_read(s) with BIO_should_write(bio))
|
|
|
|
*/
|
|
|
|
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);
|
|
|
|
else if (reason == BIO_RR_ACCEPT)
|
|
|
|
return (SSL_ERROR_WANT_ACCEPT);
|
|
|
|
else
|
|
|
|
return (SSL_ERROR_SYSCALL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ((i < 0) && SSL_want_x509_lookup(s)) {
|
|
|
|
return (SSL_ERROR_WANT_X509_LOOKUP);
|
|
|
|
}
|
2015-02-14 07:28:49 +08:00
|
|
|
if ((i < 0) && SSL_want_async(s)) {
|
|
|
|
return SSL_ERROR_WANT_ASYNC;
|
|
|
|
}
|
2015-01-22 11:40:55 +08:00
|
|
|
|
|
|
|
if (i == 0) {
|
|
|
|
if ((s->shutdown & SSL_RECEIVED_SHUTDOWN) &&
|
|
|
|
(s->s3->warn_alert == SSL_AD_CLOSE_NOTIFY))
|
|
|
|
return (SSL_ERROR_ZERO_RETURN);
|
|
|
|
}
|
|
|
|
return (SSL_ERROR_SYSCALL);
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2015-10-06 22:57:50 +08:00
|
|
|
static int ssl_do_handshake_intern(void *vargs)
|
|
|
|
{
|
|
|
|
struct ssl_async_args *args;
|
|
|
|
SSL *s;
|
|
|
|
|
|
|
|
args = (struct ssl_async_args *)vargs;
|
|
|
|
s = args->s;
|
|
|
|
|
|
|
|
return s->handshake_func(s);
|
|
|
|
}
|
|
|
|
|
1999-02-28 20:41:50 +08:00
|
|
|
int SSL_do_handshake(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
int ret = 1;
|
|
|
|
|
|
|
|
if (s->handshake_func == NULL) {
|
|
|
|
SSLerr(SSL_F_SSL_DO_HANDSHAKE, SSL_R_CONNECTION_TYPE_NOT_SET);
|
2015-10-06 22:57:50 +08:00
|
|
|
return -1;
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
s->method->ssl_renegotiate_check(s);
|
|
|
|
|
|
|
|
if (SSL_in_init(s) || SSL_in_before(s)) {
|
2015-10-06 22:57:50 +08:00
|
|
|
if((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
|
|
|
|
struct ssl_async_args args;
|
|
|
|
|
|
|
|
args.s = s;
|
|
|
|
|
2015-10-09 23:47:43 +08:00
|
|
|
ret = ssl_start_async_job(s, &args, ssl_do_handshake_intern);
|
2015-10-06 22:57:50 +08:00
|
|
|
} else {
|
|
|
|
ret = s->handshake_func(s);
|
|
|
|
}
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
2015-10-06 22:57:50 +08:00
|
|
|
return ret;
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
|
|
|
|
1999-02-28 20:41:50 +08:00
|
|
|
void SSL_set_accept_state(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
s->server = 1;
|
|
|
|
s->shutdown = 0;
|
2015-10-05 17:39:54 +08:00
|
|
|
ossl_statem_clear(s);
|
2015-01-22 11:40:55 +08:00
|
|
|
s->handshake_func = s->method->ssl_accept;
|
2015-06-13 22:50:00 +08:00
|
|
|
clear_ciphers(s);
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
1999-02-28 20:41:50 +08:00
|
|
|
void SSL_set_connect_state(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
s->server = 0;
|
|
|
|
s->shutdown = 0;
|
2015-10-05 17:39:54 +08:00
|
|
|
ossl_statem_clear(s);
|
2015-01-22 11:40:55 +08:00
|
|
|
s->handshake_func = s->method->ssl_connect;
|
2015-06-13 22:50:00 +08:00
|
|
|
clear_ciphers(s);
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
1999-02-28 20:41:50 +08:00
|
|
|
int ssl_undefined_function(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
SSLerr(SSL_F_SSL_UNDEFINED_FUNCTION, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
|
|
|
|
return (0);
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2005-03-31 17:26:39 +08:00
|
|
|
int ssl_undefined_void_function(void)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
SSLerr(SSL_F_SSL_UNDEFINED_VOID_FUNCTION,
|
|
|
|
ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
|
|
|
|
return (0);
|
|
|
|
}
|
2005-03-31 17:26:39 +08:00
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
int ssl_undefined_const_function(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return (0);
|
|
|
|
}
|
2005-03-30 18:26:02 +08:00
|
|
|
|
1999-02-28 20:41:50 +08:00
|
|
|
SSL_METHOD *ssl_bad_method(int ver)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
SSLerr(SSL_F_SSL_BAD_METHOD, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
|
|
|
|
return (NULL);
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
const char *SSL_get_version(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
if (s->version == TLS1_2_VERSION)
|
|
|
|
return ("TLSv1.2");
|
|
|
|
else if (s->version == TLS1_1_VERSION)
|
|
|
|
return ("TLSv1.1");
|
|
|
|
else if (s->version == TLS1_VERSION)
|
|
|
|
return ("TLSv1");
|
|
|
|
else if (s->version == SSL3_VERSION)
|
|
|
|
return ("SSLv3");
|
2015-03-03 23:39:26 +08:00
|
|
|
else if (s->version == DTLS1_BAD_VER)
|
|
|
|
return ("DTLSv0.9");
|
|
|
|
else if (s->version == DTLS1_VERSION)
|
|
|
|
return ("DTLSv1");
|
|
|
|
else if (s->version == DTLS1_2_VERSION)
|
|
|
|
return ("DTLSv1.2");
|
2015-01-22 11:40:55 +08:00
|
|
|
else
|
|
|
|
return ("unknown");
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
1999-02-28 20:41:50 +08:00
|
|
|
SSL *SSL_dup(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
STACK_OF(X509_NAME) *sk;
|
|
|
|
X509_NAME *xn;
|
|
|
|
SSL *ret;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if ((ret = SSL_new(SSL_get_SSL_CTX(s))) == NULL)
|
|
|
|
return (NULL);
|
|
|
|
|
|
|
|
ret->version = s->version;
|
|
|
|
ret->method = s->method;
|
|
|
|
|
|
|
|
if (s->session != NULL) {
|
|
|
|
/* This copies session-id, SSL_METHOD, sid_ctx, and 'cert' */
|
2015-04-16 13:50:03 +08:00
|
|
|
if (!SSL_copy_session_id(ret, s))
|
2015-03-24 23:10:15 +08:00
|
|
|
goto err;
|
2015-01-22 11:40:55 +08:00
|
|
|
} 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
ret->method->ssl_free(ret);
|
|
|
|
ret->method = s->method;
|
|
|
|
ret->method->ssl_new(ret);
|
|
|
|
|
|
|
|
if (s->cert != NULL) {
|
2015-04-12 04:32:54 +08:00
|
|
|
ssl_cert_free(ret->cert);
|
2015-01-22 11:40:55 +08:00
|
|
|
ret->cert = ssl_cert_dup(s->cert);
|
|
|
|
if (ret->cert == NULL)
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
2015-04-16 13:50:03 +08:00
|
|
|
if (!SSL_set_session_id_context(ret, s->sid_ctx, s->sid_ctx_length))
|
2015-03-06 22:37:17 +08:00
|
|
|
goto err;
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ret->options = s->options;
|
|
|
|
ret->mode = s->mode;
|
|
|
|
SSL_set_max_cert_list(ret, SSL_get_max_cert_list(s));
|
|
|
|
SSL_set_read_ahead(ret, SSL_get_read_ahead(s));
|
|
|
|
ret->msg_callback = s->msg_callback;
|
|
|
|
ret->msg_callback_arg = s->msg_callback_arg;
|
|
|
|
SSL_set_verify(ret, SSL_get_verify_mode(s), SSL_get_verify_callback(s));
|
|
|
|
SSL_set_verify_depth(ret, SSL_get_verify_depth(s));
|
|
|
|
ret->generate_session_id = s->generate_session_id;
|
|
|
|
|
|
|
|
SSL_set_info_callback(ret, SSL_get_info_callback(s));
|
|
|
|
|
|
|
|
ret->debug = s->debug;
|
|
|
|
|
|
|
|
/* copy app data, a little dangerous perhaps */
|
|
|
|
if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_SSL, &ret->ex_data, &s->ex_data))
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
/* 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) {
|
|
|
|
if (!BIO_dup_state(s->wbio, (char *)&ret->wbio))
|
|
|
|
goto err;
|
|
|
|
} else
|
|
|
|
ret->wbio = ret->rbio;
|
|
|
|
}
|
|
|
|
ret->rwstate = s->rwstate;
|
|
|
|
ret->handshake_func = s->handshake_func;
|
|
|
|
ret->server = s->server;
|
|
|
|
ret->renegotiate = s->renegotiate;
|
|
|
|
ret->new_session = s->new_session;
|
|
|
|
ret->quiet_shutdown = s->quiet_shutdown;
|
|
|
|
ret->shutdown = s->shutdown;
|
2015-09-08 16:13:50 +08:00
|
|
|
ret->statem = s->statem; /* SSL_dup does not really work at any state,
|
|
|
|
* though */
|
2015-02-03 18:48:28 +08:00
|
|
|
RECORD_LAYER_dup(&ret->rlayer, &s->rlayer);
|
2015-01-22 11:40:55 +08:00
|
|
|
ret->init_num = 0; /* would have to copy ret->init_buf,
|
|
|
|
* ret->init_msg, ret->init_num,
|
|
|
|
* ret->init_off */
|
|
|
|
ret->hit = s->hit;
|
|
|
|
|
2015-11-09 22:38:59 +08:00
|
|
|
ret->default_passwd_callback = s->default_passwd_callback;
|
|
|
|
ret->default_passwd_callback_userdata = s->default_passwd_callback_userdata;
|
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
X509_VERIFY_PARAM_inherit(ret->param, s->param);
|
|
|
|
|
|
|
|
/* dup the cipher_list and cipher_list_by_id stacks */
|
|
|
|
if (s->cipher_list != NULL) {
|
|
|
|
if ((ret->cipher_list = sk_SSL_CIPHER_dup(s->cipher_list)) == NULL)
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
if (s->cipher_list_by_id != NULL)
|
|
|
|
if ((ret->cipher_list_by_id = sk_SSL_CIPHER_dup(s->cipher_list_by_id))
|
|
|
|
== NULL)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
/* Dup the client_CA list */
|
|
|
|
if (s->client_CA != NULL) {
|
|
|
|
if ((sk = sk_X509_NAME_dup(s->client_CA)) == NULL)
|
|
|
|
goto err;
|
|
|
|
ret->client_CA = sk;
|
|
|
|
for (i = 0; i < sk_X509_NAME_num(sk); i++) {
|
|
|
|
xn = sk_X509_NAME_value(sk, i);
|
|
|
|
if (sk_X509_NAME_set(sk, i, X509_NAME_dup(xn)) == NULL) {
|
|
|
|
X509_NAME_free(xn);
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-05-02 02:29:48 +08:00
|
|
|
return ret;
|
2015-01-22 11:40:55 +08:00
|
|
|
|
|
|
|
err:
|
2015-05-02 02:29:48 +08:00
|
|
|
SSL_free(ret);
|
|
|
|
return NULL;
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
1999-02-28 20:41:50 +08:00
|
|
|
void ssl_clear_cipher_ctx(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
if (s->enc_read_ctx != NULL) {
|
|
|
|
EVP_CIPHER_CTX_cleanup(s->enc_read_ctx);
|
|
|
|
OPENSSL_free(s->enc_read_ctx);
|
|
|
|
s->enc_read_ctx = NULL;
|
|
|
|
}
|
|
|
|
if (s->enc_write_ctx != NULL) {
|
|
|
|
EVP_CIPHER_CTX_cleanup(s->enc_write_ctx);
|
|
|
|
OPENSSL_free(s->enc_write_ctx);
|
|
|
|
s->enc_write_ctx = NULL;
|
|
|
|
}
|
2005-10-01 07:35:33 +08:00
|
|
|
#ifndef OPENSSL_NO_COMP
|
2015-05-01 22:15:18 +08:00
|
|
|
COMP_CTX_free(s->expand);
|
|
|
|
s->expand = NULL;
|
|
|
|
COMP_CTX_free(s->compress);
|
|
|
|
s->compress = NULL;
|
2015-01-22 11:40:55 +08:00
|
|
|
#endif
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
X509 *SSL_get_certificate(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
if (s->cert != NULL)
|
|
|
|
return (s->cert->key->x509);
|
|
|
|
else
|
|
|
|
return (NULL);
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2013-11-19 02:49:46 +08:00
|
|
|
EVP_PKEY *SSL_get_privatekey(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
if (s->cert != NULL)
|
|
|
|
return (s->cert->key->privatekey);
|
|
|
|
else
|
|
|
|
return (NULL);
|
|
|
|
}
|
1998-12-21 18:52:47 +08:00
|
|
|
|
2013-11-19 02:49:46 +08:00
|
|
|
X509 *SSL_CTX_get0_certificate(const SSL_CTX *ctx)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
if (ctx->cert != NULL)
|
|
|
|
return ctx->cert->key->x509;
|
|
|
|
else
|
|
|
|
return NULL;
|
|
|
|
}
|
2013-11-19 02:49:46 +08:00
|
|
|
|
|
|
|
EVP_PKEY *SSL_CTX_get0_privatekey(const SSL_CTX *ctx)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
if (ctx->cert != NULL)
|
|
|
|
return ctx->cert->key->privatekey;
|
|
|
|
else
|
|
|
|
return NULL;
|
|
|
|
}
|
2013-11-19 02:49:46 +08:00
|
|
|
|
2008-10-12 22:32:47 +08:00
|
|
|
const SSL_CIPHER *SSL_get_current_cipher(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
if ((s->session != NULL) && (s->session->cipher != NULL))
|
|
|
|
return (s->session->cipher);
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
2003-10-06 20:18:39 +08:00
|
|
|
const COMP_METHOD *SSL_get_current_compression(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
2015-05-09 00:05:36 +08:00
|
|
|
#ifndef OPENSSL_NO_COMP
|
|
|
|
return s->compress ? COMP_CTX_get_method(s->compress) : NULL;
|
|
|
|
#else
|
|
|
|
return NULL;
|
|
|
|
#endif
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
2003-10-06 20:18:39 +08:00
|
|
|
|
|
|
|
const COMP_METHOD *SSL_get_current_expansion(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
2015-05-09 00:05:36 +08:00
|
|
|
#ifndef OPENSSL_NO_COMP
|
|
|
|
return s->expand ? COMP_CTX_get_method(s->expand) : NULL;
|
|
|
|
#else
|
|
|
|
return NULL;
|
2015-01-22 11:40:55 +08:00
|
|
|
#endif
|
2015-05-09 00:05:36 +08:00
|
|
|
}
|
2015-01-22 11:40:55 +08:00
|
|
|
|
|
|
|
int ssl_init_wbio_buffer(SSL *s, int push)
|
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
(void)BIO_reset(bbio);
|
|
|
|
/* 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);
|
|
|
|
}
|
Updates to the new SSL compression code
[Eric A. Young, (from changes to C2Net SSLeay, integrated by Mark Cox)]
Fix so that the version number in the master secret, when passed
via RSA, checks that if TLS was proposed, but we roll back to SSLv3
(because the server will not accept higher), that the version number
is 0x03,0x01, not 0x03,0x00
[Eric A. Young, (from changes to C2Net SSLeay, integrated by Mark Cox)]
Submitted by:
Reviewed by:
PR:
1999-02-16 17:22:21 +08:00
|
|
|
|
1999-02-28 20:41:50 +08:00
|
|
|
void ssl_free_wbio_buffer(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
2015-04-11 22:22:36 +08:00
|
|
|
/* callers ensure s is never null */
|
2015-01-22 11:40:55 +08:00
|
|
|
if (s->bbio == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (s->bbio == s->wbio) {
|
|
|
|
/* remove buffering */
|
|
|
|
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);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
BIO_free(s->bbio);
|
|
|
|
s->bbio = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx, int mode)
|
|
|
|
{
|
|
|
|
ctx->quiet_shutdown = mode;
|
|
|
|
}
|
1998-12-21 18:56:39 +08:00
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
int SSL_CTX_get_quiet_shutdown(const SSL_CTX *ctx)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return (ctx->quiet_shutdown);
|
|
|
|
}
|
1998-12-21 18:56:39 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
void SSL_set_quiet_shutdown(SSL *s, int mode)
|
|
|
|
{
|
|
|
|
s->quiet_shutdown = mode;
|
|
|
|
}
|
1998-12-21 18:56:39 +08:00
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
int SSL_get_quiet_shutdown(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return (s->quiet_shutdown);
|
|
|
|
}
|
1998-12-21 18:56:39 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
void SSL_set_shutdown(SSL *s, int mode)
|
|
|
|
{
|
|
|
|
s->shutdown = mode;
|
|
|
|
}
|
1998-12-21 18:56:39 +08:00
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
int SSL_get_shutdown(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return (s->shutdown);
|
|
|
|
}
|
1998-12-21 18:56:39 +08:00
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
int SSL_version(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return (s->version);
|
|
|
|
}
|
1998-12-21 18:56:39 +08:00
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return (ssl->ctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX *ctx)
|
|
|
|
{
|
2015-03-19 02:02:50 +08:00
|
|
|
CERT *new_cert;
|
2015-01-22 11:40:55 +08:00
|
|
|
if (ssl->ctx == ctx)
|
|
|
|
return ssl->ctx;
|
|
|
|
if (ctx == NULL)
|
|
|
|
ctx = ssl->initial_ctx;
|
2015-03-19 02:02:50 +08:00
|
|
|
new_cert = ssl_cert_dup(ctx->cert);
|
|
|
|
if (new_cert == NULL) {
|
|
|
|
return NULL;
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
2015-03-19 02:02:50 +08:00
|
|
|
ssl_cert_free(ssl->cert);
|
|
|
|
ssl->cert = new_cert;
|
2015-01-22 11:40:55 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Program invariant: |sid_ctx| has fixed size (SSL_MAX_SID_CTX_LENGTH),
|
|
|
|
* so setter APIs must prevent invalid lengths from entering the system.
|
|
|
|
*/
|
|
|
|
OPENSSL_assert(ssl->sid_ctx_length <= sizeof(ssl->sid_ctx));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the session ID context matches that of the parent SSL_CTX,
|
|
|
|
* inherit it from the new SSL_CTX as well. If however the context does
|
|
|
|
* not match (i.e., it was set per-ssl with SSL_set_session_id_context),
|
|
|
|
* leave it unchanged.
|
|
|
|
*/
|
|
|
|
if ((ssl->ctx != NULL) &&
|
|
|
|
(ssl->sid_ctx_length == ssl->ctx->sid_ctx_length) &&
|
|
|
|
(memcmp(ssl->sid_ctx, ssl->ctx->sid_ctx, ssl->sid_ctx_length) == 0)) {
|
|
|
|
ssl->sid_ctx_length = ctx->sid_ctx_length;
|
|
|
|
memcpy(&ssl->sid_ctx, &ctx->sid_ctx, sizeof(ssl->sid_ctx));
|
|
|
|
}
|
|
|
|
|
|
|
|
CRYPTO_add(&ctx->references, 1, CRYPTO_LOCK_SSL_CTX);
|
2015-04-12 04:32:54 +08:00
|
|
|
SSL_CTX_free(ssl->ctx); /* decrement reference count */
|
2015-01-22 11:40:55 +08:00
|
|
|
ssl->ctx = ctx;
|
|
|
|
|
|
|
|
return (ssl->ctx);
|
|
|
|
}
|
2006-01-03 07:14:37 +08:00
|
|
|
|
1999-02-28 20:41:50 +08:00
|
|
|
int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return (X509_STORE_set_default_paths(ctx->cert_store));
|
|
|
|
}
|
1998-12-21 18:56:39 +08:00
|
|
|
|
2015-09-22 23:50:32 +08:00
|
|
|
int SSL_CTX_set_default_verify_dir(SSL_CTX *ctx)
|
|
|
|
{
|
|
|
|
X509_LOOKUP *lookup;
|
|
|
|
|
|
|
|
lookup = X509_STORE_add_lookup(ctx->cert_store, X509_LOOKUP_hash_dir());
|
|
|
|
if (lookup == NULL)
|
|
|
|
return 0;
|
|
|
|
X509_LOOKUP_add_dir(lookup, NULL, X509_FILETYPE_DEFAULT);
|
|
|
|
|
|
|
|
/* Clear any errors if the default directory does not exist */
|
|
|
|
ERR_clear_error();
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int SSL_CTX_set_default_verify_file(SSL_CTX *ctx)
|
|
|
|
{
|
|
|
|
X509_LOOKUP *lookup;
|
|
|
|
|
|
|
|
lookup = X509_STORE_add_lookup(ctx->cert_store, X509_LOOKUP_file());
|
|
|
|
if (lookup == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
X509_LOOKUP_load_file(lookup, NULL, X509_FILETYPE_DEFAULT);
|
|
|
|
|
|
|
|
/* Clear any errors if the default file does not exist */
|
|
|
|
ERR_clear_error();
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
1999-05-09 18:12:10 +08:00
|
|
|
int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,
|
2015-01-22 11:40:55 +08:00
|
|
|
const char *CApath)
|
|
|
|
{
|
|
|
|
return (X509_STORE_load_locations(ctx->cert_store, CAfile, CApath));
|
|
|
|
}
|
1998-12-21 18:56:39 +08:00
|
|
|
|
2002-01-12 23:56:13 +08:00
|
|
|
void SSL_set_info_callback(SSL *ssl,
|
2015-01-22 11:40:55 +08:00
|
|
|
void (*cb) (const SSL *ssl, int type, int val))
|
|
|
|
{
|
|
|
|
ssl->info_callback = cb;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* One compiler (Diab DCC) doesn't like argument names in returned function
|
|
|
|
* pointer.
|
|
|
|
*/
|
|
|
|
void (*SSL_get_info_callback(const SSL *ssl)) (const SSL * /* ssl */ ,
|
|
|
|
int /* type */ ,
|
|
|
|
int /* val */ ) {
|
|
|
|
return ssl->info_callback;
|
|
|
|
}
|
1998-12-21 18:56:39 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
void SSL_set_verify_result(SSL *ssl, long arg)
|
|
|
|
{
|
|
|
|
ssl->verify_result = arg;
|
|
|
|
}
|
1998-12-21 18:56:39 +08:00
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
long SSL_get_verify_result(const SSL *ssl)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return (ssl->verify_result);
|
|
|
|
}
|
|
|
|
|
2015-05-28 23:36:51 +08:00
|
|
|
size_t SSL_get_client_random(const SSL *ssl, unsigned char *out, size_t outlen)
|
2015-05-26 05:12:49 +08:00
|
|
|
{
|
2015-05-28 18:12:54 +08:00
|
|
|
if (outlen == 0)
|
2015-05-26 05:12:49 +08:00
|
|
|
return sizeof(ssl->s3->client_random);
|
|
|
|
if (outlen > sizeof(ssl->s3->client_random))
|
|
|
|
outlen = sizeof(ssl->s3->client_random);
|
|
|
|
memcpy(out, ssl->s3->client_random, outlen);
|
2015-05-28 23:36:51 +08:00
|
|
|
return outlen;
|
2015-05-26 05:12:49 +08:00
|
|
|
}
|
|
|
|
|
2015-05-28 23:36:51 +08:00
|
|
|
size_t SSL_get_server_random(const SSL *ssl, unsigned char *out, size_t outlen)
|
2015-05-26 05:12:49 +08:00
|
|
|
{
|
2015-05-28 18:12:54 +08:00
|
|
|
if (outlen == 0)
|
2015-05-26 05:12:49 +08:00
|
|
|
return sizeof(ssl->s3->server_random);
|
|
|
|
if (outlen > sizeof(ssl->s3->server_random))
|
|
|
|
outlen = sizeof(ssl->s3->server_random);
|
|
|
|
memcpy(out, ssl->s3->server_random, outlen);
|
2015-05-28 23:36:51 +08:00
|
|
|
return outlen;
|
2015-05-26 05:12:49 +08:00
|
|
|
}
|
|
|
|
|
2015-05-28 23:36:51 +08:00
|
|
|
size_t SSL_SESSION_get_master_key(const SSL_SESSION *session,
|
2015-05-28 18:12:54 +08:00
|
|
|
unsigned char *out, size_t outlen)
|
2015-05-26 05:12:49 +08:00
|
|
|
{
|
2015-05-28 18:12:54 +08:00
|
|
|
if (session->master_key_length < 0) {
|
|
|
|
/* Should never happen */
|
|
|
|
return 0;
|
|
|
|
}
|
2015-05-28 23:36:51 +08:00
|
|
|
if (outlen == 0)
|
|
|
|
return session->master_key_length;
|
2015-05-28 18:12:54 +08:00
|
|
|
if (outlen > (size_t)session->master_key_length)
|
2015-05-26 05:12:49 +08:00
|
|
|
outlen = session->master_key_length;
|
|
|
|
memcpy(out, session->master_key, outlen);
|
2015-05-28 23:36:51 +08:00
|
|
|
return outlen;
|
2015-05-26 05:12:49 +08:00
|
|
|
}
|
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
int SSL_set_ex_data(SSL *s, int idx, void *arg)
|
|
|
|
{
|
|
|
|
return (CRYPTO_set_ex_data(&s->ex_data, idx, arg));
|
|
|
|
}
|
|
|
|
|
|
|
|
void *SSL_get_ex_data(const SSL *s, int idx)
|
|
|
|
{
|
|
|
|
return (CRYPTO_get_ex_data(&s->ex_data, idx));
|
|
|
|
}
|
|
|
|
|
|
|
|
int SSL_CTX_set_ex_data(SSL_CTX *s, int idx, void *arg)
|
|
|
|
{
|
|
|
|
return (CRYPTO_set_ex_data(&s->ex_data, idx, arg));
|
|
|
|
}
|
|
|
|
|
|
|
|
void *SSL_CTX_get_ex_data(const SSL_CTX *s, int idx)
|
|
|
|
{
|
|
|
|
return (CRYPTO_get_ex_data(&s->ex_data, idx));
|
|
|
|
}
|
1998-12-21 18:56:39 +08:00
|
|
|
|
1999-02-28 20:41:50 +08:00
|
|
|
int ssl_ok(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return (1);
|
|
|
|
}
|
1998-12-21 19:00:56 +08:00
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
X509_STORE *SSL_CTX_get_cert_store(const SSL_CTX *ctx)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return (ctx->cert_store);
|
|
|
|
}
|
Updates to the new SSL compression code
[Eric A. Young, (from changes to C2Net SSLeay, integrated by Mark Cox)]
Fix so that the version number in the master secret, when passed
via RSA, checks that if TLS was proposed, but we roll back to SSLv3
(because the server will not accept higher), that the version number
is 0x03,0x01, not 0x03,0x00
[Eric A. Young, (from changes to C2Net SSLeay, integrated by Mark Cox)]
Submitted by:
Reviewed by:
PR:
1999-02-16 17:22:21 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
void SSL_CTX_set_cert_store(SSL_CTX *ctx, X509_STORE *store)
|
|
|
|
{
|
2015-05-01 05:33:59 +08:00
|
|
|
X509_STORE_free(ctx->cert_store);
|
2015-01-22 11:40:55 +08:00
|
|
|
ctx->cert_store = store;
|
|
|
|
}
|
Updates to the new SSL compression code
[Eric A. Young, (from changes to C2Net SSLeay, integrated by Mark Cox)]
Fix so that the version number in the master secret, when passed
via RSA, checks that if TLS was proposed, but we roll back to SSLv3
(because the server will not accept higher), that the version number
is 0x03,0x01, not 0x03,0x00
[Eric A. Young, (from changes to C2Net SSLeay, integrated by Mark Cox)]
Submitted by:
Reviewed by:
PR:
1999-02-16 17:22:21 +08:00
|
|
|
|
2005-03-30 18:26:02 +08:00
|
|
|
int SSL_want(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return (s->rwstate);
|
|
|
|
}
|
Updates to the new SSL compression code
[Eric A. Young, (from changes to C2Net SSLeay, integrated by Mark Cox)]
Fix so that the version number in the master secret, when passed
via RSA, checks that if TLS was proposed, but we roll back to SSLv3
(because the server will not accept higher), that the version number
is 0x03,0x01, not 0x03,0x00
[Eric A. Young, (from changes to C2Net SSLeay, integrated by Mark Cox)]
Submitted by:
Reviewed by:
PR:
1999-02-16 17:22:21 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
/**
|
1999-02-28 20:41:50 +08:00
|
|
|
* \brief Set the callback for generating temporary DH keys.
|
|
|
|
* \param ctx the SSL context.
|
|
|
|
* \param dh the callback
|
|
|
|
*/
|
|
|
|
|
2001-02-20 16:13:47 +08:00
|
|
|
#ifndef OPENSSL_NO_DH
|
2015-01-22 11:40:55 +08:00
|
|
|
void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,
|
|
|
|
DH *(*dh) (SSL *ssl, int is_export,
|
|
|
|
int keylength))
|
|
|
|
{
|
|
|
|
SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_TMP_DH_CB, (void (*)(void))dh);
|
|
|
|
}
|
1999-01-07 06:53:34 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
void SSL_set_tmp_dh_callback(SSL *ssl, DH *(*dh) (SSL *ssl, int is_export,
|
|
|
|
int keylength))
|
|
|
|
{
|
|
|
|
SSL_callback_ctrl(ssl, SSL_CTRL_SET_TMP_DH_CB, (void (*)(void))dh);
|
|
|
|
}
|
1999-04-27 11:19:12 +08:00
|
|
|
#endif
|
1999-02-25 22:40:29 +08:00
|
|
|
|
2006-03-11 07:06:27 +08:00
|
|
|
#ifndef OPENSSL_NO_PSK
|
|
|
|
int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx, const char *identity_hint)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
2015-09-15 00:58:04 +08:00
|
|
|
OPENSSL_free(ctx->cert->psk_identity_hint);
|
2015-01-22 11:40:55 +08:00
|
|
|
if (identity_hint != NULL) {
|
2015-09-15 00:58:04 +08:00
|
|
|
ctx->cert->psk_identity_hint = BUF_strdup(identity_hint);
|
|
|
|
if (ctx->cert->psk_identity_hint == NULL)
|
2015-01-22 11:40:55 +08:00
|
|
|
return 0;
|
|
|
|
} else
|
2015-09-15 00:58:04 +08:00
|
|
|
ctx->cert->psk_identity_hint = NULL;
|
2015-01-22 11:40:55 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2006-03-11 07:06:27 +08:00
|
|
|
|
|
|
|
int SSL_use_psk_identity_hint(SSL *s, const char *identity_hint)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
if (s == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2015-09-15 00:58:04 +08:00
|
|
|
OPENSSL_free(s->cert->psk_identity_hint);
|
2015-01-22 11:40:55 +08:00
|
|
|
if (identity_hint != NULL) {
|
2015-09-15 00:58:04 +08:00
|
|
|
s->cert->psk_identity_hint = BUF_strdup(identity_hint);
|
|
|
|
if (s->cert->psk_identity_hint == NULL)
|
2015-01-22 11:40:55 +08:00
|
|
|
return 0;
|
|
|
|
} else
|
2015-09-15 00:58:04 +08:00
|
|
|
s->cert->psk_identity_hint = NULL;
|
2015-01-22 11:40:55 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2006-03-11 07:06:27 +08:00
|
|
|
|
|
|
|
const char *SSL_get_psk_identity_hint(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
if (s == NULL || s->session == NULL)
|
|
|
|
return NULL;
|
|
|
|
return (s->session->psk_identity_hint);
|
|
|
|
}
|
2006-03-11 07:06:27 +08:00
|
|
|
|
|
|
|
const char *SSL_get_psk_identity(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
if (s == NULL || s->session == NULL)
|
|
|
|
return NULL;
|
|
|
|
return (s->session->psk_identity);
|
|
|
|
}
|
2006-11-30 04:54:57 +08:00
|
|
|
|
2007-02-17 14:45:38 +08:00
|
|
|
void SSL_set_psk_client_callback(SSL *s,
|
2015-01-22 11:40:55 +08:00
|
|
|
unsigned int (*cb) (SSL *ssl,
|
|
|
|
const char *hint,
|
|
|
|
char *identity,
|
|
|
|
unsigned int
|
|
|
|
max_identity_len,
|
|
|
|
unsigned char *psk,
|
|
|
|
unsigned int
|
|
|
|
max_psk_len))
|
|
|
|
{
|
|
|
|
s->psk_client_callback = cb;
|
|
|
|
}
|
2006-11-30 04:54:57 +08:00
|
|
|
|
|
|
|
void SSL_CTX_set_psk_client_callback(SSL_CTX *ctx,
|
2015-01-22 11:40:55 +08:00
|
|
|
unsigned int (*cb) (SSL *ssl,
|
|
|
|
const char *hint,
|
|
|
|
char *identity,
|
|
|
|
unsigned int
|
|
|
|
max_identity_len,
|
|
|
|
unsigned char *psk,
|
|
|
|
unsigned int
|
|
|
|
max_psk_len))
|
|
|
|
{
|
|
|
|
ctx->psk_client_callback = cb;
|
|
|
|
}
|
2006-11-30 04:54:57 +08:00
|
|
|
|
2007-02-17 14:45:38 +08:00
|
|
|
void SSL_set_psk_server_callback(SSL *s,
|
2015-01-22 11:40:55 +08:00
|
|
|
unsigned int (*cb) (SSL *ssl,
|
|
|
|
const char *identity,
|
|
|
|
unsigned char *psk,
|
|
|
|
unsigned int
|
|
|
|
max_psk_len))
|
|
|
|
{
|
|
|
|
s->psk_server_callback = cb;
|
|
|
|
}
|
2006-11-30 04:54:57 +08:00
|
|
|
|
|
|
|
void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx,
|
2015-01-22 11:40:55 +08:00
|
|
|
unsigned int (*cb) (SSL *ssl,
|
|
|
|
const char *identity,
|
|
|
|
unsigned char *psk,
|
|
|
|
unsigned int
|
|
|
|
max_psk_len))
|
|
|
|
{
|
|
|
|
ctx->psk_server_callback = cb;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
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))
|
|
|
|
{
|
|
|
|
SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
|
|
|
|
}
|
|
|
|
|
|
|
|
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))
|
|
|
|
{
|
|
|
|
SSL_callback_ctrl(ssl, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
|
|
|
|
}
|
2001-10-21 01:56:36 +08:00
|
|
|
|
2010-08-26 23:15:47 +08:00
|
|
|
void SSL_CTX_set_not_resumable_session_callback(SSL_CTX *ctx,
|
2015-01-22 11:40:55 +08:00
|
|
|
int (*cb) (SSL *ssl,
|
|
|
|
int
|
|
|
|
is_forward_secure))
|
|
|
|
{
|
|
|
|
SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB,
|
|
|
|
(void (*)(void))cb);
|
|
|
|
}
|
|
|
|
|
2010-08-26 23:15:47 +08:00
|
|
|
void SSL_set_not_resumable_session_callback(SSL *ssl,
|
2015-01-22 11:40:55 +08:00
|
|
|
int (*cb) (SSL *ssl,
|
|
|
|
int is_forward_secure))
|
|
|
|
{
|
|
|
|
SSL_callback_ctrl(ssl, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB,
|
|
|
|
(void (*)(void))cb);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
2008-06-03 10:48:34 +08:00
|
|
|
*/
|
2007-06-05 01:04:40 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
EVP_MD_CTX *ssl_replace_hash(EVP_MD_CTX **hash, const EVP_MD *md)
|
2007-06-05 01:04:40 +08:00
|
|
|
{
|
2015-01-22 11:40:55 +08:00
|
|
|
ssl_clear_hash_ctx(hash);
|
2015-12-02 07:49:35 +08:00
|
|
|
*hash = EVP_MD_CTX_new();
|
2015-11-07 00:31:21 +08:00
|
|
|
if (*hash == NULL || (md && EVP_DigestInit_ex(*hash, md, NULL) <= 0)) {
|
2015-12-02 07:49:35 +08:00
|
|
|
EVP_MD_CTX_free(*hash);
|
2015-11-07 00:31:21 +08:00
|
|
|
*hash = NULL;
|
|
|
|
return NULL;
|
|
|
|
}
|
2015-01-22 11:40:55 +08:00
|
|
|
return *hash;
|
2007-06-05 01:04:40 +08:00
|
|
|
}
|
2015-01-22 11:40:55 +08:00
|
|
|
|
|
|
|
void ssl_clear_hash_ctx(EVP_MD_CTX **hash)
|
2007-06-05 01:04:40 +08:00
|
|
|
{
|
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
if (*hash)
|
2015-12-02 07:49:35 +08:00
|
|
|
EVP_MD_CTX_free(*hash);
|
2015-01-22 11:40:55 +08:00
|
|
|
*hash = NULL;
|
2007-06-05 01:04:40 +08:00
|
|
|
}
|
2001-10-21 01:56:36 +08:00
|
|
|
|
2015-01-23 10:37:27 +08:00
|
|
|
/* Retrieve handshake hashes */
|
|
|
|
int ssl_handshake_hash(SSL *s, unsigned char *out, int outlen)
|
|
|
|
{
|
2015-11-27 21:02:12 +08:00
|
|
|
EVP_MD_CTX *ctx = NULL;
|
2015-11-26 02:20:50 +08:00
|
|
|
EVP_MD_CTX *hdgst = s->s3->handshake_dgst;
|
|
|
|
int ret = EVP_MD_CTX_size(hdgst);
|
|
|
|
if (ret < 0 || ret > outlen) {
|
|
|
|
ret = 0;
|
|
|
|
goto err;
|
2015-01-23 10:37:27 +08:00
|
|
|
}
|
2015-12-02 07:49:35 +08:00
|
|
|
ctx = EVP_MD_CTX_new();
|
2015-11-27 21:02:12 +08:00
|
|
|
if (ctx == NULL) {
|
|
|
|
ret = 0;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
if (!EVP_MD_CTX_copy_ex(ctx, hdgst)
|
|
|
|
|| EVP_DigestFinal_ex(ctx, out, NULL) <= 0)
|
2015-11-26 02:20:50 +08:00
|
|
|
ret = 0;
|
2015-01-23 10:37:27 +08:00
|
|
|
err:
|
2015-12-02 07:49:35 +08:00
|
|
|
EVP_MD_CTX_free(ctx);
|
2015-01-23 10:37:27 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-04-30 06:37:12 +08:00
|
|
|
void SSL_set_debug(SSL *s, int debug)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
s->debug = debug;
|
|
|
|
}
|
2011-04-30 06:37:12 +08:00
|
|
|
|
|
|
|
int SSL_cache_hit(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return s->hit;
|
|
|
|
}
|
2011-04-30 06:37:12 +08:00
|
|
|
|
2012-07-03 22:25:17 +08:00
|
|
|
int SSL_is_server(SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return s->server;
|
|
|
|
}
|
2012-07-03 22:25:17 +08:00
|
|
|
|
2013-12-15 21:32:24 +08:00
|
|
|
void SSL_set_security_level(SSL *s, int level)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
s->cert->sec_level = level;
|
|
|
|
}
|
2013-12-15 21:32:24 +08:00
|
|
|
|
|
|
|
int SSL_get_security_level(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return s->cert->sec_level;
|
|
|
|
}
|
2013-12-15 21:32:24 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
void SSL_set_security_callback(SSL *s,
|
|
|
|
int (*cb) (SSL *s, SSL_CTX *ctx, int op,
|
|
|
|
int bits, int nid, void *other,
|
|
|
|
void *ex))
|
|
|
|
{
|
|
|
|
s->cert->sec_cb = cb;
|
|
|
|
}
|
2013-12-15 21:32:24 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
int (*SSL_get_security_callback(const SSL *s)) (SSL *s, SSL_CTX *ctx, int op,
|
|
|
|
int bits, int nid,
|
|
|
|
void *other, void *ex) {
|
|
|
|
return s->cert->sec_cb;
|
|
|
|
}
|
2013-12-15 21:32:24 +08:00
|
|
|
|
|
|
|
void SSL_set0_security_ex_data(SSL *s, void *ex)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
s->cert->sec_ex = ex;
|
|
|
|
}
|
2013-12-15 21:32:24 +08:00
|
|
|
|
|
|
|
void *SSL_get0_security_ex_data(const SSL *s)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return s->cert->sec_ex;
|
|
|
|
}
|
2013-12-15 21:32:24 +08:00
|
|
|
|
|
|
|
void SSL_CTX_set_security_level(SSL_CTX *ctx, int level)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
ctx->cert->sec_level = level;
|
|
|
|
}
|
2013-12-15 21:32:24 +08:00
|
|
|
|
|
|
|
int SSL_CTX_get_security_level(const SSL_CTX *ctx)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return ctx->cert->sec_level;
|
|
|
|
}
|
2013-12-15 21:32:24 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
void SSL_CTX_set_security_callback(SSL_CTX *ctx,
|
|
|
|
int (*cb) (SSL *s, SSL_CTX *ctx, int op,
|
|
|
|
int bits, int nid, void *other,
|
|
|
|
void *ex))
|
|
|
|
{
|
|
|
|
ctx->cert->sec_cb = cb;
|
|
|
|
}
|
2013-12-15 21:32:24 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
int (*SSL_CTX_get_security_callback(const SSL_CTX *ctx)) (SSL *s,
|
|
|
|
SSL_CTX *ctx,
|
|
|
|
int op, int bits,
|
|
|
|
int nid,
|
|
|
|
void *other,
|
|
|
|
void *ex) {
|
|
|
|
return ctx->cert->sec_cb;
|
|
|
|
}
|
2013-12-15 21:32:24 +08:00
|
|
|
|
|
|
|
void SSL_CTX_set0_security_ex_data(SSL_CTX *ctx, void *ex)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
ctx->cert->sec_ex = ex;
|
|
|
|
}
|
2013-12-15 21:32:24 +08:00
|
|
|
|
|
|
|
void *SSL_CTX_get0_security_ex_data(const SSL_CTX *ctx)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
return ctx->cert->sec_ex;
|
|
|
|
}
|
2013-12-15 21:32:24 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
IMPLEMENT_OBJ_BSEARCH_GLOBAL_CMP_FN(SSL_CIPHER, SSL_CIPHER, ssl_cipher_id);
|