#include <tls_policy.h>

Inheritance diagram for Botan::TLS::Policy:

Public Member Functions
virtual bool	abort_connection_on_undesired_renegotiation () const

virtual std::optional< std::vector< Signature_Scheme > >	acceptable_certificate_signature_schemes () const

virtual bool	acceptable_ciphersuite (const Ciphersuite &suite) const

virtual bool	acceptable_protocol_version (Protocol_Version version) const

virtual std::vector< Signature_Scheme >	acceptable_signature_schemes () const

virtual std::vector< Certificate_Type >	accepted_client_certificate_types () const

virtual std::vector< Certificate_Type >	accepted_server_certificate_types () const

virtual bool	allow_client_initiated_renegotiation () const

virtual bool	allow_dtls12 () const

virtual bool	allow_dtls_epoch0_restart () const

virtual bool	allow_insecure_renegotiation () const

virtual bool	allow_resumption_for_renegotiation () const

virtual bool	allow_server_initiated_renegotiation () const

virtual bool	allow_ssl_key_log_file () const

virtual bool	allow_tls12 () const

virtual bool	allow_tls13 () const

virtual std::vector< std::string >	allowed_ciphers () const

virtual std::vector< std::string >	allowed_key_exchange_methods () const

virtual std::vector< std::string >	allowed_macs () const

bool	allowed_signature_hash (std::string_view hash) const

virtual std::vector< std::string >	allowed_signature_hashes () const

bool	allowed_signature_method (std::string_view sig_method) const

virtual std::vector< std::string >	allowed_signature_methods () const

virtual std::vector< Signature_Scheme >	allowed_signature_schemes () const

virtual void	check_peer_key_acceptable (const Public_Key &public_key) const

virtual Group_Params	choose_key_exchange_group (const std::vector< Group_Params > &supported_by_peer, const std::vector< Group_Params > &offered_by_peer) const

virtual std::vector< uint16_t >	ciphersuite_list (Protocol_Version version) const

virtual Group_Params	default_dh_group () const

virtual size_t	dtls_default_mtu () const

virtual size_t	dtls_initial_timeout () const

virtual size_t	dtls_maximum_timeout () const

virtual bool	hash_hello_random () const

virtual bool	hide_unknown_users () const

virtual bool	include_time_in_hello_random () const

virtual std::vector< Group_Params >	key_exchange_groups () const

virtual std::vector< Group_Params >	key_exchange_groups_to_offer () const

virtual Protocol_Version	latest_supported_version (bool datagram) const

virtual size_t	maximum_certificate_chain_size () const

virtual size_t	maximum_session_tickets_per_client_hello () const

virtual size_t	minimum_dh_group_size () const

virtual size_t	minimum_ecdh_group_size () const

virtual size_t	minimum_ecdsa_group_size () const

virtual size_t	minimum_rsa_bits () const

virtual size_t	minimum_signature_strength () const

virtual bool	negotiate_encrypt_then_mac () const

virtual size_t	new_session_tickets_upon_handshake_success () const

virtual bool	only_resume_with_exact_version () const

virtual void	print (std::ostream &o) const

virtual std::optional< uint16_t >	record_size_limit () const

virtual bool	request_client_certificate_authentication () const

virtual bool	require_cert_revocation_info () const

virtual bool	require_client_certificate_authentication () const

virtual bool	reuse_session_tickets () const

virtual bool	server_uses_own_ciphersuite_preferences () const

virtual std::chrono::seconds	session_ticket_lifetime () const

virtual std::vector< uint16_t >	srtp_profiles () const

virtual bool	support_cert_status_message () const

virtual bool	tls_13_middlebox_compatibility_mode () const

std::string	to_string () const

virtual bool	use_ecc_point_compression () const

virtual	~Policy ()=default

Detailed Description

TLS Policy Base Class Inherit and overload as desired to suit local policy concerns

Definition at line 32 of file tls_policy.h.

Constructor & Destructor Documentation

◆ ~Policy()

virtual Botan::TLS::Policy::~Policy ( )

virtualdefault

Member Function Documentation

◆ abort_connection_on_undesired_renegotiation()

bool Botan::TLS::Policy::abort_connection_on_undesired_renegotiation ( ) const

virtual

If true, a request to renegotiate will close the connection with a fatal alert. Otherwise, a warning alert is sent.

Note: Has no effect for TLS 1.3 connections.

Definition at line 394 of file tls_policy.cpp.

                                                               {
   return false;
}

◆ acceptable_certificate_signature_schemes()

std::optional< std::vector< Signature_Scheme > > Botan::TLS::Policy::acceptable_certificate_signature_schemes ( ) const

virtual

Definition at line 47 of file tls_policy.cpp.

                                                                                                {
   // the restrictions of ::acceptable_signature_schemes() shall apply
   return std::nullopt;
}

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

◆ acceptable_ciphersuite()

bool Botan::TLS::Policy::acceptable_ciphersuite ( const Ciphersuite & suite ) const

virtual

Allows policy to reject any ciphersuites which are undesirable for whatever reason without having to reimplement ciphersuite_list

Definition at line 305 of file tls_policy.cpp.

                                                                        {
   return value_exists(allowed_ciphers(), ciphersuite.cipher_algo()) &&
          value_exists(allowed_macs(), ciphersuite.mac_algo());
}

References allowed_ciphers(), allowed_macs(), Botan::TLS::Ciphersuite::cipher_algo(), Botan::TLS::Ciphersuite::mac_algo(), and Botan::value_exists().

Referenced by ciphersuite_list().

◆ acceptable_protocol_version()

bool Botan::TLS::Policy::acceptable_protocol_version ( Protocol_Version version ) const

virtual

Returns: true if and only if we are willing to accept this version Default accepts TLS v1.2 and later or DTLS v1.2 or later.

Definition at line 266 of file tls_policy.cpp.

                                                                       {
#if defined(BOTAN_HAS_TLS_13)
   if(version == Protocol_Version::TLS_V13 && allow_tls13()) {
      return true;
   }
#endif
 
#if defined(BOTAN_HAS_TLS_12)
   if(version == Protocol_Version::TLS_V12 && allow_tls12()) {
      return true;
   }
 
   if(version == Protocol_Version::DTLS_V12 && allow_dtls12()) {
      return true;
   }
#endif
 
   return false;
}

References allow_dtls12(), allow_tls12(), and allow_tls13().

Referenced by Botan::TLS::Client_Hello_12::Client_Hello_12(), Botan::TLS::Client_Hello_12::Client_Hello_12(), Botan::TLS::Client_Hello_13::highest_supported_version(), and latest_supported_version().

◆ acceptable_signature_schemes()

