#include <tls_extensions.h>

Public Member Functions
void	add (Extension *extn)

void	add (std::unique_ptr< Extension > extn)

const std::vector< std::unique_ptr< Extension > > &	all () const

bool	contains_implemented_extensions_other_than (const std::set< Extension_Code > &allowed_extensions) const

bool	contains_other_than (const std::set< Extension_Code > &allowed_extensions, bool allow_unknown_extensions=false) const

void	deserialize (TLS_Data_Reader &reader, Connection_Side from, Handshake_Type message_type)

bool	empty () const

std::set< Extension_Code >	extension_types () const

	Extensions ()=default

	Extensions (const Extensions &)=delete

	Extensions (Extensions &&)=default

	Extensions (TLS_Data_Reader &reader, Connection_Side side, Handshake_Type message_type)

template<typename T >
T *	get () const

Extension *	get (Extension_Code type) const

template<typename T >
bool	has () const

bool	has (Extension_Code type) const

Extensions &	operator= (const Extensions &)=delete

Extensions &	operator= (Extensions &&)=default

bool	remove_extension (Extension_Code type)

std::vector< uint8_t >	serialize (Connection_Side whoami) const

size_t	size () const

template<typename T >
decltype(auto)	take ()

std::unique_ptr< Extension >	take (Extension_Code type)

Detailed Description

Represents a block of extensions in a hello message

Definition at line 908 of file tls_extensions.h.

Constructor & Destructor Documentation

◆ Extensions() [1/4]

Botan::TLS::Extensions::Extensions ( )

default

◆ Extensions() [2/4]

Botan::TLS::Extensions::Extensions ( const Extensions & )

delete

◆ Extensions() [3/4]

Botan::TLS::Extensions::Extensions ( Extensions && )

default

◆ Extensions() [4/4]

Botan::TLS::Extensions::Extensions	(	TLS_Data_Reader &	reader,
		Connection_Side	side,
		Handshake_Type	message_type )

inline

Definition at line 1001 of file tls_extensions.h.

                                                                                             {
         deserialize(reader, side, message_type);
      }

Member Function Documentation

◆ add() [1/2]

void Botan::TLS::Extensions::add ( Extension * extn )

inline

Definition at line 932 of file tls_extensions.h.

932{ add(std::unique_ptr<Extension>(extn)); }

Botan::TLS::Extensions::add

void add(std::unique_ptr< Extension > extn)

Definition tls_extensions.cpp:110

References add().

Referenced by add().

◆ add() [2/2]

void Botan::TLS::Extensions::add ( std::unique_ptr< Extension > extn )

Definition at line 110 of file tls_extensions.cpp.

                                                  {
   if(has(extn->type())) {
      throw Invalid_Argument("cannot add the same extension twice: " +
                             std::to_string(static_cast<uint16_t>(extn->type())));
   }
 
   m_extensions.emplace_back(extn.release());
}

References has().

Referenced by deserialize(), and Botan::TLS::Encrypted_Extensions::Encrypted_Extensions().

◆ all()

const std::vector< std::unique_ptr< Extension > > & Botan::TLS::Extensions::all ( ) const

inline

Definition at line 912 of file tls_extensions.h.

912{ return m_extensions; }

◆ contains_implemented_extensions_other_than()

bool Botan::TLS::Extensions::contains_implemented_extensions_other_than ( const std::set< Extension_Code > & allowed_extensions ) const

inline

Parameters

allowed_extensions extension types that are allowed

Returns: true if this contains any extensions implemented by Botan that are not contained in allowed_extensions.

Definition at line 958 of file tls_extensions.h.

                                                                                                              {
         return contains_other_than(allowed_extensions, true);
      }

Referenced by Botan::TLS::Certificate_13::Certificate_Entry::Certificate_Entry(), Botan::TLS::Certificate_Request_13::Certificate_Request_13(), Botan::TLS::Encrypted_Extensions::Encrypted_Extensions(), and Botan::TLS::New_Session_Ticket_13::New_Session_Ticket_13().

◆ contains_other_than()

bool Botan::TLS::Extensions::contains_other_than	(	const std::set< Extension_Code > &	allowed_extensions,
		bool	allow_unknown_extensions = false ) const

Parameters

allowed_extensions	extension types that are allowed
allow_unknown_extensions	if true, ignores unrecognized extensions

Returns: true if this contains any extensions that are not contained in allowed_extensions.

