Botan::TLS::Client Class Reference

#include <tls_client.h>

Inheritance diagram for Botan::TLS::Client:

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
std::string	application_protocol () const override
	Client (Callbacks &callbacks, Session_Manager &session_manager, Credentials_Manager &creds, const Policy &policy, RandomNumberGenerator &rng, const Server_Information &server_info=Server_Information(), const Protocol_Version &offer_version=Protocol_Version::latest_tls_version(), const std::vector< std::string > &next_protocols={}, size_t reserved_io_buffer_size=TLS::Client::IO_BUF_DEFAULT_SIZE)
	Client (output_fn data_output_fn, data_cb app_data_cb, alert_cb recv_alert_cb, handshake_cb hs_cb, Session_Manager &session_manager, Credentials_Manager &creds, const Policy &policy, RandomNumberGenerator &rng, const Server_Information &server_info=Server_Information(), const Protocol_Version &offer_version=Protocol_Version::latest_tls_version(), const std::vector< std::string > &next_protocols={}, size_t reserved_io_buffer_size=TLS::Client::IO_BUF_DEFAULT_SIZE)
	Client (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, Credentials_Manager &creds, const Policy &policy, RandomNumberGenerator &rng, const Server_Information &server_info=Server_Information(), const Protocol_Version &offer_version=Protocol_Version::latest_tls_version(), const std::vector< std::string > &next_protocols={})
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
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 ()

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)
void	inspect_handshake_message (const Handshake_Message &msg)
const Policy &	policy () const
void	reset_active_association_state ()
RandomNumberGenerator &	rng ()
bool	save_session (const Session &session)
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

SSL/TLS Client

Definition at line 24 of file tls_client.h.

Member Typedef Documentation

alert_cb

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

inherited

Definition at line 42 of file tls_channel.h.

data_cb

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

inherited

Definition at line 41 of file tls_channel.h.

handshake_cb

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

inherited

Definition at line 43 of file tls_channel.h.

handshake_msg_cb

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

inherited

Definition at line 44 of file tls_channel.h.

output_fn

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

inherited

Definition at line 40 of file tls_channel.h.

Constructor & Destructor Documentation

Client() [1/3]

Botan::TLS::Client::Client	(	Callbacks &	callbacks,
		Session_Manager &	session_manager,
		Credentials_Manager &	creds,
		const Policy &	policy,
		RandomNumberGenerator &	rng,
		const Server_Information &	server_info = Server_Information(),
		const Protocol_Version &	offer_version = Protocol_Version::latest_tls_version(),
		const std::vector< std::string > &	next_protocols = {},
		size_t	reserved_io_buffer_size = TLS::Client::IO_BUF_DEFAULT_SIZE
	)

Set up a new TLS client session

Parameters

callbacks	contains a set of callback function references required by the TLS client.
session_manager	manages session state
creds	manages application/user credentials
policy	specifies other connection policy information
rng	a random number generator
server_info	is identifying information about the TLS server
offer_version	specifies which version we will offer to the TLS server.
next_protocols	specifies protocols to advertise with ALPN
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.

Definition at line 64 of file tls_client.cpp.

                                 :
   Channel(callbacks, session_manager, rng, policy,
           false, offer_version.is_datagram_protocol(), io_buf_sz),
   m_creds(creds),
   m_info(info)
   {
   init(offer_version, next_protos);
   }

Client() [2/3]

Botan::TLS::Client::Client	(	output_fn	data_output_fn,
		data_cb	app_data_cb,
		alert_cb	recv_alert_cb,
		handshake_cb	hs_cb,
		Session_Manager &	session_manager,
		Credentials_Manager &	creds,
		const Policy &	policy,
		RandomNumberGenerator &	rng,
		const Server_Information &	server_info = Server_Information(),
		const Protocol_Version &	offer_version = Protocol_Version::latest_tls_version(),
		const std::vector< std::string > &	next_protocols = {},
		size_t	reserved_io_buffer_size = TLS::Client::IO_BUF_DEFAULT_SIZE
	)

DEPRECATED. This constructor is only provided for backward compatibility and should not be used in new code. It will be removed in a future release.

Set up a new TLS client session

Parameters

