#include <tls_handshake_layer_13.h>

Public Member Functions
void	copy_data (std::span< const uint8_t > data_from_peer)

	Handshake_Layer (Connection_Side whoami)

bool	has_pending_data () const

std::optional< Handshake_Message_13 >	next_message (const Policy &policy, Transcript_Hash_State &transcript_hash)

std::optional< Post_Handshake_Message_13 >	next_post_handshake_message (const Policy &policy)

void	set_selected_certificate_type (Certificate_Type cert_type)

Static Public Member Functions
static std::vector< uint8_t >	prepare_message (Handshake_Message_13_Ref message, Transcript_Hash_State &transcript_hash)

static std::vector< uint8_t >	prepare_post_handshake_message (const Post_Handshake_Message_13 &message)

Detailed Description

Implementation of the TLS 1.3 handshake protocol layer

This component transforms payload bytes received in TLS records from the peer into parsed handshake messages and vice versa.

Definition at line 28 of file tls_handshake_layer_13.h.

Constructor & Destructor Documentation

◆ Handshake_Layer()

Botan::TLS::Handshake_Layer::Handshake_Layer ( Connection_Side whoami )

inline

Definition at line 30 of file tls_handshake_layer_13.h.

                                              :
            m_peer(whoami == Connection_Side::Server ? Connection_Side::Client : Connection_Side::Server)
            // RFC 8446 4.4.2
            //    If the corresponding certificate type extension
            //    ("server_certificate_type" or "client_certificate_type") was not
            //    negotiated in EncryptedExtensions, or the X.509 certificate type
            //    was negotiated, then each CertificateEntry contains a DER-encoded
            //    X.509 certificate.
            //
            // We need the certificate_type info to parse Certificate messages.
            ,
            m_certificate_type(Certificate_Type::X509) {}

Member Function Documentation

◆ copy_data()

void Botan::TLS::Handshake_Layer::copy_data ( std::span< const uint8_t > data_from_peer )

Reads data that was received in handshake records and stores it internally for further processing during the invocation of next_message().

Parameters

data_from_peer The data to be parsed.

Definition at line 19 of file tls_handshake_layer_13.cpp.

                                                                     {
   m_read_buffer.insert(m_read_buffer.end(), data_from_peer.begin(), data_from_peer.end());
}

Referenced by Botan::TLS::Channel_Impl_13::from_peer().

◆ has_pending_data()

bool Botan::TLS::Handshake_Layer::has_pending_data ( ) const

inline

Check if the Handshake_Layer has stored a partial message in its internal buffer. This can happen if a handshake message spans multiple records.

Definition at line 95 of file tls_handshake_layer_13.h.

95{ return !m_read_buffer.empty(); }

Referenced by Botan::TLS::Channel_Impl_13::from_peer(), and Botan::TLS::Channel_Impl_13::handle().

◆ next_message()

std::optional< Handshake_Message_13 > Botan::TLS::Handshake_Layer::next_message	(	const Policy &	policy,
		Transcript_Hash_State &	transcript_hash )

Parses one handshake message off the internal buffer that is being filled using copy_data.

Parameters

policy	the TLS policy
transcript_hash	the transcript hash state to be updated

Returns: the parsed handshake message, or nullopt if more data is needed to complete the message

Definition at line 119 of file tls_handshake_layer_13.cpp.

                                                                                                          {
   TLS::TLS_Data_Reader reader("handshake message", m_read_buffer);
 
   auto msg = parse_message<Handshake_Message_13>(reader, policy, m_peer, m_certificate_type);
   if(msg.has_value()) {
      BOTAN_ASSERT_NOMSG(m_read_buffer.size() >= reader.read_so_far());
      transcript_hash.update(std::span{m_read_buffer.data(), reader.read_so_far()});
      m_read_buffer.erase(m_read_buffer.cbegin(), m_read_buffer.cbegin() + reader.read_so_far());
   }
 
   return msg;
}

