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