data_output_fn	is called with data for the outbound socket
app_data_cb	is called when new application data is received
recv_alert_cb	is called when a TLS alert is received
hs_cb	is called when a handshake is completed
session_manager	manages session state
creds	manages application/user credentials
policy	specifies other connection policy information
rng	a random number generator
server_info	is identifying information about the TLS server
offer_version	specifies which version we will offer to the TLS server.
next_protocols	specifies protocols to advertise with ALPN
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.

Definition at line 81 of file tls_client.cpp.

                                 :
   Channel(data_output_fn, proc_cb, recv_alert_cb, hs_cb, Channel::handshake_msg_cb(),
           session_manager, rng, policy, false, offer_version.is_datagram_protocol(), io_buf_sz),
   m_creds(creds),
   m_info(info)
   {
   init(offer_version, next_protos);
   }

Client() [3/3]

Botan::TLS::Client::Client	(	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,
		Credentials_Manager &	creds,
		const Policy &	policy,
		RandomNumberGenerator &	rng,
		const Server_Information &	server_info = Server_Information(),
		const Protocol_Version &	offer_version = Protocol_Version::latest_tls_version(),
		const std::vector< std::string > &	next_protocols = {}
	)

DEPRECATED. This constructor is only provided for backward compatibility and should not be used in new implementations.

Definition at line 101 of file tls_client.cpp.

                                                        :
   Channel(data_output_fn, proc_cb, recv_alert_cb, hs_cb, hs_msg_cb,
           session_manager, rng, policy, false, offer_version.is_datagram_protocol()),
   m_creds(creds),
   m_info(info)
   {
   init(offer_version, next_protos);
   }

Member Function Documentation

activate_session()

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

protectedinherited

Definition at line 291 of file tls_channel.cpp.

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

   {
   std::swap(m_active_state, m_pending_state);
   m_pending_state.reset();

   if(!m_active_state->version().is_datagram_protocol())
      {
      // TLS is easy just remove all but the current state
      const uint16_t current_epoch = sequence_numbers().current_write_epoch();

      const auto not_current_epoch =
         [current_epoch](uint16_t epoch) { return (epoch != current_epoch); };

      map_remove_if(not_current_epoch, m_write_cipher_states);
      map_remove_if(not_current_epoch, m_read_cipher_states);
      }

   callbacks().tls_session_activated();
   }

application_protocol()

std::string Botan::TLS::Client::application_protocol ( ) const

inlineoverridevirtual

Returns

network protocol as advertised by the TLS server, if server sent the ALPN extension

Implements Botan::TLS::Channel.

Definition at line 135 of file tls_client.h.

{ return m_application_protocol; }

callbacks()

Callbacks& Botan::TLS::Channel::callbacks ( ) const

inlineprotectedinherited

Definition at line 242 of file tls_channel.h.

Referenced by Botan::TLS::Channel::activate_session(), and Botan::TLS::Channel::save_session().

{ return m_callbacks; }

change_cipher_spec_reader()

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

protectedinherited

Definition at line 222 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(), and Botan::TLS::SERVER.

   {
   auto pending = pending_state();

   BOTAN_ASSERT(pending && pending->server_hello(),
                "Have received server hello");

   if(pending->server_hello()->compression_method() != 0)
      throw Internal_Error("Negotiated unknown compression algorithm");

   sequence_numbers().new_read_cipher_state();

   const uint16_t epoch = sequence_numbers().current_read_epoch();

   BOTAN_ASSERT(m_read_cipher_states.count(epoch) == 0,
                "No read cipher state currently set for next epoch");

   // flip side as we are reading
   std::shared_ptr<Connection_Cipher_State> read_state(
      new Connection_Cipher_State(pending->version(),
                                  (side == CLIENT) ? SERVER : CLIENT,
                                  false,
                                  pending->ciphersuite(),
                                  pending->session_keys(),
                                  pending->server_hello()->supports_encrypt_then_mac()));

   m_read_cipher_states[epoch] = read_state;
   }

change_cipher_spec_writer()

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

protectedinherited

Definition at line 251 of file tls_channel.cpp.

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

   {
   auto pending = pending_state();

   BOTAN_ASSERT(pending && pending->server_hello(),
                "Have received server hello");

   if(pending->server_hello()->compression_method() != 0)
      throw Internal_Error("Negotiated unknown compression algorithm");

   sequence_numbers().new_write_cipher_state();

   const uint16_t epoch = sequence_numbers().current_write_epoch();

   BOTAN_ASSERT(m_write_cipher_states.count(epoch) == 0,
                "No write cipher state currently set for next epoch");

   std::shared_ptr<Connection_Cipher_State> write_state(
      new Connection_Cipher_State(pending->version(),
                                  side,
                                  true,
                                  pending->ciphersuite(),
                                  pending->session_keys(),
                                  pending->server_hello()->supports_encrypt_then_mac()));

   m_write_cipher_states[epoch] = write_state;
   }

