Botan::TLS::Datagram_Handshake_IO Class Reference

#include <tls_handshake_io.h>

Inheritance diagram for Botan::TLS::Datagram_Handshake_IO:

Public Types
typedef std::function< void(uint16_t, Record_Type, const std::vector< uint8_t > &)>	writer_fn

Public Member Functions
void	add_record (const uint8_t record[], size_t record_len, Record_Type type, uint64_t sequence_number) override
	Datagram_Handshake_IO (writer_fn writer, class Connection_Sequence_Numbers &seq, uint16_t mtu, uint64_t initial_timeout_ms, uint64_t max_timeout_ms, size_t max_handshake_msg_size)
std::vector< uint8_t >	format (const std::vector< uint8_t > &handshake_msg, Handshake_Type handshake_type) const override
std::pair< Handshake_Type, std::vector< uint8_t > >	get_next_record (bool expecting_ccs, size_t max_message_size) override
bool	have_more_data () const override
Protocol_Version	initial_record_version () const override
std::vector< uint8_t >	send (const Handshake_Message &msg) override
std::vector< uint8_t >	send_under_epoch (const Handshake_Message &msg, uint16_t epoch) override
bool	timeout_check () override

Detailed Description

Handshake IO for datagram-based handshakes

Definition at line 114 of file tls_handshake_io.h.

Member Typedef Documentation

writer_fn

typedef std::function<void(uint16_t, Record_Type, const std::vector<uint8_t>&)> Botan::TLS::Datagram_Handshake_IO::writer_fn

Definition at line 116 of file tls_handshake_io.h.

Constructor & Destructor Documentation

Datagram_Handshake_IO()

Botan::TLS::Datagram_Handshake_IO::Datagram_Handshake_IO ( writer_fn writer, class Connection_Sequence_Numbers & seq, uint16_t mtu, uint64_t initial_timeout_ms, uint64_t max_timeout_ms, size_t max_handshake_msg_size )

inline

Definition at line 118 of file tls_handshake_io.h.

                                                           :
            m_seqs(seq),
            m_flights(1),
            m_initial_timeout(initial_timeout_ms),
            m_max_timeout(max_timeout_ms),
            m_send_hs(std::move(writer)),
            m_mtu(mtu),
            m_max_handshake_msg_size(max_handshake_msg_size) {}

Member Function Documentation

add_record()

void Botan::TLS::Datagram_Handshake_IO::add_record ( const uint8_t record[], size_t record_len, Record_Type type, uint64_t sequence_number )

overridevirtual

Implements Botan::TLS::Handshake_IO.

Definition at line 204 of file tls_handshake_io.cpp.

                                                                 {
   const uint16_t epoch = static_cast<uint16_t>(record_sequence >> 48);
 
   if(record_type == Record_Type::ChangeCipherSpec) {
      if(record_len != 1 || record[0] != 1) {
         throw Decoding_Error("Invalid ChangeCipherSpec");
      }
 
      // TODO: check this is otherwise empty
      m_ccs_epochs.insert(epoch);
      return;
   }
 
   const size_t DTLS_HANDSHAKE_HEADER_LEN = 12;
 
   while(record_len > 0) {
      if(record_len < DTLS_HANDSHAKE_HEADER_LEN) {
         return;  // completely bogus? at least degenerate/weird
      }
 
      const Handshake_Type msg_type = static_cast<Handshake_Type>(record[0]);
 
      verify_is_expected_wire_handshake_type(msg_type);
 
      const size_t msg_len = load_be24(&record[1]);
 
      if(m_max_handshake_msg_size > 0 && msg_len > m_max_handshake_msg_size) {
         throw TLS_Exception(
            Alert::HandshakeFailure,
            Botan::fmt("Handshake message is {} bytes, policy maximum is {}", msg_len, m_max_handshake_msg_size));
      }
 
      const uint16_t message_seq = load_be<uint16_t>(&record[4], 0);
      const size_t fragment_offset = load_be24(&record[6]);
      const size_t fragment_length = load_be24(&record[9]);
 
      const size_t total_size = DTLS_HANDSHAKE_HEADER_LEN + fragment_length;
 
      if(record_len < total_size) {
         throw Decoding_Error("Bad lengths in DTLS header");
      }
 
      // Bound the out-of-order reassembly window.
      constexpr uint16_t reassembly_window = 16;
 
      // Independently cap total bytes committed to in-flight reassembly slots
      const size_t max_pending = 4 * m_max_handshake_msg_size;
 
      if(message_seq >= m_in_message_seq && (message_seq - m_in_message_seq) < reassembly_window) {
         auto [it, inserted] = m_messages.try_emplace(message_seq);
         if(inserted) {
            if(m_max_handshake_msg_size > 0 && m_pending_reassembly_bytes + msg_len > max_pending) {
               m_messages.erase(it);
               record += total_size;
               record_len -= total_size;
               continue;
            }
            m_pending_reassembly_bytes += msg_len;
         }
         it->second.add_fragment(
            &record[DTLS_HANDSHAKE_HEADER_LEN], fragment_length, fragment_offset, epoch, msg_type, msg_len);
      } else {
         // TODO: detect retransmitted flight
      }
 
      record += total_size;
      record_len -= total_size;
   }
}

References Botan::TLS::ChangeCipherSpec, Botan::fmt(), and Botan::load_be().

format()

std::vector< uint8_t > Botan::TLS::Datagram_Handshake_IO::format ( const std::vector< uint8_t > & handshake_msg, Handshake_Type handshake_type ) const

overridevirtual

Implements Botan::TLS::Handshake_IO.

