/*

* Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved.

* Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved

* Copyright 2005 Nokia. All rights reserved.

*

* Licensed under the OpenSSL license (the "License"). You may not use

* this file except in compliance with the License. You can obtain a copy

* in the file LICENSE in the source distribution or at

* https://www.openssl.org/source/license.html

*/

#include <stdio.h>

#include "ssl_locl.h"

#include <openssl/objects.h>

#include <openssl/x509v3.h>

#include <openssl/rand.h>

#include <openssl/rand_drbg.h>

#include <openssl/ocsp.h>

#include <openssl/dh.h>

#include <openssl/engine.h>

#include <openssl/async.h>

#include <openssl/ct.h>

#include "internal/cryptlib.h"

#include "internal/refcount.h"

const char SSL_version_str[] = OPENSSL_VERSION_TEXT;

static int ssl_undefined_function_1(SSL *ssl, SSL3_RECORD *r, size_t s, int t)

{

(void)r;

(void)s;

(void)t;

return ssl_undefined_function(ssl);

}

static int ssl_undefined_function_2(SSL *ssl, SSL3_RECORD *r, unsigned char *s,

int t)

{

(void)r;

(void)s;

(void)t;

return ssl_undefined_function(ssl);

}

static int ssl_undefined_function_3(SSL *ssl, unsigned char *r,

unsigned char *s, size_t t, size_t *u)

{

(void)r;

(void)s;

(void)t;

(void)u;

return ssl_undefined_function(ssl);

}

static int ssl_undefined_function_4(SSL *ssl, int r)

{

(void)r;

return ssl_undefined_function(ssl);

}

static size_t ssl_undefined_function_5(SSL *ssl, const char *r, size_t s,

unsigned char *t)

{

(void)r;

(void)s;

(void)t;

return ssl_undefined_function(ssl);

}

static int ssl_undefined_function_6(int r)

{

(void)r;

return ssl_undefined_function(NULL);

}

static int ssl_undefined_function_7(SSL *ssl, unsigned char *r, size_t s,

const char *t, size_t u,

const unsigned char *v, size_t w, int x)

{

(void)r;

(void)s;

(void)t;

(void)u;

(void)v;

(void)w;

(void)x;

return ssl_undefined_function(ssl);

}

SSL3_ENC_METHOD ssl3_undef_enc_method = {

ssl_undefined_function_1,

ssl_undefined_function_2,

ssl_undefined_function,

ssl_undefined_function_3,

ssl_undefined_function_4,

ssl_undefined_function_5,

NULL, /* client_finished_label */

0, /* client_finished_label_len */

NULL, /* server_finished_label */

0, /* server_finished_label_len */

ssl_undefined_function_6,

ssl_undefined_function_7,

};

struct ssl_async_args {

SSL *s;

void *buf;

size_t num;

enum { READFUNC, WRITEFUNC, OTHERFUNC } type;

union {

int (*func_read) (SSL *, void *, size_t, size_t *);

int (*func_write) (SSL *, const void *, size_t, size_t *);

int (*func_other) (SSL *);

} f;

};

static const struct {

uint8_t mtype;

uint8_t ord;

int nid;

} dane_mds[] = {

{

DANETLS_MATCHING_FULL, 0, NID_undef

},

{

DANETLS_MATCHING_2256, 1, NID_sha256

},

{

DANETLS_MATCHING_2512, 2, NID_sha512

},

};

static int dane_ctx_enable(struct dane_ctx_st *dctx)

{

const EVP_MD **mdevp;

uint8_t *mdord;

uint8_t mdmax = DANETLS_MATCHING_LAST;

int n = ((int)mdmax) + 1; /* int to handle PrivMatch(255) */

size_t i;

if (dctx->mdevp != NULL)

return 1;

mdevp = OPENSSL_zalloc(n * sizeof(*mdevp));

mdord = OPENSSL_zalloc(n * sizeof(*mdord));

if (mdord == NULL || mdevp == NULL) {

OPENSSL_free(mdord);

OPENSSL_free(mdevp);

SSLerr(SSL_F_DANE_CTX_ENABLE, ERR_R_MALLOC_FAILURE);

return 0;

}

/* Install default entries */

for (i = 0; i < OSSL_NELEM(dane_mds); ++i) {

const EVP_MD *md;

if (dane_mds[i].nid == NID_undef ||

(md = EVP_get_digestbynid(dane_mds[i].nid)) == NULL)

continue;

mdevp[dane_mds[i].mtype] = md;

mdord[dane_mds[i].mtype] = dane_mds[i].ord;

}

dctx->mdevp = mdevp;

dctx->mdord = mdord;

dctx->mdmax = mdmax;

return 1;

}

