Botan::TLS::Client_Hello_12 Class Reference

#include <tls_messages_12.h>

Inheritance diagram for Botan::TLS::Client_Hello_12:

Classes
class	Settings

Public Member Functions
std::vector< Signature_Scheme >	certificate_signature_schemes () const
const std::vector< uint16_t > &	ciphersuites () const
	Client_Hello_12 (const std::vector< uint8_t > &buf)
	Client_Hello_12 (Handshake_IO &io, Handshake_Hash &hash, const Policy &policy, Callbacks &cb, RandomNumberGenerator &rng, const std::vector< uint8_t > &reneg_info, const Session_with_Handle &session_and_handle, const std::vector< std::string > &next_protocols)
	Client_Hello_12 (Handshake_IO &io, Handshake_Hash &hash, const Policy &policy, Callbacks &cb, RandomNumberGenerator &rng, const std::vector< uint8_t > &reneg_info, const Settings &client_settings, const std::vector< std::string > &next_protocols)
const std::vector< uint8_t > &	compression_methods () const
const std::vector< uint8_t > &	cookie () const
std::vector< uint8_t >	cookie_input_data () const
std::set< Extension_Code >	extension_types () const
const Extensions &	extensions () const
Protocol_Version	legacy_version () const
std::vector< std::string >	next_protocols () const
bool	offered_suite (uint16_t ciphersuite) const
bool	prefers_compressed_ec_points () const
const std::vector< uint8_t > &	random () const
std::vector< uint8_t >	renegotiation_info () const
bool	secure_renegotiation () const
bool	sent_signature_algorithms () const
std::vector< uint8_t >	serialize () const override
std::optional< Session_Handle >	session_handle () const
const Session_ID &	session_id () const
Session_Ticket	session_ticket () const
std::vector< Signature_Scheme >	signature_schemes () const
std::string	sni_hostname () const
std::vector< uint16_t >	srtp_profiles () const
std::vector< Group_Params >	supported_dh_groups () const
std::vector< Group_Params >	supported_ecc_curves () const
std::vector< Protocol_Version >	supported_versions () const
bool	supports_alpn () const
bool	supports_cert_status_message () const
bool	supports_encrypt_then_mac () const
bool	supports_extended_master_secret () const
bool	supports_session_ticket () const
Handshake_Type	type () const override
std::string	type_string () const
void	update_hello_cookie (const Hello_Verify_Request &hello_verify)
virtual Handshake_Type	wire_type () const

Protected Member Functions
	Client_Hello ()
	Client_Hello (Client_Hello &&) noexcept
	Client_Hello (const Client_Hello &)=delete
	Client_Hello (std::unique_ptr< Client_Hello_Internal > data)

Protected Attributes
std::unique_ptr< Client_Hello_Internal >	m_data

Detailed Description

Definition at line 21 of file tls_messages_12.h.

Constructor & Destructor Documentation

Client_Hello_12() [1/3]

Botan::TLS::Client_Hello_12::Client_Hello_12	(	Handshake_IO &	io,
		Handshake_Hash &	hash,
		const Policy &	policy,
		Callbacks &	cb,
		RandomNumberGenerator &	rng,
		const std::vector< uint8_t > &	reneg_info,
		const Settings &	client_settings,
		const std::vector< std::string > &	next_protocols )

