Botan 3.9.0
Crypto and TLS for C&
Botan::TLS::Handshake_State Class Reference

#include <tls_handshake_state.h>

Public Member Functions

Callbackscallbacks () const
const Certificate_Request_12cert_req () const
void cert_req (std::unique_ptr< Certificate_Request_12 > cert_req)
std::pair< std::string, Signature_Formatchoose_sig_format (const Private_Key &key, Signature_Scheme &scheme, bool for_client_auth, const Policy &policy) const
const Ciphersuiteciphersuite () const
const Certificate_12client_certs () const
void client_certs (std::unique_ptr< Certificate_12 > client_certs)
const Finished_12client_finished () const
void client_finished (std::unique_ptr< Finished_12 > client_finished)
const Client_Hello_12client_hello () const
void client_hello (std::unique_ptr< Client_Hello_12 > client_hello)
const Client_Key_Exchangeclient_kex () const
void client_kex (std::unique_ptr< Client_Key_Exchange > client_kex)
const Certificate_Verify_12client_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 ()
Handshake_IOhandshake_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_Hashhash ()
const Handshake_Hashhash () const
void hello_verify_request (const Hello_Verify_Request &hello_verify)
const New_Session_Ticket_12new_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_Stateoperator= (const Handshake_State &other)=delete
Handshake_Stateoperator= (Handshake_State &&other)=delete
std::pair< std::string, Signature_Formatparse_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< KDFprotocol_specific_prf () const
std::optional< std::string > psk_identity () const
bool received_handshake_msg (Handshake_Type msg_type) const
const Certificate_Statusserver_cert_status () const
void server_cert_status (std::unique_ptr< Certificate_Status > server_cert_status)
const Certificate_12server_certs () const
void server_certs (std::unique_ptr< Certificate_12 > server_certs)
const Finished_12server_finished () const
void server_finished (std::unique_ptr< Finished_12 > server_finished)
const Server_Hello_12server_hello () const
void server_hello (std::unique_ptr< Server_Hello_12 > server_hello)
const Server_Hello_Doneserver_hello_done () const
void server_hello_done (std::unique_ptr< Server_Hello_Done > server_hello_done)
const Server_Key_Exchangeserver_kex () const
void server_kex (std::unique_ptr< Server_Key_Exchange > server_kex)
const Certificate_Verify_12server_verify () const
void server_verify (std::unique_ptr< Certificate_Verify_12 > server_verify)
const Session_Keyssession_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/3]

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

Definition at line 95 of file tls_handshake_state.cpp.

95 :
96 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()

◆ 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.

