#include <tls_handshake_state_13.h>

Inheritance diagram for Botan::TLS::Handshake_State_13< whoami, Outbound_Message_T, Inbound_Message_T, Inbound_Post_Handshake_Message_T >:

Public Member Functions
const Certificate_Request_13 &	certificate_request () const
const Certificate_13 &	client_certificate () const
const Certificate_Verify_13 &	client_certificate_verify () const
const Finished_13 &	client_finished () const
Client_Hello_13 &	client_hello ()
const Client_Hello_13 &	client_hello () const
void	confirm_peer_finished_verified ()
const Encrypted_Extensions &	encrypted_extensions () const
bool	handshake_finished () const
	Handshake_State_13 ()
bool	has_certificate_request () const
bool	has_client_certificate_msg () const
bool	has_client_finished () const
bool	has_client_hello () const
bool	has_hello_retry_request () const
bool	has_server_certificate_msg () const
bool	has_server_finished () const
bool	has_server_hello () const
const Hello_Retry_Request &	hello_retry_request () const
decltype(auto)	received (Handshake_Message_13 message)
decltype(auto)	received (Post_Handshake_Message_13 message)
template<typename MsgT> requires (std::is_constructible_v<Outbound_Message_T, MsgT>)
std::reference_wrapper< MsgT >	sending (MsgT msg)
template<typename... MsgTs> requires (is_generalizable_to<Outbound_Message_T>(message))
decltype(auto)	sending (std::variant< MsgTs... > message)
const Certificate_13 &	server_certificate () const
const Certificate_Verify_13 &	server_certificate_verify () const
const Finished_13 &	server_finished () const
const Server_Hello_13 &	server_hello () const

Protected Member Functions
Certificate_13 &	store (Certificate_13 certificate, bool from_peer)
Certificate_Request_13 &	store (Certificate_Request_13 certificate_request, bool from_peer)
Certificate_Verify_13 &	store (Certificate_Verify_13 certificate_verify, bool from_peer)
Client_Hello_12_Shim &	store (Client_Hello_12_Shim client_hello, bool from_peer)
Client_Hello_13 &	store (Client_Hello_13 client_hello, bool from_peer)
Encrypted_Extensions &	store (Encrypted_Extensions encrypted_extensions, bool from_peer)
Finished_13 &	store (Finished_13 finished, bool from_peer)
Hello_Retry_Request &	store (Hello_Retry_Request hello_retry_request, bool from_peer)
Server_Hello_12_Shim &	store (Server_Hello_12_Shim server_hello, bool from_peer)
Server_Hello_13 &	store (Server_Hello_13 server_hello, bool from_peer)

Detailed Description

template<Connection_Side whoami, typename Outbound_Message_T, typename Inbound_Message_T, typename Inbound_Post_Handshake_Message_T>
class Botan::TLS::Handshake_State_13< whoami, Outbound_Message_T, Inbound_Message_T, Inbound_Post_Handshake_Message_T >

Place to store TLS handshake messages

This class is used to keep all handshake messages that have been received from and sent to the peer as part of the TLS 1.3 handshake. Getters are provided for all message types. Specializations for the client and server side provide specific setters in the form of sent and received that only allow those types of handshake messages that are sensible for the respective connection side.

The handshake state machine as described in RFC 8446 Appendix A is NOT validated here.

Definition at line 154 of file tls_handshake_state_13.h.

Constructor & Destructor Documentation

◆ Handshake_State_13()

template<Connection_Side whoami, typename Outbound_Message_T, typename Inbound_Message_T, typename Inbound_Post_Handshake_Message_T>

Botan::TLS::Handshake_State_13< whoami, Outbound_Message_T, Inbound_Message_T, Inbound_Post_Handshake_Message_T >::Handshake_State_13 ( )

inline

Definition at line 156 of file tls_handshake_state_13.h.

156: Handshake_State_13_Base(whoami) {}

Botan::TLS::Handshake_State_13

Definition tls_handshake_state_13.h:154

Botan::TLS::Internal::Handshake_State_13_Base::Handshake_State_13_Base

Handshake_State_13_Base(Connection_Side whoami)

