#include <tls_extensions.h>

Public Member Functions
void	add (Extension *extn)
void	add (std::unique_ptr< Extension > extn)
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::optional< std::vector< uint8_t > >	extension_raw_bytes (Extension_Code type) 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
std::optional< Extension_Code >	last_added () const
Extensions &	operator= (const Extensions &)=delete
Extensions &	operator= (Extensions &&)=default
bool	remove_extension (Extension_Code type)
void	reorder (std::span< const Extension_Code > order)
std::vector< uint8_t >	serialize (Connection_Side whoami) const
size_t	size () const
	~Extensions ()

Detailed Description

Represents a block of extensions in a hello message

Definition at line 473 of file tls_extensions.h.

Constructor & Destructor Documentation

◆ Extensions() [1/4]

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

default

Referenced by Extensions(), Extensions(), operator=(), and operator=().

◆ Extensions() [2/4]

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

delete

References Extensions().

◆ Extensions() [3/4]

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

default

References Extensions().

◆ ~Extensions()

Botan::TLS::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 555 of file tls_extensions.h.

                                                                                             {
         deserialize(reader, side, message_type);
      }

References deserialize().

Member Function Documentation

◆ add() [1/2]

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

inline

Definition at line 495 of file tls_extensions.h.

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

Botan::TLS::Extensions::add

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

Definition tls_extensions.cpp:157

References add().

Referenced by add().

◆ add() [2/2]

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

Definition at line 157 of file tls_extensions.cpp.

                                                  {
   const auto type = extn->type();
   if(has(type)) {
      throw Invalid_Argument("cannot add the same extension twice: " + std::to_string(static_cast<uint16_t>(type)));
   }
 
   m_extension_codes.push_back(type);
   m_extensions.emplace(type, std::move(extn));
}

References has(), and Botan::TLS::Extension::type().

◆ 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 516 of file tls_extensions.h.

                                                                                                              {
         return contains_other_than(allowed_extensions, true);
      }

References contains_other_than().

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

Referenced by contains_implemented_extensions_other_than().

◆ deserialize()

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

Definition at line 167 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);
         m_raw_extension_data[type] = extn_data;
         TLS_Data_Reader extn_reader("Extension", extn_data);
         this->add(make_extension(extn_reader, type, from, message_type));
         extn_reader.assert_done();
      }
   }
}

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

◆ empty()

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

inline

Definition at line 491 of file tls_extensions.h.

491{ return m_extensions.empty(); }

◆ extension_raw_bytes()

std::optional< std::vector< uint8_t > > Botan::TLS::Extensions::extension_raw_bytes ( Extension_Code type ) const

inline

Returns: the raw bytes of the extension with the given type as they appeared on the wire during deserialization, or std::nullopt if the extension was not present or was added programmatically.

Definition at line 564 of file tls_extensions.h.

                                                                                     {
         auto it = m_raw_extension_data.find(type);
         if(it != m_raw_extension_data.end()) {
            return it->second;
         }
         return std::nullopt;
      }

Referenced by Botan::TLS::Client_Hello_13::validate_updates().

◆ extension_types()

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

Definition at line 274 of file tls_extensions.cpp.

                                                         {
   std::set<Extension_Code> offers;
   for(const auto& [extn_type, extn] : m_extensions) {
      // Consistent with serialize(): empty extensions are not placed on
      // the wire so they must not appear in the "offered" set either.
      if(!extn->empty()) {
         offers.insert(extn_type);
      }
   }
   return offers;
}

Referenced by contains_other_than().

◆ get() [1/2]

template<typename T>

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

inline

Definition at line 478 of file tls_extensions.h.

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

References get().

Referenced by Botan::TLS::Certificate_13::Certificate_13(), Botan::TLS::Certificate_13::Certificate_13(), get(), has(), Botan::TLS::Hello_Retry_Request::Hello_Retry_Request(), and Botan::TLS::Client_Hello_13::retry().

◆ get() [2/2]

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

Definition at line 147 of file tls_extensions.cpp.

                                                    {
   const auto i = m_extensions.find(type);
 
   if(i == m_extensions.end()) {
      return nullptr;
   } else {
      return i->second.get();
   }
}