139{ 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 147 of file tls_handshake_state.cpp.

147 {
149 m_cert_req = std::move(cert_req);
150 note_message(*m_cert_req);
151}
#define BOTAN_ASSERT_NONNULL(ptr)
Definition assert.h:114
void note_message(const Handshake_Message &msg)
void cert_req(std::unique_ptr< Certificate_Request_12 > 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 264 of file tls_handshake_state.cpp.

267 {
268 const std::string sig_algo = key.algo_name();
269
270 const std::vector<Signature_Scheme> allowed = policy.allowed_signature_schemes();
271
272 std::vector<Signature_Scheme> requested =
273 (for_client_auth) ? cert_req()->signature_schemes() : client_hello()->signature_schemes();
274
275 for(Signature_Scheme scheme : allowed) {
276 if(!scheme.is_available()) {
277 continue;
278 }
279
280 if(scheme.algorithm_name() == sig_algo) {
281 if(std::find(requested.begin(), requested.end(), scheme) != requested.end()) {
282 chosen_scheme = scheme;
283 break;
284 }
285 }
286 }
287
288 const std::string hash = chosen_scheme.hash_function_name();
289
290 if(!policy.allowed_signature_hash(hash)) {
291 throw TLS_Exception(Alert::HandshakeFailure, "Policy refuses to accept signing with any hash supported by peer");
292 }
293
294 if(!chosen_scheme.format().has_value()) {
295 throw Invalid_Argument(sig_algo + " is invalid/unknown for TLS signatures");
296 }
297
298 return std::make_pair(chosen_scheme.padding_string(), chosen_scheme.format().value());
299}
const std::vector< Signature_Scheme > & signature_schemes() const
std::vector< Signature_Scheme > signature_schemes() const
const Client_Hello_12 * client_hello() const
const Certificate_Request_12 * cert_req() const

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

201 {
202 if(!m_ciphersuite.has_value()) {
203 throw Invalid_State("Cipher suite is not set");
204 }
205 return m_ciphersuite.value();
206}

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.

143{ 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 159 of file tls_handshake_state.cpp.

159 {
161 m_client_certs = std::move(client_certs);
162 note_message(*m_client_certs);
163}
void client_certs(std::unique_ptr< Certificate_12 > 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 157 of file tls_handshake_state.h.

157{ 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 195 of file tls_handshake_state.cpp.

195 {
197 m_client_finished = std::move(client_finished);
198 note_message(*m_client_finished);
199}
void client_finished(std::unique_ptr< Finished_12 > 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 131 of file tls_handshake_state.h.

131{ 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 111 of file tls_handshake_state.cpp.

111 {
112 // Legacy behavior (exception to the rule): Allow client_hello to be nullptr to reset state.
113 if(client_hello == nullptr) {
114 m_client_hello.reset();
115 hash().reset();
116 } else {
117 m_client_hello = std::move(client_hello);
118 note_message(*m_client_hello);
119 }
120}
void client_hello(std::unique_ptr< Client_Hello_12 > 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 145 of file tls_handshake_state.h.

145{ 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 165 of file tls_handshake_state.cpp.

165 {
167 m_client_kex = std::move(client_kex);
168 note_message(*m_client_kex);
169}
void client_kex(std::unique_ptr< Client_Key_Exchange > 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 147 of file tls_handshake_state.h.

147{ 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 171 of file tls_handshake_state.cpp.

171 {
173 m_client_verify = std::move(client_verify);
174 note_message(*m_client_verify);
175}
void client_verify(std::unique_ptr< Certificate_Verify_12 > 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 219 of file tls_handshake_state.cpp.

219 {
220 m_session_keys = Session_Keys(this, client_kex()->pre_master_secret(), false);
221}
const Client_Key_Exchange * client_kex() const

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

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

◆ 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_typethe message type

Definition at line 227 of file tls_handshake_state.cpp.

227 {
228 m_transitions.confirm_transition_to(handshake_msg);
229}

◆ get_next_handshake_msg()

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

Definition at line 239 of file tls_handshake_state.cpp.

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

◆ handshake_io()

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

Definition at line 69 of file tls_handshake_state.h.

69{ return *m_handshake_io; }

Referenced by hello_verify_request().

◆ hash() [1/2]

◆ hash() [2/2]

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

Definition at line 173 of file tls_handshake_state.h.

173{ 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.

102 {
103 note_message(hello_verify);
104
105 m_client_hello->update_hello_cookie(hello_verify);
106 hash().reset();
107 hash().update(handshake_io().send(*m_client_hello));
108 note_message(*m_client_hello);
109}
void update(const uint8_t in[], size_t length)

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.

153{ 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 183 of file tls_handshake_state.cpp.

183 {
185 m_new_session_ticket = std::move(new_session_ticket);
186 note_message(*m_new_session_ticket);
187}
void new_session_ticket(std::unique_ptr< New_Session_Ticket_12 > 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)

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

322 {
323 const std::string key_type = key.algo_name();
324
325 if(!policy.allowed_signature_method(key_type)) {
326 throw TLS_Exception(Alert::HandshakeFailure, "Rejecting " + key_type + " signature");
327 }
328
329 if(!scheme.is_available()) {
330 throw TLS_Exception(Alert::IllegalParameter, "Peer sent unknown signature scheme");
331 }
332
333 if(key_type != scheme.algorithm_name()) {
334 throw Decoding_Error("Counterparty sent inconsistent key and sig types");
335 }
336
337 if(for_client_auth && cert_req() == nullptr) {
338 throw TLS_Exception(Alert::HandshakeFailure, "No CertificateVerify message received");
339 }
340
341 /*
342 Confirm the signature type we just received against the
343 supported_algos list that we sent; it better be there.
344 */
345
346 const std::vector<Signature_Scheme> supported_algos =
347 for_client_auth ? cert_req()->signature_schemes() : offered_schemes;
348
349 const std::string hash_algo = scheme.hash_function_name();
350
351 if(!scheme.is_compatible_with(Protocol_Version::TLS_V12)) {
352 throw TLS_Exception(Alert::IllegalParameter, "Peer sent unexceptable signature scheme");
353 }
354
355 if(!supported_algos_include(supported_algos, key_type, hash_algo)) {
356 throw TLS_Exception(Alert::IllegalParameter,
357 "TLS signature extension did not allow for " + key_type + "/" + hash_algo + " signature");
358 }
359
360 if(!scheme.format().has_value()) {
361 throw Invalid_Argument(key_type + " is invalid/unknown for TLS signatures");
362 }
363
364 return std::make_pair(scheme.padding_string(), scheme.format().value());
365}

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

254 {
255 const std::string prf_algo = ciphersuite().prf_algo();
256
257 if(prf_algo == "MD5" || prf_algo == "SHA-1") {
258 return KDF::create_or_throw("TLS-12-PRF(SHA-256)");
259 }
260
261 return KDF::create_or_throw("TLS-12-PRF(" + prf_algo + ")");
262}
static std::unique_ptr< KDF > create_or_throw(std::string_view algo_spec, std::string_view provider="")
Definition kdf.cpp:204
std::string prf_algo() const
const Ciphersuite & ciphersuite() const

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

208 {
209 if(!m_client_kex) {
210 return std::nullopt;
211 }
212 return m_client_kex->psk_identity();
213}

◆ 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_typethe message type

Definition at line 235 of file tls_handshake_state.cpp.

235 {
236 return m_transitions.received_handshake_msg(handshake_msg);
237}

◆ 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.

151{ 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 135 of file tls_handshake_state.cpp.

135 {
137 m_server_cert_status = std::move(server_cert_status);
138 note_message(*m_server_cert_status);
139}
void server_cert_status(std::unique_ptr< Certificate_Status > 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 135 of file tls_handshake_state.h.

135{ 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 129 of file tls_handshake_state.cpp.

129 {
131 m_server_certs = std::move(server_certs);
132 note_message(*m_server_certs);
133}
void server_certs(std::unique_ptr< Certificate_12 > 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 155 of file tls_handshake_state.h.

155{ 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 189 of file tls_handshake_state.cpp.

189 {
191 m_server_finished = std::move(server_finished);
192 note_message(*m_server_finished);
193}
void server_finished(std::unique_ptr< Finished_12 > 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 133 of file tls_handshake_state.h.

133{ 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 122 of file tls_handshake_state.cpp.

122 {
124 m_server_hello = std::move(server_hello);
125 m_ciphersuite = Ciphersuite::by_id(m_server_hello->ciphersuite());
126 note_message(*m_server_hello);
127}
static std::optional< Ciphersuite > by_id(uint16_t suite)
void server_hello(std::unique_ptr< Server_Hello_12 > 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 141 of file tls_handshake_state.h.

141{ 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 153 of file tls_handshake_state.cpp.

153 {
155 m_server_hello_done = std::move(server_hello_done);
156 note_message(*m_server_hello_done);
157}
void server_hello_done(std::unique_ptr< Server_Hello_Done > 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 137 of file tls_handshake_state.h.

137{ 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 141 of file tls_handshake_state.cpp.

141 {
143 m_server_kex = std::move(server_kex);
144 note_message(*m_server_kex);
145}
void server_kex(std::unique_ptr< Server_Key_Exchange > 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 149 of file tls_handshake_state.h.

149{ 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 177 of file tls_handshake_state.cpp.

177 {
179 m_server_verify = std::move(server_verify);
180 note_message(*m_server_verify);
181}
void server_verify(std::unique_ptr< Certificate_Verify_12 > 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 163 of file tls_handshake_state.h.

163{ return m_session_keys; }

◆ session_ticket()

Session_Ticket Botan::TLS::Handshake_State::session_ticket ( ) const

Definition at line 243 of file tls_handshake_state.cpp.

243 {
244 if(const auto* nst = new_session_ticket()) {
245 const auto& ticket = nst->ticket();
246 if(!ticket.empty()) {
247 return ticket;
248 }
249 }
250
251 return client_hello()->session_ticket();
252}
Session_Ticket session_ticket() const
const New_Session_Ticket_12 * new_session_ticket() const

References 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_typethe message type

Definition at line 231 of file tls_handshake_state.cpp.

231 {
232 m_transitions.set_expected_next(handshake_msg);
233}

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

215 {
216 m_version = version;
217}
Protocol_Version version() const

References version().

◆ version()

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

Definition at line 106 of file tls_handshake_state.h.

106{ return m_version; }

Referenced by set_version().


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