ssl/statem/statem.c

   1 /*
   2  * Copyright 2015-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 "internal/cryptlib.h"
  11 #include <openssl/rand.h>
  12 #include "../ssl_locl.h"
  13 #include "statem_locl.h"
  14 #include <assert.h>
  15
  16 /*
  17  * This file implements the SSL/TLS/DTLS state machines.
  18  *
  19  * There are two primary state machines:
  20  *
  21  * 1) Message flow state machine
  22  * 2) Handshake state machine
  23  *
  24  * The Message flow state machine controls the reading and sending of messages
  25  * including handling of non-blocking IO events, flushing of the underlying
  26  * write BIO, handling unexpected messages, etc. It is itself broken into two
  27  * separate sub-state machines which control reading and writing respectively.
  28  *
  29  * The Handshake state machine keeps track of the current SSL/TLS handshake
  30  * state. Transitions of the handshake state are the result of events that
  31  * occur within the Message flow state machine.
  32  *
  33  * Overall it looks like this:
  34  *
  35  * ---------------------------------------------            -------------------
  36  * |                                           |            |                 |
  37  * | Message flow state machine                |            |                 |
  38  * |                                           |            |                 |
  39  * | -------------------- -------------------- | Transition | Handshake state |
  40  * | | MSG_FLOW_READING | | MSG_FLOW_WRITING | | Event      | machine         |
  41  * | | sub-state        | | sub-state        | |----------->|                 |
  42  * | | machine for      | | machine for      | |            |                 |
  43  * | | reading messages | | writing messages | |            |                 |
  44  * | -------------------- -------------------- |            |                 |
  45  * |                                           |            |                 |
  46  * ---------------------------------------------            -------------------
  47  *
  48  */
  49
  50 /* Sub state machine return values */
  51 typedef enum {
  52     /* Something bad happened or NBIO */
  53     SUB_STATE_ERROR,
  54     /* Sub state finished go to the next sub state */
  55     SUB_STATE_FINISHED,
  56     /* Sub state finished and handshake was completed */
  57     SUB_STATE_END_HANDSHAKE
  58 } SUB_STATE_RETURN;
  59
  60 static int state_machine(SSL *s, int server);
  61 static void init_read_state_machine(SSL *s);
  62 static SUB_STATE_RETURN read_state_machine(SSL *s);
  63 static void init_write_state_machine(SSL *s);
  64 static SUB_STATE_RETURN write_state_machine(SSL *s);
  65
  66 OSSL_HANDSHAKE_STATE SSL_get_state(const SSL *ssl)
  67 {
  68     return ssl->statem.hand_state;
  69 }
  70
  71 int SSL_in_init(const SSL *s)
  72 {
  73     return s->statem.in_init;
  74 }
  75
  76 int SSL_is_init_finished(const SSL *s)
  77 {
  78     return !(s->statem.in_init) && (s->statem.hand_state == TLS_ST_OK);
  79 }
  80
  81 int SSL_in_before(const SSL *s)
  82 {
  83     /*
  84      * Historically being "in before" meant before anything had happened. In the
  85      * current code though we remain in the "before" state for a while after we
  86      * have started the handshake process (e.g. as a server waiting for the
  87      * first message to arrive). There "in before" is taken to mean "in before"
  88      * and not started any handshake process yet.
  89      */
  90     return (s->statem.hand_state == TLS_ST_BEFORE)
  91         && (s->statem.state == MSG_FLOW_UNINITED);
  92 }
  93
  94 /*
  95  * Clear the state machine state and reset back to MSG_FLOW_UNINITED
  96  */
  97 void ossl_statem_clear(SSL *s)
  98 {
  99     s->statem.state = MSG_FLOW_UNINITED;
 100     s->statem.hand_state = TLS_ST_BEFORE;
 101     s->statem.in_init = 1;
 102     s->statem.no_cert_verify = 0;
 103 }
 104
 105 /*
 106  * Set the state machine up ready for a renegotiation handshake
 107  */
 108 void ossl_statem_set_renegotiate(SSL *s)
 109 {
 110     s->statem.in_init = 1;
 111     s->statem.request_state = TLS_ST_SW_HELLO_REQ;
 112 }
 113
 114 /*
 115  * Put the state machine into an error state and send an alert if appropriate.
 116  * This is a permanent error for the current connection.
 117  */
 118 void ossl_statem_fatal(SSL *s, int al, int func, int reason, const char *file,
 119                        int line)
 120 {
 121     ERR_put_error(ERR_LIB_SSL, func, reason, file, line);
 122     /* We shouldn't call SSLfatal() twice. Once is enough */
 123     if (s->statem.in_init && s->statem.state == MSG_FLOW_ERROR)
 124       return;
 125     s->statem.in_init = 1;
 126     s->statem.state = MSG_FLOW_ERROR;
 127     if (al != SSL_AD_NO_ALERT
 128             && s->statem.enc_write_state != ENC_WRITE_STATE_INVALID)
 129         ssl3_send_alert(s, SSL3_AL_FATAL, al);
 130 }
 131
 132 /*
 133  * This macro should only be called if we are already expecting to be in
 134  * a fatal error state. We verify that we are, and set it if not (this would
 135  * indicate a bug).
 136  */
 137 #define check_fatal(s, f) \
 138     do { \
 139         if (!ossl_assert((s)->statem.in_init \
 140                          && (s)->statem.state == MSG_FLOW_ERROR)) \
 141             SSLfatal(s, SSL_AD_INTERNAL_ERROR, (f), \
 142                      SSL_R_MISSING_FATAL); \
 143     } while (0)
 144
 145 /*
 146  * Discover whether the current connection is in the error state.
 147  *
 148  * Valid return values are:
 149  *   1: Yes
 150  *   0: No
 151  */
 152 int ossl_statem_in_error(const SSL *s)
 153 {
 154     if (s->statem.state == MSG_FLOW_ERROR)
 155         return 1;
 156
 157     return 0;
 158 }
 159
 160 void ossl_statem_set_in_init(SSL *s, int init)
 161 {
 162     s->statem.in_init = init;
 163 }
 164
 165 int ossl_statem_get_in_handshake(SSL *s)
 166 {
 167     return s->statem.in_handshake;
 168 }
 169
 170 void ossl_statem_set_in_handshake(SSL *s, int inhand)
 171 {
 172     if (inhand)
 173         s->statem.in_handshake++;
 174     else
 175         s->statem.in_handshake--;
 176 }
 177
 178 /* Are we in a sensible state to skip over unreadable early data? */
 179 int ossl_statem_skip_early_data(SSL *s)
 180 {
 181     if (s->ext.early_data != SSL_EARLY_DATA_REJECTED)
 182         return 0;
 183
 184     if (!s->server
 185             || s->statem.hand_state != TLS_ST_EARLY_DATA
 186             || s->hello_retry_request == SSL_HRR_COMPLETE)
 187         return 0;
 188
 189     return 1;
 190 }
 191
 192 /*
 193  * Called when we are in SSL_read*(), SSL_write*(), or SSL_accept()
 194  * /SSL_connect()/SSL_do_handshake(). Used to test whether we are in an early
 195  * data state and whether we should attempt to move the handshake on if so.
 196  * |sending| is 1 if we are attempting to send data (SSL_write*()), 0 if we are
 197  * attempting to read data (SSL_read*()), or -1 if we are in SSL_do_handshake()
 198  * or similar.
 199  */
 200 void ossl_statem_check_finish_init(SSL *s, int sending)
 201 {
 202     if (sending == -1) {
 203         if (s->statem.hand_state == TLS_ST_PENDING_EARLY_DATA_END
 204                 || s->statem.hand_state == TLS_ST_EARLY_DATA) {
 205             ossl_statem_set_in_init(s, 1);
 206             if (s->early_data_state == SSL_EARLY_DATA_WRITE_RETRY) {
 207                 /*
 208                  * SSL_connect() or SSL_do_handshake() has been called directly.
 209                  * We don't allow any more writing of early data.
 210                  */
 211                 s->early_data_state = SSL_EARLY_DATA_FINISHED_WRITING;
 212             }
 213         }
 214     } else if (!s->server) {
 215         if ((sending && (s->statem.hand_state == TLS_ST_PENDING_EARLY_DATA_END
 216                       || s->statem.hand_state == TLS_ST_EARLY_DATA)
 217                   && s->early_data_state != SSL_EARLY_DATA_WRITING)
 218                 || (!sending && s->statem.hand_state == TLS_ST_EARLY_DATA)) {
 219             ossl_statem_set_in_init(s, 1);
 220             /*
 221              * SSL_write() has been called directly. We don't allow any more
 222              * writing of early data.
 223              */
 224             if (sending && s->early_data_state == SSL_EARLY_DATA_WRITE_RETRY)
 225                 s->early_data_state = SSL_EARLY_DATA_FINISHED_WRITING;
 226         }
 227     } else {
 228         if (s->early_data_state == SSL_EARLY_DATA_FINISHED_READING
 229                 && s->statem.hand_state == TLS_ST_EARLY_DATA)
 230             ossl_statem_set_in_init(s, 1);
 231     }
 232 }
 233
 234 void ossl_statem_set_hello_verify_done(SSL *s)
 235 {
 236     s->statem.state = MSG_FLOW_UNINITED;
 237     s->statem.in_init = 1;
 238     /*
 239      * This will get reset (briefly) back to TLS_ST_BEFORE when we enter
 240      * state_machine() because |state| is MSG_FLOW_UNINITED, but until then any
 241      * calls to SSL_in_before() will return false. Also calls to
 242      * SSL_state_string() and SSL_state_string_long() will return something
 243      * sensible.
 244      */
 245     s->statem.hand_state = TLS_ST_SR_CLNT_HELLO;
 246 }
 247
 248 int ossl_statem_connect(SSL *s)
 249 {
 250     return state_machine(s, 0);
 251 }
 252
 253 int ossl_statem_accept(SSL *s)
 254 {
 255     return state_machine(s, 1);
 256 }
 257
 258 typedef void (*info_cb) (const SSL *, int, int);
 259
 260 static info_cb get_callback(SSL *s)
 261 {
 262     if (s->info_callback != NULL)
 263         return s->info_callback;
 264     else if (s->ctx->info_callback != NULL)
 265         return s->ctx->info_callback;
 266
 267     return NULL;
 268 }
 269
 270 /*
 271  * The main message flow state machine. We start in the MSG_FLOW_UNINITED or
 272  * MSG_FLOW_FINISHED state and finish in MSG_FLOW_FINISHED. Valid states and
 273  * transitions are as follows:
 274  *
 275  * MSG_FLOW_UNINITED     MSG_FLOW_FINISHED
 276  *        |                       |
 277  *        +-----------------------+
 278  *        v
 279  * MSG_FLOW_WRITING <---> MSG_FLOW_READING
 280  *        |
 281  *        V
 282  * MSG_FLOW_FINISHED
 283  *        |
 284  *        V
 285  *    [SUCCESS]
 286  *
 287  * We may exit at any point due to an error or NBIO event. If an NBIO event
 288  * occurs then we restart at the point we left off when we are recalled.
 289  * MSG_FLOW_WRITING and MSG_FLOW_READING have sub-state machines associated with them.
 290  *
 291  * In addition to the above there is also the MSG_FLOW_ERROR state. We can move
 292  * into that state at any point in the event that an irrecoverable error occurs.
 293  *
 294  * Valid return values are:
 295  *   1: Success
 296  * <=0: NBIO or error
 297  */
 298 static int state_machine(SSL *s, int server)
 299 {
 300     BUF_MEM *buf = NULL;
 301     void (*cb) (const SSL *ssl, int type, int val) = NULL;
 302     OSSL_STATEM *st = &s->statem;
 303     int ret = -1;
 304     int ssret;
 305
 306     if (st->state == MSG_FLOW_ERROR) {
 307         /* Shouldn't have been called if we're already in the error state */
 308         return -1;
 309     }
 310
 311     ERR_clear_error();
 312     clear_sys_error();
 313
 314     cb = get_callback(s);
 315
 316     st->in_handshake++;
 317     if (!SSL_in_init(s) || SSL_in_before(s)) {
 318         /*
 319          * If we are stateless then we already called SSL_clear() - don't do
 320          * it again and clear the STATELESS flag itself.
 321          */
 322         if ((s->s3->flags & TLS1_FLAGS_STATELESS) == 0 && !SSL_clear(s))
 323             return -1;
 324     }
 325 #ifndef OPENSSL_NO_SCTP
 326     if (SSL_IS_DTLS(s) && BIO_dgram_is_sctp(SSL_get_wbio(s))) {
 327         /*
 328          * Notify SCTP BIO socket to enter handshake mode and prevent stream
 329          * identifier other than 0.
 330          */
 331         BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE,
 332                  st->in_handshake, NULL);
 333     }
 334 #endif
 335
 336     /* Initialise state machine */
 337     if (st->state == MSG_FLOW_UNINITED
 338             || st->state == MSG_FLOW_FINISHED) {
 339         if (st->state == MSG_FLOW_UNINITED) {
 340             st->hand_state = TLS_ST_BEFORE;
 341             st->request_state = TLS_ST_BEFORE;
 342         }
 343
 344         s->server = server;
 345         if (cb != NULL)
 346             cb(s, SSL_CB_HANDSHAKE_START, 1);
 347
 348         /*
 349          * Fatal errors in this block don't send an alert because we have
 350          * failed to even initialise properly. Sending an alert is probably
 351          * doomed to failure.
 352          */
 353
 354         if (SSL_IS_DTLS(s)) {
 355             if ((s->version & 0xff00) != (DTLS1_VERSION & 0xff00) &&
 356                 (server || (s->version & 0xff00) != (DTLS1_BAD_VER & 0xff00))) {
 357                 SSLfatal(s, SSL_AD_NO_ALERT, SSL_F_STATE_MACHINE,
 358                          ERR_R_INTERNAL_ERROR);
 359                 goto end;
 360             }
 361         } else {
 362             if ((s->version >> 8) != SSL3_VERSION_MAJOR) {
 363                 SSLfatal(s, SSL_AD_NO_ALERT, SSL_F_STATE_MACHINE,
 364                          ERR_R_INTERNAL_ERROR);
 365                 goto end;
 366             }
 367         }
 368
 369         if (!ssl_security(s, SSL_SECOP_VERSION, 0, s->version, NULL)) {
 370             SSLfatal(s, SSL_AD_NO_ALERT, SSL_F_STATE_MACHINE,
 371                      ERR_R_INTERNAL_ERROR);
 372             goto end;
 373         }
 374
 375         if (s->init_buf == NULL) {
 376             if ((buf = BUF_MEM_new()) == NULL) {
 377                 SSLfatal(s, SSL_AD_NO_ALERT, SSL_F_STATE_MACHINE,
 378                          ERR_R_INTERNAL_ERROR);
 379                 goto end;
 380             }
 381             if (!BUF_MEM_grow(buf, SSL3_RT_MAX_PLAIN_LENGTH)) {
 382                 SSLfatal(s, SSL_AD_NO_ALERT, SSL_F_STATE_MACHINE,
 383                          ERR_R_INTERNAL_ERROR);
 384                 goto end;
 385             }
 386             s->init_buf = buf;
 387             buf = NULL;
 388         }
 389
 390         if (!ssl3_setup_buffers(s)) {
 391             SSLfatal(s, SSL_AD_NO_ALERT, SSL_F_STATE_MACHINE,
 392                      ERR_R_INTERNAL_ERROR);
 393             goto end;
 394         }
 395         s->init_num = 0;
 396
 397         /*
 398          * Should have been reset by tls_process_finished, too.
 399          */
 400         s->s3->change_cipher_spec = 0;
 401
 402         /*
 403          * Ok, we now need to push on a buffering BIO ...but not with
 404          * SCTP
 405          */
 406 #ifndef OPENSSL_NO_SCTP
 407         if (!SSL_IS_DTLS(s) || !BIO_dgram_is_sctp(SSL_get_wbio(s)))
 408 #endif
 409             if (!ssl_init_wbio_buffer(s)) {
 410                 SSLfatal(s, SSL_AD_NO_ALERT, SSL_F_STATE_MACHINE,
 411                          ERR_R_INTERNAL_ERROR);
 412                 goto end;
 413             }
 414
 415         if ((SSL_in_before(s))
 416                 || s->renegotiate) {
 417             if (!tls_setup_handshake(s)) {
 418                 /* SSLfatal() already called */
 419                 goto end;
 420             }
 421
 422             if (SSL_IS_FIRST_HANDSHAKE(s))
 423                 st->read_state_first_init = 1;
 424         }
 425
 426         st->state = MSG_FLOW_WRITING;
 427         init_write_state_machine(s);
 428     }
 429
 430     while (st->state != MSG_FLOW_FINISHED) {
 431         if (st->state == MSG_FLOW_READING) {
 432             ssret = read_state_machine(s);
 433             if (ssret == SUB_STATE_FINISHED) {
 434                 st->state = MSG_FLOW_WRITING;
 435                 init_write_state_machine(s);
 436             } else {
 437                 /* NBIO or error */
 438                 goto end;
 439             }
 440         } else if (st->state == MSG_FLOW_WRITING) {
 441             ssret = write_state_machine(s);
 442             if (ssret == SUB_STATE_FINISHED) {
 443                 st->state = MSG_FLOW_READING;
 444                 init_read_state_machine(s);
 445             } else if (ssret == SUB_STATE_END_HANDSHAKE) {
 446                 st->state = MSG_FLOW_FINISHED;
 447             } else {
 448                 /* NBIO or error */
 449                 goto end;
 450             }
 451         } else {
 452             /* Error */
 453             check_fatal(s, SSL_F_STATE_MACHINE);
 454             SSLerr(SSL_F_STATE_MACHINE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 455             goto end;
 456         }
 457     }
 458
 459     ret = 1;
 460
 461  end:
 462     st->in_handshake--;
 463
 464 #ifndef OPENSSL_NO_SCTP
 465     if (SSL_IS_DTLS(s) && BIO_dgram_is_sctp(SSL_get_wbio(s))) {
 466         /*
 467          * Notify SCTP BIO socket to leave handshake mode and allow stream
 468          * identifier other than 0.
 469          */
 470         BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE,
 471                  st->in_handshake, NULL);
 472     }
 473 #endif
 474
 475     BUF_MEM_free(buf);
 476     if (cb != NULL) {
 477         if (server)
 478             cb(s, SSL_CB_ACCEPT_EXIT, ret);
 479         else
 480             cb(s, SSL_CB_CONNECT_EXIT, ret);
 481     }
 482     return ret;
 483 }
 484
 485 /*
 486  * Initialise the MSG_FLOW_READING sub-state machine
 487  */
 488 static void init_read_state_machine(SSL *s)
 489 {
 490     OSSL_STATEM *st = &s->statem;
 491
 492     st->read_state = READ_STATE_HEADER;
 493 }
 494
 495 static int grow_init_buf(SSL *s, size_t size) {
 496
 497     size_t msg_offset = (char *)s->init_msg - s->init_buf->data;
 498
 499     if (!BUF_MEM_grow_clean(s->init_buf, (int)size))
 500         return 0;
 501
 502     if (size < msg_offset)
 503         return 0;
 504
 505     s->init_msg = s->init_buf->data + msg_offset;
 506
 507     return 1;
 508 }
 509
 510 /*
 511  * This function implements the sub-state machine when the message flow is in
 512  * MSG_FLOW_READING. The valid sub-states and transitions are:
 513  *
 514  * READ_STATE_HEADER <--+<-------------+
 515  *        |             |              |
 516  *        v             |              |
 517  * READ_STATE_BODY -----+-->READ_STATE_POST_PROCESS
 518  *        |                            |
 519  *        +----------------------------+
 520  *        v
 521  * [SUB_STATE_FINISHED]
 522  *
 523  * READ_STATE_HEADER has the responsibility for reading in the message header
 524  * and transitioning the state of the handshake state machine.
 525  *
 526  * READ_STATE_BODY reads in the rest of the message and then subsequently
 527  * processes it.
 528  *
 529  * READ_STATE_POST_PROCESS is an optional step that may occur if some post
 530  * processing activity performed on the message may block.
 531  *
 532  * Any of the above states could result in an NBIO event occurring in which case
 533  * control returns to the calling application. When this function is recalled we
 534  * will resume in the same state where we left off.
 535  */
 536 static SUB_STATE_RETURN read_state_machine(SSL *s)
 537 {
 538     OSSL_STATEM *st = &s->statem;
 539     int ret, mt;
 540     size_t len = 0;
 541     int (*transition) (SSL *s, int mt);
 542     PACKET pkt;
 543     MSG_PROCESS_RETURN(*process_message) (SSL *s, PACKET *pkt);
 544     WORK_STATE(*post_process_message) (SSL *s, WORK_STATE wst);
 545     size_t (*max_message_size) (SSL *s);
 546     void (*cb) (const SSL *ssl, int type, int val) = NULL;
 547
 548     cb = get_callback(s);
 549
 550     if (s->server) {
 551         transition = ossl_statem_server_read_transition;
 552         process_message = ossl_statem_server_process_message;
 553         max_message_size = ossl_statem_server_max_message_size;
 554         post_process_message = ossl_statem_server_post_process_message;
 555     } else {
 556         transition = ossl_statem_client_read_transition;
 557         process_message = ossl_statem_client_process_message;
 558         max_message_size = ossl_statem_client_max_message_size;
 559         post_process_message = ossl_statem_client_post_process_message;
 560     }
 561
 562     if (st->read_state_first_init) {
 563         s->first_packet = 1;
 564         st->read_state_first_init = 0;
 565     }
 566
 567     while (1) {
 568         switch (st->read_state) {
 569         case READ_STATE_HEADER:
 570             /* Get the state the peer wants to move to */
 571             if (SSL_IS_DTLS(s)) {
 572                 /*
 573                  * In DTLS we get the whole message in one go - header and body
 574                  */
 575                 ret = dtls_get_message(s, &mt, &len);
 576             } else {
 577                 ret = tls_get_message_header(s, &mt);
 578             }
 579
 580             if (ret == 0) {
 581                 /* Could be non-blocking IO */
 582                 return SUB_STATE_ERROR;
 583             }
 584
 585             if (cb != NULL) {
 586                 /* Notify callback of an impending state change */
 587                 if (s->server)
 588                     cb(s, SSL_CB_ACCEPT_LOOP, 1);
 589                 else
 590                     cb(s, SSL_CB_CONNECT_LOOP, 1);
 591             }
 592             /*
 593              * Validate that we are allowed to move to the new state and move
 594              * to that state if so
 595              */
 596             if (!transition(s, mt))
 597                 return SUB_STATE_ERROR;
 598
 599             if (s->s3->tmp.message_size > max_message_size(s)) {
 600                 SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_READ_STATE_MACHINE,
 601                          SSL_R_EXCESSIVE_MESSAGE_SIZE);
 602                 return SUB_STATE_ERROR;
 603             }
 604
 605             /* dtls_get_message already did this */
 606             if (!SSL_IS_DTLS(s)
 607                     && s->s3->tmp.message_size > 0
 608                     && !grow_init_buf(s, s->s3->tmp.message_size
 609                                          + SSL3_HM_HEADER_LENGTH)) {
 610                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_READ_STATE_MACHINE,
 611                          ERR_R_BUF_LIB);
 612                 return SUB_STATE_ERROR;
 613             }
 614
 615             st->read_state = READ_STATE_BODY;
 616             /* Fall through */
 617
 618         case READ_STATE_BODY:
 619             if (!SSL_IS_DTLS(s)) {
 620                 /* We already got this above for DTLS */
 621                 ret = tls_get_message_body(s, &len);
 622                 if (ret == 0) {
 623                     /* Could be non-blocking IO */
 624                     return SUB_STATE_ERROR;
 625                 }
 626             }
 627
 628             s->first_packet = 0;
 629             if (!PACKET_buf_init(&pkt, s->init_msg, len)) {
 630                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_READ_STATE_MACHINE,
 631                          ERR_R_INTERNAL_ERROR);
 632                 return SUB_STATE_ERROR;
 633             }
 634             ret = process_message(s, &pkt);
 635
 636             /* Discard the packet data */
 637             s->init_num = 0;
 638
 639             switch (ret) {
 640             case MSG_PROCESS_ERROR:
 641                 check_fatal(s, SSL_F_READ_STATE_MACHINE);
 642                 return SUB_STATE_ERROR;
 643
 644             case MSG_PROCESS_FINISHED_READING:
 645                 if (SSL_IS_DTLS(s)) {
 646                     dtls1_stop_timer(s);
 647                 }
 648                 return SUB_STATE_FINISHED;
 649
 650             case MSG_PROCESS_CONTINUE_PROCESSING:
 651                 st->read_state = READ_STATE_POST_PROCESS;
 652                 st->read_state_work = WORK_MORE_A;
 653                 break;
 654
 655             default:
 656                 st->read_state = READ_STATE_HEADER;
 657                 break;
 658             }
 659             break;
 660
 661         case READ_STATE_POST_PROCESS:
 662             st->read_state_work = post_process_message(s, st->read_state_work);
 663             switch (st->read_state_work) {
 664             case WORK_ERROR:
 665                 check_fatal(s, SSL_F_READ_STATE_MACHINE);
 666                 /* Fall through */
 667             case WORK_MORE_A:
 668             case WORK_MORE_B:
 669             case WORK_MORE_C:
 670                 return SUB_STATE_ERROR;
 671
 672             case WORK_FINISHED_CONTINUE:
 673                 st->read_state = READ_STATE_HEADER;
 674                 break;
 675
 676             case WORK_FINISHED_STOP:
 677                 if (SSL_IS_DTLS(s)) {
 678                     dtls1_stop_timer(s);
 679                 }
 680                 return SUB_STATE_FINISHED;
 681             }
 682             break;
 683
 684         default:
 685             /* Shouldn't happen */
 686             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_READ_STATE_MACHINE,
 687                      ERR_R_INTERNAL_ERROR);
 688             return SUB_STATE_ERROR;
 689         }
 690     }
 691 }
 692
 693 /*
 694  * Send a previously constructed message to the peer.
 695  */
 696 static int statem_do_write(SSL *s)
 697 {
 698     OSSL_STATEM *st = &s->statem;
 699
 700     if (st->hand_state == TLS_ST_CW_CHANGE
 701         || st->hand_state == TLS_ST_SW_CHANGE) {
 702         if (SSL_IS_DTLS(s))
 703             return dtls1_do_write(s, SSL3_RT_CHANGE_CIPHER_SPEC);
 704         else
 705             return ssl3_do_write(s, SSL3_RT_CHANGE_CIPHER_SPEC);
 706     } else {
 707         return ssl_do_write(s);
 708     }
 709 }
 710
 711 /*
 712  * Initialise the MSG_FLOW_WRITING sub-state machine
 713  */
 714 static void init_write_state_machine(SSL *s)
 715 {
 716     OSSL_STATEM *st = &s->statem;
 717
 718     st->write_state = WRITE_STATE_TRANSITION;
 719 }
 720
 721 /*
 722  * This function implements the sub-state machine when the message flow is in
 723  * MSG_FLOW_WRITING. The valid sub-states and transitions are:
 724  *
 725  * +-> WRITE_STATE_TRANSITION ------> [SUB_STATE_FINISHED]
 726  * |             |
 727  * |             v
 728  * |      WRITE_STATE_PRE_WORK -----> [SUB_STATE_END_HANDSHAKE]
 729  * |             |
 730  * |             v
 731  * |       WRITE_STATE_SEND
 732  * |             |
 733  * |             v
 734  * |     WRITE_STATE_POST_WORK
 735  * |             |
 736  * +-------------+
 737  *
 738  * WRITE_STATE_TRANSITION transitions the state of the handshake state machine
 739
 740  * WRITE_STATE_PRE_WORK performs any work necessary to prepare the later
 741  * sending of the message. This could result in an NBIO event occurring in
 742  * which case control returns to the calling application. When this function
 743  * is recalled we will resume in the same state where we left off.
 744  *
 745  * WRITE_STATE_SEND sends the message and performs any work to be done after
 746  * sending.
 747  *
 748  * WRITE_STATE_POST_WORK performs any work necessary after the sending of the
 749  * message has been completed. As for WRITE_STATE_PRE_WORK this could also
 750  * result in an NBIO event.
 751  */
 752 static SUB_STATE_RETURN write_state_machine(SSL *s)
 753 {
 754     OSSL_STATEM *st = &s->statem;
 755     int ret;
 756     WRITE_TRAN(*transition) (SSL *s);
 757     WORK_STATE(*pre_work) (SSL *s, WORK_STATE wst);
 758     WORK_STATE(*post_work) (SSL *s, WORK_STATE wst);
 759     int (*get_construct_message_f) (SSL *s, WPACKET *pkt,
 760                                     int (**confunc) (SSL *s, WPACKET *pkt),
 761                                     int *mt);
 762     void (*cb) (const SSL *ssl, int type, int val) = NULL;
 763     int (*confunc) (SSL *s, WPACKET *pkt);
 764     int mt;
 765     WPACKET pkt;
 766
 767     cb = get_callback(s);
 768
 769     if (s->server) {
 770         transition = ossl_statem_server_write_transition;
 771         pre_work = ossl_statem_server_pre_work;
 772         post_work = ossl_statem_server_post_work;
 773         get_construct_message_f = ossl_statem_server_construct_message;
 774     } else {
 775         transition = ossl_statem_client_write_transition;
 776         pre_work = ossl_statem_client_pre_work;
 777         post_work = ossl_statem_client_post_work;
 778         get_construct_message_f = ossl_statem_client_construct_message;
 779     }
 780
 781     while (1) {
 782         switch (st->write_state) {
 783         case WRITE_STATE_TRANSITION:
 784             if (cb != NULL) {
 785                 /* Notify callback of an impending state change */
 786                 if (s->server)
 787                     cb(s, SSL_CB_ACCEPT_LOOP, 1);
 788                 else
 789                     cb(s, SSL_CB_CONNECT_LOOP, 1);
 790             }
 791             switch (transition(s)) {
 792             case WRITE_TRAN_CONTINUE:
 793                 st->write_state = WRITE_STATE_PRE_WORK;
 794                 st->write_state_work = WORK_MORE_A;
 795                 break;
 796
 797             case WRITE_TRAN_FINISHED:
 798                 return SUB_STATE_FINISHED;
 799                 break;
 800
 801             case WRITE_TRAN_ERROR:
 802                 check_fatal(s, SSL_F_WRITE_STATE_MACHINE);
 803                 return SUB_STATE_ERROR;
 804             }
 805             break;
 806
 807         case WRITE_STATE_PRE_WORK:
 808             switch (st->write_state_work = pre_work(s, st->write_state_work)) {
 809             case WORK_ERROR:
 810                 check_fatal(s, SSL_F_WRITE_STATE_MACHINE);
 811                 /* Fall through */
 812             case WORK_MORE_A:
 813             case WORK_MORE_B:
 814             case WORK_MORE_C:
 815                 return SUB_STATE_ERROR;
 816
 817             case WORK_FINISHED_CONTINUE:
 818                 st->write_state = WRITE_STATE_SEND;
 819                 break;
 820
 821             case WORK_FINISHED_STOP:
 822                 return SUB_STATE_END_HANDSHAKE;
 823             }
 824             if (!get_construct_message_f(s, &pkt, &confunc, &mt)) {
 825                 /* SSLfatal() already called */
 826                 return SUB_STATE_ERROR;
 827             }
 828             if (mt == SSL3_MT_DUMMY) {
 829                 /* Skip construction and sending. This isn't a "real" state */
 830                 st->write_state = WRITE_STATE_POST_WORK;
 831                 st->write_state_work = WORK_MORE_A;
 832                 break;
 833             }
 834             if (!WPACKET_init(&pkt, s->init_buf)
 835                     || !ssl_set_handshake_header(s, &pkt, mt)) {
 836                 WPACKET_cleanup(&pkt);
 837                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_WRITE_STATE_MACHINE,
 838                          ERR_R_INTERNAL_ERROR);
 839                 return SUB_STATE_ERROR;
 840             }
 841             if (confunc != NULL && !confunc(s, &pkt)) {
 842                 WPACKET_cleanup(&pkt);
 843                 check_fatal(s, SSL_F_WRITE_STATE_MACHINE);
 844                 return SUB_STATE_ERROR;
 845             }
 846             if (!ssl_close_construct_packet(s, &pkt, mt)
 847                     || !WPACKET_finish(&pkt)) {
 848                 WPACKET_cleanup(&pkt);
 849                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_WRITE_STATE_MACHINE,
 850                          ERR_R_INTERNAL_ERROR);
 851                 return SUB_STATE_ERROR;
 852             }
 853
 854             /* Fall through */
 855
 856         case WRITE_STATE_SEND:
 857             if (SSL_IS_DTLS(s) && st->use_timer) {
 858                 dtls1_start_timer(s);
 859             }
 860             ret = statem_do_write(s);
 861             if (ret <= 0) {
 862                 return SUB_STATE_ERROR;
 863             }
 864             st->write_state = WRITE_STATE_POST_WORK;
 865             st->write_state_work = WORK_MORE_A;
 866             /* Fall through */
 867
 868         case WRITE_STATE_POST_WORK:
 869             switch (st->write_state_work = post_work(s, st->write_state_work)) {
 870             case WORK_ERROR:
 871                 check_fatal(s, SSL_F_WRITE_STATE_MACHINE);
 872                 /* Fall through */
 873             case WORK_MORE_A:
 874             case WORK_MORE_B:
 875             case WORK_MORE_C:
 876                 return SUB_STATE_ERROR;
 877
 878             case WORK_FINISHED_CONTINUE:
 879                 st->write_state = WRITE_STATE_TRANSITION;
 880                 break;
 881
 882             case WORK_FINISHED_STOP:
 883                 return SUB_STATE_END_HANDSHAKE;
 884             }
 885             break;
 886
 887         default:
 888             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_WRITE_STATE_MACHINE,
 889                      ERR_R_INTERNAL_ERROR);
 890             return SUB_STATE_ERROR;
 891         }
 892     }
 893 }
 894
 895 /*
 896  * Flush the write BIO
 897  */
 898 int statem_flush(SSL *s)
 899 {
 900     s->rwstate = SSL_WRITING;
 901     if (BIO_flush(s->wbio) <= 0) {
 902         return 0;
 903     }
 904     s->rwstate = SSL_NOTHING;
 905
 906     return 1;
 907 }
 908
 909 /*
 910  * Called by the record layer to determine whether application data is
 911  * allowed to be received in the current handshake state or not.
 912  *
 913  * Return values are:
 914  *   1: Yes (application data allowed)
 915  *   0: No (application data not allowed)
 916  */
 917 int ossl_statem_app_data_allowed(SSL *s)
 918 {
 919     OSSL_STATEM *st = &s->statem;
 920
 921     if (st->state == MSG_FLOW_UNINITED)
 922         return 0;
 923
 924     if (!s->s3->in_read_app_data || (s->s3->total_renegotiations == 0))
 925         return 0;
 926
 927     if (s->server) {
 928         /*
 929          * If we're a server and we haven't got as far as writing our
 930          * ServerHello yet then we allow app data
 931          */
 932         if (st->hand_state == TLS_ST_BEFORE
 933             || st->hand_state == TLS_ST_SR_CLNT_HELLO)
 934             return 1;
 935     } else {
 936         /*
 937          * If we're a client and we haven't read the ServerHello yet then we
 938          * allow app data
 939          */
 940         if (st->hand_state == TLS_ST_CW_CLNT_HELLO)
 941             return 1;
 942     }
 943
 944     return 0;
 945 }
 946
 947 /*
 948  * This function returns 1 if TLS exporter is ready to export keying
 949  * material, or 0 if otherwise.
 950  */
 951 int ossl_statem_export_allowed(SSL *s)
 952 {
 953     return s->s3->previous_server_finished_len != 0
 954            && s->statem.hand_state != TLS_ST_SW_FINISHED;
 955 }
 956
 957 /*
 958  * Return 1 if early TLS exporter is ready to export keying material,
 959  * or 0 if otherwise.
 960  */
 961 int ossl_statem_export_early_allowed(SSL *s)
 962 {
 963     /*
 964      * The early exporter secret is only present on the server if we
 965      * have accepted early_data. It is present on the client as long
 966      * as we have sent early_data.
 967      */
 968     return s->ext.early_data == SSL_EARLY_DATA_ACCEPTED
 969            || (!s->server && s->ext.early_data != SSL_EARLY_DATA_NOT_SENT);
 970 }