◆ has() [1/2]

template<typename T>

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

inline

Definition at line 483 of file tls_extensions.h.

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

References get().

Referenced by add(), Botan::TLS::Certificate_13::Certificate_13(), deserialize(), Botan::TLS::Hello_Retry_Request::Hello_Retry_Request(), Botan::TLS::Client_Hello_13::retry(), and Botan::TLS::Client_Hello_13::validate_updates().

◆ has() [2/2]

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

Definition at line 143 of file tls_extensions.cpp.

                                              {
   return m_extensions.contains(type);
}

◆ last_added()

std::optional< Extension_Code > Botan::TLS::Extensions::last_added ( ) const

inline

Return the code of the extension that appears last in the encoding This is used for checking the position of PSK extension in TLS 1.3

Definition at line 540 of file tls_extensions.h.

                                                     {
         if(m_extension_codes.empty()) {
            return {};
         } else {
            return m_extension_codes.back();
         }
      }

◆ operator=() [1/2]

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

delete

References Extensions().

◆ operator=() [2/2]

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

default

References Extensions().

◆ remove_extension()

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

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 219 of file tls_extensions.cpp.

                                                     {
   auto i = m_extensions.find(type);
 
   if(i == m_extensions.end()) {
      return false;
   } else {
      m_extensions.erase(i);
      std::erase(m_extension_codes, type);
      m_raw_extension_data.erase(type);
      return true;
   }
}

◆ reorder()

void Botan::TLS::Extensions::reorder ( std::span< const Extension_Code > order )

Reorder extensions for serialization. Extensions not mentioned in order retain their relative position at the front; extensions in order are appended in the given order.

Definition at line 286 of file tls_extensions.cpp.

                                                            {
   const std::set<Extension_Code> in_order(order.begin(), order.end());
 
   std::vector<Extension_Code> new_codes;
   new_codes.reserve(m_extension_codes.size());
 
   // First: extensions not mentioned in the order (preserving their relative order)
   for(auto code : m_extension_codes) {
      if(!in_order.contains(code)) {
         new_codes.push_back(code);
      }
   }
 
   // Then: extensions in the specified order. Deduplicate so a caller that
   // accidentally lists the same code twice doesn't cause it to be
   // serialized twice (which would also break peers that reject duplicate
   // extension codes per RFC 8446 4.2 / RFC 5246 7.4.1.4).
   std::unordered_set<Extension_Code> already_pushed;
   for(auto code : order) {
      if(m_extensions.contains(code) && already_pushed.insert(code).second) {
         new_codes.push_back(code);
      }
   }
 
   m_extension_codes = std::move(new_codes);
}

◆ serialize()

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

Definition at line 232 of file tls_extensions.cpp.

                                                                     {
   std::vector<uint8_t> buf(2);  // 2 bytes for length field
 
   // Serialize in the order extensions were added, which matters for TLS 1.3
   for(const auto extn_type : m_extension_codes) {
      const auto& extn = m_extensions.at(extn_type);
 
      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);
 
      // Each extension carries a uint16 length prefix.
      BOTAN_ASSERT_NOMSG(extn_val.size() <= 0xFFFF);
 
      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;
   }
 
   // The outer extensions block is itself uint16-length-prefixed.
   BOTAN_ASSERT_NOMSG(buf.size() - 2 <= 0xFFFF);
   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_ASSERT_NOMSG, and Botan::get_byte().

◆ size()

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

inline

Definition at line 489 of file tls_extensions.h.

489{ return m_extensions.size(); }

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

◆ Extensions() [4/4]

Member Function Documentation

◆ add() [1/2]

◆ add() [2/2]

◆ contains_implemented_extensions_other_than()

◆ contains_other_than()

◆ deserialize()

◆ empty()

◆ extension_raw_bytes()

◆ extension_types()

◆ get() [1/2]

◆ get() [2/2]

◆ has() [1/2]

◆ has() [2/2]

◆ last_added()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ remove_extension()

◆ reorder()

◆ serialize()

◆ size()