Botan 2.1.0 Crypto and TLS for C++11

- Main Page
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

Public Types | Public Member Functions | Static Public Attributes | Protected Member Functions | List of all members
Botan::TLS::Channel Class Referenceabstract

`#include <tls_channel.h>`

Inheritance diagram for Botan::TLS::Channel:

## Public Types
typedef std::function< void(Alert, const uint8_t[], size_t)> | alert_cb
typedef std::function< void(const uint8_t[], size_t)> | data_cb
typedef std::function< bool(const Session &)> | handshake_cb
typedef std::function< void(const Handshake_Message &)> | handshake_msg_cb
typedef std::function< void(const uint8_t[], size_t)> | output_fn

## Public Member Functions
| Channel (Callbacks &callbacks, Session_Manager &session_manager, RandomNumberGenerator &rng, const Policy &policy, bool is_datagram, size_t io_buf_sz=IO_BUF_DEFAULT_SIZE)
| Channel (output_fn out, data_cb app_data_cb, alert_cb alert_cb, handshake_cb hs_cb, handshake_msg_cb hs_msg_cb, Session_Manager &session_manager, RandomNumberGenerator &rng, const Policy &policy, bool is_datagram, size_t io_buf_sz=IO_BUF_DEFAULT_SIZE)
| Channel (const Channel &)=delete
void | close ()
bool | is_active () const
bool | is_closed () const
SymmetricKey | key_material_export (const std::string &label, const std::string &context, size_t length) const
Channel & | operator= (const Channel &)=delete
std::vector< X509_Certificate > | peer_cert_chain () const
size_t | received_data (const uint8_t buf[], size_t buf_size)
size_t | received_data (const std::vector< uint8_t > &buf)
void | renegotiate (bool force_full_renegotiation=false)
bool | secure_renegotiation_supported () const
void | send (const uint8_t buf[], size_t buf_size)
void | send (const std::string &val)
template<typename Alloc >
void | send (const std::vector< unsigned char, Alloc > &val)
void | send_alert (const Alert &alert)
void | send_fatal_alert (Alert::Type type)
void | send_warning_alert (Alert::Type type)
bool | timeout_check ()
virtual | ~Channel ()

## Static Public Attributes
static size_t | IO_BUF_DEFAULT_SIZE = 10*1024

## Protected Member Functions
void | activate_session ()
Callbacks & | callbacks () const
void | change_cipher_spec_reader (Connection_Side side)
void | change_cipher_spec_writer (Connection_Side side)
Handshake_State & | create_handshake_state (Protocol_Version version)
virtual std::vector< X509_Certificate > | get_peer_cert_chain (const Handshake_State &state) const =0
virtual void | initiate_handshake (Handshake_State &state, bool force_full_renegotiation)=0
void | inspect_handshake_message (const Handshake_Message &msg)
virtual Handshake_State * | new_handshake_state (class Handshake_IO *io)=0
const Policy & | policy () const
virtual void | process_handshake_msg (const Handshake_State *active_state, Handshake_State &pending_state, Handshake_Type type, const std::vector< uint8_t > &contents)=0
RandomNumberGenerator & | rng ()
bool | save_session (const Session &session) const
void | secure_renegotiation_check (const Client_Hello *client_hello)
void | secure_renegotiation_check (const Server_Hello *server_hello)
std::vector< uint8_t > | secure_renegotiation_data_for_client_hello () const
std::vector< uint8_t > | secure_renegotiation_data_for_server_hello () const
Session_Manager & | session_manager ()

## Detailed Description

Generic interface for TLS endpoint

Definition at line 36 of file tls_channel.h.

## Member Typedef Documentation

typedef std::function<void (Alert, const uint8_t[], size_t)> Botan::TLS::Channel::alert_cb

Definition at line 41 of file tls_channel.h.

typedef std::function<void (const uint8_t[], size_t)> Botan::TLS::Channel::data_cb

Definition at line 40 of file tls_channel.h.

typedef std::function<bool (const Session&)> Botan::TLS::Channel::handshake_cb

Definition at line 42 of file tls_channel.h.

typedef std::function<void (const Handshake_Message&)> Botan::TLS::Channel::handshake_msg_cb

Definition at line 43 of file tls_channel.h.

typedef std::function<void (const uint8_t[], size_t)> Botan::TLS::Channel::output_fn

Definition at line 39 of file tls_channel.h.

## Constructor & Destructor Documentation

Botan::TLS::Channel::Channel | ( | Callbacks & | callbacks,
|  | Session_Manager & | session_manager,
|  | RandomNumberGenerator & | rng,
|  | const Policy & | policy,
|  | bool | is_datagram,
|  | size_t | io_buf_sz = `IO_BUF_DEFAULT_SIZE`
| ) |  |

