ssl/ssl_lib.c

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