ssl/ssl_lib.c

   1 /*
   2  * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
   3  * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
   4  * Copyright 2005 Nokia. All rights reserved.
   5  *
   6  * Licensed under the Apache License 2.0 (the "License").  You may not use
   7  * this file except in compliance with the License.  You can obtain a copy
   8  * in the file LICENSE in the source distribution or at
   9  * https://www.openssl.org/source/license.html
  10  */
  11
  12 /* We need to use some engine deprecated APIs */
  13 #define OPENSSL_SUPPRESS_DEPRECATED
  14
  15 #include <stdio.h>
  16 #include "ssl_local.h"
  17 #include "e_os.h"
  18 #include <openssl/objects.h>
  19 #include <openssl/x509v3.h>
  20 #include <openssl/rand.h>
  21 #include <openssl/ocsp.h>
  22 #include <openssl/dh.h>
  23 #include <openssl/engine.h>
  24 #include <openssl/async.h>
  25 #include <openssl/ct.h>
  26 #include <openssl/trace.h>
  27 #include "internal/cryptlib.h"
  28 #include "internal/refcount.h"
  29 #include "internal/ktls.h"
  30
  31 DEFINE_STACK_OF(OCSP_RESPID)
  32 DEFINE_STACK_OF(SCT)
  33
  34 static int ssl_undefined_function_1(SSL *ssl, SSL3_RECORD *r, size_t s, int t,
  35                                     SSL_MAC_BUF *mac, size_t macsize)
  36 {
  37     return ssl_undefined_function(ssl);
  38 }
  39
  40 static int ssl_undefined_function_2(SSL *ssl, SSL3_RECORD *r, unsigned char *s,
  41                                     int t)
  42 {
  43     return ssl_undefined_function(ssl);
  44 }
  45
  46 static int ssl_undefined_function_3(SSL *ssl, unsigned char *r,
  47                                     unsigned char *s, size_t t, size_t *u)
  48 {
  49     return ssl_undefined_function(ssl);
  50 }
  51
  52 static int ssl_undefined_function_4(SSL *ssl, int r)
  53 {
  54     return ssl_undefined_function(ssl);
  55 }
  56
  57 static size_t ssl_undefined_function_5(SSL *ssl, const char *r, size_t s,
  58                                        unsigned char *t)
  59 {
  60     return ssl_undefined_function(ssl);
  61 }
  62
  63 static int ssl_undefined_function_6(int r)
  64 {
  65     return ssl_undefined_function(NULL);
  66 }
  67
  68 static int ssl_undefined_function_7(SSL *ssl, unsigned char *r, size_t s,
  69                                     const char *t, size_t u,
  70                                     const unsigned char *v, size_t w, int x)
  71 {
  72     return ssl_undefined_function(ssl);
  73 }
  74
  75 SSL3_ENC_METHOD ssl3_undef_enc_method = {
  76     ssl_undefined_function_1,
  77     ssl_undefined_function_2,
  78     ssl_undefined_function,
  79     ssl_undefined_function_3,
  80     ssl_undefined_function_4,
  81     ssl_undefined_function_5,
  82     NULL,                       /* client_finished_label */
  83     0,                          /* client_finished_label_len */
  84     NULL,                       /* server_finished_label */
  85     0,                          /* server_finished_label_len */
  86     ssl_undefined_function_6,
  87     ssl_undefined_function_7,
  88 };
  89
  90 struct ssl_async_args {
  91     SSL *s;
  92     void *buf;
  93     size_t num;
  94     enum { READFUNC, WRITEFUNC, OTHERFUNC } type;
  95     union {
  96         int (*func_read) (SSL *, void *, size_t, size_t *);
  97         int (*func_write) (SSL *, const void *, size_t, size_t *);
  98         int (*func_other) (SSL *);
  99     } f;
 100 };
 101
 102 static const struct {
 103     uint8_t mtype;
 104     uint8_t ord;
 105     int nid;
 106 } dane_mds[] = {
 107     {
 108         DANETLS_MATCHING_FULL, 0, NID_undef
 109     },
 110     {
 111         DANETLS_MATCHING_2256, 1, NID_sha256
 112     },
 113     {
 114         DANETLS_MATCHING_2512, 2, NID_sha512
 115     },
 116 };
 117
 118 static int dane_ctx_enable(struct dane_ctx_st *dctx)
 119 {
 120     const EVP_MD **mdevp;
 121     uint8_t *mdord;
 122     uint8_t mdmax = DANETLS_MATCHING_LAST;
 123     int n = ((int)mdmax) + 1;   /* int to handle PrivMatch(255) */
 124     size_t i;
 125
 126     if (dctx->mdevp != NULL)
 127         return 1;
 128
 129     mdevp = OPENSSL_zalloc(n * sizeof(*mdevp));
 130     mdord = OPENSSL_zalloc(n * sizeof(*mdord));
 131
 132     if (mdord == NULL || mdevp == NULL) {
 133         OPENSSL_free(mdord);
 134         OPENSSL_free(mdevp);
 135         SSLerr(SSL_F_DANE_CTX_ENABLE, ERR_R_MALLOC_FAILURE);
 136         return 0;
 137     }
 138
 139     /* Install default entries */
 140     for (i = 0; i < OSSL_NELEM(dane_mds); ++i) {
 141         const EVP_MD *md;
 142
 143         if (dane_mds[i].nid == NID_undef ||
 144             (md = EVP_get_digestbynid(dane_mds[i].nid)) == NULL)
 145             continue;
 146         mdevp[dane_mds[i].mtype] = md;
 147         mdord[dane_mds[i].mtype] = dane_mds[i].ord;
 148     }
 149
 150     dctx->mdevp = mdevp;
 151     dctx->mdord = mdord;
 152     dctx->mdmax = mdmax;
 153
 154     return 1;
 155 }
 156
 157 static void dane_ctx_final(struct dane_ctx_st *dctx)
 158 {
 159     OPENSSL_free(dctx->mdevp);
 160     dctx->mdevp = NULL;
 161
 162     OPENSSL_free(dctx->mdord);
 163     dctx->mdord = NULL;
 164     dctx->mdmax = 0;
 165 }
 166
 167 static void tlsa_free(danetls_record *t)
 168 {
 169     if (t == NULL)
 170         return;
 171     OPENSSL_free(t->data);
 172     EVP_PKEY_free(t->spki);
 173     OPENSSL_free(t);
 174 }
 175
 176 static void dane_final(SSL_DANE *dane)
 177 {
 178     sk_danetls_record_pop_free(dane->trecs, tlsa_free);
 179     dane->trecs = NULL;
 180
 181     sk_X509_pop_free(dane->certs, X509_free);
 182     dane->certs = NULL;
 183
 184     X509_free(dane->mcert);
 185     dane->mcert = NULL;
 186     dane->mtlsa = NULL;
 187     dane->mdpth = -1;
 188     dane->pdpth = -1;
 189 }
 190
 191 /*
 192  * dane_copy - Copy dane configuration, sans verification state.
 193  */
 194 static int ssl_dane_dup(SSL *to, SSL *from)
 195 {
 196     int num;
 197     int i;
 198
 199     if (!DANETLS_ENABLED(&from->dane))
 200         return 1;
 201
 202     num = sk_danetls_record_num(from->dane.trecs);
 203     dane_final(&to->dane);
 204     to->dane.flags = from->dane.flags;
 205     to->dane.dctx = &to->ctx->dane;
 206     to->dane.trecs = sk_danetls_record_new_reserve(NULL, num);
 207
 208     if (to->dane.trecs == NULL) {
 209         SSLerr(SSL_F_SSL_DANE_DUP, ERR_R_MALLOC_FAILURE);
 210         return 0;
 211     }
 212
 213     for (i = 0; i < num; ++i) {
 214         danetls_record *t = sk_danetls_record_value(from->dane.trecs, i);
 215
 216         if (SSL_dane_tlsa_add(to, t->usage, t->selector, t->mtype,
 217                               t->data, t->dlen) <= 0)
 218             return 0;
 219     }
 220     return 1;
 221 }
 222
 223 static int dane_mtype_set(struct dane_ctx_st *dctx,
 224                           const EVP_MD *md, uint8_t mtype, uint8_t ord)
 225 {
 226     int i;
 227
 228     if (mtype == DANETLS_MATCHING_FULL && md != NULL) {
 229         SSLerr(SSL_F_DANE_MTYPE_SET, SSL_R_DANE_CANNOT_OVERRIDE_MTYPE_FULL);
 230         return 0;
 231     }
 232
 233     if (mtype > dctx->mdmax) {
 234         const EVP_MD **mdevp;
 235         uint8_t *mdord;
 236         int n = ((int)mtype) + 1;
 237
 238         mdevp = OPENSSL_realloc(dctx->mdevp, n * sizeof(*mdevp));
 239         if (mdevp == NULL) {
 240             SSLerr(SSL_F_DANE_MTYPE_SET, ERR_R_MALLOC_FAILURE);
 241             return -1;
 242         }
 243         dctx->mdevp = mdevp;
 244
 245         mdord = OPENSSL_realloc(dctx->mdord, n * sizeof(*mdord));
 246         if (mdord == NULL) {
 247             SSLerr(SSL_F_DANE_MTYPE_SET, ERR_R_MALLOC_FAILURE);
 248             return -1;
 249         }
 250         dctx->mdord = mdord;
 251
 252         /* Zero-fill any gaps */
 253         for (i = dctx->mdmax + 1; i < mtype; ++i) {
 254             mdevp[i] = NULL;
 255             mdord[i] = 0;
 256         }
 257
 258         dctx->mdmax = mtype;
 259     }
 260
 261     dctx->mdevp[mtype] = md;
 262     /* Coerce ordinal of disabled matching types to 0 */
 263     dctx->mdord[mtype] = (md == NULL) ? 0 : ord;
 264
 265     return 1;
 266 }
 267
 268 static const EVP_MD *tlsa_md_get(SSL_DANE *dane, uint8_t mtype)
 269 {
 270     if (mtype > dane->dctx->mdmax)
 271         return NULL;
 272     return dane->dctx->mdevp[mtype];
 273 }
 274
 275 static int dane_tlsa_add(SSL_DANE *dane,
 276                          uint8_t usage,
 277                          uint8_t selector,
 278                          uint8_t mtype, unsigned const char *data, size_t dlen)
 279 {
 280     danetls_record *t;
 281     const EVP_MD *md = NULL;
 282     int ilen = (int)dlen;
 283     int i;
 284     int num;
 285
 286     if (dane->trecs == NULL) {
 287         SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_NOT_ENABLED);
 288         return -1;
 289     }
 290
 291     if (ilen < 0 || dlen != (size_t)ilen) {
 292         SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_DATA_LENGTH);
 293         return 0;
 294     }
 295
 296     if (usage > DANETLS_USAGE_LAST) {
 297         SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_CERTIFICATE_USAGE);
 298         return 0;
 299     }
 300
 301     if (selector > DANETLS_SELECTOR_LAST) {
 302         SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_SELECTOR);
 303         return 0;
 304     }
 305
 306     if (mtype != DANETLS_MATCHING_FULL) {
 307         md = tlsa_md_get(dane, mtype);
 308         if (md == NULL) {
 309             SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_MATCHING_TYPE);
 310             return 0;
 311         }
 312     }
 313
 314     if (md != NULL && dlen != (size_t)EVP_MD_size(md)) {
 315         SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_DIGEST_LENGTH);
 316         return 0;
 317     }
 318     if (!data) {
 319         SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_NULL_DATA);
 320         return 0;
 321     }
 322
 323     if ((t = OPENSSL_zalloc(sizeof(*t))) == NULL) {
 324         SSLerr(SSL_F_DANE_TLSA_ADD, ERR_R_MALLOC_FAILURE);
 325         return -1;
 326     }
 327
 328     t->usage = usage;
 329     t->selector = selector;
 330     t->mtype = mtype;
 331     t->data = OPENSSL_malloc(dlen);
 332     if (t->data == NULL) {
 333         tlsa_free(t);
 334         SSLerr(SSL_F_DANE_TLSA_ADD, ERR_R_MALLOC_FAILURE);
 335         return -1;
 336     }
 337     memcpy(t->data, data, dlen);
 338     t->dlen = dlen;
 339
 340     /* Validate and cache full certificate or public key */
 341     if (mtype == DANETLS_MATCHING_FULL) {
 342         const unsigned char *p = data;
 343         X509 *cert = NULL;
 344         EVP_PKEY *pkey = NULL;
 345
 346         switch (selector) {
 347         case DANETLS_SELECTOR_CERT:
 348             if (!d2i_X509(&cert, &p, ilen) || p < data ||
 349                 dlen != (size_t)(p - data)) {
 350                 tlsa_free(t);
 351                 SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_CERTIFICATE);
 352                 return 0;
 353             }
 354             if (X509_get0_pubkey(cert) == NULL) {
 355                 tlsa_free(t);
 356                 SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_CERTIFICATE);
 357                 return 0;
 358             }
 359
 360             if ((DANETLS_USAGE_BIT(usage) & DANETLS_TA_MASK) == 0) {
 361                 X509_free(cert);
 362                 break;
 363             }
 364
 365             /*
 366              * For usage DANE-TA(2), we support authentication via "2 0 0" TLSA
 367              * records that contain full certificates of trust-anchors that are
 368              * not present in the wire chain.  For usage PKIX-TA(0), we augment
 369              * the chain with untrusted Full(0) certificates from DNS, in case
 370              * they are missing from the chain.
 371              */
 372             if ((dane->certs == NULL &&
 373                  (dane->certs = sk_X509_new_null()) == NULL) ||
 374                 !sk_X509_push(dane->certs, cert)) {
 375                 SSLerr(SSL_F_DANE_TLSA_ADD, ERR_R_MALLOC_FAILURE);
 376                 X509_free(cert);
 377                 tlsa_free(t);
 378                 return -1;
 379             }
 380             break;
 381
 382         case DANETLS_SELECTOR_SPKI:
 383             if (!d2i_PUBKEY(&pkey, &p, ilen) || p < data ||
 384                 dlen != (size_t)(p - data)) {
 385                 tlsa_free(t);
 386                 SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_PUBLIC_KEY);
 387                 return 0;
 388             }
 389
 390             /*
 391              * For usage DANE-TA(2), we support authentication via "2 1 0" TLSA
 392              * records that contain full bare keys of trust-anchors that are
 393              * not present in the wire chain.
 394              */
 395             if (usage == DANETLS_USAGE_DANE_TA)
 396                 t->spki = pkey;
 397             else
 398                 EVP_PKEY_free(pkey);
 399             break;
 400         }
 401     }
 402
 403     /*-
 404      * Find the right insertion point for the new record.
 405      *
 406      * See crypto/x509/x509_vfy.c.  We sort DANE-EE(3) records first, so that
 407      * they can be processed first, as they require no chain building, and no
 408      * expiration or hostname checks.  Because DANE-EE(3) is numerically
 409      * largest, this is accomplished via descending sort by "usage".
 410      *
 411      * We also sort in descending order by matching ordinal to simplify
 412      * the implementation of digest agility in the verification code.
 413      *
 414      * The choice of order for the selector is not significant, so we
 415      * use the same descending order for consistency.
 416      */
 417     num = sk_danetls_record_num(dane->trecs);
 418     for (i = 0; i < num; ++i) {
 419         danetls_record *rec = sk_danetls_record_value(dane->trecs, i);
 420
 421         if (rec->usage > usage)
 422             continue;
 423         if (rec->usage < usage)
 424             break;
 425         if (rec->selector > selector)
 426             continue;
 427         if (rec->selector < selector)
 428             break;
 429         if (dane->dctx->mdord[rec->mtype] > dane->dctx->mdord[mtype])
 430             continue;
 431         break;
 432     }
 433
 434     if (!sk_danetls_record_insert(dane->trecs, t, i)) {
 435         tlsa_free(t);
 436         SSLerr(SSL_F_DANE_TLSA_ADD, ERR_R_MALLOC_FAILURE);
 437         return -1;
 438     }
 439     dane->umask |= DANETLS_USAGE_BIT(usage);
 440
 441     return 1;
 442 }
 443
 444 /*
 445  * Return 0 if there is only one version configured and it was disabled
 446  * at configure time.  Return 1 otherwise.
 447  */
 448 static int ssl_check_allowed_versions(int min_version, int max_version)
 449 {
 450     int minisdtls = 0, maxisdtls = 0;
 451
 452     /* Figure out if we're doing DTLS versions or TLS versions */
 453     if (min_version == DTLS1_BAD_VER
 454         || min_version >> 8 == DTLS1_VERSION_MAJOR)
 455         minisdtls = 1;
 456     if (max_version == DTLS1_BAD_VER
 457         || max_version >> 8 == DTLS1_VERSION_MAJOR)
 458         maxisdtls = 1;
 459     /* A wildcard version of 0 could be DTLS or TLS. */
 460     if ((minisdtls && !maxisdtls && max_version != 0)
 461         || (maxisdtls && !minisdtls && min_version != 0)) {
 462         /* Mixing DTLS and TLS versions will lead to sadness; deny it. */
 463         return 0;
 464     }
 465
 466     if (minisdtls || maxisdtls) {
 467         /* Do DTLS version checks. */
 468         if (min_version == 0)
 469             /* Ignore DTLS1_BAD_VER */
 470             min_version = DTLS1_VERSION;
 471         if (max_version == 0)
 472             max_version = DTLS1_2_VERSION;
 473 #ifdef OPENSSL_NO_DTLS1_2
 474         if (max_version == DTLS1_2_VERSION)
 475             max_version = DTLS1_VERSION;
 476 #endif
 477 #ifdef OPENSSL_NO_DTLS1
 478         if (min_version == DTLS1_VERSION)
 479             min_version = DTLS1_2_VERSION;
 480 #endif
 481         /* Done massaging versions; do the check. */
 482         if (0
 483 #ifdef OPENSSL_NO_DTLS1
 484             || (DTLS_VERSION_GE(min_version, DTLS1_VERSION)
 485                 && DTLS_VERSION_GE(DTLS1_VERSION, max_version))
 486 #endif
 487 #ifdef OPENSSL_NO_DTLS1_2
 488             || (DTLS_VERSION_GE(min_version, DTLS1_2_VERSION)
 489                 && DTLS_VERSION_GE(DTLS1_2_VERSION, max_version))
 490 #endif
 491             )
 492             return 0;
 493     } else {
 494         /* Regular TLS version checks. */
 495         if (min_version == 0)
 496             min_version = SSL3_VERSION;
 497         if (max_version == 0)
 498             max_version = TLS1_3_VERSION;
 499 #ifdef OPENSSL_NO_TLS1_3
 500         if (max_version == TLS1_3_VERSION)
 501             max_version = TLS1_2_VERSION;
 502 #endif
 503 #ifdef OPENSSL_NO_TLS1_2
 504         if (max_version == TLS1_2_VERSION)
 505             max_version = TLS1_1_VERSION;
 506 #endif
 507 #ifdef OPENSSL_NO_TLS1_1
 508         if (max_version == TLS1_1_VERSION)
 509             max_version = TLS1_VERSION;
 510 #endif
 511 #ifdef OPENSSL_NO_TLS1
 512         if (max_version == TLS1_VERSION)
 513             max_version = SSL3_VERSION;
 514 #endif
 515 #ifdef OPENSSL_NO_SSL3
 516         if (min_version == SSL3_VERSION)
 517             min_version = TLS1_VERSION;
 518 #endif
 519 #ifdef OPENSSL_NO_TLS1
 520         if (min_version == TLS1_VERSION)
 521             min_version = TLS1_1_VERSION;
 522 #endif
 523 #ifdef OPENSSL_NO_TLS1_1
 524         if (min_version == TLS1_1_VERSION)
 525             min_version = TLS1_2_VERSION;
 526 #endif
 527 #ifdef OPENSSL_NO_TLS1_2
 528         if (min_version == TLS1_2_VERSION)
 529             min_version = TLS1_3_VERSION;
 530 #endif
 531         /* Done massaging versions; do the check. */
 532         if (0
 533 #ifdef OPENSSL_NO_SSL3
 534             || (min_version <= SSL3_VERSION && SSL3_VERSION <= max_version)
 535 #endif
 536 #ifdef OPENSSL_NO_TLS1
 537             || (min_version <= TLS1_VERSION && TLS1_VERSION <= max_version)
 538 #endif
 539 #ifdef OPENSSL_NO_TLS1_1
 540             || (min_version <= TLS1_1_VERSION && TLS1_1_VERSION <= max_version)
 541 #endif
 542 #ifdef OPENSSL_NO_TLS1_2
 543             || (min_version <= TLS1_2_VERSION && TLS1_2_VERSION <= max_version)
 544 #endif
 545 #ifdef OPENSSL_NO_TLS1_3
 546             || (min_version <= TLS1_3_VERSION && TLS1_3_VERSION <= max_version)
 547 #endif
 548             )
 549             return 0;
 550     }
 551     return 1;
 552 }
 553
 554 #if defined(__TANDEM) && defined(OPENSSL_VPROC)
 555 /*
 556  * Define a VPROC function for HP NonStop build ssl library.
 557  * This is used by platform version identification tools.
 558  * Do not inline this procedure or make it static.
 559  */
 560 # define OPENSSL_VPROC_STRING_(x)    x##_SSL
 561 # define OPENSSL_VPROC_STRING(x)     OPENSSL_VPROC_STRING_(x)
 562 # define OPENSSL_VPROC_FUNC          OPENSSL_VPROC_STRING(OPENSSL_VPROC)
 563 void OPENSSL_VPROC_FUNC(void) {}
 564 #endif
 565
 566
 567 static void clear_ciphers(SSL *s)
 568 {
 569     /* clear the current cipher */
 570     ssl_clear_cipher_ctx(s);
 571     ssl_clear_hash_ctx(&s->read_hash);
 572     ssl_clear_hash_ctx(&s->write_hash);
 573 }
 574
 575 int SSL_clear(SSL *s)
 576 {
 577     if (s->method == NULL) {
 578         SSLerr(SSL_F_SSL_CLEAR, SSL_R_NO_METHOD_SPECIFIED);
 579         return 0;
 580     }
 581
 582     if (ssl_clear_bad_session(s)) {
 583         SSL_SESSION_free(s->session);
 584         s->session = NULL;
 585     }
 586     SSL_SESSION_free(s->psksession);
 587     s->psksession = NULL;
 588     OPENSSL_free(s->psksession_id);
 589     s->psksession_id = NULL;
 590     s->psksession_id_len = 0;
 591     s->hello_retry_request = 0;
 592     s->sent_tickets = 0;
 593
 594     s->error = 0;
 595     s->hit = 0;
 596     s->shutdown = 0;
 597
 598     if (s->renegotiate) {
 599         SSLerr(SSL_F_SSL_CLEAR, ERR_R_INTERNAL_ERROR);
 600         return 0;
 601     }
 602
 603     ossl_statem_clear(s);
 604
 605     s->version = s->method->version;
 606     s->client_version = s->version;
 607     s->rwstate = SSL_NOTHING;
 608
 609     BUF_MEM_free(s->init_buf);
 610     s->init_buf = NULL;
 611     clear_ciphers(s);
 612     s->first_packet = 0;
 613
 614     s->key_update = SSL_KEY_UPDATE_NONE;
 615
 616     EVP_MD_CTX_free(s->pha_dgst);
 617     s->pha_dgst = NULL;
 618
 619     /* Reset DANE verification result state */
 620     s->dane.mdpth = -1;
 621     s->dane.pdpth = -1;
 622     X509_free(s->dane.mcert);
 623     s->dane.mcert = NULL;
 624     s->dane.mtlsa = NULL;
 625
 626     /* Clear the verification result peername */
 627     X509_VERIFY_PARAM_move_peername(s->param, NULL);
 628
 629     /* Clear any shared connection state */
 630     OPENSSL_free(s->shared_sigalgs);
 631     s->shared_sigalgs = NULL;
 632     s->shared_sigalgslen = 0;
 633
 634     /*
 635      * Check to see if we were changed into a different method, if so, revert
 636      * back.
 637      */
 638     if (s->method != s->ctx->method) {
 639         s->method->ssl_free(s);
 640         s->method = s->ctx->method;
 641         if (!s->method->ssl_new(s))
 642             return 0;
 643     } else {
 644         if (!s->method->ssl_clear(s))
 645             return 0;
 646     }
 647
 648     RECORD_LAYER_clear(&s->rlayer);
 649
 650     return 1;
 651 }
 652
 653 #ifndef OPENSSL_NO_DEPRECATED_3_0
 654 /** Used to change an SSL_CTXs default SSL method type */
 655 int SSL_CTX_set_ssl_version(SSL_CTX *ctx, const SSL_METHOD *meth)
 656 {
 657     STACK_OF(SSL_CIPHER) *sk;
 658
 659     ctx->method = meth;
 660
 661     if (!SSL_CTX_set_ciphersuites(ctx, OSSL_default_ciphersuites())) {
 662         SSLerr(SSL_F_SSL_CTX_SET_SSL_VERSION, SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS);
 663         return 0;
 664     }
 665     sk = ssl_create_cipher_list(ctx->method,
 666                                 ctx->tls13_ciphersuites,
 667                                 &(ctx->cipher_list),
 668                                 &(ctx->cipher_list_by_id),
 669                                 OSSL_default_cipher_list(), ctx->cert);
 670     if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= 0)) {
 671         SSLerr(SSL_F_SSL_CTX_SET_SSL_VERSION, SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS);
 672         return 0;
 673     }
 674     return 1;
 675 }
 676 #endif
 677
 678 SSL *SSL_new(SSL_CTX *ctx)
 679 {
 680     SSL *s;
 681
 682     if (ctx == NULL) {
 683         SSLerr(SSL_F_SSL_NEW, SSL_R_NULL_SSL_CTX);
 684         return NULL;
 685     }
 686     if (ctx->method == NULL) {
 687         SSLerr(SSL_F_SSL_NEW, SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION);
 688         return NULL;
 689     }
 690
 691     s = OPENSSL_zalloc(sizeof(*s));
 692     if (s == NULL)
 693         goto err;
 694
 695     s->references = 1;
 696     s->lock = CRYPTO_THREAD_lock_new();
 697     if (s->lock == NULL) {
 698         OPENSSL_free(s);
 699         s = NULL;
 700         goto err;
 701     }
 702
 703     RECORD_LAYER_init(&s->rlayer, s);
 704
 705     s->options = ctx->options;
 706     s->dane.flags = ctx->dane.flags;
 707     s->min_proto_version = ctx->min_proto_version;
 708     s->max_proto_version = ctx->max_proto_version;
 709     s->mode = ctx->mode;
 710     s->max_cert_list = ctx->max_cert_list;
 711     s->max_early_data = ctx->max_early_data;
 712     s->recv_max_early_data = ctx->recv_max_early_data;
 713     s->num_tickets = ctx->num_tickets;
 714     s->pha_enabled = ctx->pha_enabled;
 715
 716     /* Shallow copy of the ciphersuites stack */
 717     s->tls13_ciphersuites = sk_SSL_CIPHER_dup(ctx->tls13_ciphersuites);
 718     if (s->tls13_ciphersuites == NULL)
 719         goto err;
 720
 721     /*
 722      * Earlier library versions used to copy the pointer to the CERT, not
 723      * its contents; only when setting new parameters for the per-SSL
 724      * copy, ssl_cert_new would be called (and the direct reference to
 725      * the per-SSL_CTX settings would be lost, but those still were
 726      * indirectly accessed for various purposes, and for that reason they
 727      * used to be known as s->ctx->default_cert). Now we don't look at the
 728      * SSL_CTX's CERT after having duplicated it once.
 729      */
 730     s->cert = ssl_cert_dup(ctx->cert);
 731     if (s->cert == NULL)
 732         goto err;
 733
 734     RECORD_LAYER_set_read_ahead(&s->rlayer, ctx->read_ahead);
 735     s->msg_callback = ctx->msg_callback;
 736     s->msg_callback_arg = ctx->msg_callback_arg;
 737     s->verify_mode = ctx->verify_mode;
 738     s->not_resumable_session_cb = ctx->not_resumable_session_cb;
 739     s->record_padding_cb = ctx->record_padding_cb;
 740     s->record_padding_arg = ctx->record_padding_arg;
 741     s->block_padding = ctx->block_padding;
 742     s->sid_ctx_length = ctx->sid_ctx_length;
 743     if (!ossl_assert(s->sid_ctx_length <= sizeof(s->sid_ctx)))
 744         goto err;
 745     memcpy(&s->sid_ctx, &ctx->sid_ctx, sizeof(s->sid_ctx));
 746     s->verify_callback = ctx->default_verify_callback;
 747     s->generate_session_id = ctx->generate_session_id;
 748
 749     s->param = X509_VERIFY_PARAM_new();
 750     if (s->param == NULL)
 751         goto err;
 752     X509_VERIFY_PARAM_inherit(s->param, ctx->param);
 753     s->quiet_shutdown = ctx->quiet_shutdown;
 754
 755     s->ext.max_fragment_len_mode = ctx->ext.max_fragment_len_mode;
 756     s->max_send_fragment = ctx->max_send_fragment;
 757     s->split_send_fragment = ctx->split_send_fragment;
 758     s->max_pipelines = ctx->max_pipelines;
 759     if (s->max_pipelines > 1)
 760         RECORD_LAYER_set_read_ahead(&s->rlayer, 1);
 761     if (ctx->default_read_buf_len > 0)
 762         SSL_set_default_read_buffer_len(s, ctx->default_read_buf_len);
 763
 764     SSL_CTX_up_ref(ctx);
 765     s->ctx = ctx;
 766     s->ext.debug_cb = 0;
 767     s->ext.debug_arg = NULL;
 768     s->ext.ticket_expected = 0;
 769     s->ext.status_type = ctx->ext.status_type;
 770     s->ext.status_expected = 0;
 771     s->ext.ocsp.ids = NULL;
 772     s->ext.ocsp.exts = NULL;
 773     s->ext.ocsp.resp = NULL;
 774     s->ext.ocsp.resp_len = 0;
 775     SSL_CTX_up_ref(ctx);
 776     s->session_ctx = ctx;
 777 #ifndef OPENSSL_NO_EC
 778     if (ctx->ext.ecpointformats) {
 779         s->ext.ecpointformats =
 780             OPENSSL_memdup(ctx->ext.ecpointformats,
 781                            ctx->ext.ecpointformats_len);
 782         if (!s->ext.ecpointformats)
 783             goto err;
 784         s->ext.ecpointformats_len =
 785             ctx->ext.ecpointformats_len;
 786     }
 787 #endif
 788     if (ctx->ext.supportedgroups) {
 789         s->ext.supportedgroups =
 790             OPENSSL_memdup(ctx->ext.supportedgroups,
 791                            ctx->ext.supportedgroups_len
 792                                 * sizeof(*ctx->ext.supportedgroups));
 793         if (!s->ext.supportedgroups)
 794             goto err;
 795         s->ext.supportedgroups_len = ctx->ext.supportedgroups_len;
 796     }
 797
 798 #ifndef OPENSSL_NO_NEXTPROTONEG
 799     s->ext.npn = NULL;
 800 #endif
 801
 802     if (s->ctx->ext.alpn) {
 803         s->ext.alpn = OPENSSL_malloc(s->ctx->ext.alpn_len);
 804         if (s->ext.alpn == NULL)
 805             goto err;
 806         memcpy(s->ext.alpn, s->ctx->ext.alpn, s->ctx->ext.alpn_len);
 807         s->ext.alpn_len = s->ctx->ext.alpn_len;
 808     }
 809
 810     s->verified_chain = NULL;
 811     s->verify_result = X509_V_OK;
 812
 813     s->default_passwd_callback = ctx->default_passwd_callback;
 814     s->default_passwd_callback_userdata = ctx->default_passwd_callback_userdata;
 815
 816     s->method = ctx->method;
 817
 818     s->key_update = SSL_KEY_UPDATE_NONE;
 819
 820     s->allow_early_data_cb = ctx->allow_early_data_cb;
 821     s->allow_early_data_cb_data = ctx->allow_early_data_cb_data;
 822
 823     if (!s->method->ssl_new(s))
 824         goto err;
 825
 826     s->server = (ctx->method->ssl_accept == ssl_undefined_function) ? 0 : 1;
 827
 828     if (!SSL_clear(s))
 829         goto err;
 830
 831     if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data))
 832         goto err;
 833
 834 #ifndef OPENSSL_NO_PSK
 835     s->psk_client_callback = ctx->psk_client_callback;
 836     s->psk_server_callback = ctx->psk_server_callback;
 837 #endif
 838     s->psk_find_session_cb = ctx->psk_find_session_cb;
 839     s->psk_use_session_cb = ctx->psk_use_session_cb;
 840
 841     s->async_cb = ctx->async_cb;
 842     s->async_cb_arg = ctx->async_cb_arg;
 843
 844     s->job = NULL;
 845
 846 #ifndef OPENSSL_NO_CT
 847     if (!SSL_set_ct_validation_callback(s, ctx->ct_validation_callback,
 848                                         ctx->ct_validation_callback_arg))
 849         goto err;
 850 #endif
 851
 852     return s;
 853  err:
 854     SSL_free(s);
 855     SSLerr(SSL_F_SSL_NEW, ERR_R_MALLOC_FAILURE);
 856     return NULL;
 857 }
 858
 859 int SSL_is_dtls(const SSL *s)
 860 {
 861     return SSL_IS_DTLS(s) ? 1 : 0;
 862 }
 863
 864 int SSL_up_ref(SSL *s)
 865 {
 866     int i;
 867
 868     if (CRYPTO_UP_REF(&s->references, &i, s->lock) <= 0)
 869         return 0;
 870
 871     REF_PRINT_COUNT("SSL", s);
 872     REF_ASSERT_ISNT(i < 2);
 873     return ((i > 1) ? 1 : 0);
 874 }
 875
 876 int SSL_CTX_set_session_id_context(SSL_CTX *ctx, const unsigned char *sid_ctx,
 877                                    unsigned int sid_ctx_len)
 878 {
 879     if (sid_ctx_len > SSL_MAX_SID_CTX_LENGTH) {
 880         SSLerr(SSL_F_SSL_CTX_SET_SESSION_ID_CONTEXT,
 881                SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
 882         return 0;
 883     }
 884     ctx->sid_ctx_length = sid_ctx_len;
 885     memcpy(ctx->sid_ctx, sid_ctx, sid_ctx_len);
 886
 887     return 1;
 888 }
 889
 890 int SSL_set_session_id_context(SSL *ssl, const unsigned char *sid_ctx,
 891                                unsigned int sid_ctx_len)
 892 {
 893     if (sid_ctx_len > SSL_MAX_SID_CTX_LENGTH) {
 894         SSLerr(SSL_F_SSL_SET_SESSION_ID_CONTEXT,
 895                SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
 896         return 0;
 897     }
 898     ssl->sid_ctx_length = sid_ctx_len;
 899     memcpy(ssl->sid_ctx, sid_ctx, sid_ctx_len);
 900
 901     return 1;
 902 }
 903
 904 int SSL_CTX_set_generate_session_id(SSL_CTX *ctx, GEN_SESSION_CB cb)
 905 {
 906     CRYPTO_THREAD_write_lock(ctx->lock);
 907     ctx->generate_session_id = cb;
 908     CRYPTO_THREAD_unlock(ctx->lock);
 909     return 1;
 910 }
 911
 912 int SSL_set_generate_session_id(SSL *ssl, GEN_SESSION_CB cb)
 913 {
 914     CRYPTO_THREAD_write_lock(ssl->lock);
 915     ssl->generate_session_id = cb;
 916     CRYPTO_THREAD_unlock(ssl->lock);
 917     return 1;
 918 }
 919
 920 int SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id,
 921                                 unsigned int id_len)
 922 {
 923     /*
 924      * A quick examination of SSL_SESSION_hash and SSL_SESSION_cmp shows how
 925      * we can "construct" a session to give us the desired check - i.e. to
 926      * find if there's a session in the hash table that would conflict with
 927      * any new session built out of this id/id_len and the ssl_version in use
 928      * by this SSL.
 929      */
 930     SSL_SESSION r, *p;
 931
 932     if (id_len > sizeof(r.session_id))
 933         return 0;
 934
 935     r.ssl_version = ssl->version;
 936     r.session_id_length = id_len;
 937     memcpy(r.session_id, id, id_len);
 938
 939     CRYPTO_THREAD_read_lock(ssl->session_ctx->lock);
 940     p = lh_SSL_SESSION_retrieve(ssl->session_ctx->sessions, &r);
 941     CRYPTO_THREAD_unlock(ssl->session_ctx->lock);
 942     return (p != NULL);
 943 }
 944
 945 int SSL_CTX_set_purpose(SSL_CTX *s, int purpose)
 946 {
 947     return X509_VERIFY_PARAM_set_purpose(s->param, purpose);
 948 }
 949
 950 int SSL_set_purpose(SSL *s, int purpose)
 951 {
 952     return X509_VERIFY_PARAM_set_purpose(s->param, purpose);
 953 }
 954
 955 int SSL_CTX_set_trust(SSL_CTX *s, int trust)
 956 {
 957     return X509_VERIFY_PARAM_set_trust(s->param, trust);
 958 }
 959
 960 int SSL_set_trust(SSL *s, int trust)
 961 {
 962     return X509_VERIFY_PARAM_set_trust(s->param, trust);
 963 }
 964
 965 int SSL_set1_host(SSL *s, const char *hostname)
 966 {
 967     /* If a hostname is provided and parses as an IP address,
 968      * treat it as such. */
 969     if (hostname && X509_VERIFY_PARAM_set1_ip_asc(s->param, hostname) == 1)
 970         return 1;
 971
 972     return X509_VERIFY_PARAM_set1_host(s->param, hostname, 0);
 973 }
 974
 975 int SSL_add1_host(SSL *s, const char *hostname)
 976 {
 977     /* If a hostname is provided and parses as an IP address,
 978      * treat it as such. */
 979     if (hostname)
 980     {
 981         ASN1_OCTET_STRING *ip;
 982         char *old_ip;
 983
 984         ip = a2i_IPADDRESS(hostname);
 985         if (ip) {
 986             /* We didn't want it; only to check if it *is* an IP address */
 987             ASN1_OCTET_STRING_free(ip);
 988
 989             old_ip = X509_VERIFY_PARAM_get1_ip_asc(s->param);
 990             if (old_ip)
 991             {
 992                 OPENSSL_free(old_ip);
 993                 /* There can be only one IP address */
 994                 return 0;
 995             }
 996
 997             return X509_VERIFY_PARAM_set1_ip_asc(s->param, hostname);
 998         }
 999     }
1000
1001     return X509_VERIFY_PARAM_add1_host(s->param, hostname, 0);
1002 }
1003
1004 void SSL_set_hostflags(SSL *s, unsigned int flags)
1005 {
1006     X509_VERIFY_PARAM_set_hostflags(s->param, flags);
1007 }
1008
1009 const char *SSL_get0_peername(SSL *s)
1010 {
1011     return X509_VERIFY_PARAM_get0_peername(s->param);
1012 }
1013
1014 int SSL_CTX_dane_enable(SSL_CTX *ctx)
1015 {
1016     return dane_ctx_enable(&ctx->dane);
1017 }
1018
1019 unsigned long SSL_CTX_dane_set_flags(SSL_CTX *ctx, unsigned long flags)
1020 {
1021     unsigned long orig = ctx->dane.flags;
1022
1023     ctx->dane.flags |= flags;
1024     return orig;
1025 }
1026
1027 unsigned long SSL_CTX_dane_clear_flags(SSL_CTX *ctx, unsigned long flags)
1028 {
1029     unsigned long orig = ctx->dane.flags;
1030
1031     ctx->dane.flags &= ~flags;
1032     return orig;
1033 }
1034
1035 int SSL_dane_enable(SSL *s, const char *basedomain)
1036 {
1037     SSL_DANE *dane = &s->dane;
1038
1039     if (s->ctx->dane.mdmax == 0) {
1040         SSLerr(SSL_F_SSL_DANE_ENABLE, SSL_R_CONTEXT_NOT_DANE_ENABLED);
1041         return 0;
1042     }
1043     if (dane->trecs != NULL) {
1044         SSLerr(SSL_F_SSL_DANE_ENABLE, SSL_R_DANE_ALREADY_ENABLED);
1045         return 0;
1046     }
1047
1048     /*
1049      * Default SNI name.  This rejects empty names, while set1_host below
1050      * accepts them and disables host name checks.  To avoid side-effects with
1051      * invalid input, set the SNI name first.
1052      */
1053     if (s->ext.hostname == NULL) {
1054         if (!SSL_set_tlsext_host_name(s, basedomain)) {
1055             SSLerr(SSL_F_SSL_DANE_ENABLE, SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN);
1056             return -1;
1057         }
1058     }
1059
1060     /* Primary RFC6125 reference identifier */
1061     if (!X509_VERIFY_PARAM_set1_host(s->param, basedomain, 0)) {
1062         SSLerr(SSL_F_SSL_DANE_ENABLE, SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN);
1063         return -1;
1064     }
1065
1066     dane->mdpth = -1;
1067     dane->pdpth = -1;
1068     dane->dctx = &s->ctx->dane;
1069     dane->trecs = sk_danetls_record_new_null();
1070
1071     if (dane->trecs == NULL) {
1072         SSLerr(SSL_F_SSL_DANE_ENABLE, ERR_R_MALLOC_FAILURE);
1073         return -1;
1074     }
1075     return 1;
1076 }
1077
1078 unsigned long SSL_dane_set_flags(SSL *ssl, unsigned long flags)
1079 {
1080     unsigned long orig = ssl->dane.flags;
1081
1082     ssl->dane.flags |= flags;
1083     return orig;
1084 }
1085
1086 unsigned long SSL_dane_clear_flags(SSL *ssl, unsigned long flags)
1087 {
1088     unsigned long orig = ssl->dane.flags;
1089
1090     ssl->dane.flags &= ~flags;
1091     return orig;
1092 }
1093
1094 int SSL_get0_dane_authority(SSL *s, X509 **mcert, EVP_PKEY **mspki)
1095 {
1096     SSL_DANE *dane = &s->dane;
1097
1098     if (!DANETLS_ENABLED(dane) || s->verify_result != X509_V_OK)
1099         return -1;
1100     if (dane->mtlsa) {
1101         if (mcert)
1102             *mcert = dane->mcert;
1103         if (mspki)
1104             *mspki = (dane->mcert == NULL) ? dane->mtlsa->spki : NULL;
1105     }
1106     return dane->mdpth;
1107 }
1108
1109 int SSL_get0_dane_tlsa(SSL *s, uint8_t *usage, uint8_t *selector,
1110                        uint8_t *mtype, unsigned const char **data, size_t *dlen)
1111 {
1112     SSL_DANE *dane = &s->dane;
1113
1114     if (!DANETLS_ENABLED(dane) || s->verify_result != X509_V_OK)
1115         return -1;
1116     if (dane->mtlsa) {
1117         if (usage)
1118             *usage = dane->mtlsa->usage;
1119         if (selector)
1120             *selector = dane->mtlsa->selector;
1121         if (mtype)
1122             *mtype = dane->mtlsa->mtype;
1123         if (data)
1124             *data = dane->mtlsa->data;
1125         if (dlen)
1126             *dlen = dane->mtlsa->dlen;
1127     }
1128     return dane->mdpth;
1129 }
1130
1131 SSL_DANE *SSL_get0_dane(SSL *s)
1132 {
1133     return &s->dane;
1134 }
1135
1136 int SSL_dane_tlsa_add(SSL *s, uint8_t usage, uint8_t selector,
1137                       uint8_t mtype, unsigned const char *data, size_t dlen)
1138 {
1139     return dane_tlsa_add(&s->dane, usage, selector, mtype, data, dlen);
1140 }
1141
1142 int SSL_CTX_dane_mtype_set(SSL_CTX *ctx, const EVP_MD *md, uint8_t mtype,
1143                            uint8_t ord)
1144 {
1145     return dane_mtype_set(&ctx->dane, md, mtype, ord);
1146 }
1147
1148 int SSL_CTX_set1_param(SSL_CTX *ctx, X509_VERIFY_PARAM *vpm)
1149 {
1150     return X509_VERIFY_PARAM_set1(ctx->param, vpm);
1151 }
1152
1153 int SSL_set1_param(SSL *ssl, X509_VERIFY_PARAM *vpm)
1154 {
1155     return X509_VERIFY_PARAM_set1(ssl->param, vpm);
1156 }
1157
1158 X509_VERIFY_PARAM *SSL_CTX_get0_param(SSL_CTX *ctx)
1159 {
1160     return ctx->param;
1161 }
1162
1163 X509_VERIFY_PARAM *SSL_get0_param(SSL *ssl)
1164 {
1165     return ssl->param;
1166 }
1167
1168 void SSL_certs_clear(SSL *s)
1169 {
1170     ssl_cert_clear_certs(s->cert);
1171 }
1172
1173 void SSL_free(SSL *s)
1174 {
1175     int i;
1176
1177     if (s == NULL)
1178         return;
1179     CRYPTO_DOWN_REF(&s->references, &i, s->lock);
1180     REF_PRINT_COUNT("SSL", s);
1181     if (i > 0)
1182         return;
1183     REF_ASSERT_ISNT(i < 0);
1184
1185     X509_VERIFY_PARAM_free(s->param);
1186     dane_final(&s->dane);
1187     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
1188
1189     RECORD_LAYER_release(&s->rlayer);
1190
1191     /* Ignore return value */
1192     ssl_free_wbio_buffer(s);
1193
1194     BIO_free_all(s->wbio);
1195     s->wbio = NULL;
1196     BIO_free_all(s->rbio);
1197     s->rbio = NULL;
1198
1199     BUF_MEM_free(s->init_buf);
1200
1201     /* add extra stuff */
1202     sk_SSL_CIPHER_free(s->cipher_list);
1203     sk_SSL_CIPHER_free(s->cipher_list_by_id);
1204     sk_SSL_CIPHER_free(s->tls13_ciphersuites);
1205     sk_SSL_CIPHER_free(s->peer_ciphers);
1206
1207     /* Make the next call work :-) */
1208     if (s->session != NULL) {
1209         ssl_clear_bad_session(s);
1210         SSL_SESSION_free(s->session);
1211     }
1212     SSL_SESSION_free(s->psksession);
1213     OPENSSL_free(s->psksession_id);
1214
1215     clear_ciphers(s);
1216
1217     ssl_cert_free(s->cert);
1218     OPENSSL_free(s->shared_sigalgs);
1219     /* Free up if allocated */
1220
1221     OPENSSL_free(s->ext.hostname);
1222     SSL_CTX_free(s->session_ctx);
1223 #ifndef OPENSSL_NO_EC
1224     OPENSSL_free(s->ext.ecpointformats);
1225     OPENSSL_free(s->ext.peer_ecpointformats);
1226 #endif                          /* OPENSSL_NO_EC */
1227     OPENSSL_free(s->ext.supportedgroups);
1228     OPENSSL_free(s->ext.peer_supportedgroups);
1229     sk_X509_EXTENSION_pop_free(s->ext.ocsp.exts, X509_EXTENSION_free);
1230 #ifndef OPENSSL_NO_OCSP
1231     sk_OCSP_RESPID_pop_free(s->ext.ocsp.ids, OCSP_RESPID_free);
1232 #endif
1233 #ifndef OPENSSL_NO_CT
1234     SCT_LIST_free(s->scts);
1235     OPENSSL_free(s->ext.scts);
1236 #endif
1237     OPENSSL_free(s->ext.ocsp.resp);
1238     OPENSSL_free(s->ext.alpn);
1239     OPENSSL_free(s->ext.tls13_cookie);
1240     if (s->clienthello != NULL)
1241         OPENSSL_free(s->clienthello->pre_proc_exts);
1242     OPENSSL_free(s->clienthello);
1243     OPENSSL_free(s->pha_context);
1244     EVP_MD_CTX_free(s->pha_dgst);
1245
1246     sk_X509_NAME_pop_free(s->ca_names, X509_NAME_free);
1247     sk_X509_NAME_pop_free(s->client_ca_names, X509_NAME_free);
1248
1249     sk_X509_pop_free(s->verified_chain, X509_free);
1250
1251     if (s->method != NULL)
1252         s->method->ssl_free(s);
1253
1254     SSL_CTX_free(s->ctx);
1255
1256     ASYNC_WAIT_CTX_free(s->waitctx);
1257
1258 #if !defined(OPENSSL_NO_NEXTPROTONEG)
1259     OPENSSL_free(s->ext.npn);
1260 #endif
1261
1262 #ifndef OPENSSL_NO_SRTP
1263     sk_SRTP_PROTECTION_PROFILE_free(s->srtp_profiles);
1264 #endif
1265
1266     CRYPTO_THREAD_lock_free(s->lock);
1267
1268     OPENSSL_free(s);
1269 }
1270
1271 void SSL_set0_rbio(SSL *s, BIO *rbio)
1272 {
1273     BIO_free_all(s->rbio);
1274     s->rbio = rbio;
1275 }
1276
1277 void SSL_set0_wbio(SSL *s, BIO *wbio)
1278 {
1279     /*
1280      * If the output buffering BIO is still in place, remove it
1281      */
1282     if (s->bbio != NULL)
1283         s->wbio = BIO_pop(s->wbio);
1284
1285     BIO_free_all(s->wbio);
1286     s->wbio = wbio;
1287
1288     /* Re-attach |bbio| to the new |wbio|. */
1289     if (s->bbio != NULL)
1290         s->wbio = BIO_push(s->bbio, s->wbio);
1291 }
1292
1293 void SSL_set_bio(SSL *s, BIO *rbio, BIO *wbio)
1294 {
1295     /*
1296      * For historical reasons, this function has many different cases in
1297      * ownership handling.
1298      */
1299
1300     /* If nothing has changed, do nothing */
1301     if (rbio == SSL_get_rbio(s) && wbio == SSL_get_wbio(s))
1302         return;
1303
1304     /*
1305      * If the two arguments are equal then one fewer reference is granted by the
1306      * caller than we want to take
1307      */
1308     if (rbio != NULL && rbio == wbio)
1309         BIO_up_ref(rbio);
1310
1311     /*
1312      * If only the wbio is changed only adopt one reference.
1313      */
1314     if (rbio == SSL_get_rbio(s)) {
1315         SSL_set0_wbio(s, wbio);
1316         return;
1317     }
1318     /*
1319      * There is an asymmetry here for historical reasons. If only the rbio is
1320      * changed AND the rbio and wbio were originally different, then we only
1321      * adopt one reference.
1322      */
1323     if (wbio == SSL_get_wbio(s) && SSL_get_rbio(s) != SSL_get_wbio(s)) {
1324         SSL_set0_rbio(s, rbio);
1325         return;
1326     }
1327
1328     /* Otherwise, adopt both references. */
1329     SSL_set0_rbio(s, rbio);
1330     SSL_set0_wbio(s, wbio);
1331 }
1332
1333 BIO *SSL_get_rbio(const SSL *s)
1334 {
1335     return s->rbio;
1336 }
1337
1338 BIO *SSL_get_wbio(const SSL *s)
1339 {
1340     if (s->bbio != NULL) {
1341         /*
1342          * If |bbio| is active, the true caller-configured BIO is its
1343          * |next_bio|.
1344          */
1345         return BIO_next(s->bbio);
1346     }
1347     return s->wbio;
1348 }
1349
1350 int SSL_get_fd(const SSL *s)
1351 {
1352     return SSL_get_rfd(s);
1353 }
1354
1355 int SSL_get_rfd(const SSL *s)
1356 {
1357     int ret = -1;
1358     BIO *b, *r;
1359
1360     b = SSL_get_rbio(s);
1361     r = BIO_find_type(b, BIO_TYPE_DESCRIPTOR);
1362     if (r != NULL)
1363         BIO_get_fd(r, &ret);
1364     return ret;
1365 }
1366
1367 int SSL_get_wfd(const SSL *s)
1368 {
1369     int ret = -1;
1370     BIO *b, *r;
1371
1372     b = SSL_get_wbio(s);
1373     r = BIO_find_type(b, BIO_TYPE_DESCRIPTOR);
1374     if (r != NULL)
1375         BIO_get_fd(r, &ret);
1376     return ret;
1377 }
1378
1379 #ifndef OPENSSL_NO_SOCK
1380 int SSL_set_fd(SSL *s, int fd)
1381 {
1382     int ret = 0;
1383     BIO *bio = NULL;
1384
1385     bio = BIO_new(BIO_s_socket());
1386
1387     if (bio == NULL) {
1388         SSLerr(SSL_F_SSL_SET_FD, ERR_R_BUF_LIB);
1389         goto err;
1390     }
1391     BIO_set_fd(bio, fd, BIO_NOCLOSE);
1392     SSL_set_bio(s, bio, bio);
1393 #ifndef OPENSSL_NO_KTLS
1394     /*
1395      * The new socket is created successfully regardless of ktls_enable.
1396      * ktls_enable doesn't change any functionality of the socket, except
1397      * changing the setsockopt to enable the processing of ktls_start.
1398      * Thus, it is not a problem to call it for non-TLS sockets.
1399      */
1400     ktls_enable(fd);
1401 #endif /* OPENSSL_NO_KTLS */
1402     ret = 1;
1403  err:
1404     return ret;
1405 }
1406
1407 int SSL_set_wfd(SSL *s, int fd)
1408 {
1409     BIO *rbio = SSL_get_rbio(s);
1410
1411     if (rbio == NULL || BIO_method_type(rbio) != BIO_TYPE_SOCKET
1412         || (int)BIO_get_fd(rbio, NULL) != fd) {
1413         BIO *bio = BIO_new(BIO_s_socket());
1414
1415         if (bio == NULL) {
1416             SSLerr(SSL_F_SSL_SET_WFD, ERR_R_BUF_LIB);
1417             return 0;
1418         }
1419         BIO_set_fd(bio, fd, BIO_NOCLOSE);
1420         SSL_set0_wbio(s, bio);
1421 #ifndef OPENSSL_NO_KTLS
1422         /*
1423          * The new socket is created successfully regardless of ktls_enable.
1424          * ktls_enable doesn't change any functionality of the socket, except
1425          * changing the setsockopt to enable the processing of ktls_start.
1426          * Thus, it is not a problem to call it for non-TLS sockets.
1427          */
1428         ktls_enable(fd);
1429 #endif /* OPENSSL_NO_KTLS */
1430     } else {
1431         BIO_up_ref(rbio);
1432         SSL_set0_wbio(s, rbio);
1433     }
1434     return 1;
1435 }
1436
1437 int SSL_set_rfd(SSL *s, int fd)
1438 {
1439     BIO *wbio = SSL_get_wbio(s);
1440
1441     if (wbio == NULL || BIO_method_type(wbio) != BIO_TYPE_SOCKET
1442         || ((int)BIO_get_fd(wbio, NULL) != fd)) {
1443         BIO *bio = BIO_new(BIO_s_socket());
1444
1445         if (bio == NULL) {
1446             SSLerr(SSL_F_SSL_SET_RFD, ERR_R_BUF_LIB);
1447             return 0;
1448         }
1449         BIO_set_fd(bio, fd, BIO_NOCLOSE);
1450         SSL_set0_rbio(s, bio);
1451     } else {
1452         BIO_up_ref(wbio);
1453         SSL_set0_rbio(s, wbio);
1454     }
1455
1456     return 1;
1457 }
1458 #endif
1459
1460 /* return length of latest Finished message we sent, copy to 'buf' */
1461 size_t SSL_get_finished(const SSL *s, void *buf, size_t count)
1462 {
1463     size_t ret = 0;
1464
1465     ret = s->s3.tmp.finish_md_len;
1466     if (count > ret)
1467         count = ret;
1468     memcpy(buf, s->s3.tmp.finish_md, count);
1469     return ret;
1470 }
1471
1472 /* return length of latest Finished message we expected, copy to 'buf' */
1473 size_t SSL_get_peer_finished(const SSL *s, void *buf, size_t count)
1474 {
1475     size_t ret = 0;
1476
1477     ret = s->s3.tmp.peer_finish_md_len;
1478     if (count > ret)
1479         count = ret;
1480     memcpy(buf, s->s3.tmp.peer_finish_md, count);
1481     return ret;
1482 }
1483
1484 int SSL_get_verify_mode(const SSL *s)
1485 {
1486     return s->verify_mode;
1487 }
1488
1489 int SSL_get_verify_depth(const SSL *s)
1490 {
1491     return X509_VERIFY_PARAM_get_depth(s->param);
1492 }
1493
1494 int (*SSL_get_verify_callback(const SSL *s)) (int, X509_STORE_CTX *) {
1495     return s->verify_callback;
1496 }
1497
1498 int SSL_CTX_get_verify_mode(const SSL_CTX *ctx)
1499 {
1500     return ctx->verify_mode;
1501 }
1502
1503 int SSL_CTX_get_verify_depth(const SSL_CTX *ctx)
1504 {
1505     return X509_VERIFY_PARAM_get_depth(ctx->param);
1506 }
1507
1508 int (*SSL_CTX_get_verify_callback(const SSL_CTX *ctx)) (int, X509_STORE_CTX *) {
1509     return ctx->default_verify_callback;
1510 }
1511
1512 void SSL_set_verify(SSL *s, int mode,
1513                     int (*callback) (int ok, X509_STORE_CTX *ctx))
1514 {
1515     s->verify_mode = mode;
1516     if (callback != NULL)
1517         s->verify_callback = callback;
1518 }
1519
1520 void SSL_set_verify_depth(SSL *s, int depth)
1521 {
1522     X509_VERIFY_PARAM_set_depth(s->param, depth);
1523 }
1524
1525 void SSL_set_read_ahead(SSL *s, int yes)
1526 {
1527     RECORD_LAYER_set_read_ahead(&s->rlayer, yes);
1528 }
1529
1530 int SSL_get_read_ahead(const SSL *s)
1531 {
1532     return RECORD_LAYER_get_read_ahead(&s->rlayer);
1533 }
1534
1535 int SSL_pending(const SSL *s)
1536 {
1537     size_t pending = s->method->ssl_pending(s);
1538
1539     /*
1540      * SSL_pending cannot work properly if read-ahead is enabled
1541      * (SSL_[CTX_]ctrl(..., SSL_CTRL_SET_READ_AHEAD, 1, NULL)), and it is
1542      * impossible to fix since SSL_pending cannot report errors that may be
1543      * observed while scanning the new data. (Note that SSL_pending() is
1544      * often used as a boolean value, so we'd better not return -1.)
1545      *
1546      * SSL_pending also cannot work properly if the value >INT_MAX. In that case
1547      * we just return INT_MAX.
1548      */
1549     return pending < INT_MAX ? (int)pending : INT_MAX;
1550 }
1551
1552 int SSL_has_pending(const SSL *s)
1553 {
1554     /*
1555      * Similar to SSL_pending() but returns a 1 to indicate that we have
1556      * unprocessed data available or 0 otherwise (as opposed to the number of
1557      * bytes available). Unlike SSL_pending() this will take into account
1558      * read_ahead data. A 1 return simply indicates that we have unprocessed
1559      * data. That data may not result in any application data, or we may fail
1560      * to parse the records for some reason.
1561      */
1562     if (RECORD_LAYER_processed_read_pending(&s->rlayer))
1563         return 1;
1564
1565     return RECORD_LAYER_read_pending(&s->rlayer);
1566 }
1567
1568 X509 *SSL_get1_peer_certificate(const SSL *s)
1569 {
1570     X509 *r = SSL_get0_peer_certificate(s);
1571
1572     if (r != NULL)
1573         X509_up_ref(r);
1574
1575     return r;
1576 }
1577
1578 X509 *SSL_get0_peer_certificate(const SSL *s)
1579 {
1580     if ((s == NULL) || (s->session == NULL))
1581         return NULL;
1582     else
1583         return s->session->peer;
1584 }
1585
1586 STACK_OF(X509) *SSL_get_peer_cert_chain(const SSL *s)
1587 {
1588     STACK_OF(X509) *r;
1589
1590     if ((s == NULL) || (s->session == NULL))
1591         r = NULL;
1592     else
1593         r = s->session->peer_chain;
1594
1595     /*
1596      * If we are a client, cert_chain includes the peer's own certificate; if
1597      * we are a server, it does not.
1598      */
1599
1600     return r;
1601 }
1602
1603 /*
1604  * Now in theory, since the calling process own 't' it should be safe to
1605  * modify.  We need to be able to read f without being hassled
1606  */
1607 int SSL_copy_session_id(SSL *t, const SSL *f)
1608 {
1609     int i;
1610     /* Do we need to to SSL locking? */
1611     if (!SSL_set_session(t, SSL_get_session(f))) {
1612         return 0;
1613     }
1614
1615     /*
1616      * what if we are setup for one protocol version but want to talk another
1617      */
1618     if (t->method != f->method) {
1619         t->method->ssl_free(t);
1620         t->method = f->method;
1621         if (t->method->ssl_new(t) == 0)
1622             return 0;
1623     }
1624
1625     CRYPTO_UP_REF(&f->cert->references, &i, f->cert->lock);
1626     ssl_cert_free(t->cert);
1627     t->cert = f->cert;
1628     if (!SSL_set_session_id_context(t, f->sid_ctx, (int)f->sid_ctx_length)) {
1629         return 0;
1630     }
1631
1632     return 1;
1633 }
1634
1635 /* Fix this so it checks all the valid key/cert options */
1636 int SSL_CTX_check_private_key(const SSL_CTX *ctx)
1637 {
1638     if ((ctx == NULL) || (ctx->cert->key->x509 == NULL)) {
1639         SSLerr(SSL_F_SSL_CTX_CHECK_PRIVATE_KEY, SSL_R_NO_CERTIFICATE_ASSIGNED);
1640         return 0;
1641     }
1642     if (ctx->cert->key->privatekey == NULL) {
1643         SSLerr(SSL_F_SSL_CTX_CHECK_PRIVATE_KEY, SSL_R_NO_PRIVATE_KEY_ASSIGNED);
1644         return 0;
1645     }
1646     return X509_check_private_key
1647             (ctx->cert->key->x509, ctx->cert->key->privatekey);
1648 }
1649
1650 /* Fix this function so that it takes an optional type parameter */
1651 int SSL_check_private_key(const SSL *ssl)
1652 {
1653     if (ssl == NULL) {
1654         SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY, ERR_R_PASSED_NULL_PARAMETER);
1655         return 0;
1656     }
1657     if (ssl->cert->key->x509 == NULL) {
1658         SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY, SSL_R_NO_CERTIFICATE_ASSIGNED);
1659         return 0;
1660     }
1661     if (ssl->cert->key->privatekey == NULL) {
1662         SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY, SSL_R_NO_PRIVATE_KEY_ASSIGNED);
1663         return 0;
1664     }
1665     return X509_check_private_key(ssl->cert->key->x509,
1666                                    ssl->cert->key->privatekey);
1667 }
1668
1669 int SSL_waiting_for_async(SSL *s)
1670 {
1671     if (s->job)
1672         return 1;
1673
1674     return 0;
1675 }
1676
1677 int SSL_get_all_async_fds(SSL *s, OSSL_ASYNC_FD *fds, size_t *numfds)
1678 {
1679     ASYNC_WAIT_CTX *ctx = s->waitctx;
1680
1681     if (ctx == NULL)
1682         return 0;
1683     return ASYNC_WAIT_CTX_get_all_fds(ctx, fds, numfds);
1684 }
1685
1686 int SSL_get_changed_async_fds(SSL *s, OSSL_ASYNC_FD *addfd, size_t *numaddfds,
1687                               OSSL_ASYNC_FD *delfd, size_t *numdelfds)
1688 {
1689     ASYNC_WAIT_CTX *ctx = s->waitctx;
1690
1691     if (ctx == NULL)
1692         return 0;
1693     return ASYNC_WAIT_CTX_get_changed_fds(ctx, addfd, numaddfds, delfd,
1694                                           numdelfds);
1695 }
1696
1697 int SSL_CTX_set_async_callback(SSL_CTX *ctx, SSL_async_callback_fn callback)
1698 {
1699     ctx->async_cb = callback;
1700     return 1;
1701 }
1702
1703 int SSL_CTX_set_async_callback_arg(SSL_CTX *ctx, void *arg)
1704 {
1705     ctx->async_cb_arg = arg;
1706     return 1;
1707 }
1708
1709 int SSL_set_async_callback(SSL *s, SSL_async_callback_fn callback)
1710 {
1711     s->async_cb = callback;
1712     return 1;
1713 }
1714
1715 int SSL_set_async_callback_arg(SSL *s, void *arg)
1716 {
1717     s->async_cb_arg = arg;
1718     return 1;
1719 }
1720
1721 int SSL_get_async_status(SSL *s, int *status)
1722 {
1723     ASYNC_WAIT_CTX *ctx = s->waitctx;
1724
1725     if (ctx == NULL)
1726         return 0;
1727     *status = ASYNC_WAIT_CTX_get_status(ctx);
1728     return 1;
1729 }
1730
1731 int SSL_accept(SSL *s)
1732 {
1733     if (s->handshake_func == NULL) {
1734         /* Not properly initialized yet */
1735         SSL_set_accept_state(s);
1736     }
1737
1738     return SSL_do_handshake(s);
1739 }
1740
1741 int SSL_connect(SSL *s)
1742 {
1743     if (s->handshake_func == NULL) {
1744         /* Not properly initialized yet */
1745         SSL_set_connect_state(s);
1746     }
1747
1748     return SSL_do_handshake(s);
1749 }
1750
1751 long SSL_get_default_timeout(const SSL *s)
1752 {
1753     return s->method->get_timeout();
1754 }
1755
1756 static int ssl_async_wait_ctx_cb(void *arg)
1757 {
1758     SSL *s = (SSL *)arg;
1759
1760     return s->async_cb(s, s->async_cb_arg);
1761 }
1762
1763 static int ssl_start_async_job(SSL *s, struct ssl_async_args *args,
1764                                int (*func) (void *))
1765 {
1766     int ret;
1767     if (s->waitctx == NULL) {
1768         s->waitctx = ASYNC_WAIT_CTX_new();
1769         if (s->waitctx == NULL)
1770             return -1;
1771         if (s->async_cb != NULL
1772             && !ASYNC_WAIT_CTX_set_callback
1773                  (s->waitctx, ssl_async_wait_ctx_cb, s))
1774             return -1;
1775     }
1776     switch (ASYNC_start_job(&s->job, s->waitctx, &ret, func, args,
1777                             sizeof(struct ssl_async_args))) {
1778     case ASYNC_ERR:
1779         s->rwstate = SSL_NOTHING;
1780         SSLerr(SSL_F_SSL_START_ASYNC_JOB, SSL_R_FAILED_TO_INIT_ASYNC);
1781         return -1;
1782     case ASYNC_PAUSE:
1783         s->rwstate = SSL_ASYNC_PAUSED;
1784         return -1;
1785     case ASYNC_NO_JOBS:
1786         s->rwstate = SSL_ASYNC_NO_JOBS;
1787         return -1;
1788     case ASYNC_FINISH:
1789         s->job = NULL;
1790         return ret;
1791     default:
1792         s->rwstate = SSL_NOTHING;
1793         SSLerr(SSL_F_SSL_START_ASYNC_JOB, ERR_R_INTERNAL_ERROR);
1794         /* Shouldn't happen */
1795         return -1;
1796     }
1797 }
1798
1799 static int ssl_io_intern(void *vargs)
1800 {
1801     struct ssl_async_args *args;
1802     SSL *s;
1803     void *buf;
1804     size_t num;
1805
1806     args = (struct ssl_async_args *)vargs;
1807     s = args->s;
1808     buf = args->buf;
1809     num = args->num;
1810     switch (args->type) {
1811     case READFUNC:
1812         return args->f.func_read(s, buf, num, &s->asyncrw);
1813     case WRITEFUNC:
1814         return args->f.func_write(s, buf, num, &s->asyncrw);
1815     case OTHERFUNC:
1816         return args->f.func_other(s);
1817     }
1818     return -1;
1819 }
1820
1821 int ssl_read_internal(SSL *s, void *buf, size_t num, size_t *readbytes)
1822 {
1823     if (s->handshake_func == NULL) {
1824         SSLerr(SSL_F_SSL_READ_INTERNAL, SSL_R_UNINITIALIZED);
1825         return -1;
1826     }
1827
1828     if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
1829         s->rwstate = SSL_NOTHING;
1830         return 0;
1831     }
1832
1833     if (s->early_data_state == SSL_EARLY_DATA_CONNECT_RETRY
1834                 || s->early_data_state == SSL_EARLY_DATA_ACCEPT_RETRY) {
1835         SSLerr(SSL_F_SSL_READ_INTERNAL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
1836         return 0;
1837     }
1838     /*
1839      * If we are a client and haven't received the ServerHello etc then we
1840      * better do that
1841      */
1842     ossl_statem_check_finish_init(s, 0);
1843
1844     if ((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
1845         struct ssl_async_args args;
1846         int ret;
1847
1848         args.s = s;
1849         args.buf = buf;
1850         args.num = num;
1851         args.type = READFUNC;
1852         args.f.func_read = s->method->ssl_read;
1853
1854         ret = ssl_start_async_job(s, &args, ssl_io_intern);
1855         *readbytes = s->asyncrw;
1856         return ret;
1857     } else {
1858         return s->method->ssl_read(s, buf, num, readbytes);
1859     }
1860 }
1861
1862 int SSL_read(SSL *s, void *buf, int num)
1863 {
1864     int ret;
1865     size_t readbytes;
1866
1867     if (num < 0) {
1868         SSLerr(SSL_F_SSL_READ, SSL_R_BAD_LENGTH);
1869         return -1;
1870     }
1871
1872     ret = ssl_read_internal(s, buf, (size_t)num, &readbytes);
1873
1874     /*
1875      * The cast is safe here because ret should be <= INT_MAX because num is
1876      * <= INT_MAX
1877      */
1878     if (ret > 0)
1879         ret = (int)readbytes;
1880
1881     return ret;
1882 }
1883
1884 int SSL_read_ex(SSL *s, void *buf, size_t num, size_t *readbytes)
1885 {
1886     int ret = ssl_read_internal(s, buf, num, readbytes);
1887
1888     if (ret < 0)
1889         ret = 0;
1890     return ret;
1891 }
1892
1893 int SSL_read_early_data(SSL *s, void *buf, size_t num, size_t *readbytes)
1894 {
1895     int ret;
1896
1897     if (!s->server) {
1898         SSLerr(SSL_F_SSL_READ_EARLY_DATA, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
1899         return SSL_READ_EARLY_DATA_ERROR;
1900     }
1901
1902     switch (s->early_data_state) {
1903     case SSL_EARLY_DATA_NONE:
1904         if (!SSL_in_before(s)) {
1905             SSLerr(SSL_F_SSL_READ_EARLY_DATA,
1906                    ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
1907             return SSL_READ_EARLY_DATA_ERROR;
1908         }
1909         /* fall through */
1910
1911     case SSL_EARLY_DATA_ACCEPT_RETRY:
1912         s->early_data_state = SSL_EARLY_DATA_ACCEPTING;
1913         ret = SSL_accept(s);
1914         if (ret <= 0) {
1915             /* NBIO or error */
1916             s->early_data_state = SSL_EARLY_DATA_ACCEPT_RETRY;
1917             return SSL_READ_EARLY_DATA_ERROR;
1918         }
1919         /* fall through */
1920
1921     case SSL_EARLY_DATA_READ_RETRY:
1922         if (s->ext.early_data == SSL_EARLY_DATA_ACCEPTED) {
1923             s->early_data_state = SSL_EARLY_DATA_READING;
1924             ret = SSL_read_ex(s, buf, num, readbytes);
1925             /*
1926              * State machine will update early_data_state to
1927              * SSL_EARLY_DATA_FINISHED_READING if we get an EndOfEarlyData
1928              * message
1929              */
1930             if (ret > 0 || (ret <= 0 && s->early_data_state
1931                                         != SSL_EARLY_DATA_FINISHED_READING)) {
1932                 s->early_data_state = SSL_EARLY_DATA_READ_RETRY;
1933                 return ret > 0 ? SSL_READ_EARLY_DATA_SUCCESS
1934                                : SSL_READ_EARLY_DATA_ERROR;
1935             }
1936         } else {
1937             s->early_data_state = SSL_EARLY_DATA_FINISHED_READING;
1938         }
1939         *readbytes = 0;
1940         return SSL_READ_EARLY_DATA_FINISH;
1941
1942     default:
1943         SSLerr(SSL_F_SSL_READ_EARLY_DATA, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
1944         return SSL_READ_EARLY_DATA_ERROR;
1945     }
1946 }
1947
1948 int SSL_get_early_data_status(const SSL *s)
1949 {
1950     return s->ext.early_data;
1951 }
1952
1953 static int ssl_peek_internal(SSL *s, void *buf, size_t num, size_t *readbytes)
1954 {
1955     if (s->handshake_func == NULL) {
1956         SSLerr(SSL_F_SSL_PEEK_INTERNAL, SSL_R_UNINITIALIZED);
1957         return -1;
1958     }
1959
1960     if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
1961         return 0;
1962     }
1963     if ((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
1964         struct ssl_async_args args;
1965         int ret;
1966
1967         args.s = s;
1968         args.buf = buf;
1969         args.num = num;
1970         args.type = READFUNC;
1971         args.f.func_read = s->method->ssl_peek;
1972
1973         ret = ssl_start_async_job(s, &args, ssl_io_intern);
1974         *readbytes = s->asyncrw;
1975         return ret;
1976     } else {
1977         return s->method->ssl_peek(s, buf, num, readbytes);
1978     }
1979 }
1980
1981 int SSL_peek(SSL *s, void *buf, int num)
1982 {
1983     int ret;
1984     size_t readbytes;
1985
1986     if (num < 0) {
1987         SSLerr(SSL_F_SSL_PEEK, SSL_R_BAD_LENGTH);
1988         return -1;
1989     }
1990
1991     ret = ssl_peek_internal(s, buf, (size_t)num, &readbytes);
1992
1993     /*
1994      * The cast is safe here because ret should be <= INT_MAX because num is
1995      * <= INT_MAX
1996      */
1997     if (ret > 0)
1998         ret = (int)readbytes;
1999
2000     return ret;
2001 }
2002
2003
2004 int SSL_peek_ex(SSL *s, void *buf, size_t num, size_t *readbytes)
2005 {
2006     int ret = ssl_peek_internal(s, buf, num, readbytes);
2007
2008     if (ret < 0)
2009         ret = 0;
2010     return ret;
2011 }
2012
2013 int ssl_write_internal(SSL *s, const void *buf, size_t num, size_t *written)
2014 {
2015     if (s->handshake_func == NULL) {
2016         SSLerr(SSL_F_SSL_WRITE_INTERNAL, SSL_R_UNINITIALIZED);
2017         return -1;
2018     }
2019
2020     if (s->shutdown & SSL_SENT_SHUTDOWN) {
2021         s->rwstate = SSL_NOTHING;
2022         SSLerr(SSL_F_SSL_WRITE_INTERNAL, SSL_R_PROTOCOL_IS_SHUTDOWN);
2023         return -1;
2024     }
2025
2026     if (s->early_data_state == SSL_EARLY_DATA_CONNECT_RETRY
2027                 || s->early_data_state == SSL_EARLY_DATA_ACCEPT_RETRY
2028                 || s->early_data_state == SSL_EARLY_DATA_READ_RETRY) {
2029         SSLerr(SSL_F_SSL_WRITE_INTERNAL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
2030         return 0;
2031     }
2032     /* If we are a client and haven't sent the Finished we better do that */
2033     ossl_statem_check_finish_init(s, 1);
2034
2035     if ((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
2036         int ret;
2037         struct ssl_async_args args;
2038
2039         args.s = s;
2040         args.buf = (void *)buf;
2041         args.num = num;
2042         args.type = WRITEFUNC;
2043         args.f.func_write = s->method->ssl_write;
2044
2045         ret = ssl_start_async_job(s, &args, ssl_io_intern);
2046         *written = s->asyncrw;
2047         return ret;
2048     } else {
2049         return s->method->ssl_write(s, buf, num, written);
2050     }
2051 }
2052
2053 ossl_ssize_t SSL_sendfile(SSL *s, int fd, off_t offset, size_t size, int flags)
2054 {
2055     ossl_ssize_t ret;
2056
2057     if (s->handshake_func == NULL) {
2058         SSLerr(SSL_F_SSL_SENDFILE, SSL_R_UNINITIALIZED);
2059         return -1;
2060     }
2061
2062     if (s->shutdown & SSL_SENT_SHUTDOWN) {
2063         s->rwstate = SSL_NOTHING;
2064         SSLerr(SSL_F_SSL_SENDFILE, SSL_R_PROTOCOL_IS_SHUTDOWN);
2065         return -1;
2066     }
2067
2068     if (!BIO_get_ktls_send(s->wbio)) {
2069         SSLerr(SSL_F_SSL_SENDFILE, SSL_R_UNINITIALIZED);
2070         return -1;
2071     }
2072
2073     /* If we have an alert to send, lets send it */
2074     if (s->s3.alert_dispatch) {
2075         ret = (ossl_ssize_t)s->method->ssl_dispatch_alert(s);
2076         if (ret <= 0) {
2077             /* SSLfatal() already called if appropriate */
2078             return ret;
2079         }
2080         /* if it went, fall through and send more stuff */
2081     }
2082
2083     s->rwstate = SSL_WRITING;
2084     if (BIO_flush(s->wbio) <= 0) {
2085         if (!BIO_should_retry(s->wbio)) {
2086             s->rwstate = SSL_NOTHING;
2087         } else {
2088 #ifdef EAGAIN
2089             set_sys_error(EAGAIN);
2090 #endif
2091         }
2092         return -1;
2093     }
2094
2095 #ifdef OPENSSL_NO_KTLS
2096     ERR_raise_data(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR,
2097                    "can't call ktls_sendfile(), ktls disabled");
2098     return -1;
2099 #else
2100     ret = ktls_sendfile(SSL_get_wfd(s), fd, offset, size, flags);
2101     if (ret < 0) {
2102 #if defined(EAGAIN) && defined(EINTR) && defined(EBUSY)
2103         if ((get_last_sys_error() == EAGAIN) ||
2104             (get_last_sys_error() == EINTR) ||
2105             (get_last_sys_error() == EBUSY))
2106             BIO_set_retry_write(s->wbio);
2107         else
2108 #endif
2109             SSLerr(SSL_F_SSL_SENDFILE, SSL_R_UNINITIALIZED);
2110         return ret;
2111     }
2112     s->rwstate = SSL_NOTHING;
2113     return ret;
2114 #endif
2115 }
2116
2117 int SSL_write(SSL *s, const void *buf, int num)
2118 {
2119     int ret;
2120     size_t written;
2121
2122     if (num < 0) {
2123         SSLerr(SSL_F_SSL_WRITE, SSL_R_BAD_LENGTH);
2124         return -1;
2125     }
2126
2127     ret = ssl_write_internal(s, buf, (size_t)num, &written);
2128
2129     /*
2130      * The cast is safe here because ret should be <= INT_MAX because num is
2131      * <= INT_MAX
2132      */
2133     if (ret > 0)
2134         ret = (int)written;
2135
2136     return ret;
2137 }
2138
2139 int SSL_write_ex(SSL *s, const void *buf, size_t num, size_t *written)
2140 {
2141     int ret = ssl_write_internal(s, buf, num, written);
2142
2143     if (ret < 0)
2144         ret = 0;
2145     return ret;
2146 }
2147
2148 int SSL_write_early_data(SSL *s, const void *buf, size_t num, size_t *written)
2149 {
2150     int ret, early_data_state;
2151     size_t writtmp;
2152     uint32_t partialwrite;
2153
2154     switch (s->early_data_state) {
2155     case SSL_EARLY_DATA_NONE:
2156         if (s->server
2157                 || !SSL_in_before(s)
2158                 || ((s->session == NULL || s->session->ext.max_early_data == 0)
2159                      && (s->psk_use_session_cb == NULL))) {
2160             SSLerr(SSL_F_SSL_WRITE_EARLY_DATA,
2161                    ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
2162             return 0;
2163         }
2164         /* fall through */
2165
2166     case SSL_EARLY_DATA_CONNECT_RETRY:
2167         s->early_data_state = SSL_EARLY_DATA_CONNECTING;
2168         ret = SSL_connect(s);
2169         if (ret <= 0) {
2170             /* NBIO or error */
2171             s->early_data_state = SSL_EARLY_DATA_CONNECT_RETRY;
2172             return 0;
2173         }
2174         /* fall through */
2175
2176     case SSL_EARLY_DATA_WRITE_RETRY:
2177         s->early_data_state = SSL_EARLY_DATA_WRITING;
2178         /*
2179          * We disable partial write for early data because we don't keep track
2180          * of how many bytes we've written between the SSL_write_ex() call and
2181          * the flush if the flush needs to be retried)
2182          */
2183         partialwrite = s->mode & SSL_MODE_ENABLE_PARTIAL_WRITE;
2184         s->mode &= ~SSL_MODE_ENABLE_PARTIAL_WRITE;
2185         ret = SSL_write_ex(s, buf, num, &writtmp);
2186         s->mode |= partialwrite;
2187         if (!ret) {
2188             s->early_data_state = SSL_EARLY_DATA_WRITE_RETRY;
2189             return ret;
2190         }
2191         s->early_data_state = SSL_EARLY_DATA_WRITE_FLUSH;
2192         /* fall through */
2193
2194     case SSL_EARLY_DATA_WRITE_FLUSH:
2195         /* The buffering BIO is still in place so we need to flush it */
2196         if (statem_flush(s) != 1)
2197             return 0;
2198         *written = num;
2199         s->early_data_state = SSL_EARLY_DATA_WRITE_RETRY;
2200         return 1;
2201
2202     case SSL_EARLY_DATA_FINISHED_READING:
2203     case SSL_EARLY_DATA_READ_RETRY:
2204         early_data_state = s->early_data_state;
2205         /* We are a server writing to an unauthenticated client */
2206         s->early_data_state = SSL_EARLY_DATA_UNAUTH_WRITING;
2207         ret = SSL_write_ex(s, buf, num, written);
2208         /* The buffering BIO is still in place */
2209         if (ret)
2210             (void)BIO_flush(s->wbio);
2211         s->early_data_state = early_data_state;
2212         return ret;
2213
2214     default:
2215         SSLerr(SSL_F_SSL_WRITE_EARLY_DATA, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
2216         return 0;
2217     }
2218 }
2219
2220 int SSL_shutdown(SSL *s)
2221 {
2222     /*
2223      * Note that this function behaves differently from what one might
2224      * expect.  Return values are 0 for no success (yet), 1 for success; but
2225      * calling it once is usually not enough, even if blocking I/O is used
2226      * (see ssl3_shutdown).
2227      */
2228
2229     if (s->handshake_func == NULL) {
2230         SSLerr(SSL_F_SSL_SHUTDOWN, SSL_R_UNINITIALIZED);
2231         return -1;
2232     }
2233
2234     if (!SSL_in_init(s)) {
2235         if ((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
2236             struct ssl_async_args args;
2237
2238             args.s = s;
2239             args.type = OTHERFUNC;
2240             args.f.func_other = s->method->ssl_shutdown;
2241
2242             return ssl_start_async_job(s, &args, ssl_io_intern);
2243         } else {
2244             return s->method->ssl_shutdown(s);
2245         }
2246     } else {
2247         SSLerr(SSL_F_SSL_SHUTDOWN, SSL_R_SHUTDOWN_WHILE_IN_INIT);
2248         return -1;
2249     }
2250 }
2251
2252 int SSL_key_update(SSL *s, int updatetype)
2253 {
2254     /*
2255      * TODO(TLS1.3): How will applications know whether TLSv1.3 has been
2256      * negotiated, and that it is appropriate to call SSL_key_update() instead
2257      * of SSL_renegotiate().
2258      */
2259     if (!SSL_IS_TLS13(s)) {
2260         SSLerr(SSL_F_SSL_KEY_UPDATE, SSL_R_WRONG_SSL_VERSION);
2261         return 0;
2262     }
2263
2264     if (updatetype != SSL_KEY_UPDATE_NOT_REQUESTED
2265             && updatetype != SSL_KEY_UPDATE_REQUESTED) {
2266         SSLerr(SSL_F_SSL_KEY_UPDATE, SSL_R_INVALID_KEY_UPDATE_TYPE);
2267         return 0;
2268     }
2269
2270     if (!SSL_is_init_finished(s)) {
2271         SSLerr(SSL_F_SSL_KEY_UPDATE, SSL_R_STILL_IN_INIT);
2272         return 0;
2273     }
2274
2275     ossl_statem_set_in_init(s, 1);
2276     s->key_update = updatetype;
2277     return 1;
2278 }
2279
2280 int SSL_get_key_update_type(const SSL *s)
2281 {
2282     return s->key_update;
2283 }
2284
2285 int SSL_renegotiate(SSL *s)
2286 {
2287     if (SSL_IS_TLS13(s)) {
2288         SSLerr(SSL_F_SSL_RENEGOTIATE, SSL_R_WRONG_SSL_VERSION);
2289         return 0;
2290     }
2291
2292     if ((s->options & SSL_OP_NO_RENEGOTIATION)) {
2293         SSLerr(SSL_F_SSL_RENEGOTIATE, SSL_R_NO_RENEGOTIATION);
2294         return 0;
2295     }
2296
2297     s->renegotiate = 1;
2298     s->new_session = 1;
2299
2300     return s->method->ssl_renegotiate(s);
2301 }
2302
2303 int SSL_renegotiate_abbreviated(SSL *s)
2304 {
2305     if (SSL_IS_TLS13(s)) {
2306         SSLerr(SSL_F_SSL_RENEGOTIATE_ABBREVIATED, SSL_R_WRONG_SSL_VERSION);
2307         return 0;
2308     }
2309
2310     if ((s->options & SSL_OP_NO_RENEGOTIATION)) {
2311         SSLerr(SSL_F_SSL_RENEGOTIATE_ABBREVIATED, SSL_R_NO_RENEGOTIATION);
2312         return 0;
2313     }
2314
2315     s->renegotiate = 1;
2316     s->new_session = 0;
2317
2318     return s->method->ssl_renegotiate(s);
2319 }
2320
2321 int SSL_renegotiate_pending(const SSL *s)
2322 {
2323     /*
2324      * becomes true when negotiation is requested; false again once a
2325      * handshake has finished
2326      */
2327     return (s->renegotiate != 0);
2328 }
2329
2330 int SSL_new_session_ticket(SSL *s)
2331 {
2332     if (SSL_in_init(s) || SSL_IS_FIRST_HANDSHAKE(s) || !s->server
2333             || !SSL_IS_TLS13(s))
2334         return 0;
2335     s->ext.extra_tickets_expected++;
2336     return 1;
2337 }
2338
2339 long SSL_ctrl(SSL *s, int cmd, long larg, void *parg)
2340 {
2341     long l;
2342
2343     switch (cmd) {
2344     case SSL_CTRL_GET_READ_AHEAD:
2345         return RECORD_LAYER_get_read_ahead(&s->rlayer);
2346     case SSL_CTRL_SET_READ_AHEAD:
2347         l = RECORD_LAYER_get_read_ahead(&s->rlayer);
2348         RECORD_LAYER_set_read_ahead(&s->rlayer, larg);
2349         return l;
2350
2351     case SSL_CTRL_SET_MSG_CALLBACK_ARG:
2352         s->msg_callback_arg = parg;
2353         return 1;
2354
2355     case SSL_CTRL_MODE:
2356         return (s->mode |= larg);
2357     case SSL_CTRL_CLEAR_MODE:
2358         return (s->mode &= ~larg);
2359     case SSL_CTRL_GET_MAX_CERT_LIST:
2360         return (long)s->max_cert_list;
2361     case SSL_CTRL_SET_MAX_CERT_LIST:
2362         if (larg < 0)
2363             return 0;
2364         l = (long)s->max_cert_list;
2365         s->max_cert_list = (size_t)larg;
2366         return l;
2367     case SSL_CTRL_SET_MAX_SEND_FRAGMENT:
2368         if (larg < 512 || larg > SSL3_RT_MAX_PLAIN_LENGTH)
2369             return 0;
2370 #ifndef OPENSSL_NO_KTLS
2371         if (s->wbio != NULL && BIO_get_ktls_send(s->wbio))
2372             return 0;
2373 #endif /* OPENSSL_NO_KTLS */
2374         s->max_send_fragment = larg;
2375         if (s->max_send_fragment < s->split_send_fragment)
2376             s->split_send_fragment = s->max_send_fragment;
2377         return 1;
2378     case SSL_CTRL_SET_SPLIT_SEND_FRAGMENT:
2379         if ((size_t)larg > s->max_send_fragment || larg == 0)
2380             return 0;
2381         s->split_send_fragment = larg;
2382         return 1;
2383     case SSL_CTRL_SET_MAX_PIPELINES:
2384         if (larg < 1 || larg > SSL_MAX_PIPELINES)
2385             return 0;
2386         s->max_pipelines = larg;
2387         if (larg > 1)
2388             RECORD_LAYER_set_read_ahead(&s->rlayer, 1);
2389         return 1;
2390     case SSL_CTRL_GET_RI_SUPPORT:
2391         return s->s3.send_connection_binding;
2392     case SSL_CTRL_CERT_FLAGS:
2393         return (s->cert->cert_flags |= larg);
2394     case SSL_CTRL_CLEAR_CERT_FLAGS:
2395         return (s->cert->cert_flags &= ~larg);
2396
2397     case SSL_CTRL_GET_RAW_CIPHERLIST:
2398         if (parg) {
2399             if (s->s3.tmp.ciphers_raw == NULL)
2400                 return 0;
2401             *(unsigned char **)parg = s->s3.tmp.ciphers_raw;
2402             return (int)s->s3.tmp.ciphers_rawlen;
2403         } else {
2404             return TLS_CIPHER_LEN;
2405         }
2406     case SSL_CTRL_GET_EXTMS_SUPPORT:
2407         if (!s->session || SSL_in_init(s) || ossl_statem_get_in_handshake(s))
2408             return -1;
2409         if (s->session->flags & SSL_SESS_FLAG_EXTMS)
2410             return 1;
2411         else
2412             return 0;
2413     case SSL_CTRL_SET_MIN_PROTO_VERSION:
2414         return ssl_check_allowed_versions(larg, s->max_proto_version)
2415                && ssl_set_version_bound(s->ctx->method->version, (int)larg,
2416                                         &s->min_proto_version);
2417     case SSL_CTRL_GET_MIN_PROTO_VERSION:
2418         return s->min_proto_version;
2419     case SSL_CTRL_SET_MAX_PROTO_VERSION:
2420         return ssl_check_allowed_versions(s->min_proto_version, larg)
2421                && ssl_set_version_bound(s->ctx->method->version, (int)larg,
2422                                         &s->max_proto_version);
2423     case SSL_CTRL_GET_MAX_PROTO_VERSION:
2424         return s->max_proto_version;
2425     default:
2426         return s->method->ssl_ctrl(s, cmd, larg, parg);
2427     }
2428 }
2429
2430 long SSL_callback_ctrl(SSL *s, int cmd, void (*fp) (void))
2431 {
2432     switch (cmd) {
2433     case SSL_CTRL_SET_MSG_CALLBACK:
2434         s->msg_callback = (void (*)
2435                            (int write_p, int version, int content_type,
2436                             const void *buf, size_t len, SSL *ssl,
2437                             void *arg))(fp);
2438         return 1;
2439
2440     default:
2441         return s->method->ssl_callback_ctrl(s, cmd, fp);
2442     }
2443 }
2444
2445 LHASH_OF(SSL_SESSION) *SSL_CTX_sessions(SSL_CTX *ctx)
2446 {
2447     return ctx->sessions;
2448 }
2449
2450 long SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg)
2451 {
2452     long l;
2453     /* For some cases with ctx == NULL perform syntax checks */
2454     if (ctx == NULL) {
2455         switch (cmd) {
2456         case SSL_CTRL_SET_GROUPS_LIST:
2457             return tls1_set_groups_list(ctx, NULL, NULL, parg);
2458         case SSL_CTRL_SET_SIGALGS_LIST:
2459         case SSL_CTRL_SET_CLIENT_SIGALGS_LIST:
2460             return tls1_set_sigalgs_list(NULL, parg, 0);
2461         default:
2462             return 0;
2463         }
2464     }
2465
2466     switch (cmd) {
2467     case SSL_CTRL_GET_READ_AHEAD:
2468         return ctx->read_ahead;
2469     case SSL_CTRL_SET_READ_AHEAD:
2470         l = ctx->read_ahead;
2471         ctx->read_ahead = larg;
2472         return l;
2473
2474     case SSL_CTRL_SET_MSG_CALLBACK_ARG:
2475         ctx->msg_callback_arg = parg;
2476         return 1;
2477
2478     case SSL_CTRL_GET_MAX_CERT_LIST:
2479         return (long)ctx->max_cert_list;
2480     case SSL_CTRL_SET_MAX_CERT_LIST:
2481         if (larg < 0)
2482             return 0;
2483         l = (long)ctx->max_cert_list;
2484         ctx->max_cert_list = (size_t)larg;
2485         return l;
2486
2487     case SSL_CTRL_SET_SESS_CACHE_SIZE:
2488         if (larg < 0)
2489             return 0;
2490         l = (long)ctx->session_cache_size;
2491         ctx->session_cache_size = (size_t)larg;
2492         return l;
2493     case SSL_CTRL_GET_SESS_CACHE_SIZE:
2494         return (long)ctx->session_cache_size;
2495     case SSL_CTRL_SET_SESS_CACHE_MODE:
2496         l = ctx->session_cache_mode;
2497         ctx->session_cache_mode = larg;
2498         return l;
2499     case SSL_CTRL_GET_SESS_CACHE_MODE:
2500         return ctx->session_cache_mode;
2501
2502     case SSL_CTRL_SESS_NUMBER:
2503         return lh_SSL_SESSION_num_items(ctx->sessions);
2504     case SSL_CTRL_SESS_CONNECT:
2505         return tsan_load(&ctx->stats.sess_connect);
2506     case SSL_CTRL_SESS_CONNECT_GOOD:
2507         return tsan_load(&ctx->stats.sess_connect_good);
2508     case SSL_CTRL_SESS_CONNECT_RENEGOTIATE:
2509         return tsan_load(&ctx->stats.sess_connect_renegotiate);
2510     case SSL_CTRL_SESS_ACCEPT:
2511         return tsan_load(&ctx->stats.sess_accept);
2512     case SSL_CTRL_SESS_ACCEPT_GOOD:
2513         return tsan_load(&ctx->stats.sess_accept_good);
2514     case SSL_CTRL_SESS_ACCEPT_RENEGOTIATE:
2515         return tsan_load(&ctx->stats.sess_accept_renegotiate);
2516     case SSL_CTRL_SESS_HIT:
2517         return tsan_load(&ctx->stats.sess_hit);
2518     case SSL_CTRL_SESS_CB_HIT:
2519         return tsan_load(&ctx->stats.sess_cb_hit);
2520     case SSL_CTRL_SESS_MISSES:
2521         return tsan_load(&ctx->stats.sess_miss);
2522     case SSL_CTRL_SESS_TIMEOUTS:
2523         return tsan_load(&ctx->stats.sess_timeout);
2524     case SSL_CTRL_SESS_CACHE_FULL:
2525         return tsan_load(&ctx->stats.sess_cache_full);
2526     case SSL_CTRL_MODE:
2527         return (ctx->mode |= larg);
2528     case SSL_CTRL_CLEAR_MODE:
2529         return (ctx->mode &= ~larg);
2530     case SSL_CTRL_SET_MAX_SEND_FRAGMENT:
2531         if (larg < 512 || larg > SSL3_RT_MAX_PLAIN_LENGTH)
2532             return 0;
2533         ctx->max_send_fragment = larg;
2534         if (ctx->max_send_fragment < ctx->split_send_fragment)
2535             ctx->split_send_fragment = ctx->max_send_fragment;
2536         return 1;
2537     case SSL_CTRL_SET_SPLIT_SEND_FRAGMENT:
2538         if ((size_t)larg > ctx->max_send_fragment || larg == 0)
2539             return 0;
2540         ctx->split_send_fragment = larg;
2541         return 1;
2542     case SSL_CTRL_SET_MAX_PIPELINES:
2543         if (larg < 1 || larg > SSL_MAX_PIPELINES)
2544             return 0;
2545         ctx->max_pipelines = larg;
2546         return 1;
2547     case SSL_CTRL_CERT_FLAGS:
2548         return (ctx->cert->cert_flags |= larg);
2549     case SSL_CTRL_CLEAR_CERT_FLAGS:
2550         return (ctx->cert->cert_flags &= ~larg);
2551     case SSL_CTRL_SET_MIN_PROTO_VERSION:
2552         return ssl_check_allowed_versions(larg, ctx->max_proto_version)
2553                && ssl_set_version_bound(ctx->method->version, (int)larg,
2554                                         &ctx->min_proto_version);
2555     case SSL_CTRL_GET_MIN_PROTO_VERSION:
2556         return ctx->min_proto_version;
2557     case SSL_CTRL_SET_MAX_PROTO_VERSION:
2558         return ssl_check_allowed_versions(ctx->min_proto_version, larg)
2559                && ssl_set_version_bound(ctx->method->version, (int)larg,
2560                                         &ctx->max_proto_version);
2561     case SSL_CTRL_GET_MAX_PROTO_VERSION:
2562         return ctx->max_proto_version;
2563     default:
2564         return ctx->method->ssl_ctx_ctrl(ctx, cmd, larg, parg);
2565     }
2566 }
2567
2568 long SSL_CTX_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp) (void))
2569 {
2570     switch (cmd) {
2571     case SSL_CTRL_SET_MSG_CALLBACK:
2572         ctx->msg_callback = (void (*)
2573                              (int write_p, int version, int content_type,
2574                               const void *buf, size_t len, SSL *ssl,
2575                               void *arg))(fp);
2576         return 1;
2577
2578     default:
2579         return ctx->method->ssl_ctx_callback_ctrl(ctx, cmd, fp);
2580     }
2581 }
2582
2583 int ssl_cipher_id_cmp(const SSL_CIPHER *a, const SSL_CIPHER *b)
2584 {
2585     if (a->id > b->id)
2586         return 1;
2587     if (a->id < b->id)
2588         return -1;
2589     return 0;
2590 }
2591
2592 int ssl_cipher_ptr_id_cmp(const SSL_CIPHER *const *ap,
2593                           const SSL_CIPHER *const *bp)
2594 {
2595     if ((*ap)->id > (*bp)->id)
2596         return 1;
2597     if ((*ap)->id < (*bp)->id)
2598         return -1;
2599     return 0;
2600 }
2601
2602 /** return a STACK of the ciphers available for the SSL and in order of
2603  * preference */
2604 STACK_OF(SSL_CIPHER) *SSL_get_ciphers(const SSL *s)
2605 {
2606     if (s != NULL) {
2607         if (s->cipher_list != NULL) {
2608             return s->cipher_list;
2609         } else if ((s->ctx != NULL) && (s->ctx->cipher_list != NULL)) {
2610             return s->ctx->cipher_list;
2611         }
2612     }
2613     return NULL;
2614 }
2615
2616 STACK_OF(SSL_CIPHER) *SSL_get_client_ciphers(const SSL *s)
2617 {
2618     if ((s == NULL) || !s->server)
2619         return NULL;
2620     return s->peer_ciphers;
2621 }
2622
2623 STACK_OF(SSL_CIPHER) *SSL_get1_supported_ciphers(SSL *s)
2624 {
2625     STACK_OF(SSL_CIPHER) *sk = NULL, *ciphers;
2626     int i;
2627
2628     ciphers = SSL_get_ciphers(s);
2629     if (!ciphers)
2630         return NULL;
2631     if (!ssl_set_client_disabled(s))
2632         return NULL;
2633     for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
2634         const SSL_CIPHER *c = sk_SSL_CIPHER_value(ciphers, i);
2635         if (!ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_SUPPORTED, 0)) {
2636             if (!sk)
2637                 sk = sk_SSL_CIPHER_new_null();
2638             if (!sk)
2639                 return NULL;
2640             if (!sk_SSL_CIPHER_push(sk, c)) {
2641                 sk_SSL_CIPHER_free(sk);
2642                 return NULL;
2643             }
2644         }
2645     }
2646     return sk;
2647 }
2648
2649 /** return a STACK of the ciphers available for the SSL and in order of
2650  * algorithm id */
2651 STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL *s)
2652 {
2653     if (s != NULL) {
2654         if (s->cipher_list_by_id != NULL) {
2655             return s->cipher_list_by_id;
2656         } else if ((s->ctx != NULL) && (s->ctx->cipher_list_by_id != NULL)) {
2657             return s->ctx->cipher_list_by_id;
2658         }
2659     }
2660     return NULL;
2661 }
2662
2663 /** The old interface to get the same thing as SSL_get_ciphers() */
2664 const char *SSL_get_cipher_list(const SSL *s, int n)
2665 {
2666     const SSL_CIPHER *c;
2667     STACK_OF(SSL_CIPHER) *sk;
2668
2669     if (s == NULL)
2670         return NULL;
2671     sk = SSL_get_ciphers(s);
2672     if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= n))
2673         return NULL;
2674     c = sk_SSL_CIPHER_value(sk, n);
2675     if (c == NULL)
2676         return NULL;
2677     return c->name;
2678 }
2679
2680 /** return a STACK of the ciphers available for the SSL_CTX and in order of
2681  * preference */
2682 STACK_OF(SSL_CIPHER) *SSL_CTX_get_ciphers(const SSL_CTX *ctx)
2683 {
2684     if (ctx != NULL)
2685         return ctx->cipher_list;
2686     return NULL;
2687 }
2688
2689 /*
2690  * Distinguish between ciphers controlled by set_ciphersuite() and
2691  * set_cipher_list() when counting.
2692  */
2693 static int cipher_list_tls12_num(STACK_OF(SSL_CIPHER) *sk)
2694 {
2695     int i, num = 0;
2696     const SSL_CIPHER *c;
2697
2698     if (sk == NULL)
2699         return 0;
2700     for (i = 0; i < sk_SSL_CIPHER_num(sk); ++i) {
2701         c = sk_SSL_CIPHER_value(sk, i);
2702         if (c->min_tls >= TLS1_3_VERSION)
2703             continue;
2704         num++;
2705     }
2706     return num;
2707 }
2708
2709 /** specify the ciphers to be used by default by the SSL_CTX */
2710 int SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str)
2711 {
2712     STACK_OF(SSL_CIPHER) *sk;
2713
2714     sk = ssl_create_cipher_list(ctx->method, ctx->tls13_ciphersuites,
2715                                 &ctx->cipher_list, &ctx->cipher_list_by_id, str,
2716                                 ctx->cert);
2717     /*
2718      * ssl_create_cipher_list may return an empty stack if it was unable to
2719      * find a cipher matching the given rule string (for example if the rule
2720      * string specifies a cipher which has been disabled). This is not an
2721      * error as far as ssl_create_cipher_list is concerned, and hence
2722      * ctx->cipher_list and ctx->cipher_list_by_id has been updated.
2723      */
2724     if (sk == NULL)
2725         return 0;
2726     else if (cipher_list_tls12_num(sk) == 0) {
2727         SSLerr(SSL_F_SSL_CTX_SET_CIPHER_LIST, SSL_R_NO_CIPHER_MATCH);
2728         return 0;
2729     }
2730     return 1;
2731 }
2732
2733 /** specify the ciphers to be used by the SSL */
2734 int SSL_set_cipher_list(SSL *s, const char *str)
2735 {
2736     STACK_OF(SSL_CIPHER) *sk;
2737
2738     sk = ssl_create_cipher_list(s->ctx->method, s->tls13_ciphersuites,
2739                                 &s->cipher_list, &s->cipher_list_by_id, str,
2740                                 s->cert);
2741     /* see comment in SSL_CTX_set_cipher_list */
2742     if (sk == NULL)
2743         return 0;
2744     else if (cipher_list_tls12_num(sk) == 0) {
2745         SSLerr(SSL_F_SSL_SET_CIPHER_LIST, SSL_R_NO_CIPHER_MATCH);
2746         return 0;
2747     }
2748     return 1;
2749 }
2750
2751 char *SSL_get_shared_ciphers(const SSL *s, char *buf, int size)
2752 {
2753     char *p;
2754     STACK_OF(SSL_CIPHER) *clntsk, *srvrsk;
2755     const SSL_CIPHER *c;
2756     int i;
2757
2758     if (!s->server
2759             || s->peer_ciphers == NULL
2760             || size < 2)
2761         return NULL;
2762
2763     p = buf;
2764     clntsk = s->peer_ciphers;
2765     srvrsk = SSL_get_ciphers(s);
2766     if (clntsk == NULL || srvrsk == NULL)
2767         return NULL;
2768
2769     if (sk_SSL_CIPHER_num(clntsk) == 0 || sk_SSL_CIPHER_num(srvrsk) == 0)
2770         return NULL;
2771
2772     for (i = 0; i < sk_SSL_CIPHER_num(clntsk); i++) {
2773         int n;
2774
2775         c = sk_SSL_CIPHER_value(clntsk, i);
2776         if (sk_SSL_CIPHER_find(srvrsk, c) < 0)
2777             continue;
2778
2779         n = strlen(c->name);
2780         if (n + 1 > size) {
2781             if (p != buf)
2782                 --p;
2783             *p = '\0';
2784             return buf;
2785         }
2786         strcpy(p, c->name);
2787         p += n;
2788         *(p++) = ':';
2789         size -= n + 1;
2790     }
2791     p[-1] = '\0';
2792     return buf;
2793 }
2794
2795 /**
2796  * Return the requested servername (SNI) value. Note that the behaviour varies
2797  * depending on:
2798  * - whether this is called by the client or the server,
2799  * - if we are before or during/after the handshake,
2800  * - if a resumption or normal handshake is being attempted/has occurred
2801  * - whether we have negotiated TLSv1.2 (or below) or TLSv1.3
2802  *
2803  * Note that only the host_name type is defined (RFC 3546).
2804  */
2805 const char *SSL_get_servername(const SSL *s, const int type)
2806 {
2807     /*
2808      * If we don't know if we are the client or the server yet then we assume
2809      * client.
2810      */
2811     int server = s->handshake_func == NULL ? 0 : s->server;
2812     if (type != TLSEXT_NAMETYPE_host_name)
2813         return NULL;
2814
2815     if (server) {
2816         /**
2817          * Server side
2818          * In TLSv1.3 on the server SNI is not associated with the session
2819          * but in TLSv1.2 or below it is.
2820          *
2821          * Before the handshake:
2822          *  - return NULL
2823          *
2824          * During/after the handshake (TLSv1.2 or below resumption occurred):
2825          * - If a servername was accepted by the server in the original
2826          *   handshake then it will return that servername, or NULL otherwise.
2827          *
2828          * During/after the handshake (TLSv1.2 or below resumption did not occur):
2829          * - The function will return the servername requested by the client in
2830          *   this handshake or NULL if none was requested.
2831          */
2832          if (s->hit && !SSL_IS_TLS13(s))
2833             return s->session->ext.hostname;
2834     } else {
2835         /**
2836          * Client side
2837          *
2838          * Before the handshake:
2839          *  - If a servername has been set via a call to
2840          *    SSL_set_tlsext_host_name() then it will return that servername
2841          *  - If one has not been set, but a TLSv1.2 resumption is being
2842          *    attempted and the session from the original handshake had a
2843          *    servername accepted by the server then it will return that
2844          *    servername
2845          *  - Otherwise it returns NULL
2846          *
2847          * During/after the handshake (TLSv1.2 or below resumption occurred):
2848          * - If the session from the orignal handshake had a servername accepted
2849          *   by the server then it will return that servername.
2850          * - Otherwise it returns the servername set via
2851          *   SSL_set_tlsext_host_name() (or NULL if it was not called).
2852          *
2853          * During/after the handshake (TLSv1.2 or below resumption did not occur):
2854          * - It will return the servername set via SSL_set_tlsext_host_name()
2855          *   (or NULL if it was not called).
2856          */
2857         if (SSL_in_before(s)) {
2858             if (s->ext.hostname == NULL
2859                     && s->session != NULL
2860                     && s->session->ssl_version != TLS1_3_VERSION)
2861                 return s->session->ext.hostname;
2862         } else {
2863             if (!SSL_IS_TLS13(s) && s->hit && s->session->ext.hostname != NULL)
2864                 return s->session->ext.hostname;
2865         }
2866     }
2867
2868     return s->ext.hostname;
2869 }
2870
2871 int SSL_get_servername_type(const SSL *s)
2872 {
2873     if (SSL_get_servername(s, TLSEXT_NAMETYPE_host_name) != NULL)
2874         return TLSEXT_NAMETYPE_host_name;
2875     return -1;
2876 }
2877
2878 /*
2879  * SSL_select_next_proto implements the standard protocol selection. It is
2880  * expected that this function is called from the callback set by
2881  * SSL_CTX_set_next_proto_select_cb. The protocol data is assumed to be a
2882  * vector of 8-bit, length prefixed byte strings. The length byte itself is
2883  * not included in the length. A byte string of length 0 is invalid. No byte
2884  * string may be truncated. The current, but experimental algorithm for
2885  * selecting the protocol is: 1) If the server doesn't support NPN then this
2886  * is indicated to the callback. In this case, the client application has to
2887  * abort the connection or have a default application level protocol. 2) If
2888  * the server supports NPN, but advertises an empty list then the client
2889  * selects the first protocol in its list, but indicates via the API that this
2890  * fallback case was enacted. 3) Otherwise, the client finds the first
2891  * protocol in the server's list that it supports and selects this protocol.
2892  * This is because it's assumed that the server has better information about
2893  * which protocol a client should use. 4) If the client doesn't support any
2894  * of the server's advertised protocols, then this is treated the same as
2895  * case 2. It returns either OPENSSL_NPN_NEGOTIATED if a common protocol was
2896  * found, or OPENSSL_NPN_NO_OVERLAP if the fallback case was reached.
2897  */
2898 int SSL_select_next_proto(unsigned char **out, unsigned char *outlen,
2899                           const unsigned char *server,
2900                           unsigned int server_len,
2901                           const unsigned char *client, unsigned int client_len)
2902 {
2903     unsigned int i, j;
2904     const unsigned char *result;
2905     int status = OPENSSL_NPN_UNSUPPORTED;
2906
2907     /*
2908      * For each protocol in server preference order, see if we support it.
2909      */
2910     for (i = 0; i < server_len;) {
2911         for (j = 0; j < client_len;) {
2912             if (server[i] == client[j] &&
2913                 memcmp(&server[i + 1], &client[j + 1], server[i]) == 0) {
2914                 /* We found a match */
2915                 result = &server[i];
2916                 status = OPENSSL_NPN_NEGOTIATED;
2917                 goto found;
2918             }
2919             j += client[j];
2920             j++;
2921         }
2922         i += server[i];
2923         i++;
2924     }
2925
2926     /* There's no overlap between our protocols and the server's list. */
2927     result = client;
2928     status = OPENSSL_NPN_NO_OVERLAP;
2929
2930  found:
2931     *out = (unsigned char *)result + 1;
2932     *outlen = result[0];
2933     return status;
2934 }
2935
2936 #ifndef OPENSSL_NO_NEXTPROTONEG
2937 /*
2938  * SSL_get0_next_proto_negotiated sets *data and *len to point to the
2939  * client's requested protocol for this connection and returns 0. If the
2940  * client didn't request any protocol, then *data is set to NULL. Note that
2941  * the client can request any protocol it chooses. The value returned from
2942  * this function need not be a member of the list of supported protocols
2943  * provided by the callback.
2944  */
2945 void SSL_get0_next_proto_negotiated(const SSL *s, const unsigned char **data,
2946                                     unsigned *len)
2947 {
2948     *data = s->ext.npn;
2949     if (*data == NULL) {
2950         *len = 0;
2951     } else {
2952         *len = (unsigned int)s->ext.npn_len;
2953     }
2954 }
2955
2956 /*
2957  * SSL_CTX_set_npn_advertised_cb sets a callback that is called when
2958  * a TLS server needs a list of supported protocols for Next Protocol
2959  * Negotiation. The returned list must be in wire format.  The list is
2960  * returned by setting |out| to point to it and |outlen| to its length. This
2961  * memory will not be modified, but one should assume that the SSL* keeps a
2962  * reference to it. The callback should return SSL_TLSEXT_ERR_OK if it
2963  * wishes to advertise. Otherwise, no such extension will be included in the
2964  * ServerHello.
2965  */
2966 void SSL_CTX_set_npn_advertised_cb(SSL_CTX *ctx,
2967                                    SSL_CTX_npn_advertised_cb_func cb,
2968                                    void *arg)
2969 {
2970     ctx->ext.npn_advertised_cb = cb;
2971     ctx->ext.npn_advertised_cb_arg = arg;
2972 }
2973
2974 /*
2975  * SSL_CTX_set_next_proto_select_cb sets a callback that is called when a
2976  * client needs to select a protocol from the server's provided list. |out|
2977  * must be set to point to the selected protocol (which may be within |in|).
2978  * The length of the protocol name must be written into |outlen|. The
2979  * server's advertised protocols are provided in |in| and |inlen|. The
2980  * callback can assume that |in| is syntactically valid. The client must
2981  * select a protocol. It is fatal to the connection if this callback returns
2982  * a value other than SSL_TLSEXT_ERR_OK.
2983  */
2984 void SSL_CTX_set_npn_select_cb(SSL_CTX *ctx,
2985                                SSL_CTX_npn_select_cb_func cb,
2986                                void *arg)
2987 {
2988     ctx->ext.npn_select_cb = cb;
2989     ctx->ext.npn_select_cb_arg = arg;
2990 }
2991 #endif
2992
2993 /*
2994  * SSL_CTX_set_alpn_protos sets the ALPN protocol list on |ctx| to |protos|.
2995  * |protos| must be in wire-format (i.e. a series of non-empty, 8-bit
2996  * length-prefixed strings). Returns 0 on success.
2997  */
2998 int SSL_CTX_set_alpn_protos(SSL_CTX *ctx, const unsigned char *protos,
2999                             unsigned int protos_len)
3000 {
3001     OPENSSL_free(ctx->ext.alpn);
3002     ctx->ext.alpn = OPENSSL_memdup(protos, protos_len);
3003     if (ctx->ext.alpn == NULL) {
3004         SSLerr(SSL_F_SSL_CTX_SET_ALPN_PROTOS, ERR_R_MALLOC_FAILURE);
3005         return 1;
3006     }
3007     ctx->ext.alpn_len = protos_len;
3008
3009     return 0;
3010 }
3011
3012 /*
3013  * SSL_set_alpn_protos sets the ALPN protocol list on |ssl| to |protos|.
3014  * |protos| must be in wire-format (i.e. a series of non-empty, 8-bit
3015  * length-prefixed strings). Returns 0 on success.
3016  */
3017 int SSL_set_alpn_protos(SSL *ssl, const unsigned char *protos,
3018                         unsigned int protos_len)
3019 {
3020     OPENSSL_free(ssl->ext.alpn);
3021     ssl->ext.alpn = OPENSSL_memdup(protos, protos_len);
3022     if (ssl->ext.alpn == NULL) {
3023         SSLerr(SSL_F_SSL_SET_ALPN_PROTOS, ERR_R_MALLOC_FAILURE);
3024         return 1;
3025     }
3026     ssl->ext.alpn_len = protos_len;
3027
3028     return 0;
3029 }
3030
3031 /*
3032  * SSL_CTX_set_alpn_select_cb sets a callback function on |ctx| that is
3033  * called during ClientHello processing in order to select an ALPN protocol
3034  * from the client's list of offered protocols.
3035  */
3036 void SSL_CTX_set_alpn_select_cb(SSL_CTX *ctx,
3037                                 SSL_CTX_alpn_select_cb_func cb,
3038                                 void *arg)
3039 {
3040     ctx->ext.alpn_select_cb = cb;
3041     ctx->ext.alpn_select_cb_arg = arg;
3042 }
3043
3044 /*
3045  * SSL_get0_alpn_selected gets the selected ALPN protocol (if any) from |ssl|.
3046  * On return it sets |*data| to point to |*len| bytes of protocol name
3047  * (not including the leading length-prefix byte). If the server didn't
3048  * respond with a negotiated protocol then |*len| will be zero.
3049  */
3050 void SSL_get0_alpn_selected(const SSL *ssl, const unsigned char **data,
3051                             unsigned int *len)
3052 {
3053     *data = ssl->s3.alpn_selected;
3054     if (*data == NULL)
3055         *len = 0;
3056     else
3057         *len = (unsigned int)ssl->s3.alpn_selected_len;
3058 }
3059
3060 int SSL_export_keying_material(SSL *s, unsigned char *out, size_t olen,
3061                                const char *label, size_t llen,
3062                                const unsigned char *context, size_t contextlen,
3063                                int use_context)
3064 {
3065     if (s->session == NULL
3066         || (s->version < TLS1_VERSION && s->version != DTLS1_BAD_VER))
3067         return -1;
3068
3069     return s->method->ssl3_enc->export_keying_material(s, out, olen, label,
3070                                                        llen, context,
3071                                                        contextlen, use_context);
3072 }
3073
3074 int SSL_export_keying_material_early(SSL *s, unsigned char *out, size_t olen,
3075                                      const char *label, size_t llen,
3076                                      const unsigned char *context,
3077                                      size_t contextlen)
3078 {
3079     if (s->version != TLS1_3_VERSION)
3080         return 0;
3081
3082     return tls13_export_keying_material_early(s, out, olen, label, llen,
3083                                               context, contextlen);
3084 }
3085
3086 static unsigned long ssl_session_hash(const SSL_SESSION *a)
3087 {
3088     const unsigned char *session_id = a->session_id;
3089     unsigned long l;
3090     unsigned char tmp_storage[4];
3091
3092     if (a->session_id_length < sizeof(tmp_storage)) {
3093         memset(tmp_storage, 0, sizeof(tmp_storage));
3094         memcpy(tmp_storage, a->session_id, a->session_id_length);
3095         session_id = tmp_storage;
3096     }
3097
3098     l = (unsigned long)
3099         ((unsigned long)session_id[0]) |
3100         ((unsigned long)session_id[1] << 8L) |
3101         ((unsigned long)session_id[2] << 16L) |
3102         ((unsigned long)session_id[3] << 24L);
3103     return l;
3104 }
3105
3106 /*
3107  * NB: If this function (or indeed the hash function which uses a sort of
3108  * coarser function than this one) is changed, ensure
3109  * SSL_CTX_has_matching_session_id() is checked accordingly. It relies on
3110  * being able to construct an SSL_SESSION that will collide with any existing
3111  * session with a matching session ID.
3112  */
3113 static int ssl_session_cmp(const SSL_SESSION *a, const SSL_SESSION *b)
3114 {
3115     if (a->ssl_version != b->ssl_version)
3116         return 1;
3117     if (a->session_id_length != b->session_id_length)
3118         return 1;
3119     return memcmp(a->session_id, b->session_id, a->session_id_length);
3120 }
3121
3122 /*
3123  * These wrapper functions should remain rather than redeclaring
3124  * SSL_SESSION_hash and SSL_SESSION_cmp for void* types and casting each
3125  * variable. The reason is that the functions aren't static, they're exposed
3126  * via ssl.h.
3127  */
3128
3129 SSL_CTX *SSL_CTX_new_with_libctx(OPENSSL_CTX *libctx, const char *propq,
3130                                  const SSL_METHOD *meth)
3131 {
3132     SSL_CTX *ret = NULL;
3133
3134     if (meth == NULL) {
3135         SSLerr(0, SSL_R_NULL_SSL_METHOD_PASSED);
3136         return NULL;
3137     }
3138
3139     if (!OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS, NULL))
3140         return NULL;
3141
3142     if (SSL_get_ex_data_X509_STORE_CTX_idx() < 0) {
3143         SSLerr(0, SSL_R_X509_VERIFICATION_SETUP_PROBLEMS);
3144         goto err;
3145     }
3146     ret = OPENSSL_zalloc(sizeof(*ret));
3147     if (ret == NULL)
3148         goto err;
3149
3150     ret->libctx = libctx;
3151     if (propq != NULL) {
3152         ret->propq = OPENSSL_strdup(propq);
3153         if (ret->propq == NULL)
3154             goto err;
3155     }
3156
3157     ret->method = meth;
3158     ret->min_proto_version = 0;
3159     ret->max_proto_version = 0;
3160     ret->mode = SSL_MODE_AUTO_RETRY;
3161     ret->session_cache_mode = SSL_SESS_CACHE_SERVER;
3162     ret->session_cache_size = SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;
3163     /* We take the system default. */
3164     ret->session_timeout = meth->get_timeout();
3165     ret->references = 1;
3166     ret->lock = CRYPTO_THREAD_lock_new();
3167     if (ret->lock == NULL) {
3168         SSLerr(0, ERR_R_MALLOC_FAILURE);
3169         OPENSSL_free(ret);
3170         return NULL;
3171     }
3172     ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;
3173     ret->verify_mode = SSL_VERIFY_NONE;
3174     if ((ret->cert = ssl_cert_new()) == NULL)
3175         goto err;
3176
3177     ret->sessions = lh_SSL_SESSION_new(ssl_session_hash, ssl_session_cmp);
3178     if (ret->sessions == NULL)
3179         goto err;
3180     ret->cert_store = X509_STORE_new();
3181     if (ret->cert_store == NULL)
3182         goto err;
3183 #ifndef OPENSSL_NO_CT
3184     ret->ctlog_store = CTLOG_STORE_new_with_libctx(libctx, propq);
3185     if (ret->ctlog_store == NULL)
3186         goto err;
3187 #endif
3188
3189     /* initialize cipher/digest methods table */
3190     if (!ssl_load_ciphers(ret))
3191         goto err2;
3192     /* initialise sig algs */
3193     if (!ssl_setup_sig_algs(ret))
3194         goto err2;
3195
3196
3197     if (!ssl_load_groups(ret))
3198         goto err2;
3199
3200     if (!SSL_CTX_set_ciphersuites(ret, OSSL_default_ciphersuites()))
3201         goto err;
3202
3203     if (!ssl_create_cipher_list(ret->method,
3204                                 ret->tls13_ciphersuites,
3205                                 &ret->cipher_list, &ret->cipher_list_by_id,
3206                                 OSSL_default_cipher_list(), ret->cert)
3207         || sk_SSL_CIPHER_num(ret->cipher_list) <= 0) {
3208         SSLerr(0, SSL_R_LIBRARY_HAS_NO_CIPHERS);
3209         goto err2;
3210     }
3211
3212     ret->param = X509_VERIFY_PARAM_new();
3213     if (ret->param == NULL)
3214         goto err;
3215
3216     /*
3217      * If these aren't available from the provider we'll get NULL returns.
3218      * That's fine but will cause errors later if SSLv3 is negotiated
3219      */
3220     ret->md5 = ssl_evp_md_fetch(libctx, NID_md5, propq);
3221     ret->sha1 = ssl_evp_md_fetch(libctx, NID_sha1, propq);
3222
3223     if ((ret->ca_names = sk_X509_NAME_new_null()) == NULL)
3224         goto err;
3225
3226     if ((ret->client_ca_names = sk_X509_NAME_new_null()) == NULL)
3227         goto err;
3228
3229     if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ret, &ret->ex_data))
3230         goto err;
3231
3232     if ((ret->ext.secure = OPENSSL_secure_zalloc(sizeof(*ret->ext.secure))) == NULL)
3233         goto err;
3234
3235     /* No compression for DTLS */
3236     if (!(meth->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS))
3237         ret->comp_methods = SSL_COMP_get_compression_methods();
3238
3239     ret->max_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH;
3240     ret->split_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH;
3241
3242     /* Setup RFC5077 ticket keys */
3243     if ((RAND_bytes_ex(libctx, ret->ext.tick_key_name,
3244                        sizeof(ret->ext.tick_key_name)) <= 0)
3245         || (RAND_priv_bytes_ex(libctx, ret->ext.secure->tick_hmac_key,
3246                                sizeof(ret->ext.secure->tick_hmac_key)) <= 0)
3247         || (RAND_priv_bytes_ex(libctx, ret->ext.secure->tick_aes_key,
3248                                sizeof(ret->ext.secure->tick_aes_key)) <= 0))
3249         ret->options |= SSL_OP_NO_TICKET;
3250
3251     if (RAND_priv_bytes_ex(libctx, ret->ext.cookie_hmac_key,
3252                            sizeof(ret->ext.cookie_hmac_key)) <= 0)
3253         goto err;
3254
3255 #ifndef OPENSSL_NO_SRP
3256     if (!SSL_CTX_SRP_CTX_init(ret))
3257         goto err;
3258 #endif
3259 #ifndef OPENSSL_NO_ENGINE
3260 # ifdef OPENSSL_SSL_CLIENT_ENGINE_AUTO
3261 #  define eng_strx(x)     #x
3262 #  define eng_str(x)      eng_strx(x)
3263     /* Use specific client engine automatically... ignore errors */
3264     {
3265         ENGINE *eng;
3266         eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));
3267         if (!eng) {
3268             ERR_clear_error();
3269             ENGINE_load_builtin_engines();
3270             eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));
3271         }
3272         if (!eng || !SSL_CTX_set_client_cert_engine(ret, eng))
3273             ERR_clear_error();
3274     }
3275 # endif
3276 #endif
3277     /*
3278      * Default is to connect to non-RI servers. When RI is more widely
3279      * deployed might change this.
3280      */
3281     ret->options |= SSL_OP_LEGACY_SERVER_CONNECT;
3282     /*
3283      * Disable compression by default to prevent CRIME. Applications can
3284      * re-enable compression by configuring
3285      * SSL_CTX_clear_options(ctx, SSL_OP_NO_COMPRESSION);
3286      * or by using the SSL_CONF library. Similarly we also enable TLSv1.3
3287      * middlebox compatibility by default. This may be disabled by default in
3288      * a later OpenSSL version.
3289      */
3290     ret->options |= SSL_OP_NO_COMPRESSION | SSL_OP_ENABLE_MIDDLEBOX_COMPAT;
3291
3292     ret->ext.status_type = TLSEXT_STATUSTYPE_nothing;
3293
3294     /*
3295      * We cannot usefully set a default max_early_data here (which gets
3296      * propagated in SSL_new(), for the following reason: setting the
3297      * SSL field causes tls_construct_stoc_early_data() to tell the
3298      * client that early data will be accepted when constructing a TLS 1.3
3299      * session ticket, and the client will accordingly send us early data
3300      * when using that ticket (if the client has early data to send).
3301      * However, in order for the early data to actually be consumed by
3302      * the application, the application must also have calls to
3303      * SSL_read_early_data(); otherwise we'll just skip past the early data
3304      * and ignore it.  So, since the application must add calls to
3305      * SSL_read_early_data(), we also require them to add
3306      * calls to SSL_CTX_set_max_early_data() in order to use early data,
3307      * eliminating the bandwidth-wasting early data in the case described
3308      * above.
3309      */
3310     ret->max_early_data = 0;
3311
3312     /*
3313      * Default recv_max_early_data is a fully loaded single record. Could be
3314      * split across multiple records in practice. We set this differently to
3315      * max_early_data so that, in the default case, we do not advertise any
3316      * support for early_data, but if a client were to send us some (e.g.
3317      * because of an old, stale ticket) then we will tolerate it and skip over
3318      * it.
3319      */
3320     ret->recv_max_early_data = SSL3_RT_MAX_PLAIN_LENGTH;
3321
3322     /* By default we send two session tickets automatically in TLSv1.3 */
3323     ret->num_tickets = 2;
3324
3325     ssl_ctx_system_config(ret);
3326
3327     return ret;
3328  err:
3329     SSLerr(0, ERR_R_MALLOC_FAILURE);
3330  err2:
3331     SSL_CTX_free(ret);
3332     return NULL;
3333 }
3334
3335 SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth)
3336 {
3337     return SSL_CTX_new_with_libctx(NULL, NULL, meth);
3338 }
3339
3340 int SSL_CTX_up_ref(SSL_CTX *ctx)
3341 {
3342     int i;
3343
3344     if (CRYPTO_UP_REF(&ctx->references, &i, ctx->lock) <= 0)
3345         return 0;
3346
3347     REF_PRINT_COUNT("SSL_CTX", ctx);
3348     REF_ASSERT_ISNT(i < 2);
3349     return ((i > 1) ? 1 : 0);
3350 }
3351
3352 void SSL_CTX_free(SSL_CTX *a)
3353 {
3354     int i;
3355     size_t j;
3356
3357     if (a == NULL)
3358         return;
3359
3360     CRYPTO_DOWN_REF(&a->references, &i, a->lock);
3361     REF_PRINT_COUNT("SSL_CTX", a);
3362     if (i > 0)
3363         return;
3364     REF_ASSERT_ISNT(i < 0);
3365
3366     X509_VERIFY_PARAM_free(a->param);
3367     dane_ctx_final(&a->dane);
3368
3369     /*
3370      * Free internal session cache. However: the remove_cb() may reference
3371      * the ex_data of SSL_CTX, thus the ex_data store can only be removed
3372      * after the sessions were flushed.
3373      * As the ex_data handling routines might also touch the session cache,
3374      * the most secure solution seems to be: empty (flush) the cache, then
3375      * free ex_data, then finally free the cache.
3376      * (See ticket [openssl.org #212].)
3377      */
3378     if (a->sessions != NULL)
3379         SSL_CTX_flush_sessions(a, 0);
3380
3381     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL_CTX, a, &a->ex_data);
3382     lh_SSL_SESSION_free(a->sessions);
3383     X509_STORE_free(a->cert_store);
3384 #ifndef OPENSSL_NO_CT
3385     CTLOG_STORE_free(a->ctlog_store);
3386 #endif
3387     sk_SSL_CIPHER_free(a->cipher_list);
3388     sk_SSL_CIPHER_free(a->cipher_list_by_id);
3389     sk_SSL_CIPHER_free(a->tls13_ciphersuites);
3390     ssl_cert_free(a->cert);
3391     sk_X509_NAME_pop_free(a->ca_names, X509_NAME_free);
3392     sk_X509_NAME_pop_free(a->client_ca_names, X509_NAME_free);
3393     sk_X509_pop_free(a->extra_certs, X509_free);
3394     a->comp_methods = NULL;
3395 #ifndef OPENSSL_NO_SRTP
3396     sk_SRTP_PROTECTION_PROFILE_free(a->srtp_profiles);
3397 #endif
3398 #ifndef OPENSSL_NO_SRP
3399     SSL_CTX_SRP_CTX_free(a);
3400 #endif
3401 #ifndef OPENSSL_NO_ENGINE
3402     ENGINE_finish(a->client_cert_engine);
3403 #endif
3404
3405 #ifndef OPENSSL_NO_EC
3406     OPENSSL_free(a->ext.ecpointformats);
3407 #endif
3408     OPENSSL_free(a->ext.supportedgroups);
3409     OPENSSL_free(a->ext.alpn);
3410     OPENSSL_secure_free(a->ext.secure);
3411
3412     ssl_evp_md_free(a->md5);
3413     ssl_evp_md_free(a->sha1);
3414
3415     for (j = 0; j < SSL_ENC_NUM_IDX; j++)
3416         ssl_evp_cipher_free(a->ssl_cipher_methods[j]);
3417     for (j = 0; j < SSL_MD_NUM_IDX; j++)
3418         ssl_evp_md_free(a->ssl_digest_methods[j]);
3419     for (j = 0; j < a->group_list_len; j++) {
3420         OPENSSL_free(a->group_list[j].tlsname);
3421         OPENSSL_free(a->group_list[j].realname);
3422         OPENSSL_free(a->group_list[j].algorithm);
3423     }
3424     OPENSSL_free(a->group_list);
3425
3426     OPENSSL_free(a->sigalg_lookup_cache);
3427
3428     CRYPTO_THREAD_lock_free(a->lock);
3429
3430     OPENSSL_free(a->propq);
3431
3432     OPENSSL_free(a);
3433 }
3434
3435 void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb)
3436 {
3437     ctx->default_passwd_callback = cb;
3438 }
3439
3440 void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx, void *u)
3441 {
3442     ctx->default_passwd_callback_userdata = u;
3443 }
3444
3445 pem_password_cb *SSL_CTX_get_default_passwd_cb(SSL_CTX *ctx)
3446 {
3447     return ctx->default_passwd_callback;
3448 }
3449
3450 void *SSL_CTX_get_default_passwd_cb_userdata(SSL_CTX *ctx)
3451 {
3452     return ctx->default_passwd_callback_userdata;
3453 }
3454
3455 void SSL_set_default_passwd_cb(SSL *s, pem_password_cb *cb)
3456 {
3457     s->default_passwd_callback = cb;
3458 }
3459
3460 void SSL_set_default_passwd_cb_userdata(SSL *s, void *u)
3461 {
3462     s->default_passwd_callback_userdata = u;
3463 }
3464
3465 pem_password_cb *SSL_get_default_passwd_cb(SSL *s)
3466 {
3467     return s->default_passwd_callback;
3468 }
3469
3470 void *SSL_get_default_passwd_cb_userdata(SSL *s)
3471 {
3472     return s->default_passwd_callback_userdata;
3473 }
3474
3475 void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx,
3476                                       int (*cb) (X509_STORE_CTX *, void *),
3477                                       void *arg)
3478 {
3479     ctx->app_verify_callback = cb;
3480     ctx->app_verify_arg = arg;
3481 }
3482
3483 void SSL_CTX_set_verify(SSL_CTX *ctx, int mode,
3484                         int (*cb) (int, X509_STORE_CTX *))
3485 {
3486     ctx->verify_mode = mode;
3487     ctx->default_verify_callback = cb;
3488 }
3489
3490 void SSL_CTX_set_verify_depth(SSL_CTX *ctx, int depth)
3491 {
3492     X509_VERIFY_PARAM_set_depth(ctx->param, depth);
3493 }
3494
3495 void SSL_CTX_set_cert_cb(SSL_CTX *c, int (*cb) (SSL *ssl, void *arg), void *arg)
3496 {
3497     ssl_cert_set_cert_cb(c->cert, cb, arg);
3498 }
3499
3500 void SSL_set_cert_cb(SSL *s, int (*cb) (SSL *ssl, void *arg), void *arg)
3501 {
3502     ssl_cert_set_cert_cb(s->cert, cb, arg);
3503 }
3504
3505 void ssl_set_masks(SSL *s)
3506 {
3507     CERT *c = s->cert;
3508     uint32_t *pvalid = s->s3.tmp.valid_flags;
3509     int rsa_enc, rsa_sign, dh_tmp, dsa_sign;
3510     unsigned long mask_k, mask_a;
3511 #ifndef OPENSSL_NO_EC
3512     int have_ecc_cert, ecdsa_ok;
3513 #endif
3514     if (c == NULL)
3515         return;
3516
3517 #ifndef OPENSSL_NO_DH
3518     dh_tmp = (c->dh_tmp != NULL || c->dh_tmp_cb != NULL || c->dh_tmp_auto);
3519 #else
3520     dh_tmp = 0;
3521 #endif
3522
3523     rsa_enc = pvalid[SSL_PKEY_RSA] & CERT_PKEY_VALID;
3524     rsa_sign = pvalid[SSL_PKEY_RSA] & CERT_PKEY_VALID;
3525     dsa_sign = pvalid[SSL_PKEY_DSA_SIGN] & CERT_PKEY_VALID;
3526 #ifndef OPENSSL_NO_EC
3527     have_ecc_cert = pvalid[SSL_PKEY_ECC] & CERT_PKEY_VALID;
3528 #endif
3529     mask_k = 0;
3530     mask_a = 0;
3531
3532     OSSL_TRACE4(TLS_CIPHER, "dh_tmp=%d rsa_enc=%d rsa_sign=%d dsa_sign=%d\n",
3533                dh_tmp, rsa_enc, rsa_sign, dsa_sign);
3534
3535 #ifndef OPENSSL_NO_GOST
3536     if (ssl_has_cert(s, SSL_PKEY_GOST12_512)) {
3537         mask_k |= SSL_kGOST | SSL_kGOST18;
3538         mask_a |= SSL_aGOST12;
3539     }
3540     if (ssl_has_cert(s, SSL_PKEY_GOST12_256)) {
3541         mask_k |= SSL_kGOST | SSL_kGOST18;
3542         mask_a |= SSL_aGOST12;
3543     }
3544     if (ssl_has_cert(s, SSL_PKEY_GOST01)) {
3545         mask_k |= SSL_kGOST;
3546         mask_a |= SSL_aGOST01;
3547     }
3548 #endif
3549
3550     if (rsa_enc)
3551         mask_k |= SSL_kRSA;
3552
3553     if (dh_tmp)
3554         mask_k |= SSL_kDHE;
3555
3556     /*
3557      * If we only have an RSA-PSS certificate allow RSA authentication
3558      * if TLS 1.2 and peer supports it.
3559      */
3560
3561     if (rsa_enc || rsa_sign || (ssl_has_cert(s, SSL_PKEY_RSA_PSS_SIGN)
3562                 && pvalid[SSL_PKEY_RSA_PSS_SIGN] & CERT_PKEY_EXPLICIT_SIGN
3563                 && TLS1_get_version(s) == TLS1_2_VERSION))
3564         mask_a |= SSL_aRSA;
3565
3566     if (dsa_sign) {
3567         mask_a |= SSL_aDSS;
3568     }
3569
3570     mask_a |= SSL_aNULL;
3571
3572     /*
3573      * An ECC certificate may be usable for ECDH and/or ECDSA cipher suites
3574      * depending on the key usage extension.
3575      */
3576 #ifndef OPENSSL_NO_EC
3577     if (have_ecc_cert) {
3578         uint32_t ex_kusage;
3579         ex_kusage = X509_get_key_usage(c->pkeys[SSL_PKEY_ECC].x509);
3580         ecdsa_ok = ex_kusage & X509v3_KU_DIGITAL_SIGNATURE;
3581         if (!(pvalid[SSL_PKEY_ECC] & CERT_PKEY_SIGN))
3582             ecdsa_ok = 0;
3583         if (ecdsa_ok)
3584             mask_a |= SSL_aECDSA;
3585     }
3586     /* Allow Ed25519 for TLS 1.2 if peer supports it */
3587     if (!(mask_a & SSL_aECDSA) && ssl_has_cert(s, SSL_PKEY_ED25519)
3588             && pvalid[SSL_PKEY_ED25519] & CERT_PKEY_EXPLICIT_SIGN
3589             && TLS1_get_version(s) == TLS1_2_VERSION)
3590             mask_a |= SSL_aECDSA;
3591
3592     /* Allow Ed448 for TLS 1.2 if peer supports it */
3593     if (!(mask_a & SSL_aECDSA) && ssl_has_cert(s, SSL_PKEY_ED448)
3594             && pvalid[SSL_PKEY_ED448] & CERT_PKEY_EXPLICIT_SIGN
3595             && TLS1_get_version(s) == TLS1_2_VERSION)
3596             mask_a |= SSL_aECDSA;
3597 #endif
3598
3599 #ifndef OPENSSL_NO_EC
3600     mask_k |= SSL_kECDHE;
3601 #endif
3602
3603 #ifndef OPENSSL_NO_PSK
3604     mask_k |= SSL_kPSK;
3605     mask_a |= SSL_aPSK;
3606     if (mask_k & SSL_kRSA)
3607         mask_k |= SSL_kRSAPSK;
3608     if (mask_k & SSL_kDHE)
3609         mask_k |= SSL_kDHEPSK;
3610     if (mask_k & SSL_kECDHE)
3611         mask_k |= SSL_kECDHEPSK;
3612 #endif
3613
3614     s->s3.tmp.mask_k = mask_k;
3615     s->s3.tmp.mask_a = mask_a;
3616 }
3617
3618 #ifndef OPENSSL_NO_EC
3619
3620 int ssl_check_srvr_ecc_cert_and_alg(X509 *x, SSL *s)
3621 {
3622     if (s->s3.tmp.new_cipher->algorithm_auth & SSL_aECDSA) {
3623         /* key usage, if present, must allow signing */
3624         if (!(X509_get_key_usage(x) & X509v3_KU_DIGITAL_SIGNATURE)) {
3625             SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG,
3626                    SSL_R_ECC_CERT_NOT_FOR_SIGNING);
3627             return 0;
3628         }
3629     }
3630     return 1;                   /* all checks are ok */
3631 }
3632
3633 #endif
3634
3635 int ssl_get_server_cert_serverinfo(SSL *s, const unsigned char **serverinfo,
3636                                    size_t *serverinfo_length)
3637 {
3638     CERT_PKEY *cpk = s->s3.tmp.cert;
3639     *serverinfo_length = 0;
3640
3641     if (cpk == NULL || cpk->serverinfo == NULL)
3642         return 0;
3643
3644     *serverinfo = cpk->serverinfo;
3645     *serverinfo_length = cpk->serverinfo_length;
3646     return 1;
3647 }
3648
3649 void ssl_update_cache(SSL *s, int mode)
3650 {
3651     int i;
3652
3653     /*
3654      * If the session_id_length is 0, we are not supposed to cache it, and it
3655      * would be rather hard to do anyway :-)
3656      */
3657     if (s->session->session_id_length == 0)
3658         return;
3659
3660     /*
3661      * If sid_ctx_length is 0 there is no specific application context
3662      * associated with this session, so when we try to resume it and
3663      * SSL_VERIFY_PEER is requested to verify the client identity, we have no
3664      * indication that this is actually a session for the proper application
3665      * context, and the *handshake* will fail, not just the resumption attempt.
3666      * Do not cache (on the server) these sessions that are not resumable
3667      * (clients can set SSL_VERIFY_PEER without needing a sid_ctx set).
3668      */
3669     if (s->server && s->session->sid_ctx_length == 0
3670             && (s->verify_mode & SSL_VERIFY_PEER) != 0)
3671         return;
3672
3673     i = s->session_ctx->session_cache_mode;
3674     if ((i & mode) != 0
3675         && (!s->hit || SSL_IS_TLS13(s))) {
3676         /*
3677          * Add the session to the internal cache. In server side TLSv1.3 we
3678          * normally don't do this because by default it's a full stateless ticket
3679          * with only a dummy session id so there is no reason to cache it,
3680          * unless:
3681          * - we are doing early_data, in which case we cache so that we can
3682          *   detect replays
3683          * - the application has set a remove_session_cb so needs to know about
3684          *   session timeout events
3685          * - SSL_OP_NO_TICKET is set in which case it is a stateful ticket
3686          */
3687         if ((i & SSL_SESS_CACHE_NO_INTERNAL_STORE) == 0
3688                 && (!SSL_IS_TLS13(s)
3689                     || !s->server
3690                     || (s->max_early_data > 0
3691                         && (s->options & SSL_OP_NO_ANTI_REPLAY) == 0)
3692                     || s->session_ctx->remove_session_cb != NULL
3693                     || (s->options & SSL_OP_NO_TICKET) != 0))
3694             SSL_CTX_add_session(s->session_ctx, s->session);
3695
3696         /*
3697          * Add the session to the external cache. We do this even in server side
3698          * TLSv1.3 without early data because some applications just want to
3699          * know about the creation of a session and aren't doing a full cache.
3700          */
3701         if (s->session_ctx->new_session_cb != NULL) {
3702             SSL_SESSION_up_ref(s->session);
3703             if (!s->session_ctx->new_session_cb(s, s->session))
3704                 SSL_SESSION_free(s->session);
3705         }
3706     }
3707
3708     /* auto flush every 255 connections */
3709     if ((!(i & SSL_SESS_CACHE_NO_AUTO_CLEAR)) && ((i & mode) == mode)) {
3710         TSAN_QUALIFIER int *stat;
3711         if (mode & SSL_SESS_CACHE_CLIENT)
3712             stat = &s->session_ctx->stats.sess_connect_good;
3713         else
3714             stat = &s->session_ctx->stats.sess_accept_good;
3715         if ((tsan_load(stat) & 0xff) == 0xff)
3716             SSL_CTX_flush_sessions(s->session_ctx, (unsigned long)time(NULL));
3717     }
3718 }
3719
3720 const SSL_METHOD *SSL_CTX_get_ssl_method(const SSL_CTX *ctx)
3721 {
3722     return ctx->method;
3723 }
3724
3725 const SSL_METHOD *SSL_get_ssl_method(const SSL *s)
3726 {
3727     return s->method;
3728 }
3729
3730 int SSL_set_ssl_method(SSL *s, const SSL_METHOD *meth)
3731 {
3732     int ret = 1;
3733
3734     if (s->method != meth) {
3735         const SSL_METHOD *sm = s->method;
3736         int (*hf) (SSL *) = s->handshake_func;
3737
3738         if (sm->version == meth->version)
3739             s->method = meth;
3740         else {
3741             sm->ssl_free(s);
3742             s->method = meth;
3743             ret = s->method->ssl_new(s);
3744         }
3745
3746         if (hf == sm->ssl_connect)
3747             s->handshake_func = meth->ssl_connect;
3748         else if (hf == sm->ssl_accept)
3749             s->handshake_func = meth->ssl_accept;
3750     }
3751     return ret;
3752 }
3753
3754 int SSL_get_error(const SSL *s, int i)
3755 {
3756     int reason;
3757     unsigned long l;
3758     BIO *bio;
3759
3760     if (i > 0)
3761         return SSL_ERROR_NONE;
3762
3763     /*
3764      * Make things return SSL_ERROR_SYSCALL when doing SSL_do_handshake etc,
3765      * where we do encode the error
3766      */
3767     if ((l = ERR_peek_error()) != 0) {
3768         if (ERR_GET_LIB(l) == ERR_LIB_SYS)
3769             return SSL_ERROR_SYSCALL;
3770         else
3771             return SSL_ERROR_SSL;
3772     }
3773
3774     if (SSL_want_read(s)) {
3775         bio = SSL_get_rbio(s);
3776         if (BIO_should_read(bio))
3777             return SSL_ERROR_WANT_READ;
3778         else if (BIO_should_write(bio))
3779             /*
3780              * This one doesn't make too much sense ... We never try to write
3781              * to the rbio, and an application program where rbio and wbio
3782              * are separate couldn't even know what it should wait for.
3783              * However if we ever set s->rwstate incorrectly (so that we have
3784              * SSL_want_read(s) instead of SSL_want_write(s)) and rbio and
3785              * wbio *are* the same, this test works around that bug; so it
3786              * might be safer to keep it.
3787              */
3788             return SSL_ERROR_WANT_WRITE;
3789         else if (BIO_should_io_special(bio)) {
3790             reason = BIO_get_retry_reason(bio);
3791             if (reason == BIO_RR_CONNECT)
3792                 return SSL_ERROR_WANT_CONNECT;
3793             else if (reason == BIO_RR_ACCEPT)
3794                 return SSL_ERROR_WANT_ACCEPT;
3795             else
3796                 return SSL_ERROR_SYSCALL; /* unknown */
3797         }
3798     }
3799
3800     if (SSL_want_write(s)) {
3801         /* Access wbio directly - in order to use the buffered bio if present */
3802         bio = s->wbio;
3803         if (BIO_should_write(bio))
3804             return SSL_ERROR_WANT_WRITE;
3805         else if (BIO_should_read(bio))
3806             /*
3807              * See above (SSL_want_read(s) with BIO_should_write(bio))
3808              */
3809             return SSL_ERROR_WANT_READ;
3810         else if (BIO_should_io_special(bio)) {
3811             reason = BIO_get_retry_reason(bio);
3812             if (reason == BIO_RR_CONNECT)
3813                 return SSL_ERROR_WANT_CONNECT;
3814             else if (reason == BIO_RR_ACCEPT)
3815                 return SSL_ERROR_WANT_ACCEPT;
3816             else
3817                 return SSL_ERROR_SYSCALL;
3818         }
3819     }
3820     if (SSL_want_x509_lookup(s))
3821         return SSL_ERROR_WANT_X509_LOOKUP;
3822     if (SSL_want_async(s))
3823         return SSL_ERROR_WANT_ASYNC;
3824     if (SSL_want_async_job(s))
3825         return SSL_ERROR_WANT_ASYNC_JOB;
3826     if (SSL_want_client_hello_cb(s))
3827         return SSL_ERROR_WANT_CLIENT_HELLO_CB;
3828
3829     if ((s->shutdown & SSL_RECEIVED_SHUTDOWN) &&
3830         (s->s3.warn_alert == SSL_AD_CLOSE_NOTIFY))
3831         return SSL_ERROR_ZERO_RETURN;
3832
3833     return SSL_ERROR_SYSCALL;
3834 }
3835
3836 static int ssl_do_handshake_intern(void *vargs)
3837 {
3838     struct ssl_async_args *args;
3839     SSL *s;
3840
3841     args = (struct ssl_async_args *)vargs;
3842     s = args->s;
3843
3844     return s->handshake_func(s);
3845 }
3846
3847 int SSL_do_handshake(SSL *s)
3848 {
3849     int ret = 1;
3850
3851     if (s->handshake_func == NULL) {
3852         SSLerr(SSL_F_SSL_DO_HANDSHAKE, SSL_R_CONNECTION_TYPE_NOT_SET);
3853         return -1;
3854     }
3855
3856     ossl_statem_check_finish_init(s, -1);
3857
3858     s->method->ssl_renegotiate_check(s, 0);
3859
3860     if (SSL_in_init(s) || SSL_in_before(s)) {
3861         if ((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
3862             struct ssl_async_args args;
3863
3864             args.s = s;
3865
3866             ret = ssl_start_async_job(s, &args, ssl_do_handshake_intern);
3867         } else {
3868             ret = s->handshake_func(s);
3869         }
3870     }
3871     return ret;
3872 }
3873
3874 void SSL_set_accept_state(SSL *s)
3875 {
3876     s->server = 1;
3877     s->shutdown = 0;
3878     ossl_statem_clear(s);
3879     s->handshake_func = s->method->ssl_accept;
3880     clear_ciphers(s);
3881 }
3882
3883 void SSL_set_connect_state(SSL *s)
3884 {
3885     s->server = 0;
3886     s->shutdown = 0;
3887     ossl_statem_clear(s);
3888     s->handshake_func = s->method->ssl_connect;
3889     clear_ciphers(s);
3890 }
3891
3892 int ssl_undefined_function(SSL *s)
3893 {
3894     SSLerr(SSL_F_SSL_UNDEFINED_FUNCTION, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
3895     return 0;
3896 }
3897
3898 int ssl_undefined_void_function(void)
3899 {
3900     SSLerr(SSL_F_SSL_UNDEFINED_VOID_FUNCTION,
3901            ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
3902     return 0;
3903 }
3904
3905 int ssl_undefined_const_function(const SSL *s)
3906 {
3907     return 0;
3908 }
3909
3910 const SSL_METHOD *ssl_bad_method(int ver)
3911 {
3912     SSLerr(SSL_F_SSL_BAD_METHOD, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
3913     return NULL;
3914 }
3915
3916 const char *ssl_protocol_to_string(int version)
3917 {
3918     switch(version)
3919     {
3920     case TLS1_3_VERSION:
3921         return "TLSv1.3";
3922
3923     case TLS1_2_VERSION:
3924         return "TLSv1.2";
3925
3926     case TLS1_1_VERSION:
3927         return "TLSv1.1";
3928
3929     case TLS1_VERSION:
3930         return "TLSv1";
3931
3932     case SSL3_VERSION:
3933         return "SSLv3";
3934
3935     case DTLS1_BAD_VER:
3936         return "DTLSv0.9";
3937
3938     case DTLS1_VERSION:
3939         return "DTLSv1";
3940
3941     case DTLS1_2_VERSION:
3942         return "DTLSv1.2";
3943
3944     default:
3945         return "unknown";
3946     }
3947 }
3948
3949 const char *SSL_get_version(const SSL *s)
3950 {
3951     return ssl_protocol_to_string(s->version);
3952 }
3953
3954 static int dup_ca_names(STACK_OF(X509_NAME) **dst, STACK_OF(X509_NAME) *src)
3955 {
3956     STACK_OF(X509_NAME) *sk;
3957     X509_NAME *xn;
3958     int i;
3959
3960     if (src == NULL) {
3961         *dst = NULL;
3962         return 1;
3963     }
3964
3965     if ((sk = sk_X509_NAME_new_null()) == NULL)
3966         return 0;
3967     for (i = 0; i < sk_X509_NAME_num(src); i++) {
3968         xn = X509_NAME_dup(sk_X509_NAME_value(src, i));
3969         if (xn == NULL) {
3970             sk_X509_NAME_pop_free(sk, X509_NAME_free);
3971             return 0;
3972         }
3973         if (sk_X509_NAME_insert(sk, xn, i) == 0) {
3974             X509_NAME_free(xn);
3975             sk_X509_NAME_pop_free(sk, X509_NAME_free);
3976             return 0;
3977         }
3978     }
3979     *dst = sk;
3980
3981     return 1;
3982 }
3983
3984 SSL *SSL_dup(SSL *s)
3985 {
3986     SSL *ret;
3987     int i;
3988
3989     /* If we're not quiescent, just up_ref! */
3990     if (!SSL_in_init(s) || !SSL_in_before(s)) {
3991         CRYPTO_UP_REF(&s->references, &i, s->lock);
3992         return s;
3993     }
3994
3995     /*
3996      * Otherwise, copy configuration state, and session if set.
3997      */
3998     if ((ret = SSL_new(SSL_get_SSL_CTX(s))) == NULL)
3999         return NULL;
4000
4001     if (s->session != NULL) {
4002         /*
4003          * Arranges to share the same session via up_ref.  This "copies"
4004          * session-id, SSL_METHOD, sid_ctx, and 'cert'
4005          */
4006         if (!SSL_copy_session_id(ret, s))
4007             goto err;
4008     } else {
4009         /*
4010          * No session has been established yet, so we have to expect that
4011          * s->cert or ret->cert will be changed later -- they should not both
4012          * point to the same object, and thus we can't use
4013          * SSL_copy_session_id.
4014          */
4015         if (!SSL_set_ssl_method(ret, s->method))
4016             goto err;
4017
4018         if (s->cert != NULL) {
4019             ssl_cert_free(ret->cert);
4020             ret->cert = ssl_cert_dup(s->cert);
4021             if (ret->cert == NULL)
4022                 goto err;
4023         }
4024
4025         if (!SSL_set_session_id_context(ret, s->sid_ctx,
4026                                         (int)s->sid_ctx_length))
4027             goto err;
4028     }
4029
4030     if (!ssl_dane_dup(ret, s))
4031         goto err;
4032     ret->version = s->version;
4033     ret->options = s->options;
4034     ret->min_proto_version = s->min_proto_version;
4035     ret->max_proto_version = s->max_proto_version;
4036     ret->mode = s->mode;
4037     SSL_set_max_cert_list(ret, SSL_get_max_cert_list(s));
4038     SSL_set_read_ahead(ret, SSL_get_read_ahead(s));
4039     ret->msg_callback = s->msg_callback;
4040     ret->msg_callback_arg = s->msg_callback_arg;
4041     SSL_set_verify(ret, SSL_get_verify_mode(s), SSL_get_verify_callback(s));
4042     SSL_set_verify_depth(ret, SSL_get_verify_depth(s));
4043     ret->generate_session_id = s->generate_session_id;
4044
4045     SSL_set_info_callback(ret, SSL_get_info_callback(s));
4046
4047     /* copy app data, a little dangerous perhaps */
4048     if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_SSL, &ret->ex_data, &s->ex_data))
4049         goto err;
4050
4051     ret->server = s->server;
4052     if (s->handshake_func) {
4053         if (s->server)
4054             SSL_set_accept_state(ret);
4055         else
4056             SSL_set_connect_state(ret);
4057     }
4058     ret->shutdown = s->shutdown;
4059     ret->hit = s->hit;
4060
4061     ret->default_passwd_callback = s->default_passwd_callback;
4062     ret->default_passwd_callback_userdata = s->default_passwd_callback_userdata;
4063
4064     X509_VERIFY_PARAM_inherit(ret->param, s->param);
4065
4066     /* dup the cipher_list and cipher_list_by_id stacks */
4067     if (s->cipher_list != NULL) {
4068         if ((ret->cipher_list = sk_SSL_CIPHER_dup(s->cipher_list)) == NULL)
4069             goto err;
4070     }
4071     if (s->cipher_list_by_id != NULL)
4072         if ((ret->cipher_list_by_id = sk_SSL_CIPHER_dup(s->cipher_list_by_id))
4073             == NULL)
4074             goto err;
4075
4076     /* Dup the client_CA list */
4077     if (!dup_ca_names(&ret->ca_names, s->ca_names)
4078             || !dup_ca_names(&ret->client_ca_names, s->client_ca_names))
4079         goto err;
4080
4081     return ret;
4082
4083  err:
4084     SSL_free(ret);
4085     return NULL;
4086 }
4087
4088 void ssl_clear_cipher_ctx(SSL *s)
4089 {
4090     if (s->enc_read_ctx != NULL) {
4091         EVP_CIPHER_CTX_free(s->enc_read_ctx);
4092         s->enc_read_ctx = NULL;
4093     }
4094     if (s->enc_write_ctx != NULL) {
4095         EVP_CIPHER_CTX_free(s->enc_write_ctx);
4096         s->enc_write_ctx = NULL;
4097     }
4098 #ifndef OPENSSL_NO_COMP
4099     COMP_CTX_free(s->expand);
4100     s->expand = NULL;
4101     COMP_CTX_free(s->compress);
4102     s->compress = NULL;
4103 #endif
4104 }
4105
4106 X509 *SSL_get_certificate(const SSL *s)
4107 {
4108     if (s->cert != NULL)
4109         return s->cert->key->x509;
4110     else
4111         return NULL;
4112 }
4113
4114 EVP_PKEY *SSL_get_privatekey(const SSL *s)
4115 {
4116     if (s->cert != NULL)
4117         return s->cert->key->privatekey;
4118     else
4119         return NULL;
4120 }
4121
4122 X509 *SSL_CTX_get0_certificate(const SSL_CTX *ctx)
4123 {
4124     if (ctx->cert != NULL)
4125         return ctx->cert->key->x509;
4126     else
4127         return NULL;
4128 }
4129
4130 EVP_PKEY *SSL_CTX_get0_privatekey(const SSL_CTX *ctx)
4131 {
4132     if (ctx->cert != NULL)
4133         return ctx->cert->key->privatekey;
4134     else
4135         return NULL;
4136 }
4137
4138 const SSL_CIPHER *SSL_get_current_cipher(const SSL *s)
4139 {
4140     if ((s->session != NULL) && (s->session->cipher != NULL))
4141         return s->session->cipher;
4142     return NULL;
4143 }
4144
4145 const SSL_CIPHER *SSL_get_pending_cipher(const SSL *s)
4146 {
4147     return s->s3.tmp.new_cipher;
4148 }
4149
4150 const COMP_METHOD *SSL_get_current_compression(const SSL *s)
4151 {
4152 #ifndef OPENSSL_NO_COMP
4153     return s->compress ? COMP_CTX_get_method(s->compress) : NULL;
4154 #else
4155     return NULL;
4156 #endif
4157 }
4158
4159 const COMP_METHOD *SSL_get_current_expansion(const SSL *s)
4160 {
4161 #ifndef OPENSSL_NO_COMP
4162     return s->expand ? COMP_CTX_get_method(s->expand) : NULL;
4163 #else
4164     return NULL;
4165 #endif
4166 }
4167
4168 int ssl_init_wbio_buffer(SSL *s)
4169 {
4170     BIO *bbio;
4171
4172     if (s->bbio != NULL) {
4173         /* Already buffered. */
4174         return 1;
4175     }
4176
4177     bbio = BIO_new(BIO_f_buffer());
4178     if (bbio == NULL || !BIO_set_read_buffer_size(bbio, 1)) {
4179         BIO_free(bbio);
4180         SSLerr(SSL_F_SSL_INIT_WBIO_BUFFER, ERR_R_BUF_LIB);
4181         return 0;
4182     }
4183     s->bbio = bbio;
4184     s->wbio = BIO_push(bbio, s->wbio);
4185
4186     return 1;
4187 }
4188
4189 int ssl_free_wbio_buffer(SSL *s)
4190 {
4191     /* callers ensure s is never null */
4192     if (s->bbio == NULL)
4193         return 1;
4194
4195     s->wbio = BIO_pop(s->wbio);
4196     BIO_free(s->bbio);
4197     s->bbio = NULL;
4198
4199     return 1;
4200 }
4201
4202 void SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx, int mode)
4203 {
4204     ctx->quiet_shutdown = mode;
4205 }
4206
4207 int SSL_CTX_get_quiet_shutdown(const SSL_CTX *ctx)
4208 {
4209     return ctx->quiet_shutdown;
4210 }
4211
4212 void SSL_set_quiet_shutdown(SSL *s, int mode)
4213 {
4214     s->quiet_shutdown = mode;
4215 }
4216
4217 int SSL_get_quiet_shutdown(const SSL *s)
4218 {
4219     return s->quiet_shutdown;
4220 }
4221
4222 void SSL_set_shutdown(SSL *s, int mode)
4223 {
4224     s->shutdown = mode;
4225 }
4226
4227 int SSL_get_shutdown(const SSL *s)
4228 {
4229     return s->shutdown;
4230 }
4231
4232 int SSL_version(const SSL *s)
4233 {
4234     return s->version;
4235 }
4236
4237 int SSL_client_version(const SSL *s)
4238 {
4239     return s->client_version;
4240 }
4241
4242 SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl)
4243 {
4244     return ssl->ctx;
4245 }
4246
4247 SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX *ctx)
4248 {
4249     CERT *new_cert;
4250     if (ssl->ctx == ctx)
4251         return ssl->ctx;
4252     if (ctx == NULL)
4253         ctx = ssl->session_ctx;
4254     new_cert = ssl_cert_dup(ctx->cert);
4255     if (new_cert == NULL) {
4256         return NULL;
4257     }
4258
4259     if (!custom_exts_copy_flags(&new_cert->custext, &ssl->cert->custext)) {
4260         ssl_cert_free(new_cert);
4261         return NULL;
4262     }
4263
4264     ssl_cert_free(ssl->cert);
4265     ssl->cert = new_cert;
4266
4267     /*
4268      * Program invariant: |sid_ctx| has fixed size (SSL_MAX_SID_CTX_LENGTH),
4269      * so setter APIs must prevent invalid lengths from entering the system.
4270      */
4271     if (!ossl_assert(ssl->sid_ctx_length <= sizeof(ssl->sid_ctx)))
4272         return NULL;
4273
4274     /*
4275      * If the session ID context matches that of the parent SSL_CTX,
4276      * inherit it from the new SSL_CTX as well. If however the context does
4277      * not match (i.e., it was set per-ssl with SSL_set_session_id_context),
4278      * leave it unchanged.
4279      */
4280     if ((ssl->ctx != NULL) &&
4281         (ssl->sid_ctx_length == ssl->ctx->sid_ctx_length) &&
4282         (memcmp(ssl->sid_ctx, ssl->ctx->sid_ctx, ssl->sid_ctx_length) == 0)) {
4283         ssl->sid_ctx_length = ctx->sid_ctx_length;
4284         memcpy(&ssl->sid_ctx, &ctx->sid_ctx, sizeof(ssl->sid_ctx));
4285     }
4286
4287     SSL_CTX_up_ref(ctx);
4288     SSL_CTX_free(ssl->ctx);     /* decrement reference count */
4289     ssl->ctx = ctx;
4290
4291     return ssl->ctx;
4292 }
4293
4294 int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx)
4295 {
4296     return X509_STORE_set_default_paths_with_libctx(ctx->cert_store,
4297                                                     ctx->libctx, ctx->propq);
4298 }
4299
4300 int SSL_CTX_set_default_verify_dir(SSL_CTX *ctx)
4301 {
4302     X509_LOOKUP *lookup;
4303
4304     lookup = X509_STORE_add_lookup(ctx->cert_store, X509_LOOKUP_hash_dir());
4305     if (lookup == NULL)
4306         return 0;
4307
4308     /* We ignore errors, in case the directory doesn't exist */
4309     ERR_set_mark();
4310
4311     X509_LOOKUP_add_dir(lookup, NULL, X509_FILETYPE_DEFAULT);
4312
4313     ERR_pop_to_mark();
4314
4315     return 1;
4316 }
4317
4318 int SSL_CTX_set_default_verify_file(SSL_CTX *ctx)
4319 {
4320     X509_LOOKUP *lookup;
4321
4322     lookup = X509_STORE_add_lookup(ctx->cert_store, X509_LOOKUP_file());
4323     if (lookup == NULL)
4324         return 0;
4325
4326     /* We ignore errors, in case the directory doesn't exist */
4327     ERR_set_mark();
4328
4329     X509_LOOKUP_load_file_with_libctx(lookup, NULL, X509_FILETYPE_DEFAULT,
4330                                       ctx->libctx, ctx->propq);
4331
4332     ERR_pop_to_mark();
4333
4334     return 1;
4335 }
4336
4337 int SSL_CTX_set_default_verify_store(SSL_CTX *ctx)
4338 {
4339     X509_LOOKUP *lookup;
4340
4341     lookup = X509_STORE_add_lookup(ctx->cert_store, X509_LOOKUP_store());
4342     if (lookup == NULL)
4343         return 0;
4344
4345     /* We ignore errors, in case the directory doesn't exist */
4346     ERR_set_mark();
4347
4348     X509_LOOKUP_add_store_with_libctx(lookup, NULL, ctx->libctx, ctx->propq);
4349
4350     ERR_pop_to_mark();
4351
4352     return 1;
4353 }
4354
4355 int SSL_CTX_load_verify_file(SSL_CTX *ctx, const char *CAfile)
4356 {
4357     return X509_STORE_load_file_with_libctx(ctx->cert_store, CAfile,
4358                                             ctx->libctx, ctx->propq);
4359 }
4360
4361 int SSL_CTX_load_verify_dir(SSL_CTX *ctx, const char *CApath)
4362 {
4363     return X509_STORE_load_path(ctx->cert_store, CApath);
4364 }
4365
4366 int SSL_CTX_load_verify_store(SSL_CTX *ctx, const char *CAstore)
4367 {
4368     return X509_STORE_load_store_with_libctx(ctx->cert_store, CAstore,
4369                                              ctx->libctx, ctx->propq);
4370 }
4371
4372 int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,
4373                                   const char *CApath)
4374 {
4375     if (CAfile == NULL && CApath == NULL)
4376         return 0;
4377     if (CAfile != NULL && !SSL_CTX_load_verify_file(ctx, CAfile))
4378         return 0;
4379     if (CApath != NULL && !SSL_CTX_load_verify_dir(ctx, CApath))
4380         return 0;
4381     return 1;
4382 }
4383
4384 void SSL_set_info_callback(SSL *ssl,
4385                            void (*cb) (const SSL *ssl, int type, int val))
4386 {
4387     ssl->info_callback = cb;
4388 }
4389
4390 /*
4391  * One compiler (Diab DCC) doesn't like argument names in returned function
4392  * pointer.
4393  */
4394 void (*SSL_get_info_callback(const SSL *ssl)) (const SSL * /* ssl */ ,
4395                                                int /* type */ ,
4396                                                int /* val */ ) {
4397     return ssl->info_callback;
4398 }
4399
4400 void SSL_set_verify_result(SSL *ssl, long arg)
4401 {
4402     ssl->verify_result = arg;
4403 }
4404
4405 long SSL_get_verify_result(const SSL *ssl)
4406 {
4407     return ssl->verify_result;
4408 }
4409
4410 size_t SSL_get_client_random(const SSL *ssl, unsigned char *out, size_t outlen)
4411 {
4412     if (outlen == 0)
4413         return sizeof(ssl->s3.client_random);
4414     if (outlen > sizeof(ssl->s3.client_random))
4415         outlen = sizeof(ssl->s3.client_random);
4416     memcpy(out, ssl->s3.client_random, outlen);
4417     return outlen;
4418 }
4419
4420 size_t SSL_get_server_random(const SSL *ssl, unsigned char *out, size_t outlen)
4421 {
4422     if (outlen == 0)
4423         return sizeof(ssl->s3.server_random);
4424     if (outlen > sizeof(ssl->s3.server_random))
4425         outlen = sizeof(ssl->s3.server_random);
4426     memcpy(out, ssl->s3.server_random, outlen);
4427     return outlen;
4428 }
4429
4430 size_t SSL_SESSION_get_master_key(const SSL_SESSION *session,
4431                                   unsigned char *out, size_t outlen)
4432 {
4433     if (outlen == 0)
4434         return session->master_key_length;
4435     if (outlen > session->master_key_length)
4436         outlen = session->master_key_length;
4437     memcpy(out, session->master_key, outlen);
4438     return outlen;
4439 }
4440
4441 int SSL_SESSION_set1_master_key(SSL_SESSION *sess, const unsigned char *in,
4442                                 size_t len)
4443 {
4444     if (len > sizeof(sess->master_key))
4445         return 0;
4446
4447     memcpy(sess->master_key, in, len);
4448     sess->master_key_length = len;
4449     return 1;
4450 }
4451
4452
4453 int SSL_set_ex_data(SSL *s, int idx, void *arg)
4454 {
4455     return CRYPTO_set_ex_data(&s->ex_data, idx, arg);
4456 }
4457
4458 void *SSL_get_ex_data(const SSL *s, int idx)
4459 {
4460     return CRYPTO_get_ex_data(&s->ex_data, idx);
4461 }
4462
4463 int SSL_CTX_set_ex_data(SSL_CTX *s, int idx, void *arg)
4464 {
4465     return CRYPTO_set_ex_data(&s->ex_data, idx, arg);
4466 }
4467
4468 void *SSL_CTX_get_ex_data(const SSL_CTX *s, int idx)
4469 {
4470     return CRYPTO_get_ex_data(&s->ex_data, idx);
4471 }
4472
4473 X509_STORE *SSL_CTX_get_cert_store(const SSL_CTX *ctx)
4474 {
4475     return ctx->cert_store;
4476 }
4477
4478 void SSL_CTX_set_cert_store(SSL_CTX *ctx, X509_STORE *store)
4479 {
4480     X509_STORE_free(ctx->cert_store);
4481     ctx->cert_store = store;
4482 }
4483
4484 void SSL_CTX_set1_cert_store(SSL_CTX *ctx, X509_STORE *store)
4485 {
4486     if (store != NULL)
4487         X509_STORE_up_ref(store);
4488     SSL_CTX_set_cert_store(ctx, store);
4489 }
4490
4491 int SSL_want(const SSL *s)
4492 {
4493     return s->rwstate;
4494 }
4495
4496 /**
4497  * \brief Set the callback for generating temporary DH keys.
4498  * \param ctx the SSL context.
4499  * \param dh the callback
4500  */
4501
4502 #ifndef OPENSSL_NO_DH
4503 void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,
4504                                  DH *(*dh) (SSL *ssl, int is_export,
4505                                             int keylength))
4506 {
4507     SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_TMP_DH_CB, (void (*)(void))dh);
4508 }
4509
4510 void SSL_set_tmp_dh_callback(SSL *ssl, DH *(*dh) (SSL *ssl, int is_export,
4511                                                   int keylength))
4512 {
4513     SSL_callback_ctrl(ssl, SSL_CTRL_SET_TMP_DH_CB, (void (*)(void))dh);
4514 }
4515 #endif
4516
4517 #ifndef OPENSSL_NO_PSK
4518 int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx, const char *identity_hint)
4519 {
4520     if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN) {
4521         SSLerr(SSL_F_SSL_CTX_USE_PSK_IDENTITY_HINT, SSL_R_DATA_LENGTH_TOO_LONG);
4522         return 0;
4523     }
4524     OPENSSL_free(ctx->cert->psk_identity_hint);
4525     if (identity_hint != NULL) {
4526         ctx->cert->psk_identity_hint = OPENSSL_strdup(identity_hint);
4527         if (ctx->cert->psk_identity_hint == NULL)
4528             return 0;
4529     } else
4530         ctx->cert->psk_identity_hint = NULL;
4531     return 1;
4532 }
4533
4534 int SSL_use_psk_identity_hint(SSL *s, const char *identity_hint)
4535 {
4536     if (s == NULL)
4537         return 0;
4538
4539     if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN) {
4540         SSLerr(SSL_F_SSL_USE_PSK_IDENTITY_HINT, SSL_R_DATA_LENGTH_TOO_LONG);
4541         return 0;
4542     }
4543     OPENSSL_free(s->cert->psk_identity_hint);
4544     if (identity_hint != NULL) {
4545         s->cert->psk_identity_hint = OPENSSL_strdup(identity_hint);
4546         if (s->cert->psk_identity_hint == NULL)
4547             return 0;
4548     } else
4549         s->cert->psk_identity_hint = NULL;
4550     return 1;
4551 }
4552
4553 const char *SSL_get_psk_identity_hint(const SSL *s)
4554 {
4555     if (s == NULL || s->session == NULL)
4556         return NULL;
4557     return s->session->psk_identity_hint;
4558 }
4559
4560 const char *SSL_get_psk_identity(const SSL *s)
4561 {
4562     if (s == NULL || s->session == NULL)
4563         return NULL;
4564     return s->session->psk_identity;
4565 }
4566
4567 void SSL_set_psk_client_callback(SSL *s, SSL_psk_client_cb_func cb)
4568 {
4569     s->psk_client_callback = cb;
4570 }
4571
4572 void SSL_CTX_set_psk_client_callback(SSL_CTX *ctx, SSL_psk_client_cb_func cb)
4573 {
4574     ctx->psk_client_callback = cb;
4575 }
4576
4577 void SSL_set_psk_server_callback(SSL *s, SSL_psk_server_cb_func cb)
4578 {
4579     s->psk_server_callback = cb;
4580 }
4581
4582 void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx, SSL_psk_server_cb_func cb)
4583 {
4584     ctx->psk_server_callback = cb;
4585 }
4586 #endif
4587
4588 void SSL_set_psk_find_session_callback(SSL *s, SSL_psk_find_session_cb_func cb)
4589 {
4590     s->psk_find_session_cb = cb;
4591 }
4592
4593 void SSL_CTX_set_psk_find_session_callback(SSL_CTX *ctx,
4594                                            SSL_psk_find_session_cb_func cb)
4595 {
4596     ctx->psk_find_session_cb = cb;
4597 }
4598
4599 void SSL_set_psk_use_session_callback(SSL *s, SSL_psk_use_session_cb_func cb)
4600 {
4601     s->psk_use_session_cb = cb;
4602 }
4603
4604 void SSL_CTX_set_psk_use_session_callback(SSL_CTX *ctx,
4605                                            SSL_psk_use_session_cb_func cb)
4606 {
4607     ctx->psk_use_session_cb = cb;
4608 }
4609
4610 void SSL_CTX_set_msg_callback(SSL_CTX *ctx,
4611                               void (*cb) (int write_p, int version,
4612                                           int content_type, const void *buf,
4613                                           size_t len, SSL *ssl, void *arg))
4614 {
4615     SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
4616 }
4617
4618 void SSL_set_msg_callback(SSL *ssl,
4619                           void (*cb) (int write_p, int version,
4620                                       int content_type, const void *buf,
4621                                       size_t len, SSL *ssl, void *arg))
4622 {
4623     SSL_callback_ctrl(ssl, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
4624 }
4625
4626 void SSL_CTX_set_not_resumable_session_callback(SSL_CTX *ctx,
4627                                                 int (*cb) (SSL *ssl,
4628                                                            int
4629                                                            is_forward_secure))
4630 {
4631     SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB,
4632                           (void (*)(void))cb);
4633 }
4634
4635 void SSL_set_not_resumable_session_callback(SSL *ssl,
4636                                             int (*cb) (SSL *ssl,
4637                                                        int is_forward_secure))
4638 {
4639     SSL_callback_ctrl(ssl, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB,
4640                       (void (*)(void))cb);
4641 }
4642
4643 void SSL_CTX_set_record_padding_callback(SSL_CTX *ctx,
4644                                          size_t (*cb) (SSL *ssl, int type,
4645                                                        size_t len, void *arg))
4646 {
4647     ctx->record_padding_cb = cb;
4648 }
4649
4650 void SSL_CTX_set_record_padding_callback_arg(SSL_CTX *ctx, void *arg)
4651 {
4652     ctx->record_padding_arg = arg;
4653 }
4654
4655 void *SSL_CTX_get_record_padding_callback_arg(const SSL_CTX *ctx)
4656 {
4657     return ctx->record_padding_arg;
4658 }
4659
4660 int SSL_CTX_set_block_padding(SSL_CTX *ctx, size_t block_size)
4661 {
4662     /* block size of 0 or 1 is basically no padding */
4663     if (block_size == 1)
4664         ctx->block_padding = 0;
4665     else if (block_size <= SSL3_RT_MAX_PLAIN_LENGTH)
4666         ctx->block_padding = block_size;
4667     else
4668         return 0;
4669     return 1;
4670 }
4671
4672 int SSL_set_record_padding_callback(SSL *ssl,
4673                                      size_t (*cb) (SSL *ssl, int type,
4674                                                    size_t len, void *arg))
4675 {
4676     BIO *b;
4677
4678     b = SSL_get_wbio(ssl);
4679     if (b == NULL || !BIO_get_ktls_send(b)) {
4680         ssl->record_padding_cb = cb;
4681         return 1;
4682     }
4683     return 0;
4684 }
4685
4686 void SSL_set_record_padding_callback_arg(SSL *ssl, void *arg)
4687 {
4688     ssl->record_padding_arg = arg;
4689 }
4690
4691 void *SSL_get_record_padding_callback_arg(const SSL *ssl)
4692 {
4693     return ssl->record_padding_arg;
4694 }
4695
4696 int SSL_set_block_padding(SSL *ssl, size_t block_size)
4697 {
4698     /* block size of 0 or 1 is basically no padding */
4699     if (block_size == 1)
4700         ssl->block_padding = 0;
4701     else if (block_size <= SSL3_RT_MAX_PLAIN_LENGTH)
4702         ssl->block_padding = block_size;
4703     else
4704         return 0;
4705     return 1;
4706 }
4707
4708 int SSL_set_num_tickets(SSL *s, size_t num_tickets)
4709 {
4710     s->num_tickets = num_tickets;
4711
4712     return 1;
4713 }
4714
4715 size_t SSL_get_num_tickets(const SSL *s)
4716 {
4717     return s->num_tickets;
4718 }
4719
4720 int SSL_CTX_set_num_tickets(SSL_CTX *ctx, size_t num_tickets)
4721 {
4722     ctx->num_tickets = num_tickets;
4723
4724     return 1;
4725 }
4726
4727 size_t SSL_CTX_get_num_tickets(const SSL_CTX *ctx)
4728 {
4729     return ctx->num_tickets;
4730 }
4731
4732 /*
4733  * Allocates new EVP_MD_CTX and sets pointer to it into given pointer
4734  * variable, freeing EVP_MD_CTX previously stored in that variable, if any.
4735  * If EVP_MD pointer is passed, initializes ctx with this |md|.
4736  * Returns the newly allocated ctx;
4737  */
4738
4739 EVP_MD_CTX *ssl_replace_hash(EVP_MD_CTX **hash, const EVP_MD *md)
4740 {
4741     ssl_clear_hash_ctx(hash);
4742     *hash = EVP_MD_CTX_new();
4743     if (*hash == NULL || (md && EVP_DigestInit_ex(*hash, md, NULL) <= 0)) {
4744         EVP_MD_CTX_free(*hash);
4745         *hash = NULL;
4746         return NULL;
4747     }
4748     return *hash;
4749 }
4750
4751 void ssl_clear_hash_ctx(EVP_MD_CTX **hash)
4752 {
4753
4754     EVP_MD_CTX_free(*hash);
4755     *hash = NULL;
4756 }
4757
4758 /* Retrieve handshake hashes */
4759 int ssl_handshake_hash(SSL *s, unsigned char *out, size_t outlen,
4760                        size_t *hashlen)
4761 {
4762     EVP_MD_CTX *ctx = NULL;
4763     EVP_MD_CTX *hdgst = s->s3.handshake_dgst;
4764     int hashleni = EVP_MD_CTX_size(hdgst);
4765     int ret = 0;
4766
4767     if (hashleni < 0 || (size_t)hashleni > outlen) {
4768         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL_HANDSHAKE_HASH,
4769                  ERR_R_INTERNAL_ERROR);
4770         goto err;
4771     }
4772
4773     ctx = EVP_MD_CTX_new();
4774     if (ctx == NULL)
4775         goto err;
4776
4777     if (!EVP_MD_CTX_copy_ex(ctx, hdgst)
4778         || EVP_DigestFinal_ex(ctx, out, NULL) <= 0) {
4779         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL_HANDSHAKE_HASH,
4780                  ERR_R_INTERNAL_ERROR);
4781         goto err;
4782     }
4783
4784     *hashlen = hashleni;
4785
4786     ret = 1;
4787  err:
4788     EVP_MD_CTX_free(ctx);
4789     return ret;
4790 }
4791
4792 int SSL_session_reused(const SSL *s)
4793 {
4794     return s->hit;
4795 }
4796
4797 int SSL_is_server(const SSL *s)
4798 {
4799     return s->server;
4800 }
4801
4802 #ifndef OPENSSL_NO_DEPRECATED_1_1_0
4803 void SSL_set_debug(SSL *s, int debug)
4804 {
4805     /* Old function was do-nothing anyway... */
4806     (void)s;
4807     (void)debug;
4808 }
4809 #endif
4810
4811 void SSL_set_security_level(SSL *s, int level)
4812 {
4813     s->cert->sec_level = level;
4814 }
4815
4816 int SSL_get_security_level(const SSL *s)
4817 {
4818     return s->cert->sec_level;
4819 }
4820
4821 void SSL_set_security_callback(SSL *s,
4822                                int (*cb) (const SSL *s, const SSL_CTX *ctx,
4823                                           int op, int bits, int nid,
4824                                           void *other, void *ex))
4825 {
4826     s->cert->sec_cb = cb;
4827 }
4828
4829 int (*SSL_get_security_callback(const SSL *s)) (const SSL *s,
4830                                                 const SSL_CTX *ctx, int op,
4831                                                 int bits, int nid, void *other,
4832                                                 void *ex) {
4833     return s->cert->sec_cb;
4834 }
4835
4836 void SSL_set0_security_ex_data(SSL *s, void *ex)
4837 {
4838     s->cert->sec_ex = ex;
4839 }
4840
4841 void *SSL_get0_security_ex_data(const SSL *s)
4842 {
4843     return s->cert->sec_ex;
4844 }
4845
4846 void SSL_CTX_set_security_level(SSL_CTX *ctx, int level)
4847 {
4848     ctx->cert->sec_level = level;
4849 }
4850
4851 int SSL_CTX_get_security_level(const SSL_CTX *ctx)
4852 {
4853     return ctx->cert->sec_level;
4854 }
4855
4856 void SSL_CTX_set_security_callback(SSL_CTX *ctx,
4857                                    int (*cb) (const SSL *s, const SSL_CTX *ctx,
4858                                               int op, int bits, int nid,
4859                                               void *other, void *ex))
4860 {
4861     ctx->cert->sec_cb = cb;
4862 }
4863
4864 int (*SSL_CTX_get_security_callback(const SSL_CTX *ctx)) (const SSL *s,
4865                                                           const SSL_CTX *ctx,
4866                                                           int op, int bits,
4867                                                           int nid,
4868                                                           void *other,
4869                                                           void *ex) {
4870     return ctx->cert->sec_cb;
4871 }
4872
4873 void SSL_CTX_set0_security_ex_data(SSL_CTX *ctx, void *ex)
4874 {
4875     ctx->cert->sec_ex = ex;
4876 }
4877
4878 void *SSL_CTX_get0_security_ex_data(const SSL_CTX *ctx)
4879 {
4880     return ctx->cert->sec_ex;
4881 }
4882
4883 /*
4884  * Get/Set/Clear options in SSL_CTX or SSL, formerly macros, now functions that
4885  * can return unsigned long, instead of the generic long return value from the
4886  * control interface.
4887  */
4888 unsigned long SSL_CTX_get_options(const SSL_CTX *ctx)
4889 {
4890     return ctx->options;
4891 }
4892
4893 unsigned long SSL_get_options(const SSL *s)
4894 {
4895     return s->options;
4896 }
4897
4898 unsigned long SSL_CTX_set_options(SSL_CTX *ctx, unsigned long op)
4899 {
4900     return ctx->options |= op;
4901 }
4902
4903 unsigned long SSL_set_options(SSL *s, unsigned long op)
4904 {
4905     return s->options |= op;
4906 }
4907
4908 unsigned long SSL_CTX_clear_options(SSL_CTX *ctx, unsigned long op)
4909 {
4910     return ctx->options &= ~op;
4911 }
4912
4913 unsigned long SSL_clear_options(SSL *s, unsigned long op)
4914 {
4915     return s->options &= ~op;
4916 }
4917
4918 STACK_OF(X509) *SSL_get0_verified_chain(const SSL *s)
4919 {
4920     return s->verified_chain;
4921 }
4922
4923 IMPLEMENT_OBJ_BSEARCH_GLOBAL_CMP_FN(SSL_CIPHER, SSL_CIPHER, ssl_cipher_id);
4924
4925 #ifndef OPENSSL_NO_CT
4926
4927 /*
4928  * Moves SCTs from the |src| stack to the |dst| stack.
4929  * The source of each SCT will be set to |origin|.
4930  * If |dst| points to a NULL pointer, a new stack will be created and owned by
4931  * the caller.
4932  * Returns the number of SCTs moved, or a negative integer if an error occurs.
4933  */
4934 static int ct_move_scts(STACK_OF(SCT) **dst, STACK_OF(SCT) *src,
4935                         sct_source_t origin)
4936 {
4937     int scts_moved = 0;
4938     SCT *sct = NULL;
4939
4940     if (*dst == NULL) {
4941         *dst = sk_SCT_new_null();
4942         if (*dst == NULL) {
4943             SSLerr(SSL_F_CT_MOVE_SCTS, ERR_R_MALLOC_FAILURE);
4944             goto err;
4945         }
4946     }
4947
4948     while ((sct = sk_SCT_pop(src)) != NULL) {
4949         if (SCT_set_source(sct, origin) != 1)
4950             goto err;
4951
4952         if (sk_SCT_push(*dst, sct) <= 0)
4953             goto err;
4954         scts_moved += 1;
4955     }
4956
4957     return scts_moved;
4958  err:
4959     if (sct != NULL)
4960         sk_SCT_push(src, sct);  /* Put the SCT back */
4961     return -1;
4962 }
4963
4964 /*
4965  * Look for data collected during ServerHello and parse if found.
4966  * Returns the number of SCTs extracted.
4967  */
4968 static int ct_extract_tls_extension_scts(SSL *s)
4969 {
4970     int scts_extracted = 0;
4971
4972     if (s->ext.scts != NULL) {
4973         const unsigned char *p = s->ext.scts;
4974         STACK_OF(SCT) *scts = o2i_SCT_LIST(NULL, &p, s->ext.scts_len);
4975
4976         scts_extracted = ct_move_scts(&s->scts, scts, SCT_SOURCE_TLS_EXTENSION);
4977
4978         SCT_LIST_free(scts);
4979     }
4980
4981     return scts_extracted;
4982 }
4983
4984 /*
4985  * Checks for an OCSP response and then attempts to extract any SCTs found if it
4986  * contains an SCT X509 extension. They will be stored in |s->scts|.
4987  * Returns:
4988  * - The number of SCTs extracted, assuming an OCSP response exists.
4989  * - 0 if no OCSP response exists or it contains no SCTs.
4990  * - A negative integer if an error occurs.
4991  */
4992 static int ct_extract_ocsp_response_scts(SSL *s)
4993 {
4994 # ifndef OPENSSL_NO_OCSP
4995     int scts_extracted = 0;
4996     const unsigned char *p;
4997     OCSP_BASICRESP *br = NULL;
4998     OCSP_RESPONSE *rsp = NULL;
4999     STACK_OF(SCT) *scts = NULL;
5000     int i;
5001
5002     if (s->ext.ocsp.resp == NULL || s->ext.ocsp.resp_len == 0)
5003         goto err;
5004
5005     p = s->ext.ocsp.resp;
5006     rsp = d2i_OCSP_RESPONSE(NULL, &p, (int)s->ext.ocsp.resp_len);
5007     if (rsp == NULL)
5008         goto err;
5009
5010     br = OCSP_response_get1_basic(rsp);
5011     if (br == NULL)
5012         goto err;
5013
5014     for (i = 0; i < OCSP_resp_count(br); ++i) {
5015         OCSP_SINGLERESP *single = OCSP_resp_get0(br, i);
5016
5017         if (single == NULL)
5018             continue;
5019
5020         scts =
5021             OCSP_SINGLERESP_get1_ext_d2i(single, NID_ct_cert_scts, NULL, NULL);
5022         scts_extracted =
5023             ct_move_scts(&s->scts, scts, SCT_SOURCE_OCSP_STAPLED_RESPONSE);
5024         if (scts_extracted < 0)
5025             goto err;
5026     }
5027  err:
5028     SCT_LIST_free(scts);
5029     OCSP_BASICRESP_free(br);
5030     OCSP_RESPONSE_free(rsp);
5031     return scts_extracted;
5032 # else
5033     /* Behave as if no OCSP response exists */
5034     return 0;
5035 # endif
5036 }
5037
5038 /*
5039  * Attempts to extract SCTs from the peer certificate.
5040  * Return the number of SCTs extracted, or a negative integer if an error
5041  * occurs.
5042  */
5043 static int ct_extract_x509v3_extension_scts(SSL *s)
5044 {
5045     int scts_extracted = 0;
5046     X509 *cert = s->session != NULL ? s->session->peer : NULL;
5047
5048     if (cert != NULL) {
5049         STACK_OF(SCT) *scts =
5050             X509_get_ext_d2i(cert, NID_ct_precert_scts, NULL, NULL);
5051
5052         scts_extracted =
5053             ct_move_scts(&s->scts, scts, SCT_SOURCE_X509V3_EXTENSION);
5054
5055         SCT_LIST_free(scts);
5056     }
5057
5058     return scts_extracted;
5059 }
5060
5061 /*
5062  * Attempts to find all received SCTs by checking TLS extensions, the OCSP
5063  * response (if it exists) and X509v3 extensions in the certificate.
5064  * Returns NULL if an error occurs.
5065  */
5066 const STACK_OF(SCT) *SSL_get0_peer_scts(SSL *s)
5067 {
5068     if (!s->scts_parsed) {
5069         if (ct_extract_tls_extension_scts(s) < 0 ||
5070             ct_extract_ocsp_response_scts(s) < 0 ||
5071             ct_extract_x509v3_extension_scts(s) < 0)
5072             goto err;
5073
5074         s->scts_parsed = 1;
5075     }
5076     return s->scts;
5077  err:
5078     return NULL;
5079 }
5080
5081 static int ct_permissive(const CT_POLICY_EVAL_CTX * ctx,
5082                          const STACK_OF(SCT) *scts, void *unused_arg)
5083 {
5084     return 1;
5085 }
5086
5087 static int ct_strict(const CT_POLICY_EVAL_CTX * ctx,
5088                      const STACK_OF(SCT) *scts, void *unused_arg)
5089 {
5090     int count = scts != NULL ? sk_SCT_num(scts) : 0;
5091     int i;
5092
5093     for (i = 0; i < count; ++i) {
5094         SCT *sct = sk_SCT_value(scts, i);
5095         int status = SCT_get_validation_status(sct);
5096
5097         if (status == SCT_VALIDATION_STATUS_VALID)
5098             return 1;
5099     }
5100     SSLerr(SSL_F_CT_STRICT, SSL_R_NO_VALID_SCTS);
5101     return 0;
5102 }
5103
5104 int SSL_set_ct_validation_callback(SSL *s, ssl_ct_validation_cb callback,
5105                                    void *arg)
5106 {
5107     /*
5108      * Since code exists that uses the custom extension handler for CT, look
5109      * for this and throw an error if they have already registered to use CT.
5110      */
5111     if (callback != NULL && SSL_CTX_has_client_custom_ext(s->ctx,
5112                                                           TLSEXT_TYPE_signed_certificate_timestamp))
5113     {
5114         SSLerr(SSL_F_SSL_SET_CT_VALIDATION_CALLBACK,
5115                SSL_R_CUSTOM_EXT_HANDLER_ALREADY_INSTALLED);
5116         return 0;
5117     }
5118
5119     if (callback != NULL) {
5120         /*
5121          * If we are validating CT, then we MUST accept SCTs served via OCSP
5122          */
5123         if (!SSL_set_tlsext_status_type(s, TLSEXT_STATUSTYPE_ocsp))
5124             return 0;
5125     }
5126
5127     s->ct_validation_callback = callback;
5128     s->ct_validation_callback_arg = arg;
5129
5130     return 1;
5131 }
5132
5133 int SSL_CTX_set_ct_validation_callback(SSL_CTX *ctx,
5134                                        ssl_ct_validation_cb callback, void *arg)
5135 {
5136     /*
5137      * Since code exists that uses the custom extension handler for CT, look for
5138      * this and throw an error if they have already registered to use CT.
5139      */
5140     if (callback != NULL && SSL_CTX_has_client_custom_ext(ctx,
5141                                                           TLSEXT_TYPE_signed_certificate_timestamp))
5142     {
5143         SSLerr(SSL_F_SSL_CTX_SET_CT_VALIDATION_CALLBACK,
5144                SSL_R_CUSTOM_EXT_HANDLER_ALREADY_INSTALLED);
5145         return 0;
5146     }
5147
5148     ctx->ct_validation_callback = callback;
5149     ctx->ct_validation_callback_arg = arg;
5150     return 1;
5151 }
5152
5153 int SSL_ct_is_enabled(const SSL *s)
5154 {
5155     return s->ct_validation_callback != NULL;
5156 }
5157
5158 int SSL_CTX_ct_is_enabled(const SSL_CTX *ctx)
5159 {
5160     return ctx->ct_validation_callback != NULL;
5161 }
5162
5163 int ssl_validate_ct(SSL *s)
5164 {
5165     int ret = 0;
5166     X509 *cert = s->session != NULL ? s->session->peer : NULL;
5167     X509 *issuer;
5168     SSL_DANE *dane = &s->dane;
5169     CT_POLICY_EVAL_CTX *ctx = NULL;
5170     const STACK_OF(SCT) *scts;
5171
5172     /*
5173      * If no callback is set, the peer is anonymous, or its chain is invalid,
5174      * skip SCT validation - just return success.  Applications that continue
5175      * handshakes without certificates, with unverified chains, or pinned leaf
5176      * certificates are outside the scope of the WebPKI and CT.
5177      *
5178      * The above exclusions notwithstanding the vast majority of peers will
5179      * have rather ordinary certificate chains validated by typical
5180      * applications that perform certificate verification and therefore will
5181      * process SCTs when enabled.
5182      */
5183     if (s->ct_validation_callback == NULL || cert == NULL ||
5184         s->verify_result != X509_V_OK ||
5185         s->verified_chain == NULL || sk_X509_num(s->verified_chain) <= 1)
5186         return 1;
5187
5188     /*
5189      * CT not applicable for chains validated via DANE-TA(2) or DANE-EE(3)
5190      * trust-anchors.  See https://tools.ietf.org/html/rfc7671#section-4.2
5191      */
5192     if (DANETLS_ENABLED(dane) && dane->mtlsa != NULL) {
5193         switch (dane->mtlsa->usage) {
5194         case DANETLS_USAGE_DANE_TA:
5195         case DANETLS_USAGE_DANE_EE:
5196             return 1;
5197         }
5198     }
5199
5200     ctx = CT_POLICY_EVAL_CTX_new_with_libctx(s->ctx->libctx, s->ctx->propq);
5201     if (ctx == NULL) {
5202         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL_VALIDATE_CT,
5203                  ERR_R_MALLOC_FAILURE);
5204         goto end;
5205     }
5206
5207     issuer = sk_X509_value(s->verified_chain, 1);
5208     CT_POLICY_EVAL_CTX_set1_cert(ctx, cert);
5209     CT_POLICY_EVAL_CTX_set1_issuer(ctx, issuer);
5210     CT_POLICY_EVAL_CTX_set_shared_CTLOG_STORE(ctx, s->ctx->ctlog_store);
5211     CT_POLICY_EVAL_CTX_set_time(
5212             ctx, (uint64_t)SSL_SESSION_get_time(SSL_get0_session(s)) * 1000);
5213
5214     scts = SSL_get0_peer_scts(s);
5215
5216     /*
5217      * This function returns success (> 0) only when all the SCTs are valid, 0
5218      * when some are invalid, and < 0 on various internal errors (out of
5219      * memory, etc.).  Having some, or even all, invalid SCTs is not sufficient
5220      * reason to abort the handshake, that decision is up to the callback.
5221      * Therefore, we error out only in the unexpected case that the return
5222      * value is negative.
5223      *
5224      * XXX: One might well argue that the return value of this function is an
5225      * unfortunate design choice.  Its job is only to determine the validation
5226      * status of each of the provided SCTs.  So long as it correctly separates
5227      * the wheat from the chaff it should return success.  Failure in this case
5228      * ought to correspond to an inability to carry out its duties.
5229      */
5230     if (SCT_LIST_validate(scts, ctx) < 0) {
5231         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_F_SSL_VALIDATE_CT,
5232                  SSL_R_SCT_VERIFICATION_FAILED);
5233         goto end;
5234     }
5235
5236     ret = s->ct_validation_callback(ctx, scts, s->ct_validation_callback_arg);
5237     if (ret < 0)
5238         ret = 0;                /* This function returns 0 on failure */
5239     if (!ret)
5240         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_F_SSL_VALIDATE_CT,
5241                  SSL_R_CALLBACK_FAILED);
5242
5243  end:
5244     CT_POLICY_EVAL_CTX_free(ctx);
5245     /*
5246      * With SSL_VERIFY_NONE the session may be cached and re-used despite a
5247      * failure return code here.  Also the application may wish the complete
5248      * the handshake, and then disconnect cleanly at a higher layer, after
5249      * checking the verification status of the completed connection.
5250      *
5251      * We therefore force a certificate verification failure which will be
5252      * visible via SSL_get_verify_result() and cached as part of any resumed
5253      * session.
5254      *
5255      * Note: the permissive callback is for information gathering only, always
5256      * returns success, and does not affect verification status.  Only the
5257      * strict callback or a custom application-specified callback can trigger
5258      * connection failure or record a verification error.
5259      */
5260     if (ret <= 0)
5261         s->verify_result = X509_V_ERR_NO_VALID_SCTS;
5262     return ret;
5263 }
5264
5265 int SSL_CTX_enable_ct(SSL_CTX *ctx, int validation_mode)
5266 {
5267     switch (validation_mode) {
5268     default:
5269         SSLerr(SSL_F_SSL_CTX_ENABLE_CT, SSL_R_INVALID_CT_VALIDATION_TYPE);
5270         return 0;
5271     case SSL_CT_VALIDATION_PERMISSIVE:
5272         return SSL_CTX_set_ct_validation_callback(ctx, ct_permissive, NULL);
5273     case SSL_CT_VALIDATION_STRICT:
5274         return SSL_CTX_set_ct_validation_callback(ctx, ct_strict, NULL);
5275     }
5276 }
5277
5278 int SSL_enable_ct(SSL *s, int validation_mode)
5279 {
5280     switch (validation_mode) {
5281     default:
5282         SSLerr(SSL_F_SSL_ENABLE_CT, SSL_R_INVALID_CT_VALIDATION_TYPE);
5283         return 0;
5284     case SSL_CT_VALIDATION_PERMISSIVE:
5285         return SSL_set_ct_validation_callback(s, ct_permissive, NULL);
5286     case SSL_CT_VALIDATION_STRICT:
5287         return SSL_set_ct_validation_callback(s, ct_strict, NULL);
5288     }
5289 }
5290
5291 int SSL_CTX_set_default_ctlog_list_file(SSL_CTX *ctx)
5292 {
5293     return CTLOG_STORE_load_default_file(ctx->ctlog_store);
5294 }
5295
5296 int SSL_CTX_set_ctlog_list_file(SSL_CTX *ctx, const char *path)
5297 {
5298     return CTLOG_STORE_load_file(ctx->ctlog_store, path);
5299 }
5300
5301 void SSL_CTX_set0_ctlog_store(SSL_CTX *ctx, CTLOG_STORE * logs)
5302 {
5303     CTLOG_STORE_free(ctx->ctlog_store);
5304     ctx->ctlog_store = logs;
5305 }
5306
5307 const CTLOG_STORE *SSL_CTX_get0_ctlog_store(const SSL_CTX *ctx)
5308 {
5309     return ctx->ctlog_store;
5310 }
5311
5312 #endif  /* OPENSSL_NO_CT */
5313
5314 void SSL_CTX_set_client_hello_cb(SSL_CTX *c, SSL_client_hello_cb_fn cb,
5315                                  void *arg)
5316 {
5317     c->client_hello_cb = cb;
5318     c->client_hello_cb_arg = arg;
5319 }
5320
5321 int SSL_client_hello_isv2(SSL *s)
5322 {
5323     if (s->clienthello == NULL)
5324         return 0;
5325     return s->clienthello->isv2;
5326 }
5327
5328 unsigned int SSL_client_hello_get0_legacy_version(SSL *s)
5329 {
5330     if (s->clienthello == NULL)
5331         return 0;
5332     return s->clienthello->legacy_version;
5333 }
5334
5335 size_t SSL_client_hello_get0_random(SSL *s, const unsigned char **out)
5336 {
5337     if (s->clienthello == NULL)
5338         return 0;
5339     if (out != NULL)
5340         *out = s->clienthello->random;
5341     return SSL3_RANDOM_SIZE;
5342 }
5343
5344 size_t SSL_client_hello_get0_session_id(SSL *s, const unsigned char **out)
5345 {
5346     if (s->clienthello == NULL)
5347         return 0;
5348     if (out != NULL)
5349         *out = s->clienthello->session_id;
5350     return s->clienthello->session_id_len;
5351 }
5352
5353 size_t SSL_client_hello_get0_ciphers(SSL *s, const unsigned char **out)
5354 {
5355     if (s->clienthello == NULL)
5356         return 0;
5357     if (out != NULL)
5358         *out = PACKET_data(&s->clienthello->ciphersuites);
5359     return PACKET_remaining(&s->clienthello->ciphersuites);
5360 }
5361
5362 size_t SSL_client_hello_get0_compression_methods(SSL *s, const unsigned char **out)
5363 {
5364     if (s->clienthello == NULL)
5365         return 0;
5366     if (out != NULL)
5367         *out = s->clienthello->compressions;
5368     return s->clienthello->compressions_len;
5369 }
5370
5371 int SSL_client_hello_get1_extensions_present(SSL *s, int **out, size_t *outlen)
5372 {
5373     RAW_EXTENSION *ext;
5374     int *present;
5375     size_t num = 0, i;
5376
5377     if (s->clienthello == NULL || out == NULL || outlen == NULL)
5378         return 0;
5379     for (i = 0; i < s->clienthello->pre_proc_exts_len; i++) {
5380         ext = s->clienthello->pre_proc_exts + i;
5381         if (ext->present)
5382             num++;
5383     }
5384     if (num == 0) {
5385         *out = NULL;
5386         *outlen = 0;
5387         return 1;
5388     }
5389     if ((present = OPENSSL_malloc(sizeof(*present) * num)) == NULL) {
5390         SSLerr(SSL_F_SSL_CLIENT_HELLO_GET1_EXTENSIONS_PRESENT,
5391                ERR_R_MALLOC_FAILURE);
5392         return 0;
5393     }
5394     for (i = 0; i < s->clienthello->pre_proc_exts_len; i++) {
5395         ext = s->clienthello->pre_proc_exts + i;
5396         if (ext->present) {
5397             if (ext->received_order >= num)
5398                 goto err;
5399             present[ext->received_order] = ext->type;
5400         }
5401     }
5402     *out = present;
5403     *outlen = num;
5404     return 1;
5405  err:
5406     OPENSSL_free(present);
5407     return 0;
5408 }
5409
5410 int SSL_client_hello_get0_ext(SSL *s, unsigned int type, const unsigned char **out,
5411                        size_t *outlen)
5412 {
5413     size_t i;
5414     RAW_EXTENSION *r;
5415
5416     if (s->clienthello == NULL)
5417         return 0;
5418     for (i = 0; i < s->clienthello->pre_proc_exts_len; ++i) {
5419         r = s->clienthello->pre_proc_exts + i;
5420         if (r->present && r->type == type) {
5421             if (out != NULL)
5422                 *out = PACKET_data(&r->data);
5423             if (outlen != NULL)
5424                 *outlen = PACKET_remaining(&r->data);
5425             return 1;
5426         }
5427     }
5428     return 0;
5429 }
5430
5431 int SSL_free_buffers(SSL *ssl)
5432 {
5433     RECORD_LAYER *rl = &ssl->rlayer;
5434
5435     if (RECORD_LAYER_read_pending(rl) || RECORD_LAYER_write_pending(rl))
5436         return 0;
5437
5438     RECORD_LAYER_release(rl);
5439     return 1;
5440 }
5441
5442 int SSL_alloc_buffers(SSL *ssl)
5443 {
5444     return ssl3_setup_buffers(ssl);
5445 }
5446
5447 void SSL_CTX_set_keylog_callback(SSL_CTX *ctx, SSL_CTX_keylog_cb_func cb)
5448 {
5449     ctx->keylog_callback = cb;
5450 }
5451
5452 SSL_CTX_keylog_cb_func SSL_CTX_get_keylog_callback(const SSL_CTX *ctx)
5453 {
5454     return ctx->keylog_callback;
5455 }
5456
5457 static int nss_keylog_int(const char *prefix,
5458                           SSL *ssl,
5459                           const uint8_t *parameter_1,
5460                           size_t parameter_1_len,
5461                           const uint8_t *parameter_2,
5462                           size_t parameter_2_len)
5463 {
5464     char *out = NULL;
5465     char *cursor = NULL;
5466     size_t out_len = 0;
5467     size_t i;
5468     size_t prefix_len;
5469
5470     if (ssl->ctx->keylog_callback == NULL)
5471         return 1;
5472
5473     /*
5474      * Our output buffer will contain the following strings, rendered with
5475      * space characters in between, terminated by a NULL character: first the
5476      * prefix, then the first parameter, then the second parameter. The
5477      * meaning of each parameter depends on the specific key material being
5478      * logged. Note that the first and second parameters are encoded in
5479      * hexadecimal, so we need a buffer that is twice their lengths.
5480      */
5481     prefix_len = strlen(prefix);
5482     out_len = prefix_len + (2 * parameter_1_len) + (2 * parameter_2_len) + 3;
5483     if ((out = cursor = OPENSSL_malloc(out_len)) == NULL) {
5484         SSLfatal(ssl, SSL_AD_INTERNAL_ERROR, SSL_F_NSS_KEYLOG_INT,
5485                  ERR_R_MALLOC_FAILURE);
5486         return 0;
5487     }
5488
5489     strcpy(cursor, prefix);
5490     cursor += prefix_len;
5491     *cursor++ = ' ';
5492
5493     for (i = 0; i < parameter_1_len; i++) {
5494         sprintf(cursor, "%02x", parameter_1[i]);
5495         cursor += 2;
5496     }
5497     *cursor++ = ' ';
5498
5499     for (i = 0; i < parameter_2_len; i++) {
5500         sprintf(cursor, "%02x", parameter_2[i]);
5501         cursor += 2;
5502     }
5503     *cursor = '\0';
5504
5505     ssl->ctx->keylog_callback(ssl, (const char *)out);
5506     OPENSSL_clear_free(out, out_len);
5507     return 1;
5508
5509 }
5510
5511 int ssl_log_rsa_client_key_exchange(SSL *ssl,
5512                                     const uint8_t *encrypted_premaster,
5513                                     size_t encrypted_premaster_len,
5514                                     const uint8_t *premaster,
5515                                     size_t premaster_len)
5516 {
5517     if (encrypted_premaster_len < 8) {
5518         SSLfatal(ssl, SSL_AD_INTERNAL_ERROR,
5519                  SSL_F_SSL_LOG_RSA_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
5520         return 0;
5521     }
5522
5523     /* We only want the first 8 bytes of the encrypted premaster as a tag. */
5524     return nss_keylog_int("RSA",
5525                           ssl,
5526                           encrypted_premaster,
5527                           8,
5528                           premaster,
5529                           premaster_len);
5530 }
5531
5532 int ssl_log_secret(SSL *ssl,
5533                    const char *label,
5534                    const uint8_t *secret,
5535                    size_t secret_len)
5536 {
5537     return nss_keylog_int(label,
5538                           ssl,
5539                           ssl->s3.client_random,
5540                           SSL3_RANDOM_SIZE,
5541                           secret,
5542                           secret_len);
5543 }
5544
5545 #define SSLV2_CIPHER_LEN    3
5546
5547 int ssl_cache_cipherlist(SSL *s, PACKET *cipher_suites, int sslv2format)
5548 {
5549     int n;
5550
5551     n = sslv2format ? SSLV2_CIPHER_LEN : TLS_CIPHER_LEN;
5552
5553     if (PACKET_remaining(cipher_suites) == 0) {
5554         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_SSL_CACHE_CIPHERLIST,
5555                  SSL_R_NO_CIPHERS_SPECIFIED);
5556         return 0;
5557     }
5558
5559     if (PACKET_remaining(cipher_suites) % n != 0) {
5560         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_SSL_CACHE_CIPHERLIST,
5561                  SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST);
5562         return 0;
5563     }
5564
5565     OPENSSL_free(s->s3.tmp.ciphers_raw);
5566     s->s3.tmp.ciphers_raw = NULL;
5567     s->s3.tmp.ciphers_rawlen = 0;
5568
5569     if (sslv2format) {
5570         size_t numciphers = PACKET_remaining(cipher_suites) / n;
5571         PACKET sslv2ciphers = *cipher_suites;
5572         unsigned int leadbyte;
5573         unsigned char *raw;
5574
5575         /*
5576          * We store the raw ciphers list in SSLv3+ format so we need to do some
5577          * preprocessing to convert the list first. If there are any SSLv2 only
5578          * ciphersuites with a non-zero leading byte then we are going to
5579          * slightly over allocate because we won't store those. But that isn't a
5580          * problem.
5581          */
5582         raw = OPENSSL_malloc(numciphers * TLS_CIPHER_LEN);
5583         s->s3.tmp.ciphers_raw = raw;
5584         if (raw == NULL) {
5585             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL_CACHE_CIPHERLIST,
5586                      ERR_R_MALLOC_FAILURE);
5587             return 0;
5588         }
5589         for (s->s3.tmp.ciphers_rawlen = 0;
5590              PACKET_remaining(&sslv2ciphers) > 0;
5591              raw += TLS_CIPHER_LEN) {
5592             if (!PACKET_get_1(&sslv2ciphers, &leadbyte)
5593                     || (leadbyte == 0
5594                         && !PACKET_copy_bytes(&sslv2ciphers, raw,
5595                                               TLS_CIPHER_LEN))
5596                     || (leadbyte != 0
5597                         && !PACKET_forward(&sslv2ciphers, TLS_CIPHER_LEN))) {
5598                 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_SSL_CACHE_CIPHERLIST,
5599                          SSL_R_BAD_PACKET);
5600                 OPENSSL_free(s->s3.tmp.ciphers_raw);
5601                 s->s3.tmp.ciphers_raw = NULL;
5602                 s->s3.tmp.ciphers_rawlen = 0;
5603                 return 0;
5604             }
5605             if (leadbyte == 0)
5606                 s->s3.tmp.ciphers_rawlen += TLS_CIPHER_LEN;
5607         }
5608     } else if (!PACKET_memdup(cipher_suites, &s->s3.tmp.ciphers_raw,
5609                            &s->s3.tmp.ciphers_rawlen)) {
5610         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL_CACHE_CIPHERLIST,
5611                  ERR_R_INTERNAL_ERROR);
5612         return 0;
5613     }
5614     return 1;
5615 }
5616
5617 int SSL_bytes_to_cipher_list(SSL *s, const unsigned char *bytes, size_t len,
5618                              int isv2format, STACK_OF(SSL_CIPHER) **sk,
5619                              STACK_OF(SSL_CIPHER) **scsvs)
5620 {
5621     PACKET pkt;
5622
5623     if (!PACKET_buf_init(&pkt, bytes, len))
5624         return 0;
5625     return bytes_to_cipher_list(s, &pkt, sk, scsvs, isv2format, 0);
5626 }
5627
5628 int bytes_to_cipher_list(SSL *s, PACKET *cipher_suites,
5629                          STACK_OF(SSL_CIPHER) **skp,
5630                          STACK_OF(SSL_CIPHER) **scsvs_out,
5631                          int sslv2format, int fatal)
5632 {
5633     const SSL_CIPHER *c;
5634     STACK_OF(SSL_CIPHER) *sk = NULL;
5635     STACK_OF(SSL_CIPHER) *scsvs = NULL;
5636     int n;
5637     /* 3 = SSLV2_CIPHER_LEN > TLS_CIPHER_LEN = 2. */
5638     unsigned char cipher[SSLV2_CIPHER_LEN];
5639
5640     n = sslv2format ? SSLV2_CIPHER_LEN : TLS_CIPHER_LEN;
5641
5642     if (PACKET_remaining(cipher_suites) == 0) {
5643         if (fatal)
5644             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_BYTES_TO_CIPHER_LIST,
5645                      SSL_R_NO_CIPHERS_SPECIFIED);
5646         else
5647             SSLerr(SSL_F_BYTES_TO_CIPHER_LIST, SSL_R_NO_CIPHERS_SPECIFIED);
5648         return 0;
5649     }
5650
5651     if (PACKET_remaining(cipher_suites) % n != 0) {
5652         if (fatal)
5653             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_BYTES_TO_CIPHER_LIST,
5654                      SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST);
5655         else
5656             SSLerr(SSL_F_BYTES_TO_CIPHER_LIST,
5657                    SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST);
5658         return 0;
5659     }
5660
5661     sk = sk_SSL_CIPHER_new_null();
5662     scsvs = sk_SSL_CIPHER_new_null();
5663     if (sk == NULL || scsvs == NULL) {
5664         if (fatal)
5665             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_BYTES_TO_CIPHER_LIST,
5666                      ERR_R_MALLOC_FAILURE);
5667         else
5668             SSLerr(SSL_F_BYTES_TO_CIPHER_LIST, ERR_R_MALLOC_FAILURE);
5669         goto err;
5670     }
5671
5672     while (PACKET_copy_bytes(cipher_suites, cipher, n)) {
5673         /*
5674          * SSLv3 ciphers wrapped in an SSLv2-compatible ClientHello have the
5675          * first byte set to zero, while true SSLv2 ciphers have a non-zero
5676          * first byte. We don't support any true SSLv2 ciphers, so skip them.
5677          */
5678         if (sslv2format && cipher[0] != '\0')
5679             continue;
5680
5681         /* For SSLv2-compat, ignore leading 0-byte. */
5682         c = ssl_get_cipher_by_char(s, sslv2format ? &cipher[1] : cipher, 1);
5683         if (c != NULL) {
5684             if ((c->valid && !sk_SSL_CIPHER_push(sk, c)) ||
5685                 (!c->valid && !sk_SSL_CIPHER_push(scsvs, c))) {
5686                 if (fatal)
5687                     SSLfatal(s, SSL_AD_INTERNAL_ERROR,
5688                              SSL_F_BYTES_TO_CIPHER_LIST, ERR_R_MALLOC_FAILURE);
5689                 else
5690                     SSLerr(SSL_F_BYTES_TO_CIPHER_LIST, ERR_R_MALLOC_FAILURE);
5691                 goto err;
5692             }
5693         }
5694     }
5695     if (PACKET_remaining(cipher_suites) > 0) {
5696         if (fatal)
5697             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_BYTES_TO_CIPHER_LIST,
5698                      SSL_R_BAD_LENGTH);
5699         else
5700             SSLerr(SSL_F_BYTES_TO_CIPHER_LIST, SSL_R_BAD_LENGTH);
5701         goto err;
5702     }
5703
5704     if (skp != NULL)
5705         *skp = sk;
5706     else
5707         sk_SSL_CIPHER_free(sk);
5708     if (scsvs_out != NULL)
5709         *scsvs_out = scsvs;
5710     else
5711         sk_SSL_CIPHER_free(scsvs);
5712     return 1;
5713  err:
5714     sk_SSL_CIPHER_free(sk);
5715     sk_SSL_CIPHER_free(scsvs);
5716     return 0;
5717 }
5718
5719 int SSL_CTX_set_max_early_data(SSL_CTX *ctx, uint32_t max_early_data)
5720 {
5721     ctx->max_early_data = max_early_data;
5722
5723     return 1;
5724 }
5725
5726 uint32_t SSL_CTX_get_max_early_data(const SSL_CTX *ctx)
5727 {
5728     return ctx->max_early_data;
5729 }
5730
5731 int SSL_set_max_early_data(SSL *s, uint32_t max_early_data)
5732 {
5733     s->max_early_data = max_early_data;
5734
5735     return 1;
5736 }
5737
5738 uint32_t SSL_get_max_early_data(const SSL *s)
5739 {
5740     return s->max_early_data;
5741 }
5742
5743 int SSL_CTX_set_recv_max_early_data(SSL_CTX *ctx, uint32_t recv_max_early_data)
5744 {
5745     ctx->recv_max_early_data = recv_max_early_data;
5746
5747     return 1;
5748 }
5749
5750 uint32_t SSL_CTX_get_recv_max_early_data(const SSL_CTX *ctx)
5751 {
5752     return ctx->recv_max_early_data;
5753 }
5754
5755 int SSL_set_recv_max_early_data(SSL *s, uint32_t recv_max_early_data)
5756 {
5757     s->recv_max_early_data = recv_max_early_data;
5758
5759     return 1;
5760 }
5761
5762 uint32_t SSL_get_recv_max_early_data(const SSL *s)
5763 {
5764     return s->recv_max_early_data;
5765 }
5766
5767 __owur unsigned int ssl_get_max_send_fragment(const SSL *ssl)
5768 {
5769     /* Return any active Max Fragment Len extension */
5770     if (ssl->session != NULL && USE_MAX_FRAGMENT_LENGTH_EXT(ssl->session))
5771         return GET_MAX_FRAGMENT_LENGTH(ssl->session);
5772
5773     /* return current SSL connection setting */
5774     return ssl->max_send_fragment;
5775 }
5776
5777 __owur unsigned int ssl_get_split_send_fragment(const SSL *ssl)
5778 {
5779     /* Return a value regarding an active Max Fragment Len extension */
5780     if (ssl->session != NULL && USE_MAX_FRAGMENT_LENGTH_EXT(ssl->session)
5781         && ssl->split_send_fragment > GET_MAX_FRAGMENT_LENGTH(ssl->session))
5782         return GET_MAX_FRAGMENT_LENGTH(ssl->session);
5783
5784     /* else limit |split_send_fragment| to current |max_send_fragment| */
5785     if (ssl->split_send_fragment > ssl->max_send_fragment)
5786         return ssl->max_send_fragment;
5787
5788     /* return current SSL connection setting */
5789     return ssl->split_send_fragment;
5790 }
5791
5792 int SSL_stateless(SSL *s)
5793 {
5794     int ret;
5795
5796     /* Ensure there is no state left over from a previous invocation */
5797     if (!SSL_clear(s))
5798         return 0;
5799
5800     ERR_clear_error();
5801
5802     s->s3.flags |= TLS1_FLAGS_STATELESS;
5803     ret = SSL_accept(s);
5804     s->s3.flags &= ~TLS1_FLAGS_STATELESS;
5805
5806     if (ret > 0 && s->ext.cookieok)
5807         return 1;
5808
5809     if (s->hello_retry_request == SSL_HRR_PENDING && !ossl_statem_in_error(s))
5810         return 0;
5811
5812     return -1;
5813 }
5814
5815 void SSL_CTX_set_post_handshake_auth(SSL_CTX *ctx, int val)
5816 {
5817     ctx->pha_enabled = val;
5818 }
5819
5820 void SSL_set_post_handshake_auth(SSL *ssl, int val)
5821 {
5822     ssl->pha_enabled = val;
5823 }
5824
5825 int SSL_verify_client_post_handshake(SSL *ssl)
5826 {
5827     if (!SSL_IS_TLS13(ssl)) {
5828         SSLerr(SSL_F_SSL_VERIFY_CLIENT_POST_HANDSHAKE, SSL_R_WRONG_SSL_VERSION);
5829         return 0;
5830     }
5831     if (!ssl->server) {
5832         SSLerr(SSL_F_SSL_VERIFY_CLIENT_POST_HANDSHAKE, SSL_R_NOT_SERVER);
5833         return 0;
5834     }
5835
5836     if (!SSL_is_init_finished(ssl)) {
5837         SSLerr(SSL_F_SSL_VERIFY_CLIENT_POST_HANDSHAKE, SSL_R_STILL_IN_INIT);
5838         return 0;
5839     }
5840
5841     switch (ssl->post_handshake_auth) {
5842     case SSL_PHA_NONE:
5843         SSLerr(SSL_F_SSL_VERIFY_CLIENT_POST_HANDSHAKE, SSL_R_EXTENSION_NOT_RECEIVED);
5844         return 0;
5845     default:
5846     case SSL_PHA_EXT_SENT:
5847         SSLerr(SSL_F_SSL_VERIFY_CLIENT_POST_HANDSHAKE, ERR_R_INTERNAL_ERROR);
5848         return 0;
5849     case SSL_PHA_EXT_RECEIVED:
5850         break;
5851     case SSL_PHA_REQUEST_PENDING:
5852         SSLerr(SSL_F_SSL_VERIFY_CLIENT_POST_HANDSHAKE, SSL_R_REQUEST_PENDING);
5853         return 0;
5854     case SSL_PHA_REQUESTED:
5855         SSLerr(SSL_F_SSL_VERIFY_CLIENT_POST_HANDSHAKE, SSL_R_REQUEST_SENT);
5856         return 0;
5857     }
5858
5859     ssl->post_handshake_auth = SSL_PHA_REQUEST_PENDING;
5860
5861     /* checks verify_mode and algorithm_auth */
5862     if (!send_certificate_request(ssl)) {
5863         ssl->post_handshake_auth = SSL_PHA_EXT_RECEIVED; /* restore on error */
5864         SSLerr(SSL_F_SSL_VERIFY_CLIENT_POST_HANDSHAKE, SSL_R_INVALID_CONFIG);
5865         return 0;
5866     }
5867
5868     ossl_statem_set_in_init(ssl, 1);
5869     return 1;
5870 }
5871
5872 int SSL_CTX_set_session_ticket_cb(SSL_CTX *ctx,
5873                                   SSL_CTX_generate_session_ticket_fn gen_cb,
5874                                   SSL_CTX_decrypt_session_ticket_fn dec_cb,
5875                                   void *arg)
5876 {
5877     ctx->generate_ticket_cb = gen_cb;
5878     ctx->decrypt_ticket_cb = dec_cb;
5879     ctx->ticket_cb_data = arg;
5880     return 1;
5881 }
5882
5883 void SSL_CTX_set_allow_early_data_cb(SSL_CTX *ctx,
5884                                      SSL_allow_early_data_cb_fn cb,
5885                                      void *arg)
5886 {
5887     ctx->allow_early_data_cb = cb;
5888     ctx->allow_early_data_cb_data = arg;
5889 }
5890
5891 void SSL_set_allow_early_data_cb(SSL *s,
5892                                  SSL_allow_early_data_cb_fn cb,
5893                                  void *arg)
5894 {
5895     s->allow_early_data_cb = cb;
5896     s->allow_early_data_cb_data = arg;
5897 }
5898
5899 const EVP_CIPHER *ssl_evp_cipher_fetch(OPENSSL_CTX *libctx,
5900                                        int nid,
5901                                        const char *properties)
5902 {
5903     EVP_CIPHER *ciph;
5904
5905 #ifndef OPENSSL_NO_ENGINE
5906     ENGINE *eng;
5907
5908     /*
5909      * If there is an Engine available for this cipher we use the "implicit"
5910      * form to ensure we use that engine later.
5911      */
5912     eng = ENGINE_get_cipher_engine(nid);
5913     if (eng != NULL) {
5914         ENGINE_finish(eng);
5915         return EVP_get_cipherbynid(nid);
5916     }
5917 #endif
5918
5919     /* Otherwise we do an explicit fetch. This may fail and that could be ok */
5920     ERR_set_mark();
5921     ciph = EVP_CIPHER_fetch(libctx, OBJ_nid2sn(nid), properties);
5922     ERR_pop_to_mark();
5923     return ciph;
5924 }
5925
5926
5927 int ssl_evp_cipher_up_ref(const EVP_CIPHER *cipher)
5928 {
5929     /* Don't up-ref an implicit EVP_CIPHER */
5930     if (EVP_CIPHER_provider(cipher) == NULL)
5931         return 1;
5932
5933     /*
5934      * The cipher was explicitly fetched and therefore it is safe to cast
5935      * away the const
5936      */
5937     return EVP_CIPHER_up_ref((EVP_CIPHER *)cipher);
5938 }
5939
5940 void ssl_evp_cipher_free(const EVP_CIPHER *cipher)
5941 {
5942     if (cipher == NULL)
5943         return;
5944
5945     if (EVP_CIPHER_provider(cipher) != NULL) {
5946         /*
5947          * The cipher was explicitly fetched and therefore it is safe to cast
5948          * away the const
5949          */
5950         EVP_CIPHER_free((EVP_CIPHER *)cipher);
5951     }
5952 }
5953
5954 const EVP_MD *ssl_evp_md_fetch(OPENSSL_CTX *libctx,
5955                                int nid,
5956                                const char *properties)
5957 {
5958     EVP_MD *md;
5959
5960 #ifndef OPENSSL_NO_ENGINE
5961     ENGINE *eng;
5962
5963     /*
5964      * If there is an Engine available for this digest we use the "implicit"
5965      * form to ensure we use that engine later.
5966      */
5967     eng = ENGINE_get_digest_engine(nid);
5968     if (eng != NULL) {
5969         ENGINE_finish(eng);
5970         return EVP_get_digestbynid(nid);
5971     }
5972 #endif
5973
5974     /* Otherwise we do an explicit fetch */
5975     ERR_set_mark();
5976     md = EVP_MD_fetch(libctx, OBJ_nid2sn(nid), properties);
5977     ERR_pop_to_mark();
5978     return md;
5979 }
5980
5981 int ssl_evp_md_up_ref(const EVP_MD *md)
5982 {
5983     /* Don't up-ref an implicit EVP_MD */
5984     if (EVP_MD_provider(md) == NULL)
5985         return 1;
5986
5987     /*
5988      * The digest was explicitly fetched and therefore it is safe to cast
5989      * away the const
5990      */
5991     return EVP_MD_up_ref((EVP_MD *)md);
5992 }
5993
5994 void ssl_evp_md_free(const EVP_MD *md)
5995 {
5996     if (md == NULL)
5997         return;
5998
5999     if (EVP_MD_provider(md) != NULL) {
6000         /*
6001          * The digest was explicitly fetched and therefore it is safe to cast
6002          * away the const
6003          */
6004         EVP_MD_free((EVP_MD *)md);
6005     }
6006 }