Set up a new TLS session

Parameters

  callbacks | contains a set of callback function references required by the TLS endpoint.
  session_manager | manages session state
  rng | a random number generator
  policy | specifies other connection policy information
  is_datagram | whether this is a DTLS session
  io_buf_sz | This many bytes of memory will be preallocated for the read and write buffers. Smaller values just mean reallocations and copies are more likely.

Definition at line 24 of file tls_channel.cpp.

29 :
30 m_is_datagram(is_datagram),
31 m_callbacks(callbacks),
32 m_session_manager(session_manager),
33 m_policy(policy),
34 m_rng(rng)
35 {
36 init(reserved_io_buffer_size);
37 }
Botan::TLS::Channel::callbacks
Callbacks & callbacks() const
Definition: tls_channel.h:241
Botan::TLS::Channel::rng
RandomNumberGenerator & rng()
Definition: tls_channel.h:233
m_rng
RandomNumberGenerator & m_rng
Definition: ecdh.cpp:52
Botan::TLS::Channel::policy
const Policy & policy() const
Definition: tls_channel.h:237
Botan::TLS::Channel::session_manager
Session_Manager & session_manager()
Definition: tls_channel.h:235

Botan::TLS::Channel::Channel | ( | output_fn | out,
|  | data_cb | app_data_cb,
|  | alert_cb | alert_cb,
|  | handshake_cb | hs_cb,
|  | handshake_msg_cb | hs_msg_cb,
|  | Session_Manager & | session_manager,
|  | RandomNumberGenerator & | rng,
|  | const Policy & | policy,
|  | bool | is_datagram,
|  | size_t | io_buf_sz = `IO_BUF_DEFAULT_SIZE`
| ) |  |

DEPRECATED. This constructor is only provided for backward compatibility and should not be used in new implementations. (Not marked deprecated since it is only called internally, by other deprecated constructors)

Definition at line 39 of file tls_channel.cpp.

48 :
49 m_is_datagram(is_datagram),
50 m_compat_callbacks(new Compat_Callbacks(out, app_data_cb, alert_cb, hs_cb, hs_msg_cb)),
51 m_callbacks(*m_compat_callbacks.get()),
52 m_session_manager(session_manager),
53 m_policy(policy),
54 m_rng(rng)
55 {
56 init(io_buf_sz);
57 }
Botan::TLS::Channel::alert_cb
std::function< void(Alert, const uint8_t[], size_t)> alert_cb
Definition: tls_channel.h:41
Botan::TLS::Channel::rng
RandomNumberGenerator & rng()
Definition: tls_channel.h:233
m_rng
RandomNumberGenerator & m_rng
Definition: ecdh.cpp:52
Botan::TLS::Channel::policy
const Policy & policy() const
Definition: tls_channel.h:237
Botan::TLS::Channel::session_manager
Session_Manager & session_manager()
Definition: tls_channel.h:235

Botan::TLS::Channel::Channel | ( | const Channel & |  | ) |
| delete

Botan::TLS::Channel::~Channel | ( |  | ) |
| virtual

Definition at line 78 of file tls_channel.cpp.

79 {
80 // So unique_ptr destructors run correctly
81 }

## Member Function Documentation

void Botan::TLS::Channel::activate_session | ( |  | ) |
| protected

Definition at line 259 of file tls_channel.cpp.

References callbacks(), Botan::TLS::Connection_Sequence_Numbers::current_write_epoch(), Botan::map_remove_if(), and Botan::TLS::Callbacks::tls_session_activated().

260 {
261 std::swap(m_active_state, m_pending_state);
262 m_pending_state.reset();
263
264 if(!m_active_state->version().is_datagram_protocol())
265 {
266 // TLS is easy just remove all but the current state
267 const uint16_t current_epoch = sequence_numbers().current_write_epoch();
268
269 const auto not_current_epoch =
270 [current_epoch](uint16_t epoch) { return (epoch != current_epoch); };
271
272 map_remove_if(not_current_epoch, m_write_cipher_states);
273 map_remove_if(not_current_epoch, m_read_cipher_states);
274 }
275
276 callbacks().tls_session_activated();
277 }
Botan::TLS::Channel::callbacks
Callbacks & callbacks() const
Definition: tls_channel.h:241
Botan::TLS::Callbacks::tls_session_activated
virtual void tls_session_activated()
Definition: tls_callbacks.h:92
Botan::map_remove_if
void map_remove_if(Pred pred, T &assoc)
Definition: stl_util.h:96
Botan::TLS::Connection_Sequence_Numbers::current_write_epoch
virtual uint16_t current_write_epoch() const =0

