test/sslapitest.c

   1 /*
   2  * Copyright 2016 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 "test_main_custom.h"
  21 #include "e_os.h"
  22
  23 static char *cert = NULL;
  24 static char *privkey = NULL;
  25
  26 #define LOG_BUFFER_SIZE 1024
  27 static char server_log_buffer[LOG_BUFFER_SIZE + 1] = {0};
  28 static int server_log_buffer_index = 0;
  29 static char client_log_buffer[LOG_BUFFER_SIZE + 1] = {0};
  30 static int client_log_buffer_index = 0;
  31 static int error_writing_log = 0;
  32
  33 #ifndef OPENSSL_NO_OCSP
  34 static const unsigned char orespder[] = "Dummy OCSP Response";
  35 static int ocsp_server_called = 0;
  36 static int ocsp_client_called = 0;
  37
  38 static int cdummyarg = 1;
  39 static X509 *ocspcert = NULL;
  40 #endif
  41
  42 #define NUM_EXTRA_CERTS 40
  43
  44 /*
  45  * This structure is used to validate that the correct number of log messages
  46  * of various types are emitted when emitting secret logs.
  47  */
  48 struct sslapitest_log_counts {
  49     unsigned int rsa_key_exchange_count;
  50     unsigned int master_secret_count;
  51     unsigned int client_handshake_secret_count;
  52     unsigned int server_handshake_secret_count;
  53     unsigned int client_application_secret_count;
  54     unsigned int server_application_secret_count;
  55 };
  56
  57 static void client_keylog_callback(const SSL *ssl, const char *line) {
  58     int line_length = strlen(line);
  59
  60     /* If the log doesn't fit, error out. */
  61     if ((client_log_buffer_index + line_length) > LOG_BUFFER_SIZE) {
  62         printf("No room in client log\n");
  63         error_writing_log = 1;
  64         return;
  65     }
  66
  67     strcat(client_log_buffer, line);
  68     client_log_buffer_index += line_length;
  69     client_log_buffer[client_log_buffer_index] = '\n';
  70     client_log_buffer_index += 1;
  71
  72     return;
  73 }
  74
  75 static void server_keylog_callback(const SSL *ssl, const char *line) {
  76     int line_length = strlen(line);
  77
  78     /* If the log doesn't fit, error out. */
  79     if ((server_log_buffer_index + line_length) > LOG_BUFFER_SIZE) {
  80         printf("No room in server log\n");
  81         error_writing_log = 1;
  82         return;
  83     }
  84
  85     strcat(server_log_buffer, line);
  86     server_log_buffer_index += line_length;
  87     server_log_buffer[server_log_buffer_index] = '\n';
  88     server_log_buffer_index += 1;
  89
  90     return;
  91 }
  92
  93 static int compare_hex_encoded_buffer(const char *hex_encoded,
  94                                       size_t hex_length,
  95                                       const uint8_t *raw,
  96                                       size_t raw_length) {
  97     size_t i;
  98     size_t j;
  99
 100     /* One byte too big, just to be safe. */
 101     char hexed[3] = {0};
 102
 103     if ((raw_length * 2) != hex_length) {
 104         printf("Inconsistent hex encoded lengths.\n");
 105         return 1;
 106     }
 107
 108     for (i = j = 0; (i < raw_length) && ((j + 1) < hex_length); i++) {
 109         sprintf(hexed, "%02x", raw[i]);
 110         if ((hexed[0] != hex_encoded[j]) || (hexed[1] != hex_encoded[j + 1])) {
 111             printf("Hex output does not match.\n");
 112             return 1;
 113         }
 114         j += 2;
 115     }
 116
 117     return 0;
 118 }
 119
 120 static int test_keylog_output(char *buffer, const SSL *ssl,
 121                               const SSL_SESSION *session,
 122                               struct sslapitest_log_counts *expected) {
 123     char *token = NULL;
 124     unsigned char actual_client_random[SSL3_RANDOM_SIZE] = {0};
 125     size_t client_random_size = SSL3_RANDOM_SIZE;
 126     unsigned char actual_master_key[SSL_MAX_MASTER_KEY_LENGTH] = {0};
 127     size_t master_key_size = SSL_MAX_MASTER_KEY_LENGTH;
 128     unsigned int rsa_key_exchange_count = 0;
 129     unsigned int master_secret_count = 0;
 130     unsigned int client_handshake_secret_count = 0;
 131     unsigned int server_handshake_secret_count = 0;
 132     unsigned int client_application_secret_count = 0;
 133     unsigned int server_application_secret_count = 0;
 134
 135     token = strtok(buffer, " \n");
 136     while (token) {
 137         if (strcmp(token, "RSA") == 0) {
 138             /*
 139              * Premaster secret. Tokens should be: 16 ASCII bytes of
 140              * hex-encoded encrypted secret, then the hex-encoded pre-master
 141              * secret.
 142              */
 143             token = strtok(NULL, " \n");
 144             if (!token) {
 145                 printf("Unexpectedly short premaster secret log.\n");
 146                 return 0;
 147             }
 148             if (strlen(token) != 16) {
 149                 printf("Bad value for encrypted secret: %s\n", token);
 150                 return 0;
 151             }
 152             token = strtok(NULL, " \n");
 153             if (!token) {
 154                 printf("Unexpectedly short premaster secret log.\n");
 155                 return 0;
 156             }
 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 (client_random_size != SSL3_RANDOM_SIZE) {
 172                 printf("Unexpected short client random.\n");
 173                 return 0;
 174             }
 175
 176             token = strtok(NULL, " \n");
 177             if (!token) {
 178                 printf("Unexpected short master secret log.\n");
 179                 return 0;
 180             }
 181             if (strlen(token) != 64) {
 182                 printf("Bad value for client random: %s\n", token);
 183                 return 0;
 184             }
 185             if (compare_hex_encoded_buffer(token, 64, actual_client_random,
 186                                            client_random_size)) {
 187                 printf("Bad value for client random: %s\n", token);
 188                 return 0;
 189             }
 190
 191             token = strtok(NULL, " \n");
 192             if (!token) {
 193                 printf("Unexpectedly short master secret log.\n");
 194                 return 0;
 195             }
 196
 197             master_key_size = SSL_SESSION_get_master_key(session,
 198                                                          actual_master_key,
 199                                                          master_key_size);
 200             if (!master_key_size) {
 201                 printf("Error getting master key to compare.\n");
 202                 return 0;
 203             }
 204             if (compare_hex_encoded_buffer(token, strlen(token),
 205                                            actual_master_key,
 206                                            master_key_size)) {
 207                 printf("Bad value for master key: %s\n", token);
 208                 return 0;
 209             }
 210
 211             master_secret_count++;
 212         } else if ((strcmp(token, "CLIENT_HANDSHAKE_TRAFFIC_SECRET") == 0) ||
 213                    (strcmp(token, "SERVER_HANDSHAKE_TRAFFIC_SECRET") == 0) ||
 214                    (strcmp(token, "CLIENT_TRAFFIC_SECRET_0") == 0) ||
 215                    (strcmp(token, "SERVER_TRAFFIC_SECRET_0") == 0)) {
 216             /*
 217              * TLSv1.3 secret. Tokens should be: 64 ASCII bytes of hex-encoded
 218              * client random, and then the hex-encoded secret. In this case,
 219              * we treat all of these secrets identically and then just
 220              * distinguish between them when counting what we saw.
 221              */
 222             if (strcmp(token, "CLIENT_HANDSHAKE_TRAFFIC_SECRET") == 0)
 223                 client_handshake_secret_count++;
 224             else if (strcmp(token, "SERVER_HANDSHAKE_TRAFFIC_SECRET") == 0)
 225                 server_handshake_secret_count++;
 226             else if (strcmp(token, "CLIENT_TRAFFIC_SECRET_0") == 0)
 227                 client_application_secret_count++;
 228             else if (strcmp(token, "SERVER_TRAFFIC_SECRET_0") == 0)
 229                 server_application_secret_count++;
 230
 231             client_random_size = SSL_get_client_random(ssl,
 232                                                        actual_client_random,
 233                                                        SSL3_RANDOM_SIZE);
 234             if (client_random_size != SSL3_RANDOM_SIZE) {
 235                 printf("Unexpected short client random.\n");
 236                 return 0;
 237             }
 238
 239             token = strtok(NULL, " \n");
 240             if (!token) {
 241                 printf("Unexpected short client handshake secret log.\n");
 242                 return 0;
 243             }
 244             if (strlen(token) != 64) {
 245                 printf("Bad value for client random: %s\n", token);
 246                 return 0;
 247             }
 248             if (compare_hex_encoded_buffer(token, 64, actual_client_random,
 249                                            client_random_size)) {
 250                 printf("Bad value for client random: %s\n", token);
 251                 return 0;
 252             }
 253
 254             token = strtok(NULL, " \n");
 255             if (!token) {
 256                 printf("Unexpectedly short master secret log.\n");
 257                 return 0;
 258             }
 259
 260             /*
 261              * TODO(TLS1.3): test that application traffic secrets are what
 262              * we expect */
 263         } else {
 264             printf("Unexpected token in buffer: %s\n", token);
 265             return 0;
 266         }
 267
 268         token = strtok(NULL, " \n");
 269     }
 270
 271     /* Return whether we got what we expected. */
 272     return ((rsa_key_exchange_count == expected->rsa_key_exchange_count) &&
 273             (master_secret_count == expected->master_secret_count) &&
 274             (client_handshake_secret_count == expected->client_handshake_secret_count) &&
 275             (server_handshake_secret_count == expected->server_handshake_secret_count) &&
 276             (client_application_secret_count == expected->client_application_secret_count) &&
 277             (server_application_secret_count == expected->server_application_secret_count));
 278 }
 279
 280 static int test_keylog(void) {
 281     SSL_CTX *cctx = NULL, *sctx = NULL;
 282     SSL *clientssl = NULL, *serverssl = NULL;
 283     int testresult = 0;
 284     int rc;
 285     struct sslapitest_log_counts expected = {0};
 286
 287     /* Clean up logging space */
 288     memset(client_log_buffer, 0, LOG_BUFFER_SIZE + 1);
 289     memset(server_log_buffer, 0, LOG_BUFFER_SIZE + 1);
 290     client_log_buffer_index = 0;
 291     server_log_buffer_index = 0;
 292     error_writing_log = 0;
 293
 294     if (!create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(), &sctx,
 295                              &cctx, cert, privkey)) {
 296         printf("Unable to create SSL_CTX pair\n");
 297         return 0;
 298     }
 299
 300     /* We cannot log the master secret for TLSv1.3, so we should forbid it. */
 301     SSL_CTX_set_options(cctx, SSL_OP_NO_TLSv1_3);
 302     SSL_CTX_set_options(sctx, SSL_OP_NO_TLSv1_3);
 303
 304     /* We also want to ensure that we use RSA-based key exchange. */
 305     rc = SSL_CTX_set_cipher_list(cctx, "RSA");
 306     if (rc == 0) {
 307         printf("Unable to restrict to RSA key exchange.\n");
 308         goto end;
 309     }
 310
 311     if (SSL_CTX_get_keylog_callback(cctx)) {
 312         printf("Unexpected initial value for client "
 313                "SSL_CTX_get_keylog_callback()\n");
 314         goto end;
 315     }
 316     if (SSL_CTX_get_keylog_callback(sctx)) {
 317         printf("Unexpected initial value for server "
 318                "SSL_CTX_get_keylog_callback()\n");
 319         goto end;
 320     }
 321
 322     SSL_CTX_set_keylog_callback(cctx, client_keylog_callback);
 323     SSL_CTX_set_keylog_callback(sctx, server_keylog_callback);
 324
 325     if (SSL_CTX_get_keylog_callback(cctx) != client_keylog_callback) {
 326         printf("Unexpected set value for client "
 327                "SSL_CTX_get_keylog_callback()\n");
 328     }
 329
 330     if (SSL_CTX_get_keylog_callback(sctx) != server_keylog_callback) {
 331         printf("Unexpected set value for server "
 332                "SSL_CTX_get_keylog_callback()\n");
 333     }
 334
 335     /* Now do a handshake and check that the logs have been written to. */
 336     if (!create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL, NULL)) {
 337         printf("Unable to create SSL objects\n");
 338         goto end;
 339     }
 340
 341     if (!create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)) {
 342         printf("Unable to create SSL connection\n");
 343         goto end;
 344     }
 345
 346     if (error_writing_log) {
 347         printf("Error encountered while logging\n");
 348         goto end;
 349     }
 350
 351     if ((client_log_buffer_index == 0) || (server_log_buffer_index == 0)) {
 352         printf("No logs written\n");
 353         goto end;
 354     }
 355
 356     /*
 357      * Now we want to test that our output data was vaguely sensible. We
 358      * do that by using strtok and confirming that we have more or less the
 359      * data we expect. For both client and server, we expect to see one master
 360      * secret. The client should also see a RSA key exchange.
 361      */
 362     expected.rsa_key_exchange_count = 1;
 363     expected.master_secret_count = 1;
 364     if (!test_keylog_output(client_log_buffer, clientssl,
 365                             SSL_get_session(clientssl), &expected)) {
 366         printf("Error encountered in client log buffer\n");
 367         goto end;
 368     }
 369
 370     expected.rsa_key_exchange_count = 0;
 371     if (!test_keylog_output(server_log_buffer, serverssl,
 372                             SSL_get_session(serverssl), &expected)) {
 373         printf("Error encountered in server log buffer\n");
 374         goto end;
 375     }
 376
 377     testresult = 1;
 378
 379 end:
 380     SSL_free(serverssl);
 381     SSL_free(clientssl);
 382     SSL_CTX_free(sctx);
 383     SSL_CTX_free(cctx);
 384
 385     return testresult;
 386 }
 387
 388 #ifndef OPENSSL_NO_TLS1_3
 389 static int test_keylog_no_master_key(void) {
 390     SSL_CTX *cctx = NULL, *sctx = NULL;
 391     SSL *clientssl = NULL, *serverssl = NULL;
 392     int testresult = 0;
 393     struct sslapitest_log_counts expected = {0};
 394
 395     /* Clean up logging space */
 396     memset(client_log_buffer, 0, LOG_BUFFER_SIZE + 1);
 397     memset(server_log_buffer, 0, LOG_BUFFER_SIZE + 1);
 398     client_log_buffer_index = 0;
 399     server_log_buffer_index = 0;
 400     error_writing_log = 0;
 401
 402     if (!create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(), &sctx,
 403                              &cctx, cert, privkey)) {
 404         printf("Unable to create SSL_CTX pair\n");
 405         return 0;
 406     }
 407
 408     if (SSL_CTX_get_keylog_callback(cctx)) {
 409         printf("Unexpected initial value for client "
 410                "SSL_CTX_get_keylog_callback()\n");
 411         goto end;
 412     }
 413     if (SSL_CTX_get_keylog_callback(sctx)) {
 414         printf("Unexpected initial value for server "
 415                "SSL_CTX_get_keylog_callback()\n");
 416         goto end;
 417     }
 418
 419     SSL_CTX_set_keylog_callback(cctx, client_keylog_callback);
 420     SSL_CTX_set_keylog_callback(sctx, server_keylog_callback);
 421
 422     if (SSL_CTX_get_keylog_callback(cctx) != client_keylog_callback) {
 423         printf("Unexpected set value for client "
 424                "SSL_CTX_get_keylog_callback()\n");
 425     }
 426
 427     if (SSL_CTX_get_keylog_callback(sctx) != server_keylog_callback) {
 428         printf("Unexpected set value for server "
 429                "SSL_CTX_get_keylog_callback()\n");
 430     }
 431
 432     /* Now do a handshake and check that the logs have been written to. */
 433     if (!create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL, NULL)) {
 434         printf("Unable to create SSL objects\n");
 435         goto end;
 436     }
 437
 438     if (!create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)) {
 439         printf("Unable to create SSL connection\n");
 440         goto end;
 441     }
 442
 443     if (error_writing_log) {
 444         printf("Error encountered while logging\n");
 445         goto end;
 446     }
 447
 448     /*
 449      * Now we want to test that our output data was vaguely sensible. For this
 450      * test, we expect no CLIENT_RANDOM entry becuase it doesn't make sense for
 451      * TLSv1.3, but we do expect both client and server to emit keys.
 452      */
 453     expected.client_handshake_secret_count = 1;
 454     expected.server_handshake_secret_count = 1;
 455     expected.client_application_secret_count = 1;
 456     expected.server_application_secret_count = 1;
 457     if (!test_keylog_output(client_log_buffer, clientssl,
 458                             SSL_get_session(clientssl), &expected)) {
 459         printf("Error encountered in client log buffer\n");
 460         goto end;
 461     }
 462     if (!test_keylog_output(server_log_buffer, serverssl,
 463                             SSL_get_session(serverssl), &expected)) {
 464         printf("Error encountered in server log buffer\n");
 465         goto end;
 466     }
 467
 468     testresult = 1;
 469
 470 end:
 471     SSL_free(serverssl);
 472     SSL_free(clientssl);
 473     SSL_CTX_free(sctx);
 474     SSL_CTX_free(cctx);
 475
 476     return testresult;
 477 }
 478 #endif
 479
 480 static int execute_test_large_message(const SSL_METHOD *smeth,
 481                                       const SSL_METHOD *cmeth, int read_ahead)
 482 {
 483     SSL_CTX *cctx = NULL, *sctx = NULL;
 484     SSL *clientssl = NULL, *serverssl = NULL;
 485     int testresult = 0;
 486     int i;
 487     BIO *certbio = BIO_new_file(cert, "r");
 488     X509 *chaincert = NULL;
 489     int certlen;
 490
 491     if (certbio == NULL) {
 492         printf("Can't load the certficate file\n");
 493         goto end;
 494     }
 495     chaincert = PEM_read_bio_X509(certbio, NULL, NULL, NULL);
 496     BIO_free(certbio);
 497     certbio = NULL;
 498     if (chaincert == NULL) {
 499         printf("Unable to load certificate for chain\n");
 500         goto end;
 501     }
 502
 503     if (!create_ssl_ctx_pair(smeth, cmeth, &sctx,
 504                              &cctx, cert, privkey)) {
 505         printf("Unable to create SSL_CTX pair\n");
 506         goto end;
 507     }
 508
 509     if(read_ahead) {
 510         /*
 511          * Test that read_ahead works correctly when dealing with large
 512          * records
 513          */
 514         SSL_CTX_set_read_ahead(cctx, 1);
 515     }
 516
 517     /*
 518      * We assume the supplied certificate is big enough so that if we add
 519      * NUM_EXTRA_CERTS it will make the overall message large enough. The
 520      * default buffer size is requested to be 16k, but due to the way BUF_MEM
 521      * works, it ends up allocing a little over 21k (16 * 4/3). So, in this test
 522      * we need to have a message larger than that.
 523      */
 524     certlen = i2d_X509(chaincert, NULL);
 525     OPENSSL_assert((certlen * NUM_EXTRA_CERTS)
 526                    > ((SSL3_RT_MAX_PLAIN_LENGTH * 4) / 3));
 527     for (i = 0; i < NUM_EXTRA_CERTS; i++) {
 528         if (!X509_up_ref(chaincert)) {
 529             printf("Unable to up ref cert\n");
 530             goto end;
 531         }
 532         if (!SSL_CTX_add_extra_chain_cert(sctx, chaincert)) {
 533             printf("Unable to add extra chain cert %d\n", i);
 534             X509_free(chaincert);
 535             goto end;
 536         }
 537     }
 538
 539     if (!create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL, NULL)) {
 540         printf("Unable to create SSL objects\n");
 541         goto end;
 542     }
 543
 544     if (!create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)) {
 545         printf("Unable to create SSL connection\n");
 546         goto end;
 547     }
 548
 549     /*
 550      * Calling SSL_clear() first is not required but this tests that SSL_clear()
 551      * doesn't leak (when using enable-crypto-mdebug).
 552      */
 553     if (!SSL_clear(serverssl)) {
 554         printf("Unexpected failure from SSL_clear()\n");
 555         goto end;
 556     }
 557
 558     testresult = 1;
 559  end:
 560     X509_free(chaincert);
 561     SSL_free(serverssl);
 562     SSL_free(clientssl);
 563     SSL_CTX_free(sctx);
 564     SSL_CTX_free(cctx);
 565
 566     return testresult;
 567 }
 568
 569 static int test_large_message_tls(void)
 570 {
 571     return execute_test_large_message(TLS_server_method(), TLS_client_method(),
 572                                       0);
 573 }
 574
 575 static int test_large_message_tls_read_ahead(void)
 576 {
 577     return execute_test_large_message(TLS_server_method(), TLS_client_method(),
 578                                       1);
 579 }
 580
 581 #ifndef OPENSSL_NO_DTLS
 582 static int test_large_message_dtls(void)
 583 {
 584     /*
 585      * read_ahead is not relevant to DTLS because DTLS always acts as if
 586      * read_ahead is set.
 587      */
 588     return execute_test_large_message(DTLS_server_method(),
 589                                       DTLS_client_method(), 0);
 590 }
 591 #endif
 592
 593 #ifndef OPENSSL_NO_OCSP
 594 static int ocsp_server_cb(SSL *s, void *arg)
 595 {
 596     int *argi = (int *)arg;
 597     unsigned char *orespdercopy = NULL;
 598     STACK_OF(OCSP_RESPID) *ids = NULL;
 599     OCSP_RESPID *id = NULL;
 600
 601     if (*argi == 2) {
 602         /* In this test we are expecting exactly 1 OCSP_RESPID */
 603         SSL_get_tlsext_status_ids(s, &ids);
 604         if (ids == NULL || sk_OCSP_RESPID_num(ids) != 1)
 605             return SSL_TLSEXT_ERR_ALERT_FATAL;
 606
 607         id = sk_OCSP_RESPID_value(ids, 0);
 608         if (id == NULL || !OCSP_RESPID_match(id, ocspcert))
 609             return SSL_TLSEXT_ERR_ALERT_FATAL;
 610     } else if (*argi != 1) {
 611         return SSL_TLSEXT_ERR_ALERT_FATAL;
 612     }
 613
 614
 615     orespdercopy = OPENSSL_memdup(orespder, sizeof(orespder));
 616     if (orespdercopy == NULL)
 617         return SSL_TLSEXT_ERR_ALERT_FATAL;
 618
 619     SSL_set_tlsext_status_ocsp_resp(s, orespdercopy, sizeof(orespder));
 620
 621     ocsp_server_called = 1;
 622
 623     return SSL_TLSEXT_ERR_OK;
 624 }
 625
 626 static int ocsp_client_cb(SSL *s, void *arg)
 627 {
 628     int *argi = (int *)arg;
 629     const unsigned char *respderin;
 630     size_t len;
 631
 632     if (*argi != 1 && *argi != 2)
 633         return 0;
 634
 635     len = SSL_get_tlsext_status_ocsp_resp(s, &respderin);
 636
 637     if (memcmp(orespder, respderin, len) != 0)
 638         return 0;
 639
 640     ocsp_client_called = 1;
 641
 642     return 1;
 643 }
 644
 645 static int test_tlsext_status_type(void)
 646 {
 647     SSL_CTX *cctx = NULL, *sctx = NULL;
 648     SSL *clientssl = NULL, *serverssl = NULL;
 649     int testresult = 0;
 650     STACK_OF(OCSP_RESPID) *ids = NULL;
 651     OCSP_RESPID *id = NULL;
 652     BIO *certbio = NULL;
 653
 654     if (!create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(), &sctx,
 655                              &cctx, cert, privkey)) {
 656         printf("Unable to create SSL_CTX pair\n");
 657         return 0;
 658     }
 659
 660     if (SSL_CTX_get_tlsext_status_type(cctx) != -1) {
 661         printf("Unexpected initial value for "
 662                "SSL_CTX_get_tlsext_status_type()\n");
 663         goto end;
 664     }
 665
 666     /* First just do various checks getting and setting tlsext_status_type */
 667
 668     clientssl = SSL_new(cctx);
 669     if (SSL_get_tlsext_status_type(clientssl) != -1) {
 670         printf("Unexpected initial value for SSL_get_tlsext_status_type()\n");
 671         goto end;
 672     }
 673
 674     if (!SSL_set_tlsext_status_type(clientssl, TLSEXT_STATUSTYPE_ocsp)) {
 675         printf("Unexpected fail for SSL_set_tlsext_status_type()\n");
 676         goto end;
 677     }
 678
 679     if (SSL_get_tlsext_status_type(clientssl) != TLSEXT_STATUSTYPE_ocsp) {
 680         printf("Unexpected result for SSL_get_tlsext_status_type()\n");
 681         goto end;
 682     }
 683
 684     SSL_free(clientssl);
 685     clientssl = NULL;
 686
 687     if (!SSL_CTX_set_tlsext_status_type(cctx, TLSEXT_STATUSTYPE_ocsp)) {
 688         printf("Unexpected fail for SSL_CTX_set_tlsext_status_type()\n");
 689         goto end;
 690     }
 691
 692     if (SSL_CTX_get_tlsext_status_type(cctx) != TLSEXT_STATUSTYPE_ocsp) {
 693         printf("Unexpected result for SSL_CTX_get_tlsext_status_type()\n");
 694         goto end;
 695     }
 696
 697     clientssl = SSL_new(cctx);
 698
 699     if (SSL_get_tlsext_status_type(clientssl) != TLSEXT_STATUSTYPE_ocsp) {
 700         printf("Unexpected result for SSL_get_tlsext_status_type() (test 2)\n");
 701         goto end;
 702     }
 703
 704     SSL_free(clientssl);
 705     clientssl = NULL;
 706
 707     /*
 708      * Now actually do a handshake and check OCSP information is exchanged and
 709      * the callbacks get called
 710      */
 711
 712     SSL_CTX_set_tlsext_status_cb(cctx, ocsp_client_cb);
 713     SSL_CTX_set_tlsext_status_arg(cctx, &cdummyarg);
 714     SSL_CTX_set_tlsext_status_cb(sctx, ocsp_server_cb);
 715     SSL_CTX_set_tlsext_status_arg(sctx, &cdummyarg);
 716
 717     if (!create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL, NULL)) {
 718         printf("Unable to create SSL objects\n");
 719         goto end;
 720     }
 721
 722     if (!create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)) {
 723         printf("Unable to create SSL connection\n");
 724         goto end;
 725     }
 726
 727     if (!ocsp_client_called || !ocsp_server_called) {
 728         printf("OCSP callbacks not called\n");
 729         goto end;
 730     }
 731
 732     SSL_free(serverssl);
 733     SSL_free(clientssl);
 734     serverssl = NULL;
 735     clientssl = NULL;
 736
 737     /* Try again but this time force the server side callback to fail */
 738     ocsp_client_called = 0;
 739     ocsp_server_called = 0;
 740     cdummyarg = 0;
 741
 742     if (!create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL, NULL)) {
 743         printf("Unable to create SSL objects\n");
 744         goto end;
 745     }
 746
 747     /* This should fail because the callback will fail */
 748     if (create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)) {
 749         printf("Unexpected success creating the connection\n");
 750         goto end;
 751     }
 752
 753     if (ocsp_client_called || ocsp_server_called) {
 754         printf("OCSP callbacks successfully called unexpectedly\n");
 755         goto end;
 756     }
 757
 758     SSL_free(serverssl);
 759     SSL_free(clientssl);
 760     serverssl = NULL;
 761     clientssl = NULL;
 762
 763     /*
 764      * This time we'll get the client to send an OCSP_RESPID that it will
 765      * accept.
 766      */
 767     ocsp_client_called = 0;
 768     ocsp_server_called = 0;
 769     cdummyarg = 2;
 770
 771     if (!create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL, NULL)) {
 772         printf("Unable to create SSL objects\n");
 773         goto end;
 774     }
 775
 776     /*
 777      * We'll just use any old cert for this test - it doesn't have to be an OCSP
 778      * specifc one. We'll use the server cert.
 779      */
 780     certbio = BIO_new_file(cert, "r");
 781     if (certbio == NULL) {
 782         printf("Can't load the certficate file\n");
 783         goto end;
 784     }
 785     id = OCSP_RESPID_new();
 786     ids = sk_OCSP_RESPID_new_null();
 787     ocspcert = PEM_read_bio_X509(certbio, NULL, NULL, NULL);
 788     if (id == NULL || ids == NULL || ocspcert == NULL
 789             || !OCSP_RESPID_set_by_key(id, ocspcert)
 790             || !sk_OCSP_RESPID_push(ids, id)) {
 791         printf("Unable to set OCSP_RESPIDs\n");
 792         goto end;
 793     }
 794     id = NULL;
 795     SSL_set_tlsext_status_ids(clientssl, ids);
 796     /* Control has been transferred */
 797     ids = NULL;
 798
 799     BIO_free(certbio);
 800     certbio = NULL;
 801
 802     if (!create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)) {
 803         printf("Unable to create SSL connection\n");
 804         goto end;
 805     }
 806
 807     if (!ocsp_client_called || !ocsp_server_called) {
 808         printf("OCSP callbacks not called\n");
 809         goto end;
 810     }
 811
 812     testresult = 1;
 813
 814  end:
 815     SSL_free(serverssl);
 816     SSL_free(clientssl);
 817     SSL_CTX_free(sctx);
 818     SSL_CTX_free(cctx);
 819     sk_OCSP_RESPID_pop_free(ids, OCSP_RESPID_free);
 820     OCSP_RESPID_free(id);
 821     BIO_free(certbio);
 822     X509_free(ocspcert);
 823     ocspcert = NULL;
 824
 825     return testresult;
 826 }
 827 #endif
 828
 829 typedef struct ssl_session_test_fixture {
 830     const char *test_case_name;
 831     int use_ext_cache;
 832     int use_int_cache;
 833 } SSL_SESSION_TEST_FIXTURE;
 834
 835 static int new_called = 0, remove_called = 0;
 836
 837 static SSL_SESSION_TEST_FIXTURE
 838 ssl_session_set_up(const char *const test_case_name)
 839 {
 840     SSL_SESSION_TEST_FIXTURE fixture;
 841
 842     fixture.test_case_name = test_case_name;
 843     fixture.use_ext_cache = 1;
 844     fixture.use_int_cache = 1;
 845
 846     new_called = remove_called = 0;
 847
 848     return fixture;
 849 }
 850
 851 static void ssl_session_tear_down(SSL_SESSION_TEST_FIXTURE fixture)
 852 {
 853 }
 854
 855 static int new_session_cb(SSL *ssl, SSL_SESSION *sess)
 856 {
 857     new_called++;
 858
 859     return 1;
 860 }
 861
 862 static void remove_session_cb(SSL_CTX *ctx, SSL_SESSION *sess)
 863 {
 864     remove_called++;
 865 }
 866
 867 static int execute_test_session(SSL_SESSION_TEST_FIXTURE fix)
 868 {
 869     SSL_CTX *sctx = NULL, *cctx = NULL;
 870     SSL *serverssl1 = NULL, *clientssl1 = NULL;
 871     SSL *serverssl2 = NULL, *clientssl2 = NULL;
 872 #ifndef OPENSSL_NO_TLS1_1
 873     SSL *serverssl3 = NULL, *clientssl3 = NULL;
 874 #endif
 875     SSL_SESSION *sess1 = NULL, *sess2 = NULL;
 876     int testresult = 0;
 877
 878     if (!create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(), &sctx,
 879                              &cctx, cert, privkey)) {
 880         printf("Unable to create SSL_CTX pair\n");
 881         return 0;
 882     }
 883
 884 #ifndef OPENSSL_NO_TLS1_2
 885     /* Only allow TLS1.2 so we can force a connection failure later */
 886     SSL_CTX_set_min_proto_version(cctx, TLS1_2_VERSION);
 887 #endif
 888
 889     /* Set up session cache */
 890     if (fix.use_ext_cache) {
 891         SSL_CTX_sess_set_new_cb(cctx, new_session_cb);
 892         SSL_CTX_sess_set_remove_cb(cctx, remove_session_cb);
 893     }
 894     if (fix.use_int_cache) {
 895         /* Also covers instance where both are set */
 896         SSL_CTX_set_session_cache_mode(cctx, SSL_SESS_CACHE_CLIENT);
 897     } else {
 898         SSL_CTX_set_session_cache_mode(cctx,
 899                                        SSL_SESS_CACHE_CLIENT
 900                                        | SSL_SESS_CACHE_NO_INTERNAL_STORE);
 901     }
 902
 903     if (!create_ssl_objects(sctx, cctx, &serverssl1, &clientssl1, NULL,
 904                                NULL)) {
 905         printf("Unable to create SSL objects\n");
 906         goto end;
 907     }
 908
 909     if (!create_ssl_connection(serverssl1, clientssl1, SSL_ERROR_NONE)) {
 910         printf("Unable to create SSL connection\n");
 911         goto end;
 912     }
 913     sess1 = SSL_get1_session(clientssl1);
 914     if (sess1 == NULL) {
 915         printf("Unexpected NULL session\n");
 916         goto end;
 917     }
 918
 919     if (fix.use_int_cache && SSL_CTX_add_session(cctx, sess1)) {
 920         /* Should have failed because it should already be in the cache */
 921         printf("Unexpected success adding session to cache\n");
 922         goto end;
 923     }
 924
 925     if (fix.use_ext_cache && (new_called != 1 || remove_called != 0)) {
 926         printf("Session not added to cache\n");
 927         goto end;
 928     }
 929
 930     if (!create_ssl_objects(sctx, cctx, &serverssl2, &clientssl2, NULL, NULL)) {
 931         printf("Unable to create second SSL objects\n");
 932         goto end;
 933     }
 934
 935     if (!create_ssl_connection(serverssl2, clientssl2, SSL_ERROR_NONE)) {
 936         printf("Unable to create second SSL connection\n");
 937         goto end;
 938     }
 939
 940     sess2 = SSL_get1_session(clientssl2);
 941     if (sess2 == NULL) {
 942         printf("Unexpected NULL session from clientssl2\n");
 943         goto end;
 944     }
 945
 946     if (fix.use_ext_cache && (new_called != 2 || remove_called != 0)) {
 947         printf("Remove session callback unexpectedly called\n");
 948         goto end;
 949     }
 950
 951     /*
 952      * This should clear sess2 from the cache because it is a "bad" session. See
 953      * SSL_set_session() documentation.
 954      */
 955     if (!SSL_set_session(clientssl2, sess1)) {
 956         printf("Unexpected failure setting session\n");
 957         goto end;
 958     }
 959
 960     if (fix.use_ext_cache && (new_called != 2 || remove_called != 1)) {
 961         printf("Failed to call callback to remove session\n");
 962         goto end;
 963     }
 964
 965
 966     if (SSL_get_session(clientssl2) != sess1) {
 967         printf("Unexpected session found\n");
 968         goto end;
 969     }
 970
 971     if (fix.use_int_cache) {
 972         if (!SSL_CTX_add_session(cctx, sess2)) {
 973             /*
 974              * Should have succeeded because it should not already be in the cache
 975              */
 976             printf("Unexpected failure adding session to cache\n");
 977             goto end;
 978         }
 979
 980         if (!SSL_CTX_remove_session(cctx, sess2)) {
 981             printf("Unexpected failure removing session from cache\n");
 982             goto end;
 983         }
 984
 985         /* This is for the purposes of internal cache testing...ignore the
 986          * counter for external cache
 987          */
 988         if (fix.use_ext_cache)
 989             remove_called--;
 990     }
 991
 992     /* This shouldn't be in the cache so should fail */
 993     if (SSL_CTX_remove_session(cctx, sess2)) {
 994         printf("Unexpected success removing session from cache\n");
 995         goto end;
 996     }
 997
 998     if (fix.use_ext_cache && (new_called != 2 || remove_called != 2)) {
 999         printf("Failed to call callback to remove session #2\n");
1000         goto end;
1001     }
1002
1003 #if !defined(OPENSSL_NO_TLS1_1) && !defined(OPENSSL_NO_TLS1_2)
1004     /* Force a connection failure */
1005     SSL_CTX_set_max_proto_version(sctx, TLS1_1_VERSION);
1006
1007     if (!create_ssl_objects(sctx, cctx, &serverssl3, &clientssl3, NULL, NULL)) {
1008         printf("Unable to create third SSL objects\n");
1009         goto end;
1010     }
1011
1012     if (!SSL_set_session(clientssl3, sess1)) {
1013         printf("Unable to set session for third connection\n");
1014         goto end;
1015     }
1016
1017     /* This should fail because of the mismatched protocol versions */
1018     if (create_ssl_connection(serverssl3, clientssl3, SSL_ERROR_NONE)) {
1019         printf("Unable to create third SSL connection\n");
1020         goto end;
1021     }
1022
1023
1024     /* We should have automatically removed the session from the cache */
1025     if (fix.use_ext_cache && (new_called != 2 || remove_called != 3)) {
1026         printf("Failed to call callback to remove session #2\n");
1027         goto end;
1028     }
1029
1030     if (fix.use_int_cache && !SSL_CTX_add_session(cctx, sess2)) {
1031         /*
1032          * Should have succeeded because it should not already be in the cache
1033          */
1034         printf("Unexpected failure adding session to cache #2\n");
1035         goto end;
1036     }
1037 #endif
1038
1039     testresult = 1;
1040
1041  end:
1042     SSL_free(serverssl1);
1043     SSL_free(clientssl1);
1044     SSL_free(serverssl2);
1045     SSL_free(clientssl2);
1046 #ifndef OPENSSL_NO_TLS1_1
1047     SSL_free(serverssl3);
1048     SSL_free(clientssl3);
1049 #endif
1050     SSL_SESSION_free(sess1);
1051     SSL_SESSION_free(sess2);
1052     /*
1053      * Check if we need to remove any sessions up-refed for the external cache
1054      */
1055     if (new_called >= 1)
1056         SSL_SESSION_free(sess1);
1057     if (new_called >= 2)
1058         SSL_SESSION_free(sess2);
1059     SSL_CTX_free(sctx);
1060     SSL_CTX_free(cctx);
1061
1062     return testresult;
1063 }
1064
1065 static int test_session_with_only_int_cache(void)
1066 {
1067     SETUP_TEST_FIXTURE(SSL_SESSION_TEST_FIXTURE, ssl_session_set_up);
1068
1069     fixture.use_ext_cache = 0;
1070
1071     EXECUTE_TEST(execute_test_session, ssl_session_tear_down);
1072 }
1073
1074 static int test_session_with_only_ext_cache(void)
1075 {
1076     SETUP_TEST_FIXTURE(SSL_SESSION_TEST_FIXTURE, ssl_session_set_up);
1077
1078     fixture.use_int_cache = 0;
1079
1080     EXECUTE_TEST(execute_test_session, ssl_session_tear_down);
1081 }
1082
1083 static int test_session_with_both_cache(void)
1084 {
1085     SETUP_TEST_FIXTURE(SSL_SESSION_TEST_FIXTURE, ssl_session_set_up);
1086
1087     EXECUTE_TEST(execute_test_session, ssl_session_tear_down);
1088 }
1089
1090 #define USE_NULL    0
1091 #define USE_BIO_1   1
1092 #define USE_BIO_2   2
1093
1094 #define TOTAL_SSL_SET_BIO_TESTS (3 * 3 * 3 * 3)
1095
1096 static void setupbio(BIO **res, BIO *bio1, BIO *bio2, int type)
1097 {
1098     switch (type) {
1099     case USE_NULL:
1100         *res = NULL;
1101         break;
1102     case USE_BIO_1:
1103         *res = bio1;
1104         break;
1105     case USE_BIO_2:
1106         *res = bio2;
1107         break;
1108     }
1109 }
1110
1111 static int test_ssl_set_bio(int idx)
1112 {
1113     SSL_CTX *ctx = SSL_CTX_new(TLS_method());
1114     BIO *bio1 = NULL;
1115     BIO *bio2 = NULL;
1116     BIO *irbio = NULL, *iwbio = NULL, *nrbio = NULL, *nwbio = NULL;
1117     SSL *ssl = NULL;
1118     int initrbio, initwbio, newrbio, newwbio;
1119     int testresult = 0;
1120
1121     if (ctx == NULL) {
1122         printf("Failed to allocate SSL_CTX\n");
1123         goto end;
1124     }
1125
1126     ssl = SSL_new(ctx);
1127     if (ssl == NULL) {
1128         printf("Failed to allocate SSL object\n");
1129         goto end;
1130     }
1131
1132     initrbio = idx % 3;
1133     idx /= 3;
1134     initwbio = idx % 3;
1135     idx /= 3;
1136     newrbio = idx % 3;
1137     idx /= 3;
1138     newwbio = idx;
1139     OPENSSL_assert(newwbio <= 2);
1140
1141     if (initrbio == USE_BIO_1 || initwbio == USE_BIO_1 || newrbio == USE_BIO_1
1142             || newwbio == USE_BIO_1) {
1143         bio1 = BIO_new(BIO_s_mem());
1144         if (bio1 == NULL) {
1145             printf("Failed to allocate bio1\n");
1146             goto end;
1147         }
1148     }
1149
1150     if (initrbio == USE_BIO_2 || initwbio == USE_BIO_2 || newrbio == USE_BIO_2
1151             || newwbio == USE_BIO_2) {
1152         bio2 = BIO_new(BIO_s_mem());
1153         if (bio2 == NULL) {
1154             printf("Failed to allocate bio2\n");
1155             goto end;
1156         }
1157     }
1158
1159     setupbio(&irbio, bio1, bio2, initrbio);
1160     setupbio(&iwbio, bio1, bio2, initwbio);
1161
1162     /*
1163      * We want to maintain our own refs to these BIO, so do an up ref for each
1164      * BIO that will have ownersip transferred in the SSL_set_bio() call
1165      */
1166     if (irbio != NULL)
1167         BIO_up_ref(irbio);
1168     if (iwbio != NULL && iwbio != irbio)
1169         BIO_up_ref(iwbio);
1170
1171     SSL_set_bio(ssl, irbio, iwbio);
1172
1173     setupbio(&nrbio, bio1, bio2, newrbio);
1174     setupbio(&nwbio, bio1, bio2, newwbio);
1175
1176     /*
1177      * We will (maybe) transfer ownership again so do more up refs.
1178      * SSL_set_bio() has some really complicated ownership rules where BIOs have
1179      * already been set!
1180      */
1181     if (nrbio != NULL && nrbio != irbio && (nwbio != iwbio || nrbio != nwbio))
1182         BIO_up_ref(nrbio);
1183     if (nwbio != NULL && nwbio != nrbio && (nwbio != iwbio || (nwbio == iwbio && irbio == iwbio)))
1184         BIO_up_ref(nwbio);
1185
1186     SSL_set_bio(ssl, nrbio, nwbio);
1187
1188     testresult = 1;
1189
1190  end:
1191     SSL_free(ssl);
1192     BIO_free(bio1);
1193     BIO_free(bio2);
1194     /*
1195      * This test is checking that the ref counting for SSL_set_bio is correct.
1196      * If we get here and we did too many frees then we will fail in the above
1197      * functions. If we haven't done enough then this will only be detected in
1198      * a crypto-mdebug build
1199      */
1200     SSL_CTX_free(ctx);
1201
1202     return testresult;
1203 }
1204
1205 typedef struct ssl_bio_test_fixture {
1206     const char *test_case_name;
1207     int pop_ssl;
1208     enum { NO_BIO_CHANGE, CHANGE_RBIO, CHANGE_WBIO } change_bio;
1209 } SSL_BIO_TEST_FIXTURE;
1210
1211 static SSL_BIO_TEST_FIXTURE ssl_bio_set_up(const char *const test_case_name)
1212 {
1213     SSL_BIO_TEST_FIXTURE fixture;
1214
1215     fixture.test_case_name = test_case_name;
1216     fixture.pop_ssl = 0;
1217     fixture.change_bio = NO_BIO_CHANGE;
1218
1219     return fixture;
1220 }
1221
1222 static void ssl_bio_tear_down(SSL_BIO_TEST_FIXTURE fixture)
1223 {
1224 }
1225
1226 static int execute_test_ssl_bio(SSL_BIO_TEST_FIXTURE fix)
1227 {
1228     BIO *sslbio = NULL, *membio1 = NULL, *membio2 = NULL;
1229     SSL_CTX *ctx = SSL_CTX_new(TLS_method());
1230     SSL *ssl = NULL;
1231     int testresult = 0;
1232
1233     if (ctx == NULL) {
1234         printf("Failed to allocate SSL_CTX\n");
1235         return 0;
1236     }
1237
1238     ssl = SSL_new(ctx);
1239     if (ssl == NULL) {
1240         printf("Failed to allocate SSL object\n");
1241         goto end;
1242     }
1243
1244     sslbio = BIO_new(BIO_f_ssl());
1245     membio1 = BIO_new(BIO_s_mem());
1246
1247     if (sslbio == NULL || membio1 == NULL) {
1248         printf("Malloc failure creating BIOs\n");
1249         goto end;
1250     }
1251
1252     BIO_set_ssl(sslbio, ssl, BIO_CLOSE);
1253
1254     /*
1255      * If anything goes wrong here then we could leak memory, so this will
1256      * be caught in a crypto-mdebug build
1257      */
1258     BIO_push(sslbio, membio1);
1259
1260     /* Verify chaning the rbio/wbio directly does not cause leaks */
1261     if (fix.change_bio != NO_BIO_CHANGE) {
1262         membio2 = BIO_new(BIO_s_mem());
1263         if (membio2 == NULL) {
1264             printf("Malloc failure creating membio2\n");
1265             goto end;
1266         }
1267         if (fix.change_bio == CHANGE_RBIO)
1268             SSL_set0_rbio(ssl, membio2);
1269         else
1270             SSL_set0_wbio(ssl, membio2);
1271     }
1272     ssl = NULL;
1273
1274     if (fix.pop_ssl)
1275         BIO_pop(sslbio);
1276     else
1277         BIO_pop(membio1);
1278
1279     testresult = 1;
1280  end:
1281     BIO_free(membio1);
1282     BIO_free(sslbio);
1283     SSL_free(ssl);
1284     SSL_CTX_free(ctx);
1285
1286     return testresult;
1287 }
1288
1289 static int test_ssl_bio_pop_next_bio(void)
1290 {
1291     SETUP_TEST_FIXTURE(SSL_BIO_TEST_FIXTURE, ssl_bio_set_up);
1292
1293     EXECUTE_TEST(execute_test_ssl_bio, ssl_bio_tear_down);
1294 }
1295
1296 static int test_ssl_bio_pop_ssl_bio(void)
1297 {
1298     SETUP_TEST_FIXTURE(SSL_BIO_TEST_FIXTURE, ssl_bio_set_up);
1299
1300     fixture.pop_ssl = 1;
1301
1302     EXECUTE_TEST(execute_test_ssl_bio, ssl_bio_tear_down);
1303 }
1304
1305 static int test_ssl_bio_change_rbio(void)
1306 {
1307     SETUP_TEST_FIXTURE(SSL_BIO_TEST_FIXTURE, ssl_bio_set_up);
1308
1309     fixture.change_bio = CHANGE_RBIO;
1310
1311     EXECUTE_TEST(execute_test_ssl_bio, ssl_bio_tear_down);
1312 }
1313
1314 static int test_ssl_bio_change_wbio(void)
1315 {
1316     SETUP_TEST_FIXTURE(SSL_BIO_TEST_FIXTURE, ssl_bio_set_up);
1317
1318     fixture.change_bio = CHANGE_WBIO;
1319
1320     EXECUTE_TEST(execute_test_ssl_bio, ssl_bio_tear_down);
1321 }
1322
1323 typedef struct {
1324     /* The list of sig algs */
1325     const int *list;
1326     /* The length of the list */
1327     size_t listlen;
1328     /* A sigalgs list in string format */
1329     const char *liststr;
1330     /* Whether setting the list should succeed */
1331     int valid;
1332     /* Whether creating a connection with the list should succeed */
1333     int connsuccess;
1334 } sigalgs_list;
1335
1336 static const int validlist1[] = {NID_sha256, EVP_PKEY_RSA};
1337 #ifndef OPENSSL_NO_EC
1338 static const int validlist2[] = {NID_sha256, EVP_PKEY_RSA, NID_sha512, EVP_PKEY_EC};
1339 static const int validlist3[] = {NID_sha512, EVP_PKEY_EC};
1340 #endif
1341 static const int invalidlist1[] = {NID_undef, EVP_PKEY_RSA};
1342 static const int invalidlist2[] = {NID_sha256, NID_undef};
1343 static const int invalidlist3[] = {NID_sha256, EVP_PKEY_RSA, NID_sha256};
1344 static const int invalidlist4[] = {NID_sha256};
1345 static const sigalgs_list testsigalgs[] = {
1346     {validlist1, OSSL_NELEM(validlist1), NULL, 1, 1},
1347 #ifndef OPENSSL_NO_EC
1348     {validlist2, OSSL_NELEM(validlist2), NULL, 1, 1},
1349     {validlist3, OSSL_NELEM(validlist3), NULL, 1, 0},
1350 #endif
1351     {NULL, 0, "RSA+SHA256", 1, 1},
1352 #ifndef OPENSSL_NO_EC
1353     {NULL, 0, "RSA+SHA256:ECDSA+SHA512", 1, 1},
1354     {NULL, 0, "ECDSA+SHA512", 1, 0},
1355 #endif
1356     {invalidlist1, OSSL_NELEM(invalidlist1), NULL, 0, 0},
1357     {invalidlist2, OSSL_NELEM(invalidlist2), NULL, 0, 0},
1358     {invalidlist3, OSSL_NELEM(invalidlist3), NULL, 0, 0},
1359     {invalidlist4, OSSL_NELEM(invalidlist4), NULL, 0, 0},
1360     {NULL, 0, "RSA", 0, 0},
1361     {NULL, 0, "SHA256", 0, 0},
1362     {NULL, 0, "RSA+SHA256:SHA256", 0, 0},
1363     {NULL, 0, "Invalid", 0, 0}};
1364
1365 static int test_set_sigalgs(int idx)
1366 {
1367     SSL_CTX *cctx = NULL, *sctx = NULL;
1368     SSL *clientssl = NULL, *serverssl = NULL;
1369     int testresult = 0;
1370     const sigalgs_list *curr;
1371     int testctx;
1372
1373     /* Should never happen */
1374     if ((size_t)idx >= OSSL_NELEM(testsigalgs) * 2)
1375         return 0;
1376
1377     testctx = ((size_t)idx < OSSL_NELEM(testsigalgs));
1378     curr = testctx ? &testsigalgs[idx]
1379                    : &testsigalgs[idx - OSSL_NELEM(testsigalgs)];
1380
1381     if (!create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(), &sctx,
1382                              &cctx, cert, privkey)) {
1383         printf("Unable to create SSL_CTX pair\n");
1384         return 0;
1385     }
1386
1387     /*
1388      * TODO(TLS1.3): These APIs cannot set TLSv1.3 sig algs so we just test it
1389      * for TLSv1.2 for now until we add a new API.
1390      */
1391     SSL_CTX_set_max_proto_version(cctx, TLS1_2_VERSION);
1392
1393     if (testctx) {
1394         int ret;
1395         if (curr->list != NULL)
1396             ret = SSL_CTX_set1_sigalgs(cctx, curr->list, curr->listlen);
1397         else
1398             ret = SSL_CTX_set1_sigalgs_list(cctx, curr->liststr);
1399
1400         if (!ret) {
1401             if (curr->valid)
1402                 printf("Unexpected failure setting sigalgs in SSL_CTX (%d)\n",
1403                        idx);
1404             else
1405                 testresult = 1;
1406             goto end;
1407         }
1408         if (!curr->valid) {
1409             printf("Unexpected success setting sigalgs in SSL_CTX (%d)\n", idx);
1410             goto end;
1411         }
1412     }
1413
1414     if (!create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL, NULL)) {
1415         printf("Unable to create SSL objects\n");
1416         goto end;
1417     }
1418
1419     if (!testctx) {
1420         int ret;
1421
1422         if (curr->list != NULL)
1423             ret = SSL_set1_sigalgs(clientssl, curr->list, curr->listlen);
1424         else
1425             ret = SSL_set1_sigalgs_list(clientssl, curr->liststr);
1426         if (!ret) {
1427             if (curr->valid)
1428                 printf("Unexpected failure setting sigalgs in SSL (%d)\n", idx);
1429             else
1430                 testresult = 1;
1431             goto end;
1432         }
1433         if (!curr->valid) {
1434             printf("Unexpected success setting sigalgs in SSL (%d)\n", idx);
1435             goto end;
1436         }
1437     }
1438
1439     if (curr->connsuccess != create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)) {
1440         printf("Unexpected return value creating SSL connection (%d)\n", idx);
1441         goto end;
1442     }
1443
1444     testresult = 1;
1445
1446  end:
1447     SSL_free(serverssl);
1448     SSL_free(clientssl);
1449     SSL_CTX_free(sctx);
1450     SSL_CTX_free(cctx);
1451
1452     return testresult;
1453 }
1454
1455 int test_main(int argc, char *argv[])
1456 {
1457     int testresult = 1;
1458
1459     if (argc != 3) {
1460         printf("Invalid argument count\n");
1461         return 1;
1462     }
1463
1464     cert = argv[1];
1465     privkey = argv[2];
1466
1467     ADD_TEST(test_large_message_tls);
1468     ADD_TEST(test_large_message_tls_read_ahead);
1469 #ifndef OPENSSL_NO_DTLS
1470     ADD_TEST(test_large_message_dtls);
1471 #endif
1472 #ifndef OPENSSL_NO_OCSP
1473     ADD_TEST(test_tlsext_status_type);
1474 #endif
1475     ADD_TEST(test_session_with_only_int_cache);
1476     ADD_TEST(test_session_with_only_ext_cache);
1477     ADD_TEST(test_session_with_both_cache);
1478     ADD_ALL_TESTS(test_ssl_set_bio, TOTAL_SSL_SET_BIO_TESTS);
1479     ADD_TEST(test_ssl_bio_pop_next_bio);
1480     ADD_TEST(test_ssl_bio_pop_ssl_bio);
1481     ADD_TEST(test_ssl_bio_change_rbio);
1482     ADD_TEST(test_ssl_bio_change_wbio);
1483     ADD_ALL_TESTS(test_set_sigalgs, OSSL_NELEM(testsigalgs) * 2);
1484     ADD_TEST(test_keylog);
1485 #ifndef OPENSSL_NO_TLS1_3
1486     ADD_TEST(test_keylog_no_master_key);
1487 #endif
1488
1489     testresult = run_tests(argv[0]);
1490
1491     bio_s_mempacket_test_free();
1492
1493     return testresult;
1494 }