X-Git-Url: https://git.openssl.org/?p=openssl.git;a=blobdiff_plain;f=test%2Fsslapitest.c;h=436fbbb10fc872f53e5d8bb622cc24f7242982aa;hp=1fa9a8df9b52a6fba10b5210fd65c965492829a4;hb=a9c6d221055c3a85edb23b1364cd60baafed4b9f;hpb=e364c3b24e38bd60d40487e0a532261348a9bb10 diff --git a/test/sslapitest.c b/test/sslapitest.c index 1fa9a8df9b..436fbbb10f 100644 --- a/test/sslapitest.c +++ b/test/sslapitest.c @@ -17,20 +17,550 @@ #include "ssltestlib.h" #include "testutil.h" -#include "test_main_custom.h" +#include "e_os.h" static char *cert = NULL; static char *privkey = NULL; +#define LOG_BUFFER_SIZE 1024 +static char server_log_buffer[LOG_BUFFER_SIZE + 1] = {0}; +static int server_log_buffer_index = 0; +static char client_log_buffer[LOG_BUFFER_SIZE + 1] = {0}; +static int client_log_buffer_index = 0; +static int error_writing_log = 0; + +#ifndef OPENSSL_NO_OCSP static const unsigned char orespder[] = "Dummy OCSP Response"; static int ocsp_server_called = 0; static int ocsp_client_called = 0; static int cdummyarg = 1; static X509 *ocspcert = NULL; +#endif #define NUM_EXTRA_CERTS 40 +/* + * This structure is used to validate that the correct number of log messages + * of various types are emitted when emitting secret logs. + */ +struct sslapitest_log_counts { + unsigned int rsa_key_exchange_count; + unsigned int master_secret_count; + unsigned int client_handshake_secret_count; + unsigned int server_handshake_secret_count; + unsigned int client_application_secret_count; + unsigned int server_application_secret_count; +}; + +static void client_keylog_callback(const SSL *ssl, const char *line) { + int line_length = strlen(line); + + /* If the log doesn't fit, error out. */ + if ((client_log_buffer_index + line_length) > LOG_BUFFER_SIZE) { + printf("No room in client log\n"); + error_writing_log = 1; + return; + } + + strcat(client_log_buffer, line); + client_log_buffer_index += line_length; + client_log_buffer[client_log_buffer_index] = '\n'; + client_log_buffer_index += 1; + + return; +} + +static void server_keylog_callback(const SSL *ssl, const char *line) { + int line_length = strlen(line); + + /* If the log doesn't fit, error out. */ + if ((server_log_buffer_index + line_length) > LOG_BUFFER_SIZE) { + printf("No room in server log\n"); + error_writing_log = 1; + return; + } + + strcat(server_log_buffer, line); + server_log_buffer_index += line_length; + server_log_buffer[server_log_buffer_index] = '\n'; + server_log_buffer_index += 1; + + return; +} + +static int compare_hex_encoded_buffer(const char *hex_encoded, + size_t hex_length, + const uint8_t *raw, + size_t raw_length) { + size_t i; + size_t j; + + /* One byte too big, just to be safe. */ + char hexed[3] = {0}; + + if ((raw_length * 2) != hex_length) { + printf("Inconsistent hex encoded lengths.\n"); + return 1; + } + + for (i = j = 0; (i < raw_length) && ((j + 1) < hex_length); i++) { + sprintf(hexed, "%02x", raw[i]); + if ((hexed[0] != hex_encoded[j]) || (hexed[1] != hex_encoded[j + 1])) { + printf("Hex output does not match.\n"); + return 1; + } + j += 2; + } + + return 0; +} + +static int test_keylog_output(char *buffer, const SSL *ssl, + const SSL_SESSION *session, + struct sslapitest_log_counts *expected) { + char *token = NULL; + unsigned char actual_client_random[SSL3_RANDOM_SIZE] = {0}; + size_t client_random_size = SSL3_RANDOM_SIZE; + unsigned char actual_master_key[SSL_MAX_MASTER_KEY_LENGTH] = {0}; + size_t master_key_size = SSL_MAX_MASTER_KEY_LENGTH; + unsigned int rsa_key_exchange_count = 0; + unsigned int master_secret_count = 0; + unsigned int client_handshake_secret_count = 0; + unsigned int server_handshake_secret_count = 0; + unsigned int client_application_secret_count = 0; + unsigned int server_application_secret_count = 0; + + token = strtok(buffer, " \n"); + while (token) { + if (strcmp(token, "RSA") == 0) { + /* + * Premaster secret. Tokens should be: 16 ASCII bytes of + * hex-encoded encrypted secret, then the hex-encoded pre-master + * secret. + */ + token = strtok(NULL, " \n"); + if (!token) { + printf("Unexpectedly short premaster secret log.\n"); + return 0; + } + if (strlen(token) != 16) { + printf("Bad value for encrypted secret: %s\n", token); + return 0; + } + token = strtok(NULL, " \n"); + if (!token) { + printf("Unexpectedly short premaster secret log.\n"); + return 0; + } + /* + * We can't sensibly check the log because the premaster secret is + * transient, and OpenSSL doesn't keep hold of it once the master + * secret is generated. + */ + rsa_key_exchange_count++; + } else if (strcmp(token, "CLIENT_RANDOM") == 0) { + /* + * Master secret. Tokens should be: 64 ASCII bytes of hex-encoded + * client random, then the hex-encoded master secret. + */ + client_random_size = SSL_get_client_random(ssl, + actual_client_random, + SSL3_RANDOM_SIZE); + if (client_random_size != SSL3_RANDOM_SIZE) { + printf("Unexpected short client random.\n"); + return 0; + } + + token = strtok(NULL, " \n"); + if (!token) { + printf("Unexpected short master secret log.\n"); + return 0; + } + if (strlen(token) != 64) { + printf("Bad value for client random: %s\n", token); + return 0; + } + if (compare_hex_encoded_buffer(token, 64, actual_client_random, + client_random_size)) { + printf("Bad value for client random: %s\n", token); + return 0; + } + + token = strtok(NULL, " \n"); + if (!token) { + printf("Unexpectedly short master secret log.\n"); + return 0; + } + + master_key_size = SSL_SESSION_get_master_key(session, + actual_master_key, + master_key_size); + if (!master_key_size) { + printf("Error getting master key to compare.\n"); + return 0; + } + if (compare_hex_encoded_buffer(token, strlen(token), + actual_master_key, + master_key_size)) { + printf("Bad value for master key: %s\n", token); + return 0; + } + + master_secret_count++; + } else if ((strcmp(token, "CLIENT_HANDSHAKE_TRAFFIC_SECRET") == 0) || + (strcmp(token, "SERVER_HANDSHAKE_TRAFFIC_SECRET") == 0) || + (strcmp(token, "CLIENT_TRAFFIC_SECRET_0") == 0) || + (strcmp(token, "SERVER_TRAFFIC_SECRET_0") == 0)) { + /* + * TLSv1.3 secret. Tokens should be: 64 ASCII bytes of hex-encoded + * client random, and then the hex-encoded secret. In this case, + * we treat all of these secrets identically and then just + * distinguish between them when counting what we saw. + */ + if (strcmp(token, "CLIENT_HANDSHAKE_TRAFFIC_SECRET") == 0) + client_handshake_secret_count++; + else if (strcmp(token, "SERVER_HANDSHAKE_TRAFFIC_SECRET") == 0) + server_handshake_secret_count++; + else if (strcmp(token, "CLIENT_TRAFFIC_SECRET_0") == 0) + client_application_secret_count++; + else if (strcmp(token, "SERVER_TRAFFIC_SECRET_0") == 0) + server_application_secret_count++; + + client_random_size = SSL_get_client_random(ssl, + actual_client_random, + SSL3_RANDOM_SIZE); + if (client_random_size != SSL3_RANDOM_SIZE) { + printf("Unexpected short client random.\n"); + return 0; + } + + token = strtok(NULL, " \n"); + if (!token) { + printf("Unexpected short client handshake secret log.\n"); + return 0; + } + if (strlen(token) != 64) { + printf("Bad value for client random: %s\n", token); + return 0; + } + if (compare_hex_encoded_buffer(token, 64, actual_client_random, + client_random_size)) { + printf("Bad value for client random: %s\n", token); + return 0; + } + + token = strtok(NULL, " \n"); + if (!token) { + printf("Unexpectedly short master secret log.\n"); + return 0; + } + + /* + * TODO(TLS1.3): test that application traffic secrets are what + * we expect */ + } else { + printf("Unexpected token in buffer: %s\n", token); + return 0; + } + + token = strtok(NULL, " \n"); + } + + /* Return whether we got what we expected. */ + return ((rsa_key_exchange_count == expected->rsa_key_exchange_count) && + (master_secret_count == expected->master_secret_count) && + (client_handshake_secret_count == expected->client_handshake_secret_count) && + (server_handshake_secret_count == expected->server_handshake_secret_count) && + (client_application_secret_count == expected->client_application_secret_count) && + (server_application_secret_count == expected->server_application_secret_count)); +} + +static int test_keylog(void) { + SSL_CTX *cctx = NULL, *sctx = NULL; + SSL *clientssl = NULL, *serverssl = NULL; + int testresult = 0; + int rc; + struct sslapitest_log_counts expected = {0}; + + /* Clean up logging space */ + memset(client_log_buffer, 0, LOG_BUFFER_SIZE + 1); + memset(server_log_buffer, 0, LOG_BUFFER_SIZE + 1); + client_log_buffer_index = 0; + server_log_buffer_index = 0; + error_writing_log = 0; + + if (!create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(), &sctx, + &cctx, cert, privkey)) { + printf("Unable to create SSL_CTX pair\n"); + return 0; + } + + /* We cannot log the master secret for TLSv1.3, so we should forbid it. */ + SSL_CTX_set_options(cctx, SSL_OP_NO_TLSv1_3); + SSL_CTX_set_options(sctx, SSL_OP_NO_TLSv1_3); + + /* We also want to ensure that we use RSA-based key exchange. */ + rc = SSL_CTX_set_cipher_list(cctx, "RSA"); + if (rc == 0) { + printf("Unable to restrict to RSA key exchange.\n"); + goto end; + } + + if (SSL_CTX_get_keylog_callback(cctx)) { + printf("Unexpected initial value for client " + "SSL_CTX_get_keylog_callback()\n"); + goto end; + } + if (SSL_CTX_get_keylog_callback(sctx)) { + printf("Unexpected initial value for server " + "SSL_CTX_get_keylog_callback()\n"); + goto end; + } + + SSL_CTX_set_keylog_callback(cctx, client_keylog_callback); + SSL_CTX_set_keylog_callback(sctx, server_keylog_callback); + + if (SSL_CTX_get_keylog_callback(cctx) != client_keylog_callback) { + printf("Unexpected set value for client " + "SSL_CTX_get_keylog_callback()\n"); + } + + if (SSL_CTX_get_keylog_callback(sctx) != server_keylog_callback) { + printf("Unexpected set value for server " + "SSL_CTX_get_keylog_callback()\n"); + } + + /* Now do a handshake and check that the logs have been written to. */ + if (!create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL, NULL)) { + printf("Unable to create SSL objects\n"); + goto end; + } + + if (!create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)) { + printf("Unable to create SSL connection\n"); + goto end; + } + + if (error_writing_log) { + printf("Error encountered while logging\n"); + goto end; + } + + if ((client_log_buffer_index == 0) || (server_log_buffer_index == 0)) { + printf("No logs written\n"); + goto end; + } + + /* + * Now we want to test that our output data was vaguely sensible. We + * do that by using strtok and confirming that we have more or less the + * data we expect. For both client and server, we expect to see one master + * secret. The client should also see a RSA key exchange. + */ + expected.rsa_key_exchange_count = 1; + expected.master_secret_count = 1; + if (!test_keylog_output(client_log_buffer, clientssl, + SSL_get_session(clientssl), &expected)) { + printf("Error encountered in client log buffer\n"); + goto end; + } + + expected.rsa_key_exchange_count = 0; + if (!test_keylog_output(server_log_buffer, serverssl, + SSL_get_session(serverssl), &expected)) { + printf("Error encountered in server log buffer\n"); + goto end; + } + + testresult = 1; + +end: + SSL_free(serverssl); + SSL_free(clientssl); + SSL_CTX_free(sctx); + SSL_CTX_free(cctx); + + return testresult; +} + +#ifndef OPENSSL_NO_TLS1_3 +static int test_keylog_no_master_key(void) { + SSL_CTX *cctx = NULL, *sctx = NULL; + SSL *clientssl = NULL, *serverssl = NULL; + int testresult = 0; + struct sslapitest_log_counts expected = {0}; + + /* Clean up logging space */ + memset(client_log_buffer, 0, LOG_BUFFER_SIZE + 1); + memset(server_log_buffer, 0, LOG_BUFFER_SIZE + 1); + client_log_buffer_index = 0; + server_log_buffer_index = 0; + error_writing_log = 0; + + if (!create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(), &sctx, + &cctx, cert, privkey)) { + printf("Unable to create SSL_CTX pair\n"); + return 0; + } + + if (SSL_CTX_get_keylog_callback(cctx)) { + printf("Unexpected initial value for client " + "SSL_CTX_get_keylog_callback()\n"); + goto end; + } + if (SSL_CTX_get_keylog_callback(sctx)) { + printf("Unexpected initial value for server " + "SSL_CTX_get_keylog_callback()\n"); + goto end; + } + + SSL_CTX_set_keylog_callback(cctx, client_keylog_callback); + SSL_CTX_set_keylog_callback(sctx, server_keylog_callback); + + if (SSL_CTX_get_keylog_callback(cctx) != client_keylog_callback) { + printf("Unexpected set value for client " + "SSL_CTX_get_keylog_callback()\n"); + } + + if (SSL_CTX_get_keylog_callback(sctx) != server_keylog_callback) { + printf("Unexpected set value for server " + "SSL_CTX_get_keylog_callback()\n"); + } + + /* Now do a handshake and check that the logs have been written to. */ + if (!create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL, NULL)) { + printf("Unable to create SSL objects\n"); + goto end; + } + + if (!create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)) { + printf("Unable to create SSL connection\n"); + goto end; + } + + if (error_writing_log) { + printf("Error encountered while logging\n"); + goto end; + } + + /* + * Now we want to test that our output data was vaguely sensible. For this + * test, we expect no CLIENT_RANDOM entry because it doesn't make sense for + * TLSv1.3, but we do expect both client and server to emit keys. + */ + expected.client_handshake_secret_count = 1; + expected.server_handshake_secret_count = 1; + expected.client_application_secret_count = 1; + expected.server_application_secret_count = 1; + if (!test_keylog_output(client_log_buffer, clientssl, + SSL_get_session(clientssl), &expected)) { + printf("Error encountered in client log buffer\n"); + goto end; + } + if (!test_keylog_output(server_log_buffer, serverssl, + SSL_get_session(serverssl), &expected)) { + printf("Error encountered in server log buffer\n"); + goto end; + } + + testresult = 1; + +end: + SSL_free(serverssl); + SSL_free(clientssl); + SSL_CTX_free(sctx); + SSL_CTX_free(cctx); + + return testresult; +} +#endif + +#ifndef OPENSSL_NO_TLS1_2 +static int full_early_callback(SSL *s, int *al, void *arg) +{ + int *ctr = arg; + const unsigned char *p; + /* We only configure two ciphers, but the SCSV is added automatically. */ +#ifdef OPENSSL_NO_EC + const unsigned char expected_ciphers[] = {0x00, 0x9d, 0x00, 0xff}; +#else + const unsigned char expected_ciphers[] = {0x00, 0x9d, 0xc0, + 0x2c, 0x00, 0xff}; +#endif + size_t len; + + /* Make sure we can defer processing and get called back. */ + if ((*ctr)++ == 0) + return -1; + + len = SSL_early_get0_ciphers(s, &p); + if (len != sizeof(expected_ciphers) || + memcmp(p, expected_ciphers, len) != 0) { + printf("Early callback expected ciphers mismatch\n"); + return 0; + } + len = SSL_early_get0_compression_methods(s, &p); + if (len != 1 || *p != 0) { + printf("Early callback expected compression methods mismatch\n"); + return 0; + } + return 1; +} + +static int test_early_cb(void) { + SSL_CTX *cctx = NULL, *sctx = NULL; + SSL *clientssl = NULL, *serverssl = NULL; + int testctr = 0, testresult = 0; + + if (!create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(), &sctx, + &cctx, cert, privkey)) { + printf("Unable to create SSL_CTX pair\n"); + goto end; + } + + SSL_CTX_set_early_cb(sctx, full_early_callback, &testctr); + /* The gimpy cipher list we configure can't do TLS 1.3. */ + SSL_CTX_set_max_proto_version(cctx, TLS1_2_VERSION); + if (!SSL_CTX_set_cipher_list(cctx, + "AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384")) { + printf("Failed to set cipher list\n"); + goto end; + } + + if (!create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL, NULL)) { + printf("Unable to create SSL objects\n"); + goto end; + } + + if (create_ssl_connection(serverssl, clientssl, SSL_ERROR_WANT_EARLY)) { + printf("Creating SSL connection succeeded with async early return\n"); + goto end; + } + + /* Passing a -1 literal is a hack since the real value was lost. */ + if (SSL_get_error(serverssl, -1) != SSL_ERROR_WANT_EARLY) { + printf("Early callback failed to make state SSL_ERROR_WANT_EARLY\n"); + goto end; + } + + if (!create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)) { + printf("Restarting SSL connection failed\n"); + goto end; + } + + testresult = 1; + +end: + SSL_free(serverssl); + SSL_free(clientssl); + SSL_CTX_free(sctx); + SSL_CTX_free(cctx); + + return testresult; +} +#endif + static int execute_test_large_message(const SSL_METHOD *smeth, const SSL_METHOD *cmeth, int read_ahead) { @@ -43,7 +573,7 @@ static int execute_test_large_message(const SSL_METHOD *smeth, int certlen; if (certbio == NULL) { - printf("Can't load the certficate file\n"); + printf("Can't load the certificate file\n"); goto end; } chaincert = PEM_read_bio_X509(certbio, NULL, NULL, NULL); @@ -72,7 +602,7 @@ static int execute_test_large_message(const SSL_METHOD *smeth, * We assume the supplied certificate is big enough so that if we add * NUM_EXTRA_CERTS it will make the overall message large enough. The * default buffer size is requested to be 16k, but due to the way BUF_MEM - * works, it ends up allocing a little over 21k (16 * 4/3). So, in this test + * works, it ends up allocating a little over 21k (16 * 4/3). So, in this test * we need to have a message larger than that. */ certlen = i2d_X509(chaincert, NULL); @@ -95,13 +625,21 @@ static int execute_test_large_message(const SSL_METHOD *smeth, goto end; } - if (!create_ssl_connection(serverssl, clientssl)) { + if (!create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)) { printf("Unable to create SSL connection\n"); goto end; } - testresult = 1; + /* + * Calling SSL_clear() first is not required but this tests that SSL_clear() + * doesn't leak (when using enable-crypto-mdebug). + */ + if (!SSL_clear(serverssl)) { + printf("Unexpected failure from SSL_clear()\n"); + goto end; + } + testresult = 1; end: X509_free(chaincert); SSL_free(serverssl); @@ -136,6 +674,7 @@ static int test_large_message_dtls(void) } #endif +#ifndef OPENSSL_NO_OCSP static int ocsp_server_cb(SSL *s, void *arg) { int *argi = (int *)arg; @@ -264,7 +803,7 @@ static int test_tlsext_status_type(void) goto end; } - if (!create_ssl_connection(serverssl, clientssl)) { + if (!create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)) { printf("Unable to create SSL connection\n"); goto end; } @@ -290,7 +829,7 @@ static int test_tlsext_status_type(void) } /* This should fail because the callback will fail */ - if (create_ssl_connection(serverssl, clientssl)) { + if (create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)) { printf("Unexpected success creating the connection\n"); goto end; } @@ -320,11 +859,11 @@ static int test_tlsext_status_type(void) /* * We'll just use any old cert for this test - it doesn't have to be an OCSP - * specifc one. We'll use the server cert. + * specific one. We'll use the server cert. */ certbio = BIO_new_file(cert, "r"); if (certbio == NULL) { - printf("Can't load the certficate file\n"); + printf("Can't load the certificate file\n"); goto end; } id = OCSP_RESPID_new(); @@ -344,7 +883,7 @@ static int test_tlsext_status_type(void) BIO_free(certbio); certbio = NULL; - if (!create_ssl_connection(serverssl, clientssl)) { + if (!create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)) { printf("Unable to create SSL connection\n"); goto end; } @@ -369,6 +908,7 @@ static int test_tlsext_status_type(void) return testresult; } +#endif typedef struct ssl_session_test_fixture { const char *test_case_name; @@ -450,7 +990,7 @@ static int execute_test_session(SSL_SESSION_TEST_FIXTURE fix) goto end; } - if (!create_ssl_connection(serverssl1, clientssl1)) { + if (!create_ssl_connection(serverssl1, clientssl1, SSL_ERROR_NONE)) { printf("Unable to create SSL connection\n"); goto end; } @@ -476,7 +1016,7 @@ static int execute_test_session(SSL_SESSION_TEST_FIXTURE fix) goto end; } - if (!create_ssl_connection(serverssl2, clientssl2)) { + if (!create_ssl_connection(serverssl2, clientssl2, SSL_ERROR_NONE)) { printf("Unable to create second SSL connection\n"); goto end; } @@ -559,7 +1099,7 @@ static int execute_test_session(SSL_SESSION_TEST_FIXTURE fix) } /* This should fail because of the mismatched protocol versions */ - if (create_ssl_connection(serverssl3, clientssl3)) { + if (create_ssl_connection(serverssl3, clientssl3, SSL_ERROR_NONE)) { printf("Unable to create third SSL connection\n"); goto end; } @@ -705,7 +1245,7 @@ static int test_ssl_set_bio(int idx) /* * We want to maintain our own refs to these BIO, so do an up ref for each - * BIO that will have ownersip transferred in the SSL_set_bio() call + * BIO that will have ownership transferred in the SSL_set_bio() call */ if (irbio != NULL) BIO_up_ref(irbio); @@ -801,7 +1341,7 @@ static int execute_test_ssl_bio(SSL_BIO_TEST_FIXTURE fix) */ BIO_push(sslbio, membio1); - /* Verify chaning the rbio/wbio directly does not cause leaks */ + /* Verify changing the rbio/wbio directly does not cause leaks */ if (fix.change_bio != NO_BIO_CHANGE) { membio2 = BIO_new(BIO_s_mem()); if (membio2 == NULL) { @@ -864,32 +1404,1208 @@ static int test_ssl_bio_change_wbio(void) EXECUTE_TEST(execute_test_ssl_bio, ssl_bio_tear_down); } -int test_main(int argc, char *argv[]) +typedef struct { + /* The list of sig algs */ + const int *list; + /* The length of the list */ + size_t listlen; + /* A sigalgs list in string format */ + const char *liststr; + /* Whether setting the list should succeed */ + int valid; + /* Whether creating a connection with the list should succeed */ + int connsuccess; +} sigalgs_list; + +static const int validlist1[] = {NID_sha256, EVP_PKEY_RSA}; +#ifndef OPENSSL_NO_EC +static const int validlist2[] = {NID_sha256, EVP_PKEY_RSA, NID_sha512, EVP_PKEY_EC}; +static const int validlist3[] = {NID_sha512, EVP_PKEY_EC}; +#endif +static const int invalidlist1[] = {NID_undef, EVP_PKEY_RSA}; +static const int invalidlist2[] = {NID_sha256, NID_undef}; +static const int invalidlist3[] = {NID_sha256, EVP_PKEY_RSA, NID_sha256}; +static const int invalidlist4[] = {NID_sha256}; +static const sigalgs_list testsigalgs[] = { + {validlist1, OSSL_NELEM(validlist1), NULL, 1, 1}, +#ifndef OPENSSL_NO_EC + {validlist2, OSSL_NELEM(validlist2), NULL, 1, 1}, + {validlist3, OSSL_NELEM(validlist3), NULL, 1, 0}, +#endif + {NULL, 0, "RSA+SHA256", 1, 1}, +#ifndef OPENSSL_NO_EC + {NULL, 0, "RSA+SHA256:ECDSA+SHA512", 1, 1}, + {NULL, 0, "ECDSA+SHA512", 1, 0}, +#endif + {invalidlist1, OSSL_NELEM(invalidlist1), NULL, 0, 0}, + {invalidlist2, OSSL_NELEM(invalidlist2), NULL, 0, 0}, + {invalidlist3, OSSL_NELEM(invalidlist3), NULL, 0, 0}, + {invalidlist4, OSSL_NELEM(invalidlist4), NULL, 0, 0}, + {NULL, 0, "RSA", 0, 0}, + {NULL, 0, "SHA256", 0, 0}, + {NULL, 0, "RSA+SHA256:SHA256", 0, 0}, + {NULL, 0, "Invalid", 0, 0}}; + +static int test_set_sigalgs(int idx) { - int testresult = 1; + SSL_CTX *cctx = NULL, *sctx = NULL; + SSL *clientssl = NULL, *serverssl = NULL; + int testresult = 0; + const sigalgs_list *curr; + int testctx; - if (argc != 3) { - printf("Invalid argument count\n"); - return 1; + /* Should never happen */ + if ((size_t)idx >= OSSL_NELEM(testsigalgs) * 2) + return 0; + + testctx = ((size_t)idx < OSSL_NELEM(testsigalgs)); + curr = testctx ? &testsigalgs[idx] + : &testsigalgs[idx - OSSL_NELEM(testsigalgs)]; + + if (!create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(), &sctx, + &cctx, cert, privkey)) { + printf("Unable to create SSL_CTX pair\n"); + return 0; } - cert = argv[1]; - privkey = argv[2]; + /* + * TODO(TLS1.3): These APIs cannot set TLSv1.3 sig algs so we just test it + * for TLSv1.2 for now until we add a new API. + */ + SSL_CTX_set_max_proto_version(cctx, TLS1_2_VERSION); - ADD_TEST(test_large_message_tls); - ADD_TEST(test_large_message_tls_read_ahead); -#ifndef OPENSSL_NO_DTLS - ADD_TEST(test_large_message_dtls); -#endif - ADD_TEST(test_tlsext_status_type); - ADD_TEST(test_session_with_only_int_cache); - ADD_TEST(test_session_with_only_ext_cache); - ADD_TEST(test_session_with_both_cache); - ADD_ALL_TESTS(test_ssl_set_bio, TOTAL_SSL_SET_BIO_TESTS); - ADD_TEST(test_ssl_bio_pop_next_bio); - ADD_TEST(test_ssl_bio_pop_ssl_bio); - ADD_TEST(test_ssl_bio_change_rbio); - ADD_TEST(test_ssl_bio_change_wbio); + if (testctx) { + int ret; + if (curr->list != NULL) + ret = SSL_CTX_set1_sigalgs(cctx, curr->list, curr->listlen); + else + ret = SSL_CTX_set1_sigalgs_list(cctx, curr->liststr); + + if (!ret) { + if (curr->valid) + printf("Unexpected failure setting sigalgs in SSL_CTX (%d)\n", + idx); + else + testresult = 1; + goto end; + } + if (!curr->valid) { + printf("Unexpected success setting sigalgs in SSL_CTX (%d)\n", idx); + goto end; + } + } + + if (!create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL, NULL)) { + printf("Unable to create SSL objects\n"); + goto end; + } + + if (!testctx) { + int ret; + + if (curr->list != NULL) + ret = SSL_set1_sigalgs(clientssl, curr->list, curr->listlen); + else + ret = SSL_set1_sigalgs_list(clientssl, curr->liststr); + if (!ret) { + if (curr->valid) + printf("Unexpected failure setting sigalgs in SSL (%d)\n", idx); + else + testresult = 1; + goto end; + } + if (!curr->valid) { + printf("Unexpected success setting sigalgs in SSL (%d)\n", idx); + goto end; + } + } + + if (curr->connsuccess != create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)) { + printf("Unexpected return value creating SSL connection (%d)\n", idx); + goto end; + } + + testresult = 1; + + end: + SSL_free(serverssl); + SSL_free(clientssl); + SSL_CTX_free(sctx); + SSL_CTX_free(cctx); + + return testresult; +} + +#ifndef OPENSSL_NO_TLS1_3 + +#define MSG1 "Hello" +#define MSG2 "World." +#define MSG3 "This" +#define MSG4 "is" +#define MSG5 "a" +#define MSG6 "test" +#define MSG7 "message." + +/* + * Helper method to setup objects for early data test. Caller frees objects on + * error. + */ +static int setupearly_data_test(SSL_CTX **cctx, SSL_CTX **sctx, SSL **clientssl, + SSL **serverssl, SSL_SESSION **sess, int idx) +{ + if (!create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(), sctx, + cctx, cert, privkey)) { + printf("Unable to create SSL_CTX pair\n"); + return 0; + } + + /* When idx == 1 we repeat the tests with read_ahead set */ + if (idx > 0) { + SSL_CTX_set_read_ahead(*cctx, 1); + SSL_CTX_set_read_ahead(*sctx, 1); + } + + if (!create_ssl_objects(*sctx, *cctx, serverssl, clientssl, NULL, NULL)) { + printf("Unable to create SSL objects\n"); + return 0; + } + + if (!create_ssl_connection(*serverssl, *clientssl, SSL_ERROR_NONE)) { + printf("Unable to create SSL connection\n"); + return 0; + } + + *sess = SSL_get1_session(*clientssl); + + SSL_shutdown(*clientssl); + SSL_shutdown(*serverssl); + + SSL_free(*serverssl); + SSL_free(*clientssl); + *serverssl = *clientssl = NULL; + + if (!create_ssl_objects(*sctx, *cctx, serverssl, clientssl, NULL, NULL)) { + printf("Unable to create SSL objects (2)\n"); + return 0; + } + + if (!SSL_set_session(*clientssl, *sess)) { + printf("Failed setting session\n"); + return 0; + } + + return 1; +} + +static int test_early_data_read_write(int idx) +{ + SSL_CTX *cctx = NULL, *sctx = NULL; + SSL *clientssl = NULL, *serverssl = NULL; + int testresult = 0; + SSL_SESSION *sess = NULL; + unsigned char buf[20], data[1024]; + size_t readbytes, written, eoedlen, rawread, rawwritten; + BIO *rbio; + + if (!setupearly_data_test(&cctx, &sctx, &clientssl, &serverssl, &sess, idx)) + goto end; + + /* Write and read some early data */ + if (!SSL_write_early_data(clientssl, MSG1, strlen(MSG1), &written) + || written != strlen(MSG1)) { + printf("Failed writing early data message 1\n"); + goto end; + } + + if (SSL_read_early_data(serverssl, buf, sizeof(buf), &readbytes) + != SSL_READ_EARLY_DATA_SUCCESS + || readbytes != strlen(MSG1) + || memcmp(MSG1, buf, strlen(MSG1))) { + printf("Failed reading early data message 1\n"); + goto end; + } + + if (SSL_get_early_data_status(serverssl) != SSL_EARLY_DATA_ACCEPTED) { + printf("Unexpected early data status\n"); + goto end; + } + + /* + * Server should be able to write data, and client should be able to + * read it. + */ + if (!SSL_write_early_data(serverssl, MSG2, strlen(MSG2), &written) + || written != strlen(MSG2)) { + printf("Failed writing message 2\n"); + goto end; + } + + if (!SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes) + || readbytes != strlen(MSG2) + || memcmp(MSG2, buf, strlen(MSG2))) { + printf("Failed reading message 2\n"); + goto end; + } + + /* Even after reading normal data, client should be able write early data */ + if (!SSL_write_early_data(clientssl, MSG3, strlen(MSG3), &written) + || written != strlen(MSG3)) { + printf("Failed writing early data message 3\n"); + goto end; + } + + /* Server should still be able read early data after writing data */ + if (SSL_read_early_data(serverssl, buf, sizeof(buf), &readbytes) + != SSL_READ_EARLY_DATA_SUCCESS + || readbytes != strlen(MSG3) + || memcmp(MSG3, buf, strlen(MSG3))) { + printf("Failed reading early data message 3\n"); + goto end; + } + + /* Write more data from server and read it from client */ + if (!SSL_write_early_data(serverssl, MSG4, strlen(MSG4), &written) + || written != strlen(MSG4)) { + printf("Failed writing message 4\n"); + goto end; + } + + if (!SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes) + || readbytes != strlen(MSG4) + || memcmp(MSG4, buf, strlen(MSG4))) { + printf("Failed reading message 4\n"); + goto end; + } + + /* + * If client writes normal data it should mean writing early data is no + * longer possible. + */ + if (!SSL_write_ex(clientssl, MSG5, strlen(MSG5), &written) + || written != strlen(MSG5)) { + printf("Failed writing message 5\n"); + goto end; + } + + if (SSL_get_early_data_status(clientssl) != SSL_EARLY_DATA_ACCEPTED) { + printf("Unexpected early data status(2)\n"); + goto end; + } + + /* + * At this point the client has written EndOfEarlyData, ClientFinished and + * normal (fully protected) data. We are going to cause a delay between the + * arrival of EndOfEarlyData and ClientFinished. We read out all the data + * in the read BIO, and then just put back the EndOfEarlyData message. + */ + rbio = SSL_get_rbio(serverssl); + if (!BIO_read_ex(rbio, data, sizeof(data), &rawread) + || rawread >= sizeof(data) + || rawread < SSL3_RT_HEADER_LENGTH) { + printf("Failed reading data from rbio\n"); + goto end; + } + /* Record length is in the 4th and 5th bytes of the record header */ + eoedlen = SSL3_RT_HEADER_LENGTH + (data[3] << 8 | data[4]); + if (!BIO_write_ex(rbio, data, eoedlen, &rawwritten) + || rawwritten != eoedlen) { + printf("Failed to write the EndOfEarlyData message to server rbio\n"); + goto end; + } + + /* Server should be told that there is no more early data */ + if (SSL_read_early_data(serverssl, buf, sizeof(buf), &readbytes) + != SSL_READ_EARLY_DATA_FINISH + || readbytes != 0) { + printf("Failed finishing read of early data\n"); + goto end; + } + + /* + * Server has not finished init yet, so should still be able to write early + * data. + */ + if (!SSL_write_early_data(serverssl, MSG6, strlen(MSG6), &written) + || written != strlen(MSG6)) { + printf("Failed writing early data message 6\n"); + goto end; + } + + /* Push the ClientFinished and the normal data back into the server rbio */ + if (!BIO_write_ex(rbio, data + eoedlen, rawread - eoedlen, &rawwritten) + || rawwritten != rawread - eoedlen) { + printf("Failed to write the ClientFinished and data to server rbio\n"); + goto end; + } + + /* Server should be able to read normal data */ + if (!SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes) + || readbytes != strlen(MSG5)) { + printf("Failed reading message 5\n"); + goto end; + } + + /* Client and server should not be able to write/read early data now */ + if (SSL_write_early_data(clientssl, MSG6, strlen(MSG6), &written)) { + printf("Unexpected success writing early data\n"); + goto end; + } + ERR_clear_error(); + + if (SSL_read_early_data(serverssl, buf, sizeof(buf), &readbytes) + != SSL_READ_EARLY_DATA_ERROR) { + printf("Unexpected success reading early data\n"); + goto end; + } + ERR_clear_error(); + + /* Client should be able to read the data sent by the server */ + if (!SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes) + || readbytes != strlen(MSG6) + || memcmp(MSG6, buf, strlen(MSG6))) { + printf("Failed reading message 6\n"); + goto end; + } + /* + * Make sure we process the NewSessionTicket. This arrives post-handshake. + * We attempt a read which we do not expect to return any data. + */ + if (SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes)) { + printf("Unexpected success doing final client read\n"); + goto end; + } + + /* Server should be able to write normal data */ + if (!SSL_write_ex(serverssl, MSG7, strlen(MSG7), &written) + || written != strlen(MSG7)) { + printf("Failed writing normal data message 7\n"); + goto end; + } + if (!SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes) + || readbytes != strlen(MSG7) + || memcmp(MSG7, buf, strlen(MSG7))) { + printf("Failed reading message 7\n"); + goto end; + } + + SSL_SESSION_free(sess); + sess = SSL_get1_session(clientssl); + + SSL_shutdown(clientssl); + SSL_shutdown(serverssl); + + SSL_free(serverssl); + SSL_free(clientssl); + serverssl = clientssl = NULL; + + if (!create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL, NULL)) { + printf("Unable to create SSL objects (3)\n"); + goto end; + } + + if (!SSL_set_session(clientssl, sess)) { + printf("Failed setting session (2)\n"); + goto end; + } + + /* Write and read some early data */ + if (!SSL_write_early_data(clientssl, MSG1, strlen(MSG1), &written) + || written != strlen(MSG1)) { + printf("Failed writing early data message 1\n"); + goto end; + } + + if (SSL_read_early_data(serverssl, buf, sizeof(buf), &readbytes) + != SSL_READ_EARLY_DATA_SUCCESS + || readbytes != strlen(MSG1) + || memcmp(MSG1, buf, strlen(MSG1))) { + printf("Failed reading early data message 1\n"); + goto end; + } + + if (SSL_connect(clientssl) <= 0) { + printf("Unable to complete client handshake\n"); + goto end; + } + + if (SSL_accept(serverssl) <= 0) { + printf("Unable to complete server handshake\n"); + goto end; + } + + /* Client and server should not be able to write/read early data now */ + if (SSL_write_early_data(clientssl, MSG6, strlen(MSG6), &written)) { + printf("Unexpected success writing early data (2)\n"); + goto end; + } + ERR_clear_error(); + + if (SSL_read_early_data(serverssl, buf, sizeof(buf), &readbytes) + != SSL_READ_EARLY_DATA_ERROR) { + printf("Unexpected success reading early data (2)\n"); + goto end; + } + ERR_clear_error(); + + /* Client and server should be able to write/read normal data */ + if (!SSL_write_ex(clientssl, MSG5, strlen(MSG5), &written) + || written != strlen(MSG5)) { + printf("Failed writing message 5 (2)\n"); + goto end; + } + + if (!SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes) + || readbytes != strlen(MSG5)) { + printf("Failed reading message 5 (2)\n"); + goto end; + } + + testresult = 1; + + end: + if(!testresult) + ERR_print_errors_fp(stdout); + SSL_SESSION_free(sess); + SSL_free(serverssl); + SSL_free(clientssl); + SSL_CTX_free(sctx); + SSL_CTX_free(cctx); + + return testresult; +} + +static int test_early_data_skip(int idx) +{ + SSL_CTX *cctx = NULL, *sctx = NULL; + SSL *clientssl = NULL, *serverssl = NULL; + int testresult = 0; + SSL_SESSION *sess; + unsigned char buf[20]; + size_t readbytes, written; + + /* + * Test that a server attempting to read early data can handle a connection + * from a client where the early data is not acceptable. + */ + + if (!setupearly_data_test(&cctx, &sctx, &clientssl, &serverssl, &sess, idx)) + goto end; + + /* + * Deliberately corrupt the creation time. We take 20 seconds off the time. + * It could be any value as long as it is not within tolerance. This should + * mean the ticket is rejected. + */ + if (!SSL_SESSION_set_time(sess, time(NULL) - 20)) { + printf("Unexpected failure setting session creation time\n"); + goto end; + } + + /* Write some early data */ + if (!SSL_write_early_data(clientssl, MSG1, strlen(MSG1), &written) + || written != strlen(MSG1)) { + printf("Failed writing early data message 1\n"); + goto end; + } + + /* Server should reject the early data and skip over it */ + if (SSL_read_early_data(serverssl, buf, sizeof(buf), &readbytes) + != SSL_READ_EARLY_DATA_FINISH + || readbytes != 0) { + printf("Failed reading early data\n"); + goto end; + } + + if (SSL_get_early_data_status(serverssl) != SSL_EARLY_DATA_REJECTED) { + printf("Unexpected early data status\n"); + goto end; + } + + /* + * We should be able to send normal data despite rejection of early data + */ + if (!SSL_write_ex(clientssl, MSG2, strlen(MSG2), &written) + || written != strlen(MSG2)) { + printf("Failed writing message 2\n"); + goto end; + } + + if (SSL_get_early_data_status(clientssl) != SSL_EARLY_DATA_REJECTED) { + printf("Unexpected early data status (2)\n"); + goto end; + } + + if (!SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes) + || readbytes != strlen(MSG2) + || memcmp(MSG2, buf, strlen(MSG2))) { + printf("Failed reading message 2\n"); + goto end; + } + + testresult = 1; + + end: + if(!testresult) + ERR_print_errors_fp(stdout); + SSL_SESSION_free(sess); + SSL_free(serverssl); + SSL_free(clientssl); + SSL_CTX_free(sctx); + SSL_CTX_free(cctx); + + return testresult; +} + +static int test_early_data_not_sent(int idx) +{ + SSL_CTX *cctx = NULL, *sctx = NULL; + SSL *clientssl = NULL, *serverssl = NULL; + int testresult = 0; + SSL_SESSION *sess; + unsigned char buf[20]; + size_t readbytes, written; + + /* + * Test that a server attempting to read early data can handle a connection + * from a client that doesn't send any. + */ + + if (!setupearly_data_test(&cctx, &sctx, &clientssl, &serverssl, &sess, idx)) + goto end; + + /* Write some data - should block due to handshake with server */ + SSL_set_connect_state(clientssl); + if (SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written)) { + printf("Unexpected success writing message 1\n"); + goto end; + } + + /* Server should detect that early data has not been sent */ + if (SSL_read_early_data(serverssl, buf, sizeof(buf), &readbytes) + != SSL_READ_EARLY_DATA_FINISH + || readbytes != 0) { + printf("Failed reading early data\n"); + goto end; + } + + if (SSL_get_early_data_status(serverssl) != SSL_EARLY_DATA_NOT_SENT) { + printf("Unexpected early data status\n"); + goto end; + } + + if (SSL_get_early_data_status(clientssl) != SSL_EARLY_DATA_NOT_SENT) { + printf("Unexpected early data status (2)\n"); + goto end; + } + + /* Continue writing the message we started earlier */ + if (!SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written) + || written != strlen(MSG1)) { + printf("Failed writing message 1\n"); + goto end; + } + + if (!SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes) + || readbytes != strlen(MSG1) + || memcmp(MSG1, buf, strlen(MSG1))) { + printf("Failed reading message 1\n"); + goto end; + } + + if (!SSL_write_ex(serverssl, MSG2, strlen(MSG2), &written) + || written != strlen(MSG2)) { + printf("Failed writing message 2\n"); + goto end; + } + + /* + * Should block due to the NewSessionTicket arrival unless we're using + * read_ahead + */ + if (idx == 0) { + if (SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes)) { + printf("Unexpected success reading message 2\n"); + goto end; + } + } + + if (!SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes) + || readbytes != strlen(MSG2) + || memcmp(MSG2, buf, strlen(MSG2))) { + printf("Failed reading message 2\n"); + goto end; + } + + testresult = 1; + + end: + if(!testresult) + ERR_print_errors_fp(stdout); + SSL_SESSION_free(sess); + SSL_free(serverssl); + SSL_free(clientssl); + SSL_CTX_free(sctx); + SSL_CTX_free(cctx); + + return testresult; +} + +static int test_early_data_not_expected(int idx) +{ + SSL_CTX *cctx = NULL, *sctx = NULL; + SSL *clientssl = NULL, *serverssl = NULL; + int testresult = 0; + SSL_SESSION *sess; + unsigned char buf[20]; + size_t readbytes, written; + + /* + * Test that a server that doesn't try to read early data can handle a + * client sending some. + */ + + if (!setupearly_data_test(&cctx, &sctx, &clientssl, &serverssl, &sess, idx)) + goto end; + + /* Write some early data */ + if (!SSL_write_early_data(clientssl, MSG1, strlen(MSG1), &written)) { + printf("Unexpected failure writing message 1\n"); + goto end; + } + + /* + * Server should skip over early data and then block waiting for client to + * continue handshake + */ + if (SSL_accept(serverssl) > 0) { + printf("Unexpected success setting up server connection\n"); + goto end; + } + + if (SSL_connect(clientssl) <= 0) { + printf("Failed setting up client connection\n"); + goto end; + } + + if (SSL_get_early_data_status(serverssl) != SSL_EARLY_DATA_REJECTED) { + printf("Unexpected early data status\n"); + goto end; + } + + if (SSL_accept(serverssl) <= 0) { + printf("Failed setting up server connection\n"); + goto end; + } + + if (SSL_get_early_data_status(clientssl) != SSL_EARLY_DATA_REJECTED) { + printf("Unexpected early data status (2)\n"); + goto end; + } + + /* Send some normal data from client to server */ + if (!SSL_write_ex(clientssl, MSG2, strlen(MSG2), &written) + || written != strlen(MSG2)) { + printf("Failed writing message 2\n"); + goto end; + } + + if (!SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes) + || readbytes != strlen(MSG2) + || memcmp(MSG2, buf, strlen(MSG2))) { + printf("Failed reading message 2\n"); + goto end; + } + + testresult = 1; + + end: + if(!testresult) + ERR_print_errors_fp(stdout); + SSL_SESSION_free(sess); + SSL_free(serverssl); + SSL_free(clientssl); + SSL_CTX_free(sctx); + SSL_CTX_free(cctx); + + return testresult; +} + + +# ifndef OPENSSL_NO_TLS1_2 +static int test_early_data_tls1_2(int idx) +{ + SSL_CTX *cctx = NULL, *sctx = NULL; + SSL *clientssl = NULL, *serverssl = NULL; + int testresult = 0; + unsigned char buf[20]; + size_t readbytes, written; + + /* + * Test that a server attempting to read early data can handle a connection + * from a TLSv1.2 client. + */ + + if (!create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(), &sctx, + &cctx, cert, privkey)) { + printf("Unable to create SSL_CTX pair\n"); + goto end; + } + + /* When idx == 1 we repeat the tests with read_ahead set */ + if (idx > 0) { + SSL_CTX_set_read_ahead(cctx, 1); + SSL_CTX_set_read_ahead(sctx, 1); + } + + if (!create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL, NULL)) { + printf("Unable to create SSL objects\n"); + goto end; + } + + /* Write some data - should block due to handshake with server */ + SSL_set_max_proto_version(clientssl, TLS1_2_VERSION); + SSL_set_connect_state(clientssl); + if (SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written)) { + printf("Unexpected success writing message 1\n"); + goto end; + } + + /* + * Server should do TLSv1.2 handshake. First it will block waiting for more + * messages from client after ServerDone. Then SSL_read_early_data should + * finish and detect that early data has not been sent + */ + if (SSL_read_early_data(serverssl, buf, sizeof(buf), &readbytes) + != SSL_READ_EARLY_DATA_ERROR) { + printf("Unexpected success reading early data\n"); + goto end; + } + + /* + * Continue writing the message we started earlier. Will still block waiting + * for the CCS/Finished from server + */ + if (SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written)) { + printf("Unexpected success writing message 1\n"); + goto end; + } + + if (SSL_read_early_data(serverssl, buf, sizeof(buf), &readbytes) + != SSL_READ_EARLY_DATA_FINISH + || readbytes != 0) { + printf("Failed reading early data\n"); + goto end; + } + + if (SSL_get_early_data_status(serverssl) != SSL_EARLY_DATA_NOT_SENT) { + printf("Unexpected early data status\n"); + goto end; + } + + /* Continue writing the message we started earlier */ + if (!SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written) + || written != strlen(MSG1)) { + printf("Failed writing message 1\n"); + goto end; + } + + if (SSL_get_early_data_status(clientssl) != SSL_EARLY_DATA_NOT_SENT) { + printf("Unexpected early data status (2)\n"); + goto end; + } + + if (!SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes) + || readbytes != strlen(MSG1) + || memcmp(MSG1, buf, strlen(MSG1))) { + printf("Failed reading message 1\n"); + goto end; + } + + if (!SSL_write_ex(serverssl, MSG2, strlen(MSG2), &written) + || written != strlen(MSG2)) { + printf("Failed writing message 2\n"); + goto end; + } + + if (!SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes) + || readbytes != strlen(MSG2) + || memcmp(MSG2, buf, strlen(MSG2))) { + printf("Failed reading message 2\n"); + goto end; + } + + testresult = 1; + + end: + if(!testresult) + ERR_print_errors_fp(stdout); + SSL_free(serverssl); + SSL_free(clientssl); + SSL_CTX_free(sctx); + SSL_CTX_free(cctx); + + return testresult; +} +# endif +#endif + +static int clntaddoldcb = 0; +static int clntparseoldcb = 0; +static int srvaddoldcb = 0; +static int srvparseoldcb = 0; +static int clntaddnewcb = 0; +static int clntparsenewcb = 0; +static int srvaddnewcb = 0; +static int srvparsenewcb = 0; + +#define TEST_EXT_TYPE1 0xff00 + +static int old_add_cb(SSL *s, unsigned int ext_type, const unsigned char **out, + size_t *outlen, int *al, void *add_arg) +{ + int *server = (int *)add_arg; + unsigned char *data; + + if (SSL_is_server(s)) + srvaddoldcb++; + else + clntaddoldcb++; + + if (*server != SSL_is_server(s)) + return -1; + + data = OPENSSL_malloc(sizeof(char)); + if (data == NULL) + return -1; + + *data = 1; + *out = data; + *outlen = sizeof(char); + + return 1; +} + +static void old_free_cb(SSL *s, unsigned int ext_type, const unsigned char *out, + void *add_arg) +{ + OPENSSL_free((unsigned char *)out); +} + +static int old_parse_cb(SSL *s, unsigned int ext_type, const unsigned char *in, + size_t inlen, int *al, void *parse_arg) +{ + int *server = (int *)parse_arg; + + if (SSL_is_server(s)) + srvparseoldcb++; + else + clntparseoldcb++; + + if (*server != SSL_is_server(s)) + return -1; + + if (inlen != sizeof(char) || *in != 1) + return -1; + + return 1; +} + +static int new_add_cb(SSL *s, unsigned int ext_type, unsigned int context, + const unsigned char **out, size_t *outlen, X509 *x, + size_t chainidx, int *al, void *add_arg) +{ + int *server = (int *)add_arg; + unsigned char *data; + + if (SSL_is_server(s)) + srvaddnewcb++; + else + clntaddnewcb++; + + if (*server != SSL_is_server(s)) + return -1; + + data = OPENSSL_malloc(sizeof(char)); + if (data == NULL) + return -1; + + *data = 1; + *out = data; + *outlen = sizeof(char); + + return 1; +} + +static void new_free_cb(SSL *s, unsigned int ext_type, unsigned int context, + const unsigned char *out, void *add_arg) +{ + OPENSSL_free((unsigned char *)out); +} + +static int new_parse_cb(SSL *s, unsigned int ext_type, unsigned int context, + const unsigned char *in, size_t inlen, X509 *x, + size_t chainidx, int *al, void *parse_arg) +{ + int *server = (int *)parse_arg; + + if (SSL_is_server(s)) + srvparsenewcb++; + else + clntparsenewcb++; + + if (*server != SSL_is_server(s)) + return -1; + + if (inlen != sizeof(char) || *in != 1) + return -1; + + return 1; +} +/* + * Custom call back tests. + * Test 0: Old style callbacks in TLSv1.2 + * Test 1: New style callbacks in TLSv1.2 + * Test 2: New style callbacks in TLSv1.3. Extensions in CH and EE + * Test 3: New style callbacks in TLSv1.3. Extensions in CH, SH, EE, Cert + NST + */ +static int test_custom_exts(int tst) { + SSL_CTX *cctx = NULL, *sctx = NULL; + SSL *clientssl = NULL, *serverssl = NULL; + int testresult = 0; + static int server = 1; + static int client = 0; + SSL_SESSION *sess = NULL; + unsigned int context; + + /* Reset callback counters */ + clntaddoldcb = clntparseoldcb = srvaddoldcb = srvparseoldcb = 0; + clntaddnewcb = clntparsenewcb = srvaddnewcb = srvparsenewcb = 0; + + if (!create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(), &sctx, + &cctx, cert, privkey)) { + printf("Unable to create SSL_CTX pair\n"); + return 0; + } + + if (tst < 2) { + SSL_CTX_set_options(cctx, SSL_OP_NO_TLSv1_3); + SSL_CTX_set_options(sctx, SSL_OP_NO_TLSv1_3); + } + + if (tst == 3) { + context = SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO + | SSL_EXT_TLS1_3_SERVER_HELLO + | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS + | SSL_EXT_TLS1_3_CERTIFICATE + | SSL_EXT_TLS1_3_NEW_SESSION_TICKET; + } else { + context = SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO + | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS; + } + + /* Create a client side custom extension */ + if (tst == 0) { + if (!SSL_CTX_add_client_custom_ext(cctx, TEST_EXT_TYPE1, old_add_cb, + old_free_cb, &client, old_parse_cb, + &client)) { + printf("Unable to create old style client side custom extension\n"); + return 0; + } + } else { + if (!SSL_CTX_add_custom_ext(cctx, TEST_EXT_TYPE1, context, new_add_cb, + new_free_cb, &client, new_parse_cb, + &client)) { + printf("Unable to create new style client side custom extension\n"); + return 0; + } + } + + /* Should not be able to add duplicates */ + if (SSL_CTX_add_client_custom_ext(cctx, TEST_EXT_TYPE1, old_add_cb, + old_free_cb, &client, old_parse_cb, + &client)) { + printf("Unexpected success adding duplicate client custom extension\n"); + return 0; + } + if (SSL_CTX_add_custom_ext(cctx, TEST_EXT_TYPE1, context, new_add_cb, + new_free_cb, &client, new_parse_cb, &client)) { + printf("Unexpected success adding duplicate client custom extension\n"); + return 0; + } + + /* Create a server side custom extension */ + if (tst == 0) { + if (!SSL_CTX_add_server_custom_ext(sctx, TEST_EXT_TYPE1, old_add_cb, + old_free_cb, &server, old_parse_cb, + &server)) { + printf("Unable to create old style server side custom extension\n"); + return 0; + } + } else { + if (!SSL_CTX_add_custom_ext(sctx, TEST_EXT_TYPE1, context, new_add_cb, + new_free_cb, &server, new_parse_cb, + &server)) { + printf("Unable to create new style server side custom extension\n"); + return 0; + } + } + + /* Should not be able to add duplicates */ + if (SSL_CTX_add_server_custom_ext(sctx, TEST_EXT_TYPE1, old_add_cb, + old_free_cb, &server, old_parse_cb, + &server)) { + printf("Unexpected success adding duplicate server custom extension\n"); + return 0; + } + if (SSL_CTX_add_custom_ext(sctx, TEST_EXT_TYPE1, context, new_add_cb, + new_free_cb, &server, new_parse_cb, &server)) { + printf("Unexpected success adding duplicate server custom extension\n"); + return 0; + } + + if (!create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL, NULL)) { + printf("Unable to create SSL objects\n"); + goto end; + } + + if (!create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)) { + printf("Unable to create SSL connection\n"); + goto end; + } + + if (tst == 0) { + if (clntaddoldcb != 1 || clntparseoldcb != 1 || srvaddoldcb != 1 + || srvparseoldcb != 1) { + printf("Custom extension callbacks not called\n"); + goto end; + } + } else if (tst == 1 || tst == 2) { + if (clntaddnewcb != 1 || clntparsenewcb != 1 || srvaddnewcb != 1 + || srvparsenewcb != 1) { + printf("Custom extension callbacks not called\n"); + goto end; + } + } else { + if (clntaddnewcb != 1 || clntparsenewcb != 4 || srvaddnewcb != 4 + || srvparsenewcb != 1) { + printf("Custom extension callbacks not called\n"); + goto end; + } + } + + sess = SSL_get1_session(clientssl); + + SSL_shutdown(clientssl); + SSL_shutdown(serverssl); + + SSL_free(serverssl); + SSL_free(clientssl); + serverssl = clientssl = NULL; + + if (!create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL, NULL)) { + printf("Unable to create SSL objects (2)\n"); + goto end; + } + + if (!SSL_set_session(clientssl, sess)) { + printf("Failed setting session\n"); + goto end; + } + + if (!create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)) { + printf("Unable to create SSL connection (2)\n"); + goto end; + } + + /* + * For a resumed session we expect to add the ClientHello extension. For the + * old style callbacks we ignore it on the server side because they set + * SSL_EXT_IGNORE_ON_RESUMPTION. The new style callbacks do not ignore + * them. + */ + if (tst == 0) { + if (clntaddoldcb != 2 || clntparseoldcb != 1 || srvaddoldcb != 1 + || srvparseoldcb != 1) { + printf("Unexpected custom extension callback calls\n"); + goto end; + } + } else if (tst == 1 || tst == 2) { + if (clntaddnewcb != 2 || clntparsenewcb != 2 || srvaddnewcb != 2 + || srvparsenewcb != 2) { + printf("Unexpected custom extension callback calls\n"); + goto end; + } + } else { + /* No Certificate message extensions in the resumption handshake */ + if (clntaddnewcb != 2 || clntparsenewcb != 7 || srvaddnewcb != 7 + || srvparsenewcb != 2) { + printf("Unexpected custom extension callback calls\n"); + goto end; + } + } + + testresult = 1; + +end: + SSL_SESSION_free(sess); + SSL_free(serverssl); + SSL_free(clientssl); + SSL_CTX_free(sctx); + SSL_CTX_free(cctx); + + return testresult; +} + +int test_main(int argc, char *argv[]) +{ + int testresult = 1; + + if (argc != 3) { + printf("Invalid argument count\n"); + return 1; + } + + cert = argv[1]; + privkey = argv[2]; + + ADD_TEST(test_large_message_tls); + ADD_TEST(test_large_message_tls_read_ahead); +#ifndef OPENSSL_NO_DTLS + ADD_TEST(test_large_message_dtls); +#endif +#ifndef OPENSSL_NO_OCSP + ADD_TEST(test_tlsext_status_type); +#endif + ADD_TEST(test_session_with_only_int_cache); + ADD_TEST(test_session_with_only_ext_cache); + ADD_TEST(test_session_with_both_cache); + ADD_ALL_TESTS(test_ssl_set_bio, TOTAL_SSL_SET_BIO_TESTS); + ADD_TEST(test_ssl_bio_pop_next_bio); + ADD_TEST(test_ssl_bio_pop_ssl_bio); + ADD_TEST(test_ssl_bio_change_rbio); + ADD_TEST(test_ssl_bio_change_wbio); + ADD_ALL_TESTS(test_set_sigalgs, OSSL_NELEM(testsigalgs) * 2); + ADD_TEST(test_keylog); +#ifndef OPENSSL_NO_TLS1_3 + ADD_TEST(test_keylog_no_master_key); +#endif +#ifndef OPENSSL_NO_TLS1_2 + ADD_TEST(test_early_cb); +#endif +#ifndef OPENSSL_NO_TLS1_3 + ADD_ALL_TESTS(test_early_data_read_write, 2); + ADD_ALL_TESTS(test_early_data_skip, 2); + ADD_ALL_TESTS(test_early_data_not_sent, 2); + ADD_ALL_TESTS(test_early_data_not_expected, 2); +# ifndef OPENSSL_NO_TLS1_2 + ADD_ALL_TESTS(test_early_data_tls1_2, 2); +# endif +#endif +#ifndef OPENSSL_NO_TLS1_3 + ADD_ALL_TESTS(test_custom_exts, 4); +#else + ADD_ALL_TESTS(test_custom_exts, 2); +#endif testresult = run_tests(argv[0]);