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