Definition at line 147 of file tls_extensions.cpp.

                                                                                {
   const auto found = extension_types();
 
   std::vector<Extension_Code> diff;
   std::set_difference(
      found.cbegin(), found.end(), allowed_extensions.cbegin(), allowed_extensions.cend(), std::back_inserter(diff));
 
   if(allow_unknown_extensions) {
      // Go through the found unexpected extensions whether any of those
      // is known to this TLS implementation.
      const auto itr = std::find_if(diff.cbegin(), diff.cend(), [this](const auto ext_type) {
         const auto ext = get(ext_type);
         return ext && ext->is_implemented();
      });
 
      // ... if yes, `contains_other_than` is true
      return itr != diff.cend();
   }
 
   return !diff.empty();
}

References extension_types().

◆ deserialize()

void Botan::TLS::Extensions::deserialize	(	TLS_Data_Reader &	reader,
		Connection_Side	from,
		Handshake_Type	message_type )

Definition at line 119 of file tls_extensions.cpp.

                                                                                                                   {
   if(reader.has_remaining()) {
      const uint16_t all_extn_size = reader.get_uint16_t();
 
      if(reader.remaining_bytes() != all_extn_size) {
         throw Decoding_Error("Bad extension size");
      }
 
      while(reader.has_remaining()) {
         const uint16_t extension_code = reader.get_uint16_t();
         const uint16_t extension_size = reader.get_uint16_t();
 
         const auto type = static_cast<Extension_Code>(extension_code);
 
         if(this->has(type)) {
            throw TLS_Exception(TLS::Alert::DecodeError, "Peer sent duplicated extensions");
         }
 
         // TODO offer a function on reader that returns a byte range as a reference
         // to avoid this copy of the extension data
         const std::vector<uint8_t> extn_data = reader.get_fixed<uint8_t>(extension_size);
         TLS_Data_Reader extn_reader("Extension", extn_data);
         this->add(make_extension(extn_reader, type, from, message_type));
         extn_reader.assert_done();
      }
   }
}

References add(), Botan::TLS::TLS_Data_Reader::get_fixed(), Botan::TLS::TLS_Data_Reader::get_uint16_t(), has(), Botan::TLS::TLS_Data_Reader::has_remaining(), and Botan::TLS::TLS_Data_Reader::remaining_bytes().

Referenced by Botan::TLS::Certificate_13::Certificate_Entry::Certificate_Entry(), Botan::TLS::Certificate_Request_13::Certificate_Request_13(), Botan::TLS::Encrypted_Extensions::Encrypted_Extensions(), and Botan::TLS::New_Session_Ticket_13::New_Session_Ticket_13().

◆ empty()

bool Botan::TLS::Extensions::empty ( ) const

inline

Definition at line 928 of file tls_extensions.h.

928{ return m_extensions.empty(); }

Referenced by Botan::TLS::New_Session_Ticket_13::serialize().

◆ extension_types()

std::set< Extension_Code > Botan::TLS::Extensions::extension_types ( ) const

Definition at line 217 of file tls_extensions.cpp.

                                                         {
   std::set<Extension_Code> offers;
   std::transform(
      m_extensions.cbegin(), m_extensions.cend(), std::inserter(offers, offers.begin()), [](const auto& ext) {
         return ext->type();
      });
   return offers;
}

Referenced by contains_other_than().

◆ get() [1/2]

template<typename T >

T * Botan::TLS::Extensions::get ( ) const

inline

Definition at line 915 of file tls_extensions.h.

                     {
         return dynamic_cast<T*>(get(T::static_type()));
      }

References T.

Referenced by Botan::TLS::Certificate_Request_13::acceptable_CAs(), Botan::TLS::Certificate_13::Certificate_13(), Botan::TLS::Certificate_13::Certificate_13(), Botan::TLS::Certificate_Request_13::certificate_signature_schemes(), Botan::TLS::New_Session_Ticket_13::early_data_byte_limit(), Botan::TLS::Hello_Retry_Request::Hello_Retry_Request(), Botan::TLS::Client_Hello_13::retry(), Botan::TLS::Certificate_Request_13::signature_schemes(), and Botan::TLS::Client_Hello_13::validate_updates().

◆ get() [2/2]

Extension * Botan::TLS::Extensions::get ( Extension_Code type ) const

inline

Definition at line 934 of file tls_extensions.h.

                                                {
         const auto i = std::find_if(
            m_extensions.cbegin(), m_extensions.cend(), [type](const auto& ext) { return ext->type() == type; });
 
         return (i != m_extensions.end()) ? i->get() : nullptr;
      }

◆ has() [1/2]

template<typename T >

bool Botan::TLS::Extensions::has ( ) const

inline

Definition at line 920 of file tls_extensions.h.

                       {
         return get<T>() != nullptr;
      }

Referenced by Botan::TLS::Certificate_Request_13::acceptable_CAs(), add(), Botan::TLS::Certificate_13::Certificate_13(), Botan::TLS::Certificate_Request_13::Certificate_Request_13(), deserialize(), Botan::TLS::New_Session_Ticket_13::early_data_byte_limit(), Botan::TLS::Hello_Retry_Request::Hello_Retry_Request(), Botan::TLS::Client_Hello_13::retry(), Botan::TLS::Certificate_Request_13::signature_schemes(), and Botan::TLS::Client_Hello_13::validate_updates().