References BOTAN_ASSERT_NOMSG, Botan::TLS::TLS_Data_Reader::read_so_far(), and Botan::TLS::Transcript_Hash_State::update().

Referenced by Botan::TLS::Channel_Impl_13::from_peer().

◆ next_post_handshake_message()

std::optional< Post_Handshake_Message_13 > Botan::TLS::Handshake_Layer::next_post_handshake_message ( const Policy & policy )

Parses one post-handshake message off the internal buffer that is being filled using copy_data.

Parameters

policy the TLS policy

Returns: the parsed post-handshake message, or nullopt if more data is needed to complete the message

Definition at line 133 of file tls_handshake_layer_13.cpp.

                                                                                                        {
   TLS::TLS_Data_Reader reader("post handshake message", m_read_buffer);
 
   auto msg = parse_message<Post_Handshake_Message_13>(reader, policy, m_peer, m_certificate_type);
   if(msg.has_value()) {
      m_read_buffer.erase(m_read_buffer.cbegin(), m_read_buffer.cbegin() + reader.read_so_far());
   }
 
   return msg;
}

References Botan::TLS::TLS_Data_Reader::read_so_far().

Referenced by Botan::TLS::Channel_Impl_13::from_peer().

◆ prepare_message()

std::vector< uint8_t > Botan::TLS::Handshake_Layer::prepare_message	(	Handshake_Message_13_Ref	message,
		Transcript_Hash_State &	transcript_hash )

static

Marshalls one handshake message for sending in an (encrypted) record and updates the provided transcript hash state accordingly.

Parameters

message	the handshake message to be marshalled
transcript_hash	the transcript hash state to be updated

Returns: the marshalled handshake message

Definition at line 172 of file tls_handshake_layer_13.cpp.

                                                                                              {
   auto msg = marshall_message(message);
   transcript_hash.update(msg);
   return msg;
}

References Botan::TLS::Transcript_Hash_State::update().

Referenced by Botan::TLS::Channel_Impl_13::AggregatedHandshakeMessages::add().

◆ prepare_post_handshake_message()

std::vector< uint8_t > Botan::TLS::Handshake_Layer::prepare_post_handshake_message ( const Post_Handshake_Message_13 & message )

static

Marshalls one post-handshake message for sending in an (encrypted) record.

Parameters

message the post handshake message to be marshalled

Returns: the marshalled post-handshake message

Definition at line 179 of file tls_handshake_layer_13.cpp.

                                                                                                           {
   return marshall_message(message);
}

Referenced by Botan::TLS::Channel_Impl_13::AggregatedPostHandshakeMessages::add().

◆ set_selected_certificate_type()

void Botan::TLS::Handshake_Layer::set_selected_certificate_type ( Certificate_Type cert_type )

inline

Set the certificate_type used for parsing Certificate messages. This is determined via (client/server)_certificate_type extensions during the handshake.

RFC 7250 4.3 and 4.4 When the TLS server has specified RawPublicKey as the [client_certificate_type/server_certificate_type], authentication of the TLS [client/server] to the TLS [server/client] is supported only through authentication of the received client SubjectPublicKeyInfo via an out-of-band method.

If the peer sends a Certificate message containing an incompatible means of authentication, a 'decode_error' will be generated.

Definition at line 112 of file tls_handshake_layer_13.h.

112{ m_certificate_type = cert_type; }

Referenced by Botan::TLS::Channel_Impl_13::set_selected_certificate_type().

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

src/lib/tls/tls13/tls_handshake_layer_13.h
src/lib/tls/tls13/tls_handshake_layer_13.cpp

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ Handshake_Layer()

Member Function Documentation

◆ copy_data()

◆ has_pending_data()

◆ next_message()

◆ next_post_handshake_message()

◆ prepare_message()

◆ prepare_post_handshake_message()

◆ set_selected_certificate_type()