static void dane_ctx_final(struct dane_ctx_st *dctx)

{

OPENSSL_free(dctx->mdevp);

dctx->mdevp = NULL;

OPENSSL_free(dctx->mdord);

dctx->mdord = NULL;

dctx->mdmax = 0;

}

static void tlsa_free(danetls_record *t)

{

if (t == NULL)

return;

OPENSSL_free(t->data);

EVP_PKEY_free(t->spki);

OPENSSL_free(t);

}

static void dane_final(SSL_DANE *dane)

{

sk_danetls_record_pop_free(dane->trecs, tlsa_free);

dane->trecs = NULL;

sk_X509_pop_free(dane->certs, X509_free);

dane->certs = NULL;

X509_free(dane->mcert);

dane->mcert = NULL;

dane->mtlsa = NULL;

dane->mdpth = -1;

dane->pdpth = -1;

}

/*

* dane_copy - Copy dane configuration, sans verification state.

*/

static int ssl_dane_dup(SSL *to, SSL *from)

{

int num;

int i;

if (!DANETLS_ENABLED(&from->dane))

return 1;

num = sk_danetls_record_num(from->dane.trecs);

dane_final(&to->dane);

to->dane.flags = from->dane.flags;

to->dane.dctx = &to->ctx->dane;

to->dane.trecs = sk_danetls_record_new_reserve(NULL, num);

if (to->dane.trecs == NULL) {

SSLerr(SSL_F_SSL_DANE_DUP, ERR_R_MALLOC_FAILURE);

return 0;

}

for (i = 0; i < num; ++i) {

danetls_record *t = sk_danetls_record_value(from->dane.trecs, i);

if (SSL_dane_tlsa_add(to, t->usage, t->selector, t->mtype,

t->data, t->dlen) <= 0)

return 0;

}

return 1;

}

static int dane_mtype_set(struct dane_ctx_st *dctx,

const EVP_MD *md, uint8_t mtype, uint8_t ord)

{

int i;

if (mtype == DANETLS_MATCHING_FULL && md != NULL) {

SSLerr(SSL_F_DANE_MTYPE_SET, SSL_R_DANE_CANNOT_OVERRIDE_MTYPE_FULL);

return 0;

}

if (mtype > dctx->mdmax) {

const EVP_MD **mdevp;

uint8_t *mdord;

int n = ((int)mtype) + 1;

mdevp = OPENSSL_realloc(dctx->mdevp, n * sizeof(*mdevp));

if (mdevp == NULL) {

SSLerr(SSL_F_DANE_MTYPE_SET, ERR_R_MALLOC_FAILURE);

return -1;

}

dctx->mdevp = mdevp;

mdord = OPENSSL_realloc(dctx->mdord, n * sizeof(*mdord));

if (mdord == NULL) {

SSLerr(SSL_F_DANE_MTYPE_SET, ERR_R_MALLOC_FAILURE);

return -1;

}

dctx->mdord = mdord;

/* Zero-fill any gaps */

for (i = dctx->mdmax + 1; i < mtype; ++i) {

mdevp[i] = NULL;

mdord[i] = 0;

}

dctx->mdmax = mtype;

}

dctx->mdevp[mtype] = md;

/* Coerce ordinal of disabled matching types to 0 */

dctx->mdord[mtype] = (md == NULL) ? 0 : ord;

return 1;

}

static const EVP_MD *tlsa_md_get(SSL_DANE *dane, uint8_t mtype)

{

if (mtype > dane->dctx->mdmax)

return NULL;

return dane->dctx->mdevp[mtype];

}

