fe355f2f4c9e3f4b2fa1b16d85c248e73fc0badc
[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     /* Should fail because it should already be in the cache */
1076     if (use_int_cache && !TEST_false(SSL_CTX_add_session(sctx, sess2)))
1077         goto end;
1078
1079     if (use_ext_cache) {
1080         SSL_SESSION *tmp = sess2;
1081
1082         if (!TEST_int_eq(new_called, numnewsesstick)
1083                 || !TEST_int_eq(remove_called, 0)
1084                 || !TEST_int_eq(get_called, 0))
1085             goto end;
1086         /*
1087          * Delete the session from the internal cache to force a lookup from
1088          * the external cache. We take a copy first because
1089          * SSL_CTX_remove_session() also marks the session as non-resumable.
1090          */
1091         if (use_int_cache) {
1092             if (!TEST_ptr(tmp = SSL_SESSION_dup(sess2))
1093                     || !TEST_true(SSL_CTX_remove_session(sctx, sess2)))
1094                 goto end;
1095             SSL_SESSION_free(sess2);
1096         }
1097         sess2 = tmp;
1098     }
1099
1100     new_called = remove_called = get_called = 0;
1101     get_sess_val = sess2;
1102     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl2,
1103                                       &clientssl2, NULL, NULL))
1104             || !TEST_true(SSL_set_session(clientssl2, sess1))
1105             || !TEST_true(create_ssl_connection(serverssl2, clientssl2,
1106                                                 SSL_ERROR_NONE))
1107             || !TEST_true(SSL_session_reused(clientssl2)))
1108         goto end;
1109
1110     if (use_ext_cache) {
1111         if (!TEST_int_eq(remove_called, 0))
1112             goto end;
1113
1114         if (maxprot == TLS1_3_VERSION) {
1115             if (!TEST_int_eq(new_called, 1)
1116                     || !TEST_int_eq(get_called, 0))
1117                 goto end;
1118         } else {
1119             if (!TEST_int_eq(new_called, 0)
1120                     || !TEST_int_eq(get_called, 1))
1121                 goto end;
1122         }
1123     }
1124
1125     testresult = 1;
1126
1127  end:
1128     SSL_free(serverssl1);
1129     SSL_free(clientssl1);
1130     SSL_free(serverssl2);
1131     SSL_free(clientssl2);
1132 # ifndef OPENSSL_NO_TLS1_1
1133     SSL_free(serverssl3);
1134     SSL_free(clientssl3);
1135 # endif
1136     SSL_SESSION_free(sess1);
1137     SSL_SESSION_free(sess2);
1138     SSL_CTX_free(sctx);
1139     SSL_CTX_free(cctx);
1140
1141     return testresult;
1142 }
1143 #endif /* !defined(OPENSSL_NO_TLS1_3) || !defined(OPENSSL_NO_TLS1_2) */
1144
1145 static int test_session_with_only_int_cache(void)
1146 {
1147 #ifndef OPENSSL_NO_TLS1_3
1148     if (!execute_test_session(TLS1_3_VERSION, 1, 0))
1149         return 0;
1150 #endif
1151
1152 #ifndef OPENSSL_NO_TLS1_2
1153     return execute_test_session(TLS1_2_VERSION, 1, 0);
1154 #else
1155     return 1;
1156 #endif
1157 }
1158
1159 static int test_session_with_only_ext_cache(void)
1160 {
1161 #ifndef OPENSSL_NO_TLS1_3
1162     if (!execute_test_session(TLS1_3_VERSION, 0, 1))
1163         return 0;
1164 #endif
1165
1166 #ifndef OPENSSL_NO_TLS1_2
1167     return execute_test_session(TLS1_2_VERSION, 0, 1);
1168 #else
1169     return 1;
1170 #endif
1171 }
1172
1173 static int test_session_with_both_cache(void)
1174 {
1175 #ifndef OPENSSL_NO_TLS1_3
1176     if (!execute_test_session(TLS1_3_VERSION, 1, 1))
1177         return 0;
1178 #endif
1179
1180 #ifndef OPENSSL_NO_TLS1_2
1181     return execute_test_session(TLS1_2_VERSION, 1, 1);
1182 #else
1183     return 1;
1184 #endif
1185 }
1186
1187 static SSL_SESSION *sesscache[6];
1188 static int do_cache;
1189
1190 static int new_cachesession_cb(SSL *ssl, SSL_SESSION *sess)
1191 {
1192     if (do_cache) {
1193         sesscache[new_called] = sess;
1194     } else {
1195         /* We don't need the reference to the session, so free it */
1196         SSL_SESSION_free(sess);
1197     }
1198     new_called++;
1199
1200     return 1;
1201 }
1202
1203 static int post_handshake_verify(SSL *sssl, SSL *cssl)
1204 {
1205     SSL_set_verify(sssl, SSL_VERIFY_PEER, NULL);
1206     if (!TEST_true(SSL_verify_client_post_handshake(sssl)))
1207         return 0;
1208
1209     /* Start handshake on the server and client */
1210     if (!TEST_int_eq(SSL_do_handshake(sssl), 1)
1211             || !TEST_int_le(SSL_read(cssl, NULL, 0), 0)
1212             || !TEST_int_le(SSL_read(sssl, NULL, 0), 0)
1213             || !TEST_true(create_ssl_connection(sssl, cssl,
1214                                                 SSL_ERROR_NONE)))
1215         return 0;
1216
1217     return 1;
1218 }
1219
1220 static int test_tickets(int idx)
1221 {
1222     SSL_CTX *sctx = NULL, *cctx = NULL;
1223     SSL *serverssl = NULL, *clientssl = NULL;
1224     int testresult = 0, i;
1225     size_t j;
1226
1227     /* idx is the test number, but also the number of tickets we want */
1228
1229     new_called = 0;
1230     do_cache = 1;
1231
1232     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
1233                                        TLS1_VERSION, TLS_MAX_VERSION, &sctx,
1234                                        &cctx, cert, privkey))
1235             || !TEST_true(SSL_CTX_set_num_tickets(sctx, idx)))
1236         goto end;
1237
1238     SSL_CTX_set_session_cache_mode(cctx, SSL_SESS_CACHE_CLIENT
1239                                          | SSL_SESS_CACHE_NO_INTERNAL_STORE);
1240     SSL_CTX_sess_set_new_cb(cctx, new_cachesession_cb);
1241
1242     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
1243                                           &clientssl, NULL, NULL)))
1244         goto end;
1245
1246     SSL_force_post_handshake_auth(clientssl);
1247
1248     if (!TEST_true(create_ssl_connection(serverssl, clientssl,
1249                                                 SSL_ERROR_NONE))
1250                /* Check we got the number of tickets we were expecting */
1251             || !TEST_int_eq(idx, new_called))
1252         goto end;
1253
1254     /* After a post-handshake authentication we should get new tickets issued */
1255     if (!post_handshake_verify(serverssl, clientssl)
1256             || !TEST_int_eq(idx * 2, new_called))
1257         goto end;
1258
1259     SSL_shutdown(clientssl);
1260     SSL_shutdown(serverssl);
1261     SSL_free(serverssl);
1262     SSL_free(clientssl);
1263     serverssl = clientssl = NULL;
1264
1265     /* Stop caching sessions - just count them */
1266     do_cache = 0;
1267
1268     /* Test that we can resume with all the tickets we got given */
1269     for (i = 0; i < idx * 2; i++) {
1270         new_called = 0;
1271         if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
1272                                               &clientssl, NULL, NULL))
1273                 || !TEST_true(SSL_set_session(clientssl, sesscache[i])))
1274             goto end;
1275
1276         SSL_force_post_handshake_auth(clientssl);
1277
1278         if (!TEST_true(create_ssl_connection(serverssl, clientssl,
1279                                                     SSL_ERROR_NONE))
1280                 || !TEST_true(SSL_session_reused(clientssl))
1281                    /* Following a resumption we only get 1 ticket */
1282                 || !TEST_int_eq(new_called, 1))
1283             goto end;
1284
1285         new_called = 0;
1286         /* After a post-handshake authentication we should get 1 new ticket */
1287         if (!post_handshake_verify(serverssl, clientssl)
1288                 || !TEST_int_eq(new_called, 1))
1289             goto end;
1290
1291         SSL_shutdown(clientssl);
1292         SSL_shutdown(serverssl);
1293         SSL_free(serverssl);
1294         SSL_free(clientssl);
1295         serverssl = clientssl = NULL;
1296         SSL_SESSION_free(sesscache[i]);
1297         sesscache[i] = NULL;
1298     }
1299
1300     testresult = 1;
1301
1302  end:
1303     SSL_free(serverssl);
1304     SSL_free(clientssl);
1305     for (j = 0; j < OSSL_NELEM(sesscache); j++) {
1306         SSL_SESSION_free(sesscache[j]);
1307         sesscache[j] = NULL;
1308     }
1309     SSL_CTX_free(sctx);
1310     SSL_CTX_free(cctx);
1311
1312     return testresult;
1313 }
1314
1315 #define USE_NULL            0
1316 #define USE_BIO_1           1
1317 #define USE_BIO_2           2
1318 #define USE_DEFAULT         3
1319
1320 #define CONNTYPE_CONNECTION_SUCCESS  0
1321 #define CONNTYPE_CONNECTION_FAIL     1
1322 #define CONNTYPE_NO_CONNECTION       2
1323
1324 #define TOTAL_NO_CONN_SSL_SET_BIO_TESTS         (3 * 3 * 3 * 3)
1325 #define TOTAL_CONN_SUCCESS_SSL_SET_BIO_TESTS    (2 * 2)
1326 #if !defined(OPENSSL_NO_TLS1_3) && !defined(OPENSSL_NO_TLS1_2)
1327 # define TOTAL_CONN_FAIL_SSL_SET_BIO_TESTS       (2 * 2)
1328 #else
1329 # define TOTAL_CONN_FAIL_SSL_SET_BIO_TESTS       0
1330 #endif
1331
1332 #define TOTAL_SSL_SET_BIO_TESTS TOTAL_NO_CONN_SSL_SET_BIO_TESTS \
1333                                 + TOTAL_CONN_SUCCESS_SSL_SET_BIO_TESTS \
1334                                 + TOTAL_CONN_FAIL_SSL_SET_BIO_TESTS
1335
1336 static void setupbio(BIO **res, BIO *bio1, BIO *bio2, int type)
1337 {
1338     switch (type) {
1339     case USE_NULL:
1340         *res = NULL;
1341         break;
1342     case USE_BIO_1:
1343         *res = bio1;
1344         break;
1345     case USE_BIO_2:
1346         *res = bio2;
1347         break;
1348     }
1349 }
1350
1351
1352 /*
1353  * Tests calls to SSL_set_bio() under various conditions.
1354  *
1355  * For the first 3 * 3 * 3 * 3 = 81 tests we do 2 calls to SSL_set_bio() with
1356  * various combinations of valid BIOs or NULL being set for the rbio/wbio. We
1357  * then do more tests where we create a successful connection first using our
1358  * standard connection setup functions, and then call SSL_set_bio() with
1359  * various combinations of valid BIOs or NULL. We then repeat these tests
1360  * following a failed connection. In this last case we are looking to check that
1361  * SSL_set_bio() functions correctly in the case where s->bbio is not NULL.
1362  */
1363 static int test_ssl_set_bio(int idx)
1364 {
1365     SSL_CTX *sctx = NULL, *cctx = NULL;
1366     BIO *bio1 = NULL;
1367     BIO *bio2 = NULL;
1368     BIO *irbio = NULL, *iwbio = NULL, *nrbio = NULL, *nwbio = NULL;
1369     SSL *serverssl = NULL, *clientssl = NULL;
1370     int initrbio, initwbio, newrbio, newwbio, conntype;
1371     int testresult = 0;
1372
1373     if (idx < TOTAL_NO_CONN_SSL_SET_BIO_TESTS) {
1374         initrbio = idx % 3;
1375         idx /= 3;
1376         initwbio = idx % 3;
1377         idx /= 3;
1378         newrbio = idx % 3;
1379         idx /= 3;
1380         newwbio = idx % 3;
1381         conntype = CONNTYPE_NO_CONNECTION;
1382     } else {
1383         idx -= TOTAL_NO_CONN_SSL_SET_BIO_TESTS;
1384         initrbio = initwbio = USE_DEFAULT;
1385         newrbio = idx % 2;
1386         idx /= 2;
1387         newwbio = idx % 2;
1388         idx /= 2;
1389         conntype = idx % 2;
1390     }
1391
1392     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
1393                                        TLS1_VERSION, TLS_MAX_VERSION,
1394                                        &sctx, &cctx, cert, privkey)))
1395         goto end;
1396
1397     if (conntype == CONNTYPE_CONNECTION_FAIL) {
1398         /*
1399          * We won't ever get here if either TLSv1.3 or TLSv1.2 is disabled
1400          * because we reduced the number of tests in the definition of
1401          * TOTAL_CONN_FAIL_SSL_SET_BIO_TESTS to avoid this scenario. By setting
1402          * mismatched protocol versions we will force a connection failure.
1403          */
1404         SSL_CTX_set_min_proto_version(sctx, TLS1_3_VERSION);
1405         SSL_CTX_set_max_proto_version(cctx, TLS1_2_VERSION);
1406     }
1407
1408     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
1409                                       NULL, NULL)))
1410         goto end;
1411
1412     if (initrbio == USE_BIO_1
1413             || initwbio == USE_BIO_1
1414             || newrbio == USE_BIO_1
1415             || newwbio == USE_BIO_1) {
1416         if (!TEST_ptr(bio1 = BIO_new(BIO_s_mem())))
1417             goto end;
1418     }
1419
1420     if (initrbio == USE_BIO_2
1421             || initwbio == USE_BIO_2
1422             || newrbio == USE_BIO_2
1423             || newwbio == USE_BIO_2) {
1424         if (!TEST_ptr(bio2 = BIO_new(BIO_s_mem())))
1425             goto end;
1426     }
1427
1428     if (initrbio != USE_DEFAULT) {
1429         setupbio(&irbio, bio1, bio2, initrbio);
1430         setupbio(&iwbio, bio1, bio2, initwbio);
1431         SSL_set_bio(clientssl, irbio, iwbio);
1432
1433         /*
1434          * We want to maintain our own refs to these BIO, so do an up ref for
1435          * each BIO that will have ownership transferred in the SSL_set_bio()
1436          * call
1437          */
1438         if (irbio != NULL)
1439             BIO_up_ref(irbio);
1440         if (iwbio != NULL && iwbio != irbio)
1441             BIO_up_ref(iwbio);
1442     }
1443
1444     if (conntype != CONNTYPE_NO_CONNECTION
1445             && !TEST_true(create_ssl_connection(serverssl, clientssl,
1446                                                 SSL_ERROR_NONE)
1447                           == (conntype == CONNTYPE_CONNECTION_SUCCESS)))
1448         goto end;
1449
1450     setupbio(&nrbio, bio1, bio2, newrbio);
1451     setupbio(&nwbio, bio1, bio2, newwbio);
1452
1453     /*
1454      * We will (maybe) transfer ownership again so do more up refs.
1455      * SSL_set_bio() has some really complicated ownership rules where BIOs have
1456      * already been set!
1457      */
1458     if (nrbio != NULL
1459             && nrbio != irbio
1460             && (nwbio != iwbio || nrbio != nwbio))
1461         BIO_up_ref(nrbio);
1462     if (nwbio != NULL
1463             && nwbio != nrbio
1464             && (nwbio != iwbio || (nwbio == iwbio && irbio == iwbio)))
1465         BIO_up_ref(nwbio);
1466
1467     SSL_set_bio(clientssl, nrbio, nwbio);
1468
1469     testresult = 1;
1470
1471  end:
1472     BIO_free(bio1);
1473     BIO_free(bio2);
1474
1475     /*
1476      * This test is checking that the ref counting for SSL_set_bio is correct.
1477      * If we get here and we did too many frees then we will fail in the above
1478      * functions. If we haven't done enough then this will only be detected in
1479      * a crypto-mdebug build
1480      */
1481     SSL_free(serverssl);
1482     SSL_free(clientssl);
1483     SSL_CTX_free(sctx);
1484     SSL_CTX_free(cctx);
1485     return testresult;
1486 }
1487
1488 typedef enum { NO_BIO_CHANGE, CHANGE_RBIO, CHANGE_WBIO } bio_change_t;
1489
1490 static int execute_test_ssl_bio(int pop_ssl, bio_change_t change_bio)
1491 {
1492     BIO *sslbio = NULL, *membio1 = NULL, *membio2 = NULL;
1493     SSL_CTX *ctx;
1494     SSL *ssl = NULL;
1495     int testresult = 0;
1496
1497     if (!TEST_ptr(ctx = SSL_CTX_new(TLS_method()))
1498             || !TEST_ptr(ssl = SSL_new(ctx))
1499             || !TEST_ptr(sslbio = BIO_new(BIO_f_ssl()))
1500             || !TEST_ptr(membio1 = BIO_new(BIO_s_mem())))
1501         goto end;
1502
1503     BIO_set_ssl(sslbio, ssl, BIO_CLOSE);
1504
1505     /*
1506      * If anything goes wrong here then we could leak memory, so this will
1507      * be caught in a crypto-mdebug build
1508      */
1509     BIO_push(sslbio, membio1);
1510
1511     /* Verify changing the rbio/wbio directly does not cause leaks */
1512     if (change_bio != NO_BIO_CHANGE) {
1513         if (!TEST_ptr(membio2 = BIO_new(BIO_s_mem())))
1514             goto end;
1515         if (change_bio == CHANGE_RBIO)
1516             SSL_set0_rbio(ssl, membio2);
1517         else
1518             SSL_set0_wbio(ssl, membio2);
1519     }
1520     ssl = NULL;
1521
1522     if (pop_ssl)
1523         BIO_pop(sslbio);
1524     else
1525         BIO_pop(membio1);
1526
1527     testresult = 1;
1528  end:
1529     BIO_free(membio1);
1530     BIO_free(sslbio);
1531     SSL_free(ssl);
1532     SSL_CTX_free(ctx);
1533
1534     return testresult;
1535 }
1536
1537 static int test_ssl_bio_pop_next_bio(void)
1538 {
1539     return execute_test_ssl_bio(0, NO_BIO_CHANGE);
1540 }
1541
1542 static int test_ssl_bio_pop_ssl_bio(void)
1543 {
1544     return execute_test_ssl_bio(1, NO_BIO_CHANGE);
1545 }
1546
1547 static int test_ssl_bio_change_rbio(void)
1548 {
1549     return execute_test_ssl_bio(0, CHANGE_RBIO);
1550 }
1551
1552 static int test_ssl_bio_change_wbio(void)
1553 {
1554     return execute_test_ssl_bio(0, CHANGE_WBIO);
1555 }
1556
1557 #if !defined(OPENSSL_NO_TLS1_2) || defined(OPENSSL_NO_TLS1_3)
1558 typedef struct {
1559     /* The list of sig algs */
1560     const int *list;
1561     /* The length of the list */
1562     size_t listlen;
1563     /* A sigalgs list in string format */
1564     const char *liststr;
1565     /* Whether setting the list should succeed */
1566     int valid;
1567     /* Whether creating a connection with the list should succeed */
1568     int connsuccess;
1569 } sigalgs_list;
1570
1571 static const int validlist1[] = {NID_sha256, EVP_PKEY_RSA};
1572 # ifndef OPENSSL_NO_EC
1573 static const int validlist2[] = {NID_sha256, EVP_PKEY_RSA, NID_sha512, EVP_PKEY_EC};
1574 static const int validlist3[] = {NID_sha512, EVP_PKEY_EC};
1575 # endif
1576 static const int invalidlist1[] = {NID_undef, EVP_PKEY_RSA};
1577 static const int invalidlist2[] = {NID_sha256, NID_undef};
1578 static const int invalidlist3[] = {NID_sha256, EVP_PKEY_RSA, NID_sha256};
1579 static const int invalidlist4[] = {NID_sha256};
1580 static const sigalgs_list testsigalgs[] = {
1581     {validlist1, OSSL_NELEM(validlist1), NULL, 1, 1},
1582 # ifndef OPENSSL_NO_EC
1583     {validlist2, OSSL_NELEM(validlist2), NULL, 1, 1},
1584     {validlist3, OSSL_NELEM(validlist3), NULL, 1, 0},
1585 # endif
1586     {NULL, 0, "RSA+SHA256", 1, 1},
1587 # ifndef OPENSSL_NO_EC
1588     {NULL, 0, "RSA+SHA256:ECDSA+SHA512", 1, 1},
1589     {NULL, 0, "ECDSA+SHA512", 1, 0},
1590 # endif
1591     {invalidlist1, OSSL_NELEM(invalidlist1), NULL, 0, 0},
1592     {invalidlist2, OSSL_NELEM(invalidlist2), NULL, 0, 0},
1593     {invalidlist3, OSSL_NELEM(invalidlist3), NULL, 0, 0},
1594     {invalidlist4, OSSL_NELEM(invalidlist4), NULL, 0, 0},
1595     {NULL, 0, "RSA", 0, 0},
1596     {NULL, 0, "SHA256", 0, 0},
1597     {NULL, 0, "RSA+SHA256:SHA256", 0, 0},
1598     {NULL, 0, "Invalid", 0, 0}
1599 };
1600
1601 static int test_set_sigalgs(int idx)
1602 {
1603     SSL_CTX *cctx = NULL, *sctx = NULL;
1604     SSL *clientssl = NULL, *serverssl = NULL;
1605     int testresult = 0;
1606     const sigalgs_list *curr;
1607     int testctx;
1608
1609     /* Should never happen */
1610     if (!TEST_size_t_le((size_t)idx, OSSL_NELEM(testsigalgs) * 2))
1611         return 0;
1612
1613     testctx = ((size_t)idx < OSSL_NELEM(testsigalgs));
1614     curr = testctx ? &testsigalgs[idx]
1615                    : &testsigalgs[idx - OSSL_NELEM(testsigalgs)];
1616
1617     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
1618                                        TLS1_VERSION, TLS_MAX_VERSION,
1619                                        &sctx, &cctx, cert, privkey)))
1620         return 0;
1621
1622     /*
1623      * TODO(TLS1.3): These APIs cannot set TLSv1.3 sig algs so we just test it
1624      * for TLSv1.2 for now until we add a new API.
1625      */
1626     SSL_CTX_set_max_proto_version(cctx, TLS1_2_VERSION);
1627
1628     if (testctx) {
1629         int ret;
1630
1631         if (curr->list != NULL)
1632             ret = SSL_CTX_set1_sigalgs(cctx, curr->list, curr->listlen);
1633         else
1634             ret = SSL_CTX_set1_sigalgs_list(cctx, curr->liststr);
1635
1636         if (!ret) {
1637             if (curr->valid)
1638                 TEST_info("Failure setting sigalgs in SSL_CTX (%d)\n", idx);
1639             else
1640                 testresult = 1;
1641             goto end;
1642         }
1643         if (!curr->valid) {
1644             TEST_info("Not-failed setting sigalgs in SSL_CTX (%d)\n", idx);
1645             goto end;
1646         }
1647     }
1648
1649     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
1650                                       &clientssl, NULL, NULL)))
1651         goto end;
1652
1653     if (!testctx) {
1654         int ret;
1655
1656         if (curr->list != NULL)
1657             ret = SSL_set1_sigalgs(clientssl, curr->list, curr->listlen);
1658         else
1659             ret = SSL_set1_sigalgs_list(clientssl, curr->liststr);
1660         if (!ret) {
1661             if (curr->valid)
1662                 TEST_info("Failure setting sigalgs in SSL (%d)\n", idx);
1663             else
1664                 testresult = 1;
1665             goto end;
1666         }
1667         if (!curr->valid)
1668             goto end;
1669     }
1670
1671     if (!TEST_int_eq(create_ssl_connection(serverssl, clientssl,
1672                                            SSL_ERROR_NONE),
1673                 curr->connsuccess))
1674         goto end;
1675
1676     testresult = 1;
1677
1678  end:
1679     SSL_free(serverssl);
1680     SSL_free(clientssl);
1681     SSL_CTX_free(sctx);
1682     SSL_CTX_free(cctx);
1683
1684     return testresult;
1685 }
1686 #endif
1687
1688 #ifndef OPENSSL_NO_TLS1_3
1689
1690 static SSL_SESSION *clientpsk = NULL;
1691 static SSL_SESSION *serverpsk = NULL;
1692 static const char *pskid = "Identity";
1693 static const char *srvid;
1694
1695 static int use_session_cb_cnt = 0;
1696 static int find_session_cb_cnt = 0;
1697 static int psk_client_cb_cnt = 0;
1698 static int psk_server_cb_cnt = 0;
1699
1700 static int use_session_cb(SSL *ssl, const EVP_MD *md, const unsigned char **id,
1701                           size_t *idlen, SSL_SESSION **sess)
1702 {
1703     switch (++use_session_cb_cnt) {
1704     case 1:
1705         /* The first call should always have a NULL md */
1706         if (md != NULL)
1707             return 0;
1708         break;
1709
1710     case 2:
1711         /* The second call should always have an md */
1712         if (md == NULL)
1713             return 0;
1714         break;
1715
1716     default:
1717         /* We should only be called a maximum of twice */
1718         return 0;
1719     }
1720
1721     if (clientpsk != NULL)
1722         SSL_SESSION_up_ref(clientpsk);
1723
1724     *sess = clientpsk;
1725     *id = (const unsigned char *)pskid;
1726     *idlen = strlen(pskid);
1727
1728     return 1;
1729 }
1730
1731 #ifndef OPENSSL_NO_PSK
1732 static unsigned int psk_client_cb(SSL *ssl, const char *hint, char *id,
1733                                   unsigned int max_id_len,
1734                                   unsigned char *psk,
1735                                   unsigned int max_psk_len)
1736 {
1737     unsigned int psklen = 0;
1738
1739     psk_client_cb_cnt++;
1740
1741     if (strlen(pskid) + 1 > max_id_len)
1742         return 0;
1743
1744     /* We should only ever be called a maximum of twice per connection */
1745     if (psk_client_cb_cnt > 2)
1746         return 0;
1747
1748     if (clientpsk == NULL)
1749         return 0;
1750
1751     /* We'll reuse the PSK we set up for TLSv1.3 */
1752     if (SSL_SESSION_get_master_key(clientpsk, NULL, 0) > max_psk_len)
1753         return 0;
1754     psklen = SSL_SESSION_get_master_key(clientpsk, psk, max_psk_len);
1755     strncpy(id, pskid, max_id_len);
1756
1757     return psklen;
1758 }
1759 #endif /* OPENSSL_NO_PSK */
1760
1761 static int find_session_cb(SSL *ssl, const unsigned char *identity,
1762                            size_t identity_len, SSL_SESSION **sess)
1763 {
1764     find_session_cb_cnt++;
1765
1766     /* We should only ever be called a maximum of twice per connection */
1767     if (find_session_cb_cnt > 2)
1768         return 0;
1769
1770     if (serverpsk == NULL)
1771         return 0;
1772
1773     /* Identity should match that set by the client */
1774     if (strlen(srvid) != identity_len
1775             || strncmp(srvid, (const char *)identity, identity_len) != 0) {
1776         /* No PSK found, continue but without a PSK */
1777         *sess = NULL;
1778         return 1;
1779     }
1780
1781     SSL_SESSION_up_ref(serverpsk);
1782     *sess = serverpsk;
1783
1784     return 1;
1785 }
1786
1787 #ifndef OPENSSL_NO_PSK
1788 static unsigned int psk_server_cb(SSL *ssl, const char *identity,
1789                                   unsigned char *psk, unsigned int max_psk_len)
1790 {
1791     unsigned int psklen = 0;
1792
1793     psk_server_cb_cnt++;
1794
1795     /* We should only ever be called a maximum of twice per connection */
1796     if (find_session_cb_cnt > 2)
1797         return 0;
1798
1799     if (serverpsk == NULL)
1800         return 0;
1801
1802     /* Identity should match that set by the client */
1803     if (strcmp(srvid, identity) != 0) {
1804         return 0;
1805     }
1806
1807     /* We'll reuse the PSK we set up for TLSv1.3 */
1808     if (SSL_SESSION_get_master_key(serverpsk, NULL, 0) > max_psk_len)
1809         return 0;
1810     psklen = SSL_SESSION_get_master_key(serverpsk, psk, max_psk_len);
1811
1812     return psklen;
1813 }
1814 #endif /* OPENSSL_NO_PSK */
1815
1816 #define MSG1    "Hello"
1817 #define MSG2    "World."
1818 #define MSG3    "This"
1819 #define MSG4    "is"
1820 #define MSG5    "a"
1821 #define MSG6    "test"
1822 #define MSG7    "message."
1823
1824 #define TLS13_AES_256_GCM_SHA384_BYTES  ((const unsigned char *)"\x13\x02")
1825 #define TLS13_AES_128_GCM_SHA256_BYTES  ((const unsigned char *)"\x13\x01")
1826
1827 /*
1828  * Helper method to setup objects for early data test. Caller frees objects on
1829  * error.
1830  */
1831 static int setupearly_data_test(SSL_CTX **cctx, SSL_CTX **sctx, SSL **clientssl,
1832                                 SSL **serverssl, SSL_SESSION **sess, int idx)
1833 {
1834     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
1835                                        TLS1_VERSION, TLS_MAX_VERSION,
1836                                        sctx, cctx, cert, privkey))
1837         || !TEST_true(SSL_CTX_set_max_early_data(*sctx,
1838                                                  SSL3_RT_MAX_PLAIN_LENGTH)))
1839         return 0;
1840
1841     if (idx == 1) {
1842         /* When idx == 1 we repeat the tests with read_ahead set */
1843         SSL_CTX_set_read_ahead(*cctx, 1);
1844         SSL_CTX_set_read_ahead(*sctx, 1);
1845     } else if (idx == 2) {
1846         /* When idx == 2 we are doing early_data with a PSK. Set up callbacks */
1847         SSL_CTX_set_psk_use_session_callback(*cctx, use_session_cb);
1848         SSL_CTX_set_psk_find_session_callback(*sctx, find_session_cb);
1849         use_session_cb_cnt = 0;
1850         find_session_cb_cnt = 0;
1851         srvid = pskid;
1852     }
1853
1854     if (!TEST_true(create_ssl_objects(*sctx, *cctx, serverssl, clientssl,
1855                                       NULL, NULL)))
1856         return 0;
1857
1858     /*
1859      * For one of the run throughs (doesn't matter which one), we'll try sending
1860      * some SNI data in the initial ClientHello. This will be ignored (because
1861      * there is no SNI cb set up by the server), so it should not impact
1862      * early_data.
1863      */
1864     if (idx == 1
1865             && !TEST_true(SSL_set_tlsext_host_name(*clientssl, "localhost")))
1866         return 0;
1867
1868     if (idx == 2) {
1869         /* Create the PSK */
1870         const SSL_CIPHER *cipher = NULL;
1871         const unsigned char key[] = {
1872             0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
1873             0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
1874             0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
1875             0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b,
1876             0x2c, 0x2d, 0x2e, 0x2f
1877         };
1878
1879         cipher = SSL_CIPHER_find(*clientssl, TLS13_AES_256_GCM_SHA384_BYTES);
1880         clientpsk = SSL_SESSION_new();
1881         if (!TEST_ptr(clientpsk)
1882                 || !TEST_ptr(cipher)
1883                 || !TEST_true(SSL_SESSION_set1_master_key(clientpsk, key,
1884                                                           sizeof(key)))
1885                 || !TEST_true(SSL_SESSION_set_cipher(clientpsk, cipher))
1886                 || !TEST_true(
1887                         SSL_SESSION_set_protocol_version(clientpsk,
1888                                                          TLS1_3_VERSION))
1889                    /*
1890                     * We just choose an arbitrary value for max_early_data which
1891                     * should be big enough for testing purposes.
1892                     */
1893                 || !TEST_true(SSL_SESSION_set_max_early_data(clientpsk,
1894                                                              0x100))
1895                 || !TEST_true(SSL_SESSION_up_ref(clientpsk))) {
1896             SSL_SESSION_free(clientpsk);
1897             clientpsk = NULL;
1898             return 0;
1899         }
1900         serverpsk = clientpsk;
1901
1902         if (sess != NULL) {
1903             if (!TEST_true(SSL_SESSION_up_ref(clientpsk))) {
1904                 SSL_SESSION_free(clientpsk);
1905                 SSL_SESSION_free(serverpsk);
1906                 clientpsk = serverpsk = NULL;
1907                 return 0;
1908             }
1909             *sess = clientpsk;
1910         }
1911         return 1;
1912     }
1913
1914     if (sess == NULL)
1915         return 1;
1916
1917     if (!TEST_true(create_ssl_connection(*serverssl, *clientssl,
1918                                          SSL_ERROR_NONE)))
1919         return 0;
1920
1921     *sess = SSL_get1_session(*clientssl);
1922     SSL_shutdown(*clientssl);
1923     SSL_shutdown(*serverssl);
1924     SSL_free(*serverssl);
1925     SSL_free(*clientssl);
1926     *serverssl = *clientssl = NULL;
1927
1928     if (!TEST_true(create_ssl_objects(*sctx, *cctx, serverssl,
1929                                       clientssl, NULL, NULL))
1930             || !TEST_true(SSL_set_session(*clientssl, *sess)))
1931         return 0;
1932
1933     return 1;
1934 }
1935
1936 static int test_early_data_read_write(int idx)
1937 {
1938     SSL_CTX *cctx = NULL, *sctx = NULL;
1939     SSL *clientssl = NULL, *serverssl = NULL;
1940     int testresult = 0;
1941     SSL_SESSION *sess = NULL;
1942     unsigned char buf[20], data[1024];
1943     size_t readbytes, written, eoedlen, rawread, rawwritten;
1944     BIO *rbio;
1945
1946     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
1947                                         &serverssl, &sess, idx)))
1948         goto end;
1949
1950     /* Write and read some early data */
1951     if (!TEST_true(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
1952                                         &written))
1953             || !TEST_size_t_eq(written, strlen(MSG1))
1954             || !TEST_int_eq(SSL_read_early_data(serverssl, buf,
1955                                                 sizeof(buf), &readbytes),
1956                             SSL_READ_EARLY_DATA_SUCCESS)
1957             || !TEST_mem_eq(MSG1, readbytes, buf, strlen(MSG1))
1958             || !TEST_int_eq(SSL_get_early_data_status(serverssl),
1959                             SSL_EARLY_DATA_ACCEPTED))
1960         goto end;
1961
1962     /*
1963      * Server should be able to write data, and client should be able to
1964      * read it.
1965      */
1966     if (!TEST_true(SSL_write_early_data(serverssl, MSG2, strlen(MSG2),
1967                                         &written))
1968             || !TEST_size_t_eq(written, strlen(MSG2))
1969             || !TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
1970             || !TEST_mem_eq(buf, readbytes, MSG2, strlen(MSG2)))
1971         goto end;
1972
1973     /* Even after reading normal data, client should be able write early data */
1974     if (!TEST_true(SSL_write_early_data(clientssl, MSG3, strlen(MSG3),
1975                                         &written))
1976             || !TEST_size_t_eq(written, strlen(MSG3)))
1977         goto end;
1978
1979     /* Server should still be able read early data after writing data */
1980     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
1981                                          &readbytes),
1982                      SSL_READ_EARLY_DATA_SUCCESS)
1983             || !TEST_mem_eq(buf, readbytes, MSG3, strlen(MSG3)))
1984         goto end;
1985
1986     /* Write more data from server and read it from client */
1987     if (!TEST_true(SSL_write_early_data(serverssl, MSG4, strlen(MSG4),
1988                                         &written))
1989             || !TEST_size_t_eq(written, strlen(MSG4))
1990             || !TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
1991             || !TEST_mem_eq(buf, readbytes, MSG4, strlen(MSG4)))
1992         goto end;
1993
1994     /*
1995      * If client writes normal data it should mean writing early data is no
1996      * longer possible.
1997      */
1998     if (!TEST_true(SSL_write_ex(clientssl, MSG5, strlen(MSG5), &written))
1999             || !TEST_size_t_eq(written, strlen(MSG5))
2000             || !TEST_int_eq(SSL_get_early_data_status(clientssl),
2001                             SSL_EARLY_DATA_ACCEPTED))
2002         goto end;
2003
2004     /*
2005      * At this point the client has written EndOfEarlyData, ClientFinished and
2006      * normal (fully protected) data. We are going to cause a delay between the
2007      * arrival of EndOfEarlyData and ClientFinished. We read out all the data
2008      * in the read BIO, and then just put back the EndOfEarlyData message.
2009      */
2010     rbio = SSL_get_rbio(serverssl);
2011     if (!TEST_true(BIO_read_ex(rbio, data, sizeof(data), &rawread))
2012             || !TEST_size_t_lt(rawread, sizeof(data))
2013             || !TEST_size_t_gt(rawread, SSL3_RT_HEADER_LENGTH))
2014         goto end;
2015
2016     /* Record length is in the 4th and 5th bytes of the record header */
2017     eoedlen = SSL3_RT_HEADER_LENGTH + (data[3] << 8 | data[4]);
2018     if (!TEST_true(BIO_write_ex(rbio, data, eoedlen, &rawwritten))
2019             || !TEST_size_t_eq(rawwritten, eoedlen))
2020         goto end;
2021
2022     /* Server should be told that there is no more early data */
2023     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2024                                          &readbytes),
2025                      SSL_READ_EARLY_DATA_FINISH)
2026             || !TEST_size_t_eq(readbytes, 0))
2027         goto end;
2028
2029     /*
2030      * Server has not finished init yet, so should still be able to write early
2031      * data.
2032      */
2033     if (!TEST_true(SSL_write_early_data(serverssl, MSG6, strlen(MSG6),
2034                                         &written))
2035             || !TEST_size_t_eq(written, strlen(MSG6)))
2036         goto end;
2037
2038     /* Push the ClientFinished and the normal data back into the server rbio */
2039     if (!TEST_true(BIO_write_ex(rbio, data + eoedlen, rawread - eoedlen,
2040                                 &rawwritten))
2041             || !TEST_size_t_eq(rawwritten, rawread - eoedlen))
2042         goto end;
2043
2044     /* Server should be able to read normal data */
2045     if (!TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
2046             || !TEST_size_t_eq(readbytes, strlen(MSG5)))
2047         goto end;
2048
2049     /* Client and server should not be able to write/read early data now */
2050     if (!TEST_false(SSL_write_early_data(clientssl, MSG6, strlen(MSG6),
2051                                          &written)))
2052         goto end;
2053     ERR_clear_error();
2054     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2055                                          &readbytes),
2056                      SSL_READ_EARLY_DATA_ERROR))
2057         goto end;
2058     ERR_clear_error();
2059
2060     /* Client should be able to read the data sent by the server */
2061     if (!TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
2062             || !TEST_mem_eq(buf, readbytes, MSG6, strlen(MSG6)))
2063         goto end;
2064
2065     /*
2066      * Make sure we process the two NewSessionTickets. These arrive
2067      * post-handshake. We attempt reads which we do not expect to return any
2068      * data.
2069      */
2070     if (!TEST_false(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
2071             || !TEST_false(SSL_read_ex(clientssl, buf, sizeof(buf),
2072                            &readbytes)))
2073         goto end;
2074
2075     /* Server should be able to write normal data */
2076     if (!TEST_true(SSL_write_ex(serverssl, MSG7, strlen(MSG7), &written))
2077             || !TEST_size_t_eq(written, strlen(MSG7))
2078             || !TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
2079             || !TEST_mem_eq(buf, readbytes, MSG7, strlen(MSG7)))
2080         goto end;
2081
2082     SSL_SESSION_free(sess);
2083     sess = SSL_get1_session(clientssl);
2084     use_session_cb_cnt = 0;
2085     find_session_cb_cnt = 0;
2086
2087     SSL_shutdown(clientssl);
2088     SSL_shutdown(serverssl);
2089     SSL_free(serverssl);
2090     SSL_free(clientssl);
2091     serverssl = clientssl = NULL;
2092     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
2093                                       &clientssl, NULL, NULL))
2094             || !TEST_true(SSL_set_session(clientssl, sess)))
2095         goto end;
2096
2097     /* Write and read some early data */
2098     if (!TEST_true(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
2099                                         &written))
2100             || !TEST_size_t_eq(written, strlen(MSG1))
2101             || !TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2102                                                 &readbytes),
2103                             SSL_READ_EARLY_DATA_SUCCESS)
2104             || !TEST_mem_eq(buf, readbytes, MSG1, strlen(MSG1)))
2105         goto end;
2106
2107     if (!TEST_int_gt(SSL_connect(clientssl), 0)
2108             || !TEST_int_gt(SSL_accept(serverssl), 0))
2109         goto end;
2110
2111     /* Client and server should not be able to write/read early data now */
2112     if (!TEST_false(SSL_write_early_data(clientssl, MSG6, strlen(MSG6),
2113                                          &written)))
2114         goto end;
2115     ERR_clear_error();
2116     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2117                                          &readbytes),
2118                      SSL_READ_EARLY_DATA_ERROR))
2119         goto end;
2120     ERR_clear_error();
2121
2122     /* Client and server should be able to write/read normal data */
2123     if (!TEST_true(SSL_write_ex(clientssl, MSG5, strlen(MSG5), &written))
2124             || !TEST_size_t_eq(written, strlen(MSG5))
2125             || !TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
2126             || !TEST_size_t_eq(readbytes, strlen(MSG5)))
2127         goto end;
2128
2129     testresult = 1;
2130
2131  end:
2132     SSL_SESSION_free(sess);
2133     SSL_SESSION_free(clientpsk);
2134     SSL_SESSION_free(serverpsk);
2135     clientpsk = serverpsk = NULL;
2136     SSL_free(serverssl);
2137     SSL_free(clientssl);
2138     SSL_CTX_free(sctx);
2139     SSL_CTX_free(cctx);
2140     return testresult;
2141 }
2142
2143 static int test_early_data_replay(int idx)
2144 {
2145     SSL_CTX *cctx = NULL, *sctx = NULL;
2146     SSL *clientssl = NULL, *serverssl = NULL;
2147     int testresult = 0;
2148     SSL_SESSION *sess = NULL;
2149
2150     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
2151                                         &serverssl, &sess, idx)))
2152         goto end;
2153
2154     /*
2155      * The server is configured to accept early data. Create a connection to
2156      * "use up" the ticket
2157      */
2158     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE))
2159             || !TEST_true(SSL_session_reused(clientssl)))
2160         goto end;
2161
2162     SSL_shutdown(clientssl);
2163     SSL_shutdown(serverssl);
2164     SSL_free(serverssl);
2165     SSL_free(clientssl);
2166     serverssl = clientssl = NULL;
2167
2168     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
2169                                       &clientssl, NULL, NULL))
2170             || !TEST_true(SSL_set_session(clientssl, sess))
2171             || !TEST_true(create_ssl_connection(serverssl, clientssl,
2172                           SSL_ERROR_NONE))
2173                /*
2174                 * This time we should not have resumed the session because we
2175                 * already used it once.
2176                 */
2177             || !TEST_false(SSL_session_reused(clientssl)))
2178         goto end;
2179
2180     testresult = 1;
2181
2182  end:
2183     SSL_SESSION_free(sess);
2184     SSL_SESSION_free(clientpsk);
2185     SSL_SESSION_free(serverpsk);
2186     clientpsk = serverpsk = NULL;
2187     SSL_free(serverssl);
2188     SSL_free(clientssl);
2189     SSL_CTX_free(sctx);
2190     SSL_CTX_free(cctx);
2191     return testresult;
2192 }
2193
2194 /*
2195  * Helper function to test that a server attempting to read early data can
2196  * handle a connection from a client where the early data should be skipped.
2197  */
2198 static int early_data_skip_helper(int hrr, int idx)
2199 {
2200     SSL_CTX *cctx = NULL, *sctx = NULL;
2201     SSL *clientssl = NULL, *serverssl = NULL;
2202     int testresult = 0;
2203     SSL_SESSION *sess = NULL;
2204     unsigned char buf[20];
2205     size_t readbytes, written;
2206
2207     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
2208                                         &serverssl, &sess, idx)))
2209         goto end;
2210
2211     if (hrr) {
2212         /* Force an HRR to occur */
2213         if (!TEST_true(SSL_set1_groups_list(serverssl, "P-256")))
2214             goto end;
2215     } else if (idx == 2) {
2216         /*
2217          * We force early_data rejection by ensuring the PSK identity is
2218          * unrecognised
2219          */
2220         srvid = "Dummy Identity";
2221     } else {
2222         /*
2223          * Deliberately corrupt the creation time. We take 20 seconds off the
2224          * time. It could be any value as long as it is not within tolerance.
2225          * This should mean the ticket is rejected.
2226          */
2227         if (!TEST_true(SSL_SESSION_set_time(sess, (long)(time(NULL) - 20))))
2228             goto end;
2229     }
2230
2231     /* Write some early data */
2232     if (!TEST_true(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
2233                                         &written))
2234             || !TEST_size_t_eq(written, strlen(MSG1)))
2235         goto end;
2236
2237     /* Server should reject the early data and skip over it */
2238     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2239                                          &readbytes),
2240                      SSL_READ_EARLY_DATA_FINISH)
2241             || !TEST_size_t_eq(readbytes, 0)
2242             || !TEST_int_eq(SSL_get_early_data_status(serverssl),
2243                             SSL_EARLY_DATA_REJECTED))
2244         goto end;
2245
2246     if (hrr) {
2247         /*
2248          * Finish off the handshake. We perform the same writes and reads as
2249          * further down but we expect them to fail due to the incomplete
2250          * handshake.
2251          */
2252         if (!TEST_false(SSL_write_ex(clientssl, MSG2, strlen(MSG2), &written))
2253                 || !TEST_false(SSL_read_ex(serverssl, buf, sizeof(buf),
2254                                &readbytes)))
2255             goto end;
2256     }
2257
2258     /* Should be able to send normal data despite rejection of early data */
2259     if (!TEST_true(SSL_write_ex(clientssl, MSG2, strlen(MSG2), &written))
2260             || !TEST_size_t_eq(written, strlen(MSG2))
2261             || !TEST_int_eq(SSL_get_early_data_status(clientssl),
2262                             SSL_EARLY_DATA_REJECTED)
2263             || !TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
2264             || !TEST_mem_eq(buf, readbytes, MSG2, strlen(MSG2)))
2265         goto end;
2266
2267     testresult = 1;
2268
2269  end:
2270     SSL_SESSION_free(clientpsk);
2271     SSL_SESSION_free(serverpsk);
2272     clientpsk = serverpsk = NULL;
2273     SSL_SESSION_free(sess);
2274     SSL_free(serverssl);
2275     SSL_free(clientssl);
2276     SSL_CTX_free(sctx);
2277     SSL_CTX_free(cctx);
2278     return testresult;
2279 }
2280
2281 /*
2282  * Test that a server attempting to read early data can handle a connection
2283  * from a client where the early data is not acceptable.
2284  */
2285 static int test_early_data_skip(int idx)
2286 {
2287     return early_data_skip_helper(0, idx);
2288 }
2289
2290 /*
2291  * Test that a server attempting to read early data can handle a connection
2292  * from a client where an HRR occurs.
2293  */
2294 static int test_early_data_skip_hrr(int idx)
2295 {
2296     return early_data_skip_helper(1, idx);
2297 }
2298
2299 /*
2300  * Test that a server attempting to read early data can handle a connection
2301  * from a client that doesn't send any.
2302  */
2303 static int test_early_data_not_sent(int idx)
2304 {
2305     SSL_CTX *cctx = NULL, *sctx = NULL;
2306     SSL *clientssl = NULL, *serverssl = NULL;
2307     int testresult = 0;
2308     SSL_SESSION *sess = NULL;
2309     unsigned char buf[20];
2310     size_t readbytes, written;
2311
2312     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
2313                                         &serverssl, &sess, idx)))
2314         goto end;
2315
2316     /* Write some data - should block due to handshake with server */
2317     SSL_set_connect_state(clientssl);
2318     if (!TEST_false(SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written)))
2319         goto end;
2320
2321     /* Server should detect that early data has not been sent */
2322     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2323                                          &readbytes),
2324                      SSL_READ_EARLY_DATA_FINISH)
2325             || !TEST_size_t_eq(readbytes, 0)
2326             || !TEST_int_eq(SSL_get_early_data_status(serverssl),
2327                             SSL_EARLY_DATA_NOT_SENT)
2328             || !TEST_int_eq(SSL_get_early_data_status(clientssl),
2329                             SSL_EARLY_DATA_NOT_SENT))
2330         goto end;
2331
2332     /* Continue writing the message we started earlier */
2333     if (!TEST_true(SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written))
2334             || !TEST_size_t_eq(written, strlen(MSG1))
2335             || !TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
2336             || !TEST_mem_eq(buf, readbytes, MSG1, strlen(MSG1))
2337             || !SSL_write_ex(serverssl, MSG2, strlen(MSG2), &written)
2338             || !TEST_size_t_eq(written, strlen(MSG2)))
2339         goto end;
2340
2341     /*
2342      * Should block due to the NewSessionTicket arrival unless we're using
2343      * read_ahead, or PSKs
2344      */
2345     if (idx != 1 && idx != 2) {
2346         if (!TEST_false(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes)))
2347             goto end;
2348     }
2349
2350     if (!TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
2351             || !TEST_mem_eq(buf, readbytes, MSG2, strlen(MSG2)))
2352         goto end;
2353
2354     testresult = 1;
2355
2356  end:
2357     SSL_SESSION_free(sess);
2358     SSL_SESSION_free(clientpsk);
2359     SSL_SESSION_free(serverpsk);
2360     clientpsk = serverpsk = NULL;
2361     SSL_free(serverssl);
2362     SSL_free(clientssl);
2363     SSL_CTX_free(sctx);
2364     SSL_CTX_free(cctx);
2365     return testresult;
2366 }
2367
2368 static int hostname_cb(SSL *s, int *al, void *arg)
2369 {
2370     const char *hostname = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
2371
2372     if (hostname != NULL && strcmp(hostname, "goodhost") == 0)
2373         return  SSL_TLSEXT_ERR_OK;
2374
2375     return SSL_TLSEXT_ERR_NOACK;
2376 }
2377
2378 static const char *servalpn;
2379
2380 static int alpn_select_cb(SSL *ssl, const unsigned char **out,
2381                           unsigned char *outlen, const unsigned char *in,
2382                           unsigned int inlen, void *arg)
2383 {
2384     unsigned int protlen = 0;
2385     const unsigned char *prot;
2386
2387     for (prot = in; prot < in + inlen; prot += protlen) {
2388         protlen = *prot++;
2389         if (in + inlen < prot + protlen)
2390             return SSL_TLSEXT_ERR_NOACK;
2391
2392         if (protlen == strlen(servalpn)
2393                 && memcmp(prot, servalpn, protlen) == 0) {
2394             *out = prot;
2395             *outlen = protlen;
2396             return SSL_TLSEXT_ERR_OK;
2397         }
2398     }
2399
2400     return SSL_TLSEXT_ERR_NOACK;
2401 }
2402
2403 /* Test that a PSK can be used to send early_data */
2404 static int test_early_data_psk(int idx)
2405 {
2406     SSL_CTX *cctx = NULL, *sctx = NULL;
2407     SSL *clientssl = NULL, *serverssl = NULL;
2408     int testresult = 0;
2409     SSL_SESSION *sess = NULL;
2410     unsigned char alpnlist[] = {
2411         0x08, 'g', 'o', 'o', 'd', 'a', 'l', 'p', 'n', 0x07, 'b', 'a', 'd', 'a',
2412         'l', 'p', 'n'
2413     };
2414 #define GOODALPNLEN     9
2415 #define BADALPNLEN      8
2416 #define GOODALPN        (alpnlist)
2417 #define BADALPN         (alpnlist + GOODALPNLEN)
2418     int err = 0;
2419     unsigned char buf[20];
2420     size_t readbytes, written;
2421     int readearlyres = SSL_READ_EARLY_DATA_SUCCESS, connectres = 1;
2422     int edstatus = SSL_EARLY_DATA_ACCEPTED;
2423
2424     /* We always set this up with a final parameter of "2" for PSK */
2425     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
2426                                         &serverssl, &sess, 2)))
2427         goto end;
2428
2429     servalpn = "goodalpn";
2430
2431     /*
2432      * Note: There is no test for inconsistent SNI with late client detection.
2433      * This is because servers do not acknowledge SNI even if they are using
2434      * it in a resumption handshake - so it is not actually possible for a
2435      * client to detect a problem.
2436      */
2437     switch (idx) {
2438     case 0:
2439         /* Set inconsistent SNI (early client detection) */
2440         err = SSL_R_INCONSISTENT_EARLY_DATA_SNI;
2441         if (!TEST_true(SSL_SESSION_set1_hostname(sess, "goodhost"))
2442                 || !TEST_true(SSL_set_tlsext_host_name(clientssl, "badhost")))
2443             goto end;
2444         break;
2445
2446     case 1:
2447         /* Set inconsistent ALPN (early client detection) */
2448         err = SSL_R_INCONSISTENT_EARLY_DATA_ALPN;
2449         /* SSL_set_alpn_protos returns 0 for success and 1 for failure */
2450         if (!TEST_true(SSL_SESSION_set1_alpn_selected(sess, GOODALPN,
2451                                                       GOODALPNLEN))
2452                 || !TEST_false(SSL_set_alpn_protos(clientssl, BADALPN,
2453                                                    BADALPNLEN)))
2454             goto end;
2455         break;
2456
2457     case 2:
2458         /*
2459          * Set invalid protocol version. Technically this affects PSKs without
2460          * early_data too, but we test it here because it is similar to the
2461          * SNI/ALPN consistency tests.
2462          */
2463         err = SSL_R_BAD_PSK;
2464         if (!TEST_true(SSL_SESSION_set_protocol_version(sess, TLS1_2_VERSION)))
2465             goto end;
2466         break;
2467
2468     case 3:
2469         /*
2470          * Set inconsistent SNI (server detected). In this case the connection
2471          * will succeed but reject early_data.
2472          */
2473         SSL_SESSION_free(serverpsk);
2474         serverpsk = SSL_SESSION_dup(clientpsk);
2475         if (!TEST_ptr(serverpsk)
2476                 || !TEST_true(SSL_SESSION_set1_hostname(serverpsk, "badhost")))
2477             goto end;
2478         edstatus = SSL_EARLY_DATA_REJECTED;
2479         readearlyres = SSL_READ_EARLY_DATA_FINISH;
2480         /* Fall through */
2481     case 4:
2482         /* Set consistent SNI */
2483         if (!TEST_true(SSL_SESSION_set1_hostname(sess, "goodhost"))
2484                 || !TEST_true(SSL_set_tlsext_host_name(clientssl, "goodhost"))
2485                 || !TEST_true(SSL_CTX_set_tlsext_servername_callback(sctx,
2486                                 hostname_cb)))
2487             goto end;
2488         break;
2489
2490     case 5:
2491         /*
2492          * Set inconsistent ALPN (server detected). In this case the connection
2493          * will succeed but reject early_data.
2494          */
2495         servalpn = "badalpn";
2496         edstatus = SSL_EARLY_DATA_REJECTED;
2497         readearlyres = SSL_READ_EARLY_DATA_FINISH;
2498         /* Fall through */
2499     case 6:
2500         /*
2501          * Set consistent ALPN.
2502          * SSL_set_alpn_protos returns 0 for success and 1 for failure. It
2503          * accepts a list of protos (each one length prefixed).
2504          * SSL_set1_alpn_selected accepts a single protocol (not length
2505          * prefixed)
2506          */
2507         if (!TEST_true(SSL_SESSION_set1_alpn_selected(sess, GOODALPN + 1,
2508                                                       GOODALPNLEN - 1))
2509                 || !TEST_false(SSL_set_alpn_protos(clientssl, GOODALPN,
2510                                                    GOODALPNLEN)))
2511             goto end;
2512
2513         SSL_CTX_set_alpn_select_cb(sctx, alpn_select_cb, NULL);
2514         break;
2515
2516     case 7:
2517         /* Set inconsistent ALPN (late client detection) */
2518         SSL_SESSION_free(serverpsk);
2519         serverpsk = SSL_SESSION_dup(clientpsk);
2520         if (!TEST_ptr(serverpsk)
2521                 || !TEST_true(SSL_SESSION_set1_alpn_selected(clientpsk,
2522                                                              BADALPN + 1,
2523                                                              BADALPNLEN - 1))
2524                 || !TEST_true(SSL_SESSION_set1_alpn_selected(serverpsk,
2525                                                              GOODALPN + 1,
2526                                                              GOODALPNLEN - 1))
2527                 || !TEST_false(SSL_set_alpn_protos(clientssl, alpnlist,
2528                                                    sizeof(alpnlist))))
2529             goto end;
2530         SSL_CTX_set_alpn_select_cb(sctx, alpn_select_cb, NULL);
2531         edstatus = SSL_EARLY_DATA_ACCEPTED;
2532         readearlyres = SSL_READ_EARLY_DATA_SUCCESS;
2533         /* SSL_connect() call should fail */
2534         connectres = -1;
2535         break;
2536
2537     default:
2538         TEST_error("Bad test index");
2539         goto end;
2540     }
2541
2542     SSL_set_connect_state(clientssl);
2543     if (err != 0) {
2544         if (!TEST_false(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
2545                                             &written))
2546                 || !TEST_int_eq(SSL_get_error(clientssl, 0), SSL_ERROR_SSL)
2547                 || !TEST_int_eq(ERR_GET_REASON(ERR_get_error()), err))
2548             goto end;
2549     } else {
2550         if (!TEST_true(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
2551                                             &written)))
2552             goto end;
2553
2554         if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2555                                              &readbytes), readearlyres)
2556                 || (readearlyres == SSL_READ_EARLY_DATA_SUCCESS
2557                     && !TEST_mem_eq(buf, readbytes, MSG1, strlen(MSG1)))
2558                 || !TEST_int_eq(SSL_get_early_data_status(serverssl), edstatus)
2559                 || !TEST_int_eq(SSL_connect(clientssl), connectres))
2560             goto end;
2561     }
2562
2563     testresult = 1;
2564
2565  end:
2566     SSL_SESSION_free(sess);
2567     SSL_SESSION_free(clientpsk);
2568     SSL_SESSION_free(serverpsk);
2569     clientpsk = serverpsk = NULL;
2570     SSL_free(serverssl);
2571     SSL_free(clientssl);
2572     SSL_CTX_free(sctx);
2573     SSL_CTX_free(cctx);
2574     return testresult;
2575 }
2576
2577 /*
2578  * Test that a server that doesn't try to read early data can handle a
2579  * client sending some.
2580  */
2581 static int test_early_data_not_expected(int idx)
2582 {
2583     SSL_CTX *cctx = NULL, *sctx = NULL;
2584     SSL *clientssl = NULL, *serverssl = NULL;
2585     int testresult = 0;
2586     SSL_SESSION *sess = NULL;
2587     unsigned char buf[20];
2588     size_t readbytes, written;
2589
2590     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
2591                                         &serverssl, &sess, idx)))
2592         goto end;
2593
2594     /* Write some early data */
2595     if (!TEST_true(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
2596                                         &written)))
2597         goto end;
2598
2599     /*
2600      * Server should skip over early data and then block waiting for client to
2601      * continue handshake
2602      */
2603     if (!TEST_int_le(SSL_accept(serverssl), 0)
2604      || !TEST_int_gt(SSL_connect(clientssl), 0)
2605      || !TEST_int_eq(SSL_get_early_data_status(serverssl),
2606                      SSL_EARLY_DATA_REJECTED)
2607      || !TEST_int_gt(SSL_accept(serverssl), 0)
2608      || !TEST_int_eq(SSL_get_early_data_status(clientssl),
2609                      SSL_EARLY_DATA_REJECTED))
2610         goto end;
2611
2612     /* Send some normal data from client to server */
2613     if (!TEST_true(SSL_write_ex(clientssl, MSG2, strlen(MSG2), &written))
2614             || !TEST_size_t_eq(written, strlen(MSG2)))
2615         goto end;
2616
2617     if (!TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
2618             || !TEST_mem_eq(buf, readbytes, MSG2, strlen(MSG2)))
2619         goto end;
2620
2621     testresult = 1;
2622
2623  end:
2624     SSL_SESSION_free(sess);
2625     SSL_SESSION_free(clientpsk);
2626     SSL_SESSION_free(serverpsk);
2627     clientpsk = serverpsk = NULL;
2628     SSL_free(serverssl);
2629     SSL_free(clientssl);
2630     SSL_CTX_free(sctx);
2631     SSL_CTX_free(cctx);
2632     return testresult;
2633 }
2634
2635
2636 # ifndef OPENSSL_NO_TLS1_2
2637 /*
2638  * Test that a server attempting to read early data can handle a connection
2639  * from a TLSv1.2 client.
2640  */
2641 static int test_early_data_tls1_2(int idx)
2642 {
2643     SSL_CTX *cctx = NULL, *sctx = NULL;
2644     SSL *clientssl = NULL, *serverssl = NULL;
2645     int testresult = 0;
2646     unsigned char buf[20];
2647     size_t readbytes, written;
2648
2649     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
2650                                         &serverssl, NULL, idx)))
2651         goto end;
2652
2653     /* Write some data - should block due to handshake with server */
2654     SSL_set_max_proto_version(clientssl, TLS1_2_VERSION);
2655     SSL_set_connect_state(clientssl);
2656     if (!TEST_false(SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written)))
2657         goto end;
2658
2659     /*
2660      * Server should do TLSv1.2 handshake. First it will block waiting for more
2661      * messages from client after ServerDone. Then SSL_read_early_data should
2662      * finish and detect that early data has not been sent
2663      */
2664     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2665                                          &readbytes),
2666                      SSL_READ_EARLY_DATA_ERROR))
2667         goto end;
2668
2669     /*
2670      * Continue writing the message we started earlier. Will still block waiting
2671      * for the CCS/Finished from server
2672      */
2673     if (!TEST_false(SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written))
2674             || !TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2675                                                 &readbytes),
2676                             SSL_READ_EARLY_DATA_FINISH)
2677             || !TEST_size_t_eq(readbytes, 0)
2678             || !TEST_int_eq(SSL_get_early_data_status(serverssl),
2679                             SSL_EARLY_DATA_NOT_SENT))
2680         goto end;
2681
2682     /* Continue writing the message we started earlier */
2683     if (!TEST_true(SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written))
2684             || !TEST_size_t_eq(written, strlen(MSG1))
2685             || !TEST_int_eq(SSL_get_early_data_status(clientssl),
2686                             SSL_EARLY_DATA_NOT_SENT)
2687             || !TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
2688             || !TEST_mem_eq(buf, readbytes, MSG1, strlen(MSG1))
2689             || !TEST_true(SSL_write_ex(serverssl, MSG2, strlen(MSG2), &written))
2690             || !TEST_size_t_eq(written, strlen(MSG2))
2691             || !SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes)
2692             || !TEST_mem_eq(buf, readbytes, MSG2, strlen(MSG2)))
2693         goto end;
2694
2695     testresult = 1;
2696
2697  end:
2698     SSL_SESSION_free(clientpsk);
2699     SSL_SESSION_free(serverpsk);
2700     clientpsk = serverpsk = NULL;
2701     SSL_free(serverssl);
2702     SSL_free(clientssl);
2703     SSL_CTX_free(sctx);
2704     SSL_CTX_free(cctx);
2705
2706     return testresult;
2707 }
2708 # endif /* OPENSSL_NO_TLS1_2 */
2709
2710 /*
2711  * Test configuring the TLSv1.3 ciphersuites
2712  *
2713  * Test 0: Set a default ciphersuite in the SSL_CTX (no explicit cipher_list)
2714  * Test 1: Set a non-default ciphersuite in the SSL_CTX (no explicit cipher_list)
2715  * Test 2: Set a default ciphersuite in the SSL (no explicit cipher_list)
2716  * Test 3: Set a non-default ciphersuite in the SSL (no explicit cipher_list)
2717  * Test 4: Set a default ciphersuite in the SSL_CTX (SSL_CTX cipher_list)
2718  * Test 5: Set a non-default ciphersuite in the SSL_CTX (SSL_CTX cipher_list)
2719  * Test 6: Set a default ciphersuite in the SSL (SSL_CTX cipher_list)
2720  * Test 7: Set a non-default ciphersuite in the SSL (SSL_CTX cipher_list)
2721  * Test 8: Set a default ciphersuite in the SSL (SSL cipher_list)
2722  * Test 9: Set a non-default ciphersuite in the SSL (SSL cipher_list)
2723  */
2724 static int test_set_ciphersuite(int idx)
2725 {
2726     SSL_CTX *cctx = NULL, *sctx = NULL;
2727     SSL *clientssl = NULL, *serverssl = NULL;
2728     int testresult = 0;
2729
2730     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
2731                                        TLS1_VERSION, TLS_MAX_VERSION,
2732                                        &sctx, &cctx, cert, privkey))
2733             || !TEST_true(SSL_CTX_set_ciphersuites(sctx,
2734                            "TLS_AES_128_GCM_SHA256:TLS_AES_128_CCM_SHA256")))
2735         goto end;
2736
2737     if (idx >=4 && idx <= 7) {
2738         /* SSL_CTX explicit cipher list */
2739         if (!TEST_true(SSL_CTX_set_cipher_list(cctx, "AES256-GCM-SHA384")))
2740             goto end;
2741     }
2742
2743     if (idx == 0 || idx == 4) {
2744         /* Default ciphersuite */
2745         if (!TEST_true(SSL_CTX_set_ciphersuites(cctx,
2746                                                 "TLS_AES_128_GCM_SHA256")))
2747             goto end;
2748     } else if (idx == 1 || idx == 5) {
2749         /* Non default ciphersuite */
2750         if (!TEST_true(SSL_CTX_set_ciphersuites(cctx,
2751                                                 "TLS_AES_128_CCM_SHA256")))
2752             goto end;
2753     }
2754
2755     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
2756                                           &clientssl, NULL, NULL)))
2757         goto end;
2758
2759     if (idx == 8 || idx == 9) {
2760         /* SSL explicit cipher list */
2761         if (!TEST_true(SSL_set_cipher_list(clientssl, "AES256-GCM-SHA384")))
2762             goto end;
2763     }
2764
2765     if (idx == 2 || idx == 6 || idx == 8) {
2766         /* Default ciphersuite */
2767         if (!TEST_true(SSL_set_ciphersuites(clientssl,
2768                                             "TLS_AES_128_GCM_SHA256")))
2769             goto end;
2770     } else if (idx == 3 || idx == 7 || idx == 9) {
2771         /* Non default ciphersuite */
2772         if (!TEST_true(SSL_set_ciphersuites(clientssl,
2773                                             "TLS_AES_128_CCM_SHA256")))
2774             goto end;
2775     }
2776
2777     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
2778         goto end;
2779
2780     testresult = 1;
2781
2782  end:
2783     SSL_free(serverssl);
2784     SSL_free(clientssl);
2785     SSL_CTX_free(sctx);
2786     SSL_CTX_free(cctx);
2787
2788     return testresult;
2789 }
2790
2791 static int test_ciphersuite_change(void)
2792 {
2793     SSL_CTX *cctx = NULL, *sctx = NULL;
2794     SSL *clientssl = NULL, *serverssl = NULL;
2795     SSL_SESSION *clntsess = NULL;
2796     int testresult = 0;
2797     const SSL_CIPHER *aes_128_gcm_sha256 = NULL;
2798
2799     /* Create a session based on SHA-256 */
2800     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
2801                                        TLS1_VERSION, TLS_MAX_VERSION,
2802                                        &sctx, &cctx, cert, privkey))
2803             || !TEST_true(SSL_CTX_set_ciphersuites(cctx,
2804                                                    "TLS_AES_128_GCM_SHA256"))
2805             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
2806                                           &clientssl, NULL, NULL))
2807             || !TEST_true(create_ssl_connection(serverssl, clientssl,
2808                                                 SSL_ERROR_NONE)))
2809         goto end;
2810
2811     clntsess = SSL_get1_session(clientssl);
2812     /* Save for later */
2813     aes_128_gcm_sha256 = SSL_SESSION_get0_cipher(clntsess);
2814     SSL_shutdown(clientssl);
2815     SSL_shutdown(serverssl);
2816     SSL_free(serverssl);
2817     SSL_free(clientssl);
2818     serverssl = clientssl = NULL;
2819
2820 # if !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305)
2821     /* Check we can resume a session with a different SHA-256 ciphersuite */
2822     if (!TEST_true(SSL_CTX_set_ciphersuites(cctx,
2823                                             "TLS_CHACHA20_POLY1305_SHA256"))
2824             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
2825                                              NULL, NULL))
2826             || !TEST_true(SSL_set_session(clientssl, clntsess))
2827             || !TEST_true(create_ssl_connection(serverssl, clientssl,
2828                                                 SSL_ERROR_NONE))
2829             || !TEST_true(SSL_session_reused(clientssl)))
2830         goto end;
2831
2832     SSL_SESSION_free(clntsess);
2833     clntsess = SSL_get1_session(clientssl);
2834     SSL_shutdown(clientssl);
2835     SSL_shutdown(serverssl);
2836     SSL_free(serverssl);
2837     SSL_free(clientssl);
2838     serverssl = clientssl = NULL;
2839 # endif
2840
2841     /*
2842      * Check attempting to resume a SHA-256 session with no SHA-256 ciphersuites
2843      * succeeds but does not resume.
2844      */
2845     if (!TEST_true(SSL_CTX_set_ciphersuites(cctx, "TLS_AES_256_GCM_SHA384"))
2846             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
2847                                              NULL, NULL))
2848             || !TEST_true(SSL_set_session(clientssl, clntsess))
2849             || !TEST_true(create_ssl_connection(serverssl, clientssl,
2850                                                 SSL_ERROR_SSL))
2851             || !TEST_false(SSL_session_reused(clientssl)))
2852         goto end;
2853
2854     SSL_SESSION_free(clntsess);
2855     clntsess = NULL;
2856     SSL_shutdown(clientssl);
2857     SSL_shutdown(serverssl);
2858     SSL_free(serverssl);
2859     SSL_free(clientssl);
2860     serverssl = clientssl = NULL;
2861
2862     /* Create a session based on SHA384 */
2863     if (!TEST_true(SSL_CTX_set_ciphersuites(cctx, "TLS_AES_256_GCM_SHA384"))
2864             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
2865                                           &clientssl, NULL, NULL))
2866             || !TEST_true(create_ssl_connection(serverssl, clientssl,
2867                                                 SSL_ERROR_NONE)))
2868         goto end;
2869
2870     clntsess = SSL_get1_session(clientssl);
2871     SSL_shutdown(clientssl);
2872     SSL_shutdown(serverssl);
2873     SSL_free(serverssl);
2874     SSL_free(clientssl);
2875     serverssl = clientssl = NULL;
2876
2877     if (!TEST_true(SSL_CTX_set_ciphersuites(cctx,
2878                    "TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384"))
2879             || !TEST_true(SSL_CTX_set_ciphersuites(sctx,
2880                                                    "TLS_AES_256_GCM_SHA384"))
2881             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
2882                                              NULL, NULL))
2883             || !TEST_true(SSL_set_session(clientssl, clntsess))
2884                /*
2885                 * We use SSL_ERROR_WANT_READ below so that we can pause the
2886                 * connection after the initial ClientHello has been sent to
2887                 * enable us to make some session changes.
2888                 */
2889             || !TEST_false(create_ssl_connection(serverssl, clientssl,
2890                                                 SSL_ERROR_WANT_READ)))
2891         goto end;
2892
2893     /* Trick the client into thinking this session is for a different digest */
2894     clntsess->cipher = aes_128_gcm_sha256;
2895     clntsess->cipher_id = clntsess->cipher->id;
2896
2897     /*
2898      * Continue the previously started connection. Server has selected a SHA-384
2899      * ciphersuite, but client thinks the session is for SHA-256, so it should
2900      * bail out.
2901      */
2902     if (!TEST_false(create_ssl_connection(serverssl, clientssl,
2903                                                 SSL_ERROR_SSL))
2904             || !TEST_int_eq(ERR_GET_REASON(ERR_get_error()),
2905                             SSL_R_CIPHERSUITE_DIGEST_HAS_CHANGED))
2906         goto end;
2907
2908     testresult = 1;
2909
2910  end:
2911     SSL_SESSION_free(clntsess);
2912     SSL_free(serverssl);
2913     SSL_free(clientssl);
2914     SSL_CTX_free(sctx);
2915     SSL_CTX_free(cctx);
2916
2917     return testresult;
2918 }
2919
2920 /*
2921  * Test TLSv1.3 PSKs
2922  * Test 0 = Test new style callbacks
2923  * Test 1 = Test both new and old style callbacks
2924  * Test 2 = Test old style callbacks
2925  * Test 3 = Test old style callbacks with no certificate
2926  */
2927 static int test_tls13_psk(int idx)
2928 {
2929     SSL_CTX *sctx = NULL, *cctx = NULL;
2930     SSL *serverssl = NULL, *clientssl = NULL;
2931     const SSL_CIPHER *cipher = NULL;
2932     const unsigned char key[] = {
2933         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
2934         0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
2935         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
2936         0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f
2937     };
2938     int testresult = 0;
2939
2940     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
2941                                        TLS1_VERSION, TLS_MAX_VERSION,
2942                                        &sctx, &cctx, idx == 3 ? NULL : cert,
2943                                        idx == 3 ? NULL : privkey)))
2944         goto end;
2945
2946     if (idx != 3) {
2947         /*
2948          * We use a ciphersuite with SHA256 to ease testing old style PSK
2949          * callbacks which will always default to SHA256. This should not be
2950          * necessary if we have no cert/priv key. In that case the server should
2951          * prefer SHA256 automatically.
2952          */
2953         if (!TEST_true(SSL_CTX_set_ciphersuites(cctx,
2954                                                 "TLS_AES_128_GCM_SHA256")))
2955             goto end;
2956     }
2957
2958     /*
2959      * Test 0: New style callbacks only
2960      * Test 1: New and old style callbacks (only the new ones should be used)
2961      * Test 2: Old style callbacks only
2962      */
2963     if (idx == 0 || idx == 1) {
2964         SSL_CTX_set_psk_use_session_callback(cctx, use_session_cb);
2965         SSL_CTX_set_psk_find_session_callback(sctx, find_session_cb);
2966     }
2967 #ifndef OPENSSL_NO_PSK
2968     if (idx >= 1) {
2969         SSL_CTX_set_psk_client_callback(cctx, psk_client_cb);
2970         SSL_CTX_set_psk_server_callback(sctx, psk_server_cb);
2971     }
2972 #endif
2973     srvid = pskid;
2974     use_session_cb_cnt = 0;
2975     find_session_cb_cnt = 0;
2976     psk_client_cb_cnt = 0;
2977     psk_server_cb_cnt = 0;
2978
2979     if (idx != 3) {
2980         /*
2981          * Check we can create a connection if callback decides not to send a
2982          * PSK
2983          */
2984         if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
2985                                                  NULL, NULL))
2986                 || !TEST_true(create_ssl_connection(serverssl, clientssl,
2987                                                     SSL_ERROR_NONE))
2988                 || !TEST_false(SSL_session_reused(clientssl))
2989                 || !TEST_false(SSL_session_reused(serverssl)))
2990             goto end;
2991
2992         if (idx == 0 || idx == 1) {
2993             if (!TEST_true(use_session_cb_cnt == 1)
2994                     || !TEST_true(find_session_cb_cnt == 0)
2995                        /*
2996                         * If no old style callback then below should be 0
2997                         * otherwise 1
2998                         */
2999                     || !TEST_true(psk_client_cb_cnt == idx)
3000                     || !TEST_true(psk_server_cb_cnt == 0))
3001                 goto end;
3002         } else {
3003             if (!TEST_true(use_session_cb_cnt == 0)
3004                     || !TEST_true(find_session_cb_cnt == 0)
3005                     || !TEST_true(psk_client_cb_cnt == 1)
3006                     || !TEST_true(psk_server_cb_cnt == 0))
3007                 goto end;
3008         }
3009
3010         shutdown_ssl_connection(serverssl, clientssl);
3011         serverssl = clientssl = NULL;
3012         use_session_cb_cnt = psk_client_cb_cnt = 0;
3013     }
3014
3015     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
3016                                              NULL, NULL)))
3017         goto end;
3018
3019     /* Create the PSK */
3020     cipher = SSL_CIPHER_find(clientssl, TLS13_AES_128_GCM_SHA256_BYTES);
3021     clientpsk = SSL_SESSION_new();
3022     if (!TEST_ptr(clientpsk)
3023             || !TEST_ptr(cipher)
3024             || !TEST_true(SSL_SESSION_set1_master_key(clientpsk, key,
3025                                                       sizeof(key)))
3026             || !TEST_true(SSL_SESSION_set_cipher(clientpsk, cipher))
3027             || !TEST_true(SSL_SESSION_set_protocol_version(clientpsk,
3028                                                            TLS1_3_VERSION))
3029             || !TEST_true(SSL_SESSION_up_ref(clientpsk)))
3030         goto end;
3031     serverpsk = clientpsk;
3032
3033     /* Check we can create a connection and the PSK is used */
3034     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE))
3035             || !TEST_true(SSL_session_reused(clientssl))
3036             || !TEST_true(SSL_session_reused(serverssl)))
3037         goto end;
3038
3039     if (idx == 0 || idx == 1) {
3040         if (!TEST_true(use_session_cb_cnt == 1)
3041                 || !TEST_true(find_session_cb_cnt == 1)
3042                 || !TEST_true(psk_client_cb_cnt == 0)
3043                 || !TEST_true(psk_server_cb_cnt == 0))
3044             goto end;
3045     } else {
3046         if (!TEST_true(use_session_cb_cnt == 0)
3047                 || !TEST_true(find_session_cb_cnt == 0)
3048                 || !TEST_true(psk_client_cb_cnt == 1)
3049                 || !TEST_true(psk_server_cb_cnt == 1))
3050             goto end;
3051     }
3052
3053     shutdown_ssl_connection(serverssl, clientssl);
3054     serverssl = clientssl = NULL;
3055     use_session_cb_cnt = find_session_cb_cnt = 0;
3056     psk_client_cb_cnt = psk_server_cb_cnt = 0;
3057
3058     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
3059                                              NULL, NULL)))
3060         goto end;
3061
3062     /* Force an HRR */
3063     if (!TEST_true(SSL_set1_groups_list(serverssl, "P-256")))
3064         goto end;
3065
3066     /*
3067      * Check we can create a connection, the PSK is used and the callbacks are
3068      * called twice.
3069      */
3070     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE))
3071             || !TEST_true(SSL_session_reused(clientssl))
3072             || !TEST_true(SSL_session_reused(serverssl)))
3073         goto end;
3074
3075     if (idx == 0 || idx == 1) {
3076         if (!TEST_true(use_session_cb_cnt == 2)
3077                 || !TEST_true(find_session_cb_cnt == 2)
3078                 || !TEST_true(psk_client_cb_cnt == 0)
3079                 || !TEST_true(psk_server_cb_cnt == 0))
3080             goto end;
3081     } else {
3082         if (!TEST_true(use_session_cb_cnt == 0)
3083                 || !TEST_true(find_session_cb_cnt == 0)
3084                 || !TEST_true(psk_client_cb_cnt == 2)
3085                 || !TEST_true(psk_server_cb_cnt == 2))
3086             goto end;
3087     }
3088
3089     shutdown_ssl_connection(serverssl, clientssl);
3090     serverssl = clientssl = NULL;
3091     use_session_cb_cnt = find_session_cb_cnt = 0;
3092     psk_client_cb_cnt = psk_server_cb_cnt = 0;
3093
3094     if (idx != 3) {
3095         /*
3096          * Check that if the server rejects the PSK we can still connect, but with
3097          * a full handshake
3098          */
3099         srvid = "Dummy Identity";
3100         if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
3101                                                  NULL, NULL))
3102                 || !TEST_true(create_ssl_connection(serverssl, clientssl,
3103                                                     SSL_ERROR_NONE))
3104                 || !TEST_false(SSL_session_reused(clientssl))
3105                 || !TEST_false(SSL_session_reused(serverssl)))
3106             goto end;
3107
3108         if (idx == 0 || idx == 1) {
3109             if (!TEST_true(use_session_cb_cnt == 1)
3110                     || !TEST_true(find_session_cb_cnt == 1)
3111                     || !TEST_true(psk_client_cb_cnt == 0)
3112                        /*
3113                         * If no old style callback then below should be 0
3114                         * otherwise 1
3115                         */
3116                     || !TEST_true(psk_server_cb_cnt == idx))
3117                 goto end;
3118         } else {
3119             if (!TEST_true(use_session_cb_cnt == 0)
3120                     || !TEST_true(find_session_cb_cnt == 0)
3121                     || !TEST_true(psk_client_cb_cnt == 1)
3122                     || !TEST_true(psk_server_cb_cnt == 1))
3123                 goto end;
3124         }
3125
3126         shutdown_ssl_connection(serverssl, clientssl);
3127         serverssl = clientssl = NULL;
3128     }
3129     testresult = 1;
3130
3131  end:
3132     SSL_SESSION_free(clientpsk);
3133     SSL_SESSION_free(serverpsk);
3134     clientpsk = serverpsk = NULL;
3135     SSL_free(serverssl);
3136     SSL_free(clientssl);
3137     SSL_CTX_free(sctx);
3138     SSL_CTX_free(cctx);
3139     return testresult;
3140 }
3141
3142 static unsigned char cookie_magic_value[] = "cookie magic";
3143
3144 static int generate_cookie_callback(SSL *ssl, unsigned char *cookie,
3145                                     unsigned int *cookie_len)
3146 {
3147     /*
3148      * Not suitable as a real cookie generation function but good enough for
3149      * testing!
3150      */
3151     memcpy(cookie, cookie_magic_value, sizeof(cookie_magic_value) - 1);
3152     *cookie_len = sizeof(cookie_magic_value) - 1;
3153
3154     return 1;
3155 }
3156
3157 static int verify_cookie_callback(SSL *ssl, const unsigned char *cookie,
3158                                   unsigned int cookie_len)
3159 {
3160     if (cookie_len == sizeof(cookie_magic_value) - 1
3161         && memcmp(cookie, cookie_magic_value, cookie_len) == 0)
3162         return 1;
3163
3164     return 0;
3165 }
3166
3167 static int generate_stateless_cookie_callback(SSL *ssl, unsigned char *cookie,
3168                                         size_t *cookie_len)
3169 {
3170     unsigned int temp;
3171     int res = generate_cookie_callback(ssl, cookie, &temp);
3172     *cookie_len = temp;
3173     return res;
3174 }
3175
3176 static int verify_stateless_cookie_callback(SSL *ssl, const unsigned char *cookie,
3177                                       size_t cookie_len)
3178 {
3179     return verify_cookie_callback(ssl, cookie, cookie_len);
3180 }
3181
3182 static int test_stateless(void)
3183 {
3184     SSL_CTX *sctx = NULL, *cctx = NULL;
3185     SSL *serverssl = NULL, *clientssl = NULL;
3186     int testresult = 0;
3187
3188     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
3189                                        TLS1_VERSION, TLS_MAX_VERSION,
3190                                        &sctx, &cctx, cert, privkey)))
3191         goto end;
3192
3193     /* The arrival of CCS messages can confuse the test */
3194     SSL_CTX_clear_options(cctx, SSL_OP_ENABLE_MIDDLEBOX_COMPAT);
3195
3196     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
3197                                       NULL, NULL))
3198                /* Send the first ClientHello */
3199             || !TEST_false(create_ssl_connection(serverssl, clientssl,
3200                                                  SSL_ERROR_WANT_READ))
3201                /*
3202                 * This should fail with a -1 return because we have no callbacks
3203                 * set up
3204                 */
3205             || !TEST_int_eq(SSL_stateless(serverssl), -1))
3206         goto end;
3207
3208     /* Fatal error so abandon the connection from this client */
3209     SSL_free(clientssl);
3210     clientssl = NULL;
3211
3212     /* Set up the cookie generation and verification callbacks */
3213     SSL_CTX_set_stateless_cookie_generate_cb(sctx, generate_stateless_cookie_callback);
3214     SSL_CTX_set_stateless_cookie_verify_cb(sctx, verify_stateless_cookie_callback);
3215
3216     /*
3217      * Create a new connection from the client (we can reuse the server SSL
3218      * object).
3219      */
3220     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
3221                                              NULL, NULL))
3222                /* Send the first ClientHello */
3223             || !TEST_false(create_ssl_connection(serverssl, clientssl,
3224                                                 SSL_ERROR_WANT_READ))
3225                /* This should fail because there is no cookie */
3226             || !TEST_int_eq(SSL_stateless(serverssl), 0))
3227         goto end;
3228
3229     /* Abandon the connection from this client */
3230     SSL_free(clientssl);
3231     clientssl = NULL;
3232
3233     /*
3234      * Now create a connection from a new client but with the same server SSL
3235      * object
3236      */
3237     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
3238                                              NULL, NULL))
3239                /* Send the first ClientHello */
3240             || !TEST_false(create_ssl_connection(serverssl, clientssl,
3241                                                 SSL_ERROR_WANT_READ))
3242                /* This should fail because there is no cookie */
3243             || !TEST_int_eq(SSL_stateless(serverssl), 0)
3244                /* Send the second ClientHello */
3245             || !TEST_false(create_ssl_connection(serverssl, clientssl,
3246                                                 SSL_ERROR_WANT_READ))
3247                /* This should succeed because a cookie is now present */
3248             || !TEST_int_eq(SSL_stateless(serverssl), 1)
3249                /* Complete the connection */
3250             || !TEST_true(create_ssl_connection(serverssl, clientssl,
3251                                                 SSL_ERROR_NONE)))
3252         goto end;
3253
3254     shutdown_ssl_connection(serverssl, clientssl);
3255     serverssl = clientssl = NULL;
3256     testresult = 1;
3257
3258  end:
3259     SSL_free(serverssl);
3260     SSL_free(clientssl);
3261     SSL_CTX_free(sctx);
3262     SSL_CTX_free(cctx);
3263     return testresult;
3264
3265 }
3266 #endif /* OPENSSL_NO_TLS1_3 */
3267
3268 static int clntaddoldcb = 0;
3269 static int clntparseoldcb = 0;
3270 static int srvaddoldcb = 0;
3271 static int srvparseoldcb = 0;
3272 static int clntaddnewcb = 0;
3273 static int clntparsenewcb = 0;
3274 static int srvaddnewcb = 0;
3275 static int srvparsenewcb = 0;
3276 static int snicb = 0;
3277
3278 #define TEST_EXT_TYPE1  0xff00
3279
3280 static int old_add_cb(SSL *s, unsigned int ext_type, const unsigned char **out,
3281                       size_t *outlen, int *al, void *add_arg)
3282 {
3283     int *server = (int *)add_arg;
3284     unsigned char *data;
3285
3286     if (SSL_is_server(s))
3287         srvaddoldcb++;
3288     else
3289         clntaddoldcb++;
3290
3291     if (*server != SSL_is_server(s)
3292             || (data = OPENSSL_malloc(sizeof(*data))) == NULL)
3293         return -1;
3294
3295     *data = 1;
3296     *out = data;
3297     *outlen = sizeof(char);
3298     return 1;
3299 }
3300
3301 static void old_free_cb(SSL *s, unsigned int ext_type, const unsigned char *out,
3302                         void *add_arg)
3303 {
3304     OPENSSL_free((unsigned char *)out);
3305 }
3306
3307 static int old_parse_cb(SSL *s, unsigned int ext_type, const unsigned char *in,
3308                         size_t inlen, int *al, void *parse_arg)
3309 {
3310     int *server = (int *)parse_arg;
3311
3312     if (SSL_is_server(s))
3313         srvparseoldcb++;
3314     else
3315         clntparseoldcb++;
3316
3317     if (*server != SSL_is_server(s)
3318             || inlen != sizeof(char)
3319             || *in != 1)
3320         return -1;
3321
3322     return 1;
3323 }
3324
3325 static int new_add_cb(SSL *s, unsigned int ext_type, unsigned int context,
3326                       const unsigned char **out, size_t *outlen, X509 *x,
3327                       size_t chainidx, int *al, void *add_arg)
3328 {
3329     int *server = (int *)add_arg;
3330     unsigned char *data;
3331
3332     if (SSL_is_server(s))
3333         srvaddnewcb++;
3334     else
3335         clntaddnewcb++;
3336
3337     if (*server != SSL_is_server(s)
3338             || (data = OPENSSL_malloc(sizeof(*data))) == NULL)
3339         return -1;
3340
3341     *data = 1;
3342     *out = data;
3343     *outlen = sizeof(*data);
3344     return 1;
3345 }
3346
3347 static void new_free_cb(SSL *s, unsigned int ext_type, unsigned int context,
3348                         const unsigned char *out, void *add_arg)
3349 {
3350     OPENSSL_free((unsigned char *)out);
3351 }
3352
3353 static int new_parse_cb(SSL *s, unsigned int ext_type, unsigned int context,
3354                         const unsigned char *in, size_t inlen, X509 *x,
3355                         size_t chainidx, int *al, void *parse_arg)
3356 {
3357     int *server = (int *)parse_arg;
3358
3359     if (SSL_is_server(s))
3360         srvparsenewcb++;
3361     else
3362         clntparsenewcb++;
3363
3364     if (*server != SSL_is_server(s)
3365             || inlen != sizeof(char) || *in != 1)
3366         return -1;
3367
3368     return 1;
3369 }
3370
3371 static int sni_cb(SSL *s, int *al, void *arg)
3372 {
3373     SSL_CTX *ctx = (SSL_CTX *)arg;
3374
3375     if (SSL_set_SSL_CTX(s, ctx) == NULL) {
3376         *al = SSL_AD_INTERNAL_ERROR;
3377         return SSL_TLSEXT_ERR_ALERT_FATAL;
3378     }
3379     snicb++;
3380     return SSL_TLSEXT_ERR_OK;
3381 }
3382
3383 /*
3384  * Custom call back tests.
3385  * Test 0: Old style callbacks in TLSv1.2
3386  * Test 1: New style callbacks in TLSv1.2
3387  * Test 2: New style callbacks in TLSv1.2 with SNI
3388  * Test 3: New style callbacks in TLSv1.3. Extensions in CH and EE
3389  * Test 4: New style callbacks in TLSv1.3. Extensions in CH, SH, EE, Cert + NST
3390  */
3391 static int test_custom_exts(int tst)
3392 {
3393     SSL_CTX *cctx = NULL, *sctx = NULL, *sctx2 = NULL;
3394     SSL *clientssl = NULL, *serverssl = NULL;
3395     int testresult = 0;
3396     static int server = 1;
3397     static int client = 0;
3398     SSL_SESSION *sess = NULL;
3399     unsigned int context;
3400
3401 #if defined(OPENSSL_NO_TLS1_2) && !defined(OPENSSL_NO_TLS1_3)
3402     /* Skip tests for TLSv1.2 and below in this case */
3403     if (tst < 3)
3404         return 1;
3405 #endif
3406
3407     /* Reset callback counters */
3408     clntaddoldcb = clntparseoldcb = srvaddoldcb = srvparseoldcb = 0;
3409     clntaddnewcb = clntparsenewcb = srvaddnewcb = srvparsenewcb = 0;
3410     snicb = 0;
3411
3412     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
3413                                        TLS1_VERSION, TLS_MAX_VERSION,
3414                                        &sctx, &cctx, cert, privkey)))
3415         goto end;
3416
3417     if (tst == 2
3418             && !TEST_true(create_ssl_ctx_pair(TLS_server_method(), NULL,
3419                                               TLS1_VERSION, TLS_MAX_VERSION,
3420                                               &sctx2, NULL, cert, privkey)))
3421         goto end;
3422
3423
3424     if (tst < 3) {
3425         SSL_CTX_set_options(cctx, SSL_OP_NO_TLSv1_3);
3426         SSL_CTX_set_options(sctx, SSL_OP_NO_TLSv1_3);
3427         if (sctx2 != NULL)
3428             SSL_CTX_set_options(sctx2, SSL_OP_NO_TLSv1_3);
3429     }
3430
3431     if (tst == 4) {
3432         context = SSL_EXT_CLIENT_HELLO
3433                   | SSL_EXT_TLS1_2_SERVER_HELLO
3434                   | SSL_EXT_TLS1_3_SERVER_HELLO
3435                   | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS
3436                   | SSL_EXT_TLS1_3_CERTIFICATE
3437                   | SSL_EXT_TLS1_3_NEW_SESSION_TICKET;
3438     } else {
3439         context = SSL_EXT_CLIENT_HELLO
3440                   | SSL_EXT_TLS1_2_SERVER_HELLO
3441                   | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS;
3442     }
3443
3444     /* Create a client side custom extension */
3445     if (tst == 0) {
3446         if (!TEST_true(SSL_CTX_add_client_custom_ext(cctx, TEST_EXT_TYPE1,
3447                                                      old_add_cb, old_free_cb,
3448                                                      &client, old_parse_cb,
3449                                                      &client)))
3450             goto end;
3451     } else {
3452         if (!TEST_true(SSL_CTX_add_custom_ext(cctx, TEST_EXT_TYPE1, context,
3453                                               new_add_cb, new_free_cb,
3454                                               &client, new_parse_cb, &client)))
3455             goto end;
3456     }
3457
3458     /* Should not be able to add duplicates */
3459     if (!TEST_false(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             || !TEST_false(SSL_CTX_add_custom_ext(cctx, TEST_EXT_TYPE1,
3464                                                   context, new_add_cb,
3465                                                   new_free_cb, &client,
3466                                                   new_parse_cb, &client)))
3467         goto end;
3468
3469     /* Create a server side custom extension */
3470     if (tst == 0) {
3471         if (!TEST_true(SSL_CTX_add_server_custom_ext(sctx, TEST_EXT_TYPE1,
3472                                                      old_add_cb, old_free_cb,
3473                                                      &server, old_parse_cb,
3474                                                      &server)))
3475             goto end;
3476     } else {
3477         if (!TEST_true(SSL_CTX_add_custom_ext(sctx, TEST_EXT_TYPE1, context,
3478                                               new_add_cb, new_free_cb,
3479                                               &server, new_parse_cb, &server)))
3480             goto end;
3481         if (sctx2 != NULL
3482                 && !TEST_true(SSL_CTX_add_custom_ext(sctx2, TEST_EXT_TYPE1,
3483                                                      context, new_add_cb,
3484                                                      new_free_cb, &server,
3485                                                      new_parse_cb, &server)))
3486             goto end;
3487     }
3488
3489     /* Should not be able to add duplicates */
3490     if (!TEST_false(SSL_CTX_add_server_custom_ext(sctx, TEST_EXT_TYPE1,
3491                                                   old_add_cb, old_free_cb,
3492                                                   &server, old_parse_cb,
3493                                                   &server))
3494             || !TEST_false(SSL_CTX_add_custom_ext(sctx, TEST_EXT_TYPE1,
3495                                                   context, new_add_cb,
3496                                                   new_free_cb, &server,
3497                                                   new_parse_cb, &server)))
3498         goto end;
3499
3500     if (tst == 2) {
3501         /* Set up SNI */
3502         if (!TEST_true(SSL_CTX_set_tlsext_servername_callback(sctx, sni_cb))