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