Definition at line 111 of file msg_client_hello_12.cpp.

                                                                             {
   m_data->m_legacy_version = client_settings.protocol_version();
   m_data->m_random = make_hello_random(rng, cb, policy);
   m_data->m_suites = policy.ciphersuite_list(client_settings.protocol_version());
 
   if(!policy.acceptable_protocol_version(m_data->legacy_version())) {
      throw Internal_Error("Offering " + m_data->legacy_version().to_string() +
                           " but our own policy does not accept it");
   }
 
   /*
    * Place all empty extensions in front to avoid a bug in some systems
    * which reject hellos when the last extension in the list is empty.
    */
 
   // NOLINTBEGIN(*-owning-memory)
 
   // EMS must always be used with TLS 1.2, regardless of the policy used.
 
   m_data->extensions().add(new Extended_Master_Secret);
 
   if(policy.negotiate_encrypt_then_mac()) {
      m_data->extensions().add(new Encrypt_then_MAC);
   }
 
   m_data->extensions().add(new Session_Ticket_Extension());
 
   m_data->extensions().add(new Renegotiation_Extension(reneg_info));
 
   m_data->extensions().add(new Supported_Versions(m_data->legacy_version(), policy));
 
   if(Server_Name_Indicator::hostname_acceptable_for_sni(client_settings.hostname())) {
      m_data->extensions().add(new Server_Name_Indicator(client_settings.hostname()));
   }
 
   if(policy.support_cert_status_message()) {
      m_data->extensions().add(new Certificate_Status_Request({}, {}));
   }
 
   add_tls12_supported_groups_extensions(policy);
 
   m_data->extensions().add(new Signature_Algorithms(policy.acceptable_signature_schemes()));
   if(auto cert_signing_prefs = policy.acceptable_certificate_signature_schemes()) {
      // RFC 8446 4.2.3
      //    TLS 1.2 implementations SHOULD also process this extension.
      //    Implementations which have the same policy in both cases MAY omit
      //    the "signature_algorithms_cert" extension.
      m_data->extensions().add(new Signature_Algorithms_Cert(std::move(cert_signing_prefs.value())));
   }
 
   if(reneg_info.empty() && !next_protocols.empty()) {
      m_data->extensions().add(new Application_Layer_Protocol_Notification(next_protocols));
   }
 
   if(m_data->legacy_version().is_datagram_protocol()) {
      m_data->extensions().add(new SRTP_Protection_Profiles(policy.srtp_profiles()));
   }
 
   // NOLINTEND(*-owning-memory)
 
   cb.tls_modify_extensions(m_data->extensions(), Connection_Side::Client, type());
 
   hash.update(io.send(*this));
}

References Botan::TLS::Policy::acceptable_certificate_signature_schemes(), Botan::TLS::Policy::acceptable_protocol_version(), Botan::TLS::Policy::acceptable_signature_schemes(), Botan::TLS::Policy::ciphersuite_list(), Botan::TLS::Client, Botan::TLS::Client_Hello_12::Settings::hostname(), Botan::TLS::Server_Name_Indicator::hostname_acceptable_for_sni(), Botan::TLS::Client_Hello::m_data, Botan::TLS::make_hello_random(), Botan::TLS::Policy::negotiate_encrypt_then_mac(), Botan::TLS::Client_Hello::next_protocols(), Botan::TLS::Client_Hello_12::Settings::protocol_version(), Botan::TLS::Handshake_IO::send(), Botan::TLS::Policy::srtp_profiles(), Botan::TLS::Policy::support_cert_status_message(), Botan::TLS::Callbacks::tls_modify_extensions(), Botan::TLS::Client_Hello::type(), and Botan::TLS::Handshake_Hash::update().

Referenced by Client_Hello_12().

Client_Hello_12() [2/3]

Botan::TLS::Client_Hello_12::Client_Hello_12	(	Handshake_IO &	io,
		Handshake_Hash &	hash,
		const Policy &	policy,
		Callbacks &	cb,
		RandomNumberGenerator &	rng,
		const std::vector< uint8_t > &	reneg_info,
		const Session_with_Handle &	session_and_handle,
		const std::vector< std::string > &	next_protocols )

