ssl/ssl_lib.c

   1 /*
   2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 /* ====================================================================
  11  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
  12  * ECC cipher suite support in OpenSSL originally developed by
  13  * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
  14  */
  15 /* ====================================================================
  16  * Copyright 2005 Nokia. All rights reserved.
  17  *
  18  * The portions of the attached software ("Contribution") is developed by
  19  * Nokia Corporation and is licensed pursuant to the OpenSSL open source
  20  * license.
  21  *
  22  * The Contribution, originally written by Mika Kousa and Pasi Eronen of
  23  * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
  24  * support (see RFC 4279) to OpenSSL.
  25  *
  26  * No patent licenses or other rights except those expressly stated in
  27  * the OpenSSL open source license shall be deemed granted or received
  28  * expressly, by implication, estoppel, or otherwise.
  29  *
  30  * No assurances are provided by Nokia that the Contribution does not
  31  * infringe the patent or other intellectual property rights of any third
  32  * party or that the license provides you with all the necessary rights
  33  * to make use of the Contribution.
  34  *
  35  * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
  36  * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
  37  * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
  38  * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
  39  * OTHERWISE.
  40  */
  41
  42 #include <assert.h>
  43 #include <stdio.h>
  44 #include "ssl_locl.h"
  45 #include <openssl/objects.h>
  46 #include <openssl/lhash.h>
  47 #include <openssl/x509v3.h>
  48 #include <openssl/rand.h>
  49 #include <openssl/ocsp.h>
  50 #include <openssl/dh.h>
  51 #include <openssl/engine.h>
  52 #include <openssl/async.h>
  53 #include <openssl/ct.h>
  54
  55 const char SSL_version_str[] = OPENSSL_VERSION_TEXT;
  56
  57 SSL3_ENC_METHOD ssl3_undef_enc_method = {
  58     /*
  59      * evil casts, but these functions are only called if there's a library
  60      * bug
  61      */
  62     (int (*)(SSL *, SSL3_RECORD *, unsigned int, int))ssl_undefined_function,
  63     (int (*)(SSL *, SSL3_RECORD *, unsigned char *, int))ssl_undefined_function,
  64     ssl_undefined_function,
  65     (int (*)(SSL *, unsigned char *, unsigned char *, int))
  66         ssl_undefined_function,
  67     (int (*)(SSL *, int))ssl_undefined_function,
  68     (int (*)(SSL *, const char *, int, unsigned char *))
  69         ssl_undefined_function,
  70     0,                          /* finish_mac_length */
  71     NULL,                       /* client_finished_label */
  72     0,                          /* client_finished_label_len */
  73     NULL,                       /* server_finished_label */
  74     0,                          /* server_finished_label_len */
  75     (int (*)(int))ssl_undefined_function,
  76     (int (*)(SSL *, unsigned char *, size_t, const char *,
  77              size_t, const unsigned char *, size_t,
  78              int use_context))ssl_undefined_function,
  79 };
  80
  81 struct ssl_async_args {
  82     SSL *s;
  83     void *buf;
  84     int num;
  85     enum { READFUNC, WRITEFUNC,  OTHERFUNC} type;
  86     union {
  87         int (*func_read)(SSL *, void *, int);
  88         int (*func_write)(SSL *, const void *, int);
  89         int (*func_other)(SSL *);
  90     } f;
  91 };
  92
  93 static const struct {
  94     uint8_t mtype;
  95     uint8_t ord;
  96     int     nid;
  97 } dane_mds[] = {
  98     { DANETLS_MATCHING_FULL, 0, NID_undef },
  99     { DANETLS_MATCHING_2256, 1, NID_sha256 },
 100     { DANETLS_MATCHING_2512, 2, NID_sha512 },
 101 };
 102
 103 static int dane_ctx_enable(struct dane_ctx_st *dctx)
 104 {
 105     const EVP_MD **mdevp;
 106     uint8_t *mdord;
 107     uint8_t mdmax = DANETLS_MATCHING_LAST;
 108     int n = ((int) mdmax) + 1;          /* int to handle PrivMatch(255) */
 109     size_t i;
 110
 111     if (dctx->mdevp != NULL)
 112         return 1;
 113
 114     mdevp = OPENSSL_zalloc(n * sizeof(*mdevp));
 115     mdord = OPENSSL_zalloc(n * sizeof(*mdord));
 116
 117     if (mdord == NULL || mdevp == NULL) {
 118         OPENSSL_free(mdord);
 119         OPENSSL_free(mdevp);
 120         SSLerr(SSL_F_DANE_CTX_ENABLE, ERR_R_MALLOC_FAILURE);
 121         return 0;
 122     }
 123
 124     /* Install default entries */
 125     for (i = 0; i < OSSL_NELEM(dane_mds); ++i) {
 126         const EVP_MD *md;
 127
 128         if (dane_mds[i].nid == NID_undef ||
 129             (md = EVP_get_digestbynid(dane_mds[i].nid)) == NULL)
 130             continue;
 131         mdevp[dane_mds[i].mtype] = md;
 132         mdord[dane_mds[i].mtype] = dane_mds[i].ord;
 133     }
 134
 135     dctx->mdevp = mdevp;
 136     dctx->mdord = mdord;
 137     dctx->mdmax = mdmax;
 138
 139     return 1;
 140 }
 141
 142 static void dane_ctx_final(struct dane_ctx_st *dctx)
 143 {
 144     OPENSSL_free(dctx->mdevp);
 145     dctx->mdevp = NULL;
 146
 147     OPENSSL_free(dctx->mdord);
 148     dctx->mdord = NULL;
 149     dctx->mdmax = 0;
 150 }
 151
 152 static void tlsa_free(danetls_record *t)
 153 {
 154     if (t == NULL)
 155         return;
 156     OPENSSL_free(t->data);
 157     EVP_PKEY_free(t->spki);
 158     OPENSSL_free(t);
 159 }
 160
 161 static void dane_final(SSL_DANE *dane)
 162 {
 163     sk_danetls_record_pop_free(dane->trecs, tlsa_free);
 164     dane->trecs = NULL;
 165
 166     sk_X509_pop_free(dane->certs, X509_free);
 167     dane->certs = NULL;
 168
 169     X509_free(dane->mcert);
 170     dane->mcert = NULL;
 171     dane->mtlsa = NULL;
 172     dane->mdpth = -1;
 173     dane->pdpth = -1;
 174 }
 175
 176 /*
 177  * dane_copy - Copy dane configuration, sans verification state.
 178  */
 179 static int ssl_dane_dup(SSL *to, SSL *from)
 180 {
 181     int num;
 182     int i;
 183
 184     if (!DANETLS_ENABLED(&from->dane))
 185         return 1;
 186
 187     dane_final(&to->dane);
 188     to->dane.flags = from->dane.flags;
 189     to->dane.dctx = &to->ctx->dane;
 190     to->dane.trecs = sk_danetls_record_new_null();
 191
 192     if (to->dane.trecs == NULL) {
 193         SSLerr(SSL_F_SSL_DANE_DUP, ERR_R_MALLOC_FAILURE);
 194         return 0;
 195     }
 196
 197     num  = sk_danetls_record_num(from->dane.trecs);
 198     for (i = 0; i < num; ++i) {
 199         danetls_record *t = sk_danetls_record_value(from->dane.trecs, i);
 200
 201         if (SSL_dane_tlsa_add(to, t->usage, t->selector, t->mtype,
 202                               t->data, t->dlen) <= 0)
 203             return 0;
 204     }
 205     return 1;
 206 }
 207
 208 static int dane_mtype_set(
 209     struct dane_ctx_st *dctx,
 210     const EVP_MD *md,
 211     uint8_t mtype,
 212     uint8_t ord)
 213 {
 214     int i;
 215
 216     if (mtype == DANETLS_MATCHING_FULL && md != NULL) {
 217         SSLerr(SSL_F_DANE_MTYPE_SET,
 218                 SSL_R_DANE_CANNOT_OVERRIDE_MTYPE_FULL);
 219         return 0;
 220     }
 221
 222     if (mtype > dctx->mdmax) {
 223         const EVP_MD **mdevp;
 224         uint8_t *mdord;
 225         int n = ((int) mtype) + 1;
 226
 227         mdevp = OPENSSL_realloc(dctx->mdevp, n * sizeof(*mdevp));
 228         if (mdevp == NULL) {
 229             SSLerr(SSL_F_DANE_MTYPE_SET, ERR_R_MALLOC_FAILURE);
 230             return -1;
 231         }
 232         dctx->mdevp = mdevp;
 233
 234         mdord = OPENSSL_realloc(dctx->mdord, n * sizeof(*mdord));
 235         if (mdord == NULL) {
 236             SSLerr(SSL_F_DANE_MTYPE_SET, ERR_R_MALLOC_FAILURE);
 237             return -1;
 238         }
 239         dctx->mdord = mdord;
 240
 241         /* Zero-fill any gaps */
 242         for (i = dctx->mdmax+1; i < mtype; ++i) {
 243             mdevp[i] = NULL;
 244             mdord[i] = 0;
 245         }
 246
 247         dctx->mdmax = mtype;
 248     }
 249
 250     dctx->mdevp[mtype] = md;
 251     /* Coerce ordinal of disabled matching types to 0 */
 252     dctx->mdord[mtype] = (md == NULL) ? 0 : ord;
 253
 254     return 1;
 255 }
 256
 257 static const EVP_MD *tlsa_md_get(SSL_DANE *dane, uint8_t mtype)
 258 {
 259     if (mtype > dane->dctx->mdmax)
 260         return NULL;
 261     return dane->dctx->mdevp[mtype];
 262 }
 263
 264 static int dane_tlsa_add(
 265     SSL_DANE *dane,
 266     uint8_t usage,
 267     uint8_t selector,
 268     uint8_t mtype,
 269     unsigned char *data,
 270     size_t dlen)
 271 {
 272     danetls_record *t;
 273     const EVP_MD *md = NULL;
 274     int ilen = (int)dlen;
 275     int i;
 276     int num;
 277
 278     if (dane->trecs == NULL) {
 279         SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_NOT_ENABLED);
 280         return -1;
 281     }
 282
 283     if (ilen < 0 || dlen != (size_t)ilen) {
 284         SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_DATA_LENGTH);
 285         return 0;
 286     }
 287
 288     if (usage > DANETLS_USAGE_LAST) {
 289         SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_CERTIFICATE_USAGE);
 290         return 0;
 291     }
 292
 293     if (selector > DANETLS_SELECTOR_LAST) {
 294         SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_SELECTOR);
 295         return 0;
 296     }
 297
 298     if (mtype != DANETLS_MATCHING_FULL) {
 299         md = tlsa_md_get(dane, mtype);
 300         if (md == NULL) {
 301             SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_MATCHING_TYPE);
 302             return 0;
 303         }
 304     }
 305
 306     if (md != NULL && dlen != (size_t)EVP_MD_size(md)) {
 307         SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_DIGEST_LENGTH);
 308         return 0;
 309     }
 310     if (!data) {
 311         SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_NULL_DATA);
 312         return 0;
 313     }
 314
 315     if ((t = OPENSSL_zalloc(sizeof(*t))) == NULL) {
 316         SSLerr(SSL_F_DANE_TLSA_ADD, ERR_R_MALLOC_FAILURE);
 317         return -1;
 318     }
 319
 320     t->usage = usage;
 321     t->selector = selector;
 322     t->mtype = mtype;
 323     t->data = OPENSSL_malloc(ilen);
 324     if (t->data == NULL) {
 325         tlsa_free(t);
 326         SSLerr(SSL_F_DANE_TLSA_ADD, ERR_R_MALLOC_FAILURE);
 327         return -1;
 328     }
 329     memcpy(t->data, data, ilen);
 330     t->dlen = ilen;
 331
 332     /* Validate and cache full certificate or public key */
 333     if (mtype == DANETLS_MATCHING_FULL) {
 334         const unsigned char *p = data;
 335         X509 *cert = NULL;
 336         EVP_PKEY *pkey = NULL;
 337
 338         switch (selector) {
 339         case DANETLS_SELECTOR_CERT:
 340             if (!d2i_X509(&cert, &p, dlen) || p < data ||
 341                 dlen != (size_t)(p - data)) {
 342                 tlsa_free(t);
 343                 SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_CERTIFICATE);
 344                 return 0;
 345             }
 346             if (X509_get0_pubkey(cert) == NULL) {
 347                 tlsa_free(t);
 348                 SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_CERTIFICATE);
 349                 return 0;
 350             }
 351
 352             if ((DANETLS_USAGE_BIT(usage) & DANETLS_TA_MASK) == 0) {
 353                 X509_free(cert);
 354                 break;
 355             }
 356
 357             /*
 358              * For usage DANE-TA(2), we support authentication via "2 0 0" TLSA
 359              * records that contain full certificates of trust-anchors that are
 360              * not present in the wire chain.  For usage PKIX-TA(0), we augment
 361              * the chain with untrusted Full(0) certificates from DNS, in case
 362              * they are missing from the chain.
 363              */
 364             if ((dane->certs == NULL &&
 365                  (dane->certs = sk_X509_new_null()) == NULL) ||
 366                 !sk_X509_push(dane->certs, cert)) {
 367                 SSLerr(SSL_F_DANE_TLSA_ADD, ERR_R_MALLOC_FAILURE);
 368                 X509_free(cert);
 369                 tlsa_free(t);
 370                 return -1;
 371             }
 372             break;
 373
 374         case DANETLS_SELECTOR_SPKI:
 375             if (!d2i_PUBKEY(&pkey, &p, dlen) || p < data ||
 376                 dlen != (size_t)(p - data)) {
 377                 tlsa_free(t);
 378                 SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_PUBLIC_KEY);
 379                 return 0;
 380             }
 381
 382             /*
 383              * For usage DANE-TA(2), we support authentication via "2 1 0" TLSA
 384              * records that contain full bare keys of trust-anchors that are
 385              * not present in the wire chain.
 386              */
 387             if (usage == DANETLS_USAGE_DANE_TA)
 388                 t->spki = pkey;
 389             else
 390                 EVP_PKEY_free(pkey);
 391             break;
 392         }
 393     }
 394
 395     /*-
 396      * Find the right insertion point for the new record.
 397      *
 398      * See crypto/x509/x509_vfy.c.  We sort DANE-EE(3) records first, so that
 399      * they can be processed first, as they require no chain building, and no
 400      * expiration or hostname checks.  Because DANE-EE(3) is numerically
 401      * largest, this is accomplished via descending sort by "usage".
 402      *
 403      * We also sort in descending order by matching ordinal to simplify
 404      * the implementation of digest agility in the verification code.
 405      *
 406      * The choice of order for the selector is not significant, so we
 407      * use the same descending order for consistency.
 408      */
 409     num = sk_danetls_record_num(dane->trecs);
 410     for (i = 0; i < num; ++i) {
 411         danetls_record *rec = sk_danetls_record_value(dane->trecs, i);
 412
 413         if (rec->usage > usage)
 414             continue;
 415         if (rec->usage < usage)
 416             break;
 417         if (rec->selector > selector)
 418             continue;
 419         if (rec->selector < selector)
 420             break;
 421         if (dane->dctx->mdord[rec->mtype] > dane->dctx->mdord[mtype])
 422             continue;
 423         break;
 424     }
 425
 426     if (!sk_danetls_record_insert(dane->trecs, t, i)) {
 427         tlsa_free(t);
 428         SSLerr(SSL_F_DANE_TLSA_ADD, ERR_R_MALLOC_FAILURE);
 429         return -1;
 430     }
 431     dane->umask |= DANETLS_USAGE_BIT(usage);
 432
 433     return 1;
 434 }
 435
 436 static void clear_ciphers(SSL *s)
 437 {
 438     /* clear the current cipher */
 439     ssl_clear_cipher_ctx(s);
 440     ssl_clear_hash_ctx(&s->read_hash);
 441     ssl_clear_hash_ctx(&s->write_hash);
 442 }
 443
 444 int SSL_clear(SSL *s)
 445 {
 446     if (s->method == NULL) {
 447         SSLerr(SSL_F_SSL_CLEAR, SSL_R_NO_METHOD_SPECIFIED);
 448         return (0);
 449     }
 450
 451     if (ssl_clear_bad_session(s)) {
 452         SSL_SESSION_free(s->session);
 453         s->session = NULL;
 454     }
 455
 456     s->error = 0;
 457     s->hit = 0;
 458     s->shutdown = 0;
 459
 460     if (s->renegotiate) {
 461         SSLerr(SSL_F_SSL_CLEAR, ERR_R_INTERNAL_ERROR);
 462         return 0;
 463     }
 464
 465     ossl_statem_clear(s);
 466
 467     s->version = s->method->version;
 468     s->client_version = s->version;
 469     s->rwstate = SSL_NOTHING;
 470
 471     BUF_MEM_free(s->init_buf);
 472     s->init_buf = NULL;
 473     clear_ciphers(s);
 474     s->first_packet = 0;
 475
 476     /* Reset DANE verification result state */
 477     s->dane.mdpth = -1;
 478     s->dane.pdpth = -1;
 479     X509_free(s->dane.mcert);
 480     s->dane.mcert = NULL;
 481     s->dane.mtlsa = NULL;
 482
 483     /* Clear the verification result peername */
 484     X509_VERIFY_PARAM_move_peername(s->param, NULL);
 485
 486     /*
 487      * Check to see if we were changed into a different method, if so, revert
 488      * back if we are not doing session-id reuse.
 489      */
 490     if (!ossl_statem_get_in_handshake(s) && (s->session == NULL)
 491         && (s->method != s->ctx->method)) {
 492         s->method->ssl_free(s);
 493         s->method = s->ctx->method;
 494         if (!s->method->ssl_new(s))
 495             return (0);
 496     } else
 497         s->method->ssl_clear(s);
 498
 499     RECORD_LAYER_clear(&s->rlayer);
 500
 501     return (1);
 502 }
 503
 504 /** Used to change an SSL_CTXs default SSL method type */
 505 int SSL_CTX_set_ssl_version(SSL_CTX *ctx, const SSL_METHOD *meth)
 506 {
 507     STACK_OF(SSL_CIPHER) *sk;
 508
 509     ctx->method = meth;
 510
 511     sk = ssl_create_cipher_list(ctx->method, &(ctx->cipher_list),
 512                                 &(ctx->cipher_list_by_id),
 513                                 SSL_DEFAULT_CIPHER_LIST, ctx->cert);
 514     if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= 0)) {
 515         SSLerr(SSL_F_SSL_CTX_SET_SSL_VERSION,
 516                SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS);
 517         return (0);
 518     }
 519     return (1);
 520 }
 521
 522 SSL *SSL_new(SSL_CTX *ctx)
 523 {
 524     SSL *s;
 525
 526     if (ctx == NULL) {
 527         SSLerr(SSL_F_SSL_NEW, SSL_R_NULL_SSL_CTX);
 528         return (NULL);
 529     }
 530     if (ctx->method == NULL) {
 531         SSLerr(SSL_F_SSL_NEW, SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION);
 532         return (NULL);
 533     }
 534
 535     s = OPENSSL_zalloc(sizeof(*s));
 536     if (s == NULL)
 537         goto err;
 538
 539     s->lock = CRYPTO_THREAD_lock_new();
 540     if (s->lock == NULL) {
 541         SSLerr(SSL_F_SSL_NEW, ERR_R_MALLOC_FAILURE);
 542         OPENSSL_free(s);
 543         return NULL;
 544     }
 545
 546     RECORD_LAYER_init(&s->rlayer, s);
 547
 548     s->options = ctx->options;
 549     s->dane.flags = ctx->dane.flags;
 550     s->min_proto_version = ctx->min_proto_version;
 551     s->max_proto_version = ctx->max_proto_version;
 552     s->mode = ctx->mode;
 553     s->max_cert_list = ctx->max_cert_list;
 554     s->references = 1;
 555
 556     /*
 557      * Earlier library versions used to copy the pointer to the CERT, not
 558      * its contents; only when setting new parameters for the per-SSL
 559      * copy, ssl_cert_new would be called (and the direct reference to
 560      * the per-SSL_CTX settings would be lost, but those still were
 561      * indirectly accessed for various purposes, and for that reason they
 562      * used to be known as s->ctx->default_cert). Now we don't look at the
 563      * SSL_CTX's CERT after having duplicated it once.
 564      */
 565     s->cert = ssl_cert_dup(ctx->cert);
 566     if (s->cert == NULL)
 567         goto err;
 568
 569     RECORD_LAYER_set_read_ahead(&s->rlayer, ctx->read_ahead);
 570     s->msg_callback = ctx->msg_callback;
 571     s->msg_callback_arg = ctx->msg_callback_arg;
 572     s->verify_mode = ctx->verify_mode;
 573     s->not_resumable_session_cb = ctx->not_resumable_session_cb;
 574     s->sid_ctx_length = ctx->sid_ctx_length;
 575     OPENSSL_assert(s->sid_ctx_length <= sizeof s->sid_ctx);
 576     memcpy(&s->sid_ctx, &ctx->sid_ctx, sizeof(s->sid_ctx));
 577     s->verify_callback = ctx->default_verify_callback;
 578     s->generate_session_id = ctx->generate_session_id;
 579
 580     s->param = X509_VERIFY_PARAM_new();
 581     if (s->param == NULL)
 582         goto err;
 583     X509_VERIFY_PARAM_inherit(s->param, ctx->param);
 584     s->quiet_shutdown = ctx->quiet_shutdown;
 585     s->max_send_fragment = ctx->max_send_fragment;
 586     s->split_send_fragment = ctx->split_send_fragment;
 587     s->max_pipelines = ctx->max_pipelines;
 588     if (s->max_pipelines > 1)
 589         RECORD_LAYER_set_read_ahead(&s->rlayer, 1);
 590     if (ctx->default_read_buf_len > 0)
 591         SSL_set_default_read_buffer_len(s, ctx->default_read_buf_len);
 592
 593     SSL_CTX_up_ref(ctx);
 594     s->ctx = ctx;
 595     s->tlsext_debug_cb = 0;
 596     s->tlsext_debug_arg = NULL;
 597     s->tlsext_ticket_expected = 0;
 598     s->tlsext_status_type = ctx->tlsext_status_type;
 599     s->tlsext_status_expected = 0;
 600     s->tlsext_ocsp_ids = NULL;
 601     s->tlsext_ocsp_exts = NULL;
 602     s->tlsext_ocsp_resp = NULL;
 603     s->tlsext_ocsp_resplen = -1;
 604     SSL_CTX_up_ref(ctx);
 605     s->initial_ctx = ctx;
 606 # ifndef OPENSSL_NO_EC
 607     if (ctx->tlsext_ecpointformatlist) {
 608         s->tlsext_ecpointformatlist =
 609             OPENSSL_memdup(ctx->tlsext_ecpointformatlist,
 610                            ctx->tlsext_ecpointformatlist_length);
 611         if (!s->tlsext_ecpointformatlist)
 612             goto err;
 613         s->tlsext_ecpointformatlist_length =
 614             ctx->tlsext_ecpointformatlist_length;
 615     }
 616     if (ctx->tlsext_ellipticcurvelist) {
 617         s->tlsext_ellipticcurvelist =
 618             OPENSSL_memdup(ctx->tlsext_ellipticcurvelist,
 619                            ctx->tlsext_ellipticcurvelist_length);
 620         if (!s->tlsext_ellipticcurvelist)
 621             goto err;
 622         s->tlsext_ellipticcurvelist_length =
 623             ctx->tlsext_ellipticcurvelist_length;
 624     }
 625 # endif
 626 # ifndef OPENSSL_NO_NEXTPROTONEG
 627     s->next_proto_negotiated = NULL;
 628 # endif
 629
 630     if (s->ctx->alpn_client_proto_list) {
 631         s->alpn_client_proto_list =
 632             OPENSSL_malloc(s->ctx->alpn_client_proto_list_len);
 633         if (s->alpn_client_proto_list == NULL)
 634             goto err;
 635         memcpy(s->alpn_client_proto_list, s->ctx->alpn_client_proto_list,
 636                s->ctx->alpn_client_proto_list_len);
 637         s->alpn_client_proto_list_len = s->ctx->alpn_client_proto_list_len;
 638     }
 639
 640     s->verified_chain = NULL;
 641     s->verify_result = X509_V_OK;
 642
 643     s->default_passwd_callback = ctx->default_passwd_callback;
 644     s->default_passwd_callback_userdata = ctx->default_passwd_callback_userdata;
 645
 646     s->method = ctx->method;
 647
 648     if (!s->method->ssl_new(s))
 649         goto err;
 650
 651     s->server = (ctx->method->ssl_accept == ssl_undefined_function) ? 0 : 1;
 652
 653     if (!SSL_clear(s))
 654         goto err;
 655
 656     if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data))
 657         goto err;
 658
 659 #ifndef OPENSSL_NO_PSK
 660     s->psk_client_callback = ctx->psk_client_callback;
 661     s->psk_server_callback = ctx->psk_server_callback;
 662 #endif
 663
 664     s->job = NULL;
 665
 666 #ifndef OPENSSL_NO_CT
 667     if (!SSL_set_ct_validation_callback(s, ctx->ct_validation_callback,
 668             ctx->ct_validation_callback_arg))
 669         goto err;
 670 #endif
 671
 672     return s;
 673  err:
 674     SSL_free(s);
 675     SSLerr(SSL_F_SSL_NEW, ERR_R_MALLOC_FAILURE);
 676     return NULL;
 677 }
 678
 679 int SSL_is_dtls(const SSL *s)
 680 {
 681     return SSL_IS_DTLS(s) ? 1 : 0;
 682 }
 683
 684 int SSL_up_ref(SSL *s)
 685 {
 686     int i;
 687
 688     if (CRYPTO_atomic_add(&s->references, 1, &i, s->lock) <= 0)
 689         return 0;
 690
 691     REF_PRINT_COUNT("SSL", s);
 692     REF_ASSERT_ISNT(i < 2);
 693     return ((i > 1) ? 1 : 0);
 694 }
 695
 696 int SSL_CTX_set_session_id_context(SSL_CTX *ctx, const unsigned char *sid_ctx,
 697                                    unsigned int sid_ctx_len)
 698 {
 699     if (sid_ctx_len > sizeof ctx->sid_ctx) {
 700         SSLerr(SSL_F_SSL_CTX_SET_SESSION_ID_CONTEXT,
 701                SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
 702         return 0;
 703     }
 704     ctx->sid_ctx_length = sid_ctx_len;
 705     memcpy(ctx->sid_ctx, sid_ctx, sid_ctx_len);
 706
 707     return 1;
 708 }
 709
 710 int SSL_set_session_id_context(SSL *ssl, const unsigned char *sid_ctx,
 711                                unsigned int sid_ctx_len)
 712 {
 713     if (sid_ctx_len > SSL_MAX_SID_CTX_LENGTH) {
 714         SSLerr(SSL_F_SSL_SET_SESSION_ID_CONTEXT,
 715                SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
 716         return 0;
 717     }
 718     ssl->sid_ctx_length = sid_ctx_len;
 719     memcpy(ssl->sid_ctx, sid_ctx, sid_ctx_len);
 720
 721     return 1;
 722 }
 723
 724 int SSL_CTX_set_generate_session_id(SSL_CTX *ctx, GEN_SESSION_CB cb)
 725 {
 726     CRYPTO_THREAD_write_lock(ctx->lock);
 727     ctx->generate_session_id = cb;
 728     CRYPTO_THREAD_unlock(ctx->lock);
 729     return 1;
 730 }
 731
 732 int SSL_set_generate_session_id(SSL *ssl, GEN_SESSION_CB cb)
 733 {
 734     CRYPTO_THREAD_write_lock(ssl->lock);
 735     ssl->generate_session_id = cb;
 736     CRYPTO_THREAD_unlock(ssl->lock);
 737     return 1;
 738 }
 739
 740 int SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id,
 741                                 unsigned int id_len)
 742 {
 743     /*
 744      * A quick examination of SSL_SESSION_hash and SSL_SESSION_cmp shows how
 745      * we can "construct" a session to give us the desired check - ie. to
 746      * find if there's a session in the hash table that would conflict with
 747      * any new session built out of this id/id_len and the ssl_version in use
 748      * by this SSL.
 749      */
 750     SSL_SESSION r, *p;
 751
 752     if (id_len > sizeof r.session_id)
 753         return 0;
 754
 755     r.ssl_version = ssl->version;
 756     r.session_id_length = id_len;
 757     memcpy(r.session_id, id, id_len);
 758
 759     CRYPTO_THREAD_read_lock(ssl->session_ctx->lock);
 760     p = lh_SSL_SESSION_retrieve(ssl->session_ctx->sessions, &r);
 761     CRYPTO_THREAD_unlock(ssl->session_ctx->lock);
 762     return (p != NULL);
 763 }
 764
 765 int SSL_CTX_set_purpose(SSL_CTX *s, int purpose)
 766 {
 767     return X509_VERIFY_PARAM_set_purpose(s->param, purpose);
 768 }
 769
 770 int SSL_set_purpose(SSL *s, int purpose)
 771 {
 772     return X509_VERIFY_PARAM_set_purpose(s->param, purpose);
 773 }
 774
 775 int SSL_CTX_set_trust(SSL_CTX *s, int trust)
 776 {
 777     return X509_VERIFY_PARAM_set_trust(s->param, trust);
 778 }
 779
 780 int SSL_set_trust(SSL *s, int trust)
 781 {
 782     return X509_VERIFY_PARAM_set_trust(s->param, trust);
 783 }
 784
 785 int SSL_set1_host(SSL *s, const char *hostname)
 786 {
 787     return X509_VERIFY_PARAM_set1_host(s->param, hostname, 0);
 788 }
 789
 790 int SSL_add1_host(SSL *s, const char *hostname)
 791 {
 792     return X509_VERIFY_PARAM_add1_host(s->param, hostname, 0);
 793 }
 794
 795 void SSL_set_hostflags(SSL *s, unsigned int flags)
 796 {
 797     X509_VERIFY_PARAM_set_hostflags(s->param, flags);
 798 }
 799
 800 const char *SSL_get0_peername(SSL *s)
 801 {
 802     return X509_VERIFY_PARAM_get0_peername(s->param);
 803 }
 804
 805 int SSL_CTX_dane_enable(SSL_CTX *ctx)
 806 {
 807     return dane_ctx_enable(&ctx->dane);
 808 }
 809
 810 unsigned long SSL_CTX_dane_set_flags(SSL_CTX *ctx, unsigned long flags)
 811 {
 812     unsigned long orig = ctx->dane.flags;
 813
 814     ctx->dane.flags |= flags;
 815     return orig;
 816 }
 817
 818 unsigned long SSL_CTX_dane_clear_flags(SSL_CTX *ctx, unsigned long flags)
 819 {
 820     unsigned long orig = ctx->dane.flags;
 821
 822     ctx->dane.flags &= ~flags;
 823     return orig;
 824 }
 825
 826 int SSL_dane_enable(SSL *s, const char *basedomain)
 827 {
 828     SSL_DANE *dane = &s->dane;
 829
 830     if (s->ctx->dane.mdmax == 0) {
 831         SSLerr(SSL_F_SSL_DANE_ENABLE, SSL_R_CONTEXT_NOT_DANE_ENABLED);
 832         return 0;
 833     }
 834     if (dane->trecs != NULL) {
 835         SSLerr(SSL_F_SSL_DANE_ENABLE, SSL_R_DANE_ALREADY_ENABLED);
 836         return 0;
 837     }
 838
 839     /*
 840      * Default SNI name.  This rejects empty names, while set1_host below
 841      * accepts them and disables host name checks.  To avoid side-effects with
 842      * invalid input, set the SNI name first.
 843      */
 844     if (s->tlsext_hostname == NULL) {
 845         if (!SSL_set_tlsext_host_name(s, basedomain)) {
 846             SSLerr(SSL_F_SSL_DANE_ENABLE, SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN);
 847             return -1;
 848         }
 849     }
 850
 851     /* Primary RFC6125 reference identifier */
 852     if (!X509_VERIFY_PARAM_set1_host(s->param, basedomain, 0)) {
 853         SSLerr(SSL_F_SSL_DANE_ENABLE, SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN);
 854         return -1;
 855     }
 856
 857     dane->mdpth = -1;
 858     dane->pdpth = -1;
 859     dane->dctx = &s->ctx->dane;
 860     dane->trecs = sk_danetls_record_new_null();
 861
 862     if (dane->trecs == NULL) {
 863         SSLerr(SSL_F_SSL_DANE_ENABLE, ERR_R_MALLOC_FAILURE);
 864         return -1;
 865     }
 866     return 1;
 867 }
 868
 869 unsigned long SSL_dane_set_flags(SSL *ssl, unsigned long flags)
 870 {
 871     unsigned long orig = ssl->dane.flags;
 872
 873     ssl->dane.flags |= flags;
 874     return orig;
 875 }
 876
 877 unsigned long SSL_dane_clear_flags(SSL *ssl, unsigned long flags)
 878 {
 879     unsigned long orig = ssl->dane.flags;
 880
 881     ssl->dane.flags &= ~flags;
 882     return orig;
 883 }
 884
 885 int SSL_get0_dane_authority(SSL *s, X509 **mcert, EVP_PKEY **mspki)
 886 {
 887     SSL_DANE *dane = &s->dane;
 888
 889     if (!DANETLS_ENABLED(dane) || s->verify_result != X509_V_OK)
 890         return -1;
 891     if (dane->mtlsa) {
 892         if (mcert)
 893             *mcert = dane->mcert;
 894         if (mspki)
 895             *mspki = (dane->mcert == NULL) ? dane->mtlsa->spki : NULL;
 896     }
 897     return dane->mdpth;
 898 }
 899
 900 int SSL_get0_dane_tlsa(SSL *s, uint8_t *usage, uint8_t *selector,
 901                        uint8_t *mtype, unsigned const char **data, size_t *dlen)
 902 {
 903     SSL_DANE *dane = &s->dane;
 904
 905     if (!DANETLS_ENABLED(dane) || s->verify_result != X509_V_OK)
 906         return -1;
 907     if (dane->mtlsa) {
 908         if (usage)
 909             *usage = dane->mtlsa->usage;
 910         if (selector)
 911             *selector = dane->mtlsa->selector;
 912         if (mtype)
 913             *mtype = dane->mtlsa->mtype;
 914         if (data)
 915             *data = dane->mtlsa->data;
 916         if (dlen)
 917             *dlen = dane->mtlsa->dlen;
 918     }
 919     return dane->mdpth;
 920 }
 921
 922 SSL_DANE *SSL_get0_dane(SSL *s)
 923 {
 924     return &s->dane;
 925 }
 926
 927 int SSL_dane_tlsa_add(SSL *s, uint8_t usage, uint8_t selector,
 928                       uint8_t mtype, unsigned char *data, size_t dlen)
 929 {
 930     return dane_tlsa_add(&s->dane, usage, selector, mtype, data, dlen);
 931 }
 932
 933 int SSL_CTX_dane_mtype_set(SSL_CTX *ctx, const EVP_MD *md, uint8_t mtype, uint8_t ord)
 934 {
 935     return dane_mtype_set(&ctx->dane, md, mtype, ord);
 936 }
 937
 938 int SSL_CTX_set1_param(SSL_CTX *ctx, X509_VERIFY_PARAM *vpm)
 939 {
 940     return X509_VERIFY_PARAM_set1(ctx->param, vpm);
 941 }
 942
 943 int SSL_set1_param(SSL *ssl, X509_VERIFY_PARAM *vpm)
 944 {
 945     return X509_VERIFY_PARAM_set1(ssl->param, vpm);
 946 }
 947
 948 X509_VERIFY_PARAM *SSL_CTX_get0_param(SSL_CTX *ctx)
 949 {
 950     return ctx->param;
 951 }
 952
 953 X509_VERIFY_PARAM *SSL_get0_param(SSL *ssl)
 954 {
 955     return ssl->param;
 956 }
 957
 958 void SSL_certs_clear(SSL *s)
 959 {
 960     ssl_cert_clear_certs(s->cert);
 961 }
 962
 963 void SSL_free(SSL *s)
 964 {
 965     int i;
 966
 967     if (s == NULL)
 968         return;
 969
 970     CRYPTO_atomic_add(&s->references, -1, &i, s->lock);
 971     REF_PRINT_COUNT("SSL", s);
 972     if (i > 0)
 973         return;
 974     REF_ASSERT_ISNT(i < 0);
 975
 976     X509_VERIFY_PARAM_free(s->param);
 977     dane_final(&s->dane);
 978     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
 979
 980     if (s->bbio != NULL) {
 981         /* If the buffering BIO is in place, pop it off */
 982         if (s->bbio == s->wbio) {
 983             s->wbio = BIO_pop(s->wbio);
 984         }
 985         BIO_free(s->bbio);
 986         s->bbio = NULL;
 987     }
 988     if (s->wbio != s->rbio)
 989         BIO_free_all(s->wbio);
 990     BIO_free_all(s->rbio);
 991
 992     BUF_MEM_free(s->init_buf);
 993
 994     /* add extra stuff */
 995     sk_SSL_CIPHER_free(s->cipher_list);
 996     sk_SSL_CIPHER_free(s->cipher_list_by_id);
 997
 998     /* Make the next call work :-) */
 999     if (s->session != NULL) {
1000         ssl_clear_bad_session(s);
1001         SSL_SESSION_free(s->session);
1002     }
1003
1004     clear_ciphers(s);
1005
1006     ssl_cert_free(s->cert);
1007     /* Free up if allocated */
1008
1009     OPENSSL_free(s->tlsext_hostname);
1010     SSL_CTX_free(s->initial_ctx);
1011 #ifndef OPENSSL_NO_EC
1012     OPENSSL_free(s->tlsext_ecpointformatlist);
1013     OPENSSL_free(s->tlsext_ellipticcurvelist);
1014 #endif                         /* OPENSSL_NO_EC */
1015     sk_X509_EXTENSION_pop_free(s->tlsext_ocsp_exts, X509_EXTENSION_free);
1016 #ifndef OPENSSL_NO_OCSP
1017     sk_OCSP_RESPID_pop_free(s->tlsext_ocsp_ids, OCSP_RESPID_free);
1018 #endif
1019 #ifndef OPENSSL_NO_CT
1020     SCT_LIST_free(s->scts);
1021     OPENSSL_free(s->tlsext_scts);
1022 #endif
1023     OPENSSL_free(s->tlsext_ocsp_resp);
1024     OPENSSL_free(s->alpn_client_proto_list);
1025
1026     sk_X509_NAME_pop_free(s->client_CA, X509_NAME_free);
1027
1028     sk_X509_pop_free(s->verified_chain, X509_free);
1029
1030     if (s->method != NULL)
1031         s->method->ssl_free(s);
1032
1033     RECORD_LAYER_release(&s->rlayer);
1034
1035     SSL_CTX_free(s->ctx);
1036
1037     ASYNC_WAIT_CTX_free(s->waitctx);
1038
1039 #if !defined(OPENSSL_NO_NEXTPROTONEG)
1040     OPENSSL_free(s->next_proto_negotiated);
1041 #endif
1042
1043 #ifndef OPENSSL_NO_SRTP
1044     sk_SRTP_PROTECTION_PROFILE_free(s->srtp_profiles);
1045 #endif
1046
1047     CRYPTO_THREAD_lock_free(s->lock);
1048
1049     OPENSSL_free(s);
1050 }
1051
1052 void SSL_set_rbio(SSL *s, BIO *rbio)
1053 {
1054     if (s->rbio != rbio)
1055         BIO_free_all(s->rbio);
1056     s->rbio = rbio;
1057 }
1058
1059 void SSL_set_wbio(SSL *s, BIO *wbio)
1060 {
1061     /*
1062      * If the output buffering BIO is still in place, remove it
1063      */
1064     if (s->bbio != NULL) {
1065         if (s->wbio == s->bbio) {
1066             s->wbio = BIO_next(s->wbio);
1067             BIO_set_next(s->bbio, NULL);
1068         }
1069     }
1070     if (s->wbio != wbio && s->rbio != s->wbio)
1071         BIO_free_all(s->wbio);
1072     s->wbio = wbio;
1073 }
1074
1075 void SSL_set_bio(SSL *s, BIO *rbio, BIO *wbio)
1076 {
1077     SSL_set_wbio(s, wbio);
1078     SSL_set_rbio(s, rbio);
1079 }
1080
1081 BIO *SSL_get_rbio(const SSL *s)
1082 {
1083     return (s->rbio);
1084 }
1085
1086 BIO *SSL_get_wbio(const SSL *s)
1087 {
1088     return (s->wbio);
1089 }
1090
1091 int SSL_get_fd(const SSL *s)
1092 {
1093     return (SSL_get_rfd(s));
1094 }
1095
1096 int SSL_get_rfd(const SSL *s)
1097 {
1098     int ret = -1;
1099     BIO *b, *r;
1100
1101     b = SSL_get_rbio(s);
1102     r = BIO_find_type(b, BIO_TYPE_DESCRIPTOR);
1103     if (r != NULL)
1104         BIO_get_fd(r, &ret);
1105     return (ret);
1106 }
1107
1108 int SSL_get_wfd(const SSL *s)
1109 {
1110     int ret = -1;
1111     BIO *b, *r;
1112
1113     b = SSL_get_wbio(s);
1114     r = BIO_find_type(b, BIO_TYPE_DESCRIPTOR);
1115     if (r != NULL)
1116         BIO_get_fd(r, &ret);
1117     return (ret);
1118 }
1119
1120 #ifndef OPENSSL_NO_SOCK
1121 int SSL_set_fd(SSL *s, int fd)
1122 {
1123     int ret = 0;
1124     BIO *bio = NULL;
1125
1126     bio = BIO_new(BIO_s_socket());
1127
1128     if (bio == NULL) {
1129         SSLerr(SSL_F_SSL_SET_FD, ERR_R_BUF_LIB);
1130         goto err;
1131     }
1132     BIO_set_fd(bio, fd, BIO_NOCLOSE);
1133     SSL_set_bio(s, bio, bio);
1134     ret = 1;
1135  err:
1136     return (ret);
1137 }
1138
1139 int SSL_set_wfd(SSL *s, int fd)
1140 {
1141     int ret = 0;
1142     BIO *bio = NULL;
1143
1144     if ((s->rbio == NULL) || (BIO_method_type(s->rbio) != BIO_TYPE_SOCKET)
1145         || ((int)BIO_get_fd(s->rbio, NULL) != fd)) {
1146         bio = BIO_new(BIO_s_socket());
1147
1148         if (bio == NULL) {
1149             SSLerr(SSL_F_SSL_SET_WFD, ERR_R_BUF_LIB);
1150             goto err;
1151         }
1152         BIO_set_fd(bio, fd, BIO_NOCLOSE);
1153         SSL_set_bio(s, SSL_get_rbio(s), bio);
1154     } else
1155         SSL_set_bio(s, SSL_get_rbio(s), SSL_get_rbio(s));
1156     ret = 1;
1157  err:
1158     return (ret);
1159 }
1160
1161 int SSL_set_rfd(SSL *s, int fd)
1162 {
1163     int ret = 0;
1164     BIO *bio = NULL;
1165
1166     if ((s->wbio == NULL) || (BIO_method_type(s->wbio) != BIO_TYPE_SOCKET)
1167         || ((int)BIO_get_fd(s->wbio, NULL) != fd)) {
1168         bio = BIO_new(BIO_s_socket());
1169
1170         if (bio == NULL) {
1171             SSLerr(SSL_F_SSL_SET_RFD, ERR_R_BUF_LIB);
1172             goto err;
1173         }
1174         BIO_set_fd(bio, fd, BIO_NOCLOSE);
1175         SSL_set_bio(s, bio, SSL_get_wbio(s));
1176     } else
1177         SSL_set_bio(s, SSL_get_wbio(s), SSL_get_wbio(s));
1178     ret = 1;
1179  err:
1180     return (ret);
1181 }
1182 #endif
1183
1184 /* return length of latest Finished message we sent, copy to 'buf' */
1185 size_t SSL_get_finished(const SSL *s, void *buf, size_t count)
1186 {
1187     size_t ret = 0;
1188
1189     if (s->s3 != NULL) {
1190         ret = s->s3->tmp.finish_md_len;
1191         if (count > ret)
1192             count = ret;
1193         memcpy(buf, s->s3->tmp.finish_md, count);
1194     }
1195     return ret;
1196 }
1197
1198 /* return length of latest Finished message we expected, copy to 'buf' */
1199 size_t SSL_get_peer_finished(const SSL *s, void *buf, size_t count)
1200 {
1201     size_t ret = 0;
1202
1203     if (s->s3 != NULL) {
1204         ret = s->s3->tmp.peer_finish_md_len;
1205         if (count > ret)
1206             count = ret;
1207         memcpy(buf, s->s3->tmp.peer_finish_md, count);
1208     }
1209     return ret;
1210 }
1211
1212 int SSL_get_verify_mode(const SSL *s)
1213 {
1214     return (s->verify_mode);
1215 }
1216
1217 int SSL_get_verify_depth(const SSL *s)
1218 {
1219     return X509_VERIFY_PARAM_get_depth(s->param);
1220 }
1221
1222 int (*SSL_get_verify_callback(const SSL *s)) (int, X509_STORE_CTX *) {
1223     return (s->verify_callback);
1224 }
1225
1226 int SSL_CTX_get_verify_mode(const SSL_CTX *ctx)
1227 {
1228     return (ctx->verify_mode);
1229 }
1230
1231 int SSL_CTX_get_verify_depth(const SSL_CTX *ctx)
1232 {
1233     return X509_VERIFY_PARAM_get_depth(ctx->param);
1234 }
1235
1236 int (*SSL_CTX_get_verify_callback(const SSL_CTX *ctx)) (int, X509_STORE_CTX *) {
1237     return (ctx->default_verify_callback);
1238 }
1239
1240 void SSL_set_verify(SSL *s, int mode,
1241                     int (*callback) (int ok, X509_STORE_CTX *ctx))
1242 {
1243     s->verify_mode = mode;
1244     if (callback != NULL)
1245         s->verify_callback = callback;
1246 }
1247
1248 void SSL_set_verify_depth(SSL *s, int depth)
1249 {
1250     X509_VERIFY_PARAM_set_depth(s->param, depth);
1251 }
1252
1253 void SSL_set_read_ahead(SSL *s, int yes)
1254 {
1255     RECORD_LAYER_set_read_ahead(&s->rlayer, yes);
1256 }
1257
1258 int SSL_get_read_ahead(const SSL *s)
1259 {
1260     return RECORD_LAYER_get_read_ahead(&s->rlayer);
1261 }
1262
1263 int SSL_pending(const SSL *s)
1264 {
1265     /*
1266      * SSL_pending cannot work properly if read-ahead is enabled
1267      * (SSL_[CTX_]ctrl(..., SSL_CTRL_SET_READ_AHEAD, 1, NULL)), and it is
1268      * impossible to fix since SSL_pending cannot report errors that may be
1269      * observed while scanning the new data. (Note that SSL_pending() is
1270      * often used as a boolean value, so we'd better not return -1.)
1271      */
1272     return (s->method->ssl_pending(s));
1273 }
1274
1275 int SSL_has_pending(const SSL *s)
1276 {
1277     /*
1278      * Similar to SSL_pending() but returns a 1 to indicate that we have
1279      * unprocessed data available or 0 otherwise (as opposed to the number of
1280      * bytes available). Unlike SSL_pending() this will take into account
1281      * read_ahead data. A 1 return simply indicates that we have unprocessed
1282      * data. That data may not result in any application data, or we may fail
1283      * to parse the records for some reason.
1284      */
1285     if (SSL_pending(s))
1286         return 1;
1287
1288     return RECORD_LAYER_read_pending(&s->rlayer);
1289 }
1290
1291 X509 *SSL_get_peer_certificate(const SSL *s)
1292 {
1293     X509 *r;
1294
1295     if ((s == NULL) || (s->session == NULL))
1296         r = NULL;
1297     else
1298         r = s->session->peer;
1299
1300     if (r == NULL)
1301         return (r);
1302
1303     X509_up_ref(r);
1304
1305     return (r);
1306 }
1307
1308 STACK_OF(X509) *SSL_get_peer_cert_chain(const SSL *s)
1309 {
1310     STACK_OF(X509) *r;
1311
1312     if ((s == NULL) || (s->session == NULL))
1313         r = NULL;
1314     else
1315         r = s->session->peer_chain;
1316
1317     /*
1318      * If we are a client, cert_chain includes the peer's own certificate; if
1319      * we are a server, it does not.
1320      */
1321
1322     return (r);
1323 }
1324
1325 /*
1326  * Now in theory, since the calling process own 't' it should be safe to
1327  * modify.  We need to be able to read f without being hassled
1328  */
1329 int SSL_copy_session_id(SSL *t, const SSL *f)
1330 {
1331     int i;
1332     /* Do we need to to SSL locking? */
1333     if (!SSL_set_session(t, SSL_get_session(f))) {
1334         return 0;
1335     }
1336
1337     /*
1338      * what if we are setup for one protocol version but want to talk another
1339      */
1340     if (t->method != f->method) {
1341         t->method->ssl_free(t);
1342         t->method = f->method;
1343         if (t->method->ssl_new(t) == 0)
1344             return 0;
1345     }
1346
1347     CRYPTO_atomic_add(&f->cert->references, 1, &i, f->cert->lock);
1348     ssl_cert_free(t->cert);
1349     t->cert = f->cert;
1350     if (!SSL_set_session_id_context(t, f->sid_ctx, f->sid_ctx_length)) {
1351         return 0;
1352     }
1353
1354     return 1;
1355 }
1356
1357 /* Fix this so it checks all the valid key/cert options */
1358 int SSL_CTX_check_private_key(const SSL_CTX *ctx)
1359 {
1360     if ((ctx == NULL) ||
1361         (ctx->cert->key->x509 == NULL)) {
1362         SSLerr(SSL_F_SSL_CTX_CHECK_PRIVATE_KEY,
1363                SSL_R_NO_CERTIFICATE_ASSIGNED);
1364         return (0);
1365     }
1366     if (ctx->cert->key->privatekey == NULL) {
1367         SSLerr(SSL_F_SSL_CTX_CHECK_PRIVATE_KEY,
1368                SSL_R_NO_PRIVATE_KEY_ASSIGNED);
1369         return (0);
1370     }
1371     return (X509_check_private_key
1372             (ctx->cert->key->x509, ctx->cert->key->privatekey));
1373 }
1374
1375 /* Fix this function so that it takes an optional type parameter */
1376 int SSL_check_private_key(const SSL *ssl)
1377 {
1378     if (ssl == NULL) {
1379         SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY, ERR_R_PASSED_NULL_PARAMETER);
1380         return (0);
1381     }
1382     if (ssl->cert->key->x509 == NULL) {
1383         SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY, SSL_R_NO_CERTIFICATE_ASSIGNED);
1384         return (0);
1385     }
1386     if (ssl->cert->key->privatekey == NULL) {
1387         SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY, SSL_R_NO_PRIVATE_KEY_ASSIGNED);
1388         return (0);
1389     }
1390     return (X509_check_private_key(ssl->cert->key->x509,
1391                                    ssl->cert->key->privatekey));
1392 }
1393
1394 int SSL_waiting_for_async(SSL *s)
1395 {
1396     if (s->job)
1397         return 1;
1398
1399     return 0;
1400 }
1401
1402 int SSL_get_all_async_fds(SSL *s, OSSL_ASYNC_FD *fds, size_t *numfds)
1403 {
1404     ASYNC_WAIT_CTX *ctx = s->waitctx;
1405
1406     if (ctx == NULL)
1407         return 0;
1408     return ASYNC_WAIT_CTX_get_all_fds(ctx, fds, numfds);
1409 }
1410
1411 int SSL_get_changed_async_fds(SSL *s, OSSL_ASYNC_FD *addfd, size_t *numaddfds,
1412                               OSSL_ASYNC_FD *delfd, size_t *numdelfds)
1413 {
1414     ASYNC_WAIT_CTX *ctx = s->waitctx;
1415
1416     if (ctx == NULL)
1417         return 0;
1418     return ASYNC_WAIT_CTX_get_changed_fds(ctx, addfd, numaddfds, delfd,
1419                                           numdelfds);
1420 }
1421
1422 int SSL_accept(SSL *s)
1423 {
1424     if (s->handshake_func == NULL) {
1425         /* Not properly initialized yet */
1426         SSL_set_accept_state(s);
1427     }
1428
1429     return SSL_do_handshake(s);
1430 }
1431
1432 int SSL_connect(SSL *s)
1433 {
1434     if (s->handshake_func == NULL) {
1435         /* Not properly initialized yet */
1436         SSL_set_connect_state(s);
1437     }
1438
1439     return SSL_do_handshake(s);
1440 }
1441
1442 long SSL_get_default_timeout(const SSL *s)
1443 {
1444     return (s->method->get_timeout());
1445 }
1446
1447 static int ssl_start_async_job(SSL *s, struct ssl_async_args *args,
1448                           int (*func)(void *)) {
1449     int ret;
1450     if (s->waitctx == NULL) {
1451         s->waitctx = ASYNC_WAIT_CTX_new();
1452         if (s->waitctx == NULL)
1453             return -1;
1454     }
1455     switch (ASYNC_start_job(&s->job, s->waitctx, &ret, func, args,
1456         sizeof(struct ssl_async_args))) {
1457     case ASYNC_ERR:
1458         s->rwstate = SSL_NOTHING;
1459         SSLerr(SSL_F_SSL_START_ASYNC_JOB, SSL_R_FAILED_TO_INIT_ASYNC);
1460         return -1;
1461     case ASYNC_PAUSE:
1462         s->rwstate = SSL_ASYNC_PAUSED;
1463         return -1;
1464     case ASYNC_NO_JOBS:
1465         s->rwstate = SSL_ASYNC_NO_JOBS;
1466         return -1;
1467     case ASYNC_FINISH:
1468         s->job = NULL;
1469         return ret;
1470     default:
1471         s->rwstate = SSL_NOTHING;
1472         SSLerr(SSL_F_SSL_START_ASYNC_JOB, ERR_R_INTERNAL_ERROR);
1473         /* Shouldn't happen */
1474         return -1;
1475     }
1476 }
1477
1478 static int ssl_io_intern(void *vargs)
1479 {
1480     struct ssl_async_args *args;
1481     SSL *s;
1482     void *buf;
1483     int num;
1484
1485     args = (struct ssl_async_args *)vargs;
1486     s = args->s;
1487     buf = args->buf;
1488     num = args->num;
1489     switch (args->type) {
1490     case READFUNC:
1491         return args->f.func_read(s, buf, num);
1492     case WRITEFUNC:
1493         return args->f.func_write(s, buf, num);
1494     case OTHERFUNC:
1495         return args->f.func_other(s);
1496     }
1497     return -1;
1498 }
1499
1500 int SSL_read(SSL *s, void *buf, int num)
1501 {
1502     if (s->handshake_func == NULL) {
1503         SSLerr(SSL_F_SSL_READ, SSL_R_UNINITIALIZED);
1504         return -1;
1505     }
1506
1507     if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
1508         s->rwstate = SSL_NOTHING;
1509         return (0);
1510     }
1511
1512     if ((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
1513         struct ssl_async_args args;
1514
1515         args.s = s;
1516         args.buf = buf;
1517         args.num = num;
1518         args.type = READFUNC;
1519         args.f.func_read = s->method->ssl_read;
1520
1521         return ssl_start_async_job(s, &args, ssl_io_intern);
1522     } else {
1523         return s->method->ssl_read(s, buf, num);
1524     }
1525 }
1526
1527 int SSL_peek(SSL *s, void *buf, int num)
1528 {
1529     if (s->handshake_func == NULL) {
1530         SSLerr(SSL_F_SSL_PEEK, SSL_R_UNINITIALIZED);
1531         return -1;
1532     }
1533
1534     if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
1535         return (0);
1536     }
1537     if ((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
1538         struct ssl_async_args args;
1539
1540         args.s = s;
1541         args.buf = buf;
1542         args.num = num;
1543         args.type = READFUNC;
1544         args.f.func_read = s->method->ssl_peek;
1545
1546         return ssl_start_async_job(s, &args, ssl_io_intern);
1547     } else {
1548         return s->method->ssl_peek(s, buf, num);
1549     }
1550 }
1551
1552 int SSL_write(SSL *s, const void *buf, int num)
1553 {
1554     if (s->handshake_func == NULL) {
1555         SSLerr(SSL_F_SSL_WRITE, SSL_R_UNINITIALIZED);
1556         return -1;
1557     }
1558
1559     if (s->shutdown & SSL_SENT_SHUTDOWN) {
1560         s->rwstate = SSL_NOTHING;
1561         SSLerr(SSL_F_SSL_WRITE, SSL_R_PROTOCOL_IS_SHUTDOWN);
1562         return (-1);
1563     }
1564
1565     if ((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
1566         struct ssl_async_args args;
1567
1568         args.s = s;
1569         args.buf = (void *)buf;
1570         args.num = num;
1571         args.type = WRITEFUNC;
1572         args.f.func_write = s->method->ssl_write;
1573
1574         return ssl_start_async_job(s, &args, ssl_io_intern);
1575     } else {
1576         return s->method->ssl_write(s, buf, num);
1577     }
1578 }
1579
1580 int SSL_shutdown(SSL *s)
1581 {
1582     /*
1583      * Note that this function behaves differently from what one might
1584      * expect.  Return values are 0 for no success (yet), 1 for success; but
1585      * calling it once is usually not enough, even if blocking I/O is used
1586      * (see ssl3_shutdown).
1587      */
1588
1589     if (s->handshake_func == NULL) {
1590         SSLerr(SSL_F_SSL_SHUTDOWN, SSL_R_UNINITIALIZED);
1591         return -1;
1592     }
1593
1594     if (!SSL_in_init(s)) {
1595         if ((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
1596             struct ssl_async_args args;
1597
1598             args.s = s;
1599             args.type = OTHERFUNC;
1600             args.f.func_other = s->method->ssl_shutdown;
1601
1602             return ssl_start_async_job(s, &args, ssl_io_intern);
1603         } else {
1604             return s->method->ssl_shutdown(s);
1605         }
1606     } else {
1607         SSLerr(SSL_F_SSL_SHUTDOWN, SSL_R_SHUTDOWN_WHILE_IN_INIT);
1608         return -1;
1609     }
1610 }
1611
1612 int SSL_renegotiate(SSL *s)
1613 {
1614     if (s->renegotiate == 0)
1615         s->renegotiate = 1;
1616
1617     s->new_session = 1;
1618
1619     return (s->method->ssl_renegotiate(s));
1620 }
1621
1622 int SSL_renegotiate_abbreviated(SSL *s)
1623 {
1624     if (s->renegotiate == 0)
1625         s->renegotiate = 1;
1626
1627     s->new_session = 0;
1628
1629     return (s->method->ssl_renegotiate(s));
1630 }
1631
1632 int SSL_renegotiate_pending(SSL *s)
1633 {
1634     /*
1635      * becomes true when negotiation is requested; false again once a
1636      * handshake has finished
1637      */
1638     return (s->renegotiate != 0);
1639 }
1640
1641 long SSL_ctrl(SSL *s, int cmd, long larg, void *parg)
1642 {
1643     long l;
1644
1645     switch (cmd) {
1646     case SSL_CTRL_GET_READ_AHEAD:
1647         return (RECORD_LAYER_get_read_ahead(&s->rlayer));
1648     case SSL_CTRL_SET_READ_AHEAD:
1649         l = RECORD_LAYER_get_read_ahead(&s->rlayer);
1650         RECORD_LAYER_set_read_ahead(&s->rlayer, larg);
1651         return (l);
1652
1653     case SSL_CTRL_SET_MSG_CALLBACK_ARG:
1654         s->msg_callback_arg = parg;
1655         return 1;
1656
1657     case SSL_CTRL_MODE:
1658         return (s->mode |= larg);
1659     case SSL_CTRL_CLEAR_MODE:
1660         return (s->mode &= ~larg);
1661     case SSL_CTRL_GET_MAX_CERT_LIST:
1662         return (s->max_cert_list);
1663     case SSL_CTRL_SET_MAX_CERT_LIST:
1664         l = s->max_cert_list;
1665         s->max_cert_list = larg;
1666         return (l);
1667     case SSL_CTRL_SET_MAX_SEND_FRAGMENT:
1668         if (larg < 512 || larg > SSL3_RT_MAX_PLAIN_LENGTH)
1669             return 0;
1670         s->max_send_fragment = larg;
1671         if (s->max_send_fragment < s->split_send_fragment)
1672             s->split_send_fragment = s->max_send_fragment;
1673         return 1;
1674     case SSL_CTRL_SET_SPLIT_SEND_FRAGMENT:
1675         if ((unsigned int)larg > s->max_send_fragment || larg == 0)
1676             return 0;
1677         s->split_send_fragment = larg;
1678         return 1;
1679     case SSL_CTRL_SET_MAX_PIPELINES:
1680         if (larg < 1 || larg > SSL_MAX_PIPELINES)
1681             return 0;
1682         s->max_pipelines = larg;
1683         if (larg > 1)
1684             RECORD_LAYER_set_read_ahead(&s->rlayer, 1);
1685         return 1;
1686     case SSL_CTRL_GET_RI_SUPPORT:
1687         if (s->s3)
1688             return s->s3->send_connection_binding;
1689         else
1690             return 0;
1691     case SSL_CTRL_CERT_FLAGS:
1692         return (s->cert->cert_flags |= larg);
1693     case SSL_CTRL_CLEAR_CERT_FLAGS:
1694         return (s->cert->cert_flags &= ~larg);
1695
1696     case SSL_CTRL_GET_RAW_CIPHERLIST:
1697         if (parg) {
1698             if (s->s3->tmp.ciphers_raw == NULL)
1699                 return 0;
1700             *(unsigned char **)parg = s->s3->tmp.ciphers_raw;
1701             return (int)s->s3->tmp.ciphers_rawlen;
1702         } else {
1703             return TLS_CIPHER_LEN;
1704         }
1705     case SSL_CTRL_GET_EXTMS_SUPPORT:
1706         if (!s->session || SSL_in_init(s) || ossl_statem_get_in_handshake(s))
1707                 return -1;
1708         if (s->session->flags & SSL_SESS_FLAG_EXTMS)
1709             return 1;
1710         else
1711             return 0;
1712     case SSL_CTRL_SET_MIN_PROTO_VERSION:
1713         return ssl_set_version_bound(s->ctx->method->version, (int)larg,
1714                                      &s->min_proto_version);
1715     case SSL_CTRL_SET_MAX_PROTO_VERSION:
1716         return ssl_set_version_bound(s->ctx->method->version, (int)larg,
1717                                      &s->max_proto_version);
1718     default:
1719         return (s->method->ssl_ctrl(s, cmd, larg, parg));
1720     }
1721 }
1722
1723 long SSL_callback_ctrl(SSL *s, int cmd, void (*fp) (void))
1724 {
1725     switch (cmd) {
1726     case SSL_CTRL_SET_MSG_CALLBACK:
1727         s->msg_callback = (void (*)
1728                            (int write_p, int version, int content_type,
1729                             const void *buf, size_t len, SSL *ssl,
1730                             void *arg))(fp);
1731         return 1;
1732
1733     default:
1734         return (s->method->ssl_callback_ctrl(s, cmd, fp));
1735     }
1736 }
1737
1738 LHASH_OF(SSL_SESSION) *SSL_CTX_sessions(SSL_CTX *ctx)
1739 {
1740     return ctx->sessions;
1741 }
1742
1743 long SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg)
1744 {
1745     long l;
1746     /* For some cases with ctx == NULL perform syntax checks */
1747     if (ctx == NULL) {
1748         switch (cmd) {
1749 #ifndef OPENSSL_NO_EC
1750         case SSL_CTRL_SET_CURVES_LIST:
1751             return tls1_set_curves_list(NULL, NULL, parg);
1752 #endif
1753         case SSL_CTRL_SET_SIGALGS_LIST:
1754         case SSL_CTRL_SET_CLIENT_SIGALGS_LIST:
1755             return tls1_set_sigalgs_list(NULL, parg, 0);
1756         default:
1757             return 0;
1758         }
1759     }
1760
1761     switch (cmd) {
1762     case SSL_CTRL_GET_READ_AHEAD:
1763         return (ctx->read_ahead);
1764     case SSL_CTRL_SET_READ_AHEAD:
1765         l = ctx->read_ahead;
1766         ctx->read_ahead = larg;
1767         return (l);
1768
1769     case SSL_CTRL_SET_MSG_CALLBACK_ARG:
1770         ctx->msg_callback_arg = parg;
1771         return 1;
1772
1773     case SSL_CTRL_GET_MAX_CERT_LIST:
1774         return (ctx->max_cert_list);
1775     case SSL_CTRL_SET_MAX_CERT_LIST:
1776         l = ctx->max_cert_list;
1777         ctx->max_cert_list = larg;
1778         return (l);
1779
1780     case SSL_CTRL_SET_SESS_CACHE_SIZE:
1781         l = ctx->session_cache_size;
1782         ctx->session_cache_size = larg;
1783         return (l);
1784     case SSL_CTRL_GET_SESS_CACHE_SIZE:
1785         return (ctx->session_cache_size);
1786     case SSL_CTRL_SET_SESS_CACHE_MODE:
1787         l = ctx->session_cache_mode;
1788         ctx->session_cache_mode = larg;
1789         return (l);
1790     case SSL_CTRL_GET_SESS_CACHE_MODE:
1791         return (ctx->session_cache_mode);
1792
1793     case SSL_CTRL_SESS_NUMBER:
1794         return (lh_SSL_SESSION_num_items(ctx->sessions));
1795     case SSL_CTRL_SESS_CONNECT:
1796         return (ctx->stats.sess_connect);
1797     case SSL_CTRL_SESS_CONNECT_GOOD:
1798         return (ctx->stats.sess_connect_good);
1799     case SSL_CTRL_SESS_CONNECT_RENEGOTIATE:
1800         return (ctx->stats.sess_connect_renegotiate);
1801     case SSL_CTRL_SESS_ACCEPT:
1802         return (ctx->stats.sess_accept);
1803     case SSL_CTRL_SESS_ACCEPT_GOOD:
1804         return (ctx->stats.sess_accept_good);
1805     case SSL_CTRL_SESS_ACCEPT_RENEGOTIATE:
1806         return (ctx->stats.sess_accept_renegotiate);
1807     case SSL_CTRL_SESS_HIT:
1808         return (ctx->stats.sess_hit);
1809     case SSL_CTRL_SESS_CB_HIT:
1810         return (ctx->stats.sess_cb_hit);
1811     case SSL_CTRL_SESS_MISSES:
1812         return (ctx->stats.sess_miss);
1813     case SSL_CTRL_SESS_TIMEOUTS:
1814         return (ctx->stats.sess_timeout);
1815     case SSL_CTRL_SESS_CACHE_FULL:
1816         return (ctx->stats.sess_cache_full);
1817     case SSL_CTRL_MODE:
1818         return (ctx->mode |= larg);
1819     case SSL_CTRL_CLEAR_MODE:
1820         return (ctx->mode &= ~larg);
1821     case SSL_CTRL_SET_MAX_SEND_FRAGMENT:
1822         if (larg < 512 || larg > SSL3_RT_MAX_PLAIN_LENGTH)
1823             return 0;
1824         ctx->max_send_fragment = larg;
1825         if (ctx->max_send_fragment < ctx->split_send_fragment)
1826             ctx->split_send_fragment = ctx->max_send_fragment;
1827         return 1;
1828     case SSL_CTRL_SET_SPLIT_SEND_FRAGMENT:
1829         if ((unsigned int)larg > ctx->max_send_fragment || larg == 0)
1830             return 0;
1831         ctx->split_send_fragment = larg;
1832         return 1;
1833     case SSL_CTRL_SET_MAX_PIPELINES:
1834         if (larg < 1 || larg > SSL_MAX_PIPELINES)
1835             return 0;
1836         ctx->max_pipelines = larg;
1837         return 1;
1838     case SSL_CTRL_CERT_FLAGS:
1839         return (ctx->cert->cert_flags |= larg);
1840     case SSL_CTRL_CLEAR_CERT_FLAGS:
1841         return (ctx->cert->cert_flags &= ~larg);
1842     case SSL_CTRL_SET_MIN_PROTO_VERSION:
1843         return ssl_set_version_bound(ctx->method->version, (int)larg,
1844                                      &ctx->min_proto_version);
1845     case SSL_CTRL_SET_MAX_PROTO_VERSION:
1846         return ssl_set_version_bound(ctx->method->version, (int)larg,
1847                                      &ctx->max_proto_version);
1848     default:
1849         return (ctx->method->ssl_ctx_ctrl(ctx, cmd, larg, parg));
1850     }
1851 }
1852
1853 long SSL_CTX_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp) (void))
1854 {
1855     switch (cmd) {
1856     case SSL_CTRL_SET_MSG_CALLBACK:
1857         ctx->msg_callback = (void (*)
1858                              (int write_p, int version, int content_type,
1859                               const void *buf, size_t len, SSL *ssl,
1860                               void *arg))(fp);
1861         return 1;
1862
1863     default:
1864         return (ctx->method->ssl_ctx_callback_ctrl(ctx, cmd, fp));
1865     }
1866 }
1867
1868 int ssl_cipher_id_cmp(const SSL_CIPHER *a, const SSL_CIPHER *b)
1869 {
1870     if (a->id > b->id)
1871         return 1;
1872     if (a->id < b->id)
1873         return -1;
1874     return 0;
1875 }
1876
1877 int ssl_cipher_ptr_id_cmp(const SSL_CIPHER *const *ap,
1878                           const SSL_CIPHER *const *bp)
1879 {
1880     if ((*ap)->id > (*bp)->id)
1881         return 1;
1882     if ((*ap)->id < (*bp)->id)
1883         return -1;
1884     return 0;
1885 }
1886
1887 /** return a STACK of the ciphers available for the SSL and in order of
1888  * preference */
1889 STACK_OF(SSL_CIPHER) *SSL_get_ciphers(const SSL *s)
1890 {
1891     if (s != NULL) {
1892         if (s->cipher_list != NULL) {
1893             return (s->cipher_list);
1894         } else if ((s->ctx != NULL) && (s->ctx->cipher_list != NULL)) {
1895             return (s->ctx->cipher_list);
1896         }
1897     }
1898     return (NULL);
1899 }
1900
1901 STACK_OF(SSL_CIPHER) *SSL_get_client_ciphers(const SSL *s)
1902 {
1903     if ((s == NULL) || (s->session == NULL) || !s->server)
1904         return NULL;
1905     return s->session->ciphers;
1906 }
1907
1908 STACK_OF(SSL_CIPHER) *SSL_get1_supported_ciphers(SSL *s)
1909 {
1910     STACK_OF(SSL_CIPHER) *sk = NULL, *ciphers;
1911     int i;
1912     ciphers = SSL_get_ciphers(s);
1913     if (!ciphers)
1914         return NULL;
1915     ssl_set_client_disabled(s);
1916     for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
1917         const SSL_CIPHER *c = sk_SSL_CIPHER_value(ciphers, i);
1918         if (!ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_SUPPORTED)) {
1919             if (!sk)
1920                 sk = sk_SSL_CIPHER_new_null();
1921             if (!sk)
1922                 return NULL;
1923             if (!sk_SSL_CIPHER_push(sk, c)) {
1924                 sk_SSL_CIPHER_free(sk);
1925                 return NULL;
1926             }
1927         }
1928     }
1929     return sk;
1930 }
1931
1932 /** return a STACK of the ciphers available for the SSL and in order of
1933  * algorithm id */
1934 STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL *s)
1935 {
1936     if (s != NULL) {
1937         if (s->cipher_list_by_id != NULL) {
1938             return (s->cipher_list_by_id);
1939         } else if ((s->ctx != NULL) && (s->ctx->cipher_list_by_id != NULL)) {
1940             return (s->ctx->cipher_list_by_id);
1941         }
1942     }
1943     return (NULL);
1944 }
1945
1946 /** The old interface to get the same thing as SSL_get_ciphers() */
1947 const char *SSL_get_cipher_list(const SSL *s, int n)
1948 {
1949     const SSL_CIPHER *c;
1950     STACK_OF(SSL_CIPHER) *sk;
1951
1952     if (s == NULL)
1953         return (NULL);
1954     sk = SSL_get_ciphers(s);
1955     if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= n))
1956         return (NULL);
1957     c = sk_SSL_CIPHER_value(sk, n);
1958     if (c == NULL)
1959         return (NULL);
1960     return (c->name);
1961 }
1962
1963 /** return a STACK of the ciphers available for the SSL_CTX and in order of
1964  * preference */
1965 STACK_OF(SSL_CIPHER) *SSL_CTX_get_ciphers(const SSL_CTX *ctx)
1966 {
1967     if (ctx != NULL)
1968         return ctx->cipher_list;
1969     return NULL;
1970 }
1971
1972 /** specify the ciphers to be used by default by the SSL_CTX */
1973 int SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str)
1974 {
1975     STACK_OF(SSL_CIPHER) *sk;
1976
1977     sk = ssl_create_cipher_list(ctx->method, &ctx->cipher_list,
1978                                 &ctx->cipher_list_by_id, str, ctx->cert);
1979     /*
1980      * ssl_create_cipher_list may return an empty stack if it was unable to
1981      * find a cipher matching the given rule string (for example if the rule
1982      * string specifies a cipher which has been disabled). This is not an
1983      * error as far as ssl_create_cipher_list is concerned, and hence
1984      * ctx->cipher_list and ctx->cipher_list_by_id has been updated.
1985      */
1986     if (sk == NULL)
1987         return 0;
1988     else if (sk_SSL_CIPHER_num(sk) == 0) {
1989         SSLerr(SSL_F_SSL_CTX_SET_CIPHER_LIST, SSL_R_NO_CIPHER_MATCH);
1990         return 0;
1991     }
1992     return 1;
1993 }
1994
1995 /** specify the ciphers to be used by the SSL */
1996 int SSL_set_cipher_list(SSL *s, const char *str)
1997 {
1998     STACK_OF(SSL_CIPHER) *sk;
1999
2000     sk = ssl_create_cipher_list(s->ctx->method, &s->cipher_list,
2001                                 &s->cipher_list_by_id, str, s->cert);
2002     /* see comment in SSL_CTX_set_cipher_list */
2003     if (sk == NULL)
2004         return 0;
2005     else if (sk_SSL_CIPHER_num(sk) == 0) {
2006         SSLerr(SSL_F_SSL_SET_CIPHER_LIST, SSL_R_NO_CIPHER_MATCH);
2007         return 0;
2008     }
2009     return 1;
2010 }
2011
2012 char *SSL_get_shared_ciphers(const SSL *s, char *buf, int len)
2013 {
2014     char *p;
2015     STACK_OF(SSL_CIPHER) *sk;
2016     const SSL_CIPHER *c;
2017     int i;
2018
2019     if ((s->session == NULL) || (s->session->ciphers == NULL) || (len < 2))
2020         return (NULL);
2021
2022     p = buf;
2023     sk = s->session->ciphers;
2024
2025     if (sk_SSL_CIPHER_num(sk) == 0)
2026         return NULL;
2027
2028     for (i = 0; i < sk_SSL_CIPHER_num(sk); i++) {
2029         int n;
2030
2031         c = sk_SSL_CIPHER_value(sk, i);
2032         n = strlen(c->name);
2033         if (n + 1 > len) {
2034             if (p != buf)
2035                 --p;
2036             *p = '\0';
2037             return buf;
2038         }
2039         memcpy(p, c->name, n + 1);
2040         p += n;
2041         *(p++) = ':';
2042         len -= n + 1;
2043     }
2044     p[-1] = '\0';
2045     return (buf);
2046 }
2047
2048 /** return a servername extension value if provided in Client Hello, or NULL.
2049  * So far, only host_name types are defined (RFC 3546).
2050  */
2051
2052 const char *SSL_get_servername(const SSL *s, const int type)
2053 {
2054     if (type != TLSEXT_NAMETYPE_host_name)
2055         return NULL;
2056
2057     return s->session && !s->tlsext_hostname ?
2058         s->session->tlsext_hostname : s->tlsext_hostname;
2059 }
2060
2061 int SSL_get_servername_type(const SSL *s)
2062 {
2063     if (s->session
2064         && (!s->tlsext_hostname ? s->session->
2065             tlsext_hostname : s->tlsext_hostname))
2066         return TLSEXT_NAMETYPE_host_name;
2067     return -1;
2068 }
2069
2070 /*
2071  * SSL_select_next_proto implements the standard protocol selection. It is
2072  * expected that this function is called from the callback set by
2073  * SSL_CTX_set_next_proto_select_cb. The protocol data is assumed to be a
2074  * vector of 8-bit, length prefixed byte strings. The length byte itself is
2075  * not included in the length. A byte string of length 0 is invalid. No byte
2076  * string may be truncated. The current, but experimental algorithm for
2077  * selecting the protocol is: 1) If the server doesn't support NPN then this
2078  * is indicated to the callback. In this case, the client application has to
2079  * abort the connection or have a default application level protocol. 2) If
2080  * the server supports NPN, but advertises an empty list then the client
2081  * selects the first protocol in its list, but indicates via the API that this
2082  * fallback case was enacted. 3) Otherwise, the client finds the first
2083  * protocol in the server's list that it supports and selects this protocol.
2084  * This is because it's assumed that the server has better information about
2085  * which protocol a client should use. 4) If the client doesn't support any
2086  * of the server's advertised protocols, then this is treated the same as
2087  * case 2. It returns either OPENSSL_NPN_NEGOTIATED if a common protocol was
2088  * found, or OPENSSL_NPN_NO_OVERLAP if the fallback case was reached.
2089  */
2090 int SSL_select_next_proto(unsigned char **out, unsigned char *outlen,
2091                           const unsigned char *server,
2092                           unsigned int server_len,
2093                           const unsigned char *client,
2094                           unsigned int client_len)
2095 {
2096     unsigned int i, j;
2097     const unsigned char *result;
2098     int status = OPENSSL_NPN_UNSUPPORTED;
2099
2100     /*
2101      * For each protocol in server preference order, see if we support it.
2102      */
2103     for (i = 0; i < server_len;) {
2104         for (j = 0; j < client_len;) {
2105             if (server[i] == client[j] &&
2106                 memcmp(&server[i + 1], &client[j + 1], server[i]) == 0) {
2107                 /* We found a match */
2108                 result = &server[i];
2109                 status = OPENSSL_NPN_NEGOTIATED;
2110                 goto found;
2111             }
2112             j += client[j];
2113             j++;
2114         }
2115         i += server[i];
2116         i++;
2117     }
2118
2119     /* There's no overlap between our protocols and the server's list. */
2120     result = client;
2121     status = OPENSSL_NPN_NO_OVERLAP;
2122
2123  found:
2124     *out = (unsigned char *)result + 1;
2125     *outlen = result[0];
2126     return status;
2127 }
2128
2129 #ifndef OPENSSL_NO_NEXTPROTONEG
2130 /*
2131  * SSL_get0_next_proto_negotiated sets *data and *len to point to the
2132  * client's requested protocol for this connection and returns 0. If the
2133  * client didn't request any protocol, then *data is set to NULL. Note that
2134  * the client can request any protocol it chooses. The value returned from
2135  * this function need not be a member of the list of supported protocols
2136  * provided by the callback.
2137  */
2138 void SSL_get0_next_proto_negotiated(const SSL *s, const unsigned char **data,
2139                                     unsigned *len)
2140 {
2141     *data = s->next_proto_negotiated;
2142     if (!*data) {
2143         *len = 0;
2144     } else {
2145         *len = s->next_proto_negotiated_len;
2146     }
2147 }
2148
2149 /*
2150  * SSL_CTX_set_next_protos_advertised_cb sets a callback that is called when
2151  * a TLS server needs a list of supported protocols for Next Protocol
2152  * Negotiation. The returned list must be in wire format.  The list is
2153  * returned by setting |out| to point to it and |outlen| to its length. This
2154  * memory will not be modified, but one should assume that the SSL* keeps a
2155  * reference to it. The callback should return SSL_TLSEXT_ERR_OK if it
2156  * wishes to advertise. Otherwise, no such extension will be included in the
2157  * ServerHello.
2158  */
2159 void SSL_CTX_set_next_protos_advertised_cb(SSL_CTX *ctx,
2160                                            int (*cb) (SSL *ssl,
2161                                                       const unsigned char
2162                                                       **out,
2163                                                       unsigned int *outlen,
2164                                                       void *arg), void *arg)
2165 {
2166     ctx->next_protos_advertised_cb = cb;
2167     ctx->next_protos_advertised_cb_arg = arg;
2168 }
2169
2170 /*
2171  * SSL_CTX_set_next_proto_select_cb sets a callback that is called when a
2172  * client needs to select a protocol from the server's provided list. |out|
2173  * must be set to point to the selected protocol (which may be within |in|).
2174  * The length of the protocol name must be written into |outlen|. The
2175  * server's advertised protocols are provided in |in| and |inlen|. The
2176  * callback can assume that |in| is syntactically valid. The client must
2177  * select a protocol. It is fatal to the connection if this callback returns
2178  * a value other than SSL_TLSEXT_ERR_OK.
2179  */
2180 void SSL_CTX_set_next_proto_select_cb(SSL_CTX *ctx,
2181                                       int (*cb) (SSL *s, unsigned char **out,
2182                                                  unsigned char *outlen,
2183                                                  const unsigned char *in,
2184                                                  unsigned int inlen,
2185                                                  void *arg), void *arg)
2186 {
2187     ctx->next_proto_select_cb = cb;
2188     ctx->next_proto_select_cb_arg = arg;
2189 }
2190 #endif
2191
2192 /*
2193  * SSL_CTX_set_alpn_protos sets the ALPN protocol list on |ctx| to |protos|.
2194  * |protos| must be in wire-format (i.e. a series of non-empty, 8-bit
2195  * length-prefixed strings). Returns 0 on success.
2196  */
2197 int SSL_CTX_set_alpn_protos(SSL_CTX *ctx, const unsigned char *protos,
2198                             unsigned int protos_len)
2199 {
2200     OPENSSL_free(ctx->alpn_client_proto_list);
2201     ctx->alpn_client_proto_list = OPENSSL_memdup(protos, protos_len);
2202     if (ctx->alpn_client_proto_list == NULL) {
2203         SSLerr(SSL_F_SSL_CTX_SET_ALPN_PROTOS, ERR_R_MALLOC_FAILURE);
2204         return 1;
2205     }
2206     ctx->alpn_client_proto_list_len = protos_len;
2207
2208     return 0;
2209 }
2210
2211 /*
2212  * SSL_set_alpn_protos sets the ALPN protocol list on |ssl| to |protos|.
2213  * |protos| must be in wire-format (i.e. a series of non-empty, 8-bit
2214  * length-prefixed strings). Returns 0 on success.
2215  */
2216 int SSL_set_alpn_protos(SSL *ssl, const unsigned char *protos,
2217                         unsigned int protos_len)
2218 {
2219     OPENSSL_free(ssl->alpn_client_proto_list);
2220     ssl->alpn_client_proto_list = OPENSSL_memdup(protos, protos_len);
2221     if (ssl->alpn_client_proto_list == NULL) {
2222         SSLerr(SSL_F_SSL_SET_ALPN_PROTOS, ERR_R_MALLOC_FAILURE);
2223         return 1;
2224     }
2225     ssl->alpn_client_proto_list_len = protos_len;
2226
2227     return 0;
2228 }
2229
2230 /*
2231  * SSL_CTX_set_alpn_select_cb sets a callback function on |ctx| that is
2232  * called during ClientHello processing in order to select an ALPN protocol
2233  * from the client's list of offered protocols.
2234  */
2235 void SSL_CTX_set_alpn_select_cb(SSL_CTX *ctx,
2236                                 int (*cb) (SSL *ssl,
2237                                            const unsigned char **out,
2238                                            unsigned char *outlen,
2239                                            const unsigned char *in,
2240                                            unsigned int inlen,
2241                                            void *arg), void *arg)
2242 {
2243     ctx->alpn_select_cb = cb;
2244     ctx->alpn_select_cb_arg = arg;
2245 }
2246
2247 /*
2248  * SSL_get0_alpn_selected gets the selected ALPN protocol (if any) from
2249  * |ssl|. On return it sets |*data| to point to |*len| bytes of protocol name
2250  * (not including the leading length-prefix byte). If the server didn't
2251  * respond with a negotiated protocol then |*len| will be zero.
2252  */
2253 void SSL_get0_alpn_selected(const SSL *ssl, const unsigned char **data,
2254                             unsigned int *len)
2255 {
2256     *data = NULL;
2257     if (ssl->s3)
2258         *data = ssl->s3->alpn_selected;
2259     if (*data == NULL)
2260         *len = 0;
2261     else
2262         *len = ssl->s3->alpn_selected_len;
2263 }
2264
2265
2266 int SSL_export_keying_material(SSL *s, unsigned char *out, size_t olen,
2267                                const char *label, size_t llen,
2268                                const unsigned char *p, size_t plen,
2269                                int use_context)
2270 {
2271     if (s->version < TLS1_VERSION)
2272         return -1;
2273
2274     return s->method->ssl3_enc->export_keying_material(s, out, olen, label,
2275                                                        llen, p, plen,
2276                                                        use_context);
2277 }
2278
2279 static unsigned long ssl_session_hash(const SSL_SESSION *a)
2280 {
2281     unsigned long l;
2282
2283     l = (unsigned long)
2284         ((unsigned int)a->session_id[0]) |
2285         ((unsigned int)a->session_id[1] << 8L) |
2286         ((unsigned long)a->session_id[2] << 16L) |
2287         ((unsigned long)a->session_id[3] << 24L);
2288     return (l);
2289 }
2290
2291 /*
2292  * NB: If this function (or indeed the hash function which uses a sort of
2293  * coarser function than this one) is changed, ensure
2294  * SSL_CTX_has_matching_session_id() is checked accordingly. It relies on
2295  * being able to construct an SSL_SESSION that will collide with any existing
2296  * session with a matching session ID.
2297  */
2298 static int ssl_session_cmp(const SSL_SESSION *a, const SSL_SESSION *b)
2299 {
2300     if (a->ssl_version != b->ssl_version)
2301         return (1);
2302     if (a->session_id_length != b->session_id_length)
2303         return (1);
2304     return (memcmp(a->session_id, b->session_id, a->session_id_length));
2305 }
2306
2307 /*
2308  * These wrapper functions should remain rather than redeclaring
2309  * SSL_SESSION_hash and SSL_SESSION_cmp for void* types and casting each
2310  * variable. The reason is that the functions aren't static, they're exposed
2311  * via ssl.h.
2312  */
2313
2314 SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth)
2315 {
2316     SSL_CTX *ret = NULL;
2317
2318     if (meth == NULL) {
2319         SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_NULL_SSL_METHOD_PASSED);
2320         return (NULL);
2321     }
2322
2323     if (!OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS, NULL))
2324         return NULL;
2325
2326     if (FIPS_mode() && (meth->version < TLS1_VERSION)) {
2327         SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_AT_LEAST_TLS_1_0_NEEDED_IN_FIPS_MODE);
2328         return NULL;
2329     }
2330
2331     if (SSL_get_ex_data_X509_STORE_CTX_idx() < 0) {
2332         SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_X509_VERIFICATION_SETUP_PROBLEMS);
2333         goto err;
2334     }
2335     ret = OPENSSL_zalloc(sizeof(*ret));
2336     if (ret == NULL)
2337         goto err;
2338
2339     ret->method = meth;
2340     ret->min_proto_version = 0;
2341     ret->max_proto_version = 0;
2342     ret->session_cache_mode = SSL_SESS_CACHE_SERVER;
2343     ret->session_cache_size = SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;
2344     /* We take the system default. */
2345     ret->session_timeout = meth->get_timeout();
2346     ret->references = 1;
2347     ret->lock = CRYPTO_THREAD_lock_new();
2348     if (ret->lock == NULL) {
2349         SSLerr(SSL_F_SSL_CTX_NEW, ERR_R_MALLOC_FAILURE);
2350         OPENSSL_free(ret);
2351         return NULL;
2352     }
2353     ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;
2354     ret->verify_mode = SSL_VERIFY_NONE;
2355     if ((ret->cert = ssl_cert_new()) == NULL)
2356         goto err;
2357
2358     ret->sessions = lh_SSL_SESSION_new(ssl_session_hash, ssl_session_cmp);
2359     if (ret->sessions == NULL)
2360         goto err;
2361     ret->cert_store = X509_STORE_new();
2362     if (ret->cert_store == NULL)
2363         goto err;
2364 #ifndef OPENSSL_NO_CT
2365     ret->ctlog_store = CTLOG_STORE_new();
2366     if (ret->ctlog_store == NULL)
2367         goto err;
2368 #endif
2369     if (!ssl_create_cipher_list(ret->method,
2370                            &ret->cipher_list, &ret->cipher_list_by_id,
2371                            SSL_DEFAULT_CIPHER_LIST, ret->cert)
2372        || sk_SSL_CIPHER_num(ret->cipher_list) <= 0) {
2373         SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_LIBRARY_HAS_NO_CIPHERS);
2374         goto err2;
2375     }
2376
2377     ret->param = X509_VERIFY_PARAM_new();
2378     if (ret->param == NULL)
2379         goto err;
2380
2381     if ((ret->md5 = EVP_get_digestbyname("ssl3-md5")) == NULL) {
2382         SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES);
2383         goto err2;
2384     }
2385     if ((ret->sha1 = EVP_get_digestbyname("ssl3-sha1")) == NULL) {
2386         SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES);
2387         goto err2;
2388     }
2389
2390     if ((ret->client_CA = sk_X509_NAME_new_null()) == NULL)
2391         goto err;
2392
2393     if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ret, &ret->ex_data))
2394         goto err;
2395
2396     /* No compression for DTLS */
2397     if (!(meth->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS))
2398         ret->comp_methods = SSL_COMP_get_compression_methods();
2399
2400     ret->max_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH;
2401     ret->split_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH;
2402
2403     /* Setup RFC5077 ticket keys */
2404     if ((RAND_bytes(ret->tlsext_tick_key_name, sizeof(ret->tlsext_tick_key_name)) <= 0)
2405         || (RAND_bytes(ret->tlsext_tick_hmac_key, sizeof(ret->tlsext_tick_hmac_key)) <= 0)
2406         || (RAND_bytes(ret->tlsext_tick_aes_key, sizeof(ret->tlsext_tick_aes_key)) <= 0))
2407         ret->options |= SSL_OP_NO_TICKET;
2408
2409 #ifndef OPENSSL_NO_SRP
2410     if (!SSL_CTX_SRP_CTX_init(ret))
2411         goto err;
2412 #endif
2413 #ifndef OPENSSL_NO_ENGINE
2414 # ifdef OPENSSL_SSL_CLIENT_ENGINE_AUTO
2415 #  define eng_strx(x)     #x
2416 #  define eng_str(x)      eng_strx(x)
2417     /* Use specific client engine automatically... ignore errors */
2418     {
2419         ENGINE *eng;
2420         eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));
2421         if (!eng) {
2422             ERR_clear_error();
2423             ENGINE_load_builtin_engines();
2424             eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));
2425         }
2426         if (!eng || !SSL_CTX_set_client_cert_engine(ret, eng))
2427             ERR_clear_error();
2428     }
2429 # endif
2430 #endif
2431     /*
2432      * Default is to connect to non-RI servers. When RI is more widely
2433      * deployed might change this.
2434      */
2435     ret->options |= SSL_OP_LEGACY_SERVER_CONNECT;
2436     /*
2437      * Disable compression by default to prevent CRIME. Applications can
2438      * re-enable compression by configuring
2439      * SSL_CTX_clear_options(ctx, SSL_OP_NO_COMPRESSION);
2440      * or by using the SSL_CONF library.
2441      */
2442     ret->options |= SSL_OP_NO_COMPRESSION;
2443
2444     ret->tlsext_status_type = -1;
2445
2446     return ret;
2447  err:
2448     SSLerr(SSL_F_SSL_CTX_NEW, ERR_R_MALLOC_FAILURE);
2449  err2:
2450     SSL_CTX_free(ret);
2451     return NULL;
2452 }
2453
2454 int SSL_CTX_up_ref(SSL_CTX *ctx)
2455 {
2456     int i;
2457
2458     if (CRYPTO_atomic_add(&ctx->references, 1, &i, ctx->lock) <= 0)
2459         return 0;
2460
2461     REF_PRINT_COUNT("SSL_CTX", ctx);
2462     REF_ASSERT_ISNT(i < 2);
2463     return ((i > 1) ? 1 : 0);
2464 }
2465
2466 void SSL_CTX_free(SSL_CTX *a)
2467 {
2468     int i;
2469
2470     if (a == NULL)
2471         return;
2472
2473     CRYPTO_atomic_add(&a->references, -1, &i, a->lock);
2474     REF_PRINT_COUNT("SSL_CTX", a);
2475     if (i > 0)
2476         return;
2477     REF_ASSERT_ISNT(i < 0);
2478
2479     X509_VERIFY_PARAM_free(a->param);
2480     dane_ctx_final(&a->dane);
2481
2482     /*
2483      * Free internal session cache. However: the remove_cb() may reference
2484      * the ex_data of SSL_CTX, thus the ex_data store can only be removed
2485      * after the sessions were flushed.
2486      * As the ex_data handling routines might also touch the session cache,
2487      * the most secure solution seems to be: empty (flush) the cache, then
2488      * free ex_data, then finally free the cache.
2489      * (See ticket [openssl.org #212].)
2490      */
2491     if (a->sessions != NULL)
2492         SSL_CTX_flush_sessions(a, 0);
2493
2494     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL_CTX, a, &a->ex_data);
2495     lh_SSL_SESSION_free(a->sessions);
2496     X509_STORE_free(a->cert_store);
2497 #ifndef OPENSSL_NO_CT
2498     CTLOG_STORE_free(a->ctlog_store);
2499 #endif
2500     sk_SSL_CIPHER_free(a->cipher_list);
2501     sk_SSL_CIPHER_free(a->cipher_list_by_id);
2502     ssl_cert_free(a->cert);
2503     sk_X509_NAME_pop_free(a->client_CA, X509_NAME_free);
2504     sk_X509_pop_free(a->extra_certs, X509_free);
2505     a->comp_methods = NULL;
2506 #ifndef OPENSSL_NO_SRTP
2507     sk_SRTP_PROTECTION_PROFILE_free(a->srtp_profiles);
2508 #endif
2509 #ifndef OPENSSL_NO_SRP
2510     SSL_CTX_SRP_CTX_free(a);
2511 #endif
2512 #ifndef OPENSSL_NO_ENGINE
2513     ENGINE_finish(a->client_cert_engine);
2514 #endif
2515
2516 #ifndef OPENSSL_NO_EC
2517     OPENSSL_free(a->tlsext_ecpointformatlist);
2518     OPENSSL_free(a->tlsext_ellipticcurvelist);
2519 #endif
2520     OPENSSL_free(a->alpn_client_proto_list);
2521
2522     CRYPTO_THREAD_lock_free(a->lock);
2523
2524     OPENSSL_free(a);
2525 }
2526
2527 void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb)
2528 {
2529     ctx->default_passwd_callback = cb;
2530 }
2531
2532 void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx, void *u)
2533 {
2534     ctx->default_passwd_callback_userdata = u;
2535 }
2536
2537 pem_password_cb *SSL_CTX_get_default_passwd_cb(SSL_CTX *ctx)
2538 {
2539     return ctx->default_passwd_callback;
2540 }
2541
2542 void *SSL_CTX_get_default_passwd_cb_userdata(SSL_CTX *ctx)
2543 {
2544     return ctx->default_passwd_callback_userdata;
2545 }
2546
2547 void SSL_set_default_passwd_cb(SSL *s, pem_password_cb *cb)
2548 {
2549     s->default_passwd_callback = cb;
2550 }
2551
2552 void SSL_set_default_passwd_cb_userdata(SSL *s, void *u)
2553 {
2554     s->default_passwd_callback_userdata = u;
2555 }
2556
2557 pem_password_cb *SSL_get_default_passwd_cb(SSL *s)
2558 {
2559     return s->default_passwd_callback;
2560 }
2561
2562 void *SSL_get_default_passwd_cb_userdata(SSL *s)
2563 {
2564     return s->default_passwd_callback_userdata;
2565 }
2566
2567 void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx,
2568                                       int (*cb) (X509_STORE_CTX *, void *),
2569                                       void *arg)
2570 {
2571     ctx->app_verify_callback = cb;
2572     ctx->app_verify_arg = arg;
2573 }
2574
2575 void SSL_CTX_set_verify(SSL_CTX *ctx, int mode,
2576                         int (*cb) (int, X509_STORE_CTX *))
2577 {
2578     ctx->verify_mode = mode;
2579     ctx->default_verify_callback = cb;
2580 }
2581
2582 void SSL_CTX_set_verify_depth(SSL_CTX *ctx, int depth)
2583 {
2584     X509_VERIFY_PARAM_set_depth(ctx->param, depth);
2585 }
2586
2587 void SSL_CTX_set_cert_cb(SSL_CTX *c, int (*cb) (SSL *ssl, void *arg),
2588                          void *arg)
2589 {
2590     ssl_cert_set_cert_cb(c->cert, cb, arg);
2591 }
2592
2593 void SSL_set_cert_cb(SSL *s, int (*cb) (SSL *ssl, void *arg), void *arg)
2594 {
2595     ssl_cert_set_cert_cb(s->cert, cb, arg);
2596 }
2597
2598 void ssl_set_masks(SSL *s)
2599 {
2600 #if !defined(OPENSSL_NO_EC) || !defined(OPENSSL_NO_GOST)
2601     CERT_PKEY *cpk;
2602 #endif
2603     CERT *c = s->cert;
2604     uint32_t *pvalid = s->s3->tmp.valid_flags;
2605     int rsa_enc, rsa_sign, dh_tmp, dsa_sign;
2606     unsigned long mask_k, mask_a;
2607 #ifndef OPENSSL_NO_EC
2608     int have_ecc_cert, ecdsa_ok;
2609     X509 *x = NULL;
2610 #endif
2611     if (c == NULL)
2612         return;
2613
2614 #ifndef OPENSSL_NO_DH
2615     dh_tmp = (c->dh_tmp != NULL || c->dh_tmp_cb != NULL || c->dh_tmp_auto);
2616 #else
2617     dh_tmp = 0;
2618 #endif
2619
2620     rsa_enc = pvalid[SSL_PKEY_RSA_ENC] & CERT_PKEY_VALID;
2621     rsa_sign = pvalid[SSL_PKEY_RSA_SIGN] & CERT_PKEY_SIGN;
2622     dsa_sign = pvalid[SSL_PKEY_DSA_SIGN] & CERT_PKEY_SIGN;
2623 #ifndef OPENSSL_NO_EC
2624     have_ecc_cert = pvalid[SSL_PKEY_ECC] & CERT_PKEY_VALID;
2625 #endif
2626     mask_k = 0;
2627     mask_a = 0;
2628
2629 #ifdef CIPHER_DEBUG
2630     fprintf(stderr, "dht=%d re=%d rs=%d ds=%d\n",
2631             dh_tmp, rsa_enc, rsa_sign, dsa_sign);
2632 #endif
2633
2634 #ifndef OPENSSL_NO_GOST
2635     cpk = &(c->pkeys[SSL_PKEY_GOST12_512]);
2636     if (cpk->x509 != NULL && cpk->privatekey != NULL) {
2637         mask_k |= SSL_kGOST;
2638         mask_a |= SSL_aGOST12;
2639     }
2640     cpk = &(c->pkeys[SSL_PKEY_GOST12_256]);
2641     if (cpk->x509 != NULL && cpk->privatekey != NULL) {
2642         mask_k |= SSL_kGOST;
2643         mask_a |= SSL_aGOST12;
2644     }
2645     cpk = &(c->pkeys[SSL_PKEY_GOST01]);
2646     if (cpk->x509 != NULL && cpk->privatekey != NULL) {
2647         mask_k |= SSL_kGOST;
2648         mask_a |= SSL_aGOST01;
2649     }
2650 #endif
2651
2652     if (rsa_enc)
2653         mask_k |= SSL_kRSA;
2654
2655     if (dh_tmp)
2656         mask_k |= SSL_kDHE;
2657
2658     if (rsa_enc || rsa_sign) {
2659         mask_a |= SSL_aRSA;
2660     }
2661
2662     if (dsa_sign) {
2663         mask_a |= SSL_aDSS;
2664     }
2665
2666     mask_a |= SSL_aNULL;
2667
2668     /*
2669      * An ECC certificate may be usable for ECDH and/or ECDSA cipher suites
2670      * depending on the key usage extension.
2671      */
2672 #ifndef OPENSSL_NO_EC
2673     if (have_ecc_cert) {
2674         uint32_t ex_kusage;
2675         cpk = &c->pkeys[SSL_PKEY_ECC];
2676         x = cpk->x509;
2677         ex_kusage = X509_get_key_usage(x);
2678         ecdsa_ok = ex_kusage & X509v3_KU_DIGITAL_SIGNATURE;
2679         if (!(pvalid[SSL_PKEY_ECC] & CERT_PKEY_SIGN))
2680             ecdsa_ok = 0;
2681         if (ecdsa_ok)
2682             mask_a |= SSL_aECDSA;
2683     }
2684 #endif
2685
2686 #ifndef OPENSSL_NO_EC
2687     mask_k |= SSL_kECDHE;
2688 #endif
2689
2690 #ifndef OPENSSL_NO_PSK
2691     mask_k |= SSL_kPSK;
2692     mask_a |= SSL_aPSK;
2693     if (mask_k & SSL_kRSA)
2694         mask_k |= SSL_kRSAPSK;
2695     if (mask_k & SSL_kDHE)
2696         mask_k |= SSL_kDHEPSK;
2697     if (mask_k & SSL_kECDHE)
2698         mask_k |= SSL_kECDHEPSK;
2699 #endif
2700
2701     s->s3->tmp.mask_k = mask_k;
2702     s->s3->tmp.mask_a = mask_a;
2703 }
2704
2705 #ifndef OPENSSL_NO_EC
2706
2707 int ssl_check_srvr_ecc_cert_and_alg(X509 *x, SSL *s)
2708 {
2709     if (s->s3->tmp.new_cipher->algorithm_auth & SSL_aECDSA) {
2710         /* key usage, if present, must allow signing */
2711         if (!(X509_get_key_usage(x) & X509v3_KU_DIGITAL_SIGNATURE)) {
2712             SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG,
2713                    SSL_R_ECC_CERT_NOT_FOR_SIGNING);
2714             return 0;
2715         }
2716     }
2717     return 1;                   /* all checks are ok */
2718 }
2719
2720 #endif
2721
2722 static int ssl_get_server_cert_index(const SSL *s)
2723 {
2724     int idx;
2725     idx = ssl_cipher_get_cert_index(s->s3->tmp.new_cipher);
2726     if (idx == SSL_PKEY_RSA_ENC && !s->cert->pkeys[SSL_PKEY_RSA_ENC].x509)
2727         idx = SSL_PKEY_RSA_SIGN;
2728     if (idx == SSL_PKEY_GOST_EC) {
2729         if (s->cert->pkeys[SSL_PKEY_GOST12_512].x509)
2730             idx = SSL_PKEY_GOST12_512;
2731         else if (s->cert->pkeys[SSL_PKEY_GOST12_256].x509)
2732             idx = SSL_PKEY_GOST12_256;
2733         else if (s->cert->pkeys[SSL_PKEY_GOST01].x509)
2734             idx = SSL_PKEY_GOST01;
2735         else
2736             idx = -1;
2737     }
2738     if (idx == -1)
2739         SSLerr(SSL_F_SSL_GET_SERVER_CERT_INDEX, ERR_R_INTERNAL_ERROR);
2740     return idx;
2741 }
2742
2743 CERT_PKEY *ssl_get_server_send_pkey(SSL *s)
2744 {
2745     CERT *c;
2746     int i;
2747
2748     c = s->cert;
2749     if (!s->s3 || !s->s3->tmp.new_cipher)
2750         return NULL;
2751     ssl_set_masks(s);
2752
2753     i = ssl_get_server_cert_index(s);
2754
2755     /* This may or may not be an error. */
2756     if (i < 0)
2757         return NULL;
2758
2759     /* May be NULL. */
2760     return &c->pkeys[i];
2761 }
2762
2763 EVP_PKEY *ssl_get_sign_pkey(SSL *s, const SSL_CIPHER *cipher,
2764                             const EVP_MD **pmd)
2765 {
2766     unsigned long alg_a;
2767     CERT *c;
2768     int idx = -1;
2769
2770     alg_a = cipher->algorithm_auth;
2771     c = s->cert;
2772
2773     if ((alg_a & SSL_aDSS) &&
2774             (c->pkeys[SSL_PKEY_DSA_SIGN].privatekey != NULL))
2775         idx = SSL_PKEY_DSA_SIGN;
2776     else if (alg_a & SSL_aRSA) {
2777         if (c->pkeys[SSL_PKEY_RSA_SIGN].privatekey != NULL)
2778             idx = SSL_PKEY_RSA_SIGN;
2779         else if (c->pkeys[SSL_PKEY_RSA_ENC].privatekey != NULL)
2780             idx = SSL_PKEY_RSA_ENC;
2781     } else if ((alg_a & SSL_aECDSA) &&
2782                (c->pkeys[SSL_PKEY_ECC].privatekey != NULL))
2783         idx = SSL_PKEY_ECC;
2784     if (idx == -1) {
2785         SSLerr(SSL_F_SSL_GET_SIGN_PKEY, ERR_R_INTERNAL_ERROR);
2786         return (NULL);
2787     }
2788     if (pmd)
2789         *pmd = s->s3->tmp.md[idx];
2790     return c->pkeys[idx].privatekey;
2791 }
2792
2793 int ssl_get_server_cert_serverinfo(SSL *s, const unsigned char **serverinfo,
2794                                    size_t *serverinfo_length)
2795 {
2796     CERT *c = NULL;
2797     int i = 0;
2798     *serverinfo_length = 0;
2799
2800     c = s->cert;
2801     i = ssl_get_server_cert_index(s);
2802
2803     if (i == -1)
2804         return 0;
2805     if (c->pkeys[i].serverinfo == NULL)
2806         return 0;
2807
2808     *serverinfo = c->pkeys[i].serverinfo;
2809     *serverinfo_length = c->pkeys[i].serverinfo_length;
2810     return 1;
2811 }
2812
2813 void ssl_update_cache(SSL *s, int mode)
2814 {
2815     int i;
2816
2817     /*
2818      * If the session_id_length is 0, we are not supposed to cache it, and it
2819      * would be rather hard to do anyway :-)
2820      */
2821     if (s->session->session_id_length == 0)
2822         return;
2823
2824     i = s->session_ctx->session_cache_mode;
2825     if ((i & mode) && (!s->hit)
2826         && ((i & SSL_SESS_CACHE_NO_INTERNAL_STORE)
2827             || SSL_CTX_add_session(s->session_ctx, s->session))
2828         && (s->session_ctx->new_session_cb != NULL)) {
2829         SSL_SESSION_up_ref(s->session);
2830         if (!s->session_ctx->new_session_cb(s, s->session))
2831             SSL_SESSION_free(s->session);
2832     }
2833
2834     /* auto flush every 255 connections */
2835     if ((!(i & SSL_SESS_CACHE_NO_AUTO_CLEAR)) && ((i & mode) == mode)) {
2836         if ((((mode & SSL_SESS_CACHE_CLIENT)
2837               ? s->session_ctx->stats.sess_connect_good
2838               : s->session_ctx->stats.sess_accept_good) & 0xff) == 0xff) {
2839             SSL_CTX_flush_sessions(s->session_ctx, (unsigned long)time(NULL));
2840         }
2841     }
2842 }
2843
2844 const SSL_METHOD *SSL_CTX_get_ssl_method(SSL_CTX *ctx)
2845 {
2846     return ctx->method;
2847 }
2848
2849 const SSL_METHOD *SSL_get_ssl_method(SSL *s)
2850 {
2851     return (s->method);
2852 }
2853
2854 int SSL_set_ssl_method(SSL *s, const SSL_METHOD *meth)
2855 {
2856     int ret = 1;
2857
2858     if (s->method != meth) {
2859         const SSL_METHOD *sm = s->method;
2860         int (*hf)(SSL *) = s->handshake_func;
2861
2862         if (sm->version == meth->version)
2863             s->method = meth;
2864         else {
2865             sm->ssl_free(s);
2866             s->method = meth;
2867             ret = s->method->ssl_new(s);
2868         }
2869
2870         if (hf == sm->ssl_connect)
2871             s->handshake_func = meth->ssl_connect;
2872         else if (hf == sm->ssl_accept)
2873             s->handshake_func = meth->ssl_accept;
2874     }
2875     return (ret);
2876 }
2877
2878 int SSL_get_error(const SSL *s, int i)
2879 {
2880     int reason;
2881     unsigned long l;
2882     BIO *bio;
2883
2884     if (i > 0)
2885         return (SSL_ERROR_NONE);
2886
2887     /*
2888      * Make things return SSL_ERROR_SYSCALL when doing SSL_do_handshake etc,
2889      * where we do encode the error
2890      */
2891     if ((l = ERR_peek_error()) != 0) {
2892         if (ERR_GET_LIB(l) == ERR_LIB_SYS)
2893             return (SSL_ERROR_SYSCALL);
2894         else
2895             return (SSL_ERROR_SSL);
2896     }
2897
2898     if (i < 0) {
2899         if (SSL_want_read(s)) {
2900             bio = SSL_get_rbio(s);
2901             if (BIO_should_read(bio))
2902                 return (SSL_ERROR_WANT_READ);
2903             else if (BIO_should_write(bio))
2904                 /*
2905                  * This one doesn't make too much sense ... We never try to write
2906                  * to the rbio, and an application program where rbio and wbio
2907                  * are separate couldn't even know what it should wait for.
2908                  * However if we ever set s->rwstate incorrectly (so that we have
2909                  * SSL_want_read(s) instead of SSL_want_write(s)) and rbio and
2910                  * wbio *are* the same, this test works around that bug; so it
2911                  * might be safer to keep it.
2912                  */
2913                 return (SSL_ERROR_WANT_WRITE);
2914             else if (BIO_should_io_special(bio)) {
2915                 reason = BIO_get_retry_reason(bio);
2916                 if (reason == BIO_RR_CONNECT)
2917                     return (SSL_ERROR_WANT_CONNECT);
2918                 else if (reason == BIO_RR_ACCEPT)
2919                     return (SSL_ERROR_WANT_ACCEPT);
2920                 else
2921                     return (SSL_ERROR_SYSCALL); /* unknown */
2922             }
2923         }
2924
2925         if (SSL_want_write(s)) {
2926             bio = SSL_get_wbio(s);
2927             if (BIO_should_write(bio))
2928                 return (SSL_ERROR_WANT_WRITE);
2929             else if (BIO_should_read(bio))
2930                 /*
2931                  * See above (SSL_want_read(s) with BIO_should_write(bio))
2932                  */
2933                 return (SSL_ERROR_WANT_READ);
2934             else if (BIO_should_io_special(bio)) {
2935                 reason = BIO_get_retry_reason(bio);
2936                 if (reason == BIO_RR_CONNECT)
2937                     return (SSL_ERROR_WANT_CONNECT);
2938                 else if (reason == BIO_RR_ACCEPT)
2939                     return (SSL_ERROR_WANT_ACCEPT);
2940                 else
2941                     return (SSL_ERROR_SYSCALL);
2942             }
2943         }
2944         if (SSL_want_x509_lookup(s)) {
2945             return (SSL_ERROR_WANT_X509_LOOKUP);
2946         }
2947         if (SSL_want_async(s)) {
2948             return SSL_ERROR_WANT_ASYNC;
2949         }
2950         if (SSL_want_async_job(s)) {
2951             return SSL_ERROR_WANT_ASYNC_JOB;
2952         }
2953     }
2954
2955     if (i == 0) {
2956         if ((s->shutdown & SSL_RECEIVED_SHUTDOWN) &&
2957             (s->s3->warn_alert == SSL_AD_CLOSE_NOTIFY))
2958             return (SSL_ERROR_ZERO_RETURN);
2959     }
2960     return (SSL_ERROR_SYSCALL);
2961 }
2962
2963 static int ssl_do_handshake_intern(void *vargs)
2964 {
2965     struct ssl_async_args *args;
2966     SSL *s;
2967
2968     args = (struct ssl_async_args *)vargs;
2969     s = args->s;
2970
2971     return s->handshake_func(s);
2972 }
2973
2974 int SSL_do_handshake(SSL *s)
2975 {
2976     int ret = 1;
2977
2978     if (s->handshake_func == NULL) {
2979         SSLerr(SSL_F_SSL_DO_HANDSHAKE, SSL_R_CONNECTION_TYPE_NOT_SET);
2980         return -1;
2981     }
2982
2983     s->method->ssl_renegotiate_check(s);
2984
2985     if (SSL_in_init(s) || SSL_in_before(s)) {
2986         if ((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
2987             struct ssl_async_args args;
2988
2989             args.s = s;
2990
2991             ret = ssl_start_async_job(s, &args, ssl_do_handshake_intern);
2992         } else {
2993             ret = s->handshake_func(s);
2994         }
2995     }
2996     return ret;
2997 }
2998
2999 void SSL_set_accept_state(SSL *s)
3000 {
3001     s->server = 1;
3002     s->shutdown = 0;
3003     ossl_statem_clear(s);
3004     s->handshake_func = s->method->ssl_accept;
3005     clear_ciphers(s);
3006 }
3007
3008 void SSL_set_connect_state(SSL *s)
3009 {
3010     s->server = 0;
3011     s->shutdown = 0;
3012     ossl_statem_clear(s);
3013     s->handshake_func = s->method->ssl_connect;
3014     clear_ciphers(s);
3015 }
3016
3017 int ssl_undefined_function(SSL *s)
3018 {
3019     SSLerr(SSL_F_SSL_UNDEFINED_FUNCTION, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
3020     return (0);
3021 }
3022
3023 int ssl_undefined_void_function(void)
3024 {
3025     SSLerr(SSL_F_SSL_UNDEFINED_VOID_FUNCTION,
3026            ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
3027     return (0);
3028 }
3029
3030 int ssl_undefined_const_function(const SSL *s)
3031 {
3032     return (0);
3033 }
3034
3035 const SSL_METHOD *ssl_bad_method(int ver)
3036 {
3037     SSLerr(SSL_F_SSL_BAD_METHOD, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
3038     return (NULL);
3039 }
3040
3041 const char *ssl_protocol_to_string(int version)
3042 {
3043     if (version == TLS1_2_VERSION)
3044         return "TLSv1.2";
3045     else if (version == TLS1_1_VERSION)
3046         return "TLSv1.1";
3047     else if (version == TLS1_VERSION)
3048         return "TLSv1";
3049     else if (version == SSL3_VERSION)
3050         return "SSLv3";
3051     else if (version == DTLS1_BAD_VER)
3052         return "DTLSv0.9";
3053     else if (version == DTLS1_VERSION)
3054         return "DTLSv1";
3055     else if (version == DTLS1_2_VERSION)
3056         return "DTLSv1.2";
3057     else
3058         return ("unknown");
3059 }
3060
3061 const char *SSL_get_version(const SSL *s)
3062 {
3063     return ssl_protocol_to_string(s->version);
3064 }
3065
3066 SSL *SSL_dup(SSL *s)
3067 {
3068     STACK_OF(X509_NAME) *sk;
3069     X509_NAME *xn;
3070     SSL *ret;
3071     int i;
3072
3073     /* If we're not quiescent, just up_ref! */
3074     if (!SSL_in_init(s) || !SSL_in_before(s)) {
3075         CRYPTO_atomic_add(&s->references, 1, &i, s->lock);
3076         return s;
3077     }
3078
3079     /*
3080      * Otherwise, copy configuration state, and session if set.
3081      */
3082     if ((ret = SSL_new(SSL_get_SSL_CTX(s))) == NULL)
3083         return (NULL);
3084
3085     if (s->session != NULL) {
3086         /*
3087          * Arranges to share the same session via up_ref.  This "copies"
3088          * session-id, SSL_METHOD, sid_ctx, and 'cert'
3089          */
3090         if (!SSL_copy_session_id(ret, s))
3091             goto err;
3092     } else {
3093         /*
3094          * No session has been established yet, so we have to expect that
3095          * s->cert or ret->cert will be changed later -- they should not both
3096          * point to the same object, and thus we can't use
3097          * SSL_copy_session_id.
3098          */
3099         if (!SSL_set_ssl_method(ret, s->method))
3100             goto err;
3101
3102         if (s->cert != NULL) {
3103             ssl_cert_free(ret->cert);
3104             ret->cert = ssl_cert_dup(s->cert);
3105             if (ret->cert == NULL)
3106                 goto err;
3107         }
3108
3109         if (!SSL_set_session_id_context(ret, s->sid_ctx, s->sid_ctx_length))
3110             goto err;
3111     }
3112
3113     if (!ssl_dane_dup(ret, s))
3114         goto err;
3115     ret->version = s->version;
3116     ret->options = s->options;
3117     ret->mode = s->mode;
3118     SSL_set_max_cert_list(ret, SSL_get_max_cert_list(s));
3119     SSL_set_read_ahead(ret, SSL_get_read_ahead(s));
3120     ret->msg_callback = s->msg_callback;
3121     ret->msg_callback_arg = s->msg_callback_arg;
3122     SSL_set_verify(ret, SSL_get_verify_mode(s), SSL_get_verify_callback(s));
3123     SSL_set_verify_depth(ret, SSL_get_verify_depth(s));
3124     ret->generate_session_id = s->generate_session_id;
3125
3126     SSL_set_info_callback(ret, SSL_get_info_callback(s));
3127
3128     /* copy app data, a little dangerous perhaps */
3129     if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_SSL, &ret->ex_data, &s->ex_data))
3130         goto err;
3131
3132     /* setup rbio, and wbio */
3133     if (s->rbio != NULL) {
3134         if (!BIO_dup_state(s->rbio, (char *)&ret->rbio))
3135             goto err;
3136     }
3137     if (s->wbio != NULL) {
3138         if (s->wbio != s->rbio) {
3139             if (!BIO_dup_state(s->wbio, (char *)&ret->wbio))
3140                 goto err;
3141         } else
3142             ret->wbio = ret->rbio;
3143     }
3144
3145     ret->server = s->server;
3146     if (s->handshake_func) {
3147         if (s->server)
3148             SSL_set_accept_state(ret);
3149         else
3150             SSL_set_connect_state(ret);
3151     }
3152     ret->shutdown = s->shutdown;
3153     ret->hit = s->hit;
3154
3155     ret->default_passwd_callback = s->default_passwd_callback;
3156     ret->default_passwd_callback_userdata = s->default_passwd_callback_userdata;
3157
3158     X509_VERIFY_PARAM_inherit(ret->param, s->param);
3159
3160     /* dup the cipher_list and cipher_list_by_id stacks */
3161     if (s->cipher_list != NULL) {
3162         if ((ret->cipher_list = sk_SSL_CIPHER_dup(s->cipher_list)) == NULL)
3163             goto err;
3164     }
3165     if (s->cipher_list_by_id != NULL)
3166         if ((ret->cipher_list_by_id = sk_SSL_CIPHER_dup(s->cipher_list_by_id))
3167             == NULL)
3168             goto err;
3169
3170     /* Dup the client_CA list */
3171     if (s->client_CA != NULL) {
3172         if ((sk = sk_X509_NAME_dup(s->client_CA)) == NULL)
3173             goto err;
3174         ret->client_CA = sk;
3175         for (i = 0; i < sk_X509_NAME_num(sk); i++) {
3176             xn = sk_X509_NAME_value(sk, i);
3177             if (sk_X509_NAME_set(sk, i, X509_NAME_dup(xn)) == NULL) {
3178                 X509_NAME_free(xn);
3179                 goto err;
3180             }
3181         }
3182     }
3183     return ret;
3184
3185  err:
3186     SSL_free(ret);
3187     return NULL;
3188 }
3189
3190 void ssl_clear_cipher_ctx(SSL *s)
3191 {
3192     if (s->enc_read_ctx != NULL) {
3193         EVP_CIPHER_CTX_free(s->enc_read_ctx);
3194         s->enc_read_ctx = NULL;
3195     }
3196     if (s->enc_write_ctx != NULL) {
3197         EVP_CIPHER_CTX_free(s->enc_write_ctx);
3198         s->enc_write_ctx = NULL;
3199     }
3200 #ifndef OPENSSL_NO_COMP
3201     COMP_CTX_free(s->expand);
3202     s->expand = NULL;
3203     COMP_CTX_free(s->compress);
3204     s->compress = NULL;
3205 #endif
3206 }
3207
3208 X509 *SSL_get_certificate(const SSL *s)
3209 {
3210     if (s->cert != NULL)
3211         return (s->cert->key->x509);
3212     else
3213         return (NULL);
3214 }
3215
3216 EVP_PKEY *SSL_get_privatekey(const SSL *s)
3217 {
3218     if (s->cert != NULL)
3219         return (s->cert->key->privatekey);
3220     else
3221         return (NULL);
3222 }
3223
3224 X509 *SSL_CTX_get0_certificate(const SSL_CTX *ctx)
3225 {
3226     if (ctx->cert != NULL)
3227         return ctx->cert->key->x509;
3228     else
3229         return NULL;
3230 }
3231
3232 EVP_PKEY *SSL_CTX_get0_privatekey(const SSL_CTX *ctx)
3233 {
3234     if (ctx->cert != NULL)
3235         return ctx->cert->key->privatekey;
3236     else
3237         return NULL;
3238 }
3239
3240 const SSL_CIPHER *SSL_get_current_cipher(const SSL *s)
3241 {
3242     if ((s->session != NULL) && (s->session->cipher != NULL))
3243         return (s->session->cipher);
3244     return (NULL);
3245 }
3246
3247 const COMP_METHOD *SSL_get_current_compression(SSL *s)
3248 {
3249 #ifndef OPENSSL_NO_COMP
3250     return s->compress ? COMP_CTX_get_method(s->compress) : NULL;
3251 #else
3252     return NULL;
3253 #endif
3254 }
3255
3256 const COMP_METHOD *SSL_get_current_expansion(SSL *s)
3257 {
3258 #ifndef OPENSSL_NO_COMP
3259     return s->expand ? COMP_CTX_get_method(s->expand) : NULL;
3260 #else
3261     return NULL;
3262 #endif
3263 }
3264
3265 int ssl_init_wbio_buffer(SSL *s)
3266 {
3267     BIO *bbio;
3268
3269     if (s->bbio == NULL) {
3270         bbio = BIO_new(BIO_f_buffer());
3271         if (bbio == NULL)
3272             return 0;
3273         s->bbio = bbio;
3274         s->wbio = BIO_push(bbio, s->wbio);
3275     } else {
3276         bbio = s->bbio;
3277         (void)BIO_reset(bbio);
3278     }
3279
3280     if (!BIO_set_read_buffer_size(bbio, 1)) {
3281         SSLerr(SSL_F_SSL_INIT_WBIO_BUFFER, ERR_R_BUF_LIB);
3282         return 0;
3283     }
3284
3285     return 1;
3286 }
3287
3288 void ssl_free_wbio_buffer(SSL *s)
3289 {
3290     /* callers ensure s is never null */
3291     if (s->bbio == NULL)
3292         return;
3293
3294     if (s->bbio == s->wbio) {
3295         /* remove buffering */
3296         s->wbio = BIO_pop(s->wbio);
3297         assert(s->wbio != NULL);
3298     }
3299     BIO_free(s->bbio);
3300     s->bbio = NULL;
3301 }
3302
3303 void SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx, int mode)
3304 {
3305     ctx->quiet_shutdown = mode;
3306 }
3307
3308 int SSL_CTX_get_quiet_shutdown(const SSL_CTX *ctx)
3309 {
3310     return (ctx->quiet_shutdown);
3311 }
3312
3313 void SSL_set_quiet_shutdown(SSL *s, int mode)
3314 {
3315     s->quiet_shutdown = mode;
3316 }
3317
3318 int SSL_get_quiet_shutdown(const SSL *s)
3319 {
3320     return (s->quiet_shutdown);
3321 }
3322
3323 void SSL_set_shutdown(SSL *s, int mode)
3324 {
3325     s->shutdown = mode;
3326 }
3327
3328 int SSL_get_shutdown(const SSL *s)
3329 {
3330     return s->shutdown;
3331 }
3332
3333 int SSL_version(const SSL *s)
3334 {
3335     return s->version;
3336 }
3337
3338 int SSL_client_version(const SSL *s)
3339 {
3340     return s->client_version;
3341 }
3342
3343 SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl)
3344 {
3345     return ssl->ctx;
3346 }
3347
3348 SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX *ctx)
3349 {
3350     CERT *new_cert;
3351     if (ssl->ctx == ctx)
3352         return ssl->ctx;
3353     if (ctx == NULL)
3354         ctx = ssl->initial_ctx;
3355     new_cert = ssl_cert_dup(ctx->cert);
3356     if (new_cert == NULL) {
3357         return NULL;
3358     }
3359     ssl_cert_free(ssl->cert);
3360     ssl->cert = new_cert;
3361
3362     /*
3363      * Program invariant: |sid_ctx| has fixed size (SSL_MAX_SID_CTX_LENGTH),
3364      * so setter APIs must prevent invalid lengths from entering the system.
3365      */
3366     OPENSSL_assert(ssl->sid_ctx_length <= sizeof(ssl->sid_ctx));
3367
3368     /*
3369      * If the session ID context matches that of the parent SSL_CTX,
3370      * inherit it from the new SSL_CTX as well. If however the context does
3371      * not match (i.e., it was set per-ssl with SSL_set_session_id_context),
3372      * leave it unchanged.
3373      */
3374     if ((ssl->ctx != NULL) &&
3375         (ssl->sid_ctx_length == ssl->ctx->sid_ctx_length) &&
3376         (memcmp(ssl->sid_ctx, ssl->ctx->sid_ctx, ssl->sid_ctx_length) == 0)) {
3377         ssl->sid_ctx_length = ctx->sid_ctx_length;
3378         memcpy(&ssl->sid_ctx, &ctx->sid_ctx, sizeof(ssl->sid_ctx));
3379     }
3380
3381     SSL_CTX_up_ref(ctx);
3382     SSL_CTX_free(ssl->ctx); /* decrement reference count */
3383     ssl->ctx = ctx;
3384
3385     return ssl->ctx;
3386 }
3387
3388 int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx)
3389 {
3390     return (X509_STORE_set_default_paths(ctx->cert_store));
3391 }
3392
3393 int SSL_CTX_set_default_verify_dir(SSL_CTX *ctx)
3394 {
3395     X509_LOOKUP *lookup;
3396
3397     lookup = X509_STORE_add_lookup(ctx->cert_store, X509_LOOKUP_hash_dir());
3398     if (lookup == NULL)
3399         return 0;
3400     X509_LOOKUP_add_dir(lookup, NULL, X509_FILETYPE_DEFAULT);
3401
3402     /* Clear any errors if the default directory does not exist */
3403     ERR_clear_error();
3404
3405     return 1;
3406 }
3407
3408 int SSL_CTX_set_default_verify_file(SSL_CTX *ctx)
3409 {
3410     X509_LOOKUP *lookup;
3411
3412     lookup = X509_STORE_add_lookup(ctx->cert_store, X509_LOOKUP_file());
3413     if (lookup == NULL)
3414         return 0;
3415
3416     X509_LOOKUP_load_file(lookup, NULL, X509_FILETYPE_DEFAULT);
3417
3418     /* Clear any errors if the default file does not exist */
3419     ERR_clear_error();
3420
3421     return 1;
3422 }
3423
3424 int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,
3425                                   const char *CApath)
3426 {
3427     return (X509_STORE_load_locations(ctx->cert_store, CAfile, CApath));
3428 }
3429
3430 void SSL_set_info_callback(SSL *ssl,
3431                            void (*cb) (const SSL *ssl, int type, int val))
3432 {
3433     ssl->info_callback = cb;
3434 }
3435
3436 /*
3437  * One compiler (Diab DCC) doesn't like argument names in returned function
3438  * pointer.
3439  */
3440 void (*SSL_get_info_callback(const SSL *ssl)) (const SSL * /* ssl */ ,
3441                                                int /* type */ ,
3442                                                int /* val */ ) {
3443     return ssl->info_callback;
3444 }
3445
3446 void SSL_set_verify_result(SSL *ssl, long arg)
3447 {
3448     ssl->verify_result = arg;
3449 }
3450
3451 long SSL_get_verify_result(const SSL *ssl)
3452 {
3453     return (ssl->verify_result);
3454 }
3455
3456 size_t SSL_get_client_random(const SSL *ssl, unsigned char *out, size_t outlen)
3457 {
3458     if (outlen == 0)
3459         return sizeof(ssl->s3->client_random);
3460     if (outlen > sizeof(ssl->s3->client_random))
3461         outlen = sizeof(ssl->s3->client_random);
3462     memcpy(out, ssl->s3->client_random, outlen);
3463     return outlen;
3464 }
3465
3466 size_t SSL_get_server_random(const SSL *ssl, unsigned char *out, size_t outlen)
3467 {
3468     if (outlen == 0)
3469         return sizeof(ssl->s3->server_random);
3470     if (outlen > sizeof(ssl->s3->server_random))
3471         outlen = sizeof(ssl->s3->server_random);
3472     memcpy(out, ssl->s3->server_random, outlen);
3473     return outlen;
3474 }
3475
3476 size_t SSL_SESSION_get_master_key(const SSL_SESSION *session,
3477                                unsigned char *out, size_t outlen)
3478 {
3479     if (session->master_key_length < 0) {
3480         /* Should never happen */
3481         return 0;
3482     }
3483     if (outlen == 0)
3484         return session->master_key_length;
3485     if (outlen > (size_t)session->master_key_length)
3486         outlen = session->master_key_length;
3487     memcpy(out, session->master_key, outlen);
3488     return outlen;
3489 }
3490
3491 int SSL_set_ex_data(SSL *s, int idx, void *arg)
3492 {
3493     return (CRYPTO_set_ex_data(&s->ex_data, idx, arg));
3494 }
3495
3496 void *SSL_get_ex_data(const SSL *s, int idx)
3497 {
3498     return (CRYPTO_get_ex_data(&s->ex_data, idx));
3499 }
3500
3501 int SSL_CTX_set_ex_data(SSL_CTX *s, int idx, void *arg)
3502 {
3503     return (CRYPTO_set_ex_data(&s->ex_data, idx, arg));
3504 }
3505
3506 void *SSL_CTX_get_ex_data(const SSL_CTX *s, int idx)
3507 {
3508     return (CRYPTO_get_ex_data(&s->ex_data, idx));
3509 }
3510
3511 int ssl_ok(SSL *s)
3512 {
3513     return (1);
3514 }
3515
3516 X509_STORE *SSL_CTX_get_cert_store(const SSL_CTX *ctx)
3517 {
3518     return (ctx->cert_store);
3519 }
3520
3521 void SSL_CTX_set_cert_store(SSL_CTX *ctx, X509_STORE *store)
3522 {
3523     X509_STORE_free(ctx->cert_store);
3524     ctx->cert_store = store;
3525 }
3526
3527 int SSL_want(const SSL *s)
3528 {
3529     return (s->rwstate);
3530 }
3531
3532 /**
3533  * \brief Set the callback for generating temporary DH keys.
3534  * \param ctx the SSL context.
3535  * \param dh the callback
3536  */
3537
3538 #ifndef OPENSSL_NO_DH
3539 void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,
3540                                  DH *(*dh) (SSL *ssl, int is_export,
3541                                             int keylength))
3542 {
3543     SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_TMP_DH_CB, (void (*)(void))dh);
3544 }
3545
3546 void SSL_set_tmp_dh_callback(SSL *ssl, DH *(*dh) (SSL *ssl, int is_export,
3547                                                   int keylength))
3548 {
3549     SSL_callback_ctrl(ssl, SSL_CTRL_SET_TMP_DH_CB, (void (*)(void))dh);
3550 }
3551 #endif
3552
3553 #ifndef OPENSSL_NO_PSK
3554 int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx, const char *identity_hint)
3555 {
3556     if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN) {
3557         SSLerr(SSL_F_SSL_CTX_USE_PSK_IDENTITY_HINT,
3558                SSL_R_DATA_LENGTH_TOO_LONG);
3559         return 0;
3560     }
3561     OPENSSL_free(ctx->cert->psk_identity_hint);
3562     if (identity_hint != NULL) {
3563         ctx->cert->psk_identity_hint = OPENSSL_strdup(identity_hint);
3564         if (ctx->cert->psk_identity_hint == NULL)
3565             return 0;
3566     } else
3567         ctx->cert->psk_identity_hint = NULL;
3568     return 1;
3569 }
3570
3571 int SSL_use_psk_identity_hint(SSL *s, const char *identity_hint)
3572 {
3573     if (s == NULL)
3574         return 0;
3575
3576     if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN) {
3577         SSLerr(SSL_F_SSL_USE_PSK_IDENTITY_HINT, SSL_R_DATA_LENGTH_TOO_LONG);
3578         return 0;
3579     }
3580     OPENSSL_free(s->cert->psk_identity_hint);
3581     if (identity_hint != NULL) {
3582         s->cert->psk_identity_hint = OPENSSL_strdup(identity_hint);
3583         if (s->cert->psk_identity_hint == NULL)
3584             return 0;
3585     } else
3586         s->cert->psk_identity_hint = NULL;
3587     return 1;
3588 }
3589
3590 const char *SSL_get_psk_identity_hint(const SSL *s)
3591 {
3592     if (s == NULL || s->session == NULL)
3593         return NULL;
3594     return (s->session->psk_identity_hint);
3595 }
3596
3597 const char *SSL_get_psk_identity(const SSL *s)
3598 {
3599     if (s == NULL || s->session == NULL)
3600         return NULL;
3601     return (s->session->psk_identity);
3602 }
3603
3604 void SSL_set_psk_client_callback(SSL *s,
3605                                  unsigned int (*cb) (SSL *ssl,
3606                                                      const char *hint,
3607                                                      char *identity,
3608                                                      unsigned int
3609                                                      max_identity_len,
3610                                                      unsigned char *psk,
3611                                                      unsigned int
3612                                                      max_psk_len))
3613 {
3614     s->psk_client_callback = cb;
3615 }
3616
3617 void SSL_CTX_set_psk_client_callback(SSL_CTX *ctx,
3618                                      unsigned int (*cb) (SSL *ssl,
3619                                                          const char *hint,
3620                                                          char *identity,
3621                                                          unsigned int
3622                                                          max_identity_len,
3623                                                          unsigned char *psk,
3624                                                          unsigned int
3625                                                          max_psk_len))
3626 {
3627     ctx->psk_client_callback = cb;
3628 }
3629
3630 void SSL_set_psk_server_callback(SSL *s,
3631                                  unsigned int (*cb) (SSL *ssl,
3632                                                      const char *identity,
3633                                                      unsigned char *psk,
3634                                                      unsigned int
3635                                                      max_psk_len))
3636 {
3637     s->psk_server_callback = cb;
3638 }
3639
3640 void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx,
3641                                      unsigned int (*cb) (SSL *ssl,
3642                                                          const char *identity,
3643                                                          unsigned char *psk,
3644                                                          unsigned int
3645                                                          max_psk_len))
3646 {
3647     ctx->psk_server_callback = cb;
3648 }
3649 #endif
3650
3651 void SSL_CTX_set_msg_callback(SSL_CTX *ctx,
3652                               void (*cb) (int write_p, int version,
3653                                           int content_type, const void *buf,
3654                                           size_t len, SSL *ssl, void *arg))
3655 {
3656     SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
3657 }
3658
3659 void SSL_set_msg_callback(SSL *ssl,
3660                           void (*cb) (int write_p, int version,
3661                                       int content_type, const void *buf,
3662                                       size_t len, SSL *ssl, void *arg))
3663 {
3664     SSL_callback_ctrl(ssl, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
3665 }
3666
3667 void SSL_CTX_set_not_resumable_session_callback(SSL_CTX *ctx,
3668                                                 int (*cb) (SSL *ssl,
3669                                                            int
3670                                                            is_forward_secure))
3671 {
3672     SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB,
3673                           (void (*)(void))cb);
3674 }
3675
3676 void SSL_set_not_resumable_session_callback(SSL *ssl,
3677                                             int (*cb) (SSL *ssl,
3678                                                        int is_forward_secure))
3679 {
3680     SSL_callback_ctrl(ssl, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB,
3681                       (void (*)(void))cb);
3682 }
3683
3684 /*
3685  * Allocates new EVP_MD_CTX and sets pointer to it into given pointer
3686  * variable, freeing EVP_MD_CTX previously stored in that variable, if any.
3687  * If EVP_MD pointer is passed, initializes ctx with this md Returns newly
3688  * allocated ctx;
3689  */
3690
3691 EVP_MD_CTX *ssl_replace_hash(EVP_MD_CTX **hash, const EVP_MD *md)
3692 {
3693     ssl_clear_hash_ctx(hash);
3694     *hash = EVP_MD_CTX_new();
3695     if (*hash == NULL || (md && EVP_DigestInit_ex(*hash, md, NULL) <= 0)) {
3696         EVP_MD_CTX_free(*hash);
3697         *hash = NULL;
3698         return NULL;
3699     }
3700     return *hash;
3701 }
3702
3703 void ssl_clear_hash_ctx(EVP_MD_CTX **hash)
3704 {
3705
3706     if (*hash)
3707         EVP_MD_CTX_free(*hash);
3708     *hash = NULL;
3709 }
3710
3711 /* Retrieve handshake hashes */
3712 int ssl_handshake_hash(SSL *s, unsigned char *out, int outlen)
3713 {
3714     EVP_MD_CTX *ctx = NULL;
3715     EVP_MD_CTX *hdgst = s->s3->handshake_dgst;
3716     int ret = EVP_MD_CTX_size(hdgst);
3717     if (ret < 0 || ret > outlen) {
3718         ret = 0;
3719         goto err;
3720     }
3721     ctx = EVP_MD_CTX_new();
3722     if (ctx == NULL) {
3723         ret = 0;
3724         goto err;
3725     }
3726     if (!EVP_MD_CTX_copy_ex(ctx, hdgst)
3727         || EVP_DigestFinal_ex(ctx, out, NULL) <= 0)
3728         ret = 0;
3729  err:
3730     EVP_MD_CTX_free(ctx);
3731     return ret;
3732 }
3733
3734 int SSL_session_reused(SSL *s)
3735 {
3736     return s->hit;
3737 }
3738
3739 int SSL_is_server(SSL *s)
3740 {
3741     return s->server;
3742 }
3743
3744 #if OPENSSL_API_COMPAT < 0x10100000L
3745 void SSL_set_debug(SSL *s, int debug)
3746 {
3747     /* Old function was do-nothing anyway... */
3748     (void)s;
3749     (void)debug;
3750 }
3751 #endif
3752
3753
3754 void SSL_set_security_level(SSL *s, int level)
3755 {
3756     s->cert->sec_level = level;
3757 }
3758
3759 int SSL_get_security_level(const SSL *s)
3760 {
3761     return s->cert->sec_level;
3762 }
3763
3764 void SSL_set_security_callback(SSL *s,
3765                                int (*cb) (const SSL *s, const SSL_CTX *ctx, int op,
3766                                           int bits, int nid, void *other,
3767                                           void *ex))
3768 {
3769     s->cert->sec_cb = cb;
3770 }
3771
3772 int (*SSL_get_security_callback(const SSL *s)) (const SSL *s, const SSL_CTX *ctx, int op,
3773                                                 int bits, int nid,
3774                                                 void *other, void *ex) {
3775     return s->cert->sec_cb;
3776 }
3777
3778 void SSL_set0_security_ex_data(SSL *s, void *ex)
3779 {
3780     s->cert->sec_ex = ex;
3781 }
3782
3783 void *SSL_get0_security_ex_data(const SSL *s)
3784 {
3785     return s->cert->sec_ex;
3786 }
3787
3788 void SSL_CTX_set_security_level(SSL_CTX *ctx, int level)
3789 {
3790     ctx->cert->sec_level = level;
3791 }
3792
3793 int SSL_CTX_get_security_level(const SSL_CTX *ctx)
3794 {
3795     return ctx->cert->sec_level;
3796 }
3797
3798 void SSL_CTX_set_security_callback(SSL_CTX *ctx,
3799                                    int (*cb) (const SSL *s, const SSL_CTX *ctx, int op,
3800                                               int bits, int nid, void *other,
3801                                               void *ex))
3802 {
3803     ctx->cert->sec_cb = cb;
3804 }
3805
3806 int (*SSL_CTX_get_security_callback(const SSL_CTX *ctx)) (const SSL *s,
3807                                                           const SSL_CTX *ctx,
3808                                                           int op, int bits,
3809                                                           int nid,
3810                                                           void *other,
3811                                                           void *ex) {
3812     return ctx->cert->sec_cb;
3813 }
3814
3815 void SSL_CTX_set0_security_ex_data(SSL_CTX *ctx, void *ex)
3816 {
3817     ctx->cert->sec_ex = ex;
3818 }
3819
3820 void *SSL_CTX_get0_security_ex_data(const SSL_CTX *ctx)
3821 {
3822     return ctx->cert->sec_ex;
3823 }
3824
3825
3826 /*
3827  * Get/Set/Clear options in SSL_CTX or SSL, formerly macros, now functions that
3828  * can return unsigned long, instead of the generic long return value from the
3829  * control interface.
3830  */
3831 unsigned long SSL_CTX_get_options(const SSL_CTX *ctx)
3832 {
3833     return ctx->options;
3834 }
3835 unsigned long SSL_get_options(const SSL* s)
3836 {
3837     return s->options;
3838 }
3839 unsigned long SSL_CTX_set_options(SSL_CTX *ctx, unsigned long op)
3840 {
3841     return ctx->options |= op;
3842 }
3843 unsigned long SSL_set_options(SSL *s, unsigned long op)
3844 {
3845     return s->options |= op;
3846 }
3847 unsigned long SSL_CTX_clear_options(SSL_CTX *ctx, unsigned long op)
3848 {
3849     return ctx->options &= ~op;
3850 }
3851 unsigned long SSL_clear_options(SSL *s, unsigned long op)
3852 {
3853     return s->options &= ~op;
3854 }
3855
3856 STACK_OF(X509) *SSL_get0_verified_chain(const SSL *s)
3857 {
3858     return s->verified_chain;
3859 }
3860
3861 IMPLEMENT_OBJ_BSEARCH_GLOBAL_CMP_FN(SSL_CIPHER, SSL_CIPHER, ssl_cipher_id);
3862
3863 #ifndef OPENSSL_NO_CT
3864
3865 /*
3866  * Moves SCTs from the |src| stack to the |dst| stack.
3867  * The source of each SCT will be set to |origin|.
3868  * If |dst| points to a NULL pointer, a new stack will be created and owned by
3869  * the caller.
3870  * Returns the number of SCTs moved, or a negative integer if an error occurs.
3871  */
3872 static int ct_move_scts(STACK_OF(SCT) **dst, STACK_OF(SCT) *src, sct_source_t origin)
3873 {
3874     int scts_moved = 0;
3875     SCT *sct = NULL;
3876
3877     if (*dst == NULL) {
3878         *dst = sk_SCT_new_null();
3879         if (*dst == NULL) {
3880             SSLerr(SSL_F_CT_MOVE_SCTS, ERR_R_MALLOC_FAILURE);
3881             goto err;
3882         }
3883     }
3884
3885     while ((sct = sk_SCT_pop(src)) != NULL) {
3886         if (SCT_set_source(sct, origin) != 1)
3887             goto err;
3888
3889         if (sk_SCT_push(*dst, sct) <= 0)
3890             goto err;
3891         scts_moved += 1;
3892     }
3893
3894     return scts_moved;
3895 err:
3896     if (sct != NULL)
3897         sk_SCT_push(src, sct); /* Put the SCT back */
3898     return -1;
3899 }
3900
3901 /*
3902 * Look for data collected during ServerHello and parse if found.
3903 * Return 1 on success, 0 on failure.
3904 */
3905 static int ct_extract_tls_extension_scts(SSL *s)
3906 {
3907     int scts_extracted = 0;
3908
3909     if (s->tlsext_scts != NULL) {
3910         const unsigned char *p = s->tlsext_scts;
3911         STACK_OF(SCT) *scts = o2i_SCT_LIST(NULL, &p, s->tlsext_scts_len);
3912
3913         scts_extracted = ct_move_scts(&s->scts, scts, SCT_SOURCE_TLS_EXTENSION);
3914
3915         SCT_LIST_free(scts);
3916     }
3917
3918     return scts_extracted;
3919 }
3920
3921 /*
3922  * Checks for an OCSP response and then attempts to extract any SCTs found if it
3923  * contains an SCT X509 extension. They will be stored in |s->scts|.
3924  * Returns:
3925  * - The number of SCTs extracted, assuming an OCSP response exists.
3926  * - 0 if no OCSP response exists or it contains no SCTs.
3927  * - A negative integer if an error occurs.
3928  */
3929 static int ct_extract_ocsp_response_scts(SSL *s)
3930 {
3931 #ifndef OPENSSL_NO_OCSP
3932     int scts_extracted = 0;
3933     const unsigned char *p;
3934     OCSP_BASICRESP *br = NULL;
3935     OCSP_RESPONSE *rsp = NULL;
3936     STACK_OF(SCT) *scts = NULL;
3937     int i;
3938
3939     if (s->tlsext_ocsp_resp == NULL || s->tlsext_ocsp_resplen == 0)
3940         goto err;
3941
3942     p = s->tlsext_ocsp_resp;
3943     rsp = d2i_OCSP_RESPONSE(NULL, &p, s->tlsext_ocsp_resplen);
3944     if (rsp == NULL)
3945         goto err;
3946
3947     br = OCSP_response_get1_basic(rsp);
3948     if (br == NULL)
3949         goto err;
3950
3951     for (i = 0; i < OCSP_resp_count(br); ++i) {
3952         OCSP_SINGLERESP *single = OCSP_resp_get0(br, i);
3953
3954         if (single == NULL)
3955             continue;
3956
3957         scts = OCSP_SINGLERESP_get1_ext_d2i(single, NID_ct_cert_scts, NULL, NULL);
3958         scts_extracted = ct_move_scts(&s->scts, scts,
3959                                       SCT_SOURCE_OCSP_STAPLED_RESPONSE);
3960         if (scts_extracted < 0)
3961             goto err;
3962     }
3963 err:
3964     SCT_LIST_free(scts);
3965     OCSP_BASICRESP_free(br);
3966     OCSP_RESPONSE_free(rsp);
3967     return scts_extracted;
3968 #else
3969     /* Behave as if no OCSP response exists */
3970     return 0;
3971 #endif
3972 }
3973
3974 /*
3975  * Attempts to extract SCTs from the peer certificate.
3976  * Return the number of SCTs extracted, or a negative integer if an error
3977  * occurs.
3978  */
3979 static int ct_extract_x509v3_extension_scts(SSL *s)
3980 {
3981     int scts_extracted = 0;
3982     X509 *cert = s->session != NULL ? s->session->peer : NULL;
3983
3984     if (cert != NULL) {
3985         STACK_OF(SCT) *scts =
3986             X509_get_ext_d2i(cert, NID_ct_precert_scts, NULL, NULL);
3987
3988         scts_extracted =
3989             ct_move_scts(&s->scts, scts, SCT_SOURCE_X509V3_EXTENSION);
3990
3991         SCT_LIST_free(scts);
3992     }
3993
3994     return scts_extracted;
3995 }
3996
3997 /*
3998  * Attempts to find all received SCTs by checking TLS extensions, the OCSP
3999  * response (if it exists) and X509v3 extensions in the certificate.
4000  * Returns NULL if an error occurs.
4001  */
4002 const STACK_OF(SCT) *SSL_get0_peer_scts(SSL *s)
4003 {
4004     if (!s->scts_parsed) {
4005         if (ct_extract_tls_extension_scts(s) < 0 ||
4006             ct_extract_ocsp_response_scts(s) < 0 ||
4007             ct_extract_x509v3_extension_scts(s) < 0)
4008             goto err;
4009
4010         s->scts_parsed = 1;
4011     }
4012     return s->scts;
4013 err:
4014     return NULL;
4015 }
4016
4017 static int ct_permissive(const CT_POLICY_EVAL_CTX *ctx,
4018                          const STACK_OF(SCT) *scts, void *unused_arg)
4019 {
4020     return 1;
4021 }
4022
4023 static int ct_strict(const CT_POLICY_EVAL_CTX *ctx,
4024                      const STACK_OF(SCT) *scts, void *unused_arg)
4025 {
4026     int count = scts != NULL ? sk_SCT_num(scts) : 0;
4027     int i;
4028
4029     for (i = 0; i < count; ++i) {
4030         SCT *sct = sk_SCT_value(scts, i);
4031         int status = SCT_get_validation_status(sct);
4032
4033         if (status == SCT_VALIDATION_STATUS_VALID)
4034             return 1;
4035     }
4036     SSLerr(SSL_F_CT_STRICT, SSL_R_NO_VALID_SCTS);
4037     return 0;
4038 }
4039
4040 int SSL_set_ct_validation_callback(SSL *s, ssl_ct_validation_cb callback,
4041                                    void *arg)
4042 {
4043     /*
4044      * Since code exists that uses the custom extension handler for CT, look
4045      * for this and throw an error if they have already registered to use CT.
4046      */
4047     if (callback != NULL && SSL_CTX_has_client_custom_ext(s->ctx,
4048             TLSEXT_TYPE_signed_certificate_timestamp)) {
4049         SSLerr(SSL_F_SSL_SET_CT_VALIDATION_CALLBACK,
4050                SSL_R_CUSTOM_EXT_HANDLER_ALREADY_INSTALLED);
4051         return 0;
4052     }
4053
4054     if (callback != NULL) {
4055         /* If we are validating CT, then we MUST accept SCTs served via OCSP */
4056         if (!SSL_set_tlsext_status_type(s, TLSEXT_STATUSTYPE_ocsp))
4057             return 0;
4058     }
4059
4060     s->ct_validation_callback = callback;
4061     s->ct_validation_callback_arg = arg;
4062
4063     return 1;
4064 }
4065
4066 int SSL_CTX_set_ct_validation_callback(SSL_CTX *ctx,
4067                                        ssl_ct_validation_cb callback,
4068                                        void *arg)
4069 {
4070     /*
4071      * Since code exists that uses the custom extension handler for CT, look for
4072      * this and throw an error if they have already registered to use CT.
4073      */
4074     if (callback != NULL && SSL_CTX_has_client_custom_ext(ctx,
4075             TLSEXT_TYPE_signed_certificate_timestamp)) {
4076         SSLerr(SSL_F_SSL_CTX_SET_CT_VALIDATION_CALLBACK,
4077                SSL_R_CUSTOM_EXT_HANDLER_ALREADY_INSTALLED);
4078         return 0;
4079     }
4080
4081     ctx->ct_validation_callback = callback;
4082     ctx->ct_validation_callback_arg = arg;
4083     return 1;
4084 }
4085
4086 int SSL_ct_is_enabled(const SSL *s)
4087 {
4088     return s->ct_validation_callback != NULL;
4089 }
4090
4091 int SSL_CTX_ct_is_enabled(const SSL_CTX *ctx)
4092 {
4093     return ctx->ct_validation_callback != NULL;
4094 }
4095
4096 int ssl_validate_ct(SSL *s)
4097 {
4098     int ret = 0;
4099     X509 *cert = s->session != NULL ? s->session->peer : NULL;
4100     X509 *issuer;
4101     SSL_DANE *dane = &s->dane;
4102     CT_POLICY_EVAL_CTX *ctx = NULL;
4103     const STACK_OF(SCT) *scts;
4104
4105     /*
4106      * If no callback is set, the peer is anonymous, or its chain is invalid,
4107      * skip SCT validation - just return success.  Applications that continue
4108      * handshakes without certificates, with unverified chains, or pinned leaf
4109      * certificates are outside the scope of the WebPKI and CT.
4110      *
4111      * The above exclusions notwithstanding the vast majority of peers will
4112      * have rather ordinary certificate chains validated by typical
4113      * applications that perform certificate verification and therefore will
4114      * process SCTs when enabled.
4115      */
4116     if (s->ct_validation_callback == NULL || cert == NULL ||
4117         s->verify_result != X509_V_OK ||
4118         s->verified_chain == NULL ||
4119         sk_X509_num(s->verified_chain) <= 1)
4120         return 1;
4121
4122     /*
4123      * CT not applicable for chains validated via DANE-TA(2) or DANE-EE(3)
4124      * trust-anchors.  See https://tools.ietf.org/html/rfc7671#section-4.2
4125      */
4126     if (DANETLS_ENABLED(dane) && dane->mtlsa != NULL) {
4127         switch (dane->mtlsa->usage) {
4128         case DANETLS_USAGE_DANE_TA:
4129         case DANETLS_USAGE_DANE_EE:
4130             return 1;
4131         }
4132     }
4133
4134     ctx = CT_POLICY_EVAL_CTX_new();
4135     if (ctx == NULL) {
4136         SSLerr(SSL_F_SSL_VALIDATE_CT, ERR_R_MALLOC_FAILURE);
4137         goto end;
4138     }
4139
4140     issuer = sk_X509_value(s->verified_chain, 1);
4141     CT_POLICY_EVAL_CTX_set0_cert(ctx, cert);
4142     CT_POLICY_EVAL_CTX_set0_issuer(ctx, issuer);
4143     CT_POLICY_EVAL_CTX_set0_log_store(ctx, s->ctx->ctlog_store);
4144
4145     scts = SSL_get0_peer_scts(s);
4146
4147     /*
4148      * This function returns success (> 0) only when all the SCTs are valid, 0
4149      * when some are invalid, and < 0 on various internal errors (out of
4150      * memory, etc.).  Having some, or even all, invalid SCTs is not sufficient
4151      * reason to abort the handshake, that decision is up to the callback.
4152      * Therefore, we error out only in the unexpected case that the return
4153      * value is negative.
4154      *
4155      * XXX: One might well argue that the return value of this function is an
4156      * unfortunate design choice.  Its job is only to determine the validation
4157      * status of each of the provided SCTs.  So long as it correctly separates
4158      * the wheat from the chaff it should return success.  Failure in this case
4159      * ought to correspond to an inability to carry out its duties.
4160      */
4161     if (SCT_LIST_validate(scts, ctx) < 0) {
4162         SSLerr(SSL_F_SSL_VALIDATE_CT, SSL_R_SCT_VERIFICATION_FAILED);
4163         goto end;
4164     }
4165
4166     ret = s->ct_validation_callback(ctx, scts, s->ct_validation_callback_arg);
4167     if (ret < 0)
4168         ret = 0; /* This function returns 0 on failure */
4169
4170 end:
4171     CT_POLICY_EVAL_CTX_free(ctx);
4172     /*
4173      * With SSL_VERIFY_NONE the session may be cached and re-used despite a
4174      * failure return code here.  Also the application may wish the complete
4175      * the handshake, and then disconnect cleanly at a higher layer, after
4176      * checking the verification status of the completed connection.
4177      *
4178      * We therefore force a certificate verification failure which will be
4179      * visible via SSL_get_verify_result() and cached as part of any resumed
4180      * session.
4181      *
4182      * Note: the permissive callback is for information gathering only, always
4183      * returns success, and does not affect verification status.  Only the
4184      * strict callback or a custom application-specified callback can trigger
4185      * connection failure or record a verification error.
4186      */
4187     if (ret <= 0)
4188         s->verify_result = X509_V_ERR_NO_VALID_SCTS;
4189     return ret;
4190 }
4191
4192 int SSL_CTX_enable_ct(SSL_CTX *ctx, int validation_mode)
4193 {
4194     switch (validation_mode) {
4195     default:
4196         SSLerr(SSL_F_SSL_CTX_ENABLE_CT, SSL_R_INVALID_CT_VALIDATION_TYPE);
4197         return 0;
4198     case SSL_CT_VALIDATION_PERMISSIVE:
4199         return SSL_CTX_set_ct_validation_callback(ctx, ct_permissive, NULL);
4200     case SSL_CT_VALIDATION_STRICT:
4201         return SSL_CTX_set_ct_validation_callback(ctx, ct_strict, NULL);
4202     }
4203 }
4204
4205 int SSL_enable_ct(SSL *s, int validation_mode)
4206 {
4207     switch (validation_mode) {
4208     default:
4209         SSLerr(SSL_F_SSL_ENABLE_CT, SSL_R_INVALID_CT_VALIDATION_TYPE);
4210         return 0;
4211     case SSL_CT_VALIDATION_PERMISSIVE:
4212         return SSL_set_ct_validation_callback(s, ct_permissive, NULL);
4213     case SSL_CT_VALIDATION_STRICT:
4214         return SSL_set_ct_validation_callback(s, ct_strict, NULL);
4215     }
4216 }
4217
4218 int SSL_CTX_set_default_ctlog_list_file(SSL_CTX *ctx)
4219 {
4220     return CTLOG_STORE_load_default_file(ctx->ctlog_store);
4221 }
4222
4223 int SSL_CTX_set_ctlog_list_file(SSL_CTX *ctx, const char *path)
4224 {
4225     return CTLOG_STORE_load_file(ctx->ctlog_store, path);
4226 }
4227
4228 void SSL_CTX_set0_ctlog_store(SSL_CTX *ctx, CTLOG_STORE *logs)
4229 {
4230     CTLOG_STORE_free(ctx->ctlog_store);
4231     ctx->ctlog_store = logs;
4232 }
4233
4234 const CTLOG_STORE *SSL_CTX_get0_ctlog_store(const SSL_CTX *ctx)
4235 {
4236     return ctx->ctlog_store;
4237 }
4238
4239 #endif