close()

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

inlineinherited

Send a close notification alert

Definition at line 149 of file tls_channel.h.

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

{ send_warning_alert(Alert::CLOSE_NOTIFY); }

create_handshake_state()

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

protectedinherited

Definition at line 146 of file tls_channel.cpp.

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

Referenced by Botan::TLS::Channel::renegotiate().

   {
   if(pending_state())
      throw Internal_Error("create_handshake_state called during handshake");

   if(auto active = active_state())
      {
      Protocol_Version active_version = active->version();

      if(active_version.is_datagram_protocol() != version.is_datagram_protocol())
         {
         throw TLS_Exception(Alert::PROTOCOL_VERSION,
                             "Active state using version " + active_version.to_string() +
                             " cannot change to " + version.to_string() + " in pending");
         }
      }

   if(!m_sequence_numbers)
      {
      if(version.is_datagram_protocol())
         m_sequence_numbers.reset(new Datagram_Sequence_Numbers);
      else
         m_sequence_numbers.reset(new Stream_Sequence_Numbers);
      }

   using namespace std::placeholders;

   std::unique_ptr<Handshake_IO> io;
   if(version.is_datagram_protocol())
      {
      io.reset(new Datagram_Handshake_IO(
                  std::bind(&Channel::send_record_under_epoch, this, _1, _2, _3),
                  sequence_numbers(),
                  static_cast<uint16_t>(m_policy.dtls_default_mtu()),
                  m_policy.dtls_initial_timeout(),
                  m_policy.dtls_maximum_timeout()));
      }
   else
      {
      io.reset(new Stream_Handshake_IO(std::bind(&Channel::send_record, this, _1, _2)));
      }

   m_pending_state.reset(new_handshake_state(io.release()));

   if(auto active = active_state())
      m_pending_state->set_version(active->version());

   return *m_pending_state.get();
   }

inspect_handshake_message()

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

protectedinherited

is_active()

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

inherited

Returns

true iff the connection is active for sending application data

Definition at line 279 of file tls_channel.cpp.

References Botan::TLS::Channel::is_closed().

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

   {
   if(is_closed())
      return false;
   return (active_state() != nullptr);
   }

is_closed()

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

inherited

Returns

true iff the connection has been definitely closed

Definition at line 286 of file tls_channel.cpp.

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

   {
   return m_has_been_closed;
   }

key_material_export()

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

inherited

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 757 of file tls_channel.cpp.

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

   {
   if(auto active = active_state())
      {
      if(pending_state() != nullptr)
         throw Invalid_State("Channel::key_material_export cannot export during renegotiation");

      std::unique_ptr<KDF> prf(active->protocol_specific_prf());

      const secure_vector<uint8_t>& master_secret =
         active->session_keys().master_secret();

      std::vector<uint8_t> salt;
      salt += active->client_hello()->random();
      salt += active->server_hello()->random();

      if(context != "")
         {
         size_t context_size = context.length();
         if(context_size > 0xFFFF)
            throw Invalid_Argument("key_material_export context is too long");
         salt.push_back(get_byte(0, static_cast<uint16_t>(context_size)));
         salt.push_back(get_byte(1, static_cast<uint16_t>(context_size)));
         salt += to_byte_vector(context);
         }

      return prf->derive_key(length, master_secret, salt, to_byte_vector(label));
      }
   else
      {
      throw Invalid_State("Channel::key_material_export connection not active");
      }
   }

peer_cert_chain()

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

inherited

Returns

certificate chain of the peer (may be empty)

Definition at line 134 of file tls_channel.cpp.

References Botan::TLS::Channel::get_peer_cert_chain().

   {
   if(auto active = active_state())
      return get_peer_cert_chain(*active);
   return std::vector<X509_Certificate>();
   }

policy()

const Policy& Botan::TLS::Channel::policy ( ) const

inlineprotectedinherited

Definition at line 238 of file tls_channel.h.