Callbacks& Botan::TLS::Channel::callbacks | ( |  | ) | const
| inline protected

Definition at line 241 of file tls_channel.h.

Referenced by activate_session().

241 { return m_callbacks; }

void Botan::TLS::Channel::change_cipher_spec_reader | ( | Connection_Side | side | ) |
| protected

Definition at line 183 of file tls_channel.cpp.

References BOTAN_ASSERT, Botan::TLS::CLIENT, Botan::TLS::Connection_Sequence_Numbers::current_read_epoch(), Botan::TLS::Connection_Sequence_Numbers::new_read_cipher_state(), Botan::TLS::NO_COMPRESSION, and Botan::TLS::SERVER.

184 {
185 auto pending = pending_state();
186
187 BOTAN_ASSERT(pending && pending->server_hello(),
188 "Have received server hello");
189
190 if(pending->server_hello()->compression_method() != NO_COMPRESSION)
191 throw Internal_Error("Negotiated unknown compression algorithm");
192
193 sequence_numbers().new_read_cipher_state();
194
195 const uint16_t epoch = sequence_numbers().current_read_epoch();
196
197 BOTAN_ASSERT(m_read_cipher_states.count(epoch) == 0,
198 "No read cipher state currently set for next epoch");
199
200 // flip side as we are reading
201 std::shared_ptr<Connection_Cipher_State> read_state(
202 new Connection_Cipher_State(pending->version(),
203 (side == CLIENT) ? SERVER : CLIENT,
204 false,
205 pending->ciphersuite(),
206 pending->session_keys(),
207 pending->server_hello()->supports_encrypt_then_mac()));
208
209 m_read_cipher_states[epoch] = read_state;
210 }
Botan::TLS::NO_COMPRESSION
Definition: tls_magic.h:62
BOTAN_ASSERT
#define BOTAN_ASSERT(expr, assertion_made)
Definition: assert.h:27
Botan::TLS::Connection_Sequence_Numbers::new_read_cipher_state
virtual void new_read_cipher_state()=0
Botan::TLS::CLIENT
Definition: tls_magic.h:27
Botan::TLS::SERVER
Definition: tls_magic.h:27
Botan::TLS::Connection_Sequence_Numbers::current_read_epoch
virtual uint16_t current_read_epoch() const =0

void Botan::TLS::Channel::change_cipher_spec_writer | ( | Connection_Side | side | ) |
| protected

Definition at line 212 of file tls_channel.cpp.

References BOTAN_ASSERT, Botan::TLS::Connection_Sequence_Numbers::current_write_epoch(), Botan::TLS::Connection_Sequence_Numbers::new_write_cipher_state(), and Botan::TLS::NO_COMPRESSION.

213 {
214 auto pending = pending_state();
215
216 BOTAN_ASSERT(pending && pending->server_hello(),
217 "Have received server hello");
218
219 if(pending->server_hello()->compression_method() != NO_COMPRESSION)
220 throw Internal_Error("Negotiated unknown compression algorithm");
221
222 sequence_numbers().new_write_cipher_state();
223
224 const uint16_t epoch = sequence_numbers().current_write_epoch();
225
226 BOTAN_ASSERT(m_write_cipher_states.count(epoch) == 0,
227 "No write cipher state currently set for next epoch");
228
229 std::shared_ptr<Connection_Cipher_State> write_state(
230 new Connection_Cipher_State(pending->version(),
231 side,
232 true,
233 pending->ciphersuite(),
234 pending->session_keys(),
235 pending->server_hello()->supports_encrypt_then_mac()));
236
237 m_write_cipher_states[epoch] = write_state;
238 }
Botan::TLS::NO_COMPRESSION
Definition: tls_magic.h:62
BOTAN_ASSERT
#define BOTAN_ASSERT(expr, assertion_made)
Definition: assert.h:27
Botan::TLS::Connection_Sequence_Numbers::current_write_epoch
virtual uint16_t current_write_epoch() const =0
Botan::TLS::Connection_Sequence_Numbers::new_write_cipher_state
virtual void new_write_cipher_state()=0

void Botan::TLS::Channel::close | ( |  | ) |
| inline

Send a close notification alert

Definition at line 150 of file tls_channel.h.

References Botan::TLS::Alert::CLOSE_NOTIFY.

150 { send_warning_alert(Alert::CLOSE_NOTIFY); }
Botan::TLS::Channel::send_warning_alert
void send_warning_alert(Alert::Type type)
Definition: tls_channel.h:140
Botan::TLS::Alert::CLOSE_NOTIFY
Definition: tls_alert.h:28

Handshake_State & Botan::TLS::Channel::create_handshake_state | ( | Protocol_Version | version | ) |
| protected

