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
|
/*
* 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/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);
~Handshake_State();
Handshake_State(const Handshake_State&) = delete;
Handshake_State& operator=(const Handshake_State&) = delete;
Handshake_IO& handshake_io() { return *m_handshake_io; }
bool received_handshake_msg(Handshake_Type handshake_msg) const;
void confirm_transition_to(Handshake_Type handshake_msg);
void set_expected_next(Handshake_Type 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(); }
// Used by the server only, in case of RSA key exchange
Private_Key* server_rsa_kex_key = nullptr; // FIXME make private
Ciphersuite suite; // FIXME make private
Session_Keys keys; // FIXME make private
Handshake_Hash hash; // FIXME make private
/*
* Only used by clients for session resumption
*/
secure_vector<byte> resume_master_secret; // FIXME make private
/*
* Used by the server to know if resumption should be allowed on
* a server-initiated renegotiation
*/
bool allow_session_resumption = true; // FIXME make private
/**
* Used by client using NPN FIXME make private
*/
std::function<std::string (std::vector<std::string>)> client_npn_cb;
private:
std::unique_ptr<Handshake_IO> m_handshake_io;
u32bit m_hand_expecting_mask = 0;
u32bit m_hand_received_mask = 0;
Protocol_Version m_version;
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
|
