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