Botan::TLS::Stream_Handshake_IO Class Reference

#include <tls_handshake_io.h>

Inheritance diagram for Botan::TLS::Stream_Handshake_IO:

Public Types
typedef std::function< void(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
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) 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
	Stream_Handshake_IO (writer_fn writer)
bool	timeout_check () override

Detailed Description

Handshake IO for stream-based handshakes

Definition at line 81 of file tls_handshake_io.h.

Member Typedef Documentation

writer_fn

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

Definition at line 83 of file tls_handshake_io.h.

Constructor & Destructor Documentation

Stream_Handshake_IO()

Botan::TLS::Stream_Handshake_IO::Stream_Handshake_IO ( writer_fn writer )

inlineexplicit

Definition at line 85 of file tls_handshake_io.h.

: m_send_hs(std::move(writer)) {}

Member Function Documentation

add_record()

void Botan::TLS::Stream_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 43 of file tls_handshake_io.cpp.

                                                 {
   if(record_type == Record_Type::Handshake) {
      m_queue.insert(m_queue.end(), record, record + record_len);
   } else if(record_type == Record_Type::ChangeCipherSpec) {
      if(record_len != 1 || record[0] != 1) {
         throw Decoding_Error("Invalid ChangeCipherSpec");
      }
 
      // Pretend it's a regular handshake message of zero length
      const uint8_t ccs_hs[] = {static_cast<uint8_t>(Handshake_Type::HandshakeCCS), 0, 0, 0};
      m_queue.insert(m_queue.end(), ccs_hs, ccs_hs + sizeof(ccs_hs));
   } else {
      throw Decoding_Error("Unknown message type " + std::to_string(static_cast<size_t>(record_type)) +
                           " in handshake processing");
   }
}

References Botan::TLS::ChangeCipherSpec, Botan::TLS::Handshake, and Botan::TLS::HandshakeCCS.

format()

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

overridevirtual

Implements Botan::TLS::Handshake_IO.

Definition at line 98 of file tls_handshake_io.cpp.

                                                                                                       {
   std::vector<uint8_t> send_buf(4 + msg.size());
 
   const size_t buf_size = msg.size();
 
   send_buf[0] = static_cast<uint8_t>(type);
 
   store_be24(&send_buf[1], buf_size);
 
   if(!msg.empty()) {
      copy_mem(&send_buf[4], msg.data(), msg.size());
   }
 
   return send_buf;
}

References Botan::copy_mem().

Referenced by send().

get_next_record()

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

overridevirtual

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

Implements Botan::TLS::Handshake_IO.

Definition at line 63 of file tls_handshake_io.cpp.

                                                                                                   {
   if(m_queue.size() >= 4) {
      const Handshake_Type type = static_cast<Handshake_Type>(m_queue[0]);
 
      if(type == Handshake_Type::None) {
         throw Decoding_Error("Invalid handshake message type");
      }
 
      const size_t rec_length = make_uint32(0, m_queue[1], m_queue[2], m_queue[3]);
 
      // If we are expecting a CCS but the next queued message is not a CCS,
      // the peer has skipped the CCS message. This can happen when the peer
      // sends an encrypted Finished without the preceding CCS, in which case
      // the encrypted bytes are misinterpreted as a handshake message.
      if(expecting_ccs) {
         const bool is_ccs = (type == Handshake_Type::HandshakeCCS && rec_length == 0);
         if(!is_ccs) {
            throw TLS_Exception(Alert::UnexpectedMessage, "Expected ChangeCipherSpec but got a handshake message");
         }
      }
 
      const size_t length = 4 + rec_length;
 
      if(m_queue.size() >= length) {
         const std::vector<uint8_t> contents(m_queue.begin() + 4, m_queue.begin() + length);
 
         m_queue.erase(m_queue.begin(), m_queue.begin() + length);
 
         return std::make_pair(type, contents);
      }
   }
 
   return std::make_pair(Handshake_Type::None, std::vector<uint8_t>());
}

References Botan::TLS::HandshakeCCS, Botan::make_uint32(), and Botan::TLS::None.

have_more_data()

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

inlineoverridevirtual

Implements Botan::TLS::Handshake_IO.

Definition at line 91 of file tls_handshake_io.h.

{ return !m_queue.empty(); }

initial_record_version()

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

overridevirtual

Implements Botan::TLS::Handshake_IO.

Definition at line 39 of file tls_handshake_io.cpp.

                                                                   {
   return Protocol_Version::TLS_V12;
}

send()

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

overridevirtual

Implements Botan::TLS::Handshake_IO.

Definition at line 118 of file tls_handshake_io.cpp.

                                                                         {
   const std::vector<uint8_t> msg_bits = msg.serialize();
 
   if(msg.type() == Handshake_Type::HandshakeCCS) {
      m_send_hs(Record_Type::ChangeCipherSpec, msg_bits);
      return std::vector<uint8_t>();  // not included in handshake hashes
   }
 
   auto buf = format(msg_bits, msg.wire_type());
   m_send_hs(Record_Type::Handshake, buf);
   return buf;
}

References Botan::TLS::ChangeCipherSpec, format(), Botan::TLS::Handshake, Botan::TLS::HandshakeCCS, Botan::TLS::Handshake_Message::serialize(), Botan::TLS::Handshake_Message::type(), and Botan::TLS::Handshake_Message::wire_type().

send_under_epoch()

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

overridevirtual

Implements Botan::TLS::Handshake_IO.

Definition at line 114 of file tls_handshake_io.cpp.

                                                                                               {
   throw Invalid_State("Not possible to send under arbitrary epoch with stream based TLS");
}

timeout_check()

bool Botan::TLS::Stream_Handshake_IO::timeout_check ( )

inlineoverridevirtual

Implements Botan::TLS::Handshake_IO.

Definition at line 89 of file tls_handshake_io.h.

{ return false; }

---

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