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