Referenced by Botan::TLS::Channel::received_data(), and Botan::TLS::Channel::renegotiate().

{ return m_policy; }

received_data() [1/2]

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

inherited

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 316 of file tls_channel.cpp.

References Botan::TLS::ALERT, Botan::TLS::Policy::allow_dtls_epoch0_restart(), Botan::TLS::APPLICATION_DATA, Botan::TLS::Alert::BAD_RECORD_MAC, BOTAN_ASSERT, BOTAN_ASSERT_IMPLICATION, Botan::TLS::CHANGE_CIPHER_SPEC, Botan::TLS::Alert::DECODE_ERROR, Botan::TLS::Record_Header::epoch(), Botan::TLS::HANDSHAKE, Botan::TLS::Alert::INTERNAL_ERROR, Botan::TLS::Protocol_Version::major_version(), Botan::TLS::MAX_PLAINTEXT_SIZE, Botan::TLS::Record_Header::needed(), Botan::TLS::NO_RECORD, Botan::TLS::Channel::policy(), Botan::TLS::Alert::PROTOCOL_VERSION, Botan::TLS::read_record(), Botan::TLS::Alert::RECORD_OVERFLOW, Botan::TLS::Channel::send_fatal_alert(), Botan::TLS::Record_Header::sequence(), Botan::ASN1::to_string(), Botan::TLS::TLS_Exception::type(), Botan::TLS::Record_Header::type(), Botan::TLS::Alert::UNEXPECTED_MESSAGE, and Botan::TLS::Record_Header::version().

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

   {
   const bool allow_epoch0_restart = m_is_datagram && m_is_server && policy().allow_dtls_epoch0_restart();

   try
      {
      while(input_size)
         {
         size_t consumed = 0;

         auto get_epoch = [this](uint16_t epoch) { return read_cipher_state_epoch(epoch); };

         const Record_Header record =
            read_record(m_is_datagram,
                        m_readbuf,
                        input,
                        input_size,
                        consumed,
                        m_record_buf,
                        m_sequence_numbers.get(),
                        get_epoch,
                        allow_epoch0_restart);

         const size_t needed = record.needed();

         BOTAN_ASSERT(consumed > 0, "Got to eat something");

         BOTAN_ASSERT(consumed <= input_size,
                      "Record reader consumed sane amount");

         input += consumed;
         input_size -= consumed;

         BOTAN_ASSERT(input_size == 0 || needed == 0,
                      "Got a full record or consumed all input");

         if(input_size == 0 && needed != 0)
            return needed; // need more data to complete record

         // Ignore invalid records in DTLS
         if(m_is_datagram && record.type() == NO_RECORD)
            {
            return 0;
            }

         if(m_record_buf.size() > MAX_PLAINTEXT_SIZE)
            throw TLS_Exception(Alert::RECORD_OVERFLOW,
                                "TLS plaintext record is larger than allowed maximum");


         const bool epoch0_restart = m_is_datagram && record.epoch() == 0 && active_state();
         BOTAN_ASSERT_IMPLICATION(epoch0_restart, allow_epoch0_restart, "Allowed state");

         const bool initial_record = epoch0_restart || (!pending_state() && !active_state());

         if(record.type() != ALERT)
            {
            if(initial_record)
               {
               // For initial records just check for basic sanity
               if(record.version().major_version() != 3 &&
                  record.version().major_version() != 0xFE)
                  {
                  throw TLS_Exception(Alert::PROTOCOL_VERSION,
                                      "Received unexpected record version in initial record");
                  }
               }
            else if(auto pending = pending_state())
               {
               if(pending->server_hello() != nullptr && record.version() != pending->version())
                  {
                  if(record.version() != pending->version())
                     {
                     throw TLS_Exception(Alert::PROTOCOL_VERSION,
                                         "Received unexpected record version");
                     }
                  }
               }
            else if(auto active = active_state())
               {
               if(record.version() != active->version())
                  {
                  throw TLS_Exception(Alert::PROTOCOL_VERSION,
                                      "Received unexpected record version");
                  }
               }
            }

         if(record.type() == HANDSHAKE || record.type() == CHANGE_CIPHER_SPEC)
            {
            if(m_has_been_closed)
               throw TLS_Exception(Alert::UNEXPECTED_MESSAGE, "Received handshake data after connection closure");
            process_handshake_ccs(m_record_buf, record.sequence(), record.type(), record.version(), epoch0_restart);
            }
         else if(record.type() == APPLICATION_DATA)
            {
            if(m_has_been_closed)
               throw TLS_Exception(Alert::UNEXPECTED_MESSAGE, "Received application data after connection closure");
            if(pending_state() != nullptr)
               throw TLS_Exception(Alert::UNEXPECTED_MESSAGE, "Can't interleave application and handshake data");
            process_application_data(record.sequence(), m_record_buf);
            }
         else if(record.type() == ALERT)
            {
            process_alert(m_record_buf);
            }
         else if(record.type() != NO_RECORD)
            throw Unexpected_Message("Unexpected record type " +
                                     std::to_string(record.type()) +
                                     " from counterparty");
         }

      return 0; // on a record boundary
      }
   catch(TLS_Exception& e)
      {
      send_fatal_alert(e.type());
      throw;
      }
   catch(Invalid_Authentication_Tag&)
      {
      send_fatal_alert(Alert::BAD_RECORD_MAC);
      throw;
      }
   catch(Decoding_Error&)
      {
      send_fatal_alert(Alert::DECODE_ERROR);
      throw;
      }
   catch(...)
      {
      send_fatal_alert(Alert::INTERNAL_ERROR);
      throw;
      }
   }