std::vector< Signature_Scheme > Botan::TLS::Policy::acceptable_signature_schemes ( ) const

virtual

Return a list of schemes we are willing to accept

Definition at line 43 of file tls_policy.cpp.

                                                                       {
   return this->allowed_signature_schemes();
}

References allowed_signature_schemes().

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

◆ accepted_client_certificate_types()

std::vector< Certificate_Type > Botan::TLS::Policy::accepted_client_certificate_types ( ) const

virtual

Returns a list of accepted certificate types for client authentication in order of preference. See RFC 7250 and RFC 8446 4.4.2 for details. Defaults to X509 only.

Note that it is the application's responsibility to provide public keys and/or certificates according to the specification in this list via the Credentials_Manager.

Reimplemented in Botan::TLS::Text_Policy.

Definition at line 398 of file tls_policy.cpp.

                                                                            {
   return {Certificate_Type::X509};
}

References Botan::TLS::X509.

Referenced by Botan::TLS::Text_Policy::accepted_client_certificate_types(), Botan::TLS::Client_Hello_13::Client_Hello_13(), and print().

◆ accepted_server_certificate_types()

std::vector< Certificate_Type > Botan::TLS::Policy::accepted_server_certificate_types ( ) const

virtual

Returns a list of accepted certificate types for server authentication in order of preference. See RFC 7250 and RFC 8446 4.4.2 for details. Defaults to X509 only.

Note that it is the application's responsibility to provide public keys and/or certificates according to the specification in this list via the Credentials_Manager.

Reimplemented in Botan::TLS::Text_Policy.

Definition at line 402 of file tls_policy.cpp.

                                                                            {
   return {Certificate_Type::X509};
}

References Botan::TLS::X509.

Referenced by Botan::TLS::Text_Policy::accepted_server_certificate_types(), Botan::TLS::Client_Hello_13::Client_Hello_13(), and print().

◆ allow_client_initiated_renegotiation()

bool Botan::TLS::Policy::allow_client_initiated_renegotiation ( ) const

virtual

Consulted by server side. If true, allows clients to initiate a new handshake

Note: Has no effect for TLS 1.3 connections.

Reimplemented in Botan::TLS::Text_Policy.

Definition at line 310 of file tls_policy.cpp.

                                                        {
   return false;
}

Referenced by Botan::TLS::Text_Policy::allow_client_initiated_renegotiation().

◆ allow_dtls12()

bool Botan::TLS::Policy::allow_dtls12 ( ) const

virtual

Allow DTLS v1.2

Reimplemented in Botan::TLS::BSI_TR_02102_2, Botan::TLS::Datagram_Policy, Botan::TLS::NSA_Suite_B_128, Botan::TLS::NSA_Suite_B_192, and Botan::TLS::Text_Policy.

Definition at line 338 of file tls_policy.cpp.

                                {
#if defined(BOTAN_HAS_TLS_12)
   return true;
#else
   return false;
#endif
}

Referenced by acceptable_protocol_version(), Botan::TLS::Text_Policy::allow_dtls12(), Botan::TLS::make_hello_random(), print(), and Botan::TLS::Supported_Versions::Supported_Versions().

◆ allow_dtls_epoch0_restart()

bool Botan::TLS::Policy::allow_dtls_epoch0_restart ( ) const

virtual

If true, then allow a DTLS client to restart a connection to the same server association as described in section 4.2.8 of the DTLS RFC

Definition at line 406 of file tls_policy.cpp.

                                             {
   return false;
}

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

◆ allow_insecure_renegotiation()

bool Botan::TLS::Policy::allow_insecure_renegotiation ( ) const

virtual

Allow renegotiation even if the counterparty doesn't support the secure renegotiation extension.

Warning: Changing this to true exposes you to injected plaintext attacks. Read RFC 5746 for background.

Note: Has no effect for TLS 1.3 connections.

Reimplemented in Botan::TLS::BSI_TR_02102_2, and Botan::TLS::Text_Policy.

Definition at line 318 of file tls_policy.cpp.

                                                {
   return false;
}

Referenced by Botan::TLS::Text_Policy::allow_insecure_renegotiation(), and print().

◆ allow_resumption_for_renegotiation()

bool Botan::TLS::Policy::allow_resumption_for_renegotiation ( ) const

virtual

Note: Has no effect for TLS 1.3 connections.

Definition at line 370 of file tls_policy.cpp.

                                                      {
   return true;
}

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

◆ allow_server_initiated_renegotiation()

bool Botan::TLS::Policy::allow_server_initiated_renegotiation ( ) const

virtual

Consulted by client side. If true, allows servers to initiate a new handshake

Note: Has no effect for TLS 1.3 connections.

Reimplemented in Botan::TLS::BSI_TR_02102_2, and Botan::TLS::Text_Policy.

Definition at line 314 of file tls_policy.cpp.

                                                        {
   return false;
}

Referenced by Botan::TLS::Text_Policy::allow_server_initiated_renegotiation(), and print().

◆ allow_ssl_key_log_file()

bool Botan::TLS::Policy::allow_ssl_key_log_file ( ) const

virtual

Allow ssl key log file

Note: If function returns true, then Callbacks::tls_ssl_key_log_data will be invoked containing secret information for logging purposes

Reimplemented in Botan::TLS::Text_Policy.

Definition at line 24 of file tls_policy.cpp.

                                          {
   return false;
}

Referenced by Botan::TLS::Text_Policy::allow_ssl_key_log_file(), and print().

◆ allow_tls12()

bool Botan::TLS::Policy::allow_tls12 ( ) const

virtual

Allow TLS v1.2

Reimplemented in Botan::TLS::BSI_TR_02102_2, Botan::TLS::Datagram_Policy, Botan::TLS::NSA_Suite_B_128, Botan::TLS::NSA_Suite_B_192, and Botan::TLS::Text_Policy.

Definition at line 322 of file tls_policy.cpp.

                               {
#if defined(BOTAN_HAS_TLS_12)
   return true;
#else
   return false;
#endif
}

Referenced by acceptable_protocol_version(), Botan::TLS::Text_Policy::allow_tls12(), Botan::TLS::Client_Hello_13::Client_Hello_13(), Botan::TLS::Client_Impl_13::Client_Impl_13(), Botan::TLS::make_hello_random(), print(), Botan::TLS::Server_Impl_13::Server_Impl_13(), and Botan::TLS::Supported_Versions::Supported_Versions().

◆ allow_tls13()

bool Botan::TLS::Policy::allow_tls13 ( ) const

virtual

Allow TLS v1.3

Reimplemented in Botan::TLS::BSI_TR_02102_2, Botan::TLS::Datagram_Policy, Botan::TLS::NSA_Suite_B_128, Botan::TLS::NSA_Suite_B_192, and Botan::TLS::Text_Policy.

