Botan::TLS::Handshake_State Class Reference

#include <tls_handshake_state.h>

Public Member Functions
Callbacks &	callbacks () const
const Certificate_Request_12 *	cert_req () const
void	cert_req (std::unique_ptr< Certificate_Request_12 > cert_req)
std::pair< std::string, Signature_Format >	choose_sig_format (const Private_Key &key, Signature_Scheme &scheme, bool for_client_auth, const Policy &policy) const
const Ciphersuite &	ciphersuite () const
const Certificate_12 *	client_certs () const
void	client_certs (std::unique_ptr< Certificate_12 > client_certs)
const Finished_12 *	client_finished () const
void	client_finished (std::unique_ptr< Finished_12 > client_finished)
const Client_Hello_12 *	client_hello () const
void	client_hello (std::unique_ptr< Client_Hello_12 > client_hello)
const Client_Key_Exchange *	client_kex () const
void	client_kex (std::unique_ptr< Client_Key_Exchange > client_kex)
const Certificate_Verify_12 *	client_verify () const
void	client_verify (std::unique_ptr< Certificate_Verify_12 > client_verify)
void	compute_session_keys ()
void	compute_session_keys (const secure_vector< uint8_t > &resume_master_secret)
void	confirm_transition_to (Handshake_Type msg_type)
std::pair< Handshake_Type, std::vector< uint8_t > >	get_next_handshake_msg (size_t max_handshake_msg_size)
Handshake_IO &	handshake_io ()
	Handshake_State (const Handshake_State &other)=delete
	Handshake_State (Handshake_State &&other)=delete
	Handshake_State (std::unique_ptr< Handshake_IO > io, Callbacks &callbacks)
Handshake_Hash &	hash ()
const Handshake_Hash &	hash () const
void	hello_verify_request (const Hello_Verify_Request &hello_verify)
const New_Session_Ticket_12 *	new_session_ticket () const
void	new_session_ticket (std::unique_ptr< New_Session_Ticket_12 > new_session_ticket)
void	note_message (const Handshake_Message &msg)
Handshake_State &	operator= (const Handshake_State &other)=delete
Handshake_State &	operator= (Handshake_State &&other)=delete
std::pair< std::string, Signature_Format >	parse_sig_format (const Public_Key &key, Signature_Scheme scheme, const std::vector< Signature_Scheme > &offered_schemes, bool for_client_auth, const Policy &policy) const
virtual std::vector< X509_Certificate >	peer_cert_chain () const =0
std::unique_ptr< KDF >	protocol_specific_prf () const
std::optional< std::string >	psk_identity () const
bool	received_handshake_msg (Handshake_Type msg_type) const
const Certificate_Status *	server_cert_status () const
void	server_cert_status (std::unique_ptr< Certificate_Status > server_cert_status)
const Certificate_12 *	server_certs () const
void	server_certs (std::unique_ptr< Certificate_12 > server_certs)
const Finished_12 *	server_finished () const
void	server_finished (std::unique_ptr< Finished_12 > server_finished)
const Server_Hello_12 *	server_hello () const
void	server_hello (std::unique_ptr< Server_Hello_12 > server_hello)
const Server_Hello_Done *	server_hello_done () const
void	server_hello_done (std::unique_ptr< Server_Hello_Done > server_hello_done)
const Server_Key_Exchange *	server_kex () const
void	server_kex (std::unique_ptr< Server_Key_Exchange > server_kex)
const Certificate_Verify_12 *	server_verify () const
void	server_verify (std::unique_ptr< Certificate_Verify_12 > server_verify)
const Session_Keys &	session_keys () const
Session_Ticket	session_ticket () const
void	set_expected_next (Handshake_Type msg_type)
void	set_version (const Protocol_Version &version)
std::unique_ptr< Handshake_IO >	take_handshake_io ()
Protocol_Version	version () const
virtual	~Handshake_State ()

Detailed Description

SSL/TLS Handshake State

This is a data holder object for all state aggregated during the handshake, both on client and server side and across protocol versions. It does not implement any logic and offers no guarantees regarding state consistency and legal TLS state transitions.

TODO: currently it implements some logic for TLS 1.2, which should be removed TODO: investigate moving the handshake_io to the channel

Definition at line 61 of file tls_handshake_state.h.

Constructor & Destructor Documentation

Handshake_State() [1/3]