Definition at line 112 of file tls_channel.cpp.

References Botan::TLS::Protocol_Version::is_datagram_protocol(), new_handshake_state(), and Botan::TLS::Protocol_Version::to_string().

Referenced by renegotiate().

113 {
114 if(pending_state())
115 throw Internal_Error("create_handshake_state called during handshake");
116
117 if(auto active = active_state())
118 {
119 Protocol_Version active_version = active->version();
120
121 if(active_version.is_datagram_protocol() != version.is_datagram_protocol())
122 throw Exception("Active state using version " +
123 active_version.to_string() +
124 " cannot change to " +
125 version.to_string() +
126 " in pending");
127 }
128
129 if(!m_sequence_numbers)
130 {
131 if(version.is_datagram_protocol())
132 m_sequence_numbers.reset(new Datagram_Sequence_Numbers);
133 else
134 m_sequence_numbers.reset(new Stream_Sequence_Numbers);
135 }
136
137 using namespace std::placeholders;
138
139 std::unique_ptr<Handshake_IO> io;
140 if(version.is_datagram_protocol())
141 {
142 io.reset(new Datagram_Handshake_IO(
143 std::bind(&Channel::send_record_under_epoch, this, _1, _2, _3),
144 sequence_numbers(),
145 static_cast<uint16_t>(m_policy.dtls_default_mtu()),
146 m_policy.dtls_initial_timeout(),
147 m_policy.dtls_maximum_timeout()));
148 }
149 else
150 {
151 io.reset(new Stream_Handshake_IO(std::bind(&Channel::send_record, this, _1, _2)));
152 }
153
154 m_pending_state.reset(new_handshake_state(io.release()));
155
156 if(auto active = active_state())
157 m_pending_state->set_version(active->version());
158
159 return *m_pending_state.get();
160 }
placeholders
Botan::TLS::Channel::new_handshake_state
virtual Handshake_State * new_handshake_state(class Handshake_IO *io)=0

virtual std::vector<X509_Certificate> Botan::TLS::Channel::get_peer_cert_chain | ( | const Handshake_State & | state | ) | const
| protected pure virtual

Referenced by peer_cert_chain().

virtual void Botan::TLS::Channel::initiate_handshake | ( | Handshake_State & | state,
|  | bool | force_full_renegotiation
| ) |  |
| protected pure virtual

Referenced by renegotiate().

void Botan::TLS::Channel::inspect_handshake_message | ( | const Handshake_Message & | msg | ) |
| protected

bool Botan::TLS::Channel::is_active | ( |  | ) | const

Returns
  true iff the connection is active for sending application data

Definition at line 240 of file tls_channel.cpp.

Referenced by Botan::TLS::Blocking_Client::do_handshake(), and send().

241 {
242 return (active_state() != nullptr);
243 }

bool Botan::TLS::Channel::is_closed | ( |  | ) | const

Returns
  true iff the connection has been definitely closed

Definition at line 245 of file tls_channel.cpp.

Referenced by Botan::TLS::Blocking_Client::do_handshake(), Botan::TLS::Blocking_Client::read(), received_data(), and send_alert().

246 {
247 if(active_state() || pending_state())
248 return false;
249
250 /*
251 * If no active or pending state, then either we had a connection
252 * and it has been closed, or we are a server which has never
253 * received a connection. This case is detectable by also lacking
254 * m_sequence_numbers
255 */
256 return (m_sequence_numbers != nullptr);
257 }

SymmetricKey Botan::TLS::Channel::key_material_export | ( | const std::string & | label,
|  | const std::string & | context,
|  | size_t | length
| ) |  | const

Key material export (RFC 5705)

Parameters

  label | a disambiguating label string
  context | a per-association context value
  length | the length of the desired key in bytes

Returns
  key of length bytes

Definition at line 651 of file tls_channel.cpp.

References Botan::get_byte(), Botan::OctetString::length(), and Botan::to_byte_vector().

654 {
655 if(auto active = active_state())
656 {
657 std::unique_ptr<KDF> prf(active->protocol_specific_prf());
658
659 const secure_vector<uint8_t>& master_secret =
660 active->session_keys().master_secret();
661
662 std::vector<uint8_t> salt;
663 salt += active->client_hello()->random();
664 salt += active->server_hello()->random();
665
666 if(context != "")
667 {
668 size_t context_size = context.length();
669 if(context_size > 0xFFFF)
670 throw Exception("key_material_export context is too long");
671 salt.push_back(get_byte(0, static_cast<uint16_t>(context_size)));
672 salt.push_back(get_byte(1, static_cast<uint16_t>(context_size)));
673 salt += to_byte_vector(context);
674 }
675
676 return prf->derive_key(length, master_secret, salt, to_byte_vector(label));
677 }
678 else
679 throw Exception("Channel::key_material_export connection not active");
680 }
Botan::to_byte_vector
std::vector< uint8_t > to_byte_vector(const std::string &s)
Definition: stl_util.h:20
Botan::get_byte
uint8_t get_byte(size_t byte_num, T input)
Definition: loadstor.h:47