Definition tls_handshake_state_13.h:90

Member Function Documentation

◆ certificate_request()

const Certificate_Request_13 & Botan::TLS::Internal::Handshake_State_13_Base::certificate_request ( ) const

inlineinherited

Definition at line 62 of file tls_handshake_state_13.h.

62{ return get(m_certificate_request); }

Referenced by store().

◆ client_certificate()

const Certificate_13 & Botan::TLS::Internal::Handshake_State_13_Base::client_certificate ( ) const

inlineinherited

Definition at line 66 of file tls_handshake_state_13.h.

66{ return get(m_client_certificate); }

◆ client_certificate_verify()

const Certificate_Verify_13 & Botan::TLS::Internal::Handshake_State_13_Base::client_certificate_verify ( ) const

inlineinherited

Definition at line 70 of file tls_handshake_state_13.h.

70{ return get(m_client_certificate_verify); }

◆ client_finished()

const Finished_13 & Botan::TLS::Internal::Handshake_State_13_Base::client_finished ( ) const

inlineinherited

Definition at line 74 of file tls_handshake_state_13.h.

74{ return get(m_client_finished); }

◆ client_hello() [1/2]

Client_Hello_13 & Botan::TLS::Internal::Handshake_State_13_Base::client_hello ( )

inlineinherited

Definition at line 52 of file tls_handshake_state_13.h.

52{ return get(m_client_hello); }

Referenced by store(), and store().

◆ client_hello() [2/2]

const Client_Hello_13 & Botan::TLS::Internal::Handshake_State_13_Base::client_hello ( ) const

inlineinherited

Definition at line 54 of file tls_handshake_state_13.h.

54{ return get(m_client_hello); }

◆ confirm_peer_finished_verified()

void Botan::TLS::Internal::Handshake_State_13_Base::confirm_peer_finished_verified ( )

inlineinherited

Once the implementation has successfully verified the peer's Finished message, the handshake is considered complete and successful.

Definition at line 49 of file tls_handshake_state_13.h.

49{ m_peer_finished_verified = true; }

◆ encrypted_extensions()

const Encrypted_Extensions & Botan::TLS::Internal::Handshake_State_13_Base::encrypted_extensions ( ) const

inlineinherited

Definition at line 60 of file tls_handshake_state_13.h.

60{ return get(m_encrypted_extensions); }

Referenced by store().

◆ handshake_finished()

bool Botan::TLS::Internal::Handshake_State_13_Base::handshake_finished ( ) const

inlineinherited

Definition at line 41 of file tls_handshake_state_13.h.

                                      {
         return has_server_finished() && has_client_finished() && m_peer_finished_verified;
      }

References has_client_finished(), and has_server_finished().

◆ has_certificate_request()

bool Botan::TLS::Internal::Handshake_State_13_Base::has_certificate_request ( ) const

inlineinherited

Definition at line 35 of file tls_handshake_state_13.h.

35{ return m_certificate_request.has_value(); }

◆ has_client_certificate_msg()

bool Botan::TLS::Internal::Handshake_State_13_Base::has_client_certificate_msg ( ) const

inlineinherited

Definition at line 31 of file tls_handshake_state_13.h.

31{ return m_client_certificate.has_value(); }

◆ has_client_finished()

bool Botan::TLS::Internal::Handshake_State_13_Base::has_client_finished ( ) const

inlineinherited

Definition at line 39 of file tls_handshake_state_13.h.

39{ return m_client_finished.has_value(); }

Referenced by handshake_finished().

◆ has_client_hello()

bool Botan::TLS::Internal::Handshake_State_13_Base::has_client_hello ( ) const

inlineinherited

Definition at line 25 of file tls_handshake_state_13.h.

25{ return m_client_hello.has_value(); }

◆ has_hello_retry_request()

bool Botan::TLS::Internal::Handshake_State_13_Base::has_hello_retry_request ( ) const

inlineinherited

Definition at line 33 of file tls_handshake_state_13.h.

33{ return m_hello_retry_request.has_value(); }

Referenced by store().

◆ has_server_certificate_msg()

