1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
|
/*
* TLS Handshake State
* (C) 2004-2006,2011,2012 Jack Lloyd
*
* Released under the terms of the Botan license
*/
#ifndef BOTAN_TLS_HANDSHAKE_STATE_H__
#define BOTAN_TLS_HANDSHAKE_STATE_H__
#include <botan/internal/tls_handshake_hash.h>
#include <botan/internal/tls_handshake_io.h>
#include <botan/internal/tls_session_key.h>
#include <botan/tls_handshake_msg.h>
#include <botan/pk_keys.h>
#include <botan/pubkey.h>
#include <functional>
#include <utility>
#include <memory>
namespace Botan {
class KDF;
namespace TLS {
class Policy;
class Client_Hello;
class Server_Hello;
class Certificate;
class Server_Key_Exchange;
class Certificate_Req;
class Server_Hello_Done;
class Certificate;
class Client_Key_Exchange;
class Certificate_Verify;
class Next_Protocol;
class New_Session_Ticket;
class Finished;
/**
* SSL/TLS Handshake State
*/
class Handshake_State
{
public:
Handshake_State(Handshake_IO* io,
std::function<void (const Handshake_Message&)> msg_callback =
std::function<void (const Handshake_Message&)>());
virtual ~Handshake_State();
Handshake_State(const Handshake_State&) = delete;
Handshake_State& operator=(const Handshake_State&) = delete;
Handshake_IO& handshake_io() { return *m_handshake_io; }
/**
* Return true iff we have received a particular message already
* @param msg_type the message type
*/
bool received_handshake_msg(Handshake_Type msg_type) const;
/**
* Confirm that we were expecting this message type
* @param msg_type the message type
*/
void confirm_transition_to(Handshake_Type msg_type);
/**
* Record that we are expecting a particular message type next
* @param msg_type the message type
*/
void set_expected_next(Handshake_Type msg_type);
std::pair<Handshake_Type, std::vector<byte>>
get_next_handshake_msg();
const std::vector<byte>& session_ticket() const;
std::pair<std::string, Signature_Format>
understand_sig_format(const Public_Key* key,
std::string hash_algo,
std::string sig_algo,
bool for_client_auth) const;
std::pair<std::string, Signature_Format>
choose_sig_format(const Private_Key* key,
std::string& hash_algo,
std::string& sig_algo,
bool for_client_auth,
const Policy& policy) const;
std::string srp_identifier() const;
KDF* protocol_specific_prf() const;
Protocol_Version version() const { return m_version; }
void set_version(const Protocol_Version& version);
void client_hello(Client_Hello* client_hello);
void server_hello(Server_Hello* server_hello);
void server_certs(Certificate* server_certs);
void server_kex(Server_Key_Exchange* server_kex);
void cert_req(Certificate_Req* cert_req);
void server_hello_done(Server_Hello_Done* server_hello_done);
void client_certs(Certificate* client_certs);
void client_kex(Client_Key_Exchange* client_kex);
void client_verify(Certificate_Verify* client_verify);
void next_protocol(Next_Protocol* next_protocol);
void new_session_ticket(New_Session_Ticket* new_session_ticket);
void server_finished(Finished* server_finished);
void client_finished(Finished* client_finished);
const Client_Hello* client_hello() const
{ return m_client_hello.get(); }
const Server_Hello* server_hello() const
{ return m_server_hello.get(); }
const Certificate* server_certs() const
{ return m_server_certs.get(); }
const Server_Key_Exchange* server_kex() const
{ return m_server_kex.get(); }
const Certificate_Req* cert_req() const
{ return m_cert_req.get(); }
const Server_Hello_Done* server_hello_done() const
{ return m_server_hello_done.get(); }
const Certificate* client_certs() const
{ return m_client_certs.get(); }
const Client_Key_Exchange* client_kex() const
{ return m_client_kex.get(); }
const Certificate_Verify* client_verify() const
{ return m_client_verify.get(); }
const Next_Protocol* next_protocol() const
{ return m_next_protocol.get(); }
const New_Session_Ticket* new_session_ticket() const
{ return m_new_session_ticket.get(); }
const Finished* server_finished() const
{ return m_server_finished.get(); }
const Finished* client_finished() const
{ return m_client_finished.get(); }
const Ciphersuite& ciphersuite() const { return m_ciphersuite; }
const Session_Keys& session_keys() const { return m_session_keys; }
void compute_session_keys();
void compute_session_keys(const secure_vector<byte>& resume_master_secret);
Handshake_Hash& hash() { return m_handshake_hash; }
const Handshake_Hash& hash() const { return m_handshake_hash; }
void note_message(const Handshake_Message& msg)
{
if(m_msg_callback)
m_msg_callback(msg);
}
private:
std::unique_ptr<Handshake_IO> m_handshake_io;
std::function<void (const Handshake_Message&)> m_msg_callback;
u32bit m_hand_expecting_mask = 0;
u32bit m_hand_received_mask = 0;
Protocol_Version m_version;
Ciphersuite m_ciphersuite;
Session_Keys m_session_keys;
Handshake_Hash m_handshake_hash;
std::unique_ptr<Client_Hello> m_client_hello;
std::unique_ptr<Server_Hello> m_server_hello;
std::unique_ptr<Certificate> m_server_certs;
std::unique_ptr<Server_Key_Exchange> m_server_kex;
std::unique_ptr<Certificate_Req> m_cert_req;
std::unique_ptr<Server_Hello_Done> m_server_hello_done;
std::unique_ptr<Certificate> m_client_certs;
std::unique_ptr<Client_Key_Exchange> m_client_kex;
std::unique_ptr<Certificate_Verify> m_client_verify;
std::unique_ptr<Next_Protocol> m_next_protocol;
std::unique_ptr<New_Session_Ticket> m_new_session_ticket;
std::unique_ptr<Finished> m_server_finished;
std::unique_ptr<Finished> m_client_finished;
};
}
}
#endif
|