virtual Handshake_State* Botan::TLS::Channel::new_handshake_state | ( | class Handshake_IO * | io | ) |
| protected pure virtual

Referenced by create_handshake_state().

Channel& Botan::TLS::Channel::operator= | ( | const Channel & |  | ) |
| delete

std::vector< X509_Certificate > Botan::TLS::Channel::peer_cert_chain | ( |  | ) | const

Returns
  certificate chain of the peer (may be empty)

Definition at line 105 of file tls_channel.cpp.

References get_peer_cert_chain().

106 {
107 if(auto active = active_state())
108 return get_peer_cert_chain(*active);
109 return std::vector<X509_Certificate>();
110 }
Botan::TLS::Channel::get_peer_cert_chain
virtual std::vector< X509_Certificate > get_peer_cert_chain(const Handshake_State &state) const =0

const Policy& Botan::TLS::Channel::policy | ( |  | ) | const
| inline protected

Definition at line 237 of file tls_channel.h.

237 { return m_policy; }

virtual void Botan::TLS::Channel::process_handshake_msg | ( | const Handshake_State * | active_state,
|  | Handshake_State & | pending_state,
|  | Handshake_Type | type,
|  | const std::vector< uint8_t > & | contents
| ) |  |
| protected pure virtual

size_t Botan::TLS::Channel::received_data | ( | const uint8_t | buf[],
|  | size_t | buf_size
| ) |  |

Inject TLS traffic received from counterparty

Returns
  a hint as the how many more bytes we need to process the current record (this may be 0 if on a record boundary)

Definition at line 284 of file tls_channel.cpp.

References Botan::TLS::ALERT, Botan::TLS::APPLICATION_DATA, Botan::TLS::Alert::BAD_RECORD_MAC, BOTAN_ASSERT, Botan::TLS::CHANGE_CIPHER_SPEC, Botan::TLS::Alert::DECODE_ERROR, Botan::TLS::HANDSHAKE, Botan::TLS::Alert::INTERNAL_ERROR, is_closed(), Botan::TLS::MAX_PLAINTEXT_SIZE, Botan::TLS::NO_RECORD, Botan::TLS::read_record(), Botan::TLS::Alert::RECORD_OVERFLOW, send_fatal_alert(), Botan::ASN1::to_string(), and Botan::TLS::TLS_Exception::type().

Referenced by Botan::TLS::Blocking_Client::do_handshake(), Botan::TLS::Blocking_Client::read(), and received_data().