bool Botan::TLS::Internal::Handshake_State_13_Base::has_server_certificate_msg ( ) const

inlineinherited

Definition at line 29 of file tls_handshake_state_13.h.

29{ return m_server_certificate.has_value(); }

◆ has_server_finished()

bool Botan::TLS::Internal::Handshake_State_13_Base::has_server_finished ( ) const

inlineinherited

Definition at line 37 of file tls_handshake_state_13.h.

37{ return m_server_finished.has_value(); }

Referenced by handshake_finished().

◆ has_server_hello()

bool Botan::TLS::Internal::Handshake_State_13_Base::has_server_hello ( ) const

inlineinherited

Definition at line 27 of file tls_handshake_state_13.h.

27{ return m_server_hello.has_value(); }

◆ hello_retry_request()

const Hello_Retry_Request & Botan::TLS::Internal::Handshake_State_13_Base::hello_retry_request ( ) const

inlineinherited

Definition at line 58 of file tls_handshake_state_13.h.

58{ return get(m_hello_retry_request); }

Referenced by store().

◆ received() [1/2]

template<Connection_Side whoami, typename Outbound_Message_T, typename Inbound_Message_T, typename Inbound_Post_Handshake_Message_T>

decltype(auto) Botan::TLS::Handshake_State_13< whoami, Outbound_Message_T, Inbound_Message_T, Inbound_Post_Handshake_Message_T >::received ( Handshake_Message_13 message )

inline

Definition at line 176 of file tls_handshake_state_13.h.

                                                            {
         return std::visit(
            [&](auto msg) -> detail::as_wrapped_references_t<Inbound_Message_T> {
               if constexpr(std::is_constructible_v<Inbound_Message_T, decltype(msg)>) {
                  return std::reference_wrapper<decltype(msg)>(store(std::move(msg), true));
               } else {
                  throw TLS_Exception(AlertType::UnexpectedMessage, "received an illegal handshake message");
               }
            },
            std::move(message));
      }

◆ received() [2/2]

template<Connection_Side whoami, typename Outbound_Message_T, typename Inbound_Message_T, typename Inbound_Post_Handshake_Message_T>

decltype(auto) Botan::TLS::Handshake_State_13< whoami, Outbound_Message_T, Inbound_Message_T, Inbound_Post_Handshake_Message_T >::received ( Post_Handshake_Message_13 message )

inline

Definition at line 188 of file tls_handshake_state_13.h.

                                                                 {
         return std::visit(
            [](auto msg) -> Inbound_Post_Handshake_Message_T {
               if constexpr(std::is_constructible_v<Inbound_Post_Handshake_Message_T, decltype(msg)>) {
                  return msg;
               } else {
                  throw TLS_Exception(AlertType::UnexpectedMessage, "received an unexpected post-handshake message");
               }
            },
            std::move(message));
      }

◆ sending() [1/2]

template<Connection_Side whoami, typename Outbound_Message_T, typename Inbound_Message_T, typename Inbound_Post_Handshake_Message_T>

template<typename MsgT>
requires (std::is_constructible_v<Outbound_Message_T, MsgT>)

std::reference_wrapper< MsgT > Botan::TLS::Handshake_State_13< whoami, Outbound_Message_T, Inbound_Message_T, Inbound_Post_Handshake_Message_T >::sending ( MsgT msg )

inline

Definition at line 159 of file tls_handshake_state_13.h.

      {
         return std::reference_wrapper<decltype(msg)>(store(std::move(msg), false));
      }

◆ sending() [2/2]

template<Connection_Side whoami, typename Outbound_Message_T, typename Inbound_Message_T, typename Inbound_Post_Handshake_Message_T>

template<typename... MsgTs>
requires (is_generalizable_to<Outbound_Message_T>(message))

decltype(auto) Botan::TLS::Handshake_State_13< whoami, Outbound_Message_T, Inbound_Message_T, Inbound_Post_Handshake_Message_T >::sending ( std::variant< MsgTs... > message )

inline

Definition at line 166 of file tls_handshake_state_13.h.

      {
         return std::visit(
            [&](auto msg) -> detail::as_wrapped_references_t<std::variant<MsgTs...>> {
               return sending(std::move(msg));
            },
            std::move(message));
      }