Botan::TLS::Handshake_State::Handshake_State	(	std::unique_ptr< Handshake_IO >	io,
		Callbacks &	callbacks )

Definition at line 30 of file tls_handshake_state.cpp.

                                                                              :
      m_callbacks(cb), m_handshake_io(std::move(io)), m_version(m_handshake_io->initial_record_version()) {}

Referenced by Handshake_State(), Handshake_State(), operator=(), and operator=().

~Handshake_State()

Botan::TLS::Handshake_State::~Handshake_State ( )

virtualdefault

Handshake_State() [2/3]

Botan::TLS::Handshake_State::Handshake_State ( const Handshake_State & other )

delete

References Handshake_State().

Handshake_State() [3/3]

Botan::TLS::Handshake_State::Handshake_State ( Handshake_State && other )

delete

References Handshake_State().

Member Function Documentation

callbacks()

Callbacks & Botan::TLS::Handshake_State::callbacks ( ) const

inline

Definition at line 171 of file tls_handshake_state.h.

{ return m_callbacks; }

Referenced by Botan::TLS::Certificate_Verify_12::Certificate_Verify_12(), Botan::TLS::Client_Key_Exchange::Client_Key_Exchange(), Botan::TLS::Client_Key_Exchange::Client_Key_Exchange(), Botan::TLS::Server_Key_Exchange::Server_Key_Exchange(), Botan::TLS::Certificate_Verify_12::verify(), and Botan::TLS::Server_Key_Exchange::verify().

cert_req() [1/2]

const Certificate_Request_12 * Botan::TLS::Handshake_State::cert_req ( ) const

inline

Definition at line 143 of file tls_handshake_state.h.

{ return m_cert_req.get(); }

Referenced by choose_sig_format(), and parse_sig_format().

cert_req() [2/2]

void Botan::TLS::Handshake_State::cert_req

(

std::unique_ptr< Certificate_Request_12 >

cert_req

)

Definition at line 83 of file tls_handshake_state.cpp.

                                                                             {
   BOTAN_ASSERT_NONNULL(cert_req);
   m_cert_req = std::move(cert_req);
   note_message(*m_cert_req);
}

References BOTAN_ASSERT_NONNULL, cert_req(), and note_message().

Referenced by cert_req().

choose_sig_format()

std::pair< std::string, Signature_Format > Botan::TLS::Handshake_State::choose_sig_format	(	const Private_Key &	key,
		Signature_Scheme &	scheme,
		bool	for_client_auth,
		const Policy &	policy ) const

Definition at line 196 of file tls_handshake_state.cpp.

                                                                                                        {
   const std::string sig_algo = key.algo_name();
 
   const std::vector<Signature_Scheme> allowed = policy.allowed_signature_schemes();
 
   if(for_client_auth) {
      BOTAN_ASSERT_NONNULL(cert_req());
   } else {
      BOTAN_ASSERT_NONNULL(client_hello());
   }
 
   std::vector<Signature_Scheme> requested =
      (for_client_auth) ? cert_req()->signature_schemes() : client_hello()->signature_schemes();
 
   for(const Signature_Scheme scheme : allowed) {
      if(!scheme.is_available()) {
         continue;
      }
 
      if(scheme.algorithm_name() == sig_algo) {
         if(std::find(requested.begin(), requested.end(), scheme) != requested.end()) {
            chosen_scheme = scheme;
            break;
         }
      }
   }
 
   if(!chosen_scheme.is_set()) {
      throw TLS_Exception(Alert::HandshakeFailure,
                          "Could not agree on a signature scheme with peer for " + sig_algo + " key");
   }
 
   const std::string hash = chosen_scheme.hash_function_name();
 
   if(!policy.allowed_signature_hash(hash)) {
      throw TLS_Exception(Alert::HandshakeFailure, "Policy refuses to accept signing with any hash supported by peer");
   }
 
   if(!chosen_scheme.format().has_value()) {
      throw Invalid_Argument(sig_algo + " is invalid/unknown for TLS signatures");
   }
 
   return std::make_pair(chosen_scheme.padding_string(), chosen_scheme.format().value());
}

References Botan::Asymmetric_Key::algo_name(), Botan::TLS::Policy::allowed_signature_hash(), Botan::TLS::Policy::allowed_signature_schemes(), BOTAN_ASSERT_NONNULL, cert_req(), client_hello(), Botan::TLS::Signature_Scheme::format(), hash(), Botan::TLS::Signature_Scheme::hash_function_name(), Botan::TLS::Signature_Scheme::is_set(), Botan::TLS::Signature_Scheme::padding_string(), Botan::TLS::Certificate_Request_12::signature_schemes(), and Botan::TLS::Client_Hello::signature_schemes().

Referenced by Botan::TLS::Certificate_Verify_12::Certificate_Verify_12(), and Botan::TLS::Server_Key_Exchange::Server_Key_Exchange().

ciphersuite()

const Ciphersuite & Botan::TLS::Handshake_State::ciphersuite

(

)

const

Definition at line 137 of file tls_handshake_state.cpp.

                                                      {
   if(!m_ciphersuite.has_value()) {
      throw Invalid_State("Cipher suite is not set");
   }
   return m_ciphersuite.value();
}

Referenced by Botan::TLS::Client_Key_Exchange::Client_Key_Exchange(), Botan::TLS::Client_Key_Exchange::Client_Key_Exchange(), protocol_specific_prf(), Botan::TLS::Server_Key_Exchange::Server_Key_Exchange(), and Botan::TLS::Session_Keys::Session_Keys().

client_certs() [1/2]

const Certificate_12 * Botan::TLS::Handshake_State::client_certs ( ) const

inline

Definition at line 147 of file tls_handshake_state.h.

{ return m_client_certs.get(); }

client_certs() [2/2]

void Botan::TLS::Handshake_State::client_certs

(

std::unique_ptr< Certificate_12 >

client_certs

)

Definition at line 95 of file tls_handshake_state.cpp.

                                                                             {
   BOTAN_ASSERT_NONNULL(client_certs);
   m_client_certs = std::move(client_certs);
   note_message(*m_client_certs);
}

References BOTAN_ASSERT_NONNULL, client_certs(), and note_message().

Referenced by client_certs().

client_finished() [1/2]

const Finished_12 * Botan::TLS::Handshake_State::client_finished ( ) const

inline

Definition at line 161 of file tls_handshake_state.h.

{ return m_client_finished.get(); }

client_finished() [2/2]

void Botan::TLS::Handshake_State::client_finished

(

std::unique_ptr< Finished_12 >

client_finished

)

Definition at line 131 of file tls_handshake_state.cpp.

                                                                                {
   BOTAN_ASSERT_NONNULL(client_finished);
   m_client_finished = std::move(client_finished);
   note_message(*m_client_finished);
}

References BOTAN_ASSERT_NONNULL, client_finished(), and note_message().

Referenced by client_finished().

client_hello() [1/2]

const Client_Hello_12 * Botan::TLS::Handshake_State::client_hello ( ) const

inline

Definition at line 135 of file tls_handshake_state.h.

{ return m_client_hello.get(); }

Referenced by choose_sig_format(), and session_ticket().

client_hello() [2/2]

void Botan::TLS::Handshake_State::client_hello

(

std::unique_ptr< Client_Hello_12 >

client_hello

)

Definition at line 47 of file tls_handshake_state.cpp.

                                                                              {
   // Legacy behavior (exception to the rule): Allow client_hello to be nullptr to reset state.
   if(client_hello == nullptr) {
      m_client_hello.reset();
      hash().reset();
   } else {
      m_client_hello = std::move(client_hello);
      note_message(*m_client_hello);
   }
}

References client_hello(), hash(), note_message(), and Botan::TLS::Handshake_Hash::reset().

Referenced by client_hello(), Botan::TLS::Client_Impl_12::Client_Impl_12(), Botan::TLS::Client_Key_Exchange::Client_Key_Exchange(), Botan::TLS::Client_Key_Exchange::Client_Key_Exchange(), Botan::TLS::Server_Key_Exchange::Server_Key_Exchange(), Botan::TLS::Session_Keys::Session_Keys(), Botan::TLS::Certificate_Verify_12::verify(), and Botan::TLS::Server_Key_Exchange::verify().

client_kex() [1/2]

const Client_Key_Exchange * Botan::TLS::Handshake_State::client_kex ( ) const

inline

Definition at line 149 of file tls_handshake_state.h.

{ return m_client_kex.get(); }

Referenced by compute_session_keys().

client_kex() [2/2]

void Botan::TLS::Handshake_State::client_kex

(

std::unique_ptr< Client_Key_Exchange >

client_kex

)

Definition at line 101 of file tls_handshake_state.cpp.

                                                                              {
   BOTAN_ASSERT_NONNULL(client_kex);
   m_client_kex = std::move(client_kex);
   note_message(*m_client_kex);
}

References BOTAN_ASSERT_NONNULL, client_kex(), and note_message().

Referenced by client_kex().

client_verify() [1/2]

const Certificate_Verify_12 * Botan::TLS::Handshake_State::client_verify ( ) const

inline

Definition at line 151 of file tls_handshake_state.h.

{ return m_client_verify.get(); }

client_verify() [2/2]

void Botan::TLS::Handshake_State::client_verify

(

std::unique_ptr< Certificate_Verify_12 >

client_verify

)

Definition at line 107 of file tls_handshake_state.cpp.

                                                                                      {
   BOTAN_ASSERT_NONNULL(client_verify);
   m_client_verify = std::move(client_verify);
   note_message(*m_client_verify);
}

References BOTAN_ASSERT_NONNULL, client_verify(), and note_message().

Referenced by client_verify().

compute_session_keys() [1/2]

void Botan::TLS::Handshake_State::compute_session_keys

(

)

Definition at line 155 of file tls_handshake_state.cpp.

                                           {
   BOTAN_ASSERT_NONNULL(client_kex());
   m_session_keys = Session_Keys(this, client_kex()->pre_master_secret(), false);
}

References BOTAN_ASSERT_NONNULL, and client_kex().

compute_session_keys() [2/2]

void Botan::TLS::Handshake_State::compute_session_keys

(

const secure_vector< uint8_t > &

resume_master_secret

)

Definition at line 160 of file tls_handshake_state.cpp.

                                                                                             {
   m_session_keys = Session_Keys(this, resume_master_secret, true);
}

confirm_transition_to()

void Botan::TLS::Handshake_State::confirm_transition_to

(

Handshake_Type

msg_type

)

Confirm that we were expecting this message type

Parameters

msg_type

the message type

Definition at line 164 of file tls_handshake_state.cpp.

                                                                        {
   m_transitions.confirm_transition_to(handshake_msg);
}

get_next_handshake_msg()

std::pair< Handshake_Type, std::vector< uint8_t > > Botan::TLS::Handshake_State::get_next_handshake_msg

(

size_t

max_handshake_msg_size

)

Definition at line 176 of file tls_handshake_state.cpp.

                                                                                                                 {
   return m_handshake_io->get_next_record(m_transitions.change_cipher_spec_expected(), max_handshake_msg_size);
}

handshake_io()

Handshake_IO & Botan::TLS::Handshake_State::handshake_io ( )

inline

Definition at line 71 of file tls_handshake_state.h.

{ return *m_handshake_io; }

Referenced by hello_verify_request().

hash() [1/2]

Handshake_Hash & Botan::TLS::Handshake_State::hash ( )

inline

Definition at line 177 of file tls_handshake_state.h.

{ return m_handshake_hash; }

Referenced by Botan::TLS::Certificate_Verify_12::Certificate_Verify_12(), choose_sig_format(), client_hello(), Botan::TLS::Client_Impl_12::Client_Impl_12(), Botan::TLS::Client_Key_Exchange::Client_Key_Exchange(), Botan::TLS::Finished_12::Finished_12(), hello_verify_request(), Botan::TLS::Server_Key_Exchange::Server_Key_Exchange(), Botan::TLS::Session_Keys::Session_Keys(), and Botan::TLS::Certificate_Verify_12::verify().

hash() [2/2]

const Handshake_Hash & Botan::TLS::Handshake_State::hash ( ) const

inline

Definition at line 179 of file tls_handshake_state.h.

{ return m_handshake_hash; }

hello_verify_request()

void Botan::TLS::Handshake_State::hello_verify_request

(

const Hello_Verify_Request &

hello_verify

)

Definition at line 37 of file tls_handshake_state.cpp.

                                                                                   {
   note_message(hello_verify);
 
   BOTAN_ASSERT_NONNULL(m_client_hello);
   m_client_hello->update_hello_cookie(hello_verify);
   hash().reset();
   hash().update(handshake_io().send(*m_client_hello));
   note_message(*m_client_hello);
}

References BOTAN_ASSERT_NONNULL, handshake_io(), hash(), note_message(), Botan::TLS::Handshake_Hash::reset(), and Botan::TLS::Handshake_Hash::update().

new_session_ticket() [1/2]

const New_Session_Ticket_12 * Botan::TLS::Handshake_State::new_session_ticket ( ) const

inline

Definition at line 157 of file tls_handshake_state.h.

{ return m_new_session_ticket.get(); }

Referenced by session_ticket().

new_session_ticket() [2/2]

void Botan::TLS::Handshake_State::new_session_ticket

(

std::unique_ptr< New_Session_Ticket_12 >

new_session_ticket

)

Definition at line 119 of file tls_handshake_state.cpp.

                                                                                                {
   BOTAN_ASSERT_NONNULL(new_session_ticket);
   m_new_session_ticket = std::move(new_session_ticket);
   note_message(*m_new_session_ticket);
}

References BOTAN_ASSERT_NONNULL, new_session_ticket(), and note_message().

Referenced by new_session_ticket().

note_message()

void Botan::TLS::Handshake_State::note_message

(

const Handshake_Message &

msg

)

Definition at line 33 of file tls_handshake_state.cpp.

                                                               {
   m_callbacks.tls_inspect_handshake_msg(msg);
}

Referenced by cert_req(), client_certs(), client_finished(), client_hello(), client_kex(), client_verify(), hello_verify_request(), new_session_ticket(), server_cert_status(), server_certs(), server_finished(), server_hello(), server_hello_done(), server_kex(), and server_verify().

operator=() [1/2]

Handshake_State & Botan::TLS::Handshake_State::operator= ( const Handshake_State & other )

delete

References Handshake_State().

operator=() [2/2]

Handshake_State & Botan::TLS::Handshake_State::operator= ( Handshake_State && other )

delete

References Handshake_State().

parse_sig_format()

std::pair< std::string, Signature_Format > Botan::TLS::Handshake_State::parse_sig_format	(	const Public_Key &	key,
		Signature_Scheme	scheme,
		const std::vector< Signature_Scheme > &	offered_schemes,
		bool	for_client_auth,
		const Policy &	policy ) const

Definition at line 258 of file tls_handshake_state.cpp.

                               {
   const std::string key_type = key.algo_name();
 
   if(!policy.allowed_signature_method(key_type)) {
      throw TLS_Exception(Alert::HandshakeFailure, "Rejecting " + key_type + " signature");
   }
 
   if(!scheme.is_available()) {
      throw TLS_Exception(Alert::IllegalParameter, "Peer sent unknown signature scheme");
   }
 
   if(key_type != scheme.algorithm_name()) {
      throw Decoding_Error("Counterparty sent inconsistent key and sig types");
   }
 
   if(for_client_auth && cert_req() == nullptr) {
      throw TLS_Exception(Alert::HandshakeFailure, "No CertificateVerify message received");
   }
 
   /*
   Confirm the signature type we just received against the
   supported_algos list that we sent; it better be there.
   */
 
   const std::vector<Signature_Scheme> supported_algos =
      for_client_auth ? cert_req()->signature_schemes() : offered_schemes;
 
   if(!scheme.is_compatible_with(Protocol_Version::TLS_V12)) {
      throw TLS_Exception(Alert::IllegalParameter, "Peer sent unacceptable signature scheme");
   }
 
   if(!supported_algos_include(supported_algos, scheme)) {
      throw TLS_Exception(Alert::IllegalParameter,
                          "TLS signature extension did not allow for " + scheme.to_string() + " signature");
   }
 
   if(!scheme.format().has_value()) {
      throw Invalid_Argument(key_type + " is invalid/unknown for TLS signatures");
   }
 
   return std::make_pair(scheme.padding_string(), scheme.format().value());
}

References Botan::Asymmetric_Key::algo_name(), Botan::TLS::Signature_Scheme::algorithm_name(), Botan::TLS::Policy::allowed_signature_method(), cert_req(), Botan::TLS::Signature_Scheme::format(), Botan::TLS::Signature_Scheme::is_available(), Botan::TLS::Signature_Scheme::is_compatible_with(), Botan::TLS::Signature_Scheme::padding_string(), Botan::TLS::Certificate_Request_12::signature_schemes(), and Botan::TLS::Signature_Scheme::to_string().

Referenced by Botan::TLS::Certificate_Verify_12::verify(), and Botan::TLS::Server_Key_Exchange::verify().

peer_cert_chain()

