test/sslapitest.c

   1 /*
   2  * Copyright 2016-2024 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 /*
  11  * We need access to the deprecated low level HMAC APIs for legacy purposes
  12  * when the deprecated calls are not hidden
  13  */
  14 #ifndef OPENSSL_NO_DEPRECATED_3_0
  15 # define OPENSSL_SUPPRESS_DEPRECATED
  16 #endif
  17
  18 #include <stdio.h>
  19 #include <string.h>
  20
  21 #include <openssl/opensslconf.h>
  22 #include <openssl/bio.h>
  23 #include <openssl/crypto.h>
  24 #include <openssl/ssl.h>
  25 #include <openssl/ocsp.h>
  26 #include <openssl/srp.h>
  27 #include <openssl/txt_db.h>
  28 #include <openssl/aes.h>
  29 #include <openssl/rand.h>
  30 #include <openssl/core_names.h>
  31 #include <openssl/core_dispatch.h>
  32 #include <openssl/provider.h>
  33 #include <openssl/param_build.h>
  34 #include <openssl/x509v3.h>
  35 #include <openssl/dh.h>
  36 #include <openssl/engine.h>
  37
  38 #include "helpers/ssltestlib.h"
  39 #include "testutil.h"
  40 #include "testutil/output.h"
  41 #include "internal/nelem.h"
  42 #include "internal/tlsgroups.h"
  43 #include "internal/ktls.h"
  44 #include "../ssl/ssl_local.h"
  45 #include "../ssl/record/methods/recmethod_local.h"
  46 #include "filterprov.h"
  47
  48 #undef OSSL_NO_USABLE_TLS1_3
  49 #if defined(OPENSSL_NO_TLS1_3) \
  50     || (defined(OPENSSL_NO_EC) && defined(OPENSSL_NO_DH))
  51 /*
  52  * If we don't have ec or dh then there are no built-in groups that are usable
  53  * with TLSv1.3
  54  */
  55 # define OSSL_NO_USABLE_TLS1_3
  56 #endif
  57
  58 /* Defined in tls-provider.c */
  59 int tls_provider_init(const OSSL_CORE_HANDLE *handle,
  60                       const OSSL_DISPATCH *in,
  61                       const OSSL_DISPATCH **out,
  62                       void **provctx);
  63
  64 static OSSL_LIB_CTX *libctx = NULL;
  65 static OSSL_PROVIDER *defctxnull = NULL;
  66
  67 #ifndef OSSL_NO_USABLE_TLS1_3
  68
  69 static SSL_SESSION *clientpsk = NULL;
  70 static SSL_SESSION *serverpsk = NULL;
  71 static const char *pskid = "Identity";
  72 static const char *srvid;
  73
  74 static int use_session_cb(SSL *ssl, const EVP_MD *md, const unsigned char **id,
  75                           size_t *idlen, SSL_SESSION **sess);
  76 static int find_session_cb(SSL *ssl, const unsigned char *identity,
  77                            size_t identity_len, SSL_SESSION **sess);
  78
  79 static int use_session_cb_cnt = 0;
  80 static int find_session_cb_cnt = 0;
  81 #endif
  82
  83 static char *certsdir = NULL;
  84 static char *cert = NULL;
  85 static char *privkey = NULL;
  86 static char *cert2 = NULL;
  87 static char *privkey2 = NULL;
  88 static char *cert1024 = NULL;
  89 static char *privkey1024 = NULL;
  90 static char *cert3072 = NULL;
  91 static char *privkey3072 = NULL;
  92 static char *cert4096 = NULL;
  93 static char *privkey4096 = NULL;
  94 static char *cert8192 = NULL;
  95 static char *privkey8192 = NULL;
  96 static char *srpvfile = NULL;
  97 static char *tmpfilename = NULL;
  98 static char *dhfile = NULL;
  99
 100 static int is_fips = 0;
 101 static int fips_ems_check = 0;
 102
 103 #define LOG_BUFFER_SIZE 2048
 104 static char server_log_buffer[LOG_BUFFER_SIZE + 1] = {0};
 105 static size_t server_log_buffer_index = 0;
 106 static char client_log_buffer[LOG_BUFFER_SIZE + 1] = {0};
 107 static size_t client_log_buffer_index = 0;
 108 static int error_writing_log = 0;
 109
 110 #ifndef OPENSSL_NO_OCSP
 111 static const unsigned char orespder[] = "Dummy OCSP Response";
 112 static int ocsp_server_called = 0;
 113 static int ocsp_client_called = 0;
 114
 115 static int cdummyarg = 1;
 116 static X509 *ocspcert = NULL;
 117 #endif
 118
 119 #define CLIENT_VERSION_LEN      2
 120
 121 /*
 122  * This structure is used to validate that the correct number of log messages
 123  * of various types are emitted when emitting secret logs.
 124  */
 125 struct sslapitest_log_counts {
 126     unsigned int rsa_key_exchange_count;
 127     unsigned int master_secret_count;
 128     unsigned int client_early_secret_count;
 129     unsigned int client_handshake_secret_count;
 130     unsigned int server_handshake_secret_count;
 131     unsigned int client_application_secret_count;
 132     unsigned int server_application_secret_count;
 133     unsigned int early_exporter_secret_count;
 134     unsigned int exporter_secret_count;
 135 };
 136
 137
 138 static int hostname_cb(SSL *s, int *al, void *arg)
 139 {
 140     const char *hostname = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
 141
 142     if (hostname != NULL && (strcmp(hostname, "goodhost") == 0
 143                              || strcmp(hostname, "altgoodhost") == 0))
 144         return  SSL_TLSEXT_ERR_OK;
 145
 146     return SSL_TLSEXT_ERR_NOACK;
 147 }
 148
 149 static void client_keylog_callback(const SSL *ssl, const char *line)
 150 {
 151     int line_length = strlen(line);
 152
 153     /* If the log doesn't fit, error out. */
 154     if (client_log_buffer_index + line_length > sizeof(client_log_buffer) - 1) {
 155         TEST_info("Client log too full");
 156         error_writing_log = 1;
 157         return;
 158     }
 159
 160     strcat(client_log_buffer, line);
 161     client_log_buffer_index += line_length;
 162     client_log_buffer[client_log_buffer_index++] = '\n';
 163 }
 164
 165 static void server_keylog_callback(const SSL *ssl, const char *line)
 166 {
 167     int line_length = strlen(line);
 168
 169     /* If the log doesn't fit, error out. */
 170     if (server_log_buffer_index + line_length > sizeof(server_log_buffer) - 1) {
 171         TEST_info("Server log too full");
 172         error_writing_log = 1;
 173         return;
 174     }
 175
 176     strcat(server_log_buffer, line);
 177     server_log_buffer_index += line_length;
 178     server_log_buffer[server_log_buffer_index++] = '\n';
 179 }
 180
 181 static int compare_hex_encoded_buffer(const char *hex_encoded,
 182                                       size_t hex_length,
 183                                       const uint8_t *raw,
 184                                       size_t raw_length)
 185 {
 186     size_t i, j;
 187     char hexed[3];
 188
 189     if (!TEST_size_t_eq(raw_length * 2, hex_length))
 190         return 1;
 191
 192     for (i = j = 0; i < raw_length && j + 1 < hex_length; i++, j += 2) {
 193         sprintf(hexed, "%02x", raw[i]);
 194         if (!TEST_int_eq(hexed[0], hex_encoded[j])
 195                 || !TEST_int_eq(hexed[1], hex_encoded[j + 1]))
 196             return 1;
 197     }
 198
 199     return 0;
 200 }
 201
 202 static int test_keylog_output(char *buffer, const SSL *ssl,
 203                               const SSL_SESSION *session,
 204                               struct sslapitest_log_counts *expected)
 205 {
 206     char *token = NULL;
 207     unsigned char actual_client_random[SSL3_RANDOM_SIZE] = {0};
 208     size_t client_random_size = SSL3_RANDOM_SIZE;
 209     unsigned char actual_master_key[SSL_MAX_MASTER_KEY_LENGTH] = {0};
 210     size_t master_key_size = SSL_MAX_MASTER_KEY_LENGTH;
 211     unsigned int rsa_key_exchange_count = 0;
 212     unsigned int master_secret_count = 0;
 213     unsigned int client_early_secret_count = 0;
 214     unsigned int client_handshake_secret_count = 0;
 215     unsigned int server_handshake_secret_count = 0;
 216     unsigned int client_application_secret_count = 0;
 217     unsigned int server_application_secret_count = 0;
 218     unsigned int early_exporter_secret_count = 0;
 219     unsigned int exporter_secret_count = 0;
 220
 221     for (token = strtok(buffer, " \n"); token != NULL;
 222          token = strtok(NULL, " \n")) {
 223         if (strcmp(token, "RSA") == 0) {
 224             /*
 225              * Premaster secret. Tokens should be: 16 ASCII bytes of
 226              * hex-encoded encrypted secret, then the hex-encoded pre-master
 227              * secret.
 228              */
 229             if (!TEST_ptr(token = strtok(NULL, " \n")))
 230                 return 0;
 231             if (!TEST_size_t_eq(strlen(token), 16))
 232                 return 0;
 233             if (!TEST_ptr(token = strtok(NULL, " \n")))
 234                 return 0;
 235             /*
 236              * We can't sensibly check the log because the premaster secret is
 237              * transient, and OpenSSL doesn't keep hold of it once the master
 238              * secret is generated.
 239              */
 240             rsa_key_exchange_count++;
 241         } else if (strcmp(token, "CLIENT_RANDOM") == 0) {
 242             /*
 243              * Master secret. Tokens should be: 64 ASCII bytes of hex-encoded
 244              * client random, then the hex-encoded master secret.
 245              */
 246             client_random_size = SSL_get_client_random(ssl,
 247                                                        actual_client_random,
 248                                                        SSL3_RANDOM_SIZE);
 249             if (!TEST_size_t_eq(client_random_size, SSL3_RANDOM_SIZE))
 250                 return 0;
 251
 252             if (!TEST_ptr(token = strtok(NULL, " \n")))
 253                 return 0;
 254             if (!TEST_size_t_eq(strlen(token), 64))
 255                 return 0;
 256             if (!TEST_false(compare_hex_encoded_buffer(token, 64,
 257                                                        actual_client_random,
 258                                                        client_random_size)))
 259                 return 0;
 260
 261             if (!TEST_ptr(token = strtok(NULL, " \n")))
 262                 return 0;
 263             master_key_size = SSL_SESSION_get_master_key(session,
 264                                                          actual_master_key,
 265                                                          master_key_size);
 266             if (!TEST_size_t_ne(master_key_size, 0))
 267                 return 0;
 268             if (!TEST_false(compare_hex_encoded_buffer(token, strlen(token),
 269                                                        actual_master_key,
 270                                                        master_key_size)))
 271                 return 0;
 272             master_secret_count++;
 273         } else if (strcmp(token, "CLIENT_EARLY_TRAFFIC_SECRET") == 0
 274                     || strcmp(token, "CLIENT_HANDSHAKE_TRAFFIC_SECRET") == 0
 275                     || strcmp(token, "SERVER_HANDSHAKE_TRAFFIC_SECRET") == 0
 276                     || strcmp(token, "CLIENT_TRAFFIC_SECRET_0") == 0
 277                     || strcmp(token, "SERVER_TRAFFIC_SECRET_0") == 0
 278                     || strcmp(token, "EARLY_EXPORTER_SECRET") == 0
 279                     || strcmp(token, "EXPORTER_SECRET") == 0) {
 280             /*
 281              * TLSv1.3 secret. Tokens should be: 64 ASCII bytes of hex-encoded
 282              * client random, and then the hex-encoded secret. In this case,
 283              * we treat all of these secrets identically and then just
 284              * distinguish between them when counting what we saw.
 285              */
 286             if (strcmp(token, "CLIENT_EARLY_TRAFFIC_SECRET") == 0)
 287                 client_early_secret_count++;
 288             else if (strcmp(token, "CLIENT_HANDSHAKE_TRAFFIC_SECRET") == 0)
 289                 client_handshake_secret_count++;
 290             else if (strcmp(token, "SERVER_HANDSHAKE_TRAFFIC_SECRET") == 0)
 291                 server_handshake_secret_count++;
 292             else if (strcmp(token, "CLIENT_TRAFFIC_SECRET_0") == 0)
 293                 client_application_secret_count++;
 294             else if (strcmp(token, "SERVER_TRAFFIC_SECRET_0") == 0)
 295                 server_application_secret_count++;
 296             else if (strcmp(token, "EARLY_EXPORTER_SECRET") == 0)
 297                 early_exporter_secret_count++;
 298             else if (strcmp(token, "EXPORTER_SECRET") == 0)
 299                 exporter_secret_count++;
 300
 301             client_random_size = SSL_get_client_random(ssl,
 302                                                        actual_client_random,
 303                                                        SSL3_RANDOM_SIZE);
 304             if (!TEST_size_t_eq(client_random_size, SSL3_RANDOM_SIZE))
 305                 return 0;
 306
 307             if (!TEST_ptr(token = strtok(NULL, " \n")))
 308                 return 0;
 309             if (!TEST_size_t_eq(strlen(token), 64))
 310                 return 0;
 311             if (!TEST_false(compare_hex_encoded_buffer(token, 64,
 312                                                        actual_client_random,
 313                                                        client_random_size)))
 314                 return 0;
 315
 316             if (!TEST_ptr(token = strtok(NULL, " \n")))
 317                 return 0;
 318         } else {
 319             TEST_info("Unexpected token %s\n", token);
 320             return 0;
 321         }
 322     }
 323
 324     /* Got what we expected? */
 325     if (!TEST_size_t_eq(rsa_key_exchange_count,
 326                         expected->rsa_key_exchange_count)
 327             || !TEST_size_t_eq(master_secret_count,
 328                                expected->master_secret_count)
 329             || !TEST_size_t_eq(client_early_secret_count,
 330                                expected->client_early_secret_count)
 331             || !TEST_size_t_eq(client_handshake_secret_count,
 332                                expected->client_handshake_secret_count)
 333             || !TEST_size_t_eq(server_handshake_secret_count,
 334                                expected->server_handshake_secret_count)
 335             || !TEST_size_t_eq(client_application_secret_count,
 336                                expected->client_application_secret_count)
 337             || !TEST_size_t_eq(server_application_secret_count,
 338                                expected->server_application_secret_count)
 339             || !TEST_size_t_eq(early_exporter_secret_count,
 340                                expected->early_exporter_secret_count)
 341             || !TEST_size_t_eq(exporter_secret_count,
 342                                expected->exporter_secret_count))
 343         return 0;
 344     return 1;
 345 }
 346
 347 #if !defined(OPENSSL_NO_TLS1_2) || defined(OSSL_NO_USABLE_TLS1_3)
 348 static int test_keylog(void)
 349 {
 350     SSL_CTX *cctx = NULL, *sctx = NULL;
 351     SSL *clientssl = NULL, *serverssl = NULL;
 352     int testresult = 0;
 353     struct sslapitest_log_counts expected;
 354
 355     /* Clean up logging space */
 356     memset(&expected, 0, sizeof(expected));
 357     memset(client_log_buffer, 0, sizeof(client_log_buffer));
 358     memset(server_log_buffer, 0, sizeof(server_log_buffer));
 359     client_log_buffer_index = 0;
 360     server_log_buffer_index = 0;
 361     error_writing_log = 0;
 362
 363     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
 364                                        TLS_client_method(),
 365                                        TLS1_VERSION, 0,
 366                                        &sctx, &cctx, cert, privkey)))
 367         return 0;
 368
 369     /* We cannot log the master secret for TLSv1.3, so we should forbid it. */
 370     SSL_CTX_set_options(cctx, SSL_OP_NO_TLSv1_3);
 371     SSL_CTX_set_options(sctx, SSL_OP_NO_TLSv1_3);
 372
 373     /* We also want to ensure that we use RSA-based key exchange. */
 374     if (!TEST_true(SSL_CTX_set_cipher_list(cctx, "RSA")))
 375         goto end;
 376
 377     if (!TEST_true(SSL_CTX_get_keylog_callback(cctx) == NULL)
 378             || !TEST_true(SSL_CTX_get_keylog_callback(sctx) == NULL))
 379         goto end;
 380     SSL_CTX_set_keylog_callback(cctx, client_keylog_callback);
 381     if (!TEST_true(SSL_CTX_get_keylog_callback(cctx)
 382                    == client_keylog_callback))
 383         goto end;
 384     SSL_CTX_set_keylog_callback(sctx, server_keylog_callback);
 385     if (!TEST_true(SSL_CTX_get_keylog_callback(sctx)
 386                    == server_keylog_callback))
 387         goto end;
 388
 389     /* Now do a handshake and check that the logs have been written to. */
 390     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
 391                                       &clientssl, NULL, NULL))
 392             || !TEST_true(create_ssl_connection(serverssl, clientssl,
 393                                                 SSL_ERROR_NONE))
 394             || !TEST_false(error_writing_log)
 395             || !TEST_int_gt(client_log_buffer_index, 0)
 396             || !TEST_int_gt(server_log_buffer_index, 0))
 397         goto end;
 398
 399     /*
 400      * Now we want to test that our output data was vaguely sensible. We
 401      * do that by using strtok and confirming that we have more or less the
 402      * data we expect. For both client and server, we expect to see one master
 403      * secret. The client should also see an RSA key exchange.
 404      */
 405     expected.rsa_key_exchange_count = 1;
 406     expected.master_secret_count = 1;
 407     if (!TEST_true(test_keylog_output(client_log_buffer, clientssl,
 408                                       SSL_get_session(clientssl), &expected)))
 409         goto end;
 410
 411     expected.rsa_key_exchange_count = 0;
 412     if (!TEST_true(test_keylog_output(server_log_buffer, serverssl,
 413                                       SSL_get_session(serverssl), &expected)))
 414         goto end;
 415
 416     testresult = 1;
 417
 418 end:
 419     SSL_free(serverssl);
 420     SSL_free(clientssl);
 421     SSL_CTX_free(sctx);
 422     SSL_CTX_free(cctx);
 423
 424     return testresult;
 425 }
 426 #endif
 427
 428 #ifndef OSSL_NO_USABLE_TLS1_3
 429 static int test_keylog_no_master_key(void)
 430 {
 431     SSL_CTX *cctx = NULL, *sctx = NULL;
 432     SSL *clientssl = NULL, *serverssl = NULL;
 433     SSL_SESSION *sess = NULL;
 434     int testresult = 0;
 435     struct sslapitest_log_counts expected;
 436     unsigned char buf[1];
 437     size_t readbytes, written;
 438
 439     /* Clean up logging space */
 440     memset(&expected, 0, sizeof(expected));
 441     memset(client_log_buffer, 0, sizeof(client_log_buffer));
 442     memset(server_log_buffer, 0, sizeof(server_log_buffer));
 443     client_log_buffer_index = 0;
 444     server_log_buffer_index = 0;
 445     error_writing_log = 0;
 446
 447     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
 448                                        TLS_client_method(), TLS1_VERSION, 0,
 449                                        &sctx, &cctx, cert, privkey))
 450         || !TEST_true(SSL_CTX_set_max_early_data(sctx,
 451                                                  SSL3_RT_MAX_PLAIN_LENGTH)))
 452         return 0;
 453
 454     if (!TEST_true(SSL_CTX_get_keylog_callback(cctx) == NULL)
 455             || !TEST_true(SSL_CTX_get_keylog_callback(sctx) == NULL))
 456         goto end;
 457
 458     SSL_CTX_set_keylog_callback(cctx, client_keylog_callback);
 459     if (!TEST_true(SSL_CTX_get_keylog_callback(cctx)
 460                    == client_keylog_callback))
 461         goto end;
 462
 463     SSL_CTX_set_keylog_callback(sctx, server_keylog_callback);
 464     if (!TEST_true(SSL_CTX_get_keylog_callback(sctx)
 465                    == server_keylog_callback))
 466         goto end;
 467
 468     /* Now do a handshake and check that the logs have been written to. */
 469     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
 470                                       &clientssl, NULL, NULL))
 471             || !TEST_true(create_ssl_connection(serverssl, clientssl,
 472                                                 SSL_ERROR_NONE))
 473             || !TEST_false(error_writing_log))
 474         goto end;
 475
 476     /*
 477      * Now we want to test that our output data was vaguely sensible. For this
 478      * test, we expect no CLIENT_RANDOM entry because it doesn't make sense for
 479      * TLSv1.3, but we do expect both client and server to emit keys.
 480      */
 481     expected.client_handshake_secret_count = 1;
 482     expected.server_handshake_secret_count = 1;
 483     expected.client_application_secret_count = 1;
 484     expected.server_application_secret_count = 1;
 485     expected.exporter_secret_count = 1;
 486     if (!TEST_true(test_keylog_output(client_log_buffer, clientssl,
 487                                       SSL_get_session(clientssl), &expected))
 488             || !TEST_true(test_keylog_output(server_log_buffer, serverssl,
 489                                              SSL_get_session(serverssl),
 490                                              &expected)))
 491         goto end;
 492
 493     /* Terminate old session and resume with early data. */
 494     sess = SSL_get1_session(clientssl);
 495     SSL_shutdown(clientssl);
 496     SSL_shutdown(serverssl);
 497     SSL_free(serverssl);
 498     SSL_free(clientssl);
 499     serverssl = clientssl = NULL;
 500
 501     /* Reset key log */
 502     memset(client_log_buffer, 0, sizeof(client_log_buffer));
 503     memset(server_log_buffer, 0, sizeof(server_log_buffer));
 504     client_log_buffer_index = 0;
 505     server_log_buffer_index = 0;
 506
 507     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
 508                                       &clientssl, NULL, NULL))
 509             || !TEST_true(SSL_set_session(clientssl, sess))
 510             /* Here writing 0 length early data is enough. */
 511             || !TEST_true(SSL_write_early_data(clientssl, NULL, 0, &written))
 512             || !TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
 513                                                 &readbytes),
 514                             SSL_READ_EARLY_DATA_ERROR)
 515             || !TEST_int_eq(SSL_get_early_data_status(serverssl),
 516                             SSL_EARLY_DATA_ACCEPTED)
 517             || !TEST_true(create_ssl_connection(serverssl, clientssl,
 518                           SSL_ERROR_NONE))
 519             || !TEST_true(SSL_session_reused(clientssl)))
 520         goto end;
 521
 522     /* In addition to the previous entries, expect early secrets. */
 523     expected.client_early_secret_count = 1;
 524     expected.early_exporter_secret_count = 1;
 525     if (!TEST_true(test_keylog_output(client_log_buffer, clientssl,
 526                                       SSL_get_session(clientssl), &expected))
 527             || !TEST_true(test_keylog_output(server_log_buffer, serverssl,
 528                                              SSL_get_session(serverssl),
 529                                              &expected)))
 530         goto end;
 531
 532     testresult = 1;
 533
 534 end:
 535     SSL_SESSION_free(sess);
 536     SSL_free(serverssl);
 537     SSL_free(clientssl);
 538     SSL_CTX_free(sctx);
 539     SSL_CTX_free(cctx);
 540
 541     return testresult;
 542 }
 543 #endif
 544
 545 static int verify_retry_cb(X509_STORE_CTX *ctx, void *arg)
 546 {
 547     int res = X509_verify_cert(ctx);
 548     int idx = SSL_get_ex_data_X509_STORE_CTX_idx();
 549     SSL *ssl;
 550
 551     /* this should not happen but check anyway */
 552     if (idx < 0
 553         || (ssl = X509_STORE_CTX_get_ex_data(ctx, idx)) == NULL)
 554         return 0;
 555
 556     if (res == 0 && X509_STORE_CTX_get_error(ctx) ==
 557         X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY)
 558         /* indicate SSL_ERROR_WANT_RETRY_VERIFY */
 559         return SSL_set_retry_verify(ssl);
 560
 561     return res;
 562 }
 563
 564 static int test_client_cert_verify_cb(void)
 565 {
 566     /* server key, cert, chain, and root */
 567     char *skey = test_mk_file_path(certsdir, "leaf.key");
 568     char *leaf = test_mk_file_path(certsdir, "leaf.pem");
 569     char *int2 = test_mk_file_path(certsdir, "subinterCA.pem");
 570     char *int1 = test_mk_file_path(certsdir, "interCA.pem");
 571     char *root = test_mk_file_path(certsdir, "rootCA.pem");
 572     X509 *crt1 = NULL, *crt2 = NULL;
 573     STACK_OF(X509) *server_chain;
 574     SSL_CTX *cctx = NULL, *sctx = NULL;
 575     SSL *clientssl = NULL, *serverssl = NULL;
 576     int testresult = 0;
 577
 578     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
 579                                        TLS_client_method(), TLS1_VERSION, 0,
 580                                        &sctx, &cctx, NULL, NULL)))
 581         goto end;
 582     if (!TEST_int_eq(SSL_CTX_use_certificate_chain_file(sctx, leaf), 1)
 583             || !TEST_int_eq(SSL_CTX_use_PrivateKey_file(sctx, skey,
 584                                                         SSL_FILETYPE_PEM), 1)
 585             || !TEST_int_eq(SSL_CTX_check_private_key(sctx), 1))
 586         goto end;
 587     if (!TEST_true(SSL_CTX_load_verify_locations(cctx, root, NULL)))
 588         goto end;
 589     SSL_CTX_set_verify(cctx, SSL_VERIFY_PEER, NULL);
 590     SSL_CTX_set_cert_verify_callback(cctx, verify_retry_cb, NULL);
 591     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
 592                                       &clientssl, NULL, NULL)))
 593         goto end;
 594
 595     /* attempt SSL_connect() with incomplete server chain */
 596     if (!TEST_false(create_ssl_connection(serverssl, clientssl,
 597                                           SSL_ERROR_WANT_RETRY_VERIFY)))
 598         goto end;
 599
 600     /* application provides intermediate certs needed to verify server cert */
 601     if (!TEST_ptr((crt1 = load_cert_pem(int1, libctx)))
 602         || !TEST_ptr((crt2 = load_cert_pem(int2, libctx)))
 603         || !TEST_ptr((server_chain = SSL_get_peer_cert_chain(clientssl))))
 604         goto end;
 605     /* add certs in reverse order to demonstrate real chain building */
 606     if (!TEST_true(sk_X509_push(server_chain, crt1)))
 607         goto end;
 608     crt1 = NULL;
 609     if (!TEST_true(sk_X509_push(server_chain, crt2)))
 610         goto end;
 611     crt2 = NULL;
 612
 613     /* continue SSL_connect(), must now succeed with completed server chain */
 614     if (!TEST_true(create_ssl_connection(serverssl, clientssl,
 615                                          SSL_ERROR_NONE)))
 616         goto end;
 617
 618     testresult = 1;
 619
 620 end:
 621     X509_free(crt1);
 622     X509_free(crt2);
 623     if (clientssl != NULL) {
 624         SSL_shutdown(clientssl);
 625         SSL_free(clientssl);
 626     }
 627     if (serverssl != NULL) {
 628         SSL_shutdown(serverssl);
 629         SSL_free(serverssl);
 630     }
 631     SSL_CTX_free(sctx);
 632     SSL_CTX_free(cctx);
 633
 634     OPENSSL_free(skey);
 635     OPENSSL_free(leaf);
 636     OPENSSL_free(int2);
 637     OPENSSL_free(int1);
 638     OPENSSL_free(root);
 639
 640     return testresult;
 641 }
 642
 643 static int test_ssl_build_cert_chain(void)
 644 {
 645     int ret = 0;
 646     SSL_CTX *ssl_ctx = NULL;
 647     SSL *ssl = NULL;
 648     char *skey = test_mk_file_path(certsdir, "leaf.key");
 649     char *leaf_chain = test_mk_file_path(certsdir, "leaf-chain.pem");
 650
 651     if (!TEST_ptr(ssl_ctx = SSL_CTX_new_ex(libctx, NULL, TLS_server_method())))
 652         goto end;
 653     if (!TEST_ptr(ssl = SSL_new(ssl_ctx)))
 654         goto end;
 655     /* leaf_chain contains leaf + subinterCA + interCA + rootCA */
 656     if (!TEST_int_eq(SSL_use_certificate_chain_file(ssl, leaf_chain), 1)
 657         || !TEST_int_eq(SSL_use_PrivateKey_file(ssl, skey, SSL_FILETYPE_PEM), 1)
 658         || !TEST_int_eq(SSL_check_private_key(ssl), 1))
 659         goto end;
 660     if (!TEST_true(SSL_build_cert_chain(ssl, SSL_BUILD_CHAIN_FLAG_NO_ROOT
 661                                              | SSL_BUILD_CHAIN_FLAG_CHECK)))
 662         goto end;
 663     ret = 1;
 664 end:
 665     SSL_free(ssl);
 666     SSL_CTX_free(ssl_ctx);
 667     OPENSSL_free(leaf_chain);
 668     OPENSSL_free(skey);
 669     return ret;
 670 }
 671
 672 static int get_password_cb(char *buf, int size, int rw_flag, void *userdata)
 673 {
 674     static const char pass[] = "testpass";
 675
 676     if (!TEST_int_eq(size, PEM_BUFSIZE))
 677         return -1;
 678
 679     memcpy(buf, pass, sizeof(pass) - 1);
 680     return sizeof(pass) - 1;
 681 }
 682
 683 static int test_ssl_ctx_build_cert_chain(void)
 684 {
 685     int ret = 0;
 686     SSL_CTX *ctx = NULL;
 687     char *skey = test_mk_file_path(certsdir, "leaf-encrypted.key");
 688     char *leaf_chain = test_mk_file_path(certsdir, "leaf-chain.pem");
 689
 690     if (!TEST_ptr(ctx = SSL_CTX_new_ex(libctx, NULL, TLS_server_method())))
 691         goto end;
 692     SSL_CTX_set_default_passwd_cb(ctx, get_password_cb);
 693     /* leaf_chain contains leaf + subinterCA + interCA + rootCA */
 694     if (!TEST_int_eq(SSL_CTX_use_certificate_chain_file(ctx, leaf_chain), 1)
 695         || !TEST_int_eq(SSL_CTX_use_PrivateKey_file(ctx, skey,
 696                                                     SSL_FILETYPE_PEM), 1)
 697         || !TEST_int_eq(SSL_CTX_check_private_key(ctx), 1))
 698         goto end;
 699     if (!TEST_true(SSL_CTX_build_cert_chain(ctx, SSL_BUILD_CHAIN_FLAG_NO_ROOT
 700                                                 | SSL_BUILD_CHAIN_FLAG_CHECK)))
 701         goto end;
 702     ret = 1;
 703 end:
 704     SSL_CTX_free(ctx);
 705     OPENSSL_free(leaf_chain);
 706     OPENSSL_free(skey);
 707     return ret;
 708 }
 709
 710 #ifndef OPENSSL_NO_TLS1_2
 711 static int full_client_hello_callback(SSL *s, int *al, void *arg)
 712 {
 713     int *ctr = arg;
 714     const unsigned char *p;
 715     int *exts;
 716 #ifdef OPENSSL_NO_EC
 717     const unsigned char expected_ciphers[] = {0x00, 0x9d};
 718 #else
 719     const unsigned char expected_ciphers[] = {0x00, 0x9d, 0xc0,
 720                                               0x2c};
 721 #endif
 722     const int expected_extensions[] = {
 723                                        65281,
 724 #ifndef OPENSSL_NO_EC
 725                                        11, 10,
 726 #endif
 727                                        35, 22, 23, 13};
 728     size_t len;
 729
 730     /* Make sure we can defer processing and get called back. */
 731     if ((*ctr)++ == 0)
 732         return SSL_CLIENT_HELLO_RETRY;
 733
 734     len = SSL_client_hello_get0_ciphers(s, &p);
 735     if (!TEST_mem_eq(p, len, expected_ciphers, sizeof(expected_ciphers))
 736             || !TEST_size_t_eq(
 737                        SSL_client_hello_get0_compression_methods(s, &p), 1)
 738             || !TEST_int_eq(*p, 0))
 739         return SSL_CLIENT_HELLO_ERROR;
 740     if (!SSL_client_hello_get1_extensions_present(s, &exts, &len))
 741         return SSL_CLIENT_HELLO_ERROR;
 742     if (len != OSSL_NELEM(expected_extensions) ||
 743         memcmp(exts, expected_extensions, len * sizeof(*exts)) != 0) {
 744         printf("ClientHello callback expected extensions mismatch\n");
 745         OPENSSL_free(exts);
 746         return SSL_CLIENT_HELLO_ERROR;
 747     }
 748     OPENSSL_free(exts);
 749     return SSL_CLIENT_HELLO_SUCCESS;
 750 }
 751
 752 static int test_client_hello_cb(void)
 753 {
 754     SSL_CTX *cctx = NULL, *sctx = NULL;
 755     SSL *clientssl = NULL, *serverssl = NULL;
 756     int testctr = 0, testresult = 0;
 757
 758     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
 759                                        TLS_client_method(), TLS1_VERSION, 0,
 760                                        &sctx, &cctx, cert, privkey)))
 761         goto end;
 762     SSL_CTX_set_client_hello_cb(sctx, full_client_hello_callback, &testctr);
 763
 764     /* The gimpy cipher list we configure can't do TLS 1.3. */
 765     SSL_CTX_set_max_proto_version(cctx, TLS1_2_VERSION);
 766
 767     if (!TEST_true(SSL_CTX_set_cipher_list(cctx,
 768                         "AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384"))
 769             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
 770                                              &clientssl, NULL, NULL))
 771             || !TEST_false(create_ssl_connection(serverssl, clientssl,
 772                         SSL_ERROR_WANT_CLIENT_HELLO_CB))
 773                 /*
 774                  * Passing a -1 literal is a hack since
 775                  * the real value was lost.
 776                  * */
 777             || !TEST_int_eq(SSL_get_error(serverssl, -1),
 778                             SSL_ERROR_WANT_CLIENT_HELLO_CB)
 779             || !TEST_true(create_ssl_connection(serverssl, clientssl,
 780                                                 SSL_ERROR_NONE)))
 781         goto end;
 782
 783     testresult = 1;
 784
 785 end:
 786     SSL_free(serverssl);
 787     SSL_free(clientssl);
 788     SSL_CTX_free(sctx);
 789     SSL_CTX_free(cctx);
 790
 791     return testresult;
 792 }
 793
 794 static int test_no_ems(void)
 795 {
 796     SSL_CTX *cctx = NULL, *sctx = NULL;
 797     SSL *clientssl = NULL, *serverssl = NULL;
 798     int testresult = 0, status;
 799
 800     if (!create_ssl_ctx_pair(libctx, TLS_server_method(), TLS_client_method(),
 801                              TLS1_VERSION, TLS1_2_VERSION,
 802                              &sctx, &cctx, cert, privkey)) {
 803         printf("Unable to create SSL_CTX pair\n");
 804         goto end;
 805     }
 806
 807     SSL_CTX_set_options(sctx, SSL_OP_NO_EXTENDED_MASTER_SECRET);
 808
 809     if (!create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL, NULL)) {
 810         printf("Unable to create SSL objects\n");
 811         goto end;
 812     }
 813
 814     status = create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE);
 815     if (fips_ems_check) {
 816         if (status == 1) {
 817             printf("When FIPS uses the EMS check a connection that doesn't use EMS should fail\n");
 818             goto end;
 819         }
 820     } else {
 821         if (!status) {
 822             printf("Creating SSL connection failed\n");
 823             goto end;
 824         }
 825         if (SSL_get_extms_support(serverssl)) {
 826             printf("Server reports Extended Master Secret support\n");
 827             goto end;
 828         }
 829         if (SSL_get_extms_support(clientssl)) {
 830             printf("Client reports Extended Master Secret support\n");
 831             goto end;
 832         }
 833     }
 834     testresult = 1;
 835
 836 end:
 837     SSL_free(serverssl);
 838     SSL_free(clientssl);
 839     SSL_CTX_free(sctx);
 840     SSL_CTX_free(cctx);
 841
 842     return testresult;
 843 }
 844
 845 /*
 846  * Very focused test to exercise a single case in the server-side state
 847  * machine, when the ChangeCipherState message needs to actually change
 848  * from one cipher to a different cipher (i.e., not changing from null
 849  * encryption to real encryption).
 850  */
 851 static int test_ccs_change_cipher(void)
 852 {
 853     SSL_CTX *cctx = NULL, *sctx = NULL;
 854     SSL *clientssl = NULL, *serverssl = NULL;
 855     SSL_SESSION *sess = NULL, *sesspre, *sesspost;
 856     int testresult = 0;
 857     int i;
 858     unsigned char buf;
 859     size_t readbytes;
 860
 861     /*
 862      * Create a connection so we can resume and potentially (but not) use
 863      * a different cipher in the second connection.
 864      */
 865     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
 866                                        TLS_client_method(),
 867                                        TLS1_VERSION, TLS1_2_VERSION,
 868                                        &sctx, &cctx, cert, privkey))
 869             || !TEST_true(SSL_CTX_set_options(sctx, SSL_OP_NO_TICKET))
 870             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
 871                           NULL, NULL))
 872             || !TEST_true(SSL_set_cipher_list(clientssl, "AES128-GCM-SHA256"))
 873             || !TEST_true(create_ssl_connection(serverssl, clientssl,
 874                                                 SSL_ERROR_NONE))
 875             || !TEST_ptr(sesspre = SSL_get0_session(serverssl))
 876             || !TEST_ptr(sess = SSL_get1_session(clientssl)))
 877         goto end;
 878
 879     shutdown_ssl_connection(serverssl, clientssl);
 880     serverssl = clientssl = NULL;
 881
 882     /* Resume, preferring a different cipher. Our server will force the
 883      * same cipher to be used as the initial handshake. */
 884     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
 885                           NULL, NULL))
 886             || !TEST_true(SSL_set_session(clientssl, sess))
 887             || !TEST_true(SSL_set_cipher_list(clientssl, "AES256-GCM-SHA384:AES128-GCM-SHA256"))
 888             || !TEST_true(create_ssl_connection(serverssl, clientssl,
 889                                                 SSL_ERROR_NONE))
 890             || !TEST_true(SSL_session_reused(clientssl))
 891             || !TEST_true(SSL_session_reused(serverssl))
 892             || !TEST_ptr(sesspost = SSL_get0_session(serverssl))
 893             || !TEST_ptr_eq(sesspre, sesspost)
 894             || !TEST_int_eq(TLS1_CK_RSA_WITH_AES_128_GCM_SHA256,
 895                             SSL_CIPHER_get_id(SSL_get_current_cipher(clientssl))))
 896         goto end;
 897     shutdown_ssl_connection(serverssl, clientssl);
 898     serverssl = clientssl = NULL;
 899
 900     /*
 901      * Now create a fresh connection and try to renegotiate a different
 902      * cipher on it.
 903      */
 904     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
 905                                       NULL, NULL))
 906             || !TEST_true(SSL_set_cipher_list(clientssl, "AES128-GCM-SHA256"))
 907             || !TEST_true(create_ssl_connection(serverssl, clientssl,
 908                                                 SSL_ERROR_NONE))
 909             || !TEST_ptr(sesspre = SSL_get0_session(serverssl))
 910             || !TEST_true(SSL_set_cipher_list(clientssl, "AES256-GCM-SHA384"))
 911             || !TEST_true(SSL_renegotiate(clientssl))
 912             || !TEST_true(SSL_renegotiate_pending(clientssl)))
 913         goto end;
 914     /* Actually drive the renegotiation. */
 915     for (i = 0; i < 3; i++) {
 916         if (SSL_read_ex(clientssl, &buf, sizeof(buf), &readbytes) > 0) {
 917             if (!TEST_ulong_eq(readbytes, 0))
 918                 goto end;
 919         } else if (!TEST_int_eq(SSL_get_error(clientssl, 0),
 920                                 SSL_ERROR_WANT_READ)) {
 921             goto end;
 922         }
 923         if (SSL_read_ex(serverssl, &buf, sizeof(buf), &readbytes) > 0) {
 924             if (!TEST_ulong_eq(readbytes, 0))
 925                 goto end;
 926         } else if (!TEST_int_eq(SSL_get_error(serverssl, 0),
 927                                 SSL_ERROR_WANT_READ)) {
 928             goto end;
 929         }
 930     }
 931     /* sesspre and sesspost should be different since the cipher changed. */
 932     if (!TEST_false(SSL_renegotiate_pending(clientssl))
 933             || !TEST_false(SSL_session_reused(clientssl))
 934             || !TEST_false(SSL_session_reused(serverssl))
 935             || !TEST_ptr(sesspost = SSL_get0_session(serverssl))
 936             || !TEST_ptr_ne(sesspre, sesspost)
 937             || !TEST_int_eq(TLS1_CK_RSA_WITH_AES_256_GCM_SHA384,
 938                             SSL_CIPHER_get_id(SSL_get_current_cipher(clientssl))))
 939         goto end;
 940
 941     shutdown_ssl_connection(serverssl, clientssl);
 942     serverssl = clientssl = NULL;
 943
 944     testresult = 1;
 945
 946 end:
 947     SSL_free(serverssl);
 948     SSL_free(clientssl);
 949     SSL_CTX_free(sctx);
 950     SSL_CTX_free(cctx);
 951     SSL_SESSION_free(sess);
 952
 953     return testresult;
 954 }
 955 #endif
 956
 957 static int execute_test_large_message(const SSL_METHOD *smeth,
 958                                       const SSL_METHOD *cmeth,
 959                                       int min_version, int max_version,
 960                                       int read_ahead)
 961 {
 962     SSL_CTX *cctx = NULL, *sctx = NULL;
 963     SSL *clientssl = NULL, *serverssl = NULL;
 964     int testresult = 0;
 965
 966     if (!TEST_true(create_ssl_ctx_pair(libctx, smeth, cmeth, min_version,
 967                                        max_version, &sctx, &cctx, cert,
 968                                        privkey)))
 969         goto end;
 970
 971 #ifdef OPENSSL_NO_DTLS1_2
 972     if (smeth == DTLS_server_method()) {
 973         /*
 974          * Default sigalgs are SHA1 based in <DTLS1.2 which is in security
 975          * level 0
 976          */
 977         if (!TEST_true(SSL_CTX_set_cipher_list(sctx, "DEFAULT:@SECLEVEL=0"))
 978                 || !TEST_true(SSL_CTX_set_cipher_list(cctx,
 979                                                     "DEFAULT:@SECLEVEL=0")))
 980             goto end;
 981     }
 982 #endif
 983
 984     if (read_ahead) {
 985         /*
 986          * Test that read_ahead works correctly when dealing with large
 987          * records
 988          */
 989         SSL_CTX_set_read_ahead(cctx, 1);
 990     }
 991
 992     if (!ssl_ctx_add_large_cert_chain(libctx, sctx, cert))
 993         goto end;
 994
 995     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
 996                                       NULL, NULL))
 997             || !TEST_true(create_ssl_connection(serverssl, clientssl,
 998                                                 SSL_ERROR_NONE)))
 999         goto end;
1000
1001     /*
1002      * Calling SSL_clear() first is not required but this tests that SSL_clear()
1003      * doesn't leak.
1004      */
1005     if (!TEST_true(SSL_clear(serverssl)))
1006         goto end;
1007
1008     testresult = 1;
1009  end:
1010     SSL_free(serverssl);
1011     SSL_free(clientssl);
1012     SSL_CTX_free(sctx);
1013     SSL_CTX_free(cctx);
1014
1015     return testresult;
1016 }
1017
1018 #if !defined(OPENSSL_NO_SOCK) && !defined(OPENSSL_NO_KTLS) && \
1019     !(defined(OSSL_NO_USABLE_TLS1_3) && defined(OPENSSL_NO_TLS1_2))
1020 /* sock must be connected */
1021 static int ktls_chk_platform(int sock)
1022 {
1023     if (!ktls_enable(sock))
1024         return 0;
1025     return 1;
1026 }
1027
1028 static int ping_pong_query(SSL *clientssl, SSL *serverssl)
1029 {
1030     static char count = 1;
1031     unsigned char cbuf[16000] = {0};
1032     unsigned char sbuf[16000];
1033     size_t err = 0;
1034     char crec_wseq_before[SEQ_NUM_SIZE];
1035     char crec_wseq_after[SEQ_NUM_SIZE];
1036     char crec_rseq_before[SEQ_NUM_SIZE];
1037     char crec_rseq_after[SEQ_NUM_SIZE];
1038     char srec_wseq_before[SEQ_NUM_SIZE];
1039     char srec_wseq_after[SEQ_NUM_SIZE];
1040     char srec_rseq_before[SEQ_NUM_SIZE];
1041     char srec_rseq_after[SEQ_NUM_SIZE];
1042     SSL_CONNECTION *clientsc, *serversc;
1043
1044     if (!TEST_ptr(clientsc = SSL_CONNECTION_FROM_SSL_ONLY(clientssl))
1045         || !TEST_ptr(serversc = SSL_CONNECTION_FROM_SSL_ONLY(serverssl)))
1046         goto end;
1047
1048     cbuf[0] = count++;
1049     memcpy(crec_wseq_before, &clientsc->rlayer.wrl->sequence, SEQ_NUM_SIZE);
1050     memcpy(srec_wseq_before, &serversc->rlayer.wrl->sequence, SEQ_NUM_SIZE);
1051     memcpy(crec_rseq_before, &clientsc->rlayer.rrl->sequence, SEQ_NUM_SIZE);
1052     memcpy(srec_rseq_before, &serversc->rlayer.rrl->sequence, SEQ_NUM_SIZE);
1053
1054     if (!TEST_true(SSL_write(clientssl, cbuf, sizeof(cbuf)) == sizeof(cbuf)))
1055         goto end;
1056
1057     while ((err = SSL_read(serverssl, &sbuf, sizeof(sbuf))) != sizeof(sbuf)) {
1058         if (SSL_get_error(serverssl, err) != SSL_ERROR_WANT_READ) {
1059             goto end;
1060         }
1061     }
1062
1063     if (!TEST_true(SSL_write(serverssl, sbuf, sizeof(sbuf)) == sizeof(sbuf)))
1064         goto end;
1065
1066     while ((err = SSL_read(clientssl, &cbuf, sizeof(cbuf))) != sizeof(cbuf)) {
1067         if (SSL_get_error(clientssl, err) != SSL_ERROR_WANT_READ) {
1068             goto end;
1069         }
1070     }
1071
1072     memcpy(crec_wseq_after, &clientsc->rlayer.wrl->sequence, SEQ_NUM_SIZE);
1073     memcpy(srec_wseq_after, &serversc->rlayer.wrl->sequence, SEQ_NUM_SIZE);
1074     memcpy(crec_rseq_after, &clientsc->rlayer.rrl->sequence, SEQ_NUM_SIZE);
1075     memcpy(srec_rseq_after, &serversc->rlayer.rrl->sequence, SEQ_NUM_SIZE);
1076
1077     /* verify the payload */
1078     if (!TEST_mem_eq(cbuf, sizeof(cbuf), sbuf, sizeof(sbuf)))
1079         goto end;
1080
1081     /*
1082      * If ktls is used then kernel sequences are used instead of
1083      * OpenSSL sequences
1084      */
1085     if (!BIO_get_ktls_send(clientsc->wbio)) {
1086         if (!TEST_mem_ne(crec_wseq_before, SEQ_NUM_SIZE,
1087                          crec_wseq_after, SEQ_NUM_SIZE))
1088             goto end;
1089     } else {
1090         if (!TEST_mem_eq(crec_wseq_before, SEQ_NUM_SIZE,
1091                          crec_wseq_after, SEQ_NUM_SIZE))
1092             goto end;
1093     }
1094
1095     if (!BIO_get_ktls_send(serversc->wbio)) {
1096         if (!TEST_mem_ne(srec_wseq_before, SEQ_NUM_SIZE,
1097                          srec_wseq_after, SEQ_NUM_SIZE))
1098             goto end;
1099     } else {
1100         if (!TEST_mem_eq(srec_wseq_before, SEQ_NUM_SIZE,
1101                          srec_wseq_after, SEQ_NUM_SIZE))
1102             goto end;
1103     }
1104
1105     if (!BIO_get_ktls_recv(clientsc->wbio)) {
1106         if (!TEST_mem_ne(crec_rseq_before, SEQ_NUM_SIZE,
1107                          crec_rseq_after, SEQ_NUM_SIZE))
1108             goto end;
1109     } else {
1110         if (!TEST_mem_eq(crec_rseq_before, SEQ_NUM_SIZE,
1111                          crec_rseq_after, SEQ_NUM_SIZE))
1112             goto end;
1113     }
1114
1115     if (!BIO_get_ktls_recv(serversc->wbio)) {
1116         if (!TEST_mem_ne(srec_rseq_before, SEQ_NUM_SIZE,
1117                          srec_rseq_after, SEQ_NUM_SIZE))
1118             goto end;
1119     } else {
1120         if (!TEST_mem_eq(srec_rseq_before, SEQ_NUM_SIZE,
1121                          srec_rseq_after, SEQ_NUM_SIZE))
1122             goto end;
1123     }
1124
1125     return 1;
1126 end:
1127     return 0;
1128 }
1129
1130 static int execute_test_ktls(int cis_ktls, int sis_ktls,
1131                              int tls_version, const char *cipher)
1132 {
1133     SSL_CTX *cctx = NULL, *sctx = NULL;
1134     SSL *clientssl = NULL, *serverssl = NULL;
1135     int ktls_used = 0, testresult = 0;
1136     int cfd = -1, sfd = -1;
1137     int rx_supported;
1138     SSL_CONNECTION *clientsc, *serversc;
1139     unsigned char *buf = NULL;
1140     const size_t bufsz = SSL3_RT_MAX_PLAIN_LENGTH + 16;
1141     int ret;
1142     size_t offset = 0, i;
1143
1144     if (!TEST_true(create_test_sockets(&cfd, &sfd, SOCK_STREAM, NULL)))
1145         goto end;
1146
1147     /* Skip this test if the platform does not support ktls */
1148     if (!ktls_chk_platform(cfd)) {
1149         testresult = TEST_skip("Kernel does not support KTLS");
1150         goto end;
1151     }
1152
1153     if (is_fips && strstr(cipher, "CHACHA") != NULL) {
1154         testresult = TEST_skip("CHACHA is not supported in FIPS");
1155         goto end;
1156     }
1157
1158     /* Create a session based on SHA-256 */
1159     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
1160                                        TLS_client_method(),
1161                                        tls_version, tls_version,
1162                                        &sctx, &cctx, cert, privkey)))
1163         goto end;
1164
1165     if (tls_version == TLS1_3_VERSION) {
1166         if (!TEST_true(SSL_CTX_set_ciphersuites(cctx, cipher))
1167             || !TEST_true(SSL_CTX_set_ciphersuites(sctx, cipher)))
1168             goto end;
1169     } else {
1170         if (!TEST_true(SSL_CTX_set_cipher_list(cctx, cipher))
1171             || !TEST_true(SSL_CTX_set_cipher_list(sctx, cipher)))
1172             goto end;
1173     }
1174
1175     if (!TEST_true(create_ssl_objects2(sctx, cctx, &serverssl,
1176                                        &clientssl, sfd, cfd)))
1177         goto end;
1178
1179     if (!TEST_ptr(clientsc = SSL_CONNECTION_FROM_SSL_ONLY(clientssl))
1180         || !TEST_ptr(serversc = SSL_CONNECTION_FROM_SSL_ONLY(serverssl)))
1181         goto end;
1182
1183     if (cis_ktls) {
1184         if (!TEST_true(SSL_set_options(clientssl, SSL_OP_ENABLE_KTLS)))
1185             goto end;
1186     }
1187
1188     if (sis_ktls) {
1189         if (!TEST_true(SSL_set_options(serverssl, SSL_OP_ENABLE_KTLS)))
1190             goto end;
1191     }
1192
1193     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
1194         goto end;
1195
1196     /*
1197      * The running kernel may not support a given cipher suite
1198      * or direction, so just check that KTLS isn't used when it
1199      * isn't enabled.
1200      */
1201     if (!cis_ktls) {
1202         if (!TEST_false(BIO_get_ktls_send(clientsc->wbio)))
1203             goto end;
1204     } else {
1205         if (BIO_get_ktls_send(clientsc->wbio))
1206             ktls_used = 1;
1207     }
1208
1209     if (!sis_ktls) {
1210         if (!TEST_false(BIO_get_ktls_send(serversc->wbio)))
1211             goto end;
1212     } else {
1213         if (BIO_get_ktls_send(serversc->wbio))
1214             ktls_used = 1;
1215     }
1216
1217 #if defined(OPENSSL_NO_KTLS_RX)
1218     rx_supported = 0;
1219 #else
1220     rx_supported = 1;
1221 #endif
1222     if (!cis_ktls || !rx_supported) {
1223         if (!TEST_false(BIO_get_ktls_recv(clientsc->rbio)))
1224             goto end;
1225     } else {
1226         if (BIO_get_ktls_send(clientsc->rbio))
1227             ktls_used = 1;
1228     }
1229
1230     if (!sis_ktls || !rx_supported) {
1231         if (!TEST_false(BIO_get_ktls_recv(serversc->rbio)))
1232             goto end;
1233     } else {
1234         if (BIO_get_ktls_send(serversc->rbio))
1235             ktls_used = 1;
1236     }
1237
1238     if ((cis_ktls || sis_ktls) && !ktls_used) {
1239         testresult = TEST_skip("KTLS not supported for %s cipher %s",
1240                                tls_version == TLS1_3_VERSION ? "TLS 1.3" :
1241                                "TLS 1.2", cipher);
1242         goto end;
1243     }
1244
1245     if (!TEST_true(ping_pong_query(clientssl, serverssl)))
1246         goto end;
1247
1248     buf = OPENSSL_zalloc(bufsz);
1249     if (!TEST_ptr(buf))
1250         goto end;
1251
1252     /*
1253      * Write some data that exceeds the maximum record length. KTLS may choose
1254      * to coalesce this data into a single buffer when we read it again.
1255      */
1256     while ((ret = SSL_write(clientssl, buf, bufsz)) != (int)bufsz) {
1257         if (!TEST_true(SSL_get_error(clientssl, ret) == SSL_ERROR_WANT_WRITE))
1258             goto end;
1259     }
1260
1261     /* Now check that we can read all the data we wrote */
1262     do {
1263         ret = SSL_read(serverssl, buf + offset, bufsz - offset);
1264         if (ret <= 0) {
1265             if (!TEST_true(SSL_get_error(serverssl, ret) == SSL_ERROR_WANT_READ))
1266                 goto end;
1267         } else {
1268             offset += ret;
1269         }
1270     } while (offset < bufsz);
1271
1272     if (!TEST_true(offset == bufsz))
1273         goto end;
1274     for (i = 0; i < bufsz; i++)
1275         if (!TEST_true(buf[i] == 0))
1276             goto end;
1277
1278     testresult = 1;
1279 end:
1280     OPENSSL_free(buf);
1281     if (clientssl) {
1282         SSL_shutdown(clientssl);
1283         SSL_free(clientssl);
1284     }
1285     if (serverssl) {
1286         SSL_shutdown(serverssl);
1287         SSL_free(serverssl);
1288     }
1289     SSL_CTX_free(sctx);
1290     SSL_CTX_free(cctx);
1291     serverssl = clientssl = NULL;
1292     if (cfd != -1)
1293         close(cfd);
1294     if (sfd != -1)
1295         close(sfd);
1296     return testresult;
1297 }
1298
1299 #define SENDFILE_SZ                     (16 * 4096)
1300 #define SENDFILE_CHUNK                  (4 * 4096)
1301 #define min(a,b)                        ((a) > (b) ? (b) : (a))
1302
1303 static int execute_test_ktls_sendfile(int tls_version, const char *cipher,
1304                                       int zerocopy)
1305 {
1306     SSL_CTX *cctx = NULL, *sctx = NULL;
1307     SSL *clientssl = NULL, *serverssl = NULL;
1308     unsigned char *buf, *buf_dst;
1309     BIO *out = NULL, *in = NULL;
1310     int cfd = -1, sfd = -1, ffd, err;
1311     ssize_t chunk_size = 0;
1312     off_t chunk_off = 0;
1313     int testresult = 0;
1314     FILE *ffdp;
1315     SSL_CONNECTION *serversc;
1316
1317     buf = OPENSSL_zalloc(SENDFILE_SZ);
1318     buf_dst = OPENSSL_zalloc(SENDFILE_SZ);
1319     if (!TEST_ptr(buf) || !TEST_ptr(buf_dst)
1320         || !TEST_true(create_test_sockets(&cfd, &sfd, SOCK_STREAM, NULL)))
1321         goto end;
1322
1323     /* Skip this test if the platform does not support ktls */
1324     if (!ktls_chk_platform(sfd)) {
1325         testresult = TEST_skip("Kernel does not support KTLS");
1326         goto end;
1327     }
1328
1329     if (is_fips && strstr(cipher, "CHACHA") != NULL) {
1330         testresult = TEST_skip("CHACHA is not supported in FIPS");
1331         goto end;
1332     }
1333
1334     /* Create a session based on SHA-256 */
1335     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
1336                                        TLS_client_method(),
1337                                        tls_version, tls_version,
1338                                        &sctx, &cctx, cert, privkey)))
1339         goto end;
1340
1341     if (tls_version == TLS1_3_VERSION) {
1342         if (!TEST_true(SSL_CTX_set_ciphersuites(cctx, cipher))
1343             || !TEST_true(SSL_CTX_set_ciphersuites(sctx, cipher)))
1344             goto end;
1345     } else {
1346         if (!TEST_true(SSL_CTX_set_cipher_list(cctx, cipher))
1347             || !TEST_true(SSL_CTX_set_cipher_list(sctx, cipher)))
1348             goto end;
1349     }
1350
1351     if (!TEST_true(create_ssl_objects2(sctx, cctx, &serverssl,
1352                                        &clientssl, sfd, cfd)))
1353         goto end;
1354
1355     if (!TEST_ptr(serversc = SSL_CONNECTION_FROM_SSL_ONLY(serverssl)))
1356         goto end;
1357
1358     if (!TEST_true(SSL_set_options(serverssl, SSL_OP_ENABLE_KTLS)))
1359         goto end;
1360
1361     if (zerocopy) {
1362         if (!TEST_true(SSL_set_options(serverssl,
1363                                        SSL_OP_ENABLE_KTLS_TX_ZEROCOPY_SENDFILE)))
1364             goto end;
1365     }
1366
1367     if (!TEST_true(create_ssl_connection(serverssl, clientssl,
1368                                          SSL_ERROR_NONE)))
1369         goto end;
1370
1371     if (!BIO_get_ktls_send(serversc->wbio)) {
1372         testresult = TEST_skip("Failed to enable KTLS for %s cipher %s",
1373                                tls_version == TLS1_3_VERSION ? "TLS 1.3" :
1374                                "TLS 1.2", cipher);
1375         goto end;
1376     }
1377
1378     if (!TEST_int_gt(RAND_bytes_ex(libctx, buf, SENDFILE_SZ, 0), 0))
1379         goto end;
1380
1381     out = BIO_new_file(tmpfilename, "wb");
1382     if (!TEST_ptr(out))
1383         goto end;
1384
1385     if (BIO_write(out, buf, SENDFILE_SZ) != SENDFILE_SZ)
1386         goto end;
1387
1388     BIO_free(out);
1389     out = NULL;
1390     in = BIO_new_file(tmpfilename, "rb");
1391     BIO_get_fp(in, &ffdp);
1392     ffd = fileno(ffdp);
1393
1394     while (chunk_off < SENDFILE_SZ) {
1395         chunk_size = min(SENDFILE_CHUNK, SENDFILE_SZ - chunk_off);
1396         while ((err = SSL_sendfile(serverssl,
1397                                    ffd,
1398                                    chunk_off,
1399                                    chunk_size,
1400                                    0)) != chunk_size) {
1401             if (SSL_get_error(serverssl, err) != SSL_ERROR_WANT_WRITE)
1402                 goto end;
1403         }
1404         while ((err = SSL_read(clientssl,
1405                                buf_dst + chunk_off,
1406                                chunk_size)) != chunk_size) {
1407             if (SSL_get_error(clientssl, err) != SSL_ERROR_WANT_READ)
1408                 goto end;
1409         }
1410
1411         /* verify the payload */
1412         if (!TEST_mem_eq(buf_dst + chunk_off,
1413                          chunk_size,
1414                          buf + chunk_off,
1415                          chunk_size))
1416             goto end;
1417
1418         chunk_off += chunk_size;
1419     }
1420
1421     testresult = 1;
1422 end:
1423     if (clientssl) {
1424         SSL_shutdown(clientssl);
1425         SSL_free(clientssl);
1426     }
1427     if (serverssl) {
1428         SSL_shutdown(serverssl);
1429         SSL_free(serverssl);
1430     }
1431     SSL_CTX_free(sctx);
1432     SSL_CTX_free(cctx);
1433     serverssl = clientssl = NULL;
1434     BIO_free(out);
1435     BIO_free(in);
1436     if (cfd != -1)
1437         close(cfd);
1438     if (sfd != -1)
1439         close(sfd);
1440     OPENSSL_free(buf);
1441     OPENSSL_free(buf_dst);
1442     return testresult;
1443 }
1444
1445 static struct ktls_test_cipher {
1446     int tls_version;
1447     const char *cipher;
1448 } ktls_test_ciphers[] = {
1449 # if !defined(OPENSSL_NO_TLS1_2)
1450 #  ifdef OPENSSL_KTLS_AES_GCM_128
1451     { TLS1_2_VERSION, "AES128-GCM-SHA256" },
1452 #  endif
1453 #  ifdef OPENSSL_KTLS_AES_CCM_128
1454     { TLS1_2_VERSION, "AES128-CCM"},
1455 #  endif
1456 #  ifdef OPENSSL_KTLS_AES_GCM_256
1457     { TLS1_2_VERSION, "AES256-GCM-SHA384"},
1458 #  endif
1459 #  ifdef OPENSSL_KTLS_CHACHA20_POLY1305
1460 #    ifndef OPENSSL_NO_EC
1461     { TLS1_2_VERSION, "ECDHE-RSA-CHACHA20-POLY1305"},
1462 #    endif
1463 #  endif
1464 # endif
1465 # if !defined(OSSL_NO_USABLE_TLS1_3)
1466 #  ifdef OPENSSL_KTLS_AES_GCM_128
1467     { TLS1_3_VERSION, "TLS_AES_128_GCM_SHA256" },
1468 #  endif
1469 #  ifdef OPENSSL_KTLS_AES_CCM_128
1470     { TLS1_3_VERSION, "TLS_AES_128_CCM_SHA256" },
1471 #  endif
1472 #  ifdef OPENSSL_KTLS_AES_GCM_256
1473     { TLS1_3_VERSION, "TLS_AES_256_GCM_SHA384" },
1474 #  endif
1475 #  ifdef OPENSSL_KTLS_CHACHA20_POLY1305
1476     { TLS1_3_VERSION, "TLS_CHACHA20_POLY1305_SHA256" },
1477 #  endif
1478 # endif
1479 };
1480
1481 #define NUM_KTLS_TEST_CIPHERS \
1482     (sizeof(ktls_test_ciphers) / sizeof(ktls_test_ciphers[0]))
1483
1484 static int test_ktls(int test)
1485 {
1486     struct ktls_test_cipher *cipher;
1487     int cis_ktls, sis_ktls;
1488
1489     OPENSSL_assert(test / 4 < (int)NUM_KTLS_TEST_CIPHERS);
1490     cipher = &ktls_test_ciphers[test / 4];
1491
1492     cis_ktls = (test & 1) != 0;
1493     sis_ktls = (test & 2) != 0;
1494
1495     return execute_test_ktls(cis_ktls, sis_ktls, cipher->tls_version,
1496                              cipher->cipher);
1497 }
1498
1499 static int test_ktls_sendfile(int test)
1500 {
1501     struct ktls_test_cipher *cipher;
1502     int tst = test >> 1;
1503
1504     OPENSSL_assert(tst < (int)NUM_KTLS_TEST_CIPHERS);
1505     cipher = &ktls_test_ciphers[tst];
1506
1507     return execute_test_ktls_sendfile(cipher->tls_version, cipher->cipher,
1508                                       test & 1);
1509 }
1510 #endif
1511
1512 static int test_large_message_tls(void)
1513 {
1514     return execute_test_large_message(TLS_server_method(), TLS_client_method(),
1515                                       TLS1_VERSION, 0, 0);
1516 }
1517
1518 static int test_large_message_tls_read_ahead(void)
1519 {
1520     return execute_test_large_message(TLS_server_method(), TLS_client_method(),
1521                                       TLS1_VERSION, 0, 1);
1522 }
1523
1524 #ifndef OPENSSL_NO_DTLS
1525 static int test_large_message_dtls(void)
1526 {
1527 # ifdef OPENSSL_NO_DTLS1_2
1528     /* Not supported in the FIPS provider */
1529     if (is_fips)
1530         return 1;
1531 # endif
1532     /*
1533      * read_ahead is not relevant to DTLS because DTLS always acts as if
1534      * read_ahead is set.
1535      */
1536     return execute_test_large_message(DTLS_server_method(),
1537                                       DTLS_client_method(),
1538                                       DTLS1_VERSION, 0, 0);
1539 }
1540 #endif
1541
1542 /*
1543  * Test we can successfully send the maximum amount of application data. We
1544  * test each protocol version individually, each with and without EtM enabled.
1545  * TLSv1.3 doesn't use EtM so technically it is redundant to test both but it is
1546  * simpler this way. We also test all combinations with and without the
1547  * SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS option which affects the size of the
1548  * underlying buffer.
1549  */
1550 static int test_large_app_data(int tst)
1551 {
1552     SSL_CTX *cctx = NULL, *sctx = NULL;
1553     SSL *clientssl = NULL, *serverssl = NULL;
1554     int testresult = 0, prot;
1555     unsigned char *msg, *buf = NULL;
1556     size_t written, readbytes;
1557     const SSL_METHOD *smeth = TLS_server_method();
1558     const SSL_METHOD *cmeth = TLS_client_method();
1559
1560     switch (tst >> 2) {
1561     case 0:
1562 #ifndef OSSL_NO_USABLE_TLS1_3
1563         prot = TLS1_3_VERSION;
1564         break;
1565 #else
1566         return 1;
1567 #endif
1568
1569     case 1:
1570 #ifndef OPENSSL_NO_TLS1_2
1571         prot = TLS1_2_VERSION;
1572         break;
1573 #else
1574         return 1;
1575 #endif
1576
1577     case 2:
1578 #ifndef OPENSSL_NO_TLS1_1
1579         prot = TLS1_1_VERSION;
1580         break;
1581 #else
1582         return 1;
1583 #endif
1584
1585     case 3:
1586 #ifndef OPENSSL_NO_TLS1
1587         prot = TLS1_VERSION;
1588         break;
1589 #else
1590         return 1;
1591 #endif
1592
1593     case 4:
1594 #ifndef OPENSSL_NO_SSL3
1595         prot = SSL3_VERSION;
1596         break;
1597 #else
1598         return 1;
1599 #endif
1600
1601     case 5:
1602 #ifndef OPENSSL_NO_DTLS1_2
1603         prot = DTLS1_2_VERSION;
1604         smeth = DTLS_server_method();
1605         cmeth = DTLS_client_method();
1606         break;
1607 #else
1608         return 1;
1609 #endif
1610
1611     case 6:
1612 #ifndef OPENSSL_NO_DTLS1
1613         prot = DTLS1_VERSION;
1614         smeth = DTLS_server_method();
1615         cmeth = DTLS_client_method();
1616         break;
1617 #else
1618         return 1;
1619 #endif
1620
1621     default:
1622         /* Shouldn't happen */
1623         return 0;
1624     }
1625
1626     if ((prot < TLS1_2_VERSION || prot == DTLS1_VERSION) && is_fips)
1627         return 1;
1628
1629     /* Maximal sized message of zeros */
1630     msg = OPENSSL_zalloc(SSL3_RT_MAX_PLAIN_LENGTH);
1631     if (!TEST_ptr(msg))
1632         goto end;
1633
1634     buf = OPENSSL_malloc(SSL3_RT_MAX_PLAIN_LENGTH + 1);
1635     if (!TEST_ptr(buf))
1636         goto end;
1637     /* Set whole buffer to all bits set */
1638     memset(buf, 0xff, SSL3_RT_MAX_PLAIN_LENGTH + 1);
1639
1640     if (!TEST_true(create_ssl_ctx_pair(libctx, smeth, cmeth, prot, prot,
1641                                        &sctx, &cctx, cert, privkey)))
1642         goto end;
1643
1644     if (prot < TLS1_2_VERSION || prot == DTLS1_VERSION) {
1645         /* Older protocol versions need SECLEVEL=0 due to SHA1 usage */
1646         if (!TEST_true(SSL_CTX_set_cipher_list(cctx, "DEFAULT:@SECLEVEL=0"))
1647                 || !TEST_true(SSL_CTX_set_cipher_list(sctx,
1648                                                       "DEFAULT:@SECLEVEL=0")))
1649         goto end;
1650     }
1651
1652     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
1653                                       &clientssl, NULL, NULL)))
1654         goto end;
1655
1656     if ((tst & 1) != 0) {
1657         /* Setting this option gives us a minimally sized underlying buffer */
1658         if (!TEST_true(SSL_set_options(serverssl,
1659                                        SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS))
1660                 || !TEST_true(SSL_set_options(clientssl,
1661                                               SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS)))
1662             goto end;
1663     }
1664
1665     if ((tst & 2) != 0) {
1666         /*
1667          * Setting this option means the MAC is added before encryption
1668          * giving us a larger record for the encryption process
1669          */
1670         if (!TEST_true(SSL_set_options(serverssl, SSL_OP_NO_ENCRYPT_THEN_MAC))
1671                 || !TEST_true(SSL_set_options(clientssl,
1672                                               SSL_OP_NO_ENCRYPT_THEN_MAC)))
1673             goto end;
1674     }
1675
1676     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
1677         goto end;
1678
1679     if (!TEST_true(SSL_write_ex(clientssl, msg, SSL3_RT_MAX_PLAIN_LENGTH,
1680                                 &written))
1681             || !TEST_size_t_eq(written, SSL3_RT_MAX_PLAIN_LENGTH))
1682         goto end;
1683
1684     /* We provide a buffer slightly larger than what we are actually expecting */
1685     if (!TEST_true(SSL_read_ex(serverssl, buf, SSL3_RT_MAX_PLAIN_LENGTH + 1,
1686                                &readbytes)))
1687         goto end;
1688
1689     if (!TEST_mem_eq(msg, written, buf, readbytes))
1690         goto end;
1691
1692     testresult = 1;
1693 end:
1694     OPENSSL_free(msg);
1695     OPENSSL_free(buf);
1696     SSL_free(serverssl);
1697     SSL_free(clientssl);
1698     SSL_CTX_free(sctx);
1699     SSL_CTX_free(cctx);
1700     return testresult;
1701 }
1702
1703 #if !defined(OPENSSL_NO_TLS1_2) || !defined(OSSL_NO_USABLE_TLS1_3) \
1704     || !defined(OPENSSL_NO_DTLS)
1705 static int execute_cleanse_plaintext(const SSL_METHOD *smeth,
1706                                      const SSL_METHOD *cmeth,
1707                                      int min_version, int max_version)
1708 {
1709     size_t i;
1710     SSL_CTX *cctx = NULL, *sctx = NULL;
1711     SSL *clientssl = NULL, *serverssl = NULL;
1712     int testresult = 0;
1713     const unsigned char *zbuf;
1714     SSL_CONNECTION *serversc;
1715     TLS_RECORD *rr;
1716
1717     static unsigned char cbuf[16000];
1718     static unsigned char sbuf[16000];
1719
1720     if (!TEST_true(create_ssl_ctx_pair(libctx,
1721                                        smeth, cmeth,
1722                                        min_version, max_version,
1723                                        &sctx, &cctx, cert,
1724                                        privkey)))
1725         goto end;
1726
1727 # ifdef OPENSSL_NO_DTLS1_2
1728     if (smeth == DTLS_server_method()) {
1729         /* Not supported in the FIPS provider */
1730         if (is_fips) {
1731             testresult = 1;
1732             goto end;
1733         };
1734         /*
1735          * Default sigalgs are SHA1 based in <DTLS1.2 which is in security
1736          * level 0
1737          */
1738         if (!TEST_true(SSL_CTX_set_cipher_list(sctx, "DEFAULT:@SECLEVEL=0"))
1739                 || !TEST_true(SSL_CTX_set_cipher_list(cctx,
1740                                                     "DEFAULT:@SECLEVEL=0")))
1741             goto end;
1742     }
1743 # endif
1744
1745     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
1746                                       NULL, NULL)))
1747         goto end;
1748
1749     if (!TEST_true(SSL_set_options(serverssl, SSL_OP_CLEANSE_PLAINTEXT)))
1750         goto end;
1751
1752     if (!TEST_true(create_ssl_connection(serverssl, clientssl,
1753                                          SSL_ERROR_NONE)))
1754         goto end;
1755
1756     for (i = 0; i < sizeof(cbuf); i++) {
1757         cbuf[i] = i & 0xff;
1758     }
1759
1760     if (!TEST_int_eq(SSL_write(clientssl, cbuf, sizeof(cbuf)), sizeof(cbuf)))
1761         goto end;
1762
1763     if (!TEST_int_eq(SSL_peek(serverssl, &sbuf, sizeof(sbuf)), sizeof(sbuf)))
1764         goto end;
1765
1766     if (!TEST_mem_eq(cbuf, sizeof(cbuf), sbuf, sizeof(sbuf)))
1767         goto end;
1768
1769     /*
1770      * Since we called SSL_peek(), we know the data in the record
1771      * layer is a plaintext record. We can gather the pointer to check
1772      * for zeroization after SSL_read().
1773      */
1774     if (!TEST_ptr(serversc = SSL_CONNECTION_FROM_SSL_ONLY(serverssl)))
1775         goto end;
1776     rr = serversc->rlayer.tlsrecs;
1777
1778     zbuf = &rr->data[rr->off];
1779     if (!TEST_int_eq(rr->length, sizeof(cbuf)))
1780         goto end;
1781
1782     /*
1783      * After SSL_peek() the plaintext must still be stored in the
1784      * record.
1785      */
1786     if (!TEST_mem_eq(cbuf, sizeof(cbuf), zbuf, sizeof(cbuf)))
1787         goto end;
1788
1789     memset(sbuf, 0, sizeof(sbuf));
1790     if (!TEST_int_eq(SSL_read(serverssl, &sbuf, sizeof(sbuf)), sizeof(sbuf)))
1791         goto end;
1792
1793     if (!TEST_mem_eq(cbuf, sizeof(cbuf), sbuf, sizeof(cbuf)))
1794         goto end;
1795
1796     /* Check if rbuf is cleansed */
1797     memset(cbuf, 0, sizeof(cbuf));
1798     if (!TEST_mem_eq(cbuf, sizeof(cbuf), zbuf, sizeof(cbuf)))
1799         goto end;
1800
1801     testresult = 1;
1802  end:
1803     SSL_free(serverssl);
1804     SSL_free(clientssl);
1805     SSL_CTX_free(sctx);
1806     SSL_CTX_free(cctx);
1807
1808     return testresult;
1809 }
1810 #endif /*
1811         * !defined(OPENSSL_NO_TLS1_2) || !defined(OSSL_NO_USABLE_TLS1_3)
1812         * || !defined(OPENSSL_NO_DTLS)
1813         */
1814
1815 static int test_cleanse_plaintext(void)
1816 {
1817 #if !defined(OPENSSL_NO_TLS1_2)
1818     if (!TEST_true(execute_cleanse_plaintext(TLS_server_method(),
1819                                              TLS_client_method(),
1820                                              TLS1_2_VERSION,
1821                                              TLS1_2_VERSION)))
1822         return 0;
1823
1824 #endif
1825
1826 #if !defined(OSSL_NO_USABLE_TLS1_3)
1827     if (!TEST_true(execute_cleanse_plaintext(TLS_server_method(),
1828                                              TLS_client_method(),
1829                                              TLS1_3_VERSION,
1830                                              TLS1_3_VERSION)))
1831         return 0;
1832 #endif
1833
1834 #if !defined(OPENSSL_NO_DTLS)
1835
1836     if (!TEST_true(execute_cleanse_plaintext(DTLS_server_method(),
1837                                              DTLS_client_method(),
1838                                              DTLS1_VERSION,
1839                                              0)))
1840         return 0;
1841 #endif
1842     return 1;
1843 }
1844
1845 #ifndef OPENSSL_NO_OCSP
1846 static int ocsp_server_cb(SSL *s, void *arg)
1847 {
1848     int *argi = (int *)arg;
1849     unsigned char *copy = NULL;
1850     STACK_OF(OCSP_RESPID) *ids = NULL;
1851     OCSP_RESPID *id = NULL;
1852
1853     if (*argi == 2) {
1854         /* In this test we are expecting exactly 1 OCSP_RESPID */
1855         SSL_get_tlsext_status_ids(s, &ids);
1856         if (ids == NULL || sk_OCSP_RESPID_num(ids) != 1)
1857             return SSL_TLSEXT_ERR_ALERT_FATAL;
1858
1859         id = sk_OCSP_RESPID_value(ids, 0);
1860         if (id == NULL || !OCSP_RESPID_match_ex(id, ocspcert, libctx, NULL))
1861             return SSL_TLSEXT_ERR_ALERT_FATAL;
1862     } else if (*argi != 1) {
1863         return SSL_TLSEXT_ERR_ALERT_FATAL;
1864     }
1865
1866     if (!TEST_ptr(copy = OPENSSL_memdup(orespder, sizeof(orespder))))
1867         return SSL_TLSEXT_ERR_ALERT_FATAL;
1868
1869     if (!TEST_true(SSL_set_tlsext_status_ocsp_resp(s, copy,
1870                                                    sizeof(orespder)))) {
1871         OPENSSL_free(copy);
1872         return SSL_TLSEXT_ERR_ALERT_FATAL;
1873     }
1874     ocsp_server_called = 1;
1875     return SSL_TLSEXT_ERR_OK;
1876 }
1877
1878 static int ocsp_client_cb(SSL *s, void *arg)
1879 {
1880     int *argi = (int *)arg;
1881     const unsigned char *respderin;
1882     size_t len;
1883
1884     if (*argi != 1 && *argi != 2)
1885         return 0;
1886
1887     len = SSL_get_tlsext_status_ocsp_resp(s, &respderin);
1888     if (!TEST_mem_eq(orespder, len, respderin, len))
1889         return 0;
1890
1891     ocsp_client_called = 1;
1892     return 1;
1893 }
1894
1895 static int test_tlsext_status_type(void)
1896 {
1897     SSL_CTX *cctx = NULL, *sctx = NULL;
1898     SSL *clientssl = NULL, *serverssl = NULL;
1899     int testresult = 0;
1900     STACK_OF(OCSP_RESPID) *ids = NULL;
1901     OCSP_RESPID *id = NULL;
1902     BIO *certbio = NULL;
1903
1904     if (!create_ssl_ctx_pair(libctx, TLS_server_method(), TLS_client_method(),
1905                              TLS1_VERSION, 0,
1906                              &sctx, &cctx, cert, privkey))
1907         return 0;
1908
1909     if (SSL_CTX_get_tlsext_status_type(cctx) != -1)
1910         goto end;
1911
1912     /* First just do various checks getting and setting tlsext_status_type */
1913
1914     clientssl = SSL_new(cctx);
1915     if (!TEST_int_eq(SSL_get_tlsext_status_type(clientssl), -1)
1916             || !TEST_true(SSL_set_tlsext_status_type(clientssl,
1917                                                       TLSEXT_STATUSTYPE_ocsp))
1918             || !TEST_int_eq(SSL_get_tlsext_status_type(clientssl),
1919                             TLSEXT_STATUSTYPE_ocsp))
1920         goto end;
1921
1922     SSL_free(clientssl);
1923     clientssl = NULL;
1924
1925     if (!SSL_CTX_set_tlsext_status_type(cctx, TLSEXT_STATUSTYPE_ocsp)
1926      || SSL_CTX_get_tlsext_status_type(cctx) != TLSEXT_STATUSTYPE_ocsp)
1927         goto end;
1928
1929     clientssl = SSL_new(cctx);
1930     if (SSL_get_tlsext_status_type(clientssl) != TLSEXT_STATUSTYPE_ocsp)
1931         goto end;
1932     SSL_free(clientssl);
1933     clientssl = NULL;
1934
1935     /*
1936      * Now actually do a handshake and check OCSP information is exchanged and
1937      * the callbacks get called
1938      */
1939     SSL_CTX_set_tlsext_status_cb(cctx, ocsp_client_cb);
1940     SSL_CTX_set_tlsext_status_arg(cctx, &cdummyarg);
1941     SSL_CTX_set_tlsext_status_cb(sctx, ocsp_server_cb);
1942     SSL_CTX_set_tlsext_status_arg(sctx, &cdummyarg);
1943     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
1944                                       &clientssl, NULL, NULL))
1945             || !TEST_true(create_ssl_connection(serverssl, clientssl,
1946                                                 SSL_ERROR_NONE))
1947             || !TEST_true(ocsp_client_called)
1948             || !TEST_true(ocsp_server_called))
1949         goto end;
1950     SSL_free(serverssl);
1951     SSL_free(clientssl);
1952     serverssl = NULL;
1953     clientssl = NULL;
1954
1955     /* Try again but this time force the server side callback to fail */
1956     ocsp_client_called = 0;
1957     ocsp_server_called = 0;
1958     cdummyarg = 0;
1959     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
1960                                       &clientssl, NULL, NULL))
1961                 /* This should fail because the callback will fail */
1962             || !TEST_false(create_ssl_connection(serverssl, clientssl,
1963                                                  SSL_ERROR_NONE))
1964             || !TEST_false(ocsp_client_called)
1965             || !TEST_false(ocsp_server_called))
1966         goto end;
1967     SSL_free(serverssl);
1968     SSL_free(clientssl);
1969     serverssl = NULL;
1970     clientssl = NULL;
1971
1972     /*
1973      * This time we'll get the client to send an OCSP_RESPID that it will
1974      * accept.
1975      */
1976     ocsp_client_called = 0;
1977     ocsp_server_called = 0;
1978     cdummyarg = 2;
1979     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
1980                                       &clientssl, NULL, NULL)))
1981         goto end;
1982
1983     /*
1984      * We'll just use any old cert for this test - it doesn't have to be an OCSP
1985      * specific one. We'll use the server cert.
1986      */
1987     if (!TEST_ptr(certbio = BIO_new_file(cert, "r"))
1988             || !TEST_ptr(id = OCSP_RESPID_new())
1989             || !TEST_ptr(ids = sk_OCSP_RESPID_new_null())
1990             || !TEST_ptr(ocspcert = X509_new_ex(libctx, NULL))
1991             || !TEST_ptr(PEM_read_bio_X509(certbio, &ocspcert, NULL, NULL))
1992             || !TEST_true(OCSP_RESPID_set_by_key_ex(id, ocspcert, libctx, NULL))
1993             || !TEST_true(sk_OCSP_RESPID_push(ids, id)))
1994         goto end;
1995     id = NULL;
1996     SSL_set_tlsext_status_ids(clientssl, ids);
1997     /* Control has been transferred */
1998     ids = NULL;
1999
2000     BIO_free(certbio);
2001     certbio = NULL;
2002
2003     if (!TEST_true(create_ssl_connection(serverssl, clientssl,
2004                                          SSL_ERROR_NONE))
2005             || !TEST_true(ocsp_client_called)
2006             || !TEST_true(ocsp_server_called))
2007         goto end;
2008
2009     testresult = 1;
2010
2011  end:
2012     SSL_free(serverssl);
2013     SSL_free(clientssl);
2014     SSL_CTX_free(sctx);
2015     SSL_CTX_free(cctx);
2016     sk_OCSP_RESPID_pop_free(ids, OCSP_RESPID_free);
2017     OCSP_RESPID_free(id);
2018     BIO_free(certbio);
2019     X509_free(ocspcert);
2020     ocspcert = NULL;
2021
2022     return testresult;
2023 }
2024 #endif
2025
2026 #if !defined(OSSL_NO_USABLE_TLS1_3) || !defined(OPENSSL_NO_TLS1_2)
2027 static int new_called, remove_called, get_called;
2028
2029 static int new_session_cb(SSL *ssl, SSL_SESSION *sess)
2030 {
2031     new_called++;
2032     /*
2033      * sess has been up-refed for us, but we don't actually need it so free it
2034      * immediately.
2035      */
2036     SSL_SESSION_free(sess);
2037     return 1;
2038 }
2039
2040 static void remove_session_cb(SSL_CTX *ctx, SSL_SESSION *sess)
2041 {
2042     remove_called++;
2043 }
2044
2045 static SSL_SESSION *get_sess_val = NULL;
2046
2047 static SSL_SESSION *get_session_cb(SSL *ssl, const unsigned char *id, int len,
2048                                    int *copy)
2049 {
2050     get_called++;
2051     *copy = 1;
2052     return get_sess_val;
2053 }
2054
2055 static int execute_test_session(int maxprot, int use_int_cache,
2056                                 int use_ext_cache, long s_options)
2057 {
2058     SSL_CTX *sctx = NULL, *cctx = NULL;
2059     SSL *serverssl1 = NULL, *clientssl1 = NULL;
2060     SSL *serverssl2 = NULL, *clientssl2 = NULL;
2061 # ifndef OPENSSL_NO_TLS1_1
2062     SSL *serverssl3 = NULL, *clientssl3 = NULL;
2063 # endif
2064     SSL_SESSION *sess1 = NULL, *sess2 = NULL;
2065     int testresult = 0, numnewsesstick = 1;
2066
2067     new_called = remove_called = 0;
2068
2069     /* TLSv1.3 sends 2 NewSessionTickets */
2070     if (maxprot == TLS1_3_VERSION)
2071         numnewsesstick = 2;
2072
2073     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
2074                                        TLS_client_method(), TLS1_VERSION, 0,
2075                                        &sctx, &cctx, cert, privkey)))
2076         return 0;
2077
2078     /*
2079      * Only allow the max protocol version so we can force a connection failure
2080      * later
2081      */
2082     SSL_CTX_set_min_proto_version(cctx, maxprot);
2083     SSL_CTX_set_max_proto_version(cctx, maxprot);
2084
2085     /* Set up session cache */
2086     if (use_ext_cache) {
2087         SSL_CTX_sess_set_new_cb(cctx, new_session_cb);
2088         SSL_CTX_sess_set_remove_cb(cctx, remove_session_cb);
2089     }
2090     if (use_int_cache) {
2091         /* Also covers instance where both are set */
2092         SSL_CTX_set_session_cache_mode(cctx, SSL_SESS_CACHE_CLIENT);
2093     } else {
2094         SSL_CTX_set_session_cache_mode(cctx,
2095                                        SSL_SESS_CACHE_CLIENT
2096                                        | SSL_SESS_CACHE_NO_INTERNAL_STORE);
2097     }
2098
2099     if (s_options) {
2100         SSL_CTX_set_options(sctx, s_options);
2101     }
2102
2103     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl1, &clientssl1,
2104                                       NULL, NULL))
2105             || !TEST_true(create_ssl_connection(serverssl1, clientssl1,
2106                                                 SSL_ERROR_NONE))
2107             || !TEST_ptr(sess1 = SSL_get1_session(clientssl1)))
2108         goto end;
2109
2110     /* Should fail because it should already be in the cache */
2111     if (use_int_cache && !TEST_false(SSL_CTX_add_session(cctx, sess1)))
2112         goto end;
2113     if (use_ext_cache
2114             && (!TEST_int_eq(new_called, numnewsesstick)
2115
2116                 || !TEST_int_eq(remove_called, 0)))
2117         goto end;
2118
2119     new_called = remove_called = 0;
2120     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl2,
2121                                       &clientssl2, NULL, NULL))
2122             || !TEST_true(SSL_set_session(clientssl2, sess1))
2123             || !TEST_true(create_ssl_connection(serverssl2, clientssl2,
2124                                                 SSL_ERROR_NONE))
2125             || !TEST_true(SSL_session_reused(clientssl2)))
2126         goto end;
2127
2128     if (maxprot == TLS1_3_VERSION) {
2129         /*
2130          * In TLSv1.3 we should have created a new session even though we have
2131          * resumed. Since we attempted a resume we should also have removed the
2132          * old ticket from the cache so that we try to only use tickets once.
2133          */
2134         if (use_ext_cache
2135                 && (!TEST_int_eq(new_called, 1)
2136                     || !TEST_int_eq(remove_called, 1)))
2137             goto end;
2138     } else {
2139         /*
2140          * In TLSv1.2 we expect to have resumed so no sessions added or
2141          * removed.
2142          */
2143         if (use_ext_cache
2144                 && (!TEST_int_eq(new_called, 0)
2145                     || !TEST_int_eq(remove_called, 0)))
2146             goto end;
2147     }
2148
2149     SSL_SESSION_free(sess1);
2150     if (!TEST_ptr(sess1 = SSL_get1_session(clientssl2)))
2151         goto end;
2152     shutdown_ssl_connection(serverssl2, clientssl2);
2153     serverssl2 = clientssl2 = NULL;
2154
2155     new_called = remove_called = 0;
2156     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl2,
2157                                       &clientssl2, NULL, NULL))
2158             || !TEST_true(create_ssl_connection(serverssl2, clientssl2,
2159                                                 SSL_ERROR_NONE)))
2160         goto end;
2161
2162     if (!TEST_ptr(sess2 = SSL_get1_session(clientssl2)))
2163         goto end;
2164
2165     if (use_ext_cache
2166             && (!TEST_int_eq(new_called, numnewsesstick)
2167                 || !TEST_int_eq(remove_called, 0)))
2168         goto end;
2169
2170     new_called = remove_called = 0;
2171     /*
2172      * This should clear sess2 from the cache because it is a "bad" session.
2173      * See SSL_set_session() documentation.
2174      */
2175     if (!TEST_true(SSL_set_session(clientssl2, sess1)))
2176         goto end;
2177     if (use_ext_cache
2178             && (!TEST_int_eq(new_called, 0) || !TEST_int_eq(remove_called, 1)))
2179         goto end;
2180     if (!TEST_ptr_eq(SSL_get_session(clientssl2), sess1))
2181         goto end;
2182
2183     if (use_int_cache) {
2184         /* Should succeeded because it should not already be in the cache */
2185         if (!TEST_true(SSL_CTX_add_session(cctx, sess2))
2186                 || !TEST_true(SSL_CTX_remove_session(cctx, sess2)))
2187             goto end;
2188     }
2189
2190     new_called = remove_called = 0;
2191     /* This shouldn't be in the cache so should fail */
2192     if (!TEST_false(SSL_CTX_remove_session(cctx, sess2)))
2193         goto end;
2194
2195     if (use_ext_cache
2196             && (!TEST_int_eq(new_called, 0) || !TEST_int_eq(remove_called, 1)))
2197         goto end;
2198
2199 # if !defined(OPENSSL_NO_TLS1_1)
2200     new_called = remove_called = 0;
2201     /* Force a connection failure */
2202     SSL_CTX_set_max_proto_version(sctx, TLS1_1_VERSION);
2203     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl3,
2204                                       &clientssl3, NULL, NULL))
2205             || !TEST_true(SSL_set_session(clientssl3, sess1))
2206             /* This should fail because of the mismatched protocol versions */
2207             || !TEST_false(create_ssl_connection(serverssl3, clientssl3,
2208                                                  SSL_ERROR_NONE)))
2209         goto end;
2210
2211     /* We should have automatically removed the session from the cache */
2212     if (use_ext_cache
2213             && (!TEST_int_eq(new_called, 0) || !TEST_int_eq(remove_called, 1)))
2214         goto end;
2215
2216     /* Should succeed because it should not already be in the cache */
2217     if (use_int_cache && !TEST_true(SSL_CTX_add_session(cctx, sess2)))
2218         goto end;
2219 # endif
2220
2221     /* Now do some tests for server side caching */
2222     if (use_ext_cache) {
2223         SSL_CTX_sess_set_new_cb(cctx, NULL);
2224         SSL_CTX_sess_set_remove_cb(cctx, NULL);
2225         SSL_CTX_sess_set_new_cb(sctx, new_session_cb);
2226         SSL_CTX_sess_set_remove_cb(sctx, remove_session_cb);
2227         SSL_CTX_sess_set_get_cb(sctx, get_session_cb);
2228         get_sess_val = NULL;
2229     }
2230
2231     SSL_CTX_set_session_cache_mode(cctx, 0);
2232     /* Internal caching is the default on the server side */
2233     if (!use_int_cache)
2234         SSL_CTX_set_session_cache_mode(sctx,
2235                                        SSL_SESS_CACHE_SERVER
2236                                        | SSL_SESS_CACHE_NO_INTERNAL_STORE);
2237
2238     SSL_free(serverssl1);
2239     SSL_free(clientssl1);
2240     serverssl1 = clientssl1 = NULL;
2241     SSL_free(serverssl2);
2242     SSL_free(clientssl2);
2243     serverssl2 = clientssl2 = NULL;
2244     SSL_SESSION_free(sess1);
2245     sess1 = NULL;
2246     SSL_SESSION_free(sess2);
2247     sess2 = NULL;
2248
2249     SSL_CTX_set_max_proto_version(sctx, maxprot);
2250     if (maxprot == TLS1_2_VERSION)
2251         SSL_CTX_set_options(sctx, SSL_OP_NO_TICKET);
2252     new_called = remove_called = get_called = 0;
2253     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl1, &clientssl1,
2254                                       NULL, NULL))
2255             || !TEST_true(create_ssl_connection(serverssl1, clientssl1,
2256                                                 SSL_ERROR_NONE))
2257             || !TEST_ptr(sess1 = SSL_get1_session(clientssl1))
2258             || !TEST_ptr(sess2 = SSL_get1_session(serverssl1)))
2259         goto end;
2260
2261     if (use_int_cache) {
2262         if (maxprot == TLS1_3_VERSION && !use_ext_cache) {
2263             /*
2264              * In TLSv1.3 it should not have been added to the internal cache,
2265              * except in the case where we also have an external cache (in that
2266              * case it gets added to the cache in order to generate remove
2267              * events after timeout).
2268              */
2269             if (!TEST_false(SSL_CTX_remove_session(sctx, sess2)))
2270                 goto end;
2271         } else {
2272             /* Should fail because it should already be in the cache */
2273             if (!TEST_false(SSL_CTX_add_session(sctx, sess2)))
2274                 goto end;
2275         }
2276     }
2277
2278     if (use_ext_cache) {
2279         SSL_SESSION *tmp = sess2;
2280
2281         if (!TEST_int_eq(new_called, numnewsesstick)
2282                 || !TEST_int_eq(remove_called, 0)
2283                 || !TEST_int_eq(get_called, 0))
2284             goto end;
2285         /*
2286          * Delete the session from the internal cache to force a lookup from
2287          * the external cache. We take a copy first because
2288          * SSL_CTX_remove_session() also marks the session as non-resumable.
2289          */
2290         if (use_int_cache && maxprot != TLS1_3_VERSION) {
2291             if (!TEST_ptr(tmp = SSL_SESSION_dup(sess2))
2292                 || !TEST_true(sess2->owner != NULL)
2293                 || !TEST_true(tmp->owner == NULL)
2294                 || !TEST_true(SSL_CTX_remove_session(sctx, sess2)))
2295                 goto end;
2296             SSL_SESSION_free(sess2);
2297         }
2298         sess2 = tmp;
2299     }
2300
2301     new_called = remove_called = get_called = 0;
2302     get_sess_val = sess2;
2303     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl2,
2304                                       &clientssl2, NULL, NULL))
2305             || !TEST_true(SSL_set_session(clientssl2, sess1))
2306             || !TEST_true(create_ssl_connection(serverssl2, clientssl2,
2307                                                 SSL_ERROR_NONE))
2308             || !TEST_true(SSL_session_reused(clientssl2)))
2309         goto end;
2310
2311     if (use_ext_cache) {
2312         if (!TEST_int_eq(remove_called, 0))
2313             goto end;
2314
2315         if (maxprot == TLS1_3_VERSION) {
2316             if (!TEST_int_eq(new_called, 1)
2317                     || !TEST_int_eq(get_called, 0))
2318                 goto end;
2319         } else {
2320             if (!TEST_int_eq(new_called, 0)
2321                     || !TEST_int_eq(get_called, 1))
2322                 goto end;
2323         }
2324     }
2325     /*
2326      * Make a small cache, force out all other sessions but
2327      * sess2, try to add sess1, which should succeed. Then
2328      * make sure it's there by checking the owners. Despite
2329      * the timeouts, sess1 should have kicked out sess2
2330      */
2331
2332     /* Make sess1 expire before sess2 */
2333     if (!TEST_long_gt(SSL_SESSION_set_time(sess1, 1000), 0)
2334             || !TEST_long_gt(SSL_SESSION_set_timeout(sess1, 1000), 0)
2335             || !TEST_long_gt(SSL_SESSION_set_time(sess2, 2000), 0)
2336             || !TEST_long_gt(SSL_SESSION_set_timeout(sess2, 2000), 0))
2337         goto end;
2338
2339     if (!TEST_long_ne(SSL_CTX_sess_set_cache_size(sctx, 1), 0))
2340         goto end;
2341
2342     /* Don't care about results - cache should only be sess2 at end */
2343     SSL_CTX_add_session(sctx, sess1);
2344     SSL_CTX_add_session(sctx, sess2);
2345
2346     /* Now add sess1, and make sure it remains, despite timeout */
2347     if (!TEST_true(SSL_CTX_add_session(sctx, sess1))
2348             || !TEST_ptr(sess1->owner)
2349             || !TEST_ptr_null(sess2->owner))
2350         goto end;
2351
2352     testresult = 1;
2353
2354  end:
2355     SSL_free(serverssl1);
2356     SSL_free(clientssl1);
2357     SSL_free(serverssl2);
2358     SSL_free(clientssl2);
2359 # ifndef OPENSSL_NO_TLS1_1
2360     SSL_free(serverssl3);
2361     SSL_free(clientssl3);
2362 # endif
2363     SSL_SESSION_free(sess1);
2364     SSL_SESSION_free(sess2);
2365     SSL_CTX_free(sctx);
2366     SSL_CTX_free(cctx);
2367
2368     return testresult;
2369 }
2370 #endif /* !defined(OSSL_NO_USABLE_TLS1_3) || !defined(OPENSSL_NO_TLS1_2) */
2371
2372 static int test_session_with_only_int_cache(void)
2373 {
2374 #ifndef OSSL_NO_USABLE_TLS1_3
2375     if (!execute_test_session(TLS1_3_VERSION, 1, 0, 0))
2376         return 0;
2377 #endif
2378
2379 #ifndef OPENSSL_NO_TLS1_2
2380     return execute_test_session(TLS1_2_VERSION, 1, 0, 0);
2381 #else
2382     return 1;
2383 #endif
2384 }
2385
2386 static int test_session_with_only_ext_cache(void)
2387 {
2388 #ifndef OSSL_NO_USABLE_TLS1_3
2389     if (!execute_test_session(TLS1_3_VERSION, 0, 1, 0))
2390         return 0;
2391 #endif
2392
2393 #ifndef OPENSSL_NO_TLS1_2
2394     return execute_test_session(TLS1_2_VERSION, 0, 1, 0);
2395 #else
2396     return 1;
2397 #endif
2398 }
2399
2400 static int test_session_with_both_cache(void)
2401 {
2402 #ifndef OSSL_NO_USABLE_TLS1_3
2403     if (!execute_test_session(TLS1_3_VERSION, 1, 1, 0))
2404         return 0;
2405 #endif
2406
2407 #ifndef OPENSSL_NO_TLS1_2
2408     return execute_test_session(TLS1_2_VERSION, 1, 1, 0);
2409 #else
2410     return 1;
2411 #endif
2412 }
2413
2414 static int test_session_wo_ca_names(void)
2415 {
2416 #ifndef OSSL_NO_USABLE_TLS1_3
2417     if (!execute_test_session(TLS1_3_VERSION, 1, 0, SSL_OP_DISABLE_TLSEXT_CA_NAMES))
2418         return 0;
2419 #endif
2420
2421 #ifndef OPENSSL_NO_TLS1_2
2422     return execute_test_session(TLS1_2_VERSION, 1, 0, SSL_OP_DISABLE_TLSEXT_CA_NAMES);
2423 #else
2424     return 1;
2425 #endif
2426 }
2427
2428 #ifndef OSSL_NO_USABLE_TLS1_3
2429 static SSL_SESSION *sesscache[6];
2430 static int do_cache;
2431
2432 static int new_cachesession_cb(SSL *ssl, SSL_SESSION *sess)
2433 {
2434     if (do_cache) {
2435         sesscache[new_called] = sess;
2436     } else {
2437         /* We don't need the reference to the session, so free it */
2438         SSL_SESSION_free(sess);
2439     }
2440     new_called++;
2441
2442     return 1;
2443 }
2444
2445 static int post_handshake_verify(SSL *sssl, SSL *cssl)
2446 {
2447     SSL_set_verify(sssl, SSL_VERIFY_PEER, NULL);
2448     if (!TEST_true(SSL_verify_client_post_handshake(sssl)))
2449         return 0;
2450
2451     /* Start handshake on the server and client */
2452     if (!TEST_int_eq(SSL_do_handshake(sssl), 1)
2453             || !TEST_int_le(SSL_read(cssl, NULL, 0), 0)
2454             || !TEST_int_le(SSL_read(sssl, NULL, 0), 0)
2455             || !TEST_true(create_ssl_connection(sssl, cssl,
2456                                                 SSL_ERROR_NONE)))
2457         return 0;
2458
2459     return 1;
2460 }
2461
2462 static int setup_ticket_test(int stateful, int idx, SSL_CTX **sctx,
2463                              SSL_CTX **cctx)
2464 {
2465     int sess_id_ctx = 1;
2466
2467     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
2468                                        TLS_client_method(), TLS1_VERSION, 0,
2469                                        sctx, cctx, cert, privkey))
2470             || !TEST_true(SSL_CTX_set_num_tickets(*sctx, idx))
2471             || !TEST_true(SSL_CTX_set_session_id_context(*sctx,
2472                                                          (void *)&sess_id_ctx,
2473                                                          sizeof(sess_id_ctx))))
2474         return 0;
2475
2476     if (stateful)
2477         SSL_CTX_set_options(*sctx, SSL_OP_NO_TICKET);
2478
2479     SSL_CTX_set_session_cache_mode(*cctx, SSL_SESS_CACHE_CLIENT
2480                                           | SSL_SESS_CACHE_NO_INTERNAL_STORE);
2481     SSL_CTX_sess_set_new_cb(*cctx, new_cachesession_cb);
2482
2483     return 1;
2484 }
2485
2486 static int check_resumption(int idx, SSL_CTX *sctx, SSL_CTX *cctx, int succ)
2487 {
2488     SSL *serverssl = NULL, *clientssl = NULL;
2489     int i;
2490
2491     /* Test that we can resume with all the tickets we got given */
2492     for (i = 0; i < idx * 2; i++) {
2493         new_called = 0;
2494         if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
2495                                               &clientssl, NULL, NULL))
2496                 || !TEST_true(SSL_set_session(clientssl, sesscache[i])))
2497             goto end;
2498
2499         SSL_set_post_handshake_auth(clientssl, 1);
2500
2501         if (!TEST_true(create_ssl_connection(serverssl, clientssl,
2502                                                     SSL_ERROR_NONE)))
2503             goto end;
2504
2505         /*
2506          * Following a successful resumption we only get 1 ticket. After a
2507          * failed one we should get idx tickets.
2508          */
2509         if (succ) {
2510             if (!TEST_true(SSL_session_reused(clientssl))
2511                     || !TEST_int_eq(new_called, 1))
2512                 goto end;
2513         } else {
2514             if (!TEST_false(SSL_session_reused(clientssl))
2515                     || !TEST_int_eq(new_called, idx))
2516                 goto end;
2517         }
2518
2519         new_called = 0;
2520         /* After a post-handshake authentication we should get 1 new ticket */
2521         if (succ
2522                 && (!post_handshake_verify(serverssl, clientssl)
2523                     || !TEST_int_eq(new_called, 1)))
2524             goto end;
2525
2526         SSL_shutdown(clientssl);
2527         SSL_shutdown(serverssl);
2528         SSL_free(serverssl);
2529         SSL_free(clientssl);
2530         serverssl = clientssl = NULL;
2531         SSL_SESSION_free(sesscache[i]);
2532         sesscache[i] = NULL;
2533     }
2534
2535     return 1;
2536
2537  end:
2538     SSL_free(clientssl);
2539     SSL_free(serverssl);
2540     return 0;
2541 }
2542
2543 static int test_tickets(int stateful, int idx)
2544 {
2545     SSL_CTX *sctx = NULL, *cctx = NULL;
2546     SSL *serverssl = NULL, *clientssl = NULL;
2547     int testresult = 0;
2548     size_t j;
2549
2550     /* idx is the test number, but also the number of tickets we want */
2551
2552     new_called = 0;
2553     do_cache = 1;
2554
2555     if (!setup_ticket_test(stateful, idx, &sctx, &cctx))
2556         goto end;
2557
2558     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
2559                                           &clientssl, NULL, NULL)))
2560         goto end;
2561
2562     if (!TEST_true(create_ssl_connection(serverssl, clientssl,
2563                                                 SSL_ERROR_NONE))
2564                /* Check we got the number of tickets we were expecting */
2565             || !TEST_int_eq(idx, new_called))
2566         goto end;
2567
2568     SSL_shutdown(clientssl);
2569     SSL_shutdown(serverssl);
2570     SSL_free(serverssl);
2571     SSL_free(clientssl);
2572     SSL_CTX_free(sctx);
2573     SSL_CTX_free(cctx);
2574     clientssl = serverssl = NULL;
2575     sctx = cctx = NULL;
2576
2577     /*
2578      * Now we try to resume with the tickets we previously created. The
2579      * resumption attempt is expected to fail (because we're now using a new
2580      * SSL_CTX). We should see idx number of tickets issued again.
2581      */
2582
2583     /* Stop caching sessions - just count them */
2584     do_cache = 0;
2585
2586     if (!setup_ticket_test(stateful, idx, &sctx, &cctx))
2587         goto end;
2588
2589     if (!check_resumption(idx, sctx, cctx, 0))
2590         goto end;
2591
2592     /* Start again with caching sessions */
2593     new_called = 0;
2594     do_cache = 1;
2595     SSL_CTX_free(sctx);
2596     SSL_CTX_free(cctx);
2597     sctx = cctx = NULL;
2598
2599     if (!setup_ticket_test(stateful, idx, &sctx, &cctx))
2600         goto end;
2601
2602     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
2603                                           &clientssl, NULL, NULL)))
2604         goto end;
2605
2606     SSL_set_post_handshake_auth(clientssl, 1);
2607
2608     if (!TEST_true(create_ssl_connection(serverssl, clientssl,
2609                                                 SSL_ERROR_NONE))
2610                /* Check we got the number of tickets we were expecting */
2611             || !TEST_int_eq(idx, new_called))
2612         goto end;
2613
2614     /* After a post-handshake authentication we should get new tickets issued */
2615     if (!post_handshake_verify(serverssl, clientssl)
2616             || !TEST_int_eq(idx * 2, new_called))
2617         goto end;
2618
2619     SSL_shutdown(clientssl);
2620     SSL_shutdown(serverssl);
2621     SSL_free(serverssl);
2622     SSL_free(clientssl);
2623     serverssl = clientssl = NULL;
2624
2625     /* Stop caching sessions - just count them */
2626     do_cache = 0;
2627
2628     /*
2629      * Check we can resume with all the tickets we created. This time around the
2630      * resumptions should all be successful.
2631      */
2632     if (!check_resumption(idx, sctx, cctx, 1))
2633         goto end;
2634
2635     testresult = 1;
2636
2637  end:
2638     SSL_free(serverssl);
2639     SSL_free(clientssl);
2640     for (j = 0; j < OSSL_NELEM(sesscache); j++) {
2641         SSL_SESSION_free(sesscache[j]);
2642         sesscache[j] = NULL;
2643     }
2644     SSL_CTX_free(sctx);
2645     SSL_CTX_free(cctx);
2646
2647     return testresult;
2648 }
2649
2650 static int test_stateless_tickets(int idx)
2651 {
2652     return test_tickets(0, idx);
2653 }
2654
2655 static int test_stateful_tickets(int idx)
2656 {
2657     return test_tickets(1, idx);
2658 }
2659
2660 static int test_psk_tickets(void)
2661 {
2662     SSL_CTX *sctx = NULL, *cctx = NULL;
2663     SSL *serverssl = NULL, *clientssl = NULL;
2664     int testresult = 0;
2665     int sess_id_ctx = 1;
2666
2667     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
2668                                        TLS_client_method(), TLS1_VERSION, 0,
2669                                        &sctx, &cctx, NULL, NULL))
2670             || !TEST_true(SSL_CTX_set_session_id_context(sctx,
2671                                                          (void *)&sess_id_ctx,
2672                                                          sizeof(sess_id_ctx))))
2673         goto end;
2674
2675     SSL_CTX_set_session_cache_mode(cctx, SSL_SESS_CACHE_CLIENT
2676                                          | SSL_SESS_CACHE_NO_INTERNAL_STORE);
2677     SSL_CTX_set_psk_use_session_callback(cctx, use_session_cb);
2678     SSL_CTX_set_psk_find_session_callback(sctx, find_session_cb);
2679     SSL_CTX_sess_set_new_cb(cctx, new_session_cb);
2680     use_session_cb_cnt = 0;
2681     find_session_cb_cnt = 0;
2682     srvid = pskid;
2683     new_called = 0;
2684
2685     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
2686                                       NULL, NULL)))
2687         goto end;
2688     clientpsk = serverpsk = create_a_psk(clientssl, SHA384_DIGEST_LENGTH);
2689     if (!TEST_ptr(clientpsk))
2690         goto end;
2691     SSL_SESSION_up_ref(clientpsk);
2692
2693     if (!TEST_true(create_ssl_connection(serverssl, clientssl,
2694                                                 SSL_ERROR_NONE))
2695             || !TEST_int_eq(1, find_session_cb_cnt)
2696             || !TEST_int_eq(1, use_session_cb_cnt)
2697                /* We should always get 1 ticket when using external PSK */
2698             || !TEST_int_eq(1, new_called))
2699         goto end;
2700
2701     testresult = 1;
2702
2703  end:
2704     SSL_free(serverssl);
2705     SSL_free(clientssl);
2706     SSL_CTX_free(sctx);
2707     SSL_CTX_free(cctx);
2708     SSL_SESSION_free(clientpsk);
2709     SSL_SESSION_free(serverpsk);
2710     clientpsk = serverpsk = NULL;
2711
2712     return testresult;
2713 }
2714
2715 static int test_extra_tickets(int idx)
2716 {
2717     SSL_CTX *sctx = NULL, *cctx = NULL;
2718     SSL *serverssl = NULL, *clientssl = NULL;
2719     BIO *bretry = BIO_new(bio_s_always_retry());
2720     BIO *tmp = NULL;
2721     int testresult = 0;
2722     int stateful = 0;
2723     size_t nbytes;
2724     unsigned char c, buf[1];
2725
2726     new_called = 0;
2727     do_cache = 1;
2728
2729     if (idx >= 3) {
2730         idx -= 3;
2731         stateful = 1;
2732     }
2733
2734     if (!TEST_ptr(bretry) || !setup_ticket_test(stateful, idx, &sctx, &cctx))
2735         goto end;
2736     SSL_CTX_sess_set_new_cb(sctx, new_session_cb);
2737     /* setup_ticket_test() uses new_cachesession_cb which we don't need. */
2738     SSL_CTX_sess_set_new_cb(cctx, new_session_cb);
2739
2740     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
2741                                           &clientssl, NULL, NULL)))
2742         goto end;
2743
2744     /*
2745      * Note that we have new_session_cb on both sctx and cctx, so new_called is
2746      * incremented by both client and server.
2747      */
2748     if (!TEST_true(create_ssl_connection(serverssl, clientssl,
2749                                                 SSL_ERROR_NONE))
2750                /* Check we got the number of tickets we were expecting */
2751             || !TEST_int_eq(idx * 2, new_called)
2752             || !TEST_true(SSL_new_session_ticket(serverssl))
2753             || !TEST_true(SSL_new_session_ticket(serverssl))
2754             || !TEST_int_eq(idx * 2, new_called))
2755         goto end;
2756
2757     /* Now try a (real) write to actually send the tickets */
2758     c = '1';
2759     if (!TEST_true(SSL_write_ex(serverssl, &c, 1, &nbytes))
2760             || !TEST_size_t_eq(1, nbytes)
2761             || !TEST_int_eq(idx * 2 + 2, new_called)
2762             || !TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &nbytes))
2763             || !TEST_int_eq(idx * 2 + 4, new_called)
2764             || !TEST_int_eq(sizeof(buf), nbytes)
2765             || !TEST_int_eq(c, buf[0])
2766             || !TEST_false(SSL_read_ex(clientssl, buf, sizeof(buf), &nbytes)))
2767         goto end;
2768
2769     /* Try with only requesting one new ticket, too */
2770     c = '2';
2771     new_called = 0;
2772     if (!TEST_true(SSL_new_session_ticket(serverssl))
2773             || !TEST_true(SSL_write_ex(serverssl, &c, sizeof(c), &nbytes))
2774             || !TEST_size_t_eq(sizeof(c), nbytes)
2775             || !TEST_int_eq(1, new_called)
2776             || !TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &nbytes))
2777             || !TEST_int_eq(2, new_called)
2778             || !TEST_size_t_eq(sizeof(buf), nbytes)
2779             || !TEST_int_eq(c, buf[0]))
2780         goto end;
2781
2782     /* Do it again but use dummy writes to drive the ticket generation */
2783     c = '3';
2784     new_called = 0;
2785     if (!TEST_true(SSL_new_session_ticket(serverssl))
2786             || !TEST_true(SSL_new_session_ticket(serverssl))
2787             || !TEST_true(SSL_write_ex(serverssl, &c, 0, &nbytes))
2788             || !TEST_size_t_eq(0, nbytes)
2789             || !TEST_int_eq(2, new_called)
2790             || !TEST_false(SSL_read_ex(clientssl, buf, sizeof(buf), &nbytes))
2791             || !TEST_int_eq(4, new_called))
2792         goto end;
2793
2794     /* Once more, but with SSL_do_handshake() to drive the ticket generation */
2795     c = '4';
2796     new_called = 0;
2797     if (!TEST_true(SSL_new_session_ticket(serverssl))
2798             || !TEST_true(SSL_new_session_ticket(serverssl))
2799             || !TEST_true(SSL_do_handshake(serverssl))
2800             || !TEST_int_eq(2, new_called)
2801             || !TEST_false(SSL_read_ex(clientssl, buf, sizeof(buf), &nbytes))
2802             || !TEST_int_eq(4, new_called))
2803         goto end;
2804
2805     /*
2806      * Use the always-retry BIO to exercise the logic that forces ticket
2807      * generation to wait until a record boundary.
2808      */
2809     c = '5';
2810     new_called = 0;
2811     tmp = SSL_get_wbio(serverssl);
2812     if (!TEST_ptr(tmp) || !TEST_true(BIO_up_ref(tmp))) {
2813         tmp = NULL;
2814         goto end;
2815     }
2816     SSL_set0_wbio(serverssl, bretry);
2817     bretry = NULL;
2818     if (!TEST_false(SSL_write_ex(serverssl, &c, 1, &nbytes))
2819             || !TEST_int_eq(SSL_get_error(serverssl, 0), SSL_ERROR_WANT_WRITE)
2820             || !TEST_size_t_eq(nbytes, 0))
2821         goto end;
2822     /* Restore a BIO that will let the write succeed */
2823     SSL_set0_wbio(serverssl, tmp);
2824     tmp = NULL;
2825     /*
2826      * These calls should just queue the request and not send anything
2827      * even if we explicitly try to hit the state machine.
2828      */
2829     if (!TEST_true(SSL_new_session_ticket(serverssl))
2830             || !TEST_true(SSL_new_session_ticket(serverssl))
2831             || !TEST_int_eq(0, new_called)
2832             || !TEST_true(SSL_do_handshake(serverssl))
2833             || !TEST_int_eq(0, new_called))
2834         goto end;
2835     /* Re-do the write; still no tickets sent */
2836     if (!TEST_true(SSL_write_ex(serverssl, &c, 1, &nbytes))
2837             || !TEST_size_t_eq(1, nbytes)
2838             || !TEST_int_eq(0, new_called)
2839             || !TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &nbytes))
2840             || !TEST_int_eq(0, new_called)
2841             || !TEST_int_eq(sizeof(buf), nbytes)
2842             || !TEST_int_eq(c, buf[0])
2843             || !TEST_false(SSL_read_ex(clientssl, buf, sizeof(buf), &nbytes)))
2844         goto end;
2845     /* Even trying to hit the state machine now will still not send tickets */
2846     if (!TEST_true(SSL_do_handshake(serverssl))
2847             || !TEST_int_eq(0, new_called))
2848         goto end;
2849     /* Now the *next* write should send the tickets */
2850     c = '6';
2851     if (!TEST_true(SSL_write_ex(serverssl, &c, 1, &nbytes))
2852             || !TEST_size_t_eq(1, nbytes)
2853             || !TEST_int_eq(2, new_called)
2854             || !TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &nbytes))
2855             || !TEST_int_eq(4, new_called)
2856             || !TEST_int_eq(sizeof(buf), nbytes)
2857             || !TEST_int_eq(c, buf[0])
2858             || !TEST_false(SSL_read_ex(clientssl, buf, sizeof(buf), &nbytes)))
2859         goto end;
2860
2861     SSL_shutdown(clientssl);
2862     SSL_shutdown(serverssl);
2863     testresult = 1;
2864
2865  end:
2866     BIO_free(bretry);
2867     BIO_free(tmp);
2868     SSL_free(serverssl);
2869     SSL_free(clientssl);
2870     SSL_CTX_free(sctx);
2871     SSL_CTX_free(cctx);
2872     clientssl = serverssl = NULL;
2873     sctx = cctx = NULL;
2874     return testresult;
2875 }
2876 #endif
2877
2878 #define USE_NULL            0
2879 #define USE_BIO_1           1
2880 #define USE_BIO_2           2
2881 #define USE_DEFAULT         3
2882
2883 #define CONNTYPE_CONNECTION_SUCCESS  0
2884 #define CONNTYPE_CONNECTION_FAIL     1
2885 #define CONNTYPE_NO_CONNECTION       2
2886
2887 #define TOTAL_NO_CONN_SSL_SET_BIO_TESTS         (3 * 3 * 3 * 3)
2888 #define TOTAL_CONN_SUCCESS_SSL_SET_BIO_TESTS    (2 * 2)
2889 #if !defined(OSSL_NO_USABLE_TLS1_3) && !defined(OPENSSL_NO_TLS1_2)
2890 # define TOTAL_CONN_FAIL_SSL_SET_BIO_TESTS       (2 * 2)
2891 #else
2892 # define TOTAL_CONN_FAIL_SSL_SET_BIO_TESTS       0
2893 #endif
2894
2895 #define TOTAL_SSL_SET_BIO_TESTS TOTAL_NO_CONN_SSL_SET_BIO_TESTS \
2896                                 + TOTAL_CONN_SUCCESS_SSL_SET_BIO_TESTS \
2897                                 + TOTAL_CONN_FAIL_SSL_SET_BIO_TESTS
2898
2899 static void setupbio(BIO **res, BIO *bio1, BIO *bio2, int type)
2900 {
2901     switch (type) {
2902     case USE_NULL:
2903         *res = NULL;
2904         break;
2905     case USE_BIO_1:
2906         *res = bio1;
2907         break;
2908     case USE_BIO_2:
2909         *res = bio2;
2910         break;
2911     }
2912 }
2913
2914
2915 /*
2916  * Tests calls to SSL_set_bio() under various conditions.
2917  *
2918  * For the first 3 * 3 * 3 * 3 = 81 tests we do 2 calls to SSL_set_bio() with
2919  * various combinations of valid BIOs or NULL being set for the rbio/wbio. We
2920  * then do more tests where we create a successful connection first using our
2921  * standard connection setup functions, and then call SSL_set_bio() with
2922  * various combinations of valid BIOs or NULL. We then repeat these tests
2923  * following a failed connection. In this last case we are looking to check that
2924  * SSL_set_bio() functions correctly in the case where s->bbio is not NULL.
2925  */
2926 static int test_ssl_set_bio(int idx)
2927 {
2928     SSL_CTX *sctx = NULL, *cctx = NULL;
2929     BIO *bio1 = NULL;
2930     BIO *bio2 = NULL;
2931     BIO *irbio = NULL, *iwbio = NULL, *nrbio = NULL, *nwbio = NULL;
2932     SSL *serverssl = NULL, *clientssl = NULL;
2933     int initrbio, initwbio, newrbio, newwbio, conntype;
2934     int testresult = 0;
2935
2936     if (idx < TOTAL_NO_CONN_SSL_SET_BIO_TESTS) {
2937         initrbio = idx % 3;
2938         idx /= 3;
2939         initwbio = idx % 3;
2940         idx /= 3;
2941         newrbio = idx % 3;
2942         idx /= 3;
2943         newwbio = idx % 3;
2944         conntype = CONNTYPE_NO_CONNECTION;
2945     } else {
2946         idx -= TOTAL_NO_CONN_SSL_SET_BIO_TESTS;
2947         initrbio = initwbio = USE_DEFAULT;
2948         newrbio = idx % 2;
2949         idx /= 2;
2950         newwbio = idx % 2;
2951         idx /= 2;
2952         conntype = idx % 2;
2953     }
2954
2955     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
2956                                        TLS_client_method(), TLS1_VERSION, 0,
2957                                        &sctx, &cctx, cert, privkey)))
2958         goto end;
2959
2960     if (conntype == CONNTYPE_CONNECTION_FAIL) {
2961         /*
2962          * We won't ever get here if either TLSv1.3 or TLSv1.2 is disabled
2963          * because we reduced the number of tests in the definition of
2964          * TOTAL_CONN_FAIL_SSL_SET_BIO_TESTS to avoid this scenario. By setting
2965          * mismatched protocol versions we will force a connection failure.
2966          */
2967         SSL_CTX_set_min_proto_version(sctx, TLS1_3_VERSION);
2968         SSL_CTX_set_max_proto_version(cctx, TLS1_2_VERSION);
2969     }
2970
2971     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
2972                                       NULL, NULL)))
2973         goto end;
2974
2975     if (initrbio == USE_BIO_1
2976             || initwbio == USE_BIO_1
2977             || newrbio == USE_BIO_1
2978             || newwbio == USE_BIO_1) {
2979         if (!TEST_ptr(bio1 = BIO_new(BIO_s_mem())))
2980             goto end;
2981     }
2982
2983     if (initrbio == USE_BIO_2
2984             || initwbio == USE_BIO_2
2985             || newrbio == USE_BIO_2
2986             || newwbio == USE_BIO_2) {
2987         if (!TEST_ptr(bio2 = BIO_new(BIO_s_mem())))
2988             goto end;
2989     }
2990
2991     if (initrbio != USE_DEFAULT) {
2992         setupbio(&irbio, bio1, bio2, initrbio);
2993         setupbio(&iwbio, bio1, bio2, initwbio);
2994         SSL_set_bio(clientssl, irbio, iwbio);
2995
2996         /*
2997          * We want to maintain our own refs to these BIO, so do an up ref for
2998          * each BIO that will have ownership transferred in the SSL_set_bio()
2999          * call
3000          */
3001         if (irbio != NULL)
3002             BIO_up_ref(irbio);
3003         if (iwbio != NULL && iwbio != irbio)
3004             BIO_up_ref(iwbio);
3005     }
3006
3007     if (conntype != CONNTYPE_NO_CONNECTION
3008             && !TEST_true(create_ssl_connection(serverssl, clientssl,
3009                                                 SSL_ERROR_NONE)
3010                           == (conntype == CONNTYPE_CONNECTION_SUCCESS)))
3011         goto end;
3012
3013     setupbio(&nrbio, bio1, bio2, newrbio);
3014     setupbio(&nwbio, bio1, bio2, newwbio);
3015
3016     /*
3017      * We will (maybe) transfer ownership again so do more up refs.
3018      * SSL_set_bio() has some really complicated ownership rules where BIOs have
3019      * already been set!
3020      */
3021     if (nrbio != NULL
3022             && nrbio != irbio
3023             && (nwbio != iwbio || nrbio != nwbio))
3024         BIO_up_ref(nrbio);
3025     if (nwbio != NULL
3026             && nwbio != nrbio
3027             && (nwbio != iwbio || (nwbio == iwbio && irbio == iwbio)))
3028         BIO_up_ref(nwbio);
3029
3030     SSL_set_bio(clientssl, nrbio, nwbio);
3031
3032     testresult = 1;
3033
3034  end:
3035     BIO_free(bio1);
3036     BIO_free(bio2);
3037
3038     /*
3039      * This test is checking that the ref counting for SSL_set_bio is correct.
3040      * If we get here and we did too many frees then we will fail in the above
3041      * functions.
3042      */
3043     SSL_free(serverssl);
3044     SSL_free(clientssl);
3045     SSL_CTX_free(sctx);
3046     SSL_CTX_free(cctx);
3047     return testresult;
3048 }
3049
3050 typedef enum { NO_BIO_CHANGE, CHANGE_RBIO, CHANGE_WBIO } bio_change_t;
3051
3052 static int execute_test_ssl_bio(int pop_ssl, bio_change_t change_bio)
3053 {
3054     BIO *sslbio = NULL, *membio1 = NULL, *membio2 = NULL;
3055     SSL_CTX *ctx;
3056     SSL *ssl = NULL;
3057     int testresult = 0;
3058
3059     if (!TEST_ptr(ctx = SSL_CTX_new_ex(libctx, NULL, TLS_method()))
3060             || !TEST_ptr(ssl = SSL_new(ctx))
3061             || !TEST_ptr(sslbio = BIO_new(BIO_f_ssl()))
3062             || !TEST_ptr(membio1 = BIO_new(BIO_s_mem())))
3063         goto end;
3064
3065     BIO_set_ssl(sslbio, ssl, BIO_CLOSE);
3066
3067     /*
3068      * If anything goes wrong here then we could leak memory.
3069      */
3070     BIO_push(sslbio, membio1);
3071
3072     /* Verify changing the rbio/wbio directly does not cause leaks */
3073     if (change_bio != NO_BIO_CHANGE) {
3074         if (!TEST_ptr(membio2 = BIO_new(BIO_s_mem()))) {
3075             ssl = NULL;
3076             goto end;
3077         }
3078         if (change_bio == CHANGE_RBIO)
3079             SSL_set0_rbio(ssl, membio2);
3080         else
3081             SSL_set0_wbio(ssl, membio2);
3082     }
3083     ssl = NULL;
3084
3085     if (pop_ssl)
3086         BIO_pop(sslbio);
3087     else
3088         BIO_pop(membio1);
3089
3090     testresult = 1;
3091  end:
3092     BIO_free(membio1);
3093     BIO_free(sslbio);
3094     SSL_free(ssl);
3095     SSL_CTX_free(ctx);
3096
3097     return testresult;
3098 }
3099
3100 static int test_ssl_bio_pop_next_bio(void)
3101 {
3102     return execute_test_ssl_bio(0, NO_BIO_CHANGE);
3103 }
3104
3105 static int test_ssl_bio_pop_ssl_bio(void)
3106 {
3107     return execute_test_ssl_bio(1, NO_BIO_CHANGE);
3108 }
3109
3110 static int test_ssl_bio_change_rbio(void)
3111 {
3112     return execute_test_ssl_bio(0, CHANGE_RBIO);
3113 }
3114
3115 static int test_ssl_bio_change_wbio(void)
3116 {
3117     return execute_test_ssl_bio(0, CHANGE_WBIO);
3118 }
3119
3120 #if !defined(OPENSSL_NO_TLS1_2) || defined(OSSL_NO_USABLE_TLS1_3)
3121 typedef struct {
3122     /* The list of sig algs */
3123     const int *list;
3124     /* The length of the list */
3125     size_t listlen;
3126     /* A sigalgs list in string format */
3127     const char *liststr;
3128     /* Whether setting the list should succeed */
3129     int valid;
3130     /* Whether creating a connection with the list should succeed */
3131     int connsuccess;
3132 } sigalgs_list;
3133
3134 static const int validlist1[] = {NID_sha256, EVP_PKEY_RSA};
3135 # ifndef OPENSSL_NO_EC
3136 static const int validlist2[] = {NID_sha256, EVP_PKEY_RSA, NID_sha512, EVP_PKEY_EC};
3137 static const int validlist3[] = {NID_sha512, EVP_PKEY_EC};
3138 # endif
3139 static const int invalidlist1[] = {NID_undef, EVP_PKEY_RSA};
3140 static const int invalidlist2[] = {NID_sha256, NID_undef};
3141 static const int invalidlist3[] = {NID_sha256, EVP_PKEY_RSA, NID_sha256};
3142 static const int invalidlist4[] = {NID_sha256};
3143 static const sigalgs_list testsigalgs[] = {
3144     {validlist1, OSSL_NELEM(validlist1), NULL, 1, 1},
3145 # ifndef OPENSSL_NO_EC
3146     {validlist2, OSSL_NELEM(validlist2), NULL, 1, 1},
3147     {validlist3, OSSL_NELEM(validlist3), NULL, 1, 0},
3148 # endif
3149     {NULL, 0, "RSA+SHA256", 1, 1},
3150     {NULL, 0, "RSA+SHA256:?Invalid", 1, 1},
3151 # ifndef OPENSSL_NO_EC
3152     {NULL, 0, "RSA+SHA256:ECDSA+SHA512", 1, 1},
3153     {NULL, 0, "ECDSA+SHA512", 1, 0},
3154 # endif
3155     {invalidlist1, OSSL_NELEM(invalidlist1), NULL, 0, 0},
3156     {invalidlist2, OSSL_NELEM(invalidlist2), NULL, 0, 0},
3157     {invalidlist3, OSSL_NELEM(invalidlist3), NULL, 0, 0},
3158     {invalidlist4, OSSL_NELEM(invalidlist4), NULL, 0, 0},
3159     {NULL, 0, "RSA", 0, 0},
3160     {NULL, 0, "SHA256", 0, 0},
3161     {NULL, 0, "RSA+SHA256:SHA256", 0, 0},
3162     {NULL, 0, "Invalid", 0, 0}
3163 };
3164
3165 static int test_set_sigalgs(int idx)
3166 {
3167     SSL_CTX *cctx = NULL, *sctx = NULL;
3168     SSL *clientssl = NULL, *serverssl = NULL;
3169     int testresult = 0;
3170     const sigalgs_list *curr;
3171     int testctx;
3172
3173     /* Should never happen */
3174     if (!TEST_size_t_le((size_t)idx, OSSL_NELEM(testsigalgs) * 2))
3175         return 0;
3176
3177     testctx = ((size_t)idx < OSSL_NELEM(testsigalgs));
3178     curr = testctx ? &testsigalgs[idx]
3179                    : &testsigalgs[idx - OSSL_NELEM(testsigalgs)];
3180
3181     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
3182                                        TLS_client_method(), TLS1_VERSION, 0,
3183                                        &sctx, &cctx, cert, privkey)))
3184         return 0;
3185
3186     SSL_CTX_set_max_proto_version(cctx, TLS1_2_VERSION);
3187
3188     if (testctx) {
3189         int ret;
3190
3191         if (curr->list != NULL)
3192             ret = SSL_CTX_set1_sigalgs(cctx, curr->list, curr->listlen);
3193         else
3194             ret = SSL_CTX_set1_sigalgs_list(cctx, curr->liststr);
3195
3196         if (!ret) {
3197             if (curr->valid)
3198                 TEST_info("Failure setting sigalgs in SSL_CTX (%d)\n", idx);
3199             else
3200                 testresult = 1;
3201             goto end;
3202         }
3203         if (!curr->valid) {
3204             TEST_info("Not-failed setting sigalgs in SSL_CTX (%d)\n", idx);
3205             goto end;
3206         }
3207     }
3208
3209     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
3210                                       &clientssl, NULL, NULL)))
3211         goto end;
3212
3213     if (!testctx) {
3214         int ret;
3215
3216         if (curr->list != NULL)
3217             ret = SSL_set1_sigalgs(clientssl, curr->list, curr->listlen);
3218         else
3219             ret = SSL_set1_sigalgs_list(clientssl, curr->liststr);
3220         if (!ret) {
3221             if (curr->valid)
3222                 TEST_info("Failure setting sigalgs in SSL (%d)\n", idx);
3223             else
3224                 testresult = 1;
3225             goto end;
3226         }
3227         if (!curr->valid)
3228             goto end;
3229     }
3230
3231     if (!TEST_int_eq(create_ssl_connection(serverssl, clientssl,
3232                                            SSL_ERROR_NONE),
3233                 curr->connsuccess))
3234         goto end;
3235
3236     testresult = 1;
3237
3238  end:
3239     SSL_free(serverssl);
3240     SSL_free(clientssl);
3241     SSL_CTX_free(sctx);
3242     SSL_CTX_free(cctx);
3243
3244     return testresult;
3245 }
3246 #endif
3247
3248 #ifndef OSSL_NO_USABLE_TLS1_3
3249 static int psk_client_cb_cnt = 0;
3250 static int psk_server_cb_cnt = 0;
3251
3252 static int use_session_cb(SSL *ssl, const EVP_MD *md, const unsigned char **id,
3253                           size_t *idlen, SSL_SESSION **sess)
3254 {
3255     switch (++use_session_cb_cnt) {
3256     case 1:
3257         /* The first call should always have a NULL md */
3258         if (md != NULL)
3259             return 0;
3260         break;
3261
3262     case 2:
3263         /* The second call should always have an md */
3264         if (md == NULL)
3265             return 0;
3266         break;
3267
3268     default:
3269         /* We should only be called a maximum of twice */
3270         return 0;
3271     }
3272
3273     if (clientpsk != NULL)
3274         SSL_SESSION_up_ref(clientpsk);
3275
3276     *sess = clientpsk;
3277     *id = (const unsigned char *)pskid;
3278     *idlen = strlen(pskid);
3279
3280     return 1;
3281 }
3282
3283 #ifndef OPENSSL_NO_PSK
3284 static unsigned int psk_client_cb(SSL *ssl, const char *hint, char *id,
3285                                   unsigned int max_id_len,
3286                                   unsigned char *psk,
3287                                   unsigned int max_psk_len)
3288 {
3289     unsigned int psklen = 0;
3290
3291     psk_client_cb_cnt++;
3292
3293     if (strlen(pskid) + 1 > max_id_len)
3294         return 0;
3295
3296     /* We should only ever be called a maximum of twice per connection */
3297     if (psk_client_cb_cnt > 2)
3298         return 0;
3299
3300     if (clientpsk == NULL)
3301         return 0;
3302
3303     /* We'll reuse the PSK we set up for TLSv1.3 */
3304     if (SSL_SESSION_get_master_key(clientpsk, NULL, 0) > max_psk_len)
3305         return 0;
3306     psklen = SSL_SESSION_get_master_key(clientpsk, psk, max_psk_len);
3307     strncpy(id, pskid, max_id_len);
3308
3309     return psklen;
3310 }
3311 #endif /* OPENSSL_NO_PSK */
3312
3313 static int find_session_cb(SSL *ssl, const unsigned char *identity,
3314                            size_t identity_len, SSL_SESSION **sess)
3315 {
3316     find_session_cb_cnt++;
3317
3318     /* We should only ever be called a maximum of twice per connection */
3319     if (find_session_cb_cnt > 2)
3320         return 0;
3321
3322     if (serverpsk == NULL)
3323         return 0;
3324
3325     /* Identity should match that set by the client */
3326     if (strlen(srvid) != identity_len
3327             || strncmp(srvid, (const char *)identity, identity_len) != 0) {
3328         /* No PSK found, continue but without a PSK */
3329         *sess = NULL;
3330         return 1;
3331     }
3332
3333     SSL_SESSION_up_ref(serverpsk);
3334     *sess = serverpsk;
3335
3336     return 1;
3337 }
3338
3339 #ifndef OPENSSL_NO_PSK
3340 static unsigned int psk_server_cb(SSL *ssl, const char *identity,
3341                                   unsigned char *psk, unsigned int max_psk_len)
3342 {
3343     unsigned int psklen = 0;
3344
3345     psk_server_cb_cnt++;
3346
3347     /* We should only ever be called a maximum of twice per connection */
3348     if (find_session_cb_cnt > 2)
3349         return 0;
3350
3351     if (serverpsk == NULL)
3352         return 0;
3353
3354     /* Identity should match that set by the client */
3355     if (strcmp(srvid, identity) != 0) {
3356         return 0;
3357     }
3358
3359     /* We'll reuse the PSK we set up for TLSv1.3 */
3360     if (SSL_SESSION_get_master_key(serverpsk, NULL, 0) > max_psk_len)
3361         return 0;
3362     psklen = SSL_SESSION_get_master_key(serverpsk, psk, max_psk_len);
3363
3364     return psklen;
3365 }
3366 #endif /* OPENSSL_NO_PSK */
3367
3368 #define MSG1    "Hello"
3369 #define MSG2    "World."
3370 #define MSG3    "This"
3371 #define MSG4    "is"
3372 #define MSG5    "a"
3373 #define MSG6    "test"
3374 #define MSG7    "message."
3375
3376 static int artificial_ticket_time = 0;
3377
3378 static int sub_session_time(SSL_SESSION *sess)
3379 {
3380     OSSL_TIME tick_time;
3381
3382     tick_time = ossl_time_from_time_t(SSL_SESSION_get_time_ex(sess));
3383     tick_time = ossl_time_subtract(tick_time, ossl_seconds2time(10));
3384
3385     return SSL_SESSION_set_time_ex(sess, ossl_time_to_time_t(tick_time)) != 0;
3386 }
3387
3388 static int ed_gen_cb(SSL *s, void *arg)
3389 {
3390     SSL_SESSION *sess = SSL_get0_session(s);
3391
3392     if (sess == NULL)
3393         return 0;
3394
3395     /*
3396      * Artificially give the ticket some age. Just do it for the number of
3397      * tickets we've been told to do.
3398      */
3399     if (artificial_ticket_time == 0)
3400         return 1;
3401     artificial_ticket_time--;
3402
3403     return sub_session_time(sess);
3404 }
3405
3406 /*
3407  * Helper method to setup objects for early data test. Caller frees objects on
3408  * error.
3409  */
3410 static int setupearly_data_test(SSL_CTX **cctx, SSL_CTX **sctx, SSL **clientssl,
3411                                 SSL **serverssl, SSL_SESSION **sess, int idx,
3412                                 size_t mdsize)
3413 {
3414     int artificial = (artificial_ticket_time > 0);
3415
3416     if (*sctx == NULL
3417             && !TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
3418                                               TLS_client_method(),
3419                                               TLS1_VERSION, 0,
3420                                               sctx, cctx, cert, privkey)))
3421         return 0;
3422
3423     if (artificial)
3424         SSL_CTX_set_session_ticket_cb(*sctx, ed_gen_cb, NULL, NULL);
3425
3426     if (!TEST_true(SSL_CTX_set_max_early_data(*sctx, SSL3_RT_MAX_PLAIN_LENGTH)))
3427         return 0;
3428
3429     if (idx == 1) {
3430         /* When idx == 1 we repeat the tests with read_ahead set */
3431         SSL_CTX_set_read_ahead(*cctx, 1);
3432         SSL_CTX_set_read_ahead(*sctx, 1);
3433     } else if (idx == 2) {
3434         /* When idx == 2 we are doing early_data with a PSK. Set up callbacks */
3435         SSL_CTX_set_psk_use_session_callback(*cctx, use_session_cb);
3436         SSL_CTX_set_psk_find_session_callback(*sctx, find_session_cb);
3437         use_session_cb_cnt = 0;
3438         find_session_cb_cnt = 0;
3439         srvid = pskid;
3440     }
3441
3442     if (!TEST_true(create_ssl_objects(*sctx, *cctx, serverssl, clientssl,
3443                                       NULL, NULL)))
3444         return 0;
3445
3446     /*
3447      * For one of the run throughs (doesn't matter which one), we'll try sending
3448      * some SNI data in the initial ClientHello. This will be ignored (because
3449      * there is no SNI cb set up by the server), so it should not impact
3450      * early_data.
3451      */
3452     if (idx == 1
3453             && !TEST_true(SSL_set_tlsext_host_name(*clientssl, "localhost")))
3454         return 0;
3455
3456     if (idx == 2) {
3457         clientpsk = create_a_psk(*clientssl, mdsize);
3458         if (!TEST_ptr(clientpsk)
3459                    /*
3460                     * We just choose an arbitrary value for max_early_data which
3461                     * should be big enough for testing purposes.
3462                     */
3463                 || !TEST_true(SSL_SESSION_set_max_early_data(clientpsk,
3464                                                              0x100))
3465                 || !TEST_true(SSL_SESSION_up_ref(clientpsk))) {
3466             SSL_SESSION_free(clientpsk);
3467             clientpsk = NULL;
3468             return 0;
3469         }
3470         serverpsk = clientpsk;
3471
3472         if (sess != NULL) {
3473             if (!TEST_true(SSL_SESSION_up_ref(clientpsk))) {
3474                 SSL_SESSION_free(clientpsk);
3475                 SSL_SESSION_free(serverpsk);
3476                 clientpsk = serverpsk = NULL;
3477                 return 0;
3478             }
3479             *sess = clientpsk;
3480         }
3481         return 1;
3482     }
3483
3484     if (sess == NULL)
3485         return 1;
3486
3487     if (!TEST_true(create_ssl_connection(*serverssl, *clientssl,
3488                                          SSL_ERROR_NONE)))
3489         return 0;
3490
3491     *sess = SSL_get1_session(*clientssl);
3492     SSL_shutdown(*clientssl);
3493     SSL_shutdown(*serverssl);
3494     SSL_free(*serverssl);
3495     SSL_free(*clientssl);
3496     *serverssl = *clientssl = NULL;
3497
3498     /*
3499      * Artificially give the ticket some age to match the artificial age we
3500      * gave it on the server side
3501      */
3502     if (artificial
3503             && !TEST_true(sub_session_time(*sess)))
3504         return 0;
3505
3506     if (!TEST_true(create_ssl_objects(*sctx, *cctx, serverssl,
3507                                       clientssl, NULL, NULL))
3508             || !TEST_true(SSL_set_session(*clientssl, *sess)))
3509         return 0;
3510
3511     return 1;
3512 }
3513
3514 static int check_early_data_timeout(OSSL_TIME timer)
3515 {
3516     int res = 0;
3517
3518     /*
3519      * Early data is time sensitive. We have an approx 8 second allowance
3520      * between writing the early data and reading it. If we exceed that time
3521      * then this test will fail. This can sometimes (rarely) occur in normal CI
3522      * operation. We can try and detect this and just ignore the result of this
3523      * test if it has taken too long. We assume anything over 7 seconds is too
3524      * long
3525      */
3526     timer = ossl_time_subtract(ossl_time_now(), timer);
3527     if (ossl_time_compare(timer, ossl_seconds2time(7)) >= 0)
3528         res = TEST_skip("Test took too long, ignoring result");
3529
3530     return res;
3531 }
3532
3533 static int test_early_data_read_write(int idx)
3534 {
3535     SSL_CTX *cctx = NULL, *sctx = NULL;
3536     SSL *clientssl = NULL, *serverssl = NULL;
3537     int testresult = 0;
3538     SSL_SESSION *sess = NULL;
3539     unsigned char buf[20], data[1024];
3540     size_t readbytes, written, eoedlen, rawread, rawwritten;
3541     BIO *rbio;
3542     OSSL_TIME timer;
3543
3544     /* Artificially give the next 2 tickets some age for non PSK sessions */
3545     if (idx != 2)
3546         artificial_ticket_time = 2;
3547     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
3548                                         &serverssl, &sess, idx,
3549                                         SHA384_DIGEST_LENGTH))) {
3550         artificial_ticket_time = 0;
3551         goto end;
3552     }
3553     artificial_ticket_time = 0;
3554
3555     /* Write and read some early data */
3556     timer = ossl_time_now();
3557     if (!TEST_true(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
3558                                         &written))
3559             || !TEST_size_t_eq(written, strlen(MSG1)))
3560         goto end;
3561
3562     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
3563                                          &readbytes),
3564                      SSL_READ_EARLY_DATA_SUCCESS)) {
3565         testresult = check_early_data_timeout(timer);
3566         goto end;
3567     }
3568
3569     if (!TEST_mem_eq(MSG1, readbytes, buf, strlen(MSG1))
3570             || !TEST_int_eq(SSL_get_early_data_status(serverssl),
3571                             SSL_EARLY_DATA_ACCEPTED))
3572         goto end;
3573
3574     /*
3575      * Server should be able to write data, and client should be able to
3576      * read it.
3577      */
3578     if (!TEST_true(SSL_write_early_data(serverssl, MSG2, strlen(MSG2),
3579                                         &written))
3580             || !TEST_size_t_eq(written, strlen(MSG2))
3581             || !TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
3582             || !TEST_mem_eq(buf, readbytes, MSG2, strlen(MSG2)))
3583         goto end;
3584
3585     /* Even after reading normal data, client should be able write early data */
3586     if (!TEST_true(SSL_write_early_data(clientssl, MSG3, strlen(MSG3),
3587                                         &written))
3588             || !TEST_size_t_eq(written, strlen(MSG3)))
3589         goto end;
3590
3591     /* Server should still be able read early data after writing data */
3592     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
3593                                          &readbytes),
3594                      SSL_READ_EARLY_DATA_SUCCESS)
3595             || !TEST_mem_eq(buf, readbytes, MSG3, strlen(MSG3)))
3596         goto end;
3597
3598     /* Write more data from server and read it from client */
3599     if (!TEST_true(SSL_write_early_data(serverssl, MSG4, strlen(MSG4),
3600                                         &written))
3601             || !TEST_size_t_eq(written, strlen(MSG4))
3602             || !TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
3603             || !TEST_mem_eq(buf, readbytes, MSG4, strlen(MSG4)))
3604         goto end;
3605
3606     /*
3607      * If client writes normal data it should mean writing early data is no
3608      * longer possible.
3609      */
3610     if (!TEST_true(SSL_write_ex(clientssl, MSG5, strlen(MSG5), &written))
3611             || !TEST_size_t_eq(written, strlen(MSG5))
3612             || !TEST_int_eq(SSL_get_early_data_status(clientssl),
3613                             SSL_EARLY_DATA_ACCEPTED))
3614         goto end;
3615
3616     /*
3617      * At this point the client has written EndOfEarlyData, ClientFinished and
3618      * normal (fully protected) data. We are going to cause a delay between the
3619      * arrival of EndOfEarlyData and ClientFinished. We read out all the data
3620      * in the read BIO, and then just put back the EndOfEarlyData message.
3621      */
3622     rbio = SSL_get_rbio(serverssl);
3623     if (!TEST_true(BIO_read_ex(rbio, data, sizeof(data), &rawread))
3624             || !TEST_size_t_lt(rawread, sizeof(data))
3625             || !TEST_size_t_gt(rawread, SSL3_RT_HEADER_LENGTH))
3626         goto end;
3627
3628     /* Record length is in the 4th and 5th bytes of the record header */
3629     eoedlen = SSL3_RT_HEADER_LENGTH + (data[3] << 8 | data[4]);
3630     if (!TEST_true(BIO_write_ex(rbio, data, eoedlen, &rawwritten))
3631             || !TEST_size_t_eq(rawwritten, eoedlen))
3632         goto end;
3633
3634     /* Server should be told that there is no more early data */
3635     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
3636                                          &readbytes),
3637                      SSL_READ_EARLY_DATA_FINISH)
3638             || !TEST_size_t_eq(readbytes, 0))
3639         goto end;
3640
3641     /*
3642      * Server has not finished init yet, so should still be able to write early
3643      * data.
3644      */
3645     if (!TEST_true(SSL_write_early_data(serverssl, MSG6, strlen(MSG6),
3646                                         &written))
3647             || !TEST_size_t_eq(written, strlen(MSG6)))
3648         goto end;
3649
3650     /* Push the ClientFinished and the normal data back into the server rbio */
3651     if (!TEST_true(BIO_write_ex(rbio, data + eoedlen, rawread - eoedlen,
3652                                 &rawwritten))
3653             || !TEST_size_t_eq(rawwritten, rawread - eoedlen))
3654         goto end;
3655
3656     /* Server should be able to read normal data */
3657     if (!TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
3658             || !TEST_size_t_eq(readbytes, strlen(MSG5)))
3659         goto end;
3660
3661     /* Client and server should not be able to write/read early data now */
3662     if (!TEST_false(SSL_write_early_data(clientssl, MSG6, strlen(MSG6),
3663                                          &written)))
3664         goto end;
3665     ERR_clear_error();
3666     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
3667                                          &readbytes),
3668                      SSL_READ_EARLY_DATA_ERROR))
3669         goto end;
3670     ERR_clear_error();
3671
3672     /* Client should be able to read the data sent by the server */
3673     if (!TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
3674             || !TEST_mem_eq(buf, readbytes, MSG6, strlen(MSG6)))
3675         goto end;
3676
3677     /*
3678      * Make sure we process the two NewSessionTickets. These arrive
3679      * post-handshake. We attempt reads which we do not expect to return any
3680      * data.
3681      */
3682     if (!TEST_false(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
3683             || !TEST_false(SSL_read_ex(clientssl, buf, sizeof(buf),
3684                            &readbytes)))
3685         goto end;
3686
3687     /* Server should be able to write normal data */
3688     if (!TEST_true(SSL_write_ex(serverssl, MSG7, strlen(MSG7), &written))
3689             || !TEST_size_t_eq(written, strlen(MSG7))
3690             || !TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
3691             || !TEST_mem_eq(buf, readbytes, MSG7, strlen(MSG7)))
3692         goto end;
3693
3694     SSL_SESSION_free(sess);
3695     sess = SSL_get1_session(clientssl);
3696     use_session_cb_cnt = 0;
3697     find_session_cb_cnt = 0;
3698
3699     SSL_shutdown(clientssl);
3700     SSL_shutdown(serverssl);
3701     SSL_free(serverssl);
3702     SSL_free(clientssl);
3703     serverssl = clientssl = NULL;
3704     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
3705                                       &clientssl, NULL, NULL))
3706             || !TEST_true(SSL_set_session(clientssl, sess)))
3707         goto end;
3708
3709     /* Write and read some early data */
3710     if (!TEST_true(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
3711                                         &written))
3712             || !TEST_size_t_eq(written, strlen(MSG1))
3713             || !TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
3714                                                 &readbytes),
3715                             SSL_READ_EARLY_DATA_SUCCESS)
3716             || !TEST_mem_eq(buf, readbytes, MSG1, strlen(MSG1)))
3717         goto end;
3718
3719     if (!TEST_int_gt(SSL_connect(clientssl), 0)
3720             || !TEST_int_gt(SSL_accept(serverssl), 0))
3721         goto end;
3722
3723     /* Client and server should not be able to write/read early data now */
3724     if (!TEST_false(SSL_write_early_data(clientssl, MSG6, strlen(MSG6),
3725                                          &written)))
3726         goto end;
3727     ERR_clear_error();
3728     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
3729                                          &readbytes),
3730                      SSL_READ_EARLY_DATA_ERROR))
3731         goto end;
3732     ERR_clear_error();
3733
3734     /* Client and server should be able to write/read normal data */
3735     if (!TEST_true(SSL_write_ex(clientssl, MSG5, strlen(MSG5), &written))
3736             || !TEST_size_t_eq(written, strlen(MSG5))
3737             || !TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
3738             || !TEST_size_t_eq(readbytes, strlen(MSG5)))
3739         goto end;
3740
3741     testresult = 1;
3742
3743  end:
3744     SSL_SESSION_free(sess);
3745     SSL_SESSION_free(clientpsk);
3746     SSL_SESSION_free(serverpsk);
3747     clientpsk = serverpsk = NULL;
3748     SSL_free(serverssl);
3749     SSL_free(clientssl);
3750     SSL_CTX_free(sctx);
3751     SSL_CTX_free(cctx);
3752     return testresult;
3753 }
3754
3755 static int allow_ed_cb_called = 0;
3756
3757 static int allow_early_data_cb(SSL *s, void *arg)
3758 {
3759     int *usecb = (int *)arg;
3760
3761     allow_ed_cb_called++;
3762
3763     if (*usecb == 1)
3764         return 0;
3765
3766     return 1;
3767 }
3768
3769 /*
3770  * idx == 0: Standard early_data setup
3771  * idx == 1: early_data setup using read_ahead
3772  * usecb == 0: Don't use a custom early data callback
3773  * usecb == 1: Use a custom early data callback and reject the early data
3774  * usecb == 2: Use a custom early data callback and accept the early data
3775  * confopt == 0: Configure anti-replay directly
3776  * confopt == 1: Configure anti-replay using SSL_CONF
3777  */
3778 static int test_early_data_replay_int(int idx, int usecb, int confopt)
3779 {
3780     SSL_CTX *cctx = NULL, *sctx = NULL;
3781     SSL *clientssl = NULL, *serverssl = NULL;
3782     int testresult = 0;
3783     SSL_SESSION *sess = NULL;
3784     size_t readbytes, written;
3785     unsigned char buf[20];
3786     OSSL_TIME timer;
3787
3788     allow_ed_cb_called = 0;
3789
3790     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
3791                                        TLS_client_method(), TLS1_VERSION, 0,
3792                                        &sctx, &cctx, cert, privkey)))
3793         return 0;
3794
3795     if (usecb > 0) {
3796         if (confopt == 0) {
3797             SSL_CTX_set_options(sctx, SSL_OP_NO_ANTI_REPLAY);
3798         } else {
3799             SSL_CONF_CTX *confctx = SSL_CONF_CTX_new();
3800
3801             if (!TEST_ptr(confctx))
3802                 goto end;
3803             SSL_CONF_CTX_set_flags(confctx, SSL_CONF_FLAG_FILE
3804                                             | SSL_CONF_FLAG_SERVER);
3805             SSL_CONF_CTX_set_ssl_ctx(confctx, sctx);
3806             if (!TEST_int_eq(SSL_CONF_cmd(confctx, "Options", "-AntiReplay"),
3807                              2)) {
3808                 SSL_CONF_CTX_free(confctx);
3809                 goto end;
3810             }
3811             SSL_CONF_CTX_free(confctx);
3812         }
3813         SSL_CTX_set_allow_early_data_cb(sctx, allow_early_data_cb, &usecb);
3814     }
3815
3816     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
3817                                         &serverssl, &sess, idx,
3818                                         SHA384_DIGEST_LENGTH)))
3819         goto end;
3820
3821     /*
3822      * The server is configured to accept early data. Create a connection to
3823      * "use up" the ticket
3824      */
3825     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE))
3826             || !TEST_true(SSL_session_reused(clientssl)))
3827         goto end;
3828
3829     SSL_shutdown(clientssl);
3830     SSL_shutdown(serverssl);
3831     SSL_free(serverssl);
3832     SSL_free(clientssl);
3833     serverssl = clientssl = NULL;
3834
3835     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
3836                                       &clientssl, NULL, NULL))
3837             || !TEST_true(SSL_set_session(clientssl, sess)))
3838         goto end;
3839
3840     /* Write and read some early data */
3841     timer = ossl_time_now();
3842     if (!TEST_true(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
3843                                         &written))
3844             || !TEST_size_t_eq(written, strlen(MSG1)))
3845         goto end;
3846
3847     if (usecb <= 1) {
3848         if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
3849                                              &readbytes),
3850                          SSL_READ_EARLY_DATA_FINISH)
3851                    /*
3852                     * The ticket was reused, so the we should have rejected the
3853                     * early data
3854                     */
3855                 || !TEST_int_eq(SSL_get_early_data_status(serverssl),
3856                                 SSL_EARLY_DATA_REJECTED))
3857             goto end;
3858     } else {
3859         /* In this case the callback decides to accept the early data */
3860         if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
3861                                              &readbytes),
3862                          SSL_READ_EARLY_DATA_SUCCESS)) {
3863             testresult = check_early_data_timeout(timer);
3864             goto end;
3865         }
3866         if (!TEST_mem_eq(MSG1, strlen(MSG1), buf, readbytes)
3867                    /*
3868                     * Server will have sent its flight so client can now send
3869                     * end of early data and complete its half of the handshake
3870                     */
3871                 || !TEST_int_gt(SSL_connect(clientssl), 0)
3872                 || !TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
3873                                              &readbytes),
3874                                 SSL_READ_EARLY_DATA_FINISH)
3875                 || !TEST_int_eq(SSL_get_early_data_status(serverssl),
3876                                 SSL_EARLY_DATA_ACCEPTED))
3877             goto end;
3878     }
3879
3880     /* Complete the connection */
3881     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE))
3882             || !TEST_int_eq(SSL_session_reused(clientssl), (usecb > 0) ? 1 : 0)
3883             || !TEST_int_eq(allow_ed_cb_called, usecb > 0 ? 1 : 0))
3884         goto end;
3885
3886     testresult = 1;
3887
3888  end:
3889     SSL_SESSION_free(sess);
3890     SSL_SESSION_free(clientpsk);
3891     SSL_SESSION_free(serverpsk);
3892     clientpsk = serverpsk = NULL;
3893     SSL_free(serverssl);
3894     SSL_free(clientssl);
3895     SSL_CTX_free(sctx);
3896     SSL_CTX_free(cctx);
3897     return testresult;
3898 }
3899
3900 static int test_early_data_replay(int idx)
3901 {
3902     int ret = 1, usecb, confopt;
3903
3904     for (usecb = 0; usecb < 3; usecb++) {
3905         for (confopt = 0; confopt < 2; confopt++)
3906             ret &= test_early_data_replay_int(idx, usecb, confopt);
3907     }
3908
3909     return ret;
3910 }
3911
3912 static const char *ciphersuites[] = {
3913     "TLS_AES_128_CCM_8_SHA256",
3914     "TLS_AES_128_GCM_SHA256",
3915     "TLS_AES_256_GCM_SHA384",
3916     "TLS_AES_128_CCM_SHA256",
3917 #if !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305)
3918     "TLS_CHACHA20_POLY1305_SHA256"
3919 #endif
3920 };
3921
3922 /*
3923  * Helper function to test that a server attempting to read early data can
3924  * handle a connection from a client where the early data should be skipped.
3925  * testtype: 0 == No HRR
3926  * testtype: 1 == HRR
3927  * testtype: 2 == HRR, invalid early_data sent after HRR
3928  * testtype: 3 == recv_max_early_data set to 0
3929  */
3930 static int early_data_skip_helper(int testtype, int cipher, int idx)
3931 {
3932     SSL_CTX *cctx = NULL, *sctx = NULL;
3933     SSL *clientssl = NULL, *serverssl = NULL;
3934     int testresult = 0;
3935     SSL_SESSION *sess = NULL;
3936     unsigned char buf[20];
3937     size_t readbytes, written;
3938
3939     if (is_fips && cipher == 4)
3940         return 1;
3941
3942     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
3943                                               TLS_client_method(),
3944                                               TLS1_VERSION, 0,
3945                                               &sctx, &cctx, cert, privkey)))
3946         goto end;
3947
3948     if (cipher == 0) {
3949         SSL_CTX_set_security_level(sctx, 0);
3950         SSL_CTX_set_security_level(cctx, 0);
3951     }
3952
3953     if (!TEST_true(SSL_CTX_set_ciphersuites(sctx, ciphersuites[cipher]))
3954             || !TEST_true(SSL_CTX_set_ciphersuites(cctx, ciphersuites[cipher])))
3955         goto end;
3956
3957     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
3958                                         &serverssl, &sess, idx,
3959                                         cipher == 2 ? SHA384_DIGEST_LENGTH
3960                                                     : SHA256_DIGEST_LENGTH)))
3961         goto end;
3962
3963     if (testtype == 1 || testtype == 2) {
3964         /* Force an HRR to occur */
3965 #if defined(OPENSSL_NO_EC)
3966         if (!TEST_true(SSL_set1_groups_list(serverssl, "ffdhe3072")))
3967             goto end;
3968 #else
3969         if (!TEST_true(SSL_set1_groups_list(serverssl, "P-384")))
3970             goto end;
3971 #endif
3972     } else if (idx == 2) {
3973         /*
3974          * We force early_data rejection by ensuring the PSK identity is
3975          * unrecognised
3976          */
3977         srvid = "Dummy Identity";
3978     } else {
3979         /*
3980          * Deliberately corrupt the creation time. We take 20 seconds off the
3981          * time. It could be any value as long as it is not within tolerance.
3982          * This should mean the ticket is rejected.
3983          */
3984         if (!TEST_true(SSL_SESSION_set_time(sess, (long)(time(NULL) - 20))))
3985             goto end;
3986     }
3987
3988     if (testtype == 3
3989             && !TEST_true(SSL_set_recv_max_early_data(serverssl, 0)))
3990         goto end;
3991
3992     /* Write some early data */
3993     if (!TEST_true(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
3994                                         &written))
3995             || !TEST_size_t_eq(written, strlen(MSG1)))
3996         goto end;
3997
3998     /* Server should reject the early data */
3999     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
4000                                          &readbytes),
4001                      SSL_READ_EARLY_DATA_FINISH)
4002             || !TEST_size_t_eq(readbytes, 0)
4003             || !TEST_int_eq(SSL_get_early_data_status(serverssl),
4004                             SSL_EARLY_DATA_REJECTED))
4005         goto end;
4006
4007     switch (testtype) {
4008     case 0:
4009         /* Nothing to do */
4010         break;
4011
4012     case 1:
4013         /*
4014          * Finish off the handshake. We perform the same writes and reads as
4015          * further down but we expect them to fail due to the incomplete
4016          * handshake.
4017          */
4018         if (!TEST_false(SSL_write_ex(clientssl, MSG2, strlen(MSG2), &written))
4019                 || !TEST_false(SSL_read_ex(serverssl, buf, sizeof(buf),
4020                                &readbytes)))
4021             goto end;
4022         break;
4023
4024     case 2:
4025         {
4026             BIO *wbio = SSL_get_wbio(clientssl);
4027             /* A record that will appear as bad early_data */
4028             const unsigned char bad_early_data[] = {
4029                 0x17, 0x03, 0x03, 0x00, 0x01, 0x00
4030             };
4031
4032             /*
4033              * We force the client to attempt a write. This will fail because
4034              * we're still in the handshake. It will cause the second
4035              * ClientHello to be sent.
4036              */
4037             if (!TEST_false(SSL_write_ex(clientssl, MSG2, strlen(MSG2),
4038                                          &written)))
4039                 goto end;
4040
4041             /*
4042              * Inject some early_data after the second ClientHello. This should
4043              * cause the server to fail
4044              */
4045             if (!TEST_true(BIO_write_ex(wbio, bad_early_data,
4046                                         sizeof(bad_early_data), &written)))
4047                 goto end;
4048         }
4049         /* fallthrough */
4050
4051     case 3:
4052         /*
4053          * This client has sent more early_data than we are willing to skip
4054          * (case 3) or sent invalid early_data (case 2) so the connection should
4055          * abort.
4056          */
4057         if (!TEST_false(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
4058                 || !TEST_int_eq(SSL_get_error(serverssl, 0), SSL_ERROR_SSL))
4059             goto end;
4060
4061         /* Connection has failed - nothing more to do */
4062         testresult = 1;
4063         goto end;
4064
4065     default:
4066         TEST_error("Invalid test type");
4067         goto end;
4068     }
4069
4070     ERR_clear_error();
4071     /*
4072      * Should be able to send normal data despite rejection of early data. The
4073      * early_data should be skipped.
4074      */
4075     if (!TEST_true(SSL_write_ex(clientssl, MSG2, strlen(MSG2), &written))
4076             || !TEST_size_t_eq(written, strlen(MSG2))
4077             || !TEST_int_eq(SSL_get_early_data_status(clientssl),
4078                             SSL_EARLY_DATA_REJECTED)
4079             || !TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
4080             || !TEST_mem_eq(buf, readbytes, MSG2, strlen(MSG2)))
4081         goto end;
4082
4083     /*
4084      * Failure to decrypt early data records should not leave spurious errors
4085      * on the error stack
4086      */
4087     if (!TEST_long_eq(ERR_peek_error(), 0))
4088         goto end;
4089
4090     testresult = 1;
4091
4092  end:
4093     SSL_SESSION_free(clientpsk);
4094     SSL_SESSION_free(serverpsk);
4095     clientpsk = serverpsk = NULL;
4096     SSL_SESSION_free(sess);
4097     SSL_free(serverssl);
4098     SSL_free(clientssl);
4099     SSL_CTX_free(sctx);
4100     SSL_CTX_free(cctx);
4101     return testresult;
4102 }
4103
4104 /*
4105  * Test that a server attempting to read early data can handle a connection
4106  * from a client where the early data is not acceptable.
4107  */
4108 static int test_early_data_skip(int idx)
4109 {
4110     return early_data_skip_helper(0,
4111                                   idx % OSSL_NELEM(ciphersuites),
4112                                   idx / OSSL_NELEM(ciphersuites));
4113 }
4114
4115 /*
4116  * Test that a server attempting to read early data can handle a connection
4117  * from a client where an HRR occurs.
4118  */
4119 static int test_early_data_skip_hrr(int idx)
4120 {
4121     return early_data_skip_helper(1,
4122                                   idx % OSSL_NELEM(ciphersuites),
4123                                   idx / OSSL_NELEM(ciphersuites));
4124 }
4125
4126 /*
4127  * Test that a server attempting to read early data can handle a connection
4128  * from a client where an HRR occurs and correctly fails if early_data is sent
4129  * after the HRR
4130  */
4131 static int test_early_data_skip_hrr_fail(int idx)
4132 {
4133     return early_data_skip_helper(2,
4134                                   idx % OSSL_NELEM(ciphersuites),
4135                                   idx / OSSL_NELEM(ciphersuites));
4136 }
4137
4138 /*
4139  * Test that a server attempting to read early data will abort if it tries to
4140  * skip over too much.
4141  */
4142 static int test_early_data_skip_abort(int idx)
4143 {
4144     return early_data_skip_helper(3,
4145                                   idx % OSSL_NELEM(ciphersuites),
4146                                   idx / OSSL_NELEM(ciphersuites));
4147 }
4148
4149 /*
4150  * Test that a server attempting to read early data can handle a connection
4151  * from a client that doesn't send any.
4152  */
4153 static int test_early_data_not_sent(int idx)
4154 {
4155     SSL_CTX *cctx = NULL, *sctx = NULL;
4156     SSL *clientssl = NULL, *serverssl = NULL;
4157     int testresult = 0;
4158     SSL_SESSION *sess = NULL;
4159     unsigned char buf[20];
4160     size_t readbytes, written;
4161
4162     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
4163                                         &serverssl, &sess, idx,
4164                                         SHA384_DIGEST_LENGTH)))
4165         goto end;
4166
4167     /* Write some data - should block due to handshake with server */
4168     SSL_set_connect_state(clientssl);
4169     if (!TEST_false(SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written)))
4170         goto end;
4171
4172     /* Server should detect that early data has not been sent */
4173     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
4174                                          &readbytes),
4175                      SSL_READ_EARLY_DATA_FINISH)
4176             || !TEST_size_t_eq(readbytes, 0)
4177             || !TEST_int_eq(SSL_get_early_data_status(serverssl),
4178                             SSL_EARLY_DATA_NOT_SENT)
4179             || !TEST_int_eq(SSL_get_early_data_status(clientssl),
4180                             SSL_EARLY_DATA_NOT_SENT))
4181         goto end;
4182
4183     /* Continue writing the message we started earlier */
4184     if (!TEST_true(SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written))
4185             || !TEST_size_t_eq(written, strlen(MSG1))
4186             || !TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
4187             || !TEST_mem_eq(buf, readbytes, MSG1, strlen(MSG1))
4188             || !SSL_write_ex(serverssl, MSG2, strlen(MSG2), &written)
4189             || !TEST_size_t_eq(written, strlen(MSG2)))
4190         goto end;
4191
4192     if (!TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
4193             || !TEST_mem_eq(buf, readbytes, MSG2, strlen(MSG2)))
4194         goto end;
4195
4196     testresult = 1;
4197
4198  end:
4199     SSL_SESSION_free(sess);
4200     SSL_SESSION_free(clientpsk);
4201     SSL_SESSION_free(serverpsk);
4202     clientpsk = serverpsk = NULL;
4203     SSL_free(serverssl);
4204     SSL_free(clientssl);
4205     SSL_CTX_free(sctx);
4206     SSL_CTX_free(cctx);
4207     return testresult;
4208 }
4209
4210 static const char *servalpn;
4211
4212 static int alpn_select_cb(SSL *ssl, const unsigned char **out,
4213                           unsigned char *outlen, const unsigned char *in,
4214                           unsigned int inlen, void *arg)
4215 {
4216     unsigned int protlen = 0;
4217     const unsigned char *prot;
4218
4219     for (prot = in; prot < in + inlen; prot += protlen) {
4220         protlen = *prot++;
4221         if (in + inlen < prot + protlen)
4222             return SSL_TLSEXT_ERR_NOACK;
4223
4224         if (protlen == strlen(servalpn)
4225                 && memcmp(prot, servalpn, protlen) == 0) {
4226             *out = prot;
4227             *outlen = protlen;
4228             return SSL_TLSEXT_ERR_OK;
4229         }
4230     }
4231
4232     return SSL_TLSEXT_ERR_NOACK;
4233 }
4234
4235 /* Test that a PSK can be used to send early_data */
4236 static int test_early_data_psk(int idx)
4237 {
4238     SSL_CTX *cctx = NULL, *sctx = NULL;
4239     SSL *clientssl = NULL, *serverssl = NULL;
4240     int testresult = 0;
4241     SSL_SESSION *sess = NULL;
4242     unsigned char alpnlist[] = {
4243         0x08, 'g', 'o', 'o', 'd', 'a', 'l', 'p', 'n', 0x07, 'b', 'a', 'd', 'a',
4244         'l', 'p', 'n'
4245     };
4246 #define GOODALPNLEN     9
4247 #define BADALPNLEN      8
4248 #define GOODALPN        (alpnlist)
4249 #define BADALPN         (alpnlist + GOODALPNLEN)
4250     int err = 0;
4251     unsigned char buf[20];
4252     size_t readbytes, written;
4253     int readearlyres = SSL_READ_EARLY_DATA_SUCCESS, connectres = 1;
4254     int edstatus = SSL_EARLY_DATA_ACCEPTED;
4255
4256     /* We always set this up with a final parameter of "2" for PSK */
4257     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
4258                                         &serverssl, &sess, 2,
4259                                         SHA384_DIGEST_LENGTH)))
4260         goto end;
4261
4262     servalpn = "goodalpn";
4263
4264     /*
4265      * Note: There is no test for inconsistent SNI with late client detection.
4266      * This is because servers do not acknowledge SNI even if they are using
4267      * it in a resumption handshake - so it is not actually possible for a
4268      * client to detect a problem.
4269      */
4270     switch (idx) {
4271     case 0:
4272         /* Set inconsistent SNI (early client detection) */
4273         err = SSL_R_INCONSISTENT_EARLY_DATA_SNI;
4274         if (!TEST_true(SSL_SESSION_set1_hostname(sess, "goodhost"))
4275                 || !TEST_true(SSL_set_tlsext_host_name(clientssl, "badhost")))
4276             goto end;
4277         break;
4278
4279     case 1:
4280         /* Set inconsistent ALPN (early client detection) */
4281         err = SSL_R_INCONSISTENT_EARLY_DATA_ALPN;
4282         /* SSL_set_alpn_protos returns 0 for success and 1 for failure */
4283         if (!TEST_true(SSL_SESSION_set1_alpn_selected(sess, GOODALPN,
4284                                                       GOODALPNLEN))
4285                 || !TEST_false(SSL_set_alpn_protos(clientssl, BADALPN,
4286                                                    BADALPNLEN)))
4287             goto end;
4288         break;
4289
4290     case 2:
4291         /*
4292          * Set invalid protocol version. Technically this affects PSKs without
4293          * early_data too, but we test it here because it is similar to the
4294          * SNI/ALPN consistency tests.
4295          */
4296         err = SSL_R_BAD_PSK;
4297         if (!TEST_true(SSL_SESSION_set_protocol_version(sess, TLS1_2_VERSION)))
4298             goto end;
4299         break;
4300
4301     case 3:
4302         /*
4303          * Set inconsistent SNI (server side). In this case the connection
4304          * will succeed and accept early_data. In TLSv1.3 on the server side SNI
4305          * is associated with each handshake - not the session. Therefore it
4306          * should not matter that we used a different server name last time.
4307          */
4308         SSL_SESSION_free(serverpsk);
4309         serverpsk = SSL_SESSION_dup(clientpsk);
4310         if (!TEST_ptr(serverpsk)
4311                 || !TEST_true(SSL_SESSION_set1_hostname(serverpsk, "badhost")))
4312             goto end;
4313         /* Fall through */
4314     case 4:
4315         /* Set consistent SNI */
4316         if (!TEST_true(SSL_SESSION_set1_hostname(sess, "goodhost"))
4317                 || !TEST_true(SSL_set_tlsext_host_name(clientssl, "goodhost"))
4318                 || !TEST_true(SSL_CTX_set_tlsext_servername_callback(sctx,
4319                                 hostname_cb)))
4320             goto end;
4321         break;
4322
4323     case 5:
4324         /*
4325          * Set inconsistent ALPN (server detected). In this case the connection
4326          * will succeed but reject early_data.
4327          */
4328         servalpn = "badalpn";
4329         edstatus = SSL_EARLY_DATA_REJECTED;
4330         readearlyres = SSL_READ_EARLY_DATA_FINISH;
4331         /* Fall through */
4332     case 6:
4333         /*
4334          * Set consistent ALPN.
4335          * SSL_set_alpn_protos returns 0 for success and 1 for failure. It
4336          * accepts a list of protos (each one length prefixed).
4337          * SSL_set1_alpn_selected accepts a single protocol (not length
4338          * prefixed)
4339          */
4340         if (!TEST_true(SSL_SESSION_set1_alpn_selected(sess, GOODALPN + 1,
4341                                                       GOODALPNLEN - 1))
4342                 || !TEST_false(SSL_set_alpn_protos(clientssl, GOODALPN,
4343                                                    GOODALPNLEN)))
4344             goto end;
4345
4346         SSL_CTX_set_alpn_select_cb(sctx, alpn_select_cb, NULL);
4347         break;
4348
4349     case 7:
4350         /* Set inconsistent ALPN (late client detection) */
4351         SSL_SESSION_free(serverpsk);
4352         serverpsk = SSL_SESSION_dup(clientpsk);
4353         if (!TEST_ptr(serverpsk)
4354                 || !TEST_true(SSL_SESSION_set1_alpn_selected(clientpsk,
4355                                                              BADALPN + 1,
4356                                                              BADALPNLEN - 1))
4357                 || !TEST_true(SSL_SESSION_set1_alpn_selected(serverpsk,
4358                                                              GOODALPN + 1,
4359                                                              GOODALPNLEN - 1))
4360                 || !TEST_false(SSL_set_alpn_protos(clientssl, alpnlist,
4361                                                    sizeof(alpnlist))))
4362             goto end;
4363         SSL_CTX_set_alpn_select_cb(sctx, alpn_select_cb, NULL);
4364         edstatus = SSL_EARLY_DATA_ACCEPTED;
4365         readearlyres = SSL_READ_EARLY_DATA_SUCCESS;
4366         /* SSL_connect() call should fail */
4367         connectres = -1;
4368         break;
4369
4370     default:
4371         TEST_error("Bad test index");
4372         goto end;
4373     }
4374
4375     SSL_set_connect_state(clientssl);
4376     if (err != 0) {
4377         if (!TEST_false(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
4378                                             &written))
4379                 || !TEST_int_eq(SSL_get_error(clientssl, 0), SSL_ERROR_SSL)
4380                 || !TEST_int_eq(ERR_GET_REASON(ERR_get_error()), err))
4381             goto end;
4382     } else {
4383         OSSL_TIME timer = ossl_time_now();
4384
4385         if (!TEST_true(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
4386                                             &written)))
4387             goto end;
4388
4389         if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
4390                                              &readbytes), readearlyres)) {
4391             testresult = check_early_data_timeout(timer);
4392             goto end;
4393         }
4394
4395         if ((readearlyres == SSL_READ_EARLY_DATA_SUCCESS
4396                     && !TEST_mem_eq(buf, readbytes, MSG1, strlen(MSG1)))
4397                 || !TEST_int_eq(SSL_get_early_data_status(serverssl), edstatus)
4398                 || !TEST_int_eq(SSL_connect(clientssl), connectres))
4399             goto end;
4400     }
4401
4402     testresult = 1;
4403
4404  end:
4405     SSL_SESSION_free(sess);
4406     SSL_SESSION_free(clientpsk);
4407     SSL_SESSION_free(serverpsk);
4408     clientpsk = serverpsk = NULL;
4409     SSL_free(serverssl);
4410     SSL_free(clientssl);
4411     SSL_CTX_free(sctx);
4412     SSL_CTX_free(cctx);
4413     return testresult;
4414 }
4415
4416 /*
4417  * Test TLSv1.3 PSK can be used to send early_data with all 5 ciphersuites
4418  * idx == 0: Test with TLS1_3_RFC_AES_128_GCM_SHA256
4419  * idx == 1: Test with TLS1_3_RFC_AES_256_GCM_SHA384
4420  * idx == 2: Test with TLS1_3_RFC_CHACHA20_POLY1305_SHA256,
4421  * idx == 3: Test with TLS1_3_RFC_AES_128_CCM_SHA256
4422  * idx == 4: Test with TLS1_3_RFC_AES_128_CCM_8_SHA256
4423  */
4424 static int test_early_data_psk_with_all_ciphers(int idx)
4425 {
4426     SSL_CTX *cctx = NULL, *sctx = NULL;
4427     SSL *clientssl = NULL, *serverssl = NULL;
4428     int testresult = 0;
4429     SSL_SESSION *sess = NULL;
4430     unsigned char buf[20];
4431     size_t readbytes, written;
4432     const SSL_CIPHER *cipher;
4433     OSSL_TIME timer;
4434     const char *cipher_str[] = {
4435         TLS1_3_RFC_AES_128_GCM_SHA256,
4436         TLS1_3_RFC_AES_256_GCM_SHA384,
4437 # if !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305)
4438         TLS1_3_RFC_CHACHA20_POLY1305_SHA256,
4439 # else
4440         NULL,
4441 # endif
4442         TLS1_3_RFC_AES_128_CCM_SHA256,
4443         TLS1_3_RFC_AES_128_CCM_8_SHA256
4444     };
4445     const unsigned char *cipher_bytes[] = {
4446         TLS13_AES_128_GCM_SHA256_BYTES,
4447         TLS13_AES_256_GCM_SHA384_BYTES,
4448 # if !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305)
4449         TLS13_CHACHA20_POLY1305_SHA256_BYTES,
4450 # else
4451         NULL,
4452 # endif
4453         TLS13_AES_128_CCM_SHA256_BYTES,
4454         TLS13_AES_128_CCM_8_SHA256_BYTES
4455     };
4456
4457     if (cipher_str[idx] == NULL)
4458         return 1;
4459     /* Skip ChaCha20Poly1305 as currently FIPS module does not support it */
4460     if (idx == 2 && is_fips == 1)
4461         return 1;
4462
4463     /* We always set this up with a final parameter of "2" for PSK */
4464     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
4465                                         &serverssl, &sess, 2,
4466                                         SHA384_DIGEST_LENGTH)))
4467         goto end;
4468
4469     if (idx == 4) {
4470         /* CCM8 ciphers are considered low security due to their short tag */
4471         SSL_set_security_level(clientssl, 0);
4472         SSL_set_security_level(serverssl, 0);
4473     }
4474
4475     if (!TEST_true(SSL_set_ciphersuites(clientssl, cipher_str[idx]))
4476             || !TEST_true(SSL_set_ciphersuites(serverssl, cipher_str[idx])))
4477         goto end;
4478
4479     /*
4480      * 'setupearly_data_test' creates only one instance of SSL_SESSION
4481      * and assigns to both client and server with incremented reference
4482      * and the same instance is updated in 'sess'.
4483      * So updating ciphersuite in 'sess' which will get reflected in
4484      * PSK handshake using psk use sess and find sess cb.
4485      */
4486     cipher = SSL_CIPHER_find(clientssl, cipher_bytes[idx]);
4487     if (!TEST_ptr(cipher) || !TEST_true(SSL_SESSION_set_cipher(sess, cipher)))
4488         goto end;
4489
4490     SSL_set_connect_state(clientssl);
4491     timer = ossl_time_now();
4492     if (!TEST_true(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
4493                                         &written)))
4494         goto end;
4495
4496     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
4497                                          &readbytes),
4498                                          SSL_READ_EARLY_DATA_SUCCESS)) {
4499         testresult = check_early_data_timeout(timer);
4500         goto end;
4501     }
4502
4503     if (!TEST_mem_eq(buf, readbytes, MSG1, strlen(MSG1))
4504             || !TEST_int_eq(SSL_get_early_data_status(serverssl),
4505                                                       SSL_EARLY_DATA_ACCEPTED)
4506             || !TEST_int_eq(SSL_connect(clientssl), 1)
4507             || !TEST_int_eq(SSL_accept(serverssl), 1))
4508         goto end;
4509
4510     /* Send some normal data from client to server */
4511     if (!TEST_true(SSL_write_ex(clientssl, MSG2, strlen(MSG2), &written))
4512             || !TEST_size_t_eq(written, strlen(MSG2)))
4513         goto end;
4514
4515     if (!TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
4516             || !TEST_mem_eq(buf, readbytes, MSG2, strlen(MSG2)))
4517         goto end;
4518
4519     testresult = 1;
4520  end:
4521     SSL_SESSION_free(sess);
4522     SSL_SESSION_free(clientpsk);
4523     SSL_SESSION_free(serverpsk);
4524     clientpsk = serverpsk = NULL;
4525     if (clientssl != NULL)
4526         SSL_shutdown(clientssl);
4527     if (serverssl != NULL)
4528         SSL_shutdown(serverssl);
4529     SSL_free(serverssl);
4530     SSL_free(clientssl);
4531     SSL_CTX_free(sctx);
4532     SSL_CTX_free(cctx);
4533     return testresult;
4534 }
4535
4536 /*
4537  * Test that a server that doesn't try to read early data can handle a
4538  * client sending some.
4539  */
4540 static int test_early_data_not_expected(int idx)
4541 {
4542     SSL_CTX *cctx = NULL, *sctx = NULL;
4543     SSL *clientssl = NULL, *serverssl = NULL;
4544     int testresult = 0;
4545     SSL_SESSION *sess = NULL;
4546     unsigned char buf[20];
4547     size_t readbytes, written;
4548
4549     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
4550                                         &serverssl, &sess, idx,
4551                                         SHA384_DIGEST_LENGTH)))
4552         goto end;
4553
4554     /* Write some early data */
4555     if (!TEST_true(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
4556                                         &written)))
4557         goto end;
4558
4559     /*
4560      * Server should skip over early data and then block waiting for client to
4561      * continue handshake
4562      */
4563     if (!TEST_int_le(SSL_accept(serverssl), 0)
4564      || !TEST_int_gt(SSL_connect(clientssl), 0)
4565      || !TEST_int_eq(SSL_get_early_data_status(serverssl),
4566                      SSL_EARLY_DATA_REJECTED)
4567      || !TEST_int_gt(SSL_accept(serverssl), 0)
4568      || !TEST_int_eq(SSL_get_early_data_status(clientssl),
4569                      SSL_EARLY_DATA_REJECTED))
4570         goto end;
4571
4572     /* Send some normal data from client to server */
4573     if (!TEST_true(SSL_write_ex(clientssl, MSG2, strlen(MSG2), &written))
4574             || !TEST_size_t_eq(written, strlen(MSG2)))
4575         goto end;
4576
4577     if (!TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
4578             || !TEST_mem_eq(buf, readbytes, MSG2, strlen(MSG2)))
4579         goto end;
4580
4581     testresult = 1;
4582
4583  end:
4584     SSL_SESSION_free(sess);
4585     SSL_SESSION_free(clientpsk);
4586     SSL_SESSION_free(serverpsk);
4587     clientpsk = serverpsk = NULL;
4588     SSL_free(serverssl);
4589     SSL_free(clientssl);
4590     SSL_CTX_free(sctx);
4591     SSL_CTX_free(cctx);
4592     return testresult;
4593 }
4594
4595
4596 # ifndef OPENSSL_NO_TLS1_2
4597 /*
4598  * Test that a server attempting to read early data can handle a connection
4599  * from a TLSv1.2 client.
4600  */
4601 static int test_early_data_tls1_2(int idx)
4602 {
4603     SSL_CTX *cctx = NULL, *sctx = NULL;
4604     SSL *clientssl = NULL, *serverssl = NULL;
4605     int testresult = 0;
4606     unsigned char buf[20];
4607     size_t readbytes, written;
4608
4609     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
4610                                         &serverssl, NULL, idx,
4611                                         SHA384_DIGEST_LENGTH)))
4612         goto end;
4613
4614     /* Write some data - should block due to handshake with server */
4615     SSL_set_max_proto_version(clientssl, TLS1_2_VERSION);
4616     SSL_set_connect_state(clientssl);
4617     if (!TEST_false(SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written)))
4618         goto end;
4619
4620     /*
4621      * Server should do TLSv1.2 handshake. First it will block waiting for more
4622      * messages from client after ServerDone. Then SSL_read_early_data should
4623      * finish and detect that early data has not been sent
4624      */
4625     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
4626                                          &readbytes),
4627                      SSL_READ_EARLY_DATA_ERROR))
4628         goto end;
4629
4630     /*
4631      * Continue writing the message we started earlier. Will still block waiting
4632      * for the CCS/Finished from server
4633      */
4634     if (!TEST_false(SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written))
4635             || !TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
4636                                                 &readbytes),
4637                             SSL_READ_EARLY_DATA_FINISH)
4638             || !TEST_size_t_eq(readbytes, 0)
4639             || !TEST_int_eq(SSL_get_early_data_status(serverssl),
4640                             SSL_EARLY_DATA_NOT_SENT))
4641         goto end;
4642
4643     /* Continue writing the message we started earlier */
4644     if (!TEST_true(SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written))
4645             || !TEST_size_t_eq(written, strlen(MSG1))
4646             || !TEST_int_eq(SSL_get_early_data_status(clientssl),
4647                             SSL_EARLY_DATA_NOT_SENT)
4648             || !TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
4649             || !TEST_mem_eq(buf, readbytes, MSG1, strlen(MSG1))
4650             || !TEST_true(SSL_write_ex(serverssl, MSG2, strlen(MSG2), &written))
4651             || !TEST_size_t_eq(written, strlen(MSG2))
4652             || !SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes)
4653             || !TEST_mem_eq(buf, readbytes, MSG2, strlen(MSG2)))
4654         goto end;
4655
4656     testresult = 1;
4657
4658  end:
4659     SSL_SESSION_free(clientpsk);
4660     SSL_SESSION_free(serverpsk);
4661     clientpsk = serverpsk = NULL;
4662     SSL_free(serverssl);
4663     SSL_free(clientssl);
4664     SSL_CTX_free(sctx);
4665     SSL_CTX_free(cctx);
4666
4667     return testresult;
4668 }
4669 # endif /* OPENSSL_NO_TLS1_2 */
4670
4671 /*
4672  * Test configuring the TLSv1.3 ciphersuites
4673  *
4674  * Test 0: Set a default ciphersuite in the SSL_CTX (no explicit cipher_list)
4675  * Test 1: Set a non-default ciphersuite in the SSL_CTX (no explicit cipher_list)
4676  * Test 2: Set a default ciphersuite in the SSL (no explicit cipher_list)
4677  * Test 3: Set a non-default ciphersuite in the SSL (no explicit cipher_list)
4678  * Test 4: Set a default ciphersuite in the SSL_CTX (SSL_CTX cipher_list)
4679  * Test 5: Set a non-default ciphersuite in the SSL_CTX (SSL_CTX cipher_list)
4680  * Test 6: Set a default ciphersuite in the SSL (SSL_CTX cipher_list)
4681  * Test 7: Set a non-default ciphersuite in the SSL (SSL_CTX cipher_list)
4682  * Test 8: Set a default ciphersuite in the SSL (SSL cipher_list)
4683  * Test 9: Set a non-default ciphersuite in the SSL (SSL cipher_list)
4684  */
4685 static int test_set_ciphersuite(int idx)
4686 {
4687     SSL_CTX *cctx = NULL, *sctx = NULL;
4688     SSL *clientssl = NULL, *serverssl = NULL;
4689     int testresult = 0;
4690
4691     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
4692                                        TLS_client_method(), TLS1_VERSION, 0,
4693                                        &sctx, &cctx, cert, privkey))
4694             || !TEST_true(SSL_CTX_set_ciphersuites(sctx,
4695                            "TLS_AES_128_GCM_SHA256:TLS_AES_128_CCM_SHA256")))
4696         goto end;
4697
4698     if (idx >=4 && idx <= 7) {
4699         /* SSL_CTX explicit cipher list */
4700         if (!TEST_true(SSL_CTX_set_cipher_list(cctx, "AES256-GCM-SHA384")))
4701             goto end;
4702     }
4703
4704     if (idx == 0 || idx == 4) {
4705         /* Default ciphersuite */
4706         if (!TEST_true(SSL_CTX_set_ciphersuites(cctx,
4707                                                 "TLS_AES_128_GCM_SHA256")))
4708             goto end;
4709     } else if (idx == 1 || idx == 5) {
4710         /* Non default ciphersuite */
4711         if (!TEST_true(SSL_CTX_set_ciphersuites(cctx,
4712                                                 "TLS_AES_128_CCM_SHA256")))
4713             goto end;
4714     }
4715
4716     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
4717                                           &clientssl, NULL, NULL)))
4718         goto end;
4719
4720     if (idx == 8 || idx == 9) {
4721         /* SSL explicit cipher list */
4722         if (!TEST_true(SSL_set_cipher_list(clientssl, "AES256-GCM-SHA384")))
4723             goto end;
4724     }
4725
4726     if (idx == 2 || idx == 6 || idx == 8) {
4727         /* Default ciphersuite */
4728         if (!TEST_true(SSL_set_ciphersuites(clientssl,
4729                                             "TLS_AES_128_GCM_SHA256")))
4730             goto end;
4731     } else if (idx == 3 || idx == 7 || idx == 9) {
4732         /* Non default ciphersuite */
4733         if (!TEST_true(SSL_set_ciphersuites(clientssl,
4734                                             "TLS_AES_128_CCM_SHA256")))
4735             goto end;
4736     }
4737
4738     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
4739         goto end;
4740
4741     testresult = 1;
4742
4743  end:
4744     SSL_free(serverssl);
4745     SSL_free(clientssl);
4746     SSL_CTX_free(sctx);
4747     SSL_CTX_free(cctx);
4748
4749     return testresult;
4750 }
4751
4752 static int test_ciphersuite_change(void)
4753 {
4754     SSL_CTX *cctx = NULL, *sctx = NULL;
4755     SSL *clientssl = NULL, *serverssl = NULL;
4756     SSL_SESSION *clntsess = NULL;
4757     int testresult = 0;
4758     const SSL_CIPHER *aes_128_gcm_sha256 = NULL;
4759
4760     /* Create a session based on SHA-256 */
4761     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
4762                                        TLS_client_method(), TLS1_VERSION, 0,
4763                                        &sctx, &cctx, cert, privkey))
4764             || !TEST_true(SSL_CTX_set_ciphersuites(sctx,
4765                                                    "TLS_AES_128_GCM_SHA256:"
4766                                                    "TLS_AES_256_GCM_SHA384:"
4767                                                    "TLS_AES_128_CCM_SHA256"))
4768             || !TEST_true(SSL_CTX_set_ciphersuites(cctx,
4769                                                    "TLS_AES_128_GCM_SHA256")))
4770         goto end;
4771
4772     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
4773                                       NULL, NULL))
4774             || !TEST_true(create_ssl_connection(serverssl, clientssl,
4775                                                 SSL_ERROR_NONE)))
4776         goto end;
4777
4778     clntsess = SSL_get1_session(clientssl);
4779     /* Save for later */
4780     aes_128_gcm_sha256 = SSL_SESSION_get0_cipher(clntsess);
4781     SSL_shutdown(clientssl);
4782     SSL_shutdown(serverssl);
4783     SSL_free(serverssl);
4784     SSL_free(clientssl);
4785     serverssl = clientssl = NULL;
4786
4787     /* Check we can resume a session with a different SHA-256 ciphersuite */
4788     if (!TEST_true(SSL_CTX_set_ciphersuites(cctx,
4789                                             "TLS_AES_128_CCM_SHA256"))
4790             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
4791                                              &clientssl, NULL, NULL))
4792             || !TEST_true(SSL_set_session(clientssl, clntsess))
4793             || !TEST_true(create_ssl_connection(serverssl, clientssl,
4794                                                 SSL_ERROR_NONE))
4795             || !TEST_true(SSL_session_reused(clientssl)))
4796         goto end;
4797
4798     SSL_SESSION_free(clntsess);
4799     clntsess = SSL_get1_session(clientssl);
4800     SSL_shutdown(clientssl);
4801     SSL_shutdown(serverssl);
4802     SSL_free(serverssl);
4803     SSL_free(clientssl);
4804     serverssl = clientssl = NULL;
4805
4806     /*
4807      * Check attempting to resume a SHA-256 session with no SHA-256 ciphersuites
4808      * succeeds but does not resume.
4809      */
4810     if (!TEST_true(SSL_CTX_set_ciphersuites(cctx, "TLS_AES_256_GCM_SHA384"))
4811             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
4812                                              NULL, NULL))
4813             || !TEST_true(SSL_set_session(clientssl, clntsess))
4814             || !TEST_true(create_ssl_connection(serverssl, clientssl,
4815                                                 SSL_ERROR_SSL))
4816             || !TEST_false(SSL_session_reused(clientssl)))
4817         goto end;
4818
4819     SSL_SESSION_free(clntsess);
4820     clntsess = NULL;
4821     SSL_shutdown(clientssl);
4822     SSL_shutdown(serverssl);
4823     SSL_free(serverssl);
4824     SSL_free(clientssl);
4825     serverssl = clientssl = NULL;
4826
4827     /* Create a session based on SHA384 */
4828     if (!TEST_true(SSL_CTX_set_ciphersuites(cctx, "TLS_AES_256_GCM_SHA384"))
4829             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
4830                                           &clientssl, NULL, NULL))
4831             || !TEST_true(create_ssl_connection(serverssl, clientssl,
4832                                                 SSL_ERROR_NONE)))
4833         goto end;
4834
4835     clntsess = SSL_get1_session(clientssl);
4836     SSL_shutdown(clientssl);
4837     SSL_shutdown(serverssl);
4838     SSL_free(serverssl);
4839     SSL_free(clientssl);
4840     serverssl = clientssl = NULL;
4841
4842     if (!TEST_true(SSL_CTX_set_ciphersuites(cctx,
4843                    "TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384"))
4844             || !TEST_true(SSL_CTX_set_ciphersuites(sctx,
4845                                                    "TLS_AES_256_GCM_SHA384"))
4846             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
4847                                              NULL, NULL))
4848             || !TEST_true(SSL_set_session(clientssl, clntsess))
4849                /*
4850                 * We use SSL_ERROR_WANT_READ below so that we can pause the
4851                 * connection after the initial ClientHello has been sent to
4852                 * enable us to make some session changes.
4853                 */
4854             || !TEST_false(create_ssl_connection(serverssl, clientssl,
4855                                                 SSL_ERROR_WANT_READ)))
4856         goto end;
4857
4858     /* Trick the client into thinking this session is for a different digest */
4859     clntsess->cipher = aes_128_gcm_sha256;
4860     clntsess->cipher_id = clntsess->cipher->id;
4861
4862     /*
4863      * Continue the previously started connection. Server has selected a SHA-384
4864      * ciphersuite, but client thinks the session is for SHA-256, so it should
4865      * bail out.
4866      */
4867     if (!TEST_false(create_ssl_connection(serverssl, clientssl,
4868                                                 SSL_ERROR_SSL))
4869             || !TEST_int_eq(ERR_GET_REASON(ERR_get_error()),
4870                             SSL_R_CIPHERSUITE_DIGEST_HAS_CHANGED))
4871         goto end;
4872
4873     testresult = 1;
4874
4875  end:
4876     SSL_SESSION_free(clntsess);
4877     SSL_free(serverssl);
4878     SSL_free(clientssl);
4879     SSL_CTX_free(sctx);
4880     SSL_CTX_free(cctx);
4881
4882     return testresult;
4883 }
4884
4885 /*
4886  * Test TLSv1.3 Key exchange
4887  * Test 0 = Test all ECDHE Key exchange with TLSv1.3 client and server
4888  * Test 1 = Test NID_X9_62_prime256v1 with TLSv1.3 client and server
4889  * Test 2 = Test NID_secp384r1 with TLSv1.3 client and server
4890  * Test 3 = Test NID_secp521r1 with TLSv1.3 client and server
4891  * Test 4 = Test NID_X25519 with TLSv1.3 client and server
4892  * Test 5 = Test NID_X448 with TLSv1.3 client and server
4893  * Test 6 = Test all FFDHE Key exchange with TLSv1.3 client and server
4894  * Test 7 = Test NID_ffdhe2048 with TLSv1.3 client and server
4895  * Test 8 = Test NID_ffdhe3072 with TLSv1.3 client and server
4896  * Test 9 = Test NID_ffdhe4096 with TLSv1.3 client and server
4897  * Test 10 = Test NID_ffdhe6144 with TLSv1.3 client and server
4898  * Test 11 = Test NID_ffdhe8192 with TLSv1.3 client and server
4899  * Test 12 = Test all ECDHE with TLSv1.2 client and server
4900  * Test 13 = Test all FFDHE with TLSv1.2 client and server
4901  */
4902 # ifndef OPENSSL_NO_EC
4903 static int ecdhe_kexch_groups[] = {NID_X9_62_prime256v1, NID_secp384r1,
4904                                    NID_secp521r1,
4905 #  ifndef OPENSSL_NO_ECX
4906                                    NID_X25519, NID_X448
4907 #  endif
4908                                    };
4909 # endif
4910 # ifndef OPENSSL_NO_DH
4911 static int ffdhe_kexch_groups[] = {NID_ffdhe2048, NID_ffdhe3072, NID_ffdhe4096,
4912                                    NID_ffdhe6144, NID_ffdhe8192};
4913 # endif
4914 static int test_key_exchange(int idx)
4915 {
4916     SSL_CTX *sctx = NULL, *cctx = NULL;
4917     SSL *serverssl = NULL, *clientssl = NULL;
4918     int testresult = 0;
4919     int kexch_alg;
4920     int *kexch_groups = &kexch_alg;
4921     int kexch_groups_size = 1;
4922     int max_version = TLS1_3_VERSION;
4923     char *kexch_name0 = NULL;
4924
4925     switch (idx) {
4926 # ifndef OPENSSL_NO_EC
4927 # ifndef OPENSSL_NO_TLS1_2
4928         case 12:
4929             max_version = TLS1_2_VERSION;
4930 # endif
4931             /* Fall through */
4932         case 0:
4933             kexch_groups = ecdhe_kexch_groups;
4934             kexch_groups_size = OSSL_NELEM(ecdhe_kexch_groups);
4935             kexch_name0 = "secp256r1";
4936             break;
4937         case 1:
4938             kexch_alg = NID_X9_62_prime256v1;
4939             kexch_name0 = "secp256r1";
4940             break;
4941         case 2:
4942             kexch_alg = NID_secp384r1;
4943             kexch_name0 = "secp384r1";
4944             break;
4945         case 3:
4946             kexch_alg = NID_secp521r1;
4947             kexch_name0 = "secp521r1";
4948             break;
4949 #  ifndef OPENSSL_NO_ECX
4950         case 4:
4951             kexch_alg = NID_X25519;
4952             kexch_name0 = "x25519";
4953             break;
4954         case 5:
4955             kexch_alg = NID_X448;
4956             kexch_name0 = "x448";
4957             break;
4958 #  endif
4959 # endif
4960 # ifndef OPENSSL_NO_DH
4961 # ifndef OPENSSL_NO_TLS1_2
4962         case 13:
4963             max_version = TLS1_2_VERSION;
4964             kexch_name0 = "ffdhe2048";
4965 # endif
4966             /* Fall through */
4967         case 6:
4968             kexch_groups = ffdhe_kexch_groups;
4969             kexch_groups_size = OSSL_NELEM(ffdhe_kexch_groups);
4970             kexch_name0 = "ffdhe2048";
4971             break;
4972         case 7:
4973             kexch_alg = NID_ffdhe2048;
4974             kexch_name0 = "ffdhe2048";
4975             break;
4976         case 8:
4977             kexch_alg = NID_ffdhe3072;
4978             kexch_name0 = "ffdhe3072";
4979             break;
4980         case 9:
4981             kexch_alg = NID_ffdhe4096;
4982             kexch_name0 = "ffdhe4096";
4983             break;
4984         case 10:
4985             kexch_alg = NID_ffdhe6144;
4986             kexch_name0 = "ffdhe6144";
4987             break;
4988         case 11:
4989             kexch_alg = NID_ffdhe8192;
4990             kexch_name0 = "ffdhe8192";
4991             break;
4992 # endif
4993         default:
4994             /* We're skipping this test */
4995             return 1;
4996     }
4997
4998     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
4999                                        TLS_client_method(), TLS1_VERSION,
5000                                        max_version, &sctx, &cctx, cert,
5001                                        privkey)))
5002         goto end;
5003
5004     if (!TEST_true(SSL_CTX_set_ciphersuites(sctx,
5005                    TLS1_3_RFC_AES_128_GCM_SHA256)))
5006         goto end;
5007
5008     if (!TEST_true(SSL_CTX_set_ciphersuites(cctx,
5009                    TLS1_3_RFC_AES_128_GCM_SHA256)))
5010         goto end;
5011
5012     if (!TEST_true(SSL_CTX_set_cipher_list(sctx,
5013                    TLS1_TXT_ECDHE_RSA_WITH_AES_128_GCM_SHA256 ":"
5014                    TLS1_TXT_DHE_RSA_WITH_AES_128_GCM_SHA256))
5015             || !TEST_true(SSL_CTX_set_dh_auto(sctx, 1)))
5016         goto end;
5017
5018     /*
5019      * Must include an EC ciphersuite so that we send supported groups in
5020      * TLSv1.2
5021      */
5022 # ifndef OPENSSL_NO_TLS1_2
5023     if (!TEST_true(SSL_CTX_set_cipher_list(cctx,
5024                    TLS1_TXT_ECDHE_RSA_WITH_AES_128_GCM_SHA256 ":"
5025                    TLS1_TXT_DHE_RSA_WITH_AES_128_GCM_SHA256)))
5026         goto end;
5027 # endif
5028
5029     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
5030                                              NULL, NULL)))
5031         goto end;
5032
5033     if (!TEST_true(SSL_set1_groups(serverssl, kexch_groups, kexch_groups_size))
5034         || !TEST_true(SSL_set1_groups(clientssl, kexch_groups, kexch_groups_size)))
5035         goto end;
5036
5037     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
5038         goto end;
5039
5040     /*
5041      * If Handshake succeeds the negotiated kexch alg should be the first one in
5042      * configured, except in the case of FFDHE groups (idx 13), which are
5043      * TLSv1.3 only so we expect no shared group to exist.
5044      */
5045     if (!TEST_int_eq(SSL_get_shared_group(serverssl, 0),
5046                      idx == 13 ? 0 : kexch_groups[0]))
5047         goto end;
5048
5049     if (!TEST_str_eq(SSL_group_to_name(serverssl, kexch_groups[0]),
5050                      kexch_name0))
5051         goto end;
5052
5053     /* We don't implement RFC 7919 named groups for TLS 1.2. */
5054     if (idx != 13) {
5055         if (!TEST_str_eq(SSL_get0_group_name(serverssl), kexch_name0)
5056             || !TEST_str_eq(SSL_get0_group_name(clientssl), kexch_name0))
5057             goto end;
5058         if (!TEST_int_eq(SSL_get_negotiated_group(serverssl), kexch_groups[0]))
5059             goto end;
5060         if (!TEST_int_eq(SSL_get_negotiated_group(clientssl), kexch_groups[0]))
5061             goto end;
5062     }
5063
5064     testresult = 1;
5065  end:
5066     SSL_free(serverssl);
5067     SSL_free(clientssl);
5068     SSL_CTX_free(sctx);
5069     SSL_CTX_free(cctx);
5070     return testresult;
5071 }
5072
5073 # if !defined(OPENSSL_NO_TLS1_2) \
5074      && !defined(OPENSSL_NO_EC)  \
5075      && !defined(OPENSSL_NO_DH)
5076 static int set_ssl_groups(SSL *serverssl, SSL *clientssl, int clientmulti,
5077                           int isecdhe, int idx)
5078 {
5079     int kexch_alg;
5080     int *kexch_groups = &kexch_alg;
5081     int numec, numff;
5082
5083     numec = OSSL_NELEM(ecdhe_kexch_groups);
5084     numff = OSSL_NELEM(ffdhe_kexch_groups);
5085     if (isecdhe)
5086         kexch_alg = ecdhe_kexch_groups[idx];
5087     else
5088         kexch_alg = ffdhe_kexch_groups[idx];
5089
5090     if (clientmulti) {
5091         if (!TEST_true(SSL_set1_groups(serverssl, kexch_groups, 1)))
5092             return 0;
5093         if (isecdhe) {
5094             if (!TEST_true(SSL_set1_groups(clientssl, ecdhe_kexch_groups,
5095                                            numec)))
5096                 return 0;
5097         } else {
5098             if (!TEST_true(SSL_set1_groups(clientssl, ffdhe_kexch_groups,
5099                                            numff)))
5100                 return 0;
5101         }
5102     } else {
5103         if (!TEST_true(SSL_set1_groups(clientssl, kexch_groups, 1)))
5104             return 0;
5105         if (isecdhe) {
5106             if (!TEST_true(SSL_set1_groups(serverssl, ecdhe_kexch_groups,
5107                                            numec)))
5108                 return 0;
5109         } else {
5110             if (!TEST_true(SSL_set1_groups(serverssl, ffdhe_kexch_groups,
5111                                            numff)))
5112                 return 0;
5113         }
5114     }
5115     return 1;
5116 }
5117
5118 /*-
5119  * Test the SSL_get_negotiated_group() API across a battery of scenarios.
5120  * Run through both the ECDHE and FFDHE group lists used in the previous
5121  * test, for both TLS 1.2 and TLS 1.3, negotiating each group in turn,
5122  * confirming the expected result; then perform a resumption handshake
5123  * while offering the same group list, and another resumption handshake
5124  * offering a different group list.  The returned value should be the
5125  * negotiated group for the initial handshake; for TLS 1.3 resumption
5126  * handshakes the returned value will be negotiated on the resumption
5127  * handshake itself, but for TLS 1.2 resumption handshakes the value will
5128  * be cached in the session from the original handshake, regardless of what
5129  * was offered in the resumption ClientHello.
5130  *
5131  * Using E for the number of EC groups and F for the number of FF groups:
5132  * E tests of ECDHE with TLS 1.3, server only has one group
5133  * F tests of FFDHE with TLS 1.3, server only has one group
5134  * E tests of ECDHE with TLS 1.2, server only has one group
5135  * F tests of FFDHE with TLS 1.2, server only has one group
5136  * E tests of ECDHE with TLS 1.3, client sends only one group
5137  * F tests of FFDHE with TLS 1.3, client sends only one group
5138  * E tests of ECDHE with TLS 1.2, client sends only one group
5139  * F tests of FFDHE with TLS 1.2, client sends only one group
5140  */
5141 static int test_negotiated_group(int idx)
5142 {
5143     int clientmulti, istls13, isecdhe, numec, numff, numgroups;
5144     int expectednid;
5145     SSL_CTX *sctx = NULL, *cctx = NULL;
5146     SSL *serverssl = NULL, *clientssl = NULL;
5147     SSL_SESSION *origsess = NULL;
5148     int testresult = 0;
5149     int kexch_alg;
5150     int max_version = TLS1_3_VERSION;
5151
5152     numec = OSSL_NELEM(ecdhe_kexch_groups);
5153     numff = OSSL_NELEM(ffdhe_kexch_groups);
5154     numgroups = numec + numff;
5155     clientmulti = (idx < 2 * numgroups);
5156     idx = idx % (2 * numgroups);
5157     istls13 = (idx < numgroups);
5158     idx = idx % numgroups;
5159     isecdhe = (idx < numec);
5160     if (!isecdhe)
5161         idx -= numec;
5162     /* Now 'idx' is an index into ecdhe_kexch_groups or ffdhe_kexch_groups */
5163     if (isecdhe)
5164         kexch_alg = ecdhe_kexch_groups[idx];
5165     else
5166         kexch_alg = ffdhe_kexch_groups[idx];
5167     /* We expect nothing for the unimplemented TLS 1.2 FFDHE named groups */
5168     if (!istls13 && !isecdhe)
5169         expectednid = NID_undef;
5170     else
5171         expectednid = kexch_alg;
5172
5173     if (!istls13)
5174         max_version = TLS1_2_VERSION;
5175
5176     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
5177                                        TLS_client_method(), TLS1_VERSION,
5178                                        max_version, &sctx, &cctx, cert,
5179                                        privkey)))
5180         goto end;
5181
5182     /*
5183      * Force (EC)DHE ciphers for TLS 1.2.
5184      * Be sure to enable auto tmp DH so that FFDHE can succeed.
5185      */
5186     if (!TEST_true(SSL_CTX_set_cipher_list(sctx,
5187                    TLS1_TXT_ECDHE_RSA_WITH_AES_128_GCM_SHA256 ":"
5188                    TLS1_TXT_DHE_RSA_WITH_AES_128_GCM_SHA256))
5189             || !TEST_true(SSL_CTX_set_dh_auto(sctx, 1)))
5190         goto end;
5191     if (!TEST_true(SSL_CTX_set_cipher_list(cctx,
5192                    TLS1_TXT_ECDHE_RSA_WITH_AES_128_GCM_SHA256 ":"
5193                    TLS1_TXT_DHE_RSA_WITH_AES_128_GCM_SHA256)))
5194         goto end;
5195
5196     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
5197                                              NULL, NULL)))
5198         goto end;
5199
5200     if (!TEST_true(set_ssl_groups(serverssl, clientssl, clientmulti, isecdhe,
5201                                   idx)))
5202         goto end;
5203
5204     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
5205         goto end;
5206
5207     /* Initial handshake; always the configured one */
5208     if (!TEST_uint_eq(SSL_get_negotiated_group(clientssl), expectednid)
5209             || !TEST_uint_eq(SSL_get_negotiated_group(serverssl), expectednid))
5210         goto end;
5211
5212     if (!TEST_ptr((origsess = SSL_get1_session(clientssl))))
5213         goto end;
5214
5215     SSL_shutdown(clientssl);
5216     SSL_shutdown(serverssl);
5217     SSL_free(serverssl);
5218     SSL_free(clientssl);
5219     serverssl = clientssl = NULL;
5220
5221     /* First resumption attempt; use the same config as initial handshake */
5222     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
5223                                              NULL, NULL))
5224             || !TEST_true(SSL_set_session(clientssl, origsess))
5225             || !TEST_true(set_ssl_groups(serverssl, clientssl, clientmulti,
5226                                          isecdhe, idx)))
5227         goto end;
5228
5229     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE))
5230             || !TEST_true(SSL_session_reused(clientssl)))
5231         goto end;
5232
5233     /* Still had better agree, since nothing changed... */
5234     if (!TEST_uint_eq(SSL_get_negotiated_group(clientssl), expectednid)
5235             || !TEST_uint_eq(SSL_get_negotiated_group(serverssl), expectednid))
5236         goto end;
5237
5238     SSL_shutdown(clientssl);
5239     SSL_shutdown(serverssl);
5240     SSL_free(serverssl);
5241     SSL_free(clientssl);
5242     serverssl = clientssl = NULL;
5243
5244     /*-
5245      * Second resumption attempt
5246      * The party that picks one group changes it, which we effectuate by
5247      * changing 'idx' and updating what we expect.
5248      */
5249     if (idx == 0)
5250         idx = 1;
5251     else
5252         idx--;
5253     if (istls13) {
5254         if (isecdhe)
5255             expectednid = ecdhe_kexch_groups[idx];
5256         else
5257             expectednid = ffdhe_kexch_groups[idx];
5258         /* Verify that we are changing what we expect. */
5259         if (!TEST_int_ne(expectednid, kexch_alg))
5260             goto end;
5261     } else {
5262         /* TLS 1.2 only supports named groups for ECDHE. */
5263         if (isecdhe)
5264             expectednid = kexch_alg;
5265         else
5266             expectednid = 0;
5267     }
5268     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
5269                                              NULL, NULL))
5270             || !TEST_true(SSL_set_session(clientssl, origsess))
5271             || !TEST_true(set_ssl_groups(serverssl, clientssl, clientmulti,
5272                                          isecdhe, idx)))
5273         goto end;
5274
5275     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE))
5276             || !TEST_true(SSL_session_reused(clientssl)))
5277         goto end;
5278
5279     /* Check that we get what we expected */
5280     if (!TEST_uint_eq(SSL_get_negotiated_group(clientssl), expectednid)
5281             || !TEST_uint_eq(SSL_get_negotiated_group(serverssl), expectednid))
5282         goto end;
5283
5284     testresult = 1;
5285  end:
5286     SSL_free(serverssl);
5287     SSL_free(clientssl);
5288     SSL_CTX_free(sctx);
5289     SSL_CTX_free(cctx);
5290     SSL_SESSION_free(origsess);
5291     return testresult;
5292 }
5293 # endif /* !defined(OPENSSL_NO_EC) && !defined(OPENSSL_NO_DH) */
5294
5295 /*
5296  * Test TLSv1.3 Cipher Suite
5297  * Test 0 = Set TLS1.3 cipher on context
5298  * Test 1 = Set TLS1.3 cipher on SSL
5299  * Test 2 = Set TLS1.3 and TLS1.2 cipher on context
5300  * Test 3 = Set TLS1.3 and TLS1.2 cipher on SSL
5301  */
5302 static int test_tls13_ciphersuite(int idx)
5303 {
5304     SSL_CTX *sctx = NULL, *cctx = NULL;
5305     SSL *serverssl = NULL, *clientssl = NULL;
5306     static const struct {
5307         const char *ciphername;
5308         int fipscapable;
5309         int low_security;
5310     } t13_ciphers[] = {
5311         { TLS1_3_RFC_AES_128_GCM_SHA256, 1, 0 },
5312         { TLS1_3_RFC_AES_256_GCM_SHA384, 1, 0 },
5313         { TLS1_3_RFC_AES_128_CCM_SHA256, 1, 0 },
5314 # if !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305)
5315         { TLS1_3_RFC_CHACHA20_POLY1305_SHA256, 0, 0 },
5316         { TLS1_3_RFC_AES_256_GCM_SHA384
5317           ":" TLS1_3_RFC_CHACHA20_POLY1305_SHA256, 0, 0 },
5318 # endif
5319         /* CCM8 ciphers are considered low security due to their short tag */
5320         { TLS1_3_RFC_AES_128_CCM_8_SHA256
5321           ":" TLS1_3_RFC_AES_128_CCM_SHA256, 1, 1 }
5322     };
5323     const char *t13_cipher = NULL;
5324     const char *t12_cipher = NULL;
5325     const char *negotiated_scipher;
5326     const char *negotiated_ccipher;
5327     int set_at_ctx = 0;
5328     int set_at_ssl = 0;
5329     int testresult = 0;
5330     int max_ver;
5331     size_t i;
5332
5333     switch (idx) {
5334         case 0:
5335             set_at_ctx = 1;
5336             break;
5337         case 1:
5338             set_at_ssl = 1;
5339             break;
5340         case 2:
5341             set_at_ctx = 1;
5342             t12_cipher = TLS1_TXT_RSA_WITH_AES_128_SHA256;
5343             break;
5344         case 3:
5345             set_at_ssl = 1;
5346             t12_cipher = TLS1_TXT_RSA_WITH_AES_128_SHA256;
5347             break;
5348     }
5349
5350     for (max_ver = TLS1_2_VERSION; max_ver <= TLS1_3_VERSION; max_ver++) {
5351 # ifdef OPENSSL_NO_TLS1_2
5352         if (max_ver == TLS1_2_VERSION)
5353             continue;
5354 # endif
5355         for (i = 0; i < OSSL_NELEM(t13_ciphers); i++) {
5356             if (is_fips && !t13_ciphers[i].fipscapable)
5357                 continue;
5358             t13_cipher = t13_ciphers[i].ciphername;
5359             if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
5360                                                TLS_client_method(),
5361                                                TLS1_VERSION, max_ver,
5362                                                &sctx, &cctx, cert, privkey)))
5363                 goto end;
5364
5365             if (t13_ciphers[i].low_security) {
5366                 SSL_CTX_set_security_level(sctx, 0);
5367                 SSL_CTX_set_security_level(cctx, 0);
5368             }
5369
5370             if (set_at_ctx) {
5371                 if (!TEST_true(SSL_CTX_set_ciphersuites(sctx, t13_cipher))
5372                     || !TEST_true(SSL_CTX_set_ciphersuites(cctx, t13_cipher)))
5373                     goto end;
5374                 if (t12_cipher != NULL) {
5375                     if (!TEST_true(SSL_CTX_set_cipher_list(sctx, t12_cipher))
5376                         || !TEST_true(SSL_CTX_set_cipher_list(cctx,
5377                                                               t12_cipher)))
5378                         goto end;
5379                 }
5380             }
5381
5382             if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
5383                                               &clientssl, NULL, NULL)))
5384                 goto end;
5385
5386             if (set_at_ssl) {
5387                 if (!TEST_true(SSL_set_ciphersuites(serverssl, t13_cipher))
5388                     || !TEST_true(SSL_set_ciphersuites(clientssl, t13_cipher)))
5389                     goto end;
5390                 if (t12_cipher != NULL) {
5391                     if (!TEST_true(SSL_set_cipher_list(serverssl, t12_cipher))
5392                         || !TEST_true(SSL_set_cipher_list(clientssl,
5393                                                           t12_cipher)))
5394                         goto end;
5395                 }
5396             }
5397
5398             if (!TEST_true(create_ssl_connection(serverssl, clientssl,
5399                                                  SSL_ERROR_NONE)))
5400                 goto end;
5401
5402             negotiated_scipher = SSL_CIPHER_get_name(SSL_get_current_cipher(
5403                                                                  serverssl));
5404             negotiated_ccipher = SSL_CIPHER_get_name(SSL_get_current_cipher(
5405                                                                  clientssl));
5406             if (!TEST_str_eq(negotiated_scipher, negotiated_ccipher))
5407                 goto end;
5408
5409             /*
5410              * TEST_strn_eq is used below because t13_cipher can contain
5411              * multiple ciphersuites
5412              */
5413             if (max_ver == TLS1_3_VERSION
5414                 && !TEST_strn_eq(t13_cipher, negotiated_scipher,
5415                                  strlen(negotiated_scipher)))
5416                 goto end;
5417
5418 # ifndef OPENSSL_NO_TLS1_2
5419             /* Below validation is not done when t12_cipher is NULL */
5420             if (max_ver == TLS1_2_VERSION && t12_cipher != NULL
5421                 && !TEST_str_eq(t12_cipher, negotiated_scipher))
5422                 goto end;
5423 # endif
5424
5425             SSL_free(serverssl);
5426             serverssl = NULL;
5427             SSL_free(clientssl);
5428             clientssl = NULL;
5429             SSL_CTX_free(sctx);
5430             sctx = NULL;
5431             SSL_CTX_free(cctx);
5432             cctx = NULL;
5433         }
5434     }
5435
5436     testresult = 1;
5437  end:
5438     SSL_free(serverssl);
5439     SSL_free(clientssl);
5440     SSL_CTX_free(sctx);
5441     SSL_CTX_free(cctx);
5442     return testresult;
5443 }
5444
5445 /*
5446  * Test TLSv1.3 PSKs
5447  * Test 0 = Test new style callbacks
5448  * Test 1 = Test both new and old style callbacks
5449  * Test 2 = Test old style callbacks
5450  * Test 3 = Test old style callbacks with no certificate
5451  */
5452 static int test_tls13_psk(int idx)
5453 {
5454     SSL_CTX *sctx = NULL, *cctx = NULL;
5455     SSL *serverssl = NULL, *clientssl = NULL;
5456     const SSL_CIPHER *cipher = NULL;
5457     const unsigned char key[] = {
5458         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
5459         0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
5460         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
5461         0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f
5462     };
5463     int testresult = 0;
5464
5465     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
5466                                        TLS_client_method(), TLS1_VERSION, 0,
5467                                        &sctx, &cctx, idx == 3 ? NULL : cert,
5468                                        idx == 3 ? NULL : privkey)))
5469         goto end;
5470
5471     if (idx != 3) {
5472         /*
5473          * We use a ciphersuite with SHA256 to ease testing old style PSK
5474          * callbacks which will always default to SHA256. This should not be
5475          * necessary if we have no cert/priv key. In that case the server should
5476          * prefer SHA256 automatically.
5477          */
5478         if (!TEST_true(SSL_CTX_set_ciphersuites(cctx,
5479                                                 "TLS_AES_128_GCM_SHA256")))
5480             goto end;
5481     } else {
5482         /*
5483          * As noted above the server should prefer SHA256 automatically. However
5484          * we are careful not to offer TLS_CHACHA20_POLY1305_SHA256 so this same
5485          * code works even if we are testing with only the FIPS provider loaded.
5486          */
5487         if (!TEST_true(SSL_CTX_set_ciphersuites(cctx,
5488                                                 "TLS_AES_256_GCM_SHA384:"
5489                                                 "TLS_AES_128_GCM_SHA256")))
5490             goto end;
5491     }
5492
5493     /*
5494      * Test 0: New style callbacks only
5495      * Test 1: New and old style callbacks (only the new ones should be used)
5496      * Test 2: Old style callbacks only
5497      */
5498     if (idx == 0 || idx == 1) {
5499         SSL_CTX_set_psk_use_session_callback(cctx, use_session_cb);
5500         SSL_CTX_set_psk_find_session_callback(sctx, find_session_cb);
5501     }
5502 #ifndef OPENSSL_NO_PSK
5503     if (idx >= 1) {
5504         SSL_CTX_set_psk_client_callback(cctx, psk_client_cb);
5505         SSL_CTX_set_psk_server_callback(sctx, psk_server_cb);
5506     }
5507 #endif
5508     srvid = pskid;
5509     use_session_cb_cnt = 0;
5510     find_session_cb_cnt = 0;
5511     psk_client_cb_cnt = 0;
5512     psk_server_cb_cnt = 0;
5513
5514     if (idx != 3) {
5515         /*
5516          * Check we can create a connection if callback decides not to send a
5517          * PSK
5518          */
5519         if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
5520                                                  NULL, NULL))
5521                 || !TEST_true(create_ssl_connection(serverssl, clientssl,
5522                                                     SSL_ERROR_NONE))
5523                 || !TEST_false(SSL_session_reused(clientssl))
5524                 || !TEST_false(SSL_session_reused(serverssl)))
5525             goto end;
5526
5527         if (idx == 0 || idx == 1) {
5528             if (!TEST_true(use_session_cb_cnt == 1)
5529                     || !TEST_true(find_session_cb_cnt == 0)
5530                        /*
5531                         * If no old style callback then below should be 0
5532                         * otherwise 1
5533                         */
5534                     || !TEST_true(psk_client_cb_cnt == idx)
5535                     || !TEST_true(psk_server_cb_cnt == 0))
5536                 goto end;
5537         } else {
5538             if (!TEST_true(use_session_cb_cnt == 0)
5539                     || !TEST_true(find_session_cb_cnt == 0)
5540                     || !TEST_true(psk_client_cb_cnt == 1)
5541                     || !TEST_true(psk_server_cb_cnt == 0))
5542                 goto end;
5543         }
5544
5545         shutdown_ssl_connection(serverssl, clientssl);
5546         serverssl = clientssl = NULL;
5547         use_session_cb_cnt = psk_client_cb_cnt = 0;
5548     }
5549
5550     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
5551                                              NULL, NULL)))
5552         goto end;
5553
5554     /* Create the PSK */
5555     cipher = SSL_CIPHER_find(clientssl, TLS13_AES_128_GCM_SHA256_BYTES);
5556     clientpsk = SSL_SESSION_new();
5557     if (!TEST_ptr(clientpsk)
5558             || !TEST_ptr(cipher)
5559             || !TEST_true(SSL_SESSION_set1_master_key(clientpsk, key,
5560                                                       sizeof(key)))
5561             || !TEST_true(SSL_SESSION_set_cipher(clientpsk, cipher))
5562             || !TEST_true(SSL_SESSION_set_protocol_version(clientpsk,
5563                                                            TLS1_3_VERSION))
5564             || !TEST_true(SSL_SESSION_up_ref(clientpsk)))
5565         goto end;
5566     serverpsk = clientpsk;
5567
5568     /* Check we can create a connection and the PSK is used */
5569     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE))
5570             || !TEST_true(SSL_session_reused(clientssl))
5571             || !TEST_true(SSL_session_reused(serverssl)))
5572         goto end;
5573
5574     if (idx == 0 || idx == 1) {
5575         if (!TEST_true(use_session_cb_cnt == 1)
5576                 || !TEST_true(find_session_cb_cnt == 1)
5577                 || !TEST_true(psk_client_cb_cnt == 0)
5578                 || !TEST_true(psk_server_cb_cnt == 0))
5579             goto end;
5580     } else {
5581         if (!TEST_true(use_session_cb_cnt == 0)
5582                 || !TEST_true(find_session_cb_cnt == 0)
5583                 || !TEST_true(psk_client_cb_cnt == 1)
5584                 || !TEST_true(psk_server_cb_cnt == 1))
5585             goto end;
5586     }
5587
5588     shutdown_ssl_connection(serverssl, clientssl);
5589     serverssl = clientssl = NULL;
5590     use_session_cb_cnt = find_session_cb_cnt = 0;
5591     psk_client_cb_cnt = psk_server_cb_cnt = 0;
5592
5593     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
5594                                              NULL, NULL)))
5595         goto end;
5596
5597     /* Force an HRR */
5598 #if defined(OPENSSL_NO_EC)
5599     if (!TEST_true(SSL_set1_groups_list(serverssl, "ffdhe3072")))
5600         goto end;
5601 #else
5602     if (!TEST_true(SSL_set1_groups_list(serverssl, "P-384")))
5603         goto end;
5604 #endif
5605
5606     /*
5607      * Check we can create a connection, the PSK is used and the callbacks are
5608      * called twice.
5609      */
5610     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE))
5611             || !TEST_true(SSL_session_reused(clientssl))
5612             || !TEST_true(SSL_session_reused(serverssl)))
5613         goto end;
5614
5615     if (idx == 0 || idx == 1) {
5616         if (!TEST_true(use_session_cb_cnt == 2)
5617                 || !TEST_true(find_session_cb_cnt == 2)
5618                 || !TEST_true(psk_client_cb_cnt == 0)
5619                 || !TEST_true(psk_server_cb_cnt == 0))
5620             goto end;
5621     } else {
5622         if (!TEST_true(use_session_cb_cnt == 0)
5623                 || !TEST_true(find_session_cb_cnt == 0)
5624                 || !TEST_true(psk_client_cb_cnt == 2)
5625                 || !TEST_true(psk_server_cb_cnt == 2))
5626             goto end;
5627     }
5628
5629     shutdown_ssl_connection(serverssl, clientssl);
5630     serverssl = clientssl = NULL;
5631     use_session_cb_cnt = find_session_cb_cnt = 0;
5632     psk_client_cb_cnt = psk_server_cb_cnt = 0;
5633
5634     if (idx != 3) {
5635         /*
5636          * Check that if the server rejects the PSK we can still connect, but with
5637          * a full handshake
5638          */
5639         srvid = "Dummy Identity";
5640         if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
5641                                                  NULL, NULL))
5642                 || !TEST_true(create_ssl_connection(serverssl, clientssl,
5643                                                     SSL_ERROR_NONE))
5644                 || !TEST_false(SSL_session_reused(clientssl))
5645                 || !TEST_false(SSL_session_reused(serverssl)))
5646             goto end;
5647
5648         if (idx == 0 || idx == 1) {
5649             if (!TEST_true(use_session_cb_cnt == 1)
5650                     || !TEST_true(find_session_cb_cnt == 1)
5651                     || !TEST_true(psk_client_cb_cnt == 0)
5652                        /*
5653                         * If no old style callback then below should be 0
5654                         * otherwise 1
5655                         */
5656                     || !TEST_true(psk_server_cb_cnt == idx))
5657                 goto end;
5658         } else {
5659             if (!TEST_true(use_session_cb_cnt == 0)
5660                     || !TEST_true(find_session_cb_cnt == 0)
5661                     || !TEST_true(psk_client_cb_cnt == 1)
5662                     || !TEST_true(psk_server_cb_cnt == 1))
5663                 goto end;
5664         }
5665
5666         shutdown_ssl_connection(serverssl, clientssl);
5667         serverssl = clientssl = NULL;
5668     }
5669     testresult = 1;
5670
5671  end:
5672     SSL_SESSION_free(clientpsk);
5673     SSL_SESSION_free(serverpsk);
5674     clientpsk = serverpsk = NULL;
5675     SSL_free(serverssl);
5676     SSL_free(clientssl);
5677     SSL_CTX_free(sctx);
5678     SSL_CTX_free(cctx);
5679     return testresult;
5680 }
5681
5682 #ifndef OSSL_NO_USABLE_TLS1_3
5683 /*
5684  * Test TLS1.3 connection establishment succeeds with various configurations of
5685  * the options `SSL_OP_ALLOW_NO_DHE_KEX` and `SSL_OP_PREFER_NO_DHE_KEX`.
5686  * The verification of whether the right KEX mode is chosen is not covered by
5687  * this test but by `test_tls13kexmodes`.
5688  *
5689  * Tests (idx & 1): Server has `SSL_OP_ALLOW_NO_DHE_KEX` set.
5690  * Tests (idx & 2): Server has `SSL_OP_PREFER_NO_DHE_KEX` set.
5691  * Tests (idx & 4): Client has `SSL_OP_ALLOW_NO_DHE_KEX` set.
5692  */
5693 static int test_tls13_no_dhe_kex(const int idx)
5694 {
5695     SSL_CTX *sctx = NULL, *cctx = NULL;
5696     SSL *serverssl = NULL, *clientssl = NULL;
5697     int testresult = 0;
5698     size_t j;
5699     SSL_SESSION *saved_session;
5700
5701     int server_allow_no_dhe = (idx & 1) != 0;
5702     int server_prefer_no_dhe = (idx & 2) != 0;
5703     int client_allow_no_dhe = (idx & 4) != 0;
5704
5705     uint64_t server_options = 0
5706             | (server_allow_no_dhe ? SSL_OP_ALLOW_NO_DHE_KEX : 0)
5707             | (server_prefer_no_dhe ? SSL_OP_PREFER_NO_DHE_KEX : 0);
5708
5709     uint64_t client_options = 0
5710             | (client_allow_no_dhe ? SSL_OP_ALLOW_NO_DHE_KEX : 0);
5711
5712     new_called = 0;
5713     do_cache = 1;
5714
5715     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
5716                                        TLS_client_method(), TLS1_3_VERSION, 0,
5717                                        &sctx, &cctx, cert, privkey)))
5718         goto end;
5719
5720     SSL_CTX_set_session_cache_mode(cctx, SSL_SESS_CACHE_CLIENT
5721                                           | SSL_SESS_CACHE_NO_INTERNAL_STORE);
5722
5723     SSL_CTX_set_options(sctx, server_options);
5724     SSL_CTX_set_options(cctx, client_options);
5725
5726     SSL_CTX_sess_set_new_cb(cctx, new_cachesession_cb);
5727
5728     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
5729                                       &clientssl, NULL, NULL)))
5730         goto end;
5731
5732     if (!TEST_true(create_ssl_connection(serverssl, clientssl,
5733                                          SSL_ERROR_NONE))
5734             /* Check we got the number of tickets we were expecting */
5735             || !TEST_int_eq(2, new_called))
5736         goto end;
5737
5738     /* We'll reuse the last ticket. */
5739     saved_session = sesscache[new_called - 1];
5740
5741     SSL_shutdown(clientssl);
5742     SSL_shutdown(serverssl);
5743     SSL_free(serverssl);
5744     SSL_free(clientssl);
5745     SSL_CTX_free(cctx);
5746     clientssl = serverssl = NULL;
5747     cctx = NULL;
5748
5749     /*
5750      * Now we resume with the last ticket we created.
5751      */
5752
5753     /* The server context already exists, so we only create the client. */
5754     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
5755                                        TLS_client_method(), TLS1_3_VERSION, 0,
5756                                        NULL, &cctx, cert, privkey)))
5757         goto end;
5758
5759     SSL_CTX_set_options(cctx, client_options);
5760
5761     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
5762                                       &clientssl, NULL, NULL))
5763             || !TEST_true(SSL_set_session(clientssl, saved_session)))
5764         goto end;
5765
5766     if (!TEST_true(create_ssl_connection(serverssl, clientssl,
5767                                          SSL_ERROR_NONE)))
5768         goto end;
5769
5770     /*
5771      * Make sure, the session was resumed.
5772      */
5773     if (!TEST_true(SSL_session_reused(clientssl)))
5774         goto end;
5775
5776     SSL_shutdown(clientssl);
5777     SSL_shutdown(serverssl);
5778
5779     testresult = 1;
5780
5781  end:
5782     SSL_free(serverssl);
5783     SSL_free(clientssl);
5784     for (j = 0; j < OSSL_NELEM(sesscache); j++) {
5785         SSL_SESSION_free(sesscache[j]);
5786         sesscache[j] = NULL;
5787     }
5788     SSL_CTX_free(sctx);
5789     SSL_CTX_free(cctx);
5790
5791     return testresult;
5792 }
5793 #endif /* OSSL_NO_USABLE_TLS1_3 */
5794
5795 static unsigned char cookie_magic_value[] = "cookie magic";
5796
5797 static int generate_cookie_callback(SSL *ssl, unsigned char *cookie,
5798                                     unsigned int *cookie_len)
5799 {
5800     /*
5801      * Not suitable as a real cookie generation function but good enough for
5802      * testing!
5803      */
5804     memcpy(cookie, cookie_magic_value, sizeof(cookie_magic_value) - 1);
5805     *cookie_len = sizeof(cookie_magic_value) - 1;
5806
5807     return 1;
5808 }
5809
5810 static int verify_cookie_callback(SSL *ssl, const unsigned char *cookie,
5811                                   unsigned int cookie_len)
5812 {
5813     if (cookie_len == sizeof(cookie_magic_value) - 1
5814         && memcmp(cookie, cookie_magic_value, cookie_len) == 0)
5815         return 1;
5816
5817     return 0;
5818 }
5819
5820 static int generate_stateless_cookie_callback(SSL *ssl, unsigned char *cookie,
5821                                         size_t *cookie_len)
5822 {
5823     unsigned int temp;
5824     int res = generate_cookie_callback(ssl, cookie, &temp);
5825     *cookie_len = temp;
5826     return res;
5827 }
5828
5829 static int verify_stateless_cookie_callback(SSL *ssl, const unsigned char *cookie,
5830                                       size_t cookie_len)
5831 {
5832     return verify_cookie_callback(ssl, cookie, cookie_len);
5833 }
5834
5835 static int test_stateless(void)
5836 {
5837     SSL_CTX *sctx = NULL, *cctx = NULL;
5838     SSL *serverssl = NULL, *clientssl = NULL;
5839     int testresult = 0;
5840
5841     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
5842                                        TLS_client_method(), TLS1_VERSION, 0,
5843                                        &sctx, &cctx, cert, privkey)))
5844         goto end;
5845
5846     /* The arrival of CCS messages can confuse the test */
5847     SSL_CTX_clear_options(cctx, SSL_OP_ENABLE_MIDDLEBOX_COMPAT);
5848
5849     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
5850                                       NULL, NULL))
5851                /* Send the first ClientHello */
5852             || !TEST_false(create_ssl_connection(serverssl, clientssl,
5853                                                  SSL_ERROR_WANT_READ))
5854                /*
5855                 * This should fail with a -1 return because we have no callbacks
5856                 * set up
5857                 */
5858             || !TEST_int_eq(SSL_stateless(serverssl), -1))
5859         goto end;
5860
5861     /* Fatal error so abandon the connection from this client */
5862     SSL_free(clientssl);
5863     clientssl = NULL;
5864
5865     /* Set up the cookie generation and verification callbacks */
5866     SSL_CTX_set_stateless_cookie_generate_cb(sctx, generate_stateless_cookie_callback);
5867     SSL_CTX_set_stateless_cookie_verify_cb(sctx, verify_stateless_cookie_callback);
5868
5869     /*
5870      * Create a new connection from the client (we can reuse the server SSL
5871      * object).
5872      */
5873     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
5874                                              NULL, NULL))
5875                /* Send the first ClientHello */
5876             || !TEST_false(create_ssl_connection(serverssl, clientssl,
5877                                                 SSL_ERROR_WANT_READ))
5878                /* This should fail because there is no cookie */
5879             || !TEST_int_eq(SSL_stateless(serverssl), 0))
5880         goto end;
5881
5882     /* Abandon the connection from this client */
5883     SSL_free(clientssl);
5884     clientssl = NULL;
5885
5886     /*
5887      * Now create a connection from a new client but with the same server SSL
5888      * object
5889      */
5890     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
5891                                              NULL, NULL))
5892                /* Send the first ClientHello */
5893             || !TEST_false(create_ssl_connection(serverssl, clientssl,
5894                                                 SSL_ERROR_WANT_READ))
5895                /* This should fail because there is no cookie */
5896             || !TEST_int_eq(SSL_stateless(serverssl), 0)
5897                /* Send the second ClientHello */
5898             || !TEST_false(create_ssl_connection(serverssl, clientssl,
5899                                                 SSL_ERROR_WANT_READ))
5900                /* This should succeed because a cookie is now present */
5901             || !TEST_int_eq(SSL_stateless(serverssl), 1)
5902                /* Complete the connection */
5903             || !TEST_true(create_ssl_connection(serverssl, clientssl,
5904                                                 SSL_ERROR_NONE)))
5905         goto end;
5906
5907     shutdown_ssl_connection(serverssl, clientssl);
5908     serverssl = clientssl = NULL;
5909     testresult = 1;
5910
5911  end:
5912     SSL_free(serverssl);
5913     SSL_free(clientssl);
5914     SSL_CTX_free(sctx);
5915     SSL_CTX_free(cctx);
5916     return testresult;
5917
5918 }
5919 #endif /* OSSL_NO_USABLE_TLS1_3 */
5920
5921 static int clntaddoldcb = 0;
5922 static int clntparseoldcb = 0;
5923 static int srvaddoldcb = 0;
5924 static int srvparseoldcb = 0;
5925 static int clntaddnewcb = 0;
5926 static int clntparsenewcb = 0;
5927 static int srvaddnewcb = 0;
5928 static int srvparsenewcb = 0;
5929 static int snicb = 0;
5930
5931 #define TEST_EXT_TYPE1  0xff00
5932
5933 static int old_add_cb(SSL *s, unsigned int ext_type, const unsigned char **out,
5934                       size_t *outlen, int *al, void *add_arg)
5935 {
5936     int *server = (int *)add_arg;
5937     unsigned char *data;
5938
5939     if (SSL_is_server(s))
5940         srvaddoldcb++;
5941     else
5942         clntaddoldcb++;
5943
5944     if (*server != SSL_is_server(s)
5945             || (data = OPENSSL_malloc(sizeof(*data))) == NULL)
5946         return -1;
5947
5948     *data = 1;
5949     *out = data;
5950     *outlen = sizeof(char);
5951     return 1;
5952 }
5953
5954 static void old_free_cb(SSL *s, unsigned int ext_type, const unsigned char *out,
5955                         void *add_arg)
5956 {
5957     OPENSSL_free((unsigned char *)out);
5958 }
5959
5960 static int old_parse_cb(SSL *s, unsigned int ext_type, const unsigned char *in,
5961                         size_t inlen, int *al, void *parse_arg)
5962 {
5963     int *server = (int *)parse_arg;
5964
5965     if (SSL_is_server(s))
5966         srvparseoldcb++;
5967     else
5968         clntparseoldcb++;
5969
5970     if (*server != SSL_is_server(s)
5971             || inlen != sizeof(char)
5972             || *in != 1)
5973         return -1;
5974
5975     return 1;
5976 }
5977
5978 static int new_add_cb(SSL *s, unsigned int ext_type, unsigned int context,
5979                       const unsigned char **out, size_t *outlen, X509 *x,
5980                       size_t chainidx, int *al, void *add_arg)
5981 {
5982     int *server = (int *)add_arg;
5983     unsigned char *data;
5984
5985     if (SSL_is_server(s))
5986         srvaddnewcb++;
5987     else
5988         clntaddnewcb++;
5989
5990     if (*server != SSL_is_server(s)
5991             || (data = OPENSSL_malloc(sizeof(*data))) == NULL)
5992         return -1;
5993
5994     *data = 1;
5995     *out = data;
5996     *outlen = sizeof(*data);
5997     return 1;
5998 }
5999
6000 static void new_free_cb(SSL *s, unsigned int ext_type, unsigned int context,
6001                         const unsigned char *out, void *add_arg)
6002 {
6003     OPENSSL_free((unsigned char *)out);
6004 }
6005
6006 static int new_parse_cb(SSL *s, unsigned int ext_type, unsigned int context,
6007                         const unsigned char *in, size_t inlen, X509 *x,
6008                         size_t chainidx, int *al, void *parse_arg)
6009 {
6010     int *server = (int *)parse_arg;
6011
6012     if (SSL_is_server(s))
6013         srvparsenewcb++;
6014     else
6015         clntparsenewcb++;
6016
6017     if (*server != SSL_is_server(s)
6018             || inlen != sizeof(char) || *in != 1)
6019         return -1;
6020
6021     return 1;
6022 }
6023
6024 static int sni_cb(SSL *s, int *al, void *arg)
6025 {
6026     SSL_CTX *ctx = (SSL_CTX *)arg;
6027
6028     if (SSL_set_SSL_CTX(s, ctx) == NULL) {
6029         *al = SSL_AD_INTERNAL_ERROR;
6030         return SSL_TLSEXT_ERR_ALERT_FATAL;
6031     }
6032     snicb++;
6033     return SSL_TLSEXT_ERR_OK;
6034 }
6035
6036 static int verify_cb(int preverify_ok, X509_STORE_CTX *x509_ctx)
6037 {
6038     return 1;
6039 }
6040
6041 /*
6042  * Custom call back tests.
6043  * Test 0: Old style callbacks in TLSv1.2
6044  * Test 1: New style callbacks in TLSv1.2
6045  * Test 2: New style callbacks in TLSv1.2 with SNI
6046  * Test 3: New style callbacks in TLSv1.3. Extensions in CH and EE
6047  * Test 4: New style callbacks in TLSv1.3. Extensions in CH, SH, EE, Cert + NST
6048  * Test 5: New style callbacks in TLSv1.3. Extensions in CR + Client Cert
6049  */
6050 static int test_custom_exts(int tst)
6051 {
6052     SSL_CTX *cctx = NULL, *sctx = NULL, *sctx2 = NULL;
6053     SSL *clientssl = NULL, *serverssl = NULL;
6054     int testresult = 0;
6055     static int server = 1;
6056     static int client = 0;
6057     SSL_SESSION *sess = NULL;
6058     unsigned int context;
6059
6060 #if defined(OPENSSL_NO_TLS1_2) && !defined(OSSL_NO_USABLE_TLS1_3)
6061     /* Skip tests for TLSv1.2 and below in this case */
6062     if (tst < 3)
6063         return 1;
6064 #endif
6065
6066     /* Reset callback counters */
6067     clntaddoldcb = clntparseoldcb = srvaddoldcb = srvparseoldcb = 0;
6068     clntaddnewcb = clntparsenewcb = srvaddnewcb = srvparsenewcb = 0;
6069     snicb = 0;
6070
6071     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
6072                                        TLS_client_method(), TLS1_VERSION, 0,
6073                                        &sctx, &cctx, cert, privkey)))
6074         goto end;
6075
6076     if (tst == 2
6077             && !TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(), NULL,
6078                                               TLS1_VERSION, 0,
6079                                               &sctx2, NULL, cert, privkey)))
6080         goto end;
6081
6082
6083     if (tst < 3) {
6084         SSL_CTX_set_options(cctx, SSL_OP_NO_TLSv1_3);
6085         SSL_CTX_set_options(sctx, SSL_OP_NO_TLSv1_3);
6086         if (sctx2 != NULL)
6087             SSL_CTX_set_options(sctx2, SSL_OP_NO_TLSv1_3);
6088     }
6089
6090     if (tst == 5) {
6091         context = SSL_EXT_TLS1_3_CERTIFICATE_REQUEST
6092                   | SSL_EXT_TLS1_3_CERTIFICATE;
6093         SSL_CTX_set_verify(sctx,
6094                            SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
6095                            verify_cb);
6096         if (!TEST_int_eq(SSL_CTX_use_certificate_file(cctx, cert,
6097                                                       SSL_FILETYPE_PEM), 1)
6098                 || !TEST_int_eq(SSL_CTX_use_PrivateKey_file(cctx, privkey,
6099                                                             SSL_FILETYPE_PEM), 1)
6100                 || !TEST_int_eq(SSL_CTX_check_private_key(cctx), 1))
6101             goto end;
6102     } else if (tst == 4) {
6103         context = SSL_EXT_CLIENT_HELLO
6104                   | SSL_EXT_TLS1_2_SERVER_HELLO
6105                   | SSL_EXT_TLS1_3_SERVER_HELLO
6106                   | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS
6107                   | SSL_EXT_TLS1_3_CERTIFICATE
6108                   | SSL_EXT_TLS1_3_NEW_SESSION_TICKET;
6109     } else {
6110         context = SSL_EXT_CLIENT_HELLO
6111                   | SSL_EXT_TLS1_2_SERVER_HELLO
6112                   | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS;
6113     }
6114
6115     /* Create a client side custom extension */
6116     if (tst == 0) {
6117         if (!TEST_true(SSL_CTX_add_client_custom_ext(cctx, TEST_EXT_TYPE1,
6118                                                      old_add_cb, old_free_cb,
6119                                                      &client, old_parse_cb,
6120                                                      &client)))
6121             goto end;
6122     } else {
6123         if (!TEST_true(SSL_CTX_add_custom_ext(cctx, TEST_EXT_TYPE1, context,
6124                                               new_add_cb, new_free_cb,
6125                                               &client, new_parse_cb, &client)))
6126             goto end;
6127     }
6128
6129     /* Should not be able to add duplicates */
6130     if (!TEST_false(SSL_CTX_add_client_custom_ext(cctx, TEST_EXT_TYPE1,
6131                                                   old_add_cb, old_free_cb,
6132                                                   &client, old_parse_cb,
6133                                                   &client))
6134             || !TEST_false(SSL_CTX_add_custom_ext(cctx, TEST_EXT_TYPE1,
6135                                                   context, new_add_cb,
6136                                                   new_free_cb, &client,
6137                                                   new_parse_cb, &client)))
6138         goto end;
6139
6140     /* Create a server side custom extension */
6141     if (tst == 0) {
6142         if (!TEST_true(SSL_CTX_add_server_custom_ext(sctx, TEST_EXT_TYPE1,
6143                                                      old_add_cb, old_free_cb,
6144                                                      &server, old_parse_cb,
6145                                                      &server)))
6146             goto end;
6147     } else {
6148         if (!TEST_true(SSL_CTX_add_custom_ext(sctx, TEST_EXT_TYPE1, context,
6149                                               new_add_cb, new_free_cb,
6150                                               &server, new_parse_cb, &server)))
6151             goto end;
6152         if (sctx2 != NULL
6153                 && !TEST_true(SSL_CTX_add_custom_ext(sctx2, TEST_EXT_TYPE1,
6154                                                      context, new_add_cb,
6155                                                      new_free_cb, &server,
6156                                                      new_parse_cb, &server)))
6157             goto end;
6158     }
6159
6160     /* Should not be able to add duplicates */
6161     if (!TEST_false(SSL_CTX_add_server_custom_ext(sctx, TEST_EXT_TYPE1,
6162                                                   old_add_cb, old_free_cb,
6163                                                   &server, old_parse_cb,
6164                                                   &server))
6165             || !TEST_false(SSL_CTX_add_custom_ext(sctx, TEST_EXT_TYPE1,
6166                                                   context, new_add_cb,
6167                                                   new_free_cb, &server,
6168                                                   new_parse_cb, &server)))
6169         goto end;
6170
6171     if (tst == 2) {
6172         /* Set up SNI */
6173         if (!TEST_true(SSL_CTX_set_tlsext_servername_callback(sctx, sni_cb))
6174                 || !TEST_true(SSL_CTX_set_tlsext_servername_arg(sctx, sctx2)))
6175             goto end;
6176     }
6177
6178     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
6179                                       &clientssl, NULL, NULL))
6180             || !TEST_true(create_ssl_connection(serverssl, clientssl,
6181                                                 SSL_ERROR_NONE)))
6182         goto end;
6183
6184     if (tst == 0) {
6185         if (clntaddoldcb != 1
6186                 || clntparseoldcb != 1
6187                 || srvaddoldcb != 1
6188                 || srvparseoldcb != 1)
6189             goto end;
6190     } else if (tst == 1 || tst == 2 || tst == 3) {
6191         if (clntaddnewcb != 1
6192                 || clntparsenewcb != 1
6193                 || srvaddnewcb != 1
6194                 || srvparsenewcb != 1
6195                 || (tst != 2 && snicb != 0)
6196                 || (tst == 2 && snicb != 1))
6197             goto end;
6198     } else if (tst == 5) {
6199         if (clntaddnewcb != 1
6200                 || clntparsenewcb != 1
6201                 || srvaddnewcb != 1
6202                 || srvparsenewcb != 1)
6203             goto end;
6204     } else {
6205         /* In this case there 2 NewSessionTicket messages created */
6206         if (clntaddnewcb != 1
6207                 || clntparsenewcb != 5
6208                 || srvaddnewcb != 5
6209                 || srvparsenewcb != 1)
6210             goto end;
6211     }
6212
6213     sess = SSL_get1_session(clientssl);
6214     SSL_shutdown(clientssl);
6215     SSL_shutdown(serverssl);
6216     SSL_free(serverssl);
6217     SSL_free(clientssl);
6218     serverssl = clientssl = NULL;
6219
6220     if (tst == 3 || tst == 5) {
6221         /* We don't bother with the resumption aspects for these tests */
6222         testresult = 1;
6223         goto end;
6224     }
6225
6226     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
6227                                       NULL, NULL))
6228             || !TEST_true(SSL_set_session(clientssl, sess))
6229             || !TEST_true(create_ssl_connection(serverssl, clientssl,
6230                                                SSL_ERROR_NONE)))
6231         goto end;
6232
6233     /*
6234      * For a resumed session we expect to add the ClientHello extension. For the
6235      * old style callbacks we ignore it on the server side because they set
6236      * SSL_EXT_IGNORE_ON_RESUMPTION. The new style callbacks do not ignore
6237      * them.
6238      */
6239     if (tst == 0) {
6240         if (clntaddoldcb != 2
6241                 || clntparseoldcb != 1
6242                 || srvaddoldcb != 1
6243                 || srvparseoldcb != 1)
6244             goto end;
6245     } else if (tst == 1 || tst == 2 || tst == 3) {
6246         if (clntaddnewcb != 2
6247                 || clntparsenewcb != 2
6248                 || srvaddnewcb != 2
6249                 || srvparsenewcb != 2)
6250             goto end;
6251     } else {
6252         /*
6253          * No Certificate message extensions in the resumption handshake,
6254          * 2 NewSessionTickets in the initial handshake, 1 in the resumption
6255          */
6256         if (clntaddnewcb != 2
6257                 || clntparsenewcb != 8
6258                 || srvaddnewcb != 8
6259                 || srvparsenewcb != 2)
6260             goto end;
6261     }
6262
6263     testresult = 1;
6264
6265 end:
6266     SSL_SESSION_free(sess);
6267     SSL_free(serverssl);
6268     SSL_free(clientssl);
6269     SSL_CTX_free(sctx2);
6270     SSL_CTX_free(sctx);
6271     SSL_CTX_free(cctx);
6272     return testresult;
6273 }
6274
6275 #if !defined(OPENSSL_NO_TLS1_2) && !defined(OSSL_NO_USABLE_TLS1_3)
6276
6277 #define  SYNTHV1CONTEXT     (SSL_EXT_TLS1_2_AND_BELOW_ONLY \
6278                              | SSL_EXT_CLIENT_HELLO \
6279                              | SSL_EXT_TLS1_2_SERVER_HELLO \
6280                              | SSL_EXT_IGNORE_ON_RESUMPTION)
6281
6282 #define TLS13CONTEXT (SSL_EXT_TLS1_3_CERTIFICATE \
6283                       | SSL_EXT_TLS1_2_SERVER_HELLO \
6284                       | SSL_EXT_CLIENT_HELLO)
6285
6286 #define SERVERINFO_CUSTOM                                 \
6287     0x00, (char)TLSEXT_TYPE_signed_certificate_timestamp, \
6288     0x00, 0x03,                                           \
6289     0x04, 0x05, 0x06                                      \
6290
6291 static const unsigned char serverinfo_custom_tls13[] = {
6292     0x00, 0x00, (TLS13CONTEXT >> 8) & 0xff, TLS13CONTEXT & 0xff,
6293     SERVERINFO_CUSTOM
6294 };
6295 static const unsigned char serverinfo_custom_v2[] = {
6296     0x00, 0x00, (SYNTHV1CONTEXT >> 8) & 0xff,  SYNTHV1CONTEXT & 0xff,
6297     SERVERINFO_CUSTOM
6298 };
6299 static const unsigned char serverinfo_custom_v1[] = {
6300     SERVERINFO_CUSTOM
6301 };
6302 static const size_t serverinfo_custom_tls13_len = sizeof(serverinfo_custom_tls13);
6303 static const size_t serverinfo_custom_v2_len = sizeof(serverinfo_custom_v2);
6304 static const size_t serverinfo_custom_v1_len = sizeof(serverinfo_custom_v1);
6305
6306 static int serverinfo_custom_parse_cb(SSL *s, unsigned int ext_type,
6307                                       unsigned int context,
6308                                       const unsigned char *in,
6309                                       size_t inlen, X509 *x,
6310                                       size_t chainidx, int *al,
6311                                       void *parse_arg)
6312 {
6313     const size_t len = serverinfo_custom_v1_len;
6314     const unsigned char *si = &serverinfo_custom_v1[len - 3];
6315     int *p_cb_result = (int*)parse_arg;
6316     *p_cb_result = TEST_mem_eq(in, inlen, si, 3);
6317     return 1;
6318 }
6319
6320 static int test_serverinfo_custom(const int idx)
6321 {
6322     SSL_CTX *sctx = NULL, *cctx = NULL;
6323     SSL *clientssl = NULL, *serverssl = NULL;
6324     int testresult = 0;
6325     int cb_result = 0;
6326
6327     /*
6328      * Following variables are set in the switch statement
6329      *  according to the test iteration.
6330      * Default values do not make much sense: test would fail with them.
6331      */
6332     int serverinfo_version = 0;
6333     int protocol_version = 0;
6334     unsigned int extension_context = 0;
6335     const unsigned char *si = NULL;
6336     size_t si_len = 0;
6337
6338     const int call_use_serverinfo_ex = idx > 0;
6339     switch (idx) {
6340     case 0: /* FALLTHROUGH */
6341     case 1:
6342         serverinfo_version = SSL_SERVERINFOV1;
6343         protocol_version = TLS1_2_VERSION;
6344         extension_context = SYNTHV1CONTEXT;
6345         si = serverinfo_custom_v1;
6346         si_len = serverinfo_custom_v1_len;
6347         break;
6348     case 2:
6349         serverinfo_version = SSL_SERVERINFOV2;
6350         protocol_version = TLS1_2_VERSION;
6351         extension_context = SYNTHV1CONTEXT;
6352         si = serverinfo_custom_v2;
6353         si_len = serverinfo_custom_v2_len;
6354         break;
6355     case 3:
6356         serverinfo_version = SSL_SERVERINFOV2;
6357         protocol_version = TLS1_3_VERSION;
6358         extension_context = TLS13CONTEXT;
6359         si = serverinfo_custom_tls13;
6360         si_len = serverinfo_custom_tls13_len;
6361         break;
6362     }
6363
6364     if (!TEST_true(create_ssl_ctx_pair(libctx,
6365                                        TLS_method(),
6366                                        TLS_method(),
6367                                        protocol_version,
6368                                        protocol_version,
6369                                        &sctx, &cctx, cert, privkey)))
6370         goto end;
6371
6372     if (call_use_serverinfo_ex) {
6373         if (!TEST_true(SSL_CTX_use_serverinfo_ex(sctx, serverinfo_version,
6374                                                  si, si_len)))
6375             goto end;
6376     } else {
6377         if (!TEST_true(SSL_CTX_use_serverinfo(sctx, si, si_len)))
6378             goto end;
6379     }
6380
6381     if (!TEST_true(SSL_CTX_add_custom_ext(cctx, TLSEXT_TYPE_signed_certificate_timestamp,
6382                                           extension_context,
6383                                           NULL, NULL, NULL,
6384                                           serverinfo_custom_parse_cb,
6385                                           &cb_result))
6386         || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
6387                                          NULL, NULL))
6388         || !TEST_true(create_ssl_connection(serverssl, clientssl,
6389                                             SSL_ERROR_NONE))
6390         || !TEST_int_eq(SSL_do_handshake(clientssl), 1))
6391         goto end;
6392
6393     if (!TEST_true(cb_result))
6394         goto end;
6395
6396     testresult = 1;
6397
6398  end:
6399     SSL_free(serverssl);
6400     SSL_free(clientssl);
6401     SSL_CTX_free(sctx);
6402     SSL_CTX_free(cctx);
6403
6404     return testresult;
6405 }
6406 #endif
6407
6408 /*
6409  * Test that SSL_export_keying_material() produces expected results. There are
6410  * no test vectors so all we do is test that both sides of the communication
6411  * produce the same results for different protocol versions.
6412  */
6413 #define SMALL_LABEL_LEN 10
6414 #define LONG_LABEL_LEN  249
6415 static int test_export_key_mat(int tst)
6416 {
6417     int testresult = 0;
6418     SSL_CTX *cctx = NULL, *sctx = NULL, *sctx2 = NULL;
6419     SSL *clientssl = NULL, *serverssl = NULL;
6420     const char label[LONG_LABEL_LEN + 1] = "test label";
6421     const unsigned char context[] = "context";
6422     const unsigned char *emptycontext = NULL;
6423     unsigned char longcontext[1280];
6424     int test_longcontext = fips_provider_version_ge(libctx, 3, 3, 0);
6425     unsigned char ckeymat1[80], ckeymat2[80], ckeymat3[80], ckeymat4[80];
6426     unsigned char skeymat1[80], skeymat2[80], skeymat3[80], skeymat4[80];
6427     size_t labellen;
6428     const int protocols[] = {
6429         TLS1_VERSION,
6430         TLS1_1_VERSION,
6431         TLS1_2_VERSION,
6432         TLS1_3_VERSION,
6433         TLS1_3_VERSION,
6434         TLS1_3_VERSION
6435     };
6436
6437 #ifdef OPENSSL_NO_TLS1
6438     if (tst == 0)
6439         return 1;
6440 #endif
6441 #ifdef OPENSSL_NO_TLS1_1
6442     if (tst == 1)
6443         return 1;
6444 #endif
6445     if (is_fips && (tst == 0 || tst == 1))
6446         return 1;
6447 #ifdef OPENSSL_NO_TLS1_2
6448     if (tst == 2)
6449         return 1;
6450 #endif
6451 #ifdef OSSL_NO_USABLE_TLS1_3
6452     if (tst >= 3)
6453         return 1;
6454 #endif
6455     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
6456                                        TLS_client_method(), TLS1_VERSION, 0,
6457                                        &sctx, &cctx, cert, privkey)))
6458         goto end;
6459
6460     OPENSSL_assert(tst >= 0 && (size_t)tst < OSSL_NELEM(protocols));
6461     SSL_CTX_set_max_proto_version(cctx, protocols[tst]);
6462     SSL_CTX_set_min_proto_version(cctx, protocols[tst]);
6463     if ((protocols[tst] < TLS1_2_VERSION) &&
6464         (!SSL_CTX_set_cipher_list(cctx, "DEFAULT:@SECLEVEL=0")
6465         || !SSL_CTX_set_cipher_list(sctx, "DEFAULT:@SECLEVEL=0")))
6466         goto end;
6467
6468     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL,
6469                                       NULL)))
6470         goto end;
6471
6472     /*
6473      * Premature call of SSL_export_keying_material should just fail.
6474      */
6475     if (!TEST_int_le(SSL_export_keying_material(clientssl, ckeymat1,
6476                                                 sizeof(ckeymat1), label,
6477                                                 SMALL_LABEL_LEN + 1, context,
6478                                                 sizeof(context) - 1, 1), 0))
6479         goto end;
6480
6481     if (!TEST_true(create_ssl_connection(serverssl, clientssl,
6482                                          SSL_ERROR_NONE)))
6483         goto end;
6484
6485     if (tst == 5) {
6486         /*
6487          * TLSv1.3 imposes a maximum label len of 249 bytes. Check we fail if we
6488          * go over that.
6489          */
6490         if (!TEST_int_le(SSL_export_keying_material(clientssl, ckeymat1,
6491                                                     sizeof(ckeymat1), label,
6492                                                     LONG_LABEL_LEN + 1, context,
6493                                                     sizeof(context) - 1, 1), 0))
6494             goto end;
6495
6496         testresult = 1;
6497         goto end;
6498     } else if (tst == 4) {
6499         labellen = LONG_LABEL_LEN;
6500     } else {
6501         labellen = SMALL_LABEL_LEN;
6502     }
6503
6504     memset(longcontext, 1, sizeof(longcontext));
6505
6506     if (!TEST_int_eq(SSL_export_keying_material(clientssl, ckeymat1,
6507                                                 sizeof(ckeymat1), label,
6508                                                 labellen, context,
6509                                                 sizeof(context) - 1, 1), 1)
6510             || !TEST_int_eq(SSL_export_keying_material(clientssl, ckeymat2,
6511                                                        sizeof(ckeymat2), label,
6512                                                        labellen,
6513                                                        emptycontext,
6514                                                        0, 1), 1)
6515             || !TEST_int_eq(SSL_export_keying_material(clientssl, ckeymat3,
6516                                                        sizeof(ckeymat3), label,
6517                                                        labellen,
6518                                                        NULL, 0, 0), 1)
6519             || (test_longcontext
6520                 && !TEST_int_eq(SSL_export_keying_material(clientssl,
6521                                                            ckeymat4,
6522                                                            sizeof(ckeymat4), label,
6523                                                            labellen,
6524                                                            longcontext,
6525                                                            sizeof(longcontext), 1),
6526                                 1))
6527             || !TEST_int_eq(SSL_export_keying_material(serverssl, skeymat1,
6528                                                        sizeof(skeymat1), label,
6529                                                        labellen,
6530                                                        context,
6531                                                        sizeof(context) -1, 1),
6532                             1)
6533             || !TEST_int_eq(SSL_export_keying_material(serverssl, skeymat2,
6534                                                        sizeof(skeymat2), label,
6535                                                        labellen,
6536                                                        emptycontext,
6537                                                        0, 1), 1)
6538             || !TEST_int_eq(SSL_export_keying_material(serverssl, skeymat3,
6539                                                        sizeof(skeymat3), label,
6540                                                        labellen,
6541                                                        NULL, 0, 0), 1)
6542             || (test_longcontext
6543                 && !TEST_int_eq(SSL_export_keying_material(serverssl, skeymat4,
6544                                                            sizeof(skeymat4), label,
6545                                                            labellen,
6546                                                            longcontext,
6547                                                            sizeof(longcontext), 1),
6548                                 1))
6549                /*
6550                 * Check that both sides created the same key material with the
6551                 * same context.
6552                 */
6553             || !TEST_mem_eq(ckeymat1, sizeof(ckeymat1), skeymat1,
6554                             sizeof(skeymat1))
6555                /*
6556                 * Check that both sides created the same key material with an
6557                 * empty context.
6558                 */
6559             || !TEST_mem_eq(ckeymat2, sizeof(ckeymat2), skeymat2,
6560                             sizeof(skeymat2))
6561                /*
6562                 * Check that both sides created the same key material without a
6563                 * context.
6564                 */
6565             || !TEST_mem_eq(ckeymat3, sizeof(ckeymat3), skeymat3,
6566                             sizeof(skeymat3))
6567                /*
6568                 * Check that both sides created the same key material with a
6569                 * long context.
6570                 */
6571             || (test_longcontext
6572                 && !TEST_mem_eq(ckeymat4, sizeof(ckeymat4), skeymat4,
6573                                 sizeof(skeymat4)))
6574                /* Different contexts should produce different results */
6575             || !TEST_mem_ne(ckeymat1, sizeof(ckeymat1), ckeymat2,
6576                             sizeof(ckeymat2)))
6577         goto end;
6578
6579     /*
6580      * Check that an empty context and no context produce different results in
6581      * protocols less than TLSv1.3. In TLSv1.3 they should be the same.
6582      */
6583     if ((tst < 3 && !TEST_mem_ne(ckeymat2, sizeof(ckeymat2), ckeymat3,
6584                                   sizeof(ckeymat3)))
6585             || (tst >= 3 && !TEST_mem_eq(ckeymat2, sizeof(ckeymat2), ckeymat3,
6586                                          sizeof(ckeymat3))))
6587         goto end;
6588
6589     testresult = 1;
6590
6591  end:
6592     SSL_free(serverssl);
6593     SSL_free(clientssl);
6594     SSL_CTX_free(sctx2);
6595     SSL_CTX_free(sctx);
6596     SSL_CTX_free(cctx);
6597
6598     return testresult;
6599 }
6600
6601 #ifndef OSSL_NO_USABLE_TLS1_3
6602 /*
6603  * Test that SSL_export_keying_material_early() produces expected
6604  * results. There are no test vectors so all we do is test that both
6605  * sides of the communication produce the same results for different
6606  * protocol versions.
6607  */
6608 static int test_export_key_mat_early(int idx)
6609 {
6610     static const char label[] = "test label";
6611     static const unsigned char context[] = "context";
6612     int testresult = 0;
6613     SSL_CTX *cctx = NULL, *sctx = NULL;
6614     SSL *clientssl = NULL, *serverssl = NULL;
6615     SSL_SESSION *sess = NULL;
6616     const unsigned char *emptycontext = NULL;
6617     unsigned char ckeymat1[80], ckeymat2[80];
6618     unsigned char skeymat1[80], skeymat2[80];
6619     unsigned char buf[1];
6620     size_t readbytes, written;
6621
6622     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl, &serverssl,
6623                                         &sess, idx, SHA384_DIGEST_LENGTH)))
6624         goto end;
6625
6626     /* Here writing 0 length early data is enough. */
6627     if (!TEST_true(SSL_write_early_data(clientssl, NULL, 0, &written))
6628             || !TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
6629                                                 &readbytes),
6630                             SSL_READ_EARLY_DATA_ERROR)
6631             || !TEST_int_eq(SSL_get_early_data_status(serverssl),
6632                             SSL_EARLY_DATA_ACCEPTED))
6633         goto end;
6634
6635     if (!TEST_int_eq(SSL_export_keying_material_early(
6636                      clientssl, ckeymat1, sizeof(ckeymat1), label,
6637                      sizeof(label) - 1, context, sizeof(context) - 1), 1)
6638             || !TEST_int_eq(SSL_export_keying_material_early(
6639                             clientssl, ckeymat2, sizeof(ckeymat2), label,
6640                             sizeof(label) - 1, emptycontext, 0), 1)
6641             || !TEST_int_eq(SSL_export_keying_material_early(
6642                             serverssl, skeymat1, sizeof(skeymat1), label,
6643                             sizeof(label) - 1, context, sizeof(context) - 1), 1)
6644             || !TEST_int_eq(SSL_export_keying_material_early(
6645                             serverssl, skeymat2, sizeof(skeymat2), label,
6646                             sizeof(label) - 1, emptycontext, 0), 1)
6647                /*
6648                 * Check that both sides created the same key material with the
6649                 * same context.
6650                 */
6651             || !TEST_mem_eq(ckeymat1, sizeof(ckeymat1), skeymat1,
6652                             sizeof(skeymat1))
6653                /*
6654                 * Check that both sides created the same key material with an
6655                 * empty context.
6656                 */
6657             || !TEST_mem_eq(ckeymat2, sizeof(ckeymat2), skeymat2,
6658                             sizeof(skeymat2))
6659                /* Different contexts should produce different results */
6660             || !TEST_mem_ne(ckeymat1, sizeof(ckeymat1), ckeymat2,
6661                             sizeof(ckeymat2)))
6662         goto end;
6663
6664     testresult = 1;
6665
6666  end:
6667     SSL_SESSION_free(sess);
6668     SSL_SESSION_free(clientpsk);
6669     SSL_SESSION_free(serverpsk);
6670     clientpsk = serverpsk = NULL;
6671     SSL_free(serverssl);
6672     SSL_free(clientssl);
6673     SSL_CTX_free(sctx);
6674     SSL_CTX_free(cctx);
6675
6676     return testresult;
6677 }
6678
6679 #define NUM_KEY_UPDATE_MESSAGES 40
6680 /*
6681  * Test KeyUpdate.
6682  */
6683 static int test_key_update(void)
6684 {
6685     SSL_CTX *cctx = NULL, *sctx = NULL;
6686     SSL *clientssl = NULL, *serverssl = NULL;
6687     int testresult = 0, i, j;
6688     char buf[20];
6689     static char *mess = "A test message";
6690
6691     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
6692                                        TLS_client_method(),
6693                                        TLS1_3_VERSION,
6694                                        0,
6695                                        &sctx, &cctx, cert, privkey))
6696             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
6697                                              NULL, NULL))
6698             || !TEST_true(create_ssl_connection(serverssl, clientssl,
6699                                                 SSL_ERROR_NONE)))
6700         goto end;
6701
6702     for (j = 0; j < 2; j++) {
6703         /* Send lots of KeyUpdate messages */
6704         for (i = 0; i < NUM_KEY_UPDATE_MESSAGES; i++) {
6705             if (!TEST_true(SSL_key_update(clientssl,
6706                                           (j == 0)
6707                                           ? SSL_KEY_UPDATE_NOT_REQUESTED
6708                                           : SSL_KEY_UPDATE_REQUESTED))
6709                     || !TEST_true(SSL_do_handshake(clientssl)))
6710                 goto end;
6711         }
6712
6713         /* Check that sending and receiving app data is ok */
6714         if (!TEST_int_eq(SSL_write(clientssl, mess, strlen(mess)), strlen(mess))
6715                 || !TEST_int_eq(SSL_read(serverssl, buf, sizeof(buf)),
6716                                          strlen(mess)))
6717             goto end;
6718
6719         if (!TEST_int_eq(SSL_write(serverssl, mess, strlen(mess)), strlen(mess))
6720                 || !TEST_int_eq(SSL_read(clientssl, buf, sizeof(buf)),
6721                                          strlen(mess)))
6722             goto end;
6723     }
6724
6725     testresult = 1;
6726
6727  end:
6728     SSL_free(serverssl);
6729     SSL_free(clientssl);
6730     SSL_CTX_free(sctx);
6731     SSL_CTX_free(cctx);
6732
6733     return testresult;
6734 }
6735
6736 /*
6737  * Test we can handle a KeyUpdate (update requested) message while
6738  * write data is pending in peer.
6739  * Test 0: Client sends KeyUpdate while Server is writing
6740  * Test 1: Server sends KeyUpdate while Client is writing
6741  */
6742 static int test_key_update_peer_in_write(int tst)
6743 {
6744     SSL_CTX *cctx = NULL, *sctx = NULL;
6745     SSL *clientssl = NULL, *serverssl = NULL;
6746     int testresult = 0;
6747     char buf[20];
6748     static char *mess = "A test message";
6749     BIO *bretry = BIO_new(bio_s_always_retry());
6750     BIO *tmp = NULL;
6751     SSL *peerupdate = NULL, *peerwrite = NULL;
6752
6753     if (!TEST_ptr(bretry)
6754             || !TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
6755                                               TLS_client_method(),
6756                                               TLS1_3_VERSION,
6757                                               0,
6758                                               &sctx, &cctx, cert, privkey))
6759             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
6760                                              NULL, NULL))
6761             || !TEST_true(create_ssl_connection(serverssl, clientssl,
6762                                                 SSL_ERROR_NONE)))
6763         goto end;
6764
6765     peerupdate = tst == 0 ? clientssl : serverssl;
6766     peerwrite = tst == 0 ? serverssl : clientssl;
6767
6768     if (!TEST_true(SSL_key_update(peerupdate, SSL_KEY_UPDATE_REQUESTED))
6769             || !TEST_int_eq(SSL_do_handshake(peerupdate), 1))
6770         goto end;
6771
6772     /* Swap the writing endpoint's write BIO to force a retry */
6773     tmp = SSL_get_wbio(peerwrite);
6774     if (!TEST_ptr(tmp) || !TEST_true(BIO_up_ref(tmp))) {
6775         tmp = NULL;
6776         goto end;
6777     }
6778     SSL_set0_wbio(peerwrite, bretry);
6779     bretry = NULL;
6780
6781     /* Write data that we know will fail with SSL_ERROR_WANT_WRITE */
6782     if (!TEST_int_eq(SSL_write(peerwrite, mess, strlen(mess)), -1)
6783             || !TEST_int_eq(SSL_get_error(peerwrite, 0), SSL_ERROR_WANT_WRITE)
6784             || !TEST_true(SSL_want_write(peerwrite))
6785             || !TEST_true(SSL_net_write_desired(peerwrite)))
6786         goto end;
6787
6788     /* Reinstate the original writing endpoint's write BIO */
6789     SSL_set0_wbio(peerwrite, tmp);
6790     tmp = NULL;
6791
6792     /* Now read some data - we will read the key update */
6793     if (!TEST_int_eq(SSL_read(peerwrite, buf, sizeof(buf)), -1)
6794             || !TEST_int_eq(SSL_get_error(peerwrite, 0), SSL_ERROR_WANT_READ)
6795             || !TEST_true(SSL_want_read(peerwrite))
6796             || !TEST_true(SSL_net_read_desired(peerwrite)))
6797         goto end;
6798
6799     /*
6800      * Complete the write we started previously and read it from the other
6801      * endpoint
6802      */
6803     if (!TEST_int_eq(SSL_write(peerwrite, mess, strlen(mess)), strlen(mess))
6804             || !TEST_int_eq(SSL_read(peerupdate, buf, sizeof(buf)), strlen(mess)))
6805         goto end;
6806
6807     /* Write more data to ensure we send the KeyUpdate message back */
6808     if (!TEST_int_eq(SSL_write(peerwrite, mess, strlen(mess)), strlen(mess))
6809             || !TEST_int_eq(SSL_read(peerupdate, buf, sizeof(buf)), strlen(mess)))
6810         goto end;
6811
6812     if (!TEST_false(SSL_net_read_desired(peerwrite))
6813         || !TEST_false(SSL_net_write_desired(peerwrite))
6814         || !TEST_int_eq(SSL_want(peerwrite), SSL_NOTHING))
6815         goto end;
6816
6817     testresult = 1;
6818
6819  end:
6820     SSL_free(serverssl);
6821     SSL_free(clientssl);
6822     SSL_CTX_free(sctx);
6823     SSL_CTX_free(cctx);
6824     BIO_free(bretry);
6825     BIO_free(tmp);
6826
6827     return testresult;
6828 }
6829
6830 /*
6831  * Test we can handle a KeyUpdate (update requested) message while
6832  * peer read data is pending after peer accepted keyupdate(the msg header
6833  * had been read 5 bytes).
6834  * Test 0: Client sends KeyUpdate while Server is reading
6835  * Test 1: Server sends KeyUpdate while Client is reading
6836  */
6837 static int test_key_update_peer_in_read(int tst)
6838 {
6839     SSL_CTX *cctx = NULL, *sctx = NULL;
6840     SSL *clientssl = NULL, *serverssl = NULL;
6841     int testresult = 0;
6842     char prbuf[515], lwbuf[515] = {0};
6843     static char *mess = "A test message";
6844     BIO *lbio = NULL, *pbio = NULL;
6845     SSL *local = NULL, *peer = NULL;
6846
6847     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
6848                                               TLS_client_method(),
6849                                               TLS1_3_VERSION,
6850                                               0,
6851                                               &sctx, &cctx, cert, privkey))
6852             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
6853                                              NULL, NULL))
6854             || !TEST_true(create_ssl_connection(serverssl, clientssl,
6855                                                 SSL_ERROR_NONE)))
6856         goto end;
6857
6858     local = tst == 0 ? clientssl : serverssl;
6859     peer = tst == 0 ? serverssl : clientssl;
6860
6861     if (!TEST_int_eq(BIO_new_bio_pair(&lbio, 512, &pbio, 512), 1))
6862         goto end;
6863
6864     SSL_set_bio(local, lbio, lbio);
6865     SSL_set_bio(peer, pbio, pbio);
6866
6867     /*
6868      * we first write keyupdate msg then appdata in local
6869      * write data in local will fail with SSL_ERROR_WANT_WRITE,because
6870      * lwbuf app data msg size + key updata msg size > 512(the size of
6871      * the bio pair buffer)
6872      */
6873     if (!TEST_true(SSL_key_update(local, SSL_KEY_UPDATE_REQUESTED))
6874             || !TEST_int_eq(SSL_write(local, lwbuf, sizeof(lwbuf)), -1)
6875             || !TEST_int_eq(SSL_get_error(local, -1), SSL_ERROR_WANT_WRITE))
6876         goto end;
6877
6878     /*
6879      * first read keyupdate msg in peer in peer
6880      * then read appdata that we know will fail with SSL_ERROR_WANT_READ
6881      */
6882     if (!TEST_int_eq(SSL_read(peer, prbuf, sizeof(prbuf)), -1)
6883             || !TEST_int_eq(SSL_get_error(peer, -1), SSL_ERROR_WANT_READ))
6884         goto end;
6885
6886     /* Now write some data in peer - we will write the key update */
6887     if (!TEST_int_eq(SSL_write(peer, mess, strlen(mess)), strlen(mess)))
6888         goto end;
6889
6890     /*
6891      * write data in local previously that we will complete
6892      * read data in peer previously that we will complete
6893      */
6894     if (!TEST_int_eq(SSL_write(local, lwbuf, sizeof(lwbuf)), sizeof(lwbuf))
6895             || !TEST_int_eq(SSL_read(peer, prbuf, sizeof(prbuf)), sizeof(prbuf)))
6896         goto end;
6897
6898     /* check that sending and receiving appdata ok */
6899     if (!TEST_int_eq(SSL_write(local, mess, strlen(mess)), strlen(mess))
6900             || !TEST_int_eq(SSL_read(peer, prbuf, sizeof(prbuf)), strlen(mess)))
6901         goto end;
6902
6903     testresult = 1;
6904
6905  end:
6906     SSL_free(serverssl);
6907     SSL_free(clientssl);
6908     SSL_CTX_free(sctx);
6909     SSL_CTX_free(cctx);
6910
6911     return testresult;
6912 }
6913
6914 /*
6915  * Test we can't send a KeyUpdate (update requested) message while
6916  * local write data is pending.
6917  * Test 0: Client sends KeyUpdate while Client is writing
6918  * Test 1: Server sends KeyUpdate while Server is writing
6919  */
6920 static int test_key_update_local_in_write(int tst)
6921 {
6922     SSL_CTX *cctx = NULL, *sctx = NULL;
6923     SSL *clientssl = NULL, *serverssl = NULL;
6924     int testresult = 0;
6925     char buf[20];
6926     static char *mess = "A test message";
6927     BIO *bretry = BIO_new(bio_s_always_retry());
6928     BIO *tmp = NULL;
6929     SSL *local = NULL, *peer = NULL;
6930
6931     if (!TEST_ptr(bretry)
6932             || !TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
6933                                               TLS_client_method(),
6934                                               TLS1_3_VERSION,
6935                                               0,
6936                                               &sctx, &cctx, cert, privkey))
6937             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
6938                                              NULL, NULL))
6939             || !TEST_true(create_ssl_connection(serverssl, clientssl,
6940                                                 SSL_ERROR_NONE)))
6941         goto end;
6942
6943     local = tst == 0 ? clientssl : serverssl;
6944     peer = tst == 0 ? serverssl : clientssl;
6945
6946     /* Swap the writing endpoint's write BIO to force a retry */
6947     tmp = SSL_get_wbio(local);
6948     if (!TEST_ptr(tmp) || !TEST_true(BIO_up_ref(tmp))) {
6949         tmp = NULL;
6950         goto end;
6951     }
6952     SSL_set0_wbio(local, bretry);
6953     bretry = NULL;
6954
6955     /* write data in local will fail with SSL_ERROR_WANT_WRITE */
6956     if (!TEST_int_eq(SSL_write(local, mess, strlen(mess)), -1)
6957             || !TEST_int_eq(SSL_get_error(local, -1), SSL_ERROR_WANT_WRITE))
6958         goto end;
6959
6960     /* Reinstate the original writing endpoint's write BIO */
6961     SSL_set0_wbio(local, tmp);
6962     tmp = NULL;
6963
6964     /* SSL_key_update will fail, because writing in local*/
6965     if (!TEST_false(SSL_key_update(local, SSL_KEY_UPDATE_REQUESTED))
6966         || !TEST_int_eq(ERR_GET_REASON(ERR_peek_error()), SSL_R_BAD_WRITE_RETRY))
6967     goto end;
6968
6969     ERR_clear_error();
6970     /* write data in local previously that we will complete */
6971     if (!TEST_int_eq(SSL_write(local, mess, strlen(mess)), strlen(mess)))
6972         goto end;
6973
6974     /* SSL_key_update will succeed because there is no pending write data */
6975     if (!TEST_true(SSL_key_update(local, SSL_KEY_UPDATE_REQUESTED))
6976         || !TEST_int_eq(SSL_do_handshake(local), 1))
6977         goto end;
6978
6979     /*
6980      * we write some appdata in local
6981      * read data in peer - we will read the keyupdate msg
6982      */
6983     if (!TEST_int_eq(SSL_write(local, mess, strlen(mess)), strlen(mess))
6984         || !TEST_int_eq(SSL_read(peer, buf, sizeof(buf)), strlen(mess)))
6985         goto end;
6986
6987     /* Write more peer more data to ensure we send the keyupdate message back */
6988     if (!TEST_int_eq(SSL_write(peer, mess, strlen(mess)), strlen(mess))
6989             || !TEST_int_eq(SSL_read(local, buf, sizeof(buf)), strlen(mess)))
6990         goto end;
6991
6992     testresult = 1;
6993
6994  end:
6995     SSL_free(serverssl);
6996     SSL_free(clientssl);
6997     SSL_CTX_free(sctx);
6998     SSL_CTX_free(cctx);
6999     BIO_free(bretry);
7000     BIO_free(tmp);
7001
7002     return testresult;
7003 }
7004
7005 /*
7006  * Test we can handle a KeyUpdate (update requested) message while
7007  * local read data is pending(the msg header had been read 5 bytes).
7008  * Test 0: Client sends KeyUpdate while Client is reading
7009  * Test 1: Server sends KeyUpdate while Server is reading
7010  */
7011 static int test_key_update_local_in_read(int tst)
7012 {
7013     SSL_CTX *cctx = NULL, *sctx = NULL;
7014     SSL *clientssl = NULL, *serverssl = NULL;
7015     int testresult = 0;
7016     char lrbuf[515], pwbuf[515] = {0}, prbuf[20];
7017     static char *mess = "A test message";
7018     BIO *lbio = NULL, *pbio = NULL;
7019     SSL *local = NULL, *peer = NULL;
7020
7021     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
7022                                               TLS_client_method(),
7023                                               TLS1_3_VERSION,
7024                                               0,
7025                                               &sctx, &cctx, cert, privkey))
7026             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
7027                                              NULL, NULL))
7028             || !TEST_true(create_ssl_connection(serverssl, clientssl,
7029                                                 SSL_ERROR_NONE)))
7030         goto end;
7031
7032     local = tst == 0 ? clientssl : serverssl;
7033     peer = tst == 0 ? serverssl : clientssl;
7034
7035     if (!TEST_int_eq(BIO_new_bio_pair(&lbio, 512, &pbio, 512), 1))
7036         goto end;
7037
7038     SSL_set_bio(local, lbio, lbio);
7039     SSL_set_bio(peer, pbio, pbio);
7040
7041     /* write app data in peer will fail with SSL_ERROR_WANT_WRITE */
7042     if (!TEST_int_eq(SSL_write(peer, pwbuf, sizeof(pwbuf)), -1)
7043         || !TEST_int_eq(SSL_get_error(peer, -1), SSL_ERROR_WANT_WRITE))
7044         goto end;
7045
7046     /* read appdata in local will fail with SSL_ERROR_WANT_READ */
7047     if (!TEST_int_eq(SSL_read(local, lrbuf, sizeof(lrbuf)), -1)
7048             || !TEST_int_eq(SSL_get_error(local, -1), SSL_ERROR_WANT_READ))
7049         goto end;
7050
7051     /* SSL_do_handshake will send keyupdate msg */
7052     if (!TEST_true(SSL_key_update(local, SSL_KEY_UPDATE_REQUESTED))
7053             || !TEST_int_eq(SSL_do_handshake(local), 1))
7054         goto end;
7055
7056     /*
7057      * write data in peer previously that we will complete
7058      * read data in local previously that we will complete
7059      */
7060     if (!TEST_int_eq(SSL_write(peer, pwbuf, sizeof(pwbuf)), sizeof(pwbuf))
7061         || !TEST_int_eq(SSL_read(local, lrbuf, sizeof(lrbuf)), sizeof(lrbuf)))
7062         goto end;
7063
7064     /*
7065      * write data in local
7066      * read data in peer - we will read the key update
7067      */
7068     if (!TEST_int_eq(SSL_write(local, mess, strlen(mess)), strlen(mess))
7069         || !TEST_int_eq(SSL_read(peer, prbuf, sizeof(prbuf)), strlen(mess)))
7070         goto end;
7071
7072   /* Write more peer data to ensure we send the keyupdate message back */
7073     if (!TEST_int_eq(SSL_write(peer, mess, strlen(mess)), strlen(mess))
7074             || !TEST_int_eq(SSL_read(local, lrbuf, sizeof(lrbuf)), strlen(mess)))
7075         goto end;
7076
7077     testresult = 1;
7078
7079  end:
7080     SSL_free(serverssl);
7081     SSL_free(clientssl);
7082     SSL_CTX_free(sctx);
7083     SSL_CTX_free(cctx);
7084
7085     return testresult;
7086 }
7087 #endif /* OSSL_NO_USABLE_TLS1_3 */
7088
7089 /*
7090  * Test clearing a connection via SSL_clear(), or resetting it via
7091  * SSL_set_connect_state()/SSL_set_accept_state()
7092  * Test 0: SSL_set_connect_state, TLSv1.3
7093  * Test 1: SSL_set_connect_state, TLSv1.2
7094  * Test 2: SSL_set_accept_state, TLSv1.3
7095  * Test 3: SSL_set_accept_state, TLSv1.2
7096  * Test 4: SSL_clear (client), TLSv1.3
7097  * Test 5: SSL_clear (client), TLSv1.2
7098  * Test 6: SSL_clear (server), TLSv1.3
7099  * Test 7: SSL_clear (server), TLSv1.2
7100  */
7101 static int test_ssl_clear(int idx)
7102 {
7103     SSL_CTX *cctx = NULL, *sctx = NULL;
7104     SSL *clientssl = NULL, *serverssl = NULL;
7105     SSL *writer, *reader;
7106     int testresult = 0;
7107     int tls12test, servertest, cleartest;
7108     size_t written, readbytes;
7109     const char *msg = "Hello World";
7110     unsigned char buf[5];
7111
7112     tls12test = idx & 1;
7113     idx >>= 1;
7114     servertest = idx & 1;
7115     idx >>= 1;
7116     cleartest = idx & 1;
7117
7118 #ifdef OPENSSL_NO_TLS1_2
7119     if (tls12test == 1)
7120         return TEST_skip("No TLSv1.2 in this build");
7121 #endif
7122
7123     /* Create an initial connection */
7124     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
7125                                        TLS_client_method(), TLS1_VERSION, 0,
7126                                        &sctx, &cctx, cert, privkey))
7127             || (tls12test
7128                 && !TEST_true(SSL_CTX_set_max_proto_version(cctx,
7129                                                             TLS1_2_VERSION)))
7130             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
7131                                           &clientssl, NULL, NULL))
7132             || !TEST_true(create_ssl_connection(serverssl, clientssl,
7133                                                 SSL_ERROR_NONE)))
7134         goto end;
7135
7136     if (servertest) {
7137         writer = clientssl;
7138         reader = serverssl;
7139     } else {
7140         writer = serverssl;
7141         reader = clientssl;
7142     }
7143
7144     /* Write some data */
7145     if (!TEST_true(SSL_write_ex(writer, msg, strlen(msg), &written))
7146             || written != strlen(msg))
7147         goto end;
7148
7149     /*
7150      * Read a partial record. The remaining buffered data should be cleared by
7151      * the subsequent clear/reset
7152      */
7153     if (!TEST_true(SSL_read_ex(reader, buf, sizeof(buf), &readbytes))
7154             || readbytes != sizeof(buf))
7155         goto end;
7156
7157     SSL_shutdown(clientssl);
7158     SSL_shutdown(serverssl);
7159
7160     /* Reset/clear one SSL object in order to reuse it. We free the other one */
7161     if (servertest) {
7162         if (cleartest) {
7163             if (!TEST_true(SSL_clear(serverssl)))
7164                 goto end;
7165         } else {
7166             SSL_set_accept_state(serverssl);
7167         }
7168         /*
7169          * A peculiarity of SSL_clear() is that it does not clear the session.
7170          * This is intended behaviour so that a client can create a new
7171          * connection and reuse the session. But this doesn't make much sense
7172          * on the server side - and causes incorrect behaviour due to the
7173          * handshake failing (even though the documentation does say SSL_clear()
7174          * is supposed to work on the server side). We clear the session
7175          * explicitly - although note that the documentation for
7176          * SSL_set_session() says that its only useful for clients!
7177          */
7178         if (!TEST_true(SSL_set_session(serverssl, NULL)))
7179             goto end;
7180         SSL_free(clientssl);
7181         clientssl = NULL;
7182     } else {
7183         if (cleartest) {
7184             if (!TEST_true(SSL_clear(clientssl)))
7185                 goto end;
7186         } else {
7187             SSL_set_connect_state(clientssl);
7188         }
7189         SSL_free(serverssl);
7190         serverssl = NULL;
7191     }
7192
7193     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
7194                                              NULL, NULL))
7195             || !TEST_true(create_ssl_connection(serverssl, clientssl,
7196                                                 SSL_ERROR_NONE))
7197             || !TEST_true(servertest || SSL_session_reused(clientssl)))
7198         goto end;
7199
7200     SSL_shutdown(clientssl);
7201     SSL_shutdown(serverssl);
7202
7203     testresult = 1;
7204
7205  end:
7206     SSL_free(serverssl);
7207     SSL_free(clientssl);
7208     SSL_CTX_free(sctx);
7209     SSL_CTX_free(cctx);
7210
7211     return testresult;
7212 }
7213
7214 /* Parse CH and retrieve any MFL extension value if present */
7215 static int get_MFL_from_client_hello(BIO *bio, int *mfl_codemfl_code)
7216 {
7217     long len;
7218     unsigned char *data;
7219     PACKET pkt, pkt2, pkt3;
7220     unsigned int MFL_code = 0, type = 0;
7221
7222     if (!TEST_uint_gt(len = BIO_get_mem_data(bio, (char **) &data), 0))
7223         goto end;
7224
7225     memset(&pkt, 0, sizeof(pkt));
7226     memset(&pkt2, 0, sizeof(pkt2));
7227     memset(&pkt3, 0, sizeof(pkt3));
7228
7229     if (!TEST_long_gt(len, 0)
7230             || !TEST_true(PACKET_buf_init(&pkt, data, len))
7231                /* Skip the record header */
7232             || !PACKET_forward(&pkt, SSL3_RT_HEADER_LENGTH)
7233                /* Skip the handshake message header */
7234             || !TEST_true(PACKET_forward(&pkt, SSL3_HM_HEADER_LENGTH))
7235                /* Skip client version and random */
7236             || !TEST_true(PACKET_forward(&pkt, CLIENT_VERSION_LEN
7237                                                + SSL3_RANDOM_SIZE))
7238                /* Skip session id */
7239             || !TEST_true(PACKET_get_length_prefixed_1(&pkt, &pkt2))
7240                /* Skip ciphers */
7241             || !TEST_true(PACKET_get_length_prefixed_2(&pkt, &pkt2))
7242                /* Skip compression */
7243             || !TEST_true(PACKET_get_length_prefixed_1(&pkt, &pkt2))
7244                /* Extensions len */
7245             || !TEST_true(PACKET_as_length_prefixed_2(&pkt, &pkt2)))
7246         goto end;
7247
7248     /* Loop through all extensions */
7249     while (PACKET_remaining(&pkt2)) {
7250         if (!TEST_true(PACKET_get_net_2(&pkt2, &type))
7251                 || !TEST_true(PACKET_get_length_prefixed_2(&pkt2, &pkt3)))
7252             goto end;
7253
7254         if (type == TLSEXT_TYPE_max_fragment_length) {
7255             if (!TEST_uint_ne(PACKET_remaining(&pkt3), 0)
7256                     || !TEST_true(PACKET_get_1(&pkt3, &MFL_code)))
7257                 goto end;
7258
7259             *mfl_codemfl_code = MFL_code;
7260             return 1;
7261         }
7262     }
7263
7264  end:
7265     return 0;
7266 }
7267
7268 /* Maximum-Fragment-Length TLS extension mode to test */
7269 static const unsigned char max_fragment_len_test[] = {
7270     TLSEXT_max_fragment_length_512,
7271     TLSEXT_max_fragment_length_1024,
7272     TLSEXT_max_fragment_length_2048,
7273     TLSEXT_max_fragment_length_4096
7274 };
7275
7276 static int test_max_fragment_len_ext(int idx_tst)
7277 {
7278     SSL_CTX *ctx = NULL;
7279     SSL *con = NULL;
7280     int testresult = 0, MFL_mode = 0;
7281     BIO *rbio, *wbio;
7282
7283     if (!TEST_true(create_ssl_ctx_pair(libctx, NULL, TLS_client_method(),
7284                                        TLS1_VERSION, 0, NULL, &ctx, NULL,
7285                                        NULL)))
7286         return 0;
7287
7288     if (!TEST_true(SSL_CTX_set_tlsext_max_fragment_length(
7289                    ctx, max_fragment_len_test[idx_tst])))
7290         goto end;
7291
7292     con = SSL_new(ctx);
7293     if (!TEST_ptr(con))
7294         goto end;
7295
7296     rbio = BIO_new(BIO_s_mem());
7297     wbio = BIO_new(BIO_s_mem());
7298     if (!TEST_ptr(rbio)|| !TEST_ptr(wbio)) {
7299         BIO_free(rbio);
7300         BIO_free(wbio);
7301         goto end;
7302     }
7303
7304     SSL_set_bio(con, rbio, wbio);
7305
7306     if (!TEST_int_le(SSL_connect(con), 0)) {
7307         /* This shouldn't succeed because we don't have a server! */
7308         goto end;
7309     }
7310
7311     if (!TEST_true(get_MFL_from_client_hello(wbio, &MFL_mode)))
7312         /* no MFL in client hello */
7313         goto end;
7314     if (!TEST_true(max_fragment_len_test[idx_tst] == MFL_mode))
7315         goto end;
7316
7317     testresult = 1;
7318
7319 end:
7320     SSL_free(con);
7321     SSL_CTX_free(ctx);
7322
7323     return testresult;
7324 }
7325
7326 #ifndef OSSL_NO_USABLE_TLS1_3
7327 static int test_pha_key_update(void)
7328 {
7329     SSL_CTX *cctx = NULL, *sctx = NULL;
7330     SSL *clientssl = NULL, *serverssl = NULL;
7331     int testresult = 0;
7332
7333     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
7334                                        TLS_client_method(), TLS1_VERSION, 0,
7335                                        &sctx, &cctx, cert, privkey)))
7336         return 0;
7337
7338     if (!TEST_true(SSL_CTX_set_min_proto_version(sctx, TLS1_3_VERSION))
7339         || !TEST_true(SSL_CTX_set_max_proto_version(sctx, TLS1_3_VERSION))
7340         || !TEST_true(SSL_CTX_set_min_proto_version(cctx, TLS1_3_VERSION))
7341         || !TEST_true(SSL_CTX_set_max_proto_version(cctx, TLS1_3_VERSION)))
7342         goto end;
7343
7344     SSL_CTX_set_post_handshake_auth(cctx, 1);
7345
7346     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
7347                                       NULL, NULL)))
7348         goto end;
7349
7350     if (!TEST_true(create_ssl_connection(serverssl, clientssl,
7351                                          SSL_ERROR_NONE)))
7352         goto end;
7353
7354     SSL_set_verify(serverssl, SSL_VERIFY_PEER, NULL);
7355     if (!TEST_true(SSL_verify_client_post_handshake(serverssl)))
7356         goto end;
7357
7358     if (!TEST_true(SSL_key_update(clientssl, SSL_KEY_UPDATE_NOT_REQUESTED)))
7359         goto end;
7360
7361     /* Start handshake on the server */
7362     if (!TEST_int_eq(SSL_do_handshake(serverssl), 1))
7363         goto end;
7364
7365     /* Starts with SSL_connect(), but it's really just SSL_do_handshake() */
7366     if (!TEST_true(create_ssl_connection(serverssl, clientssl,
7367                                          SSL_ERROR_NONE)))
7368         goto end;
7369
7370     SSL_shutdown(clientssl);
7371     SSL_shutdown(serverssl);
7372
7373     testresult = 1;
7374
7375  end:
7376     SSL_free(serverssl);
7377     SSL_free(clientssl);
7378     SSL_CTX_free(sctx);
7379     SSL_CTX_free(cctx);
7380     return testresult;
7381 }
7382 #endif
7383
7384 #if !defined(OPENSSL_NO_SRP) && !defined(OPENSSL_NO_TLS1_2)
7385
7386 static SRP_VBASE *vbase = NULL;
7387
7388 static int ssl_srp_cb(SSL *s, int *ad, void *arg)
7389 {
7390     int ret = SSL3_AL_FATAL;
7391     char *username;
7392     SRP_user_pwd *user = NULL;
7393
7394     username = SSL_get_srp_username(s);
7395     if (username == NULL) {
7396         *ad = SSL_AD_INTERNAL_ERROR;
7397         goto err;
7398     }
7399
7400     user = SRP_VBASE_get1_by_user(vbase, username);
7401     if (user == NULL) {
7402         *ad = SSL_AD_INTERNAL_ERROR;
7403         goto err;
7404     }
7405
7406     if (SSL_set_srp_server_param(s, user->N, user->g, user->s, user->v,
7407                                  user->info) <= 0) {
7408         *ad = SSL_AD_INTERNAL_ERROR;
7409         goto err;
7410     }
7411
7412     ret = 0;
7413
7414  err:
7415     SRP_user_pwd_free(user);
7416     return ret;
7417 }
7418
7419 static int create_new_vfile(char *userid, char *password, const char *filename)
7420 {
7421     char *gNid = NULL;
7422     OPENSSL_STRING *row = OPENSSL_zalloc(sizeof(row) * (DB_NUMBER + 1));
7423     TXT_DB *db = NULL;
7424     int ret = 0;
7425     BIO *out = NULL, *dummy = BIO_new_mem_buf("", 0);
7426     size_t i;
7427
7428     if (!TEST_ptr(dummy) || !TEST_ptr(row))
7429         goto end;
7430
7431     gNid = SRP_create_verifier_ex(userid, password, &row[DB_srpsalt],
7432                                   &row[DB_srpverifier], NULL, NULL, libctx, NULL);
7433     if (!TEST_ptr(gNid))
7434         goto end;
7435
7436     /*
7437      * The only way to create an empty TXT_DB is to provide a BIO with no data
7438      * in it!
7439      */
7440     db = TXT_DB_read(dummy, DB_NUMBER);
7441     if (!TEST_ptr(db))
7442         goto end;
7443
7444     out = BIO_new_file(filename, "w");
7445     if (!TEST_ptr(out))
7446         goto end;
7447
7448     row[DB_srpid] = OPENSSL_strdup(userid);
7449     row[DB_srptype] = OPENSSL_strdup("V");
7450     row[DB_srpgN] = OPENSSL_strdup(gNid);
7451
7452     if (!TEST_ptr(row[DB_srpid])
7453             || !TEST_ptr(row[DB_srptype])
7454             || !TEST_ptr(row[DB_srpgN])
7455             || !TEST_true(TXT_DB_insert(db, row)))
7456         goto end;
7457
7458     row = NULL;
7459
7460     if (TXT_DB_write(out, db) <= 0)
7461         goto end;
7462
7463     ret = 1;
7464  end:
7465     if (row != NULL) {
7466         for (i = 0; i < DB_NUMBER; i++)
7467             OPENSSL_free(row[i]);
7468     }
7469     OPENSSL_free(row);
7470     BIO_free(dummy);
7471     BIO_free(out);
7472     TXT_DB_free(db);
7473
7474     return ret;
7475 }
7476
7477 static int create_new_vbase(char *userid, char *password)
7478 {
7479     BIGNUM *verifier = NULL, *salt = NULL;
7480     const SRP_gN *lgN = NULL;
7481     SRP_user_pwd *user_pwd = NULL;
7482     int ret = 0;
7483
7484     lgN = SRP_get_default_gN(NULL);
7485     if (!TEST_ptr(lgN))
7486         goto end;
7487
7488     if (!TEST_true(SRP_create_verifier_BN_ex(userid, password, &salt, &verifier,
7489                                              lgN->N, lgN->g, libctx, NULL)))
7490         goto end;
7491
7492     user_pwd = OPENSSL_zalloc(sizeof(*user_pwd));
7493     if (!TEST_ptr(user_pwd))
7494         goto end;
7495
7496     user_pwd->N = lgN->N;
7497     user_pwd->g = lgN->g;
7498     user_pwd->id = OPENSSL_strdup(userid);
7499     if (!TEST_ptr(user_pwd->id))
7500         goto end;
7501
7502     user_pwd->v = verifier;
7503     user_pwd->s = salt;
7504     verifier = salt = NULL;
7505
7506     if (sk_SRP_user_pwd_insert(vbase->users_pwd, user_pwd, 0) == 0)
7507         goto end;
7508     user_pwd = NULL;
7509
7510     ret = 1;
7511 end:
7512     SRP_user_pwd_free(user_pwd);
7513     BN_free(salt);
7514     BN_free(verifier);
7515
7516     return ret;
7517 }
7518
7519 /*
7520  * SRP tests
7521  *
7522  * Test 0: Simple successful SRP connection, new vbase
7523  * Test 1: Connection failure due to bad password, new vbase
7524  * Test 2: Simple successful SRP connection, vbase loaded from existing file
7525  * Test 3: Connection failure due to bad password, vbase loaded from existing
7526  *         file
7527  * Test 4: Simple successful SRP connection, vbase loaded from new file
7528  * Test 5: Connection failure due to bad password, vbase loaded from new file
7529  */
7530 static int test_srp(int tst)
7531 {
7532     char *userid = "test", *password = "password", *tstsrpfile;
7533     SSL_CTX *cctx = NULL, *sctx = NULL;
7534     SSL *clientssl = NULL, *serverssl = NULL;
7535     int ret, testresult = 0;
7536
7537     vbase = SRP_VBASE_new(NULL);
7538     if (!TEST_ptr(vbase))
7539         goto end;
7540
7541     if (tst == 0 || tst == 1) {
7542         if (!TEST_true(create_new_vbase(userid, password)))
7543             goto end;
7544     } else {
7545         if (tst == 4 || tst == 5) {
7546             if (!TEST_true(create_new_vfile(userid, password, tmpfilename)))
7547                 goto end;
7548             tstsrpfile = tmpfilename;
7549         } else {
7550             tstsrpfile = srpvfile;
7551         }
7552         if (!TEST_int_eq(SRP_VBASE_init(vbase, tstsrpfile), SRP_NO_ERROR))
7553             goto end;
7554     }
7555
7556     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
7557                                        TLS_client_method(), TLS1_VERSION, 0,
7558                                        &sctx, &cctx, cert, privkey)))
7559         goto end;
7560
7561     if (!TEST_int_gt(SSL_CTX_set_srp_username_callback(sctx, ssl_srp_cb), 0)
7562             || !TEST_true(SSL_CTX_set_cipher_list(cctx, "SRP-AES-128-CBC-SHA"))
7563             || !TEST_true(SSL_CTX_set_max_proto_version(sctx, TLS1_2_VERSION))
7564             || !TEST_true(SSL_CTX_set_max_proto_version(cctx, TLS1_2_VERSION))
7565             || !TEST_int_gt(SSL_CTX_set_srp_username(cctx, userid), 0))
7566         goto end;
7567
7568     if (tst % 2 == 1) {
7569         if (!TEST_int_gt(SSL_CTX_set_srp_password(cctx, "badpass"), 0))
7570             goto end;
7571     } else {
7572         if (!TEST_int_gt(SSL_CTX_set_srp_password(cctx, password), 0))
7573             goto end;
7574     }
7575
7576     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
7577                                       NULL, NULL)))
7578         goto end;
7579
7580     ret = create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE);
7581     if (ret) {
7582         if (!TEST_true(tst % 2 == 0))
7583             goto end;
7584     } else {
7585         if (!TEST_true(tst % 2 == 1))
7586             goto end;
7587     }
7588
7589     testresult = 1;
7590
7591  end:
7592     SRP_VBASE_free(vbase);
7593     vbase = NULL;
7594     SSL_free(serverssl);
7595     SSL_free(clientssl);
7596     SSL_CTX_free(sctx);
7597     SSL_CTX_free(cctx);
7598
7599     return testresult;
7600 }
7601 #endif
7602
7603 static int info_cb_failed = 0;
7604 static int info_cb_offset = 0;
7605 static int info_cb_this_state = -1;
7606
7607 static struct info_cb_states_st {
7608     int where;
7609     const char *statestr;
7610 } info_cb_states[][60] = {
7611     {
7612         /* TLSv1.2 server followed by resumption */
7613         {SSL_CB_HANDSHAKE_START, NULL}, {SSL_CB_LOOP, "PINIT"},
7614         {SSL_CB_LOOP, "PINIT"}, {SSL_CB_LOOP, "TRCH"}, {SSL_CB_LOOP, "TWSH"},
7615         {SSL_CB_LOOP, "TWSC"}, {SSL_CB_LOOP, "TWSKE"}, {SSL_CB_LOOP, "TWSD"},
7616         {SSL_CB_EXIT, NULL}, {SSL_CB_LOOP, "TWSD"}, {SSL_CB_LOOP, "TRCKE"},
7617         {SSL_CB_LOOP, "TRCCS"}, {SSL_CB_LOOP, "TRFIN"}, {SSL_CB_LOOP, "TWST"},
7618         {SSL_CB_LOOP, "TWCCS"}, {SSL_CB_LOOP, "TWFIN"},
7619         {SSL_CB_HANDSHAKE_DONE, NULL}, {SSL_CB_EXIT, NULL},
7620         {SSL_CB_ALERT, NULL}, {SSL_CB_HANDSHAKE_START, NULL},
7621         {SSL_CB_LOOP, "PINIT"}, {SSL_CB_LOOP, "PINIT"}, {SSL_CB_LOOP, "TRCH"},
7622         {SSL_CB_LOOP, "TWSH"}, {SSL_CB_LOOP, "TWCCS"}, {SSL_CB_LOOP, "TWFIN"},
7623         {SSL_CB_EXIT, NULL}, {SSL_CB_LOOP, "TWFIN"}, {SSL_CB_LOOP, "TRCCS"},
7624         {SSL_CB_LOOP, "TRFIN"}, {SSL_CB_HANDSHAKE_DONE, NULL},
7625         {SSL_CB_EXIT, NULL}, {0, NULL},
7626     }, {
7627         /* TLSv1.2 client followed by resumption */
7628         {SSL_CB_HANDSHAKE_START, NULL}, {SSL_CB_LOOP, "PINIT"},
7629         {SSL_CB_LOOP, "TWCH"}, {SSL_CB_EXIT, NULL}, {SSL_CB_LOOP, "TWCH"},
7630         {SSL_CB_LOOP, "TRSH"}, {SSL_CB_LOOP, "TRSC"}, {SSL_CB_LOOP, "TRSKE"},
7631         {SSL_CB_LOOP, "TRSD"}, {SSL_CB_LOOP, "TWCKE"}, {SSL_CB_LOOP, "TWCCS"},
7632         {SSL_CB_LOOP, "TWFIN"}, {SSL_CB_EXIT, NULL}, {SSL_CB_LOOP, "TWFIN"},
7633         {SSL_CB_LOOP, "TRST"}, {SSL_CB_LOOP, "TRCCS"}, {SSL_CB_LOOP, "TRFIN"},
7634         {SSL_CB_HANDSHAKE_DONE, NULL}, {SSL_CB_EXIT, NULL}, {SSL_CB_ALERT, NULL},
7635         {SSL_CB_HANDSHAKE_START, NULL}, {SSL_CB_LOOP, "PINIT"},
7636         {SSL_CB_LOOP, "TWCH"}, {SSL_CB_EXIT, NULL}, {SSL_CB_LOOP, "TWCH"},
7637         {SSL_CB_LOOP, "TRSH"}, {SSL_CB_LOOP, "TRCCS"}, {SSL_CB_LOOP, "TRFIN"},
7638         {SSL_CB_LOOP, "TWCCS"},  {SSL_CB_LOOP, "TWFIN"},
7639         {SSL_CB_HANDSHAKE_DONE, NULL}, {SSL_CB_EXIT, NULL}, {0, NULL},
7640     }, {
7641         /* TLSv1.3 server followed by resumption */
7642         {SSL_CB_HANDSHAKE_START, NULL}, {SSL_CB_LOOP, "PINIT"},
7643         {SSL_CB_LOOP, "PINIT"}, {SSL_CB_LOOP, "TRCH"}, {SSL_CB_LOOP, "TWSH"},
7644         {SSL_CB_LOOP, "TWCCS"}, {SSL_CB_LOOP, "TWEE"}, {SSL_CB_LOOP, "TWSC"},
7645         {SSL_CB_LOOP, "TWSCV"}, {SSL_CB_LOOP, "TWFIN"}, {SSL_CB_LOOP, "TED"},
7646         {SSL_CB_EXIT, NULL}, {SSL_CB_LOOP, "TED"}, {SSL_CB_LOOP, "TRFIN"},
7647         {SSL_CB_HANDSHAKE_DONE, NULL}, {SSL_CB_LOOP, "TWST"},
7648         {SSL_CB_LOOP, "TWST"}, {SSL_CB_EXIT, NULL}, {SSL_CB_ALERT, NULL},
7649         {SSL_CB_HANDSHAKE_START, NULL}, {SSL_CB_LOOP, "PINIT"},
7650         {SSL_CB_LOOP, "PINIT"}, {SSL_CB_LOOP, "TRCH"}, {SSL_CB_LOOP, "TWSH"},
7651         {SSL_CB_LOOP, "TWCCS"}, {SSL_CB_LOOP, "TWEE"}, {SSL_CB_LOOP, "TWFIN"},
7652         {SSL_CB_LOOP, "TED"}, {SSL_CB_EXIT, NULL}, {SSL_CB_LOOP, "TED"},
7653         {SSL_CB_LOOP, "TRFIN"}, {SSL_CB_HANDSHAKE_DONE, NULL},
7654         {SSL_CB_LOOP, "TWST"}, {SSL_CB_EXIT, NULL}, {0, NULL},
7655     }, {
7656         /* TLSv1.3 client followed by resumption */
7657         {SSL_CB_HANDSHAKE_START, NULL}, {SSL_CB_LOOP, "PINIT"},
7658         {SSL_CB_LOOP, "TWCH"}, {SSL_CB_EXIT, NULL}, {SSL_CB_LOOP, "TWCH"},
7659         {SSL_CB_LOOP, "TRSH"}, {SSL_CB_LOOP, "TREE"}, {SSL_CB_LOOP, "TRSC"},
7660         {SSL_CB_LOOP, "TRSCV"}, {SSL_CB_LOOP, "TRFIN"}, {SSL_CB_LOOP, "TWCCS"},
7661         {SSL_CB_LOOP, "TWFIN"},  {SSL_CB_HANDSHAKE_DONE, NULL},
7662         {SSL_CB_EXIT, NULL}, {SSL_CB_LOOP, "SSLOK"}, {SSL_CB_LOOP, "SSLOK"},
7663         {SSL_CB_LOOP, "TRST"}, {SSL_CB_EXIT, NULL}, {SSL_CB_LOOP, "SSLOK"},
7664         {SSL_CB_LOOP, "SSLOK"}, {SSL_CB_LOOP, "TRST"}, {SSL_CB_EXIT, NULL},
7665         {SSL_CB_ALERT, NULL}, {SSL_CB_HANDSHAKE_START, NULL},
7666         {SSL_CB_LOOP, "PINIT"}, {SSL_CB_LOOP, "TWCH"}, {SSL_CB_EXIT, NULL},
7667         {SSL_CB_LOOP, "TWCH"}, {SSL_CB_LOOP, "TRSH"},  {SSL_CB_LOOP, "TREE"},
7668         {SSL_CB_LOOP, "TRFIN"}, {SSL_CB_LOOP, "TWCCS"}, {SSL_CB_LOOP, "TWFIN"},
7669         {SSL_CB_HANDSHAKE_DONE, NULL}, {SSL_CB_EXIT, NULL},
7670         {SSL_CB_LOOP, "SSLOK"}, {SSL_CB_LOOP, "SSLOK"}, {SSL_CB_LOOP, "TRST"},
7671         {SSL_CB_EXIT, NULL}, {0, NULL},
7672     }, {
7673         /* TLSv1.3 server, early_data */
7674         {SSL_CB_HANDSHAKE_START, NULL}, {SSL_CB_LOOP, "PINIT"},
7675         {SSL_CB_LOOP, "PINIT"}, {SSL_CB_LOOP, "TRCH"}, {SSL_CB_LOOP, "TWSH"},
7676         {SSL_CB_LOOP, "TWCCS"}, {SSL_CB_LOOP, "TWEE"}, {SSL_CB_LOOP, "TWFIN"},
7677         {SSL_CB_HANDSHAKE_DONE, NULL}, {SSL_CB_EXIT, NULL},
7678         {SSL_CB_HANDSHAKE_START, NULL}, {SSL_CB_LOOP, "TED"},
7679         {SSL_CB_LOOP, "TED"}, {SSL_CB_LOOP, "TWEOED"}, {SSL_CB_LOOP, "TRFIN"},
7680         {SSL_CB_HANDSHAKE_DONE, NULL}, {SSL_CB_LOOP, "TWST"},
7681         {SSL_CB_EXIT, NULL}, {0, NULL},
7682     }, {
7683         /* TLSv1.3 client, early_data */
7684         {SSL_CB_HANDSHAKE_START, NULL}, {SSL_CB_LOOP, "PINIT"},
7685         {SSL_CB_LOOP, "TWCH"}, {SSL_CB_LOOP, "TWCCS"},
7686         {SSL_CB_HANDSHAKE_DONE, NULL}, {SSL_CB_EXIT, NULL},
7687         {SSL_CB_HANDSHAKE_START, NULL}, {SSL_CB_LOOP, "TED"},
7688         {SSL_CB_LOOP, "TED"}, {SSL_CB_LOOP, "TRSH"}, {SSL_CB_LOOP, "TREE"},
7689         {SSL_CB_LOOP, "TRFIN"}, {SSL_CB_LOOP, "TPEDE"}, {SSL_CB_LOOP, "TWEOED"},
7690         {SSL_CB_LOOP, "TWFIN"}, {SSL_CB_HANDSHAKE_DONE, NULL},
7691         {SSL_CB_EXIT, NULL}, {SSL_CB_LOOP, "SSLOK"}, {SSL_CB_LOOP, "SSLOK"},
7692         {SSL_CB_LOOP, "TRST"}, {SSL_CB_EXIT, NULL}, {0, NULL},
7693     }, {
7694         /* TLSv1.3 server, certificate compression, followed by resumption */
7695         {SSL_CB_HANDSHAKE_START, NULL}, {SSL_CB_LOOP, "PINIT"},
7696         {SSL_CB_LOOP, "PINIT"}, {SSL_CB_LOOP, "TRCH"}, {SSL_CB_LOOP, "TWSH"},
7697         {SSL_CB_LOOP, "TWCCS"}, {SSL_CB_LOOP, "TWEE"}, {SSL_CB_LOOP, "TWSCC"},
7698         {SSL_CB_LOOP, "TWSCV"}, {SSL_CB_LOOP, "TWFIN"}, {SSL_CB_LOOP, "TED"},
7699         {SSL_CB_EXIT, NULL}, {SSL_CB_LOOP, "TED"}, {SSL_CB_LOOP, "TRFIN"},
7700         {SSL_CB_HANDSHAKE_DONE, NULL}, {SSL_CB_LOOP, "TWST"},
7701         {SSL_CB_LOOP, "TWST"}, {SSL_CB_EXIT, NULL}, {SSL_CB_ALERT, NULL},
7702         {SSL_CB_HANDSHAKE_START, NULL}, {SSL_CB_LOOP, "PINIT"},
7703         {SSL_CB_LOOP, "PINIT"}, {SSL_CB_LOOP, "TRCH"}, {SSL_CB_LOOP, "TWSH"},
7704         {SSL_CB_LOOP, "TWCCS"}, {SSL_CB_LOOP, "TWEE"}, {SSL_CB_LOOP, "TWFIN"},
7705         {SSL_CB_LOOP, "TED"}, {SSL_CB_EXIT, NULL}, {SSL_CB_LOOP, "TED"},
7706         {SSL_CB_LOOP, "TRFIN"}, {SSL_CB_HANDSHAKE_DONE, NULL},
7707         {SSL_CB_LOOP, "TWST"}, {SSL_CB_EXIT, NULL}, {0, NULL},
7708     }, {
7709         /* TLSv1.3 client, certificate compression, followed by resumption */
7710         {SSL_CB_HANDSHAKE_START, NULL}, {SSL_CB_LOOP, "PINIT"},
7711         {SSL_CB_LOOP, "TWCH"}, {SSL_CB_EXIT, NULL}, {SSL_CB_LOOP, "TWCH"},
7712         {SSL_CB_LOOP, "TRSH"}, {SSL_CB_LOOP, "TREE"}, {SSL_CB_LOOP, "TRSCC"},
7713         {SSL_CB_LOOP, "TRSCV"}, {SSL_CB_LOOP, "TRFIN"}, {SSL_CB_LOOP, "TWCCS"},
7714         {SSL_CB_LOOP, "TWFIN"},  {SSL_CB_HANDSHAKE_DONE, NULL},
7715         {SSL_CB_EXIT, NULL}, {SSL_CB_LOOP, "SSLOK"}, {SSL_CB_LOOP, "SSLOK"},
7716         {SSL_CB_LOOP, "TRST"}, {SSL_CB_EXIT, NULL}, {SSL_CB_LOOP, "SSLOK"},
7717         {SSL_CB_LOOP, "SSLOK"}, {SSL_CB_LOOP, "TRST"}, {SSL_CB_EXIT, NULL},
7718         {SSL_CB_ALERT, NULL}, {SSL_CB_HANDSHAKE_START, NULL},
7719         {SSL_CB_LOOP, "PINIT"}, {SSL_CB_LOOP, "TWCH"}, {SSL_CB_EXIT, NULL},
7720         {SSL_CB_LOOP, "TWCH"}, {SSL_CB_LOOP, "TRSH"},  {SSL_CB_LOOP, "TREE"},
7721         {SSL_CB_LOOP, "TRFIN"}, {SSL_CB_LOOP, "TWCCS"}, {SSL_CB_LOOP, "TWFIN"},
7722         {SSL_CB_HANDSHAKE_DONE, NULL}, {SSL_CB_EXIT, NULL},
7723         {SSL_CB_LOOP, "SSLOK"}, {SSL_CB_LOOP, "SSLOK"}, {SSL_CB_LOOP, "TRST"},
7724         {SSL_CB_EXIT, NULL}, {0, NULL},
7725     }, {
7726         {0, NULL},
7727     }
7728 };
7729
7730 static void sslapi_info_callback(const SSL *s, int where, int ret)
7731 {
7732     struct info_cb_states_st *state = info_cb_states[info_cb_offset];
7733
7734     /* We do not ever expect a connection to fail in this test */
7735     if (!TEST_false(ret == 0)) {
7736         info_cb_failed = 1;
7737         return;
7738     }
7739
7740     /*
7741      * Do some sanity checks. We never expect these things to happen in this
7742      * test
7743      */
7744     if (!TEST_false((SSL_is_server(s) && (where & SSL_ST_CONNECT) != 0))
7745             || !TEST_false(!SSL_is_server(s) && (where & SSL_ST_ACCEPT) != 0)
7746             || !TEST_int_ne(state[++info_cb_this_state].where, 0)) {
7747         info_cb_failed = 1;
7748         return;
7749     }
7750
7751     /* Now check we're in the right state */
7752     if (!TEST_true((where & state[info_cb_this_state].where) != 0)) {
7753         info_cb_failed = 1;
7754         return;
7755     }
7756     if ((where & SSL_CB_LOOP) != 0
7757             && !TEST_int_eq(strcmp(SSL_state_string(s),
7758                             state[info_cb_this_state].statestr), 0)) {
7759         info_cb_failed = 1;
7760         return;
7761     }
7762
7763     /*
7764      * Check that, if we've got SSL_CB_HANDSHAKE_DONE we are not in init
7765      */
7766     if ((where & SSL_CB_HANDSHAKE_DONE)
7767             && SSL_in_init((SSL *)s) != 0) {
7768         info_cb_failed = 1;
7769         return;
7770     }
7771 }
7772
7773 /*
7774  * Test the info callback gets called when we expect it to.
7775  *
7776  * Test 0: TLSv1.2, server
7777  * Test 1: TLSv1.2, client
7778  * Test 2: TLSv1.3, server
7779  * Test 3: TLSv1.3, client
7780  * Test 4: TLSv1.3, server, early_data
7781  * Test 5: TLSv1.3, client, early_data
7782  * Test 6: TLSv1.3, server, compressed certificate
7783  * Test 7: TLSv1.3, client, compressed certificate
7784  */
7785 static int test_info_callback(int tst)
7786 {
7787     SSL_CTX *cctx = NULL, *sctx = NULL;
7788     SSL *clientssl = NULL, *serverssl = NULL;
7789     SSL_SESSION *clntsess = NULL;
7790     int testresult = 0;
7791     int tlsvers;
7792
7793     if (tst < 2) {
7794 /* We need either ECDHE or DHE for the TLSv1.2 test to work */
7795 #if !defined(OPENSSL_NO_TLS1_2) && (!defined(OPENSSL_NO_EC) \
7796                                     || !defined(OPENSSL_NO_DH))
7797         tlsvers = TLS1_2_VERSION;
7798 #else
7799         return 1;
7800 #endif
7801     } else {
7802 #ifndef OSSL_NO_USABLE_TLS1_3
7803         tlsvers = TLS1_3_VERSION;
7804 #else
7805         return 1;
7806 #endif
7807     }
7808
7809     /* Reset globals */
7810     info_cb_failed = 0;
7811     info_cb_this_state = -1;
7812     info_cb_offset = tst;
7813
7814 #ifndef OSSL_NO_USABLE_TLS1_3
7815     if (tst >= 4 && tst < 6) {
7816         SSL_SESSION *sess = NULL;
7817         size_t written, readbytes;
7818         unsigned char buf[80];
7819         OSSL_TIME timer;
7820
7821         /* early_data tests */
7822         if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
7823                                             &serverssl, &sess, 0,
7824                                             SHA384_DIGEST_LENGTH)))
7825             goto end;
7826
7827         /* We don't actually need this reference */
7828         SSL_SESSION_free(sess);
7829
7830         SSL_set_info_callback((tst % 2) == 0 ? serverssl : clientssl,
7831                               sslapi_info_callback);
7832
7833         /* Write and read some early data and then complete the connection */
7834         timer = ossl_time_now();
7835         if (!TEST_true(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
7836                                             &written))
7837                 || !TEST_size_t_eq(written, strlen(MSG1)))
7838             goto end;
7839
7840         if (!TEST_int_eq(SSL_read_early_data(serverssl, buf,
7841                                              sizeof(buf), &readbytes),
7842                          SSL_READ_EARLY_DATA_SUCCESS)) {
7843             testresult = check_early_data_timeout(timer);
7844             goto end;
7845         }
7846
7847         if (!TEST_mem_eq(MSG1, readbytes, buf, strlen(MSG1))
7848                 || !TEST_int_eq(SSL_get_early_data_status(serverssl),
7849                                 SSL_EARLY_DATA_ACCEPTED)
7850                 || !TEST_true(create_ssl_connection(serverssl, clientssl,
7851                                                     SSL_ERROR_NONE))
7852                 || !TEST_false(info_cb_failed))
7853             goto end;
7854
7855         testresult = 1;
7856         goto end;
7857     }
7858 #endif
7859
7860     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
7861                                        TLS_client_method(),
7862                                        tlsvers, tlsvers, &sctx, &cctx, cert,
7863                                        privkey)))
7864         goto end;
7865
7866     if (!TEST_true(SSL_CTX_set_dh_auto(sctx, 1)))
7867         goto end;
7868
7869     /*
7870      * For even numbered tests we check the server callbacks. For odd numbers we
7871      * check the client.
7872      */
7873     SSL_CTX_set_info_callback((tst % 2) == 0 ? sctx : cctx,
7874                               sslapi_info_callback);
7875     if (tst >= 6) {
7876         if (!SSL_CTX_compress_certs(sctx, 0))
7877             goto end;
7878     }
7879
7880     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
7881                                           &clientssl, NULL, NULL))
7882         || !TEST_true(create_ssl_connection(serverssl, clientssl,
7883                                             SSL_ERROR_NONE))
7884         || !TEST_false(info_cb_failed))
7885     goto end;
7886
7887
7888
7889     clntsess = SSL_get1_session(clientssl);
7890     SSL_shutdown(clientssl);
7891     SSL_shutdown(serverssl);
7892     SSL_free(serverssl);
7893     SSL_free(clientssl);
7894     serverssl = clientssl = NULL;
7895
7896     /* Now do a resumption */
7897     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL,
7898                                       NULL))
7899             || !TEST_true(SSL_set_session(clientssl, clntsess))
7900             || !TEST_true(create_ssl_connection(serverssl, clientssl,
7901                                                 SSL_ERROR_NONE))
7902             || !TEST_true(SSL_session_reused(clientssl))
7903             || !TEST_false(info_cb_failed))
7904         goto end;
7905
7906     testresult = 1;
7907
7908  end:
7909     SSL_free(serverssl);
7910     SSL_free(clientssl);
7911     SSL_SESSION_free(clntsess);
7912     SSL_CTX_free(sctx);
7913     SSL_CTX_free(cctx);
7914     return testresult;
7915 }
7916
7917 static int test_ssl_pending(int tst)
7918 {
7919     SSL_CTX *cctx = NULL, *sctx = NULL;
7920     SSL *clientssl = NULL, *serverssl = NULL;
7921     int testresult = 0;
7922     char msg[] = "A test message";
7923     char buf[5];
7924     size_t written, readbytes;
7925
7926     if (tst == 0) {
7927         if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
7928                                            TLS_client_method(),
7929                                            TLS1_VERSION, 0,
7930                                            &sctx, &cctx, cert, privkey)))
7931             goto end;
7932     } else {
7933 #ifndef OPENSSL_NO_DTLS
7934         if (!TEST_true(create_ssl_ctx_pair(libctx, DTLS_server_method(),
7935                                            DTLS_client_method(),
7936                                            DTLS1_VERSION, 0,
7937                                            &sctx, &cctx, cert, privkey)))
7938             goto end;
7939
7940 # ifdef OPENSSL_NO_DTLS1_2
7941         /* Not supported in the FIPS provider */
7942         if (is_fips) {
7943             testresult = 1;
7944             goto end;
7945         };
7946         /*
7947          * Default sigalgs are SHA1 based in <DTLS1.2 which is in security
7948          * level 0
7949          */
7950         if (!TEST_true(SSL_CTX_set_cipher_list(sctx, "DEFAULT:@SECLEVEL=0"))
7951                 || !TEST_true(SSL_CTX_set_cipher_list(cctx,
7952                                                     "DEFAULT:@SECLEVEL=0")))
7953             goto end;
7954 # endif
7955 #else
7956         return 1;
7957 #endif
7958     }
7959
7960     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
7961                                              NULL, NULL))
7962             || !TEST_true(create_ssl_connection(serverssl, clientssl,
7963                                                 SSL_ERROR_NONE)))
7964         goto end;
7965
7966     if (!TEST_int_eq(SSL_pending(clientssl), 0)
7967             || !TEST_false(SSL_has_pending(clientssl))
7968             || !TEST_int_eq(SSL_pending(serverssl), 0)
7969             || !TEST_false(SSL_has_pending(serverssl))
7970             || !TEST_true(SSL_write_ex(serverssl, msg, sizeof(msg), &written))
7971             || !TEST_size_t_eq(written, sizeof(msg))
7972             || !TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
7973             || !TEST_size_t_eq(readbytes, sizeof(buf))
7974             || !TEST_int_eq(SSL_pending(clientssl), (int)(written - readbytes))
7975             || !TEST_true(SSL_has_pending(clientssl)))
7976         goto end;
7977
7978     testresult = 1;
7979
7980  end:
7981     SSL_free(serverssl);
7982     SSL_free(clientssl);
7983     SSL_CTX_free(sctx);
7984     SSL_CTX_free(cctx);
7985
7986     return testresult;
7987 }
7988
7989 static struct {
7990     unsigned int maxprot;
7991     const char *clntciphers;
7992     const char *clnttls13ciphers;
7993     const char *srvrciphers;
7994     const char *srvrtls13ciphers;
7995     const char *shared;
7996     const char *fipsshared;
7997 } shared_ciphers_data[] = {
7998 /*
7999  * We can't establish a connection (even in TLSv1.1) with these ciphersuites if
8000  * TLSv1.3 is enabled but TLSv1.2 is disabled.
8001  */
8002 #if defined(OSSL_NO_USABLE_TLS1_3) || !defined(OPENSSL_NO_TLS1_2)
8003     {
8004         TLS1_2_VERSION,
8005         "AES128-SHA:AES256-SHA",
8006         NULL,
8007         "AES256-SHA:DHE-RSA-AES128-SHA",
8008         NULL,
8009         "AES256-SHA",
8010         "AES256-SHA"
8011     },
8012 # if !defined(OPENSSL_NO_CHACHA) \
8013      && !defined(OPENSSL_NO_POLY1305) \
8014      && !defined(OPENSSL_NO_EC)
8015     {
8016         TLS1_2_VERSION,
8017         "AES128-SHA:ECDHE-RSA-CHACHA20-POLY1305",
8018         NULL,
8019         "AES128-SHA:ECDHE-RSA-CHACHA20-POLY1305",
8020         NULL,
8021         "AES128-SHA:ECDHE-RSA-CHACHA20-POLY1305",
8022         "AES128-SHA"
8023     },
8024 # endif
8025     {
8026         TLS1_2_VERSION,
8027         "AES128-SHA:DHE-RSA-AES128-SHA:AES256-SHA",
8028         NULL,
8029         "AES128-SHA:DHE-RSA-AES256-SHA:AES256-SHA",
8030         NULL,
8031         "AES128-SHA:AES256-SHA",
8032         "AES128-SHA:AES256-SHA"
8033     },
8034     {
8035         TLS1_2_VERSION,
8036         "AES128-SHA:AES256-SHA",
8037         NULL,
8038         "AES128-SHA:DHE-RSA-AES128-SHA",
8039         NULL,
8040         "AES128-SHA",
8041         "AES128-SHA"
8042     },
8043 #endif
8044 /*
8045  * This test combines TLSv1.3 and TLSv1.2 ciphersuites so they must both be
8046  * enabled.
8047  */
8048 #if !defined(OSSL_NO_USABLE_TLS1_3) && !defined(OPENSSL_NO_TLS1_2) \
8049     && !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305)
8050     {
8051         TLS1_3_VERSION,
8052         "AES128-SHA:AES256-SHA",
8053         NULL,
8054         "AES256-SHA:AES128-SHA256",
8055         NULL,
8056         "TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:"
8057         "TLS_AES_128_GCM_SHA256:AES256-SHA",
8058         "TLS_AES_256_GCM_SHA384:TLS_AES_128_GCM_SHA256:AES256-SHA"
8059     },
8060 #endif
8061 #ifndef OSSL_NO_USABLE_TLS1_3
8062     {
8063         TLS1_3_VERSION,
8064         "AES128-SHA",
8065         "TLS_AES_256_GCM_SHA384",
8066         "AES256-SHA",
8067         "TLS_AES_256_GCM_SHA384",
8068         "TLS_AES_256_GCM_SHA384",
8069         "TLS_AES_256_GCM_SHA384"
8070     },
8071 #endif
8072 };
8073
8074 static int int_test_ssl_get_shared_ciphers(int tst, int clnt)
8075 {
8076     SSL_CTX *cctx = NULL, *sctx = NULL;
8077     SSL *clientssl = NULL, *serverssl = NULL;
8078     int testresult = 0;
8079     char buf[1024];
8080     OSSL_LIB_CTX *tmplibctx = OSSL_LIB_CTX_new();
8081
8082     if (!TEST_ptr(tmplibctx))
8083         goto end;
8084
8085     /*
8086      * Regardless of whether we're testing with the FIPS provider loaded into
8087      * libctx, we want one peer to always use the full set of ciphersuites
8088      * available. Therefore we use a separate libctx with the default provider
8089      * loaded into it. We run the same tests twice - once with the client side
8090      * having the full set of ciphersuites and once with the server side.
8091      */
8092     if (clnt) {
8093         cctx = SSL_CTX_new_ex(tmplibctx, NULL, TLS_client_method());
8094         if (!TEST_ptr(cctx))
8095             goto end;
8096     } else {
8097         sctx = SSL_CTX_new_ex(tmplibctx, NULL, TLS_server_method());
8098         if (!TEST_ptr(sctx))
8099             goto end;
8100     }
8101
8102     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
8103                                        TLS_client_method(),
8104                                        TLS1_VERSION,
8105                                        shared_ciphers_data[tst].maxprot,
8106                                        &sctx, &cctx, cert, privkey)))
8107         goto end;
8108
8109     if (!TEST_true(SSL_CTX_set_cipher_list(cctx,
8110                                         shared_ciphers_data[tst].clntciphers))
8111             || (shared_ciphers_data[tst].clnttls13ciphers != NULL
8112                 && !TEST_true(SSL_CTX_set_ciphersuites(cctx,
8113                                     shared_ciphers_data[tst].clnttls13ciphers)))
8114             || !TEST_true(SSL_CTX_set_cipher_list(sctx,
8115                                         shared_ciphers_data[tst].srvrciphers))
8116             || (shared_ciphers_data[tst].srvrtls13ciphers != NULL
8117                 && !TEST_true(SSL_CTX_set_ciphersuites(sctx,
8118                                     shared_ciphers_data[tst].srvrtls13ciphers))))
8119         goto end;
8120
8121
8122     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
8123                                              NULL, NULL))
8124             || !TEST_true(create_ssl_connection(serverssl, clientssl,
8125                                                 SSL_ERROR_NONE)))
8126         goto end;
8127
8128     if (!TEST_ptr(SSL_get_shared_ciphers(serverssl, buf, sizeof(buf)))
8129             || !TEST_int_eq(strcmp(buf,
8130                                    is_fips
8131                                    ? shared_ciphers_data[tst].fipsshared
8132                                    : shared_ciphers_data[tst].shared),
8133                                    0)) {
8134         TEST_info("Shared ciphers are: %s\n", buf);
8135         goto end;
8136     }
8137
8138     testresult = 1;
8139
8140  end:
8141     SSL_free(serverssl);
8142     SSL_free(clientssl);
8143     SSL_CTX_free(sctx);
8144     SSL_CTX_free(cctx);
8145     OSSL_LIB_CTX_free(tmplibctx);
8146
8147     return testresult;
8148 }
8149
8150 static int test_ssl_get_shared_ciphers(int tst)
8151 {
8152     return int_test_ssl_get_shared_ciphers(tst, 0)
8153            && int_test_ssl_get_shared_ciphers(tst, 1);
8154 }
8155
8156
8157 static const char *appdata = "Hello World";
8158 static int gen_tick_called, dec_tick_called, tick_key_cb_called;
8159 static int tick_key_renew = 0;
8160 static SSL_TICKET_RETURN tick_dec_ret = SSL_TICKET_RETURN_ABORT;
8161
8162 static int gen_tick_cb(SSL *s, void *arg)
8163 {
8164     gen_tick_called = 1;
8165
8166     return SSL_SESSION_set1_ticket_appdata(SSL_get_session(s), appdata,
8167                                            strlen(appdata));
8168 }
8169
8170 static SSL_TICKET_RETURN dec_tick_cb(SSL *s, SSL_SESSION *ss,
8171                                      const unsigned char *keyname,
8172                                      size_t keyname_length,
8173                                      SSL_TICKET_STATUS status,
8174                                      void *arg)
8175 {
8176     void *tickdata;
8177     size_t tickdlen;
8178
8179     dec_tick_called = 1;
8180
8181     if (status == SSL_TICKET_EMPTY)
8182         return SSL_TICKET_RETURN_IGNORE_RENEW;
8183
8184     if (!TEST_true(status == SSL_TICKET_SUCCESS
8185                    || status == SSL_TICKET_SUCCESS_RENEW))
8186         return SSL_TICKET_RETURN_ABORT;
8187
8188     if (!TEST_true(SSL_SESSION_get0_ticket_appdata(ss, &tickdata,
8189                                                    &tickdlen))
8190             || !TEST_size_t_eq(tickdlen, strlen(appdata))
8191             || !TEST_int_eq(memcmp(tickdata, appdata, tickdlen), 0))
8192         return SSL_TICKET_RETURN_ABORT;
8193
8194     if (tick_key_cb_called)  {
8195         /* Don't change what the ticket key callback wanted to do */
8196         switch (status) {
8197         case SSL_TICKET_NO_DECRYPT:
8198             return SSL_TICKET_RETURN_IGNORE_RENEW;
8199
8200         case SSL_TICKET_SUCCESS:
8201             return SSL_TICKET_RETURN_USE;
8202
8203         case SSL_TICKET_SUCCESS_RENEW:
8204             return SSL_TICKET_RETURN_USE_RENEW;
8205
8206         default:
8207             return SSL_TICKET_RETURN_ABORT;
8208         }
8209     }
8210     return tick_dec_ret;
8211
8212 }
8213
8214 #ifndef OPENSSL_NO_DEPRECATED_3_0
8215 static int tick_key_cb(SSL *s, unsigned char key_name[16],
8216                        unsigned char iv[EVP_MAX_IV_LENGTH], EVP_CIPHER_CTX *ctx,
8217                        HMAC_CTX *hctx, int enc)
8218 {
8219     const unsigned char tick_aes_key[16] = "0123456789abcdef";
8220     const unsigned char tick_hmac_key[16] = "0123456789abcdef";
8221     EVP_CIPHER *aes128cbc;
8222     EVP_MD *sha256;
8223     int ret;
8224
8225     tick_key_cb_called = 1;
8226
8227     if (tick_key_renew == -1)
8228         return 0;
8229
8230     aes128cbc = EVP_CIPHER_fetch(libctx, "AES-128-CBC", NULL);
8231     if (!TEST_ptr(aes128cbc))
8232         return 0;
8233     sha256 = EVP_MD_fetch(libctx, "SHA-256", NULL);
8234     if (!TEST_ptr(sha256)) {
8235         EVP_CIPHER_free(aes128cbc);
8236         return 0;
8237     }
8238
8239     memset(iv, 0, AES_BLOCK_SIZE);
8240     memset(key_name, 0, 16);
8241     if (aes128cbc == NULL
8242             || sha256 == NULL
8243             || !EVP_CipherInit_ex(ctx, aes128cbc, NULL, tick_aes_key, iv, enc)
8244             || !HMAC_Init_ex(hctx, tick_hmac_key, sizeof(tick_hmac_key), sha256,
8245                              NULL))
8246         ret = -1;
8247     else
8248         ret = tick_key_renew ? 2 : 1;
8249
8250     EVP_CIPHER_free(aes128cbc);
8251     EVP_MD_free(sha256);
8252
8253     return ret;
8254 }
8255 #endif
8256
8257 static int tick_key_evp_cb(SSL *s, unsigned char key_name[16],
8258                            unsigned char iv[EVP_MAX_IV_LENGTH],
8259                            EVP_CIPHER_CTX *ctx, EVP_MAC_CTX *hctx, int enc)
8260 {
8261     const unsigned char tick_aes_key[16] = "0123456789abcdef";
8262     unsigned char tick_hmac_key[16] = "0123456789abcdef";
8263     OSSL_PARAM params[2];
8264     EVP_CIPHER *aes128cbc;
8265     int ret;
8266
8267     tick_key_cb_called = 1;
8268
8269     if (tick_key_renew == -1)
8270         return 0;
8271
8272     aes128cbc = EVP_CIPHER_fetch(libctx, "AES-128-CBC", NULL);
8273     if (!TEST_ptr(aes128cbc))
8274         return 0;
8275
8276     memset(iv, 0, AES_BLOCK_SIZE);
8277     memset(key_name, 0, 16);
8278     params[0] = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST,
8279                                                  "SHA256", 0);
8280     params[1] = OSSL_PARAM_construct_end();
8281     if (aes128cbc == NULL
8282             || !EVP_CipherInit_ex(ctx, aes128cbc, NULL, tick_aes_key, iv, enc)
8283             || !EVP_MAC_init(hctx, tick_hmac_key, sizeof(tick_hmac_key),
8284                              params))
8285         ret = -1;
8286     else
8287         ret = tick_key_renew ? 2 : 1;
8288
8289     EVP_CIPHER_free(aes128cbc);
8290
8291     return ret;
8292 }
8293
8294 /*
8295  * Test the various ticket callbacks
8296  * Test 0: TLSv1.2, no ticket key callback, no ticket, no renewal
8297  * Test 1: TLSv1.3, no ticket key callback, no ticket, no renewal
8298  * Test 2: TLSv1.2, no ticket key callback, no ticket, renewal
8299  * Test 3: TLSv1.3, no ticket key callback, no ticket, renewal
8300  * Test 4: TLSv1.2, no ticket key callback, ticket, no renewal
8301  * Test 5: TLSv1.3, no ticket key callback, ticket, no renewal
8302  * Test 6: TLSv1.2, no ticket key callback, ticket, renewal
8303  * Test 7: TLSv1.3, no ticket key callback, ticket, renewal
8304  * Test 8: TLSv1.2, old ticket key callback, ticket, no renewal
8305  * Test 9: TLSv1.3, old ticket key callback, ticket, no renewal
8306  * Test 10: TLSv1.2, old ticket key callback, ticket, renewal
8307  * Test 11: TLSv1.3, old ticket key callback, ticket, renewal
8308  * Test 12: TLSv1.2, old ticket key callback, no ticket
8309  * Test 13: TLSv1.3, old ticket key callback, no ticket
8310  * Test 14: TLSv1.2, ticket key callback, ticket, no renewal
8311  * Test 15: TLSv1.3, ticket key callback, ticket, no renewal
8312  * Test 16: TLSv1.2, ticket key callback, ticket, renewal
8313  * Test 17: TLSv1.3, ticket key callback, ticket, renewal
8314  * Test 18: TLSv1.2, ticket key callback, no ticket
8315  * Test 19: TLSv1.3, ticket key callback, no ticket
8316  */
8317 static int test_ticket_callbacks(int tst)
8318 {
8319     SSL_CTX *cctx = NULL, *sctx = NULL;
8320     SSL *clientssl = NULL, *serverssl = NULL;
8321     SSL_SESSION *clntsess = NULL;
8322     int testresult = 0;
8323
8324 #ifdef OPENSSL_NO_TLS1_2
8325     if (tst % 2 == 0)
8326         return 1;
8327 #endif
8328 #ifdef OSSL_NO_USABLE_TLS1_3
8329     if (tst % 2 == 1)
8330         return 1;
8331 #endif
8332 #ifdef OPENSSL_NO_DEPRECATED_3_0
8333     if (tst >= 8 && tst <= 13)
8334         return 1;
8335 #endif
8336
8337     gen_tick_called = dec_tick_called = tick_key_cb_called = 0;
8338
8339     /* Which tests the ticket key callback should request renewal for */
8340
8341     if (tst == 10 || tst == 11 || tst == 16 || tst == 17)
8342         tick_key_renew = 1;
8343     else if (tst == 12 || tst == 13 || tst == 18 || tst == 19)
8344         tick_key_renew = -1; /* abort sending the ticket/0-length ticket */
8345     else
8346         tick_key_renew = 0;
8347
8348     /* Which tests the decrypt ticket callback should request renewal for */
8349     switch (tst) {
8350     case 0:
8351     case 1:
8352         tick_dec_ret = SSL_TICKET_RETURN_IGNORE;
8353         break;
8354
8355     case 2:
8356     case 3:
8357         tick_dec_ret = SSL_TICKET_RETURN_IGNORE_RENEW;
8358         break;
8359
8360     case 4:
8361     case 5:
8362         tick_dec_ret = SSL_TICKET_RETURN_USE;
8363         break;
8364
8365     case 6:
8366     case 7:
8367         tick_dec_ret = SSL_TICKET_RETURN_USE_RENEW;
8368         break;
8369
8370     default:
8371         tick_dec_ret = SSL_TICKET_RETURN_ABORT;
8372     }
8373
8374     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
8375                                        TLS_client_method(),
8376                                        TLS1_VERSION,
8377                                        ((tst % 2) == 0) ? TLS1_2_VERSION
8378                                                         : TLS1_3_VERSION,
8379                                        &sctx, &cctx, cert, privkey)))
8380         goto end;
8381
8382     /*
8383      * We only want sessions to resume from tickets - not the session cache. So
8384      * switch the cache off.
8385      */
8386     if (!TEST_true(SSL_CTX_set_session_cache_mode(sctx, SSL_SESS_CACHE_OFF)))
8387         goto end;
8388
8389     if (!TEST_true(SSL_CTX_set_session_ticket_cb(sctx, gen_tick_cb, dec_tick_cb,
8390                                                  NULL)))
8391         goto end;
8392
8393     if (tst >= 14) {
8394         if (!TEST_true(SSL_CTX_set_tlsext_ticket_key_evp_cb(sctx, tick_key_evp_cb)))
8395             goto end;
8396 #ifndef OPENSSL_NO_DEPRECATED_3_0
8397     } else if (tst >= 8) {
8398         if (!TEST_true(SSL_CTX_set_tlsext_ticket_key_cb(sctx, tick_key_cb)))
8399             goto end;
8400 #endif
8401     }
8402
8403     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
8404                                              NULL, NULL))
8405             || !TEST_true(create_ssl_connection(serverssl, clientssl,
8406                                                 SSL_ERROR_NONE)))
8407         goto end;
8408
8409     /*
8410      * The decrypt ticket key callback in TLSv1.2 should be called even though
8411      * we have no ticket yet, because it gets called with a status of
8412      * SSL_TICKET_EMPTY (the client indicates support for tickets but does not
8413      * actually send any ticket data). This does not happen in TLSv1.3 because
8414      * it is not valid to send empty ticket data in TLSv1.3.
8415      */
8416     if (!TEST_int_eq(gen_tick_called, 1)
8417             || !TEST_int_eq(dec_tick_called, ((tst % 2) == 0) ? 1 : 0))
8418         goto end;
8419
8420     gen_tick_called = dec_tick_called = 0;
8421
8422     clntsess = SSL_get1_session(clientssl);
8423     SSL_shutdown(clientssl);
8424     SSL_shutdown(serverssl);
8425     SSL_free(serverssl);
8426     SSL_free(clientssl);
8427     serverssl = clientssl = NULL;
8428
8429     /* Now do a resumption */
8430     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL,
8431                                       NULL))
8432             || !TEST_true(SSL_set_session(clientssl, clntsess))
8433             || !TEST_true(create_ssl_connection(serverssl, clientssl,
8434                                                 SSL_ERROR_NONE)))
8435         goto end;
8436
8437     if (tick_dec_ret == SSL_TICKET_RETURN_IGNORE
8438             || tick_dec_ret == SSL_TICKET_RETURN_IGNORE_RENEW
8439             || tick_key_renew == -1) {
8440         if (!TEST_false(SSL_session_reused(clientssl)))
8441             goto end;
8442     } else {
8443         if (!TEST_true(SSL_session_reused(clientssl)))
8444             goto end;
8445     }
8446
8447     if (!TEST_int_eq(gen_tick_called,
8448                      (tick_key_renew
8449                       || tick_dec_ret == SSL_TICKET_RETURN_IGNORE_RENEW
8450                       || tick_dec_ret == SSL_TICKET_RETURN_USE_RENEW)
8451                      ? 1 : 0)
8452                /* There is no ticket to decrypt in tests 13 and 19 */
8453             || !TEST_int_eq(dec_tick_called, (tst == 13 || tst == 19) ? 0 : 1))
8454         goto end;
8455
8456     testresult = 1;
8457
8458  end:
8459     SSL_SESSION_free(clntsess);
8460     SSL_free(serverssl);
8461     SSL_free(clientssl);
8462     SSL_CTX_free(sctx);
8463     SSL_CTX_free(cctx);
8464
8465     return testresult;
8466 }
8467
8468 /*
8469  * Test incorrect shutdown.
8470  * Test 0: client does not shutdown properly,
8471  *         server does not set SSL_OP_IGNORE_UNEXPECTED_EOF,
8472  *         server should get SSL_ERROR_SSL
8473  * Test 1: client does not shutdown properly,
8474  *         server sets SSL_OP_IGNORE_UNEXPECTED_EOF,
8475  *         server should get SSL_ERROR_ZERO_RETURN
8476  */
8477 static int test_incorrect_shutdown(int tst)
8478 {
8479     SSL_CTX *cctx = NULL, *sctx = NULL;
8480     SSL *clientssl = NULL, *serverssl = NULL;
8481     int testresult = 0;
8482     char buf[80];
8483     BIO *c2s;
8484
8485     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
8486                                        TLS_client_method(), 0, 0,
8487                                        &sctx, &cctx, cert, privkey)))
8488         goto end;
8489
8490     if (tst == 1)
8491         SSL_CTX_set_options(sctx, SSL_OP_IGNORE_UNEXPECTED_EOF);
8492
8493     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
8494                                             NULL, NULL)))
8495         goto end;
8496
8497     if (!TEST_true(create_ssl_connection(serverssl, clientssl,
8498                                               SSL_ERROR_NONE)))
8499         goto end;
8500
8501     c2s = SSL_get_rbio(serverssl);
8502     BIO_set_mem_eof_return(c2s, 0);
8503
8504     if (!TEST_false(SSL_read(serverssl, buf, sizeof(buf))))
8505         goto end;
8506
8507     if (tst == 0 && !TEST_int_eq(SSL_get_error(serverssl, 0), SSL_ERROR_SSL) )
8508         goto end;
8509     if (tst == 1 && !TEST_int_eq(SSL_get_error(serverssl, 0), SSL_ERROR_ZERO_RETURN) )
8510         goto end;
8511
8512     testresult = 1;
8513
8514  end:
8515     SSL_free(serverssl);
8516     SSL_free(clientssl);
8517     SSL_CTX_free(sctx);
8518     SSL_CTX_free(cctx);
8519
8520     return testresult;
8521 }
8522
8523 /*
8524  * Test bi-directional shutdown.
8525  * Test 0: TLSv1.2
8526  * Test 1: TLSv1.2, server continues to read/write after client shutdown
8527  * Test 2: TLSv1.3, no pending NewSessionTicket messages
8528  * Test 3: TLSv1.3, pending NewSessionTicket messages
8529  * Test 4: TLSv1.3, server continues to read/write after client shutdown, server
8530  *                  sends key update, client reads it
8531  * Test 5: TLSv1.3, server continues to read/write after client shutdown, server
8532  *                  sends CertificateRequest, client reads and ignores it
8533  * Test 6: TLSv1.3, server continues to read/write after client shutdown, client
8534  *                  doesn't read it
8535  */
8536 static int test_shutdown(int tst)
8537 {
8538     SSL_CTX *cctx = NULL, *sctx = NULL;
8539     SSL *clientssl = NULL, *serverssl = NULL;
8540     int testresult = 0;
8541     char msg[] = "A test message";
8542     char buf[80];
8543     size_t written, readbytes;
8544     SSL_SESSION *sess;
8545
8546 #ifdef OPENSSL_NO_TLS1_2
8547     if (tst <= 1)
8548         return 1;
8549 #endif
8550 #ifdef OSSL_NO_USABLE_TLS1_3
8551     if (tst >= 2)
8552         return 1;
8553 #endif
8554
8555     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
8556                                        TLS_client_method(),
8557                                        TLS1_VERSION,
8558                                        (tst <= 1) ? TLS1_2_VERSION
8559                                                   : TLS1_3_VERSION,
8560                                        &sctx, &cctx, cert, privkey)))
8561         goto end;
8562
8563     if (tst == 5)
8564         SSL_CTX_set_post_handshake_auth(cctx, 1);
8565
8566     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
8567                                              NULL, NULL)))
8568         goto end;
8569
8570     if (tst == 3) {
8571         if (!TEST_true(create_bare_ssl_connection(serverssl, clientssl,
8572                                                   SSL_ERROR_NONE, 1, 0))
8573                 || !TEST_ptr_ne(sess = SSL_get_session(clientssl), NULL)
8574                 || !TEST_false(SSL_SESSION_is_resumable(sess)))
8575             goto end;
8576     } else if (!TEST_true(create_ssl_connection(serverssl, clientssl,
8577                                               SSL_ERROR_NONE))
8578             || !TEST_ptr_ne(sess = SSL_get_session(clientssl), NULL)
8579             || !TEST_true(SSL_SESSION_is_resumable(sess))) {
8580         goto end;
8581     }
8582
8583     if (!TEST_int_eq(SSL_shutdown(clientssl), 0))
8584         goto end;
8585
8586     if (tst >= 4) {
8587         /*
8588          * Reading on the server after the client has sent close_notify should
8589          * fail and provide SSL_ERROR_ZERO_RETURN
8590          */
8591         if (!TEST_false(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
8592                 || !TEST_int_eq(SSL_get_error(serverssl, 0),
8593                                 SSL_ERROR_ZERO_RETURN)
8594                 || !TEST_int_eq(SSL_get_shutdown(serverssl),
8595                                 SSL_RECEIVED_SHUTDOWN)
8596                    /*
8597                     * Even though we're shutdown on receive we should still be
8598                     * able to write.
8599                     */
8600                 || !TEST_true(SSL_write(serverssl, msg, sizeof(msg))))
8601             goto end;
8602         if (tst == 4
8603                 && !TEST_true(SSL_key_update(serverssl,
8604                                              SSL_KEY_UPDATE_REQUESTED)))
8605             goto end;
8606         if (tst == 5) {
8607             SSL_set_verify(serverssl, SSL_VERIFY_PEER, NULL);
8608             if (!TEST_true(SSL_verify_client_post_handshake(serverssl)))
8609                 goto end;
8610         }
8611         if ((tst == 4 || tst == 5)
8612                 && !TEST_true(SSL_write(serverssl, msg, sizeof(msg))))
8613             goto end;
8614         if (!TEST_int_eq(SSL_shutdown(serverssl), 1))
8615             goto end;
8616         if (tst == 4 || tst == 5) {
8617             /* Should still be able to read data from server */
8618             if (!TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf),
8619                                        &readbytes))
8620                     || !TEST_size_t_eq(readbytes, sizeof(msg))
8621                     || !TEST_int_eq(memcmp(msg, buf, readbytes), 0)
8622                     || !TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf),
8623                                               &readbytes))
8624                     || !TEST_size_t_eq(readbytes, sizeof(msg))
8625                     || !TEST_int_eq(memcmp(msg, buf, readbytes), 0))
8626                 goto end;
8627         }
8628     }
8629
8630     /* Writing on the client after sending close_notify shouldn't be possible */
8631     if (!TEST_false(SSL_write_ex(clientssl, msg, sizeof(msg), &written)))
8632         goto end;
8633
8634     if (tst < 4) {
8635         /*
8636          * For these tests the client has sent close_notify but it has not yet
8637          * been received by the server. The server has not sent close_notify
8638          * yet.
8639          */
8640         if (!TEST_int_eq(SSL_shutdown(serverssl), 0)
8641                    /*
8642                     * Writing on the server after sending close_notify shouldn't
8643                     * be possible.
8644                     */
8645                 || !TEST_false(SSL_write_ex(serverssl, msg, sizeof(msg), &written))
8646                 || !TEST_int_eq(SSL_shutdown(clientssl), 1)
8647                 || !TEST_ptr_ne(sess = SSL_get_session(clientssl), NULL)
8648                 || !TEST_true(SSL_SESSION_is_resumable(sess))
8649                 || !TEST_int_eq(SSL_shutdown(serverssl), 1))
8650             goto end;
8651     } else if (tst == 4 || tst == 5) {
8652         /*
8653          * In this test the client has sent close_notify and it has been
8654          * received by the server which has responded with a close_notify. The
8655          * client needs to read the close_notify sent by the server.
8656          */
8657         if (!TEST_int_eq(SSL_shutdown(clientssl), 1)
8658                 || !TEST_ptr_ne(sess = SSL_get_session(clientssl), NULL)
8659                 || !TEST_true(SSL_SESSION_is_resumable(sess)))
8660             goto end;
8661     } else {
8662         /*
8663          * tst == 6
8664          *
8665          * The client has sent close_notify and is expecting a close_notify
8666          * back, but instead there is application data first. The shutdown
8667          * should fail with a fatal error.
8668          */
8669         if (!TEST_int_eq(SSL_shutdown(clientssl), -1)
8670                 || !TEST_int_eq(SSL_get_error(clientssl, -1), SSL_ERROR_SSL))
8671             goto end;
8672     }
8673
8674     testresult = 1;
8675
8676  end:
8677     SSL_free(serverssl);
8678     SSL_free(clientssl);
8679     SSL_CTX_free(sctx);
8680     SSL_CTX_free(cctx);
8681
8682     return testresult;
8683 }
8684
8685 /*
8686  * Test that sending close_notify alerts works correctly in the case of a
8687  * retryable write failure.
8688  */
8689 static int test_async_shutdown(void)
8690 {
8691     SSL_CTX *cctx = NULL, *sctx = NULL;
8692     SSL *clientssl = NULL, *serverssl = NULL;
8693     int testresult = 0;
8694     BIO *bretry = BIO_new(bio_s_always_retry()), *tmp = NULL;
8695
8696     if (!TEST_ptr(bretry))
8697         goto end;
8698
8699     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
8700                                        TLS_client_method(),
8701                                        0, 0,
8702                                        &sctx, &cctx, cert, privkey)))
8703         goto end;
8704
8705     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL,
8706                                       NULL)))
8707         goto end;
8708
8709     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
8710         goto end;
8711
8712     /* Close write side of clientssl */
8713     if (!TEST_int_eq(SSL_shutdown(clientssl), 0))
8714         goto end;
8715
8716     tmp = SSL_get_wbio(serverssl);
8717     if (!TEST_true(BIO_up_ref(tmp))) {
8718         tmp = NULL;
8719         goto end;
8720     }
8721     SSL_set0_wbio(serverssl, bretry);
8722     bretry = NULL;
8723
8724     /* First server shutdown should fail because of a retrable write failure */
8725     if (!TEST_int_eq(SSL_shutdown(serverssl), -1)
8726             || !TEST_int_eq(SSL_get_error(serverssl, -1), SSL_ERROR_WANT_WRITE))
8727         goto end;
8728
8729     /* Second server shutdown should fail for the same reason */
8730     if (!TEST_int_eq(SSL_shutdown(serverssl), -1)
8731             || !TEST_int_eq(SSL_get_error(serverssl, -1), SSL_ERROR_WANT_WRITE))
8732         goto end;
8733
8734     SSL_set0_wbio(serverssl, tmp);
8735     tmp = NULL;
8736
8737     /* Third server shutdown should send close_notify */
8738     if (!TEST_int_eq(SSL_shutdown(serverssl), 0))
8739         goto end;
8740
8741     /* Fourth server shutdown should read close_notify from client and finish */
8742     if (!TEST_int_eq(SSL_shutdown(serverssl), 1))
8743         goto end;
8744
8745     /* Client should also successfully fully shutdown */
8746     if (!TEST_int_eq(SSL_shutdown(clientssl), 1))
8747         goto end;
8748
8749     testresult = 1;
8750  end:
8751     SSL_free(serverssl);
8752     SSL_free(clientssl);
8753     SSL_CTX_free(sctx);
8754     SSL_CTX_free(cctx);
8755     BIO_free(bretry);
8756     BIO_free(tmp);
8757
8758     return testresult;
8759 }
8760
8761 #if !defined(OPENSSL_NO_TLS1_2) || !defined(OSSL_NO_USABLE_TLS1_3)
8762 static int cert_cb_cnt;
8763
8764 static int cert_cb(SSL *s, void *arg)
8765 {
8766     SSL_CTX *ctx = (SSL_CTX *)arg;
8767     BIO *in = NULL;
8768     EVP_PKEY *pkey = NULL;
8769     X509 *x509 = NULL, *rootx = NULL;
8770     STACK_OF(X509) *chain = NULL;
8771     char *rootfile = NULL, *ecdsacert = NULL, *ecdsakey = NULL;
8772     int ret = 0;
8773
8774     if (cert_cb_cnt == 0) {
8775         /* Suspend the handshake */
8776         cert_cb_cnt++;
8777         return -1;
8778     } else if (cert_cb_cnt == 1) {
8779         /*
8780          * Update the SSL_CTX, set the certificate and private key and then
8781          * continue the handshake normally.
8782          */
8783         if (ctx != NULL && !TEST_ptr(SSL_set_SSL_CTX(s, ctx)))
8784             return 0;
8785
8786         if (!TEST_true(SSL_use_certificate_file(s, cert, SSL_FILETYPE_PEM))
8787                 || !TEST_true(SSL_use_PrivateKey_file(s, privkey,
8788                                                       SSL_FILETYPE_PEM))
8789                 || !TEST_true(SSL_check_private_key(s)))
8790             return 0;
8791         cert_cb_cnt++;
8792         return 1;
8793     } else if (cert_cb_cnt == 3) {
8794         int rv;
8795
8796         rootfile = test_mk_file_path(certsdir, "rootcert.pem");
8797         ecdsacert = test_mk_file_path(certsdir, "server-ecdsa-cert.pem");
8798         ecdsakey = test_mk_file_path(certsdir, "server-ecdsa-key.pem");
8799         if (!TEST_ptr(rootfile) || !TEST_ptr(ecdsacert) || !TEST_ptr(ecdsakey))
8800             goto out;
8801         chain = sk_X509_new_null();
8802         if (!TEST_ptr(chain))
8803             goto out;
8804         if (!TEST_ptr(in = BIO_new(BIO_s_file()))
8805                 || !TEST_int_gt(BIO_read_filename(in, rootfile), 0)
8806                 || !TEST_ptr(rootx = X509_new_ex(libctx, NULL))
8807                 || !TEST_ptr(PEM_read_bio_X509(in, &rootx, NULL, NULL))
8808                 || !TEST_true(sk_X509_push(chain, rootx)))
8809             goto out;
8810         rootx = NULL;
8811         BIO_free(in);
8812         if (!TEST_ptr(in = BIO_new(BIO_s_file()))
8813                 || !TEST_int_gt(BIO_read_filename(in, ecdsacert), 0)
8814                 || !TEST_ptr(x509 = X509_new_ex(libctx, NULL))
8815                 || !TEST_ptr(PEM_read_bio_X509(in, &x509, NULL, NULL)))
8816             goto out;
8817         BIO_free(in);
8818         if (!TEST_ptr(in = BIO_new(BIO_s_file()))
8819                 || !TEST_int_gt(BIO_read_filename(in, ecdsakey), 0)
8820                 || !TEST_ptr(pkey = PEM_read_bio_PrivateKey_ex(in, NULL,
8821                                                                NULL, NULL,
8822                                                                libctx, NULL)))
8823             goto out;
8824         rv = SSL_check_chain(s, x509, pkey, chain);
8825         /*
8826          * If the cert doesn't show as valid here (e.g., because we don't
8827          * have any shared sigalgs), then we will not set it, and there will
8828          * be no certificate at all on the SSL or SSL_CTX.  This, in turn,
8829          * will cause tls_choose_sigalgs() to fail the connection.
8830          */
8831         if ((rv & (CERT_PKEY_VALID | CERT_PKEY_CA_SIGNATURE))
8832                 == (CERT_PKEY_VALID | CERT_PKEY_CA_SIGNATURE)) {
8833             if (!SSL_use_cert_and_key(s, x509, pkey, NULL, 1))
8834                 goto out;
8835         }
8836
8837         ret = 1;
8838     }
8839
8840     /* Abort the handshake */
8841  out:
8842     OPENSSL_free(ecdsacert);
8843     OPENSSL_free(ecdsakey);
8844     OPENSSL_free(rootfile);
8845     BIO_free(in);
8846     EVP_PKEY_free(pkey);
8847     X509_free(x509);
8848     X509_free(rootx);
8849     OSSL_STACK_OF_X509_free(chain);
8850     return ret;
8851 }
8852
8853 /*
8854  * Test the certificate callback.
8855  * Test 0: Callback fails
8856  * Test 1: Success - no SSL_set_SSL_CTX() in the callback
8857  * Test 2: Success - SSL_set_SSL_CTX() in the callback
8858  * Test 3: Success - Call SSL_check_chain from the callback
8859  * Test 4: Failure - SSL_check_chain fails from callback due to bad cert in the
8860  *                   chain
8861  * Test 5: Failure - SSL_check_chain fails from callback due to bad ee cert
8862  */
8863 static int test_cert_cb_int(int prot, int tst)
8864 {
8865     SSL_CTX *cctx = NULL, *sctx = NULL, *snictx = NULL;
8866     SSL *clientssl = NULL, *serverssl = NULL;
8867     int testresult = 0, ret;
8868
8869 #ifdef OPENSSL_NO_EC
8870     /* We use an EC cert in these tests, so we skip in a no-ec build */
8871     if (tst >= 3)
8872         return 1;
8873 #endif
8874
8875     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
8876                                        TLS_client_method(),
8877                                        TLS1_VERSION,
8878                                        prot,
8879                                        &sctx, &cctx, NULL, NULL)))
8880         goto end;
8881
8882     if (tst == 0)
8883         cert_cb_cnt = -1;
8884     else if (tst >= 3)
8885         cert_cb_cnt = 3;
8886     else
8887         cert_cb_cnt = 0;
8888
8889     if (tst == 2) {
8890         snictx = SSL_CTX_new_ex(libctx, NULL, TLS_server_method());
8891         if (!TEST_ptr(snictx))
8892             goto end;
8893     }
8894
8895     SSL_CTX_set_cert_cb(sctx, cert_cb, snictx);
8896
8897     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
8898                                       NULL, NULL)))
8899         goto end;
8900
8901     if (tst == 4) {
8902         /*
8903          * We cause SSL_check_chain() to fail by specifying sig_algs that
8904          * the chain doesn't meet (the root uses an RSA cert)
8905          */
8906         if (!TEST_true(SSL_set1_sigalgs_list(clientssl,
8907                                              "ecdsa_secp256r1_sha256")))
8908             goto end;
8909     } else if (tst == 5) {
8910         /*
8911          * We cause SSL_check_chain() to fail by specifying sig_algs that
8912          * the ee cert doesn't meet (the ee uses an ECDSA cert)
8913          */
8914         if (!TEST_true(SSL_set1_sigalgs_list(clientssl,
8915                            "rsa_pss_rsae_sha256:rsa_pkcs1_sha256")))
8916             goto end;
8917     }
8918
8919     ret = create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE);
8920     if (!TEST_true(tst == 0 || tst == 4 || tst == 5 ? !ret : ret)
8921             || (tst > 0
8922                 && !TEST_int_eq((cert_cb_cnt - 2) * (cert_cb_cnt - 3), 0))) {
8923         goto end;
8924     }
8925
8926     testresult = 1;
8927
8928  end:
8929     SSL_free(serverssl);
8930     SSL_free(clientssl);
8931     SSL_CTX_free(sctx);
8932     SSL_CTX_free(cctx);
8933     SSL_CTX_free(snictx);
8934
8935     return testresult;
8936 }
8937 #endif
8938
8939 static int test_cert_cb(int tst)
8940 {
8941     int testresult = 1;
8942
8943 #ifndef OPENSSL_NO_TLS1_2
8944     testresult &= test_cert_cb_int(TLS1_2_VERSION, tst);
8945 #endif
8946 #ifndef OSSL_NO_USABLE_TLS1_3
8947     testresult &= test_cert_cb_int(TLS1_3_VERSION, tst);
8948 #endif
8949
8950     return testresult;
8951 }
8952
8953 static int client_cert_cb(SSL *ssl, X509 **x509, EVP_PKEY **pkey)
8954 {
8955     X509 *xcert;
8956     EVP_PKEY *privpkey;
8957     BIO *in = NULL;
8958     BIO *priv_in = NULL;
8959
8960     /* Check that SSL_get0_peer_certificate() returns something sensible */
8961     if (!TEST_ptr(SSL_get0_peer_certificate(ssl)))
8962         return 0;
8963
8964     in = BIO_new_file(cert, "r");
8965     if (!TEST_ptr(in))
8966         return 0;
8967
8968     if (!TEST_ptr(xcert = X509_new_ex(libctx, NULL))
8969             || !TEST_ptr(PEM_read_bio_X509(in, &xcert, NULL, NULL))
8970             || !TEST_ptr(priv_in = BIO_new_file(privkey, "r"))
8971             || !TEST_ptr(privpkey = PEM_read_bio_PrivateKey_ex(priv_in, NULL,
8972                                                                NULL, NULL,
8973                                                                libctx, NULL)))
8974         goto err;
8975
8976     *x509 = xcert;
8977     *pkey = privpkey;
8978
8979     BIO_free(in);
8980     BIO_free(priv_in);
8981     return 1;
8982 err:
8983     X509_free(xcert);
8984     BIO_free(in);
8985     BIO_free(priv_in);
8986     return 0;
8987 }
8988
8989 static int test_client_cert_cb(int tst)
8990 {
8991     SSL_CTX *cctx = NULL, *sctx = NULL;
8992     SSL *clientssl = NULL, *serverssl = NULL;
8993     int testresult = 0;
8994
8995 #ifdef OPENSSL_NO_TLS1_2
8996     if (tst == 0)
8997         return 1;
8998 #endif
8999 #ifdef OSSL_NO_USABLE_TLS1_3
9000     if (tst == 1)
9001         return 1;
9002 #endif
9003
9004     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
9005                                        TLS_client_method(),
9006                                        TLS1_VERSION,
9007                                        tst == 0 ? TLS1_2_VERSION
9008                                                 : TLS1_3_VERSION,
9009                                        &sctx, &cctx, cert, privkey)))
9010         goto end;
9011
9012     /*
9013      * Test that setting a client_cert_cb results in a client certificate being
9014      * sent.
9015      */
9016     SSL_CTX_set_client_cert_cb(cctx, client_cert_cb);
9017     SSL_CTX_set_verify(sctx,
9018                        SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
9019                        verify_cb);
9020
9021     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
9022                                       NULL, NULL))
9023             || !TEST_true(create_ssl_connection(serverssl, clientssl,
9024                                                 SSL_ERROR_NONE)))
9025         goto end;
9026
9027     testresult = 1;
9028
9029  end:
9030     SSL_free(serverssl);
9031     SSL_free(clientssl);
9032     SSL_CTX_free(sctx);
9033     SSL_CTX_free(cctx);
9034
9035     return testresult;
9036 }
9037
9038 #if !defined(OPENSSL_NO_TLS1_2) || !defined(OSSL_NO_USABLE_TLS1_3)
9039 /*
9040  * Test setting certificate authorities on both client and server.
9041  *
9042  * Test 0: SSL_CTX_set0_CA_list() only
9043  * Test 1: Both SSL_CTX_set0_CA_list() and SSL_CTX_set_client_CA_list()
9044  * Test 2: Only SSL_CTX_set_client_CA_list()
9045  */
9046 static int test_ca_names_int(int prot, int tst)
9047 {
9048     SSL_CTX *cctx = NULL, *sctx = NULL;
9049     SSL *clientssl = NULL, *serverssl = NULL;
9050     int testresult = 0;
9051     size_t i;
9052     X509_NAME *name[] = { NULL, NULL, NULL, NULL };
9053     char *strnames[] = { "Jack", "Jill", "John", "Joanne" };
9054     STACK_OF(X509_NAME) *sk1 = NULL, *sk2 = NULL;
9055     const STACK_OF(X509_NAME) *sktmp = NULL;
9056
9057     for (i = 0; i < OSSL_NELEM(name); i++) {
9058         name[i] = X509_NAME_new();
9059         if (!TEST_ptr(name[i])
9060                 || !TEST_true(X509_NAME_add_entry_by_txt(name[i], "CN",
9061                                                          MBSTRING_ASC,
9062                                                          (unsigned char *)
9063                                                          strnames[i],
9064                                                          -1, -1, 0)))
9065             goto end;
9066     }
9067
9068     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
9069                                        TLS_client_method(),
9070                                        TLS1_VERSION,
9071                                        prot,
9072                                        &sctx, &cctx, cert, privkey)))
9073         goto end;
9074
9075     SSL_CTX_set_verify(sctx, SSL_VERIFY_PEER, NULL);
9076
9077     if (tst == 0 || tst == 1) {
9078         if (!TEST_ptr(sk1 = sk_X509_NAME_new_null())
9079                 || !TEST_true(sk_X509_NAME_push(sk1, X509_NAME_dup(name[0])))
9080                 || !TEST_true(sk_X509_NAME_push(sk1, X509_NAME_dup(name[1])))
9081                 || !TEST_ptr(sk2 = sk_X509_NAME_new_null())
9082                 || !TEST_true(sk_X509_NAME_push(sk2, X509_NAME_dup(name[0])))
9083                 || !TEST_true(sk_X509_NAME_push(sk2, X509_NAME_dup(name[1]))))
9084             goto end;
9085
9086         SSL_CTX_set0_CA_list(sctx, sk1);
9087         SSL_CTX_set0_CA_list(cctx, sk2);
9088         sk1 = sk2 = NULL;
9089     }
9090     if (tst == 1 || tst == 2) {
9091         if (!TEST_ptr(sk1 = sk_X509_NAME_new_null())
9092                 || !TEST_true(sk_X509_NAME_push(sk1, X509_NAME_dup(name[2])))
9093                 || !TEST_true(sk_X509_NAME_push(sk1, X509_NAME_dup(name[3])))
9094                 || !TEST_ptr(sk2 = sk_X509_NAME_new_null())
9095                 || !TEST_true(sk_X509_NAME_push(sk2, X509_NAME_dup(name[2])))
9096                 || !TEST_true(sk_X509_NAME_push(sk2, X509_NAME_dup(name[3]))))
9097             goto end;
9098
9099         SSL_CTX_set_client_CA_list(sctx, sk1);
9100         SSL_CTX_set_client_CA_list(cctx, sk2);
9101         sk1 = sk2 = NULL;
9102     }
9103
9104     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
9105                                       NULL, NULL))
9106             || !TEST_true(create_ssl_connection(serverssl, clientssl,
9107                                                 SSL_ERROR_NONE)))
9108         goto end;
9109
9110     /*
9111      * We only expect certificate authorities to have been sent to the server
9112      * if we are using TLSv1.3 and SSL_set0_CA_list() was used
9113      */
9114     sktmp = SSL_get0_peer_CA_list(serverssl);
9115     if (prot == TLS1_3_VERSION
9116             && (tst == 0 || tst == 1)) {
9117         if (!TEST_ptr(sktmp)
9118                 || !TEST_int_eq(sk_X509_NAME_num(sktmp), 2)
9119                 || !TEST_int_eq(X509_NAME_cmp(sk_X509_NAME_value(sktmp, 0),
9120                                               name[0]), 0)
9121                 || !TEST_int_eq(X509_NAME_cmp(sk_X509_NAME_value(sktmp, 1),
9122                                               name[1]), 0))
9123             goto end;
9124     } else if (!TEST_ptr_null(sktmp)) {
9125         goto end;
9126     }
9127
9128     /*
9129      * In all tests we expect certificate authorities to have been sent to the
9130      * client. However, SSL_set_client_CA_list() should override
9131      * SSL_set0_CA_list()
9132      */
9133     sktmp = SSL_get0_peer_CA_list(clientssl);
9134     if (!TEST_ptr(sktmp)
9135             || !TEST_int_eq(sk_X509_NAME_num(sktmp), 2)
9136             || !TEST_int_eq(X509_NAME_cmp(sk_X509_NAME_value(sktmp, 0),
9137                                           name[tst == 0 ? 0 : 2]), 0)
9138             || !TEST_int_eq(X509_NAME_cmp(sk_X509_NAME_value(sktmp, 1),
9139                                           name[tst == 0 ? 1 : 3]), 0))
9140         goto end;
9141
9142     testresult = 1;
9143
9144  end:
9145     SSL_free(serverssl);
9146     SSL_free(clientssl);
9147     SSL_CTX_free(sctx);
9148     SSL_CTX_free(cctx);
9149     for (i = 0; i < OSSL_NELEM(name); i++)
9150         X509_NAME_free(name[i]);
9151     sk_X509_NAME_pop_free(sk1, X509_NAME_free);
9152     sk_X509_NAME_pop_free(sk2, X509_NAME_free);
9153
9154     return testresult;
9155 }
9156 #endif
9157
9158 static int test_ca_names(int tst)
9159 {
9160     int testresult = 1;
9161
9162 #ifndef OPENSSL_NO_TLS1_2
9163     testresult &= test_ca_names_int(TLS1_2_VERSION, tst);
9164 #endif
9165 #ifndef OSSL_NO_USABLE_TLS1_3
9166     testresult &= test_ca_names_int(TLS1_3_VERSION, tst);
9167 #endif
9168
9169     return testresult;
9170 }
9171
9172 #ifndef OPENSSL_NO_TLS1_2
9173 static const char *multiblock_cipherlist_data[]=
9174 {
9175     "AES128-SHA",
9176     "AES128-SHA256",
9177     "AES256-SHA",
9178     "AES256-SHA256",
9179 };
9180
9181 /* Reduce the fragment size - so the multiblock test buffer can be small */
9182 # define MULTIBLOCK_FRAGSIZE 512
9183
9184 static int test_multiblock_write(int test_index)
9185 {
9186     static const char *fetchable_ciphers[]=
9187     {
9188         "AES-128-CBC-HMAC-SHA1",
9189         "AES-128-CBC-HMAC-SHA256",
9190         "AES-256-CBC-HMAC-SHA1",
9191         "AES-256-CBC-HMAC-SHA256"
9192     };
9193     const char *cipherlist = multiblock_cipherlist_data[test_index];
9194     const SSL_METHOD *smeth = TLS_server_method();
9195     const SSL_METHOD *cmeth = TLS_client_method();
9196     int min_version = TLS1_VERSION;
9197     int max_version = TLS1_2_VERSION; /* Don't select TLS1_3 */
9198     SSL_CTX *cctx = NULL, *sctx = NULL;
9199     SSL *clientssl = NULL, *serverssl = NULL;
9200     int testresult = 0;
9201
9202     /*
9203      * Choose a buffer large enough to perform a multi-block operation
9204      * i.e: write_len >= 4 * frag_size
9205      * 9 * is chosen so that multiple multiblocks are used + some leftover.
9206      */
9207     unsigned char msg[MULTIBLOCK_FRAGSIZE * 9];
9208     unsigned char buf[sizeof(msg)], *p = buf;
9209     size_t readbytes, written, len;
9210     EVP_CIPHER *ciph = NULL;
9211
9212     /*
9213      * Check if the cipher exists before attempting to use it since it only has
9214      * a hardware specific implementation.
9215      */
9216     ciph = EVP_CIPHER_fetch(libctx, fetchable_ciphers[test_index], "");
9217     if (ciph == NULL) {
9218         TEST_skip("Multiblock cipher is not available for %s", cipherlist);
9219         return 1;
9220     }
9221     EVP_CIPHER_free(ciph);
9222
9223     /* Set up a buffer with some data that will be sent to the client */
9224     RAND_bytes(msg, sizeof(msg));
9225
9226     if (!TEST_true(create_ssl_ctx_pair(libctx, smeth, cmeth, min_version,
9227                                        max_version, &sctx, &cctx, cert,
9228                                        privkey)))
9229         goto end;
9230
9231     if (!TEST_true(SSL_CTX_set_max_send_fragment(sctx, MULTIBLOCK_FRAGSIZE)))
9232         goto end;
9233
9234     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
9235                                       NULL, NULL)))
9236             goto end;
9237
9238     /* settings to force it to use AES-CBC-HMAC_SHA */
9239     SSL_set_options(serverssl, SSL_OP_NO_ENCRYPT_THEN_MAC);
9240     if (!TEST_true(SSL_CTX_set_cipher_list(cctx, cipherlist)))
9241        goto end;
9242
9243     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
9244         goto end;
9245
9246     if (!TEST_true(SSL_write_ex(serverssl, msg, sizeof(msg), &written))
9247         || !TEST_size_t_eq(written, sizeof(msg)))
9248         goto end;
9249
9250     len = written;
9251     while (len > 0) {
9252         if (!TEST_true(SSL_read_ex(clientssl, p, MULTIBLOCK_FRAGSIZE, &readbytes)))
9253             goto end;
9254         p += readbytes;
9255         len -= readbytes;
9256     }
9257     if (!TEST_mem_eq(msg, sizeof(msg), buf, sizeof(buf)))
9258         goto end;
9259
9260     testresult = 1;
9261 end:
9262     SSL_free(serverssl);
9263     SSL_free(clientssl);
9264     SSL_CTX_free(sctx);
9265     SSL_CTX_free(cctx);
9266
9267     return testresult;
9268 }
9269 #endif /* OPENSSL_NO_TLS1_2 */
9270
9271 static int test_session_timeout(int test)
9272 {
9273     /*
9274      * Test session ordering and timeout
9275      * Can't explicitly test performance of the new code,
9276      * but can test to see if the ordering of the sessions
9277      * are correct, and they are removed as expected
9278      */
9279     SSL_SESSION *early = NULL;
9280     SSL_SESSION *middle = NULL;
9281     SSL_SESSION *late = NULL;
9282     SSL_CTX *ctx;
9283     int testresult = 0;
9284     long now = (long)time(NULL);
9285 #define TIMEOUT 10
9286
9287     if (!TEST_ptr(ctx = SSL_CTX_new_ex(libctx, NULL, TLS_method()))
9288         || !TEST_ptr(early = SSL_SESSION_new())
9289         || !TEST_ptr(middle = SSL_SESSION_new())
9290         || !TEST_ptr(late = SSL_SESSION_new()))
9291         goto end;
9292
9293     /* assign unique session ids */
9294     early->session_id_length = SSL3_SSL_SESSION_ID_LENGTH;
9295     memset(early->session_id, 1, SSL3_SSL_SESSION_ID_LENGTH);
9296     middle->session_id_length = SSL3_SSL_SESSION_ID_LENGTH;
9297     memset(middle->session_id, 2, SSL3_SSL_SESSION_ID_LENGTH);
9298     late->session_id_length = SSL3_SSL_SESSION_ID_LENGTH;
9299     memset(late->session_id, 3, SSL3_SSL_SESSION_ID_LENGTH);
9300
9301     if (!TEST_int_eq(SSL_CTX_add_session(ctx, early), 1)
9302         || !TEST_int_eq(SSL_CTX_add_session(ctx, middle), 1)
9303         || !TEST_int_eq(SSL_CTX_add_session(ctx, late), 1))
9304         goto end;
9305
9306     /* Make sure they are all added */
9307     if (!TEST_ptr(early->prev)
9308         || !TEST_ptr(middle->prev)
9309         || !TEST_ptr(late->prev))
9310         goto end;
9311
9312     if (!TEST_int_ne(SSL_SESSION_set_time(early, now - 10), 0)
9313         || !TEST_int_ne(SSL_SESSION_set_time(middle, now), 0)
9314         || !TEST_int_ne(SSL_SESSION_set_time(late, now + 10), 0))
9315         goto end;
9316
9317     if (!TEST_int_ne(SSL_SESSION_set_timeout(early, TIMEOUT), 0)
9318         || !TEST_int_ne(SSL_SESSION_set_timeout(middle, TIMEOUT), 0)
9319         || !TEST_int_ne(SSL_SESSION_set_timeout(late, TIMEOUT), 0))
9320         goto end;
9321
9322     /* Make sure they are all still there */
9323     if (!TEST_ptr(early->prev)
9324         || !TEST_ptr(middle->prev)
9325         || !TEST_ptr(late->prev))
9326         goto end;
9327
9328     /* Make sure they are in the expected order */
9329     if (!TEST_ptr_eq(late->next, middle)
9330         || !TEST_ptr_eq(middle->next, early)
9331         || !TEST_ptr_eq(early->prev, middle)
9332         || !TEST_ptr_eq(middle->prev, late))
9333         goto end;
9334
9335     /* This should remove "early" */
9336     SSL_CTX_flush_sessions(ctx, now + TIMEOUT - 1);
9337     if (!TEST_ptr_null(early->prev)
9338         || !TEST_ptr(middle->prev)
9339         || !TEST_ptr(late->prev))
9340         goto end;
9341
9342     /* This should remove "middle" */
9343     SSL_CTX_flush_sessions(ctx, now + TIMEOUT + 1);
9344     if (!TEST_ptr_null(early->prev)
9345         || !TEST_ptr_null(middle->prev)
9346         || !TEST_ptr(late->prev))
9347         goto end;
9348
9349     /* This should remove "late" */
9350     SSL_CTX_flush_sessions(ctx, now + TIMEOUT + 11);
9351     if (!TEST_ptr_null(early->prev)
9352         || !TEST_ptr_null(middle->prev)
9353         || !TEST_ptr_null(late->prev))
9354         goto end;
9355
9356     /* Add them back in again */
9357     if (!TEST_int_eq(SSL_CTX_add_session(ctx, early), 1)
9358         || !TEST_int_eq(SSL_CTX_add_session(ctx, middle), 1)
9359         || !TEST_int_eq(SSL_CTX_add_session(ctx, late), 1))
9360         goto end;
9361
9362     /* Make sure they are all added */
9363     if (!TEST_ptr(early->prev)
9364         || !TEST_ptr(middle->prev)
9365         || !TEST_ptr(late->prev))
9366         goto end;
9367
9368     /* This should remove all of them */
9369     SSL_CTX_flush_sessions(ctx, 0);
9370     if (!TEST_ptr_null(early->prev)
9371         || !TEST_ptr_null(middle->prev)
9372         || !TEST_ptr_null(late->prev))
9373         goto end;
9374
9375     (void)SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_UPDATE_TIME
9376                                          | SSL_CTX_get_session_cache_mode(ctx));
9377
9378     /* make sure |now| is NOT  equal to the current time */
9379     now -= 10;
9380     if (!TEST_int_ne(SSL_SESSION_set_time(early, now), 0)
9381         || !TEST_int_eq(SSL_CTX_add_session(ctx, early), 1)
9382         || !TEST_long_ne(SSL_SESSION_get_time(early), now))
9383         goto end;
9384
9385     testresult = 1;
9386  end:
9387     SSL_CTX_free(ctx);
9388     SSL_SESSION_free(early);
9389     SSL_SESSION_free(middle);
9390     SSL_SESSION_free(late);
9391     return testresult;
9392 }
9393
9394 /*
9395  * Test that a session cache overflow works as expected
9396  * Test 0: TLSv1.3, timeout on new session later than old session
9397  * Test 1: TLSv1.2, timeout on new session later than old session
9398  * Test 2: TLSv1.3, timeout on new session earlier than old session
9399  * Test 3: TLSv1.2, timeout on new session earlier than old session
9400  */
9401 #if !defined(OSSL_NO_USABLE_TLS1_3) || !defined(OPENSSL_NO_TLS1_2)
9402 static int test_session_cache_overflow(int idx)
9403 {
9404     SSL_CTX *sctx = NULL, *cctx = NULL;
9405     SSL *serverssl = NULL, *clientssl = NULL;
9406     int testresult = 0;
9407     SSL_SESSION *sess = NULL;
9408
9409 #ifdef OSSL_NO_USABLE_TLS1_3
9410     /* If no TLSv1.3 available then do nothing in this case */
9411     if (idx % 2 == 0)
9412         return TEST_skip("No TLSv1.3 available");
9413 #endif
9414 #ifdef OPENSSL_NO_TLS1_2
9415     /* If no TLSv1.2 available then do nothing in this case */
9416     if (idx % 2 == 1)
9417         return TEST_skip("No TLSv1.2 available");
9418 #endif
9419
9420     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
9421                                        TLS_client_method(), TLS1_VERSION,
9422                                        (idx % 2 == 0) ? TLS1_3_VERSION
9423                                                       : TLS1_2_VERSION,
9424                                        &sctx, &cctx, cert, privkey))
9425             || !TEST_true(SSL_CTX_set_options(sctx, SSL_OP_NO_TICKET)))
9426         goto end;
9427
9428     SSL_CTX_sess_set_get_cb(sctx, get_session_cb);
9429     get_sess_val = NULL;
9430
9431     SSL_CTX_sess_set_cache_size(sctx, 1);
9432
9433     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
9434                                       NULL, NULL)))
9435         goto end;
9436
9437     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
9438         goto end;
9439
9440     if (idx > 1) {
9441         sess = SSL_get_session(serverssl);
9442         if (!TEST_ptr(sess))
9443             goto end;
9444
9445         /*
9446          * Cause this session to have a longer timeout than the next session to
9447          * be added.
9448          */
9449         if (!TEST_true(SSL_SESSION_set_timeout(sess, LONG_MAX))) {
9450             sess = NULL;
9451             goto end;
9452         }
9453         sess = NULL;
9454     }
9455
9456     SSL_shutdown(serverssl);
9457     SSL_shutdown(clientssl);
9458     SSL_free(serverssl);
9459     SSL_free(clientssl);
9460     serverssl = clientssl = NULL;
9461
9462     /*
9463      * Session cache size is 1 and we already populated the cache with a session
9464      * so the next connection should cause an overflow.
9465      */
9466
9467     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
9468                                       NULL, NULL)))
9469         goto end;
9470
9471     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
9472         goto end;
9473
9474     /*
9475      * The session we just negotiated may have been already removed from the
9476      * internal cache - but we will return it anyway from our external cache.
9477      */
9478     get_sess_val = SSL_get_session(serverssl);
9479     if (!TEST_ptr(get_sess_val))
9480         goto end;
9481     sess = SSL_get1_session(clientssl);
9482     if (!TEST_ptr(sess))
9483         goto end;
9484
9485     SSL_shutdown(serverssl);
9486     SSL_shutdown(clientssl);
9487     SSL_free(serverssl);
9488     SSL_free(clientssl);
9489     serverssl = clientssl = NULL;
9490
9491     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
9492                                       NULL, NULL)))
9493         goto end;
9494
9495     if (!TEST_true(SSL_set_session(clientssl, sess)))
9496         goto end;
9497
9498     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
9499         goto end;
9500
9501     testresult = 1;
9502
9503  end:
9504     SSL_free(serverssl);
9505     SSL_free(clientssl);
9506     SSL_CTX_free(sctx);
9507     SSL_CTX_free(cctx);
9508     SSL_SESSION_free(sess);
9509
9510     return testresult;
9511 }
9512 #endif /* !defined(OSSL_NO_USABLE_TLS1_3) || !defined(OPENSSL_NO_TLS1_2) */
9513
9514 /*
9515  * Test 0: Client sets servername and server acknowledges it (TLSv1.2)
9516  * Test 1: Client sets servername and server does not acknowledge it (TLSv1.2)
9517  * Test 2: Client sets inconsistent servername on resumption (TLSv1.2)
9518  * Test 3: Client does not set servername on initial handshake (TLSv1.2)
9519  * Test 4: Client does not set servername on resumption handshake (TLSv1.2)
9520  * Test 5: Client sets servername and server acknowledges it (TLSv1.3)
9521  * Test 6: Client sets servername and server does not acknowledge it (TLSv1.3)
9522  * Test 7: Client sets inconsistent servername on resumption (TLSv1.3)
9523  * Test 8: Client does not set servername on initial handshake(TLSv1.3)
9524  * Test 9: Client does not set servername on resumption handshake (TLSv1.3)
9525  */
9526 static int test_servername(int tst)
9527 {
9528     SSL_CTX *cctx = NULL, *sctx = NULL;
9529     SSL *clientssl = NULL, *serverssl = NULL;
9530     int testresult = 0;
9531     SSL_SESSION *sess = NULL;
9532     const char *sexpectedhost = NULL, *cexpectedhost = NULL;
9533
9534 #ifdef OPENSSL_NO_TLS1_2
9535     if (tst <= 4)
9536         return 1;
9537 #endif
9538 #ifdef OSSL_NO_USABLE_TLS1_3
9539     if (tst >= 5)
9540         return 1;
9541 #endif
9542
9543     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
9544                                        TLS_client_method(),
9545                                        TLS1_VERSION,
9546                                        (tst <= 4) ? TLS1_2_VERSION
9547                                                   : TLS1_3_VERSION,
9548                                        &sctx, &cctx, cert, privkey))
9549             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
9550                                              NULL, NULL)))
9551         goto end;
9552
9553     if (tst != 1 && tst != 6) {
9554         if (!TEST_true(SSL_CTX_set_tlsext_servername_callback(sctx,
9555                                                               hostname_cb)))
9556             goto end;
9557     }
9558
9559     if (tst != 3 && tst != 8) {
9560         if (!TEST_true(SSL_set_tlsext_host_name(clientssl, "goodhost")))
9561             goto end;
9562         sexpectedhost = cexpectedhost = "goodhost";
9563     }
9564
9565     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
9566         goto end;
9567
9568     if (!TEST_str_eq(SSL_get_servername(clientssl, TLSEXT_NAMETYPE_host_name),
9569                      cexpectedhost)
9570             || !TEST_str_eq(SSL_get_servername(serverssl,
9571                                                TLSEXT_NAMETYPE_host_name),
9572                             sexpectedhost))
9573         goto end;
9574
9575     /* Now repeat with a resumption handshake */
9576
9577     if (!TEST_int_eq(SSL_shutdown(clientssl), 0)
9578             || !TEST_ptr_ne(sess = SSL_get1_session(clientssl), NULL)
9579             || !TEST_true(SSL_SESSION_is_resumable(sess))
9580             || !TEST_int_eq(SSL_shutdown(serverssl), 0))
9581         goto end;
9582
9583     SSL_free(clientssl);
9584     SSL_free(serverssl);
9585     clientssl = serverssl = NULL;
9586
9587     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL,
9588                                       NULL)))
9589         goto end;
9590
9591     if (!TEST_true(SSL_set_session(clientssl, sess)))
9592         goto end;
9593
9594     sexpectedhost = cexpectedhost = "goodhost";
9595     if (tst == 2 || tst == 7) {
9596         /* Set an inconsistent hostname */
9597         if (!TEST_true(SSL_set_tlsext_host_name(clientssl, "altgoodhost")))
9598             goto end;
9599         /*
9600          * In TLSv1.2 we expect the hostname from the original handshake, in
9601          * TLSv1.3 we expect the hostname from this handshake
9602          */
9603         if (tst == 7)
9604             sexpectedhost = cexpectedhost = "altgoodhost";
9605
9606         if (!TEST_str_eq(SSL_get_servername(clientssl,
9607                                             TLSEXT_NAMETYPE_host_name),
9608                          "altgoodhost"))
9609             goto end;
9610     } else if (tst == 4 || tst == 9) {
9611         /*
9612          * A TLSv1.3 session does not associate a session with a servername,
9613          * but a TLSv1.2 session does.
9614          */
9615         if (tst == 9)
9616             sexpectedhost = cexpectedhost = NULL;
9617
9618         if (!TEST_str_eq(SSL_get_servername(clientssl,
9619                                             TLSEXT_NAMETYPE_host_name),
9620                          cexpectedhost))
9621             goto end;
9622     } else {
9623         if (!TEST_true(SSL_set_tlsext_host_name(clientssl, "goodhost")))
9624             goto end;
9625         /*
9626          * In a TLSv1.2 resumption where the hostname was not acknowledged
9627          * we expect the hostname on the server to be empty. On the client we
9628          * return what was requested in this case.
9629          *
9630          * Similarly if the client didn't set a hostname on an original TLSv1.2
9631          * session but is now, the server hostname will be empty, but the client
9632          * is as we set it.
9633          */
9634         if (tst == 1 || tst == 3)
9635             sexpectedhost = NULL;
9636
9637         if (!TEST_str_eq(SSL_get_servername(clientssl,
9638                                             TLSEXT_NAMETYPE_host_name),
9639                          "goodhost"))
9640             goto end;
9641     }
9642
9643     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
9644         goto end;
9645
9646     if (!TEST_true(SSL_session_reused(clientssl))
9647             || !TEST_true(SSL_session_reused(serverssl))
9648             || !TEST_str_eq(SSL_get_servername(clientssl,
9649                                                TLSEXT_NAMETYPE_host_name),
9650                             cexpectedhost)
9651             || !TEST_str_eq(SSL_get_servername(serverssl,
9652                                                TLSEXT_NAMETYPE_host_name),
9653                             sexpectedhost))
9654         goto end;
9655
9656     testresult = 1;
9657
9658  end:
9659     SSL_SESSION_free(sess);
9660     SSL_free(serverssl);
9661     SSL_free(clientssl);
9662     SSL_CTX_free(sctx);
9663     SSL_CTX_free(cctx);
9664
9665     return testresult;
9666 }
9667
9668 static int test_unknown_sigalgs_groups(void)
9669 {
9670     int ret = 0;
9671     SSL_CTX *ctx = NULL;
9672
9673     if (!TEST_ptr(ctx = SSL_CTX_new_ex(libctx, NULL, TLS_server_method())))
9674         goto end;
9675
9676     if (!TEST_int_gt(SSL_CTX_set1_sigalgs_list(ctx,
9677                                                "RSA+SHA256:?nonexistent:?RSA+SHA512"),
9678                                                0))
9679         goto end;
9680     if (!TEST_size_t_eq(ctx->cert->conf_sigalgslen, 2)
9681         || !TEST_int_eq(ctx->cert->conf_sigalgs[0], TLSEXT_SIGALG_rsa_pkcs1_sha256)
9682         || !TEST_int_eq(ctx->cert->conf_sigalgs[1], TLSEXT_SIGALG_rsa_pkcs1_sha512))
9683         goto end;
9684
9685     if (!TEST_int_gt(SSL_CTX_set1_client_sigalgs_list(ctx,
9686                                                       "RSA+SHA256:?nonexistent:?RSA+SHA512"),
9687                                                       0))
9688         goto end;
9689     if (!TEST_size_t_eq(ctx->cert->client_sigalgslen, 2)
9690         || !TEST_int_eq(ctx->cert->client_sigalgs[0], TLSEXT_SIGALG_rsa_pkcs1_sha256)
9691         || !TEST_int_eq(ctx->cert->client_sigalgs[1], TLSEXT_SIGALG_rsa_pkcs1_sha512))
9692         goto end;
9693
9694     if (!TEST_int_le(SSL_CTX_set1_groups_list(ctx,
9695                                               "nonexistent"),
9696                                               0))
9697         goto end;
9698
9699     if (!TEST_int_le(SSL_CTX_set1_groups_list(ctx,
9700                                               "?nonexistent1:?nonexistent2:?nonexistent3"),
9701                                               0))
9702         goto end;
9703
9704 #ifndef OPENSSL_NO_EC
9705     if (!TEST_int_le(SSL_CTX_set1_groups_list(ctx,
9706                                               "P-256:nonexistent"),
9707                                               0))
9708         goto end;
9709
9710     if (!TEST_int_gt(SSL_CTX_set1_groups_list(ctx,
9711                                               "P-384:?nonexistent:?P-521"),
9712                                               0))
9713         goto end;
9714     if (!TEST_size_t_eq(ctx->ext.supportedgroups_len, 2)
9715         || !TEST_int_eq(ctx->ext.supportedgroups[0], OSSL_TLS_GROUP_ID_secp384r1)
9716         || !TEST_int_eq(ctx->ext.supportedgroups[1], OSSL_TLS_GROUP_ID_secp521r1))
9717         goto end;
9718 #endif
9719
9720     ret = 1;
9721  end:
9722     SSL_CTX_free(ctx);
9723     return ret;
9724 }
9725
9726 #if !defined(OPENSSL_NO_EC) \
9727     && (!defined(OSSL_NO_USABLE_TLS1_3) || !defined(OPENSSL_NO_TLS1_2))
9728 /*
9729  * Test that if signature algorithms are not available, then we do not offer or
9730  * accept them.
9731  * Test 0: Two RSA sig algs available: both RSA sig algs shared
9732  * Test 1: The client only has SHA2-256: only SHA2-256 algorithms shared
9733  * Test 2: The server only has SHA2-256: only SHA2-256 algorithms shared
9734  * Test 3: An RSA and an ECDSA sig alg available: both sig algs shared
9735  * Test 4: The client only has an ECDSA sig alg: only ECDSA algorithms shared
9736  * Test 5: The server only has an ECDSA sig alg: only ECDSA algorithms shared
9737  */
9738 static int test_sigalgs_available(int idx)
9739 {
9740     SSL_CTX *cctx = NULL, *sctx = NULL;
9741     SSL *clientssl = NULL, *serverssl = NULL;
9742     int testresult = 0;
9743     OSSL_LIB_CTX *tmpctx = OSSL_LIB_CTX_new();
9744     OSSL_LIB_CTX *clientctx = libctx, *serverctx = libctx;
9745     OSSL_PROVIDER *filterprov = NULL;
9746     int sig, hash;
9747
9748     if (!TEST_ptr(tmpctx))
9749         goto end;
9750
9751     if (idx != 0 && idx != 3) {
9752         if (!TEST_true(OSSL_PROVIDER_add_builtin(tmpctx, "filter",
9753                                                  filter_provider_init)))
9754             goto end;
9755
9756         filterprov = OSSL_PROVIDER_load(tmpctx, "filter");
9757         if (!TEST_ptr(filterprov))
9758             goto end;
9759
9760         if (idx < 3) {
9761             /*
9762              * Only enable SHA2-256 so rsa_pss_rsae_sha384 should not be offered
9763              * or accepted for the peer that uses this libctx. Note that libssl
9764              * *requires* SHA2-256 to be available so we cannot disable that. We
9765              * also need SHA1 for our certificate.
9766              */
9767             if (!TEST_true(filter_provider_set_filter(OSSL_OP_DIGEST,
9768                                                       "SHA2-256:SHA1")))
9769                 goto end;
9770         } else {
9771             if (!TEST_true(filter_provider_set_filter(OSSL_OP_SIGNATURE,
9772                                                       "ECDSA"))
9773 # ifdef OPENSSL_NO_ECX
9774                     || !TEST_true(filter_provider_set_filter(OSSL_OP_KEYMGMT, "EC"))
9775 # else
9776                     || !TEST_true(filter_provider_set_filter(OSSL_OP_KEYMGMT,
9777                                                              "EC:X25519:X448"))
9778 # endif
9779                 )
9780                 goto end;
9781         }
9782
9783         if (idx == 1 || idx == 4)
9784             clientctx = tmpctx;
9785         else
9786             serverctx = tmpctx;
9787     }
9788
9789     cctx = SSL_CTX_new_ex(clientctx, NULL, TLS_client_method());
9790     sctx = SSL_CTX_new_ex(serverctx, NULL, TLS_server_method());
9791     if (!TEST_ptr(cctx) || !TEST_ptr(sctx))
9792         goto end;
9793
9794     if (idx != 5) {
9795         if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
9796                                            TLS_client_method(),
9797                                            TLS1_VERSION,
9798                                            0,
9799                                            &sctx, &cctx, cert, privkey)))
9800             goto end;
9801     } else {
9802         if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
9803                                            TLS_client_method(),
9804                                            TLS1_VERSION,
9805                                            0,
9806                                            &sctx, &cctx, cert2, privkey2)))
9807             goto end;
9808     }
9809
9810     /* Ensure we only use TLSv1.2 ciphersuites based on SHA256 */
9811     if (idx < 4) {
9812         if (!TEST_true(SSL_CTX_set_cipher_list(cctx,
9813                                                "ECDHE-RSA-AES128-GCM-SHA256")))
9814             goto end;
9815     } else {
9816         if (!TEST_true(SSL_CTX_set_cipher_list(cctx,
9817                                                "ECDHE-ECDSA-AES128-GCM-SHA256")))
9818             goto end;
9819     }
9820
9821     if (idx < 3) {
9822         if (!SSL_CTX_set1_sigalgs_list(cctx,
9823                                        "rsa_pss_rsae_sha384"
9824                                        ":rsa_pss_rsae_sha256")
9825                 || !SSL_CTX_set1_sigalgs_list(sctx,
9826                                               "rsa_pss_rsae_sha384"
9827                                               ":rsa_pss_rsae_sha256"))
9828             goto end;
9829     } else {
9830         if (!SSL_CTX_set1_sigalgs_list(cctx, "rsa_pss_rsae_sha256:ECDSA+SHA256")
9831                 || !SSL_CTX_set1_sigalgs_list(sctx,
9832                                               "rsa_pss_rsae_sha256:ECDSA+SHA256"))
9833             goto end;
9834     }
9835
9836     if (idx != 5
9837         && (!TEST_int_eq(SSL_CTX_use_certificate_file(sctx, cert2,
9838                                                       SSL_FILETYPE_PEM), 1)
9839             || !TEST_int_eq(SSL_CTX_use_PrivateKey_file(sctx,
9840                                                         privkey2,
9841                                                         SSL_FILETYPE_PEM), 1)
9842             || !TEST_int_eq(SSL_CTX_check_private_key(sctx), 1)))
9843         goto end;
9844
9845     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
9846                                       NULL, NULL)))
9847         goto end;
9848
9849     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
9850         goto end;
9851
9852     /* For tests 0 and 3 we expect 2 shared sigalgs, otherwise exactly 1 */
9853     if (!TEST_int_eq(SSL_get_shared_sigalgs(serverssl, 0, &sig, &hash, NULL,
9854                                             NULL, NULL),
9855                      (idx == 0 || idx == 3) ? 2 : 1))
9856         goto end;
9857
9858     if (!TEST_int_eq(hash, idx == 0 ? NID_sha384 : NID_sha256))
9859         goto end;
9860
9861     if (!TEST_int_eq(sig, (idx == 4 || idx == 5) ? EVP_PKEY_EC
9862                                                  : NID_rsassaPss))
9863         goto end;
9864
9865     testresult = filter_provider_check_clean_finish();
9866
9867  end:
9868     SSL_free(serverssl);
9869     SSL_free(clientssl);
9870     SSL_CTX_free(sctx);
9871     SSL_CTX_free(cctx);
9872     OSSL_PROVIDER_unload(filterprov);
9873     OSSL_LIB_CTX_free(tmpctx);
9874
9875     return testresult;
9876 }
9877 #endif /*
9878         * !defined(OPENSSL_NO_EC) \
9879         * && (!defined(OSSL_NO_USABLE_TLS1_3) || !defined(OPENSSL_NO_TLS1_2))
9880         */
9881
9882 #ifndef OPENSSL_NO_TLS1_3
9883 /* This test can run in TLSv1.3 even if ec and dh are disabled */
9884 static int test_pluggable_group(int idx)
9885 {
9886     SSL_CTX *cctx = NULL, *sctx = NULL;
9887     SSL *clientssl = NULL, *serverssl = NULL;
9888     int testresult = 0;
9889     OSSL_PROVIDER *tlsprov = OSSL_PROVIDER_load(libctx, "tls-provider");
9890     /* Check that we are not impacted by a provider without any groups */
9891     OSSL_PROVIDER *legacyprov = OSSL_PROVIDER_load(libctx, "legacy");
9892     const char *group_name = idx == 0 ? "xorkemgroup" : "xorgroup";
9893
9894     if (!TEST_ptr(tlsprov))
9895         goto end;
9896
9897     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
9898                                        TLS_client_method(),
9899                                        TLS1_3_VERSION,
9900                                        TLS1_3_VERSION,
9901                                        &sctx, &cctx, cert, privkey))
9902             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
9903                                              NULL, NULL)))
9904         goto end;
9905
9906     /* ensure GROUPLIST_INCREMENT (=40) logic triggers: */
9907     if (!TEST_true(SSL_set1_groups_list(serverssl, "xorgroup:xorkemgroup:dummy1:dummy2:dummy3:dummy4:dummy5:dummy6:dummy7:dummy8:dummy9:dummy10:dummy11:dummy12:dummy13:dummy14:dummy15:dummy16:dummy17:dummy18:dummy19:dummy20:dummy21:dummy22:dummy23:dummy24:dummy25:dummy26:dummy27:dummy28:dummy29:dummy30:dummy31:dummy32:dummy33:dummy34:dummy35:dummy36:dummy37:dummy38:dummy39:dummy40:dummy41:dummy42:dummy43"))
9908     /* removing a single algorithm from the list makes the test pass */
9909             || !TEST_true(SSL_set1_groups_list(clientssl, group_name)))
9910         goto end;
9911
9912     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
9913         goto end;
9914
9915     if (!TEST_str_eq(group_name,
9916                      SSL_group_to_name(serverssl, SSL_get_shared_group(serverssl, 0))))
9917         goto end;
9918
9919     if (!TEST_str_eq(group_name, SSL_get0_group_name(serverssl))
9920         || !TEST_str_eq(group_name, SSL_get0_group_name(clientssl)))
9921         goto end;
9922
9923     testresult = 1;
9924
9925  end:
9926     SSL_free(serverssl);
9927     SSL_free(clientssl);
9928     SSL_CTX_free(sctx);
9929     SSL_CTX_free(cctx);
9930     OSSL_PROVIDER_unload(tlsprov);
9931     OSSL_PROVIDER_unload(legacyprov);
9932
9933     return testresult;
9934 }
9935
9936 /*
9937  * This function triggers encode, decode and sign functions
9938  * of the artificial "xorhmacsig" algorithm implemented in tls-provider
9939  * creating private key and certificate files for use in TLS testing.
9940  */
9941 static int create_cert_key(int idx, char *certfilename, char *privkeyfilename)
9942 {
9943     EVP_PKEY_CTX *evpctx = EVP_PKEY_CTX_new_from_name(libctx,
9944                              (idx == 0) ? "xorhmacsig" : "xorhmacsha2sig", NULL);
9945     EVP_PKEY *pkey = NULL;
9946     X509 *x509 = X509_new();
9947     X509_NAME *name = NULL;
9948     BIO *keybio = NULL, *certbio = NULL;
9949     int ret = 1;
9950
9951     if (!TEST_ptr(evpctx)
9952         || !TEST_true(EVP_PKEY_keygen_init(evpctx))
9953         || !TEST_true(EVP_PKEY_generate(evpctx, &pkey))
9954         || !TEST_ptr(pkey)
9955         || !TEST_ptr(x509)
9956         || !TEST_true(ASN1_INTEGER_set(X509_get_serialNumber(x509), 1))
9957         || !TEST_true(X509_gmtime_adj(X509_getm_notBefore(x509), 0))
9958         || !TEST_true(X509_gmtime_adj(X509_getm_notAfter(x509), 31536000L))
9959         || !TEST_true(X509_set_pubkey(x509, pkey))
9960         || !TEST_ptr(name = X509_get_subject_name(x509))
9961         || !TEST_true(X509_NAME_add_entry_by_txt(name, "C",  MBSTRING_ASC,
9962                            (unsigned char *)"CH", -1, -1, 0))
9963         || !TEST_true(X509_NAME_add_entry_by_txt(name, "O",  MBSTRING_ASC,
9964                            (unsigned char *)"test.org", -1, -1, 0))
9965         || !TEST_true(X509_NAME_add_entry_by_txt(name, "CN", MBSTRING_ASC,
9966                            (unsigned char *)"localhost", -1, -1, 0))
9967         || !TEST_true(X509_set_issuer_name(x509, name))
9968         || !TEST_true(X509_sign(x509, pkey, EVP_sha1()))
9969         || !TEST_ptr(keybio = BIO_new_file(privkeyfilename, "wb"))
9970         || !TEST_true(PEM_write_bio_PrivateKey(keybio, pkey, NULL, NULL, 0, NULL, NULL))
9971         || !TEST_ptr(certbio = BIO_new_file(certfilename, "wb"))
9972         || !TEST_true(PEM_write_bio_X509(certbio, x509)))
9973         ret = 0;
9974
9975     EVP_PKEY_free(pkey);
9976     X509_free(x509);
9977     EVP_PKEY_CTX_free(evpctx);
9978     BIO_free(keybio);
9979     BIO_free(certbio);
9980     return ret;
9981 }
9982
9983 /*
9984  * Test that signature algorithms loaded via the provider interface can
9985  * correctly establish a TLS (1.3) connection.
9986  * Test 0: Signature algorithm with built-in hashing functionality: "xorhmacsig"
9987  * Test 1: Signature algorithm using external SHA2 hashing: "xorhmacsha2sig"
9988  * Test 2: Test 0 using RPK
9989  * Test 3: Test 1 using RPK
9990  */
9991 static int test_pluggable_signature(int idx)
9992 {
9993     static const unsigned char cert_type_rpk[] = { TLSEXT_cert_type_rpk, TLSEXT_cert_type_x509 };
9994     SSL_CTX *cctx = NULL, *sctx = NULL;
9995     SSL *clientssl = NULL, *serverssl = NULL;
9996     int testresult = 0;
9997     OSSL_PROVIDER *tlsprov = OSSL_PROVIDER_load(libctx, "tls-provider");
9998     OSSL_PROVIDER *defaultprov = OSSL_PROVIDER_load(libctx, "default");
9999     char *certfilename = "tls-prov-cert.pem";
10000     char *privkeyfilename = "tls-prov-key.pem";
10001     int sigidx = idx % 2;
10002     int rpkidx = idx / 2;
10003
10004     /* create key and certificate for the different algorithm types */
10005     if (!TEST_ptr(tlsprov)
10006         || !TEST_true(create_cert_key(sigidx, certfilename, privkeyfilename)))
10007         goto end;
10008
10009     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
10010                                        TLS_client_method(),
10011                                        TLS1_3_VERSION,
10012                                        TLS1_3_VERSION,
10013                                        &sctx, &cctx, certfilename, privkeyfilename))
10014             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
10015                                              NULL, NULL)))
10016         goto end;
10017
10018     /* Enable RPK for server cert */
10019     if (rpkidx) {
10020         if (!TEST_true(SSL_set1_server_cert_type(serverssl, cert_type_rpk, sizeof(cert_type_rpk)))
10021                 || !TEST_true(SSL_set1_server_cert_type(clientssl, cert_type_rpk, sizeof(cert_type_rpk))))
10022             goto end;
10023     }
10024
10025     /* This is necessary to pass minimal setup w/o other groups configured */
10026     if (!TEST_true(SSL_set1_groups_list(serverssl, "xorgroup"))
10027             || !TEST_true(SSL_set1_groups_list(clientssl, "xorgroup")))
10028         goto end;
10029
10030     /*
10031      * If this connection gets established, it must have been completed
10032      * via the tls-provider-implemented "hmacsig" algorithm, testing
10033      * both sign and verify functions during handshake.
10034      */
10035     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
10036         goto end;
10037
10038     /* If using RPK, make sure we got one */
10039     if (rpkidx && !TEST_long_eq(SSL_get_verify_result(clientssl), X509_V_ERR_RPK_UNTRUSTED))
10040         goto end;
10041
10042     testresult = 1;
10043
10044  end:
10045     SSL_free(serverssl);
10046     SSL_free(clientssl);
10047     SSL_CTX_free(sctx);
10048     SSL_CTX_free(cctx);
10049     OSSL_PROVIDER_unload(tlsprov);
10050     OSSL_PROVIDER_unload(defaultprov);
10051
10052     return testresult;
10053 }
10054 #endif
10055
10056 #ifndef OPENSSL_NO_TLS1_2
10057 static int test_ssl_dup(void)
10058 {
10059     SSL_CTX *cctx = NULL, *sctx = NULL;
10060     SSL *clientssl = NULL, *serverssl = NULL, *client2ssl = NULL;
10061     int testresult = 0;
10062     BIO *rbio = NULL, *wbio = NULL;
10063
10064     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
10065                                        TLS_client_method(),
10066                                        0,
10067                                        0,
10068                                        &sctx, &cctx, cert, privkey)))
10069         goto end;
10070
10071     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
10072                                              NULL, NULL)))
10073         goto end;
10074
10075     if (!TEST_true(SSL_set_min_proto_version(clientssl, TLS1_2_VERSION))
10076             || !TEST_true(SSL_set_max_proto_version(clientssl, TLS1_2_VERSION)))
10077         goto end;
10078
10079     client2ssl = SSL_dup(clientssl);
10080     rbio = SSL_get_rbio(clientssl);
10081     if (!TEST_ptr(rbio)
10082             || !TEST_true(BIO_up_ref(rbio)))
10083         goto end;
10084     SSL_set0_rbio(client2ssl, rbio);
10085     rbio = NULL;
10086
10087     wbio = SSL_get_wbio(clientssl);
10088     if (!TEST_ptr(wbio) || !TEST_true(BIO_up_ref(wbio)))
10089         goto end;
10090     SSL_set0_wbio(client2ssl, wbio);
10091     rbio = NULL;
10092
10093     if (!TEST_ptr(client2ssl)
10094                /* Handshake not started so pointers should be different */
10095             || !TEST_ptr_ne(clientssl, client2ssl))
10096         goto end;
10097
10098     if (!TEST_int_eq(SSL_get_min_proto_version(client2ssl), TLS1_2_VERSION)
10099             || !TEST_int_eq(SSL_get_max_proto_version(client2ssl), TLS1_2_VERSION))
10100         goto end;
10101
10102     if (!TEST_true(create_ssl_connection(serverssl, client2ssl, SSL_ERROR_NONE)))
10103         goto end;
10104
10105     SSL_free(clientssl);
10106     clientssl = SSL_dup(client2ssl);
10107     if (!TEST_ptr(clientssl)
10108                /* Handshake has finished so pointers should be the same */
10109             || !TEST_ptr_eq(clientssl, client2ssl))
10110         goto end;
10111
10112     testresult = 1;
10113
10114  end:
10115     SSL_free(serverssl);
10116     SSL_free(clientssl);
10117     SSL_free(client2ssl);
10118     SSL_CTX_free(sctx);
10119     SSL_CTX_free(cctx);
10120
10121     return testresult;
10122 }
10123
10124 # ifndef OPENSSL_NO_DH
10125
10126 static EVP_PKEY *tmp_dh_params = NULL;
10127
10128 /* Helper function for the test_set_tmp_dh() tests */
10129 static EVP_PKEY *get_tmp_dh_params(void)
10130 {
10131     if (tmp_dh_params == NULL) {
10132         BIGNUM *p = NULL;
10133         OSSL_PARAM_BLD *tmpl = NULL;
10134         EVP_PKEY_CTX *pctx = NULL;
10135         OSSL_PARAM *params = NULL;
10136         EVP_PKEY *dhpkey = NULL;
10137
10138         p = BN_get_rfc3526_prime_2048(NULL);
10139         if (!TEST_ptr(p))
10140             goto end;
10141
10142         pctx = EVP_PKEY_CTX_new_from_name(libctx, "DH", NULL);
10143         if (!TEST_ptr(pctx)
10144                 || !TEST_int_eq(EVP_PKEY_fromdata_init(pctx), 1))
10145             goto end;
10146
10147         tmpl = OSSL_PARAM_BLD_new();
10148         if (!TEST_ptr(tmpl)
10149                 || !TEST_true(OSSL_PARAM_BLD_push_BN(tmpl,
10150                                                         OSSL_PKEY_PARAM_FFC_P,
10151                                                         p))
10152                 || !TEST_true(OSSL_PARAM_BLD_push_uint(tmpl,
10153                                                         OSSL_PKEY_PARAM_FFC_G,
10154                                                         2)))
10155             goto end;
10156
10157         params = OSSL_PARAM_BLD_to_param(tmpl);
10158         if (!TEST_ptr(params)
10159                 || !TEST_int_eq(EVP_PKEY_fromdata(pctx, &dhpkey,
10160                                                   EVP_PKEY_KEY_PARAMETERS,
10161                                                   params), 1))
10162             goto end;
10163
10164         tmp_dh_params = dhpkey;
10165     end:
10166         BN_free(p);
10167         EVP_PKEY_CTX_free(pctx);
10168         OSSL_PARAM_BLD_free(tmpl);
10169         OSSL_PARAM_free(params);
10170     }
10171
10172     if (tmp_dh_params != NULL && !EVP_PKEY_up_ref(tmp_dh_params))
10173         return NULL;
10174
10175     return tmp_dh_params;
10176 }
10177
10178 #  ifndef OPENSSL_NO_DEPRECATED_3_0
10179 /* Callback used by test_set_tmp_dh() */
10180 static DH *tmp_dh_callback(SSL *s, int is_export, int keylen)
10181 {
10182     EVP_PKEY *dhpkey = get_tmp_dh_params();
10183     DH *ret = NULL;
10184
10185     if (!TEST_ptr(dhpkey))
10186         return NULL;
10187
10188     /*
10189      * libssl does not free the returned DH, so we free it now knowing that even
10190      * after we free dhpkey, there will still be a reference to the owning
10191      * EVP_PKEY in tmp_dh_params, and so the DH object will live for the length
10192      * of time we need it for.
10193      */
10194     ret = EVP_PKEY_get1_DH(dhpkey);
10195     DH_free(ret);
10196
10197     EVP_PKEY_free(dhpkey);
10198
10199     return ret;
10200 }
10201 #  endif
10202
10203 /*
10204  * Test the various methods for setting temporary DH parameters
10205  *
10206  * Test  0: Default (no auto) setting
10207  * Test  1: Explicit SSL_CTX auto off
10208  * Test  2: Explicit SSL auto off
10209  * Test  3: Explicit SSL_CTX auto on
10210  * Test  4: Explicit SSL auto on
10211  * Test  5: Explicit SSL_CTX auto off, custom DH params via EVP_PKEY
10212  * Test  6: Explicit SSL auto off, custom DH params via EVP_PKEY
10213  *
10214  * The following are testing deprecated APIs, so we only run them if available
10215  * Test  7: Explicit SSL_CTX auto off, custom DH params via DH
10216  * Test  8: Explicit SSL auto off, custom DH params via DH
10217  * Test  9: Explicit SSL_CTX auto off, custom DH params via callback
10218  * Test 10: Explicit SSL auto off, custom DH params via callback
10219  */
10220 static int test_set_tmp_dh(int idx)
10221 {
10222     SSL_CTX *cctx = NULL, *sctx = NULL;
10223     SSL *clientssl = NULL, *serverssl = NULL;
10224     int testresult = 0;
10225     int dhauto = (idx == 3 || idx == 4) ? 1 : 0;
10226     int expected = (idx <= 2) ? 0 : 1;
10227     EVP_PKEY *dhpkey = NULL;
10228 #  ifndef OPENSSL_NO_DEPRECATED_3_0
10229     DH *dh = NULL;
10230 #  else
10231
10232     if (idx >= 7)
10233         return 1;
10234 #  endif
10235
10236     if (idx >= 5 && idx <= 8) {
10237         dhpkey = get_tmp_dh_params();
10238         if (!TEST_ptr(dhpkey))
10239             goto end;
10240     }
10241 #  ifndef OPENSSL_NO_DEPRECATED_3_0
10242     if (idx == 7 || idx == 8) {
10243         dh = EVP_PKEY_get1_DH(dhpkey);
10244         if (!TEST_ptr(dh))
10245             goto end;
10246     }
10247 #  endif
10248
10249     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
10250                                        TLS_client_method(),
10251                                        0,
10252                                        0,
10253                                        &sctx, &cctx, cert, privkey)))
10254         goto end;
10255
10256     if ((idx & 1) == 1) {
10257         if (!TEST_true(SSL_CTX_set_dh_auto(sctx, dhauto)))
10258             goto end;
10259     }
10260
10261     if (idx == 5) {
10262         if (!TEST_true(SSL_CTX_set0_tmp_dh_pkey(sctx, dhpkey)))
10263             goto end;
10264         dhpkey = NULL;
10265     }
10266 #  ifndef OPENSSL_NO_DEPRECATED_3_0
10267     else if (idx == 7) {
10268         if (!TEST_true(SSL_CTX_set_tmp_dh(sctx, dh)))
10269             goto end;
10270     } else if (idx == 9) {
10271         SSL_CTX_set_tmp_dh_callback(sctx, tmp_dh_callback);
10272     }
10273 #  endif
10274
10275     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
10276                                       NULL, NULL)))
10277         goto end;
10278
10279     if ((idx & 1) == 0 && idx != 0) {
10280         if (!TEST_true(SSL_set_dh_auto(serverssl, dhauto)))
10281             goto end;
10282     }
10283     if (idx == 6) {
10284         if (!TEST_true(SSL_set0_tmp_dh_pkey(serverssl, dhpkey)))
10285             goto end;
10286         dhpkey = NULL;
10287     }
10288 #  ifndef OPENSSL_NO_DEPRECATED_3_0
10289     else if (idx == 8) {
10290         if (!TEST_true(SSL_set_tmp_dh(serverssl, dh)))
10291             goto end;
10292     } else if (idx == 10) {
10293         SSL_set_tmp_dh_callback(serverssl, tmp_dh_callback);
10294     }
10295 #  endif
10296
10297     if (!TEST_true(SSL_set_min_proto_version(serverssl, TLS1_2_VERSION))
10298             || !TEST_true(SSL_set_max_proto_version(serverssl, TLS1_2_VERSION))
10299             || !TEST_true(SSL_set_cipher_list(serverssl, "DHE-RSA-AES128-SHA")))
10300         goto end;
10301
10302     /*
10303      * If autoon then we should succeed. Otherwise we expect failure because
10304      * there are no parameters
10305      */
10306     if (!TEST_int_eq(create_ssl_connection(serverssl, clientssl,
10307                                            SSL_ERROR_NONE), expected))
10308         goto end;
10309
10310     testresult = 1;
10311
10312  end:
10313 #  ifndef OPENSSL_NO_DEPRECATED_3_0
10314     DH_free(dh);
10315 #  endif
10316     SSL_free(serverssl);
10317     SSL_free(clientssl);
10318     SSL_CTX_free(sctx);
10319     SSL_CTX_free(cctx);
10320     EVP_PKEY_free(dhpkey);
10321
10322     return testresult;
10323 }
10324
10325 /*
10326  * Test the auto DH keys are appropriately sized
10327  */
10328 static int test_dh_auto(int idx)
10329 {
10330     SSL_CTX *cctx = SSL_CTX_new_ex(libctx, NULL, TLS_client_method());
10331     SSL_CTX *sctx = SSL_CTX_new_ex(libctx, NULL, TLS_server_method());
10332     SSL *clientssl = NULL, *serverssl = NULL;
10333     int testresult = 0;
10334     EVP_PKEY *tmpkey = NULL;
10335     char *thiscert = NULL, *thiskey = NULL;
10336     size_t expdhsize = 0;
10337     const char *ciphersuite = "DHE-RSA-AES128-SHA";
10338
10339     if (!TEST_ptr(sctx) || !TEST_ptr(cctx))
10340         goto end;
10341
10342     switch (idx) {
10343     case 0:
10344         /* The FIPS provider doesn't support this DH size - so we ignore it */
10345         if (is_fips) {
10346             testresult = 1;
10347             goto end;
10348         }
10349         thiscert = cert1024;
10350         thiskey = privkey1024;
10351         expdhsize = 1024;
10352         SSL_CTX_set_security_level(sctx, 1);
10353         SSL_CTX_set_security_level(cctx, 1);
10354         break;
10355     case 1:
10356         /* 2048 bit prime */
10357         thiscert = cert;
10358         thiskey = privkey;
10359         expdhsize = 2048;
10360         break;
10361     case 2:
10362         thiscert = cert3072;
10363         thiskey = privkey3072;
10364         expdhsize = 3072;
10365         break;
10366     case 3:
10367         thiscert = cert4096;
10368         thiskey = privkey4096;
10369         expdhsize = 4096;
10370         break;
10371     case 4:
10372         thiscert = cert8192;
10373         thiskey = privkey8192;
10374         expdhsize = 8192;
10375         break;
10376     /* No certificate cases */
10377     case 5:
10378         /* The FIPS provider doesn't support this DH size - so we ignore it */
10379         if (is_fips) {
10380             testresult = 1;
10381             goto end;
10382         }
10383         ciphersuite = "ADH-AES128-SHA256:@SECLEVEL=0";
10384         expdhsize = 1024;
10385         break;
10386     case 6:
10387         ciphersuite = "ADH-AES256-SHA256:@SECLEVEL=0";
10388         expdhsize = 3072;
10389         break;
10390     default:
10391         TEST_error("Invalid text index");
10392         goto end;
10393     }
10394
10395     if (!TEST_true(create_ssl_ctx_pair(libctx, NULL,
10396                                        NULL,
10397                                        0,
10398                                        0,
10399                                        &sctx, &cctx, thiscert, thiskey)))
10400         goto end;
10401
10402     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
10403                                       NULL, NULL)))
10404         goto end;
10405
10406     if (!TEST_true(SSL_set_dh_auto(serverssl, 1))
10407             || !TEST_true(SSL_set_min_proto_version(serverssl, TLS1_2_VERSION))
10408             || !TEST_true(SSL_set_max_proto_version(serverssl, TLS1_2_VERSION))
10409             || !TEST_true(SSL_set_cipher_list(serverssl, ciphersuite))
10410             || !TEST_true(SSL_set_cipher_list(clientssl, ciphersuite)))
10411         goto end;
10412
10413     /*
10414      * Send the server's first flight. At this point the server has created the
10415      * temporary DH key but hasn't finished using it yet. Once used it is
10416      * removed, so we cannot test it.
10417      */
10418     if (!TEST_int_le(SSL_connect(clientssl), 0)
10419             || !TEST_int_le(SSL_accept(serverssl), 0))
10420         goto end;
10421
10422     if (!TEST_int_gt(SSL_get_tmp_key(serverssl, &tmpkey), 0))
10423         goto end;
10424     if (!TEST_size_t_eq(EVP_PKEY_get_bits(tmpkey), expdhsize))
10425         goto end;
10426
10427     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
10428         goto end;
10429
10430     testresult = 1;
10431
10432  end:
10433     SSL_free(serverssl);
10434     SSL_free(clientssl);
10435     SSL_CTX_free(sctx);
10436     SSL_CTX_free(cctx);
10437     EVP_PKEY_free(tmpkey);
10438
10439     return testresult;
10440
10441 }
10442 # endif /* OPENSSL_NO_DH */
10443 #endif /* OPENSSL_NO_TLS1_2 */
10444
10445 #ifndef OSSL_NO_USABLE_TLS1_3
10446 /*
10447  * Test that setting an SNI callback works with TLSv1.3. Specifically we check
10448  * that it works even without a certificate configured for the original
10449  * SSL_CTX
10450  */
10451 static int test_sni_tls13(void)
10452 {
10453     SSL_CTX *cctx = NULL, *sctx = NULL, *sctx2 = NULL;
10454     SSL *clientssl = NULL, *serverssl = NULL;
10455     int testresult = 0;
10456
10457     /* Reset callback counter */
10458     snicb = 0;
10459
10460     /* Create an initial SSL_CTX with no certificate configured */
10461     sctx = SSL_CTX_new_ex(libctx, NULL, TLS_server_method());
10462     if (!TEST_ptr(sctx))
10463         goto end;
10464     /* Require TLSv1.3 as a minimum */
10465     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
10466                                        TLS_client_method(), TLS1_3_VERSION, 0,
10467                                        &sctx2, &cctx, cert, privkey)))
10468         goto end;
10469
10470     /* Set up SNI */
10471     if (!TEST_true(SSL_CTX_set_tlsext_servername_callback(sctx, sni_cb))
10472             || !TEST_true(SSL_CTX_set_tlsext_servername_arg(sctx, sctx2)))
10473         goto end;
10474
10475     /*
10476      * Connection should still succeed because the final SSL_CTX has the right
10477      * certificates configured.
10478      */
10479     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
10480                                       &clientssl, NULL, NULL))
10481             || !TEST_true(create_ssl_connection(serverssl, clientssl,
10482                                                 SSL_ERROR_NONE)))
10483         goto end;
10484
10485     /* We should have had the SNI callback called exactly once */
10486     if (!TEST_int_eq(snicb, 1))
10487         goto end;
10488
10489     testresult = 1;
10490
10491 end:
10492     SSL_free(serverssl);
10493     SSL_free(clientssl);
10494     SSL_CTX_free(sctx2);
10495     SSL_CTX_free(sctx);
10496     SSL_CTX_free(cctx);
10497     return testresult;
10498 }
10499
10500 /*
10501  * Test that the lifetime hint of a TLSv1.3 ticket is no more than 1 week
10502  * 0 = TLSv1.2
10503  * 1 = TLSv1.3
10504  */
10505 static int test_ticket_lifetime(int idx)
10506 {
10507     SSL_CTX *cctx = NULL, *sctx = NULL;
10508     SSL *clientssl = NULL, *serverssl = NULL;
10509     int testresult = 0;
10510     int version = TLS1_3_VERSION;
10511
10512 #define ONE_WEEK_SEC (7 * 24 * 60 * 60)
10513 #define TWO_WEEK_SEC (2 * ONE_WEEK_SEC)
10514
10515     if (idx == 0) {
10516 #ifdef OPENSSL_NO_TLS1_2
10517         return TEST_skip("TLS 1.2 is disabled.");
10518 #else
10519         version = TLS1_2_VERSION;
10520 #endif
10521     }
10522
10523     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
10524                                        TLS_client_method(), version, version,
10525                                        &sctx, &cctx, cert, privkey)))
10526         goto end;
10527
10528     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
10529                                       &clientssl, NULL, NULL)))
10530         goto end;
10531
10532     /*
10533      * Set the timeout to be more than 1 week
10534      * make sure the returned value is the default
10535      */
10536     if (!TEST_long_eq(SSL_CTX_set_timeout(sctx, TWO_WEEK_SEC),
10537                       SSL_get_default_timeout(serverssl)))
10538         goto end;
10539
10540     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
10541         goto end;
10542
10543     if (idx == 0) {
10544         /* TLSv1.2 uses the set value */
10545         if (!TEST_ulong_eq(SSL_SESSION_get_ticket_lifetime_hint(SSL_get_session(clientssl)), TWO_WEEK_SEC))
10546             goto end;
10547     } else {
10548         /* TLSv1.3 uses the limited value */
10549         if (!TEST_ulong_le(SSL_SESSION_get_ticket_lifetime_hint(SSL_get_session(clientssl)), ONE_WEEK_SEC))
10550             goto end;
10551     }
10552     testresult = 1;
10553
10554 end:
10555     SSL_free(serverssl);
10556     SSL_free(clientssl);
10557     SSL_CTX_free(sctx);
10558     SSL_CTX_free(cctx);
10559     return testresult;
10560 }
10561 #endif
10562 /*
10563  * Test that setting an ALPN does not violate RFC
10564  */
10565 static int test_set_alpn(void)
10566 {
10567     SSL_CTX *ctx = NULL;
10568     SSL *ssl = NULL;
10569     int testresult = 0;
10570
10571     unsigned char bad0[] = { 0x00, 'b', 'a', 'd' };
10572     unsigned char good[] = { 0x04, 'g', 'o', 'o', 'd' };
10573     unsigned char bad1[] = { 0x01, 'b', 'a', 'd' };
10574     unsigned char bad2[] = { 0x03, 'b', 'a', 'd', 0x00};
10575     unsigned char bad3[] = { 0x03, 'b', 'a', 'd', 0x01, 'b', 'a', 'd'};
10576     unsigned char bad4[] = { 0x03, 'b', 'a', 'd', 0x06, 'b', 'a', 'd'};
10577
10578     /* Create an initial SSL_CTX with no certificate configured */
10579     ctx = SSL_CTX_new_ex(libctx, NULL, TLS_server_method());
10580     if (!TEST_ptr(ctx))
10581         goto end;
10582
10583     /* the set_alpn functions return 0 (false) on success, non-zero (true) on failure */
10584     if (!TEST_false(SSL_CTX_set_alpn_protos(ctx, NULL, 2)))
10585         goto end;
10586     if (!TEST_false(SSL_CTX_set_alpn_protos(ctx, good, 0)))
10587         goto end;
10588     if (!TEST_false(SSL_CTX_set_alpn_protos(ctx, good, sizeof(good))))
10589         goto end;
10590     if (!TEST_true(SSL_CTX_set_alpn_protos(ctx, good, 1)))
10591         goto end;
10592     if (!TEST_true(SSL_CTX_set_alpn_protos(ctx, bad0, sizeof(bad0))))
10593         goto end;
10594     if (!TEST_true(SSL_CTX_set_alpn_protos(ctx, bad1, sizeof(bad1))))
10595         goto end;
10596     if (!TEST_true(SSL_CTX_set_alpn_protos(ctx, bad2, sizeof(bad2))))
10597         goto end;
10598     if (!TEST_true(SSL_CTX_set_alpn_protos(ctx, bad3, sizeof(bad3))))
10599         goto end;
10600     if (!TEST_true(SSL_CTX_set_alpn_protos(ctx, bad4, sizeof(bad4))))
10601         goto end;
10602
10603     ssl = SSL_new(ctx);
10604     if (!TEST_ptr(ssl))
10605         goto end;
10606
10607     if (!TEST_false(SSL_set_alpn_protos(ssl, NULL, 2)))
10608         goto end;
10609     if (!TEST_false(SSL_set_alpn_protos(ssl, good, 0)))
10610         goto end;
10611     if (!TEST_false(SSL_set_alpn_protos(ssl, good, sizeof(good))))
10612         goto end;
10613     if (!TEST_true(SSL_set_alpn_protos(ssl, good, 1)))
10614         goto end;
10615     if (!TEST_true(SSL_set_alpn_protos(ssl, bad0, sizeof(bad0))))
10616         goto end;
10617     if (!TEST_true(SSL_set_alpn_protos(ssl, bad1, sizeof(bad1))))
10618         goto end;
10619     if (!TEST_true(SSL_set_alpn_protos(ssl, bad2, sizeof(bad2))))
10620         goto end;
10621     if (!TEST_true(SSL_set_alpn_protos(ssl, bad3, sizeof(bad3))))
10622         goto end;
10623     if (!TEST_true(SSL_set_alpn_protos(ssl, bad4, sizeof(bad4))))
10624         goto end;
10625
10626     testresult = 1;
10627
10628 end:
10629     SSL_free(ssl);
10630     SSL_CTX_free(ctx);
10631     return testresult;
10632 }
10633
10634 /*
10635  * Test SSL_CTX_set1_verify/chain_cert_store and SSL_CTX_get_verify/chain_cert_store.
10636  */
10637 static int test_set_verify_cert_store_ssl_ctx(void)
10638 {
10639    SSL_CTX *ctx = NULL;
10640    int testresult = 0;
10641    X509_STORE *store = NULL, *new_store = NULL,
10642               *cstore = NULL, *new_cstore = NULL;
10643
10644    /* Create an initial SSL_CTX. */
10645    ctx = SSL_CTX_new_ex(libctx, NULL, TLS_server_method());
10646    if (!TEST_ptr(ctx))
10647        goto end;
10648
10649    /* Retrieve verify store pointer. */
10650    if (!TEST_true(SSL_CTX_get0_verify_cert_store(ctx, &store)))
10651        goto end;
10652
10653    /* Retrieve chain store pointer. */
10654    if (!TEST_true(SSL_CTX_get0_chain_cert_store(ctx, &cstore)))
10655        goto end;
10656
10657    /* We haven't set any yet, so this should be NULL. */
10658    if (!TEST_ptr_null(store) || !TEST_ptr_null(cstore))
10659        goto end;
10660
10661    /* Create stores. We use separate stores so pointers are different. */
10662    new_store = X509_STORE_new();
10663    if (!TEST_ptr(new_store))
10664        goto end;
10665
10666    new_cstore = X509_STORE_new();
10667    if (!TEST_ptr(new_cstore))
10668        goto end;
10669
10670    /* Set stores. */
10671    if (!TEST_true(SSL_CTX_set1_verify_cert_store(ctx, new_store)))
10672        goto end;
10673
10674    if (!TEST_true(SSL_CTX_set1_chain_cert_store(ctx, new_cstore)))
10675        goto end;
10676
10677    /* Should be able to retrieve the same pointer. */
10678    if (!TEST_true(SSL_CTX_get0_verify_cert_store(ctx, &store)))
10679        goto end;
10680
10681    if (!TEST_true(SSL_CTX_get0_chain_cert_store(ctx, &cstore)))
10682        goto end;
10683
10684    if (!TEST_ptr_eq(store, new_store) || !TEST_ptr_eq(cstore, new_cstore))
10685        goto end;
10686
10687    /* Should be able to unset again. */
10688    if (!TEST_true(SSL_CTX_set1_verify_cert_store(ctx, NULL)))
10689        goto end;
10690
10691    if (!TEST_true(SSL_CTX_set1_chain_cert_store(ctx, NULL)))
10692        goto end;
10693
10694    /* Should now be NULL. */
10695    if (!TEST_true(SSL_CTX_get0_verify_cert_store(ctx, &store)))
10696        goto end;
10697
10698    if (!TEST_true(SSL_CTX_get0_chain_cert_store(ctx, &cstore)))
10699        goto end;
10700
10701    if (!TEST_ptr_null(store) || !TEST_ptr_null(cstore))
10702        goto end;
10703
10704    testresult = 1;
10705
10706 end:
10707    X509_STORE_free(new_store);
10708    X509_STORE_free(new_cstore);
10709    SSL_CTX_free(ctx);
10710    return testresult;
10711 }
10712
10713 /*
10714  * Test SSL_set1_verify/chain_cert_store and SSL_get_verify/chain_cert_store.
10715  */
10716 static int test_set_verify_cert_store_ssl(void)
10717 {
10718    SSL_CTX *ctx = NULL;
10719    SSL *ssl = NULL;
10720    int testresult = 0;
10721    X509_STORE *store = NULL, *new_store = NULL,
10722               *cstore = NULL, *new_cstore = NULL;
10723
10724    /* Create an initial SSL_CTX. */
10725    ctx = SSL_CTX_new_ex(libctx, NULL, TLS_server_method());
10726    if (!TEST_ptr(ctx))
10727        goto end;
10728
10729    /* Create an SSL object. */
10730    ssl = SSL_new(ctx);
10731    if (!TEST_ptr(ssl))
10732        goto end;
10733
10734    /* Retrieve verify store pointer. */
10735    if (!TEST_true(SSL_get0_verify_cert_store(ssl, &store)))
10736        goto end;
10737
10738    /* Retrieve chain store pointer. */
10739    if (!TEST_true(SSL_get0_chain_cert_store(ssl, &cstore)))
10740        goto end;
10741
10742    /* We haven't set any yet, so this should be NULL. */
10743    if (!TEST_ptr_null(store) || !TEST_ptr_null(cstore))
10744        goto end;
10745
10746    /* Create stores. We use separate stores so pointers are different. */
10747    new_store = X509_STORE_new();
10748    if (!TEST_ptr(new_store))
10749        goto end;
10750
10751    new_cstore = X509_STORE_new();
10752    if (!TEST_ptr(new_cstore))
10753        goto end;
10754
10755    /* Set stores. */
10756    if (!TEST_true(SSL_set1_verify_cert_store(ssl, new_store)))
10757        goto end;
10758
10759    if (!TEST_true(SSL_set1_chain_cert_store(ssl, new_cstore)))
10760        goto end;
10761
10762    /* Should be able to retrieve the same pointer. */
10763    if (!TEST_true(SSL_get0_verify_cert_store(ssl, &store)))
10764        goto end;
10765
10766    if (!TEST_true(SSL_get0_chain_cert_store(ssl, &cstore)))
10767        goto end;
10768
10769    if (!TEST_ptr_eq(store, new_store) || !TEST_ptr_eq(cstore, new_cstore))
10770        goto end;
10771
10772    /* Should be able to unset again. */
10773    if (!TEST_true(SSL_set1_verify_cert_store(ssl, NULL)))
10774        goto end;
10775
10776    if (!TEST_true(SSL_set1_chain_cert_store(ssl, NULL)))
10777        goto end;
10778
10779    /* Should now be NULL. */
10780    if (!TEST_true(SSL_get0_verify_cert_store(ssl, &store)))
10781        goto end;
10782
10783    if (!TEST_true(SSL_get0_chain_cert_store(ssl, &cstore)))
10784        goto end;
10785
10786    if (!TEST_ptr_null(store) || !TEST_ptr_null(cstore))
10787        goto end;
10788
10789    testresult = 1;
10790
10791 end:
10792    X509_STORE_free(new_store);
10793    X509_STORE_free(new_cstore);
10794    SSL_free(ssl);
10795    SSL_CTX_free(ctx);
10796    return testresult;
10797 }
10798
10799
10800 static int test_inherit_verify_param(void)
10801 {
10802     int testresult = 0;
10803
10804     SSL_CTX *ctx = NULL;
10805     X509_VERIFY_PARAM *cp = NULL;
10806     SSL *ssl = NULL;
10807     X509_VERIFY_PARAM *sp = NULL;
10808     int hostflags = X509_CHECK_FLAG_NEVER_CHECK_SUBJECT;
10809
10810     ctx = SSL_CTX_new_ex(libctx, NULL, TLS_server_method());
10811     if (!TEST_ptr(ctx))
10812         goto end;
10813
10814     cp = SSL_CTX_get0_param(ctx);
10815     if (!TEST_ptr(cp))
10816         goto end;
10817     if (!TEST_int_eq(X509_VERIFY_PARAM_get_hostflags(cp), 0))
10818         goto end;
10819
10820     X509_VERIFY_PARAM_set_hostflags(cp, hostflags);
10821
10822     ssl = SSL_new(ctx);
10823     if (!TEST_ptr(ssl))
10824         goto end;
10825
10826     sp = SSL_get0_param(ssl);
10827     if (!TEST_ptr(sp))
10828         goto end;
10829     if (!TEST_int_eq(X509_VERIFY_PARAM_get_hostflags(sp), hostflags))
10830         goto end;
10831
10832     testresult = 1;
10833
10834  end:
10835     SSL_free(ssl);
10836     SSL_CTX_free(ctx);
10837
10838     return testresult;
10839 }
10840
10841 static int test_load_dhfile(void)
10842 {
10843 #ifndef OPENSSL_NO_DH
10844     int testresult = 0;
10845
10846     SSL_CTX *ctx = NULL;
10847     SSL_CONF_CTX *cctx = NULL;
10848
10849     if (dhfile == NULL)
10850         return 1;
10851
10852     if (!TEST_ptr(ctx = SSL_CTX_new_ex(libctx, NULL, TLS_client_method()))
10853         || !TEST_ptr(cctx = SSL_CONF_CTX_new()))
10854         goto end;
10855
10856     SSL_CONF_CTX_set_ssl_ctx(cctx, ctx);
10857     SSL_CONF_CTX_set_flags(cctx,
10858                            SSL_CONF_FLAG_CERTIFICATE
10859                            | SSL_CONF_FLAG_SERVER
10860                            | SSL_CONF_FLAG_FILE);
10861
10862     if (!TEST_int_eq(SSL_CONF_cmd(cctx, "DHParameters", dhfile), 2))
10863         goto end;
10864
10865     testresult = 1;
10866 end:
10867     SSL_CONF_CTX_free(cctx);
10868     SSL_CTX_free(ctx);
10869
10870     return testresult;
10871 #else
10872     return TEST_skip("DH not supported by this build");
10873 #endif
10874 }
10875
10876 #ifndef OSSL_NO_USABLE_TLS1_3
10877 /* Test that read_ahead works across a key change */
10878 static int test_read_ahead_key_change(void)
10879 {
10880     SSL_CTX *cctx = NULL, *sctx = NULL;
10881     SSL *clientssl = NULL, *serverssl = NULL;
10882     int testresult = 0;
10883     char *msg = "Hello World";
10884     size_t written, readbytes;
10885     char buf[80];
10886     int i;
10887
10888     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
10889                                        TLS_client_method(), TLS1_3_VERSION, 0,
10890                                        &sctx, &cctx, cert, privkey)))
10891         goto end;
10892
10893     SSL_CTX_set_read_ahead(sctx, 1);
10894
10895     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
10896                                       &clientssl, NULL, NULL)))
10897         goto end;
10898
10899     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
10900         goto end;
10901
10902     /* Write some data, send a key update, write more data */
10903     if (!TEST_true(SSL_write_ex(clientssl, msg, strlen(msg), &written))
10904         || !TEST_size_t_eq(written, strlen(msg)))
10905         goto end;
10906
10907     if (!TEST_true(SSL_key_update(clientssl, SSL_KEY_UPDATE_NOT_REQUESTED)))
10908         goto end;
10909
10910     if (!TEST_true(SSL_write_ex(clientssl, msg, strlen(msg), &written))
10911         || !TEST_size_t_eq(written, strlen(msg)))
10912         goto end;
10913
10914     /*
10915      * Since read_ahead is on the first read below should read the record with
10916      * the first app data, the second record with the key update message, and
10917      * the third record with the app data all in one go. We should be able to
10918      * still process the read_ahead data correctly even though it crosses
10919      * epochs
10920      */
10921     for (i = 0; i < 2; i++) {
10922         if (!TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf) - 1,
10923                                     &readbytes)))
10924             goto end;
10925
10926         buf[readbytes] = '\0';
10927         if (!TEST_str_eq(buf, msg))
10928             goto end;
10929     }
10930
10931     testresult = 1;
10932
10933 end:
10934     SSL_free(serverssl);
10935     SSL_free(clientssl);
10936     SSL_CTX_free(sctx);
10937     SSL_CTX_free(cctx);
10938     return testresult;
10939 }
10940
10941 static size_t record_pad_cb(SSL *s, int type, size_t len, void *arg)
10942 {
10943     int *called = arg;
10944
10945     switch ((*called)++) {
10946     case 0:
10947         /* Add some padding to first record */
10948         return 512;
10949     case 1:
10950         /* Maximally pad the second record */
10951         return SSL3_RT_MAX_PLAIN_LENGTH - len;
10952     case 2:
10953         /*
10954          * Exceeding the maximum padding should be fine. It should just pad to
10955          * the maximum anyway
10956          */
10957         return SSL3_RT_MAX_PLAIN_LENGTH + 1 - len;
10958     case 3:
10959         /*
10960          * Very large padding should also be ok. Should just pad to the maximum
10961          * allowed
10962          */
10963         return SIZE_MAX;
10964     default:
10965         return 0;
10966     }
10967 }
10968
10969 /*
10970  * Test that setting record padding in TLSv1.3 works as expected
10971  * Test 0: Record padding callback on the SSL_CTX
10972  * Test 1: Record padding callback on the SSL
10973  * Test 2: Record block padding on the SSL_CTX
10974  * Test 3: Record block padding on the SSL
10975  */
10976 static int test_tls13_record_padding(int idx)
10977 {
10978     SSL_CTX *cctx = NULL, *sctx = NULL;
10979     SSL *clientssl = NULL, *serverssl = NULL;
10980     int testresult = 0;
10981     char *msg = "Hello World";
10982     size_t written, readbytes;
10983     char buf[80];
10984     int i;
10985     int called = 0;
10986
10987     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
10988                                        TLS_client_method(), TLS1_3_VERSION, 0,
10989                                        &sctx, &cctx, cert, privkey)))
10990         goto end;
10991
10992     if (idx == 0) {
10993         SSL_CTX_set_record_padding_callback(cctx, record_pad_cb);
10994         SSL_CTX_set_record_padding_callback_arg(cctx, &called);
10995         if (!TEST_ptr_eq(SSL_CTX_get_record_padding_callback_arg(cctx), &called))
10996             goto end;
10997     } else if (idx == 2) {
10998         /* Exceeding the max plain length should fail */
10999         if (!TEST_false(SSL_CTX_set_block_padding(cctx,
11000                                                   SSL3_RT_MAX_PLAIN_LENGTH + 1)))
11001             goto end;
11002         if (!TEST_true(SSL_CTX_set_block_padding(cctx, 512)))
11003             goto end;
11004     }
11005
11006     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
11007                                       &clientssl, NULL, NULL)))
11008         goto end;
11009
11010     if (idx == 1) {
11011         SSL_set_record_padding_callback(clientssl, record_pad_cb);
11012         SSL_set_record_padding_callback_arg(clientssl, &called);
11013         if (!TEST_ptr_eq(SSL_get_record_padding_callback_arg(clientssl), &called))
11014             goto end;
11015     } else if (idx == 3) {
11016         /* Exceeding the max plain length should fail */
11017         if (!TEST_false(SSL_set_block_padding(clientssl,
11018                                               SSL3_RT_MAX_PLAIN_LENGTH + 1)))
11019             goto end;
11020         if (!TEST_true(SSL_set_block_padding(clientssl, 512)))
11021             goto end;
11022     }
11023
11024     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
11025         goto end;
11026
11027     called = 0;
11028     /*
11029      * Write some data, then check we can read it. Do this four times to check
11030      * we can continue to write and read padded data after the initial record
11031      * padding has been added. We don't actually check that the padding has
11032      * been applied to the record - just that we can continue to communicate
11033      * normally and that the callback has been called (if appropriate).
11034      */
11035     for (i = 0; i < 4; i++) {
11036         if (!TEST_true(SSL_write_ex(clientssl, msg, strlen(msg), &written))
11037             || !TEST_size_t_eq(written, strlen(msg)))
11038             goto end;
11039
11040         if (!TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf) - 1,
11041                                     &readbytes))
11042                 || !TEST_size_t_eq(written, readbytes))
11043             goto end;
11044
11045         buf[readbytes] = '\0';
11046         if (!TEST_str_eq(buf, msg))
11047             goto end;
11048     }
11049
11050     if ((idx == 0 || idx == 1) && !TEST_int_eq(called, 4))
11051         goto end;
11052
11053     testresult = 1;
11054 end:
11055     SSL_free(serverssl);
11056     SSL_free(clientssl);
11057     SSL_CTX_free(sctx);
11058     SSL_CTX_free(cctx);
11059     return testresult;
11060 }
11061 #endif /* OSSL_NO_USABLE_TLS1_3 */
11062
11063 #if !defined(OPENSSL_NO_TLS1_2) && !defined(OPENSSL_NO_DYNAMIC_ENGINE)
11064
11065 static ENGINE *load_dasync(void)
11066 {
11067     ENGINE *e;
11068
11069     if (!TEST_ptr(e = ENGINE_by_id("dasync")))
11070         return NULL;
11071
11072     if (!TEST_true(ENGINE_init(e))) {
11073         ENGINE_free(e);
11074         return NULL;
11075     }
11076
11077     if (!TEST_true(ENGINE_register_ciphers(e))) {
11078         ENGINE_free(e);
11079         return NULL;
11080     }
11081
11082     return e;
11083 }
11084
11085 /*
11086  * Test TLSv1.2 with a pipeline capable cipher. TLSv1.3 and DTLS do not
11087  * support this yet. The only pipeline capable cipher that we have is in the
11088  * dasync engine (providers don't support this yet), so we have to use
11089  * deprecated APIs for this test.
11090  *
11091  * Test 0: Client has pipelining enabled, server does not
11092  * Test 1: Server has pipelining enabled, client does not
11093  * Test 2: Client has pipelining enabled, server does not: not enough data to
11094  *         fill all the pipelines
11095  * Test 3: Client has pipelining enabled, server does not: not enough data to
11096  *         fill all the pipelines by more than a full pipeline's worth
11097  * Test 4: Client has pipelining enabled, server does not: more data than all
11098  *         the available pipelines can take
11099  * Test 5: Client has pipelining enabled, server does not: Maximum size pipeline
11100  * Test 6: Repeat of test 0, but the engine is loaded late (after the SSL_CTX
11101  *         is created)
11102  */
11103 static int test_pipelining(int idx)
11104 {
11105     SSL_CTX *cctx = NULL, *sctx = NULL;
11106     SSL *clientssl = NULL, *serverssl = NULL, *peera, *peerb;
11107     int testresult = 0, numreads;
11108     /* A 55 byte message */
11109     unsigned char *msg = (unsigned char *)
11110         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz123";
11111     size_t written, readbytes, offset, msglen, fragsize = 10, numpipes = 5;
11112     size_t expectedreads;
11113     unsigned char *buf = NULL;
11114     ENGINE *e = NULL;
11115
11116     if (idx != 6) {
11117         e = load_dasync();
11118         if (e == NULL)
11119             return 0;
11120     }
11121
11122     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
11123                                        TLS_client_method(), 0,
11124                                        TLS1_2_VERSION, &sctx, &cctx, cert,
11125                                        privkey)))
11126         goto end;
11127
11128     if (idx == 6) {
11129         e = load_dasync();
11130         if (e == NULL)
11131             goto end;
11132         /* Now act like test 0 */
11133         idx = 0;
11134     }
11135
11136     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
11137                                       &clientssl, NULL, NULL)))
11138         goto end;
11139
11140     if (!TEST_true(SSL_set_cipher_list(clientssl, "AES128-SHA")))
11141         goto end;
11142
11143     /* peera is always configured for pipelining, while peerb is not. */
11144     if (idx == 1) {
11145         peera = serverssl;
11146         peerb = clientssl;
11147
11148     } else {
11149         peera = clientssl;
11150         peerb = serverssl;
11151     }
11152
11153     if (idx == 5) {
11154         numpipes = 2;
11155         /* Maximum allowed fragment size */
11156         fragsize = SSL3_RT_MAX_PLAIN_LENGTH;
11157         msglen = fragsize * numpipes;
11158         msg = OPENSSL_malloc(msglen);
11159         if (!TEST_ptr(msg))
11160             goto end;
11161         if (!TEST_int_gt(RAND_bytes_ex(libctx, msg, msglen, 0), 0))
11162             goto end;
11163     } else if (idx == 4) {
11164         msglen = 55;
11165     } else {
11166         msglen = 50;
11167     }
11168     if (idx == 2)
11169         msglen -= 2; /* Send 2 less bytes */
11170     else if (idx == 3)
11171         msglen -= 12; /* Send 12 less bytes */
11172
11173     buf = OPENSSL_malloc(msglen);
11174     if (!TEST_ptr(buf))
11175         goto end;
11176
11177     if (idx == 5) {
11178         /*
11179          * Test that setting a split send fragment longer than the maximum
11180          * allowed fails
11181          */
11182         if (!TEST_false(SSL_set_split_send_fragment(peera, fragsize + 1)))
11183             goto end;
11184     }
11185
11186     /*
11187      * In the normal case. We have 5 pipelines with 10 bytes per pipeline
11188      * (50 bytes in total). This is a ridiculously small number of bytes -
11189      * but sufficient for our purposes
11190      */
11191     if (!TEST_true(SSL_set_max_pipelines(peera, numpipes))
11192             || !TEST_true(SSL_set_split_send_fragment(peera, fragsize)))
11193         goto end;
11194
11195     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
11196         goto end;
11197
11198     /* Write some data from peera to peerb */
11199     if (!TEST_true(SSL_write_ex(peera, msg, msglen, &written))
11200         || !TEST_size_t_eq(written, msglen))
11201         goto end;
11202
11203     /*
11204      * If the pipelining code worked, then we expect all |numpipes| pipelines to
11205      * have been used - except in test 3 where only |numpipes - 1| pipelines
11206      * will be used. This will result in |numpipes| records (|numpipes - 1| for
11207      * test 3) having been sent to peerb. Since peerb is not using read_ahead we
11208      * expect this to be read in |numpipes| or |numpipes - 1| separate
11209      * SSL_read_ex calls. In the case of test 4, there is then one additional
11210      * read for left over data that couldn't fit in the previous pipelines
11211      */
11212     for (offset = 0, numreads = 0;
11213          offset < msglen;
11214          offset += readbytes, numreads++) {
11215         if (!TEST_true(SSL_read_ex(peerb, buf + offset,
11216                                    msglen - offset, &readbytes)))
11217             goto end;
11218     }
11219
11220     expectedreads = idx == 4 ? numpipes + 1
11221                              : (idx == 3 ? numpipes - 1 : numpipes);
11222     if (!TEST_mem_eq(msg, msglen, buf, offset)
11223             || !TEST_int_eq(numreads, expectedreads))
11224         goto end;
11225
11226     /*
11227      * Write some data from peerb to peera. We do this in up to |numpipes + 1|
11228      * chunks to exercise the read pipelining code on peera.
11229      */
11230     for (offset = 0; offset < msglen; offset += fragsize) {
11231         size_t sendlen = msglen - offset;
11232
11233         if (sendlen > fragsize)
11234             sendlen = fragsize;
11235         if (!TEST_true(SSL_write_ex(peerb, msg + offset, sendlen, &written))
11236                 || !TEST_size_t_eq(written, sendlen))
11237             goto end;
11238     }
11239
11240     /*
11241      * The data was written in |numpipes|, |numpipes - 1| or |numpipes + 1|
11242      * separate chunks (depending on which test we are running). If the
11243      * pipelining is working then we expect peera to read up to numpipes chunks
11244      * and process them in parallel, giving back the complete result in a single
11245      * call to SSL_read_ex
11246      */
11247     if (!TEST_true(SSL_read_ex(peera, buf, msglen, &readbytes))
11248             || !TEST_size_t_le(readbytes, msglen))
11249         goto end;
11250
11251     if (idx == 4) {
11252         size_t readbytes2;
11253
11254         if (!TEST_true(SSL_read_ex(peera, buf + readbytes,
11255                                    msglen - readbytes, &readbytes2)))
11256             goto end;
11257         readbytes += readbytes2;
11258         if (!TEST_size_t_le(readbytes, msglen))
11259             goto end;
11260     }
11261
11262     if (!TEST_mem_eq(msg, msglen, buf, readbytes))
11263         goto end;
11264
11265     testresult = 1;
11266 end:
11267     SSL_free(serverssl);
11268     SSL_free(clientssl);
11269     SSL_CTX_free(sctx);
11270     SSL_CTX_free(cctx);
11271     if (e != NULL) {
11272         ENGINE_unregister_ciphers(e);
11273         ENGINE_finish(e);
11274         ENGINE_free(e);
11275     }
11276     OPENSSL_free(buf);
11277     if (fragsize == SSL3_RT_MAX_PLAIN_LENGTH)
11278         OPENSSL_free(msg);
11279     return testresult;
11280 }
11281 #endif /* !defined(OPENSSL_NO_TLS1_2) && !defined(OPENSSL_NO_DYNAMIC_ENGINE) */
11282
11283 static int check_version_string(SSL *s, int version)
11284 {
11285     const char *verstr = NULL;
11286
11287     switch (version) {
11288     case SSL3_VERSION:
11289         verstr = "SSLv3";
11290         break;
11291     case TLS1_VERSION:
11292         verstr = "TLSv1";
11293         break;
11294     case TLS1_1_VERSION:
11295         verstr = "TLSv1.1";
11296         break;
11297     case TLS1_2_VERSION:
11298         verstr = "TLSv1.2";
11299         break;
11300     case TLS1_3_VERSION:
11301         verstr = "TLSv1.3";
11302         break;
11303     case DTLS1_VERSION:
11304         verstr = "DTLSv1";
11305         break;
11306     case DTLS1_2_VERSION:
11307         verstr = "DTLSv1.2";
11308     }
11309
11310     return TEST_str_eq(verstr, SSL_get_version(s));
11311 }
11312
11313 /*
11314  * Test that SSL_version, SSL_get_version, SSL_is_quic, SSL_is_tls and
11315  * SSL_is_dtls return the expected results for a (D)TLS connection. Compare with
11316  * test_version() in quicapitest.c which does the same thing for QUIC
11317  * connections.
11318  */
11319 static int test_version(int idx)
11320 {
11321     SSL_CTX *cctx = NULL, *sctx = NULL;
11322     SSL *clientssl = NULL, *serverssl = NULL;
11323     int testresult = 0, version;
11324     const SSL_METHOD *servmeth = TLS_server_method();
11325     const SSL_METHOD *clientmeth = TLS_client_method();
11326
11327     switch (idx) {
11328 #if !defined(OPENSSL_NO_SSL3)
11329     case 0:
11330         version = SSL3_VERSION;
11331         break;
11332 #endif
11333 #if !defined(OPENSSL_NO_TLS1)
11334     case 1:
11335         version = TLS1_VERSION;
11336         break;
11337 #endif
11338 #if !defined(OPENSSL_NO_TLS1_2)
11339     case 2:
11340         version = TLS1_2_VERSION;
11341         break;
11342 #endif
11343 #if !defined(OSSL_NO_USABLE_TLS1_3)
11344     case 3:
11345         version = TLS1_3_VERSION;
11346         break;
11347 #endif
11348 #if !defined(OPENSSL_NO_DTLS1)
11349     case 4:
11350         version = DTLS1_VERSION;
11351         break;
11352 #endif
11353 #if !defined(OPENSSL_NO_DTLS1_2)
11354     case 5:
11355         version = DTLS1_2_VERSION;
11356         break;
11357 #endif
11358     /*
11359      * NB we do not support QUIC in this test. That is covered by quicapitest.c
11360      * We also don't support DTLS1_BAD_VER since we have no server support for
11361      * that.
11362      */
11363     default:
11364         TEST_skip("Unsupported protocol version");
11365         return 1;
11366     }
11367
11368     if (is_fips
11369             && (version == SSL3_VERSION
11370                 || version == TLS1_VERSION
11371                 || version == DTLS1_VERSION)) {
11372         TEST_skip("Protocol version not supported with FIPS");
11373         return 1;
11374     }
11375
11376 #if !defined(OPENSSL_NO_DTLS)
11377     if (version == DTLS1_VERSION || version == DTLS1_2_VERSION) {
11378         servmeth = DTLS_server_method();
11379         clientmeth = DTLS_client_method();
11380     }
11381 #endif
11382
11383     if (!TEST_true(create_ssl_ctx_pair(libctx, servmeth, clientmeth, version,
11384                                        version, &sctx, &cctx, cert, privkey)))
11385         goto end;
11386
11387     if (!TEST_true(SSL_CTX_set_cipher_list(sctx, "DEFAULT:@SECLEVEL=0"))
11388             || !TEST_true(SSL_CTX_set_cipher_list(cctx,
11389                                                 "DEFAULT:@SECLEVEL=0")))
11390         goto end;
11391
11392     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
11393                                       &clientssl, NULL, NULL)))
11394         goto end;
11395
11396     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
11397         goto end;
11398
11399     if (!TEST_int_eq(SSL_version(serverssl), version)
11400             || !TEST_int_eq(SSL_version(clientssl), version)
11401             || !TEST_true(check_version_string(serverssl, version))
11402             || !TEST_true(check_version_string(clientssl, version)))
11403         goto end;
11404
11405     if (version == DTLS1_VERSION || version == DTLS1_2_VERSION) {
11406         if (!TEST_true(SSL_is_dtls(serverssl))
11407                 || !TEST_true(SSL_is_dtls(clientssl))
11408                 || !TEST_false(SSL_is_tls(serverssl))
11409                 || !TEST_false(SSL_is_tls(clientssl))
11410                 || !TEST_false(SSL_is_quic(serverssl))
11411                 || !TEST_false(SSL_is_quic(clientssl)))
11412         goto end;
11413     } else {
11414         if (!TEST_true(SSL_is_tls(serverssl))
11415                 || !TEST_true(SSL_is_tls(clientssl))
11416                 || !TEST_false(SSL_is_dtls(serverssl))
11417                 || !TEST_false(SSL_is_dtls(clientssl))
11418                 || !TEST_false(SSL_is_quic(serverssl))
11419                 || !TEST_false(SSL_is_quic(clientssl)))
11420         goto end;
11421     }
11422
11423     testresult = 1;
11424 end:
11425     SSL_free(serverssl);
11426     SSL_free(clientssl);
11427     SSL_CTX_free(sctx);
11428     SSL_CTX_free(cctx);
11429     return testresult;
11430 }
11431
11432 /*
11433  * Test that the SSL_rstate_string*() APIs return sane results
11434  */
11435 static int test_rstate_string(void)
11436 {
11437     SSL_CTX *cctx = NULL, *sctx = NULL;
11438     SSL *clientssl = NULL, *serverssl = NULL;
11439     int testresult = 0, version;
11440     const SSL_METHOD *servmeth = TLS_server_method();
11441     const SSL_METHOD *clientmeth = TLS_client_method();
11442     size_t written, readbytes;
11443     unsigned char buf[2];
11444     unsigned char dummyheader[SSL3_RT_HEADER_LENGTH] = {
11445         SSL3_RT_APPLICATION_DATA,
11446         TLS1_2_VERSION_MAJOR,
11447         0, /* To be filled in later */
11448         0,
11449         1
11450     };
11451
11452     if (!TEST_true(create_ssl_ctx_pair(libctx, servmeth, clientmeth, 0,
11453                                        0, &sctx, &cctx, cert, privkey)))
11454         goto end;
11455
11456     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
11457                                       &clientssl, NULL, NULL)))
11458         goto end;
11459
11460     if (!TEST_str_eq(SSL_rstate_string(serverssl), "RH")
11461             || !TEST_str_eq(SSL_rstate_string_long(serverssl), "read header"))
11462         goto end;
11463
11464     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
11465         goto end;
11466
11467     if (!TEST_str_eq(SSL_rstate_string(serverssl), "RH")
11468             || !TEST_str_eq(SSL_rstate_string_long(serverssl), "read header"))
11469         goto end;
11470
11471     /* Fill in the correct version for the record header */
11472     version = SSL_version(serverssl);
11473     if (version == TLS1_3_VERSION)
11474         version = TLS1_2_VERSION;
11475     dummyheader[2] = version & 0xff;
11476
11477     /*
11478      * Send a dummy header. If we continued to read the body as well this
11479      * would fail with a bad record mac, but we're not going to go that far.
11480      */
11481     if (!TEST_true(BIO_write_ex(SSL_get_rbio(serverssl), dummyheader,
11482                                 sizeof(dummyheader), &written))
11483             || !TEST_size_t_eq(written, SSL3_RT_HEADER_LENGTH))
11484         goto end;
11485
11486     if (!TEST_false(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes)))
11487         goto end;
11488
11489     if (!TEST_str_eq(SSL_rstate_string(serverssl), "RB")
11490             || !TEST_str_eq(SSL_rstate_string_long(serverssl), "read body"))
11491         goto end;
11492
11493     testresult = 1;
11494 end:
11495     SSL_free(serverssl);
11496     SSL_free(clientssl);
11497     SSL_CTX_free(sctx);
11498     SSL_CTX_free(cctx);
11499     return testresult;
11500 }
11501
11502 /*
11503  * Force a write retry during handshaking. We test various combinations of
11504  * scenarios. We test a large certificate message which will fill the buffering
11505  * BIO used in the handshake. We try with client auth on and off. Finally we
11506  * also try a BIO that indicates retry via a 0 return. BIO_write() is documented
11507  * to indicate retry via -1 - but sometimes BIOs don't do that.
11508  *
11509  * Test 0: Standard certificate message
11510  * Test 1: Large certificate message
11511  * Test 2: Standard cert, verify peer
11512  * Test 3: Large cert, verify peer
11513  * Test 4: Standard cert, BIO returns 0 on retry
11514  * Test 5: Large cert, BIO returns 0 on retry
11515  * Test 6: Standard cert, verify peer, BIO returns 0 on retry
11516  * Test 7: Large cert, verify peer, BIO returns 0 on retry
11517  * Test 8-15: Repeat of above with TLSv1.2
11518  */
11519 static int test_handshake_retry(int idx)
11520 {
11521     SSL_CTX *cctx = NULL, *sctx = NULL;
11522     SSL *clientssl = NULL, *serverssl = NULL;
11523     int testresult = 0;
11524     BIO *tmp = NULL, *bretry = BIO_new(bio_s_always_retry());
11525     int maxversion = 0;
11526
11527     if (!TEST_ptr(bretry))
11528         goto end;
11529
11530 #ifndef OPENSSL_NO_TLS1_2
11531     if ((idx & 8) == 8)
11532         maxversion = TLS1_2_VERSION;
11533 #else
11534     if ((idx & 8) == 8)
11535         return TEST_skip("No TLSv1.2");
11536 #endif
11537
11538     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
11539                                        TLS_client_method(), 0, maxversion,
11540                                        &sctx, &cctx, cert, privkey)))
11541         goto end;
11542
11543     /*
11544      * Add a large amount of data to fill the buffering BIO used by the SSL
11545      * object
11546      */
11547     if ((idx & 1) == 1 && !ssl_ctx_add_large_cert_chain(libctx, sctx, cert))
11548         goto end;
11549
11550     /*
11551      * We don't actually configure a client cert, but neither do we fail if one
11552      * isn't present.
11553      */
11554     if ((idx & 2) == 2)
11555         SSL_CTX_set_verify(sctx, SSL_VERIFY_PEER, NULL);
11556
11557     if ((idx & 4) == 4)
11558         set_always_retry_err_val(0);
11559
11560     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
11561                                       &clientssl, NULL, NULL)))
11562         goto end;
11563
11564     tmp = SSL_get_wbio(serverssl);
11565     if (!TEST_ptr(tmp) || !TEST_true(BIO_up_ref(tmp))) {
11566         tmp = NULL;
11567         goto end;
11568     }
11569     SSL_set0_wbio(serverssl, bretry);
11570     bretry = NULL;
11571
11572     if (!TEST_int_eq(SSL_connect(clientssl), -1))
11573         goto end;
11574
11575     if (!TEST_int_eq(SSL_accept(serverssl), -1)
11576             || !TEST_int_eq(SSL_get_error(serverssl, -1), SSL_ERROR_WANT_WRITE))
11577         goto end;
11578
11579     /* Restore a BIO that will let the write succeed */
11580     SSL_set0_wbio(serverssl, tmp);
11581     tmp = NULL;
11582
11583     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
11584         goto end;
11585
11586     testresult = 1;
11587 end:
11588     SSL_free(serverssl);
11589     SSL_free(clientssl);
11590     SSL_CTX_free(sctx);
11591     SSL_CTX_free(cctx);
11592     BIO_free(bretry);
11593     BIO_free(tmp);
11594     set_always_retry_err_val(-1);
11595     return testresult;
11596 }
11597
11598 /*
11599  * Test that receiving retries when writing application data works as expected
11600  */
11601 static int test_data_retry(void)
11602 {
11603     SSL_CTX *cctx = NULL, *sctx = NULL;
11604     SSL *clientssl = NULL, *serverssl = NULL;
11605     int testresult = 0;
11606     unsigned char inbuf[1200], outbuf[1200];
11607     size_t i;
11608     BIO *tmp = NULL;
11609     BIO *bretry = BIO_new(bio_s_maybe_retry());
11610     size_t written, readbytes, totread = 0;
11611
11612     if (!TEST_ptr(bretry))
11613         goto end;
11614
11615     for (i = 0; i < sizeof(inbuf); i++)
11616         inbuf[i] = (unsigned char)(0xff & i);
11617     memset(outbuf, 0, sizeof(outbuf));
11618
11619     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
11620                                        TLS_client_method(), 0, 0, &sctx, &cctx,
11621                                        cert, privkey)))
11622         goto end;
11623
11624     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL,
11625                                       NULL)))
11626         goto end;
11627
11628     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
11629         goto end;
11630
11631     /* Smallest possible max send fragment is 512 */
11632     if (!TEST_true(SSL_set_max_send_fragment(clientssl, 512)))
11633         goto end;
11634
11635     tmp = SSL_get_wbio(clientssl);
11636     if (!TEST_ptr(tmp))
11637         goto end;
11638     if (!TEST_true(BIO_up_ref(tmp)))
11639         goto end;
11640     BIO_push(bretry, tmp);
11641     tmp = NULL;
11642     SSL_set0_wbio(clientssl, bretry);
11643     if (!BIO_up_ref(bretry)) {
11644         bretry = NULL;
11645         goto end;
11646     }
11647
11648     for (i = 0; i < 3; i++) {
11649         /* We expect this call to make no progress and indicate retry */
11650         if (!TEST_false(SSL_write_ex(clientssl, inbuf, sizeof(inbuf), &written)))
11651             goto end;
11652         if (!TEST_int_eq(SSL_get_error(clientssl, 0), SSL_ERROR_WANT_WRITE))
11653             goto end;
11654
11655         /* Allow one write to progress, but the next one to signal retry */
11656         if (!TEST_true(BIO_ctrl(bretry, MAYBE_RETRY_CTRL_SET_RETRY_AFTER_CNT, 1,
11657                                 NULL)))
11658             goto end;
11659
11660         if (i == 2)
11661             break;
11662
11663         /*
11664          * This call will hopefully make progress but will still indicate retry
11665          * because there is more data than will fit into a single record.
11666          */
11667         if (!TEST_false(SSL_write_ex(clientssl, inbuf, sizeof(inbuf), &written)))
11668             goto end;
11669         if (!TEST_int_eq(SSL_get_error(clientssl, 0), SSL_ERROR_WANT_WRITE))
11670             goto end;
11671     }
11672
11673     /* The final call should write the last chunk of data and succeed */
11674     if (!TEST_true(SSL_write_ex(clientssl, inbuf, sizeof(inbuf), &written)))
11675         goto end;
11676     /* Read all the data available */
11677     while (SSL_read_ex(serverssl, outbuf + totread, sizeof(outbuf) - totread,
11678                        &readbytes))
11679         totread += readbytes;
11680     if (!TEST_mem_eq(inbuf, sizeof(inbuf), outbuf, totread))
11681         goto end;
11682
11683     testresult = 1;
11684 end:
11685     SSL_free(serverssl);
11686     SSL_free(clientssl);
11687     SSL_CTX_free(sctx);
11688     SSL_CTX_free(cctx);
11689     BIO_free_all(bretry);
11690     BIO_free(tmp);
11691     return testresult;
11692 }
11693
11694 struct resume_servername_cb_data {
11695     int i;
11696     SSL_CTX *cctx;
11697     SSL_CTX *sctx;
11698     SSL_SESSION *sess;
11699     int recurse;
11700 };
11701
11702 /*
11703  * Servername callback. We use it here to run another complete handshake using
11704  * the same session - and mark the session as not_resuamble at the end
11705  */
11706 static int resume_servername_cb(SSL *s, int *ad, void *arg)
11707 {
11708     struct resume_servername_cb_data *cbdata = arg;
11709     SSL *serverssl = NULL, *clientssl = NULL;
11710     int ret = SSL_TLSEXT_ERR_ALERT_FATAL;
11711
11712     if (cbdata->recurse)
11713         return SSL_TLSEXT_ERR_ALERT_FATAL;
11714
11715     if ((cbdata->i % 3) != 1)
11716         return SSL_TLSEXT_ERR_OK;
11717
11718     cbdata->recurse = 1;
11719
11720     if (!TEST_true(create_ssl_objects(cbdata->sctx, cbdata->cctx, &serverssl,
11721                                       &clientssl, NULL, NULL))
11722             || !TEST_true(SSL_set_session(clientssl, cbdata->sess)))
11723         goto end;
11724
11725     ERR_set_mark();
11726     /*
11727      * We expect this to fail - because the servername cb will fail. This will
11728      * mark the session as not_resumable.
11729      */
11730     if (!TEST_false(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE))) {
11731         ERR_clear_last_mark();
11732         goto end;
11733     }
11734     ERR_pop_to_mark();
11735
11736     ret = SSL_TLSEXT_ERR_OK;
11737  end:
11738     SSL_free(serverssl);
11739     SSL_free(clientssl);
11740     cbdata->recurse = 0;
11741     return ret;
11742 }
11743 /*
11744  * Test multiple resumptions and cache size handling
11745  * Test 0: TLSv1.3 (max_early_data set)
11746  * Test 1: TLSv1.3 (SSL_OP_NO_TICKET set)
11747  * Test 2: TLSv1.3 (max_early_data and SSL_OP_NO_TICKET set)
11748  * Test 3: TLSv1.3 (SSL_OP_NO_TICKET, simultaneous resumes)
11749  * Test 4: TLSv1.2
11750  */
11751 static int test_multi_resume(int idx)
11752 {
11753     SSL_CTX *sctx = NULL, *cctx = NULL;
11754     SSL *serverssl = NULL, *clientssl = NULL;
11755     SSL_SESSION *sess = NULL;
11756     int max_version = TLS1_3_VERSION;
11757     int i, testresult = 0;
11758     struct resume_servername_cb_data cbdata;
11759
11760 #if defined(OPENSSL_NO_TLS1_2)
11761     if (idx == 4)
11762         return TEST_skip("TLSv1.2 is disabled in this build");
11763 #else
11764     if (idx == 4)
11765         max_version = TLS1_2_VERSION;
11766 #endif
11767 #if defined(OSSL_NO_USABLE_TLS1_3)
11768     if (idx != 4)
11769         return TEST_skip("No usable TLSv1.3 in this build");
11770 #endif
11771
11772     if (!TEST_true(create_ssl_ctx_pair(libctx, TLS_server_method(),
11773                                        TLS_client_method(), TLS1_VERSION,
11774                                        max_version, &sctx, &cctx, cert,
11775                                        privkey)))
11776         goto end;
11777
11778     /*
11779      * TLSv1.3 only uses a session cache if either max_early_data > 0 (used for
11780      * replay protection), or if SSL_OP_NO_TICKET is in use
11781      */
11782     if (idx == 0 || idx == 2)  {
11783         if (!TEST_true(SSL_CTX_set_max_early_data(sctx, 1024)))
11784             goto end;
11785     }
11786     if (idx == 1 || idx == 2 || idx == 3)
11787         SSL_CTX_set_options(sctx, SSL_OP_NO_TICKET);
11788
11789     SSL_CTX_sess_set_cache_size(sctx, 5);
11790
11791     if (idx == 3) {
11792         SSL_CTX_set_tlsext_servername_callback(sctx, resume_servername_cb);
11793         SSL_CTX_set_tlsext_servername_arg(sctx, &cbdata);
11794         cbdata.cctx = cctx;
11795         cbdata.sctx = sctx;
11796         cbdata.recurse = 0;
11797     }
11798
11799     for (i = 0; i < 30; i++) {
11800         if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
11801                                                 NULL, NULL))
11802                 || !TEST_true(SSL_set_session(clientssl, sess)))
11803             goto end;
11804
11805         /*
11806          * Check simultaneous resumes. We pause the connection part way through
11807          * the handshake by (mis)using the servername_cb. The pause occurs after
11808          * session resumption has already occurred, but before any session
11809          * tickets have been issued. While paused we run another complete
11810          * handshake resuming the same session.
11811          */
11812         if (idx == 3) {
11813             cbdata.i = i;
11814             cbdata.sess = sess;
11815         }
11816
11817         /*
11818          * Recreate a bug where dynamically changing the max_early_data value
11819          * can cause sessions in the session cache which cannot be deleted.
11820          */
11821         if ((idx == 0 || idx == 2) && (i % 3) == 2)
11822             SSL_set_max_early_data(serverssl, 0);
11823
11824         if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
11825             goto end;
11826
11827         if (sess == NULL || (idx == 0 && (i % 3) == 2)) {
11828             if (!TEST_false(SSL_session_reused(clientssl)))
11829                 goto end;
11830         } else {
11831             if (!TEST_true(SSL_session_reused(clientssl)))
11832                 goto end;
11833         }
11834         SSL_SESSION_free(sess);
11835
11836         /* Do a full handshake, followed by two resumptions */
11837         if ((i % 3) == 2) {
11838             sess = NULL;
11839         } else {
11840             if (!TEST_ptr((sess = SSL_get1_session(clientssl))))
11841                 goto end;
11842         }
11843
11844         SSL_shutdown(clientssl);
11845         SSL_shutdown(serverssl);
11846         SSL_free(serverssl);
11847         SSL_free(clientssl);
11848         serverssl = clientssl = NULL;
11849     }
11850
11851     /* We should never exceed the session cache size limit */
11852     if (!TEST_long_le(SSL_CTX_sess_number(sctx), 5))
11853         goto end;
11854
11855     testresult = 1;
11856  end:
11857     SSL_free(serverssl);
11858     SSL_free(clientssl);
11859     SSL_CTX_free(sctx);
11860     SSL_CTX_free(cctx);
11861     SSL_SESSION_free(sess);
11862     return testresult;
11863 }
11864
11865 OPT_TEST_DECLARE_USAGE("certfile privkeyfile srpvfile tmpfile provider config dhfile\n")
11866
11867 int setup_tests(void)
11868 {
11869     char *modulename;
11870     char *configfile;
11871
11872     libctx = OSSL_LIB_CTX_new();
11873     if (!TEST_ptr(libctx))
11874         return 0;
11875
11876     defctxnull = OSSL_PROVIDER_load(NULL, "null");
11877
11878     /*
11879      * Verify that the default and fips providers in the default libctx are not
11880      * available
11881      */
11882     if (!TEST_false(OSSL_PROVIDER_available(NULL, "default"))
11883             || !TEST_false(OSSL_PROVIDER_available(NULL, "fips")))
11884         return 0;
11885
11886     if (!test_skip_common_options()) {
11887         TEST_error("Error parsing test options\n");
11888         return 0;
11889     }
11890
11891     if (!TEST_ptr(certsdir = test_get_argument(0))
11892             || !TEST_ptr(srpvfile = test_get_argument(1))
11893             || !TEST_ptr(tmpfilename = test_get_argument(2))
11894             || !TEST_ptr(modulename = test_get_argument(3))
11895             || !TEST_ptr(configfile = test_get_argument(4))
11896             || !TEST_ptr(dhfile = test_get_argument(5)))
11897         return 0;
11898
11899     if (!TEST_true(OSSL_LIB_CTX_load_config(libctx, configfile)))
11900         return 0;
11901
11902     /* Check we have the expected provider available */
11903     if (!TEST_true(OSSL_PROVIDER_available(libctx, modulename)))
11904         return 0;
11905
11906     /* Check the default provider is not available */
11907     if (strcmp(modulename, "default") != 0
11908             && !TEST_false(OSSL_PROVIDER_available(libctx, "default")))
11909         return 0;
11910
11911     if (strcmp(modulename, "fips") == 0) {
11912         OSSL_PROVIDER *prov = NULL;
11913         OSSL_PARAM params[2];
11914
11915         is_fips = 1;
11916
11917         prov = OSSL_PROVIDER_load(libctx, "fips");
11918         if (prov != NULL) {
11919             /* Query the fips provider to check if the check ems option is enabled */
11920             params[0] =
11921                 OSSL_PARAM_construct_int(OSSL_PROV_PARAM_TLS1_PRF_EMS_CHECK,
11922                                          &fips_ems_check);
11923             params[1] = OSSL_PARAM_construct_end();
11924             OSSL_PROVIDER_get_params(prov, params);
11925             OSSL_PROVIDER_unload(prov);
11926         }
11927     }
11928
11929     /*
11930      * We add, but don't load the test "tls-provider". We'll load it when we
11931      * need it.
11932      */
11933     if (!TEST_true(OSSL_PROVIDER_add_builtin(libctx, "tls-provider",
11934                                              tls_provider_init)))
11935         return 0;
11936
11937
11938     if (getenv("OPENSSL_TEST_GETCOUNTS") != NULL) {
11939 #ifdef OPENSSL_NO_CRYPTO_MDEBUG
11940         TEST_error("not supported in this build");
11941         return 0;
11942 #else
11943         int i, mcount, rcount, fcount;
11944
11945         for (i = 0; i < 4; i++)
11946             test_export_key_mat(i);
11947         CRYPTO_get_alloc_counts(&mcount, &rcount, &fcount);
11948         test_printf_stdout("malloc %d realloc %d free %d\n",
11949                 mcount, rcount, fcount);
11950         return 1;
11951 #endif
11952     }
11953
11954     cert = test_mk_file_path(certsdir, "servercert.pem");
11955     if (cert == NULL)
11956         goto err;
11957
11958     privkey = test_mk_file_path(certsdir, "serverkey.pem");
11959     if (privkey == NULL)
11960         goto err;
11961
11962     cert2 = test_mk_file_path(certsdir, "server-ecdsa-cert.pem");
11963     if (cert2 == NULL)
11964         goto err;
11965
11966     privkey2 = test_mk_file_path(certsdir, "server-ecdsa-key.pem");
11967     if (privkey2 == NULL)
11968         goto err;
11969
11970     cert1024 = test_mk_file_path(certsdir, "ee-cert-1024.pem");
11971     if (cert1024 == NULL)
11972         goto err;
11973
11974     privkey1024 = test_mk_file_path(certsdir, "ee-key-1024.pem");
11975     if (privkey1024 == NULL)
11976         goto err;
11977
11978     cert3072 = test_mk_file_path(certsdir, "ee-cert-3072.pem");
11979     if (cert3072 == NULL)
11980         goto err;
11981
11982     privkey3072 = test_mk_file_path(certsdir, "ee-key-3072.pem");
11983     if (privkey3072 == NULL)
11984         goto err;
11985
11986     cert4096 = test_mk_file_path(certsdir, "ee-cert-4096.pem");
11987     if (cert4096 == NULL)
11988         goto err;
11989
11990     privkey4096 = test_mk_file_path(certsdir, "ee-key-4096.pem");
11991     if (privkey4096 == NULL)
11992         goto err;
11993
11994     cert8192 = test_mk_file_path(certsdir, "ee-cert-8192.pem");
11995     if (cert8192 == NULL)
11996         goto err;
11997
11998     privkey8192 = test_mk_file_path(certsdir, "ee-key-8192.pem");
11999     if (privkey8192 == NULL)
12000         goto err;
12001
12002     if (fips_ems_check) {
12003 #ifndef OPENSSL_NO_TLS1_2
12004         ADD_TEST(test_no_ems);
12005 #endif
12006         return 1;
12007     }
12008 #if !defined(OPENSSL_NO_KTLS) && !defined(OPENSSL_NO_SOCK)
12009 # if !defined(OPENSSL_NO_TLS1_2) || !defined(OSSL_NO_USABLE_TLS1_3)
12010     ADD_ALL_TESTS(test_ktls, NUM_KTLS_TEST_CIPHERS * 4);
12011     ADD_ALL_TESTS(test_ktls_sendfile, NUM_KTLS_TEST_CIPHERS * 2);
12012 # endif
12013 #endif
12014     ADD_TEST(test_large_message_tls);
12015     ADD_TEST(test_large_message_tls_read_ahead);
12016 #ifndef OPENSSL_NO_DTLS
12017     ADD_TEST(test_large_message_dtls);
12018 #endif
12019     ADD_ALL_TESTS(test_large_app_data, 28);
12020     ADD_TEST(test_cleanse_plaintext);
12021 #ifndef OPENSSL_NO_OCSP
12022     ADD_TEST(test_tlsext_status_type);
12023 #endif
12024     ADD_TEST(test_session_with_only_int_cache);
12025     ADD_TEST(test_session_with_only_ext_cache);
12026     ADD_TEST(test_session_with_both_cache);
12027     ADD_TEST(test_session_wo_ca_names);
12028 #ifndef OSSL_NO_USABLE_TLS1_3
12029     ADD_ALL_TESTS(test_stateful_tickets, 3);
12030     ADD_ALL_TESTS(test_stateless_tickets, 3);
12031     ADD_TEST(test_psk_tickets);
12032     ADD_ALL_TESTS(test_extra_tickets, 6);
12033 #endif
12034     ADD_ALL_TESTS(test_ssl_set_bio, TOTAL_SSL_SET_BIO_TESTS);
12035     ADD_TEST(test_ssl_bio_pop_next_bio);
12036     ADD_TEST(test_ssl_bio_pop_ssl_bio);
12037     ADD_TEST(test_ssl_bio_change_rbio);
12038     ADD_TEST(test_ssl_bio_change_wbio);
12039 #if !defined(OPENSSL_NO_TLS1_2) || defined(OSSL_NO_USABLE_TLS1_3)
12040     ADD_ALL_TESTS(test_set_sigalgs, OSSL_NELEM(testsigalgs) * 2);
12041     ADD_TEST(test_keylog);
12042 #endif
12043 #ifndef OSSL_NO_USABLE_TLS1_3
12044     ADD_TEST(test_keylog_no_master_key);
12045 #endif
12046     ADD_TEST(test_client_cert_verify_cb);
12047     ADD_TEST(test_ssl_build_cert_chain);
12048     ADD_TEST(test_ssl_ctx_build_cert_chain);
12049 #ifndef OPENSSL_NO_TLS1_2
12050     ADD_TEST(test_client_hello_cb);
12051     ADD_TEST(test_no_ems);
12052     ADD_TEST(test_ccs_change_cipher);
12053 #endif
12054 #ifndef OSSL_NO_USABLE_TLS1_3
12055     ADD_ALL_TESTS(test_early_data_read_write, 6);
12056     /*
12057      * We don't do replay tests for external PSK. Replay protection isn't used
12058      * in that scenario.
12059      */
12060     ADD_ALL_TESTS(test_early_data_replay, 2);
12061     ADD_ALL_TESTS(test_early_data_skip, OSSL_NELEM(ciphersuites) * 3);
12062     ADD_ALL_TESTS(test_early_data_skip_hrr, OSSL_NELEM(ciphersuites) * 3);
12063     ADD_ALL_TESTS(test_early_data_skip_hrr_fail, OSSL_NELEM(ciphersuites) * 3);
12064     ADD_ALL_TESTS(test_early_data_skip_abort, OSSL_NELEM(ciphersuites) * 3);
12065     ADD_ALL_TESTS(test_early_data_not_sent, 3);
12066     ADD_ALL_TESTS(test_early_data_psk, 8);
12067     ADD_ALL_TESTS(test_early_data_psk_with_all_ciphers, 5);
12068     ADD_ALL_TESTS(test_early_data_not_expected, 3);
12069 # ifndef OPENSSL_NO_TLS1_2
12070     ADD_ALL_TESTS(test_early_data_tls1_2, 3);
12071 # endif
12072 #endif
12073 #ifndef OSSL_NO_USABLE_TLS1_3
12074     ADD_ALL_TESTS(test_set_ciphersuite, 10);
12075     ADD_TEST(test_ciphersuite_change);
12076     ADD_ALL_TESTS(test_tls13_ciphersuite, 4);
12077 # ifdef OPENSSL_NO_PSK
12078     ADD_ALL_TESTS(test_tls13_psk, 1);
12079 # else
12080     ADD_ALL_TESTS(test_tls13_psk, 4);
12081 # endif  /* OPENSSL_NO_PSK */
12082 #ifndef OSSL_NO_USABLE_TLS1_3
12083     ADD_ALL_TESTS(test_tls13_no_dhe_kex, 8);
12084 #endif /* OSSL_NO_USABLE_TLS1_3 */
12085 # ifndef OPENSSL_NO_TLS1_2
12086     /* Test with both TLSv1.3 and 1.2 versions */
12087     ADD_ALL_TESTS(test_key_exchange, 14);
12088 #  if !defined(OPENSSL_NO_EC) && !defined(OPENSSL_NO_DH)
12089     ADD_ALL_TESTS(test_negotiated_group,
12090                   4 * (OSSL_NELEM(ecdhe_kexch_groups)
12091                        + OSSL_NELEM(ffdhe_kexch_groups)));
12092 #  endif
12093 # else
12094     /* Test with only TLSv1.3 versions */
12095     ADD_ALL_TESTS(test_key_exchange, 12);
12096 # endif
12097     ADD_ALL_TESTS(test_custom_exts, 6);
12098     ADD_TEST(test_stateless);
12099     ADD_TEST(test_pha_key_update);
12100 #else
12101     ADD_ALL_TESTS(test_custom_exts, 3);
12102 #endif
12103     ADD_ALL_TESTS(test_export_key_mat, 6);
12104 #ifndef OSSL_NO_USABLE_TLS1_3
12105     ADD_ALL_TESTS(test_export_key_mat_early, 3);
12106     ADD_TEST(test_key_update);
12107     ADD_ALL_TESTS(test_key_update_peer_in_write, 2);
12108     ADD_ALL_TESTS(test_key_update_peer_in_read, 2);
12109     ADD_ALL_TESTS(test_key_update_local_in_write, 2);
12110     ADD_ALL_TESTS(test_key_update_local_in_read, 2);
12111 #endif
12112     ADD_ALL_TESTS(test_ssl_clear, 8);
12113     ADD_ALL_TESTS(test_max_fragment_len_ext, OSSL_NELEM(max_fragment_len_test));
12114 #if !defined(OPENSSL_NO_SRP) && !defined(OPENSSL_NO_TLS1_2)
12115     ADD_ALL_TESTS(test_srp, 6);
12116 #endif
12117 #if !defined(OPENSSL_NO_COMP_ALG)
12118     /* Add compression case */
12119     ADD_ALL_TESTS(test_info_callback, 8);
12120 #else
12121     ADD_ALL_TESTS(test_info_callback, 6);
12122 #endif
12123     ADD_ALL_TESTS(test_ssl_pending, 2);
12124     ADD_ALL_TESTS(test_ssl_get_shared_ciphers, OSSL_NELEM(shared_ciphers_data));
12125     ADD_ALL_TESTS(test_ticket_callbacks, 20);
12126     ADD_ALL_TESTS(test_shutdown, 7);
12127     ADD_TEST(test_async_shutdown);
12128     ADD_ALL_TESTS(test_incorrect_shutdown, 2);
12129     ADD_ALL_TESTS(test_cert_cb, 6);
12130     ADD_ALL_TESTS(test_client_cert_cb, 2);
12131     ADD_ALL_TESTS(test_ca_names, 3);
12132 #ifndef OPENSSL_NO_TLS1_2
12133     ADD_ALL_TESTS(test_multiblock_write, OSSL_NELEM(multiblock_cipherlist_data));
12134 #endif
12135     ADD_ALL_TESTS(test_servername, 10);
12136     ADD_TEST(test_unknown_sigalgs_groups);
12137 #if !defined(OPENSSL_NO_EC) \
12138     && (!defined(OSSL_NO_USABLE_TLS1_3) || !defined(OPENSSL_NO_TLS1_2))
12139     ADD_ALL_TESTS(test_sigalgs_available, 6);
12140 #endif
12141 #ifndef OPENSSL_NO_TLS1_3
12142     ADD_ALL_TESTS(test_pluggable_group, 2);
12143     ADD_ALL_TESTS(test_pluggable_signature, 4);
12144 #endif
12145 #ifndef OPENSSL_NO_TLS1_2
12146     ADD_TEST(test_ssl_dup);
12147 # ifndef OPENSSL_NO_DH
12148     ADD_ALL_TESTS(test_set_tmp_dh, 11);
12149     ADD_ALL_TESTS(test_dh_auto, 7);
12150 # endif
12151 #endif
12152 #ifndef OSSL_NO_USABLE_TLS1_3
12153     ADD_TEST(test_sni_tls13);
12154     ADD_ALL_TESTS(test_ticket_lifetime, 2);
12155 #endif
12156     ADD_TEST(test_inherit_verify_param);
12157     ADD_TEST(test_set_alpn);
12158     ADD_TEST(test_set_verify_cert_store_ssl_ctx);
12159     ADD_TEST(test_set_verify_cert_store_ssl);
12160     ADD_ALL_TESTS(test_session_timeout, 1);
12161 #if !defined(OSSL_NO_USABLE_TLS1_3) || !defined(OPENSSL_NO_TLS1_2)
12162     ADD_ALL_TESTS(test_session_cache_overflow, 4);
12163 #endif
12164     ADD_TEST(test_load_dhfile);
12165 #ifndef OSSL_NO_USABLE_TLS1_3
12166     ADD_TEST(test_read_ahead_key_change);
12167     ADD_ALL_TESTS(test_tls13_record_padding, 4);
12168 #endif
12169 #if !defined(OPENSSL_NO_TLS1_2) && !defined(OSSL_NO_USABLE_TLS1_3)
12170     ADD_ALL_TESTS(test_serverinfo_custom, 4);
12171 #endif
12172 #if !defined(OPENSSL_NO_TLS1_2) && !defined(OPENSSL_NO_DYNAMIC_ENGINE)
12173     ADD_ALL_TESTS(test_pipelining, 7);
12174 #endif
12175     ADD_ALL_TESTS(test_version, 6);
12176     ADD_TEST(test_rstate_string);
12177     ADD_ALL_TESTS(test_handshake_retry, 16);
12178     ADD_TEST(test_data_retry);
12179     ADD_ALL_TESTS(test_multi_resume, 5);
12180     return 1;
12181
12182  err:
12183     OPENSSL_free(cert);
12184     OPENSSL_free(privkey);
12185     OPENSSL_free(cert2);
12186     OPENSSL_free(privkey2);
12187     return 0;
12188 }
12189
12190 void cleanup_tests(void)
12191 {
12192 # if !defined(OPENSSL_NO_TLS1_2) && !defined(OPENSSL_NO_DH)
12193     EVP_PKEY_free(tmp_dh_params);
12194 #endif
12195     OPENSSL_free(cert);
12196     OPENSSL_free(privkey);
12197     OPENSSL_free(cert2);
12198     OPENSSL_free(privkey2);
12199     OPENSSL_free(cert1024);
12200     OPENSSL_free(privkey1024);
12201     OPENSSL_free(cert3072);
12202     OPENSSL_free(privkey3072);
12203     OPENSSL_free(cert4096);
12204     OPENSSL_free(privkey4096);
12205     OPENSSL_free(cert8192);
12206     OPENSSL_free(privkey8192);
12207     bio_s_mempacket_test_free();
12208     bio_s_always_retry_free();
12209     bio_s_maybe_retry_free();
12210     OSSL_PROVIDER_unload(defctxnull);
12211     OSSL_LIB_CTX_free(libctx);
12212 }