#include <tls_extensions.h>

Inheritance diagram for Botan::TLS::Record_Size_Limit:

Public Member Functions
bool	empty () const override
virtual bool	is_implemented () const
uint16_t	limit () const
	Record_Size_Limit (TLS_Data_Reader &reader, uint16_t extension_size, Connection_Side from)
	Record_Size_Limit (uint16_t limit)
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

Record Size Limit (RFC 8449)

TODO: the record size limit is currently not honored by the TLS 1.2 stack

Definition at line 415 of file tls_extensions.h.

Constructor & Destructor Documentation

◆ Record_Size_Limit() [1/2]

Botan::TLS::Record_Size_Limit::Record_Size_Limit ( uint16_t limit )

explicit

Definition at line 866 of file tls_extensions.cpp.

                                                         : m_limit(limit) {
   BOTAN_ARG_CHECK(limit >= 64, "RFC 8449 does not allow record size limits smaller than 64 bytes");
   BOTAN_ARG_CHECK(limit <= MAX_PLAINTEXT_SIZE + 1 /* encrypted content type byte */,
                   "RFC 8449 does not allow record size limits larger than 2^14+1");
}

References BOTAN_ARG_CHECK, limit(), and Botan::TLS::MAX_PLAINTEXT_SIZE.

◆ Record_Size_Limit() [2/2]

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

Definition at line 872 of file tls_extensions.cpp.

                                                                                                           {
   if(extension_size != 2) {
      throw TLS_Exception(Alert::DecodeError, "invalid record_size_limit extension");
   }
 
   m_limit = reader.get_uint16_t();
 
   // RFC 8449 4.
   //    This value is the length of the plaintext of a protected record.
   //    The value includes the content type and padding added in TLS 1.3 (that
   //    is, the complete length of TLSInnerPlaintext).
   //
   //    A server MUST NOT enforce this restriction; a client might advertise
   //    a higher limit that is enabled by an extension or version the server
   //    does not understand. A client MAY abort the handshake with an
   //    "illegal_parameter" alert.
   //
   // Note: We are currently supporting this extension in TLS 1.3 only, hence
   //       we check for the TLS 1.3 limit. The TLS 1.2 limit would not include
   //       the "content type byte" and hence be one byte less!
   if(m_limit > MAX_PLAINTEXT_SIZE + 1 /* encrypted content type byte */ && from == Connection_Side::Server) {
      throw TLS_Exception(Alert::IllegalParameter,
                          "Server requested a record size limit larger than the protocol's maximum");
   }
 
   // RFC 8449 4.
   //    Endpoints MUST NOT send a "record_size_limit" extension with a value
   //    smaller than 64.  An endpoint MUST treat receipt of a smaller value
   //    as a fatal error and generate an "illegal_parameter" alert.
   if(m_limit < 64) {
      throw TLS_Exception(Alert::IllegalParameter, "Received a record size limit smaller than 64 bytes");
   }
}

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

Member Function Documentation

◆ empty()

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

inlineoverridevirtual

Returns: if we should encode this extension or not

Implements Botan::TLS::Extension.

Definition at line 429 of file tls_extensions.h.

429{ return m_limit == 0; }

◆ 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; }

◆ limit()

uint16_t Botan::TLS::Record_Size_Limit::limit ( ) const

inline

Definition at line 425 of file tls_extensions.h.

425{ return m_limit; }

Referenced by Record_Size_Limit().

◆ serialize()

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

overridevirtual

Returns: serialized binary for the extension

Implements Botan::TLS::Extension.

Definition at line 906 of file tls_extensions.cpp.

                                                                       {
   std::vector<uint8_t> buf;
 
   buf.push_back(get_byte<0>(m_limit));
   buf.push_back(get_byte<1>(m_limit));
 
   return buf;
}