◆ server_certificate()

const Certificate_13 & Botan::TLS::Internal::Handshake_State_13_Base::server_certificate ( ) const

inlineinherited

Definition at line 64 of file tls_handshake_state_13.h.

64{ return get(m_server_certificate); }

◆ server_certificate_verify()

const Certificate_Verify_13 & Botan::TLS::Internal::Handshake_State_13_Base::server_certificate_verify ( ) const

inlineinherited

Definition at line 68 of file tls_handshake_state_13.h.

68{ return get(m_server_certificate_verify); }

◆ server_finished()

const Finished_13 & Botan::TLS::Internal::Handshake_State_13_Base::server_finished ( ) const

inlineinherited

Definition at line 72 of file tls_handshake_state_13.h.

72{ return get(m_server_finished); }

◆ server_hello()

const Server_Hello_13 & Botan::TLS::Internal::Handshake_State_13_Base::server_hello ( ) const

inlineinherited

Definition at line 56 of file tls_handshake_state_13.h.

56{ return get(m_server_hello); }

Referenced by store(), and store().

◆ store() [1/10]

Certificate_13 & Botan::TLS::Internal::Handshake_State_13_Base::store	(	Certificate_13	certificate,
		bool	from_peer )

protectedinherited

Definition at line 67 of file tls_handshake_state_13.cpp.

                                                                                               {
   auto& target = ((m_side == Connection_Side::Client) == from_peer) ? m_server_certificate : m_client_certificate;
   BOTAN_STATE_CHECK(!target.has_value());
   target = std::move(certificate);
   return target.value();
}

References BOTAN_STATE_CHECK, and Botan::TLS::Client.

◆ store() [2/10]

Certificate_Request_13 & Botan::TLS::Internal::Handshake_State_13_Base::store	(	Certificate_Request_13	certificate_request,
		bool	from_peer )

protectedinherited

Definition at line 60 of file tls_handshake_state_13.cpp.

                                                                     {
   BOTAN_STATE_CHECK(!m_certificate_request.has_value());
   m_certificate_request = std::move(certificate_request);
   return m_certificate_request.value();
}

References BOTAN_STATE_CHECK, and certificate_request().

◆ store() [3/10]

Certificate_Verify_13 & Botan::TLS::Internal::Handshake_State_13_Base::store	(	Certificate_Verify_13	certificate_verify,
		bool	from_peer )

protectedinherited

Definition at line 74 of file tls_handshake_state_13.cpp.

                                                                                                                    {
   auto& target =
      ((m_side == Connection_Side::Client) == from_peer) ? m_server_certificate_verify : m_client_certificate_verify;
   BOTAN_STATE_CHECK(!target.has_value());
   target = std::move(certificate_verify);
   return target.value();
}

References BOTAN_STATE_CHECK, and Botan::TLS::Client.

◆ store() [4/10]

Client_Hello_12_Shim & Botan::TLS::Internal::Handshake_State_13_Base::store	(	Client_Hello_12_Shim	client_hello,
		bool	from_peer )

protectedinherited

Definition at line 26 of file tls_handshake_state_13.cpp.

                                                                                                    {
   BOTAN_STATE_CHECK(!m_client_hello_12.has_value());
   m_client_hello_12 = std::move(client_hello);
   return m_client_hello_12.value();
}

References BOTAN_STATE_CHECK, and client_hello().

◆ store() [5/10]

Client_Hello_13 & Botan::TLS::Internal::Handshake_State_13_Base::store	(	Client_Hello_13	client_hello,
		bool	from_peer )

protectedinherited

Definition at line 15 of file tls_handshake_state_13.cpp.

                                                                                          {
   if(m_client_hello) {
      // Make sure that the updated Client Hello is compatible to the initial one.
      BOTAN_STATE_CHECK(has_hello_retry_request());
      m_client_hello->validate_updates(client_hello);
   }
 
   m_client_hello = std::move(client_hello);
   return m_client_hello.value();
}

References BOTAN_STATE_CHECK, client_hello(), and has_hello_retry_request().

