#include <tls_extensions.h>

Inheritance diagram for Botan::TLS::Supported_Versions:

Public Member Functions
bool	empty () const override
virtual bool	is_implemented () const
std::vector< uint8_t >	serialize (Connection_Side whoami) const override
	Supported_Versions (Protocol_Version version)
	Supported_Versions (Protocol_Version version, const Policy &policy)
	Supported_Versions (TLS_Data_Reader &reader, uint16_t extension_size, Connection_Side from)
bool	supports (Protocol_Version version) const
Extension_Code	type () const override
const std::vector< Protocol_Version > &	versions () const

Static Public Member Functions
static Extension_Code	static_type ()

Detailed Description

Supported Versions from RFC 8446

Definition at line 381 of file tls_extensions.h.

Constructor & Destructor Documentation

◆ Supported_Versions() [1/3]

Botan::TLS::Supported_Versions::Supported_Versions	(	Protocol_Version	version,
		const Policy &	policy )

Definition at line 702 of file tls_extensions.cpp.

                                                                                   {
   // RFC 8446 4.2.1
   //    The extension contains a list of supported versions in preference order,
   //    with the most preferred version first. Implementations [...] MUST send
   //    this extension in the ClientHello containing all versions of TLS which
   //    they are prepared to negotiate.
   //
   // We simply assume that we always want the newest available TLS version.
#if defined(BOTAN_HAS_TLS_13)
   if(!offer.is_datagram_protocol()) {
      if(offer >= Protocol_Version::TLS_V13 && policy.allow_tls13()) {
         m_versions.push_back(Protocol_Version::TLS_V13);
      }
   }
#endif
 
#if defined(BOTAN_HAS_TLS_12)
   if(offer.is_datagram_protocol()) {
      if(offer >= Protocol_Version::DTLS_V12 && policy.allow_dtls12()) {
         m_versions.push_back(Protocol_Version::DTLS_V12);
      }
   } else {
      if(offer >= Protocol_Version::TLS_V12 && policy.allow_tls12()) {
         m_versions.push_back(Protocol_Version::TLS_V12);
      }
   }
#endif
 
   // if no versions are supported, the input variables are not used
   BOTAN_UNUSED(offer, policy);
}

References Botan::TLS::Policy::allow_dtls12(), Botan::TLS::Policy::allow_tls12(), Botan::TLS::Policy::allow_tls13(), BOTAN_UNUSED, and Botan::TLS::Protocol_Version::is_datagram_protocol().

◆ Supported_Versions() [2/3]

Botan::TLS::Supported_Versions::Supported_Versions ( Protocol_Version version )

inlineexplicit

Definition at line 393 of file tls_extensions.h.

393{ m_versions.push_back(version); }

◆ Supported_Versions() [3/3]

Botan::TLS::Supported_Versions::Supported_Versions	(	TLS_Data_Reader &	reader,
		uint16_t	extension_size,
		Connection_Side	from )

Definition at line 734 of file tls_extensions.cpp.

                                                                                                             {
   if(from == Connection_Side::Server) {
      if(extension_size != 2) {
         throw Decoding_Error("Server sent invalid supported_versions extension");
      }
      m_versions.push_back(Protocol_Version(reader.get_uint16_t()));
   } else {
      auto versions = reader.get_range<uint16_t>(1, 1, 127);
 
      for(auto v : versions) {
         m_versions.push_back(Protocol_Version(v));
      }
 
      if(extension_size != 1 + 2 * versions.size()) {
         throw Decoding_Error("Client sent invalid supported_versions extension");
      }
   }
}

References Botan::TLS::TLS_Data_Reader::get_range(), Botan::TLS::TLS_Data_Reader::get_uint16_t(), Botan::TLS::Server, and versions().

Member Function Documentation

◆ empty()

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

inlineoverridevirtual

Returns: if we should encode this extension or not

Implements Botan::TLS::Extension.

Definition at line 389 of file tls_extensions.h.

389{ return m_versions.empty(); }

◆ is_implemented()

virtual bool Botan::TLS::Extension::is_implemented ( ) const

inlinevirtualinherited

Returns: true if this extension is known and implemented by Botan

Reimplemented in Botan::TLS::Unknown_Extension.

Definition at line 95 of file tls_extensions.h.

95{ return true; }

◆ serialize()

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

overridevirtual

Returns: serialized binary for the extension

Implements Botan::TLS::Extension.

Definition at line 680 of file tls_extensions.cpp.

                                                                             {
   std::vector<uint8_t> buf;
 
   if(whoami == Connection_Side::Server) {
      BOTAN_ASSERT_NOMSG(m_versions.size() == 1);
      buf.push_back(m_versions[0].major_version());
      buf.push_back(m_versions[0].minor_version());
   } else {
      BOTAN_ASSERT_NOMSG(!m_versions.empty());
      const uint8_t len = static_cast<uint8_t>(m_versions.size() * 2);
 
      buf.push_back(len);
 
      for(const Protocol_Version version : m_versions) {
         buf.push_back(version.major_version());
         buf.push_back(version.minor_version());
      }
   }
 
   return buf;
}

References BOTAN_ASSERT_NOMSG, and Botan::TLS::Server.

◆ static_type()

Extension_Code Botan::TLS::Supported_Versions::static_type ( )

inlinestatic

Definition at line 383 of file tls_extensions.h.

383{ return Extension_Code::SupportedVersions; }

Botan::TLS::Extension_Code::SupportedVersions

@ SupportedVersions

Definition tls_extensions.h:60

References Botan::TLS::SupportedVersions.

Referenced by type().

◆ supports()

bool Botan::TLS::Supported_Versions::supports ( Protocol_Version version ) const

Definition at line 753 of file tls_extensions.cpp.

                                                                {
   for(auto v : m_versions) {
      if(version == v) {
         return true;
      }
   }
   return false;
}