Make sure that exporting keying material is allowed
[openssl.git] / ssl / statem / statem.h
1 /*
2  * Copyright 2015-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 /*****************************************************************************
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  */
20 typedef 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 */
36 typedef 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 */
46 typedef 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 */
60 typedef enum {
61     READ_STATE_HEADER,
62     READ_STATE_BODY,
63     READ_STATE_POST_PROCESS
64 } READ_STATE;
65
66 /* Write states */
67 typedef enum {
68     WRITE_STATE_TRANSITION,
69     WRITE_STATE_PRE_WORK,
70     WRITE_STATE_SEND,
71     WRITE_STATE_POST_WORK
72 } WRITE_STATE;
73
74 /*****************************************************************************
75  *                                                                           *
76  * This structure should be considered "opaque" to anything outside of the   *
77  * state machine. No non-state machine code should be accessing the members  *
78  * of this structure.                                                        *
79  *                                                                           *
80  *****************************************************************************/
81
82 struct ossl_statem_st {
83     MSG_FLOW_STATE state;
84     WRITE_STATE write_state;
85     WORK_STATE write_state_work;
86     READ_STATE read_state;
87     WORK_STATE read_state_work;
88     OSSL_HANDSHAKE_STATE hand_state;
89     /* The handshake state requested by an API call (e.g. HelloRequest) */
90     OSSL_HANDSHAKE_STATE request_state;
91     int in_init;
92     int read_state_first_init;
93     /* true when we are actually in SSL_accept() or SSL_connect() */
94     int in_handshake;
95     /*
96      * True when are processing a "real" handshake that needs cleaning up (not
97      * just a HelloRequest or similar).
98      */
99     int cleanuphand;
100     /* Should we skip the CertificateVerify message? */
101     unsigned int no_cert_verify;
102     int use_timer;
103 };
104 typedef struct ossl_statem_st OSSL_STATEM;
105
106 /*****************************************************************************
107  *                                                                           *
108  * The following macros/functions represent the libssl internal API to the   *
109  * state machine. Any libssl code may call these functions/macros            *
110  *                                                                           *
111  *****************************************************************************/
112
113 __owur int ossl_statem_accept(SSL *s);
114 __owur int ossl_statem_connect(SSL *s);
115 void ossl_statem_clear(SSL *s);
116 void ossl_statem_set_renegotiate(SSL *s);
117 void ossl_statem_fatal(SSL *s, int al, int func, int reason, const char *file,
118                        int line);
119 # define SSL_AD_NO_ALERT    -1
120 # ifndef OPENSSL_NO_ERR
121 #  define SSLfatal(s, al, f, r)  ossl_statem_fatal((s), (al), (f), (r), \
122                                                    OPENSSL_FILE, OPENSSL_LINE)
123 # else
124 #  define SSLfatal(s, al, f, r)  ossl_statem_fatal((s), (al), (f), (r), NULL, 0)
125 # endif
126
127 int ossl_statem_in_error(const SSL *s);
128 void ossl_statem_set_in_init(SSL *s, int init);
129 int ossl_statem_get_in_handshake(SSL *s);
130 void ossl_statem_set_in_handshake(SSL *s, int inhand);
131 __owur int ossl_statem_skip_early_data(SSL *s);
132 void ossl_statem_check_finish_init(SSL *s, int send);
133 void ossl_statem_set_hello_verify_done(SSL *s);
134 __owur int ossl_statem_app_data_allowed(SSL *s);
135 __owur int ossl_statem_export_allowed(SSL *s);
136
137 /* Flush the write BIO */
138 int statem_flush(SSL *s);