static int dane_tlsa_add(SSL_DANE *dane,

uint8_t usage,

uint8_t selector,

uint8_t mtype, unsigned const char *data, size_t dlen)

{

danetls_record *t;

const EVP_MD *md = NULL;

int ilen = (int)dlen;

int i;

int num;

if (dane->trecs == NULL) {

SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_NOT_ENABLED);

return -1;

}

if (ilen < 0 || dlen != (size_t)ilen) {

SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_DATA_LENGTH);

return 0;

}

if (usage > DANETLS_USAGE_LAST) {

SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_CERTIFICATE_USAGE);

return 0;

}

if (selector > DANETLS_SELECTOR_LAST) {

SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_SELECTOR);

return 0;

}

if (mtype != DANETLS_MATCHING_FULL) {

md = tlsa_md_get(dane, mtype);

if (md == NULL) {

SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_MATCHING_TYPE);

return 0;

}

}

if (md != NULL && dlen != (size_t)EVP_MD_size(md)) {

SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_DIGEST_LENGTH);

return 0;

}

if (!data) {

SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_NULL_DATA);

return 0;

}

if ((t = OPENSSL_zalloc(sizeof(*t))) == NULL) {

SSLerr(SSL_F_DANE_TLSA_ADD, ERR_R_MALLOC_FAILURE);

return -1;

}

t->usage = usage;

t->selector = selector;

t->mtype = mtype;

t->data = OPENSSL_malloc(dlen);

if (t->data == NULL) {

tlsa_free(t);

SSLerr(SSL_F_DANE_TLSA_ADD, ERR_R_MALLOC_FAILURE);

return -1;

}

memcpy(t->data, data, dlen);

t->dlen = dlen;

/* Validate and cache full certificate or public key */

if (mtype == DANETLS_MATCHING_FULL) {

const unsigned char *p = data;

X509 *cert = NULL;

EVP_PKEY *pkey = NULL;

switch (selector) {

case DANETLS_SELECTOR_CERT:

if (!d2i_X509(&cert, &p, ilen) || p < data ||

dlen != (size_t)(p - data)) {

tlsa_free(t);

SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_CERTIFICATE);

return 0;

}

if (X509_get0_pubkey(cert) == NULL) {

tlsa_free(t);

SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_CERTIFICATE);

return 0;

}

if ((DANETLS_USAGE_BIT(usage) & DANETLS_TA_MASK) == 0) {

X509_free(cert);

break;

}

/*

* For usage DANE-TA(2), we support authentication via "2 0 0" TLSA

* records that contain full certificates of trust-anchors that are

* not present in the wire chain. For usage PKIX-TA(0), we augment

* the chain with untrusted Full(0) certificates from DNS, in case

* they are missing from the chain.

*/

if ((dane->certs == NULL &&

(dane->certs = sk_X509_new_null()) == NULL) ||

!sk_X509_push(dane->certs, cert)) {

SSLerr(SSL_F_DANE_TLSA_ADD, ERR_R_MALLOC_FAILURE);

X509_free(cert);

tlsa_free(t);

return -1;

}

break;

case DANETLS_SELECTOR_SPKI:

if (!d2i_PUBKEY(&pkey, &p, ilen) || p < data ||

dlen != (size_t)(p - data)) {

tlsa_free(t);

SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_PUBLIC_KEY);

return 0;

}

/*

* For usage DANE-TA(2), we support authentication via "2 1 0" TLSA

* records that contain full bare keys of trust-anchors that are

* not present in the wire chain.

*/

if (usage == DANETLS_USAGE_DANE_TA)

t->spki = pkey;

else

EVP_PKEY_free(pkey);

break;

}

}

/*-

* Find the right insertion point for the new record.

*

* See crypto/x509/x509_vfy.c. We sort DANE-EE(3) records first, so that

* they can be processed first, as they require no chain building, and no

* expiration or hostname checks. Because DANE-EE(3) is numerically

* largest, this is accomplished via descending sort by "usage".

*

* We also sort in descending order by matching ordinal to simplify

* the implementation of digest agility in the verification code.

*

* The choice of order for the selector is not significant, so we

* use the same descending order for consistency.

*/

