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