test/sslapitest.c

   1 /*
   2  * Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <string.h>
  11
  12 #include <openssl/opensslconf.h>
  13 #include <openssl/bio.h>
  14 #include <openssl/crypto.h>
  15 #include <openssl/ssl.h>
  16 #include <openssl/ocsp.h>
  17 #include <openssl/srp.h>
  18 #include <openssl/txt_db.h>
  19 #include <openssl/aes.h>
  20
  21 #include "ssltestlib.h"
  22 #include "testutil.h"
  23 #include "testutil/output.h"
  24 #include "internal/nelem.h"
  25 #include "../ssl/ssl_locl.h"
  26
  27 static char *cert = NULL;
  28 static char *privkey = NULL;
  29 static char *srpvfile = NULL;
  30 static char *tmpfilename = NULL;
  31
  32 #define LOG_BUFFER_SIZE 2048
  33 static char server_log_buffer[LOG_BUFFER_SIZE + 1] = {0};
  34 static size_t server_log_buffer_index = 0;
  35 static char client_log_buffer[LOG_BUFFER_SIZE + 1] = {0};
  36 static size_t client_log_buffer_index = 0;
  37 static int error_writing_log = 0;
  38
  39 #ifndef OPENSSL_NO_OCSP
  40 static const unsigned char orespder[] = "Dummy OCSP Response";
  41 static int ocsp_server_called = 0;
  42 static int ocsp_client_called = 0;
  43
  44 static int cdummyarg = 1;
  45 static X509 *ocspcert = NULL;
  46 #endif
  47
  48 #define NUM_EXTRA_CERTS 40
  49 #define CLIENT_VERSION_LEN      2
  50
  51 /*
  52  * This structure is used to validate that the correct number of log messages
  53  * of various types are emitted when emitting secret logs.
  54  */
  55 struct sslapitest_log_counts {
  56     unsigned int rsa_key_exchange_count;
  57     unsigned int master_secret_count;
  58     unsigned int client_early_secret_count;
  59     unsigned int client_handshake_secret_count;
  60     unsigned int server_handshake_secret_count;
  61     unsigned int client_application_secret_count;
  62     unsigned int server_application_secret_count;
  63     unsigned int early_exporter_secret_count;
  64     unsigned int exporter_secret_count;
  65 };
  66
  67
  68 static unsigned char serverinfov1[] = {
  69     0xff, 0xff, /* Dummy extension type */
  70     0x00, 0x01, /* Extension length is 1 byte */
  71     0xff        /* Dummy extension data */
  72 };
  73
  74 static unsigned char serverinfov2[] = {
  75     0x00, 0x00, 0x00,
  76     (unsigned char)(SSL_EXT_CLIENT_HELLO & 0xff), /* Dummy context - 4 bytes */
  77     0xff, 0xff, /* Dummy extension type */
  78     0x00, 0x01, /* Extension length is 1 byte */
  79     0xff        /* Dummy extension data */
  80 };
  81
  82 static void client_keylog_callback(const SSL *ssl, const char *line)
  83 {
  84     int line_length = strlen(line);
  85
  86     /* If the log doesn't fit, error out. */
  87     if (client_log_buffer_index + line_length > sizeof(client_log_buffer) - 1) {
  88         TEST_info("Client log too full");
  89         error_writing_log = 1;
  90         return;
  91     }
  92
  93     strcat(client_log_buffer, line);
  94     client_log_buffer_index += line_length;
  95     client_log_buffer[client_log_buffer_index++] = '\n';
  96 }
  97
  98 static void server_keylog_callback(const SSL *ssl, const char *line)
  99 {
 100     int line_length = strlen(line);
 101
 102     /* If the log doesn't fit, error out. */
 103     if (server_log_buffer_index + line_length > sizeof(server_log_buffer) - 1) {
 104         TEST_info("Server log too full");
 105         error_writing_log = 1;
 106         return;
 107     }
 108
 109     strcat(server_log_buffer, line);
 110     server_log_buffer_index += line_length;
 111     server_log_buffer[server_log_buffer_index++] = '\n';
 112 }
 113
 114 static int compare_hex_encoded_buffer(const char *hex_encoded,
 115                                       size_t hex_length,
 116                                       const uint8_t *raw,
 117                                       size_t raw_length)
 118 {
 119     size_t i, j;
 120     char hexed[3];
 121
 122     if (!TEST_size_t_eq(raw_length * 2, hex_length))
 123         return 1;
 124
 125     for (i = j = 0; i < raw_length && j + 1 < hex_length; i++, j += 2) {
 126         sprintf(hexed, "%02x", raw[i]);
 127         if (!TEST_int_eq(hexed[0], hex_encoded[j])
 128                 || !TEST_int_eq(hexed[1], hex_encoded[j + 1]))
 129             return 1;
 130     }
 131
 132     return 0;
 133 }
 134
 135 static int test_keylog_output(char *buffer, const SSL *ssl,
 136                               const SSL_SESSION *session,
 137                               struct sslapitest_log_counts *expected)
 138 {
 139     char *token = NULL;
 140     unsigned char actual_client_random[SSL3_RANDOM_SIZE] = {0};
 141     size_t client_random_size = SSL3_RANDOM_SIZE;
 142     unsigned char actual_master_key[SSL_MAX_MASTER_KEY_LENGTH] = {0};
 143     size_t master_key_size = SSL_MAX_MASTER_KEY_LENGTH;
 144     unsigned int rsa_key_exchange_count = 0;
 145     unsigned int master_secret_count = 0;
 146     unsigned int client_early_secret_count = 0;
 147     unsigned int client_handshake_secret_count = 0;
 148     unsigned int server_handshake_secret_count = 0;
 149     unsigned int client_application_secret_count = 0;
 150     unsigned int server_application_secret_count = 0;
 151     unsigned int early_exporter_secret_count = 0;
 152     unsigned int exporter_secret_count = 0;
 153
 154     for (token = strtok(buffer, " \n"); token != NULL;
 155          token = strtok(NULL, " \n")) {
 156         if (strcmp(token, "RSA") == 0) {
 157             /*
 158              * Premaster secret. Tokens should be: 16 ASCII bytes of
 159              * hex-encoded encrypted secret, then the hex-encoded pre-master
 160              * secret.
 161              */
 162             if (!TEST_ptr(token = strtok(NULL, " \n")))
 163                 return 0;
 164             if (!TEST_size_t_eq(strlen(token), 16))
 165                 return 0;
 166             if (!TEST_ptr(token = strtok(NULL, " \n")))
 167                 return 0;
 168             /*
 169              * We can't sensibly check the log because the premaster secret is
 170              * transient, and OpenSSL doesn't keep hold of it once the master
 171              * secret is generated.
 172              */
 173             rsa_key_exchange_count++;
 174         } else if (strcmp(token, "CLIENT_RANDOM") == 0) {
 175             /*
 176              * Master secret. Tokens should be: 64 ASCII bytes of hex-encoded
 177              * client random, then the hex-encoded master secret.
 178              */
 179             client_random_size = SSL_get_client_random(ssl,
 180                                                        actual_client_random,
 181                                                        SSL3_RANDOM_SIZE);
 182             if (!TEST_size_t_eq(client_random_size, SSL3_RANDOM_SIZE))
 183                 return 0;
 184
 185             if (!TEST_ptr(token = strtok(NULL, " \n")))
 186                 return 0;
 187             if (!TEST_size_t_eq(strlen(token), 64))
 188                 return 0;
 189             if (!TEST_false(compare_hex_encoded_buffer(token, 64,
 190                                                        actual_client_random,
 191                                                        client_random_size)))
 192                 return 0;
 193
 194             if (!TEST_ptr(token = strtok(NULL, " \n")))
 195                 return 0;
 196             master_key_size = SSL_SESSION_get_master_key(session,
 197                                                          actual_master_key,
 198                                                          master_key_size);
 199             if (!TEST_size_t_ne(master_key_size, 0))
 200                 return 0;
 201             if (!TEST_false(compare_hex_encoded_buffer(token, strlen(token),
 202                                                        actual_master_key,
 203                                                        master_key_size)))
 204                 return 0;
 205             master_secret_count++;
 206         } else if (strcmp(token, "CLIENT_EARLY_TRAFFIC_SECRET") == 0
 207                     || strcmp(token, "CLIENT_HANDSHAKE_TRAFFIC_SECRET") == 0
 208                     || strcmp(token, "SERVER_HANDSHAKE_TRAFFIC_SECRET") == 0
 209                     || strcmp(token, "CLIENT_TRAFFIC_SECRET_0") == 0
 210                     || strcmp(token, "SERVER_TRAFFIC_SECRET_0") == 0
 211                     || strcmp(token, "EARLY_EXPORTER_SECRET") == 0
 212                     || strcmp(token, "EXPORTER_SECRET") == 0) {
 213             /*
 214              * TLSv1.3 secret. Tokens should be: 64 ASCII bytes of hex-encoded
 215              * client random, and then the hex-encoded secret. In this case,
 216              * we treat all of these secrets identically and then just
 217              * distinguish between them when counting what we saw.
 218              */
 219             if (strcmp(token, "CLIENT_EARLY_TRAFFIC_SECRET") == 0)
 220                 client_early_secret_count++;
 221             else if (strcmp(token, "CLIENT_HANDSHAKE_TRAFFIC_SECRET") == 0)
 222                 client_handshake_secret_count++;
 223             else if (strcmp(token, "SERVER_HANDSHAKE_TRAFFIC_SECRET") == 0)
 224                 server_handshake_secret_count++;
 225             else if (strcmp(token, "CLIENT_TRAFFIC_SECRET_0") == 0)
 226                 client_application_secret_count++;
 227             else if (strcmp(token, "SERVER_TRAFFIC_SECRET_0") == 0)
 228                 server_application_secret_count++;
 229             else if (strcmp(token, "EARLY_EXPORTER_SECRET") == 0)
 230                 early_exporter_secret_count++;
 231             else if (strcmp(token, "EXPORTER_SECRET") == 0)
 232                 exporter_secret_count++;
 233
 234             client_random_size = SSL_get_client_random(ssl,
 235                                                        actual_client_random,
 236                                                        SSL3_RANDOM_SIZE);
 237             if (!TEST_size_t_eq(client_random_size, SSL3_RANDOM_SIZE))
 238                 return 0;
 239
 240             if (!TEST_ptr(token = strtok(NULL, " \n")))
 241                 return 0;
 242             if (!TEST_size_t_eq(strlen(token), 64))
 243                 return 0;
 244             if (!TEST_false(compare_hex_encoded_buffer(token, 64,
 245                                                        actual_client_random,
 246                                                        client_random_size)))
 247                 return 0;
 248
 249             if (!TEST_ptr(token = strtok(NULL, " \n")))
 250                 return 0;
 251
 252             /*
 253              * TODO(TLS1.3): test that application traffic secrets are what
 254              * we expect */
 255         } else {
 256             TEST_info("Unexpected token %s\n", token);
 257             return 0;
 258         }
 259     }
 260
 261     /* Got what we expected? */
 262     if (!TEST_size_t_eq(rsa_key_exchange_count,
 263                         expected->rsa_key_exchange_count)
 264             || !TEST_size_t_eq(master_secret_count,
 265                                expected->master_secret_count)
 266             || !TEST_size_t_eq(client_early_secret_count,
 267                                expected->client_early_secret_count)
 268             || !TEST_size_t_eq(client_handshake_secret_count,
 269                                expected->client_handshake_secret_count)
 270             || !TEST_size_t_eq(server_handshake_secret_count,
 271                                expected->server_handshake_secret_count)
 272             || !TEST_size_t_eq(client_application_secret_count,
 273                                expected->client_application_secret_count)
 274             || !TEST_size_t_eq(server_application_secret_count,
 275                                expected->server_application_secret_count)
 276             || !TEST_size_t_eq(early_exporter_secret_count,
 277                                expected->early_exporter_secret_count)
 278             || !TEST_size_t_eq(exporter_secret_count,
 279                                expected->exporter_secret_count))
 280         return 0;
 281     return 1;
 282 }
 283
 284 #if !defined(OPENSSL_NO_TLS1_2) || defined(OPENSSL_NO_TLS1_3)
 285 static int test_keylog(void)
 286 {
 287     SSL_CTX *cctx = NULL, *sctx = NULL;
 288     SSL *clientssl = NULL, *serverssl = NULL;
 289     int testresult = 0;
 290     struct sslapitest_log_counts expected = {0};
 291
 292     /* Clean up logging space */
 293     memset(client_log_buffer, 0, sizeof(client_log_buffer));
 294     memset(server_log_buffer, 0, sizeof(server_log_buffer));
 295     client_log_buffer_index = 0;
 296     server_log_buffer_index = 0;
 297     error_writing_log = 0;
 298
 299     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(),
 300                                        TLS_client_method(),
 301                                        TLS1_VERSION, TLS_MAX_VERSION,
 302                                        &sctx, &cctx, cert, privkey)))
 303         return 0;
 304
 305     /* We cannot log the master secret for TLSv1.3, so we should forbid it. */
 306     SSL_CTX_set_options(cctx, SSL_OP_NO_TLSv1_3);
 307     SSL_CTX_set_options(sctx, SSL_OP_NO_TLSv1_3);
 308
 309     /* We also want to ensure that we use RSA-based key exchange. */
 310     if (!TEST_true(SSL_CTX_set_cipher_list(cctx, "RSA")))
 311         goto end;
 312
 313     if (!TEST_true(SSL_CTX_get_keylog_callback(cctx) == NULL)
 314             || !TEST_true(SSL_CTX_get_keylog_callback(sctx) == NULL))
 315         goto end;
 316     SSL_CTX_set_keylog_callback(cctx, client_keylog_callback);
 317     if (!TEST_true(SSL_CTX_get_keylog_callback(cctx)
 318                    == client_keylog_callback))
 319         goto end;
 320     SSL_CTX_set_keylog_callback(sctx, server_keylog_callback);
 321     if (!TEST_true(SSL_CTX_get_keylog_callback(sctx)
 322                    == server_keylog_callback))
 323         goto end;
 324
 325     /* Now do a handshake and check that the logs have been written to. */
 326     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
 327                                       &clientssl, NULL, NULL))
 328             || !TEST_true(create_ssl_connection(serverssl, clientssl,
 329                                                 SSL_ERROR_NONE))
 330             || !TEST_false(error_writing_log)
 331             || !TEST_int_gt(client_log_buffer_index, 0)
 332             || !TEST_int_gt(server_log_buffer_index, 0))
 333         goto end;
 334
 335     /*
 336      * Now we want to test that our output data was vaguely sensible. We
 337      * do that by using strtok and confirming that we have more or less the
 338      * data we expect. For both client and server, we expect to see one master
 339      * secret. The client should also see a RSA key exchange.
 340      */
 341     expected.rsa_key_exchange_count = 1;
 342     expected.master_secret_count = 1;
 343     if (!TEST_true(test_keylog_output(client_log_buffer, clientssl,
 344                                       SSL_get_session(clientssl), &expected)))
 345         goto end;
 346
 347     expected.rsa_key_exchange_count = 0;
 348     if (!TEST_true(test_keylog_output(server_log_buffer, serverssl,
 349                                       SSL_get_session(serverssl), &expected)))
 350         goto end;
 351
 352     testresult = 1;
 353
 354 end:
 355     SSL_free(serverssl);
 356     SSL_free(clientssl);
 357     SSL_CTX_free(sctx);
 358     SSL_CTX_free(cctx);
 359
 360     return testresult;
 361 }
 362 #endif
 363
 364 #ifndef OPENSSL_NO_TLS1_3
 365 static int test_keylog_no_master_key(void)
 366 {
 367     SSL_CTX *cctx = NULL, *sctx = NULL;
 368     SSL *clientssl = NULL, *serverssl = NULL;
 369     SSL_SESSION *sess = NULL;
 370     int testresult = 0;
 371     struct sslapitest_log_counts expected = {0};
 372     unsigned char buf[1];
 373     size_t readbytes, written;
 374
 375     /* Clean up logging space */
 376     memset(client_log_buffer, 0, sizeof(client_log_buffer));
 377     memset(server_log_buffer, 0, sizeof(server_log_buffer));
 378     client_log_buffer_index = 0;
 379     server_log_buffer_index = 0;
 380     error_writing_log = 0;
 381
 382     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
 383                                        TLS1_VERSION, TLS_MAX_VERSION,
 384                                        &sctx, &cctx, cert, privkey))
 385         || !TEST_true(SSL_CTX_set_max_early_data(sctx,
 386                                                  SSL3_RT_MAX_PLAIN_LENGTH)))
 387         return 0;
 388
 389     if (!TEST_true(SSL_CTX_get_keylog_callback(cctx) == NULL)
 390             || !TEST_true(SSL_CTX_get_keylog_callback(sctx) == NULL))
 391         goto end;
 392
 393     SSL_CTX_set_keylog_callback(cctx, client_keylog_callback);
 394     if (!TEST_true(SSL_CTX_get_keylog_callback(cctx)
 395                    == client_keylog_callback))
 396         goto end;
 397
 398     SSL_CTX_set_keylog_callback(sctx, server_keylog_callback);
 399     if (!TEST_true(SSL_CTX_get_keylog_callback(sctx)
 400                    == server_keylog_callback))
 401         goto end;
 402
 403     /* Now do a handshake and check that the logs have been written to. */
 404     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
 405                                       &clientssl, NULL, NULL))
 406             || !TEST_true(create_ssl_connection(serverssl, clientssl,
 407                                                 SSL_ERROR_NONE))
 408             || !TEST_false(error_writing_log))
 409         goto end;
 410
 411     /*
 412      * Now we want to test that our output data was vaguely sensible. For this
 413      * test, we expect no CLIENT_RANDOM entry because it doesn't make sense for
 414      * TLSv1.3, but we do expect both client and server to emit keys.
 415      */
 416     expected.client_handshake_secret_count = 1;
 417     expected.server_handshake_secret_count = 1;
 418     expected.client_application_secret_count = 1;
 419     expected.server_application_secret_count = 1;
 420     expected.exporter_secret_count = 1;
 421     if (!TEST_true(test_keylog_output(client_log_buffer, clientssl,
 422                                       SSL_get_session(clientssl), &expected))
 423             || !TEST_true(test_keylog_output(server_log_buffer, serverssl,
 424                                              SSL_get_session(serverssl),
 425                                              &expected)))
 426         goto end;
 427
 428     /* Terminate old session and resume with early data. */
 429     sess = SSL_get1_session(clientssl);
 430     SSL_shutdown(clientssl);
 431     SSL_shutdown(serverssl);
 432     SSL_free(serverssl);
 433     SSL_free(clientssl);
 434     serverssl = clientssl = NULL;
 435
 436     /* Reset key log */
 437     memset(client_log_buffer, 0, sizeof(client_log_buffer));
 438     memset(server_log_buffer, 0, sizeof(server_log_buffer));
 439     client_log_buffer_index = 0;
 440     server_log_buffer_index = 0;
 441
 442     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
 443                                       &clientssl, NULL, NULL))
 444             || !TEST_true(SSL_set_session(clientssl, sess))
 445             /* Here writing 0 length early data is enough. */
 446             || !TEST_true(SSL_write_early_data(clientssl, NULL, 0, &written))
 447             || !TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
 448                                                 &readbytes),
 449                             SSL_READ_EARLY_DATA_ERROR)
 450             || !TEST_int_eq(SSL_get_early_data_status(serverssl),
 451                             SSL_EARLY_DATA_ACCEPTED)
 452             || !TEST_true(create_ssl_connection(serverssl, clientssl,
 453                           SSL_ERROR_NONE))
 454             || !TEST_true(SSL_session_reused(clientssl)))
 455         goto end;
 456
 457     /* In addition to the previous entries, expect early secrets. */
 458     expected.client_early_secret_count = 1;
 459     expected.early_exporter_secret_count = 1;
 460     if (!TEST_true(test_keylog_output(client_log_buffer, clientssl,
 461                                       SSL_get_session(clientssl), &expected))
 462             || !TEST_true(test_keylog_output(server_log_buffer, serverssl,
 463                                              SSL_get_session(serverssl),
 464                                              &expected)))
 465         goto end;
 466
 467     testresult = 1;
 468
 469 end:
 470     SSL_SESSION_free(sess);
 471     SSL_free(serverssl);
 472     SSL_free(clientssl);
 473     SSL_CTX_free(sctx);
 474     SSL_CTX_free(cctx);
 475
 476     return testresult;
 477 }
 478 #endif
 479
 480 #ifndef OPENSSL_NO_TLS1_2
 481 static int full_client_hello_callback(SSL *s, int *al, void *arg)
 482 {
 483     int *ctr = arg;
 484     const unsigned char *p;
 485     int *exts;
 486     /* We only configure two ciphers, but the SCSV is added automatically. */
 487 #ifdef OPENSSL_NO_EC
 488     const unsigned char expected_ciphers[] = {0x00, 0x9d, 0x00, 0xff};
 489 #else
 490     const unsigned char expected_ciphers[] = {0x00, 0x9d, 0xc0,
 491                                               0x2c, 0x00, 0xff};
 492 #endif
 493     const int expected_extensions[] = {
 494 #ifndef OPENSSL_NO_EC
 495                                        11, 10,
 496 #endif
 497                                        35, 22, 23, 13};
 498     size_t len;
 499
 500     /* Make sure we can defer processing and get called back. */
 501     if ((*ctr)++ == 0)
 502         return SSL_CLIENT_HELLO_RETRY;
 503
 504     len = SSL_client_hello_get0_ciphers(s, &p);
 505     if (!TEST_mem_eq(p, len, expected_ciphers, sizeof(expected_ciphers))
 506             || !TEST_size_t_eq(
 507                        SSL_client_hello_get0_compression_methods(s, &p), 1)
 508             || !TEST_int_eq(*p, 0))
 509         return SSL_CLIENT_HELLO_ERROR;
 510     if (!SSL_client_hello_get1_extensions_present(s, &exts, &len))
 511         return SSL_CLIENT_HELLO_ERROR;
 512     if (len != OSSL_NELEM(expected_extensions) ||
 513         memcmp(exts, expected_extensions, len * sizeof(*exts)) != 0) {
 514         printf("ClientHello callback expected extensions mismatch\n");
 515         OPENSSL_free(exts);
 516         return SSL_CLIENT_HELLO_ERROR;
 517     }
 518     OPENSSL_free(exts);
 519     return SSL_CLIENT_HELLO_SUCCESS;
 520 }
 521
 522 static int test_client_hello_cb(void)
 523 {
 524     SSL_CTX *cctx = NULL, *sctx = NULL;
 525     SSL *clientssl = NULL, *serverssl = NULL;
 526     int testctr = 0, testresult = 0;
 527
 528     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
 529                                        TLS1_VERSION, TLS_MAX_VERSION,
 530                                        &sctx, &cctx, cert, privkey)))
 531         goto end;
 532     SSL_CTX_set_client_hello_cb(sctx, full_client_hello_callback, &testctr);
 533
 534     /* The gimpy cipher list we configure can't do TLS 1.3. */
 535     SSL_CTX_set_max_proto_version(cctx, TLS1_2_VERSION);
 536
 537     if (!TEST_true(SSL_CTX_set_cipher_list(cctx,
 538                         "AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384"))
 539             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
 540                                              &clientssl, NULL, NULL))
 541             || !TEST_false(create_ssl_connection(serverssl, clientssl,
 542                         SSL_ERROR_WANT_CLIENT_HELLO_CB))
 543                 /*
 544                  * Passing a -1 literal is a hack since
 545                  * the real value was lost.
 546                  * */
 547             || !TEST_int_eq(SSL_get_error(serverssl, -1),
 548                             SSL_ERROR_WANT_CLIENT_HELLO_CB)
 549             || !TEST_true(create_ssl_connection(serverssl, clientssl,
 550                                                 SSL_ERROR_NONE)))
 551         goto end;
 552
 553     testresult = 1;
 554
 555 end:
 556     SSL_free(serverssl);
 557     SSL_free(clientssl);
 558     SSL_CTX_free(sctx);
 559     SSL_CTX_free(cctx);
 560
 561     return testresult;
 562 }
 563 #endif
 564
 565 static int execute_test_large_message(const SSL_METHOD *smeth,
 566                                       const SSL_METHOD *cmeth,
 567                                       int min_version, int max_version,
 568                                       int read_ahead)
 569 {
 570     SSL_CTX *cctx = NULL, *sctx = NULL;
 571     SSL *clientssl = NULL, *serverssl = NULL;
 572     int testresult = 0;
 573     int i;
 574     BIO *certbio = NULL;
 575     X509 *chaincert = NULL;
 576     int certlen;
 577
 578     if (!TEST_ptr(certbio = BIO_new_file(cert, "r")))
 579         goto end;
 580     chaincert = PEM_read_bio_X509(certbio, NULL, NULL, NULL);
 581     BIO_free(certbio);
 582     certbio = NULL;
 583     if (!TEST_ptr(chaincert))
 584         goto end;
 585
 586     if (!TEST_true(create_ssl_ctx_pair(smeth, cmeth, min_version, max_version,
 587                                        &sctx, &cctx, cert, privkey)))
 588         goto end;
 589
 590     if (read_ahead) {
 591         /*
 592          * Test that read_ahead works correctly when dealing with large
 593          * records
 594          */
 595         SSL_CTX_set_read_ahead(cctx, 1);
 596     }
 597
 598     /*
 599      * We assume the supplied certificate is big enough so that if we add
 600      * NUM_EXTRA_CERTS it will make the overall message large enough. The
 601      * default buffer size is requested to be 16k, but due to the way BUF_MEM
 602      * works, it ends up allocating a little over 21k (16 * 4/3). So, in this
 603      * test we need to have a message larger than that.
 604      */
 605     certlen = i2d_X509(chaincert, NULL);
 606     OPENSSL_assert(certlen * NUM_EXTRA_CERTS >
 607                    (SSL3_RT_MAX_PLAIN_LENGTH * 4) / 3);
 608     for (i = 0; i < NUM_EXTRA_CERTS; i++) {
 609         if (!X509_up_ref(chaincert))
 610             goto end;
 611         if (!SSL_CTX_add_extra_chain_cert(sctx, chaincert)) {
 612             X509_free(chaincert);
 613             goto end;
 614         }
 615     }
 616
 617     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
 618                                       NULL, NULL))
 619             || !TEST_true(create_ssl_connection(serverssl, clientssl,
 620                                                 SSL_ERROR_NONE)))
 621         goto end;
 622
 623     /*
 624      * Calling SSL_clear() first is not required but this tests that SSL_clear()
 625      * doesn't leak (when using enable-crypto-mdebug).
 626      */
 627     if (!TEST_true(SSL_clear(serverssl)))
 628         goto end;
 629
 630     testresult = 1;
 631  end:
 632     X509_free(chaincert);
 633     SSL_free(serverssl);
 634     SSL_free(clientssl);
 635     SSL_CTX_free(sctx);
 636     SSL_CTX_free(cctx);
 637
 638     return testresult;
 639 }
 640
 641 static int test_large_message_tls(void)
 642 {
 643     return execute_test_large_message(TLS_server_method(), TLS_client_method(),
 644                                       TLS1_VERSION, TLS_MAX_VERSION,
 645                                       0);
 646 }
 647
 648 static int test_large_message_tls_read_ahead(void)
 649 {
 650     return execute_test_large_message(TLS_server_method(), TLS_client_method(),
 651                                       TLS1_VERSION, TLS_MAX_VERSION,
 652                                       1);
 653 }
 654
 655 #ifndef OPENSSL_NO_DTLS
 656 static int test_large_message_dtls(void)
 657 {
 658     /*
 659      * read_ahead is not relevant to DTLS because DTLS always acts as if
 660      * read_ahead is set.
 661      */
 662     return execute_test_large_message(DTLS_server_method(),
 663                                       DTLS_client_method(),
 664                                       DTLS1_VERSION, DTLS_MAX_VERSION,
 665                                       0);
 666 }
 667 #endif
 668
 669 #ifndef OPENSSL_NO_OCSP
 670 static int ocsp_server_cb(SSL *s, void *arg)
 671 {
 672     int *argi = (int *)arg;
 673     unsigned char *copy = NULL;
 674     STACK_OF(OCSP_RESPID) *ids = NULL;
 675     OCSP_RESPID *id = NULL;
 676
 677     if (*argi == 2) {
 678         /* In this test we are expecting exactly 1 OCSP_RESPID */
 679         SSL_get_tlsext_status_ids(s, &ids);
 680         if (ids == NULL || sk_OCSP_RESPID_num(ids) != 1)
 681             return SSL_TLSEXT_ERR_ALERT_FATAL;
 682
 683         id = sk_OCSP_RESPID_value(ids, 0);
 684         if (id == NULL || !OCSP_RESPID_match(id, ocspcert))
 685             return SSL_TLSEXT_ERR_ALERT_FATAL;
 686     } else if (*argi != 1) {
 687         return SSL_TLSEXT_ERR_ALERT_FATAL;
 688     }
 689
 690     if (!TEST_ptr(copy = OPENSSL_memdup(orespder, sizeof(orespder))))
 691         return SSL_TLSEXT_ERR_ALERT_FATAL;
 692
 693     SSL_set_tlsext_status_ocsp_resp(s, copy, sizeof(orespder));
 694     ocsp_server_called = 1;
 695     return SSL_TLSEXT_ERR_OK;
 696 }
 697
 698 static int ocsp_client_cb(SSL *s, void *arg)
 699 {
 700     int *argi = (int *)arg;
 701     const unsigned char *respderin;
 702     size_t len;
 703
 704     if (*argi != 1 && *argi != 2)
 705         return 0;
 706
 707     len = SSL_get_tlsext_status_ocsp_resp(s, &respderin);
 708     if (!TEST_mem_eq(orespder, len, respderin, len))
 709         return 0;
 710
 711     ocsp_client_called = 1;
 712     return 1;
 713 }
 714
 715 static int test_tlsext_status_type(void)
 716 {
 717     SSL_CTX *cctx = NULL, *sctx = NULL;
 718     SSL *clientssl = NULL, *serverssl = NULL;
 719     int testresult = 0;
 720     STACK_OF(OCSP_RESPID) *ids = NULL;
 721     OCSP_RESPID *id = NULL;
 722     BIO *certbio = NULL;
 723
 724     if (!create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
 725                              TLS1_VERSION, TLS_MAX_VERSION,
 726                              &sctx, &cctx, cert, privkey))
 727         return 0;
 728
 729     if (SSL_CTX_get_tlsext_status_type(cctx) != -1)
 730         goto end;
 731
 732     /* First just do various checks getting and setting tlsext_status_type */
 733
 734     clientssl = SSL_new(cctx);
 735     if (!TEST_int_eq(SSL_get_tlsext_status_type(clientssl), -1)
 736             || !TEST_true(SSL_set_tlsext_status_type(clientssl,
 737                                                       TLSEXT_STATUSTYPE_ocsp))
 738             || !TEST_int_eq(SSL_get_tlsext_status_type(clientssl),
 739                             TLSEXT_STATUSTYPE_ocsp))
 740         goto end;
 741
 742     SSL_free(clientssl);
 743     clientssl = NULL;
 744
 745     if (!SSL_CTX_set_tlsext_status_type(cctx, TLSEXT_STATUSTYPE_ocsp)
 746      || SSL_CTX_get_tlsext_status_type(cctx) != TLSEXT_STATUSTYPE_ocsp)
 747         goto end;
 748
 749     clientssl = SSL_new(cctx);
 750     if (SSL_get_tlsext_status_type(clientssl) != TLSEXT_STATUSTYPE_ocsp)
 751         goto end;
 752     SSL_free(clientssl);
 753     clientssl = NULL;
 754
 755     /*
 756      * Now actually do a handshake and check OCSP information is exchanged and
 757      * the callbacks get called
 758      */
 759     SSL_CTX_set_tlsext_status_cb(cctx, ocsp_client_cb);
 760     SSL_CTX_set_tlsext_status_arg(cctx, &cdummyarg);
 761     SSL_CTX_set_tlsext_status_cb(sctx, ocsp_server_cb);
 762     SSL_CTX_set_tlsext_status_arg(sctx, &cdummyarg);
 763     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
 764                                       &clientssl, NULL, NULL))
 765             || !TEST_true(create_ssl_connection(serverssl, clientssl,
 766                                                 SSL_ERROR_NONE))
 767             || !TEST_true(ocsp_client_called)
 768             || !TEST_true(ocsp_server_called))
 769         goto end;
 770     SSL_free(serverssl);
 771     SSL_free(clientssl);
 772     serverssl = NULL;
 773     clientssl = NULL;
 774
 775     /* Try again but this time force the server side callback to fail */
 776     ocsp_client_called = 0;
 777     ocsp_server_called = 0;
 778     cdummyarg = 0;
 779     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
 780                                       &clientssl, NULL, NULL))
 781                 /* This should fail because the callback will fail */
 782             || !TEST_false(create_ssl_connection(serverssl, clientssl,
 783                                                  SSL_ERROR_NONE))
 784             || !TEST_false(ocsp_client_called)
 785             || !TEST_false(ocsp_server_called))
 786         goto end;
 787     SSL_free(serverssl);
 788     SSL_free(clientssl);
 789     serverssl = NULL;
 790     clientssl = NULL;
 791
 792     /*
 793      * This time we'll get the client to send an OCSP_RESPID that it will
 794      * accept.
 795      */
 796     ocsp_client_called = 0;
 797     ocsp_server_called = 0;
 798     cdummyarg = 2;
 799     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
 800                                       &clientssl, NULL, NULL)))
 801         goto end;
 802
 803     /*
 804      * We'll just use any old cert for this test - it doesn't have to be an OCSP
 805      * specific one. We'll use the server cert.
 806      */
 807     if (!TEST_ptr(certbio = BIO_new_file(cert, "r"))
 808             || !TEST_ptr(id = OCSP_RESPID_new())
 809             || !TEST_ptr(ids = sk_OCSP_RESPID_new_null())
 810             || !TEST_ptr(ocspcert = PEM_read_bio_X509(certbio,
 811                                                       NULL, NULL, NULL))
 812             || !TEST_true(OCSP_RESPID_set_by_key(id, ocspcert))
 813             || !TEST_true(sk_OCSP_RESPID_push(ids, id)))
 814         goto end;
 815     id = NULL;
 816     SSL_set_tlsext_status_ids(clientssl, ids);
 817     /* Control has been transferred */
 818     ids = NULL;
 819
 820     BIO_free(certbio);
 821     certbio = NULL;
 822
 823     if (!TEST_true(create_ssl_connection(serverssl, clientssl,
 824                                          SSL_ERROR_NONE))
 825             || !TEST_true(ocsp_client_called)
 826             || !TEST_true(ocsp_server_called))
 827         goto end;
 828
 829     testresult = 1;
 830
 831  end:
 832     SSL_free(serverssl);
 833     SSL_free(clientssl);
 834     SSL_CTX_free(sctx);
 835     SSL_CTX_free(cctx);
 836     sk_OCSP_RESPID_pop_free(ids, OCSP_RESPID_free);
 837     OCSP_RESPID_free(id);
 838     BIO_free(certbio);
 839     X509_free(ocspcert);
 840     ocspcert = NULL;
 841
 842     return testresult;
 843 }
 844 #endif
 845
 846 #if !defined(OPENSSL_NO_TLS1_3) || !defined(OPENSSL_NO_TLS1_2)
 847 static int new_called, remove_called, get_called;
 848
 849 static int new_session_cb(SSL *ssl, SSL_SESSION *sess)
 850 {
 851     new_called++;
 852     /*
 853      * sess has been up-refed for us, but we don't actually need it so free it
 854      * immediately.
 855      */
 856     SSL_SESSION_free(sess);
 857     return 1;
 858 }
 859
 860 static void remove_session_cb(SSL_CTX *ctx, SSL_SESSION *sess)
 861 {
 862     remove_called++;
 863 }
 864
 865 static SSL_SESSION *get_sess_val = NULL;
 866
 867 static SSL_SESSION *get_session_cb(SSL *ssl, const unsigned char *id, int len,
 868                                    int *copy)
 869 {
 870     get_called++;
 871     *copy = 1;
 872     return get_sess_val;
 873 }
 874
 875 static int execute_test_session(int maxprot, int use_int_cache,
 876                                 int use_ext_cache)
 877 {
 878     SSL_CTX *sctx = NULL, *cctx = NULL;
 879     SSL *serverssl1 = NULL, *clientssl1 = NULL;
 880     SSL *serverssl2 = NULL, *clientssl2 = NULL;
 881 # ifndef OPENSSL_NO_TLS1_1
 882     SSL *serverssl3 = NULL, *clientssl3 = NULL;
 883 # endif
 884     SSL_SESSION *sess1 = NULL, *sess2 = NULL;
 885     int testresult = 0, numnewsesstick = 1;
 886
 887     new_called = remove_called = 0;
 888
 889     /* TLSv1.3 sends 2 NewSessionTickets */
 890     if (maxprot == TLS1_3_VERSION)
 891         numnewsesstick = 2;
 892
 893     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
 894                                        TLS1_VERSION, TLS_MAX_VERSION,
 895                                        &sctx, &cctx, cert, privkey)))
 896         return 0;
 897
 898     /*
 899      * Only allow the max protocol version so we can force a connection failure
 900      * later
 901      */
 902     SSL_CTX_set_min_proto_version(cctx, maxprot);
 903     SSL_CTX_set_max_proto_version(cctx, maxprot);
 904
 905     /* Set up session cache */
 906     if (use_ext_cache) {
 907         SSL_CTX_sess_set_new_cb(cctx, new_session_cb);
 908         SSL_CTX_sess_set_remove_cb(cctx, remove_session_cb);
 909     }
 910     if (use_int_cache) {
 911         /* Also covers instance where both are set */
 912         SSL_CTX_set_session_cache_mode(cctx, SSL_SESS_CACHE_CLIENT);
 913     } else {
 914         SSL_CTX_set_session_cache_mode(cctx,
 915                                        SSL_SESS_CACHE_CLIENT
 916                                        | SSL_SESS_CACHE_NO_INTERNAL_STORE);
 917     }
 918
 919     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl1, &clientssl1,
 920                                       NULL, NULL))
 921             || !TEST_true(create_ssl_connection(serverssl1, clientssl1,
 922                                                 SSL_ERROR_NONE))
 923             || !TEST_ptr(sess1 = SSL_get1_session(clientssl1)))
 924         goto end;
 925
 926     /* Should fail because it should already be in the cache */
 927     if (use_int_cache && !TEST_false(SSL_CTX_add_session(cctx, sess1)))
 928         goto end;
 929     if (use_ext_cache
 930             && (!TEST_int_eq(new_called, numnewsesstick)
 931
 932                 || !TEST_int_eq(remove_called, 0)))
 933         goto end;
 934
 935     new_called = remove_called = 0;
 936     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl2,
 937                                       &clientssl2, NULL, NULL))
 938             || !TEST_true(SSL_set_session(clientssl2, sess1))
 939             || !TEST_true(create_ssl_connection(serverssl2, clientssl2,
 940                                                 SSL_ERROR_NONE))
 941             || !TEST_true(SSL_session_reused(clientssl2)))
 942         goto end;
 943
 944     if (maxprot == TLS1_3_VERSION) {
 945         /*
 946          * In TLSv1.3 we should have created a new session even though we have
 947          * resumed.
 948          */
 949         if (use_ext_cache
 950                 && (!TEST_int_eq(new_called, 1)
 951                     || !TEST_int_eq(remove_called, 0)))
 952             goto end;
 953     } else {
 954         /*
 955          * In TLSv1.2 we expect to have resumed so no sessions added or
 956          * removed.
 957          */
 958         if (use_ext_cache
 959                 && (!TEST_int_eq(new_called, 0)
 960                     || !TEST_int_eq(remove_called, 0)))
 961             goto end;
 962     }
 963
 964     SSL_SESSION_free(sess1);
 965     if (!TEST_ptr(sess1 = SSL_get1_session(clientssl2)))
 966         goto end;
 967     shutdown_ssl_connection(serverssl2, clientssl2);
 968     serverssl2 = clientssl2 = NULL;
 969
 970     new_called = remove_called = 0;
 971     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl2,
 972                                       &clientssl2, NULL, NULL))
 973             || !TEST_true(create_ssl_connection(serverssl2, clientssl2,
 974                                                 SSL_ERROR_NONE)))
 975         goto end;
 976
 977     if (!TEST_ptr(sess2 = SSL_get1_session(clientssl2)))
 978         goto end;
 979
 980     if (use_ext_cache
 981             && (!TEST_int_eq(new_called, numnewsesstick)
 982                 || !TEST_int_eq(remove_called, 0)))
 983         goto end;
 984
 985     new_called = remove_called = 0;
 986     /*
 987      * This should clear sess2 from the cache because it is a "bad" session.
 988      * See SSL_set_session() documentation.
 989      */
 990     if (!TEST_true(SSL_set_session(clientssl2, sess1)))
 991         goto end;
 992     if (use_ext_cache
 993             && (!TEST_int_eq(new_called, 0) || !TEST_int_eq(remove_called, 1)))
 994         goto end;
 995     if (!TEST_ptr_eq(SSL_get_session(clientssl2), sess1))
 996         goto end;
 997
 998     if (use_int_cache) {
 999         /* Should succeeded because it should not already be in the cache */
1000         if (!TEST_true(SSL_CTX_add_session(cctx, sess2))
1001                 || !TEST_true(SSL_CTX_remove_session(cctx, sess2)))
1002             goto end;
1003     }
1004
1005     new_called = remove_called = 0;
1006     /* This shouldn't be in the cache so should fail */
1007     if (!TEST_false(SSL_CTX_remove_session(cctx, sess2)))
1008         goto end;
1009
1010     if (use_ext_cache
1011             && (!TEST_int_eq(new_called, 0) || !TEST_int_eq(remove_called, 1)))
1012         goto end;
1013
1014 # if !defined(OPENSSL_NO_TLS1_1)
1015     new_called = remove_called = 0;
1016     /* Force a connection failure */
1017     SSL_CTX_set_max_proto_version(sctx, TLS1_1_VERSION);
1018     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl3,
1019                                       &clientssl3, NULL, NULL))
1020             || !TEST_true(SSL_set_session(clientssl3, sess1))
1021             /* This should fail because of the mismatched protocol versions */
1022             || !TEST_false(create_ssl_connection(serverssl3, clientssl3,
1023                                                  SSL_ERROR_NONE)))
1024         goto end;
1025
1026     /* We should have automatically removed the session from the cache */
1027     if (use_ext_cache
1028             && (!TEST_int_eq(new_called, 0) || !TEST_int_eq(remove_called, 1)))
1029         goto end;
1030
1031     /* Should succeed because it should not already be in the cache */
1032     if (use_int_cache && !TEST_true(SSL_CTX_add_session(cctx, sess2)))
1033         goto end;
1034 # endif
1035
1036     /* Now do some tests for server side caching */
1037     if (use_ext_cache) {
1038         SSL_CTX_sess_set_new_cb(cctx, NULL);
1039         SSL_CTX_sess_set_remove_cb(cctx, NULL);
1040         SSL_CTX_sess_set_new_cb(sctx, new_session_cb);
1041         SSL_CTX_sess_set_remove_cb(sctx, remove_session_cb);
1042         SSL_CTX_sess_set_get_cb(sctx, get_session_cb);
1043         get_sess_val = NULL;
1044     }
1045
1046     SSL_CTX_set_session_cache_mode(cctx, 0);
1047     /* Internal caching is the default on the server side */
1048     if (!use_int_cache)
1049         SSL_CTX_set_session_cache_mode(sctx,
1050                                        SSL_SESS_CACHE_SERVER
1051                                        | SSL_SESS_CACHE_NO_INTERNAL_STORE);
1052
1053     SSL_free(serverssl1);
1054     SSL_free(clientssl1);
1055     serverssl1 = clientssl1 = NULL;
1056     SSL_free(serverssl2);
1057     SSL_free(clientssl2);
1058     serverssl2 = clientssl2 = NULL;
1059     SSL_SESSION_free(sess1);
1060     sess1 = NULL;
1061     SSL_SESSION_free(sess2);
1062     sess2 = NULL;
1063
1064     SSL_CTX_set_max_proto_version(sctx, maxprot);
1065     SSL_CTX_set_options(sctx, SSL_OP_NO_TICKET);
1066     new_called = remove_called = get_called = 0;
1067     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl1, &clientssl1,
1068                                       NULL, NULL))
1069             || !TEST_true(create_ssl_connection(serverssl1, clientssl1,
1070                                                 SSL_ERROR_NONE))
1071             || !TEST_ptr(sess1 = SSL_get1_session(clientssl1))
1072             || !TEST_ptr(sess2 = SSL_get1_session(serverssl1)))
1073         goto end;
1074
1075     /* Should fail because it should already be in the cache */
1076     if (use_int_cache && !TEST_false(SSL_CTX_add_session(sctx, sess2)))
1077         goto end;
1078
1079     if (use_ext_cache) {
1080         SSL_SESSION *tmp = sess2;
1081
1082         if (!TEST_int_eq(new_called, numnewsesstick)
1083                 || !TEST_int_eq(remove_called, 0)
1084                 || !TEST_int_eq(get_called, 0))
1085             goto end;
1086         /*
1087          * Delete the session from the internal cache to force a lookup from
1088          * the external cache. We take a copy first because
1089          * SSL_CTX_remove_session() also marks the session as non-resumable.
1090          */
1091         if (use_int_cache) {
1092             if (!TEST_ptr(tmp = SSL_SESSION_dup(sess2))
1093                     || !TEST_true(SSL_CTX_remove_session(sctx, sess2)))
1094                 goto end;
1095             SSL_SESSION_free(sess2);
1096         }
1097         sess2 = tmp;
1098     }
1099
1100     new_called = remove_called = get_called = 0;
1101     get_sess_val = sess2;
1102     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl2,
1103                                       &clientssl2, NULL, NULL))
1104             || !TEST_true(SSL_set_session(clientssl2, sess1))
1105             || !TEST_true(create_ssl_connection(serverssl2, clientssl2,
1106                                                 SSL_ERROR_NONE))
1107             || !TEST_true(SSL_session_reused(clientssl2)))
1108         goto end;
1109
1110     if (use_ext_cache) {
1111         if (!TEST_int_eq(remove_called, 0))
1112             goto end;
1113
1114         if (maxprot == TLS1_3_VERSION) {
1115             if (!TEST_int_eq(new_called, 1)
1116                     || !TEST_int_eq(get_called, 0))
1117                 goto end;
1118         } else {
1119             if (!TEST_int_eq(new_called, 0)
1120                     || !TEST_int_eq(get_called, 1))
1121                 goto end;
1122         }
1123     }
1124
1125     testresult = 1;
1126
1127  end:
1128     SSL_free(serverssl1);
1129     SSL_free(clientssl1);
1130     SSL_free(serverssl2);
1131     SSL_free(clientssl2);
1132 # ifndef OPENSSL_NO_TLS1_1
1133     SSL_free(serverssl3);
1134     SSL_free(clientssl3);
1135 # endif
1136     SSL_SESSION_free(sess1);
1137     SSL_SESSION_free(sess2);
1138     SSL_CTX_free(sctx);
1139     SSL_CTX_free(cctx);
1140
1141     return testresult;
1142 }
1143 #endif /* !defined(OPENSSL_NO_TLS1_3) || !defined(OPENSSL_NO_TLS1_2) */
1144
1145 static int test_session_with_only_int_cache(void)
1146 {
1147 #ifndef OPENSSL_NO_TLS1_3
1148     if (!execute_test_session(TLS1_3_VERSION, 1, 0))
1149         return 0;
1150 #endif
1151
1152 #ifndef OPENSSL_NO_TLS1_2
1153     return execute_test_session(TLS1_2_VERSION, 1, 0);
1154 #else
1155     return 1;
1156 #endif
1157 }
1158
1159 static int test_session_with_only_ext_cache(void)
1160 {
1161 #ifndef OPENSSL_NO_TLS1_3
1162     if (!execute_test_session(TLS1_3_VERSION, 0, 1))
1163         return 0;
1164 #endif
1165
1166 #ifndef OPENSSL_NO_TLS1_2
1167     return execute_test_session(TLS1_2_VERSION, 0, 1);
1168 #else
1169     return 1;
1170 #endif
1171 }
1172
1173 static int test_session_with_both_cache(void)
1174 {
1175 #ifndef OPENSSL_NO_TLS1_3
1176     if (!execute_test_session(TLS1_3_VERSION, 1, 1))
1177         return 0;
1178 #endif
1179
1180 #ifndef OPENSSL_NO_TLS1_2
1181     return execute_test_session(TLS1_2_VERSION, 1, 1);
1182 #else
1183     return 1;
1184 #endif
1185 }
1186
1187 SSL_SESSION *sesscache[9];
1188
1189 static int new_cachesession_cb(SSL *ssl, SSL_SESSION *sess)
1190 {
1191     sesscache[new_called++] = sess;
1192
1193     return 1;
1194 }
1195
1196 static int test_tickets(int idx)
1197 {
1198     SSL_CTX *sctx = NULL, *cctx = NULL;
1199     SSL *serverssl = NULL, *clientssl = NULL;
1200     int testresult = 0, i;
1201     size_t j;
1202
1203     /* idx is the test number, but also the number of tickets we want */
1204
1205     new_called = 0;
1206
1207     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
1208                                        TLS1_VERSION, TLS_MAX_VERSION, &sctx,
1209                                        &cctx, cert, privkey))
1210             || !TEST_true(SSL_CTX_set_num_tickets(sctx, idx)))
1211         goto end;
1212
1213     SSL_CTX_set_session_cache_mode(cctx, SSL_SESS_CACHE_CLIENT
1214                                          | SSL_SESS_CACHE_NO_INTERNAL_STORE);
1215     SSL_CTX_sess_set_new_cb(cctx, new_cachesession_cb);
1216
1217     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
1218                                           &clientssl, NULL, NULL)))
1219         goto end;
1220
1221     SSL_force_post_handshake_auth(clientssl);
1222
1223     if (!TEST_true(create_ssl_connection(serverssl, clientssl,
1224                                                 SSL_ERROR_NONE))
1225                /* Check we got the number of tickets we were expecting */
1226             || !TEST_int_eq(idx, new_called))
1227         goto end;
1228
1229     /* After a post-handshake authentication we should get new tickets issued */
1230     SSL_set_verify(serverssl, SSL_VERIFY_PEER, NULL);
1231     if (!TEST_true(SSL_verify_client_post_handshake(serverssl)))
1232         goto end;
1233
1234     /* Start handshake on the server and client */
1235     if (!TEST_int_eq(SSL_do_handshake(serverssl), 1)
1236             || !TEST_int_le(SSL_read(clientssl, NULL, 0), 0)
1237             || !TEST_int_le(SSL_read(serverssl, NULL, 0), 0)
1238             || !TEST_true(create_ssl_connection(serverssl, clientssl,
1239                                                 SSL_ERROR_NONE))
1240             || !TEST_int_eq(idx * 2, new_called))
1241         goto end;
1242
1243     SSL_CTX_sess_set_new_cb(cctx, NULL);
1244     SSL_shutdown(clientssl);
1245     SSL_shutdown(serverssl);
1246     SSL_free(serverssl);
1247     SSL_free(clientssl);
1248     serverssl = clientssl = NULL;
1249
1250     /* Test that we can resume with all the tickets we got given */
1251     for (i = 0; i < new_called; i++) {
1252         if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
1253                                               &clientssl, NULL, NULL))
1254                 || !TEST_true(SSL_set_session(clientssl, sesscache[i]))
1255                 || !TEST_true(create_ssl_connection(serverssl, clientssl,
1256                                                     SSL_ERROR_NONE))
1257                 || !TEST_true(SSL_session_reused(clientssl)))
1258             goto end;
1259
1260         SSL_shutdown(clientssl);
1261         SSL_shutdown(serverssl);
1262         SSL_free(serverssl);
1263         SSL_free(clientssl);
1264         serverssl = clientssl = NULL;
1265         SSL_SESSION_free(sesscache[i]);
1266         sesscache[i] = NULL;
1267     }
1268
1269     testresult = 1;
1270
1271  end:
1272     SSL_free(serverssl);
1273     SSL_free(clientssl);
1274     for (j = 0; j < OSSL_NELEM(sesscache); j++)
1275         SSL_SESSION_free(sesscache[j]);
1276     SSL_CTX_free(sctx);
1277     SSL_CTX_free(cctx);
1278
1279     return testresult;
1280 }
1281
1282 #define USE_NULL            0
1283 #define USE_BIO_1           1
1284 #define USE_BIO_2           2
1285 #define USE_DEFAULT         3
1286
1287 #define CONNTYPE_CONNECTION_SUCCESS  0
1288 #define CONNTYPE_CONNECTION_FAIL     1
1289 #define CONNTYPE_NO_CONNECTION       2
1290
1291 #define TOTAL_NO_CONN_SSL_SET_BIO_TESTS         (3 * 3 * 3 * 3)
1292 #define TOTAL_CONN_SUCCESS_SSL_SET_BIO_TESTS    (2 * 2)
1293 #if !defined(OPENSSL_NO_TLS1_3) && !defined(OPENSSL_NO_TLS1_2)
1294 # define TOTAL_CONN_FAIL_SSL_SET_BIO_TESTS       (2 * 2)
1295 #else
1296 # define TOTAL_CONN_FAIL_SSL_SET_BIO_TESTS       0
1297 #endif
1298
1299 #define TOTAL_SSL_SET_BIO_TESTS TOTAL_NO_CONN_SSL_SET_BIO_TESTS \
1300                                 + TOTAL_CONN_SUCCESS_SSL_SET_BIO_TESTS \
1301                                 + TOTAL_CONN_FAIL_SSL_SET_BIO_TESTS
1302
1303 static void setupbio(BIO **res, BIO *bio1, BIO *bio2, int type)
1304 {
1305     switch (type) {
1306     case USE_NULL:
1307         *res = NULL;
1308         break;
1309     case USE_BIO_1:
1310         *res = bio1;
1311         break;
1312     case USE_BIO_2:
1313         *res = bio2;
1314         break;
1315     }
1316 }
1317
1318
1319 /*
1320  * Tests calls to SSL_set_bio() under various conditions.
1321  *
1322  * For the first 3 * 3 * 3 * 3 = 81 tests we do 2 calls to SSL_set_bio() with
1323  * various combinations of valid BIOs or NULL being set for the rbio/wbio. We
1324  * then do more tests where we create a successful connection first using our
1325  * standard connection setup functions, and then call SSL_set_bio() with
1326  * various combinations of valid BIOs or NULL. We then repeat these tests
1327  * following a failed connection. In this last case we are looking to check that
1328  * SSL_set_bio() functions correctly in the case where s->bbio is not NULL.
1329  */
1330 static int test_ssl_set_bio(int idx)
1331 {
1332     SSL_CTX *sctx = NULL, *cctx = NULL;
1333     BIO *bio1 = NULL;
1334     BIO *bio2 = NULL;
1335     BIO *irbio = NULL, *iwbio = NULL, *nrbio = NULL, *nwbio = NULL;
1336     SSL *serverssl = NULL, *clientssl = NULL;
1337     int initrbio, initwbio, newrbio, newwbio, conntype;
1338     int testresult = 0;
1339
1340     if (idx < TOTAL_NO_CONN_SSL_SET_BIO_TESTS) {
1341         initrbio = idx % 3;
1342         idx /= 3;
1343         initwbio = idx % 3;
1344         idx /= 3;
1345         newrbio = idx % 3;
1346         idx /= 3;
1347         newwbio = idx % 3;
1348         conntype = CONNTYPE_NO_CONNECTION;
1349     } else {
1350         idx -= TOTAL_NO_CONN_SSL_SET_BIO_TESTS;
1351         initrbio = initwbio = USE_DEFAULT;
1352         newrbio = idx % 2;
1353         idx /= 2;
1354         newwbio = idx % 2;
1355         idx /= 2;
1356         conntype = idx % 2;
1357     }
1358
1359     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
1360                                        TLS1_VERSION, TLS_MAX_VERSION,
1361                                        &sctx, &cctx, cert, privkey)))
1362         goto end;
1363
1364     if (conntype == CONNTYPE_CONNECTION_FAIL) {
1365         /*
1366          * We won't ever get here if either TLSv1.3 or TLSv1.2 is disabled
1367          * because we reduced the number of tests in the definition of
1368          * TOTAL_CONN_FAIL_SSL_SET_BIO_TESTS to avoid this scenario. By setting
1369          * mismatched protocol versions we will force a connection failure.
1370          */
1371         SSL_CTX_set_min_proto_version(sctx, TLS1_3_VERSION);
1372         SSL_CTX_set_max_proto_version(cctx, TLS1_2_VERSION);
1373     }
1374
1375     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
1376                                       NULL, NULL)))
1377         goto end;
1378
1379     if (initrbio == USE_BIO_1
1380             || initwbio == USE_BIO_1
1381             || newrbio == USE_BIO_1
1382             || newwbio == USE_BIO_1) {
1383         if (!TEST_ptr(bio1 = BIO_new(BIO_s_mem())))
1384             goto end;
1385     }
1386
1387     if (initrbio == USE_BIO_2
1388             || initwbio == USE_BIO_2
1389             || newrbio == USE_BIO_2
1390             || newwbio == USE_BIO_2) {
1391         if (!TEST_ptr(bio2 = BIO_new(BIO_s_mem())))
1392             goto end;
1393     }
1394
1395     if (initrbio != USE_DEFAULT) {
1396         setupbio(&irbio, bio1, bio2, initrbio);
1397         setupbio(&iwbio, bio1, bio2, initwbio);
1398         SSL_set_bio(clientssl, irbio, iwbio);
1399
1400         /*
1401          * We want to maintain our own refs to these BIO, so do an up ref for
1402          * each BIO that will have ownership transferred in the SSL_set_bio()
1403          * call
1404          */
1405         if (irbio != NULL)
1406             BIO_up_ref(irbio);
1407         if (iwbio != NULL && iwbio != irbio)
1408             BIO_up_ref(iwbio);
1409     }
1410
1411     if (conntype != CONNTYPE_NO_CONNECTION
1412             && !TEST_true(create_ssl_connection(serverssl, clientssl,
1413                                                 SSL_ERROR_NONE)
1414                           == (conntype == CONNTYPE_CONNECTION_SUCCESS)))
1415         goto end;
1416
1417     setupbio(&nrbio, bio1, bio2, newrbio);
1418     setupbio(&nwbio, bio1, bio2, newwbio);
1419
1420     /*
1421      * We will (maybe) transfer ownership again so do more up refs.
1422      * SSL_set_bio() has some really complicated ownership rules where BIOs have
1423      * already been set!
1424      */
1425     if (nrbio != NULL
1426             && nrbio != irbio
1427             && (nwbio != iwbio || nrbio != nwbio))
1428         BIO_up_ref(nrbio);
1429     if (nwbio != NULL
1430             && nwbio != nrbio
1431             && (nwbio != iwbio || (nwbio == iwbio && irbio == iwbio)))
1432         BIO_up_ref(nwbio);
1433
1434     SSL_set_bio(clientssl, nrbio, nwbio);
1435
1436     testresult = 1;
1437
1438  end:
1439     BIO_free(bio1);
1440     BIO_free(bio2);
1441
1442     /*
1443      * This test is checking that the ref counting for SSL_set_bio is correct.
1444      * If we get here and we did too many frees then we will fail in the above
1445      * functions. If we haven't done enough then this will only be detected in
1446      * a crypto-mdebug build
1447      */
1448     SSL_free(serverssl);
1449     SSL_free(clientssl);
1450     SSL_CTX_free(sctx);
1451     SSL_CTX_free(cctx);
1452     return testresult;
1453 }
1454
1455 typedef enum { NO_BIO_CHANGE, CHANGE_RBIO, CHANGE_WBIO } bio_change_t;
1456
1457 static int execute_test_ssl_bio(int pop_ssl, bio_change_t change_bio)
1458 {
1459     BIO *sslbio = NULL, *membio1 = NULL, *membio2 = NULL;
1460     SSL_CTX *ctx;
1461     SSL *ssl = NULL;
1462     int testresult = 0;
1463
1464     if (!TEST_ptr(ctx = SSL_CTX_new(TLS_method()))
1465             || !TEST_ptr(ssl = SSL_new(ctx))
1466             || !TEST_ptr(sslbio = BIO_new(BIO_f_ssl()))
1467             || !TEST_ptr(membio1 = BIO_new(BIO_s_mem())))
1468         goto end;
1469
1470     BIO_set_ssl(sslbio, ssl, BIO_CLOSE);
1471
1472     /*
1473      * If anything goes wrong here then we could leak memory, so this will
1474      * be caught in a crypto-mdebug build
1475      */
1476     BIO_push(sslbio, membio1);
1477
1478     /* Verify changing the rbio/wbio directly does not cause leaks */
1479     if (change_bio != NO_BIO_CHANGE) {
1480         if (!TEST_ptr(membio2 = BIO_new(BIO_s_mem())))
1481             goto end;
1482         if (change_bio == CHANGE_RBIO)
1483             SSL_set0_rbio(ssl, membio2);
1484         else
1485             SSL_set0_wbio(ssl, membio2);
1486     }
1487     ssl = NULL;
1488
1489     if (pop_ssl)
1490         BIO_pop(sslbio);
1491     else
1492         BIO_pop(membio1);
1493
1494     testresult = 1;
1495  end:
1496     BIO_free(membio1);
1497     BIO_free(sslbio);
1498     SSL_free(ssl);
1499     SSL_CTX_free(ctx);
1500
1501     return testresult;
1502 }
1503
1504 static int test_ssl_bio_pop_next_bio(void)
1505 {
1506     return execute_test_ssl_bio(0, NO_BIO_CHANGE);
1507 }
1508
1509 static int test_ssl_bio_pop_ssl_bio(void)
1510 {
1511     return execute_test_ssl_bio(1, NO_BIO_CHANGE);
1512 }
1513
1514 static int test_ssl_bio_change_rbio(void)
1515 {
1516     return execute_test_ssl_bio(0, CHANGE_RBIO);
1517 }
1518
1519 static int test_ssl_bio_change_wbio(void)
1520 {
1521     return execute_test_ssl_bio(0, CHANGE_WBIO);
1522 }
1523
1524 #if !defined(OPENSSL_NO_TLS1_2) || defined(OPENSSL_NO_TLS1_3)
1525 typedef struct {
1526     /* The list of sig algs */
1527     const int *list;
1528     /* The length of the list */
1529     size_t listlen;
1530     /* A sigalgs list in string format */
1531     const char *liststr;
1532     /* Whether setting the list should succeed */
1533     int valid;
1534     /* Whether creating a connection with the list should succeed */
1535     int connsuccess;
1536 } sigalgs_list;
1537
1538 static const int validlist1[] = {NID_sha256, EVP_PKEY_RSA};
1539 # ifndef OPENSSL_NO_EC
1540 static const int validlist2[] = {NID_sha256, EVP_PKEY_RSA, NID_sha512, EVP_PKEY_EC};
1541 static const int validlist3[] = {NID_sha512, EVP_PKEY_EC};
1542 # endif
1543 static const int invalidlist1[] = {NID_undef, EVP_PKEY_RSA};
1544 static const int invalidlist2[] = {NID_sha256, NID_undef};
1545 static const int invalidlist3[] = {NID_sha256, EVP_PKEY_RSA, NID_sha256};
1546 static const int invalidlist4[] = {NID_sha256};
1547 static const sigalgs_list testsigalgs[] = {
1548     {validlist1, OSSL_NELEM(validlist1), NULL, 1, 1},
1549 # ifndef OPENSSL_NO_EC
1550     {validlist2, OSSL_NELEM(validlist2), NULL, 1, 1},
1551     {validlist3, OSSL_NELEM(validlist3), NULL, 1, 0},
1552 # endif
1553     {NULL, 0, "RSA+SHA256", 1, 1},
1554 # ifndef OPENSSL_NO_EC
1555     {NULL, 0, "RSA+SHA256:ECDSA+SHA512", 1, 1},
1556     {NULL, 0, "ECDSA+SHA512", 1, 0},
1557 # endif
1558     {invalidlist1, OSSL_NELEM(invalidlist1), NULL, 0, 0},
1559     {invalidlist2, OSSL_NELEM(invalidlist2), NULL, 0, 0},
1560     {invalidlist3, OSSL_NELEM(invalidlist3), NULL, 0, 0},
1561     {invalidlist4, OSSL_NELEM(invalidlist4), NULL, 0, 0},
1562     {NULL, 0, "RSA", 0, 0},
1563     {NULL, 0, "SHA256", 0, 0},
1564     {NULL, 0, "RSA+SHA256:SHA256", 0, 0},
1565     {NULL, 0, "Invalid", 0, 0}
1566 };
1567
1568 static int test_set_sigalgs(int idx)
1569 {
1570     SSL_CTX *cctx = NULL, *sctx = NULL;
1571     SSL *clientssl = NULL, *serverssl = NULL;
1572     int testresult = 0;
1573     const sigalgs_list *curr;
1574     int testctx;
1575
1576     /* Should never happen */
1577     if (!TEST_size_t_le((size_t)idx, OSSL_NELEM(testsigalgs) * 2))
1578         return 0;
1579
1580     testctx = ((size_t)idx < OSSL_NELEM(testsigalgs));
1581     curr = testctx ? &testsigalgs[idx]
1582                    : &testsigalgs[idx - OSSL_NELEM(testsigalgs)];
1583
1584     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
1585                                        TLS1_VERSION, TLS_MAX_VERSION,
1586                                        &sctx, &cctx, cert, privkey)))
1587         return 0;
1588
1589     /*
1590      * TODO(TLS1.3): These APIs cannot set TLSv1.3 sig algs so we just test it
1591      * for TLSv1.2 for now until we add a new API.
1592      */
1593     SSL_CTX_set_max_proto_version(cctx, TLS1_2_VERSION);
1594
1595     if (testctx) {
1596         int ret;
1597
1598         if (curr->list != NULL)
1599             ret = SSL_CTX_set1_sigalgs(cctx, curr->list, curr->listlen);
1600         else
1601             ret = SSL_CTX_set1_sigalgs_list(cctx, curr->liststr);
1602
1603         if (!ret) {
1604             if (curr->valid)
1605                 TEST_info("Failure setting sigalgs in SSL_CTX (%d)\n", idx);
1606             else
1607                 testresult = 1;
1608             goto end;
1609         }
1610         if (!curr->valid) {
1611             TEST_info("Not-failed setting sigalgs in SSL_CTX (%d)\n", idx);
1612             goto end;
1613         }
1614     }
1615
1616     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
1617                                       &clientssl, NULL, NULL)))
1618         goto end;
1619
1620     if (!testctx) {
1621         int ret;
1622
1623         if (curr->list != NULL)
1624             ret = SSL_set1_sigalgs(clientssl, curr->list, curr->listlen);
1625         else
1626             ret = SSL_set1_sigalgs_list(clientssl, curr->liststr);
1627         if (!ret) {
1628             if (curr->valid)
1629                 TEST_info("Failure setting sigalgs in SSL (%d)\n", idx);
1630             else
1631                 testresult = 1;
1632             goto end;
1633         }
1634         if (!curr->valid)
1635             goto end;
1636     }
1637
1638     if (!TEST_int_eq(create_ssl_connection(serverssl, clientssl,
1639                                            SSL_ERROR_NONE),
1640                 curr->connsuccess))
1641         goto end;
1642
1643     testresult = 1;
1644
1645  end:
1646     SSL_free(serverssl);
1647     SSL_free(clientssl);
1648     SSL_CTX_free(sctx);
1649     SSL_CTX_free(cctx);
1650
1651     return testresult;
1652 }
1653 #endif
1654
1655 #ifndef OPENSSL_NO_TLS1_3
1656
1657 static SSL_SESSION *clientpsk = NULL;
1658 static SSL_SESSION *serverpsk = NULL;
1659 static const char *pskid = "Identity";
1660 static const char *srvid;
1661
1662 static int use_session_cb_cnt = 0;
1663 static int find_session_cb_cnt = 0;
1664 static int psk_client_cb_cnt = 0;
1665 static int psk_server_cb_cnt = 0;
1666
1667 static int use_session_cb(SSL *ssl, const EVP_MD *md, const unsigned char **id,
1668                           size_t *idlen, SSL_SESSION **sess)
1669 {
1670     switch (++use_session_cb_cnt) {
1671     case 1:
1672         /* The first call should always have a NULL md */
1673         if (md != NULL)
1674             return 0;
1675         break;
1676
1677     case 2:
1678         /* The second call should always have an md */
1679         if (md == NULL)
1680             return 0;
1681         break;
1682
1683     default:
1684         /* We should only be called a maximum of twice */
1685         return 0;
1686     }
1687
1688     if (clientpsk != NULL)
1689         SSL_SESSION_up_ref(clientpsk);
1690
1691     *sess = clientpsk;
1692     *id = (const unsigned char *)pskid;
1693     *idlen = strlen(pskid);
1694
1695     return 1;
1696 }
1697
1698 #ifndef OPENSSL_NO_PSK
1699 static unsigned int psk_client_cb(SSL *ssl, const char *hint, char *id,
1700                                   unsigned int max_id_len,
1701                                   unsigned char *psk,
1702                                   unsigned int max_psk_len)
1703 {
1704     unsigned int psklen = 0;
1705
1706     psk_client_cb_cnt++;
1707
1708     if (strlen(pskid) + 1 > max_id_len)
1709         return 0;
1710
1711     /* We should only ever be called a maximum of twice per connection */
1712     if (psk_client_cb_cnt > 2)
1713         return 0;
1714
1715     if (clientpsk == NULL)
1716         return 0;
1717
1718     /* We'll reuse the PSK we set up for TLSv1.3 */
1719     if (SSL_SESSION_get_master_key(clientpsk, NULL, 0) > max_psk_len)
1720         return 0;
1721     psklen = SSL_SESSION_get_master_key(clientpsk, psk, max_psk_len);
1722     strncpy(id, pskid, max_id_len);
1723
1724     return psklen;
1725 }
1726 #endif /* OPENSSL_NO_PSK */
1727
1728 static int find_session_cb(SSL *ssl, const unsigned char *identity,
1729                            size_t identity_len, SSL_SESSION **sess)
1730 {
1731     find_session_cb_cnt++;
1732
1733     /* We should only ever be called a maximum of twice per connection */
1734     if (find_session_cb_cnt > 2)
1735         return 0;
1736
1737     if (serverpsk == NULL)
1738         return 0;
1739
1740     /* Identity should match that set by the client */
1741     if (strlen(srvid) != identity_len
1742             || strncmp(srvid, (const char *)identity, identity_len) != 0) {
1743         /* No PSK found, continue but without a PSK */
1744         *sess = NULL;
1745         return 1;
1746     }
1747
1748     SSL_SESSION_up_ref(serverpsk);
1749     *sess = serverpsk;
1750
1751     return 1;
1752 }
1753
1754 #ifndef OPENSSL_NO_PSK
1755 static unsigned int psk_server_cb(SSL *ssl, const char *identity,
1756                                   unsigned char *psk, unsigned int max_psk_len)
1757 {
1758     unsigned int psklen = 0;
1759
1760     psk_server_cb_cnt++;
1761
1762     /* We should only ever be called a maximum of twice per connection */
1763     if (find_session_cb_cnt > 2)
1764         return 0;
1765
1766     if (serverpsk == NULL)
1767         return 0;
1768
1769     /* Identity should match that set by the client */
1770     if (strcmp(srvid, identity) != 0) {
1771         return 0;
1772     }
1773
1774     /* We'll reuse the PSK we set up for TLSv1.3 */
1775     if (SSL_SESSION_get_master_key(serverpsk, NULL, 0) > max_psk_len)
1776         return 0;
1777     psklen = SSL_SESSION_get_master_key(serverpsk, psk, max_psk_len);
1778
1779     return psklen;
1780 }
1781 #endif /* OPENSSL_NO_PSK */
1782
1783 #define MSG1    "Hello"
1784 #define MSG2    "World."
1785 #define MSG3    "This"
1786 #define MSG4    "is"
1787 #define MSG5    "a"
1788 #define MSG6    "test"
1789 #define MSG7    "message."
1790
1791 #define TLS13_AES_256_GCM_SHA384_BYTES  ((const unsigned char *)"\x13\x02")
1792 #define TLS13_AES_128_GCM_SHA256_BYTES  ((const unsigned char *)"\x13\x01")
1793
1794 /*
1795  * Helper method to setup objects for early data test. Caller frees objects on
1796  * error.
1797  */
1798 static int setupearly_data_test(SSL_CTX **cctx, SSL_CTX **sctx, SSL **clientssl,
1799                                 SSL **serverssl, SSL_SESSION **sess, int idx)
1800 {
1801     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
1802                                        TLS1_VERSION, TLS_MAX_VERSION,
1803                                        sctx, cctx, cert, privkey))
1804         || !TEST_true(SSL_CTX_set_max_early_data(*sctx,
1805                                                  SSL3_RT_MAX_PLAIN_LENGTH)))
1806         return 0;
1807
1808     if (idx == 1) {
1809         /* When idx == 1 we repeat the tests with read_ahead set */
1810         SSL_CTX_set_read_ahead(*cctx, 1);
1811         SSL_CTX_set_read_ahead(*sctx, 1);
1812     } else if (idx == 2) {
1813         /* When idx == 2 we are doing early_data with a PSK. Set up callbacks */
1814         SSL_CTX_set_psk_use_session_callback(*cctx, use_session_cb);
1815         SSL_CTX_set_psk_find_session_callback(*sctx, find_session_cb);
1816         use_session_cb_cnt = 0;
1817         find_session_cb_cnt = 0;
1818         srvid = pskid;
1819     }
1820
1821     if (!TEST_true(create_ssl_objects(*sctx, *cctx, serverssl, clientssl,
1822                                       NULL, NULL)))
1823         return 0;
1824
1825     /*
1826      * For one of the run throughs (doesn't matter which one), we'll try sending
1827      * some SNI data in the initial ClientHello. This will be ignored (because
1828      * there is no SNI cb set up by the server), so it should not impact
1829      * early_data.
1830      */
1831     if (idx == 1
1832             && !TEST_true(SSL_set_tlsext_host_name(*clientssl, "localhost")))
1833         return 0;
1834
1835     if (idx == 2) {
1836         /* Create the PSK */
1837         const SSL_CIPHER *cipher = NULL;
1838         const unsigned char key[] = {
1839             0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
1840             0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
1841             0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
1842             0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b,
1843             0x2c, 0x2d, 0x2e, 0x2f
1844         };
1845
1846         cipher = SSL_CIPHER_find(*clientssl, TLS13_AES_256_GCM_SHA384_BYTES);
1847         clientpsk = SSL_SESSION_new();
1848         if (!TEST_ptr(clientpsk)
1849                 || !TEST_ptr(cipher)
1850                 || !TEST_true(SSL_SESSION_set1_master_key(clientpsk, key,
1851                                                           sizeof(key)))
1852                 || !TEST_true(SSL_SESSION_set_cipher(clientpsk, cipher))
1853                 || !TEST_true(
1854                         SSL_SESSION_set_protocol_version(clientpsk,
1855                                                          TLS1_3_VERSION))
1856                    /*
1857                     * We just choose an arbitrary value for max_early_data which
1858                     * should be big enough for testing purposes.
1859                     */
1860                 || !TEST_true(SSL_SESSION_set_max_early_data(clientpsk,
1861                                                              0x100))
1862                 || !TEST_true(SSL_SESSION_up_ref(clientpsk))) {
1863             SSL_SESSION_free(clientpsk);
1864             clientpsk = NULL;
1865             return 0;
1866         }
1867         serverpsk = clientpsk;
1868
1869         if (sess != NULL) {
1870             if (!TEST_true(SSL_SESSION_up_ref(clientpsk))) {
1871                 SSL_SESSION_free(clientpsk);
1872                 SSL_SESSION_free(serverpsk);
1873                 clientpsk = serverpsk = NULL;
1874                 return 0;
1875             }
1876             *sess = clientpsk;
1877         }
1878         return 1;
1879     }
1880
1881     if (sess == NULL)
1882         return 1;
1883
1884     if (!TEST_true(create_ssl_connection(*serverssl, *clientssl,
1885                                          SSL_ERROR_NONE)))
1886         return 0;
1887
1888     *sess = SSL_get1_session(*clientssl);
1889     SSL_shutdown(*clientssl);
1890     SSL_shutdown(*serverssl);
1891     SSL_free(*serverssl);
1892     SSL_free(*clientssl);
1893     *serverssl = *clientssl = NULL;
1894
1895     if (!TEST_true(create_ssl_objects(*sctx, *cctx, serverssl,
1896                                       clientssl, NULL, NULL))
1897             || !TEST_true(SSL_set_session(*clientssl, *sess)))
1898         return 0;
1899
1900     return 1;
1901 }
1902
1903 static int test_early_data_read_write(int idx)
1904 {
1905     SSL_CTX *cctx = NULL, *sctx = NULL;
1906     SSL *clientssl = NULL, *serverssl = NULL;
1907     int testresult = 0;
1908     SSL_SESSION *sess = NULL;
1909     unsigned char buf[20], data[1024];
1910     size_t readbytes, written, eoedlen, rawread, rawwritten;
1911     BIO *rbio;
1912
1913     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
1914                                         &serverssl, &sess, idx)))
1915         goto end;
1916
1917     /* Write and read some early data */
1918     if (!TEST_true(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
1919                                         &written))
1920             || !TEST_size_t_eq(written, strlen(MSG1))
1921             || !TEST_int_eq(SSL_read_early_data(serverssl, buf,
1922                                                 sizeof(buf), &readbytes),
1923                             SSL_READ_EARLY_DATA_SUCCESS)
1924             || !TEST_mem_eq(MSG1, readbytes, buf, strlen(MSG1))
1925             || !TEST_int_eq(SSL_get_early_data_status(serverssl),
1926                             SSL_EARLY_DATA_ACCEPTED))
1927         goto end;
1928
1929     /*
1930      * Server should be able to write data, and client should be able to
1931      * read it.
1932      */
1933     if (!TEST_true(SSL_write_early_data(serverssl, MSG2, strlen(MSG2),
1934                                         &written))
1935             || !TEST_size_t_eq(written, strlen(MSG2))
1936             || !TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
1937             || !TEST_mem_eq(buf, readbytes, MSG2, strlen(MSG2)))
1938         goto end;
1939
1940     /* Even after reading normal data, client should be able write early data */
1941     if (!TEST_true(SSL_write_early_data(clientssl, MSG3, strlen(MSG3),
1942                                         &written))
1943             || !TEST_size_t_eq(written, strlen(MSG3)))
1944         goto end;
1945
1946     /* Server should still be able read early data after writing data */
1947     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
1948                                          &readbytes),
1949                      SSL_READ_EARLY_DATA_SUCCESS)
1950             || !TEST_mem_eq(buf, readbytes, MSG3, strlen(MSG3)))
1951         goto end;
1952
1953     /* Write more data from server and read it from client */
1954     if (!TEST_true(SSL_write_early_data(serverssl, MSG4, strlen(MSG4),
1955                                         &written))
1956             || !TEST_size_t_eq(written, strlen(MSG4))
1957             || !TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
1958             || !TEST_mem_eq(buf, readbytes, MSG4, strlen(MSG4)))
1959         goto end;
1960
1961     /*
1962      * If client writes normal data it should mean writing early data is no
1963      * longer possible.
1964      */
1965     if (!TEST_true(SSL_write_ex(clientssl, MSG5, strlen(MSG5), &written))
1966             || !TEST_size_t_eq(written, strlen(MSG5))
1967             || !TEST_int_eq(SSL_get_early_data_status(clientssl),
1968                             SSL_EARLY_DATA_ACCEPTED))
1969         goto end;
1970
1971     /*
1972      * At this point the client has written EndOfEarlyData, ClientFinished and
1973      * normal (fully protected) data. We are going to cause a delay between the
1974      * arrival of EndOfEarlyData and ClientFinished. We read out all the data
1975      * in the read BIO, and then just put back the EndOfEarlyData message.
1976      */
1977     rbio = SSL_get_rbio(serverssl);
1978     if (!TEST_true(BIO_read_ex(rbio, data, sizeof(data), &rawread))
1979             || !TEST_size_t_lt(rawread, sizeof(data))
1980             || !TEST_size_t_gt(rawread, SSL3_RT_HEADER_LENGTH))
1981         goto end;
1982
1983     /* Record length is in the 4th and 5th bytes of the record header */
1984     eoedlen = SSL3_RT_HEADER_LENGTH + (data[3] << 8 | data[4]);
1985     if (!TEST_true(BIO_write_ex(rbio, data, eoedlen, &rawwritten))
1986             || !TEST_size_t_eq(rawwritten, eoedlen))
1987         goto end;
1988
1989     /* Server should be told that there is no more early data */
1990     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
1991                                          &readbytes),
1992                      SSL_READ_EARLY_DATA_FINISH)
1993             || !TEST_size_t_eq(readbytes, 0))
1994         goto end;
1995
1996     /*
1997      * Server has not finished init yet, so should still be able to write early
1998      * data.
1999      */
2000     if (!TEST_true(SSL_write_early_data(serverssl, MSG6, strlen(MSG6),
2001                                         &written))
2002             || !TEST_size_t_eq(written, strlen(MSG6)))
2003         goto end;
2004
2005     /* Push the ClientFinished and the normal data back into the server rbio */
2006     if (!TEST_true(BIO_write_ex(rbio, data + eoedlen, rawread - eoedlen,
2007                                 &rawwritten))
2008             || !TEST_size_t_eq(rawwritten, rawread - eoedlen))
2009         goto end;
2010
2011     /* Server should be able to read normal data */
2012     if (!TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
2013             || !TEST_size_t_eq(readbytes, strlen(MSG5)))
2014         goto end;
2015
2016     /* Client and server should not be able to write/read early data now */
2017     if (!TEST_false(SSL_write_early_data(clientssl, MSG6, strlen(MSG6),
2018                                          &written)))
2019         goto end;
2020     ERR_clear_error();
2021     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2022                                          &readbytes),
2023                      SSL_READ_EARLY_DATA_ERROR))
2024         goto end;
2025     ERR_clear_error();
2026
2027     /* Client should be able to read the data sent by the server */
2028     if (!TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
2029             || !TEST_mem_eq(buf, readbytes, MSG6, strlen(MSG6)))
2030         goto end;
2031
2032     /*
2033      * Make sure we process the two NewSessionTickets. These arrive
2034      * post-handshake. We attempt reads which we do not expect to return any
2035      * data.
2036      */
2037     if (!TEST_false(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
2038             || !TEST_false(SSL_read_ex(clientssl, buf, sizeof(buf),
2039                            &readbytes)))
2040         goto end;
2041
2042     /* Server should be able to write normal data */
2043     if (!TEST_true(SSL_write_ex(serverssl, MSG7, strlen(MSG7), &written))
2044             || !TEST_size_t_eq(written, strlen(MSG7))
2045             || !TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
2046             || !TEST_mem_eq(buf, readbytes, MSG7, strlen(MSG7)))
2047         goto end;
2048
2049     SSL_SESSION_free(sess);
2050     sess = SSL_get1_session(clientssl);
2051     use_session_cb_cnt = 0;
2052     find_session_cb_cnt = 0;
2053
2054     SSL_shutdown(clientssl);
2055     SSL_shutdown(serverssl);
2056     SSL_free(serverssl);
2057     SSL_free(clientssl);
2058     serverssl = clientssl = NULL;
2059     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
2060                                       &clientssl, NULL, NULL))
2061             || !TEST_true(SSL_set_session(clientssl, sess)))
2062         goto end;
2063
2064     /* Write and read some early data */
2065     if (!TEST_true(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
2066                                         &written))
2067             || !TEST_size_t_eq(written, strlen(MSG1))
2068             || !TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2069                                                 &readbytes),
2070                             SSL_READ_EARLY_DATA_SUCCESS)
2071             || !TEST_mem_eq(buf, readbytes, MSG1, strlen(MSG1)))
2072         goto end;
2073
2074     if (!TEST_int_gt(SSL_connect(clientssl), 0)
2075             || !TEST_int_gt(SSL_accept(serverssl), 0))
2076         goto end;
2077
2078     /* Client and server should not be able to write/read early data now */
2079     if (!TEST_false(SSL_write_early_data(clientssl, MSG6, strlen(MSG6),
2080                                          &written)))
2081         goto end;
2082     ERR_clear_error();
2083     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2084                                          &readbytes),
2085                      SSL_READ_EARLY_DATA_ERROR))
2086         goto end;
2087     ERR_clear_error();
2088
2089     /* Client and server should be able to write/read normal data */
2090     if (!TEST_true(SSL_write_ex(clientssl, MSG5, strlen(MSG5), &written))
2091             || !TEST_size_t_eq(written, strlen(MSG5))
2092             || !TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
2093             || !TEST_size_t_eq(readbytes, strlen(MSG5)))
2094         goto end;
2095
2096     testresult = 1;
2097
2098  end:
2099     SSL_SESSION_free(sess);
2100     SSL_SESSION_free(clientpsk);
2101     SSL_SESSION_free(serverpsk);
2102     clientpsk = serverpsk = NULL;
2103     SSL_free(serverssl);
2104     SSL_free(clientssl);
2105     SSL_CTX_free(sctx);
2106     SSL_CTX_free(cctx);
2107     return testresult;
2108 }
2109
2110 static int test_early_data_replay(int idx)
2111 {
2112     SSL_CTX *cctx = NULL, *sctx = NULL;
2113     SSL *clientssl = NULL, *serverssl = NULL;
2114     int testresult = 0;
2115     SSL_SESSION *sess = NULL;
2116
2117     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
2118                                         &serverssl, &sess, idx)))
2119         goto end;
2120
2121     /*
2122      * The server is configured to accept early data. Create a connection to
2123      * "use up" the ticket
2124      */
2125     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE))
2126             || !TEST_true(SSL_session_reused(clientssl)))
2127         goto end;
2128
2129     SSL_shutdown(clientssl);
2130     SSL_shutdown(serverssl);
2131     SSL_free(serverssl);
2132     SSL_free(clientssl);
2133     serverssl = clientssl = NULL;
2134
2135     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
2136                                       &clientssl, NULL, NULL))
2137             || !TEST_true(SSL_set_session(clientssl, sess))
2138             || !TEST_true(create_ssl_connection(serverssl, clientssl,
2139                           SSL_ERROR_NONE))
2140                /*
2141                 * This time we should not have resumed the session because we
2142                 * already used it once.
2143                 */
2144             || !TEST_false(SSL_session_reused(clientssl)))
2145         goto end;
2146
2147     testresult = 1;
2148
2149  end:
2150     SSL_SESSION_free(sess);
2151     SSL_SESSION_free(clientpsk);
2152     SSL_SESSION_free(serverpsk);
2153     clientpsk = serverpsk = NULL;
2154     SSL_free(serverssl);
2155     SSL_free(clientssl);
2156     SSL_CTX_free(sctx);
2157     SSL_CTX_free(cctx);
2158     return testresult;
2159 }
2160
2161 /*
2162  * Helper function to test that a server attempting to read early data can
2163  * handle a connection from a client where the early data should be skipped.
2164  */
2165 static int early_data_skip_helper(int hrr, int idx)
2166 {
2167     SSL_CTX *cctx = NULL, *sctx = NULL;
2168     SSL *clientssl = NULL, *serverssl = NULL;
2169     int testresult = 0;
2170     SSL_SESSION *sess = NULL;
2171     unsigned char buf[20];
2172     size_t readbytes, written;
2173
2174     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
2175                                         &serverssl, &sess, idx)))
2176         goto end;
2177
2178     if (hrr) {
2179         /* Force an HRR to occur */
2180         if (!TEST_true(SSL_set1_groups_list(serverssl, "P-256")))
2181             goto end;
2182     } else if (idx == 2) {
2183         /*
2184          * We force early_data rejection by ensuring the PSK identity is
2185          * unrecognised
2186          */
2187         srvid = "Dummy Identity";
2188     } else {
2189         /*
2190          * Deliberately corrupt the creation time. We take 20 seconds off the
2191          * time. It could be any value as long as it is not within tolerance.
2192          * This should mean the ticket is rejected.
2193          */
2194         if (!TEST_true(SSL_SESSION_set_time(sess, (long)(time(NULL) - 20))))
2195             goto end;
2196     }
2197
2198     /* Write some early data */
2199     if (!TEST_true(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
2200                                         &written))
2201             || !TEST_size_t_eq(written, strlen(MSG1)))
2202         goto end;
2203
2204     /* Server should reject the early data and skip over it */
2205     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2206                                          &readbytes),
2207                      SSL_READ_EARLY_DATA_FINISH)
2208             || !TEST_size_t_eq(readbytes, 0)
2209             || !TEST_int_eq(SSL_get_early_data_status(serverssl),
2210                             SSL_EARLY_DATA_REJECTED))
2211         goto end;
2212
2213     if (hrr) {
2214         /*
2215          * Finish off the handshake. We perform the same writes and reads as
2216          * further down but we expect them to fail due to the incomplete
2217          * handshake.
2218          */
2219         if (!TEST_false(SSL_write_ex(clientssl, MSG2, strlen(MSG2), &written))
2220                 || !TEST_false(SSL_read_ex(serverssl, buf, sizeof(buf),
2221                                &readbytes)))
2222             goto end;
2223     }
2224
2225     /* Should be able to send normal data despite rejection of early data */
2226     if (!TEST_true(SSL_write_ex(clientssl, MSG2, strlen(MSG2), &written))
2227             || !TEST_size_t_eq(written, strlen(MSG2))
2228             || !TEST_int_eq(SSL_get_early_data_status(clientssl),
2229                             SSL_EARLY_DATA_REJECTED)
2230             || !TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
2231             || !TEST_mem_eq(buf, readbytes, MSG2, strlen(MSG2)))
2232         goto end;
2233
2234     testresult = 1;
2235
2236  end:
2237     SSL_SESSION_free(clientpsk);
2238     SSL_SESSION_free(serverpsk);
2239     clientpsk = serverpsk = NULL;
2240     SSL_SESSION_free(sess);
2241     SSL_free(serverssl);
2242     SSL_free(clientssl);
2243     SSL_CTX_free(sctx);
2244     SSL_CTX_free(cctx);
2245     return testresult;
2246 }
2247
2248 /*
2249  * Test that a server attempting to read early data can handle a connection
2250  * from a client where the early data is not acceptable.
2251  */
2252 static int test_early_data_skip(int idx)
2253 {
2254     return early_data_skip_helper(0, idx);
2255 }
2256
2257 /*
2258  * Test that a server attempting to read early data can handle a connection
2259  * from a client where an HRR occurs.
2260  */
2261 static int test_early_data_skip_hrr(int idx)
2262 {
2263     return early_data_skip_helper(1, idx);
2264 }
2265
2266 /*
2267  * Test that a server attempting to read early data can handle a connection
2268  * from a client that doesn't send any.
2269  */
2270 static int test_early_data_not_sent(int idx)
2271 {
2272     SSL_CTX *cctx = NULL, *sctx = NULL;
2273     SSL *clientssl = NULL, *serverssl = NULL;
2274     int testresult = 0;
2275     SSL_SESSION *sess = NULL;
2276     unsigned char buf[20];
2277     size_t readbytes, written;
2278
2279     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
2280                                         &serverssl, &sess, idx)))
2281         goto end;
2282
2283     /* Write some data - should block due to handshake with server */
2284     SSL_set_connect_state(clientssl);
2285     if (!TEST_false(SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written)))
2286         goto end;
2287
2288     /* Server should detect that early data has not been sent */
2289     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2290                                          &readbytes),
2291                      SSL_READ_EARLY_DATA_FINISH)
2292             || !TEST_size_t_eq(readbytes, 0)
2293             || !TEST_int_eq(SSL_get_early_data_status(serverssl),
2294                             SSL_EARLY_DATA_NOT_SENT)
2295             || !TEST_int_eq(SSL_get_early_data_status(clientssl),
2296                             SSL_EARLY_DATA_NOT_SENT))
2297         goto end;
2298
2299     /* Continue writing the message we started earlier */
2300     if (!TEST_true(SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written))
2301             || !TEST_size_t_eq(written, strlen(MSG1))
2302             || !TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
2303             || !TEST_mem_eq(buf, readbytes, MSG1, strlen(MSG1))
2304             || !SSL_write_ex(serverssl, MSG2, strlen(MSG2), &written)
2305             || !TEST_size_t_eq(written, strlen(MSG2)))
2306         goto end;
2307
2308     /*
2309      * Should block due to the NewSessionTicket arrival unless we're using
2310      * read_ahead, or PSKs
2311      */
2312     if (idx != 1 && idx != 2) {
2313         if (!TEST_false(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes)))
2314             goto end;
2315     }
2316
2317     if (!TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
2318             || !TEST_mem_eq(buf, readbytes, MSG2, strlen(MSG2)))
2319         goto end;
2320
2321     testresult = 1;
2322
2323  end:
2324     SSL_SESSION_free(sess);
2325     SSL_SESSION_free(clientpsk);
2326     SSL_SESSION_free(serverpsk);
2327     clientpsk = serverpsk = NULL;
2328     SSL_free(serverssl);
2329     SSL_free(clientssl);
2330     SSL_CTX_free(sctx);
2331     SSL_CTX_free(cctx);
2332     return testresult;
2333 }
2334
2335 static int hostname_cb(SSL *s, int *al, void *arg)
2336 {
2337     const char *hostname = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
2338
2339     if (hostname != NULL && strcmp(hostname, "goodhost") == 0)
2340         return  SSL_TLSEXT_ERR_OK;
2341
2342     return SSL_TLSEXT_ERR_NOACK;
2343 }
2344
2345 static const char *servalpn;
2346
2347 static int alpn_select_cb(SSL *ssl, const unsigned char **out,
2348                           unsigned char *outlen, const unsigned char *in,
2349                           unsigned int inlen, void *arg)
2350 {
2351     unsigned int protlen = 0;
2352     const unsigned char *prot;
2353
2354     for (prot = in; prot < in + inlen; prot += protlen) {
2355         protlen = *prot++;
2356         if (in + inlen < prot + protlen)
2357             return SSL_TLSEXT_ERR_NOACK;
2358
2359         if (protlen == strlen(servalpn)
2360                 && memcmp(prot, servalpn, protlen) == 0) {
2361             *out = prot;
2362             *outlen = protlen;
2363             return SSL_TLSEXT_ERR_OK;
2364         }
2365     }
2366
2367     return SSL_TLSEXT_ERR_NOACK;
2368 }
2369
2370 /* Test that a PSK can be used to send early_data */
2371 static int test_early_data_psk(int idx)
2372 {
2373     SSL_CTX *cctx = NULL, *sctx = NULL;
2374     SSL *clientssl = NULL, *serverssl = NULL;
2375     int testresult = 0;
2376     SSL_SESSION *sess = NULL;
2377     unsigned char alpnlist[] = {
2378         0x08, 'g', 'o', 'o', 'd', 'a', 'l', 'p', 'n', 0x07, 'b', 'a', 'd', 'a',
2379         'l', 'p', 'n'
2380     };
2381 #define GOODALPNLEN     9
2382 #define BADALPNLEN      8
2383 #define GOODALPN        (alpnlist)
2384 #define BADALPN         (alpnlist + GOODALPNLEN)
2385     int err = 0;
2386     unsigned char buf[20];
2387     size_t readbytes, written;
2388     int readearlyres = SSL_READ_EARLY_DATA_SUCCESS, connectres = 1;
2389     int edstatus = SSL_EARLY_DATA_ACCEPTED;
2390
2391     /* We always set this up with a final parameter of "2" for PSK */
2392     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
2393                                         &serverssl, &sess, 2)))
2394         goto end;
2395
2396     servalpn = "goodalpn";
2397
2398     /*
2399      * Note: There is no test for inconsistent SNI with late client detection.
2400      * This is because servers do not acknowledge SNI even if they are using
2401      * it in a resumption handshake - so it is not actually possible for a
2402      * client to detect a problem.
2403      */
2404     switch (idx) {
2405     case 0:
2406         /* Set inconsistent SNI (early client detection) */
2407         err = SSL_R_INCONSISTENT_EARLY_DATA_SNI;
2408         if (!TEST_true(SSL_SESSION_set1_hostname(sess, "goodhost"))
2409                 || !TEST_true(SSL_set_tlsext_host_name(clientssl, "badhost")))
2410             goto end;
2411         break;
2412
2413     case 1:
2414         /* Set inconsistent ALPN (early client detection) */
2415         err = SSL_R_INCONSISTENT_EARLY_DATA_ALPN;
2416         /* SSL_set_alpn_protos returns 0 for success and 1 for failure */
2417         if (!TEST_true(SSL_SESSION_set1_alpn_selected(sess, GOODALPN,
2418                                                       GOODALPNLEN))
2419                 || !TEST_false(SSL_set_alpn_protos(clientssl, BADALPN,
2420                                                    BADALPNLEN)))
2421             goto end;
2422         break;
2423
2424     case 2:
2425         /*
2426          * Set invalid protocol version. Technically this affects PSKs without
2427          * early_data too, but we test it here because it is similar to the
2428          * SNI/ALPN consistency tests.
2429          */
2430         err = SSL_R_BAD_PSK;
2431         if (!TEST_true(SSL_SESSION_set_protocol_version(sess, TLS1_2_VERSION)))
2432             goto end;
2433         break;
2434
2435     case 3:
2436         /*
2437          * Set inconsistent SNI (server detected). In this case the connection
2438          * will succeed but reject early_data.
2439          */
2440         SSL_SESSION_free(serverpsk);
2441         serverpsk = SSL_SESSION_dup(clientpsk);
2442         if (!TEST_ptr(serverpsk)
2443                 || !TEST_true(SSL_SESSION_set1_hostname(serverpsk, "badhost")))
2444             goto end;
2445         edstatus = SSL_EARLY_DATA_REJECTED;
2446         readearlyres = SSL_READ_EARLY_DATA_FINISH;
2447         /* Fall through */
2448     case 4:
2449         /* Set consistent SNI */
2450         if (!TEST_true(SSL_SESSION_set1_hostname(sess, "goodhost"))
2451                 || !TEST_true(SSL_set_tlsext_host_name(clientssl, "goodhost"))
2452                 || !TEST_true(SSL_CTX_set_tlsext_servername_callback(sctx,
2453                                 hostname_cb)))
2454             goto end;
2455         break;
2456
2457     case 5:
2458         /*
2459          * Set inconsistent ALPN (server detected). In this case the connection
2460          * will succeed but reject early_data.
2461          */
2462         servalpn = "badalpn";
2463         edstatus = SSL_EARLY_DATA_REJECTED;
2464         readearlyres = SSL_READ_EARLY_DATA_FINISH;
2465         /* Fall through */
2466     case 6:
2467         /*
2468          * Set consistent ALPN.
2469          * SSL_set_alpn_protos returns 0 for success and 1 for failure. It
2470          * accepts a list of protos (each one length prefixed).
2471          * SSL_set1_alpn_selected accepts a single protocol (not length
2472          * prefixed)
2473          */
2474         if (!TEST_true(SSL_SESSION_set1_alpn_selected(sess, GOODALPN + 1,
2475                                                       GOODALPNLEN - 1))
2476                 || !TEST_false(SSL_set_alpn_protos(clientssl, GOODALPN,
2477                                                    GOODALPNLEN)))
2478             goto end;
2479
2480         SSL_CTX_set_alpn_select_cb(sctx, alpn_select_cb, NULL);
2481         break;
2482
2483     case 7:
2484         /* Set inconsistent ALPN (late client detection) */
2485         SSL_SESSION_free(serverpsk);
2486         serverpsk = SSL_SESSION_dup(clientpsk);
2487         if (!TEST_ptr(serverpsk)
2488                 || !TEST_true(SSL_SESSION_set1_alpn_selected(clientpsk,
2489                                                              BADALPN + 1,
2490                                                              BADALPNLEN - 1))
2491                 || !TEST_true(SSL_SESSION_set1_alpn_selected(serverpsk,
2492                                                              GOODALPN + 1,
2493                                                              GOODALPNLEN - 1))
2494                 || !TEST_false(SSL_set_alpn_protos(clientssl, alpnlist,
2495                                                    sizeof(alpnlist))))
2496             goto end;
2497         SSL_CTX_set_alpn_select_cb(sctx, alpn_select_cb, NULL);
2498         edstatus = SSL_EARLY_DATA_ACCEPTED;
2499         readearlyres = SSL_READ_EARLY_DATA_SUCCESS;
2500         /* SSL_connect() call should fail */
2501         connectres = -1;
2502         break;
2503
2504     default:
2505         TEST_error("Bad test index");
2506         goto end;
2507     }
2508
2509     SSL_set_connect_state(clientssl);
2510     if (err != 0) {
2511         if (!TEST_false(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
2512                                             &written))
2513                 || !TEST_int_eq(SSL_get_error(clientssl, 0), SSL_ERROR_SSL)
2514                 || !TEST_int_eq(ERR_GET_REASON(ERR_get_error()), err))
2515             goto end;
2516     } else {
2517         if (!TEST_true(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
2518                                             &written)))
2519             goto end;
2520
2521         if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2522                                              &readbytes), readearlyres)
2523                 || (readearlyres == SSL_READ_EARLY_DATA_SUCCESS
2524                     && !TEST_mem_eq(buf, readbytes, MSG1, strlen(MSG1)))
2525                 || !TEST_int_eq(SSL_get_early_data_status(serverssl), edstatus)
2526                 || !TEST_int_eq(SSL_connect(clientssl), connectres))
2527             goto end;
2528     }
2529
2530     testresult = 1;
2531
2532  end:
2533     SSL_SESSION_free(sess);
2534     SSL_SESSION_free(clientpsk);
2535     SSL_SESSION_free(serverpsk);
2536     clientpsk = serverpsk = NULL;
2537     SSL_free(serverssl);
2538     SSL_free(clientssl);
2539     SSL_CTX_free(sctx);
2540     SSL_CTX_free(cctx);
2541     return testresult;
2542 }
2543
2544 /*
2545  * Test that a server that doesn't try to read early data can handle a
2546  * client sending some.
2547  */
2548 static int test_early_data_not_expected(int idx)
2549 {
2550     SSL_CTX *cctx = NULL, *sctx = NULL;
2551     SSL *clientssl = NULL, *serverssl = NULL;
2552     int testresult = 0;
2553     SSL_SESSION *sess = NULL;
2554     unsigned char buf[20];
2555     size_t readbytes, written;
2556
2557     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
2558                                         &serverssl, &sess, idx)))
2559         goto end;
2560
2561     /* Write some early data */
2562     if (!TEST_true(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
2563                                         &written)))
2564         goto end;
2565
2566     /*
2567      * Server should skip over early data and then block waiting for client to
2568      * continue handshake
2569      */
2570     if (!TEST_int_le(SSL_accept(serverssl), 0)
2571      || !TEST_int_gt(SSL_connect(clientssl), 0)
2572      || !TEST_int_eq(SSL_get_early_data_status(serverssl),
2573                      SSL_EARLY_DATA_REJECTED)
2574      || !TEST_int_gt(SSL_accept(serverssl), 0)
2575      || !TEST_int_eq(SSL_get_early_data_status(clientssl),
2576                      SSL_EARLY_DATA_REJECTED))
2577         goto end;
2578
2579     /* Send some normal data from client to server */
2580     if (!TEST_true(SSL_write_ex(clientssl, MSG2, strlen(MSG2), &written))
2581             || !TEST_size_t_eq(written, strlen(MSG2)))
2582         goto end;
2583
2584     if (!TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
2585             || !TEST_mem_eq(buf, readbytes, MSG2, strlen(MSG2)))
2586         goto end;
2587
2588     testresult = 1;
2589
2590  end:
2591     SSL_SESSION_free(sess);
2592     SSL_SESSION_free(clientpsk);
2593     SSL_SESSION_free(serverpsk);
2594     clientpsk = serverpsk = NULL;
2595     SSL_free(serverssl);
2596     SSL_free(clientssl);
2597     SSL_CTX_free(sctx);
2598     SSL_CTX_free(cctx);
2599     return testresult;
2600 }
2601
2602
2603 # ifndef OPENSSL_NO_TLS1_2
2604 /*
2605  * Test that a server attempting to read early data can handle a connection
2606  * from a TLSv1.2 client.
2607  */
2608 static int test_early_data_tls1_2(int idx)
2609 {
2610     SSL_CTX *cctx = NULL, *sctx = NULL;
2611     SSL *clientssl = NULL, *serverssl = NULL;
2612     int testresult = 0;
2613     unsigned char buf[20];
2614     size_t readbytes, written;
2615
2616     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
2617                                         &serverssl, NULL, idx)))
2618         goto end;
2619
2620     /* Write some data - should block due to handshake with server */
2621     SSL_set_max_proto_version(clientssl, TLS1_2_VERSION);
2622     SSL_set_connect_state(clientssl);
2623     if (!TEST_false(SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written)))
2624         goto end;
2625
2626     /*
2627      * Server should do TLSv1.2 handshake. First it will block waiting for more
2628      * messages from client after ServerDone. Then SSL_read_early_data should
2629      * finish and detect that early data has not been sent
2630      */
2631     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2632                                          &readbytes),
2633                      SSL_READ_EARLY_DATA_ERROR))
2634         goto end;
2635
2636     /*
2637      * Continue writing the message we started earlier. Will still block waiting
2638      * for the CCS/Finished from server
2639      */
2640     if (!TEST_false(SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written))
2641             || !TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2642                                                 &readbytes),
2643                             SSL_READ_EARLY_DATA_FINISH)
2644             || !TEST_size_t_eq(readbytes, 0)
2645             || !TEST_int_eq(SSL_get_early_data_status(serverssl),
2646                             SSL_EARLY_DATA_NOT_SENT))
2647         goto end;
2648
2649     /* Continue writing the message we started earlier */
2650     if (!TEST_true(SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written))
2651             || !TEST_size_t_eq(written, strlen(MSG1))
2652             || !TEST_int_eq(SSL_get_early_data_status(clientssl),
2653                             SSL_EARLY_DATA_NOT_SENT)
2654             || !TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
2655             || !TEST_mem_eq(buf, readbytes, MSG1, strlen(MSG1))
2656             || !TEST_true(SSL_write_ex(serverssl, MSG2, strlen(MSG2), &written))
2657             || !TEST_size_t_eq(written, strlen(MSG2))
2658             || !SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes)
2659             || !TEST_mem_eq(buf, readbytes, MSG2, strlen(MSG2)))
2660         goto end;
2661
2662     testresult = 1;
2663
2664  end:
2665     SSL_SESSION_free(clientpsk);
2666     SSL_SESSION_free(serverpsk);
2667     clientpsk = serverpsk = NULL;
2668     SSL_free(serverssl);
2669     SSL_free(clientssl);
2670     SSL_CTX_free(sctx);
2671     SSL_CTX_free(cctx);
2672
2673     return testresult;
2674 }
2675 # endif /* OPENSSL_NO_TLS1_2 */
2676
2677 /*
2678  * Test configuring the TLSv1.3 ciphersuites
2679  *
2680  * Test 0: Set a default ciphersuite in the SSL_CTX (no explicit cipher_list)
2681  * Test 1: Set a non-default ciphersuite in the SSL_CTX (no explicit cipher_list)
2682  * Test 2: Set a default ciphersuite in the SSL (no explicit cipher_list)
2683  * Test 3: Set a non-default ciphersuite in the SSL (no explicit cipher_list)
2684  * Test 4: Set a default ciphersuite in the SSL_CTX (SSL_CTX cipher_list)
2685  * Test 5: Set a non-default ciphersuite in the SSL_CTX (SSL_CTX cipher_list)
2686  * Test 6: Set a default ciphersuite in the SSL (SSL_CTX cipher_list)
2687  * Test 7: Set a non-default ciphersuite in the SSL (SSL_CTX cipher_list)
2688  * Test 8: Set a default ciphersuite in the SSL (SSL cipher_list)
2689  * Test 9: Set a non-default ciphersuite in the SSL (SSL cipher_list)
2690  */
2691 static int test_set_ciphersuite(int idx)
2692 {
2693     SSL_CTX *cctx = NULL, *sctx = NULL;
2694     SSL *clientssl = NULL, *serverssl = NULL;
2695     int testresult = 0;
2696
2697     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
2698                                        TLS1_VERSION, TLS_MAX_VERSION,
2699                                        &sctx, &cctx, cert, privkey))
2700             || !TEST_true(SSL_CTX_set_ciphersuites(sctx,
2701                            "TLS_AES_128_GCM_SHA256:TLS_AES_128_CCM_SHA256")))
2702         goto end;
2703
2704     if (idx >=4 && idx <= 7) {
2705         /* SSL_CTX explicit cipher list */
2706         if (!TEST_true(SSL_CTX_set_cipher_list(cctx, "AES256-GCM-SHA384")))
2707             goto end;
2708     }
2709
2710     if (idx == 0 || idx == 4) {
2711         /* Default ciphersuite */
2712         if (!TEST_true(SSL_CTX_set_ciphersuites(cctx,
2713                                                 "TLS_AES_128_GCM_SHA256")))
2714             goto end;
2715     } else if (idx == 1 || idx == 5) {
2716         /* Non default ciphersuite */
2717         if (!TEST_true(SSL_CTX_set_ciphersuites(cctx,
2718                                                 "TLS_AES_128_CCM_SHA256")))
2719             goto end;
2720     }
2721
2722     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
2723                                           &clientssl, NULL, NULL)))
2724         goto end;
2725
2726     if (idx == 8 || idx == 9) {
2727         /* SSL explicit cipher list */
2728         if (!TEST_true(SSL_set_cipher_list(clientssl, "AES256-GCM-SHA384")))
2729             goto end;
2730     }
2731
2732     if (idx == 2 || idx == 6 || idx == 8) {
2733         /* Default ciphersuite */
2734         if (!TEST_true(SSL_set_ciphersuites(clientssl,
2735                                             "TLS_AES_128_GCM_SHA256")))
2736             goto end;
2737     } else if (idx == 3 || idx == 7 || idx == 9) {
2738         /* Non default ciphersuite */
2739         if (!TEST_true(SSL_set_ciphersuites(clientssl,
2740                                             "TLS_AES_128_CCM_SHA256")))
2741             goto end;
2742     }
2743
2744     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
2745         goto end;
2746
2747     testresult = 1;
2748
2749  end:
2750     SSL_free(serverssl);
2751     SSL_free(clientssl);
2752     SSL_CTX_free(sctx);
2753     SSL_CTX_free(cctx);
2754
2755     return testresult;
2756 }
2757
2758 static int test_ciphersuite_change(void)
2759 {
2760     SSL_CTX *cctx = NULL, *sctx = NULL;
2761     SSL *clientssl = NULL, *serverssl = NULL;
2762     SSL_SESSION *clntsess = NULL;
2763     int testresult = 0;
2764     const SSL_CIPHER *aes_128_gcm_sha256 = NULL;
2765
2766     /* Create a session based on SHA-256 */
2767     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
2768                                        TLS1_VERSION, TLS_MAX_VERSION,
2769                                        &sctx, &cctx, cert, privkey))
2770             || !TEST_true(SSL_CTX_set_ciphersuites(cctx,
2771                                                    "TLS_AES_128_GCM_SHA256"))
2772             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
2773                                           &clientssl, NULL, NULL))
2774             || !TEST_true(create_ssl_connection(serverssl, clientssl,
2775                                                 SSL_ERROR_NONE)))
2776         goto end;
2777
2778     clntsess = SSL_get1_session(clientssl);
2779     /* Save for later */
2780     aes_128_gcm_sha256 = SSL_SESSION_get0_cipher(clntsess);
2781     SSL_shutdown(clientssl);
2782     SSL_shutdown(serverssl);
2783     SSL_free(serverssl);
2784     SSL_free(clientssl);
2785     serverssl = clientssl = NULL;
2786
2787 # if !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305)
2788     /* Check we can resume a session with a different SHA-256 ciphersuite */
2789     if (!TEST_true(SSL_CTX_set_ciphersuites(cctx,
2790                                             "TLS_CHACHA20_POLY1305_SHA256"))
2791             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
2792                                              NULL, NULL))
2793             || !TEST_true(SSL_set_session(clientssl, clntsess))
2794             || !TEST_true(create_ssl_connection(serverssl, clientssl,
2795                                                 SSL_ERROR_NONE))
2796             || !TEST_true(SSL_session_reused(clientssl)))
2797         goto end;
2798
2799     SSL_SESSION_free(clntsess);
2800     clntsess = SSL_get1_session(clientssl);
2801     SSL_shutdown(clientssl);
2802     SSL_shutdown(serverssl);
2803     SSL_free(serverssl);
2804     SSL_free(clientssl);
2805     serverssl = clientssl = NULL;
2806 # endif
2807
2808     /*
2809      * Check attempting to resume a SHA-256 session with no SHA-256 ciphersuites
2810      * succeeds but does not resume.
2811      */
2812     if (!TEST_true(SSL_CTX_set_ciphersuites(cctx, "TLS_AES_256_GCM_SHA384"))
2813             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
2814                                              NULL, NULL))
2815             || !TEST_true(SSL_set_session(clientssl, clntsess))
2816             || !TEST_true(create_ssl_connection(serverssl, clientssl,
2817                                                 SSL_ERROR_SSL))
2818             || !TEST_false(SSL_session_reused(clientssl)))
2819         goto end;
2820
2821     SSL_SESSION_free(clntsess);
2822     clntsess = NULL;
2823     SSL_shutdown(clientssl);
2824     SSL_shutdown(serverssl);
2825     SSL_free(serverssl);
2826     SSL_free(clientssl);
2827     serverssl = clientssl = NULL;
2828
2829     /* Create a session based on SHA384 */
2830     if (!TEST_true(SSL_CTX_set_ciphersuites(cctx, "TLS_AES_256_GCM_SHA384"))
2831             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
2832                                           &clientssl, NULL, NULL))
2833             || !TEST_true(create_ssl_connection(serverssl, clientssl,
2834                                                 SSL_ERROR_NONE)))
2835         goto end;
2836
2837     clntsess = SSL_get1_session(clientssl);
2838     SSL_shutdown(clientssl);
2839     SSL_shutdown(serverssl);
2840     SSL_free(serverssl);
2841     SSL_free(clientssl);
2842     serverssl = clientssl = NULL;
2843
2844     if (!TEST_true(SSL_CTX_set_ciphersuites(cctx,
2845                    "TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384"))
2846             || !TEST_true(SSL_CTX_set_ciphersuites(sctx,
2847                                                    "TLS_AES_256_GCM_SHA384"))
2848             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
2849                                              NULL, NULL))
2850             || !TEST_true(SSL_set_session(clientssl, clntsess))
2851                /*
2852                 * We use SSL_ERROR_WANT_READ below so that we can pause the
2853                 * connection after the initial ClientHello has been sent to
2854                 * enable us to make some session changes.
2855                 */
2856             || !TEST_false(create_ssl_connection(serverssl, clientssl,
2857                                                 SSL_ERROR_WANT_READ)))
2858         goto end;
2859
2860     /* Trick the client into thinking this session is for a different digest */
2861     clntsess->cipher = aes_128_gcm_sha256;
2862     clntsess->cipher_id = clntsess->cipher->id;
2863
2864     /*
2865      * Continue the previously started connection. Server has selected a SHA-384
2866      * ciphersuite, but client thinks the session is for SHA-256, so it should
2867      * bail out.
2868      */
2869     if (!TEST_false(create_ssl_connection(serverssl, clientssl,
2870                                                 SSL_ERROR_SSL))
2871             || !TEST_int_eq(ERR_GET_REASON(ERR_get_error()),
2872                             SSL_R_CIPHERSUITE_DIGEST_HAS_CHANGED))
2873         goto end;
2874
2875     testresult = 1;
2876
2877  end:
2878     SSL_SESSION_free(clntsess);
2879     SSL_free(serverssl);
2880     SSL_free(clientssl);
2881     SSL_CTX_free(sctx);
2882     SSL_CTX_free(cctx);
2883
2884     return testresult;
2885 }
2886
2887 /*
2888  * Test TLSv1.3 PSKs
2889  * Test 0 = Test new style callbacks
2890  * Test 1 = Test both new and old style callbacks
2891  * Test 2 = Test old style callbacks
2892  * Test 3 = Test old style callbacks with no certificate
2893  */
2894 static int test_tls13_psk(int idx)
2895 {
2896     SSL_CTX *sctx = NULL, *cctx = NULL;
2897     SSL *serverssl = NULL, *clientssl = NULL;
2898     const SSL_CIPHER *cipher = NULL;
2899     const unsigned char key[] = {
2900         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
2901         0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
2902         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
2903         0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f
2904     };
2905     int testresult = 0;
2906
2907     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
2908                                        TLS1_VERSION, TLS_MAX_VERSION,
2909                                        &sctx, &cctx, idx == 3 ? NULL : cert,
2910                                        idx == 3 ? NULL : privkey)))
2911         goto end;
2912
2913     if (idx != 3) {
2914         /*
2915          * We use a ciphersuite with SHA256 to ease testing old style PSK
2916          * callbacks which will always default to SHA256. This should not be
2917          * necessary if we have no cert/priv key. In that case the server should
2918          * prefer SHA256 automatically.
2919          */
2920         if (!TEST_true(SSL_CTX_set_ciphersuites(cctx,
2921                                                 "TLS_AES_128_GCM_SHA256")))
2922             goto end;
2923     }
2924
2925     /*
2926      * Test 0: New style callbacks only
2927      * Test 1: New and old style callbacks (only the new ones should be used)
2928      * Test 2: Old style callbacks only
2929      */
2930     if (idx == 0 || idx == 1) {
2931         SSL_CTX_set_psk_use_session_callback(cctx, use_session_cb);
2932         SSL_CTX_set_psk_find_session_callback(sctx, find_session_cb);
2933     }
2934 #ifndef OPENSSL_NO_PSK
2935     if (idx >= 1) {
2936         SSL_CTX_set_psk_client_callback(cctx, psk_client_cb);
2937         SSL_CTX_set_psk_server_callback(sctx, psk_server_cb);
2938     }
2939 #endif
2940     srvid = pskid;
2941     use_session_cb_cnt = 0;
2942     find_session_cb_cnt = 0;
2943     psk_client_cb_cnt = 0;
2944     psk_server_cb_cnt = 0;
2945
2946     if (idx != 3) {
2947         /*
2948          * Check we can create a connection if callback decides not to send a
2949          * PSK
2950          */
2951         if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
2952                                                  NULL, NULL))
2953                 || !TEST_true(create_ssl_connection(serverssl, clientssl,
2954                                                     SSL_ERROR_NONE))
2955                 || !TEST_false(SSL_session_reused(clientssl))
2956                 || !TEST_false(SSL_session_reused(serverssl)))
2957             goto end;
2958
2959         if (idx == 0 || idx == 1) {
2960             if (!TEST_true(use_session_cb_cnt == 1)
2961                     || !TEST_true(find_session_cb_cnt == 0)
2962                        /*
2963                         * If no old style callback then below should be 0
2964                         * otherwise 1
2965                         */
2966                     || !TEST_true(psk_client_cb_cnt == idx)
2967                     || !TEST_true(psk_server_cb_cnt == 0))
2968                 goto end;
2969         } else {
2970             if (!TEST_true(use_session_cb_cnt == 0)
2971                     || !TEST_true(find_session_cb_cnt == 0)
2972                     || !TEST_true(psk_client_cb_cnt == 1)
2973                     || !TEST_true(psk_server_cb_cnt == 0))
2974                 goto end;
2975         }
2976
2977         shutdown_ssl_connection(serverssl, clientssl);
2978         serverssl = clientssl = NULL;
2979         use_session_cb_cnt = psk_client_cb_cnt = 0;
2980     }
2981
2982     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
2983                                              NULL, NULL)))
2984         goto end;
2985
2986     /* Create the PSK */
2987     cipher = SSL_CIPHER_find(clientssl, TLS13_AES_128_GCM_SHA256_BYTES);
2988     clientpsk = SSL_SESSION_new();
2989     if (!TEST_ptr(clientpsk)
2990             || !TEST_ptr(cipher)
2991             || !TEST_true(SSL_SESSION_set1_master_key(clientpsk, key,
2992                                                       sizeof(key)))
2993             || !TEST_true(SSL_SESSION_set_cipher(clientpsk, cipher))
2994             || !TEST_true(SSL_SESSION_set_protocol_version(clientpsk,
2995                                                            TLS1_3_VERSION))
2996             || !TEST_true(SSL_SESSION_up_ref(clientpsk)))
2997         goto end;
2998     serverpsk = clientpsk;
2999
3000     /* Check we can create a connection and the PSK is used */
3001     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE))
3002             || !TEST_true(SSL_session_reused(clientssl))
3003             || !TEST_true(SSL_session_reused(serverssl)))
3004         goto end;
3005
3006     if (idx == 0 || idx == 1) {
3007         if (!TEST_true(use_session_cb_cnt == 1)
3008                 || !TEST_true(find_session_cb_cnt == 1)
3009                 || !TEST_true(psk_client_cb_cnt == 0)
3010                 || !TEST_true(psk_server_cb_cnt == 0))
3011             goto end;
3012     } else {
3013         if (!TEST_true(use_session_cb_cnt == 0)
3014                 || !TEST_true(find_session_cb_cnt == 0)
3015                 || !TEST_true(psk_client_cb_cnt == 1)
3016                 || !TEST_true(psk_server_cb_cnt == 1))
3017             goto end;
3018     }
3019
3020     shutdown_ssl_connection(serverssl, clientssl);
3021     serverssl = clientssl = NULL;
3022     use_session_cb_cnt = find_session_cb_cnt = 0;
3023     psk_client_cb_cnt = psk_server_cb_cnt = 0;
3024
3025     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
3026                                              NULL, NULL)))
3027         goto end;
3028
3029     /* Force an HRR */
3030     if (!TEST_true(SSL_set1_groups_list(serverssl, "P-256")))
3031         goto end;
3032
3033     /*
3034      * Check we can create a connection, the PSK is used and the callbacks are
3035      * called twice.
3036      */
3037     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE))
3038             || !TEST_true(SSL_session_reused(clientssl))
3039             || !TEST_true(SSL_session_reused(serverssl)))
3040         goto end;
3041
3042     if (idx == 0 || idx == 1) {
3043         if (!TEST_true(use_session_cb_cnt == 2)
3044                 || !TEST_true(find_session_cb_cnt == 2)
3045                 || !TEST_true(psk_client_cb_cnt == 0)
3046                 || !TEST_true(psk_server_cb_cnt == 0))
3047             goto end;
3048     } else {
3049         if (!TEST_true(use_session_cb_cnt == 0)
3050                 || !TEST_true(find_session_cb_cnt == 0)
3051                 || !TEST_true(psk_client_cb_cnt == 2)
3052                 || !TEST_true(psk_server_cb_cnt == 2))
3053             goto end;
3054     }
3055
3056     shutdown_ssl_connection(serverssl, clientssl);
3057     serverssl = clientssl = NULL;
3058     use_session_cb_cnt = find_session_cb_cnt = 0;
3059     psk_client_cb_cnt = psk_server_cb_cnt = 0;
3060
3061     if (idx != 3) {
3062         /*
3063          * Check that if the server rejects the PSK we can still connect, but with
3064          * a full handshake
3065          */
3066         srvid = "Dummy Identity";
3067         if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
3068                                                  NULL, NULL))
3069                 || !TEST_true(create_ssl_connection(serverssl, clientssl,
3070                                                     SSL_ERROR_NONE))
3071                 || !TEST_false(SSL_session_reused(clientssl))
3072                 || !TEST_false(SSL_session_reused(serverssl)))
3073             goto end;
3074
3075         if (idx == 0 || idx == 1) {
3076             if (!TEST_true(use_session_cb_cnt == 1)
3077                     || !TEST_true(find_session_cb_cnt == 1)
3078                     || !TEST_true(psk_client_cb_cnt == 0)
3079                        /*
3080                         * If no old style callback then below should be 0
3081                         * otherwise 1
3082                         */
3083                     || !TEST_true(psk_server_cb_cnt == idx))
3084                 goto end;
3085         } else {
3086             if (!TEST_true(use_session_cb_cnt == 0)
3087                     || !TEST_true(find_session_cb_cnt == 0)
3088                     || !TEST_true(psk_client_cb_cnt == 1)
3089                     || !TEST_true(psk_server_cb_cnt == 1))
3090                 goto end;
3091         }
3092
3093         shutdown_ssl_connection(serverssl, clientssl);
3094         serverssl = clientssl = NULL;
3095     }
3096     testresult = 1;
3097
3098  end:
3099     SSL_SESSION_free(clientpsk);
3100     SSL_SESSION_free(serverpsk);
3101     clientpsk = serverpsk = NULL;
3102     SSL_free(serverssl);
3103     SSL_free(clientssl);
3104     SSL_CTX_free(sctx);
3105     SSL_CTX_free(cctx);
3106     return testresult;
3107 }
3108
3109 static unsigned char cookie_magic_value[] = "cookie magic";
3110
3111 static int generate_cookie_callback(SSL *ssl, unsigned char *cookie,
3112                                     unsigned int *cookie_len)
3113 {
3114     /*
3115      * Not suitable as a real cookie generation function but good enough for
3116      * testing!
3117      */
3118     memcpy(cookie, cookie_magic_value, sizeof(cookie_magic_value) - 1);
3119     *cookie_len = sizeof(cookie_magic_value) - 1;
3120
3121     return 1;
3122 }
3123
3124 static int verify_cookie_callback(SSL *ssl, const unsigned char *cookie,
3125                                   unsigned int cookie_len)
3126 {
3127     if (cookie_len == sizeof(cookie_magic_value) - 1
3128         && memcmp(cookie, cookie_magic_value, cookie_len) == 0)
3129         return 1;
3130
3131     return 0;
3132 }
3133
3134 static int generate_stateless_cookie_callback(SSL *ssl, unsigned char *cookie,
3135                                         size_t *cookie_len)
3136 {
3137     unsigned int temp;
3138     int res = generate_cookie_callback(ssl, cookie, &temp);
3139     *cookie_len = temp;
3140     return res;
3141 }
3142
3143 static int verify_stateless_cookie_callback(SSL *ssl, const unsigned char *cookie,
3144                                       size_t cookie_len)
3145 {
3146     return verify_cookie_callback(ssl, cookie, cookie_len);
3147 }
3148
3149 static int test_stateless(void)
3150 {
3151     SSL_CTX *sctx = NULL, *cctx = NULL;
3152     SSL *serverssl = NULL, *clientssl = NULL;
3153     int testresult = 0;
3154
3155     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
3156                                        TLS1_VERSION, TLS_MAX_VERSION,
3157                                        &sctx, &cctx, cert, privkey)))
3158         goto end;
3159
3160     /* The arrival of CCS messages can confuse the test */
3161     SSL_CTX_clear_options(cctx, SSL_OP_ENABLE_MIDDLEBOX_COMPAT);
3162
3163     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
3164                                       NULL, NULL))
3165                /* Send the first ClientHello */
3166             || !TEST_false(create_ssl_connection(serverssl, clientssl,
3167                                                  SSL_ERROR_WANT_READ))
3168                /*
3169                 * This should fail with a -1 return because we have no callbacks
3170                 * set up
3171                 */
3172             || !TEST_int_eq(SSL_stateless(serverssl), -1))
3173         goto end;
3174
3175     /* Fatal error so abandon the connection from this client */
3176     SSL_free(clientssl);
3177     clientssl = NULL;
3178
3179     /* Set up the cookie generation and verification callbacks */
3180     SSL_CTX_set_stateless_cookie_generate_cb(sctx, generate_stateless_cookie_callback);
3181     SSL_CTX_set_stateless_cookie_verify_cb(sctx, verify_stateless_cookie_callback);
3182
3183     /*
3184      * Create a new connection from the client (we can reuse the server SSL
3185      * object).
3186      */
3187     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
3188                                              NULL, NULL))
3189                /* Send the first ClientHello */
3190             || !TEST_false(create_ssl_connection(serverssl, clientssl,
3191                                                 SSL_ERROR_WANT_READ))
3192                /* This should fail because there is no cookie */
3193             || !TEST_int_eq(SSL_stateless(serverssl), 0))
3194         goto end;
3195
3196     /* Abandon the connection from this client */
3197     SSL_free(clientssl);
3198     clientssl = NULL;
3199
3200     /*
3201      * Now create a connection from a new client but with the same server SSL
3202      * object
3203      */
3204     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
3205                                              NULL, NULL))
3206                /* Send the first ClientHello */
3207             || !TEST_false(create_ssl_connection(serverssl, clientssl,
3208                                                 SSL_ERROR_WANT_READ))
3209                /* This should fail because there is no cookie */
3210             || !TEST_int_eq(SSL_stateless(serverssl), 0)
3211                /* Send the second ClientHello */
3212             || !TEST_false(create_ssl_connection(serverssl, clientssl,
3213                                                 SSL_ERROR_WANT_READ))
3214                /* This should succeed because a cookie is now present */
3215             || !TEST_int_eq(SSL_stateless(serverssl), 1)
3216                /* Complete the connection */
3217             || !TEST_true(create_ssl_connection(serverssl, clientssl,
3218                                                 SSL_ERROR_NONE)))
3219         goto end;
3220
3221     shutdown_ssl_connection(serverssl, clientssl);
3222     serverssl = clientssl = NULL;
3223     testresult = 1;
3224
3225  end:
3226     SSL_free(serverssl);
3227     SSL_free(clientssl);
3228     SSL_CTX_free(sctx);
3229     SSL_CTX_free(cctx);
3230     return testresult;
3231
3232 }
3233 #endif /* OPENSSL_NO_TLS1_3 */
3234
3235 static int clntaddoldcb = 0;
3236 static int clntparseoldcb = 0;
3237 static int srvaddoldcb = 0;
3238 static int srvparseoldcb = 0;
3239 static int clntaddnewcb = 0;
3240 static int clntparsenewcb = 0;
3241 static int srvaddnewcb = 0;
3242 static int srvparsenewcb = 0;
3243 static int snicb = 0;
3244
3245 #define TEST_EXT_TYPE1  0xff00
3246
3247 static int old_add_cb(SSL *s, unsigned int ext_type, const unsigned char **out,
3248                       size_t *outlen, int *al, void *add_arg)
3249 {
3250     int *server = (int *)add_arg;
3251     unsigned char *data;
3252
3253     if (SSL_is_server(s))
3254         srvaddoldcb++;
3255     else
3256         clntaddoldcb++;
3257
3258     if (*server != SSL_is_server(s)
3259             || (data = OPENSSL_malloc(sizeof(*data))) == NULL)
3260         return -1;
3261
3262     *data = 1;
3263     *out = data;
3264     *outlen = sizeof(char);
3265     return 1;
3266 }
3267
3268 static void old_free_cb(SSL *s, unsigned int ext_type, const unsigned char *out,
3269                         void *add_arg)
3270 {
3271     OPENSSL_free((unsigned char *)out);
3272 }
3273
3274 static int old_parse_cb(SSL *s, unsigned int ext_type, const unsigned char *in,
3275                         size_t inlen, int *al, void *parse_arg)
3276 {
3277     int *server = (int *)parse_arg;
3278
3279     if (SSL_is_server(s))
3280         srvparseoldcb++;
3281     else
3282         clntparseoldcb++;
3283
3284     if (*server != SSL_is_server(s)
3285             || inlen != sizeof(char)
3286             || *in != 1)
3287         return -1;
3288
3289     return 1;
3290 }
3291
3292 static int new_add_cb(SSL *s, unsigned int ext_type, unsigned int context,
3293                       const unsigned char **out, size_t *outlen, X509 *x,
3294                       size_t chainidx, int *al, void *add_arg)
3295 {
3296     int *server = (int *)add_arg;
3297     unsigned char *data;
3298
3299     if (SSL_is_server(s))
3300         srvaddnewcb++;
3301     else
3302         clntaddnewcb++;
3303
3304     if (*server != SSL_is_server(s)
3305             || (data = OPENSSL_malloc(sizeof(*data))) == NULL)
3306         return -1;
3307
3308     *data = 1;
3309     *out = data;
3310     *outlen = sizeof(*data);
3311     return 1;
3312 }
3313
3314 static void new_free_cb(SSL *s, unsigned int ext_type, unsigned int context,
3315                         const unsigned char *out, void *add_arg)
3316 {
3317     OPENSSL_free((unsigned char *)out);
3318 }
3319
3320 static int new_parse_cb(SSL *s, unsigned int ext_type, unsigned int context,
3321                         const unsigned char *in, size_t inlen, X509 *x,
3322                         size_t chainidx, int *al, void *parse_arg)
3323 {
3324     int *server = (int *)parse_arg;
3325
3326     if (SSL_is_server(s))
3327         srvparsenewcb++;
3328     else
3329         clntparsenewcb++;
3330
3331     if (*server != SSL_is_server(s)
3332             || inlen != sizeof(char) || *in != 1)
3333         return -1;
3334
3335     return 1;
3336 }
3337
3338 static int sni_cb(SSL *s, int *al, void *arg)
3339 {
3340     SSL_CTX *ctx = (SSL_CTX *)arg;
3341
3342     if (SSL_set_SSL_CTX(s, ctx) == NULL) {
3343         *al = SSL_AD_INTERNAL_ERROR;
3344         return SSL_TLSEXT_ERR_ALERT_FATAL;
3345     }
3346     snicb++;
3347     return SSL_TLSEXT_ERR_OK;
3348 }
3349
3350 /*
3351  * Custom call back tests.
3352  * Test 0: Old style callbacks in TLSv1.2
3353  * Test 1: New style callbacks in TLSv1.2
3354  * Test 2: New style callbacks in TLSv1.2 with SNI
3355  * Test 3: New style callbacks in TLSv1.3. Extensions in CH and EE
3356  * Test 4: New style callbacks in TLSv1.3. Extensions in CH, SH, EE, Cert + NST
3357  */
3358 static int test_custom_exts(int tst)
3359 {
3360     SSL_CTX *cctx = NULL, *sctx = NULL, *sctx2 = NULL;
3361     SSL *clientssl = NULL, *serverssl = NULL;
3362     int testresult = 0;
3363     static int server = 1;
3364     static int client = 0;
3365     SSL_SESSION *sess = NULL;
3366     unsigned int context;
3367
3368 #if defined(OPENSSL_NO_TLS1_2) && !defined(OPENSSL_NO_TLS1_3)
3369     /* Skip tests for TLSv1.2 and below in this case */
3370     if (tst < 3)
3371         return 1;
3372 #endif
3373
3374     /* Reset callback counters */
3375     clntaddoldcb = clntparseoldcb = srvaddoldcb = srvparseoldcb = 0;
3376     clntaddnewcb = clntparsenewcb = srvaddnewcb = srvparsenewcb = 0;
3377     snicb = 0;
3378
3379     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
3380                                        TLS1_VERSION, TLS_MAX_VERSION,
3381                                        &sctx, &cctx, cert, privkey)))
3382         goto end;
3383
3384     if (tst == 2
3385             && !TEST_true(create_ssl_ctx_pair(TLS_server_method(), NULL,
3386                                               TLS1_VERSION, TLS_MAX_VERSION,
3387                                               &sctx2, NULL, cert, privkey)))
3388         goto end;
3389
3390
3391     if (tst < 3) {
3392         SSL_CTX_set_options(cctx, SSL_OP_NO_TLSv1_3);
3393         SSL_CTX_set_options(sctx, SSL_OP_NO_TLSv1_3);
3394         if (sctx2 != NULL)
3395             SSL_CTX_set_options(sctx2, SSL_OP_NO_TLSv1_3);
3396     }
3397
3398     if (tst == 4) {
3399         context = SSL_EXT_CLIENT_HELLO
3400                   | SSL_EXT_TLS1_2_SERVER_HELLO
3401                   | SSL_EXT_TLS1_3_SERVER_HELLO
3402                   | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS
3403                   | SSL_EXT_TLS1_3_CERTIFICATE
3404                   | SSL_EXT_TLS1_3_NEW_SESSION_TICKET;
3405     } else {
3406         context = SSL_EXT_CLIENT_HELLO
3407                   | SSL_EXT_TLS1_2_SERVER_HELLO
3408                   | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS;
3409     }
3410
3411     /* Create a client side custom extension */
3412     if (tst == 0) {
3413         if (!TEST_true(SSL_CTX_add_client_custom_ext(cctx, TEST_EXT_TYPE1,
3414                                                      old_add_cb, old_free_cb,
3415                                                      &client, old_parse_cb,
3416                                                      &client)))
3417             goto end;
3418     } else {
3419         if (!TEST_true(SSL_CTX_add_custom_ext(cctx, TEST_EXT_TYPE1, context,
3420                                               new_add_cb, new_free_cb,
3421                                               &client, new_parse_cb, &client)))
3422             goto end;
3423     }
3424
3425     /* Should not be able to add duplicates */
3426     if (!TEST_false(SSL_CTX_add_client_custom_ext(cctx, TEST_EXT_TYPE1,
3427                                                   old_add_cb, old_free_cb,
3428                                                   &client, old_parse_cb,
3429                                                   &client))
3430             || !TEST_false(SSL_CTX_add_custom_ext(cctx, TEST_EXT_TYPE1,
3431                                                   context, new_add_cb,
3432                                                   new_free_cb, &client,
3433                                                   new_parse_cb, &client)))
3434         goto end;
3435
3436     /* Create a server side custom extension */
3437     if (tst == 0) {
3438         if (!TEST_true(SSL_CTX_add_server_custom_ext(sctx, TEST_EXT_TYPE1,
3439                                                      old_add_cb, old_free_cb,
3440                                                      &server, old_parse_cb,
3441                                                      &server)))
3442             goto end;
3443     } else {
3444         if (!TEST_true(SSL_CTX_add_custom_ext(sctx, TEST_EXT_TYPE1, context,
3445                                               new_add_cb, new_free_cb,
3446                                               &server, new_parse_cb, &server)))
3447             goto end;
3448         if (sctx2 != NULL
3449                 && !TEST_true(SSL_CTX_add_custom_ext(sctx2, TEST_EXT_TYPE1,
3450                                                      context, new_add_cb,
3451                                                      new_free_cb, &server,
3452                                                      new_parse_cb, &server)))
3453             goto end;
3454     }
3455
3456     /* Should not be able to add duplicates */
3457     if (!TEST_false(SSL_CTX_add_server_custom_ext(sctx, TEST_EXT_TYPE1,
3458                                                   old_add_cb, old_free_cb,
3459                                                   &server, old_parse_cb,
3460                                                   &server))
3461             || !TEST_false(SSL_CTX_add_custom_ext(sctx, TEST_EXT_TYPE1,
3462                                                   context, new_add_cb,
3463                                                   new_free_cb, &server,
3464                                                   new_parse_cb, &server)))
3465         goto end;
3466
3467     if (tst == 2) {
3468         /* Set up SNI */
3469         if (!TEST_true(SSL_CTX_set_tlsext_servername_callback(sctx, sni_cb))
3470                 || !TEST_true(SSL_CTX_set_tlsext_servername_arg(sctx, sctx2)))
3471             goto end;
3472     }
3473
3474     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
3475                                       &clientssl, NULL, NULL))
3476             || !TEST_true(create_ssl_connection(serverssl, clientssl,
3477                                                 SSL_ERROR_NONE)))
3478         goto end;
3479
3480     if (tst == 0) {
3481         if (clntaddoldcb != 1
3482                 || clntparseoldcb != 1
3483                 || srvaddoldcb != 1
3484                 || srvparseoldcb != 1)
3485             goto end;
3486     } else if (tst == 1 || tst == 2 || tst == 3) {
3487         if (clntaddnewcb != 1
3488                 || clntparsenewcb != 1
3489                 || srvaddnewcb != 1
3490                 || srvparsenewcb != 1
3491                 || (tst != 2 && snicb != 0)
3492                 || (tst == 2 && snicb != 1))
3493             goto end;