285 {
286 try
287 {
288 while(!is_closed() && input_size)
289 {
290 secure_vector<uint8_t> record_data;
291 uint64_t record_sequence = 0;
292 Record_Type record_type = NO_RECORD;
293 Protocol_Version record_version;
294
295 size_t consumed = 0;
296
297 Record_Raw_Input raw_input(input, input_size, consumed, m_is_datagram);
298 Record record(record_data, &record_sequence, &record_version, &record_type);
299 const size_t needed =
300 read_record(m_readbuf,
301 raw_input,
302 record,
303 m_sequence_numbers.get(),
304 std::bind(&TLS::Channel::read_cipher_state_epoch, this,
305 std::placeholders::_1));
306
307 BOTAN_ASSERT(consumed > 0, "Got to eat something");
308
309 BOTAN_ASSERT(consumed <= input_size,
310 "Record reader consumed sane amount");
311
312 input += consumed;
313 input_size -= consumed;
314
315 BOTAN_ASSERT(input_size == 0 || needed == 0,
316 "Got a full record or consumed all input");
317
318 if(input_size == 0 && needed != 0)
319 return needed; // need more data to complete record
320
321 if(record_data.size() > MAX_PLAINTEXT_SIZE)
322 throw TLS_Exception(Alert::RECORD_OVERFLOW,
323 "TLS plaintext record is larger than allowed maximum");
324
325 if(record_type == HANDSHAKE || record_type == CHANGE_CIPHER_SPEC)
326 {
327 process_handshake_ccs(record_data, record_sequence, record_type, record_version);
328 }
329 else if(record_type == APPLICATION_DATA)
330 {
331 process_application_data(record_sequence, record_data);
332 }
333 else if(record_type == ALERT)
334 {
335 process_alert(record_data);
336 }
337 else if(record_type != NO_RECORD)
338 throw Unexpected_Message("Unexpected record type " +
339 std::to_string(record_type) +
340 " from counterparty");
341 }
342
343 return 0; // on a record boundary
344 }
345 catch(TLS_Exception& e)
346 {
347 send_fatal_alert(e.type());
348 throw;
349 }
350 catch(Integrity_Failure&)
351 {
352 send_fatal_alert(Alert::BAD_RECORD_MAC);
353 throw;
354 }
355 catch(Decoding_Error&)
356 {
357 send_fatal_alert(Alert::DECODE_ERROR);
358 throw;
359 }
360 catch(...)
361 {
362 send_fatal_alert(Alert::INTERNAL_ERROR);
363 throw;
364 }
365 }
Botan::TLS::ALERT
Definition: tls_magic.h:31
Botan::TLS::MAX_PLAINTEXT_SIZE
Definition: tls_magic.h:22
Botan::TLS::read_record
size_t read_record(secure_vector< uint8_t > &readbuf, Record_Raw_Input &raw_input, Record &rec, Connection_Sequence_Numbers *sequence_numbers, get_cipherstate_fn get_cipherstate)
Definition: tls_record.cpp:494
Botan::TLS::Alert::INTERNAL_ERROR
Definition: tls_alert.h:49
Botan::TLS::APPLICATION_DATA
Definition: tls_magic.h:33
Botan::ASN1::to_string
std::string to_string(const BER_Object &obj)
Definition: asn1_obj.cpp:47
BOTAN_ASSERT
#define BOTAN_ASSERT(expr, assertion_made)
Definition: assert.h:27
Botan::TLS::Channel::is_closed
bool is_closed() const
Definition: tls_channel.cpp:245
Botan::TLS::Alert::DECODE_ERROR
Definition: tls_alert.h:44
Botan::TLS::Record_Type
Record_Type
Definition: tls_magic.h:29
Botan::TLS::Channel::send_fatal_alert
void send_fatal_alert(Alert::Type type)
Definition: tls_channel.h:145
Botan::TLS::CHANGE_CIPHER_SPEC
Definition: tls_magic.h:30
Botan::TLS::NO_RECORD
Definition: tls_magic.h:35
Botan::TLS::Alert::RECORD_OVERFLOW
Definition: tls_alert.h:32
Botan::TLS::HANDSHAKE
Definition: tls_magic.h:32
Botan::TLS::Alert::BAD_RECORD_MAC
Definition: tls_alert.h:30

size_t Botan::TLS::Channel::received_data | ( | const std::vector< uint8_t > & | buf | ) |

Inject TLS traffic received from counterparty

Returns
  a hint as the how many more bytes we need to process the current record (this may be 0 if on a record boundary)

Definition at line 279 of file tls_channel.cpp.

References received_data().

280 {
281 return this->received_data(buf.data(), buf.size());
282 }
Botan::TLS::Channel::received_data
size_t received_data(const uint8_t buf[], size_t buf_size)
Definition: tls_channel.cpp:284

void Botan::TLS::Channel::renegotiate | ( | bool | force_full_renegotiation = `false` | ) |

Attempt to renegotiate the session

Parameters

  force_full_renegotiation | if true, require a full renegotiation, otherwise allow session resumption

Definition at line 171 of file tls_channel.cpp.

References create_handshake_state(), and initiate_handshake().

172 {
173 if(pending_state()) // currently in handshake?
174 return;
175
176 if(auto active = active_state())
177 initiate_handshake(create_handshake_state(active->version()),
178 force_full_renegotiation);
179 else
180 throw Exception("Cannot renegotiate on inactive connection");
181 }
Botan::TLS::Channel::create_handshake_state
Handshake_State & create_handshake_state(Protocol_Version version)
Definition: tls_channel.cpp:112
Botan::TLS::Channel::initiate_handshake
virtual void initiate_handshake(Handshake_State &state, bool force_full_renegotiation)=0

RandomNumberGenerator& Botan::TLS::Channel::rng | ( |  | ) |
| inline protected

Definition at line 233 of file tls_channel.h.

References m_rng.

233 { return m_rng; }
m_rng
RandomNumberGenerator & m_rng
Definition: ecdh.cpp:52

bool Botan::TLS::Channel::save_session | ( | const Session & | session | ) | const
| inline protected

Definition at line 239 of file tls_channel.h.

239 { return callbacks().tls_session_established(session); }
Botan::TLS::Callbacks::tls_session_established
virtual bool tls_session_established(const Session &session)=0
Botan::TLS::Channel::callbacks
Callbacks & callbacks() const
Definition: tls_channel.h:241

void Botan::TLS::Channel::secure_renegotiation_check | ( | const Client_Hello * | client_hello | ) |
| protected

