598b02a0566c6b1deb65e56d5a32ccf65f073359
[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. Since we attempted a resume we should also have removed the
948          * old ticket from the cache so that we try to only use tickets once.
949          */
950         if (use_ext_cache
951                 && (!TEST_int_eq(new_called, 1)
952                     || !TEST_int_eq(remove_called, 1)))
953             goto end;
954     } else {
955         /*
956          * In TLSv1.2 we expect to have resumed so no sessions added or
957          * removed.
958          */
959         if (use_ext_cache
960                 && (!TEST_int_eq(new_called, 0)
961                     || !TEST_int_eq(remove_called, 0)))
962             goto end;
963     }
964
965     SSL_SESSION_free(sess1);
966     if (!TEST_ptr(sess1 = SSL_get1_session(clientssl2)))
967         goto end;
968     shutdown_ssl_connection(serverssl2, clientssl2);
969     serverssl2 = clientssl2 = NULL;
970
971     new_called = remove_called = 0;
972     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl2,
973                                       &clientssl2, NULL, NULL))
974             || !TEST_true(create_ssl_connection(serverssl2, clientssl2,
975                                                 SSL_ERROR_NONE)))
976         goto end;
977
978     if (!TEST_ptr(sess2 = SSL_get1_session(clientssl2)))
979         goto end;
980
981     if (use_ext_cache
982             && (!TEST_int_eq(new_called, numnewsesstick)
983                 || !TEST_int_eq(remove_called, 0)))
984         goto end;
985
986     new_called = remove_called = 0;
987     /*
988      * This should clear sess2 from the cache because it is a "bad" session.
989      * See SSL_set_session() documentation.
990      */
991     if (!TEST_true(SSL_set_session(clientssl2, sess1)))
992         goto end;
993     if (use_ext_cache
994             && (!TEST_int_eq(new_called, 0) || !TEST_int_eq(remove_called, 1)))
995         goto end;
996     if (!TEST_ptr_eq(SSL_get_session(clientssl2), sess1))
997         goto end;
998
999     if (use_int_cache) {
1000         /* Should succeeded because it should not already be in the cache */
1001         if (!TEST_true(SSL_CTX_add_session(cctx, sess2))
1002                 || !TEST_true(SSL_CTX_remove_session(cctx, sess2)))
1003             goto end;
1004     }
1005
1006     new_called = remove_called = 0;
1007     /* This shouldn't be in the cache so should fail */
1008     if (!TEST_false(SSL_CTX_remove_session(cctx, sess2)))
1009         goto end;
1010
1011     if (use_ext_cache
1012             && (!TEST_int_eq(new_called, 0) || !TEST_int_eq(remove_called, 1)))
1013         goto end;
1014
1015 # if !defined(OPENSSL_NO_TLS1_1)
1016     new_called = remove_called = 0;
1017     /* Force a connection failure */
1018     SSL_CTX_set_max_proto_version(sctx, TLS1_1_VERSION);
1019     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl3,
1020                                       &clientssl3, NULL, NULL))
1021             || !TEST_true(SSL_set_session(clientssl3, sess1))
1022             /* This should fail because of the mismatched protocol versions */
1023             || !TEST_false(create_ssl_connection(serverssl3, clientssl3,
1024                                                  SSL_ERROR_NONE)))
1025         goto end;
1026
1027     /* We should have automatically removed the session from the cache */
1028     if (use_ext_cache
1029             && (!TEST_int_eq(new_called, 0) || !TEST_int_eq(remove_called, 1)))
1030         goto end;
1031
1032     /* Should succeed because it should not already be in the cache */
1033     if (use_int_cache && !TEST_true(SSL_CTX_add_session(cctx, sess2)))
1034         goto end;
1035 # endif
1036
1037     /* Now do some tests for server side caching */
1038     if (use_ext_cache) {
1039         SSL_CTX_sess_set_new_cb(cctx, NULL);
1040         SSL_CTX_sess_set_remove_cb(cctx, NULL);
1041         SSL_CTX_sess_set_new_cb(sctx, new_session_cb);
1042         SSL_CTX_sess_set_remove_cb(sctx, remove_session_cb);
1043         SSL_CTX_sess_set_get_cb(sctx, get_session_cb);
1044         get_sess_val = NULL;
1045     }
1046
1047     SSL_CTX_set_session_cache_mode(cctx, 0);
1048     /* Internal caching is the default on the server side */
1049     if (!use_int_cache)
1050         SSL_CTX_set_session_cache_mode(sctx,
1051                                        SSL_SESS_CACHE_SERVER
1052                                        | SSL_SESS_CACHE_NO_INTERNAL_STORE);
1053
1054     SSL_free(serverssl1);
1055     SSL_free(clientssl1);
1056     serverssl1 = clientssl1 = NULL;
1057     SSL_free(serverssl2);
1058     SSL_free(clientssl2);
1059     serverssl2 = clientssl2 = NULL;
1060     SSL_SESSION_free(sess1);
1061     sess1 = NULL;
1062     SSL_SESSION_free(sess2);
1063     sess2 = NULL;
1064
1065     SSL_CTX_set_max_proto_version(sctx, maxprot);
1066     if (maxprot == TLS1_2_VERSION)
1067         SSL_CTX_set_options(sctx, SSL_OP_NO_TICKET);
1068     new_called = remove_called = get_called = 0;
1069     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl1, &clientssl1,
1070                                       NULL, NULL))
1071             || !TEST_true(create_ssl_connection(serverssl1, clientssl1,
1072                                                 SSL_ERROR_NONE))
1073             || !TEST_ptr(sess1 = SSL_get1_session(clientssl1))
1074             || !TEST_ptr(sess2 = SSL_get1_session(serverssl1)))
1075         goto end;
1076
1077     if (use_int_cache) {
1078         if (maxprot == TLS1_3_VERSION && !use_ext_cache) {
1079             /*
1080              * In TLSv1.3 it should not have been added to the internal cache,
1081              * except in the case where we also have an external cache (in that
1082              * case it gets added to the cache in order to generate remove
1083              * events after timeout).
1084              */
1085             if (!TEST_false(SSL_CTX_remove_session(sctx, sess2)))
1086                 goto end;
1087         } else {
1088             /* Should fail because it should already be in the cache */
1089             if (!TEST_false(SSL_CTX_add_session(sctx, sess2)))
1090                 goto end;
1091         }
1092     }
1093
1094     if (use_ext_cache) {
1095         SSL_SESSION *tmp = sess2;
1096
1097         if (!TEST_int_eq(new_called, numnewsesstick)
1098                 || !TEST_int_eq(remove_called, 0)
1099                 || !TEST_int_eq(get_called, 0))
1100             goto end;
1101         /*
1102          * Delete the session from the internal cache to force a lookup from
1103          * the external cache. We take a copy first because
1104          * SSL_CTX_remove_session() also marks the session as non-resumable.
1105          */
1106         if (use_int_cache && maxprot != TLS1_3_VERSION) {
1107             if (!TEST_ptr(tmp = SSL_SESSION_dup(sess2))
1108                     || !TEST_true(SSL_CTX_remove_session(sctx, sess2)))
1109                 goto end;
1110             SSL_SESSION_free(sess2);
1111         }
1112         sess2 = tmp;
1113     }
1114
1115     new_called = remove_called = get_called = 0;
1116     get_sess_val = sess2;
1117     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl2,
1118                                       &clientssl2, NULL, NULL))
1119             || !TEST_true(SSL_set_session(clientssl2, sess1))
1120             || !TEST_true(create_ssl_connection(serverssl2, clientssl2,
1121                                                 SSL_ERROR_NONE))
1122             || !TEST_true(SSL_session_reused(clientssl2)))
1123         goto end;
1124
1125     if (use_ext_cache) {
1126         if (!TEST_int_eq(remove_called, 0))
1127             goto end;
1128
1129         if (maxprot == TLS1_3_VERSION) {
1130             if (!TEST_int_eq(new_called, 1)
1131                     || !TEST_int_eq(get_called, 0))
1132                 goto end;
1133         } else {
1134             if (!TEST_int_eq(new_called, 0)
1135                     || !TEST_int_eq(get_called, 1))
1136                 goto end;
1137         }
1138     }
1139
1140     testresult = 1;
1141
1142  end:
1143     SSL_free(serverssl1);
1144     SSL_free(clientssl1);
1145     SSL_free(serverssl2);
1146     SSL_free(clientssl2);
1147 # ifndef OPENSSL_NO_TLS1_1
1148     SSL_free(serverssl3);
1149     SSL_free(clientssl3);
1150 # endif
1151     SSL_SESSION_free(sess1);
1152     SSL_SESSION_free(sess2);
1153     SSL_CTX_free(sctx);
1154     SSL_CTX_free(cctx);
1155
1156     return testresult;
1157 }
1158 #endif /* !defined(OPENSSL_NO_TLS1_3) || !defined(OPENSSL_NO_TLS1_2) */
1159
1160 static int test_session_with_only_int_cache(void)
1161 {
1162 #ifndef OPENSSL_NO_TLS1_3
1163     if (!execute_test_session(TLS1_3_VERSION, 1, 0))
1164         return 0;
1165 #endif
1166
1167 #ifndef OPENSSL_NO_TLS1_2
1168     return execute_test_session(TLS1_2_VERSION, 1, 0);
1169 #else
1170     return 1;
1171 #endif
1172 }
1173
1174 static int test_session_with_only_ext_cache(void)
1175 {
1176 #ifndef OPENSSL_NO_TLS1_3
1177     if (!execute_test_session(TLS1_3_VERSION, 0, 1))
1178         return 0;
1179 #endif
1180
1181 #ifndef OPENSSL_NO_TLS1_2
1182     return execute_test_session(TLS1_2_VERSION, 0, 1);
1183 #else
1184     return 1;
1185 #endif
1186 }
1187
1188 static int test_session_with_both_cache(void)
1189 {
1190 #ifndef OPENSSL_NO_TLS1_3
1191     if (!execute_test_session(TLS1_3_VERSION, 1, 1))
1192         return 0;
1193 #endif
1194
1195 #ifndef OPENSSL_NO_TLS1_2
1196     return execute_test_session(TLS1_2_VERSION, 1, 1);
1197 #else
1198     return 1;
1199 #endif
1200 }
1201
1202 #ifndef OPENSSL_NO_TLS1_3
1203 static SSL_SESSION *sesscache[6];
1204 static int do_cache;
1205
1206 static int new_cachesession_cb(SSL *ssl, SSL_SESSION *sess)
1207 {
1208     if (do_cache) {
1209         sesscache[new_called] = sess;
1210     } else {
1211         /* We don't need the reference to the session, so free it */
1212         SSL_SESSION_free(sess);
1213     }
1214     new_called++;
1215
1216     return 1;
1217 }
1218
1219 static int post_handshake_verify(SSL *sssl, SSL *cssl)
1220 {
1221     SSL_set_verify(sssl, SSL_VERIFY_PEER, NULL);
1222     if (!TEST_true(SSL_verify_client_post_handshake(sssl)))
1223         return 0;
1224
1225     /* Start handshake on the server and client */
1226     if (!TEST_int_eq(SSL_do_handshake(sssl), 1)
1227             || !TEST_int_le(SSL_read(cssl, NULL, 0), 0)
1228             || !TEST_int_le(SSL_read(sssl, NULL, 0), 0)
1229             || !TEST_true(create_ssl_connection(sssl, cssl,
1230                                                 SSL_ERROR_NONE)))
1231         return 0;
1232
1233     return 1;
1234 }
1235
1236 static int test_tickets(int idx)
1237 {
1238     SSL_CTX *sctx = NULL, *cctx = NULL;
1239     SSL *serverssl = NULL, *clientssl = NULL;
1240     int testresult = 0, i;
1241     size_t j;
1242
1243     /* idx is the test number, but also the number of tickets we want */
1244
1245     new_called = 0;
1246     do_cache = 1;
1247
1248     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
1249                                        TLS1_VERSION, TLS_MAX_VERSION, &sctx,
1250                                        &cctx, cert, privkey))
1251             || !TEST_true(SSL_CTX_set_num_tickets(sctx, idx)))
1252         goto end;
1253
1254     SSL_CTX_set_session_cache_mode(cctx, SSL_SESS_CACHE_CLIENT
1255                                          | SSL_SESS_CACHE_NO_INTERNAL_STORE);
1256     SSL_CTX_sess_set_new_cb(cctx, new_cachesession_cb);
1257
1258     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
1259                                           &clientssl, NULL, NULL)))
1260         goto end;
1261
1262     SSL_force_post_handshake_auth(clientssl);
1263
1264     if (!TEST_true(create_ssl_connection(serverssl, clientssl,
1265                                                 SSL_ERROR_NONE))
1266                /* Check we got the number of tickets we were expecting */
1267             || !TEST_int_eq(idx, new_called))
1268         goto end;
1269
1270     /* After a post-handshake authentication we should get new tickets issued */
1271     if (!post_handshake_verify(serverssl, clientssl)
1272             || !TEST_int_eq(idx * 2, new_called))
1273         goto end;
1274
1275     SSL_shutdown(clientssl);
1276     SSL_shutdown(serverssl);
1277     SSL_free(serverssl);
1278     SSL_free(clientssl);
1279     serverssl = clientssl = NULL;
1280
1281     /* Stop caching sessions - just count them */
1282     do_cache = 0;
1283
1284     /* Test that we can resume with all the tickets we got given */
1285     for (i = 0; i < idx * 2; i++) {
1286         new_called = 0;
1287         if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
1288                                               &clientssl, NULL, NULL))
1289                 || !TEST_true(SSL_set_session(clientssl, sesscache[i])))
1290             goto end;
1291
1292         SSL_force_post_handshake_auth(clientssl);
1293
1294         if (!TEST_true(create_ssl_connection(serverssl, clientssl,
1295                                                     SSL_ERROR_NONE))
1296                 || !TEST_true(SSL_session_reused(clientssl))
1297                    /* Following a resumption we only get 1 ticket */
1298                 || !TEST_int_eq(new_called, 1))
1299             goto end;
1300
1301         new_called = 0;
1302         /* After a post-handshake authentication we should get 1 new ticket */
1303         if (!post_handshake_verify(serverssl, clientssl)
1304                 || !TEST_int_eq(new_called, 1))
1305             goto end;
1306
1307         SSL_shutdown(clientssl);
1308         SSL_shutdown(serverssl);
1309         SSL_free(serverssl);
1310         SSL_free(clientssl);
1311         serverssl = clientssl = NULL;
1312         SSL_SESSION_free(sesscache[i]);
1313         sesscache[i] = NULL;
1314     }
1315
1316     testresult = 1;
1317
1318  end:
1319     SSL_free(serverssl);
1320     SSL_free(clientssl);
1321     for (j = 0; j < OSSL_NELEM(sesscache); j++) {
1322         SSL_SESSION_free(sesscache[j]);
1323         sesscache[j] = NULL;
1324     }
1325     SSL_CTX_free(sctx);
1326     SSL_CTX_free(cctx);
1327
1328     return testresult;
1329 }
1330 #endif
1331
1332 #define USE_NULL            0
1333 #define USE_BIO_1           1
1334 #define USE_BIO_2           2
1335 #define USE_DEFAULT         3
1336
1337 #define CONNTYPE_CONNECTION_SUCCESS  0
1338 #define CONNTYPE_CONNECTION_FAIL     1
1339 #define CONNTYPE_NO_CONNECTION       2
1340
1341 #define TOTAL_NO_CONN_SSL_SET_BIO_TESTS         (3 * 3 * 3 * 3)
1342 #define TOTAL_CONN_SUCCESS_SSL_SET_BIO_TESTS    (2 * 2)
1343 #if !defined(OPENSSL_NO_TLS1_3) && !defined(OPENSSL_NO_TLS1_2)
1344 # define TOTAL_CONN_FAIL_SSL_SET_BIO_TESTS       (2 * 2)
1345 #else
1346 # define TOTAL_CONN_FAIL_SSL_SET_BIO_TESTS       0
1347 #endif
1348
1349 #define TOTAL_SSL_SET_BIO_TESTS TOTAL_NO_CONN_SSL_SET_BIO_TESTS \
1350                                 + TOTAL_CONN_SUCCESS_SSL_SET_BIO_TESTS \
1351                                 + TOTAL_CONN_FAIL_SSL_SET_BIO_TESTS
1352
1353 static void setupbio(BIO **res, BIO *bio1, BIO *bio2, int type)
1354 {
1355     switch (type) {
1356     case USE_NULL:
1357         *res = NULL;
1358         break;
1359     case USE_BIO_1:
1360         *res = bio1;
1361         break;
1362     case USE_BIO_2:
1363         *res = bio2;
1364         break;
1365     }
1366 }
1367
1368
1369 /*
1370  * Tests calls to SSL_set_bio() under various conditions.
1371  *
1372  * For the first 3 * 3 * 3 * 3 = 81 tests we do 2 calls to SSL_set_bio() with
1373  * various combinations of valid BIOs or NULL being set for the rbio/wbio. We
1374  * then do more tests where we create a successful connection first using our
1375  * standard connection setup functions, and then call SSL_set_bio() with
1376  * various combinations of valid BIOs or NULL. We then repeat these tests
1377  * following a failed connection. In this last case we are looking to check that
1378  * SSL_set_bio() functions correctly in the case where s->bbio is not NULL.
1379  */
1380 static int test_ssl_set_bio(int idx)
1381 {
1382     SSL_CTX *sctx = NULL, *cctx = NULL;
1383     BIO *bio1 = NULL;
1384     BIO *bio2 = NULL;
1385     BIO *irbio = NULL, *iwbio = NULL, *nrbio = NULL, *nwbio = NULL;
1386     SSL *serverssl = NULL, *clientssl = NULL;
1387     int initrbio, initwbio, newrbio, newwbio, conntype;
1388     int testresult = 0;
1389
1390     if (idx < TOTAL_NO_CONN_SSL_SET_BIO_TESTS) {
1391         initrbio = idx % 3;
1392         idx /= 3;
1393         initwbio = idx % 3;
1394         idx /= 3;
1395         newrbio = idx % 3;
1396         idx /= 3;
1397         newwbio = idx % 3;
1398         conntype = CONNTYPE_NO_CONNECTION;
1399     } else {
1400         idx -= TOTAL_NO_CONN_SSL_SET_BIO_TESTS;
1401         initrbio = initwbio = USE_DEFAULT;
1402         newrbio = idx % 2;
1403         idx /= 2;
1404         newwbio = idx % 2;
1405         idx /= 2;
1406         conntype = idx % 2;
1407     }
1408
1409     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
1410                                        TLS1_VERSION, TLS_MAX_VERSION,
1411                                        &sctx, &cctx, cert, privkey)))
1412         goto end;
1413
1414     if (conntype == CONNTYPE_CONNECTION_FAIL) {
1415         /*
1416          * We won't ever get here if either TLSv1.3 or TLSv1.2 is disabled
1417          * because we reduced the number of tests in the definition of
1418          * TOTAL_CONN_FAIL_SSL_SET_BIO_TESTS to avoid this scenario. By setting
1419          * mismatched protocol versions we will force a connection failure.
1420          */
1421         SSL_CTX_set_min_proto_version(sctx, TLS1_3_VERSION);
1422         SSL_CTX_set_max_proto_version(cctx, TLS1_2_VERSION);
1423     }
1424
1425     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
1426                                       NULL, NULL)))
1427         goto end;
1428
1429     if (initrbio == USE_BIO_1
1430             || initwbio == USE_BIO_1
1431             || newrbio == USE_BIO_1
1432             || newwbio == USE_BIO_1) {
1433         if (!TEST_ptr(bio1 = BIO_new(BIO_s_mem())))
1434             goto end;
1435     }
1436
1437     if (initrbio == USE_BIO_2
1438             || initwbio == USE_BIO_2
1439             || newrbio == USE_BIO_2
1440             || newwbio == USE_BIO_2) {
1441         if (!TEST_ptr(bio2 = BIO_new(BIO_s_mem())))
1442             goto end;
1443     }
1444
1445     if (initrbio != USE_DEFAULT) {
1446         setupbio(&irbio, bio1, bio2, initrbio);
1447         setupbio(&iwbio, bio1, bio2, initwbio);
1448         SSL_set_bio(clientssl, irbio, iwbio);
1449
1450         /*
1451          * We want to maintain our own refs to these BIO, so do an up ref for
1452          * each BIO that will have ownership transferred in the SSL_set_bio()
1453          * call
1454          */
1455         if (irbio != NULL)
1456             BIO_up_ref(irbio);
1457         if (iwbio != NULL && iwbio != irbio)
1458             BIO_up_ref(iwbio);
1459     }
1460
1461     if (conntype != CONNTYPE_NO_CONNECTION
1462             && !TEST_true(create_ssl_connection(serverssl, clientssl,
1463                                                 SSL_ERROR_NONE)
1464                           == (conntype == CONNTYPE_CONNECTION_SUCCESS)))
1465         goto end;
1466
1467     setupbio(&nrbio, bio1, bio2, newrbio);
1468     setupbio(&nwbio, bio1, bio2, newwbio);
1469
1470     /*
1471      * We will (maybe) transfer ownership again so do more up refs.
1472      * SSL_set_bio() has some really complicated ownership rules where BIOs have
1473      * already been set!
1474      */
1475     if (nrbio != NULL
1476             && nrbio != irbio
1477             && (nwbio != iwbio || nrbio != nwbio))
1478         BIO_up_ref(nrbio);
1479     if (nwbio != NULL
1480             && nwbio != nrbio
1481             && (nwbio != iwbio || (nwbio == iwbio && irbio == iwbio)))
1482         BIO_up_ref(nwbio);
1483
1484     SSL_set_bio(clientssl, nrbio, nwbio);
1485
1486     testresult = 1;
1487
1488  end:
1489     BIO_free(bio1);
1490     BIO_free(bio2);
1491
1492     /*
1493      * This test is checking that the ref counting for SSL_set_bio is correct.
1494      * If we get here and we did too many frees then we will fail in the above
1495      * functions. If we haven't done enough then this will only be detected in
1496      * a crypto-mdebug build
1497      */
1498     SSL_free(serverssl);
1499     SSL_free(clientssl);
1500     SSL_CTX_free(sctx);
1501     SSL_CTX_free(cctx);
1502     return testresult;
1503 }
1504
1505 typedef enum { NO_BIO_CHANGE, CHANGE_RBIO, CHANGE_WBIO } bio_change_t;
1506
1507 static int execute_test_ssl_bio(int pop_ssl, bio_change_t change_bio)
1508 {
1509     BIO *sslbio = NULL, *membio1 = NULL, *membio2 = NULL;
1510     SSL_CTX *ctx;
1511     SSL *ssl = NULL;
1512     int testresult = 0;
1513
1514     if (!TEST_ptr(ctx = SSL_CTX_new(TLS_method()))
1515             || !TEST_ptr(ssl = SSL_new(ctx))
1516             || !TEST_ptr(sslbio = BIO_new(BIO_f_ssl()))
1517             || !TEST_ptr(membio1 = BIO_new(BIO_s_mem())))
1518         goto end;
1519
1520     BIO_set_ssl(sslbio, ssl, BIO_CLOSE);
1521
1522     /*
1523      * If anything goes wrong here then we could leak memory, so this will
1524      * be caught in a crypto-mdebug build
1525      */
1526     BIO_push(sslbio, membio1);
1527
1528     /* Verify changing the rbio/wbio directly does not cause leaks */
1529     if (change_bio != NO_BIO_CHANGE) {
1530         if (!TEST_ptr(membio2 = BIO_new(BIO_s_mem())))
1531             goto end;
1532         if (change_bio == CHANGE_RBIO)
1533             SSL_set0_rbio(ssl, membio2);
1534         else
1535             SSL_set0_wbio(ssl, membio2);
1536     }
1537     ssl = NULL;
1538
1539     if (pop_ssl)
1540         BIO_pop(sslbio);
1541     else
1542         BIO_pop(membio1);
1543
1544     testresult = 1;
1545  end:
1546     BIO_free(membio1);
1547     BIO_free(sslbio);
1548     SSL_free(ssl);
1549     SSL_CTX_free(ctx);
1550
1551     return testresult;
1552 }
1553
1554 static int test_ssl_bio_pop_next_bio(void)
1555 {
1556     return execute_test_ssl_bio(0, NO_BIO_CHANGE);
1557 }
1558
1559 static int test_ssl_bio_pop_ssl_bio(void)
1560 {
1561     return execute_test_ssl_bio(1, NO_BIO_CHANGE);
1562 }
1563
1564 static int test_ssl_bio_change_rbio(void)
1565 {
1566     return execute_test_ssl_bio(0, CHANGE_RBIO);
1567 }
1568
1569 static int test_ssl_bio_change_wbio(void)
1570 {
1571     return execute_test_ssl_bio(0, CHANGE_WBIO);
1572 }
1573
1574 #if !defined(OPENSSL_NO_TLS1_2) || defined(OPENSSL_NO_TLS1_3)
1575 typedef struct {
1576     /* The list of sig algs */
1577     const int *list;
1578     /* The length of the list */
1579     size_t listlen;
1580     /* A sigalgs list in string format */
1581     const char *liststr;
1582     /* Whether setting the list should succeed */
1583     int valid;
1584     /* Whether creating a connection with the list should succeed */
1585     int connsuccess;
1586 } sigalgs_list;
1587
1588 static const int validlist1[] = {NID_sha256, EVP_PKEY_RSA};
1589 # ifndef OPENSSL_NO_EC
1590 static const int validlist2[] = {NID_sha256, EVP_PKEY_RSA, NID_sha512, EVP_PKEY_EC};
1591 static const int validlist3[] = {NID_sha512, EVP_PKEY_EC};
1592 # endif
1593 static const int invalidlist1[] = {NID_undef, EVP_PKEY_RSA};
1594 static const int invalidlist2[] = {NID_sha256, NID_undef};
1595 static const int invalidlist3[] = {NID_sha256, EVP_PKEY_RSA, NID_sha256};
1596 static const int invalidlist4[] = {NID_sha256};
1597 static const sigalgs_list testsigalgs[] = {
1598     {validlist1, OSSL_NELEM(validlist1), NULL, 1, 1},
1599 # ifndef OPENSSL_NO_EC
1600     {validlist2, OSSL_NELEM(validlist2), NULL, 1, 1},
1601     {validlist3, OSSL_NELEM(validlist3), NULL, 1, 0},
1602 # endif
1603     {NULL, 0, "RSA+SHA256", 1, 1},
1604 # ifndef OPENSSL_NO_EC
1605     {NULL, 0, "RSA+SHA256:ECDSA+SHA512", 1, 1},
1606     {NULL, 0, "ECDSA+SHA512", 1, 0},
1607 # endif
1608     {invalidlist1, OSSL_NELEM(invalidlist1), NULL, 0, 0},
1609     {invalidlist2, OSSL_NELEM(invalidlist2), NULL, 0, 0},
1610     {invalidlist3, OSSL_NELEM(invalidlist3), NULL, 0, 0},
1611     {invalidlist4, OSSL_NELEM(invalidlist4), NULL, 0, 0},
1612     {NULL, 0, "RSA", 0, 0},
1613     {NULL, 0, "SHA256", 0, 0},
1614     {NULL, 0, "RSA+SHA256:SHA256", 0, 0},
1615     {NULL, 0, "Invalid", 0, 0}
1616 };
1617
1618 static int test_set_sigalgs(int idx)
1619 {
1620     SSL_CTX *cctx = NULL, *sctx = NULL;
1621     SSL *clientssl = NULL, *serverssl = NULL;
1622     int testresult = 0;
1623     const sigalgs_list *curr;
1624     int testctx;
1625
1626     /* Should never happen */
1627     if (!TEST_size_t_le((size_t)idx, OSSL_NELEM(testsigalgs) * 2))
1628         return 0;
1629
1630     testctx = ((size_t)idx < OSSL_NELEM(testsigalgs));
1631     curr = testctx ? &testsigalgs[idx]
1632                    : &testsigalgs[idx - OSSL_NELEM(testsigalgs)];
1633
1634     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
1635                                        TLS1_VERSION, TLS_MAX_VERSION,
1636                                        &sctx, &cctx, cert, privkey)))
1637         return 0;
1638
1639     /*
1640      * TODO(TLS1.3): These APIs cannot set TLSv1.3 sig algs so we just test it
1641      * for TLSv1.2 for now until we add a new API.
1642      */
1643     SSL_CTX_set_max_proto_version(cctx, TLS1_2_VERSION);
1644
1645     if (testctx) {
1646         int ret;
1647
1648         if (curr->list != NULL)
1649             ret = SSL_CTX_set1_sigalgs(cctx, curr->list, curr->listlen);
1650         else
1651             ret = SSL_CTX_set1_sigalgs_list(cctx, curr->liststr);
1652
1653         if (!ret) {
1654             if (curr->valid)
1655                 TEST_info("Failure setting sigalgs in SSL_CTX (%d)\n", idx);
1656             else
1657                 testresult = 1;
1658             goto end;
1659         }
1660         if (!curr->valid) {
1661             TEST_info("Not-failed setting sigalgs in SSL_CTX (%d)\n", idx);
1662             goto end;
1663         }
1664     }
1665
1666     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
1667                                       &clientssl, NULL, NULL)))
1668         goto end;
1669
1670     if (!testctx) {
1671         int ret;
1672
1673         if (curr->list != NULL)
1674             ret = SSL_set1_sigalgs(clientssl, curr->list, curr->listlen);
1675         else
1676             ret = SSL_set1_sigalgs_list(clientssl, curr->liststr);
1677         if (!ret) {
1678             if (curr->valid)
1679                 TEST_info("Failure setting sigalgs in SSL (%d)\n", idx);
1680             else
1681                 testresult = 1;
1682             goto end;
1683         }
1684         if (!curr->valid)
1685             goto end;
1686     }
1687
1688     if (!TEST_int_eq(create_ssl_connection(serverssl, clientssl,
1689                                            SSL_ERROR_NONE),
1690                 curr->connsuccess))
1691         goto end;
1692
1693     testresult = 1;
1694
1695  end:
1696     SSL_free(serverssl);
1697     SSL_free(clientssl);
1698     SSL_CTX_free(sctx);
1699     SSL_CTX_free(cctx);
1700
1701     return testresult;
1702 }
1703 #endif
1704
1705 #ifndef OPENSSL_NO_TLS1_3
1706
1707 static SSL_SESSION *clientpsk = NULL;
1708 static SSL_SESSION *serverpsk = NULL;
1709 static const char *pskid = "Identity";
1710 static const char *srvid;
1711
1712 static int use_session_cb_cnt = 0;
1713 static int find_session_cb_cnt = 0;
1714 static int psk_client_cb_cnt = 0;
1715 static int psk_server_cb_cnt = 0;
1716
1717 static int use_session_cb(SSL *ssl, const EVP_MD *md, const unsigned char **id,
1718                           size_t *idlen, SSL_SESSION **sess)
1719 {
1720     switch (++use_session_cb_cnt) {
1721     case 1:
1722         /* The first call should always have a NULL md */
1723         if (md != NULL)
1724             return 0;
1725         break;
1726
1727     case 2:
1728         /* The second call should always have an md */
1729         if (md == NULL)
1730             return 0;
1731         break;
1732
1733     default:
1734         /* We should only be called a maximum of twice */
1735         return 0;
1736     }
1737
1738     if (clientpsk != NULL)
1739         SSL_SESSION_up_ref(clientpsk);
1740
1741     *sess = clientpsk;
1742     *id = (const unsigned char *)pskid;
1743     *idlen = strlen(pskid);
1744
1745     return 1;
1746 }
1747
1748 #ifndef OPENSSL_NO_PSK
1749 static unsigned int psk_client_cb(SSL *ssl, const char *hint, char *id,
1750                                   unsigned int max_id_len,
1751                                   unsigned char *psk,
1752                                   unsigned int max_psk_len)
1753 {
1754     unsigned int psklen = 0;
1755
1756     psk_client_cb_cnt++;
1757
1758     if (strlen(pskid) + 1 > max_id_len)
1759         return 0;
1760
1761     /* We should only ever be called a maximum of twice per connection */
1762     if (psk_client_cb_cnt > 2)
1763         return 0;
1764
1765     if (clientpsk == NULL)
1766         return 0;
1767
1768     /* We'll reuse the PSK we set up for TLSv1.3 */
1769     if (SSL_SESSION_get_master_key(clientpsk, NULL, 0) > max_psk_len)
1770         return 0;
1771     psklen = SSL_SESSION_get_master_key(clientpsk, psk, max_psk_len);
1772     strncpy(id, pskid, max_id_len);
1773
1774     return psklen;
1775 }
1776 #endif /* OPENSSL_NO_PSK */
1777
1778 static int find_session_cb(SSL *ssl, const unsigned char *identity,
1779                            size_t identity_len, SSL_SESSION **sess)
1780 {
1781     find_session_cb_cnt++;
1782
1783     /* We should only ever be called a maximum of twice per connection */
1784     if (find_session_cb_cnt > 2)
1785         return 0;
1786
1787     if (serverpsk == NULL)
1788         return 0;
1789
1790     /* Identity should match that set by the client */
1791     if (strlen(srvid) != identity_len
1792             || strncmp(srvid, (const char *)identity, identity_len) != 0) {
1793         /* No PSK found, continue but without a PSK */
1794         *sess = NULL;
1795         return 1;
1796     }
1797
1798     SSL_SESSION_up_ref(serverpsk);
1799     *sess = serverpsk;
1800
1801     return 1;
1802 }
1803
1804 #ifndef OPENSSL_NO_PSK
1805 static unsigned int psk_server_cb(SSL *ssl, const char *identity,
1806                                   unsigned char *psk, unsigned int max_psk_len)
1807 {
1808     unsigned int psklen = 0;
1809
1810     psk_server_cb_cnt++;
1811
1812     /* We should only ever be called a maximum of twice per connection */
1813     if (find_session_cb_cnt > 2)
1814         return 0;
1815
1816     if (serverpsk == NULL)
1817         return 0;
1818
1819     /* Identity should match that set by the client */
1820     if (strcmp(srvid, identity) != 0) {
1821         return 0;
1822     }
1823
1824     /* We'll reuse the PSK we set up for TLSv1.3 */
1825     if (SSL_SESSION_get_master_key(serverpsk, NULL, 0) > max_psk_len)
1826         return 0;
1827     psklen = SSL_SESSION_get_master_key(serverpsk, psk, max_psk_len);
1828
1829     return psklen;
1830 }
1831 #endif /* OPENSSL_NO_PSK */
1832
1833 #define MSG1    "Hello"
1834 #define MSG2    "World."
1835 #define MSG3    "This"
1836 #define MSG4    "is"
1837 #define MSG5    "a"
1838 #define MSG6    "test"
1839 #define MSG7    "message."
1840
1841 #define TLS13_AES_256_GCM_SHA384_BYTES  ((const unsigned char *)"\x13\x02")
1842 #define TLS13_AES_128_GCM_SHA256_BYTES  ((const unsigned char *)"\x13\x01")
1843
1844 /*
1845  * Helper method to setup objects for early data test. Caller frees objects on
1846  * error.
1847  */
1848 static int setupearly_data_test(SSL_CTX **cctx, SSL_CTX **sctx, SSL **clientssl,
1849                                 SSL **serverssl, SSL_SESSION **sess, int idx)
1850 {
1851     if (*sctx == NULL
1852             && !TEST_true(create_ssl_ctx_pair(TLS_server_method(),
1853                                               TLS_client_method(),
1854                                               TLS1_VERSION, TLS_MAX_VERSION,
1855                                               sctx, cctx, cert, privkey)))
1856         return 0;
1857
1858     if (!TEST_true(SSL_CTX_set_max_early_data(*sctx, SSL3_RT_MAX_PLAIN_LENGTH)))
1859         return 0;
1860
1861     if (idx == 1) {
1862         /* When idx == 1 we repeat the tests with read_ahead set */
1863         SSL_CTX_set_read_ahead(*cctx, 1);
1864         SSL_CTX_set_read_ahead(*sctx, 1);
1865     } else if (idx == 2) {
1866         /* When idx == 2 we are doing early_data with a PSK. Set up callbacks */
1867         SSL_CTX_set_psk_use_session_callback(*cctx, use_session_cb);
1868         SSL_CTX_set_psk_find_session_callback(*sctx, find_session_cb);
1869         use_session_cb_cnt = 0;
1870         find_session_cb_cnt = 0;
1871         srvid = pskid;
1872     }
1873
1874     if (!TEST_true(create_ssl_objects(*sctx, *cctx, serverssl, clientssl,
1875                                       NULL, NULL)))
1876         return 0;
1877
1878     /*
1879      * For one of the run throughs (doesn't matter which one), we'll try sending
1880      * some SNI data in the initial ClientHello. This will be ignored (because
1881      * there is no SNI cb set up by the server), so it should not impact
1882      * early_data.
1883      */
1884     if (idx == 1
1885             && !TEST_true(SSL_set_tlsext_host_name(*clientssl, "localhost")))
1886         return 0;
1887
1888     if (idx == 2) {
1889         /* Create the PSK */
1890         const SSL_CIPHER *cipher = NULL;
1891         const unsigned char key[] = {
1892             0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
1893             0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
1894             0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
1895             0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b,
1896             0x2c, 0x2d, 0x2e, 0x2f
1897         };
1898
1899         cipher = SSL_CIPHER_find(*clientssl, TLS13_AES_256_GCM_SHA384_BYTES);
1900         clientpsk = SSL_SESSION_new();
1901         if (!TEST_ptr(clientpsk)
1902                 || !TEST_ptr(cipher)
1903                 || !TEST_true(SSL_SESSION_set1_master_key(clientpsk, key,
1904                                                           sizeof(key)))
1905                 || !TEST_true(SSL_SESSION_set_cipher(clientpsk, cipher))
1906                 || !TEST_true(
1907                         SSL_SESSION_set_protocol_version(clientpsk,
1908                                                          TLS1_3_VERSION))
1909                    /*
1910                     * We just choose an arbitrary value for max_early_data which
1911                     * should be big enough for testing purposes.
1912                     */
1913                 || !TEST_true(SSL_SESSION_set_max_early_data(clientpsk,
1914                                                              0x100))
1915                 || !TEST_true(SSL_SESSION_up_ref(clientpsk))) {
1916             SSL_SESSION_free(clientpsk);
1917             clientpsk = NULL;
1918             return 0;
1919         }
1920         serverpsk = clientpsk;
1921
1922         if (sess != NULL) {
1923             if (!TEST_true(SSL_SESSION_up_ref(clientpsk))) {
1924                 SSL_SESSION_free(clientpsk);
1925                 SSL_SESSION_free(serverpsk);
1926                 clientpsk = serverpsk = NULL;
1927                 return 0;
1928             }
1929             *sess = clientpsk;
1930         }
1931         return 1;
1932     }
1933
1934     if (sess == NULL)
1935         return 1;
1936
1937     if (!TEST_true(create_ssl_connection(*serverssl, *clientssl,
1938                                          SSL_ERROR_NONE)))
1939         return 0;
1940
1941     *sess = SSL_get1_session(*clientssl);
1942     SSL_shutdown(*clientssl);
1943     SSL_shutdown(*serverssl);
1944     SSL_free(*serverssl);
1945     SSL_free(*clientssl);
1946     *serverssl = *clientssl = NULL;
1947
1948     if (!TEST_true(create_ssl_objects(*sctx, *cctx, serverssl,
1949                                       clientssl, NULL, NULL))
1950             || !TEST_true(SSL_set_session(*clientssl, *sess)))
1951         return 0;
1952
1953     return 1;
1954 }
1955
1956 static int test_early_data_read_write(int idx)
1957 {
1958     SSL_CTX *cctx = NULL, *sctx = NULL;
1959     SSL *clientssl = NULL, *serverssl = NULL;
1960     int testresult = 0;
1961     SSL_SESSION *sess = NULL;
1962     unsigned char buf[20], data[1024];
1963     size_t readbytes, written, eoedlen, rawread, rawwritten;
1964     BIO *rbio;
1965
1966     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
1967                                         &serverssl, &sess, idx)))
1968         goto end;
1969
1970     /* Write and read some early data */
1971     if (!TEST_true(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
1972                                         &written))
1973             || !TEST_size_t_eq(written, strlen(MSG1))
1974             || !TEST_int_eq(SSL_read_early_data(serverssl, buf,
1975                                                 sizeof(buf), &readbytes),
1976                             SSL_READ_EARLY_DATA_SUCCESS)
1977             || !TEST_mem_eq(MSG1, readbytes, buf, strlen(MSG1))
1978             || !TEST_int_eq(SSL_get_early_data_status(serverssl),
1979                             SSL_EARLY_DATA_ACCEPTED))
1980         goto end;
1981
1982     /*
1983      * Server should be able to write data, and client should be able to
1984      * read it.
1985      */
1986     if (!TEST_true(SSL_write_early_data(serverssl, MSG2, strlen(MSG2),
1987                                         &written))
1988             || !TEST_size_t_eq(written, strlen(MSG2))
1989             || !TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
1990             || !TEST_mem_eq(buf, readbytes, MSG2, strlen(MSG2)))
1991         goto end;
1992
1993     /* Even after reading normal data, client should be able write early data */
1994     if (!TEST_true(SSL_write_early_data(clientssl, MSG3, strlen(MSG3),
1995                                         &written))
1996             || !TEST_size_t_eq(written, strlen(MSG3)))
1997         goto end;
1998
1999     /* Server should still be able read early data after writing data */
2000     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2001                                          &readbytes),
2002                      SSL_READ_EARLY_DATA_SUCCESS)
2003             || !TEST_mem_eq(buf, readbytes, MSG3, strlen(MSG3)))
2004         goto end;
2005
2006     /* Write more data from server and read it from client */
2007     if (!TEST_true(SSL_write_early_data(serverssl, MSG4, strlen(MSG4),
2008                                         &written))
2009             || !TEST_size_t_eq(written, strlen(MSG4))
2010             || !TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
2011             || !TEST_mem_eq(buf, readbytes, MSG4, strlen(MSG4)))
2012         goto end;
2013
2014     /*
2015      * If client writes normal data it should mean writing early data is no
2016      * longer possible.
2017      */
2018     if (!TEST_true(SSL_write_ex(clientssl, MSG5, strlen(MSG5), &written))
2019             || !TEST_size_t_eq(written, strlen(MSG5))
2020             || !TEST_int_eq(SSL_get_early_data_status(clientssl),
2021                             SSL_EARLY_DATA_ACCEPTED))
2022         goto end;
2023
2024     /*
2025      * At this point the client has written EndOfEarlyData, ClientFinished and
2026      * normal (fully protected) data. We are going to cause a delay between the
2027      * arrival of EndOfEarlyData and ClientFinished. We read out all the data
2028      * in the read BIO, and then just put back the EndOfEarlyData message.
2029      */
2030     rbio = SSL_get_rbio(serverssl);
2031     if (!TEST_true(BIO_read_ex(rbio, data, sizeof(data), &rawread))
2032             || !TEST_size_t_lt(rawread, sizeof(data))
2033             || !TEST_size_t_gt(rawread, SSL3_RT_HEADER_LENGTH))
2034         goto end;
2035
2036     /* Record length is in the 4th and 5th bytes of the record header */
2037     eoedlen = SSL3_RT_HEADER_LENGTH + (data[3] << 8 | data[4]);
2038     if (!TEST_true(BIO_write_ex(rbio, data, eoedlen, &rawwritten))
2039             || !TEST_size_t_eq(rawwritten, eoedlen))
2040         goto end;
2041
2042     /* Server should be told that there is no more early data */
2043     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2044                                          &readbytes),
2045                      SSL_READ_EARLY_DATA_FINISH)
2046             || !TEST_size_t_eq(readbytes, 0))
2047         goto end;
2048
2049     /*
2050      * Server has not finished init yet, so should still be able to write early
2051      * data.
2052      */
2053     if (!TEST_true(SSL_write_early_data(serverssl, MSG6, strlen(MSG6),
2054                                         &written))
2055             || !TEST_size_t_eq(written, strlen(MSG6)))
2056         goto end;
2057
2058     /* Push the ClientFinished and the normal data back into the server rbio */
2059     if (!TEST_true(BIO_write_ex(rbio, data + eoedlen, rawread - eoedlen,
2060                                 &rawwritten))
2061             || !TEST_size_t_eq(rawwritten, rawread - eoedlen))
2062         goto end;
2063
2064     /* Server should be able to read normal data */
2065     if (!TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
2066             || !TEST_size_t_eq(readbytes, strlen(MSG5)))
2067         goto end;
2068
2069     /* Client and server should not be able to write/read early data now */
2070     if (!TEST_false(SSL_write_early_data(clientssl, MSG6, strlen(MSG6),
2071                                          &written)))
2072         goto end;
2073     ERR_clear_error();
2074     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2075                                          &readbytes),
2076                      SSL_READ_EARLY_DATA_ERROR))
2077         goto end;
2078     ERR_clear_error();
2079
2080     /* Client should be able to read the data sent by the server */
2081     if (!TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
2082             || !TEST_mem_eq(buf, readbytes, MSG6, strlen(MSG6)))
2083         goto end;
2084
2085     /*
2086      * Make sure we process the two NewSessionTickets. These arrive
2087      * post-handshake. We attempt reads which we do not expect to return any
2088      * data.
2089      */
2090     if (!TEST_false(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
2091             || !TEST_false(SSL_read_ex(clientssl, buf, sizeof(buf),
2092                            &readbytes)))
2093         goto end;
2094
2095     /* Server should be able to write normal data */
2096     if (!TEST_true(SSL_write_ex(serverssl, MSG7, strlen(MSG7), &written))
2097             || !TEST_size_t_eq(written, strlen(MSG7))
2098             || !TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
2099             || !TEST_mem_eq(buf, readbytes, MSG7, strlen(MSG7)))
2100         goto end;
2101
2102     SSL_SESSION_free(sess);
2103     sess = SSL_get1_session(clientssl);
2104     use_session_cb_cnt = 0;
2105     find_session_cb_cnt = 0;
2106
2107     SSL_shutdown(clientssl);
2108     SSL_shutdown(serverssl);
2109     SSL_free(serverssl);
2110     SSL_free(clientssl);
2111     serverssl = clientssl = NULL;
2112     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
2113                                       &clientssl, NULL, NULL))
2114             || !TEST_true(SSL_set_session(clientssl, sess)))
2115         goto end;
2116
2117     /* Write and read some early data */
2118     if (!TEST_true(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
2119                                         &written))
2120             || !TEST_size_t_eq(written, strlen(MSG1))
2121             || !TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2122                                                 &readbytes),
2123                             SSL_READ_EARLY_DATA_SUCCESS)
2124             || !TEST_mem_eq(buf, readbytes, MSG1, strlen(MSG1)))
2125         goto end;
2126
2127     if (!TEST_int_gt(SSL_connect(clientssl), 0)
2128             || !TEST_int_gt(SSL_accept(serverssl), 0))
2129         goto end;
2130
2131     /* Client and server should not be able to write/read early data now */
2132     if (!TEST_false(SSL_write_early_data(clientssl, MSG6, strlen(MSG6),
2133                                          &written)))
2134         goto end;
2135     ERR_clear_error();
2136     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2137                                          &readbytes),
2138                      SSL_READ_EARLY_DATA_ERROR))
2139         goto end;
2140     ERR_clear_error();
2141
2142     /* Client and server should be able to write/read normal data */
2143     if (!TEST_true(SSL_write_ex(clientssl, MSG5, strlen(MSG5), &written))
2144             || !TEST_size_t_eq(written, strlen(MSG5))
2145             || !TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
2146             || !TEST_size_t_eq(readbytes, strlen(MSG5)))
2147         goto end;
2148
2149     testresult = 1;
2150
2151  end:
2152     SSL_SESSION_free(sess);
2153     SSL_SESSION_free(clientpsk);
2154     SSL_SESSION_free(serverpsk);
2155     clientpsk = serverpsk = NULL;
2156     SSL_free(serverssl);
2157     SSL_free(clientssl);
2158     SSL_CTX_free(sctx);
2159     SSL_CTX_free(cctx);
2160     return testresult;
2161 }
2162
2163 static int allow_ed_cb_called = 0;
2164
2165 static int allow_early_data_cb(SSL *s, void *arg)
2166 {
2167     int *usecb = (int *)arg;
2168
2169     allow_ed_cb_called++;
2170
2171     if (*usecb == 1)
2172         return 0;
2173
2174     return 1;
2175 }
2176
2177 /*
2178  * idx == 0: Standard early_data setup
2179  * idx == 1: early_data setup using read_ahead
2180  * usecb == 0: Don't use a custom early data callback
2181  * usecb == 1: Use a custom early data callback and reject the early data
2182  * usecb == 2: Use a custom early data callback and accept the early data
2183  * confopt == 0: Configure anti-replay directly
2184  * confopt == 1: Configure anti-replay using SSL_CONF
2185  */
2186 static int test_early_data_replay_int(int idx, int usecb, int confopt)
2187 {
2188     SSL_CTX *cctx = NULL, *sctx = NULL;
2189     SSL *clientssl = NULL, *serverssl = NULL;
2190     int testresult = 0;
2191     SSL_SESSION *sess = NULL;
2192     size_t readbytes, written;
2193     unsigned char buf[20];
2194
2195     allow_ed_cb_called = 0;
2196
2197     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
2198                                        TLS1_VERSION, TLS_MAX_VERSION, &sctx,
2199                                        &cctx, cert, privkey)))
2200         return 0;
2201
2202     if (usecb > 0) {
2203         if (confopt == 0) {
2204             SSL_CTX_set_options(sctx, SSL_OP_NO_ANTI_REPLAY);
2205         } else {
2206             SSL_CONF_CTX *confctx = SSL_CONF_CTX_new();
2207
2208             if (!TEST_ptr(confctx))
2209                 goto end;
2210             SSL_CONF_CTX_set_flags(confctx, SSL_CONF_FLAG_FILE
2211                                             | SSL_CONF_FLAG_SERVER);
2212             SSL_CONF_CTX_set_ssl_ctx(confctx, sctx);
2213             if (!TEST_int_eq(SSL_CONF_cmd(confctx, "Options", "-AntiReplay"),
2214                              2)) {
2215                 SSL_CONF_CTX_free(confctx);
2216                 goto end;
2217             }
2218             SSL_CONF_CTX_free(confctx);
2219         }
2220         SSL_CTX_set_allow_early_data_cb(sctx, allow_early_data_cb, &usecb);
2221     }
2222
2223     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
2224                                         &serverssl, &sess, idx)))
2225         goto end;
2226
2227     /*
2228      * The server is configured to accept early data. Create a connection to
2229      * "use up" the ticket
2230      */
2231     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE))
2232             || !TEST_true(SSL_session_reused(clientssl)))
2233         goto end;
2234
2235     SSL_shutdown(clientssl);
2236     SSL_shutdown(serverssl);
2237     SSL_free(serverssl);
2238     SSL_free(clientssl);
2239     serverssl = clientssl = NULL;
2240
2241     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
2242                                       &clientssl, NULL, NULL))
2243             || !TEST_true(SSL_set_session(clientssl, sess)))
2244         goto end;
2245
2246     /* Write and read some early data */
2247     if (!TEST_true(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
2248                                         &written))
2249             || !TEST_size_t_eq(written, strlen(MSG1)))
2250         goto end;
2251
2252     if (usecb <= 1) {
2253         if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2254                                              &readbytes),
2255                          SSL_READ_EARLY_DATA_FINISH)
2256                    /*
2257                     * The ticket was reused, so the we should have rejected the
2258                     * early data
2259                     */
2260                 || !TEST_int_eq(SSL_get_early_data_status(serverssl),
2261                                 SSL_EARLY_DATA_REJECTED))
2262             goto end;
2263     } else {
2264         /* In this case the callback decides to accept the early data */
2265         if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2266                                              &readbytes),
2267                          SSL_READ_EARLY_DATA_SUCCESS)
2268                 || !TEST_mem_eq(MSG1, strlen(MSG1), buf, readbytes)
2269                    /*
2270                     * Server will have sent its flight so client can now send
2271                     * end of early data and complete its half of the handshake
2272                     */
2273                 || !TEST_int_gt(SSL_connect(clientssl), 0)
2274                 || !TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2275                                              &readbytes),
2276                                 SSL_READ_EARLY_DATA_FINISH)
2277                 || !TEST_int_eq(SSL_get_early_data_status(serverssl),
2278                                 SSL_EARLY_DATA_ACCEPTED))
2279             goto end;
2280     }
2281
2282     /* Complete the connection */
2283     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE))
2284             || !TEST_int_eq(SSL_session_reused(clientssl), (usecb > 0) ? 1 : 0)
2285             || !TEST_int_eq(allow_ed_cb_called, usecb > 0 ? 1 : 0))
2286         goto end;
2287
2288     testresult = 1;
2289
2290  end:
2291     SSL_SESSION_free(sess);
2292     SSL_SESSION_free(clientpsk);
2293     SSL_SESSION_free(serverpsk);
2294     clientpsk = serverpsk = NULL;
2295     SSL_free(serverssl);
2296     SSL_free(clientssl);
2297     SSL_CTX_free(sctx);
2298     SSL_CTX_free(cctx);
2299     return testresult;
2300 }
2301
2302 static int test_early_data_replay(int idx)
2303 {
2304     int ret = 1, usecb, confopt;
2305
2306     for (usecb = 0; usecb < 3; usecb++) {
2307         for (confopt = 0; confopt < 2; confopt++)
2308             ret &= test_early_data_replay_int(idx, usecb, confopt);
2309     }
2310
2311     return ret;
2312 }
2313
2314 /*
2315  * Helper function to test that a server attempting to read early data can
2316  * handle a connection from a client where the early data should be skipped.
2317  */
2318 static int early_data_skip_helper(int hrr, int idx)
2319 {
2320     SSL_CTX *cctx = NULL, *sctx = NULL;
2321     SSL *clientssl = NULL, *serverssl = NULL;
2322     int testresult = 0;
2323     SSL_SESSION *sess = NULL;
2324     unsigned char buf[20];
2325     size_t readbytes, written;
2326
2327     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
2328                                         &serverssl, &sess, idx)))
2329         goto end;
2330
2331     if (hrr) {
2332         /* Force an HRR to occur */
2333         if (!TEST_true(SSL_set1_groups_list(serverssl, "P-256")))
2334             goto end;
2335     } else if (idx == 2) {
2336         /*
2337          * We force early_data rejection by ensuring the PSK identity is
2338          * unrecognised
2339          */
2340         srvid = "Dummy Identity";
2341     } else {
2342         /*
2343          * Deliberately corrupt the creation time. We take 20 seconds off the
2344          * time. It could be any value as long as it is not within tolerance.
2345          * This should mean the ticket is rejected.
2346          */
2347         if (!TEST_true(SSL_SESSION_set_time(sess, (long)(time(NULL) - 20))))
2348             goto end;
2349     }
2350
2351     /* Write some early data */
2352     if (!TEST_true(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
2353                                         &written))
2354             || !TEST_size_t_eq(written, strlen(MSG1)))
2355         goto end;
2356
2357     /* Server should reject the early data and skip over it */
2358     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2359                                          &readbytes),
2360                      SSL_READ_EARLY_DATA_FINISH)
2361             || !TEST_size_t_eq(readbytes, 0)
2362             || !TEST_int_eq(SSL_get_early_data_status(serverssl),
2363                             SSL_EARLY_DATA_REJECTED))
2364         goto end;
2365
2366     if (hrr) {
2367         /*
2368          * Finish off the handshake. We perform the same writes and reads as
2369          * further down but we expect them to fail due to the incomplete
2370          * handshake.
2371          */
2372         if (!TEST_false(SSL_write_ex(clientssl, MSG2, strlen(MSG2), &written))
2373                 || !TEST_false(SSL_read_ex(serverssl, buf, sizeof(buf),
2374                                &readbytes)))
2375             goto end;
2376     }
2377
2378     /* Should be able to send normal data despite rejection of early data */
2379     if (!TEST_true(SSL_write_ex(clientssl, MSG2, strlen(MSG2), &written))
2380             || !TEST_size_t_eq(written, strlen(MSG2))
2381             || !TEST_int_eq(SSL_get_early_data_status(clientssl),
2382                             SSL_EARLY_DATA_REJECTED)
2383             || !TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
2384             || !TEST_mem_eq(buf, readbytes, MSG2, strlen(MSG2)))
2385         goto end;
2386
2387     testresult = 1;
2388
2389  end:
2390     SSL_SESSION_free(clientpsk);
2391     SSL_SESSION_free(serverpsk);
2392     clientpsk = serverpsk = NULL;
2393     SSL_SESSION_free(sess);
2394     SSL_free(serverssl);
2395     SSL_free(clientssl);
2396     SSL_CTX_free(sctx);
2397     SSL_CTX_free(cctx);
2398     return testresult;
2399 }
2400
2401 /*
2402  * Test that a server attempting to read early data can handle a connection
2403  * from a client where the early data is not acceptable.
2404  */
2405 static int test_early_data_skip(int idx)
2406 {
2407     return early_data_skip_helper(0, idx);
2408 }
2409
2410 /*
2411  * Test that a server attempting to read early data can handle a connection
2412  * from a client where an HRR occurs.
2413  */
2414 static int test_early_data_skip_hrr(int idx)
2415 {
2416     return early_data_skip_helper(1, idx);
2417 }
2418
2419 /*
2420  * Test that a server attempting to read early data can handle a connection
2421  * from a client that doesn't send any.
2422  */
2423 static int test_early_data_not_sent(int idx)
2424 {
2425     SSL_CTX *cctx = NULL, *sctx = NULL;
2426     SSL *clientssl = NULL, *serverssl = NULL;
2427     int testresult = 0;
2428     SSL_SESSION *sess = NULL;
2429     unsigned char buf[20];
2430     size_t readbytes, written;
2431
2432     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
2433                                         &serverssl, &sess, idx)))
2434         goto end;
2435
2436     /* Write some data - should block due to handshake with server */
2437     SSL_set_connect_state(clientssl);
2438     if (!TEST_false(SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written)))
2439         goto end;
2440
2441     /* Server should detect that early data has not been sent */
2442     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2443                                          &readbytes),
2444                      SSL_READ_EARLY_DATA_FINISH)
2445             || !TEST_size_t_eq(readbytes, 0)
2446             || !TEST_int_eq(SSL_get_early_data_status(serverssl),
2447                             SSL_EARLY_DATA_NOT_SENT)
2448             || !TEST_int_eq(SSL_get_early_data_status(clientssl),
2449                             SSL_EARLY_DATA_NOT_SENT))
2450         goto end;
2451
2452     /* Continue writing the message we started earlier */
2453     if (!TEST_true(SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written))
2454             || !TEST_size_t_eq(written, strlen(MSG1))
2455             || !TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
2456             || !TEST_mem_eq(buf, readbytes, MSG1, strlen(MSG1))
2457             || !SSL_write_ex(serverssl, MSG2, strlen(MSG2), &written)
2458             || !TEST_size_t_eq(written, strlen(MSG2)))
2459         goto end;
2460
2461     if (!TEST_true(SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes))
2462             || !TEST_mem_eq(buf, readbytes, MSG2, strlen(MSG2)))
2463         goto end;
2464
2465     testresult = 1;
2466
2467  end:
2468     SSL_SESSION_free(sess);
2469     SSL_SESSION_free(clientpsk);
2470     SSL_SESSION_free(serverpsk);
2471     clientpsk = serverpsk = NULL;
2472     SSL_free(serverssl);
2473     SSL_free(clientssl);
2474     SSL_CTX_free(sctx);
2475     SSL_CTX_free(cctx);
2476     return testresult;
2477 }
2478
2479 static int hostname_cb(SSL *s, int *al, void *arg)
2480 {
2481     const char *hostname = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
2482
2483     if (hostname != NULL && strcmp(hostname, "goodhost") == 0)
2484         return  SSL_TLSEXT_ERR_OK;
2485
2486     return SSL_TLSEXT_ERR_NOACK;
2487 }
2488
2489 static const char *servalpn;
2490
2491 static int alpn_select_cb(SSL *ssl, const unsigned char **out,
2492                           unsigned char *outlen, const unsigned char *in,
2493                           unsigned int inlen, void *arg)
2494 {
2495     unsigned int protlen = 0;
2496     const unsigned char *prot;
2497
2498     for (prot = in; prot < in + inlen; prot += protlen) {
2499         protlen = *prot++;
2500         if (in + inlen < prot + protlen)
2501             return SSL_TLSEXT_ERR_NOACK;
2502
2503         if (protlen == strlen(servalpn)
2504                 && memcmp(prot, servalpn, protlen) == 0) {
2505             *out = prot;
2506             *outlen = protlen;
2507             return SSL_TLSEXT_ERR_OK;
2508         }
2509     }
2510
2511     return SSL_TLSEXT_ERR_NOACK;
2512 }
2513
2514 /* Test that a PSK can be used to send early_data */
2515 static int test_early_data_psk(int idx)
2516 {
2517     SSL_CTX *cctx = NULL, *sctx = NULL;
2518     SSL *clientssl = NULL, *serverssl = NULL;
2519     int testresult = 0;
2520     SSL_SESSION *sess = NULL;
2521     unsigned char alpnlist[] = {
2522         0x08, 'g', 'o', 'o', 'd', 'a', 'l', 'p', 'n', 0x07, 'b', 'a', 'd', 'a',
2523         'l', 'p', 'n'
2524     };
2525 #define GOODALPNLEN     9
2526 #define BADALPNLEN      8
2527 #define GOODALPN        (alpnlist)
2528 #define BADALPN         (alpnlist + GOODALPNLEN)
2529     int err = 0;
2530     unsigned char buf[20];
2531     size_t readbytes, written;
2532     int readearlyres = SSL_READ_EARLY_DATA_SUCCESS, connectres = 1;
2533     int edstatus = SSL_EARLY_DATA_ACCEPTED;
2534
2535     /* We always set this up with a final parameter of "2" for PSK */
2536     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
2537                                         &serverssl, &sess, 2)))
2538         goto end;
2539
2540     servalpn = "goodalpn";
2541
2542     /*
2543      * Note: There is no test for inconsistent SNI with late client detection.
2544      * This is because servers do not acknowledge SNI even if they are using
2545      * it in a resumption handshake - so it is not actually possible for a
2546      * client to detect a problem.
2547      */
2548     switch (idx) {
2549     case 0:
2550         /* Set inconsistent SNI (early client detection) */
2551         err = SSL_R_INCONSISTENT_EARLY_DATA_SNI;
2552         if (!TEST_true(SSL_SESSION_set1_hostname(sess, "goodhost"))
2553                 || !TEST_true(SSL_set_tlsext_host_name(clientssl, "badhost")))
2554             goto end;
2555         break;
2556
2557     case 1:
2558         /* Set inconsistent ALPN (early client detection) */
2559         err = SSL_R_INCONSISTENT_EARLY_DATA_ALPN;
2560         /* SSL_set_alpn_protos returns 0 for success and 1 for failure */
2561         if (!TEST_true(SSL_SESSION_set1_alpn_selected(sess, GOODALPN,
2562                                                       GOODALPNLEN))
2563                 || !TEST_false(SSL_set_alpn_protos(clientssl, BADALPN,
2564                                                    BADALPNLEN)))
2565             goto end;
2566         break;
2567
2568     case 2:
2569         /*
2570          * Set invalid protocol version. Technically this affects PSKs without
2571          * early_data too, but we test it here because it is similar to the
2572          * SNI/ALPN consistency tests.
2573          */
2574         err = SSL_R_BAD_PSK;
2575         if (!TEST_true(SSL_SESSION_set_protocol_version(sess, TLS1_2_VERSION)))
2576             goto end;
2577         break;
2578
2579     case 3:
2580         /*
2581          * Set inconsistent SNI (server detected). In this case the connection
2582          * will succeed but reject early_data.
2583          */
2584         SSL_SESSION_free(serverpsk);
2585         serverpsk = SSL_SESSION_dup(clientpsk);
2586         if (!TEST_ptr(serverpsk)
2587                 || !TEST_true(SSL_SESSION_set1_hostname(serverpsk, "badhost")))
2588             goto end;
2589         edstatus = SSL_EARLY_DATA_REJECTED;
2590         readearlyres = SSL_READ_EARLY_DATA_FINISH;
2591         /* Fall through */
2592     case 4:
2593         /* Set consistent SNI */
2594         if (!TEST_true(SSL_SESSION_set1_hostname(sess, "goodhost"))
2595                 || !TEST_true(SSL_set_tlsext_host_name(clientssl, "goodhost"))
2596                 || !TEST_true(SSL_CTX_set_tlsext_servername_callback(sctx,
2597                                 hostname_cb)))
2598             goto end;
2599         break;
2600
2601     case 5:
2602         /*
2603          * Set inconsistent ALPN (server detected). In this case the connection
2604          * will succeed but reject early_data.
2605          */
2606         servalpn = "badalpn";
2607         edstatus = SSL_EARLY_DATA_REJECTED;
2608         readearlyres = SSL_READ_EARLY_DATA_FINISH;
2609         /* Fall through */
2610     case 6:
2611         /*
2612          * Set consistent ALPN.
2613          * SSL_set_alpn_protos returns 0 for success and 1 for failure. It
2614          * accepts a list of protos (each one length prefixed).
2615          * SSL_set1_alpn_selected accepts a single protocol (not length
2616          * prefixed)
2617          */
2618         if (!TEST_true(SSL_SESSION_set1_alpn_selected(sess, GOODALPN + 1,
2619                                                       GOODALPNLEN - 1))
2620                 || !TEST_false(SSL_set_alpn_protos(clientssl, GOODALPN,
2621                                                    GOODALPNLEN)))
2622             goto end;
2623
2624         SSL_CTX_set_alpn_select_cb(sctx, alpn_select_cb, NULL);
2625         break;
2626
2627     case 7:
2628         /* Set inconsistent ALPN (late client detection) */
2629         SSL_SESSION_free(serverpsk);
2630         serverpsk = SSL_SESSION_dup(clientpsk);
2631         if (!TEST_ptr(serverpsk)
2632                 || !TEST_true(SSL_SESSION_set1_alpn_selected(clientpsk,
2633                                                              BADALPN + 1,
2634                                                              BADALPNLEN - 1))
2635                 || !TEST_true(SSL_SESSION_set1_alpn_selected(serverpsk,
2636                                                              GOODALPN + 1,
2637                                                              GOODALPNLEN - 1))
2638                 || !TEST_false(SSL_set_alpn_protos(clientssl, alpnlist,
2639                                                    sizeof(alpnlist))))
2640             goto end;
2641         SSL_CTX_set_alpn_select_cb(sctx, alpn_select_cb, NULL);
2642         edstatus = SSL_EARLY_DATA_ACCEPTED;
2643         readearlyres = SSL_READ_EARLY_DATA_SUCCESS;
2644         /* SSL_connect() call should fail */
2645         connectres = -1;
2646         break;
2647
2648     default:
2649         TEST_error("Bad test index");
2650         goto end;
2651     }
2652
2653     SSL_set_connect_state(clientssl);
2654     if (err != 0) {
2655         if (!TEST_false(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
2656                                             &written))
2657                 || !TEST_int_eq(SSL_get_error(clientssl, 0), SSL_ERROR_SSL)
2658                 || !TEST_int_eq(ERR_GET_REASON(ERR_get_error()), err))
2659             goto end;
2660     } else {
2661         if (!TEST_true(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
2662                                             &written)))
2663             goto end;
2664
2665         if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2666                                              &readbytes), readearlyres)
2667                 || (readearlyres == SSL_READ_EARLY_DATA_SUCCESS
2668                     && !TEST_mem_eq(buf, readbytes, MSG1, strlen(MSG1)))
2669                 || !TEST_int_eq(SSL_get_early_data_status(serverssl), edstatus)
2670                 || !TEST_int_eq(SSL_connect(clientssl), connectres))
2671             goto end;
2672     }
2673
2674     testresult = 1;
2675
2676  end:
2677     SSL_SESSION_free(sess);
2678     SSL_SESSION_free(clientpsk);
2679     SSL_SESSION_free(serverpsk);
2680     clientpsk = serverpsk = NULL;
2681     SSL_free(serverssl);
2682     SSL_free(clientssl);
2683     SSL_CTX_free(sctx);
2684     SSL_CTX_free(cctx);
2685     return testresult;
2686 }
2687
2688 /*
2689  * Test that a server that doesn't try to read early data can handle a
2690  * client sending some.
2691  */
2692 static int test_early_data_not_expected(int idx)
2693 {
2694     SSL_CTX *cctx = NULL, *sctx = NULL;
2695     SSL *clientssl = NULL, *serverssl = NULL;
2696     int testresult = 0;
2697     SSL_SESSION *sess = NULL;
2698     unsigned char buf[20];
2699     size_t readbytes, written;
2700
2701     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
2702                                         &serverssl, &sess, idx)))
2703         goto end;
2704
2705     /* Write some early data */
2706     if (!TEST_true(SSL_write_early_data(clientssl, MSG1, strlen(MSG1),
2707                                         &written)))
2708         goto end;
2709
2710     /*
2711      * Server should skip over early data and then block waiting for client to
2712      * continue handshake
2713      */
2714     if (!TEST_int_le(SSL_accept(serverssl), 0)
2715      || !TEST_int_gt(SSL_connect(clientssl), 0)
2716      || !TEST_int_eq(SSL_get_early_data_status(serverssl),
2717                      SSL_EARLY_DATA_REJECTED)
2718      || !TEST_int_gt(SSL_accept(serverssl), 0)
2719      || !TEST_int_eq(SSL_get_early_data_status(clientssl),
2720                      SSL_EARLY_DATA_REJECTED))
2721         goto end;
2722
2723     /* Send some normal data from client to server */
2724     if (!TEST_true(SSL_write_ex(clientssl, MSG2, strlen(MSG2), &written))
2725             || !TEST_size_t_eq(written, strlen(MSG2)))
2726         goto end;
2727
2728     if (!TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
2729             || !TEST_mem_eq(buf, readbytes, MSG2, strlen(MSG2)))
2730         goto end;
2731
2732     testresult = 1;
2733
2734  end:
2735     SSL_SESSION_free(sess);
2736     SSL_SESSION_free(clientpsk);
2737     SSL_SESSION_free(serverpsk);
2738     clientpsk = serverpsk = NULL;
2739     SSL_free(serverssl);
2740     SSL_free(clientssl);
2741     SSL_CTX_free(sctx);
2742     SSL_CTX_free(cctx);
2743     return testresult;
2744 }
2745
2746
2747 # ifndef OPENSSL_NO_TLS1_2
2748 /*
2749  * Test that a server attempting to read early data can handle a connection
2750  * from a TLSv1.2 client.
2751  */
2752 static int test_early_data_tls1_2(int idx)
2753 {
2754     SSL_CTX *cctx = NULL, *sctx = NULL;
2755     SSL *clientssl = NULL, *serverssl = NULL;
2756     int testresult = 0;
2757     unsigned char buf[20];
2758     size_t readbytes, written;
2759
2760     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl,
2761                                         &serverssl, NULL, idx)))
2762         goto end;
2763
2764     /* Write some data - should block due to handshake with server */
2765     SSL_set_max_proto_version(clientssl, TLS1_2_VERSION);
2766     SSL_set_connect_state(clientssl);
2767     if (!TEST_false(SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written)))
2768         goto end;
2769
2770     /*
2771      * Server should do TLSv1.2 handshake. First it will block waiting for more
2772      * messages from client after ServerDone. Then SSL_read_early_data should
2773      * finish and detect that early data has not been sent
2774      */
2775     if (!TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2776                                          &readbytes),
2777                      SSL_READ_EARLY_DATA_ERROR))
2778         goto end;
2779
2780     /*
2781      * Continue writing the message we started earlier. Will still block waiting
2782      * for the CCS/Finished from server
2783      */
2784     if (!TEST_false(SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written))
2785             || !TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
2786                                                 &readbytes),
2787                             SSL_READ_EARLY_DATA_FINISH)
2788             || !TEST_size_t_eq(readbytes, 0)
2789             || !TEST_int_eq(SSL_get_early_data_status(serverssl),
2790                             SSL_EARLY_DATA_NOT_SENT))
2791         goto end;
2792
2793     /* Continue writing the message we started earlier */
2794     if (!TEST_true(SSL_write_ex(clientssl, MSG1, strlen(MSG1), &written))
2795             || !TEST_size_t_eq(written, strlen(MSG1))
2796             || !TEST_int_eq(SSL_get_early_data_status(clientssl),
2797                             SSL_EARLY_DATA_NOT_SENT)
2798             || !TEST_true(SSL_read_ex(serverssl, buf, sizeof(buf), &readbytes))
2799             || !TEST_mem_eq(buf, readbytes, MSG1, strlen(MSG1))
2800             || !TEST_true(SSL_write_ex(serverssl, MSG2, strlen(MSG2), &written))
2801             || !TEST_size_t_eq(written, strlen(MSG2))
2802             || !SSL_read_ex(clientssl, buf, sizeof(buf), &readbytes)
2803             || !TEST_mem_eq(buf, readbytes, MSG2, strlen(MSG2)))
2804         goto end;
2805
2806     testresult = 1;
2807
2808  end:
2809     SSL_SESSION_free(clientpsk);
2810     SSL_SESSION_free(serverpsk);
2811     clientpsk = serverpsk = NULL;
2812     SSL_free(serverssl);
2813     SSL_free(clientssl);
2814     SSL_CTX_free(sctx);
2815     SSL_CTX_free(cctx);
2816
2817     return testresult;
2818 }
2819 # endif /* OPENSSL_NO_TLS1_2 */
2820
2821 /*
2822  * Test configuring the TLSv1.3 ciphersuites
2823  *
2824  * Test 0: Set a default ciphersuite in the SSL_CTX (no explicit cipher_list)
2825  * Test 1: Set a non-default ciphersuite in the SSL_CTX (no explicit cipher_list)
2826  * Test 2: Set a default ciphersuite in the SSL (no explicit cipher_list)
2827  * Test 3: Set a non-default ciphersuite in the SSL (no explicit cipher_list)
2828  * Test 4: Set a default ciphersuite in the SSL_CTX (SSL_CTX cipher_list)
2829  * Test 5: Set a non-default ciphersuite in the SSL_CTX (SSL_CTX cipher_list)
2830  * Test 6: Set a default ciphersuite in the SSL (SSL_CTX cipher_list)
2831  * Test 7: Set a non-default ciphersuite in the SSL (SSL_CTX cipher_list)
2832  * Test 8: Set a default ciphersuite in the SSL (SSL cipher_list)
2833  * Test 9: Set a non-default ciphersuite in the SSL (SSL cipher_list)
2834  */
2835 static int test_set_ciphersuite(int idx)
2836 {
2837     SSL_CTX *cctx = NULL, *sctx = NULL;
2838     SSL *clientssl = NULL, *serverssl = NULL;
2839     int testresult = 0;
2840
2841     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
2842                                        TLS1_VERSION, TLS_MAX_VERSION,
2843                                        &sctx, &cctx, cert, privkey))
2844             || !TEST_true(SSL_CTX_set_ciphersuites(sctx,
2845                            "TLS_AES_128_GCM_SHA256:TLS_AES_128_CCM_SHA256")))
2846         goto end;
2847
2848     if (idx >=4 && idx <= 7) {
2849         /* SSL_CTX explicit cipher list */
2850         if (!TEST_true(SSL_CTX_set_cipher_list(cctx, "AES256-GCM-SHA384")))
2851             goto end;
2852     }
2853
2854     if (idx == 0 || idx == 4) {
2855         /* Default ciphersuite */
2856         if (!TEST_true(SSL_CTX_set_ciphersuites(cctx,
2857                                                 "TLS_AES_128_GCM_SHA256")))
2858             goto end;
2859     } else if (idx == 1 || idx == 5) {
2860         /* Non default ciphersuite */
2861         if (!TEST_true(SSL_CTX_set_ciphersuites(cctx,
2862                                                 "TLS_AES_128_CCM_SHA256")))
2863             goto end;
2864     }
2865
2866     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
2867                                           &clientssl, NULL, NULL)))
2868         goto end;
2869
2870     if (idx == 8 || idx == 9) {
2871         /* SSL explicit cipher list */
2872         if (!TEST_true(SSL_set_cipher_list(clientssl, "AES256-GCM-SHA384")))
2873             goto end;
2874     }
2875
2876     if (idx == 2 || idx == 6 || idx == 8) {
2877         /* Default ciphersuite */
2878         if (!TEST_true(SSL_set_ciphersuites(clientssl,
2879                                             "TLS_AES_128_GCM_SHA256")))
2880             goto end;
2881     } else if (idx == 3 || idx == 7 || idx == 9) {
2882         /* Non default ciphersuite */
2883         if (!TEST_true(SSL_set_ciphersuites(clientssl,
2884                                             "TLS_AES_128_CCM_SHA256")))
2885             goto end;
2886     }
2887
2888     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE)))
2889         goto end;
2890
2891     testresult = 1;
2892
2893  end:
2894     SSL_free(serverssl);
2895     SSL_free(clientssl);
2896     SSL_CTX_free(sctx);
2897     SSL_CTX_free(cctx);
2898
2899     return testresult;
2900 }
2901
2902 static int test_ciphersuite_change(void)
2903 {
2904     SSL_CTX *cctx = NULL, *sctx = NULL;
2905     SSL *clientssl = NULL, *serverssl = NULL;
2906     SSL_SESSION *clntsess = NULL;
2907     int testresult = 0;
2908     const SSL_CIPHER *aes_128_gcm_sha256 = NULL;
2909
2910     /* Create a session based on SHA-256 */
2911     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
2912                                        TLS1_VERSION, TLS_MAX_VERSION,
2913                                        &sctx, &cctx, cert, privkey))
2914             || !TEST_true(SSL_CTX_set_ciphersuites(cctx,
2915                                                    "TLS_AES_128_GCM_SHA256"))
2916             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
2917                                           &clientssl, NULL, NULL))
2918             || !TEST_true(create_ssl_connection(serverssl, clientssl,
2919                                                 SSL_ERROR_NONE)))
2920         goto end;
2921
2922     clntsess = SSL_get1_session(clientssl);
2923     /* Save for later */
2924     aes_128_gcm_sha256 = SSL_SESSION_get0_cipher(clntsess);
2925     SSL_shutdown(clientssl);
2926     SSL_shutdown(serverssl);
2927     SSL_free(serverssl);
2928     SSL_free(clientssl);
2929     serverssl = clientssl = NULL;
2930
2931 # if !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305)
2932     /* Check we can resume a session with a different SHA-256 ciphersuite */
2933     if (!TEST_true(SSL_CTX_set_ciphersuites(cctx,
2934                                             "TLS_CHACHA20_POLY1305_SHA256"))
2935             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
2936                                              NULL, NULL))
2937             || !TEST_true(SSL_set_session(clientssl, clntsess))
2938             || !TEST_true(create_ssl_connection(serverssl, clientssl,
2939                                                 SSL_ERROR_NONE))
2940             || !TEST_true(SSL_session_reused(clientssl)))
2941         goto end;
2942
2943     SSL_SESSION_free(clntsess);
2944     clntsess = SSL_get1_session(clientssl);
2945     SSL_shutdown(clientssl);
2946     SSL_shutdown(serverssl);
2947     SSL_free(serverssl);
2948     SSL_free(clientssl);
2949     serverssl = clientssl = NULL;
2950 # endif
2951
2952     /*
2953      * Check attempting to resume a SHA-256 session with no SHA-256 ciphersuites
2954      * succeeds but does not resume.
2955      */
2956     if (!TEST_true(SSL_CTX_set_ciphersuites(cctx, "TLS_AES_256_GCM_SHA384"))
2957             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
2958                                              NULL, NULL))
2959             || !TEST_true(SSL_set_session(clientssl, clntsess))
2960             || !TEST_true(create_ssl_connection(serverssl, clientssl,
2961                                                 SSL_ERROR_SSL))
2962             || !TEST_false(SSL_session_reused(clientssl)))
2963         goto end;
2964
2965     SSL_SESSION_free(clntsess);
2966     clntsess = NULL;
2967     SSL_shutdown(clientssl);
2968     SSL_shutdown(serverssl);
2969     SSL_free(serverssl);
2970     SSL_free(clientssl);
2971     serverssl = clientssl = NULL;
2972
2973     /* Create a session based on SHA384 */
2974     if (!TEST_true(SSL_CTX_set_ciphersuites(cctx, "TLS_AES_256_GCM_SHA384"))
2975             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
2976                                           &clientssl, NULL, NULL))
2977             || !TEST_true(create_ssl_connection(serverssl, clientssl,
2978                                                 SSL_ERROR_NONE)))
2979         goto end;
2980
2981     clntsess = SSL_get1_session(clientssl);
2982     SSL_shutdown(clientssl);
2983     SSL_shutdown(serverssl);
2984     SSL_free(serverssl);
2985     SSL_free(clientssl);
2986     serverssl = clientssl = NULL;
2987
2988     if (!TEST_true(SSL_CTX_set_ciphersuites(cctx,
2989                    "TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384"))
2990             || !TEST_true(SSL_CTX_set_ciphersuites(sctx,
2991                                                    "TLS_AES_256_GCM_SHA384"))
2992             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
2993                                              NULL, NULL))
2994             || !TEST_true(SSL_set_session(clientssl, clntsess))
2995                /*
2996                 * We use SSL_ERROR_WANT_READ below so that we can pause the
2997                 * connection after the initial ClientHello has been sent to
2998                 * enable us to make some session changes.
2999                 */
3000             || !TEST_false(create_ssl_connection(serverssl, clientssl,
3001                                                 SSL_ERROR_WANT_READ)))
3002         goto end;
3003
3004     /* Trick the client into thinking this session is for a different digest */
3005     clntsess->cipher = aes_128_gcm_sha256;
3006     clntsess->cipher_id = clntsess->cipher->id;
3007
3008     /*
3009      * Continue the previously started connection. Server has selected a SHA-384
3010      * ciphersuite, but client thinks the session is for SHA-256, so it should
3011      * bail out.
3012      */
3013     if (!TEST_false(create_ssl_connection(serverssl, clientssl,
3014                                                 SSL_ERROR_SSL))
3015             || !TEST_int_eq(ERR_GET_REASON(ERR_get_error()),
3016                             SSL_R_CIPHERSUITE_DIGEST_HAS_CHANGED))
3017         goto end;
3018
3019     testresult = 1;
3020
3021  end:
3022     SSL_SESSION_free(clntsess);
3023     SSL_free(serverssl);
3024     SSL_free(clientssl);
3025     SSL_CTX_free(sctx);
3026     SSL_CTX_free(cctx);
3027
3028     return testresult;
3029 }
3030
3031 /*
3032  * Test TLSv1.3 PSKs
3033  * Test 0 = Test new style callbacks
3034  * Test 1 = Test both new and old style callbacks
3035  * Test 2 = Test old style callbacks
3036  * Test 3 = Test old style callbacks with no certificate
3037  */
3038 static int test_tls13_psk(int idx)
3039 {
3040     SSL_CTX *sctx = NULL, *cctx = NULL;
3041     SSL *serverssl = NULL, *clientssl = NULL;
3042     const SSL_CIPHER *cipher = NULL;
3043     const unsigned char key[] = {
3044         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
3045         0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
3046         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
3047         0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f
3048     };
3049     int testresult = 0;
3050
3051     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
3052                                        TLS1_VERSION, TLS_MAX_VERSION,
3053                                        &sctx, &cctx, idx == 3 ? NULL : cert,
3054                                        idx == 3 ? NULL : privkey)))
3055         goto end;
3056
3057     if (idx != 3) {
3058         /*
3059          * We use a ciphersuite with SHA256 to ease testing old style PSK
3060          * callbacks which will always default to SHA256. This should not be
3061          * necessary if we have no cert/priv key. In that case the server should
3062          * prefer SHA256 automatically.
3063          */
3064         if (!TEST_true(SSL_CTX_set_ciphersuites(cctx,
3065                                                 "TLS_AES_128_GCM_SHA256")))
3066             goto end;
3067     }
3068
3069     /*
3070      * Test 0: New style callbacks only
3071      * Test 1: New and old style callbacks (only the new ones should be used)
3072      * Test 2: Old style callbacks only
3073      */
3074     if (idx == 0 || idx == 1) {
3075         SSL_CTX_set_psk_use_session_callback(cctx, use_session_cb);
3076         SSL_CTX_set_psk_find_session_callback(sctx, find_session_cb);
3077     }
3078 #ifndef OPENSSL_NO_PSK
3079     if (idx >= 1) {
3080         SSL_CTX_set_psk_client_callback(cctx, psk_client_cb);
3081         SSL_CTX_set_psk_server_callback(sctx, psk_server_cb);
3082     }
3083 #endif
3084     srvid = pskid;
3085     use_session_cb_cnt = 0;
3086     find_session_cb_cnt = 0;
3087     psk_client_cb_cnt = 0;
3088     psk_server_cb_cnt = 0;
3089
3090     if (idx != 3) {
3091         /*
3092          * Check we can create a connection if callback decides not to send a
3093          * PSK
3094          */
3095         if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
3096                                                  NULL, NULL))
3097                 || !TEST_true(create_ssl_connection(serverssl, clientssl,
3098                                                     SSL_ERROR_NONE))
3099                 || !TEST_false(SSL_session_reused(clientssl))
3100                 || !TEST_false(SSL_session_reused(serverssl)))
3101             goto end;
3102
3103         if (idx == 0 || idx == 1) {
3104             if (!TEST_true(use_session_cb_cnt == 1)
3105                     || !TEST_true(find_session_cb_cnt == 0)
3106                        /*
3107                         * If no old style callback then below should be 0
3108                         * otherwise 1
3109                         */
3110                     || !TEST_true(psk_client_cb_cnt == idx)
3111                     || !TEST_true(psk_server_cb_cnt == 0))
3112                 goto end;
3113         } else {
3114             if (!TEST_true(use_session_cb_cnt == 0)
3115                     || !TEST_true(find_session_cb_cnt == 0)
3116                     || !TEST_true(psk_client_cb_cnt == 1)
3117                     || !TEST_true(psk_server_cb_cnt == 0))
3118                 goto end;
3119         }
3120
3121         shutdown_ssl_connection(serverssl, clientssl);
3122         serverssl = clientssl = NULL;
3123         use_session_cb_cnt = psk_client_cb_cnt = 0;
3124     }
3125
3126     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
3127                                              NULL, NULL)))
3128         goto end;
3129
3130     /* Create the PSK */
3131     cipher = SSL_CIPHER_find(clientssl, TLS13_AES_128_GCM_SHA256_BYTES);
3132     clientpsk = SSL_SESSION_new();
3133     if (!TEST_ptr(clientpsk)
3134             || !TEST_ptr(cipher)
3135             || !TEST_true(SSL_SESSION_set1_master_key(clientpsk, key,
3136                                                       sizeof(key)))
3137             || !TEST_true(SSL_SESSION_set_cipher(clientpsk, cipher))
3138             || !TEST_true(SSL_SESSION_set_protocol_version(clientpsk,
3139                                                            TLS1_3_VERSION))
3140             || !TEST_true(SSL_SESSION_up_ref(clientpsk)))
3141         goto end;
3142     serverpsk = clientpsk;
3143
3144     /* Check we can create a connection and the PSK is used */
3145     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE))
3146             || !TEST_true(SSL_session_reused(clientssl))
3147             || !TEST_true(SSL_session_reused(serverssl)))
3148         goto end;
3149
3150     if (idx == 0 || idx == 1) {
3151         if (!TEST_true(use_session_cb_cnt == 1)
3152                 || !TEST_true(find_session_cb_cnt == 1)
3153                 || !TEST_true(psk_client_cb_cnt == 0)
3154                 || !TEST_true(psk_server_cb_cnt == 0))
3155             goto end;
3156     } else {
3157         if (!TEST_true(use_session_cb_cnt == 0)
3158                 || !TEST_true(find_session_cb_cnt == 0)
3159                 || !TEST_true(psk_client_cb_cnt == 1)
3160                 || !TEST_true(psk_server_cb_cnt == 1))
3161             goto end;
3162     }
3163
3164     shutdown_ssl_connection(serverssl, clientssl);
3165     serverssl = clientssl = NULL;
3166     use_session_cb_cnt = find_session_cb_cnt = 0;
3167     psk_client_cb_cnt = psk_server_cb_cnt = 0;
3168
3169     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
3170                                              NULL, NULL)))
3171         goto end;
3172
3173     /* Force an HRR */
3174     if (!TEST_true(SSL_set1_groups_list(serverssl, "P-256")))
3175         goto end;
3176
3177     /*
3178      * Check we can create a connection, the PSK is used and the callbacks are
3179      * called twice.
3180      */
3181     if (!TEST_true(create_ssl_connection(serverssl, clientssl, SSL_ERROR_NONE))
3182             || !TEST_true(SSL_session_reused(clientssl))
3183             || !TEST_true(SSL_session_reused(serverssl)))
3184         goto end;
3185
3186     if (idx == 0 || idx == 1) {
3187         if (!TEST_true(use_session_cb_cnt == 2)
3188                 || !TEST_true(find_session_cb_cnt == 2)
3189                 || !TEST_true(psk_client_cb_cnt == 0)
3190                 || !TEST_true(psk_server_cb_cnt == 0))
3191             goto end;
3192     } else {
3193         if (!TEST_true(use_session_cb_cnt == 0)
3194                 || !TEST_true(find_session_cb_cnt == 0)
3195                 || !TEST_true(psk_client_cb_cnt == 2)
3196                 || !TEST_true(psk_server_cb_cnt == 2))
3197             goto end;
3198     }
3199
3200     shutdown_ssl_connection(serverssl, clientssl);
3201     serverssl = clientssl = NULL;
3202     use_session_cb_cnt = find_session_cb_cnt = 0;
3203     psk_client_cb_cnt = psk_server_cb_cnt = 0;
3204
3205     if (idx != 3) {
3206         /*
3207          * Check that if the server rejects the PSK we can still connect, but with
3208          * a full handshake
3209          */
3210         srvid = "Dummy Identity";
3211         if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
3212                                                  NULL, NULL))
3213                 || !TEST_true(create_ssl_connection(serverssl, clientssl,
3214                                                     SSL_ERROR_NONE))
3215                 || !TEST_false(SSL_session_reused(clientssl))
3216                 || !TEST_false(SSL_session_reused(serverssl)))
3217             goto end;
3218
3219         if (idx == 0 || idx == 1) {
3220             if (!TEST_true(use_session_cb_cnt == 1)
3221                     || !TEST_true(find_session_cb_cnt == 1)
3222                     || !TEST_true(psk_client_cb_cnt == 0)
3223                        /*
3224                         * If no old style callback then below should be 0
3225                         * otherwise 1
3226                         */
3227                     || !TEST_true(psk_server_cb_cnt == idx))
3228                 goto end;
3229         } else {
3230             if (!TEST_true(use_session_cb_cnt == 0)
3231                     || !TEST_true(find_session_cb_cnt == 0)
3232                     || !TEST_true(psk_client_cb_cnt == 1)
3233                     || !TEST_true(psk_server_cb_cnt == 1))
3234                 goto end;
3235         }
3236
3237         shutdown_ssl_connection(serverssl, clientssl);
3238         serverssl = clientssl = NULL;
3239     }
3240     testresult = 1;
3241
3242  end:
3243     SSL_SESSION_free(clientpsk);
3244     SSL_SESSION_free(serverpsk);
3245     clientpsk = serverpsk = NULL;
3246     SSL_free(serverssl);
3247     SSL_free(clientssl);
3248     SSL_CTX_free(sctx);
3249     SSL_CTX_free(cctx);
3250     return testresult;
3251 }
3252
3253 static unsigned char cookie_magic_value[] = "cookie magic";
3254
3255 static int generate_cookie_callback(SSL *ssl, unsigned char *cookie,
3256                                     unsigned int *cookie_len)
3257 {
3258     /*
3259      * Not suitable as a real cookie generation function but good enough for
3260      * testing!
3261      */
3262     memcpy(cookie, cookie_magic_value, sizeof(cookie_magic_value) - 1);
3263     *cookie_len = sizeof(cookie_magic_value) - 1;
3264
3265     return 1;
3266 }
3267
3268 static int verify_cookie_callback(SSL *ssl, const unsigned char *cookie,
3269                                   unsigned int cookie_len)
3270 {
3271     if (cookie_len == sizeof(cookie_magic_value) - 1
3272         && memcmp(cookie, cookie_magic_value, cookie_len) == 0)
3273         return 1;
3274
3275     return 0;
3276 }
3277
3278 static int generate_stateless_cookie_callback(SSL *ssl, unsigned char *cookie,
3279                                         size_t *cookie_len)
3280 {
3281     unsigned int temp;
3282     int res = generate_cookie_callback(ssl, cookie, &temp);
3283     *cookie_len = temp;
3284     return res;
3285 }
3286
3287 static int verify_stateless_cookie_callback(SSL *ssl, const unsigned char *cookie,
3288                                       size_t cookie_len)
3289 {
3290     return verify_cookie_callback(ssl, cookie, cookie_len);
3291 }
3292
3293 static int test_stateless(void)
3294 {
3295     SSL_CTX *sctx = NULL, *cctx = NULL;
3296     SSL *serverssl = NULL, *clientssl = NULL;
3297     int testresult = 0;
3298
3299     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
3300                                        TLS1_VERSION, TLS_MAX_VERSION,
3301                                        &sctx, &cctx, cert, privkey)))
3302         goto end;
3303
3304     /* The arrival of CCS messages can confuse the test */
3305     SSL_CTX_clear_options(cctx, SSL_OP_ENABLE_MIDDLEBOX_COMPAT);
3306
3307     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
3308                                       NULL, NULL))
3309                /* Send the first ClientHello */
3310             || !TEST_false(create_ssl_connection(serverssl, clientssl,
3311                                                  SSL_ERROR_WANT_READ))
3312                /*
3313                 * This should fail with a -1 return because we have no callbacks
3314                 * set up
3315                 */
3316             || !TEST_int_eq(SSL_stateless(serverssl), -1))
3317         goto end;
3318
3319     /* Fatal error so abandon the connection from this client */
3320     SSL_free(clientssl);
3321     clientssl = NULL;
3322
3323     /* Set up the cookie generation and verification callbacks */
3324     SSL_CTX_set_stateless_cookie_generate_cb(sctx, generate_stateless_cookie_callback);
3325     SSL_CTX_set_stateless_cookie_verify_cb(sctx, verify_stateless_cookie_callback);
3326
3327     /*
3328      * Create a new connection from the client (we can reuse the server SSL
3329      * object).
3330      */
3331     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
3332                                              NULL, NULL))
3333                /* Send the first ClientHello */
3334             || !TEST_false(create_ssl_connection(serverssl, clientssl,
3335                                                 SSL_ERROR_WANT_READ))
3336                /* This should fail because there is no cookie */
3337             || !TEST_int_eq(SSL_stateless(serverssl), 0))
3338         goto end;
3339
3340     /* Abandon the connection from this client */
3341     SSL_free(clientssl);
3342     clientssl = NULL;
3343
3344     /*
3345      * Now create a connection from a new client but with the same server SSL
3346      * object
3347      */
3348     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
3349                                              NULL, NULL))
3350                /* Send the first ClientHello */
3351             || !TEST_false(create_ssl_connection(serverssl, clientssl,
3352                                                 SSL_ERROR_WANT_READ))
3353                /* This should fail because there is no cookie */
3354             || !TEST_int_eq(SSL_stateless(serverssl), 0)
3355                /* Send the second ClientHello */
3356             || !TEST_false(create_ssl_connection(serverssl, clientssl,
3357                                                 SSL_ERROR_WANT_READ))
3358                /* This should succeed because a cookie is now present */
3359             || !TEST_int_eq(SSL_stateless(serverssl), 1)
3360                /* Complete the connection */
3361             || !TEST_true(create_ssl_connection(serverssl, clientssl,
3362                                                 SSL_ERROR_NONE)))
3363         goto end;
3364
3365     shutdown_ssl_connection(serverssl, clientssl);
3366     serverssl = clientssl = NULL;
3367     testresult = 1;
3368
3369  end:
3370     SSL_free(serverssl);
3371     SSL_free(clientssl);
3372     SSL_CTX_free(sctx);
3373     SSL_CTX_free(cctx);
3374     return testresult;
3375
3376 }
3377 #endif /* OPENSSL_NO_TLS1_3 */
3378
3379 static int clntaddoldcb = 0;
3380 static int clntparseoldcb = 0;
3381 static int srvaddoldcb = 0;
3382 static int srvparseoldcb = 0;
3383 static int clntaddnewcb = 0;
3384 static int clntparsenewcb = 0;
3385 static int srvaddnewcb = 0;
3386 static int srvparsenewcb = 0;
3387 static int snicb = 0;
3388
3389 #define TEST_EXT_TYPE1  0xff00
3390
3391 static int old_add_cb(SSL *s, unsigned int ext_type, const unsigned char **out,
3392                       size_t *outlen, int *al, void *add_arg)
3393 {
3394     int *server = (int *)add_arg;
3395     unsigned char *data;
3396
3397     if (SSL_is_server(s))
3398         srvaddoldcb++;
3399     else
3400         clntaddoldcb++;
3401
3402     if (*server != SSL_is_server(s)
3403             || (data = OPENSSL_malloc(sizeof(*data))) == NULL)
3404         return -1;
3405
3406     *data = 1;
3407     *out = data;
3408     *outlen = sizeof(char);
3409     return 1;
3410 }
3411
3412 static void old_free_cb(SSL *s, unsigned int ext_type, const unsigned char *out,
3413                         void *add_arg)
3414 {
3415     OPENSSL_free((unsigned char *)out);
3416 }
3417
3418 static int old_parse_cb(SSL *s, unsigned int ext_type, const unsigned char *in,
3419                         size_t inlen, int *al, void *parse_arg)
3420 {
3421     int *server = (int *)parse_arg;
3422
3423     if (SSL_is_server(s))
3424         srvparseoldcb++;
3425     else
3426         clntparseoldcb++;
3427
3428     if (*server != SSL_is_server(s)
3429             || inlen != sizeof(char)
3430             || *in != 1)
3431         return -1;
3432
3433     return 1;
3434 }
3435
3436 static int new_add_cb(SSL *s, unsigned int ext_type, unsigned int context,
3437                       const unsigned char **out, size_t *outlen, X509 *x,
3438                       size_t chainidx, int *al, void *add_arg)
3439 {
3440     int *server = (int *)add_arg;
3441     unsigned char *data;
3442
3443     if (SSL_is_server(s))
3444         srvaddnewcb++;
3445     else
3446         clntaddnewcb++;
3447
3448     if (*server != SSL_is_server(s)
3449             || (data = OPENSSL_malloc(sizeof(*data))) == NULL)
3450         return -1;
3451
3452     *data = 1;
3453     *out = data;
3454     *outlen = sizeof(*data);
3455     return 1;
3456 }
3457
3458 static void new_free_cb(SSL *s, unsigned int ext_type, unsigned int context,
3459                         const unsigned char *out, void *add_arg)
3460 {
3461     OPENSSL_free((unsigned char *)out);
3462 }
3463
3464 static int new_parse_cb(SSL *s, unsigned int ext_type, unsigned int context,
3465                         const unsigned char *in, size_t inlen, X509 *x,
3466                         size_t chainidx, int *al, void *parse_arg)
3467 {
3468     int *server = (int *)parse_arg;
3469
3470     if (SSL_is_server(s))
3471         srvparsenewcb++;
3472     else
3473         clntparsenewcb++;
3474
3475     if (*server != SSL_is_server(s)
3476             || inlen != sizeof(char) || *in != 1)
3477         return -1;
3478
3479     return 1;
3480 }
3481
3482 static int sni_cb(SSL *s, int *al, void *arg)
3483 {
3484     SSL_CTX *ctx = (SSL_CTX *)arg;
3485
3486     if (SSL_set_SSL_CTX(s, ctx) == NULL) {
3487         *al = SSL_AD_INTERNAL_ERROR;
3488         return SSL_TLSEXT_ERR_ALERT_FATAL;
3489     }
3490     snicb++;
3491     return SSL_TLSEXT_ERR_OK;
3492 }
3493
3494 /*
3495  * Custom call back tests.
3496  * Test 0: Old style callbacks in TLSv1.2
3497  * Test 1: New style callbacks in TLSv1.2
3498  * Test 2: New style callbacks in TLSv1.2 with SNI
3499  * Test 3: New style callbacks in TLSv1.3. Extensions in CH and EE
3500  * Test 4: New style callbacks in TLSv1.3. Extensions in CH, SH, EE, Cert + NST
3501  */
3502 static int test_custom_exts(int tst)
3503 {
3504     SSL_CTX *cctx = NULL, *sctx = NULL, *sctx2 = NULL;
3505     SSL *clientssl = NULL, *serverssl = NULL;
3506     int testresult = 0;
3507     static int server = 1;
3508     static int client = 0;
3509     SSL_SESSION *sess = NULL;
3510     unsigned int context;
3511
3512 #if defined(OPENSSL_NO_TLS1_2) && !defined(OPENSSL_NO_TLS1_3)
3513     /* Skip tests for TLSv1.2 and below in this case */
3514     if (tst < 3)
3515         return 1;
3516 #endif
3517
3518     /* Reset callback counters */
3519     clntaddoldcb = clntparseoldcb = srvaddoldcb = srvparseoldcb = 0;
3520     clntaddnewcb = clntparsenewcb = srvaddnewcb = srvparsenewcb = 0;
3521     snicb = 0;
3522
3523     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
3524                                        TLS1_VERSION, TLS_MAX_VERSION,
3525                                        &sctx, &cctx, cert, privkey)))
3526         goto end;
3527
3528     if (tst == 2
3529             && !TEST_true(create_ssl_ctx_pair(TLS_server_method(), NULL,
3530                                               TLS1_VERSION, TLS_MAX_VERSION,
3531                                               &sctx2, NULL, cert, privkey)))
3532         goto end;
3533
3534
3535     if (tst < 3) {
3536         SSL_CTX_set_options(cctx, SSL_OP_NO_TLSv1_3);
3537         SSL_CTX_set_options(sctx, SSL_OP_NO_TLSv1_3);
3538         if (sctx2 != NULL)
3539             SSL_CTX_set_options(sctx2, SSL_OP_NO_TLSv1_3);
3540     }
3541
3542     if (tst == 4) {
3543         context = SSL_EXT_CLIENT_HELLO
3544                   | SSL_EXT_TLS1_2_SERVER_HELLO
3545                   | SSL_EXT_TLS1_3_SERVER_HELLO
3546                   | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS
3547                   | SSL_EXT_TLS1_3_CERTIFICATE
3548                   | SSL_EXT_TLS1_3_NEW_SESSION_TICKET;
3549     } else {
3550         context = SSL_EXT_CLIENT_HELLO
3551                   | SSL_EXT_TLS1_2_SERVER_HELLO
3552                   | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS;
3553     }
3554
3555     /* Create a client side custom extension */
3556     if (tst == 0) {
3557         if (!TEST_true(SSL_CTX_add_client_custom_ext(cctx, TEST_EXT_TYPE1,
3558                                                      old_add_cb, old_free_cb,
3559                                                      &client, old_parse_cb,
3560                                                      &client)))
3561             goto end;
3562     } else {
3563         if (!TEST_true(SSL_CTX_add_custom_ext(cctx, TEST_EXT_TYPE1, context,
3564                                               new_add_cb, new_free_cb,
3565                                               &client, new_parse_cb, &client)))
3566             goto end;
3567     }
3568
3569     /* Should not be able to add duplicates */
3570     if (!TEST_false(SSL_CTX_add_client_custom_ext(cctx, TEST_EXT_TYPE1,
3571                                                   old_add_cb, old_free_cb,
3572                                                   &client, old_parse_cb,
3573                                                   &client))
3574             || !TEST_false(SSL_CTX_add_custom_ext(cctx, TEST_EXT_TYPE1,
3575                                                   context, new_add_cb,
3576                                                   new_free_cb, &client,
3577                                                   new_parse_cb, &client)))
3578         goto end;
3579
3580     /* Create a server side custom extension */
3581     if (tst == 0) {
3582         if (!TEST_true(SSL_CTX_add_server_custom_ext(sctx, TEST_EXT_TYPE1,
3583                                                      old_add_cb, old_free_cb,
3584                                                      &server, old_parse_cb,
3585                                                      &server)))
3586             goto end;
3587     } else {
3588         if (!TEST_true(SSL_CTX_add_custom_ext(sctx, TEST_EXT_TYPE1, context,
3589                                               new_add_cb, new_free_cb,
3590                                               &server, new_parse_cb, &server)))
3591             goto end;
3592         if (sctx2 != NULL
3593                 && !TEST_true(SSL_CTX_add_custom_ext(sctx2, TEST_EXT_TYPE1,
3594                                                      context, new_add_cb,
3595                                                      new_free_cb, &server,
3596                                                      new_parse_cb, &server)))
3597             goto end;
3598     }
3599
3600     /* Should not be able to add duplicates */
3601     if (!TEST_false(SSL_CTX_add_server_custom_ext(sctx, TEST_EXT_TYPE1,
3602                                                   old_add_cb, old_free_cb,
3603                                                   &server, old_parse_cb,
3604                                                   &server))
3605             || !TEST_false(SSL_CTX_add_custom_ext(sctx, TEST_EXT_TYPE1,
3606                                                   context, new_add_cb,
3607                                                   new_free_cb, &server,
3608                                                   new_parse_cb, &server)))
3609         goto end;
3610
3611     if (tst == 2) {
3612         /* Set up SNI */
3613         if (!TEST_true(SSL_CTX_set_tlsext_servername_callback(sctx, sni_cb))
3614                 || !TEST_true(SSL_CTX_set_tlsext_servername_arg(sctx, sctx2)))
3615             goto end;
3616     }
3617
3618     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
3619                                       &clientssl, NULL, NULL))
3620             || !TEST_true(create_ssl_connection(serverssl, clientssl,
3621                                                 SSL_ERROR_NONE)))
3622         goto end;
3623
3624     if (tst == 0) {
3625         if (clntaddoldcb != 1
3626                 || clntparseoldcb != 1
3627                 || srvaddoldcb != 1
3628                 || srvparseoldcb != 1)
3629             goto end;
3630     } else if (tst == 1 || tst == 2 || tst == 3) {
3631         if (clntaddnewcb != 1
3632                 || clntparsenewcb != 1
3633                 || srvaddnewcb != 1
3634                 || srvparsenewcb != 1
3635                 || (tst != 2 && snicb != 0)
3636                 || (tst == 2 && snicb != 1))
3637             goto end;
3638     } else {
3639         /* In this case there 2 NewSessionTicket messages created */
3640         if (clntaddnewcb != 1
3641                 || clntparsenewcb != 5
3642                 || srvaddnewcb != 5
3643                 || srvparsenewcb != 1)
3644             goto end;
3645     }
3646
3647     sess = SSL_get1_session(clientssl);
3648     SSL_shutdown(clientssl);
3649     SSL_shutdown(serverssl);
3650     SSL_free(serverssl);
3651     SSL_free(clientssl);
3652     serverssl = clientssl = NULL;
3653
3654     if (tst == 3) {
3655         /* We don't bother with the resumption aspects for this test */
3656         testresult = 1;
3657         goto end;
3658     }
3659
3660     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
3661                                       NULL, NULL))
3662             || !TEST_true(SSL_set_session(clientssl, sess))
3663             || !TEST_true(create_ssl_connection(serverssl, clientssl,
3664                                                SSL_ERROR_NONE)))
3665         goto end;
3666
3667     /*
3668      * For a resumed session we expect to add the ClientHello extension. For the
3669      * old style callbacks we ignore it on the server side because they set
3670      * SSL_EXT_IGNORE_ON_RESUMPTION. The new style callbacks do not ignore
3671      * them.
3672      */
3673     if (tst == 0) {
3674         if (clntaddoldcb != 2
3675                 || clntparseoldcb != 1
3676                 || srvaddoldcb != 1
3677                 || srvparseoldcb != 1)
3678             goto end;
3679     } else if (tst == 1 || tst == 2 || tst == 3) {
3680         if (clntaddnewcb != 2
3681                 || clntparsenewcb != 2
3682                 || srvaddnewcb != 2
3683                 || srvparsenewcb != 2)
3684             goto end;
3685     } else {
3686         /*
3687          * No Certificate message extensions in the resumption handshake,
3688          * 2 NewSessionTickets in the initial handshake, 1 in the resumption
3689          */
3690         if (clntaddnewcb != 2
3691                 || clntparsenewcb != 8
3692                 || srvaddnewcb != 8
3693                 || srvparsenewcb != 2)
3694             goto end;
3695     }
3696
3697     testresult = 1;
3698
3699 end:
3700     SSL_SESSION_free(sess);
3701     SSL_free(serverssl);
3702     SSL_free(clientssl);
3703     SSL_CTX_free(sctx2);
3704     SSL_CTX_free(sctx);
3705     SSL_CTX_free(cctx);
3706     return testresult;
3707 }
3708
3709 /*
3710  * Test loading of serverinfo data in various formats. test_sslmessages actually
3711  * tests to make sure the extensions appear in the handshake
3712  */
3713 static int test_serverinfo(int tst)
3714 {
3715     unsigned int version;
3716     unsigned char *sibuf;
3717     size_t sibuflen;
3718     int ret, expected, testresult = 0;
3719     SSL_CTX *ctx;
3720
3721     ctx = SSL_CTX_new(TLS_method());
3722     if (!TEST_ptr(ctx))
3723         goto end;
3724
3725     if ((tst & 0x01) == 0x01)
3726         version = SSL_SERVERINFOV2;
3727     else
3728         version = SSL_SERVERINFOV1;
3729
3730     if ((tst & 0x02) == 0x02) {
3731         sibuf = serverinfov2;
3732         sibuflen = sizeof(serverinfov2);
3733         expected = (version == SSL_SERVERINFOV2);
3734     } else {
3735         sibuf = serverinfov1;
3736         sibuflen = sizeof(serverinfov1);
3737         expected = (version == SSL_SERVERINFOV1);
3738     }
3739
3740     if ((tst & 0x04) == 0x04) {
3741         ret = SSL_CTX_use_serverinfo_ex(ctx, version, sibuf, sibuflen);
3742     } else {
3743         ret = SSL_CTX_use_serverinfo(ctx, sibuf, sibuflen);
3744
3745         /*
3746          * The version variable is irrelevant in this case - it's what is in the
3747          * buffer that matters
3748          */
3749         if ((tst & 0x02) == 0x02)
3750             expected = 0;
3751         else
3752             expected = 1;
3753     }
3754
3755     if (!TEST_true(ret == expected))
3756         goto end;
3757
3758     testresult = 1;
3759
3760  end:
3761     SSL_CTX_free(ctx);
3762
3763     return testresult;
3764 }
3765
3766 /*
3767  * Test that SSL_export_keying_material() produces expected results. There are
3768  * no test vectors so all we do is test that both sides of the communication
3769  * produce the same results for different protocol versions.
3770  */
3771 static int test_export_key_mat(int tst)
3772 {
3773     int testresult = 0;
3774     SSL_CTX *cctx = NULL, *sctx = NULL, *sctx2 = NULL;
3775     SSL *clientssl = NULL, *serverssl = NULL;
3776     const char label[] = "test label";
3777     const unsigned char context[] = "context";
3778     const unsigned char *emptycontext = NULL;
3779     unsigned char ckeymat1[80], ckeymat2[80], ckeymat3[80];
3780     unsigned char skeymat1[80], skeymat2[80], skeymat3[80];
3781     const int protocols[] = {
3782         TLS1_VERSION,
3783         TLS1_1_VERSION,
3784         TLS1_2_VERSION,
3785         TLS1_3_VERSION
3786     };
3787
3788 #ifdef OPENSSL_NO_TLS1
3789     if (tst == 0)
3790         return 1;
3791 #endif
3792 #ifdef OPENSSL_NO_TLS1_1
3793     if (tst == 1)
3794         return 1;
3795 #endif
3796 #ifdef OPENSSL_NO_TLS1_2
3797     if (tst == 2)
3798         return 1;
3799 #endif
3800 #ifdef OPENSSL_NO_TLS1_3
3801     if (tst == 3)
3802         return 1;
3803 #endif
3804     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
3805                                        TLS1_VERSION, TLS_MAX_VERSION,
3806                                        &sctx, &cctx, cert, privkey)))
3807         goto end;
3808
3809     OPENSSL_assert(tst >= 0 && (size_t)tst < OSSL_NELEM(protocols));
3810     SSL_CTX_set_max_proto_version(cctx, protocols[tst]);
3811     SSL_CTX_set_min_proto_version(cctx, protocols[tst]);
3812
3813     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl, NULL,
3814                                       NULL))
3815             || !TEST_true(create_ssl_connection(serverssl, clientssl,
3816                                                 SSL_ERROR_NONE)))
3817         goto end;
3818
3819     if (!TEST_int_eq(SSL_export_keying_material(clientssl, ckeymat1,
3820                                                 sizeof(ckeymat1), label,
3821                                                 sizeof(label) - 1, context,
3822                                                 sizeof(context) - 1, 1), 1)
3823             || !TEST_int_eq(SSL_export_keying_material(clientssl, ckeymat2,
3824                                                        sizeof(ckeymat2), label,
3825                                                        sizeof(label) - 1,
3826                                                        emptycontext,
3827                                                        0, 1), 1)
3828             || !TEST_int_eq(SSL_export_keying_material(clientssl, ckeymat3,
3829                                                        sizeof(ckeymat3), label,
3830                                                        sizeof(label) - 1,
3831                                                        NULL, 0, 0), 1)
3832             || !TEST_int_eq(SSL_export_keying_material(serverssl, skeymat1,
3833                                                        sizeof(skeymat1), label,
3834                                                        sizeof(label) - 1,
3835                                                        context,
3836                                                        sizeof(context) -1, 1),
3837                             1)
3838             || !TEST_int_eq(SSL_export_keying_material(serverssl, skeymat2,
3839                                                        sizeof(skeymat2), label,
3840                                                        sizeof(label) - 1,
3841                                                        emptycontext,
3842                                                        0, 1), 1)
3843             || !TEST_int_eq(SSL_export_keying_material(serverssl, skeymat3,
3844                                                        sizeof(skeymat3), label,
3845                                                        sizeof(label) - 1,
3846                                                        NULL, 0, 0), 1)
3847                /*
3848                 * Check that both sides created the same key material with the
3849                 * same context.
3850                 */
3851             || !TEST_mem_eq(ckeymat1, sizeof(ckeymat1), skeymat1,
3852                             sizeof(skeymat1))
3853                /*
3854                 * Check that both sides created the same key material with an
3855                 * empty context.
3856                 */
3857             || !TEST_mem_eq(ckeymat2, sizeof(ckeymat2), skeymat2,
3858                             sizeof(skeymat2))
3859                /*
3860                 * Check that both sides created the same key material without a
3861                 * context.
3862                 */
3863             || !TEST_mem_eq(ckeymat3, sizeof(ckeymat3), skeymat3,
3864                             sizeof(skeymat3))
3865                /* Different contexts should produce different results */
3866             || !TEST_mem_ne(ckeymat1, sizeof(ckeymat1), ckeymat2,
3867                             sizeof(ckeymat2)))
3868         goto end;
3869
3870     /*
3871      * Check that an empty context and no context produce different results in
3872      * protocols less than TLSv1.3. In TLSv1.3 they should be the same.
3873      */
3874     if ((tst != 3 && !TEST_mem_ne(ckeymat2, sizeof(ckeymat2), ckeymat3,
3875                                   sizeof(ckeymat3)))
3876             || (tst ==3 && !TEST_mem_eq(ckeymat2, sizeof(ckeymat2), ckeymat3,
3877                                         sizeof(ckeymat3))))
3878         goto end;
3879
3880     testresult = 1;
3881
3882  end:
3883     SSL_free(serverssl);
3884     SSL_free(clientssl);
3885     SSL_CTX_free(sctx2);
3886     SSL_CTX_free(sctx);
3887     SSL_CTX_free(cctx);
3888
3889     return testresult;
3890 }
3891
3892 #ifndef OPENSSL_NO_TLS1_3
3893 /*
3894  * Test that SSL_export_keying_material_early() produces expected
3895  * results. There are no test vectors so all we do is test that both
3896  * sides of the communication produce the same results for different
3897  * protocol versions.
3898  */
3899 static int test_export_key_mat_early(int idx)
3900 {
3901     static const char label[] = "test label";
3902     static const unsigned char context[] = "context";
3903     int testresult = 0;
3904     SSL_CTX *cctx = NULL, *sctx = NULL;
3905     SSL *clientssl = NULL, *serverssl = NULL;
3906     SSL_SESSION *sess = NULL;
3907     const unsigned char *emptycontext = NULL;
3908     unsigned char ckeymat1[80], ckeymat2[80];
3909     unsigned char skeymat1[80], skeymat2[80];
3910     unsigned char buf[1];
3911     size_t readbytes, written;
3912
3913     if (!TEST_true(setupearly_data_test(&cctx, &sctx, &clientssl, &serverssl,
3914                                         &sess, idx)))
3915         goto end;
3916
3917     /* Here writing 0 length early data is enough. */
3918     if (!TEST_true(SSL_write_early_data(clientssl, NULL, 0, &written))
3919             || !TEST_int_eq(SSL_read_early_data(serverssl, buf, sizeof(buf),
3920                                                 &readbytes),
3921                             SSL_READ_EARLY_DATA_ERROR)
3922             || !TEST_int_eq(SSL_get_early_data_status(serverssl),
3923                             SSL_EARLY_DATA_ACCEPTED))
3924         goto end;
3925
3926     if (!TEST_int_eq(SSL_export_keying_material_early(
3927                      clientssl, ckeymat1, sizeof(ckeymat1), label,
3928                      sizeof(label) - 1, context, sizeof(context) - 1), 1)
3929             || !TEST_int_eq(SSL_export_keying_material_early(
3930                             clientssl, ckeymat2, sizeof(ckeymat2), label,
3931                             sizeof(label) - 1, emptycontext, 0), 1)
3932             || !TEST_int_eq(SSL_export_keying_material_early(
3933                             serverssl, skeymat1, sizeof(skeymat1), label,
3934                             sizeof(label) - 1, context, sizeof(context) - 1), 1)
3935             || !TEST_int_eq(SSL_export_keying_material_early(
3936                             serverssl, skeymat2, sizeof(skeymat2), label,
3937                             sizeof(label) - 1, emptycontext, 0), 1)
3938                /*
3939                 * Check that both sides created the same key material with the
3940                 * same context.
3941                 */
3942             || !TEST_mem_eq(ckeymat1, sizeof(ckeymat1), skeymat1,
3943                             sizeof(skeymat1))
3944                /*
3945                 * Check that both sides created the same key material with an
3946                 * empty context.
3947                 */
3948             || !TEST_mem_eq(ckeymat2, sizeof(ckeymat2), skeymat2,
3949                             sizeof(skeymat2))
3950                /* Different contexts should produce different results */
3951             || !TEST_mem_ne(ckeymat1, sizeof(ckeymat1), ckeymat2,
3952                             sizeof(ckeymat2)))
3953         goto end;
3954
3955     testresult = 1;
3956
3957  end:
3958     SSL_SESSION_free(sess);
3959     SSL_SESSION_free(clientpsk);
3960     SSL_SESSION_free(serverpsk);
3961     clientpsk = serverpsk = NULL;
3962     SSL_free(serverssl);
3963     SSL_free(clientssl);
3964     SSL_CTX_free(sctx);
3965     SSL_CTX_free(cctx);
3966
3967     return testresult;
3968 }
3969 #endif /* OPENSSL_NO_TLS1_3 */
3970
3971 static int test_ssl_clear(int idx)
3972 {
3973     SSL_CTX *cctx = NULL, *sctx = NULL;
3974     SSL *clientssl = NULL, *serverssl = NULL;
3975     int testresult = 0;
3976
3977 #ifdef OPENSSL_NO_TLS1_2
3978     if (idx == 1)
3979         return 1;
3980 #endif
3981
3982     /* Create an initial connection */
3983     if (!TEST_true(create_ssl_ctx_pair(TLS_server_method(), TLS_client_method(),
3984                                        TLS1_VERSION, TLS_MAX_VERSION,
3985                                        &sctx, &cctx, cert, privkey))
3986             || (idx == 1
3987                 && !TEST_true(SSL_CTX_set_max_proto_version(cctx,
3988                                                             TLS1_2_VERSION)))
3989             || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl,
3990                                           &clientssl, NULL, NULL))
3991             || !TEST_true(create_ssl_connection(serverssl, clientssl,
3992                                                 SSL_ERROR_NONE)))
3993         goto end;
3994
3995     SSL_shutdown(clientssl);
3996     SSL_shutdown(serverssl);
3997     SSL_free(serverssl);
3998     serverssl = NULL;
3999
4000     /* Clear clientssl - we're going to reuse the object */
4001     if (!TEST_true(SSL_clear(clientssl)))
4002         goto end;
4003
4004     if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl,
4005                                              NULL, NULL))
4006             || !TEST_true(create_ssl_connection(serverssl, clientssl,
4007                                                 SSL_ERROR_NONE))
4008             || !TEST_true(SSL_session_reused(clientssl)))
4009         goto end;
4010
4011     SSL_shutdown(clientssl);
4012     SSL_shutdown(serverssl);
4013
4014     testresult = 1;
4015
4016  end:
4017     SSL_free(serverssl);
4018     SSL_free(clientssl);
4019     SSL_CTX_free(sctx);
4020     SSL_CTX_free(cctx);
4021
4022     return testresult;
4023 }
4024
4025 /* Parse CH and retrieve any MFL extension value if present */
4026 static int get_MFL_from_client_hello(BIO *bio, int *mfl_codemfl_code)
4027 {
4028     long len;
4029     unsigned char *data;
4030     PACKET pkt = {0}, pkt2 = {0}, pkt3 = {0};
4031     unsigned int MFL_code = 0, type = 0;
4032
4033     if (!TEST_uint_gt( len = BIO_get_mem_data( bio, (char **) &data ), 0 ) )
4034         goto end;
4035
4036     if (!TEST_true( PACKET_buf_init( &pkt, data, len ) )
4037                /* Skip the record header */
4038             || !PACKET_forward(&pkt, SSL3_RT_HEADER_LENGTH)
4039                /* Skip the handshake message header */
4040             || !TEST_true(PACKET_forward(&pkt, SSL3_HM_HEADER_LENGTH))
4041                /* Skip client version and random */
4042             || !TEST_true(PACKET_forward(&pkt, CLIENT_VERSION_LEN
4043                                                + SSL3_RANDOM_SIZE))
4044                /* Skip session id */
4045             || !TEST_true(PACKET_get_length_prefixed_1(&pkt, &pkt2))
4046                /* Skip ciphers */
4047             || !TEST_true(PACKET_get_length_prefixed_2(&pkt, &pkt2))
4048                /* Skip compression */
4049             || !TEST_true(PACKET_get_length_prefixed_1(&pkt, &pkt2))
4050                /* Extensions len */
4051             || !TEST_true(PACKET_as_length_prefixed_2(&pkt, &pkt2)))
4052         goto end;
4053
4054     /* Loop through all extensions */
4055     while (PACKET_remaining(&pkt2)) {
4056         if (!TEST_true(PACKET_get_net_2(&pkt2, &type))
4057                 || !TEST_true(PACKET_get_length_prefixed_2(&pkt2, &pkt3)))
4058             goto end;
4059
4060         if (type == TLSEXT_TYPE_max_fragment_length) {
4061             if (!TEST_uint_ne(PACKET_remaining(&pkt3), 0)
4062                     || !TEST_true(PACKET_get_1(&pkt3, &MFL_code)))
4063                 goto end;
4064
4065             *mfl_codemfl_code = MFL_code;
4066             return 1;
4067         }
4068     }
4069
4070  end:
4071     return 0;
4072 }
4073
4074 /* Maximum-Fragment-Length TLS extension mode to test */
4075 static const unsigned char max_fragment_len_test[] = {