Botan::TLS::Channel Class Reference

#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
virtual std::string	application_protocol () const =0
	Channel (Callbacks &callbacks, Session_Manager &session_manager, RandomNumberGenerator &rng, const Policy &policy, bool is_server, bool is_datagram, size_t io_buf_sz=IO_BUF_DEFAULT_SIZE)
	Channel (const Channel &)=delete
	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_server, bool is_datagram, size_t io_buf_sz=IO_BUF_DEFAULT_SIZE)
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 std::vector< uint8_t > &buf)
size_t	received_data (const uint8_t buf[], size_t buf_size)
void	renegotiate (bool force_full_renegotiation=false)
bool	secure_renegotiation_supported () const
void	send (const std::string &val)
template<typename Alloc >
void	send (const std::vector< unsigned char, Alloc > &val)
void	send (const uint8_t buf[], size_t buf_size)
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, bool epoch0_restart)=0
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

Generic interface for TLS endpoint

Definition at line 37 of file tls_channel.h.

Member Typedef Documentation

alert_cb

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

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

Definition at line 41 of file tls_channel.h.

handshake_cb

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

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

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

Definition at line 40 of file tls_channel.h.

Constructor & Destructor Documentation

Channel() [1/3]

Botan::TLS::Channel::Channel	(	Callbacks &	callbacks,
		Session_Manager &	session_manager,
		RandomNumberGenerator &	rng,
		const Policy &	policy,
		bool	is_server,
		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_server	whether this is a server session or not
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 26 of file tls_channel.cpp.

                                                 :
   m_is_server(is_server),
   m_is_datagram(is_datagram),
   m_callbacks(callbacks),
   m_session_manager(session_manager),
   m_policy(policy),
   m_rng(rng),
   m_has_been_closed(false)
   {
   init(reserved_io_buffer_size);
   }

Channel() [2/3]

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_server,
		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 44 of file tls_channel.cpp.

                                   :
    m_is_server(is_server),
    m_is_datagram(is_datagram),
    m_compat_callbacks(new Compat_Callbacks(
                          /*
                          this Channel constructor is also deprecated so its ok that it
                          relies on a deprecated API
                          */
                          Compat_Callbacks::SILENCE_DEPRECATION_WARNING::PLEASE,
                          out, app_data_cb, recv_alert_cb, hs_cb, hs_msg_cb)),
    m_callbacks(*m_compat_callbacks.get()),
    m_session_manager(session_manager),
    m_policy(policy),
    m_rng(rng),
    m_has_been_closed(false)
    {
    init(io_buf_sz);
    }

Channel() [3/3]

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

delete

~Channel()

Botan::TLS::Channel::~Channel ( )

virtual

Definition at line 107 of file tls_channel.cpp.

   {
   // So unique_ptr destructors run correctly
   }

Member Function Documentation

activate_session()

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

protected

Definition at line 291 of file tls_channel.cpp.

   {
   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();
   }

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

application_protocol()

virtual std::string Botan::TLS::Channel::application_protocol ( ) const

pure virtual

Implemented in Botan::TLS::Client, and Botan::TLS::Server.

callbacks()

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

inlineprotected

Definition at line 242 of file tls_channel.h.

{ return m_callbacks; }

Referenced by activate_session(), and save_session().

change_cipher_spec_reader()

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

protected

Definition at line 222 of file tls_channel.cpp.

   {
   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;
   }

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.

change_cipher_spec_writer()

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

protected

Definition at line 251 of file tls_channel.cpp.

   {
   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;
   }

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

close()

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

inline

Send a close notification alert

Definition at line 149 of file tls_channel.h.

{ send_warning_alert(Alert::CLOSE_NOTIFY); }

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

create_handshake_state()

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

protected

Definition at line 146 of file tls_channel.cpp.

   {
   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();
   }

References Botan::TLS::Policy::dtls_default_mtu(), Botan::TLS::Policy::dtls_initial_timeout(), Botan::TLS::Policy::dtls_maximum_timeout(), Botan::TLS::Protocol_Version::is_datagram_protocol(), new_handshake_state(), Botan::TLS::Alert::PROTOCOL_VERSION, and Botan::TLS::Protocol_Version::to_string().

Referenced by renegotiate().

get_peer_cert_chain()

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

protectedpure virtual

Referenced by peer_cert_chain().

initiate_handshake()

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

protectedpure virtual

Referenced by renegotiate().

inspect_handshake_message()

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

protected

is_active()

bool Botan::TLS::Channel::is_active

(

)

const

Returns

true iff the connection is active for sending application data

Definition at line 279 of file tls_channel.cpp.

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

References is_closed().

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

is_closed()

bool Botan::TLS::Channel::is_closed

(

)

const

Returns

true iff the connection has been definitely closed

Definition at line 286 of file tls_channel.cpp.

   {
   return m_has_been_closed;
   }

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

key_material_export()

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

   {
   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");
      }
   }

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

