24648292556

Committed 19 Apr 2026 10:53PM UTC coverage: 89.474% (+0.03%) from 89.442%

Build # 24648292556

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #5536 from randombit/jack/x509-misc

Various PKIX optimizations and bug fixes

Coverage Stats

106453 of 118977 relevant lines covered (89.47%)

11452293.24 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

59.92

/src/lib/tls/tls_algos.cpp

/*
* (C) 2017 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include <botan/tls_algos.h>

#include <botan/exceptn.h>
#include <botan/internal/fmt.h>

#include <algorithm>
#include <array>

namespace Botan::TLS {

std::string kdf_algo_to_string(KDF_Algo algo) {
   switch(algo) {
      case KDF_Algo::SHA_1:
         return "SHA-1";
      case KDF_Algo::SHA_256:
         return "SHA-256";
      case KDF_Algo::SHA_384:
         return "SHA-384";
   }

   throw Invalid_State("kdf_algo_to_string unknown enum value");
}

std::string kex_method_to_string(Kex_Algo method) {
   switch(method) {
      case Kex_Algo::STATIC_RSA:
         return "RSA";
      case Kex_Algo::DH:
         return "DH";
      case Kex_Algo::ECDH:
         return "ECDH";
      case Kex_Algo::PSK:
         return "PSK";
      case Kex_Algo::ECDHE_PSK:
         return "ECDHE_PSK";
      case Kex_Algo::DHE_PSK:
         return "DHE_PSK";
      case Kex_Algo::KEM:
         return "KEM";
      case Kex_Algo::KEM_PSK:
         return "KEM_PSK";
      case Kex_Algo::HYBRID:
         return "HYBRID";
      case Kex_Algo::HYBRID_PSK:
         return "HYBRID_PSK";
      case Kex_Algo::UNDEFINED:
         return "UNDEFINED";
   }

   throw Invalid_State("kex_method_to_string unknown enum value");
}

Kex_Algo kex_method_from_string(std::string_view str) {
   if(str == "RSA") {
      return Kex_Algo::STATIC_RSA;
   }

   if(str == "DH") {
      return Kex_Algo::DH;
   }

   if(str == "ECDH") {
      return Kex_Algo::ECDH;
   }

   if(str == "PSK") {
      return Kex_Algo::PSK;
   }

   if(str == "ECDHE_PSK") {
      return Kex_Algo::ECDHE_PSK;
   }

   if(str == "DHE_PSK") {
      return Kex_Algo::DHE_PSK;
   }

   if(str == "KEM") {
      return Kex_Algo::KEM;
   }

   if(str == "KEM_PSK") {
      return Kex_Algo::KEM_PSK;
   }

   if(str == "HYBRID") {
      return Kex_Algo::HYBRID;
   }

   if(str == "HYBRID_PSK") {
      return Kex_Algo::HYBRID_PSK;
   }

   if(str == "UNDEFINED") {
      return Kex_Algo::UNDEFINED;
   }

   throw Invalid_Argument(fmt("Unknown kex method '{}'", str));
}

std::string auth_method_to_string(Auth_Method method) {
   switch(method) {
      case Auth_Method::RSA:
         return "RSA";
      case Auth_Method::ECDSA:
         return "ECDSA";
      case Auth_Method::IMPLICIT:
         return "IMPLICIT";
      case Auth_Method::UNDEFINED:
         return "UNDEFINED";
   }

   throw Invalid_State("auth_method_to_string unknown enum value");
}

Auth_Method auth_method_from_string(std::string_view str) {
   if(str == "RSA") {
      return Auth_Method::RSA;
   }
   if(str == "ECDSA") {
      return Auth_Method::ECDSA;
   }
   if(str == "IMPLICIT") {
      return Auth_Method::IMPLICIT;
   }
   if(str == "UNDEFINED") {
      return Auth_Method::UNDEFINED;
   }

   throw Invalid_Argument(fmt("Unknown TLS signature method '{}'", str));
}

namespace {

consteval auto available_group_params() {
   auto codes = std::array {
#if defined(BOTAN_HAS_PCURVES_SECP256R1) || defined(BOTAN_HAS_PCURVES_GENERIC)
      Group_Params_Code::SECP256R1,
#endif

#if defined(BOTAN_HAS_PCURVES_SECP384R1) || defined(BOTAN_HAS_PCURVES_GENERIC)
         Group_Params_Code::SECP384R1,
#endif

#if defined(BOTAN_HAS_PCURVES_SECP521R1) || defined(BOTAN_HAS_PCURVES_GENERIC)
         Group_Params_Code::SECP521R1,
#endif

#if defined(BOTAN_HAS_PCURVES_BRAINPOOL256R1) || defined(BOTAN_HAS_PCURVES_GENERIC)
         Group_Params_Code::BRAINPOOL256R1,
#endif

#if defined(BOTAN_HAS_PCURVES_BRAINPOOL384R1) || defined(BOTAN_HAS_PCURVES_GENERIC)
         Group_Params_Code::BRAINPOOL384R1,
#endif

#if defined(BOTAN_HAS_PCURVES_BRAINPOOL512R1) || defined(BOTAN_HAS_PCURVES_GENERIC)
         Group_Params_Code::BRAINPOOL512R1,
#endif

#if defined(BOTAN_HAS_X25519)
         Group_Params_Code::X25519,
#endif

#if defined(BOTAN_HAS_X448)
         Group_Params_Code::X448,
#endif

#if defined(BOTAN_HAS_DIFFIE_HELLMAN)
         Group_Params_Code::FFDHE_2048, Group_Params_Code::FFDHE_3072, Group_Params_Code::FFDHE_4096,
         Group_Params_Code::FFDHE_6144, Group_Params_Code::FFDHE_8192,
#endif

#if defined(BOTAN_HAS_ML_KEM)
         Group_Params_Code::ML_KEM_512, Group_Params_Code::ML_KEM_768, Group_Params_Code::ML_KEM_1024,

   #if defined(BOTAN_HAS_PCURVES_SECP256R1) || defined(BOTAN_HAS_PCURVES_GENERIC)
         Group_Params_Code::HYBRID_SECP256R1_ML_KEM_768,
   #endif

   #if defined(BOTAN_HAS_PCURVES_SECP384R1) || defined(BOTAN_HAS_PCURVES_GENERIC)
         Group_Params_Code::HYBRID_SECP384R1_ML_KEM_1024,
   #endif

   #if defined(BOTAN_HAS_X25519)
         Group_Params_Code::HYBRID_X25519_ML_KEM_768,
   #endif
#endif

#if defined(BOTAN_HAS_FRODOKEM)
         Group_Params_Code::eFRODOKEM_640_SHAKE_OQS, Group_Params_Code::eFRODOKEM_976_SHAKE_OQS,
         Group_Params_Code::eFRODOKEM_1344_SHAKE_OQS, Group_Params_Code::eFRODOKEM_640_AES_OQS,
         Group_Params_Code::eFRODOKEM_976_AES_OQS, Group_Params_Code::eFRODOKEM_1344_AES_OQS,

   #if defined(BOTAN_HAS_PCURVES_SECP256R1) || defined(BOTAN_HAS_PCURVES_GENERIC)
         Group_Params_Code::HYBRID_SECP256R1_eFRODOKEM_640_SHAKE_OQS,
         Group_Params_Code::HYBRID_SECP256R1_eFRODOKEM_640_AES_OQS,
   #endif

   #if defined(BOTAN_HAS_PCURVES_SECP384R1) || defined(BOTAN_HAS_PCURVES_GENERIC)
         Group_Params_Code::HYBRID_SECP384R1_eFRODOKEM_976_SHAKE_OQS,
         Group_Params_Code::HYBRID_SECP384R1_eFRODOKEM_976_AES_OQS,
   #endif

   #if defined(BOTAN_HAS_PCURVES_SECP521R1) || defined(BOTAN_HAS_PCURVES_GENERIC)
         Group_Params_Code::HYBRID_SECP521R1_eFRODOKEM_1344_SHAKE_OQS,
         Group_Params_Code::HYBRID_SECP521R1_eFRODOKEM_1344_AES_OQS,
   #endif

   #if defined(BOTAN_HAS_X25519)
         Group_Params_Code::HYBRID_X25519_eFRODOKEM_640_SHAKE_OQS,
         Group_Params_Code::HYBRID_X25519_eFRODOKEM_640_AES_OQS,
   #endif

   #if defined(BOTAN_HAS_X448)
         Group_Params_Code::HYBRID_X448_eFRODOKEM_976_SHAKE_OQS, Group_Params_Code::HYBRID_X448_eFRODOKEM_976_AES_OQS,
   #endif
#endif
   };

   std::sort(codes.begin(), codes.end());

   return codes;
}

}  // namespace

bool Group_Params::is_available() const {
   // For group codes we recognize, check the build-time availability table.
   // Unknown codes may be user-supplied custom groups handled via callbacks.
   if(to_string().has_value()) {
      static constexpr auto codes = available_group_params();
      return std::binary_search(codes.begin(), codes.end(), this->code());
   }
   return true;
}

std::optional<Group_Params_Code> Group_Params::pqc_hybrid_ecc() const {
   switch(m_code) {
      case Group_Params_Code::HYBRID_X25519_ML_KEM_768:

      case Group_Params_Code::HYBRID_X25519_eFRODOKEM_640_SHAKE_OQS:
      case Group_Params_Code::HYBRID_X25519_eFRODOKEM_640_AES_OQS:
         return Group_Params_Code::X25519;

      case Group_Params_Code::HYBRID_X448_eFRODOKEM_976_SHAKE_OQS:
      case Group_Params_Code::HYBRID_X448_eFRODOKEM_976_AES_OQS:
         return Group_Params_Code::X448;

      case Group_Params_Code::HYBRID_SECP256R1_ML_KEM_768:
      case Group_Params_Code::HYBRID_SECP256R1_eFRODOKEM_640_SHAKE_OQS:
      case Group_Params_Code::HYBRID_SECP256R1_eFRODOKEM_640_AES_OQS:
         return Group_Params_Code::SECP256R1;

      case Group_Params_Code::HYBRID_SECP384R1_ML_KEM_1024:
      case Group_Params_Code::HYBRID_SECP384R1_eFRODOKEM_976_SHAKE_OQS:
      case Group_Params_Code::HYBRID_SECP384R1_eFRODOKEM_976_AES_OQS:
         return Group_Params_Code::SECP384R1;

      case Group_Params_Code::HYBRID_SECP521R1_eFRODOKEM_1344_SHAKE_OQS:
      case Group_Params_Code::HYBRID_SECP521R1_eFRODOKEM_1344_AES_OQS:
         return Group_Params_Code::SECP521R1;

      default:
         return {};
   }
}

std::optional<Group_Params> Group_Params::from_string(std::string_view group_name) {
   if(group_name == "secp256r1") {
      return Group_Params::SECP256R1;
   }
   if(group_name == "secp384r1") {
      return Group_Params::SECP384R1;
   }
   if(group_name == "secp521r1") {
      return Group_Params::SECP521R1;
   }
   if(group_name == "brainpool256r1") {
      return Group_Params::BRAINPOOL256R1;
   }
   if(group_name == "brainpool384r1") {
      return Group_Params::BRAINPOOL384R1;
   }
   if(group_name == "brainpool512r1") {
      return Group_Params::BRAINPOOL512R1;
   }
   if(group_name == "x25519") {
      return Group_Params::X25519;
   }
   if(group_name == "x448") {
      return Group_Params::X448;
   }

   if(group_name == "ffdhe/ietf/2048") {
      return Group_Params::FFDHE_2048;
   }
   if(group_name == "ffdhe/ietf/3072") {
      return Group_Params::FFDHE_3072;
   }
   if(group_name == "ffdhe/ietf/4096") {
      return Group_Params::FFDHE_4096;
   }
   if(group_name == "ffdhe/ietf/6144") {
      return Group_Params::FFDHE_6144;
   }
   if(group_name == "ffdhe/ietf/8192") {
      return Group_Params::FFDHE_8192;
   }

   if(group_name == "ML-KEM-512") {
      return Group_Params::ML_KEM_512;
   }
   if(group_name == "ML-KEM-768") {
      return Group_Params::ML_KEM_768;
   }
   if(group_name == "ML-KEM-1024") {
      return Group_Params::ML_KEM_1024;
   }

   if(group_name == "eFrodoKEM-640-SHAKE") {
      return Group_Params::eFRODOKEM_640_SHAKE_OQS;
   }
   if(group_name == "eFrodoKEM-976-SHAKE") {
      return Group_Params::eFRODOKEM_976_SHAKE_OQS;
   }
   if(group_name == "eFrodoKEM-1344-SHAKE") {
      return Group_Params::eFRODOKEM_1344_SHAKE_OQS;
   }
   if(group_name == "eFrodoKEM-640-AES") {
      return Group_Params::eFRODOKEM_640_AES_OQS;
   }
   if(group_name == "eFrodoKEM-976-AES") {
      return Group_Params::eFRODOKEM_976_AES_OQS;
   }
   if(group_name == "eFrodoKEM-1344-AES") {
      return Group_Params::eFRODOKEM_1344_AES_OQS;
   }

   if(group_name == "x25519/ML-KEM-768") {
      return Group_Params::HYBRID_X25519_ML_KEM_768;
   }
   if(group_name == "secp256r1/ML-KEM-768") {
      return Group_Params::HYBRID_SECP256R1_ML_KEM_768;
   }
   if(group_name == "secp384r1/ML-KEM-1024") {
      return Group_Params::HYBRID_SECP384R1_ML_KEM_1024;
   }

   if(group_name == "x25519/eFrodoKEM-640-SHAKE") {
      return Group_Params::HYBRID_X25519_eFRODOKEM_640_SHAKE_OQS;
   }
   if(group_name == "x25519/eFrodoKEM-640-AES") {
      return Group_Params::HYBRID_X25519_eFRODOKEM_640_AES_OQS;
   }
   if(group_name == "x448/eFrodoKEM-976-SHAKE") {
      return Group_Params::HYBRID_X448_eFRODOKEM_976_SHAKE_OQS;
   }
   if(group_name == "x448/eFrodoKEM-976-AES") {
      return Group_Params::HYBRID_X448_eFRODOKEM_976_AES_OQS;
   }

   if(group_name == "secp256r1/eFrodoKEM-640-SHAKE") {
      return Group_Params::HYBRID_SECP256R1_eFRODOKEM_640_SHAKE_OQS;
   }
   if(group_name == "secp256r1/eFrodoKEM-640-AES") {
      return Group_Params::HYBRID_SECP256R1_eFRODOKEM_640_AES_OQS;
   }

   if(group_name == "secp384r1/eFrodoKEM-976-SHAKE") {
      return Group_Params::HYBRID_SECP384R1_eFRODOKEM_976_SHAKE_OQS;
   }
   if(group_name == "secp384r1/eFrodoKEM-976-AES") {
      return Group_Params::HYBRID_SECP384R1_eFRODOKEM_976_AES_OQS;
   }

   if(group_name == "secp521r1/eFrodoKEM-1344-SHAKE") {
      return Group_Params::HYBRID_SECP521R1_eFRODOKEM_1344_SHAKE_OQS;
   }
   if(group_name == "secp521r1/eFrodoKEM-1344-AES") {
      return Group_Params::HYBRID_SECP521R1_eFRODOKEM_1344_AES_OQS;
   }

   return std::nullopt;
}

std::optional<std::string> Group_Params::to_string() const {
   switch(m_code) {
      case Group_Params::SECP256R1:
         return "secp256r1";
      case Group_Params::SECP384R1:
         return "secp384r1";
      case Group_Params::SECP521R1:
         return "secp521r1";
      case Group_Params::BRAINPOOL256R1:
         return "brainpool256r1";
      case Group_Params::BRAINPOOL384R1:
         return "brainpool384r1";
      case Group_Params::BRAINPOOL512R1:
         return "brainpool512r1";
      case Group_Params::X25519:
         return "x25519";
      case Group_Params::X448:
         return "x448";

      case Group_Params::FFDHE_2048:
         return "ffdhe/ietf/2048";
      case Group_Params::FFDHE_3072:
         return "ffdhe/ietf/3072";
      case Group_Params::FFDHE_4096:
         return "ffdhe/ietf/4096";
      case Group_Params::FFDHE_6144:
         return "ffdhe/ietf/6144";
      case Group_Params::FFDHE_8192:
         return "ffdhe/ietf/8192";

      case Group_Params::ML_KEM_512:
         return "ML-KEM-512";
      case Group_Params::ML_KEM_768:
         return "ML-KEM-768";
      case Group_Params::ML_KEM_1024:
         return "ML-KEM-1024";

      case Group_Params::eFRODOKEM_640_SHAKE_OQS:
         return "eFrodoKEM-640-SHAKE";
      case Group_Params::eFRODOKEM_976_SHAKE_OQS:
         return "eFrodoKEM-976-SHAKE";
      case Group_Params::eFRODOKEM_1344_SHAKE_OQS:
         return "eFrodoKEM-1344-SHAKE";
      case Group_Params::eFRODOKEM_640_AES_OQS:
         return "eFrodoKEM-640-AES";
      case Group_Params::eFRODOKEM_976_AES_OQS:
         return "eFrodoKEM-976-AES";
      case Group_Params::eFRODOKEM_1344_AES_OQS:
         return "eFrodoKEM-1344-AES";

      case Group_Params::HYBRID_X25519_eFRODOKEM_640_SHAKE_OQS:
         return "x25519/eFrodoKEM-640-SHAKE";
      case Group_Params::HYBRID_X25519_eFRODOKEM_640_AES_OQS:
         return "x25519/eFrodoKEM-640-AES";
      case Group_Params::HYBRID_X448_eFRODOKEM_976_SHAKE_OQS:
         return "x448/eFrodoKEM-976-SHAKE";
      case Group_Params::HYBRID_X448_eFRODOKEM_976_AES_OQS:
         return "x448/eFrodoKEM-976-AES";
      case Group_Params::HYBRID_SECP256R1_eFRODOKEM_640_SHAKE_OQS:
         return "secp256r1/eFrodoKEM-640-SHAKE";
      case Group_Params::HYBRID_SECP256R1_eFRODOKEM_640_AES_OQS:
         return "secp256r1/eFrodoKEM-640-AES";
      case Group_Params::HYBRID_SECP384R1_eFRODOKEM_976_SHAKE_OQS:
         return "secp384r1/eFrodoKEM-976-SHAKE";
      case Group_Params::HYBRID_SECP384R1_eFRODOKEM_976_AES_OQS:
         return "secp384r1/eFrodoKEM-976-AES";
      case Group_Params::HYBRID_SECP521R1_eFRODOKEM_1344_SHAKE_OQS:
         return "secp521r1/eFrodoKEM-1344-SHAKE";
      case Group_Params::HYBRID_SECP521R1_eFRODOKEM_1344_AES_OQS:
         return "secp521r1/eFrodoKEM-1344-AES";

      case Group_Params::HYBRID_X25519_ML_KEM_768:
         return "x25519/ML-KEM-768";
      case Group_Params::HYBRID_SECP256R1_ML_KEM_768:
         return "secp256r1/ML-KEM-768";
      case Group_Params::HYBRID_SECP384R1_ML_KEM_1024:
         return "secp384r1/ML-KEM-1024";

      default:
         return std::nullopt;
   }
}

std::string certificate_type_to_string(Certificate_Type type) {
   switch(type) {
      case Certificate_Type::X509:
         return "X509";
      case Certificate_Type::RawPublicKey:
         return "RawPublicKey";
   }

   return "Unknown";
}

Certificate_Type certificate_type_from_string(const std::string& type_str) {
   if(type_str == "X509") {
      return Certificate_Type::X509;
   } else if(type_str == "RawPublicKey") {
      return Certificate_Type::RawPublicKey;
   } else {
      throw Decoding_Error("Unknown certificate type: " + type_str);
   }
}

}  // namespace Botan::TLS

1	/*
2	* (C) 2017 Jack Lloyd
3	*
4	* Botan is released under the Simplified BSD License (see license.txt)
5	*/
6
7	#include <botan/tls_algos.h>
8
9	#include <botan/exceptn.h>
10	#include <botan/internal/fmt.h>
11
12	#include <algorithm>
13	#include <array>
14
15	namespace Botan::TLS {
16
17	std::string kdf_algo_to_string(KDF_Algo algo) {	244,185✔
18	switch(algo) {	244,185✔
19	case KDF_Algo::SHA_1:	50,771✔
20	return "SHA-1";	50,771✔
21	case KDF_Algo::SHA_256:	140,326✔
22	return "SHA-256";	140,326✔
23	case KDF_Algo::SHA_384:	53,088✔
24	return "SHA-384";	53,088✔
25	}
26
27	throw Invalid_State("kdf_algo_to_string unknown enum value");	×
28	}
29
30	std::string kex_method_to_string(Kex_Algo method) {	8,550✔
31	switch(method) {	8,550✔
32	case Kex_Algo::STATIC_RSA:	703✔
33	return "RSA";	703✔
34	case Kex_Algo::DH:	1,167✔
35	return "DH";	1,167✔
36	case Kex_Algo::ECDH:	4,692✔
37	return "ECDH";	4,692✔
38	case Kex_Algo::PSK:	982✔
39	return "PSK";	982✔
40	case Kex_Algo::ECDHE_PSK:	965✔
41	return "ECDHE_PSK";	965✔
42	case Kex_Algo::DHE_PSK:	×
43	return "DHE_PSK";	×
44	case Kex_Algo::KEM:	8✔
45	return "KEM";	8✔
46	case Kex_Algo::KEM_PSK:	×
47	return "KEM_PSK";	×
48	case Kex_Algo::HYBRID:	31✔
49	return "HYBRID";	31✔
50	case Kex_Algo::HYBRID_PSK:	2✔
51	return "HYBRID_PSK";	2✔
52	case Kex_Algo::UNDEFINED:	×
53	return "UNDEFINED";	×
54	}
55
56	throw Invalid_State("kex_method_to_string unknown enum value");	×
57	}
58
59	Kex_Algo kex_method_from_string(std::string_view str) {	5✔
60	if(str == "RSA") {	5✔
61	return Kex_Algo::STATIC_RSA;	1✔
62	}
63
64	if(str == "DH") {	4✔
65	return Kex_Algo::DH;	1✔
66	}
67
68	if(str == "ECDH") {	3✔
69	return Kex_Algo::ECDH;	1✔
70	}
71
72	if(str == "PSK") {	2✔
73	return Kex_Algo::PSK;	1✔
74	}
75
76	if(str == "ECDHE_PSK") {	1✔
77	return Kex_Algo::ECDHE_PSK;	1✔
78	}
79
80	if(str == "DHE_PSK") {	×
81	return Kex_Algo::DHE_PSK;	×
82	}
83
84	if(str == "KEM") {	×
85	return Kex_Algo::KEM;	×
86	}
87
88	if(str == "KEM_PSK") {	×
89	return Kex_Algo::KEM_PSK;	×
90	}
91
92	if(str == "HYBRID") {	×
93	return Kex_Algo::HYBRID;	×
94	}
95
96	if(str == "HYBRID_PSK") {	×
97	return Kex_Algo::HYBRID_PSK;	×
98	}
99
100	if(str == "UNDEFINED") {	×
101	return Kex_Algo::UNDEFINED;	×
102	}
103
104	throw Invalid_Argument(fmt("Unknown kex method '{}'", str));	×
105	}
106
107	std::string auth_method_to_string(Auth_Method method) {	10,324✔
108	switch(method) {	10,324✔
109	case Auth_Method::RSA:	7,128✔
110	return "RSA";	7,128✔
111	case Auth_Method::ECDSA:	3,028✔
112	return "ECDSA";	3,028✔
113	case Auth_Method::IMPLICIT:	168✔
114	return "IMPLICIT";	168✔
115	case Auth_Method::UNDEFINED:	×
116	return "UNDEFINED";	×
117	}
118
119	throw Invalid_State("auth_method_to_string unknown enum value");	×
120	}
121
122	Auth_Method auth_method_from_string(std::string_view str) {	3✔
123	if(str == "RSA") {	3✔
124	return Auth_Method::RSA;	1✔
125	}
126	if(str == "ECDSA") {	2✔
127	return Auth_Method::ECDSA;	1✔
128	}
129	if(str == "IMPLICIT") {	1✔
130	return Auth_Method::IMPLICIT;	1✔
131	}
132	if(str == "UNDEFINED") {	×
133	return Auth_Method::UNDEFINED;	×
134	}
135
136	throw Invalid_Argument(fmt("Unknown TLS signature method '{}'", str));	×
137	}
138
139	namespace {
140
141	consteval auto available_group_params() {
142	auto codes = std::array {
143	#if defined(BOTAN_HAS_PCURVES_SECP256R1) \|\| defined(BOTAN_HAS_PCURVES_GENERIC)
144	Group_Params_Code::SECP256R1,
145	#endif
146
147	#if defined(BOTAN_HAS_PCURVES_SECP384R1) \|\| defined(BOTAN_HAS_PCURVES_GENERIC)
148	Group_Params_Code::SECP384R1,
149	#endif
150
151	#if defined(BOTAN_HAS_PCURVES_SECP521R1) \|\| defined(BOTAN_HAS_PCURVES_GENERIC)
152	Group_Params_Code::SECP521R1,
153	#endif
154
155	#if defined(BOTAN_HAS_PCURVES_BRAINPOOL256R1) \|\| defined(BOTAN_HAS_PCURVES_GENERIC)
156	Group_Params_Code::BRAINPOOL256R1,
157	#endif
158
159	#if defined(BOTAN_HAS_PCURVES_BRAINPOOL384R1) \|\| defined(BOTAN_HAS_PCURVES_GENERIC)
160	Group_Params_Code::BRAINPOOL384R1,
161	#endif
162
163	#if defined(BOTAN_HAS_PCURVES_BRAINPOOL512R1) \|\| defined(BOTAN_HAS_PCURVES_GENERIC)
164	Group_Params_Code::BRAINPOOL512R1,
165	#endif
166
167	#if defined(BOTAN_HAS_X25519)
168	Group_Params_Code::X25519,
169	#endif
170
171	#if defined(BOTAN_HAS_X448)
172	Group_Params_Code::X448,
173	#endif
174
175	#if defined(BOTAN_HAS_DIFFIE_HELLMAN)
176	Group_Params_Code::FFDHE_2048, Group_Params_Code::FFDHE_3072, Group_Params_Code::FFDHE_4096,
177	Group_Params_Code::FFDHE_6144, Group_Params_Code::FFDHE_8192,
178	#endif
179
180	#if defined(BOTAN_HAS_ML_KEM)
181	Group_Params_Code::ML_KEM_512, Group_Params_Code::ML_KEM_768, Group_Params_Code::ML_KEM_1024,
182
183	#if defined(BOTAN_HAS_PCURVES_SECP256R1) \|\| defined(BOTAN_HAS_PCURVES_GENERIC)
184	Group_Params_Code::HYBRID_SECP256R1_ML_KEM_768,
185	#endif
186
187	#if defined(BOTAN_HAS_PCURVES_SECP384R1) \|\| defined(BOTAN_HAS_PCURVES_GENERIC)
188	Group_Params_Code::HYBRID_SECP384R1_ML_KEM_1024,
189	#endif
190
191	#if defined(BOTAN_HAS_X25519)
192	Group_Params_Code::HYBRID_X25519_ML_KEM_768,
193	#endif
194	#endif
195
196	#if defined(BOTAN_HAS_FRODOKEM)
197	Group_Params_Code::eFRODOKEM_640_SHAKE_OQS, Group_Params_Code::eFRODOKEM_976_SHAKE_OQS,
198	Group_Params_Code::eFRODOKEM_1344_SHAKE_OQS, Group_Params_Code::eFRODOKEM_640_AES_OQS,
199	Group_Params_Code::eFRODOKEM_976_AES_OQS, Group_Params_Code::eFRODOKEM_1344_AES_OQS,
200
201	#if defined(BOTAN_HAS_PCURVES_SECP256R1) \|\| defined(BOTAN_HAS_PCURVES_GENERIC)
202	Group_Params_Code::HYBRID_SECP256R1_eFRODOKEM_640_SHAKE_OQS,
203	Group_Params_Code::HYBRID_SECP256R1_eFRODOKEM_640_AES_OQS,
204	#endif
205
206	#if defined(BOTAN_HAS_PCURVES_SECP384R1) \|\| defined(BOTAN_HAS_PCURVES_GENERIC)
207	Group_Params_Code::HYBRID_SECP384R1_eFRODOKEM_976_SHAKE_OQS,
208	Group_Params_Code::HYBRID_SECP384R1_eFRODOKEM_976_AES_OQS,
209	#endif
210
211	#if defined(BOTAN_HAS_PCURVES_SECP521R1) \|\| defined(BOTAN_HAS_PCURVES_GENERIC)
212	Group_Params_Code::HYBRID_SECP521R1_eFRODOKEM_1344_SHAKE_OQS,
213	Group_Params_Code::HYBRID_SECP521R1_eFRODOKEM_1344_AES_OQS,
214	#endif
215
216	#if defined(BOTAN_HAS_X25519)
217	Group_Params_Code::HYBRID_X25519_eFRODOKEM_640_SHAKE_OQS,
218	Group_Params_Code::HYBRID_X25519_eFRODOKEM_640_AES_OQS,
219	#endif
220
221	#if defined(BOTAN_HAS_X448)
222	Group_Params_Code::HYBRID_X448_eFRODOKEM_976_SHAKE_OQS, Group_Params_Code::HYBRID_X448_eFRODOKEM_976_AES_OQS,
223	#endif
224	#endif
225	};
226
227	std::sort(codes.begin(), codes.end());
228
229	return codes;
230	}
231
232	} // namespace
233
234	bool Group_Params::is_available() const {	1,283✔
235	// For group codes we recognize, check the build-time availability table.
236	// Unknown codes may be user-supplied custom groups handled via callbacks.
237	if(to_string().has_value()) {	2,550✔
238	static constexpr auto codes = available_group_params();	1,267✔
239	return std::binary_search(codes.begin(), codes.end(), this->code());	2,534✔
240	}
241	return true;
242	}
243
244	std::optional<Group_Params_Code> Group_Params::pqc_hybrid_ecc() const {	×
245	switch(m_code) {	×
246	case Group_Params_Code::HYBRID_X25519_ML_KEM_768:	×
247
248	case Group_Params_Code::HYBRID_X25519_eFRODOKEM_640_SHAKE_OQS:	×
249	case Group_Params_Code::HYBRID_X25519_eFRODOKEM_640_AES_OQS:	×
250	return Group_Params_Code::X25519;	×
251
252	case Group_Params_Code::HYBRID_X448_eFRODOKEM_976_SHAKE_OQS:	×
253	case Group_Params_Code::HYBRID_X448_eFRODOKEM_976_AES_OQS:	×
254	return Group_Params_Code::X448;	×
255
256	case Group_Params_Code::HYBRID_SECP256R1_ML_KEM_768:	×
257	case Group_Params_Code::HYBRID_SECP256R1_eFRODOKEM_640_SHAKE_OQS:	×
258	case Group_Params_Code::HYBRID_SECP256R1_eFRODOKEM_640_AES_OQS:	×
259	return Group_Params_Code::SECP256R1;	×
260
261	case Group_Params_Code::HYBRID_SECP384R1_ML_KEM_1024:	×
262	case Group_Params_Code::HYBRID_SECP384R1_eFRODOKEM_976_SHAKE_OQS:	×
263	case Group_Params_Code::HYBRID_SECP384R1_eFRODOKEM_976_AES_OQS:	×
264	return Group_Params_Code::SECP384R1;	×
265
266	case Group_Params_Code::HYBRID_SECP521R1_eFRODOKEM_1344_SHAKE_OQS:	×
267	case Group_Params_Code::HYBRID_SECP521R1_eFRODOKEM_1344_AES_OQS:	×
268	return Group_Params_Code::SECP521R1;	×
269
270	default:	×
271	return {};	×
272	}
273	}
274
275	std::optional<Group_Params> Group_Params::from_string(std::string_view group_name) {	631✔
276	if(group_name == "secp256r1") {	631✔
277	return Group_Params::SECP256R1;	90✔
278	}
279	if(group_name == "secp384r1") {	541✔
280	return Group_Params::SECP384R1;	49✔
281	}
282	if(group_name == "secp521r1") {	492✔
283	return Group_Params::SECP521R1;	44✔
284	}
285	if(group_name == "brainpool256r1") {	448✔
286	return Group_Params::BRAINPOOL256R1;	28✔
287	}
288	if(group_name == "brainpool384r1") {	420✔
289	return Group_Params::BRAINPOOL384R1;	12✔
290	}
291	if(group_name == "brainpool512r1") {	408✔
292	return Group_Params::BRAINPOOL512R1;	12✔
293	}
294	if(group_name == "x25519") {	396✔
295	return Group_Params::X25519;	103✔
296	}
297	if(group_name == "x448") {	293✔
298	return Group_Params::X448;	41✔
299	}
300
301	if(group_name == "ffdhe/ietf/2048") {	252✔
302	return Group_Params::FFDHE_2048;	67✔
303	}
304	if(group_name == "ffdhe/ietf/3072") {	185✔
305	return Group_Params::FFDHE_3072;	28✔
306	}
307	if(group_name == "ffdhe/ietf/4096") {	157✔
308	return Group_Params::FFDHE_4096;	22✔
309	}
310	if(group_name == "ffdhe/ietf/6144") {	135✔
311	return Group_Params::FFDHE_6144;	16✔
312	}
313	if(group_name == "ffdhe/ietf/8192") {	119✔
314	return Group_Params::FFDHE_8192;	16✔
315	}
316
317	if(group_name == "ML-KEM-512") {	103✔
318	return Group_Params::ML_KEM_512;	×
319	}
320	if(group_name == "ML-KEM-768") {	103✔
321	return Group_Params::ML_KEM_768;	30✔
322	}
323	if(group_name == "ML-KEM-1024") {	73✔
324	return Group_Params::ML_KEM_1024;	×
325	}
326
327	if(group_name == "eFrodoKEM-640-SHAKE") {	73✔
328	return Group_Params::eFRODOKEM_640_SHAKE_OQS;	×
329	}
330	if(group_name == "eFrodoKEM-976-SHAKE") {	73✔
331	return Group_Params::eFRODOKEM_976_SHAKE_OQS;	×
332	}
333	if(group_name == "eFrodoKEM-1344-SHAKE") {	73✔
334	return Group_Params::eFRODOKEM_1344_SHAKE_OQS;	×
335	}
336	if(group_name == "eFrodoKEM-640-AES") {	73✔
337	return Group_Params::eFRODOKEM_640_AES_OQS;	×
338	}
339	if(group_name == "eFrodoKEM-976-AES") {	73✔
340	return Group_Params::eFRODOKEM_976_AES_OQS;	×
341	}
342	if(group_name == "eFrodoKEM-1344-AES") {	73✔
343	return Group_Params::eFRODOKEM_1344_AES_OQS;	×
344	}
345
346	if(group_name == "x25519/ML-KEM-768") {	73✔
347	return Group_Params::HYBRID_X25519_ML_KEM_768;	39✔
348	}
349	if(group_name == "secp256r1/ML-KEM-768") {	34✔
350	return Group_Params::HYBRID_SECP256R1_ML_KEM_768;	9✔
351	}
352	if(group_name == "secp384r1/ML-KEM-1024") {	25✔
353	return Group_Params::HYBRID_SECP384R1_ML_KEM_1024;	9✔
354	}
355
356	if(group_name == "x25519/eFrodoKEM-640-SHAKE") {	16✔
357	return Group_Params::HYBRID_X25519_eFRODOKEM_640_SHAKE_OQS;	×
358	}
359	if(group_name == "x25519/eFrodoKEM-640-AES") {	16✔
360	return Group_Params::HYBRID_X25519_eFRODOKEM_640_AES_OQS;	×
361	}
362	if(group_name == "x448/eFrodoKEM-976-SHAKE") {	16✔
363	return Group_Params::HYBRID_X448_eFRODOKEM_976_SHAKE_OQS;	×
364	}
365	if(group_name == "x448/eFrodoKEM-976-AES") {	16✔
366	return Group_Params::HYBRID_X448_eFRODOKEM_976_AES_OQS;	×
367	}
368
369	if(group_name == "secp256r1/eFrodoKEM-640-SHAKE") {	16✔
370	return Group_Params::HYBRID_SECP256R1_eFRODOKEM_640_SHAKE_OQS;	×
371	}
372	if(group_name == "secp256r1/eFrodoKEM-640-AES") {	16✔
373	return Group_Params::HYBRID_SECP256R1_eFRODOKEM_640_AES_OQS;	×
374	}
375
376	if(group_name == "secp384r1/eFrodoKEM-976-SHAKE") {	16✔
377	return Group_Params::HYBRID_SECP384R1_eFRODOKEM_976_SHAKE_OQS;	×
378	}
379	if(group_name == "secp384r1/eFrodoKEM-976-AES") {	16✔
380	return Group_Params::HYBRID_SECP384R1_eFRODOKEM_976_AES_OQS;	×
381	}
382
383	if(group_name == "secp521r1/eFrodoKEM-1344-SHAKE") {	16✔
384	return Group_Params::HYBRID_SECP521R1_eFRODOKEM_1344_SHAKE_OQS;	×
385	}
386	if(group_name == "secp521r1/eFrodoKEM-1344-AES") {	16✔
387	return Group_Params::HYBRID_SECP521R1_eFRODOKEM_1344_AES_OQS;	×
388	}
389
390	return std::nullopt;	16✔
391	}
392
393	std::optional<std::string> Group_Params::to_string() const {	3,024✔
394	switch(m_code) {	3,024✔
395	case Group_Params::SECP256R1:	409✔
396	return "secp256r1";	409✔
397	case Group_Params::SECP384R1:	374✔
398	return "secp384r1";	374✔
399	case Group_Params::SECP521R1:	284✔
400	return "secp521r1";	284✔
401	case Group_Params::BRAINPOOL256R1:	59✔
402	return "brainpool256r1";	59✔
403	case Group_Params::BRAINPOOL384R1:	22✔
404	return "brainpool384r1";	22✔
405	case Group_Params::BRAINPOOL512R1:	29✔
406	return "brainpool512r1";	29✔
407	case Group_Params::X25519:	1,211✔
408	return "x25519";	1,211✔
409	case Group_Params::X448:	49✔
410	return "x448";	49✔
411
412	case Group_Params::FFDHE_2048:	87✔
413	return "ffdhe/ietf/2048";	87✔
414	case Group_Params::FFDHE_3072:	38✔
415	return "ffdhe/ietf/3072";	38✔
416	case Group_Params::FFDHE_4096:	26✔
417	return "ffdhe/ietf/4096";	26✔
418	case Group_Params::FFDHE_6144:	18✔
419	return "ffdhe/ietf/6144";	18✔
420	case Group_Params::FFDHE_8192:	18✔
421	return "ffdhe/ietf/8192";	18✔
422
423	case Group_Params::ML_KEM_512:	×
424	return "ML-KEM-512";	×
425	case Group_Params::ML_KEM_768:	34✔
426	return "ML-KEM-768";	34✔
427	case Group_Params::ML_KEM_1024:	100✔
428	return "ML-KEM-1024";	100✔
429
430	case Group_Params::eFRODOKEM_640_SHAKE_OQS:	×
431	return "eFrodoKEM-640-SHAKE";	×
432	case Group_Params::eFRODOKEM_976_SHAKE_OQS:	×
433	return "eFrodoKEM-976-SHAKE";	×
434	case Group_Params::eFRODOKEM_1344_SHAKE_OQS:	×
435	return "eFrodoKEM-1344-SHAKE";	×
436	case Group_Params::eFRODOKEM_640_AES_OQS:	×
437	return "eFrodoKEM-640-AES";	×
438	case Group_Params::eFRODOKEM_976_AES_OQS:	×
439	return "eFrodoKEM-976-AES";	×
440	case Group_Params::eFRODOKEM_1344_AES_OQS:	×
441	return "eFrodoKEM-1344-AES";	×
442
443	case Group_Params::HYBRID_X25519_eFRODOKEM_640_SHAKE_OQS:	×
444	return "x25519/eFrodoKEM-640-SHAKE";	×
445	case Group_Params::HYBRID_X25519_eFRODOKEM_640_AES_OQS:	×
446	return "x25519/eFrodoKEM-640-AES";	×
447	case Group_Params::HYBRID_X448_eFRODOKEM_976_SHAKE_OQS:	×
448	return "x448/eFrodoKEM-976-SHAKE";	×
449	case Group_Params::HYBRID_X448_eFRODOKEM_976_AES_OQS:	×
450	return "x448/eFrodoKEM-976-AES";	×
451	case Group_Params::HYBRID_SECP256R1_eFRODOKEM_640_SHAKE_OQS:	×
452	return "secp256r1/eFrodoKEM-640-SHAKE";	×
453	case Group_Params::HYBRID_SECP256R1_eFRODOKEM_640_AES_OQS:	×
454	return "secp256r1/eFrodoKEM-640-AES";	×
455	case Group_Params::HYBRID_SECP384R1_eFRODOKEM_976_SHAKE_OQS:	×
456	return "secp384r1/eFrodoKEM-976-SHAKE";	×
457	case Group_Params::HYBRID_SECP384R1_eFRODOKEM_976_AES_OQS:	×
458	return "secp384r1/eFrodoKEM-976-AES";	×
459	case Group_Params::HYBRID_SECP521R1_eFRODOKEM_1344_SHAKE_OQS:	×
460	return "secp521r1/eFrodoKEM-1344-SHAKE";	×
461	case Group_Params::HYBRID_SECP521R1_eFRODOKEM_1344_AES_OQS:	×
462	return "secp521r1/eFrodoKEM-1344-AES";	×
463
464	case Group_Params::HYBRID_X25519_ML_KEM_768:	206✔
465	return "x25519/ML-KEM-768";	206✔
466	case Group_Params::HYBRID_SECP256R1_ML_KEM_768:	15✔
467	return "secp256r1/ML-KEM-768";	15✔
468	case Group_Params::HYBRID_SECP384R1_ML_KEM_1024:	15✔
469	return "secp384r1/ML-KEM-1024";	15✔
470
471	default:	30✔
472	return std::nullopt;	30✔
473	}
474	}
475
476	std::string certificate_type_to_string(Certificate_Type type) {	24✔
477	switch(type) {	24✔
478	case Certificate_Type::X509:	24✔
479	return "X509";	24✔
480	case Certificate_Type::RawPublicKey:	×
481	return "RawPublicKey";	×
482	}
483
484	return "Unknown";	×
485	}
486
487	Certificate_Type certificate_type_from_string(const std::string& type_str) {	10✔
488	if(type_str == "X509") {	10✔
489	return Certificate_Type::X509;
490	} else if(type_str == "RawPublicKey") {	4✔
491	return Certificate_Type::RawPublicKey;
492	} else {
493	throw Decoding_Error("Unknown certificate type: " + type_str);	×
494	}
495	}
496
497	} // namespace Botan::TLS

randombit / botan / 24648292556

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous