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 (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 (Certificate_12 *client_certs)
const Finished_12 *	client_finished () const
void	client_finished (Finished_12 *client_finished)
const Client_Hello_12 *	client_hello () const
void	client_hello (Client_Hello_12 *client_hello)
const Client_Key_Exchange *	client_kex () const
void	client_kex (Client_Key_Exchange *client_kex)
const Certificate_Verify_12 *	client_verify () const
void	client_verify (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 ()
Handshake_IO &	handshake_io ()
	Handshake_State (const Handshake_State &)=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 (New_Session_Ticket_12 *new_session_ticket)
void	note_message (const Handshake_Message &msg)
Handshake_State &	operator= (const Handshake_State &)=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
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 (Certificate_Status *server_cert_status)
const Certificate_12 *	server_certs () const
void	server_certs (Certificate_12 *server_certs)
const Finished_12 *	server_finished () const
void	server_finished (Finished_12 *server_finished)
const Server_Hello_12 *	server_hello () const
void	server_hello (Server_Hello_12 *server_hello)
const Server_Hello_Done *	server_hello_done () const
void	server_hello_done (Server_Hello_Done *server_hello_done)
const Server_Key_Exchange *	server_kex () const
void	server_kex (Server_Key_Exchange *server_kex)
const Certificate_Verify_12 *	server_verify () const
void	server_verify (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)
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 59 of file tls_handshake_state.h.

Constructor & Destructor Documentation

Handshake_State() [1/2]

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

Definition at line 95 of file tls_handshake_state.cpp.

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

~Handshake_State()

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

virtualdefault

Handshake_State() [2/2]

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

delete

Member Function Documentation

callbacks()

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

inline

Definition at line 165 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 139 of file tls_handshake_state.h.

{ return m_cert_req.get(); }

Referenced by cert_req(), choose_sig_format(), and parse_sig_format().

cert_req() [2/2]

void Botan::TLS::Handshake_State::cert_req

(

Certificate_Request_12 *

cert_req

)

Definition at line 142 of file tls_handshake_state.cpp.

                                                               {
   m_cert_req.reset(cert_req);
   note_message(*m_cert_req);
}

References cert_req(), and note_message().

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 247 of file tls_handshake_state.cpp.

                                                                                                        {
   const std::string sig_algo = key.algo_name();
 
   const std::vector<Signature_Scheme> allowed = policy.allowed_signature_schemes();
 
   std::vector<Signature_Scheme> requested =
      (for_client_auth) ? cert_req()->signature_schemes() : client_hello()->signature_schemes();
 
   for(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;
         }
      }
   }
 
   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(), cert_req(), client_hello(), Botan::TLS::Signature_Scheme::format(), hash(), Botan::TLS::Signature_Scheme::hash_function_name(), 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 187 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 143 of file tls_handshake_state.h.

{ return m_client_certs.get(); }

Referenced by client_certs().

client_certs() [2/2]

void Botan::TLS::Handshake_State::client_certs

(

Certificate_12 *

client_certs

)

Definition at line 152 of file tls_handshake_state.cpp.

                                                               {
   m_client_certs.reset(client_certs);
   note_message(*m_client_certs);
}

References client_certs(), and note_message().

client_finished() [1/2]

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

inline

Definition at line 157 of file tls_handshake_state.h.

{ return m_client_finished.get(); }

Referenced by client_finished().

client_finished() [2/2]

void Botan::TLS::Handshake_State::client_finished

(

Finished_12 *

client_finished

)

Definition at line 182 of file tls_handshake_state.cpp.

                                                                  {
   m_client_finished.reset(client_finished);
   note_message(*m_client_finished);
}

References client_finished(), and note_message().

client_hello() [1/2]

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

inline

Definition at line 131 of file tls_handshake_state.h.

{ return m_client_hello.get(); }

Referenced by choose_sig_format(), client_hello(), and session_ticket().

client_hello() [2/2]

void Botan::TLS::Handshake_State::client_hello

(

Client_Hello_12 *

client_hello

)

Definition at line 111 of file tls_handshake_state.cpp.

                                                                {
   if(client_hello == nullptr) {
      m_client_hello.reset();
      hash().reset();
   } else {
      m_client_hello.reset(client_hello);
      note_message(*m_client_hello);
   }
}

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

Referenced by 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 145 of file tls_handshake_state.h.

{ return m_client_kex.get(); }

Referenced by client_kex(), and compute_session_keys().

client_kex() [2/2]

void Botan::TLS::Handshake_State::client_kex

(

Client_Key_Exchange *

client_kex

)

Definition at line 157 of file tls_handshake_state.cpp.

                                                                {
   m_client_kex.reset(client_kex);
   note_message(*m_client_kex);
}

References client_kex(), and note_message().

client_verify() [1/2]

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

inline

Definition at line 147 of file tls_handshake_state.h.

{ return m_client_verify.get(); }

Referenced by client_verify().

client_verify() [2/2]

void Botan::TLS::Handshake_State::client_verify

(

Certificate_Verify_12 *

client_verify

)

Definition at line 162 of file tls_handshake_state.cpp.

                                                                        {
   m_client_verify.reset(client_verify);
   note_message(*m_client_verify);
}

References client_verify(), and note_message().

compute_session_keys() [1/2]

void Botan::TLS::Handshake_State::compute_session_keys

(

)

Definition at line 205 of file tls_handshake_state.cpp.

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

References 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 209 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 213 of file tls_handshake_state.cpp.

                                                                        {
   m_transitions.confirm_transition_to(handshake_msg);
}

References Botan::TLS::Handshake_Transitions::confirm_transition_to().

get_next_handshake_msg()

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

(

)

Definition at line 225 of file tls_handshake_state.cpp.

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

References Botan::TLS::Handshake_Transitions::change_cipher_spec_expected().

handshake_io()

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

inline

Definition at line 67 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 171 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 173 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 102 of file tls_handshake_state.cpp.

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

References 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 153 of file tls_handshake_state.h.

{ return m_new_session_ticket.get(); }

Referenced by new_session_ticket(), and session_ticket().

new_session_ticket() [2/2]

void Botan::TLS::Handshake_State::new_session_ticket

(

New_Session_Ticket_12 *

new_session_ticket

)

Definition at line 172 of file tls_handshake_state.cpp.

                                                                                  {
   m_new_session_ticket.reset(new_session_ticket);
   note_message(*m_new_session_ticket);
}

References new_session_ticket(), and note_message().

note_message()

void Botan::TLS::Handshake_State::note_message

(

const Handshake_Message &

msg

)

Definition at line 98 of file tls_handshake_state.cpp.

                                                               {
   m_callbacks.tls_inspect_handshake_msg(msg);
}

References Botan::TLS::Callbacks::tls_inspect_handshake_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=()

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

delete

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 300 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()) {
      throw TLS_Exception(Alert::HandshakeFailure, "No certificate verify set");
   }
 
   /*
   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;
 
   const std::string hash_algo = scheme.hash_function_name();
 
   if(!scheme.is_compatible_with(Protocol_Version::TLS_V12)) {
      throw TLS_Exception(Alert::IllegalParameter, "Peer sent unexceptable signature scheme");
   }
 
   if(!supported_algos_include(supported_algos, key_type, hash_algo)) {
      throw TLS_Exception(Alert::IllegalParameter,
                          "TLS signature extension did not allow for " + key_type + "/" + hash_algo + " 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::hash_function_name(), Botan::TLS::Signature_Scheme::is_available(), Botan::TLS::Signature_Scheme::is_compatible_with(), Botan::TLS::Signature_Scheme::padding_string(), and Botan::TLS::Certificate_Request_12::signature_schemes().

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

protocol_specific_prf()

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

(

)

const

Definition at line 237 of file tls_handshake_state.cpp.

                                                                {
   const std::string prf_algo = ciphersuite().prf_algo();
 
   if(prf_algo == "MD5" || prf_algo == "SHA-1") {
      return KDF::create_or_throw("TLS-12-PRF(SHA-256)");
   }
 
   return KDF::create_or_throw("TLS-12-PRF(" + prf_algo + ")");
}

References ciphersuite(), Botan::KDF::create_or_throw(), and Botan::TLS::Ciphersuite::prf_algo().

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

psk_identity()

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

(

)

const

Definition at line 194 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 221 of file tls_handshake_state.cpp.

                                                                               {
   return m_transitions.received_handshake_msg(handshake_msg);
}

References Botan::TLS::Handshake_Transitions::received_handshake_msg().

server_cert_status() [1/2]

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

inline

Definition at line 151 of file tls_handshake_state.h.

{ return m_server_cert_status.get(); }

Referenced by server_cert_status().

server_cert_status() [2/2]

void Botan::TLS::Handshake_State::server_cert_status

(

Certificate_Status *

server_cert_status

)

Definition at line 132 of file tls_handshake_state.cpp.

                                                                               {
   m_server_cert_status.reset(server_cert_status);
   note_message(*m_server_cert_status);
}

References note_message(), and server_cert_status().

server_certs() [1/2]

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

inline

Definition at line 135 of file tls_handshake_state.h.

{ return m_server_certs.get(); }

Referenced by server_certs().

server_certs() [2/2]

void Botan::TLS::Handshake_State::server_certs

(

Certificate_12 *

server_certs

)

Definition at line 127 of file tls_handshake_state.cpp.

                                                               {
   m_server_certs.reset(server_certs);
   note_message(*m_server_certs);
}

References note_message(), and server_certs().

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

server_finished() [1/2]

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

inline

Definition at line 155 of file tls_handshake_state.h.

{ return m_server_finished.get(); }

Referenced by server_finished().

server_finished() [2/2]

void Botan::TLS::Handshake_State::server_finished

(

Finished_12 *

server_finished

)

Definition at line 177 of file tls_handshake_state.cpp.

                                                                  {
   m_server_finished.reset(server_finished);
   note_message(*m_server_finished);
}

References note_message(), and server_finished().

server_hello() [1/2]

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

inline

Definition at line 133 of file tls_handshake_state.h.

{ return m_server_hello.get(); }

Referenced by server_hello().

server_hello() [2/2]

void Botan::TLS::Handshake_State::server_hello

(

Server_Hello_12 *

server_hello

)

Definition at line 121 of file tls_handshake_state.cpp.

                                                                {
   m_server_hello.reset(server_hello);
   m_ciphersuite = Ciphersuite::by_id(m_server_hello->ciphersuite());
   note_message(*m_server_hello);
}

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

Referenced by Botan::TLS::Client_Key_Exchange::Client_Key_Exchange(), 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 141 of file tls_handshake_state.h.

{ return m_server_hello_done.get(); }

Referenced by server_hello_done().

server_hello_done() [2/2]

void Botan::TLS::Handshake_State::server_hello_done

(

Server_Hello_Done *

server_hello_done

)

Definition at line 147 of file tls_handshake_state.cpp.

                                                                            {
   m_server_hello_done.reset(server_hello_done);
   note_message(*m_server_hello_done);
}

References note_message(), and server_hello_done().

server_kex() [1/2]

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

inline

Definition at line 137 of file tls_handshake_state.h.

{ return m_server_kex.get(); }

Referenced by server_kex().

server_kex() [2/2]

void Botan::TLS::Handshake_State::server_kex

(

Server_Key_Exchange *

server_kex

)

Definition at line 137 of file tls_handshake_state.cpp.

                                                                {
   m_server_kex.reset(server_kex);
   note_message(*m_server_kex);
}

References note_message(), and server_kex().

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

server_verify() [1/2]

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

inline

Definition at line 149 of file tls_handshake_state.h.

{ return m_server_verify.get(); }

Referenced by server_verify().

server_verify() [2/2]

void Botan::TLS::Handshake_State::server_verify

(

Certificate_Verify_12 *

server_verify

)

Definition at line 167 of file tls_handshake_state.cpp.

                                                                        {
   m_server_verify.reset(server_verify);
   note_message(*m_server_verify);
}

References note_message(), and server_verify().

session_keys()

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

inline

Definition at line 163 of file tls_handshake_state.h.

{ return m_session_keys; }

session_ticket()

Session_Ticket Botan::TLS::Handshake_State::session_ticket

(

)

const

Definition at line 229 of file tls_handshake_state.cpp.

                                                     {
   if(new_session_ticket() && !new_session_ticket()->ticket().empty()) {
      return new_session_ticket()->ticket();
   }
 
   return client_hello()->session_ticket();
}

References client_hello(), new_session_ticket(), Botan::TLS::Client_Hello_12::session_ticket(), and Botan::TLS::New_Session_Ticket_12::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 217 of file tls_handshake_state.cpp.

                                                                    {
   m_transitions.set_expected_next(handshake_msg);
}

References Botan::TLS::Handshake_Transitions::set_expected_next().

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 201 of file tls_handshake_state.cpp.

                                                                 {
   m_version = version;
}

References version().

version()

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

inline

Definition at line 104 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