num = sk_danetls_record_num(dane->trecs);

for (i = 0; i < num; ++i) {

danetls_record *rec = sk_danetls_record_value(dane->trecs, i);

if (rec->usage > usage)

continue;

if (rec->usage < usage)

break;

if (rec->selector > selector)

continue;

if (rec->selector < selector)

break;

if (dane->dctx->mdord[rec->mtype] > dane->dctx->mdord[mtype])

continue;

break;

}

if (!sk_danetls_record_insert(dane->trecs, t, i)) {

tlsa_free(t);

SSLerr(SSL_F_DANE_TLSA_ADD, ERR_R_MALLOC_FAILURE);

return -1;

}

dane->umask |= DANETLS_USAGE_BIT(usage);

return 1;

}

/*

* Return 0 if there is only one version configured and it was disabled

* at configure time. Return 1 otherwise.

*/

static int ssl_check_allowed_versions(int min_version, int max_version)

{

int minisdtls = 0, maxisdtls = 0;

/* Figure out if we're doing DTLS versions or TLS versions */

if (min_version == DTLS1_BAD_VER

|| min_version >> 8 == DTLS1_VERSION_MAJOR)

minisdtls = 1;

if (max_version == DTLS1_BAD_VER

|| max_version >> 8 == DTLS1_VERSION_MAJOR)

maxisdtls = 1;

/* A wildcard version of 0 could be DTLS or TLS. */

if ((minisdtls && !maxisdtls && max_version != 0)

|| (maxisdtls && !minisdtls && min_version != 0)) {

/* Mixing DTLS and TLS versions will lead to sadness; deny it. */

return 0;

}

if (minisdtls || maxisdtls) {

/* Do DTLS version checks. */

if (min_version == 0)

/* Ignore DTLS1_BAD_VER */

min_version = DTLS1_VERSION;

if (max_version == 0)

max_version = DTLS1_2_VERSION;

#ifdef OPENSSL_NO_DTLS1_2

if (max_version == DTLS1_2_VERSION)

max_version = DTLS1_VERSION;

#endif

#ifdef OPENSSL_NO_DTLS1

if (min_version == DTLS1_VERSION)

min_version = DTLS1_2_VERSION;

#endif

/* Done massaging versions; do the check. */

if (0

#ifdef OPENSSL_NO_DTLS1

|| (DTLS_VERSION_GE(min_version, DTLS1_VERSION)

&& DTLS_VERSION_GE(DTLS1_VERSION, max_version))

#endif

#ifdef OPENSSL_NO_DTLS1_2

|| (DTLS_VERSION_GE(min_version, DTLS1_2_VERSION)

&& DTLS_VERSION_GE(DTLS1_2_VERSION, max_version))

#endif

)

return 0;

} else {

/* Regular TLS version checks. */

if (min_version == 0)

min_version = SSL3_VERSION;

if (max_version == 0)

max_version = TLS1_3_VERSION;

#ifdef OPENSSL_NO_TLS1_3

if (max_version == TLS1_3_VERSION)

max_version = TLS1_2_VERSION;

#endif

#ifdef OPENSSL_NO_TLS1_2

if (max_version == TLS1_2_VERSION)

max_version = TLS1_1_VERSION;

#endif

#ifdef OPENSSL_NO_TLS1_1

if (max_version == TLS1_1_VERSION)

max_version = TLS1_VERSION;

#endif

#ifdef OPENSSL_NO_TLS1

if (max_version == TLS1_VERSION)

max_version = SSL3_VERSION;

#endif

#ifdef OPENSSL_NO_SSL3

if (min_version == SSL3_VERSION)

min_version = TLS1_VERSION;

#endif

#ifdef OPENSSL_NO_TLS1

if (min_version == TLS1_VERSION)

min_version = TLS1_1_VERSION;

#endif

#ifdef OPENSSL_NO_TLS1_1

if (min_version == TLS1_1_VERSION)

min_version = TLS1_2_VERSION;

#endif

#ifdef OPENSSL_NO_TLS1_2

if (min_version == TLS1_2_VERSION)

min_version = TLS1_3_VERSION;

#endif

/* Done massaging versions; do the check. */

if (0

#ifdef OPENSSL_NO_SSL3

|| (min_version <= SSL3_VERSION && SSL3_VERSION <= max_version)

#endif

#ifdef OPENSSL_NO_TLS1

|| (min_version <= TLS1_VERSION && TLS1_VERSION <= max_version)

#endif

#ifdef OPENSSL_NO_TLS1_1

|| (min_version <= TLS1_1_VERSION && TLS1_1_VERSION <= max_version)

#endif

#ifdef OPENSSL_NO_TLS1_2

|| (min_version <= TLS1_2_VERSION && TLS1_2_VERSION <= max_version)

#endif

#ifdef OPENSSL_NO_TLS1_3

|| (min_version <= TLS1_3_VERSION && TLS1_3_VERSION <= max_version)

#endif

)

return 0;

}

return 1;

}

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);

}