Definition at line 330 of file tls_policy.cpp.

                               {
#if defined(BOTAN_HAS_TLS_13)
   return true;
#else
   return false;
#endif
}

Referenced by acceptable_protocol_version(), Botan::TLS::Text_Policy::allow_tls13(), print(), and Botan::TLS::Supported_Versions::Supported_Versions().

◆ allowed_ciphers()

std::vector< std::string > Botan::TLS::Policy::allowed_ciphers ( ) const

virtual

Returns a list of ciphers we are willing to negotiate, in order of preference.

Reimplemented in Botan::TLS::BSI_TR_02102_2, Botan::TLS::NSA_Suite_B_128, Botan::TLS::NSA_Suite_B_192, Botan::TLS::Strict_Policy, and Botan::TLS::Text_Policy.

Definition at line 52 of file tls_policy.cpp.

                                                   {
   return {
      //"AES-256/OCB(12)",
      "ChaCha20Poly1305",
      "AES-256/GCM",
      "AES-128/GCM",
      //"AES-256/CCM",
      //"AES-128/CCM",
      //"AES-256/CCM(8)",
      //"AES-128/CCM(8)",
      //"Camellia-256/GCM",
      //"Camellia-128/GCM",
      //"ARIA-256/GCM",
      //"ARIA-128/GCM",
      //"AES-256",
      //"AES-128",
      //"3DES",
   };
}

Referenced by acceptable_ciphersuite(), Botan::TLS::Text_Policy::allowed_ciphers(), ciphersuite_list(), and print().

◆ allowed_key_exchange_methods()

std::vector< std::string > Botan::TLS::Policy::allowed_key_exchange_methods ( ) const

virtual

Returns a list of key exchange algorithms we are willing to use, in order of preference. Allowed values: DH, empty string (representing RSA using server certificate key)

Reimplemented in Botan::TLS::BSI_TR_02102_2, Botan::TLS::NSA_Suite_B_128, Botan::TLS::NSA_Suite_B_192, Botan::TLS::Strict_Policy, and Botan::TLS::Text_Policy.

Definition at line 94 of file tls_policy.cpp.

                                                                {
   return {
      //"ECDHE_PSK",
      //"PSK",
      "ECDH",
      "DH",
      //"RSA",
   };
}

Referenced by Botan::TLS::Text_Policy::allowed_key_exchange_methods(), ciphersuite_list(), and print().

◆ allowed_macs()

std::vector< std::string > Botan::TLS::Policy::allowed_macs ( ) const

virtual

Returns a list of MAC algorithms we are willing to use.

Reimplemented in Botan::TLS::BSI_TR_02102_2, Botan::TLS::Datagram_Policy, Botan::TLS::NSA_Suite_B_128, Botan::TLS::NSA_Suite_B_192, Botan::TLS::Strict_Policy, and Botan::TLS::Text_Policy.

Definition at line 80 of file tls_policy.cpp.

                                                {
   /*
   SHA-256 is preferred because the Lucky13 countermeasure works
   somewhat better for SHA-256 vs SHA-384:
   https://github.com/randombit/botan/pull/675
   */
   return {
      "AEAD",
      "SHA-256",
      "SHA-384",
      "SHA-1",
   };
}

Referenced by acceptable_ciphersuite(), Botan::TLS::Text_Policy::allowed_macs(), ciphersuite_list(), and print().

◆ allowed_signature_hash()

bool Botan::TLS::Policy::allowed_signature_hash ( std::string_view hash ) const

Definition at line 115 of file tls_policy.cpp.

                                                                 {
   return value_exists(allowed_signature_hashes(), sig_hash);
}

References allowed_signature_hashes(), and Botan::value_exists().

Referenced by allowed_signature_schemes(), and Botan::TLS::Handshake_State::choose_sig_format().

◆ allowed_signature_hashes()

std::vector< std::string > Botan::TLS::Policy::allowed_signature_hashes ( ) const

virtual

Returns a list of hash algorithms we are willing to use for signatures, in order of preference.

Reimplemented in Botan::TLS::BSI_TR_02102_2, Botan::TLS::NSA_Suite_B_128, Botan::TLS::NSA_Suite_B_192, Botan::TLS::Strict_Policy, and Botan::TLS::Text_Policy.

Definition at line 72 of file tls_policy.cpp.

                                                            {
   return {
      "SHA-512",
      "SHA-384",
      "SHA-256",
   };
}

Referenced by allowed_signature_hash(), Botan::TLS::Text_Policy::allowed_signature_hashes(), and print().

◆ allowed_signature_method()

bool Botan::TLS::Policy::allowed_signature_method ( std::string_view sig_method ) const

Definition at line 111 of file tls_policy.cpp.

                                                                     {
   return value_exists(allowed_signature_methods(), sig_method);
}

References allowed_signature_methods(), and Botan::value_exists().

Referenced by allowed_signature_schemes(), Botan::TLS::Certificate_13::Certificate_13(), and Botan::TLS::Handshake_State::parse_sig_format().

◆ allowed_signature_methods()

std::vector< std::string > Botan::TLS::Policy::allowed_signature_methods ( ) const

virtual

Returns a list of signature algorithms we are willing to use, in order of preference.

Reimplemented in Botan::TLS::BSI_TR_02102_2, Botan::TLS::NSA_Suite_B_128, Botan::TLS::NSA_Suite_B_192, and Botan::TLS::Text_Policy.

Definition at line 104 of file tls_policy.cpp.

                                                             {
   return {
      "ECDSA", "RSA",
      //"IMPLICIT",
   };
}

Referenced by allowed_signature_method(), Botan::TLS::Text_Policy::allowed_signature_methods(), ciphersuite_list(), and print().

◆ allowed_signature_schemes()

std::vector< Signature_Scheme > Botan::TLS::Policy::allowed_signature_schemes ( ) const

virtual

Definition at line 28 of file tls_policy.cpp.

                                                                    {
   std::vector<Signature_Scheme> schemes;
 
   for(Signature_Scheme scheme : Signature_Scheme::all_available_schemes()) {
      const bool sig_allowed = allowed_signature_method(scheme.algorithm_name());
      const bool hash_allowed = allowed_signature_hash(scheme.hash_function_name());
 
      if(sig_allowed && hash_allowed) {
         schemes.push_back(scheme);
      }
   }
 
   return schemes;
}

References Botan::TLS::Signature_Scheme::all_available_schemes(), allowed_signature_hash(), and allowed_signature_method().

Referenced by acceptable_signature_schemes(), Botan::TLS::Certificate_Verify_13::Certificate_Verify_13(), and Botan::TLS::Handshake_State::choose_sig_format().