received_data() [2/2]

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

inherited

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 311 of file tls_channel.cpp.

References Botan::TLS::Channel::received_data().

   {
   return this->received_data(buf.data(), buf.size());
   }

renegotiate()

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

inherited

Attempt to renegotiate the session

Parameters

force_full_renegotiation

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

Definition at line 205 of file tls_channel.cpp.

References Botan::TLS::Policy::allow_resumption_for_renegotiation(), Botan::TLS::Channel::create_handshake_state(), Botan::TLS::Channel::initiate_handshake(), and Botan::TLS::Channel::policy().

   {
   if(pending_state()) // currently in handshake?
      return;

   if(auto active = active_state())
      {
      if(force_full_renegotiation == false)
         force_full_renegotiation = !policy().allow_resumption_for_renegotiation();

      initiate_handshake(create_handshake_state(active->version()),
                         force_full_renegotiation);
      }
   else
      throw Invalid_State("Cannot renegotiate on inactive connection");
   }

reset_active_association_state()

void Botan::TLS::Channel::reset_active_association_state ( )

protectedinherited

Definition at line 92 of file tls_channel.cpp.

References BOTAN_ASSERT_NOMSG.

   {
   // This operation only makes sense for DTLS
   BOTAN_ASSERT_NOMSG(m_is_datagram);
   m_active_state.reset();
   m_read_cipher_states.clear();
   m_write_cipher_states.clear();

   m_write_cipher_states[0] = nullptr;
   m_read_cipher_states[0] = nullptr;

   if(m_sequence_numbers)
      m_sequence_numbers->reset();
   }

rng()

RandomNumberGenerator& Botan::TLS::Channel::rng ( )

inlineprotectedinherited

Definition at line 234 of file tls_channel.h.

{ return m_rng; }

save_session()

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

protectedinherited

Definition at line 141 of file tls_channel.cpp.

References Botan::TLS::Channel::callbacks(), and Botan::TLS::Callbacks::tls_session_established().

   {
   return callbacks().tls_session_established(session);
   }

secure_renegotiation_check() [1/2]

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

protectedinherited

Definition at line 680 of file tls_channel.cpp.

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

   {
   const bool secure_renegotiation = client_hello->secure_renegotiation();

   if(auto active = active_state())
      {
      const bool active_sr = active->client_hello()->secure_renegotiation();

      if(active_sr != secure_renegotiation)
         throw TLS_Exception(Alert::HANDSHAKE_FAILURE,
                             "Client changed its mind about secure renegotiation");
      }

   if(secure_renegotiation)
      {
      const std::vector<uint8_t>& data = client_hello->renegotiation_info();

      if(data != secure_renegotiation_data_for_client_hello())
         throw TLS_Exception(Alert::HANDSHAKE_FAILURE,
                             "Client sent bad values for secure renegotiation");
      }
   }

secure_renegotiation_check() [2/2]

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

protectedinherited

