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