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