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