int SSL_clear(SSL *s)

{

if (s->method == NULL) {

SSLerr(SSL_F_SSL_CLEAR, SSL_R_NO_METHOD_SPECIFIED);

return 0;

}

if (ssl_clear_bad_session(s)) {

SSL_SESSION_free(s->session);

s->session = NULL;

}

SSL_SESSION_free(s->psksession);

s->psksession = NULL;

OPENSSL_free(s->psksession_id);

s->psksession_id = NULL;

s->psksession_id_len = 0;

s->hello_retry_request = 0;

s->sent_tickets = 0;

s->error = 0;

s->hit = 0;

s->shutdown = 0;

if (s->renegotiate) {

SSLerr(SSL_F_SSL_CLEAR, ERR_R_INTERNAL_ERROR);

return 0;

}

ossl_statem_clear(s);

s->version = s->method->version;

s->client_version = s->version;

s->rwstate = SSL_NOTHING;

BUF_MEM_free(s->init_buf);

s->init_buf = NULL;

clear_ciphers(s);

s->first_packet = 0;

s->key_update = SSL_KEY_UPDATE_NONE;

EVP_MD_CTX_free(s->pha_dgst);

s->pha_dgst = NULL;

/* Reset DANE verification result state */

s->dane.mdpth = -1;

s->dane.pdpth = -1;

X509_free(s->dane.mcert);

s->dane.mcert = NULL;

s->dane.mtlsa = NULL;

/* Clear the verification result peername */

X509_VERIFY_PARAM_move_peername(s->param, NULL);

/*

* Check to see if we were changed into a different method, if so, revert

* back.

*/

if (s->method != s->ctx->method) {

s->method->ssl_free(s);

s->method = s->ctx->method;

if (!s->method->ssl_new(s))

return 0;

} else {

if (!s->method->ssl_clear(s))

return 0;

}

RECORD_LAYER_clear(&s->rlayer);

return 1;

}

/** Used to change an SSL_CTXs default SSL method type */

int SSL_CTX_set_ssl_version(SSL_CTX *ctx, const SSL_METHOD *meth)

