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