◆ store() [6/10]

Encrypted_Extensions & Botan::TLS::Internal::Handshake_State_13_Base::store	(	Encrypted_Extensions	encrypted_extensions,
		bool	from_peer )

protectedinherited

Definition at line 53 of file tls_handshake_state_13.cpp.

                                                                   {
   BOTAN_STATE_CHECK(!m_encrypted_extensions.has_value());
   m_encrypted_extensions = std::move(encrypted_extensions);
   return m_encrypted_extensions.value();
}

References BOTAN_STATE_CHECK, and encrypted_extensions().

◆ store() [7/10]

Finished_13 & Botan::TLS::Internal::Handshake_State_13_Base::store	(	Finished_13	finished,
		bool	from_peer )

protectedinherited

Definition at line 82 of file tls_handshake_state_13.cpp.

                                                                                      {
   auto& target = ((m_side == Connection_Side::Client) == from_peer) ? m_server_finished : m_client_finished;
   BOTAN_STATE_CHECK(!target.has_value());
   target = std::move(finished);
   return target.value();
}

References BOTAN_STATE_CHECK, and Botan::TLS::Client.

◆ store() [8/10]

Hello_Retry_Request & Botan::TLS::Internal::Handshake_State_13_Base::store	(	Hello_Retry_Request	hello_retry_request,
		bool	from_peer )

protectedinherited

Definition at line 44 of file tls_handshake_state_13.cpp.

                                                                                                         {
   // RFC 8446 4.1.4
   //    If a client receives a second HelloRetryRequest in the same connection
   //    [...], it MUST abort the handshake with an "unexpected_message" alert.
   BOTAN_STATE_CHECK(!m_hello_retry_request.has_value());
   m_hello_retry_request = std::move(hello_retry_request);
   return m_hello_retry_request.value();
}

References BOTAN_STATE_CHECK, and hello_retry_request().

◆ store() [9/10]

Server_Hello_12_Shim & Botan::TLS::Internal::Handshake_State_13_Base::store	(	Server_Hello_12_Shim	server_hello,
		bool	from_peer )

protectedinherited

Definition at line 38 of file tls_handshake_state_13.cpp.

                                                                                                    {
   BOTAN_STATE_CHECK(!m_server_hello_12.has_value());
   m_server_hello_12 = std::move(server_hello);
   return m_server_hello_12.value();
}

References BOTAN_STATE_CHECK, and server_hello().

◆ store() [10/10]

Server_Hello_13 & Botan::TLS::Internal::Handshake_State_13_Base::store	(	Server_Hello_13	server_hello,
		bool	from_peer )

protectedinherited

Definition at line 32 of file tls_handshake_state_13.cpp.

                                                                                          {
   BOTAN_STATE_CHECK(!m_server_hello.has_value());
   m_server_hello = std::move(server_hello);
   return m_server_hello.value();
}

References BOTAN_STATE_CHECK, and server_hello().

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

src/lib/tls/tls13/tls_handshake_state_13.h

Public Member Functions

Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ Handshake_State_13()

Member Function Documentation

◆ certificate_request()

◆ client_certificate()

◆ client_certificate_verify()

◆ client_finished()

◆ client_hello() [1/2]

◆ client_hello() [2/2]

◆ confirm_peer_finished_verified()

◆ encrypted_extensions()

◆ handshake_finished()

◆ has_certificate_request()

◆ has_client_certificate_msg()

◆ has_client_finished()

◆ has_client_hello()

◆ has_hello_retry_request()

◆ has_server_certificate_msg()

◆ has_server_finished()

◆ has_server_hello()

◆ hello_retry_request()

◆ received() [1/2]

◆ received() [2/2]

◆ sending() [1/2]

◆ sending() [2/2]

◆ server_certificate()

◆ server_certificate_verify()

◆ server_finished()

◆ server_hello()

◆ store() [1/10]

◆ store() [2/10]

◆ store() [3/10]

◆ store() [4/10]

◆ store() [5/10]

◆ store() [6/10]

◆ store() [7/10]

◆ store() [8/10]

◆ store() [9/10]

◆ store() [10/10]