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