ssl/ssl_lib.c

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