Definition at line 186 of file msg_client_hello_12.cpp.

                                                                             {
   m_data->m_legacy_version = session.session.version();
   m_data->m_random = make_hello_random(rng, cb, policy);
 
   // RFC 5077 3.4
   //    When presenting a ticket, the client MAY generate and include a
   //    Session ID in the TLS ClientHello. [...] If a ticket is presented by
   //    the client, the server MUST NOT attempt to use the Session ID in the
   //    ClientHello for stateful session resumption.
   m_data->m_session_id = session.handle.id().value_or(Session_ID(make_hello_random(rng, cb, policy)));
   m_data->m_suites = policy.ciphersuite_list(m_data->legacy_version());
 
   if(!policy.acceptable_protocol_version(session.session.version())) {
      throw Internal_Error("Offering " + m_data->legacy_version().to_string() +
                           " but our own policy does not accept it");
   }
 
   if(!value_exists(m_data->ciphersuites(), session.session.ciphersuite_code())) {
      m_data->m_suites.push_back(session.session.ciphersuite_code());
   }
 
   /*
    * As EMS must always be used with TLS 1.2, add it even if it wasn't used
    * in the original session. If the server understands it and follows the
    * RFC it should reject our resume attempt and upgrade us to a new session
    * with the EMS protection.
    */
   // NOLINTBEGIN(*-owning-memory)
   m_data->extensions().add(new Extended_Master_Secret);
 
   if(session.session.supports_encrypt_then_mac()) {
      m_data->extensions().add(new Encrypt_then_MAC);
   }
 
   if(session.handle.is_ticket()) {
      m_data->extensions().add(new Session_Ticket_Extension(session.handle.ticket().value()));
   }
 
   m_data->extensions().add(new Renegotiation_Extension(reneg_info));
 
   const std::string hostname = session.session.server_info().hostname();
 
   if(Server_Name_Indicator::hostname_acceptable_for_sni(hostname)) {
      m_data->extensions().add(new Server_Name_Indicator(hostname));
   }
 
   if(policy.support_cert_status_message()) {
      m_data->extensions().add(new Certificate_Status_Request({}, {}));
   }
 
   add_tls12_supported_groups_extensions(policy);
 
   m_data->extensions().add(new Signature_Algorithms(policy.acceptable_signature_schemes()));
   if(auto cert_signing_prefs = policy.acceptable_certificate_signature_schemes()) {
      // RFC 8446 4.2.3
      //    TLS 1.2 implementations SHOULD also process this extension.
      //    Implementations which have the same policy in both cases MAY omit
      //    the "signature_algorithms_cert" extension.
      m_data->extensions().add(new Signature_Algorithms_Cert(std::move(cert_signing_prefs.value())));
   }
 
   if(reneg_info.empty() && !next_protocols.empty()) {
      m_data->extensions().add(new Application_Layer_Protocol_Notification(next_protocols));
   }
 
   // NOLINTEND(*-owning-memory)
 
   cb.tls_modify_extensions(m_data->extensions(), Connection_Side::Client, type());
 
   hash.update(io.send(*this));
}

References Botan::TLS::Policy::acceptable_certificate_signature_schemes(), Botan::TLS::Policy::acceptable_protocol_version(), Botan::TLS::Policy::acceptable_signature_schemes(), Botan::TLS::Session_Base::ciphersuite_code(), Botan::TLS::Policy::ciphersuite_list(), Botan::TLS::Client, Botan::TLS::Session_with_Handle::handle, Botan::TLS::Server_Information::hostname(), Botan::TLS::Server_Name_Indicator::hostname_acceptable_for_sni(), Botan::TLS::Session_Handle::id(), Botan::TLS::Session_Handle::is_ticket(), Botan::TLS::Client_Hello::m_data, Botan::TLS::make_hello_random(), Botan::TLS::Client_Hello::next_protocols(), Botan::TLS::Handshake_IO::send(), Botan::TLS::Session_Base::server_info(), Botan::TLS::Session_with_Handle::session, Botan::TLS::Policy::support_cert_status_message(), Botan::TLS::Session_Base::supports_encrypt_then_mac(), Botan::TLS::Session_Handle::ticket(), Botan::TLS::Callbacks::tls_modify_extensions(), Botan::TLS::Client_Hello::type(), Botan::TLS::Handshake_Hash::update(), Botan::value_exists(), and Botan::TLS::Session_Base::version().

Client_Hello_12() [3/3]

Botan::TLS::Client_Hello_12::Client_Hello_12 ( const std::vector< uint8_t > & buf )

explicit

Definition at line 265 of file msg_client_hello_12.cpp.

                                                              :
      Client_Hello_12(std::make_unique<Client_Hello_Internal>(buf)) {}

References Client_Hello_12().

Member Function Documentation

certificate_signature_schemes()

std::vector< Signature_Scheme > Botan::TLS::Client_Hello::certificate_signature_schemes ( ) const

inherited

Definition at line 221 of file msg_client_hello.cpp.

                                                                              {
   // RFC 8446 4.2.3
   //   If no "signature_algorithms_cert" extension is present, then the
   //   "signature_algorithms" extension also applies to signatures appearing
   //   in certificates.
   if(const Signature_Algorithms_Cert* sigs = m_data->extensions().get<Signature_Algorithms_Cert>()) {
      return sigs->supported_schemes();
   } else {
      return signature_schemes();
   }
}

References m_data, and signature_schemes().

Referenced by ~Client_Hello().

ciphersuites()

const std::vector< uint16_t > & Botan::TLS::Client_Hello::ciphersuites ( ) const

inherited

Definition at line 157 of file msg_client_hello.cpp.

                                                            {
   return m_data->ciphersuites();
}

References m_data.

Referenced by ~Client_Hello().

Client_Hello() [1/4]

Botan::TLS::Client_Hello::Client_Hello ( )

protectedinherited

Definition at line 142 of file msg_client_hello.cpp.

: m_data(std::make_unique<Client_Hello_Internal>()) {}

References Botan::TLS::Client_Hello::m_data.

Client_Hello() [2/4]

Botan::TLS::Client_Hello::Client_Hello ( Client_Hello && )

protecteddefaultnoexceptinherited

Client_Hello() [3/4]

Botan::TLS::Client_Hello::Client_Hello ( const Client_Hello & )

protecteddeleteinherited

Referenced by Client_Hello_12_Shim().

Client_Hello() [4/4]

Botan::TLS::Client_Hello::Client_Hello ( std::unique_ptr< Client_Hello_Internal > data )

explicitprotectedinherited

Definition at line 143 of file msg_client_hello.cpp.

                                                                    : m_data(std::move(data)) {
   BOTAN_ASSERT_NONNULL(m_data);
}

compression_methods()

const std::vector< uint8_t > & Botan::TLS::Client_Hello::compression_methods

(

)

const

Definition at line 145 of file msg_client_hello.cpp.

                                                                  {
   return m_data->comp_methods();
}

References Botan::TLS::Client_Hello::m_data.

cookie()

const std::vector< uint8_t > & Botan::TLS::Client_Hello::cookie ( ) const

inherited

Definition at line 283 of file msg_client_hello.cpp.

                                                     {
   return m_data->hello_cookie();
}

References m_data.

Referenced by ~Client_Hello().

cookie_input_data()

std::vector< uint8_t > Botan::TLS::Client_Hello::cookie_input_data ( ) const

inherited

Definition at line 200 of file msg_client_hello.cpp.

                                                         {
   BOTAN_STATE_CHECK(!m_data->hello_cookie_input_bits().empty());
 
   return m_data->hello_cookie_input_bits();
}

References BOTAN_STATE_CHECK, and m_data.

Referenced by ~Client_Hello().

extension_types()

std::set< Extension_Code > Botan::TLS::Client_Hello::extension_types ( ) const

inherited

Definition at line 161 of file msg_client_hello.cpp.

                                                           {
   return m_data->extensions().extension_types();
}

References m_data.

Referenced by Botan::TLS::Server_Hello_12::Server_Hello_12(), Botan::TLS::Client_Hello_13::validate_updates(), and ~Client_Hello().

