c4b14e7c31e2bb3a0ff814fafdcbb6948fb525bf
[openssl.git] / test / handshake_helper.c
1 /*
2  * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <string.h>
11
12 #include <openssl/bio.h>
13 #include <openssl/x509_vfy.h>
14 #include <openssl/ssl.h>
15
16 #include "handshake_helper.h"
17 #include "testutil.h"
18
19 HANDSHAKE_RESULT *HANDSHAKE_RESULT_new()
20 {
21     HANDSHAKE_RESULT *ret = OPENSSL_zalloc(sizeof(*ret));
22     TEST_check(ret != NULL);
23     return ret;
24 }
25
26 void HANDSHAKE_RESULT_free(HANDSHAKE_RESULT *result)
27 {
28     if (result == NULL)
29         return;
30     OPENSSL_free(result->client_npn_negotiated);
31     OPENSSL_free(result->server_npn_negotiated);
32     OPENSSL_free(result->client_alpn_negotiated);
33     OPENSSL_free(result->server_alpn_negotiated);
34     OPENSSL_free(result);
35 }
36
37 /*
38  * Since there appears to be no way to extract the sent/received alert
39  * from the SSL object directly, we use the info callback and stash
40  * the result in ex_data.
41  */
42 typedef struct handshake_ex_data_st {
43     int alert_sent;
44     int alert_received;
45     int session_ticket_do_not_call;
46     ssl_servername_t servername;
47 } HANDSHAKE_EX_DATA;
48
49 typedef struct ctx_data_st {
50     unsigned char *npn_protocols;
51     size_t npn_protocols_len;
52     unsigned char *alpn_protocols;
53     size_t alpn_protocols_len;
54 } CTX_DATA;
55
56 /* |ctx_data| itself is stack-allocated. */
57 static void ctx_data_free_data(CTX_DATA *ctx_data)
58 {
59     OPENSSL_free(ctx_data->npn_protocols);
60     ctx_data->npn_protocols = NULL;
61     OPENSSL_free(ctx_data->alpn_protocols);
62     ctx_data->alpn_protocols = NULL;
63 }
64
65 static int ex_data_idx;
66
67 static void info_cb(const SSL *s, int where, int ret)
68 {
69     if (where & SSL_CB_ALERT) {
70         HANDSHAKE_EX_DATA *ex_data =
71             (HANDSHAKE_EX_DATA*)(SSL_get_ex_data(s, ex_data_idx));
72         if (where & SSL_CB_WRITE) {
73             ex_data->alert_sent = ret;
74         } else {
75             ex_data->alert_received = ret;
76         }
77     }
78 }
79
80 /* Select the appropriate server CTX.
81  * Returns SSL_TLSEXT_ERR_OK if a match was found.
82  * If |ignore| is 1, returns SSL_TLSEXT_ERR_NOACK on mismatch.
83  * Otherwise, returns SSL_TLSEXT_ERR_ALERT_FATAL on mismatch.
84  * An empty SNI extension also returns SSL_TSLEXT_ERR_NOACK.
85  */
86 static int select_server_ctx(SSL *s, void *arg, int ignore)
87 {
88     const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
89     HANDSHAKE_EX_DATA *ex_data =
90         (HANDSHAKE_EX_DATA*)(SSL_get_ex_data(s, ex_data_idx));
91
92     if (servername == NULL) {
93         ex_data->servername = SSL_TEST_SERVERNAME_SERVER1;
94         return SSL_TLSEXT_ERR_NOACK;
95     }
96
97     if (strcmp(servername, "server2") == 0) {
98         SSL_CTX *new_ctx = (SSL_CTX*)arg;
99         SSL_set_SSL_CTX(s, new_ctx);
100         /*
101          * Copy over all the SSL_CTX options - reasonable behavior
102          * allows testing of cases where the options between two
103          * contexts differ/conflict
104          */
105         SSL_clear_options(s, 0xFFFFFFFFL);
106         SSL_set_options(s, SSL_CTX_get_options(new_ctx));
107
108         ex_data->servername = SSL_TEST_SERVERNAME_SERVER2;
109         return SSL_TLSEXT_ERR_OK;
110     } else if (strcmp(servername, "server1") == 0) {
111         ex_data->servername = SSL_TEST_SERVERNAME_SERVER1;
112         return SSL_TLSEXT_ERR_OK;
113     } else if (ignore) {
114         ex_data->servername = SSL_TEST_SERVERNAME_SERVER1;
115         return SSL_TLSEXT_ERR_NOACK;
116     } else {
117         /* Don't set an explicit alert, to test library defaults. */
118         return SSL_TLSEXT_ERR_ALERT_FATAL;
119     }
120 }
121
122 /*
123  * (RFC 6066):
124  *  If the server understood the ClientHello extension but
125  *  does not recognize the server name, the server SHOULD take one of two
126  *  actions: either abort the handshake by sending a fatal-level
127  *  unrecognized_name(112) alert or continue the handshake.
128  *
129  * This behaviour is up to the application to configure; we test both
130  * configurations to ensure the state machine propagates the result
131  * correctly.
132  */
133 static int servername_ignore_cb(SSL *s, int *ad, void *arg)
134 {
135     return select_server_ctx(s, arg, 1);
136 }
137
138 static int servername_reject_cb(SSL *s, int *ad, void *arg)
139 {
140     return select_server_ctx(s, arg, 0);
141 }
142
143 static int verify_reject_cb(X509_STORE_CTX *ctx, void *arg) {
144     X509_STORE_CTX_set_error(ctx, X509_V_ERR_APPLICATION_VERIFICATION);
145     return 0;
146 }
147
148 static int verify_accept_cb(X509_STORE_CTX *ctx, void *arg) {
149     return 1;
150 }
151
152 static int broken_session_ticket_cb(SSL *s, unsigned char *key_name, unsigned char *iv,
153                                     EVP_CIPHER_CTX *ctx, HMAC_CTX *hctx, int enc)
154 {
155     return 0;
156 }
157
158 static int do_not_call_session_ticket_cb(SSL *s, unsigned char *key_name,
159                                          unsigned char *iv,
160                                          EVP_CIPHER_CTX *ctx,
161                                          HMAC_CTX *hctx, int enc)
162 {
163     HANDSHAKE_EX_DATA *ex_data =
164         (HANDSHAKE_EX_DATA*)(SSL_get_ex_data(s, ex_data_idx));
165     ex_data->session_ticket_do_not_call = 1;
166     return 0;
167 }
168
169 /* Parse the comma-separated list into TLS format. */
170 static void parse_protos(const char *protos, unsigned char **out, size_t *outlen)
171 {
172     size_t len, i, prefix;
173
174     len = strlen(protos);
175
176     /* Should never have reuse. */
177     TEST_check(*out == NULL);
178
179     /* Test values are small, so we omit length limit checks. */
180     *out = OPENSSL_malloc(len + 1);
181     TEST_check(*out != NULL);
182     *outlen = len + 1;
183
184     /*
185      * foo => '3', 'f', 'o', 'o'
186      * foo,bar => '3', 'f', 'o', 'o', '3', 'b', 'a', 'r'
187      */
188     memcpy(*out + 1, protos, len);
189
190     prefix = 0;
191     i = prefix + 1;
192     while (i <= len) {
193         if ((*out)[i] == ',') {
194             TEST_check(i - 1 - prefix > 0);
195             (*out)[prefix] = i - 1 - prefix;
196             prefix = i;
197         }
198         i++;
199     }
200     TEST_check(len - prefix > 0);
201     (*out)[prefix] = len - prefix;
202 }
203
204 #ifndef OPENSSL_NO_NEXTPROTONEG
205 /*
206  * The client SHOULD select the first protocol advertised by the server that it
207  * also supports.  In the event that the client doesn't support any of server's
208  * protocols, or the server doesn't advertise any, it SHOULD select the first
209  * protocol that it supports.
210  */
211 static int client_npn_cb(SSL *s, unsigned char **out, unsigned char *outlen,
212                          const unsigned char *in, unsigned int inlen,
213                          void *arg)
214 {
215     CTX_DATA *ctx_data = (CTX_DATA*)(arg);
216     int ret;
217
218     ret = SSL_select_next_proto(out, outlen, in, inlen,
219                                 ctx_data->npn_protocols,
220                                 ctx_data->npn_protocols_len);
221     /* Accept both OPENSSL_NPN_NEGOTIATED and OPENSSL_NPN_NO_OVERLAP. */
222     TEST_check(ret == OPENSSL_NPN_NEGOTIATED || ret == OPENSSL_NPN_NO_OVERLAP);
223     return SSL_TLSEXT_ERR_OK;
224 }
225
226 static int server_npn_cb(SSL *s, const unsigned char **data,
227                          unsigned int *len, void *arg)
228 {
229     CTX_DATA *ctx_data = (CTX_DATA*)(arg);
230     *data = ctx_data->npn_protocols;
231     *len = ctx_data->npn_protocols_len;
232     return SSL_TLSEXT_ERR_OK;
233 }
234 #endif
235
236 /*
237  * The server SHOULD select the most highly preferred protocol that it supports
238  * and that is also advertised by the client.  In the event that the server
239  * supports no protocols that the client advertises, then the server SHALL
240  * respond with a fatal "no_application_protocol" alert.
241  */
242 static int server_alpn_cb(SSL *s, const unsigned char **out,
243                           unsigned char *outlen, const unsigned char *in,
244                           unsigned int inlen, void *arg)
245 {
246     CTX_DATA *ctx_data = (CTX_DATA*)(arg);
247     int ret;
248
249     /* SSL_select_next_proto isn't const-correct... */
250     unsigned char *tmp_out;
251
252     /*
253      * The result points either to |in| or to |ctx_data->alpn_protocols|.
254      * The callback is allowed to point to |in| or to a long-lived buffer,
255      * so we can return directly without storing a copy.
256      */
257     ret = SSL_select_next_proto(&tmp_out, outlen,
258                                 ctx_data->alpn_protocols,
259                                 ctx_data->alpn_protocols_len, in, inlen);
260
261     *out = tmp_out;
262     /* Unlike NPN, we don't tolerate a mismatch. */
263     return ret == OPENSSL_NPN_NEGOTIATED ? SSL_TLSEXT_ERR_OK
264         : SSL_TLSEXT_ERR_NOACK;
265 }
266
267 /*
268  * Configure callbacks and other properties that can't be set directly
269  * in the server/client CONF.
270  */
271 static void configure_handshake_ctx(SSL_CTX *server_ctx, SSL_CTX *server2_ctx,
272                                     SSL_CTX *client_ctx,
273                                     const SSL_TEST_EXTRA_CONF *extra,
274                                     CTX_DATA *server_ctx_data,
275                                     CTX_DATA *server2_ctx_data,
276                                     CTX_DATA *client_ctx_data)
277 {
278     unsigned char *ticket_keys;
279     size_t ticket_key_len;
280
281     switch (extra->client.verify_callback) {
282     case SSL_TEST_VERIFY_ACCEPT_ALL:
283         SSL_CTX_set_cert_verify_callback(client_ctx, &verify_accept_cb,
284                                          NULL);
285         break;
286     case SSL_TEST_VERIFY_REJECT_ALL:
287         SSL_CTX_set_cert_verify_callback(client_ctx, &verify_reject_cb,
288                                          NULL);
289         break;
290     default:
291         break;
292     }
293
294     /* link the two contexts for SNI purposes */
295     switch (extra->server.servername_callback) {
296     case SSL_TEST_SERVERNAME_IGNORE_MISMATCH:
297         SSL_CTX_set_tlsext_servername_callback(server_ctx, servername_ignore_cb);
298         SSL_CTX_set_tlsext_servername_arg(server_ctx, server2_ctx);
299         break;
300     case SSL_TEST_SERVERNAME_REJECT_MISMATCH:
301         SSL_CTX_set_tlsext_servername_callback(server_ctx, servername_reject_cb);
302         SSL_CTX_set_tlsext_servername_arg(server_ctx, server2_ctx);
303         break;
304     default:
305         break;
306     }
307
308     /*
309      * The initial_ctx/session_ctx always handles the encrypt/decrypt of the
310      * session ticket. This ticket_key callback is assigned to the second
311      * session (assigned via SNI), and should never be invoked
312      */
313     if (server2_ctx != NULL)
314         SSL_CTX_set_tlsext_ticket_key_cb(server2_ctx,
315                                          do_not_call_session_ticket_cb);
316
317     if (extra->server.broken_session_ticket) {
318         SSL_CTX_set_tlsext_ticket_key_cb(server_ctx, broken_session_ticket_cb);
319     }
320 #ifndef OPENSSL_NO_NEXTPROTONEG
321     if (extra->server.npn_protocols != NULL) {
322         parse_protos(extra->server.npn_protocols,
323                      &server_ctx_data->npn_protocols,
324                      &server_ctx_data->npn_protocols_len);
325         SSL_CTX_set_next_protos_advertised_cb(server_ctx, server_npn_cb,
326                                               server_ctx_data);
327     }
328     if (extra->server2.npn_protocols != NULL) {
329         parse_protos(extra->server2.npn_protocols,
330                      &server2_ctx_data->npn_protocols,
331                      &server2_ctx_data->npn_protocols_len);
332         TEST_check(server2_ctx != NULL);
333         SSL_CTX_set_next_protos_advertised_cb(server2_ctx, server_npn_cb,
334                                               server2_ctx_data);
335     }
336     if (extra->client.npn_protocols != NULL) {
337         parse_protos(extra->client.npn_protocols,
338                      &client_ctx_data->npn_protocols,
339                      &client_ctx_data->npn_protocols_len);
340         SSL_CTX_set_next_proto_select_cb(client_ctx, client_npn_cb,
341                                          client_ctx_data);
342     }
343 #endif
344     if (extra->server.alpn_protocols != NULL) {
345         parse_protos(extra->server.alpn_protocols,
346                      &server_ctx_data->alpn_protocols,
347                      &server_ctx_data->alpn_protocols_len);
348         SSL_CTX_set_alpn_select_cb(server_ctx, server_alpn_cb, server_ctx_data);
349     }
350     if (extra->server2.alpn_protocols != NULL) {
351         TEST_check(server2_ctx != NULL);
352         parse_protos(extra->server2.alpn_protocols,
353                      &server2_ctx_data->alpn_protocols,
354                      &server2_ctx_data->alpn_protocols_len);
355         SSL_CTX_set_alpn_select_cb(server2_ctx, server_alpn_cb, server2_ctx_data);
356     }
357     if (extra->client.alpn_protocols != NULL) {
358         unsigned char *alpn_protos = NULL;
359         size_t alpn_protos_len;
360         parse_protos(extra->client.alpn_protocols,
361                      &alpn_protos, &alpn_protos_len);
362         /* Reversed return value convention... */
363         TEST_check(SSL_CTX_set_alpn_protos(client_ctx, alpn_protos,
364                                            alpn_protos_len) == 0);
365         OPENSSL_free(alpn_protos);
366     }
367
368     /*
369      * Use fixed session ticket keys so that we can decrypt a ticket created with
370      * one CTX in another CTX. Don't address server2 for the moment.
371      */
372     ticket_key_len = SSL_CTX_set_tlsext_ticket_keys(server_ctx, NULL, 0);
373     ticket_keys = OPENSSL_zalloc(ticket_key_len);
374     TEST_check(ticket_keys != NULL);
375     TEST_check(SSL_CTX_set_tlsext_ticket_keys(server_ctx, ticket_keys,
376                                               ticket_key_len) == 1);
377     OPENSSL_free(ticket_keys);
378
379     /* The default log list includes EC keys, so CT can't work without EC. */
380 #if !defined(OPENSSL_NO_CT) && !defined(OPENSSL_NO_EC)
381     TEST_check(SSL_CTX_set_default_ctlog_list_file(client_ctx));
382     switch (extra->client.ct_validation) {
383     case SSL_TEST_CT_VALIDATION_PERMISSIVE:
384         TEST_check(SSL_CTX_enable_ct(client_ctx, SSL_CT_VALIDATION_PERMISSIVE));
385         break;
386     case SSL_TEST_CT_VALIDATION_STRICT:
387         TEST_check(SSL_CTX_enable_ct(client_ctx, SSL_CT_VALIDATION_STRICT));
388         break;
389     case SSL_TEST_CT_VALIDATION_NONE:
390         break;
391     }
392 #endif
393 }
394
395 /* Configure per-SSL callbacks and other properties. */
396 static void configure_handshake_ssl(SSL *server, SSL *client,
397                                     const SSL_TEST_EXTRA_CONF *extra)
398 {
399     if (extra->client.servername != SSL_TEST_SERVERNAME_NONE)
400         SSL_set_tlsext_host_name(client,
401                                  ssl_servername_name(extra->client.servername));
402 }
403
404 /* The status for each connection phase. */
405 typedef enum {
406     PEER_SUCCESS,
407     PEER_RETRY,
408     PEER_ERROR
409 } peer_status_t;
410
411 /* An SSL object and associated read-write buffers. */
412 typedef struct peer_st {
413     SSL *ssl;
414     /* Buffer lengths are int to match the SSL read/write API. */
415     unsigned char *write_buf;
416     int write_buf_len;
417     unsigned char *read_buf;
418     int read_buf_len;
419     int bytes_to_write;
420     int bytes_to_read;
421     peer_status_t status;
422 } PEER;
423
424 static void create_peer(PEER *peer, SSL_CTX *ctx)
425 {
426     static const int peer_buffer_size = 64 * 1024;
427
428     peer->ssl = SSL_new(ctx);
429     TEST_check(peer->ssl != NULL);
430     peer->write_buf = OPENSSL_zalloc(peer_buffer_size);
431     TEST_check(peer->write_buf != NULL);
432     peer->read_buf = OPENSSL_zalloc(peer_buffer_size);
433     TEST_check(peer->read_buf != NULL);
434     peer->write_buf_len = peer->read_buf_len = peer_buffer_size;
435 }
436
437 static void peer_free_data(PEER *peer)
438 {
439     SSL_free(peer->ssl);
440     OPENSSL_free(peer->write_buf);
441     OPENSSL_free(peer->read_buf);
442 }
443
444 /*
445  * Note that we could do the handshake transparently under an SSL_write,
446  * but separating the steps is more helpful for debugging test failures.
447  */
448 static void do_handshake_step(PEER *peer)
449 {
450     int ret;
451
452     TEST_check(peer->status == PEER_RETRY);
453     ret = SSL_do_handshake(peer->ssl);
454
455     if (ret == 1) {
456         peer->status = PEER_SUCCESS;
457     } else if (ret == 0) {
458         peer->status = PEER_ERROR;
459     } else {
460         int error = SSL_get_error(peer->ssl, ret);
461         /* Memory bios should never block with SSL_ERROR_WANT_WRITE. */
462         if (error != SSL_ERROR_WANT_READ)
463             peer->status = PEER_ERROR;
464     }
465 }
466
467 /*-
468  * Send/receive some application data. The read-write sequence is
469  * Peer A: (R) W - first read will yield no data
470  * Peer B:  R  W
471  * ...
472  * Peer A:  R  W
473  * Peer B:  R  W
474  * Peer A:  R
475  */
476 static void do_app_data_step(PEER *peer)
477 {
478     int ret = 1, write_bytes;
479
480     TEST_check(peer->status == PEER_RETRY);
481
482     /* We read everything available... */
483     while (ret > 0 && peer->bytes_to_read) {
484         ret = SSL_read(peer->ssl, peer->read_buf, peer->read_buf_len);
485         if (ret > 0) {
486             TEST_check(ret <= peer->bytes_to_read);
487             peer->bytes_to_read -= ret;
488         } else if (ret == 0) {
489             peer->status = PEER_ERROR;
490             return;
491         } else {
492             int error = SSL_get_error(peer->ssl, ret);
493             if (error != SSL_ERROR_WANT_READ) {
494                 peer->status = PEER_ERROR;
495                 return;
496             } /* Else continue with write. */
497         }
498     }
499
500     /* ... but we only write one write-buffer-full of data. */
501     write_bytes = peer->bytes_to_write < peer->write_buf_len ? peer->bytes_to_write :
502         peer->write_buf_len;
503     if (write_bytes) {
504         ret = SSL_write(peer->ssl, peer->write_buf, write_bytes);
505         if (ret > 0) {
506             /* SSL_write will only succeed with a complete write. */
507             TEST_check(ret == write_bytes);
508             peer->bytes_to_write -= ret;
509         } else {
510             /*
511              * We should perhaps check for SSL_ERROR_WANT_READ/WRITE here
512              * but this doesn't yet occur with current app data sizes.
513              */
514             peer->status = PEER_ERROR;
515             return;
516         }
517     }
518
519     /*
520      * We could simply finish when there was nothing to read, and we have
521      * nothing left to write. But keeping track of the expected number of bytes
522      * to read gives us somewhat better guarantees that all data sent is in fact
523      * received.
524      */
525     if (!peer->bytes_to_write && !peer->bytes_to_read) {
526         peer->status = PEER_SUCCESS;
527     }
528 }
529
530 /*
531  * RFC 5246 says:
532  *
533  * Note that as of TLS 1.1,
534  *     failure to properly close a connection no longer requires that a
535  *     session not be resumed.  This is a change from TLS 1.0 to conform
536  *     with widespread implementation practice.
537  *
538  * However,
539  * (a) OpenSSL requires that a connection be shutdown for all protocol versions.
540  * (b) We test lower versions, too.
541  * So we just implement shutdown. We do a full bidirectional shutdown so that we
542  * can compare sent and received close_notify alerts and get some test coverage
543  * for SSL_shutdown as a bonus.
544  */
545 static void do_shutdown_step(PEER *peer)
546 {
547     int ret;
548
549     TEST_check(peer->status == PEER_RETRY);
550     ret = SSL_shutdown(peer->ssl);
551
552     if (ret == 1) {
553         peer->status = PEER_SUCCESS;
554     } else if (ret < 0) { /* On 0, we retry. */
555         int error = SSL_get_error(peer->ssl, ret);
556         /* Memory bios should never block with SSL_ERROR_WANT_WRITE. */
557         if (error != SSL_ERROR_WANT_READ)
558             peer->status = PEER_ERROR;
559     }
560 }
561
562 typedef enum {
563     HANDSHAKE,
564     APPLICATION_DATA,
565     SHUTDOWN,
566     CONNECTION_DONE
567 } connect_phase_t;
568
569 static connect_phase_t next_phase(connect_phase_t phase)
570 {
571     switch (phase) {
572     case HANDSHAKE:
573         return APPLICATION_DATA;
574     case APPLICATION_DATA:
575         return SHUTDOWN;
576     case SHUTDOWN:
577         return CONNECTION_DONE;
578     default:
579         TEST_check(0); /* Should never call next_phase when done. */
580     }
581 }
582
583 static void do_connect_step(PEER *peer, connect_phase_t phase)
584 {
585     switch (phase) {
586     case HANDSHAKE:
587         do_handshake_step(peer);
588         break;
589     case APPLICATION_DATA:
590         do_app_data_step(peer);
591         break;
592     case SHUTDOWN:
593         do_shutdown_step(peer);
594         break;
595     default:
596         TEST_check(0);
597     }
598 }
599
600 typedef enum {
601     /* Both parties succeeded. */
602     HANDSHAKE_SUCCESS,
603     /* Client errored. */
604     CLIENT_ERROR,
605     /* Server errored. */
606     SERVER_ERROR,
607     /* Peers are in inconsistent state. */
608     INTERNAL_ERROR,
609     /* One or both peers not done. */
610     HANDSHAKE_RETRY
611 } handshake_status_t;
612
613 /*
614  * Determine the handshake outcome.
615  * last_status: the status of the peer to have acted last.
616  * previous_status: the status of the peer that didn't act last.
617  * client_spoke_last: 1 if the client went last.
618  */
619 static handshake_status_t handshake_status(peer_status_t last_status,
620                                            peer_status_t previous_status,
621                                            int client_spoke_last)
622 {
623     switch (last_status) {
624     case PEER_SUCCESS:
625         switch (previous_status) {
626         case PEER_SUCCESS:
627             /* Both succeeded. */
628             return HANDSHAKE_SUCCESS;
629         case PEER_RETRY:
630             /* Let the first peer finish. */
631             return HANDSHAKE_RETRY;
632         case PEER_ERROR:
633             /*
634              * Second peer succeeded despite the fact that the first peer
635              * already errored. This shouldn't happen.
636              */
637             return INTERNAL_ERROR;
638         }
639
640     case PEER_RETRY:
641         if (previous_status == PEER_RETRY) {
642             /* Neither peer is done. */
643             return HANDSHAKE_RETRY;
644         } else {
645             /*
646              * Deadlock: second peer is waiting for more input while first
647              * peer thinks they're done (no more input is coming).
648              */
649             return INTERNAL_ERROR;
650         }
651     case PEER_ERROR:
652         switch (previous_status) {
653         case PEER_SUCCESS:
654             /*
655              * First peer succeeded but second peer errored.
656              * TODO(emilia): we should be able to continue here (with some
657              * application data?) to ensure the first peer receives the
658              * alert / close_notify.
659              * (No tests currently exercise this branch.)
660              */
661             return client_spoke_last ? CLIENT_ERROR : SERVER_ERROR;
662         case PEER_RETRY:
663             /* We errored; let the peer finish. */
664             return HANDSHAKE_RETRY;
665         case PEER_ERROR:
666             /* Both peers errored. Return the one that errored first. */
667             return client_spoke_last ? SERVER_ERROR : CLIENT_ERROR;
668         }
669     }
670     /* Control should never reach here. */
671     return INTERNAL_ERROR;
672 }
673
674 /* Convert unsigned char buf's that shouldn't contain any NUL-bytes to char. */
675 static char *dup_str(const unsigned char *in, size_t len)
676 {
677     char *ret;
678
679     if(len == 0)
680         return NULL;
681
682     /* Assert that the string does not contain NUL-bytes. */
683     TEST_check(OPENSSL_strnlen((const char*)(in), len) == len);
684     ret = OPENSSL_strndup((const char*)(in), len);
685     TEST_check(ret != NULL);
686     return ret;
687 }
688
689 static HANDSHAKE_RESULT *do_handshake_internal(
690     SSL_CTX *server_ctx, SSL_CTX *server2_ctx, SSL_CTX *client_ctx,
691     const SSL_TEST_EXTRA_CONF *extra, int app_data_size,
692     SSL_SESSION *session_in, SSL_SESSION **session_out)
693 {
694     PEER server, client;
695     BIO *client_to_server, *server_to_client;
696     HANDSHAKE_EX_DATA server_ex_data, client_ex_data;
697     CTX_DATA client_ctx_data, server_ctx_data, server2_ctx_data;
698     HANDSHAKE_RESULT *ret = HANDSHAKE_RESULT_new();
699     int client_turn = 1;
700     connect_phase_t phase = HANDSHAKE;
701     handshake_status_t status = HANDSHAKE_RETRY;
702     const unsigned char* tick = NULL;
703     size_t tick_len = 0;
704     SSL_SESSION* sess = NULL;
705     const unsigned char *proto = NULL;
706     /* API dictates unsigned int rather than size_t. */
707     unsigned int proto_len = 0;
708
709     memset(&server_ctx_data, 0, sizeof(server_ctx_data));
710     memset(&server2_ctx_data, 0, sizeof(server2_ctx_data));
711     memset(&client_ctx_data, 0, sizeof(client_ctx_data));
712     memset(&server, 0, sizeof(server));
713     memset(&client, 0, sizeof(client));
714
715     configure_handshake_ctx(server_ctx, server2_ctx, client_ctx, extra,
716                             &server_ctx_data, &server2_ctx_data, &client_ctx_data);
717
718     /* Setup SSL and buffers; additional configuration happens below. */
719     create_peer(&server, server_ctx);
720     create_peer(&client, client_ctx);
721
722     server.bytes_to_write = client.bytes_to_read = app_data_size;
723     client.bytes_to_write = server.bytes_to_read = app_data_size;
724
725     configure_handshake_ssl(server.ssl, client.ssl, extra);
726     if (session_in != NULL) {
727         /* In case we're testing resumption without tickets. */
728         TEST_check(SSL_CTX_add_session(server_ctx, session_in));
729         TEST_check(SSL_set_session(client.ssl, session_in));
730     }
731
732     memset(&server_ex_data, 0, sizeof(server_ex_data));
733     memset(&client_ex_data, 0, sizeof(client_ex_data));
734
735     ret->result = SSL_TEST_INTERNAL_ERROR;
736
737     client_to_server = BIO_new(BIO_s_mem());
738     server_to_client = BIO_new(BIO_s_mem());
739
740     TEST_check(client_to_server != NULL);
741     TEST_check(server_to_client != NULL);
742
743     /* Non-blocking bio. */
744     BIO_set_nbio(client_to_server, 1);
745     BIO_set_nbio(server_to_client, 1);
746
747     SSL_set_connect_state(client.ssl);
748     SSL_set_accept_state(server.ssl);
749
750     /* The bios are now owned by the SSL object. */
751     SSL_set_bio(client.ssl, server_to_client, client_to_server);
752     TEST_check(BIO_up_ref(server_to_client) > 0);
753     TEST_check(BIO_up_ref(client_to_server) > 0);
754     SSL_set_bio(server.ssl, client_to_server, server_to_client);
755
756     ex_data_idx = SSL_get_ex_new_index(0, "ex data", NULL, NULL, NULL);
757     TEST_check(ex_data_idx >= 0);
758
759     TEST_check(SSL_set_ex_data(server.ssl, ex_data_idx, &server_ex_data) == 1);
760     TEST_check(SSL_set_ex_data(client.ssl, ex_data_idx, &client_ex_data) == 1);
761
762     SSL_set_info_callback(server.ssl, &info_cb);
763     SSL_set_info_callback(client.ssl, &info_cb);
764
765     client.status = server.status = PEER_RETRY;
766
767     /*
768      * Half-duplex handshake loop.
769      * Client and server speak to each other synchronously in the same process.
770      * We use non-blocking BIOs, so whenever one peer blocks for read, it
771      * returns PEER_RETRY to indicate that it's the other peer's turn to write.
772      * The handshake succeeds once both peers have succeeded. If one peer
773      * errors out, we also let the other peer retry (and presumably fail).
774      */
775     for(;;) {
776         if (client_turn) {
777             do_connect_step(&client, phase);
778             status = handshake_status(client.status, server.status,
779                                       1 /* client went last */);
780         } else {
781             do_connect_step(&server, phase);
782             status = handshake_status(server.status, client.status,
783                                       0 /* server went last */);
784         }
785
786         switch (status) {
787         case HANDSHAKE_SUCCESS:
788             phase = next_phase(phase);
789             if (phase == CONNECTION_DONE) {
790                 ret->result = SSL_TEST_SUCCESS;
791                 goto err;
792             } else {
793                 client.status = server.status = PEER_RETRY;
794                 /*
795                  * For now, client starts each phase. Since each phase is
796                  * started separately, we can later control this more
797                  * precisely, for example, to test client-initiated and
798                  * server-initiated shutdown.
799                  */
800                 client_turn = 1;
801                 break;
802             }
803         case CLIENT_ERROR:
804             ret->result = SSL_TEST_CLIENT_FAIL;
805             goto err;
806         case SERVER_ERROR:
807             ret->result = SSL_TEST_SERVER_FAIL;
808             goto err;
809         case INTERNAL_ERROR:
810             ret->result = SSL_TEST_INTERNAL_ERROR;
811             goto err;
812         case HANDSHAKE_RETRY:
813             /* Continue. */
814             client_turn ^= 1;
815             break;
816         }
817     }
818  err:
819     ret->server_alert_sent = server_ex_data.alert_sent;
820     ret->server_alert_received = client_ex_data.alert_received;
821     ret->client_alert_sent = client_ex_data.alert_sent;
822     ret->client_alert_received = server_ex_data.alert_received;
823     ret->server_protocol = SSL_version(server.ssl);
824     ret->client_protocol = SSL_version(client.ssl);
825     ret->servername = server_ex_data.servername;
826     if ((sess = SSL_get0_session(client.ssl)) != NULL)
827         SSL_SESSION_get0_ticket(sess, &tick, &tick_len);
828     if (tick == NULL || tick_len == 0)
829         ret->session_ticket = SSL_TEST_SESSION_TICKET_NO;
830     else
831         ret->session_ticket = SSL_TEST_SESSION_TICKET_YES;
832     ret->session_ticket_do_not_call = server_ex_data.session_ticket_do_not_call;
833
834 #ifndef OPENSSL_NO_NEXTPROTONEG
835     SSL_get0_next_proto_negotiated(client.ssl, &proto, &proto_len);
836     ret->client_npn_negotiated = dup_str(proto, proto_len);
837
838     SSL_get0_next_proto_negotiated(server.ssl, &proto, &proto_len);
839     ret->server_npn_negotiated = dup_str(proto, proto_len);
840 #endif
841
842     SSL_get0_alpn_selected(client.ssl, &proto, &proto_len);
843     ret->client_alpn_negotiated = dup_str(proto, proto_len);
844
845     SSL_get0_alpn_selected(server.ssl, &proto, &proto_len);
846     ret->server_alpn_negotiated = dup_str(proto, proto_len);
847
848     ret->client_resumed = SSL_session_reused(client.ssl);
849     ret->server_resumed = SSL_session_reused(server.ssl);
850
851     if (session_out != NULL)
852         *session_out = SSL_get1_session(client.ssl);
853
854     ctx_data_free_data(&server_ctx_data);
855     ctx_data_free_data(&server2_ctx_data);
856     ctx_data_free_data(&client_ctx_data);
857
858     peer_free_data(&server);
859     peer_free_data(&client);
860     return ret;
861 }
862
863 HANDSHAKE_RESULT *do_handshake(SSL_CTX *server_ctx, SSL_CTX *server2_ctx,
864                                SSL_CTX *client_ctx, SSL_CTX *resume_server_ctx,
865                                SSL_CTX *resume_client_ctx,
866                                const SSL_TEST_CTX *test_ctx)
867 {
868     HANDSHAKE_RESULT *result;
869     SSL_SESSION *session = NULL;
870
871     result = do_handshake_internal(server_ctx, server2_ctx, client_ctx,
872                                    &test_ctx->extra, test_ctx->app_data_size,
873                                    NULL, &session);
874     if (test_ctx->handshake_mode == SSL_TEST_HANDSHAKE_SIMPLE)
875         goto end;
876
877     TEST_check(test_ctx->handshake_mode == SSL_TEST_HANDSHAKE_RESUME);
878
879     if (result->result != SSL_TEST_SUCCESS) {
880         result->result = SSL_TEST_FIRST_HANDSHAKE_FAILED;
881         goto end;
882     }
883
884     HANDSHAKE_RESULT_free(result);
885     /* We don't support SNI on second handshake yet, so server2_ctx is NULL. */
886     result = do_handshake_internal(resume_server_ctx, NULL, resume_client_ctx,
887                                    &test_ctx->resume_extra, test_ctx->app_data_size,
888                                    session, NULL);
889  end:
890     SSL_SESSION_free(session);
891     return result;
892 }