virtual std::vector< X509_Certificate > Botan::TLS::Handshake_State::peer_cert_chain ( ) const

pure virtual

protocol_specific_prf()

std::unique_ptr< KDF > Botan::TLS::Handshake_State::protocol_specific_prf

(

)

const

Definition at line 192 of file tls_handshake_state.cpp.

                                                                {
   return m_callbacks.tls12_protocol_specific_kdf(ciphersuite().prf_algo());
}

References ciphersuite().

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

psk_identity()

std::optional< std::string > Botan::TLS::Handshake_State::psk_identity

(

)

const

Definition at line 144 of file tls_handshake_state.cpp.

                                                           {
   if(!m_client_kex) {
      return std::nullopt;
   }
   return m_client_kex->psk_identity();
}

received_handshake_msg()

bool Botan::TLS::Handshake_State::received_handshake_msg

(

Handshake_Type

msg_type

)

const

Return true iff we have received a particular message already

Parameters

msg_type

the message type

Definition at line 172 of file tls_handshake_state.cpp.

                                                                               {
   return m_transitions.received_handshake_msg(handshake_msg);
}

server_cert_status() [1/2]

const Certificate_Status * Botan::TLS::Handshake_State::server_cert_status ( ) const

inline

Definition at line 155 of file tls_handshake_state.h.

{ return m_server_cert_status.get(); }

server_cert_status() [2/2]

void Botan::TLS::Handshake_State::server_cert_status

(

std::unique_ptr< Certificate_Status >

server_cert_status

)

Definition at line 71 of file tls_handshake_state.cpp.

                                                                                             {
   BOTAN_ASSERT_NONNULL(server_cert_status);
   m_server_cert_status = std::move(server_cert_status);
   note_message(*m_server_cert_status);
}

References BOTAN_ASSERT_NONNULL, note_message(), and server_cert_status().

Referenced by server_cert_status().

server_certs() [1/2]

const Certificate_12 * Botan::TLS::Handshake_State::server_certs ( ) const

inline

Definition at line 139 of file tls_handshake_state.h.

{ return m_server_certs.get(); }

server_certs() [2/2]

void Botan::TLS::Handshake_State::server_certs

(

std::unique_ptr< Certificate_12 >

server_certs

)

Definition at line 65 of file tls_handshake_state.cpp.

                                                                             {
   BOTAN_ASSERT_NONNULL(server_certs);
   m_server_certs = std::move(server_certs);
   note_message(*m_server_certs);
}

References BOTAN_ASSERT_NONNULL, note_message(), and server_certs().

Referenced by Botan::TLS::Client_Key_Exchange::Client_Key_Exchange(), and server_certs().

server_finished() [1/2]

const Finished_12 * Botan::TLS::Handshake_State::server_finished ( ) const

inline

Definition at line 159 of file tls_handshake_state.h.

{ return m_server_finished.get(); }

server_finished() [2/2]

void Botan::TLS::Handshake_State::server_finished

(

std::unique_ptr< Finished_12 >

server_finished

)

Definition at line 125 of file tls_handshake_state.cpp.

                                                                                {
   BOTAN_ASSERT_NONNULL(server_finished);
   m_server_finished = std::move(server_finished);
   note_message(*m_server_finished);
}

References BOTAN_ASSERT_NONNULL, note_message(), and server_finished().

Referenced by server_finished().

server_hello() [1/2]

const Server_Hello_12 * Botan::TLS::Handshake_State::server_hello ( ) const

inline

Definition at line 137 of file tls_handshake_state.h.

{ return m_server_hello.get(); }

server_hello() [2/2]

void Botan::TLS::Handshake_State::server_hello

(

std::unique_ptr< Server_Hello_12 >

server_hello

)

Definition at line 58 of file tls_handshake_state.cpp.

                                                                              {
   BOTAN_ASSERT_NONNULL(server_hello);
   m_server_hello = std::move(server_hello);
   m_ciphersuite = Ciphersuite::by_id(m_server_hello->ciphersuite());
   note_message(*m_server_hello);
}

References BOTAN_ASSERT_NONNULL, Botan::TLS::Ciphersuite::by_id(), note_message(), and server_hello().

Referenced by Botan::TLS::Client_Key_Exchange::Client_Key_Exchange(), server_hello(), Botan::TLS::Server_Key_Exchange::Server_Key_Exchange(), Botan::TLS::Session_Keys::Session_Keys(), and Botan::TLS::Server_Key_Exchange::verify().

