#include <tls_client.h>

Inheritance diagram for Botan::TLS::Client:

Public Member Functions
std::string	application_protocol () const override

	Client (const std::shared_ptr< Callbacks > &callbacks, const std::shared_ptr< Session_Manager > &session_manager, const std::shared_ptr< Credentials_Manager > &creds, const std::shared_ptr< const Policy > &policy, const std::shared_ptr< RandomNumberGenerator > &rng, Server_Information server_info=Server_Information(), Protocol_Version offer_version=Protocol_Version::latest_tls_version(), const std::vector< std::string > &next_protocols={}, size_t reserved_io_buffer_size=TLS::Client::IO_BUF_DEFAULT_SIZE)

void	close () override

std::optional< std::string >	external_psk_identity () const override

size_t	from_peer (std::span< const uint8_t > data) override

bool	is_active () const override

bool	is_closed () const override

bool	is_closed_for_reading () const override

bool	is_closed_for_writing () const override

bool	is_handshake_complete () const override

SymmetricKey	key_material_export (std::string_view label, std::string_view context, size_t length) const override

std::vector< X509_Certificate >	peer_cert_chain () const override

std::shared_ptr< const Public_Key >	peer_raw_public_key () const override

size_t	received_data (const uint8_t buf[], size_t buf_size)

size_t	received_data (std::span< const uint8_t > data)

void	renegotiate (bool force_full_renegotiation=false) override

bool	secure_renegotiation_supported () const override

void	send (const uint8_t buf[], size_t buf_size)

void	send (std::span< const uint8_t > data)

void	send (std::string_view s)

void	send_alert (const Alert &alert) override

void	send_fatal_alert (Alert::Type type) override

void	send_warning_alert (Alert::Type type) override

bool	timeout_check () override

void	to_peer (std::span< const uint8_t > data) override

void	update_traffic_keys (bool request_peer_update=false) override

	~Client () override

Static Public Attributes
static constexpr size_t	IO_BUF_DEFAULT_SIZE = 10 * 1024

Detailed Description

SSL/TLS Client

Definition at line 28 of file tls_client.h.

Constructor & Destructor Documentation

◆ Client()

Botan::TLS::Client::Client	(	const std::shared_ptr< Callbacks > &	callbacks,
		const std::shared_ptr< Session_Manager > &	session_manager,
		const std::shared_ptr< Credentials_Manager > &	creds,
		const std::shared_ptr< const Policy > &	policy,
		const std::shared_ptr< RandomNumberGenerator > &	rng,
		Server_Information	server_info = Server_Information(),
		Protocol_Version	offer_version = Protocol_Version::latest_tls_version(),
		const std::vector< std::string > &	next_protocols = {},
		size_t	reserved_io_buffer_size = TLS::Client::IO_BUF_DEFAULT_SIZE )

Initialize a new TLS client. The constructor will immediately initiate a new session.

The callbacks parameter specifies the various application callbacks which pertain to this particular client connection.

The session_manager is an interface for storing TLS sessions, which allows for session resumption upon reconnecting to a server. In the absence of a need for persistent sessions, use TLS::Session_Manager_In_Memory which caches connections for the lifetime of a single process.

The credentials_manager is an interface that will be called to retrieve any certificates, private keys, or pre-shared keys.

Use the optional server_info to specify the DNS name of the server you are attempting to connect to, if you know it. This helps the server select what certificate to use and helps the client validate the connection.

Use the optional offer_version to control the version of TLS you wish the client to offer. Normally, you'll want to offer the most recent version of (D)TLS that is available, however some broken servers are intolerant of certain versions being offered, and for classes of applications that have to deal with such servers (typically web browsers) it may be necessary to implement a version backdown strategy if the initial attempt fails.

Warning: Implementing such a backdown strategy allows an attacker to downgrade your connection to the weakest protocol that both you and the server support.

Setting offer_version is also used to offer DTLS instead of TLS; use TLS::Protocol_Version::latest_dtls_version().

Optionally, the client will advertise next_protocols to the server using the ALPN extension.

The optional reserved_io_buffer_size specifies how many bytes to pre-allocate in the I/O buffers. Use this if you want to control how much memory the channel uses initially (the buffers will be resized as needed to process inputs). Otherwise some reasonable default is used. The TLS 1.3 implementation ignores this.

Definition at line 30 of file tls_client.cpp.

                                 {
   BOTAN_ARG_CHECK(policy->acceptable_protocol_version(offer_version),
                   "Policy does not allow to offer requested protocol version");
 
#if defined(BOTAN_HAS_TLS_13)
   if(offer_version == Protocol_Version::TLS_V13) {
      m_impl = std::make_unique<Client_Impl_13>(
         callbacks, session_manager, creds, policy, rng, std::move(info), next_protocols);
 
      if(m_impl->expects_downgrade()) {
         m_impl->set_io_buffer_size(io_buf_sz);
      }
 
      if(m_impl->is_downgrading()) {
         // TLS 1.3 implementation found a resumable TLS 1.2 session and
         // requested a downgrade right away.
         downgrade();
      }
 
      return;
   }
#endif
 
   m_impl = std::make_unique<Client_Impl_12>(callbacks,
                                             session_manager,
                                             creds,
                                             policy,
                                             rng,
                                             std::move(info),
                                             offer_version.is_datagram_protocol(),
                                             next_protocols,
                                             io_buf_sz);
}

References BOTAN_ARG_CHECK, and Botan::TLS::Protocol_Version::is_datagram_protocol().

◆ ~Client()

Botan::TLS::Client::~Client ( )

overridedefault

Member Function Documentation

◆ application_protocol()

std::string Botan::TLS::Client::application_protocol ( ) const

overridevirtual

Returns: network protocol as advertised by the TLS server, if server sent the ALPN extension

label	a disambiguating label string
context	a per-association context value
length	the length of the desired key in bytes

Public Member Functions

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Client()

◆ ~Client()

Member Function Documentation

◆ application_protocol()

◆ close()

◆ external_psk_identity()

◆ from_peer()

◆ is_active()

◆ is_closed()

◆ is_closed_for_reading()

◆ is_closed_for_writing()

◆ is_handshake_complete()

◆ key_material_export()

◆ peer_cert_chain()

◆ peer_raw_public_key()

◆ received_data() [1/2]

◆ received_data() [2/2]

◆ renegotiate()

◆ secure_renegotiation_supported()

◆ send() [1/3]

◆ send() [2/3]

◆ send() [3/3]

◆ send_alert()

◆ send_fatal_alert()

◆ send_warning_alert()

◆ timeout_check()

◆ to_peer()

◆ update_traffic_keys()

Member Data Documentation

◆ IO_BUF_DEFAULT_SIZE