new_handshake_state()

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

protectedpure virtual

Referenced by create_handshake_state().

operator=()

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

delete

peer_cert_chain()

std::vector< X509_Certificate > Botan::TLS::Channel::peer_cert_chain

(

)

const

Returns

certificate chain of the peer (may be empty)

Definition at line 134 of file tls_channel.cpp.

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

References get_peer_cert_chain().

policy()

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

inlineprotected

Definition at line 238 of file tls_channel.h.

{ return m_policy; }

Referenced by received_data(), and renegotiate().

process_handshake_msg()

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, bool  epoch0_restart  )

protectedpure virtual

received_data() [1/2]

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

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

References received_data().

received_data() [2/2]

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

   {
   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;
      }
   }

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, policy(), Botan::TLS::Alert::PROTOCOL_VERSION, Botan::TLS::read_record(), Botan::TLS::Alert::RECORD_OVERFLOW, 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 received_data().

renegotiate()

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

   {
   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");
   }

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

reset_active_association_state()

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

protected

Definition at line 92 of file tls_channel.cpp.

   {
   // 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();
   }

References BOTAN_ASSERT_NOMSG.

rng()

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

inlineprotected

Definition at line 234 of file tls_channel.h.

{ return m_rng; }

save_session()

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

protected

Definition at line 141 of file tls_channel.cpp.

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

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

secure_renegotiation_check() [1/2]

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

protected

Definition at line 680 of file tls_channel.cpp.

   {
   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");
      }
   }

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().

secure_renegotiation_check() [2/2]

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

protected

Definition at line 703 of file tls_channel.cpp.

   {
   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");
      }
   }

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().

secure_renegotiation_data_for_client_hello()

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

protected

Definition at line 726 of file tls_channel.cpp.

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

Referenced by secure_renegotiation_check().

secure_renegotiation_data_for_server_hello()

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

protected

Definition at line 733 of file tls_channel.cpp.

   {
   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>();
   }

Referenced by secure_renegotiation_check().

secure_renegotiation_supported()

bool Botan::TLS::Channel::secure_renegotiation_supported

(

)

const

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 std::string &

val

)

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

Definition at line 646 of file tls_channel.cpp.

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

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

send() [2/3]

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 124 of file tls_channel.h.

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

send() [3/3]

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

   {
   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);
   }

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

Referenced by send().

send_alert()

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

   {
   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;
      }
   }

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().

send_fatal_alert()

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

inline

Send a fatal alert

Definition at line 144 of file tls_channel.h.

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

References type.

Referenced by received_data().

send_warning_alert()

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

inline

Send a warning alert

Definition at line 139 of file tls_channel.h.

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

References type.

session_manager()

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

inlineprotected

Definition at line 236 of file tls_channel.h.

{ return m_session_manager; }

timeout_check()

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 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

static

Definition at line 45 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