Botan::TLS::Handshake_State_13< whoami, Outbound_Message_T, Inbound_Message_T, Inbound_Post_Handshake_Message_T > Class Template Reference

#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
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 &	store (Client_Hello_12 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 &	store (Server_Hello_12 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 134 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 136 of file tls_handshake_state_13.h.

: Handshake_State_13_Base(whoami) {}

Member Function Documentation

certificate_request()

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

inlineinherited

Definition at line 56 of file tls_handshake_state_13.h.

{ return get(m_certificate_request); }

Referenced by Botan::TLS::Internal::Handshake_State_13_Base::store().

client_certificate()

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

inlineinherited

Definition at line 60 of file tls_handshake_state_13.h.

{ return get(m_client_certificate); }

Referenced by Botan::TLS::Server_Impl_13::peer_cert_chain(), and Botan::TLS::Server_Impl_13::peer_raw_public_key().

client_certificate_verify()

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

inlineinherited

Definition at line 64 of file tls_handshake_state_13.h.

{ 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 68 of file tls_handshake_state_13.h.

{ 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 46 of file tls_handshake_state_13.h.

{ return get(m_client_hello); }

Referenced by Botan::TLS::Server_Impl_13::new_session_ticket_supported(), Botan::TLS::Server_Impl_13::send_new_session_tickets(), Botan::TLS::Internal::Handshake_State_13_Base::store(), and Botan::TLS::Internal::Handshake_State_13_Base::store().

client_hello() [2/2]

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

inlineinherited

Definition at line 48 of file tls_handshake_state_13.h.

{ return get(m_client_hello); }

encrypted_extensions()

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

inlineinherited

Definition at line 54 of file tls_handshake_state_13.h.

{ return get(m_encrypted_extensions); }

Referenced by Botan::TLS::Client_Impl_13::application_protocol(), Botan::TLS::Server_Impl_13::application_protocol(), and Botan::TLS::Internal::Handshake_State_13_Base::store().

handshake_finished()

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

inlineinherited

Definition at line 43 of file tls_handshake_state_13.h.

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

Referenced by Botan::TLS::Client_Impl_13::is_handshake_complete(), and Botan::TLS::Server_Impl_13::is_handshake_complete().

has_certificate_request()

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

inlineinherited

Definition at line 37 of file tls_handshake_state_13.h.

{ 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 33 of file tls_handshake_state_13.h.

{ return m_client_certificate.has_value(); }

Referenced by Botan::TLS::Server_Impl_13::peer_cert_chain(), and Botan::TLS::Server_Impl_13::peer_raw_public_key().

has_client_finished()

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

inlineinherited

Definition at line 41 of file tls_handshake_state_13.h.

{ return m_client_finished.has_value(); }

has_client_hello()

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

inlineinherited

Definition at line 27 of file tls_handshake_state_13.h.

{ 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 35 of file tls_handshake_state_13.h.

{ return m_hello_retry_request.has_value(); }

Referenced by Botan::TLS::Internal::Handshake_State_13_Base::store().

has_server_certificate_msg()

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

inlineinherited

Definition at line 31 of file tls_handshake_state_13.h.

{ return m_server_certificate.has_value(); }

Referenced by Botan::TLS::Client_Impl_13::peer_cert_chain(), and Botan::TLS::Client_Impl_13::peer_raw_public_key().

has_server_finished()

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

inlineinherited

Definition at line 39 of file tls_handshake_state_13.h.

{ return m_server_finished.has_value(); }

has_server_hello()

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

inlineinherited

Definition at line 29 of file tls_handshake_state_13.h.

{ 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 52 of file tls_handshake_state_13.h.

{ return get(m_hello_retry_request); }

Referenced by Botan::TLS::Internal::Handshake_State_13_Base::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 154 of file tls_handshake_state_13.h.

                                                            {
         return std::visit(
            [&](auto msg) -> 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));
               }
 
               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 166 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;
               }
 
               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 139 of file tls_handshake_state_13.h.

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

Referenced by Botan::TLS::Client_Impl_13::Client_Impl_13().

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 146 of file tls_handshake_state_13.h.

      {
         return std::visit(
            [&](auto msg) -> 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 58 of file tls_handshake_state_13.h.

{ return get(m_server_certificate); }

Referenced by Botan::TLS::Client_Impl_13::peer_cert_chain(), and Botan::TLS::Client_Impl_13::peer_raw_public_key().

server_certificate_verify()

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

inlineinherited

Definition at line 62 of file tls_handshake_state_13.h.

{ 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 66 of file tls_handshake_state_13.h.

{ 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 50 of file tls_handshake_state_13.h.

{ return get(m_server_hello); }

Referenced by Botan::TLS::Server_Impl_13::send_new_session_tickets(), Botan::TLS::Internal::Handshake_State_13_Base::store(), and Botan::TLS::Internal::Handshake_State_13_Base::store().

store() [1/10]

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

protectedinherited

Definition at line 54 of file tls_handshake_state_13.cpp.

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

References 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 49 of file tls_handshake_state_13.cpp.

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

References Botan::TLS::Internal::Handshake_State_13_Base::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 60 of file tls_handshake_state_13.cpp.

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

References Botan::TLS::Client.

store() [4/10]

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

protectedinherited

Definition at line 24 of file tls_handshake_state_13.cpp.

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

References Botan::TLS::Internal::Handshake_State_13_Base::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 13 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, Botan::TLS::Internal::Handshake_State_13_Base::client_hello(), and Botan::TLS::Internal::Handshake_State_13_Base::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 44 of file tls_handshake_state_13.cpp.

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

References Botan::TLS::Internal::Handshake_State_13_Base::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 67 of file tls_handshake_state_13.cpp.

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

References 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 39 of file tls_handshake_state_13.cpp.

                                                                                                       {
   m_hello_retry_request = std::move(hello_retry_request);
   return m_hello_retry_request.value();
}

References Botan::TLS::Internal::Handshake_State_13_Base::hello_retry_request().

store() [9/10]

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

protectedinherited

Definition at line 34 of file tls_handshake_state_13.cpp.

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

References Botan::TLS::Internal::Handshake_State_13_Base::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 29 of file tls_handshake_state_13.cpp.

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

References Botan::TLS::Internal::Handshake_State_13_Base::server_hello().

---

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

• src/lib/tls/tls13/tls_handshake_state_13.h