Definition at line 414 of file tls_handshake_io.cpp.

                                                                                                         {
   BOTAN_ASSERT_NOMSG(m_in_message_seq > 0);
   return format_w_seq(msg, type, m_in_message_seq - 1);
}

References BOTAN_ASSERT_NOMSG.

get_next_record()

std::pair< Handshake_Type, std::vector< uint8_t > > Botan::TLS::Datagram_Handshake_IO::get_next_record ( bool expecting_ccs, size_t max_message_size )

overridevirtual

Returns (HANDSHAKE_NONE, std::vector<>()) if no message currently available

Implements Botan::TLS::Handshake_IO.

Definition at line 277 of file tls_handshake_io.cpp.

                                                                                                 {
   // Expecting a message means the last flight is concluded
   if(!m_flights.rbegin()->empty()) {
      m_flights.push_back(std::vector<uint16_t>());
   }
 
   if(expecting_ccs) {
      if(!m_messages.empty()) {
         const uint16_t current_epoch = m_messages.begin()->second.epoch();
 
         if(m_ccs_epochs.contains(current_epoch)) {
            return std::make_pair(Handshake_Type::HandshakeCCS, std::vector<uint8_t>());
         }
      }
      return std::make_pair(Handshake_Type::None, std::vector<uint8_t>());
   }
 
   auto i = m_messages.find(m_in_message_seq);
 
   if(i == m_messages.end() || !i->second.complete()) {
      return std::make_pair(Handshake_Type::None, std::vector<uint8_t>());
   }
 
   m_in_message_seq += 1;
 
   auto result = i->second.message();
 
   // Free the reassembly buffer for this delivered slot and uncommit its
   // bytes against the cap. The entry itself stays in m_messages because
   // the expecting_ccs branch above uses m_messages.begin()->second.epoch()
   // as an epoch-0 sentinel; it only needs the metadata, not the buffers.
   BOTAN_ASSERT_NOMSG(m_pending_reassembly_bytes >= i->second.msg_length());
   m_pending_reassembly_bytes -= i->second.msg_length();
   i->second.release_buffers();
 
   return result;
}

References BOTAN_ASSERT_NOMSG, Botan::TLS::HandshakeCCS, and Botan::TLS::None.

have_more_data()

bool Botan::TLS::Datagram_Handshake_IO::have_more_data ( ) const

overridevirtual

Implements Botan::TLS::Handshake_IO.

Definition at line 179 of file tls_handshake_io.cpp.

                                                 {
   return false;
}

initial_record_version()

Protocol_Version Botan::TLS::Datagram_Handshake_IO::initial_record_version ( ) const

overridevirtual

Implements Botan::TLS::Handshake_IO.

Definition at line 149 of file tls_handshake_io.cpp.

                                                                     {
   return Protocol_Version::DTLS_V12;
}

send()

std::vector< uint8_t > Botan::TLS::Datagram_Handshake_IO::send ( const Handshake_Message & msg )

overridevirtual

Implements Botan::TLS::Handshake_IO.

Definition at line 419 of file tls_handshake_io.cpp.

                                                                           {
   return this->send_under_epoch(msg, m_seqs.current_write_epoch());
}

References send_under_epoch().

send_under_epoch()

std::vector< uint8_t > Botan::TLS::Datagram_Handshake_IO::send_under_epoch ( const Handshake_Message & msg, uint16_t epoch )

overridevirtual

Implements Botan::TLS::Handshake_IO.

Definition at line 423 of file tls_handshake_io.cpp.

                                                                                                       {
   const std::vector<uint8_t> msg_bits = msg.serialize();
   const Handshake_Type msg_type = msg.type();
 
   if(msg_type == Handshake_Type::HandshakeCCS) {
      m_send_hs(epoch, Record_Type::ChangeCipherSpec, msg_bits);
      return std::vector<uint8_t>();  // not included in handshake hashes
   } else if(msg_type == Handshake_Type::HelloVerifyRequest) {
      // This message is not included in the handshake hashes
      send_message(m_out_message_seq, epoch, msg_type, msg_bits);
      m_out_message_seq += 1;
      return std::vector<uint8_t>();
   }
 
   // Note: not saving CCS, instead we know it was there due to change in epoch
   m_flights.rbegin()->push_back(m_out_message_seq);
   m_flight_data[m_out_message_seq] = Message_Info(epoch, msg_type, msg_bits);
 
   m_out_message_seq += 1;
   m_last_write = steady_clock_ms();
   m_next_timeout = m_initial_timeout;
 
   return send_message(m_out_message_seq - 1, epoch, msg_type, msg_bits);
}

References Botan::TLS::ChangeCipherSpec, Botan::TLS::HandshakeCCS, Botan::TLS::HelloVerifyRequest, Botan::TLS::Handshake_Message::serialize(), and Botan::TLS::Handshake_Message::type().

Referenced by send().

timeout_check()

bool Botan::TLS::Datagram_Handshake_IO::timeout_check ( )

overridevirtual

Implements Botan::TLS::Handshake_IO.

Definition at line 183 of file tls_handshake_io.cpp.

                                          {
   if(m_last_write == 0 || (m_flights.size() > 1 && !m_flights.rbegin()->empty())) {
      /*
      If we haven't written anything yet obviously no timeout.
      Also no timeout possible if we are mid-flight,
      */
      return false;
   }
 
   const uint64_t ms_since_write = steady_clock_ms() - m_last_write;
 
   if(ms_since_write < m_next_timeout) {
      return false;
   }
 
   retransmit_last_flight();
 
   m_next_timeout = std::min(2 * m_next_timeout, m_max_timeout);
   return true;
}

---

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

• src/lib/tls/tls12/tls_handshake_io.h
• src/lib/tls/tls12/tls_handshake_io.cpp