Definition at line 574 of file tls_channel.cpp.

References Botan::TLS::Alert::HANDSHAKE_FAILURE, Botan::TLS::Client_Hello::renegotiation_info(), Botan::TLS::Client_Hello::secure_renegotiation(), and secure_renegotiation_data_for_client_hello().

575 {
576 const bool secure_renegotiation = client_hello->secure_renegotiation();
577
578 if(auto active = active_state())
579 {
580 const bool active_sr = active->client_hello()->secure_renegotiation();
581
582 if(active_sr != secure_renegotiation)
583 throw TLS_Exception(Alert::HANDSHAKE_FAILURE,
584 "Client changed its mind about secure renegotiation");
585 }
586
587 if(secure_renegotiation)
588 {
589 const std::vector<uint8_t>& data = client_hello->renegotiation_info();
590
591 if(data != secure_renegotiation_data_for_client_hello())
592 throw TLS_Exception(Alert::HANDSHAKE_FAILURE,
593 "Client sent bad values for secure renegotiation");
594 }
595 }
Botan::TLS::Channel::secure_renegotiation_data_for_client_hello
std::vector< uint8_t > secure_renegotiation_data_for_client_hello() const
Definition: tls_channel.cpp:620
Botan::TLS::Alert::HANDSHAKE_FAILURE
Definition: tls_alert.h:34

void Botan::TLS::Channel::secure_renegotiation_check | ( | const Server_Hello * | server_hello | ) |
| protected

Definition at line 597 of file tls_channel.cpp.

References Botan::TLS::Alert::HANDSHAKE_FAILURE, Botan::TLS::Server_Hello::renegotiation_info(), Botan::TLS::Server_Hello::secure_renegotiation(), and secure_renegotiation_data_for_server_hello().

598 {
599 const bool secure_renegotiation = server_hello->secure_renegotiation();
600
601 if(auto active = active_state())
602 {
603 const bool active_sr = active->client_hello()->secure_renegotiation();
604
605 if(active_sr != secure_renegotiation)
606 throw TLS_Exception(Alert::HANDSHAKE_FAILURE,
607 "Server changed its mind about secure renegotiation");
608 }
609
610 if(secure_renegotiation)
611 {
612 const std::vector<uint8_t>& data = server_hello->renegotiation_info();
613
614 if(data != secure_renegotiation_data_for_server_hello())
615 throw TLS_Exception(Alert::HANDSHAKE_FAILURE,
616 "Server sent bad values for secure renegotiation");
617 }
618 }
Botan::TLS::Channel::secure_renegotiation_data_for_server_hello
std::vector< uint8_t > secure_renegotiation_data_for_server_hello() const
Definition: tls_channel.cpp:627
Botan::TLS::Alert::HANDSHAKE_FAILURE
Definition: tls_alert.h:34

std::vector< uint8_t > Botan::TLS::Channel::secure_renegotiation_data_for_client_hello | ( |  | ) | const
| protected

Definition at line 620 of file tls_channel.cpp.

Referenced by secure_renegotiation_check().

621 {
622 if(auto active = active_state())
623 return active->client_finished()->verify_data();
624 return std::vector<uint8_t>();
625 }

std::vector< uint8_t > Botan::TLS::Channel::secure_renegotiation_data_for_server_hello | ( |  | ) | const
| protected

Definition at line 627 of file tls_channel.cpp.

Referenced by secure_renegotiation_check().

628 {
629 if(auto active = active_state())
630 {
631 std::vector<uint8_t> buf = active->client_finished()->verify_data();
632 buf += active->server_finished()->verify_data();
633 return buf;
634 }
635
636 return std::vector<uint8_t>();
637 }

bool Botan::TLS::Channel::secure_renegotiation_supported | ( |  | ) | const

Returns
  true iff the counterparty supports the secure renegotiation extensions.

Definition at line 639 of file tls_channel.cpp.

640 {
641 if(auto active = active_state())
642 return active->server_hello()->secure_renegotiation();
643
644 if(auto pending = pending_state())
645 if(auto hello = pending->server_hello())
646 return hello->secure_renegotiation();
647
648 return false;
649 }

void Botan::TLS::Channel::send | ( | const uint8_t | buf[],
|  | size_t | buf_size
| ) |  |

Inject plaintext intended for counterparty Throws an exception if is_active() is false

Definition at line 538 of file tls_channel.cpp.

References Botan::TLS::APPLICATION_DATA, and is_active().

Referenced by send().

