#include <tls_extensions_13.h>

Inheritance diagram for Botan::TLS::EarlyDataIndication:

Public Member Functions
	EarlyDataIndication (std::optional< uint32_t > max_early_data_size=std::nullopt)
	EarlyDataIndication (TLS_Data_Reader &reader, uint16_t extension_size, Handshake_Type message_type)
bool	empty () const override
virtual bool	is_implemented () const
std::optional< uint32_t >	max_early_data_size () const
std::vector< uint8_t >	serialize (Connection_Side whoami) const override
Extension_Code	type () const override

Static Public Member Functions
static Extension_Code	static_type ()

Detailed Description

Indicates usage or support of early data as described in RFC 8446 4.2.10.

Definition at line 304 of file tls_extensions_13.h.

Constructor & Destructor Documentation

◆ EarlyDataIndication() [1/2]

Botan::TLS::EarlyDataIndication::EarlyDataIndication	(	TLS_Data_Reader &	reader,
		uint16_t	extension_size,
		Handshake_Type	message_type )

Definition at line 147 of file tls_extensions_13.cpp.

                                                                      {
   if(message_type == Handshake_Type::NewSessionTicket) {
      if(extension_size != 4) {
         throw TLS_Exception(Alert::DecodeError,
                             "Received an early_data extension in a NewSessionTicket message "
                             "without maximum early data size indication");
      }
 
      m_max_early_data_size = reader.get_uint32_t();
   } else if(extension_size != 0) {
      throw TLS_Exception(Alert::DecodeError,
                          "Received an early_data extension containing an unexpected data "
                          "size indication");
   }
}

References Botan::TLS::TLS_Data_Reader::get_uint32_t(), and Botan::TLS::NewSessionTicket.

◆ EarlyDataIndication() [2/2]

Botan::TLS::EarlyDataIndication::EarlyDataIndication ( std::optional< uint32_t > max_early_data_size = std::nullopt )

inlineexplicit

The max_early_data_size is exclusively provided by servers when using this extension in the NewSessionTicket message! Otherwise it stays std::nullopt and results in an empty extension. (RFC 8446 4.2.10).

Definition at line 323 of file tls_extensions_13.h.

323 :

324 m_max_early_data_size(max_early_data_size) {}

Botan::TLS::EarlyDataIndication::max_early_data_size

std::optional< uint32_t > max_early_data_size() const

Definition tls_extensions_13.h:314

References max_early_data_size().

Member Function Documentation

◆ empty()

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

overridevirtual

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 165 of file tls_extensions_13.cpp.

                                      {
   // This extension may be empty by definition but still carry information
   return false;
}

◆ 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.

113{ return true; }

◆ max_early_data_size()

std::optional< uint32_t > Botan::TLS::EarlyDataIndication::max_early_data_size ( ) const

inline

Definition at line 314 of file tls_extensions_13.h.

314{ return m_max_early_data_size; }

Referenced by Botan::TLS::New_Session_Ticket_13::early_data_byte_limit(), and EarlyDataIndication().

◆ serialize()

std::vector< uint8_t > Botan::TLS::EarlyDataIndication::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 135 of file tls_extensions_13.cpp.

                                                                         {
   std::vector<uint8_t> result;
   if(m_max_early_data_size.has_value()) {
      const auto max_data = m_max_early_data_size.value();
      result.push_back(get_byte<0>(max_data));
      result.push_back(get_byte<1>(max_data));
      result.push_back(get_byte<2>(max_data));
      result.push_back(get_byte<3>(max_data));
   }
   return result;
}