Note that the mac command is preferrable to the MAC command line options.
[openssl.git] / test / handshake_helper.c
1 /*
2  * Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <string.h>
11
12 #include <openssl/bio.h>
13 #include <openssl/x509_vfy.h>
14 #include <openssl/ssl.h>
15 #ifndef OPENSSL_NO_SRP
16 #include <openssl/srp.h>
17 #endif
18
19 #include "../ssl/ssl_locl.h"
20 #include "internal/sockets.h"
21 #include "internal/nelem.h"
22 #include "handshake_helper.h"
23 #include "testutil.h"
24
25 #if !defined(OPENSSL_NO_SCTP) && !defined(OPENSSL_NO_SOCK)
26 #include <netinet/sctp.h>
27 #endif
28
29 HANDSHAKE_RESULT *HANDSHAKE_RESULT_new(void)
30 {
31     HANDSHAKE_RESULT *ret;
32
33     TEST_ptr(ret = OPENSSL_zalloc(sizeof(*ret)));
34     return ret;
35 }
36
37 void HANDSHAKE_RESULT_free(HANDSHAKE_RESULT *result)
38 {
39     if (result == NULL)
40         return;
41     OPENSSL_free(result->client_npn_negotiated);
42     OPENSSL_free(result->server_npn_negotiated);
43     OPENSSL_free(result->client_alpn_negotiated);
44     OPENSSL_free(result->server_alpn_negotiated);
45     OPENSSL_free(result->result_session_ticket_app_data);
46     sk_X509_NAME_pop_free(result->server_ca_names, X509_NAME_free);
47     sk_X509_NAME_pop_free(result->client_ca_names, X509_NAME_free);
48     OPENSSL_free(result->cipher);
49     OPENSSL_free(result);
50 }
51
52 /*
53  * Since there appears to be no way to extract the sent/received alert
54  * from the SSL object directly, we use the info callback and stash
55  * the result in ex_data.
56  */
57 typedef struct handshake_ex_data_st {
58     int alert_sent;
59     int num_fatal_alerts_sent;
60     int alert_received;
61     int session_ticket_do_not_call;
62     ssl_servername_t servername;
63 } HANDSHAKE_EX_DATA;
64
65 typedef struct ctx_data_st {
66     unsigned char *npn_protocols;
67     size_t npn_protocols_len;
68     unsigned char *alpn_protocols;
69     size_t alpn_protocols_len;
70     char *srp_user;
71     char *srp_password;
72     char *session_ticket_app_data;
73 } CTX_DATA;
74
75 /* |ctx_data| itself is stack-allocated. */
76 static void ctx_data_free_data(CTX_DATA *ctx_data)
77 {
78     OPENSSL_free(ctx_data->npn_protocols);
79     ctx_data->npn_protocols = NULL;
80     OPENSSL_free(ctx_data->alpn_protocols);
81     ctx_data->alpn_protocols = NULL;
82     OPENSSL_free(ctx_data->srp_user);
83     ctx_data->srp_user = NULL;
84     OPENSSL_free(ctx_data->srp_password);
85     ctx_data->srp_password = NULL;
86     OPENSSL_free(ctx_data->session_ticket_app_data);
87     ctx_data->session_ticket_app_data = NULL;
88 }
89
90 static int ex_data_idx;
91
92 static void info_cb(const SSL *s, int where, int ret)
93 {
94     if (where & SSL_CB_ALERT) {
95         HANDSHAKE_EX_DATA *ex_data =
96             (HANDSHAKE_EX_DATA*)(SSL_get_ex_data(s, ex_data_idx));
97         if (where & SSL_CB_WRITE) {
98             ex_data->alert_sent = ret;
99             if (strcmp(SSL_alert_type_string(ret), "F") == 0
100                 || strcmp(SSL_alert_desc_string(ret), "CN") == 0)
101                 ex_data->num_fatal_alerts_sent++;
102         } else {
103             ex_data->alert_received = ret;
104         }
105     }
106 }
107
108 /* Select the appropriate server CTX.
109  * Returns SSL_TLSEXT_ERR_OK if a match was found.
110  * If |ignore| is 1, returns SSL_TLSEXT_ERR_NOACK on mismatch.
111  * Otherwise, returns SSL_TLSEXT_ERR_ALERT_FATAL on mismatch.
112  * An empty SNI extension also returns SSL_TSLEXT_ERR_NOACK.
113  */
114 static int select_server_ctx(SSL *s, void *arg, int ignore)
115 {
116     const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
117     HANDSHAKE_EX_DATA *ex_data =
118         (HANDSHAKE_EX_DATA*)(SSL_get_ex_data(s, ex_data_idx));
119
120     if (servername == NULL) {
121         ex_data->servername = SSL_TEST_SERVERNAME_SERVER1;
122         return SSL_TLSEXT_ERR_NOACK;
123     }
124
125     if (strcmp(servername, "server2") == 0) {
126         SSL_CTX *new_ctx = (SSL_CTX*)arg;
127         SSL_set_SSL_CTX(s, new_ctx);
128         /*
129          * Copy over all the SSL_CTX options - reasonable behavior
130          * allows testing of cases where the options between two
131          * contexts differ/conflict
132          */
133         SSL_clear_options(s, 0xFFFFFFFFL);
134         SSL_set_options(s, SSL_CTX_get_options(new_ctx));
135
136         ex_data->servername = SSL_TEST_SERVERNAME_SERVER2;
137         return SSL_TLSEXT_ERR_OK;
138     } else if (strcmp(servername, "server1") == 0) {
139         ex_data->servername = SSL_TEST_SERVERNAME_SERVER1;
140         return SSL_TLSEXT_ERR_OK;
141     } else if (ignore) {
142         ex_data->servername = SSL_TEST_SERVERNAME_SERVER1;
143         return SSL_TLSEXT_ERR_NOACK;
144     } else {
145         /* Don't set an explicit alert, to test library defaults. */
146         return SSL_TLSEXT_ERR_ALERT_FATAL;
147     }
148 }
149
150 static int client_hello_select_server_ctx(SSL *s, void *arg, int ignore)
151 {
152     const char *servername;
153     const unsigned char *p;
154     size_t len, remaining;
155     HANDSHAKE_EX_DATA *ex_data =
156         (HANDSHAKE_EX_DATA*)(SSL_get_ex_data(s, ex_data_idx));
157
158     /*
159      * The server_name extension was given too much extensibility when it
160      * was written, so parsing the normal case is a bit complex.
161      */
162     if (!SSL_client_hello_get0_ext(s, TLSEXT_TYPE_server_name, &p,
163                                    &remaining) ||
164         remaining <= 2)
165         return 0;
166     /* Extract the length of the supplied list of names. */
167     len = (*(p++) << 8);
168     len += *(p++);
169     if (len + 2 != remaining)
170         return 0;
171     remaining = len;
172     /*
173      * The list in practice only has a single element, so we only consider
174      * the first one.
175      */
176     if (remaining == 0 || *p++ != TLSEXT_NAMETYPE_host_name)
177         return 0;
178     remaining--;
179     /* Now we can finally pull out the byte array with the actual hostname. */
180     if (remaining <= 2)
181         return 0;
182     len = (*(p++) << 8);
183     len += *(p++);
184     if (len + 2 > remaining)
185         return 0;
186     remaining = len;
187     servername = (const char *)p;
188
189     if (len == strlen("server2") && strncmp(servername, "server2", len) == 0) {
190         SSL_CTX *new_ctx = arg;
191         SSL_set_SSL_CTX(s, new_ctx);
192         /*
193          * Copy over all the SSL_CTX options - reasonable behavior
194          * allows testing of cases where the options between two
195          * contexts differ/conflict
196          */
197         SSL_clear_options(s, 0xFFFFFFFFL);
198         SSL_set_options(s, SSL_CTX_get_options(new_ctx));
199
200         ex_data->servername = SSL_TEST_SERVERNAME_SERVER2;
201         return 1;
202     } else if (len == strlen("server1") &&
203                strncmp(servername, "server1", len) == 0) {
204         ex_data->servername = SSL_TEST_SERVERNAME_SERVER1;
205         return 1;
206     } else if (ignore) {
207         ex_data->servername = SSL_TEST_SERVERNAME_SERVER1;
208         return 1;
209     }
210     return 0;
211 }
212 /*
213  * (RFC 6066):
214  *  If the server understood the ClientHello extension but
215  *  does not recognize the server name, the server SHOULD take one of two
216  *  actions: either abort the handshake by sending a fatal-level
217  *  unrecognized_name(112) alert or continue the handshake.
218  *
219  * This behaviour is up to the application to configure; we test both
220  * configurations to ensure the state machine propagates the result
221  * correctly.
222  */
223 static int servername_ignore_cb(SSL *s, int *ad, void *arg)
224 {
225     return select_server_ctx(s, arg, 1);
226 }
227
228 static int servername_reject_cb(SSL *s, int *ad, void *arg)
229 {
230     return select_server_ctx(s, arg, 0);
231 }
232
233 static int client_hello_ignore_cb(SSL *s, int *al, void *arg)
234 {
235     if (!client_hello_select_server_ctx(s, arg, 1)) {
236         *al = SSL_AD_UNRECOGNIZED_NAME;
237         return SSL_CLIENT_HELLO_ERROR;
238     }
239     return SSL_CLIENT_HELLO_SUCCESS;
240 }
241
242 static int client_hello_reject_cb(SSL *s, int *al, void *arg)
243 {
244     if (!client_hello_select_server_ctx(s, arg, 0)) {
245         *al = SSL_AD_UNRECOGNIZED_NAME;
246         return SSL_CLIENT_HELLO_ERROR;
247     }
248     return SSL_CLIENT_HELLO_SUCCESS;
249 }
250
251 static int client_hello_nov12_cb(SSL *s, int *al, void *arg)
252 {
253     int ret;
254     unsigned int v;
255     const unsigned char *p;
256
257     v = SSL_client_hello_get0_legacy_version(s);
258     if (v > TLS1_2_VERSION || v < SSL3_VERSION) {
259         *al = SSL_AD_PROTOCOL_VERSION;
260         return SSL_CLIENT_HELLO_ERROR;
261     }
262     (void)SSL_client_hello_get0_session_id(s, &p);
263     if (p == NULL ||
264         SSL_client_hello_get0_random(s, &p) == 0 ||
265         SSL_client_hello_get0_ciphers(s, &p) == 0 ||
266         SSL_client_hello_get0_compression_methods(s, &p) == 0) {
267         *al = SSL_AD_INTERNAL_ERROR;
268         return SSL_CLIENT_HELLO_ERROR;
269     }
270     ret = client_hello_select_server_ctx(s, arg, 0);
271     SSL_set_max_proto_version(s, TLS1_1_VERSION);
272     if (!ret) {
273         *al = SSL_AD_UNRECOGNIZED_NAME;
274         return SSL_CLIENT_HELLO_ERROR;
275     }
276     return SSL_CLIENT_HELLO_SUCCESS;
277 }
278
279 static unsigned char dummy_ocsp_resp_good_val = 0xff;
280 static unsigned char dummy_ocsp_resp_bad_val = 0xfe;
281
282 static int server_ocsp_cb(SSL *s, void *arg)
283 {
284     unsigned char *resp;
285
286     resp = OPENSSL_malloc(1);
287     if (resp == NULL)
288         return SSL_TLSEXT_ERR_ALERT_FATAL;
289     /*
290      * For the purposes of testing we just send back a dummy OCSP response
291      */
292     *resp = *(unsigned char *)arg;
293     if (!SSL_set_tlsext_status_ocsp_resp(s, resp, 1))
294         return SSL_TLSEXT_ERR_ALERT_FATAL;
295
296     return SSL_TLSEXT_ERR_OK;
297 }
298
299 static int client_ocsp_cb(SSL *s, void *arg)
300 {
301     const unsigned char *resp;
302     int len;
303
304     len = SSL_get_tlsext_status_ocsp_resp(s, &resp);
305     if (len != 1 || *resp != dummy_ocsp_resp_good_val)
306         return 0;
307
308     return 1;
309 }
310
311 static int verify_reject_cb(X509_STORE_CTX *ctx, void *arg) {
312     X509_STORE_CTX_set_error(ctx, X509_V_ERR_APPLICATION_VERIFICATION);
313     return 0;
314 }
315
316 static int verify_accept_cb(X509_STORE_CTX *ctx, void *arg) {
317     return 1;
318 }
319
320 static int broken_session_ticket_cb(SSL *s, unsigned char *key_name, unsigned char *iv,
321                                     EVP_CIPHER_CTX *ctx, HMAC_CTX *hctx, int enc)
322 {
323     return 0;
324 }
325
326 static int do_not_call_session_ticket_cb(SSL *s, unsigned char *key_name,
327                                          unsigned char *iv,
328                                          EVP_CIPHER_CTX *ctx,
329                                          HMAC_CTX *hctx, int enc)
330 {
331     HANDSHAKE_EX_DATA *ex_data =
332         (HANDSHAKE_EX_DATA*)(SSL_get_ex_data(s, ex_data_idx));
333     ex_data->session_ticket_do_not_call = 1;
334     return 0;
335 }
336
337 /* Parse the comma-separated list into TLS format. */
338 static int parse_protos(const char *protos, unsigned char **out, size_t *outlen)
339 {
340     size_t len, i, prefix;
341
342     len = strlen(protos);
343
344     /* Should never have reuse. */
345     if (!TEST_ptr_null(*out)
346             /* Test values are small, so we omit length limit checks. */
347             || !TEST_ptr(*out = OPENSSL_malloc(len + 1)))
348         return 0;
349     *outlen = len + 1;
350
351     /*
352      * foo => '3', 'f', 'o', 'o'
353      * foo,bar => '3', 'f', 'o', 'o', '3', 'b', 'a', 'r'
354      */
355     memcpy(*out + 1, protos, len);
356
357     prefix = 0;
358     i = prefix + 1;
359     while (i <= len) {
360         if ((*out)[i] == ',') {
361             if (!TEST_int_gt(i - 1, prefix))
362                 goto err;
363             (*out)[prefix] = (unsigned char)(i - 1 - prefix);
364             prefix = i;
365         }
366         i++;
367     }
368     if (!TEST_int_gt(len, prefix))
369         goto err;
370     (*out)[prefix] = (unsigned char)(len - prefix);
371     return 1;
372
373 err:
374     OPENSSL_free(*out);
375     *out = NULL;
376     return 0;
377 }
378
379 #ifndef OPENSSL_NO_NEXTPROTONEG
380 /*
381  * The client SHOULD select the first protocol advertised by the server that it
382  * also supports.  In the event that the client doesn't support any of server's
383  * protocols, or the server doesn't advertise any, it SHOULD select the first
384  * protocol that it supports.
385  */
386 static int client_npn_cb(SSL *s, unsigned char **out, unsigned char *outlen,
387                          const unsigned char *in, unsigned int inlen,
388                          void *arg)
389 {
390     CTX_DATA *ctx_data = (CTX_DATA*)(arg);
391     int ret;
392
393     ret = SSL_select_next_proto(out, outlen, in, inlen,
394                                 ctx_data->npn_protocols,
395                                 ctx_data->npn_protocols_len);
396     /* Accept both OPENSSL_NPN_NEGOTIATED and OPENSSL_NPN_NO_OVERLAP. */
397     return TEST_true(ret == OPENSSL_NPN_NEGOTIATED || ret == OPENSSL_NPN_NO_OVERLAP)
398         ? SSL_TLSEXT_ERR_OK : SSL_TLSEXT_ERR_ALERT_FATAL;
399 }
400
401 static int server_npn_cb(SSL *s, const unsigned char **data,
402                          unsigned int *len, void *arg)
403 {
404     CTX_DATA *ctx_data = (CTX_DATA*)(arg);
405     *data = ctx_data->npn_protocols;
406     *len = ctx_data->npn_protocols_len;
407     return SSL_TLSEXT_ERR_OK;
408 }
409 #endif
410
411 /*
412  * The server SHOULD select the most highly preferred protocol that it supports
413  * and that is also advertised by the client.  In the event that the server
414  * supports no protocols that the client advertises, then the server SHALL
415  * respond with a fatal "no_application_protocol" alert.
416  */
417 static int server_alpn_cb(SSL *s, const unsigned char **out,
418                           unsigned char *outlen, const unsigned char *in,
419                           unsigned int inlen, void *arg)
420 {
421     CTX_DATA *ctx_data = (CTX_DATA*)(arg);
422     int ret;
423
424     /* SSL_select_next_proto isn't const-correct... */
425     unsigned char *tmp_out;
426
427     /*
428      * The result points either to |in| or to |ctx_data->alpn_protocols|.
429      * The callback is allowed to point to |in| or to a long-lived buffer,
430      * so we can return directly without storing a copy.
431      */
432     ret = SSL_select_next_proto(&tmp_out, outlen,
433                                 ctx_data->alpn_protocols,
434                                 ctx_data->alpn_protocols_len, in, inlen);
435
436     *out = tmp_out;
437     /* Unlike NPN, we don't tolerate a mismatch. */
438     return ret == OPENSSL_NPN_NEGOTIATED ? SSL_TLSEXT_ERR_OK
439         : SSL_TLSEXT_ERR_ALERT_FATAL;
440 }
441
442 #ifndef OPENSSL_NO_SRP
443 static char *client_srp_cb(SSL *s, void *arg)
444 {
445     CTX_DATA *ctx_data = (CTX_DATA*)(arg);
446     return OPENSSL_strdup(ctx_data->srp_password);
447 }
448
449 static int server_srp_cb(SSL *s, int *ad, void *arg)
450 {
451     CTX_DATA *ctx_data = (CTX_DATA*)(arg);
452     if (strcmp(ctx_data->srp_user, SSL_get_srp_username(s)) != 0)
453         return SSL3_AL_FATAL;
454     if (SSL_set_srp_server_param_pw(s, ctx_data->srp_user,
455                                     ctx_data->srp_password,
456                                     "2048" /* known group */) < 0) {
457         *ad = SSL_AD_INTERNAL_ERROR;
458         return SSL3_AL_FATAL;
459     }
460     return SSL_ERROR_NONE;
461 }
462 #endif  /* !OPENSSL_NO_SRP */
463
464 static int generate_session_ticket_cb(SSL *s, void *arg)
465 {
466     CTX_DATA *server_ctx_data = arg;
467     SSL_SESSION *ss = SSL_get_session(s);
468     char *app_data = server_ctx_data->session_ticket_app_data;
469
470     if (ss == NULL || app_data == NULL)
471         return 0;
472
473     return SSL_SESSION_set1_ticket_appdata(ss, app_data, strlen(app_data));
474 }
475
476 static int decrypt_session_ticket_cb(SSL *s, SSL_SESSION *ss,
477                                      const unsigned char *keyname,
478                                      size_t keyname_len,
479                                      SSL_TICKET_STATUS status,
480                                      void *arg)
481 {
482     switch (status) {
483     case SSL_TICKET_EMPTY:
484     case SSL_TICKET_NO_DECRYPT:
485         return SSL_TICKET_RETURN_IGNORE_RENEW;
486     case SSL_TICKET_SUCCESS:
487         return SSL_TICKET_RETURN_USE;
488     case SSL_TICKET_SUCCESS_RENEW:
489         return SSL_TICKET_RETURN_USE_RENEW;
490     default:
491         break;
492     }
493     return SSL_TICKET_RETURN_ABORT;
494 }
495
496 /*
497  * Configure callbacks and other properties that can't be set directly
498  * in the server/client CONF.
499  */
500 static int configure_handshake_ctx(SSL_CTX *server_ctx, SSL_CTX *server2_ctx,
501                                    SSL_CTX *client_ctx,
502                                    const SSL_TEST_CTX *test,
503                                    const SSL_TEST_EXTRA_CONF *extra,
504                                    CTX_DATA *server_ctx_data,
505                                    CTX_DATA *server2_ctx_data,
506                                    CTX_DATA *client_ctx_data)
507 {
508     unsigned char *ticket_keys;
509     size_t ticket_key_len;
510
511     if (!TEST_int_eq(SSL_CTX_set_max_send_fragment(server_ctx,
512                                                    test->max_fragment_size), 1))
513         goto err;
514     if (server2_ctx != NULL) {
515         if (!TEST_int_eq(SSL_CTX_set_max_send_fragment(server2_ctx,
516                                                        test->max_fragment_size),
517                          1))
518             goto err;
519     }
520     if (!TEST_int_eq(SSL_CTX_set_max_send_fragment(client_ctx,
521                                                    test->max_fragment_size), 1))
522         goto err;
523
524     switch (extra->client.verify_callback) {
525     case SSL_TEST_VERIFY_ACCEPT_ALL:
526         SSL_CTX_set_cert_verify_callback(client_ctx, &verify_accept_cb, NULL);
527         break;
528     case SSL_TEST_VERIFY_REJECT_ALL:
529         SSL_CTX_set_cert_verify_callback(client_ctx, &verify_reject_cb, NULL);
530         break;
531     case SSL_TEST_VERIFY_NONE:
532         break;
533     }
534
535     switch (extra->client.max_fragment_len_mode) {
536     case TLSEXT_max_fragment_length_512:
537     case TLSEXT_max_fragment_length_1024:
538     case TLSEXT_max_fragment_length_2048:
539     case TLSEXT_max_fragment_length_4096:
540     case TLSEXT_max_fragment_length_DISABLED:
541         SSL_CTX_set_tlsext_max_fragment_length(
542               client_ctx, extra->client.max_fragment_len_mode);
543         break;
544     }
545
546     /*
547      * Link the two contexts for SNI purposes.
548      * Also do ClientHello callbacks here, as setting both ClientHello and SNI
549      * is bad.
550      */
551     switch (extra->server.servername_callback) {
552     case SSL_TEST_SERVERNAME_IGNORE_MISMATCH:
553         SSL_CTX_set_tlsext_servername_callback(server_ctx, servername_ignore_cb);
554         SSL_CTX_set_tlsext_servername_arg(server_ctx, server2_ctx);
555         break;
556     case SSL_TEST_SERVERNAME_REJECT_MISMATCH:
557         SSL_CTX_set_tlsext_servername_callback(server_ctx, servername_reject_cb);
558         SSL_CTX_set_tlsext_servername_arg(server_ctx, server2_ctx);
559         break;
560     case SSL_TEST_SERVERNAME_CB_NONE:
561         break;
562     case SSL_TEST_SERVERNAME_CLIENT_HELLO_IGNORE_MISMATCH:
563         SSL_CTX_set_client_hello_cb(server_ctx, client_hello_ignore_cb, server2_ctx);
564         break;
565     case SSL_TEST_SERVERNAME_CLIENT_HELLO_REJECT_MISMATCH:
566         SSL_CTX_set_client_hello_cb(server_ctx, client_hello_reject_cb, server2_ctx);
567         break;
568     case SSL_TEST_SERVERNAME_CLIENT_HELLO_NO_V12:
569         SSL_CTX_set_client_hello_cb(server_ctx, client_hello_nov12_cb, server2_ctx);
570     }
571
572     if (extra->server.cert_status != SSL_TEST_CERT_STATUS_NONE) {
573         SSL_CTX_set_tlsext_status_type(client_ctx, TLSEXT_STATUSTYPE_ocsp);
574         SSL_CTX_set_tlsext_status_cb(client_ctx, client_ocsp_cb);
575         SSL_CTX_set_tlsext_status_arg(client_ctx, NULL);
576         SSL_CTX_set_tlsext_status_cb(server_ctx, server_ocsp_cb);
577         SSL_CTX_set_tlsext_status_arg(server_ctx,
578             ((extra->server.cert_status == SSL_TEST_CERT_STATUS_GOOD_RESPONSE)
579             ? &dummy_ocsp_resp_good_val : &dummy_ocsp_resp_bad_val));
580     }
581
582     /*
583      * The initial_ctx/session_ctx always handles the encrypt/decrypt of the
584      * session ticket. This ticket_key callback is assigned to the second
585      * session (assigned via SNI), and should never be invoked
586      */
587     if (server2_ctx != NULL)
588         SSL_CTX_set_tlsext_ticket_key_cb(server2_ctx,
589                                          do_not_call_session_ticket_cb);
590
591     if (extra->server.broken_session_ticket) {
592         SSL_CTX_set_tlsext_ticket_key_cb(server_ctx, broken_session_ticket_cb);
593     }
594 #ifndef OPENSSL_NO_NEXTPROTONEG
595     if (extra->server.npn_protocols != NULL) {
596         if (!TEST_true(parse_protos(extra->server.npn_protocols,
597                                     &server_ctx_data->npn_protocols,
598                                     &server_ctx_data->npn_protocols_len)))
599             goto err;
600         SSL_CTX_set_npn_advertised_cb(server_ctx, server_npn_cb,
601                                       server_ctx_data);
602     }
603     if (extra->server2.npn_protocols != NULL) {
604         if (!TEST_true(parse_protos(extra->server2.npn_protocols,
605                                     &server2_ctx_data->npn_protocols,
606                                     &server2_ctx_data->npn_protocols_len))
607                 || !TEST_ptr(server2_ctx))
608             goto err;
609         SSL_CTX_set_npn_advertised_cb(server2_ctx, server_npn_cb,
610                                       server2_ctx_data);
611     }
612     if (extra->client.npn_protocols != NULL) {
613         if (!TEST_true(parse_protos(extra->client.npn_protocols,
614                                     &client_ctx_data->npn_protocols,
615                                     &client_ctx_data->npn_protocols_len)))
616             goto err;
617         SSL_CTX_set_next_proto_select_cb(client_ctx, client_npn_cb,
618                                          client_ctx_data);
619     }
620 #endif
621     if (extra->server.alpn_protocols != NULL) {
622         if (!TEST_true(parse_protos(extra->server.alpn_protocols,
623                                     &server_ctx_data->alpn_protocols,
624                                     &server_ctx_data->alpn_protocols_len)))
625             goto err;
626         SSL_CTX_set_alpn_select_cb(server_ctx, server_alpn_cb, server_ctx_data);
627     }
628     if (extra->server2.alpn_protocols != NULL) {
629         if (!TEST_ptr(server2_ctx)
630                 || !TEST_true(parse_protos(extra->server2.alpn_protocols,
631                                            &server2_ctx_data->alpn_protocols,
632                                            &server2_ctx_data->alpn_protocols_len
633             )))
634             goto err;
635         SSL_CTX_set_alpn_select_cb(server2_ctx, server_alpn_cb,
636                                    server2_ctx_data);
637     }
638     if (extra->client.alpn_protocols != NULL) {
639         unsigned char *alpn_protos = NULL;
640         size_t alpn_protos_len;
641         if (!TEST_true(parse_protos(extra->client.alpn_protocols,
642                                     &alpn_protos, &alpn_protos_len))
643                 /* Reversed return value convention... */
644                 || !TEST_int_eq(SSL_CTX_set_alpn_protos(client_ctx, alpn_protos,
645                                                         alpn_protos_len), 0))
646             goto err;
647         OPENSSL_free(alpn_protos);
648     }
649
650     if (extra->server.session_ticket_app_data != NULL) {
651         server_ctx_data->session_ticket_app_data =
652             OPENSSL_strdup(extra->server.session_ticket_app_data);
653         SSL_CTX_set_session_ticket_cb(server_ctx, generate_session_ticket_cb,
654                                       decrypt_session_ticket_cb, server_ctx_data);
655     }
656     if (extra->server2.session_ticket_app_data != NULL) {
657         if (!TEST_ptr(server2_ctx))
658             goto err;
659         server2_ctx_data->session_ticket_app_data =
660             OPENSSL_strdup(extra->server2.session_ticket_app_data);
661         SSL_CTX_set_session_ticket_cb(server2_ctx, NULL,
662                                       decrypt_session_ticket_cb, server2_ctx_data);
663     }
664
665     /*
666      * Use fixed session ticket keys so that we can decrypt a ticket created with
667      * one CTX in another CTX. Don't address server2 for the moment.
668      */
669     ticket_key_len = SSL_CTX_set_tlsext_ticket_keys(server_ctx, NULL, 0);
670     if (!TEST_ptr(ticket_keys = OPENSSL_zalloc(ticket_key_len))
671             || !TEST_int_eq(SSL_CTX_set_tlsext_ticket_keys(server_ctx,
672                                                            ticket_keys,
673                                                            ticket_key_len), 1)) {
674         OPENSSL_free(ticket_keys);
675         goto err;
676     }
677     OPENSSL_free(ticket_keys);
678
679     /* The default log list includes EC keys, so CT can't work without EC. */
680 #if !defined(OPENSSL_NO_CT) && !defined(OPENSSL_NO_EC)
681     if (!TEST_true(SSL_CTX_set_default_ctlog_list_file(client_ctx)))
682         goto err;
683     switch (extra->client.ct_validation) {
684     case SSL_TEST_CT_VALIDATION_PERMISSIVE:
685         if (!TEST_true(SSL_CTX_enable_ct(client_ctx,
686                                          SSL_CT_VALIDATION_PERMISSIVE)))
687             goto err;
688         break;
689     case SSL_TEST_CT_VALIDATION_STRICT:
690         if (!TEST_true(SSL_CTX_enable_ct(client_ctx, SSL_CT_VALIDATION_STRICT)))
691             goto err;
692         break;
693     case SSL_TEST_CT_VALIDATION_NONE:
694         break;
695     }
696 #endif
697 #ifndef OPENSSL_NO_SRP
698     if (extra->server.srp_user != NULL) {
699         SSL_CTX_set_srp_username_callback(server_ctx, server_srp_cb);
700         server_ctx_data->srp_user = OPENSSL_strdup(extra->server.srp_user);
701         server_ctx_data->srp_password = OPENSSL_strdup(extra->server.srp_password);
702         SSL_CTX_set_srp_cb_arg(server_ctx, server_ctx_data);
703     }
704     if (extra->server2.srp_user != NULL) {
705         if (!TEST_ptr(server2_ctx))
706             goto err;
707         SSL_CTX_set_srp_username_callback(server2_ctx, server_srp_cb);
708         server2_ctx_data->srp_user = OPENSSL_strdup(extra->server2.srp_user);
709         server2_ctx_data->srp_password = OPENSSL_strdup(extra->server2.srp_password);
710         SSL_CTX_set_srp_cb_arg(server2_ctx, server2_ctx_data);
711     }
712     if (extra->client.srp_user != NULL) {
713         if (!TEST_true(SSL_CTX_set_srp_username(client_ctx,
714                                                 extra->client.srp_user)))
715             goto err;
716         SSL_CTX_set_srp_client_pwd_callback(client_ctx, client_srp_cb);
717         client_ctx_data->srp_password = OPENSSL_strdup(extra->client.srp_password);
718         SSL_CTX_set_srp_cb_arg(client_ctx, client_ctx_data);
719     }
720 #endif  /* !OPENSSL_NO_SRP */
721     return 1;
722 err:
723     return 0;
724 }
725
726 /* Configure per-SSL callbacks and other properties. */
727 static void configure_handshake_ssl(SSL *server, SSL *client,
728                                     const SSL_TEST_EXTRA_CONF *extra)
729 {
730     if (extra->client.servername != SSL_TEST_SERVERNAME_NONE)
731         SSL_set_tlsext_host_name(client,
732                                  ssl_servername_name(extra->client.servername));
733     if (extra->client.enable_pha)
734         SSL_set_post_handshake_auth(client, 1);
735 }
736
737 /* The status for each connection phase. */
738 typedef enum {
739     PEER_SUCCESS,
740     PEER_RETRY,
741     PEER_ERROR,
742     PEER_WAITING,
743     PEER_TEST_FAILURE
744 } peer_status_t;
745
746 /* An SSL object and associated read-write buffers. */
747 typedef struct peer_st {
748     SSL *ssl;
749     /* Buffer lengths are int to match the SSL read/write API. */
750     unsigned char *write_buf;
751     int write_buf_len;
752     unsigned char *read_buf;
753     int read_buf_len;
754     int bytes_to_write;
755     int bytes_to_read;
756     peer_status_t status;
757 } PEER;
758
759 static int create_peer(PEER *peer, SSL_CTX *ctx)
760 {
761     static const int peer_buffer_size = 64 * 1024;
762     SSL *ssl = NULL;
763     unsigned char *read_buf = NULL, *write_buf = NULL;
764
765     if (!TEST_ptr(ssl = SSL_new(ctx))
766             || !TEST_ptr(write_buf = OPENSSL_zalloc(peer_buffer_size))
767             || !TEST_ptr(read_buf = OPENSSL_zalloc(peer_buffer_size)))
768         goto err;
769
770     peer->ssl = ssl;
771     peer->write_buf = write_buf;
772     peer->read_buf = read_buf;
773     peer->write_buf_len = peer->read_buf_len = peer_buffer_size;
774     return 1;
775 err:
776     SSL_free(ssl);
777     OPENSSL_free(write_buf);
778     OPENSSL_free(read_buf);
779     return 0;
780 }
781
782 static void peer_free_data(PEER *peer)
783 {
784     SSL_free(peer->ssl);
785     OPENSSL_free(peer->write_buf);
786     OPENSSL_free(peer->read_buf);
787 }
788
789 /*
790  * Note that we could do the handshake transparently under an SSL_write,
791  * but separating the steps is more helpful for debugging test failures.
792  */
793 static void do_handshake_step(PEER *peer)
794 {
795     if (!TEST_int_eq(peer->status, PEER_RETRY)) {
796         peer->status = PEER_TEST_FAILURE;
797     } else {
798         int ret = SSL_do_handshake(peer->ssl);
799
800         if (ret == 1) {
801             peer->status = PEER_SUCCESS;
802         } else if (ret == 0) {
803             peer->status = PEER_ERROR;
804         } else {
805             int error = SSL_get_error(peer->ssl, ret);
806             /* Memory bios should never block with SSL_ERROR_WANT_WRITE. */
807             if (error != SSL_ERROR_WANT_READ)
808                 peer->status = PEER_ERROR;
809         }
810     }
811 }
812
813 /*-
814  * Send/receive some application data. The read-write sequence is
815  * Peer A: (R) W - first read will yield no data
816  * Peer B:  R  W
817  * ...
818  * Peer A:  R  W
819  * Peer B:  R  W
820  * Peer A:  R
821  */
822 static void do_app_data_step(PEER *peer)
823 {
824     int ret = 1, write_bytes;
825
826     if (!TEST_int_eq(peer->status, PEER_RETRY)) {
827         peer->status = PEER_TEST_FAILURE;
828         return;
829     }
830
831     /* We read everything available... */
832     while (ret > 0 && peer->bytes_to_read) {
833         ret = SSL_read(peer->ssl, peer->read_buf, peer->read_buf_len);
834         if (ret > 0) {
835             if (!TEST_int_le(ret, peer->bytes_to_read)) {
836                 peer->status = PEER_TEST_FAILURE;
837                 return;
838             }
839             peer->bytes_to_read -= ret;
840         } else if (ret == 0) {
841             peer->status = PEER_ERROR;
842             return;
843         } else {
844             int error = SSL_get_error(peer->ssl, ret);
845             if (error != SSL_ERROR_WANT_READ) {
846                 peer->status = PEER_ERROR;
847                 return;
848             } /* Else continue with write. */
849         }
850     }
851
852     /* ... but we only write one write-buffer-full of data. */
853     write_bytes = peer->bytes_to_write < peer->write_buf_len ? peer->bytes_to_write :
854         peer->write_buf_len;
855     if (write_bytes) {
856         ret = SSL_write(peer->ssl, peer->write_buf, write_bytes);
857         if (ret > 0) {
858             /* SSL_write will only succeed with a complete write. */
859             if (!TEST_int_eq(ret, write_bytes)) {
860                 peer->status = PEER_TEST_FAILURE;
861                 return;
862             }
863             peer->bytes_to_write -= ret;
864         } else {
865             /*
866              * We should perhaps check for SSL_ERROR_WANT_READ/WRITE here
867              * but this doesn't yet occur with current app data sizes.
868              */
869             peer->status = PEER_ERROR;
870             return;
871         }
872     }
873
874     /*
875      * We could simply finish when there was nothing to read, and we have
876      * nothing left to write. But keeping track of the expected number of bytes
877      * to read gives us somewhat better guarantees that all data sent is in fact
878      * received.
879      */
880     if (!peer->bytes_to_write && !peer->bytes_to_read) {
881         peer->status = PEER_SUCCESS;
882     }
883 }
884
885 static void do_reneg_setup_step(const SSL_TEST_CTX *test_ctx, PEER *peer)
886 {
887     int ret;
888     char buf;
889
890     if (peer->status == PEER_SUCCESS) {
891         /*
892          * We are a client that succeeded this step previously, but the server
893          * wanted to retry. Probably there is a no_renegotiation warning alert
894          * waiting for us. Attempt to continue the handshake.
895          */
896         peer->status = PEER_RETRY;
897         do_handshake_step(peer);
898         return;
899     }
900
901     if (!TEST_int_eq(peer->status, PEER_RETRY)
902             || !TEST_true(test_ctx->handshake_mode
903                               == SSL_TEST_HANDSHAKE_RENEG_SERVER
904                           || test_ctx->handshake_mode
905                               == SSL_TEST_HANDSHAKE_RENEG_CLIENT
906                           || test_ctx->handshake_mode
907                               == SSL_TEST_HANDSHAKE_KEY_UPDATE_SERVER
908                           || test_ctx->handshake_mode
909                               == SSL_TEST_HANDSHAKE_KEY_UPDATE_CLIENT
910                           || test_ctx->handshake_mode
911                               == SSL_TEST_HANDSHAKE_POST_HANDSHAKE_AUTH)) {
912         peer->status = PEER_TEST_FAILURE;
913         return;
914     }
915
916     /* Reset the count of the amount of app data we need to read/write */
917     peer->bytes_to_write = peer->bytes_to_read = test_ctx->app_data_size;
918
919     /* Check if we are the peer that is going to initiate */
920     if ((test_ctx->handshake_mode == SSL_TEST_HANDSHAKE_RENEG_SERVER
921                 && SSL_is_server(peer->ssl))
922             || (test_ctx->handshake_mode == SSL_TEST_HANDSHAKE_RENEG_CLIENT
923                 && !SSL_is_server(peer->ssl))) {
924         /*
925          * If we already asked for a renegotiation then fall through to the
926          * SSL_read() below.
927          */
928         if (!SSL_renegotiate_pending(peer->ssl)) {
929             /*
930              * If we are the client we will always attempt to resume the
931              * session. The server may or may not resume dependent on the
932              * setting of SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
933              */
934             if (SSL_is_server(peer->ssl)) {
935                 ret = SSL_renegotiate(peer->ssl);
936             } else {
937                 if (test_ctx->extra.client.reneg_ciphers != NULL) {
938                     if (!SSL_set_cipher_list(peer->ssl,
939                                 test_ctx->extra.client.reneg_ciphers)) {
940                         peer->status = PEER_ERROR;
941                         return;
942                     }
943                     ret = SSL_renegotiate(peer->ssl);
944                 } else {
945                     ret = SSL_renegotiate_abbreviated(peer->ssl);
946                 }
947             }
948             if (!ret) {
949                 peer->status = PEER_ERROR;
950                 return;
951             }
952             do_handshake_step(peer);
953             /*
954              * If status is PEER_RETRY it means we're waiting on the peer to
955              * continue the handshake. As far as setting up the renegotiation is
956              * concerned that is a success. The next step will continue the
957              * handshake to its conclusion.
958              *
959              * If status is PEER_SUCCESS then we are the server and we have
960              * successfully sent the HelloRequest. We need to continue to wait
961              * until the handshake arrives from the client.
962              */
963             if (peer->status == PEER_RETRY)
964                 peer->status = PEER_SUCCESS;
965             else if (peer->status == PEER_SUCCESS)
966                 peer->status = PEER_RETRY;
967             return;
968         }
969     } else if (test_ctx->handshake_mode == SSL_TEST_HANDSHAKE_KEY_UPDATE_SERVER
970                || test_ctx->handshake_mode
971                   == SSL_TEST_HANDSHAKE_KEY_UPDATE_CLIENT) {
972         if (SSL_is_server(peer->ssl)
973                 != (test_ctx->handshake_mode
974                     == SSL_TEST_HANDSHAKE_KEY_UPDATE_SERVER)) {
975             peer->status = PEER_SUCCESS;
976             return;
977         }
978
979         ret = SSL_key_update(peer->ssl, test_ctx->key_update_type);
980         if (!ret) {
981             peer->status = PEER_ERROR;
982             return;
983         }
984         do_handshake_step(peer);
985         /*
986          * This is a one step handshake. We shouldn't get anything other than
987          * PEER_SUCCESS
988          */
989         if (peer->status != PEER_SUCCESS)
990             peer->status = PEER_ERROR;
991         return;
992     } else if (test_ctx->handshake_mode == SSL_TEST_HANDSHAKE_POST_HANDSHAKE_AUTH) {
993         if (SSL_is_server(peer->ssl)) {
994             /* Make the server believe it's received the extension */
995             if (test_ctx->extra.server.force_pha)
996                 peer->ssl->post_handshake_auth = SSL_PHA_EXT_RECEIVED;
997             ret = SSL_verify_client_post_handshake(peer->ssl);
998             if (!ret) {
999                 peer->status = PEER_ERROR;
1000                 return;
1001             }
1002         }
1003         do_handshake_step(peer);
1004         /*
1005          * This is a one step handshake. We shouldn't get anything other than
1006          * PEER_SUCCESS
1007          */
1008         if (peer->status != PEER_SUCCESS)
1009             peer->status = PEER_ERROR;
1010         return;
1011     }
1012
1013     /*
1014      * The SSL object is still expecting app data, even though it's going to
1015      * get a handshake message. We try to read, and it should fail - after which
1016      * we should be in a handshake
1017      */
1018     ret = SSL_read(peer->ssl, &buf, sizeof(buf));
1019     if (ret >= 0) {
1020         /*
1021          * We're not actually expecting data - we're expecting a reneg to
1022          * start
1023          */
1024         peer->status = PEER_ERROR;
1025         return;
1026     } else {
1027         int error = SSL_get_error(peer->ssl, ret);
1028         if (error != SSL_ERROR_WANT_READ) {
1029             peer->status = PEER_ERROR;
1030             return;
1031         }
1032         /* If we're not in init yet then we're not done with setup yet */
1033         if (!SSL_in_init(peer->ssl))
1034             return;
1035     }
1036
1037     peer->status = PEER_SUCCESS;
1038 }
1039
1040
1041 /*
1042  * RFC 5246 says:
1043  *
1044  * Note that as of TLS 1.1,
1045  *     failure to properly close a connection no longer requires that a
1046  *     session not be resumed.  This is a change from TLS 1.0 to conform
1047  *     with widespread implementation practice.
1048  *
1049  * However,
1050  * (a) OpenSSL requires that a connection be shutdown for all protocol versions.
1051  * (b) We test lower versions, too.
1052  * So we just implement shutdown. We do a full bidirectional shutdown so that we
1053  * can compare sent and received close_notify alerts and get some test coverage
1054  * for SSL_shutdown as a bonus.
1055  */
1056 static void do_shutdown_step(PEER *peer)
1057 {
1058     int ret;
1059
1060     if (!TEST_int_eq(peer->status, PEER_RETRY)) {
1061         peer->status = PEER_TEST_FAILURE;
1062         return;
1063     }
1064     ret = SSL_shutdown(peer->ssl);
1065
1066     if (ret == 1) {
1067         peer->status = PEER_SUCCESS;
1068     } else if (ret < 0) { /* On 0, we retry. */
1069         int error = SSL_get_error(peer->ssl, ret);
1070
1071         if (error != SSL_ERROR_WANT_READ && error != SSL_ERROR_WANT_WRITE)
1072             peer->status = PEER_ERROR;
1073     }
1074 }
1075
1076 typedef enum {
1077     HANDSHAKE,
1078     RENEG_APPLICATION_DATA,
1079     RENEG_SETUP,
1080     RENEG_HANDSHAKE,
1081     APPLICATION_DATA,
1082     SHUTDOWN,
1083     CONNECTION_DONE
1084 } connect_phase_t;
1085
1086
1087 static int renegotiate_op(const SSL_TEST_CTX *test_ctx)
1088 {
1089     switch (test_ctx->handshake_mode) {
1090     case SSL_TEST_HANDSHAKE_RENEG_SERVER:
1091     case SSL_TEST_HANDSHAKE_RENEG_CLIENT:
1092         return 1;
1093     default:
1094         return 0;
1095     }
1096 }
1097 static int post_handshake_op(const SSL_TEST_CTX *test_ctx)
1098 {
1099     switch (test_ctx->handshake_mode) {
1100     case SSL_TEST_HANDSHAKE_KEY_UPDATE_CLIENT:
1101     case SSL_TEST_HANDSHAKE_KEY_UPDATE_SERVER:
1102     case SSL_TEST_HANDSHAKE_POST_HANDSHAKE_AUTH:
1103         return 1;
1104     default:
1105         return 0;
1106     }
1107 }
1108
1109 static connect_phase_t next_phase(const SSL_TEST_CTX *test_ctx,
1110                                   connect_phase_t phase)
1111 {
1112     switch (phase) {
1113     case HANDSHAKE:
1114         if (renegotiate_op(test_ctx) || post_handshake_op(test_ctx))
1115             return RENEG_APPLICATION_DATA;
1116         return APPLICATION_DATA;
1117     case RENEG_APPLICATION_DATA:
1118         return RENEG_SETUP;
1119     case RENEG_SETUP:
1120         if (post_handshake_op(test_ctx))
1121             return APPLICATION_DATA;
1122         return RENEG_HANDSHAKE;
1123     case RENEG_HANDSHAKE:
1124         return APPLICATION_DATA;
1125     case APPLICATION_DATA:
1126         return SHUTDOWN;
1127     case SHUTDOWN:
1128         return CONNECTION_DONE;
1129     case CONNECTION_DONE:
1130         TEST_error("Trying to progress after connection done");
1131         break;
1132     }
1133     return -1;
1134 }
1135
1136 static void do_connect_step(const SSL_TEST_CTX *test_ctx, PEER *peer,
1137                             connect_phase_t phase)
1138 {
1139     switch (phase) {
1140     case HANDSHAKE:
1141         do_handshake_step(peer);
1142         break;
1143     case RENEG_APPLICATION_DATA:
1144         do_app_data_step(peer);
1145         break;
1146     case RENEG_SETUP:
1147         do_reneg_setup_step(test_ctx, peer);
1148         break;
1149     case RENEG_HANDSHAKE:
1150         do_handshake_step(peer);
1151         break;
1152     case APPLICATION_DATA:
1153         do_app_data_step(peer);
1154         break;
1155     case SHUTDOWN:
1156         do_shutdown_step(peer);
1157         break;
1158     case CONNECTION_DONE:
1159         TEST_error("Action after connection done");
1160         break;
1161     }
1162 }
1163
1164 typedef enum {
1165     /* Both parties succeeded. */
1166     HANDSHAKE_SUCCESS,
1167     /* Client errored. */
1168     CLIENT_ERROR,
1169     /* Server errored. */
1170     SERVER_ERROR,
1171     /* Peers are in inconsistent state. */
1172     INTERNAL_ERROR,
1173     /* One or both peers not done. */
1174     HANDSHAKE_RETRY
1175 } handshake_status_t;
1176
1177 /*
1178  * Determine the handshake outcome.
1179  * last_status: the status of the peer to have acted last.
1180  * previous_status: the status of the peer that didn't act last.
1181  * client_spoke_last: 1 if the client went last.
1182  */
1183 static handshake_status_t handshake_status(peer_status_t last_status,
1184                                            peer_status_t previous_status,
1185                                            int client_spoke_last)
1186 {
1187     switch (last_status) {
1188     case PEER_TEST_FAILURE:
1189         return INTERNAL_ERROR;
1190
1191     case PEER_WAITING:
1192         /* Shouldn't ever happen */
1193         return INTERNAL_ERROR;
1194
1195     case PEER_SUCCESS:
1196         switch (previous_status) {
1197         case PEER_TEST_FAILURE:
1198             return INTERNAL_ERROR;
1199         case PEER_SUCCESS:
1200             /* Both succeeded. */
1201             return HANDSHAKE_SUCCESS;
1202         case PEER_WAITING:
1203         case PEER_RETRY:
1204             /* Let the first peer finish. */
1205             return HANDSHAKE_RETRY;
1206         case PEER_ERROR:
1207             /*
1208              * Second peer succeeded despite the fact that the first peer
1209              * already errored. This shouldn't happen.
1210              */
1211             return INTERNAL_ERROR;
1212         }
1213         break;
1214
1215     case PEER_RETRY:
1216         return HANDSHAKE_RETRY;
1217
1218     case PEER_ERROR:
1219         switch (previous_status) {
1220         case PEER_TEST_FAILURE:
1221             return INTERNAL_ERROR;
1222         case PEER_WAITING:
1223             /* The client failed immediately before sending the ClientHello */
1224             return client_spoke_last ? CLIENT_ERROR : INTERNAL_ERROR;
1225         case PEER_SUCCESS:
1226             /*
1227              * First peer succeeded but second peer errored.
1228              * TODO(emilia): we should be able to continue here (with some
1229              * application data?) to ensure the first peer receives the
1230              * alert / close_notify.
1231              * (No tests currently exercise this branch.)
1232              */
1233             return client_spoke_last ? CLIENT_ERROR : SERVER_ERROR;
1234         case PEER_RETRY:
1235             /* We errored; let the peer finish. */
1236             return HANDSHAKE_RETRY;
1237         case PEER_ERROR:
1238             /* Both peers errored. Return the one that errored first. */
1239             return client_spoke_last ? SERVER_ERROR : CLIENT_ERROR;
1240         }
1241     }
1242     /* Control should never reach here. */
1243     return INTERNAL_ERROR;
1244 }
1245
1246 /* Convert unsigned char buf's that shouldn't contain any NUL-bytes to char. */
1247 static char *dup_str(const unsigned char *in, size_t len)
1248 {
1249     char *ret = NULL;
1250
1251     if (len == 0)
1252         return NULL;
1253
1254     /* Assert that the string does not contain NUL-bytes. */
1255     if (TEST_size_t_eq(OPENSSL_strnlen((const char*)(in), len), len))
1256         TEST_ptr(ret = OPENSSL_strndup((const char*)(in), len));
1257     return ret;
1258 }
1259
1260 static int pkey_type(EVP_PKEY *pkey)
1261 {
1262     int nid = EVP_PKEY_id(pkey);
1263
1264 #ifndef OPENSSL_NO_EC
1265     if (nid == EVP_PKEY_EC) {
1266         const EC_KEY *ec = EVP_PKEY_get0_EC_KEY(pkey);
1267         return EC_GROUP_get_curve_name(EC_KEY_get0_group(ec));
1268     }
1269 #endif
1270     return nid;
1271 }
1272
1273 static int peer_pkey_type(SSL *s)
1274 {
1275     X509 *x = SSL_get_peer_certificate(s);
1276
1277     if (x != NULL) {
1278         int nid = pkey_type(X509_get0_pubkey(x));
1279
1280         X509_free(x);
1281         return nid;
1282     }
1283     return NID_undef;
1284 }
1285
1286 #if !defined(OPENSSL_NO_SCTP) && !defined(OPENSSL_NO_SOCK)
1287 static int set_sock_as_sctp(int sock)
1288 {
1289     struct sctp_assocparams assocparams;
1290     struct sctp_rtoinfo rto_info;
1291     BIO *tmpbio;
1292
1293     /*
1294      * To allow tests to fail fast (within a second or so), reduce the
1295      * retransmission timeouts and the number of retransmissions.
1296      */
1297     memset(&rto_info, 0, sizeof(struct sctp_rtoinfo));
1298     rto_info.srto_initial = 100;
1299     rto_info.srto_max = 200;
1300     rto_info.srto_min = 50;
1301     (void)setsockopt(sock, IPPROTO_SCTP, SCTP_RTOINFO,
1302                      (const void *)&rto_info, sizeof(struct sctp_rtoinfo));
1303     memset(&assocparams, 0, sizeof(struct sctp_assocparams));
1304     assocparams.sasoc_asocmaxrxt = 2;
1305     (void)setsockopt(sock, IPPROTO_SCTP, SCTP_ASSOCINFO,
1306                      (const void *)&assocparams,
1307                      sizeof(struct sctp_assocparams));
1308
1309     /*
1310      * For SCTP we have to set various options on the socket prior to
1311      * connecting. This is done automatically by BIO_new_dgram_sctp().
1312      * We don't actually need the created BIO though so we free it again
1313      * immediately.
1314      */
1315     tmpbio = BIO_new_dgram_sctp(sock, BIO_NOCLOSE);
1316
1317     if (tmpbio == NULL)
1318         return 0;
1319     BIO_free(tmpbio);
1320
1321     return 1;
1322 }
1323
1324 static int create_sctp_socks(int *ssock, int *csock)
1325 {
1326     BIO_ADDRINFO *res = NULL;
1327     const BIO_ADDRINFO *ai = NULL;
1328     int lsock = INVALID_SOCKET, asock = INVALID_SOCKET;
1329     int consock = INVALID_SOCKET;
1330     int ret = 0;
1331     int family = 0;
1332
1333     if (BIO_sock_init() != 1)
1334         return 0;
1335
1336     /*
1337      * Port is 4463. It could be anything. It will fail if it's already being
1338      * used for some other SCTP service. It seems unlikely though so we don't
1339      * worry about it here.
1340      */
1341     if (!BIO_lookup_ex(NULL, "4463", BIO_LOOKUP_SERVER, family, SOCK_STREAM,
1342                        IPPROTO_SCTP, &res))
1343         return 0;
1344
1345     for (ai = res; ai != NULL; ai = BIO_ADDRINFO_next(ai)) {
1346         family = BIO_ADDRINFO_family(ai);
1347         lsock = BIO_socket(family, SOCK_STREAM, IPPROTO_SCTP, 0);
1348         if (lsock == INVALID_SOCKET) {
1349             /* Maybe the kernel doesn't support the socket family, even if
1350              * BIO_lookup() added it in the returned result...
1351              */
1352             continue;
1353         }
1354
1355         if (!set_sock_as_sctp(lsock)
1356                 || !BIO_listen(lsock, BIO_ADDRINFO_address(ai),
1357                                BIO_SOCK_REUSEADDR)) {
1358             BIO_closesocket(lsock);
1359             lsock = INVALID_SOCKET;
1360             continue;
1361         }
1362
1363         /* Success, don't try any more addresses */
1364         break;
1365     }
1366
1367     if (lsock == INVALID_SOCKET)
1368         goto err;
1369
1370     BIO_ADDRINFO_free(res);
1371     res = NULL;
1372
1373     if (!BIO_lookup_ex(NULL, "4463", BIO_LOOKUP_CLIENT, family, SOCK_STREAM,
1374                         IPPROTO_SCTP, &res))
1375         goto err;
1376
1377     consock = BIO_socket(family, SOCK_STREAM, IPPROTO_SCTP, 0);
1378     if (consock == INVALID_SOCKET)
1379         goto err;
1380
1381     if (!set_sock_as_sctp(consock)
1382             || !BIO_connect(consock, BIO_ADDRINFO_address(res), 0)
1383             || !BIO_socket_nbio(consock, 1))
1384         goto err;
1385
1386     asock = BIO_accept_ex(lsock, NULL, BIO_SOCK_NONBLOCK);
1387     if (asock == INVALID_SOCKET)
1388         goto err;
1389
1390     *csock = consock;
1391     *ssock = asock;
1392     consock = asock = INVALID_SOCKET;
1393     ret = 1;
1394
1395  err:
1396     BIO_ADDRINFO_free(res);
1397     if (consock != INVALID_SOCKET)
1398         BIO_closesocket(consock);
1399     if (lsock != INVALID_SOCKET)
1400         BIO_closesocket(lsock);
1401     if (asock != INVALID_SOCKET)
1402         BIO_closesocket(asock);
1403     return ret;
1404 }
1405 #endif
1406
1407 /*
1408  * Note that |extra| points to the correct client/server configuration
1409  * within |test_ctx|. When configuring the handshake, general mode settings
1410  * are taken from |test_ctx|, and client/server-specific settings should be
1411  * taken from |extra|.
1412  *
1413  * The configuration code should never reach into |test_ctx->extra| or
1414  * |test_ctx->resume_extra| directly.
1415  *
1416  * (We could refactor test mode settings into a substructure. This would result
1417  * in cleaner argument passing but would complicate the test configuration
1418  * parsing.)
1419  */
1420 static HANDSHAKE_RESULT *do_handshake_internal(
1421     SSL_CTX *server_ctx, SSL_CTX *server2_ctx, SSL_CTX *client_ctx,
1422     const SSL_TEST_CTX *test_ctx, const SSL_TEST_EXTRA_CONF *extra,
1423     SSL_SESSION *session_in, SSL_SESSION *serv_sess_in,
1424     SSL_SESSION **session_out, SSL_SESSION **serv_sess_out)
1425 {
1426     PEER server, client;
1427     BIO *client_to_server = NULL, *server_to_client = NULL;
1428     HANDSHAKE_EX_DATA server_ex_data, client_ex_data;
1429     CTX_DATA client_ctx_data, server_ctx_data, server2_ctx_data;
1430     HANDSHAKE_RESULT *ret = HANDSHAKE_RESULT_new();
1431     int client_turn = 1, client_turn_count = 0, client_wait_count = 0;
1432     connect_phase_t phase = HANDSHAKE;
1433     handshake_status_t status = HANDSHAKE_RETRY;
1434     const unsigned char* tick = NULL;
1435     size_t tick_len = 0;
1436     const unsigned char* sess_id = NULL;
1437     unsigned int sess_id_len = 0;
1438     SSL_SESSION* sess = NULL;
1439     const unsigned char *proto = NULL;
1440     /* API dictates unsigned int rather than size_t. */
1441     unsigned int proto_len = 0;
1442     EVP_PKEY *tmp_key;
1443     const STACK_OF(X509_NAME) *names;
1444     time_t start;
1445     const char* cipher;
1446
1447     if (ret == NULL)
1448         return NULL;
1449
1450     memset(&server_ctx_data, 0, sizeof(server_ctx_data));
1451     memset(&server2_ctx_data, 0, sizeof(server2_ctx_data));
1452     memset(&client_ctx_data, 0, sizeof(client_ctx_data));
1453     memset(&server, 0, sizeof(server));
1454     memset(&client, 0, sizeof(client));
1455     memset(&server_ex_data, 0, sizeof(server_ex_data));
1456     memset(&client_ex_data, 0, sizeof(client_ex_data));
1457
1458     if (!configure_handshake_ctx(server_ctx, server2_ctx, client_ctx,
1459                                  test_ctx, extra, &server_ctx_data,
1460                                  &server2_ctx_data, &client_ctx_data)) {
1461         TEST_note("configure_handshake_ctx");
1462         return NULL;
1463     }
1464
1465 #if !defined(OPENSSL_NO_SCTP) && !defined(OPENSSL_NO_SOCK)
1466     if (test_ctx->enable_client_sctp_label_bug)
1467         SSL_CTX_set_mode(client_ctx, SSL_MODE_DTLS_SCTP_LABEL_LENGTH_BUG);
1468     if (test_ctx->enable_server_sctp_label_bug)
1469         SSL_CTX_set_mode(server_ctx, SSL_MODE_DTLS_SCTP_LABEL_LENGTH_BUG);
1470 #endif
1471
1472     /* Setup SSL and buffers; additional configuration happens below. */
1473     if (!create_peer(&server, server_ctx)) {
1474         TEST_note("creating server context");
1475         goto err;
1476     }
1477     if (!create_peer(&client, client_ctx)) {
1478         TEST_note("creating client context");
1479         goto err;
1480     }
1481
1482     server.bytes_to_write = client.bytes_to_read = test_ctx->app_data_size;
1483     client.bytes_to_write = server.bytes_to_read = test_ctx->app_data_size;
1484
1485     configure_handshake_ssl(server.ssl, client.ssl, extra);
1486     if (session_in != NULL) {
1487         SSL_SESSION_get_id(serv_sess_in, &sess_id_len);
1488         /* In case we're testing resumption without tickets. */
1489         if ((sess_id_len > 0
1490                     && !TEST_true(SSL_CTX_add_session(server_ctx,
1491                                                       serv_sess_in)))
1492                 || !TEST_true(SSL_set_session(client.ssl, session_in)))
1493             goto err;
1494         sess_id_len = 0;
1495     }
1496
1497     ret->result = SSL_TEST_INTERNAL_ERROR;
1498
1499     if (test_ctx->use_sctp) {
1500 #if !defined(OPENSSL_NO_SCTP) && !defined(OPENSSL_NO_SOCK)
1501         int csock, ssock;
1502
1503         if (create_sctp_socks(&ssock, &csock)) {
1504             client_to_server = BIO_new_dgram_sctp(csock, BIO_CLOSE);
1505             server_to_client = BIO_new_dgram_sctp(ssock, BIO_CLOSE);
1506         }
1507 #endif
1508     } else {
1509         client_to_server = BIO_new(BIO_s_mem());
1510         server_to_client = BIO_new(BIO_s_mem());
1511     }
1512
1513     if (!TEST_ptr(client_to_server)
1514             || !TEST_ptr(server_to_client))
1515         goto err;
1516
1517     /* Non-blocking bio. */
1518     BIO_set_nbio(client_to_server, 1);
1519     BIO_set_nbio(server_to_client, 1);
1520
1521     SSL_set_connect_state(client.ssl);
1522     SSL_set_accept_state(server.ssl);
1523
1524     /* The bios are now owned by the SSL object. */
1525     if (test_ctx->use_sctp) {
1526         SSL_set_bio(client.ssl, client_to_server, client_to_server);
1527         SSL_set_bio(server.ssl, server_to_client, server_to_client);
1528     } else {
1529         SSL_set_bio(client.ssl, server_to_client, client_to_server);
1530         if (!TEST_int_gt(BIO_up_ref(server_to_client), 0)
1531                 || !TEST_int_gt(BIO_up_ref(client_to_server), 0))
1532             goto err;
1533         SSL_set_bio(server.ssl, client_to_server, server_to_client);
1534     }
1535
1536     ex_data_idx = SSL_get_ex_new_index(0, "ex data", NULL, NULL, NULL);
1537     if (!TEST_int_ge(ex_data_idx, 0)
1538             || !TEST_int_eq(SSL_set_ex_data(server.ssl, ex_data_idx, &server_ex_data), 1)
1539             || !TEST_int_eq(SSL_set_ex_data(client.ssl, ex_data_idx, &client_ex_data), 1))
1540         goto err;
1541
1542     SSL_set_info_callback(server.ssl, &info_cb);
1543     SSL_set_info_callback(client.ssl, &info_cb);
1544
1545     client.status = PEER_RETRY;
1546     server.status = PEER_WAITING;
1547
1548     start = time(NULL);
1549
1550     /*
1551      * Half-duplex handshake loop.
1552      * Client and server speak to each other synchronously in the same process.
1553      * We use non-blocking BIOs, so whenever one peer blocks for read, it
1554      * returns PEER_RETRY to indicate that it's the other peer's turn to write.
1555      * The handshake succeeds once both peers have succeeded. If one peer
1556      * errors out, we also let the other peer retry (and presumably fail).
1557      */
1558     for(;;) {
1559         if (client_turn) {
1560             do_connect_step(test_ctx, &client, phase);
1561             status = handshake_status(client.status, server.status,
1562                                       1 /* client went last */);
1563             if (server.status == PEER_WAITING)
1564                 server.status = PEER_RETRY;
1565         } else {
1566             do_connect_step(test_ctx, &server, phase);
1567             status = handshake_status(server.status, client.status,
1568                                       0 /* server went last */);
1569         }
1570
1571         switch (status) {
1572         case HANDSHAKE_SUCCESS:
1573             client_turn_count = 0;
1574             phase = next_phase(test_ctx, phase);
1575             if (phase == CONNECTION_DONE) {
1576                 ret->result = SSL_TEST_SUCCESS;
1577                 goto err;
1578             } else {
1579                 client.status = server.status = PEER_RETRY;
1580                 /*
1581                  * For now, client starts each phase. Since each phase is
1582                  * started separately, we can later control this more
1583                  * precisely, for example, to test client-initiated and
1584                  * server-initiated shutdown.
1585                  */
1586                 client_turn = 1;
1587                 break;
1588             }
1589         case CLIENT_ERROR:
1590             ret->result = SSL_TEST_CLIENT_FAIL;
1591             goto err;
1592         case SERVER_ERROR:
1593             ret->result = SSL_TEST_SERVER_FAIL;
1594             goto err;
1595         case INTERNAL_ERROR:
1596             ret->result = SSL_TEST_INTERNAL_ERROR;
1597             goto err;
1598         case HANDSHAKE_RETRY:
1599             if (test_ctx->use_sctp) {
1600                 if (time(NULL) - start > 3) {
1601                     /*
1602                      * We've waited for too long. Give up.
1603                      */
1604                     ret->result = SSL_TEST_INTERNAL_ERROR;
1605                     goto err;
1606                 }
1607                 /*
1608                  * With "real" sockets we only swap to processing the peer
1609                  * if they are expecting to retry. Otherwise we just retry the
1610                  * same endpoint again.
1611                  */
1612                 if ((client_turn && server.status == PEER_RETRY)
1613                         || (!client_turn && client.status == PEER_RETRY))
1614                     client_turn ^= 1;
1615             } else {
1616                 if (client_turn_count++ >= 2000) {
1617                     /*
1618                      * At this point, there's been so many PEER_RETRY in a row
1619                      * that it's likely both sides are stuck waiting for a read.
1620                      * It's time to give up.
1621                      */
1622                     ret->result = SSL_TEST_INTERNAL_ERROR;
1623                     goto err;
1624                 }
1625                 if (client_turn && server.status == PEER_SUCCESS) {
1626                     /*
1627                      * The server may finish before the client because the
1628                      * client spends some turns processing NewSessionTickets.
1629                      */
1630                     if (client_wait_count++ >= 2) {
1631                         ret->result = SSL_TEST_INTERNAL_ERROR;
1632                         goto err;
1633                     }
1634                 } else {
1635                     /* Continue. */
1636                     client_turn ^= 1;
1637                 }
1638             }
1639             break;
1640         }
1641     }
1642  err:
1643     ret->server_alert_sent = server_ex_data.alert_sent;
1644     ret->server_num_fatal_alerts_sent = server_ex_data.num_fatal_alerts_sent;
1645     ret->server_alert_received = client_ex_data.alert_received;
1646     ret->client_alert_sent = client_ex_data.alert_sent;
1647     ret->client_num_fatal_alerts_sent = client_ex_data.num_fatal_alerts_sent;
1648     ret->client_alert_received = server_ex_data.alert_received;
1649     ret->server_protocol = SSL_version(server.ssl);
1650     ret->client_protocol = SSL_version(client.ssl);
1651     ret->servername = server_ex_data.servername;
1652     if ((sess = SSL_get0_session(client.ssl)) != NULL) {
1653         SSL_SESSION_get0_ticket(sess, &tick, &tick_len);
1654         sess_id = SSL_SESSION_get_id(sess, &sess_id_len);
1655     }
1656     if (tick == NULL || tick_len == 0)
1657         ret->session_ticket = SSL_TEST_SESSION_TICKET_NO;
1658     else
1659         ret->session_ticket = SSL_TEST_SESSION_TICKET_YES;
1660     ret->compression = (SSL_get_current_compression(client.ssl) == NULL)
1661                        ? SSL_TEST_COMPRESSION_NO
1662                        : SSL_TEST_COMPRESSION_YES;
1663     if (sess_id == NULL || sess_id_len == 0)
1664         ret->session_id = SSL_TEST_SESSION_ID_NO;
1665     else
1666         ret->session_id = SSL_TEST_SESSION_ID_YES;
1667     ret->session_ticket_do_not_call = server_ex_data.session_ticket_do_not_call;
1668
1669 #ifndef OPENSSL_NO_NEXTPROTONEG
1670     SSL_get0_next_proto_negotiated(client.ssl, &proto, &proto_len);
1671     ret->client_npn_negotiated = dup_str(proto, proto_len);
1672
1673     SSL_get0_next_proto_negotiated(server.ssl, &proto, &proto_len);
1674     ret->server_npn_negotiated = dup_str(proto, proto_len);
1675 #endif
1676
1677     SSL_get0_alpn_selected(client.ssl, &proto, &proto_len);
1678     ret->client_alpn_negotiated = dup_str(proto, proto_len);
1679
1680     SSL_get0_alpn_selected(server.ssl, &proto, &proto_len);
1681     ret->server_alpn_negotiated = dup_str(proto, proto_len);
1682
1683     if ((sess = SSL_get0_session(server.ssl)) != NULL) {
1684         SSL_SESSION_get0_ticket_appdata(sess, (void**)&tick, &tick_len);
1685         ret->result_session_ticket_app_data = OPENSSL_strndup((const char*)tick, tick_len);
1686     }
1687
1688     ret->client_resumed = SSL_session_reused(client.ssl);
1689     ret->server_resumed = SSL_session_reused(server.ssl);
1690
1691     cipher = SSL_CIPHER_get_name(SSL_get_current_cipher(client.ssl));
1692     ret->cipher = dup_str((const unsigned char*)cipher, strlen(cipher));
1693
1694     if (session_out != NULL)
1695         *session_out = SSL_get1_session(client.ssl);
1696     if (serv_sess_out != NULL) {
1697         SSL_SESSION *tmp = SSL_get_session(server.ssl);
1698
1699         /*
1700          * We create a fresh copy that is not in the server session ctx linked
1701          * list.
1702          */
1703         if (tmp != NULL)
1704             *serv_sess_out = SSL_SESSION_dup(tmp);
1705     }
1706
1707     if (SSL_get_peer_tmp_key(client.ssl, &tmp_key)) {
1708         ret->tmp_key_type = pkey_type(tmp_key);
1709         EVP_PKEY_free(tmp_key);
1710     }
1711
1712     SSL_get_peer_signature_nid(client.ssl, &ret->server_sign_hash);
1713     SSL_get_peer_signature_nid(server.ssl, &ret->client_sign_hash);
1714
1715     SSL_get_peer_signature_type_nid(client.ssl, &ret->server_sign_type);
1716     SSL_get_peer_signature_type_nid(server.ssl, &ret->client_sign_type);
1717
1718     names = SSL_get0_peer_CA_list(client.ssl);
1719     if (names == NULL)
1720         ret->client_ca_names = NULL;
1721     else
1722         ret->client_ca_names = SSL_dup_CA_list(names);
1723
1724     names = SSL_get0_peer_CA_list(server.ssl);
1725     if (names == NULL)
1726         ret->server_ca_names = NULL;
1727     else
1728         ret->server_ca_names = SSL_dup_CA_list(names);
1729
1730     ret->server_cert_type = peer_pkey_type(client.ssl);
1731     ret->client_cert_type = peer_pkey_type(server.ssl);
1732
1733     ctx_data_free_data(&server_ctx_data);
1734     ctx_data_free_data(&server2_ctx_data);
1735     ctx_data_free_data(&client_ctx_data);
1736
1737     peer_free_data(&server);
1738     peer_free_data(&client);
1739     return ret;
1740 }
1741
1742 HANDSHAKE_RESULT *do_handshake(SSL_CTX *server_ctx, SSL_CTX *server2_ctx,
1743                                SSL_CTX *client_ctx, SSL_CTX *resume_server_ctx,
1744                                SSL_CTX *resume_client_ctx,
1745                                const SSL_TEST_CTX *test_ctx)
1746 {
1747     HANDSHAKE_RESULT *result;
1748     SSL_SESSION *session = NULL, *serv_sess = NULL;
1749
1750     result = do_handshake_internal(server_ctx, server2_ctx, client_ctx,
1751                                    test_ctx, &test_ctx->extra,
1752                                    NULL, NULL, &session, &serv_sess);
1753     if (result == NULL
1754             || test_ctx->handshake_mode != SSL_TEST_HANDSHAKE_RESUME
1755             || result->result == SSL_TEST_INTERNAL_ERROR)
1756         goto end;
1757
1758     if (result->result != SSL_TEST_SUCCESS) {
1759         result->result = SSL_TEST_FIRST_HANDSHAKE_FAILED;
1760         goto end;
1761     }
1762
1763     HANDSHAKE_RESULT_free(result);
1764     /* We don't support SNI on second handshake yet, so server2_ctx is NULL. */
1765     result = do_handshake_internal(resume_server_ctx, NULL, resume_client_ctx,
1766                                    test_ctx, &test_ctx->resume_extra,
1767                                    session, serv_sess, NULL, NULL);
1768  end:
1769     SSL_SESSION_free(session);
1770     SSL_SESSION_free(serv_sess);
1771     return result;
1772 }