1/*
2 * Copyright 2015-2018 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/*****************************************************************************
11 *                                                                           *
12 * These enums should be considered PRIVATE to the state machine. No         *
13 * non-state machine code should need to use these                           *
14 *                                                                           *
15 *****************************************************************************/
16/*
17 * Valid return codes used for functions performing work prior to or after
18 * sending or receiving a message
19 */
20typedef enum {
21    /* Something went wrong */
22    WORK_ERROR,
23    /* We're done working and there shouldn't be anything else to do after */
24    WORK_FINISHED_STOP,
25    /* We're done working move onto the next thing */
26    WORK_FINISHED_CONTINUE,
27    /* We're working on phase A */
28    WORK_MORE_A,
29    /* We're working on phase B */
30    WORK_MORE_B,
31    /* We're working on phase C */
32    WORK_MORE_C
33} WORK_STATE;
34
35/* Write transition return codes */
36typedef enum {
37    /* Something went wrong */
38    WRITE_TRAN_ERROR,
39    /* A transition was successfully completed and we should continue */
40    WRITE_TRAN_CONTINUE,
41    /* There is no more write work to be done */
42    WRITE_TRAN_FINISHED
43} WRITE_TRAN;
44
45/* Message flow states */
46typedef enum {
47    /* No handshake in progress */
48    MSG_FLOW_UNINITED,
49    /* A permanent error with this connection */
50    MSG_FLOW_ERROR,
51    /* We are reading messages */
52    MSG_FLOW_READING,
53    /* We are writing messages */
54    MSG_FLOW_WRITING,
55    /* Handshake has finished */
56    MSG_FLOW_FINISHED
57} MSG_FLOW_STATE;
58
59/* Read states */
60typedef enum {
61    READ_STATE_HEADER,
62    READ_STATE_BODY,
63    READ_STATE_POST_PROCESS
64} READ_STATE;
65
66/* Write states */
67typedef enum {
68    WRITE_STATE_TRANSITION,
69    WRITE_STATE_PRE_WORK,
70    WRITE_STATE_SEND,
71    WRITE_STATE_POST_WORK
72} WRITE_STATE;
73
74typedef enum {
75    /* The enc_write_ctx can be used normally */
76    ENC_WRITE_STATE_VALID,
77    /* The enc_write_ctx cannot be used */
78    ENC_WRITE_STATE_INVALID,
79    /* Write alerts in plaintext, but otherwise use the enc_write_ctx */
80    ENC_WRITE_STATE_WRITE_PLAIN_ALERTS
81} ENC_WRITE_STATES;
82
83typedef enum {
84    /* The enc_read_ctx can be used normally */
85    ENC_READ_STATE_VALID,
86    /* We may receive encrypted or plaintext alerts */
87    ENC_READ_STATE_ALLOW_PLAIN_ALERTS
88} ENC_READ_STATES;
89
90/*****************************************************************************
91 *                                                                           *
92 * This structure should be considered "opaque" to anything outside of the   *
93 * state machine. No non-state machine code should be accessing the members  *
94 * of this structure.                                                        *
95 *                                                                           *
96 *****************************************************************************/
97
98struct ossl_statem_st {
99    MSG_FLOW_STATE state;
100    WRITE_STATE write_state;
101    WORK_STATE write_state_work;
102    READ_STATE read_state;
103    WORK_STATE read_state_work;
104    OSSL_HANDSHAKE_STATE hand_state;
105    /* The handshake state requested by an API call (e.g. HelloRequest) */
106    OSSL_HANDSHAKE_STATE request_state;
107    int in_init;
108    int read_state_first_init;
109    /* true when we are actually in SSL_accept() or SSL_connect() */
110    int in_handshake;
111    /*
112     * True when are processing a "real" handshake that needs cleaning up (not
113     * just a HelloRequest or similar).
114     */
115    int cleanuphand;
116    /* Should we skip the CertificateVerify message? */
117    unsigned int no_cert_verify;
118    int use_timer;
119    ENC_WRITE_STATES enc_write_state;
120    ENC_READ_STATES enc_read_state;
121};
122typedef struct ossl_statem_st OSSL_STATEM;
123
124/*****************************************************************************
125 *                                                                           *
126 * The following macros/functions represent the libssl internal API to the   *
127 * state machine. Any libssl code may call these functions/macros            *
128 *                                                                           *
129 *****************************************************************************/
130
131__owur int ossl_statem_accept(SSL *s);
132__owur int ossl_statem_connect(SSL *s);
133void ossl_statem_clear(SSL *s);
134void ossl_statem_set_renegotiate(SSL *s);
135void ossl_statem_fatal(SSL *s, int al, int func, int reason, const char *file,
136                       int line);
137# define SSL_AD_NO_ALERT    -1
138# ifndef OPENSSL_NO_ERR
139#  define SSLfatal(s, al, f, r)  ossl_statem_fatal((s), (al), (f), (r), \
140                                                   OPENSSL_FILE, OPENSSL_LINE)
141# else
142#  define SSLfatal(s, al, f, r)  ossl_statem_fatal((s), (al), (f), (r), NULL, 0)
143# endif
144
145int ossl_statem_in_error(const SSL *s);
146void ossl_statem_set_in_init(SSL *s, int init);
147int ossl_statem_get_in_handshake(SSL *s);
148void ossl_statem_set_in_handshake(SSL *s, int inhand);
149__owur int ossl_statem_skip_early_data(SSL *s);
150void ossl_statem_check_finish_init(SSL *s, int send);
151void ossl_statem_set_hello_verify_done(SSL *s);
152__owur int ossl_statem_app_data_allowed(SSL *s);
153__owur int ossl_statem_export_allowed(SSL *s);
154__owur int ossl_statem_export_early_allowed(SSL *s);
155
156/* Flush the write BIO */
157int statem_flush(SSL *s);
158