#include "ssltestlib.h"
#include "testutil.h"
-#include "test_main_custom.h"
#include "e_os.h"
static char *cert = NULL;
/*
* Now we want to test that our output data was vaguely sensible. For this
- * test, we expect no CLIENT_RANDOM entry becuase it doesn't make sense for
+ * 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;
}
len = SSL_early_get0_compression_methods(s, &p);
if (len != 1 || *p != 0) {
- printf("Early callback expected comperssion methods mismatch\n");
+ printf("Early callback expected compression methods mismatch\n");
return 0;
}
return 1;
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);
* 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);
/*
* 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();
/*
* 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);
*/
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) {
#define MSG3 "This"
#define MSG4 "is"
#define MSG5 "a"
-#define MSG6 "test."
+#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)
+ SSL **serverssl, SSL_SESSION **sess, int idx)
{
if (!create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(), sctx,
cctx, cert, privkey)) {
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;
return 1;
}
-static int test_early_data_read_write(void)
+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];
- size_t readbytes, written;
+ unsigned char buf[20], data[1024];
+ size_t readbytes, written, eoedlen, rawread, rawwritten;
+ BIO *rbio;
- if (!setupearly_data_test(&cctx, &sctx, &clientssl, &serverssl, &sess))
+ if (!setupearly_data_test(&cctx, &sctx, &clientssl, &serverssl, &sess, idx))
goto end;
/* Write and read some early data */
- if (!SSL_write_early(clientssl, MSG1, strlen(MSG1), &written)
+ 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(serverssl, buf, sizeof(buf), &readbytes)
- != SSL_READ_EARLY_SUCCESS
+ 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");
}
/*
- * Server should be able to write normal data, and client should be able to
+ * Server should be able to write data, and client should be able to
* read it.
*/
- if (!SSL_write_ex(serverssl, MSG2, strlen(MSG2), &written)
+ if (!SSL_write_early_data(serverssl, MSG2, strlen(MSG2), &written)
|| written != strlen(MSG2)) {
printf("Failed writing message 2\n");
goto end;
}
/* Even after reading normal data, client should be able write early data */
- if (!SSL_write_early(clientssl, MSG3, strlen(MSG3), &written)
+ 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 normal data */
- if (SSL_read_early(serverssl, buf, sizeof(buf), &readbytes)
- != SSL_READ_EARLY_SUCCESS
+ /* 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 normal data from server and read it from client */
- if (!SSL_write_ex(serverssl, MSG4, strlen(MSG4), &written)
+ /* 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;
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(serverssl, buf, sizeof(buf), &readbytes)
- != SSL_READ_EARLY_FINISH
+ 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)) {
goto end;
}
- /* Client and server should not be able to write early data now */
- if (SSL_write_early(clientssl, MSG6, strlen(MSG6), &written)) {
+ /* 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(serverssl, buf, sizeof(buf), &readbytes)
- != SSL_READ_EARLY_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
- * so we must make sure we attempt a read - even though we don't expect to
- * actually get any application data.
+ * 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);
}
/* Write and read some early data */
- if (!SSL_write_early(clientssl, MSG1, strlen(MSG1), &written)
+ 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(serverssl, buf, sizeof(buf), &readbytes)
- != SSL_READ_EARLY_SUCCESS
+ 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;
}
- /*
- * We expect SSL_accept() to initially block as it handles the end of early
- * data alert
- */
- if (SSL_accept(serverssl) > 0) {
- printf("Unexpected success completing server 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 early data now */
- if (SSL_write_early(clientssl, MSG6, strlen(MSG6), &written)) {
+ /* 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(serverssl, buf, sizeof(buf), &readbytes)
- != SSL_READ_EARLY_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;
}
return testresult;
}
-static int test_early_data_skip(void)
+static int test_early_data_skip(int idx)
{
SSL_CTX *cctx = NULL, *sctx = NULL;
SSL *clientssl = NULL, *serverssl = NULL;
* from a client where the early data is not acceptable.
*/
- if (!setupearly_data_test(&cctx, &sctx, &clientssl, &serverssl, &sess))
+ if (!setupearly_data_test(&cctx, &sctx, &clientssl, &serverssl, &sess, idx))
goto end;
/*
}
/* Write some early data */
- if (!SSL_write_early(clientssl, MSG1, strlen(MSG1), &written)
+ 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(serverssl, buf, sizeof(buf), &readbytes)
- != SSL_READ_EARLY_FINISH
+ 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;
return testresult;
}
-static int test_early_data_not_sent(void)
+static int test_early_data_not_sent(int idx)
{
SSL_CTX *cctx = NULL, *sctx = NULL;
SSL *clientssl = NULL, *serverssl = NULL;
* from a client that doesn't send any.
*/
- if (!setupearly_data_test(&cctx, &sctx, &clientssl, &serverssl, &sess))
+ if (!setupearly_data_test(&cctx, &sctx, &clientssl, &serverssl, &sess, idx))
goto end;
/* Write some data - should block due to handshake with server */
}
/* Server should detect that early data has not been sent */
- if (SSL_read_early(serverssl, buf, sizeof(buf), &readbytes)
- != SSL_READ_EARLY_FINISH
+ 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;
goto end;
}
- /* Should block due to the NewSessionTicket arrival */
- if (SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes)) {
- printf("Unexpected success reading 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)
return testresult;
}
-static int test_early_data_not_expected(void)
+static int test_early_data_not_expected(int idx)
{
SSL_CTX *cctx = NULL, *sctx = NULL;
SSL *clientssl = NULL, *serverssl = NULL;
* client sending some.
*/
- if (!setupearly_data_test(&cctx, &sctx, &clientssl, &serverssl, &sess))
+ if (!setupearly_data_test(&cctx, &sctx, &clientssl, &serverssl, &sess, idx))
goto end;
/* Write some early data */
- if (!SSL_write_early(clientssl, MSG1, strlen(MSG1), &written)) {
+ if (!SSL_write_early_data(clientssl, MSG1, strlen(MSG1), &written)) {
printf("Unexpected failure writing message 1\n");
goto end;
}
# ifndef OPENSSL_NO_TLS1_2
-static int test_early_data_tls1_2(void)
+static int test_early_data_tls1_2(int idx)
{
SSL_CTX *cctx = NULL, *sctx = NULL;
SSL *clientssl = NULL, *serverssl = NULL;
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;
/*
* Server should do TLSv1.2 handshake. First it will block waiting for more
- * messages from client after ServerDone. Then SSL_read_early should finish
- * and detect that early data has not been sent
+ * 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(serverssl, buf, sizeof(buf), &readbytes)
- != SSL_READ_EARLY_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;
}
goto end;
}
- if (SSL_read_early(serverssl, buf, sizeof(buf), &readbytes)
- != SSL_READ_EARLY_FINISH
+ 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;
# 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;
ADD_TEST(test_early_cb);
#endif
#ifndef OPENSSL_NO_TLS1_3
- ADD_TEST(test_early_data_read_write);
- ADD_TEST(test_early_data_skip);
- ADD_TEST(test_early_data_not_sent);
- ADD_TEST(test_early_data_not_expected);
+ 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_TEST(test_early_data_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]);