Botan::TLS::Supported_Versions Class Reference

#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 397 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 811 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 409 of file tls_extensions.h.

{ 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 843 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

Predicate if a TLS extension should be included or not

Returns

true if this extension should be encoded, otherwise false

Implements Botan::TLS::Extension.

Definition at line 405 of file tls_extensions.h.

{ return m_versions.empty(); }

is_implemented()

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

inlinevirtualinherited

Predicate if the extension is known/implemented

Note

this exists primarily to support unknown extension handling and doesn't need to be overridden even in the custom extension case.

Returns

true if this extension is known

Reimplemented in Botan::TLS::Unknown_Extension.

Definition at line 113 of file tls_extensions.h.

{ return true; }

serialize()

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

overridevirtual

Serialize a TLS extension

Parameters

whoami

which peer we are acting as in the protocol

Returns

serialized binary for the extension

Implements Botan::TLS::Extension.

Definition at line 787 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 {
      // RFC 8446 4.2.1: ProtocolVersion versions<2..254>; - up to 127 entries.
      BOTAN_ASSERT_NOMSG(!m_versions.empty());
      BOTAN_ASSERT_NOMSG(m_versions.size() <= 127);
      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 399 of file tls_extensions.h.

{ return Extension_Code::SupportedVersions; }

References Botan::TLS::SupportedVersions.

Referenced by type().

supports()

bool Botan::TLS::Supported_Versions::supports

(

Protocol_Version

version

)

const

Definition at line 862 of file tls_extensions.cpp.

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

type()

Extension_Code Botan::TLS::Supported_Versions::type ( ) const

inlineoverridevirtual

Return TLS extension code

Returns

code number of the extension

Implements Botan::TLS::Extension.

Definition at line 401 of file tls_extensions.h.

{ return static_type(); }

References static_type().

versions()

const std::vector< Protocol_Version > & Botan::TLS::Supported_Versions::versions ( ) const

inline

Definition at line 415 of file tls_extensions.h.

{ return m_versions; }

Referenced by Supported_Versions().

---

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

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