extensions()

const Extensions & Botan::TLS::Client_Hello::extensions ( ) const

inherited

Definition at line 165 of file msg_client_hello.cpp.

                                                 {
   return m_data->extensions();
}

References m_data.

Referenced by Botan::TLS::Certificate_13::Certificate_13(), Botan::TLS::Server_Hello_13::create(), Botan::TLS::Encrypted_Extensions::Encrypted_Extensions(), Botan::TLS::Hello_Retry_Request::Hello_Retry_Request(), Botan::TLS::Server_Hello_13::Server_Hello_13(), Botan::TLS::Client_Hello_13::validate_updates(), and ~Client_Hello().

legacy_version()

Protocol_Version Botan::TLS::Client_Hello::legacy_version ( ) const

inherited

Return the version indicated in the ClientHello. This may differ from the version indicated in the supported_versions extension.

See RFC 8446 4.1.2: TLS 1.3, the client indicates its version preferences in the "supported_versions" extension (Section 4.2.1) and the legacy_version field MUST be set to 0x0303, which is the version number for TLS 1.2.

Definition at line 141 of file msg_client_hello.cpp.

                                                    {
   return m_data->legacy_version();
}

Referenced by ~Client_Hello().

next_protocols()

std::vector< std::string > Botan::TLS::Client_Hello::next_protocols ( ) const

inherited

Definition at line 269 of file msg_client_hello.cpp.

                                                        {
   if(auto* alpn = m_data->extensions().get<Application_Layer_Protocol_Notification>()) {
      return alpn->protocols();
   }
   return {};
}

References m_data.

Referenced by Botan::TLS::Client_Hello_12::Client_Hello_12(), Botan::TLS::Client_Hello_12::Client_Hello_12(), Botan::TLS::Client_Hello_13::Client_Hello_13(), and ~Client_Hello().

offered_suite()

bool Botan::TLS::Client_Hello::offered_suite ( uint16_t ciphersuite ) const

inherited

Definition at line 209 of file msg_client_hello.cpp.

                                                           {
   return std::find(m_data->ciphersuites().cbegin(), m_data->ciphersuites().cend(), ciphersuite) !=
          m_data->ciphersuites().cend();
}

References m_data.

Referenced by ~Client_Hello().

prefers_compressed_ec_points()

bool Botan::TLS::Client_Hello_12::prefers_compressed_ec_points

(

)

const

Definition at line 29 of file msg_client_hello_12.cpp.

                                                         {
   if(const Supported_Point_Formats* ecc_formats = m_data->extensions().get<Supported_Point_Formats>()) {
      return ecc_formats->prefers_compressed();
   }
   return false;
}

References Botan::TLS::Client_Hello::m_data.

random()

const std::vector< uint8_t > & Botan::TLS::Client_Hello::random

(

)

const

Definition at line 103 of file msg_client_hello.cpp.

                                                     {
   return m_data->random();
}

References Botan::TLS::Protocol_Version::is_datagram_protocol(), and Botan::TLS::Client_Hello_Internal::m_legacy_version.

renegotiation_info()

std::vector< uint8_t > Botan::TLS::Client_Hello_12::renegotiation_info

(

)

const

Definition at line 40 of file msg_client_hello_12.cpp.

                                                             {
   if(const Renegotiation_Extension* reneg = m_data->extensions().get<Renegotiation_Extension>()) {
      return reneg->renegotiation_info();
   }
   return {};
}

References Botan::TLS::Client_Hello::m_data.

Referenced by Botan::TLS::Channel_Impl_12::secure_renegotiation_check().

secure_renegotiation()

bool Botan::TLS::Client_Hello_12::secure_renegotiation

(

)

const

Definition at line 36 of file msg_client_hello_12.cpp.

                                                 {
   return m_data->extensions().has<Renegotiation_Extension>();
}

References Botan::TLS::Client_Hello::m_data.

Referenced by Botan::TLS::Channel_Impl_12::secure_renegotiation_check(), and Botan::TLS::Server_Hello_12::Server_Hello_12().

sent_signature_algorithms()

bool Botan::TLS::Client_Hello::sent_signature_algorithms ( ) const

inherited

Definition at line 265 of file msg_client_hello.cpp.

                                                   {
   return m_data->extensions().has<Signature_Algorithms>();
}

References m_data.

Referenced by ~Client_Hello().

serialize()

std::vector< uint8_t > Botan::TLS::Client_Hello::serialize ( ) const

overridevirtualinherited

Returns

DER representation of this message

Implements Botan::TLS::Handshake_Message.

Definition at line 172 of file msg_client_hello.cpp.

                                                 {
   std::vector<uint8_t> buf;
   buf.reserve(1024);  // working around GCC warning
 
   buf.push_back(m_data->legacy_version().major_version());
   buf.push_back(m_data->legacy_version().minor_version());
   buf += m_data->random();
 
   append_tls_length_value(buf, m_data->session_id().get(), 1);
 
   if(m_data->legacy_version().is_datagram_protocol()) {
      append_tls_length_value(buf, m_data->hello_cookie(), 1);
   }
 
   append_tls_length_value(buf, m_data->ciphersuites(), 2);
   append_tls_length_value(buf, m_data->comp_methods(), 1);
 
   /*
   * May not want to send extensions at all in some cases. If so,
   * should include SCSV value (if reneg info is empty, if not we are
   * renegotiating with a modern server)
   */
 
   buf += m_data->extensions().serialize(Connection_Side::Client);
 
   return buf;
}

References Botan::TLS::append_tls_length_value(), Botan::TLS::Client, and m_data.

Referenced by ~Client_Hello().

session_handle()

std::optional< Session_Handle > Botan::TLS::Client_Hello_12::session_handle

(

)

const

Definition at line 58 of file msg_client_hello_12.cpp.

                                                                  {
   // RFC 5077 3.4
   //    If a ticket is presented by the client, the server MUST NOT attempt
   //    to use the Session ID in the ClientHello for stateful session
   //    resumption.
   if(auto ticket = session_ticket(); !ticket.empty()) {
      return Session_Handle(ticket);
   } else if(const auto& id = session_id(); !id.empty()) {
      return Session_Handle(id);
   } else {
      return std::nullopt;
   }
}

References Botan::detail::Container_Strong_Adapter_Base< T >::empty(), Botan::TLS::Client_Hello::session_id(), and session_ticket().

session_id()

const Session_ID & Botan::TLS::Client_Hello::session_id ( ) const

inherited

Definition at line 149 of file msg_client_hello.cpp.

                                                 {
   return m_data->session_id();
}

References m_data.

Referenced by Botan::TLS::Client_Hello_12::session_handle(), and ~Client_Hello().

session_ticket()

Session_Ticket Botan::TLS::Client_Hello_12::session_ticket

(

)

const

Definition at line 51 of file msg_client_hello_12.cpp.

                                                     {
   if(auto* ticket = m_data->extensions().get<Session_Ticket_Extension>()) {
      return ticket->contents();
   }
   return {};
}

References Botan::TLS::Client_Hello::m_data.

Referenced by session_handle(), and Botan::TLS::Handshake_State::session_ticket().

signature_schemes()

std::vector< Signature_Scheme > Botan::TLS::Client_Hello::signature_schemes ( ) const

inherited

Definition at line 214 of file msg_client_hello.cpp.

                                                                  {
   if(const Signature_Algorithms* sigs = m_data->extensions().get<Signature_Algorithms>()) {
      return sigs->supported_schemes();
   }
   return {};
}

References m_data.

Referenced by Botan::TLS::Certificate_13::Certificate_13(), certificate_signature_schemes(), Botan::TLS::Handshake_State::choose_sig_format(), and ~Client_Hello().

sni_hostname()

