Botan  2.1.0
Crypto and TLS for C++11
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:
Botan::TLS::Client Botan::TLS::Server

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
 
Channeloperator= (const Channel &)=delete
 
std::vector< X509_Certificatepeer_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 ()
 
Callbackscallbacks () const
 
void change_cipher_spec_reader (Connection_Side side)
 
void change_cipher_spec_writer (Connection_Side side)
 
Handshake_Statecreate_handshake_state (Protocol_Version version)
 
virtual std::vector< X509_Certificateget_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_Statenew_handshake_state (class Handshake_IO *io)=0
 
const Policypolicy () 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
 
RandomNumberGeneratorrng ()
 
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_Managersession_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
callbackscontains a set of callback function references required by the TLS endpoint.
session_managermanages session state
rnga random number generator
policyspecifies other connection policy information
is_datagramwhether this is a DTLS session
io_buf_szThis 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  }
Callbacks & callbacks() const
Definition: tls_channel.h:241
RandomNumberGenerator & rng()
Definition: tls_channel.h:233
RandomNumberGenerator & m_rng
Definition: ecdh.cpp:52
const Policy & policy() const
Definition: tls_channel.h:237
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  }
std::function< void(Alert, const uint8_t[], size_t)> alert_cb
Definition: tls_channel.h:41
RandomNumberGenerator & rng()
Definition: tls_channel.h:233
RandomNumberGenerator & m_rng
Definition: ecdh.cpp:52
const Policy & policy() const
Definition: tls_channel.h:237
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 
277  }
Callbacks & callbacks() const
Definition: tls_channel.h:241
virtual void tls_session_activated()
Definition: tls_callbacks.h:92
void map_remove_if(Pred pred, T &assoc)
Definition: stl_util.h:96
virtual uint16_t current_write_epoch() const =0
Callbacks& Botan::TLS::Channel::callbacks ( ) const
inlineprotected

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  }
#define BOTAN_ASSERT(expr, assertion_made)
Definition: assert.h:27
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  }
#define BOTAN_ASSERT(expr, assertion_made)
Definition: assert.h:27
virtual uint16_t current_write_epoch() const =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.

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  }
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
protectedpure virtual

Referenced by peer_cert_chain().

virtual void Botan::TLS::Channel::initiate_handshake ( Handshake_State state,
bool  force_full_renegotiation 
)
protectedpure 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
labela disambiguating label string
contexta per-association context value
lengththe 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  }
std::vector< uint8_t > to_byte_vector(const std::string &s)
Definition: stl_util.h:20
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)
protectedpure 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  }
virtual std::vector< X509_Certificate > get_peer_cert_chain(const Handshake_State &state) const =0
const Policy& Botan::TLS::Channel::policy ( ) const
inlineprotected

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 
)
protectedpure 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  {
353  throw;
354  }
355  catch(Decoding_Error&)
356  {
358  throw;
359  }
360  catch(...)
361  {
363  throw;
364  }
365  }
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
std::string to_string(const BER_Object &obj)
Definition: asn1_obj.cpp:47
#define BOTAN_ASSERT(expr, assertion_made)
Definition: assert.h:27
bool is_closed() const
void send_fatal_alert(Alert::Type type)
Definition: tls_channel.h:145
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  }
size_t received_data(const uint8_t buf[], size_t buf_size)
void Botan::TLS::Channel::renegotiate ( bool  force_full_renegotiation = false)

Attempt to renegotiate the session

Parameters
force_full_renegotiationif 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  }
Handshake_State & create_handshake_state(Protocol_Version version)
virtual void initiate_handshake(Handshake_State &state, bool force_full_renegotiation)=0
RandomNumberGenerator& Botan::TLS::Channel::rng ( )
inlineprotected

Definition at line 233 of file tls_channel.h.

References m_rng.

233 { return m_rng; }
RandomNumberGenerator & m_rng
Definition: ecdh.cpp:52
bool Botan::TLS::Channel::save_session ( const Session session) const
inlineprotected

Definition at line 239 of file tls_channel.h.

239 { return callbacks().tls_session_established(session); }
virtual bool tls_session_established(const Session &session)=0
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 
592  throw TLS_Exception(Alert::HANDSHAKE_FAILURE,
593  "Client sent bad values for secure renegotiation");
594  }
595  }
std::vector< uint8_t > secure_renegotiation_data_for_client_hello() const
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 
615  throw TLS_Exception(Alert::HANDSHAKE_FAILURE,
616  "Server sent bad values for secure renegotiation");
617  }
618  }
std::vector< uint8_t > secure_renegotiation_data_for_server_hello() const
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  }
bool is_active() const
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  }
void send(const uint8_t buf[], size_t buf_size)
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  }
void send(const uint8_t buf[], size_t buf_size)
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
alertthe 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  }
virtual void remove_entry(const std::vector< uint8_t > &session_id)=0
bool is_closed() const
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)); }
MechanismType type
void send_alert(const Alert &alert)
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)); }
MechanismType type
void send_alert(const Alert &alert)
Session_Manager& Botan::TLS::Channel::session_manager ( )
inlineprotected

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: