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