std::string Botan::TLS::Client_Hello::sni_hostname ( ) const

inherited

Definition at line 247 of file msg_client_hello.cpp.

                                           {
   if(const Server_Name_Indicator* sni = m_data->extensions().get<Server_Name_Indicator>()) {
      return sni->host_name();
   }
   return "";
}

References m_data.

Referenced by Botan::TLS::Certificate_13::Certificate_13(), Botan::TLS::Certificate_Request_13::maybe_create(), and ~Client_Hello().

srtp_profiles()

std::vector< uint16_t > Botan::TLS::Client_Hello::srtp_profiles ( ) const

inherited

Definition at line 276 of file msg_client_hello.cpp.

                                                      {
   if(const SRTP_Protection_Profiles* srtp = m_data->extensions().get<SRTP_Protection_Profiles>()) {
      return srtp->profiles();
   }
   return {};
}

References m_data.

Referenced by ~Client_Hello().

supported_dh_groups()

std::vector< Group_Params > Botan::TLS::Client_Hello::supported_dh_groups ( ) const

inherited

Definition at line 240 of file msg_client_hello.cpp.

                                                                {
   if(const Supported_Groups* groups = m_data->extensions().get<Supported_Groups>()) {
      return groups->dh_groups();
   }
   return std::vector<Group_Params>();
}

References m_data.

Referenced by ~Client_Hello().

supported_ecc_curves()

std::vector< Group_Params > Botan::TLS::Client_Hello::supported_ecc_curves ( ) const

inherited

Definition at line 233 of file msg_client_hello.cpp.

                                                                 {
   if(const Supported_Groups* groups = m_data->extensions().get<Supported_Groups>()) {
      return groups->ec_groups();
   }
   return {};
}

References m_data.

Referenced by ~Client_Hello().

supported_versions()

std::vector< Protocol_Version > Botan::TLS::Client_Hello::supported_versions ( ) const

inherited

Definition at line 254 of file msg_client_hello.cpp.

                                                                   {
   if(const Supported_Versions* versions = m_data->extensions().get<Supported_Versions>()) {
      return versions->versions();
   }
   return {};
}

References m_data.

Referenced by ~Client_Hello().

supports_alpn()

bool Botan::TLS::Client_Hello::supports_alpn ( ) const

inherited

Definition at line 261 of file msg_client_hello.cpp.

                                       {
   return m_data->extensions().has<Application_Layer_Protocol_Notification>();
}

References m_data.

Referenced by Botan::TLS::Server_Hello_12::Server_Hello_12(), Botan::TLS::Server_Hello_12::Server_Hello_12(), and ~Client_Hello().

supports_cert_status_message()

bool Botan::TLS::Client_Hello_12::supports_cert_status_message

(

)

const

Definition at line 76 of file msg_client_hello_12.cpp.

                                                         {
   return m_data->extensions().has<Certificate_Status_Request>();
}

References Botan::TLS::Client_Hello::m_data.

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

supports_encrypt_then_mac()

bool Botan::TLS::Client_Hello_12::supports_encrypt_then_mac

(

)

const

Definition at line 80 of file msg_client_hello_12.cpp.

                                                      {
   return m_data->extensions().has<Encrypt_then_MAC>();
}

References Botan::TLS::Client_Hello::m_data.

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

supports_extended_master_secret()

bool Botan::TLS::Client_Hello_12::supports_extended_master_secret

(

)

const

Definition at line 72 of file msg_client_hello_12.cpp.

                                                            {
   return m_data->extensions().has<Extended_Master_Secret>();
}

References Botan::TLS::Client_Hello::m_data.

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

supports_session_ticket()

bool Botan::TLS::Client_Hello_12::supports_session_ticket

(

)

const

Definition at line 47 of file msg_client_hello_12.cpp.

                                                    {
   return m_data->extensions().has<Session_Ticket_Extension>();
}

References Botan::TLS::Client_Hello::m_data.

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

type()

