Botan 3.3.0
Crypto and TLS for C&
tls_policy.h
Go to the documentation of this file.
1/*
2* Hooks for application level policies on TLS connections
3* (C) 2004-2006,2013 Jack Lloyd
4* 2017 Harry Reimann, Rohde & Schwarz Cybersecurity
5* 2022 René Meusel, Rohde & Schwarz Cybersecurity
6*
7* Botan is released under the Simplified BSD License (see license.txt)
8*/
9
10#ifndef BOTAN_TLS_POLICY_H_
11#define BOTAN_TLS_POLICY_H_
12
13#include <botan/tls_ciphersuite.h>
14#include <botan/tls_extensions.h>
15#include <botan/tls_signature_scheme.h>
16#include <botan/tls_version.h>
17#include <chrono>
18#include <map>
19#include <optional>
20#include <vector>
21
22namespace Botan {
23
24class Public_Key;
25
26namespace TLS {
27
28/**
29* TLS Policy Base Class
30* Inherit and overload as desired to suit local policy concerns
31*/
33 public:
34 /**
35 * Returns a list of ciphers we are willing to negotiate, in
36 * order of preference.
37 */
38 virtual std::vector<std::string> allowed_ciphers() const;
39
40 /**
41 * Returns a list of hash algorithms we are willing to use for
42 * signatures, in order of preference.
43 */
44 virtual std::vector<std::string> allowed_signature_hashes() const;
45
46 /**
47 * Returns a list of MAC algorithms we are willing to use.
48 */
49 virtual std::vector<std::string> allowed_macs() const;
50
51 /**
52 * Returns a list of key exchange algorithms we are willing to
53 * use, in order of preference. Allowed values: DH, empty string
54 * (representing RSA using server certificate key)
55 */
56 virtual std::vector<std::string> allowed_key_exchange_methods() const;
57
58 /**
59 * Returns a list of signature algorithms we are willing to
60 * use, in order of preference.
61 */
62 virtual std::vector<std::string> allowed_signature_methods() const;
63
64 virtual std::vector<Signature_Scheme> allowed_signature_schemes() const;
65
66 /**
67 * Return a list of schemes we are willing to accept
68 */
69 virtual std::vector<Signature_Scheme> acceptable_signature_schemes() const;
70
71 virtual std::optional<std::vector<Signature_Scheme>> acceptable_certificate_signature_schemes() const;
72
73 /**
74 * The minimum signature strength we will accept
75 * Returning 80 allows RSA 1024 and SHA-1. Values larger than 80 disable SHA-1 support.
76 * Returning 110 allows RSA 2048.
77 * Return 128 to force ECC (P-256) or large (~3000 bit) RSA keys.
78 * Default is 110
79 */
80 virtual size_t minimum_signature_strength() const;
81
82 /**
83 * Return if cert revocation info (CRL/OCSP) is required
84 * If true, validation will fail unless a valid CRL or OCSP response
85 * was examined.
86 */
87 virtual bool require_cert_revocation_info() const;
88
89 bool allowed_signature_method(std::string_view sig_method) const;
90 bool allowed_signature_hash(std::string_view hash) const;
91
92 /**
93 * Return list of ECC curves and FFDHE groups we are willing to
94 * use in order of preference.
95 */
96 virtual std::vector<Group_Params> key_exchange_groups() const;
97
98 /**
99 * Return a list of groups to provide prepared key share offers in the
100 * initial client hello for. Groups in this list must be reflected in
101 * key_exchange_groups() and in the same order. By default this returns
102 * the most preferred group from key_exchange_groups().
103 * If an empty list is returned, no prepared key share offers are sent
104 * and the decision of the group to use is left to the server.
105 *
106 * @note Has an effect on TLS 1.3 clients, only.
107 */
108 virtual std::vector<Group_Params> key_exchange_groups_to_offer() const;
109
110 /**
111 * Request that ECC curve points are sent compressed
112 *
113 * @note Has no effect for TLS 1.3 connections.
114 * RFC 8446 4.2.8.2
115 * Versions of TLS prior to 1.3 permitted point format
116 * negotiation; TLS 1.3 removes this feature in favor of a single
117 * point format for each curve.
118 */
119 virtual bool use_ecc_point_compression() const;
120
121 /**
122 * Select a key exchange group to use, from the list of groups sent by the
123 * peer. In TLS 1.3 handshakes the peer might have provided cryptographic material
124 * for a subset of its available groups. Choosing a group for which no share was
125 * provided will result in an additional round trip. If none are acceptable, return
126 * Group_Params::NONE.
127 *
128 * By default this will try to optimize for less round trips even if this results
129 * in the usage of a less preferred group.
130 */
131 virtual Group_Params choose_key_exchange_group(const std::vector<Group_Params>& supported_by_peer,
132 const std::vector<Group_Params>& offered_by_peer) const;
133
134 /**
135 * Allow renegotiation even if the counterparty doesn't
136 * support the secure renegotiation extension.
137 *
138 * @warning Changing this to true exposes you to injected
139 * plaintext attacks. Read RFC 5746 for background.
140 *
141 * @note Has no effect for TLS 1.3 connections.
142 */
143 virtual bool allow_insecure_renegotiation() const;
144
145 /**
146 * The protocol dictates that the first 32 bits of the random
147 * field are the current time in seconds. However this allows
148 * client fingerprinting attacks. Set to false to disable, in
149 * which case random bytes will be used instead.
150 */
151 virtual bool include_time_in_hello_random() const;
152
153 /**
154 * Consulted by server side. If true, allows clients to initiate a new handshake
155 *
156 * @note Has no effect for TLS 1.3 connections.
157 */
158 virtual bool allow_client_initiated_renegotiation() const;
159
160 /**
161 * Consulted by client side. If true, allows servers to initiate a new handshake
162 *
163 * @note Has no effect for TLS 1.3 connections.
164 */
165 virtual bool allow_server_initiated_renegotiation() const;
166
167 /**
168 * If true, a request to renegotiate will close the connection with
169 * a fatal alert. Otherwise, a warning alert is sent.
170 *
171 * @note Has no effect for TLS 1.3 connections.
172 */
173 virtual bool abort_connection_on_undesired_renegotiation() const;
174
175 virtual bool only_resume_with_exact_version() const;
176
177 /**
178 * Allow TLS v1.2
179 */
180 virtual bool allow_tls12() const;
181
182 /**
183 * Allow TLS v1.3
184 */
185 virtual bool allow_tls13() const;
186
187 /**
188 * Allow DTLS v1.2
189 */
190 virtual bool allow_dtls12() const;
191
192 /**
193 * @note Has no effect for TLS 1.3 connections.
194 */
195 virtual Group_Params default_dh_group() const;
196
197 /**
198 * Return the minimum DH group size we're willing to use
199 * Default is currently 1024 (insecure), should be 2048
200 */
201 virtual size_t minimum_dh_group_size() const;
202
203 /**
204 * For ECDSA authenticated ciphersuites, the smallest key size the
205 * client will accept.
206 * This policy is currently only enforced on the server by the client.
207 */
208 virtual size_t minimum_ecdsa_group_size() const;
209
210 /**
211 * Return the minimum ECDH group size we're willing to use
212 * for key exchange
213 *
214 * Default 255, allowing x25519 and larger
215 * x25519 is the smallest curve we will negotiate
216 * P-521 is the largest
217 */
218 virtual size_t minimum_ecdh_group_size() const;
219
220 /**
221 * Return the minimum bit size we're willing to accept for RSA
222 * key exchange or server signatures.
223 *
224 * It does not place any requirements on the size of any RSA signature(s)
225 * which were used to check the server certificate. This is only
226 * concerned with the server's public key.
227 *
228 * Default is 2048 which is smallest RSA key size still secure
229 * for medium term security.
230 */
231 virtual size_t minimum_rsa_bits() const;
232
233 /**
234 * Throw an exception if you don't like the peer's key.
235 * Default impl checks the key size against minimum_rsa_bits, minimum_ecdsa_group_size,
236 * or minimum_ecdh_group_size depending on the key's type.
237 * Override if you'd like to perform some other kind of test on
238 * (or logging of) the peer's keys.
239 */
240 virtual void check_peer_key_acceptable(const Public_Key& public_key) const;
241
242 /**
243 * If this function returns false, unknown PSK identifiers
244 * will be rejected with an unknown_psk_identifier alert as soon
245 * as the non-existence is identified. Otherwise, a false
246 * identifier value will be used and the protocol allowed to
247 * proceed, causing the handshake to eventually fail without
248 * revealing that the username does not exist on this system.
249 */
250 virtual bool hide_unknown_users() const;
251
252 /**
253 * Defines the maximum number of session tickets a client might
254 * offer in a single resumption attempt. Must be greater than 0.
255 *
256 * TODO: Currently, the TLS 1.3 client implementation supports
257 * exactly one ticket per handshake. RFC 8446 allows for
258 * an arbitrary amount, though.
259 *
260 * @note Has an effect on TLS 1.3 connections, only.
261 */
262 virtual size_t maximum_session_tickets_per_client_hello() const;
263
264 /**
265 * Return the allowed lifetime of a session ticket. If 0, session
266 * tickets do not expire until the session ticket key rolls over.
267 * For TLS 1.3 session tickets the lifetime must not be longer than
268 * seven days. Expired session tickets cannot be used to resume a
269 * session.
270 */
271 virtual std::chrono::seconds session_ticket_lifetime() const;
272
273 /**
274 * Decides whether stored session tickets should be used multiple
275 * times (until their lifetime runs out). This might allow passive
276 * observers to correlate connections (RFC 8446 Appendix C.4). This
277 * has no effect on TLS 1.2 resumptions based on session IDs as those
278 * are negotiated in the clear anyway.
279 */
280 virtual bool reuse_session_tickets() const;
281
282 /**
283 * Return the number of new session tickets a TLS 1.3 server should issue
284 * automatically upon a successful handshake. Note that applications can
285 * use `TLS::Server::send_new_session_tickets()` regardless of this policy.
286 *
287 * For convenience (and compatibility with the TLS 1.2 behaviour), this
288 * returns '1' by default.
289 *
290 * @note Has an effect on TLS 1.3 connections, only.
291 */
292 virtual size_t new_session_tickets_upon_handshake_success() const;
293
294 /**
295 * If this returns a non-empty vector, and DTLS is negotiated,
296 * then we will also attempt to negotiate the SRTP extension from
297 * RFC 5764 using the returned values as the profile ids.
298 */
299 virtual std::vector<uint16_t> srtp_profiles() const;
300
301 /**
302 * @return true if and only if we are willing to accept this version
303 * Default accepts TLS v1.2 and later or DTLS v1.2 or later.
304 */
305 virtual bool acceptable_protocol_version(Protocol_Version version) const;
306
307 /**
308 * Returns the most recent protocol version we are willing to
309 * use, for either TLS or DTLS depending on datagram param.
310 * Shouldn't ever need to override this unless you want to allow
311 * a user to disable specific TLS versions.
312 */
313 virtual Protocol_Version latest_supported_version(bool datagram) const;
314
315 /**
316 * Allows policy to reject any ciphersuites which are undesirable
317 * for whatever reason without having to reimplement ciphersuite_list
318 */
319 virtual bool acceptable_ciphersuite(const Ciphersuite& suite) const;
320
321 /**
322 * @return true if servers should choose the ciphersuite matching
323 * their highest preference, rather than the clients.
324 * Has no effect on client side.
325 */
326 virtual bool server_uses_own_ciphersuite_preferences() const;
327
328 /**
329 * Indicates whether the encrypt-then-MAC extension should be negotiated
330 * (RFC 7366)
331 *
332 * @note Has no effect for TLS 1.3 connections.
333 */
334 virtual bool negotiate_encrypt_then_mac() const;
335
336 /**
337 * Defines the maximum TLS record length for TLS connections.
338 * This is based on the Record Size Limit extension described in RFC 8449.
339 * By default (i.e. if std::nullopt is returned), TLS clients will omit
340 * this extension altogether.
341 *
342 * This value may be between 64 and 16385 (TLS 1.3) or 16384 (TLS 1.2).
343 *
344 * @note This is currently not implemented for TLS 1.2, hence the limit
345 * won't be negotiated by TLS 1.3 clients that support downgrading
346 * to TLS 1.2 (i.e. #allow_tls12() returning true).
347 */
348 virtual std::optional<uint16_t> record_size_limit() const;
349
350 /**
351 * Indicates whether certificate status messages should be supported
352 */
353 virtual bool support_cert_status_message() const;
354
355 /**
356 * Indicate if client certificate authentication is required.
357 * If true, then a cert will be requested and if the client does
358 * not send a certificate the connection will be closed.
359 */
360 virtual bool require_client_certificate_authentication() const;
361
362 /**
363 * Indicate if client certificate authentication is requested.
364 * If true, then a cert will be requested.
365 */
366 virtual bool request_client_certificate_authentication() const;
367
368 /**
369 * Returns a list of accepted certificate types for client authentication
370 * in order of preference. See RFC 7250 and RFC 8446 4.4.2 for details.
371 * Defaults to X509 only.
372 *
373 * Note that it is the application's responsibility to provide public keys
374 * and/or certificates according to the specification in this list via the
375 * Credentials_Manager.
376 */
377 virtual std::vector<Certificate_Type> accepted_client_certificate_types() const;
378
379 /**
380 * Returns a list of accepted certificate types for server authentication
381 * in order of preference. See RFC 7250 and RFC 8446 4.4.2 for details.
382 * Defaults to X509 only.
383 *
384 * Note that it is the application's responsibility to provide public keys
385 * and/or certificates according to the specification in this list via the
386 * Credentials_Manager.
387 */
388 virtual std::vector<Certificate_Type> accepted_server_certificate_types() const;
389
390 /**
391 * If true, then allow a DTLS client to restart a connection to the
392 * same server association as described in section 4.2.8 of the DTLS RFC
393 */
394 virtual bool allow_dtls_epoch0_restart() const;
395
396 /**
397 * Return allowed ciphersuites, in order of preference for the provided
398 * protocol version.
399 *
400 * @param version the exact protocol version to select supported and allowed
401 * ciphersuites for
402 */
403 virtual std::vector<uint16_t> ciphersuite_list(Protocol_Version version) const;
404
405 /**
406 * @return the default MTU for DTLS
407 */
408 virtual size_t dtls_default_mtu() const;
409
410 /**
411 * @return the initial timeout for DTLS
412 */
413 virtual size_t dtls_initial_timeout() const;
414
415 /**
416 * @return the maximum timeout for DTLS
417 */
418 virtual size_t dtls_maximum_timeout() const;
419
420 /**
421 * @return the maximum size of the certificate chain, in bytes.
422 * Return 0 to disable this and accept any size.
423 */
424 virtual size_t maximum_certificate_chain_size() const;
425
426 /**
427 * @note Has no effect for TLS 1.3 connections.
428 */
429 virtual bool allow_resumption_for_renegotiation() const;
430
431 /**
432 * Defines whether or not the middlebox compatibility mode should be
433 * used. Enabled by default.
434 *
435 * RFC 8446 Appendix D.4
436 * [This makes] the TLS 1.3 handshake resemble TLS 1.2 session resumption,
437 * which improves the chance of successfully connecting through middleboxes.
438 *
439 * @note Has an effect on TLS 1.3 connections, only.
440 */
441 virtual bool tls_13_middlebox_compatibility_mode() const;
442
443 /**
444 * Hash the RNG output for the client/server hello random. This is a pre-caution
445 * to avoid writing "raw" RNG output to the wire.
446 *
447 * There's not normally a reason to disable this, except when deterministic output
448 * is required for testing.
449 */
450 virtual bool hash_hello_random() const;
451
452 /**
453 * Convert this policy to a printable format.
454 * @param o stream to be printed to
455 */
456 virtual void print(std::ostream& o) const;
457
458 /**
459 * Convert this policy to a printable format.
460 * Same as calling `print` on a ostringstream and reading o.str()
461 */
462 std::string to_string() const;
463
464 virtual ~Policy() = default;
465};
466
468
469/**
470* NSA Suite B 128-bit security level (RFC 6460)
471*
472* @warning As of August 2015 NSA indicated only the 192-bit Suite B
473* should be used for all classification levels.
474*/
476 public:
477 std::vector<std::string> allowed_ciphers() const override { return std::vector<std::string>({"AES-128/GCM"}); }
478
479 std::vector<std::string> allowed_signature_hashes() const override {
480 return std::vector<std::string>({"SHA-256"});
481 }
482
483 std::vector<std::string> allowed_macs() const override { return std::vector<std::string>({"AEAD"}); }
484
485 std::vector<std::string> allowed_key_exchange_methods() const override {
486 return std::vector<std::string>({"ECDH"});
487 }
488
489 std::vector<std::string> allowed_signature_methods() const override {
490 return std::vector<std::string>({"ECDSA"});
491 }
492
493 std::vector<Group_Params> key_exchange_groups() const override { return {Group_Params::SECP256R1}; }
494
495 size_t minimum_signature_strength() const override { return 128; }
496
497 bool allow_tls12() const override { return true; }
498
499 bool allow_tls13() const override { return false; }
500
501 bool allow_dtls12() const override { return false; }
502};
503
504/**
505* NSA Suite B 192-bit security level (RFC 6460)
506*/
508 public:
509 std::vector<std::string> allowed_ciphers() const override { return std::vector<std::string>({"AES-256/GCM"}); }
510
511 std::vector<std::string> allowed_signature_hashes() const override {
512 return std::vector<std::string>({"SHA-384"});
513 }
514
515 std::vector<std::string> allowed_macs() const override { return std::vector<std::string>({"AEAD"}); }
516
517 std::vector<std::string> allowed_key_exchange_methods() const override {
518 return std::vector<std::string>({"ECDH"});
519 }
520
521 std::vector<std::string> allowed_signature_methods() const override {
522 return std::vector<std::string>({"ECDSA"});
523 }
524
525 std::vector<Group_Params> key_exchange_groups() const override { return {Group_Params::SECP384R1}; }
526
527 size_t minimum_signature_strength() const override { return 192; }
528
529 bool allow_tls12() const override { return true; }
530
531 bool allow_tls13() const override { return false; }
532
533 bool allow_dtls12() const override { return false; }
534};
535
536/**
537* BSI TR-02102-2 Policy
538*/
540 public:
541 std::vector<std::string> allowed_ciphers() const override {
542 return std::vector<std::string>(
543 {"AES-256/GCM", "AES-128/GCM", "AES-256/CCM", "AES-128/CCM", "AES-256", "AES-128"});
544 }
545
546 std::vector<std::string> allowed_signature_hashes() const override {
547 return std::vector<std::string>({"SHA-512", "SHA-384", "SHA-256"});
548 }
549
550 std::vector<std::string> allowed_macs() const override {
551 return std::vector<std::string>({"AEAD", "SHA-384", "SHA-256"});
552 }
553
554 std::vector<std::string> allowed_key_exchange_methods() const override {
555 return std::vector<std::string>({"ECDH", "DH", "ECDHE_PSK"});
556 }
557
558 std::vector<std::string> allowed_signature_methods() const override {
559 return std::vector<std::string>({"ECDSA", "RSA", "DSA"});
560 }
561
562 std::vector<Group_Params> key_exchange_groups() const override {
563 return std::vector<Group_Params>({Group_Params::BRAINPOOL512R1,
564 Group_Params::BRAINPOOL384R1,
565 Group_Params::BRAINPOOL256R1,
566 Group_Params::SECP521R1,
567 Group_Params::SECP384R1,
568 Group_Params::SECP256R1,
569 Group_Params::FFDHE_4096,
570 Group_Params::FFDHE_3072});
571 }
572
573 size_t minimum_signature_strength() const override { return 120; }
574
575 bool allow_insecure_renegotiation() const override { return false; }
576
577 bool allow_server_initiated_renegotiation() const override { return true; }
578
579 bool server_uses_own_ciphersuite_preferences() const override { return true; }
580
581 bool negotiate_encrypt_then_mac() const override { return true; }
582
583 size_t minimum_rsa_bits() const override { return 3000; }
584
585 size_t minimum_dh_group_size() const override { return 3000; }
586
587 size_t minimum_ecdh_group_size() const override { return 250; }
588
589 size_t minimum_ecdsa_group_size() const override { return 250; }
590
591 bool allow_tls12() const override { return true; }
592
593 bool allow_tls13() const override { return true; }
594
595 bool allow_dtls12() const override { return false; }
596};
597
598/**
599* Policy for DTLS. We require DTLS v1.2 and an AEAD mode.
600*/
602 public:
603 std::vector<std::string> allowed_macs() const override { return std::vector<std::string>({"AEAD"}); }
604
605 bool allow_tls12() const override { return false; }
606
607 bool allow_tls13() const override { return false; }
608
609 bool allow_dtls12() const override { return true; }
610};
611
612/*
613* This policy requires a secure version of TLS and disables all insecure
614* algorithms. It is compatible with other botan TLSes (including those using the
615* default policy) and with many other recent implementations. It is a great idea
616* to use if you control both sides of the protocol and don't have to worry
617* about ancient and/or bizarre TLS implementations.
618*/
620 public:
621 std::vector<std::string> allowed_ciphers() const override;
622
623 std::vector<std::string> allowed_signature_hashes() const override;
624
625 std::vector<std::string> allowed_macs() const override;
626
627 std::vector<std::string> allowed_key_exchange_methods() const override;
628};
629
630class BOTAN_PUBLIC_API(2, 0) Text_Policy : public Policy {
631 public:
632 std::vector<std::string> allowed_ciphers() const override;
633
634 std::vector<std::string> allowed_signature_hashes() const override;
635
636 std::vector<std::string> allowed_macs() const override;
637
638 std::vector<std::string> allowed_key_exchange_methods() const override;
639
640 std::vector<std::string> allowed_signature_methods() const override;
641
642 std::vector<Group_Params> key_exchange_groups() const override;
643
644 std::vector<Group_Params> key_exchange_groups_to_offer() const override;
645
646 bool use_ecc_point_compression() const override;
647
648 bool allow_tls12() const override;
649
650 bool allow_tls13() const override;
651
652 bool allow_dtls12() const override;
653
654 bool allow_insecure_renegotiation() const override;
655
656 bool include_time_in_hello_random() const override;
657
658 bool allow_client_initiated_renegotiation() const override;
659 bool allow_server_initiated_renegotiation() const override;
660
661 bool server_uses_own_ciphersuite_preferences() const override;
662
663 bool negotiate_encrypt_then_mac() const override;
664
665 std::optional<uint16_t> record_size_limit() const override;
666
667 bool support_cert_status_message() const override;
668
669 bool require_client_certificate_authentication() const override;
670
671 std::vector<Certificate_Type> accepted_client_certificate_types() const override;
672 std::vector<Certificate_Type> accepted_server_certificate_types() const override;
673
674 size_t minimum_ecdh_group_size() const override;
675
676 size_t minimum_ecdsa_group_size() const override;
677
678 size_t minimum_dh_group_size() const override;
679
680 size_t minimum_rsa_bits() const override;
681
682 size_t minimum_signature_strength() const override;
683
684 size_t dtls_default_mtu() const override;
685
686 size_t dtls_initial_timeout() const override;
687
688 size_t dtls_maximum_timeout() const override;
689
690 bool require_cert_revocation_info() const override;
691
692 bool hide_unknown_users() const override;
693
694 size_t maximum_session_tickets_per_client_hello() const override;
695
696 std::chrono::seconds session_ticket_lifetime() const override;
697
698 bool reuse_session_tickets() const override;
699
700 size_t new_session_tickets_upon_handshake_success() const override;
701
702 bool tls_13_middlebox_compatibility_mode() const override;
703
704 bool hash_hello_random() const override;
705
706 std::vector<uint16_t> srtp_profiles() const override;
707
708 void set(const std::string& key, const std::string& value);
709
710 explicit Text_Policy(std::string_view s);
711
712 explicit Text_Policy(std::istream& in);
713
714 protected:
715 std::vector<std::string> get_list(const std::string& key, const std::vector<std::string>& def) const;
716
717 std::vector<Group_Params> read_group_list(std::string_view group_str) const;
718 std::vector<Certificate_Type> read_cert_type_list(const std::string& cert_type_str) const;
719
720 size_t get_len(const std::string& key, size_t def) const;
721
722 std::chrono::seconds get_duration(const std::string& key, std::chrono::seconds def) const;
723
724 bool get_bool(const std::string& key, bool def) const;
725
726 std::string get_str(const std::string& key, const std::string& def = "") const;
727
728 bool set_value(const std::string& key, std::string_view val, bool overwrite);
729
730 private:
731 std::map<std::string, std::string> m_kv;
732};
733
734} // namespace TLS
735
736} // namespace Botan
737
738#endif
bool allow_dtls12() const override
Definition tls_policy.h:595
size_t minimum_ecdh_group_size() const override
Definition tls_policy.h:587
std::vector< std::string > allowed_signature_hashes() const override
Definition tls_policy.h:546
bool negotiate_encrypt_then_mac() const override
Definition tls_policy.h:581
std::vector< std::string > allowed_ciphers() const override
Definition tls_policy.h:541
std::vector< std::string > allowed_signature_methods() const override
Definition tls_policy.h:558
bool allow_server_initiated_renegotiation() const override
Definition tls_policy.h:577
bool server_uses_own_ciphersuite_preferences() const override
Definition tls_policy.h:579
bool allow_tls12() const override
Definition tls_policy.h:591
std::vector< std::string > allowed_macs() const override
Definition tls_policy.h:550
size_t minimum_rsa_bits() const override
Definition tls_policy.h:583
bool allow_tls13() const override
Definition tls_policy.h:593
std::vector< Group_Params > key_exchange_groups() const override
Definition tls_policy.h:562
size_t minimum_dh_group_size() const override
Definition tls_policy.h:585
bool allow_insecure_renegotiation() const override
Definition tls_policy.h:575
size_t minimum_ecdsa_group_size() const override
Definition tls_policy.h:589
std::vector< std::string > allowed_key_exchange_methods() const override
Definition tls_policy.h:554
size_t minimum_signature_strength() const override
Definition tls_policy.h:573
bool allow_dtls12() const override
Definition tls_policy.h:609
bool allow_tls13() const override
Definition tls_policy.h:607
bool allow_tls12() const override
Definition tls_policy.h:605
std::vector< std::string > allowed_macs() const override
Definition tls_policy.h:603
std::vector< std::string > allowed_macs() const override
Definition tls_policy.h:483
bool allow_dtls12() const override
Definition tls_policy.h:501
std::vector< Group_Params > key_exchange_groups() const override
Definition tls_policy.h:493
size_t minimum_signature_strength() const override
Definition tls_policy.h:495
std::vector< std::string > allowed_signature_methods() const override
Definition tls_policy.h:489
std::vector< std::string > allowed_key_exchange_methods() const override
Definition tls_policy.h:485
std::vector< std::string > allowed_signature_hashes() const override
Definition tls_policy.h:479
std::vector< std::string > allowed_ciphers() const override
Definition tls_policy.h:477
bool allow_tls12() const override
Definition tls_policy.h:497
bool allow_tls13() const override
Definition tls_policy.h:499
std::vector< Group_Params > key_exchange_groups() const override
Definition tls_policy.h:525
bool allow_tls12() const override
Definition tls_policy.h:529
bool allow_tls13() const override
Definition tls_policy.h:531
std::vector< std::string > allowed_macs() const override
Definition tls_policy.h:515
bool allow_dtls12() const override
Definition tls_policy.h:533
std::vector< std::string > allowed_ciphers() const override
Definition tls_policy.h:509
std::vector< std::string > allowed_key_exchange_methods() const override
Definition tls_policy.h:517
size_t minimum_signature_strength() const override
Definition tls_policy.h:527
std::vector< std::string > allowed_signature_methods() const override
Definition tls_policy.h:521
std::vector< std::string > allowed_signature_hashes() const override
Definition tls_policy.h:511
virtual ~Policy()=default
#define BOTAN_PUBLIC_API(maj, min)
Definition compiler.h:31
Policy Default_Policy
Definition tls_policy.h:467