#include <tls_extensions.h>

Inheritance diagram for Botan::TLS::Application_Layer_Protocol_Notification:

Public Member Functions
	Application_Layer_Protocol_Notification (const std::vector< std::string > &protocols)
	Application_Layer_Protocol_Notification (std::string_view protocol)
	Application_Layer_Protocol_Notification (TLS_Data_Reader &reader, uint16_t extension_size, Connection_Side from)
bool	empty () const override
virtual bool	is_implemented () const
const std::vector< std::string > &	protocols () const
std::vector< uint8_t >	serialize (Connection_Side whoami) const override
std::string	single_protocol () const
Extension_Code	type () const override

Static Public Member Functions
static Extension_Code	static_type ()

Detailed Description

ALPN (RFC 7301)

Definition at line 133 of file tls_extensions.h.

Constructor & Destructor Documentation

◆ Application_Layer_Protocol_Notification() [1/3]

Botan::TLS::Application_Layer_Protocol_Notification::Application_Layer_Protocol_Notification ( std::string_view protocol )

explicit

Single protocol, used by server

Definition at line 426 of file tls_extensions.cpp.

                                                                                                        {
   BOTAN_ARG_CHECK(!protocol.empty(), "ALPN protocol name must not be empty");
   BOTAN_ARG_CHECK(protocol.size() < 256, "ALPN protocol name too long");
   m_protocols.emplace_back(protocol);
}

References BOTAN_ARG_CHECK.

◆ Application_Layer_Protocol_Notification() [2/3]

Botan::TLS::Application_Layer_Protocol_Notification::Application_Layer_Protocol_Notification ( const std::vector< std::string > & protocols )

explicit

List of protocols, used by client

Definition at line 432 of file tls_extensions.cpp.

                                          :
      m_protocols(protocols) {
   for(const auto& protocol : protocols) {
      BOTAN_ARG_CHECK(!protocol.empty(), "ALPN protocol name must not be empty");
      BOTAN_ARG_CHECK(protocol.size() < 256, "ALPN protocol name too long");
   }
}

References BOTAN_ARG_CHECK, and protocols().

◆ Application_Layer_Protocol_Notification() [3/3]

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

Definition at line 441 of file tls_extensions.cpp.

                                                                                                       {
   if(extension_size < 2) {
      throw Decoding_Error("ALPN extension cannot be empty");
   }
 
   const uint16_t name_bytes = reader.get_uint16_t();
 
   size_t bytes_remaining = extension_size - 2;
 
   if(name_bytes != bytes_remaining) {
      throw Decoding_Error("Bad encoding of ALPN extension, bad length field");
   }
 
   // RFC 7301 3.1: ProtocolName protocol_name_list<2..2^16-1>
   if(name_bytes == 0) {
      throw Decoding_Error("Empty ALPN protocol_name_list not allowed");
   }
 
   while(bytes_remaining > 0) {
      const std::string p = reader.get_string(1, 0, 255);
 
      if(bytes_remaining < p.size() + 1) {
         throw Decoding_Error("Bad encoding of ALPN, length field too long");
      }
 
      if(p.empty()) {
         throw Decoding_Error("Empty ALPN protocol not allowed");
      }
 
      bytes_remaining -= (p.size() + 1);
 
      m_protocols.push_back(p);
   }
 
   // RFC 7301 3.1
   //    The "extension_data" field of the [...] extension is structured the
   //    same as described above for the client "extension_data", except that
   //    the "ProtocolNameList" MUST contain exactly one "ProtocolName".
   if(from == Connection_Side::Server && m_protocols.size() != 1) {
      throw TLS_Exception(
         Alert::DecodeError,
         "Server sent " + std::to_string(m_protocols.size()) + " protocols in ALPN extension response");
   }
}

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

Member Function Documentation

◆ empty()

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

inlineoverridevirtual

Returns: if we should encode this extension or not

Implements Botan::TLS::Extension.

Definition at line 157 of file tls_extensions.h.

157{ return m_protocols.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 100 of file tls_extensions.h.

100{ return true; }

◆ protocols()

const std::vector< std::string > & Botan::TLS::Application_Layer_Protocol_Notification::protocols ( ) const

inline

Definition at line 139 of file tls_extensions.h.

139{ return m_protocols; }

Referenced by Application_Layer_Protocol_Notification().

◆ serialize()

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

overridevirtual

Returns: serialized binary for the extension

Implements Botan::TLS::Extension.

Definition at line 493 of file tls_extensions.cpp.

                                                                                             {
   std::vector<uint8_t> buf(2);
 
   for(auto&& proto : m_protocols) {
      if(proto.length() >= 256) {
         throw TLS_Exception(Alert::InternalError, "ALPN name too long");
      }
      if(!proto.empty()) {
         append_tls_length_value(buf, proto, 1);
      }
   }
 
   // RFC 7301 3.1: ProtocolName protocol_name_list<2..2^16-1>;
   BOTAN_ASSERT_NOMSG(buf.size() - 2 <= 0xFFFF);
   buf[0] = get_byte<0>(static_cast<uint16_t>(buf.size() - 2));
   buf[1] = get_byte<1>(static_cast<uint16_t>(buf.size() - 2));
 
   return buf;
}

References Botan::TLS::append_tls_length_value(), BOTAN_ASSERT_NOMSG, and Botan::get_byte().

◆ single_protocol()

std::string Botan::TLS::Application_Layer_Protocol_Notification::single_protocol ( ) const

Definition at line 488 of file tls_extensions.cpp.

                                                                         {
   BOTAN_STATE_CHECK(m_protocols.size() == 1);
   return m_protocols.front();
}