Handshake_Type Botan::TLS::Client_Hello::type ( ) const

overridevirtualinherited

Returns

the message type

Implements Botan::TLS::Handshake_Message.

Definition at line 137 of file msg_client_hello.cpp.

                                        {
   return Handshake_Type::ClientHello;
}

References Botan::TLS::ClientHello.

Referenced by Botan::TLS::Client_Hello_12::Client_Hello_12(), Botan::TLS::Client_Hello_12::Client_Hello_12(), Botan::TLS::Client_Hello_13::Client_Hello_13(), Botan::TLS::Client_Hello_13::retry(), and ~Client_Hello().

type_string()

std::string Botan::TLS::Handshake_Message::type_string ( ) const

inherited

Returns

string representation of this message type

Definition at line 21 of file tls_handshake_state.cpp.

                                               {
   return handshake_type_to_string(type());
}

References Botan::TLS::handshake_type_to_string(), and type().

update_hello_cookie()

void Botan::TLS::Client_Hello_12::update_hello_cookie

(

const Hello_Verify_Request &

hello_verify

)

Definition at line 23 of file msg_client_hello_12.cpp.

                                                                                  {
   BOTAN_STATE_CHECK(m_data->legacy_version().is_datagram_protocol());
 
   m_data->m_hello_cookie = hello_verify.cookie();
}

References BOTAN_STATE_CHECK, Botan::TLS::Hello_Verify_Request::cookie(), and Botan::TLS::Client_Hello::m_data.

wire_type()

virtual Handshake_Type Botan::TLS::Handshake_Message::wire_type ( ) const

inlinevirtualinherited

Returns

the wire representation of the message's type

Reimplemented in Botan::TLS::Hello_Retry_Request.

Definition at line 39 of file tls_handshake_msg.h.

                                               {
         // Usually equal to the Handshake_Type enum value,
         // with the exception of TLS 1.3 Hello Retry Request.
         return type();
      }

References type().

Referenced by Botan::TLS::Stream_Handshake_IO::send().

Member Data Documentation

m_data

std::unique_ptr<Client_Hello_Internal> Botan::TLS::Client_Hello::m_data

protectedinherited

Definition at line 148 of file tls_messages.h.

Referenced by certificate_signature_schemes(), ciphersuites(), Client_Hello(), Client_Hello(), Botan::TLS::Client_Hello_12_Shim::Client_Hello(), Botan::TLS::Client_Hello_12::Client_Hello_12(), Botan::TLS::Client_Hello_12::Client_Hello_12(), Botan::TLS::Client_Hello_13::Client_Hello_13(), compression_methods(), Botan::TLS::Client_Hello_12::compression_methods(), cookie(), cookie_input_data(), extension_types(), extensions(), Botan::TLS::Client_Hello_13::highest_supported_version(), next_protocols(), offered_suite(), Botan::TLS::Client_Hello_12::prefers_compressed_ec_points(), Botan::TLS::Client_Hello_12::renegotiation_info(), Botan::TLS::Client_Hello_13::retry(), Botan::TLS::Client_Hello_12::secure_renegotiation(), sent_signature_algorithms(), serialize(), session_id(), Botan::TLS::Client_Hello_12::session_ticket(), signature_schemes(), sni_hostname(), srtp_profiles(), supported_dh_groups(), supported_ecc_curves(), supported_versions(), supports_alpn(), Botan::TLS::Client_Hello_12::supports_cert_status_message(), Botan::TLS::Client_Hello_12::supports_encrypt_then_mac(), Botan::TLS::Client_Hello_12::supports_extended_master_secret(), Botan::TLS::Client_Hello_12::supports_session_ticket(), Botan::TLS::Client_Hello_12::update_hello_cookie(), and Botan::TLS::Client_Hello_13::validate_updates().

---

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

• src/lib/tls/tls12/tls_messages_12.h
• src/lib/tls/tls12/msg_client_hello_12.cpp