◆ check_peer_key_acceptable()

void Botan::TLS::Policy::check_peer_key_acceptable ( const Public_Key & public_key ) const

virtual

Throw an exception if you don't like the peer's key. Default impl checks the key size against minimum_rsa_bits, minimum_ecdsa_group_size, or minimum_ecdh_group_size depending on the key's type. Override if you'd like to perform some other kind of test on (or logging of) the peer's keys.

Definition at line 224 of file tls_policy.cpp.

                                                                         {
   const std::string algo_name = public_key.algo_name();
 
   const size_t keylength = public_key.key_length();
   size_t expected_keylength = 0;
 
   if(algo_name == "RSA") {
      expected_keylength = minimum_rsa_bits();
   } else if(algo_name == "DH") {
      expected_keylength = minimum_dh_group_size();
   } else if(algo_name == "ECDH" || algo_name == "X25519" || algo_name == "X448") {
      expected_keylength = minimum_ecdh_group_size();
   } else if(algo_name == "ECDSA") {
      expected_keylength = minimum_ecdsa_group_size();
   }
   // else some other algo, so leave expected_keylength as zero and the check is a no-op
 
   if(keylength < expected_keylength) {
      throw TLS_Exception(Alert::InsufficientSecurity,
                          "Peer sent " + std::to_string(keylength) + " bit " + algo_name +
                             " key"
                             ", policy requires at least " +
                             std::to_string(expected_keylength));
   }
}

References Botan::Asymmetric_Key::algo_name(), Botan::Public_Key::key_length(), minimum_dh_group_size(), minimum_ecdh_group_size(), minimum_ecdsa_group_size(), and minimum_rsa_bits().

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

◆ choose_key_exchange_group()

Group_Params Botan::TLS::Policy::choose_key_exchange_group	(	const std::vector< Group_Params > &	supported_by_peer,
		const std::vector< Group_Params > &	offered_by_peer ) const

virtual

Select a key exchange group to use, from the list of groups sent by the peer. In TLS 1.3 handshakes the peer might have provided cryptographic material for a subset of its available groups. Choosing a group for which no share was provided will result in an additional round trip. If none are acceptable, return Group_Params::NONE.

By default this will try to optimize for less round trips even if this results in the usage of a less preferred group.

Definition at line 123 of file tls_policy.cpp.

                                                                                                     {
   if(supported_by_peer.empty()) {
      return Group_Params::NONE;
   }
 
   const std::vector<Group_Params> our_groups = key_exchange_groups();
 
   // Prefer groups that were offered by the peer for the sake of saving
   // an additional round trip. For TLS 1.2, this won't be used.
   for(auto g : offered_by_peer) {
      if(value_exists(our_groups, g)) {
         return g;
      }
   }
 
   // If no pre-offered groups fit our supported set, we prioritize our
   // own preference.
   for(auto g : our_groups) {
      if(value_exists(supported_by_peer, g)) {
         return g;
      }
   }
 
   return Group_Params::NONE;
}

References key_exchange_groups(), and Botan::value_exists().

Referenced by Botan::TLS::Client_Key_Exchange::Client_Key_Exchange(), Botan::TLS::Server_Hello_13::create(), and Botan::TLS::Server_Key_Exchange::Server_Key_Exchange().

◆ ciphersuite_list()

std::vector< uint16_t > Botan::TLS::Policy::ciphersuite_list ( Protocol_Version version ) const

virtual

Return allowed ciphersuites, in order of preference for the provided protocol version.

Parameters

version the exact protocol version to select supported and allowed ciphersuites for

Definition at line 505 of file tls_policy.cpp.

                                                                           {
   const std::vector<std::string> ciphers = allowed_ciphers();
   const std::vector<std::string> macs = allowed_macs();
   const std::vector<std::string> kex = allowed_key_exchange_methods();
   const std::vector<std::string> sigs = allowed_signature_methods();
 
   std::vector<Ciphersuite> ciphersuites;
 
   for(auto&& suite : Ciphersuite::all_known_ciphersuites()) {
      // Can we use it?
      if(!suite.valid()) {
         continue;
      }
 
      // Can we use it in this version?
      if(!suite.usable_in_version(version)) {
         continue;
      }
 
      // Is it acceptable to the policy?
      if(!this->acceptable_ciphersuite(suite)) {
         continue;
      }
 
      if(!value_exists(ciphers, suite.cipher_algo())) {
         continue;  // unsupported cipher
      }
 
      // these checks are irrelevant for TLS 1.3
      // TODO: consider making a method for this logic
      if(version.is_pre_tls_13()) {
         if(!value_exists(kex, suite.kex_algo())) {
            continue;  // unsupported key exchange
         }
 
         if(!value_exists(macs, suite.mac_algo())) {
            continue;  // unsupported MAC algo
         }
 
         if(!value_exists(sigs, suite.sig_algo())) {
            // allow if it's an empty sig algo and we want to use PSK
            if(suite.auth_method() != Auth_Method::IMPLICIT || !suite.psk_ciphersuite()) {
               continue;
            }
         }
      }
 
      // OK, consider it
      ciphersuites.push_back(suite);
   }
 
   if(ciphersuites.empty()) {
      throw Invalid_State("Policy does not allow any available cipher suite");
   }
 
   Ciphersuite_Preference_Ordering order(ciphers, macs, kex, sigs);
   std::sort(ciphersuites.begin(), ciphersuites.end(), order);
 
   std::vector<uint16_t> ciphersuite_codes;
   ciphersuite_codes.reserve(ciphersuites.size());
   for(auto i : ciphersuites) {
      ciphersuite_codes.push_back(i.ciphersuite_code());
   }
   return ciphersuite_codes;
}

References acceptable_ciphersuite(), Botan::TLS::Ciphersuite::all_known_ciphersuites(), allowed_ciphers(), allowed_key_exchange_methods(), allowed_macs(), allowed_signature_methods(), Botan::TLS::IMPLICIT, Botan::TLS::Protocol_Version::is_pre_tls_13(), and Botan::value_exists().

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

◆ default_dh_group()

Group_Params Botan::TLS::Policy::default_dh_group ( ) const

virtual

Note: Has no effect for TLS 1.3 connections.

Definition at line 150 of file tls_policy.cpp.

                                            {
   /*
   * Return the first listed or just default to 2048
   */
   for(auto g : key_exchange_groups()) {
      if(g.is_dh_named_group()) {
         return g;
      }
   }
 
   return Group_Params::FFDHE_2048;
}

References key_exchange_groups().

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

◆ dtls_default_mtu()

size_t Botan::TLS::Policy::dtls_default_mtu ( ) const