{

STACK_OF(SSL_CIPHER) *sk;

ctx->method = meth;

if (!SSL_CTX_set_ciphersuites(ctx, TLS_DEFAULT_CIPHERSUITES)) {

SSLerr(SSL_F_SSL_CTX_SET_SSL_VERSION, SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS);

return 0;

}

sk = ssl_create_cipher_list(ctx->method,

ctx->tls13_ciphersuites,

&(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;

}

SSL *SSL_new(SSL_CTX *ctx)

{

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;

}

s = OPENSSL_zalloc(sizeof(*s));

if (s == NULL)

goto err;

s->references = 1;

s->lock = CRYPTO_THREAD_lock_new();

if (s->lock == NULL) {

OPENSSL_free(s);

s = NULL;

goto err;

}

RECORD_LAYER_init(&s->rlayer, s);

s->options = ctx->options;

s->dane.flags = ctx->dane.flags;

s->min_proto_version = ctx->min_proto_version;

s->max_proto_version = ctx->max_proto_version;

s->mode = ctx->mode;

s->max_cert_list = ctx->max_cert_list;

s->max_early_data = ctx->max_early_data;

s->recv_max_early_data = ctx->recv_max_early_data;

s->num_tickets = ctx->num_tickets;

s->pha_enabled = ctx->pha_enabled;

/* Shallow copy of the ciphersuites stack */

s->tls13_ciphersuites = sk_SSL_CIPHER_dup(ctx->tls13_ciphersuites);

if (s->tls13_ciphersuites == NULL)

goto err;

/*

* 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;

RECORD_LAYER_set_read_ahead(&s->rlayer, ctx->read_ahead);

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->record_padding_cb = ctx->record_padding_cb;

s->record_padding_arg = ctx->record_padding_arg;

s->block_padding = ctx->block_padding;

s->sid_ctx_length = ctx->sid_ctx_length;

if (!ossl_assert(s->sid_ctx_length <= sizeof(s->sid_ctx)))

goto err;

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();

if (s->param == NULL)

goto err;

X509_VERIFY_PARAM_inherit(s->param, ctx->param);

s->quiet_shutdown = ctx->quiet_shutdown;

s->ext.max_fragment_len_mode = ctx->ext.max_fragment_len_mode;

s->max_send_fragment = ctx->max_send_fragment;

s->split_send_fragment = ctx->split_send_fragment;

s->max_pipelines = ctx->max_pipelines;

if (s->max_pipelines > 1)

RECORD_LAYER_set_read_ahead(&s->rlayer, 1);

if (ctx->default_read_buf_len > 0)

SSL_set_default_read_buffer_len(s, ctx->default_read_buf_len);

SSL_CTX_up_ref(ctx);

s->ctx = ctx;

s->ext.debug_cb = 0;

s->ext.debug_arg = NULL;

s->ext.ticket_expected = 0;

s->ext.status_type = ctx->ext.status_type;

s->ext.status_expected = 0;

s->ext.ocsp.ids = NULL;

s->ext.ocsp.exts = NULL;

s->ext.ocsp.resp = NULL;

s->ext.ocsp.resp_len = 0;

SSL_CTX_up_ref(ctx);

s->session_ctx = ctx;

#ifndef OPENSSL_NO_EC

if (ctx->ext.ecpointformats) {

s->ext.ecpointformats =

OPENSSL_memdup(ctx->ext.ecpointformats,

ctx->ext.ecpointformats_len);

if (!s->ext.ecpointformats)

goto err;

s->ext.ecpointformats_len =

ctx->ext.ecpointformats_len;

}

if (ctx->ext.supportedgroups) {

s->ext.supportedgroups =

OPENSSL_memdup(ctx->ext.supportedgroups,

ctx->ext.supportedgroups_len

* sizeof(*ctx->ext.supportedgroups));

if (!s->ext.supportedgroups)

goto err;

s->ext.supportedgroups_len = ctx->ext.supportedgroups_len;

}

#endif

#ifndef OPENSSL_NO_NEXTPROTONEG

s->ext.npn = NULL;

#endif

if (s->ctx->ext.alpn) {

s->ext.alpn = OPENSSL_malloc(s->ctx->ext.alpn_len);

if (s->ext.alpn == NULL)

goto err;

memcpy(s->ext.alpn, s->ctx->ext.alpn, s->ctx->ext.alpn_len);

s->ext.alpn_len = s->ctx->ext.alpn_len;

}

s->verified_chain = NULL;

s->verify_result = X509_V_OK;

s->default_passwd_callback = ctx->default_passwd_callback;

s->default_passwd_callback_userdata = ctx->default_passwd_callback_userdata;

s->method = ctx->method;

s->key_update = SSL_KEY_UPDATE_NONE;

s->allow_early_data_cb = ctx->allow_early_data_cb;

s->allow_early_data_cb_data = ctx->allow_early_data_cb_data;

if (!s->method->ssl_new(s))

goto err;

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

if (!SSL_clear(s))

goto err;

if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data))

goto err;

#ifndef OPENSSL_NO_PSK

s->psk_client_callback = ctx->psk_client_callback;

s->psk_server_callback = ctx->psk_server_callback;

#endif

s->psk_find_session_cb = ctx->psk_find_session_cb;

s->psk_use_session_cb = ctx->psk_use_session_cb;

s->job = NULL;

#ifndef OPENSSL_NO_CT

if (!SSL_set_ct_validation_callback(s, ctx->ct_validation_callback,

ctx->ct_validation_callback_arg))

goto err;

#endif

return s;

err:

SSL_free(s);

SSLerr(SSL_F_SSL_NEW, ERR_R_MALLOC_FAILURE);

return NULL;

}

int SSL_is_dtls(const SSL *s)

{

return SSL_IS_DTLS(s) ? 1 : 0;

}

int SSL_up_ref(SSL *s)

{

int i;

if (CRYPTO_UP_REF(&s->references, &i, s->lock) <= 0)

return 0;

REF_PRINT_COUNT("SSL", s);

REF_ASSERT_ISNT(i < 2);

return ((i > 1) ? 1 : 0);

}

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);

return 1;

}

int SSL_set_session_id_context(SSL *ssl, const unsigned char *sid_ctx,

unsigned int sid_ctx_len)

{

if (sid_ctx_len > SSL_MAX_SID_CTX_LENGTH) {

SSLerr(SSL_F_SSL_SET_SESSION_ID_CONTEXT,

SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);

return 0;

}

ssl->sid_ctx_length = sid_ctx_len;

memcpy(ssl->sid_ctx, sid_ctx, sid_ctx_len);

return 1;

}

int SSL_CTX_set_generate_session_id(SSL_CTX *ctx, GEN_SESSION_CB cb)

{

CRYPTO_THREAD_write_lock(ctx->lock);

ctx->generate_session_id = cb;

CRYPTO_THREAD_unlock(ctx->lock);

return 1;

}

int SSL_set_generate_session_id(SSL *ssl, GEN_SESSION_CB cb)

{

CRYPTO_THREAD_write_lock(ssl->lock);

ssl->generate_session_id = cb;

CRYPTO_THREAD_unlock(ssl->lock);

return 1;

}

int SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id,

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 - i.e. 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_THREAD_read_lock(ssl->session_ctx->lock);

p = lh_SSL_SESSION_retrieve(ssl->session_ctx->sessions, &r);

CRYPTO_THREAD_unlock(ssl->session_ctx->lock);

return (p != NULL);

}

int SSL_CTX_set_purpose(SSL_CTX *s, int purpose)

{

return X509_VERIFY_PARAM_set_purpose(s->param, purpose);

}

int SSL_set_purpose(SSL *s, int purpose)

{

return X509_VERIFY_PARAM_set_purpose(s->param, purpose);

}

int SSL_CTX_set_trust(SSL_CTX *s, int trust)

{

return X509_VERIFY_PARAM_set_trust(s->param, trust);

}

int SSL_set_trust(SSL *s, int trust)

{

return X509_VERIFY_PARAM_set_trust(s->param, trust);

}

int SSL_set1_host(SSL *s, const char *hostname)

{

return X509_VERIFY_PARAM_set1_host(s->param, hostname, 0);

}

int SSL_add1_host(SSL *s, const char *hostname)

{

return X509_VERIFY_PARAM_add1_host(s->param, hostname, 0);

}

void SSL_set_hostflags(SSL *s, unsigned int flags)

{

X509_VERIFY_PARAM_set_hostflags(s->param, flags);

}

const char *SSL_get0_peername(SSL *s)

{

return X509_VERIFY_PARAM_get0_peername(s->param);

}

int SSL_CTX_dane_enable(SSL_CTX *ctx)

{

return dane_ctx_enable(&ctx->dane);

}

unsigned long SSL_CTX_dane_set_flags(SSL_CTX *ctx, unsigned long flags)

{

unsigned long orig = ctx->dane.flags;

ctx->dane.flags |= flags;

return orig;

}

unsigned long SSL_CTX_dane_clear_flags(SSL_CTX *ctx, unsigned long flags)

{

unsigned long orig = ctx->dane.flags;

ctx->dane.flags &= ~flags;

return orig;

}

int SSL_dane_enable(SSL *s, const char *basedomain)

{

SSL_DANE *dane = &s->dane;