◆ has() [2/2]

bool Botan::TLS::Extensions::has ( Extension_Code type ) const

inline

Definition at line 924 of file tls_extensions.h.

924{ return get(type) != nullptr; }

◆ operator=() [1/2]

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

delete

◆ operator=() [2/2]

Extensions & Botan::TLS::Extensions::operator= ( Extensions && )

default

◆ remove_extension()

bool Botan::TLS::Extensions::remove_extension ( Extension_Code type )

inline

Remove an extension from this extensions object, if it exists. Returns true if the extension existed (and thus is now removed), otherwise false (the extension wasn't set in the first place).

Note: not used internally, might be used in Callbacks::tls_modify_extensions()

Definition at line 993 of file tls_extensions.h.

993{ return take(type) != nullptr; }

Botan::TLS::Extensions::take

decltype(auto) take()

Definition tls_extensions.h:967

◆ serialize()

std::vector< uint8_t > Botan::TLS::Extensions::serialize ( Connection_Side whoami ) const

Definition at line 183 of file tls_extensions.cpp.

                                                                     {
   std::vector<uint8_t> buf(2);  // 2 bytes for length field
 
   for(const auto& extn : m_extensions) {
      if(extn->empty()) {
         continue;
      }
 
      const uint16_t extn_code = static_cast<uint16_t>(extn->type());
 
      const std::vector<uint8_t> extn_val = extn->serialize(whoami);
 
      buf.push_back(get_byte<0>(extn_code));
      buf.push_back(get_byte<1>(extn_code));
 
      buf.push_back(get_byte<0>(static_cast<uint16_t>(extn_val.size())));
      buf.push_back(get_byte<1>(static_cast<uint16_t>(extn_val.size())));
 
      buf += extn_val;
   }
 
   const uint16_t extn_size = static_cast<uint16_t>(buf.size() - 2);
 
   buf[0] = get_byte<0>(extn_size);
   buf[1] = get_byte<1>(extn_size);
 
   // avoid sending a completely empty extensions block
   if(buf.size() == 2) {
      return std::vector<uint8_t>();
   }
 
   return buf;
}

References Botan::get_byte().

Referenced by Botan::TLS::Certificate_Request_13::serialize(), Botan::TLS::Encrypted_Extensions::serialize(), and Botan::TLS::New_Session_Ticket_13::serialize().

◆ size()

size_t Botan::TLS::Extensions::size ( ) const

inline

Definition at line 926 of file tls_extensions.h.

926{ return m_extensions.size(); }

◆ take() [1/2]

template<typename T >

decltype(auto) Botan::TLS::Extensions::take ( )

inline

Take the extension with the given type out of the extensions list. Returns a nullptr if the extension didn't exist.

Definition at line 967 of file tls_extensions.h.

                            {
         std::unique_ptr<T> out_ptr;
 
         auto ext = take(T::static_type());
         if(ext != nullptr) {
            out_ptr.reset(dynamic_cast<T*>(ext.get()));
            BOTAN_ASSERT_NOMSG(out_ptr != nullptr);
            ext.release();
         }
 
         return out_ptr;
      }

References BOTAN_ASSERT_NOMSG, Botan::out_ptr(), and T.

◆ take() [2/2]

std::unique_ptr< Extension > Botan::TLS::Extensions::take ( Extension_Code type )

Take the extension with the given type out of the extensions list. Returns a nullptr if the extension didn't exist.

Definition at line 170 of file tls_extensions.cpp.

                                                             {
   const auto i =
      std::find_if(m_extensions.begin(), m_extensions.end(), [type](const auto& ext) { return ext->type() == type; });
 
   std::unique_ptr<Extension> result;
   if(i != m_extensions.end()) {
      std::swap(result, *i);
      m_extensions.erase(i);
   }
 
   return result;
}

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

src/lib/tls/tls_extensions.h
src/lib/tls/tls_extensions.cpp

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ Extensions() [1/4]

◆ Extensions() [2/4]

◆ Extensions() [3/4]

◆ Extensions() [4/4]

Member Function Documentation

◆ add() [1/2]

◆ add() [2/2]

◆ all()

◆ contains_implemented_extensions_other_than()

◆ contains_other_than()

◆ deserialize()

◆ empty()

◆ extension_types()

◆ get() [1/2]

◆ get() [2/2]

◆ has() [1/2]

◆ has() [2/2]

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ remove_extension()

◆ serialize()

◆ size()

◆ take() [1/2]

◆ take() [2/2]