virtual

Returns: the default MTU for DTLS

Reimplemented in Botan::TLS::Text_Policy.

Definition at line 423 of file tls_policy.cpp.

                                      {
   // default MTU is IPv6 min MTU minus UDP/IP headers
   return 1280 - 40 - 8;
}

Referenced by Botan::TLS::Text_Policy::dtls_default_mtu().

◆ dtls_initial_timeout()

size_t Botan::TLS::Policy::dtls_initial_timeout ( ) const

virtual

Returns: the initial timeout for DTLS

Reimplemented in Botan::TLS::Text_Policy.

Definition at line 415 of file tls_policy.cpp.

                                          {
   return 1 * 1000;
}

Referenced by Botan::TLS::Text_Policy::dtls_initial_timeout().

◆ dtls_maximum_timeout()

size_t Botan::TLS::Policy::dtls_maximum_timeout ( ) const

virtual

Returns: the maximum timeout for DTLS

Reimplemented in Botan::TLS::Text_Policy.

Definition at line 419 of file tls_policy.cpp.

                                          {
   return 60 * 1000;
}

Referenced by Botan::TLS::Text_Policy::dtls_maximum_timeout().

◆ hash_hello_random()

bool Botan::TLS::Policy::hash_hello_random ( ) const

virtual

Hash the RNG output for the client/server hello random. This is a pre-caution to avoid writing "raw" RNG output to the wire.

There's not normally a reason to disable this, except when deterministic output is required for testing.

Reimplemented in Botan::TLS::Text_Policy.

Definition at line 378 of file tls_policy.cpp.

                                     {
   return true;
}

Referenced by Botan::TLS::Text_Policy::hash_hello_random(), Botan::TLS::make_hello_random(), and print().

◆ hide_unknown_users()

bool Botan::TLS::Policy::hide_unknown_users ( ) const

virtual

If this function returns false, unknown PSK identifiers will be rejected with an unknown_psk_identifier alert as soon as the non-existence is identified. Otherwise, a false identifier value will be used and the protocol allowed to proceed, causing the handshake to eventually fail without revealing that the username does not exist on this system.

Reimplemented in Botan::TLS::Text_Policy.

Definition at line 350 of file tls_policy.cpp.

                                      {
   return false;
}

Referenced by Botan::TLS::Client_Key_Exchange::Client_Key_Exchange(), Botan::TLS::Text_Policy::hide_unknown_users(), and print().

◆ include_time_in_hello_random()

bool Botan::TLS::Policy::include_time_in_hello_random ( ) const

virtual

The protocol dictates that the first 32 bits of the random field are the current time in seconds. However this allows client fingerprinting attacks. Set to false to disable, in which case random bytes will be used instead.

Reimplemented in Botan::TLS::Text_Policy.

Definition at line 346 of file tls_policy.cpp.

                                                {
   return true;
}

Referenced by Botan::TLS::Text_Policy::include_time_in_hello_random(), Botan::TLS::make_hello_random(), and print().

◆ key_exchange_groups()

std::vector< Group_Params > Botan::TLS::Policy::key_exchange_groups ( ) const

virtual

Return list of ECC curves and FFDHE groups we are willing to use in order of preference.

Reimplemented in Botan::TLS::BSI_TR_02102_2, Botan::TLS::NSA_Suite_B_128, Botan::TLS::NSA_Suite_B_192, and Botan::TLS::Text_Policy.

Definition at line 163 of file tls_policy.cpp.

                                                          {
   // Default list is ordered by performance
   return {
#if defined(BOTAN_HAS_X25519)
      Group_Params::X25519,
#endif
#if defined(BOTAN_HAS_X448)
         Group_Params::X448,
#endif
 
         Group_Params::SECP256R1, Group_Params::BRAINPOOL256R1, Group_Params::SECP384R1, Group_Params::BRAINPOOL384R1,
         Group_Params::SECP521R1, Group_Params::BRAINPOOL512R1,
 
         Group_Params::FFDHE_2048, Group_Params::FFDHE_3072, Group_Params::FFDHE_4096, Group_Params::FFDHE_6144,
         Group_Params::FFDHE_8192,
   };
}

Referenced by choose_key_exchange_group(), Botan::TLS::Client_Hello_13::Client_Hello_13(), default_dh_group(), Botan::TLS::Encrypted_Extensions::Encrypted_Extensions(), Botan::TLS::Text_Policy::key_exchange_groups(), key_exchange_groups_to_offer(), and print().

◆ key_exchange_groups_to_offer()

std::vector< Group_Params > Botan::TLS::Policy::key_exchange_groups_to_offer ( ) const

virtual

Return a list of groups to provide prepared key share offers in the initial client hello for. Groups in this list must be reflected in key_exchange_groups() and in the same order. By default this returns the most preferred group from key_exchange_groups(). If an empty list is returned, no prepared key share offers are sent and the decision of the group to use is left to the server.

Note: Has an effect on TLS 1.3 clients, only.

Reimplemented in Botan::TLS::Text_Policy.

Definition at line 181 of file tls_policy.cpp.

                                                                   {
   // by default, we offer a key share for the most-preferred group, only
   std::vector<Group_Params> groups_to_offer;
   const auto supported_groups = key_exchange_groups();
   if(!supported_groups.empty()) {
      groups_to_offer.push_back(supported_groups.front());
   }
   return groups_to_offer;
}

References key_exchange_groups().

Referenced by Botan::TLS::Text_Policy::key_exchange_groups_to_offer(), and print().

◆ latest_supported_version()

Protocol_Version Botan::TLS::Policy::latest_supported_version ( bool datagram ) const

virtual

Returns the most recent protocol version we are willing to use, for either TLS or DTLS depending on datagram param. Shouldn't ever need to override this unless you want to allow a user to disable specific TLS versions.

Definition at line 286 of file tls_policy.cpp.

                                                                     {
   if(datagram) {
      if(acceptable_protocol_version(Protocol_Version::DTLS_V12)) {
         return Protocol_Version::DTLS_V12;
      }
      throw Invalid_State("Policy forbids all available DTLS version");
   } else {
#if defined(BOTAN_HAS_TLS_13)
      if(acceptable_protocol_version(Protocol_Version::TLS_V13)) {
         return Protocol_Version::TLS_V13;
      }
#endif
      if(acceptable_protocol_version(Protocol_Version::TLS_V12)) {
         return Protocol_Version::TLS_V12;
      }
      throw Invalid_State("Policy forbids all available TLS version");
   }
}

References acceptable_protocol_version().

◆ maximum_certificate_chain_size()

size_t Botan::TLS::Policy::maximum_certificate_chain_size ( ) const

virtual

