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