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
|
/*
* TLS Client
* (C) 2004-2011 Jack Lloyd
* 2016 Matthias Gierlings
*
* Botan is released under the Simplified BSD License (see license.txt)
*/
#ifndef BOTAN_TLS_CLIENT_H__
#define BOTAN_TLS_CLIENT_H__
#include <botan/tls_channel.h>
#include <botan/credentials_manager.h>
#include <vector>
namespace Botan {
namespace TLS {
/**
* SSL/TLS Client
*/
class BOTAN_DLL Client final : public Channel
{
public:
/**
* Set up a new TLS client session
*
* @param callbacks contains a set of callback function references
* required by the TLS client.
*
* @param session_manager manages session state
*
* @param creds manages application/user credentials
*
* @param policy specifies other connection policy information
*
* @param rng a random number generator
*
* @param properties holds server information and protocol related
* properties.
*
* @param reserved_io_buffer_size This many bytes of memory will
* be preallocated for the read and write buffers. Smaller
* values just mean reallocations and copies are more likely.
*/
class Properties
{
/**
* Stores TLS Client properties.
*
* @param server_info is identifying information about the TLS server
*
* @param protocol_version specifies which version we will offer
* to the TLS server.
*
* @param next_protocols specifies protocols to advertise with ALPN
*/
public:
Properties(const Server_Information& server_info
= Server_Information(),
const Protocol_Version protocol_version
= Protocol_Version::latest_tls_version(),
const std::vector<std::string>& next_versions
= {})
: m_server_info(server_info),
m_protocol_version(protocol_version),
m_next_protocols(next_versions) {}
const Server_Information& get_server_info()
{
return m_server_info;
}
const Protocol_Version& get_protocol_version()
{
return m_protocol_version;
}
const std::vector<std::string>& get_next_protocols()
{
return m_next_protocols;
}
private:
const Server_Information& m_server_info;
const Protocol_Version m_protocol_version;
const std::vector<std::string>& m_next_protocols;
};
Client(const Callbacks& callbacks,
Session_Manager& session_manager,
Credentials_Manager& creds,
const Policy& policy,
RandomNumberGenerator& rng,
Properties properties,
size_t reserved_io_buffer_size = 16*1024
);
const std::string& application_protocol() const { return m_application_protocol; }
private:
std::vector<X509_Certificate>
get_peer_cert_chain(const Handshake_State& state) const override;
void initiate_handshake(Handshake_State& state,
bool force_full_renegotiation) override;
void send_client_hello(Handshake_State& state,
bool force_full_renegotiation,
Protocol_Version version,
const std::string& srp_identifier = "",
const std::vector<std::string>& next_protocols = {});
void process_handshake_msg(const Handshake_State* active_state,
Handshake_State& pending_state,
Handshake_Type type,
const std::vector<byte>& contents) override;
Handshake_State* new_handshake_state(Handshake_IO* io) override;
Credentials_Manager& m_creds;
const Server_Information m_info;
std::string m_application_protocol;
};
}
}
#endif
|