Returns: the maximum size of the certificate chain, in bytes. Return 0 to disable this and accept any size.

Definition at line 410 of file tls_policy.cpp.

                                                    {
   return 0;
}

Referenced by Botan::TLS::Certificate_12::Certificate_12(), and Botan::TLS::Certificate_13::Certificate_13().

◆ maximum_session_tickets_per_client_hello()

size_t Botan::TLS::Policy::maximum_session_tickets_per_client_hello ( ) const

virtual

Defines the maximum number of session tickets a client might offer in a single resumption attempt. Must be greater than 0.

TODO: Currently, the TLS 1.3 client implementation supports exactly one ticket per handshake. RFC 8446 allows for an arbitrary amount, though.

Note: Has an effect on TLS 1.3 connections, only.

Reimplemented in Botan::TLS::Text_Policy.

Definition at line 250 of file tls_policy.cpp.

                                                              {
   return 1;
}

Referenced by Botan::TLS::Session_Manager::find(), Botan::TLS::Text_Policy::maximum_session_tickets_per_client_hello(), and print().

◆ minimum_dh_group_size()

size_t Botan::TLS::Policy::minimum_dh_group_size ( ) const

virtual

Return the minimum DH group size we're willing to use Default is currently 1024 (insecure), should be 2048

Reimplemented in Botan::TLS::BSI_TR_02102_2, and Botan::TLS::Text_Policy.

Definition at line 191 of file tls_policy.cpp.

                                           {
   return 2048;
}

Referenced by check_peer_key_acceptable(), Botan::TLS::Text_Policy::minimum_dh_group_size(), and print().

◆ minimum_ecdh_group_size()

size_t Botan::TLS::Policy::minimum_ecdh_group_size ( ) const

virtual

Return the minimum ECDH group size we're willing to use for key exchange

Default 255, allowing x25519 and larger x25519 is the smallest curve we will negotiate P-521 is the largest

Reimplemented in Botan::TLS::BSI_TR_02102_2, and Botan::TLS::Text_Policy.

Definition at line 200 of file tls_policy.cpp.

                                             {
   // x25519 is smallest curve currently supported for TLS key exchange
   return 255;
}

Referenced by check_peer_key_acceptable(), Botan::TLS::Text_Policy::minimum_ecdh_group_size(), and print().

◆ minimum_ecdsa_group_size()

size_t Botan::TLS::Policy::minimum_ecdsa_group_size ( ) const

virtual

For ECDSA authenticated ciphersuites, the smallest key size the client will accept. This policy is currently only enforced on the server by the client.

Reimplemented in Botan::TLS::BSI_TR_02102_2, and Botan::TLS::Text_Policy.

Definition at line 195 of file tls_policy.cpp.

                                              {
   // Here we are at the mercy of whatever the CA signed, but most certs should be 256 bit by now
   return 256;
}

Referenced by check_peer_key_acceptable(), and Botan::TLS::Text_Policy::minimum_ecdsa_group_size().

◆ minimum_rsa_bits()

size_t Botan::TLS::Policy::minimum_rsa_bits ( ) const

virtual

Return the minimum bit size we're willing to accept for RSA key exchange or server signatures.

It does not place any requirements on the size of any RSA signature(s) which were used to check the server certificate. This is only concerned with the server's public key.

Default is 2048 which is smallest RSA key size still secure for medium term security.

Reimplemented in Botan::TLS::BSI_TR_02102_2, and Botan::TLS::Text_Policy.

Definition at line 213 of file tls_policy.cpp.

                                      {
   /* Default assumption is all end-entity certificates should
      be at least 2048 bits these days.
 
      If you are connecting to arbitrary servers on the Internet
      (ie as a web browser or SMTP client) you'll probably have to reduce this
      to 1024 bits, or perhaps even lower.
   */
   return 2048;
}

Referenced by check_peer_key_acceptable(), Botan::TLS::Text_Policy::minimum_rsa_bits(), and print().

◆ minimum_signature_strength()

size_t Botan::TLS::Policy::minimum_signature_strength ( ) const

virtual

The minimum signature strength we will accept Returning 80 allows RSA 1024 and SHA-1. Values larger than 80 disable SHA-1 support. Returning 110 allows RSA 2048. Return 128 to force ECC (P-256) or large (~3000 bit) RSA keys. Default is 110

Reimplemented in Botan::TLS::BSI_TR_02102_2, Botan::TLS::NSA_Suite_B_128, Botan::TLS::NSA_Suite_B_192, and Botan::TLS::Text_Policy.

Definition at line 205 of file tls_policy.cpp.

                                                {
   return 110;
}

Referenced by Botan::TLS::Text_Policy::minimum_signature_strength(), print(), and Botan::TLS::Callbacks::tls_verify_cert_chain().

◆ negotiate_encrypt_then_mac()

bool Botan::TLS::Policy::negotiate_encrypt_then_mac ( ) const

virtual

Indicates whether the encrypt-then-MAC extension should be negotiated (RFC 7366)

Note: Has no effect for TLS 1.3 connections.

Reimplemented in Botan::TLS::BSI_TR_02102_2, and Botan::TLS::Text_Policy.

Definition at line 358 of file tls_policy.cpp.

                                              {
   return true;
}

Referenced by Botan::TLS::Client_Hello_12::Client_Hello_12(), Botan::TLS::Client_Hello_13::Client_Hello_13(), Botan::TLS::Text_Policy::negotiate_encrypt_then_mac(), print(), Botan::TLS::Server_Hello_12::Server_Hello_12(), and Botan::TLS::Server_Hello_12::Server_Hello_12().

◆ new_session_tickets_upon_handshake_success()

size_t Botan::TLS::Policy::new_session_tickets_upon_handshake_success ( ) const

virtual

Return the number of new session tickets a TLS 1.3 server should issue automatically upon a successful handshake. Note that applications can use TLS::Server::send_new_session_tickets() regardless of this policy.

For convenience (and compatibility with the TLS 1.2 behaviour), this returns '1' by default.

Note: Has an effect on TLS 1.3 connections, only.

Reimplemented in Botan::TLS::Text_Policy.

Definition at line 262 of file tls_policy.cpp.

                                                                {
   return 1;
}

Referenced by Botan::TLS::Text_Policy::new_session_tickets_upon_handshake_success(), and print().

◆ only_resume_with_exact_version()

bool Botan::TLS::Policy::only_resume_with_exact_version ( ) const

virtual

Definition at line 382 of file tls_policy.cpp.

                                                  {
   return true;
}

◆ print()

void Botan::TLS::Policy::print ( std::ostream & o ) const

virtual

Convert this policy to a printable format.

Parameters

o	stream to be printed to

