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