server_hello_done() [1/2]

const Server_Hello_Done * Botan::TLS::Handshake_State::server_hello_done ( ) const

inline

Definition at line 145 of file tls_handshake_state.h.

{ return m_server_hello_done.get(); }

server_hello_done() [2/2]

void Botan::TLS::Handshake_State::server_hello_done

(

std::unique_ptr< Server_Hello_Done >

server_hello_done

)

Definition at line 89 of file tls_handshake_state.cpp.

                                                                                          {
   BOTAN_ASSERT_NONNULL(server_hello_done);
   m_server_hello_done = std::move(server_hello_done);
   note_message(*m_server_hello_done);
}

References BOTAN_ASSERT_NONNULL, note_message(), and server_hello_done().

Referenced by server_hello_done().

server_kex() [1/2]

const Server_Key_Exchange * Botan::TLS::Handshake_State::server_kex ( ) const

inline

Definition at line 141 of file tls_handshake_state.h.

{ return m_server_kex.get(); }

server_kex() [2/2]

void Botan::TLS::Handshake_State::server_kex

(

std::unique_ptr< Server_Key_Exchange >

server_kex

)

Definition at line 77 of file tls_handshake_state.cpp.

                                                                              {
   BOTAN_ASSERT_NONNULL(server_kex);
   m_server_kex = std::move(server_kex);
   note_message(*m_server_kex);
}

References BOTAN_ASSERT_NONNULL, note_message(), and server_kex().

Referenced by Botan::TLS::Client_Key_Exchange::Client_Key_Exchange(), Botan::TLS::Client_Key_Exchange::Client_Key_Exchange(), and server_kex().

server_verify() [1/2]

const Certificate_Verify_12 * Botan::TLS::Handshake_State::server_verify ( ) const

inline

Definition at line 153 of file tls_handshake_state.h.

{ return m_server_verify.get(); }

server_verify() [2/2]

void Botan::TLS::Handshake_State::server_verify

(

std::unique_ptr< Certificate_Verify_12 >

server_verify

)

Definition at line 113 of file tls_handshake_state.cpp.

                                                                                      {
   BOTAN_ASSERT_NONNULL(server_verify);
   m_server_verify = std::move(server_verify);
   note_message(*m_server_verify);
}

References BOTAN_ASSERT_NONNULL, note_message(), and server_verify().

Referenced by server_verify().

session_keys()

const Session_Keys & Botan::TLS::Handshake_State::session_keys ( ) const

inline

Definition at line 169 of file tls_handshake_state.h.

{ return m_session_keys; }

session_ticket()

Session_Ticket Botan::TLS::Handshake_State::session_ticket

(

)

const

Definition at line 180 of file tls_handshake_state.cpp.

                                                     {
   if(const auto* nst = new_session_ticket()) {
      const auto& ticket = nst->ticket();
      if(!ticket.empty()) {
         return ticket;
      }
   }
 
   BOTAN_ASSERT_NONNULL(client_hello());
   return client_hello()->session_ticket();
}

References BOTAN_ASSERT_NONNULL, client_hello(), new_session_ticket(), and Botan::TLS::Client_Hello_12::session_ticket().

set_expected_next()

void Botan::TLS::Handshake_State::set_expected_next

(

Handshake_Type

msg_type

)

Record that we are expecting a particular message type next

Parameters

msg_type

the message type

Definition at line 168 of file tls_handshake_state.cpp.

                                                                    {
   m_transitions.set_expected_next(handshake_msg);
}

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

set_version()

void Botan::TLS::Handshake_State::set_version

(

const Protocol_Version &

version

)

Definition at line 151 of file tls_handshake_state.cpp.

                                                                 {
   m_version = version;
}

References version().

take_handshake_io()

std::unique_ptr< Handshake_IO > Botan::TLS::Handshake_State::take_handshake_io ( )

inline

Definition at line 73 of file tls_handshake_state.h.

{ return std::move(m_handshake_io); }

version()

Protocol_Version Botan::TLS::Handshake_State::version ( ) const

inline

Definition at line 110 of file tls_handshake_state.h.

{ return m_version; }

Referenced by set_version().

---

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

• src/lib/tls/tls12/tls_handshake_state.h
• src/lib/tls/tls12/tls_handshake_state.cpp