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