Definition at line 621 of file tls_policy.cpp.

                                      {
   print_bool(o, "allow_tls12", allow_tls12());
   print_bool(o, "allow_tls13", allow_tls13());
   print_bool(o, "allow_dtls12", allow_dtls12());
   print_bool(o, "allow_ssl_key_log_file", allow_ssl_key_log_file());
   print_vec(o, "ciphers", allowed_ciphers());
   print_vec(o, "macs", allowed_macs());
   print_vec(o, "signature_hashes", allowed_signature_hashes());
   print_vec(o, "signature_methods", allowed_signature_methods());
   print_vec(o, "key_exchange_methods", allowed_key_exchange_methods());
   print_vec(o, "key_exchange_groups", key_exchange_groups());
   const auto groups_to_offer = key_exchange_groups_to_offer();
   if(groups_to_offer.empty()) {
      print_vec(o, "key_exchange_groups_to_offer", {std::string("none")});
   } else {
      print_vec(o, "key_exchange_groups_to_offer", groups_to_offer);
   }
   print_bool(o, "allow_insecure_renegotiation", allow_insecure_renegotiation());
   print_bool(o, "include_time_in_hello_random", include_time_in_hello_random());
   print_bool(o, "allow_server_initiated_renegotiation", allow_server_initiated_renegotiation());
   print_bool(o, "hide_unknown_users", hide_unknown_users());
   print_bool(o, "server_uses_own_ciphersuite_preferences", server_uses_own_ciphersuite_preferences());
   print_bool(o, "negotiate_encrypt_then_mac", negotiate_encrypt_then_mac());
   print_bool(o, "support_cert_status_message", support_cert_status_message());
   print_bool(o, "tls_13_middlebox_compatibility_mode", tls_13_middlebox_compatibility_mode());
   print_vec(o, "accepted_client_certificate_types", accepted_client_certificate_types());
   print_vec(o, "accepted_server_certificate_types", accepted_server_certificate_types());
   print_bool(o, "hash_hello_random", hash_hello_random());
   if(record_size_limit().has_value()) {
      o << "record_size_limit = " << record_size_limit().value() << '\n';
   }
   o << "maximum_session_tickets_per_client_hello = " << maximum_session_tickets_per_client_hello() << '\n';
   o << "session_ticket_lifetime = " << session_ticket_lifetime().count() << '\n';
   o << "reuse_session_tickets = " << reuse_session_tickets() << '\n';
   o << "new_session_tickets_upon_handshake_success = " << new_session_tickets_upon_handshake_success() << '\n';
   o << "minimum_dh_group_size = " << minimum_dh_group_size() << '\n';
   o << "minimum_ecdh_group_size = " << minimum_ecdh_group_size() << '\n';
   o << "minimum_rsa_bits = " << minimum_rsa_bits() << '\n';
   o << "minimum_signature_strength = " << minimum_signature_strength() << '\n';
}

References accepted_client_certificate_types(), accepted_server_certificate_types(), allow_dtls12(), allow_insecure_renegotiation(), allow_server_initiated_renegotiation(), allow_ssl_key_log_file(), allow_tls12(), allow_tls13(), allowed_ciphers(), allowed_key_exchange_methods(), allowed_macs(), allowed_signature_hashes(), allowed_signature_methods(), hash_hello_random(), hide_unknown_users(), include_time_in_hello_random(), key_exchange_groups(), key_exchange_groups_to_offer(), maximum_session_tickets_per_client_hello(), minimum_dh_group_size(), minimum_ecdh_group_size(), minimum_rsa_bits(), minimum_signature_strength(), negotiate_encrypt_then_mac(), new_session_tickets_upon_handshake_success(), record_size_limit(), reuse_session_tickets(), server_uses_own_ciphersuite_preferences(), session_ticket_lifetime(), support_cert_status_message(), and tls_13_middlebox_compatibility_mode().

Referenced by to_string().

◆ record_size_limit()

std::optional< uint16_t > Botan::TLS::Policy::record_size_limit ( ) const

virtual

Defines the maximum TLS record length for TLS connections. This is based on the Record Size Limit extension described in RFC 8449. By default (i.e. if std::nullopt is returned), TLS clients will omit this extension altogether.

This value may be between 64 and 16385 (TLS 1.3) or 16384 (TLS 1.2).

Note: This is currently not implemented for TLS 1.2, hence the limit won't be negotiated by TLS 1.3 clients that support downgrading to TLS 1.2 (i.e. allow_tls12() returning true).

Reimplemented in Botan::TLS::Text_Policy.

Definition at line 362 of file tls_policy.cpp.

                                                      {
   return std::nullopt;
}

Referenced by Botan::TLS::Client_Hello_13::Client_Hello_13(), Botan::TLS::Encrypted_Extensions::Encrypted_Extensions(), and print().

◆ request_client_certificate_authentication()

bool Botan::TLS::Policy::request_client_certificate_authentication ( ) const

virtual

Indicate if client certificate authentication is requested. If true, then a cert will be requested.

Definition at line 390 of file tls_policy.cpp.

                                                             {
   return require_client_certificate_authentication();
}

References require_client_certificate_authentication().

Referenced by Botan::TLS::Encrypted_Extensions::Encrypted_Extensions(), and Botan::TLS::Certificate_Request_13::maybe_create().

◆ require_cert_revocation_info()

bool Botan::TLS::Policy::require_cert_revocation_info ( ) const

virtual

Return if cert revocation info (CRL/OCSP) is required If true, validation will fail unless a valid CRL or OCSP response was examined.

Reimplemented in Botan::TLS::Text_Policy.

Definition at line 209 of file tls_policy.cpp.

                                                {
   return true;
}

Referenced by Botan::TLS::Text_Policy::require_cert_revocation_info(), and Botan::TLS::Callbacks::tls_verify_cert_chain().

◆ require_client_certificate_authentication()

bool Botan::TLS::Policy::require_client_certificate_authentication ( ) const

virtual

Indicate if client certificate authentication is required. If true, then a cert will be requested and if the client does not send a certificate the connection will be closed.

Reimplemented in Botan::TLS::Text_Policy.

Definition at line 386 of file tls_policy.cpp.

                                                             {
   return false;
}

Referenced by request_client_certificate_authentication(), and Botan::TLS::Text_Policy::require_client_certificate_authentication().

◆ reuse_session_tickets()

bool Botan::TLS::Policy::reuse_session_tickets ( ) const

virtual

Decides whether stored session tickets should be used multiple times (until their lifetime runs out). This might allow passive observers to correlate connections (RFC 8446 Appendix C.4). This has no effect on TLS 1.2 resumptions based on session IDs as those are negotiated in the clear anyway.

Reimplemented in Botan::TLS::Text_Policy.