Definition at line 703 of file tls_channel.cpp.

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

   {
   const bool secure_renegotiation = server_hello->secure_renegotiation();

   if(auto active = active_state())
      {
      const bool active_sr = active->server_hello()->secure_renegotiation();

      if(active_sr != secure_renegotiation)
         throw TLS_Exception(Alert::HANDSHAKE_FAILURE,
                             "Server changed its mind about secure renegotiation");
      }

   if(secure_renegotiation)
      {
      const std::vector<uint8_t>& data = server_hello->renegotiation_info();

      if(data != secure_renegotiation_data_for_server_hello())
         throw TLS_Exception(Alert::HANDSHAKE_FAILURE,
                             "Server sent bad values for secure renegotiation");
      }
   }

secure_renegotiation_data_for_client_hello()

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

protectedinherited

Definition at line 726 of file tls_channel.cpp.

Referenced by Botan::TLS::Channel::secure_renegotiation_check().

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

secure_renegotiation_data_for_server_hello()

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

protectedinherited

Definition at line 733 of file tls_channel.cpp.

Referenced by Botan::TLS::Channel::secure_renegotiation_check().

   {
   if(auto active = active_state())
      {
      std::vector<uint8_t> buf = active->client_finished()->verify_data();
      buf += active->server_finished()->verify_data();
      return buf;
      }

   return std::vector<uint8_t>();
   }

secure_renegotiation_supported()

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

inherited

Returns

true iff the counterparty supports the secure renegotiation extensions.

Definition at line 745 of file tls_channel.cpp.

   {
   if(auto active = active_state())
      return active->server_hello()->secure_renegotiation();

   if(auto pending = pending_state())
      if(auto hello = pending->server_hello())
         return hello->secure_renegotiation();

   return false;
   }

send() [1/3]

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

inherited

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

Definition at line 637 of file tls_channel.cpp.

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

Referenced by Botan::TLS::Channel::send().

   {
   if(!is_active())
      throw Invalid_State("Data cannot be sent on inactive TLS connection");

   send_record_array(sequence_numbers().current_write_epoch(),
                     APPLICATION_DATA, buf, buf_size);
   }

send() [2/3]

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

inherited

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

Definition at line 646 of file tls_channel.cpp.

References Botan::cast_char_ptr_to_uint8(), and Botan::TLS::Channel::send().

   {
   this->send(cast_char_ptr_to_uint8(string.data()), string.size());
   }

send() [3/3]

template<typename Alloc >

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

inlineinherited

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

Definition at line 124 of file tls_channel.h.

         {
         send(val.data(), val.size());
         }

send_alert()

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

inherited

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 651 of file tls_channel.cpp.

References Botan::TLS::ALERT, Botan::TLS::Alert::CLOSE_NOTIFY, Botan::TLS::Channel::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().

   {
   if(alert.is_valid() && !is_closed())
      {
      try
         {
         send_record(ALERT, alert.serialize());
         }
      catch(...) { /* swallow it */ }
      }

   if(alert.type() == Alert::NO_RENEGOTIATION)
      m_pending_state.reset();

   if(alert.is_fatal())
   {
      if(auto active = active_state())
      {
         m_session_manager.remove_entry(active->server_hello()->session_id());
      }
      reset_state();
   }

   if(alert.type() == Alert::CLOSE_NOTIFY || alert.is_fatal())
      {
      m_has_been_closed = true;
      }
   }

send_fatal_alert()

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

inlineinherited

Send a fatal alert

Definition at line 144 of file tls_channel.h.

References type.

Referenced by Botan::TLS::Channel::received_data().

{ send_alert(Alert(type, true)); }

send_warning_alert()

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

inlineinherited

Send a warning alert

Definition at line 139 of file tls_channel.h.

References type.

{ send_alert(Alert(type, false)); }

session_manager()

Session_Manager& Botan::TLS::Channel::session_manager ( )

inlineprotectedinherited

Definition at line 236 of file tls_channel.h.

{ return m_session_manager; }

timeout_check()

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

inherited

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 196 of file tls_channel.cpp.

   {
   if(m_pending_state)
      return m_pending_state->handshake_io().timeout_check();

   //FIXME: scan cipher suites and remove epochs older than 2*MSL
   return false;
   }

Member Data Documentation

IO_BUF_DEFAULT_SIZE

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

staticinherited

Definition at line 45 of file tls_channel.h.

---

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

• src/lib/tls/tls_client.h
• src/lib/tls/tls_client.cpp