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