Definition at line 258 of file tls_policy.cpp.

                                         {
   return false;
}

Referenced by Botan::TLS::Session_Manager::find(), print(), and Botan::TLS::Text_Policy::reuse_session_tickets().

◆ server_uses_own_ciphersuite_preferences()

bool Botan::TLS::Policy::server_uses_own_ciphersuite_preferences ( ) const

virtual

Returns: true if servers should choose the ciphersuite matching their highest preference, rather than the clients. Has no effect on client side.

Reimplemented in Botan::TLS::BSI_TR_02102_2, and Botan::TLS::Text_Policy.

Definition at line 354 of file tls_policy.cpp.

                                                           {
   return true;
}

Referenced by print(), and Botan::TLS::Text_Policy::server_uses_own_ciphersuite_preferences().

◆ session_ticket_lifetime()

std::chrono::seconds Botan::TLS::Policy::session_ticket_lifetime ( ) const

virtual

Return the allowed lifetime of a session ticket. If 0, session tickets do not expire until the session ticket key rolls over. For TLS 1.3 session tickets the lifetime must not be longer than seven days. Expired session tickets cannot be used to resume a session.

Reimplemented in Botan::TLS::Text_Policy.

Definition at line 254 of file tls_policy.cpp.

                                                       {
   return std::chrono::days(1);
}

Referenced by print(), Botan::TLS::Session_Manager::retrieve(), and Botan::TLS::Text_Policy::session_ticket_lifetime().

◆ srtp_profiles()

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

virtual

If this returns a non-empty vector, and DTLS is negotiated, then we will also attempt to negotiate the SRTP extension from RFC 5764 using the returned values as the profile ids.

Reimplemented in Botan::TLS::Text_Policy.

Definition at line 428 of file tls_policy.cpp.

                                                {
   return std::vector<uint16_t>();
}

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

◆ support_cert_status_message()

bool Botan::TLS::Policy::support_cert_status_message ( ) const

virtual

Indicates whether certificate status messages should be supported

Reimplemented in Botan::TLS::Text_Policy.

Definition at line 366 of file tls_policy.cpp.

                                               {
   return true;
}

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(), print(), Botan::TLS::Server_Hello_12::Server_Hello_12(), and Botan::TLS::Text_Policy::support_cert_status_message().

◆ tls_13_middlebox_compatibility_mode()

bool Botan::TLS::Policy::tls_13_middlebox_compatibility_mode ( ) const

virtual

Defines whether or not the middlebox compatibility mode should be used. Enabled by default.

RFC 8446 Appendix D.4 [This makes] the TLS 1.3 handshake resemble TLS 1.2 session resumption, which improves the chance of successfully connecting through middleboxes.

Note: Has an effect on TLS 1.3 connections, only.

Reimplemented in Botan::TLS::Text_Policy.

Definition at line 374 of file tls_policy.cpp.

                                                       {
   return true;
}

Referenced by Botan::TLS::Client_Hello_13::Client_Hello_13(), Botan::TLS::Client_Impl_13::Client_Impl_13(), print(), and Botan::TLS::Text_Policy::tls_13_middlebox_compatibility_mode().

◆ to_string()

std::string Botan::TLS::Policy::to_string ( ) const

Convert this policy to a printable format. Same as calling print on a ostringstream and reading o.str()

Definition at line 662 of file tls_policy.cpp.

                                  {
   std::ostringstream oss;
   this->print(oss);
   return oss.str();
}

References print().

◆ use_ecc_point_compression()

bool Botan::TLS::Policy::use_ecc_point_compression ( ) const

virtual

Request that ECC curve points are sent compressed

Note: Has no effect for TLS 1.3 connections. RFC 8446 4.2.8.2 Versions of TLS prior to 1.3 permitted point format negotiation; TLS 1.3 removes this feature in favor of a single point format for each curve.

Reimplemented in Botan::TLS::Text_Policy.

Definition at line 119 of file tls_policy.cpp.

                                             {
   return false;
}

Referenced by Botan::TLS::Client_Hello_13::Client_Hello_13(), Botan::TLS::Server_Hello_12::Server_Hello_12(), Botan::TLS::Server_Hello_12::Server_Hello_12(), and Botan::TLS::Text_Policy::use_ecc_point_compression().

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

src/lib/tls/tls_policy.h
src/lib/tls/tls_policy.cpp

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ ~Policy()

Member Function Documentation

◆ abort_connection_on_undesired_renegotiation()

◆ acceptable_certificate_signature_schemes()

◆ acceptable_ciphersuite()

◆ acceptable_protocol_version()

◆ acceptable_signature_schemes()

◆ accepted_client_certificate_types()

◆ accepted_server_certificate_types()

◆ allow_client_initiated_renegotiation()

◆ allow_dtls12()

◆ allow_dtls_epoch0_restart()

◆ allow_insecure_renegotiation()

◆ allow_resumption_for_renegotiation()

◆ allow_server_initiated_renegotiation()

◆ allow_ssl_key_log_file()

◆ allow_tls12()

◆ allow_tls13()

◆ allowed_ciphers()

◆ allowed_key_exchange_methods()

◆ allowed_macs()

◆ allowed_signature_hash()

◆ allowed_signature_hashes()

◆ allowed_signature_method()

◆ allowed_signature_methods()

◆ allowed_signature_schemes()

◆ check_peer_key_acceptable()

◆ choose_key_exchange_group()

◆ ciphersuite_list()

◆ default_dh_group()

◆ dtls_default_mtu()

◆ dtls_initial_timeout()

◆ dtls_maximum_timeout()

◆ hash_hello_random()

◆ hide_unknown_users()

◆ include_time_in_hello_random()

◆ key_exchange_groups()

◆ key_exchange_groups_to_offer()

◆ latest_supported_version()

◆ maximum_certificate_chain_size()

◆ maximum_session_tickets_per_client_hello()

◆ minimum_dh_group_size()

◆ minimum_ecdh_group_size()

◆ minimum_ecdsa_group_size()

◆ minimum_rsa_bits()

◆ minimum_signature_strength()

◆ negotiate_encrypt_then_mac()

◆ new_session_tickets_upon_handshake_success()

◆ only_resume_with_exact_version()

◆ print()

◆ record_size_limit()

◆ request_client_certificate_authentication()

◆ require_cert_revocation_info()

◆ require_client_certificate_authentication()

◆ reuse_session_tickets()

◆ server_uses_own_ciphersuite_preferences()

◆ session_ticket_lifetime()

◆ srtp_profiles()

◆ support_cert_status_message()

◆ tls_13_middlebox_compatibility_mode()

◆ to_string()

◆ use_ecc_point_compression()