539 {
540 if(!is_active())
541 throw Exception("Data cannot be sent on inactive TLS connection");
542
543 send_record_array(sequence_numbers().current_write_epoch(),
544 APPLICATION_DATA, buf, buf_size);
545 }
Botan::TLS::APPLICATION_DATA
Definition: tls_magic.h:33
Botan::TLS::Channel::is_active
bool is_active() const
Definition: tls_channel.cpp:240

void Botan::TLS::Channel::send | ( | const std::string & | val | ) |

Inject plaintext intended for counterparty Throws an exception if is_active() is false

Definition at line 547 of file tls_channel.cpp.

References send().

548 {
549 this->send(reinterpret_cast<const uint8_t*>(string.c_str()), string.size());
550 }
Botan::TLS::Channel::send
void send(const uint8_t buf[], size_t buf_size)
Definition: tls_channel.cpp:538
template<typename Alloc >

void Botan::TLS::Channel::send | ( | const std::vector< unsigned char, Alloc > & | val | ) |
| inline

Inject plaintext intended for counterparty Throws an exception if is_active() is false

Definition at line 125 of file tls_channel.h.

126 {
127 send(val.data(), val.size());
128 }
Botan::TLS::Channel::send
void send(const uint8_t buf[], size_t buf_size)
Definition: tls_channel.cpp:538

void Botan::TLS::Channel::send_alert | ( | const Alert & | alert | ) |

Send a TLS alert message. If the alert is fatal, the internal state (keys, etc) will be reset.

Parameters

  alert | the Alert to send

Definition at line 552 of file tls_channel.cpp.

References Botan::TLS::ALERT, Botan::TLS::Alert::CLOSE_NOTIFY, is_closed(), Botan::TLS::Alert::is_fatal(), Botan::TLS::Alert::is_valid(), Botan::TLS::Alert::NO_RENEGOTIATION, Botan::TLS::Session_Manager::remove_entry(), Botan::TLS::Alert::serialize(), and Botan::TLS::Alert::type().

553 {
554 if(alert.is_valid() && !is_closed())
555 {
556 try
557 {
558 send_record(ALERT, alert.serialize());
559 }
560 catch(...) { /* swallow it */ }
561 }
562
563 if(alert.type() == Alert::NO_RENEGOTIATION)
564 m_pending_state.reset();
565
566 if(alert.is_fatal())
567 if(auto active = active_state())
568 m_session_manager.remove_entry(active->server_hello()->session_id());
569
570 if(alert.type() == Alert::CLOSE_NOTIFY || alert.is_fatal())
571 reset_state();
572 }
Botan::TLS::ALERT
Definition: tls_magic.h:31
Botan::TLS::Session_Manager::remove_entry
virtual void remove_entry(const std::vector< uint8_t > &session_id)=0
Botan::TLS::Channel::is_closed
bool is_closed() const
Definition: tls_channel.cpp:245
Botan::TLS::Alert::CLOSE_NOTIFY
Definition: tls_alert.h:28
Botan::TLS::Alert::NO_RENEGOTIATION
Definition: tls_alert.h:52

void Botan::TLS::Channel::send_fatal_alert | ( | Alert::Type | type | ) |
| inline

Send a fatal alert

Definition at line 145 of file tls_channel.h.

Referenced by received_data().

145 { send_alert(Alert(type, true)); }
type
MechanismType type
Definition: p11_mechanism.cpp:43
Botan::TLS::Channel::send_alert
void send_alert(const Alert &alert)
Definition: tls_channel.cpp:552

void Botan::TLS::Channel::send_warning_alert | ( | Alert::Type | type | ) |
| inline

Send a warning alert

Definition at line 140 of file tls_channel.h.

140 { send_alert(Alert(type, false)); }
type
MechanismType type
Definition: p11_mechanism.cpp:43
Botan::TLS::Channel::send_alert
void send_alert(const Alert &alert)
Definition: tls_channel.cpp:552

Session_Manager& Botan::TLS::Channel::session_manager | ( |  | ) |
| inline protected

Definition at line 235 of file tls_channel.h.

235 { return m_session_manager; }

bool Botan::TLS::Channel::timeout_check | ( |  | ) |

Perform a handshake timeout check. This does nothing unless this is a DTLS channel with a pending handshake state, in which case we check for timeout and potentially retransmit handshake packets.

Definition at line 162 of file tls_channel.cpp.

163 {
164 if(m_pending_state)
165 return m_pending_state->handshake_io().timeout_check();
166
167 //FIXME: scan cipher suites and remove epochs older than 2*MSL
168 return false;
169 }

## Member Data Documentation

size_t Botan::TLS::Channel::IO_BUF_DEFAULT_SIZE = 10*1024
| static

Definition at line 44 of file tls_channel.h.

The documentation for this class was generated from the following files:

- src/lib/tls/tls_channel.h
- src/lib/tls/tls_channel.cpp