19012754211

Committed 02 Nov 2025 01:10PM UTC coverage: 90.677% (+0.006%) from 90.671%

Build # 19012754211

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #5137 from randombit/jack/clang-tidy-includes

Remove various unused includes flagged by clang-tidy misc-include-cleaner

Run Details

100457 of 110786 relevant lines covered (90.68%)

12189873.8 hits per line

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

57.83

/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>

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));
}

bool Group_Params::is_available() const {
#if !defined(BOTAN_HAS_X25519)
   if(is_x25519()) {
      return false;
   }
   if(is_pqc_hybrid() && pqc_hybrid_ecc() == Group_Params_Code::X25519) {
      return false;
   }
#endif

#if !defined(BOTAN_HAS_X448)
   if(is_x448()) {
      return false;
   }
   if(is_pqc_hybrid() && pqc_hybrid_ecc() == Group_Params_Code::X448) {
      return false;
   }
#endif

#if !defined(BOTAN_HAS_DIFFIE_HELLMAN)
   if(is_in_ffdhe_range()) {
      return false;
   }
#endif

#if !defined(BOTAN_HAS_ML_KEM)
   if(is_pure_ml_kem() || is_pqc_hybrid_ml_kem()) {
      return false;
   }
#endif

#if !defined(BOTAN_HAS_FRODOKEM)
   if(is_pure_frodokem() || is_pqc_hybrid_frodokem()) {
      return false;
   }
#endif

   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;
   }
}

}  // 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	namespace Botan::TLS {
13
14	std::string kdf_algo_to_string(KDF_Algo algo) {	227,224✔
15	switch(algo) {	227,224✔
16	case KDF_Algo::SHA_1:	47,339✔
17	return "SHA-1";	47,339✔
18	case KDF_Algo::SHA_256:	130,449✔
19	return "SHA-256";	130,449✔
20	case KDF_Algo::SHA_384:	49,436✔
21	return "SHA-384";	49,436✔
22	}
23
24	throw Invalid_State("kdf_algo_to_string unknown enum value");	×
25	}
26
27	std::string kex_method_to_string(Kex_Algo method) {	8,273✔
28	switch(method) {	8,273✔
29	case Kex_Algo::STATIC_RSA:	697✔
30	return "RSA";	697✔
31	case Kex_Algo::DH:	1,154✔
32	return "DH";	1,154✔
33	case Kex_Algo::ECDH:	4,499✔
34	return "ECDH";	4,499✔
35	case Kex_Algo::PSK:	975✔
36	return "PSK";	975✔
37	case Kex_Algo::ECDHE_PSK:	914✔
38	return "ECDHE_PSK";	914✔
39	case Kex_Algo::DHE_PSK:	×
40	return "DHE_PSK";	×
41	case Kex_Algo::KEM:	2✔
42	return "KEM";	2✔
43	case Kex_Algo::KEM_PSK:	×
44	return "KEM_PSK";	×
45	case Kex_Algo::HYBRID:	30✔
46	return "HYBRID";	30✔
47	case Kex_Algo::HYBRID_PSK:	2✔
48	return "HYBRID_PSK";	2✔
49	case Kex_Algo::UNDEFINED:	×
50	return "UNDEFINED";	×
51	}
52
53	throw Invalid_State("kex_method_to_string unknown enum value");	×
54	}
55
56	Kex_Algo kex_method_from_string(std::string_view str) {	5✔
57	if(str == "RSA") {	5✔
58	return Kex_Algo::STATIC_RSA;	1✔
59	}
60
61	if(str == "DH") {	4✔
62	return Kex_Algo::DH;	1✔
63	}
64
65	if(str == "ECDH") {	3✔
66	return Kex_Algo::ECDH;	1✔
67	}
68
69	if(str == "PSK") {	2✔
70	return Kex_Algo::PSK;	1✔
71	}
72
73	if(str == "ECDHE_PSK") {	1✔
74	return Kex_Algo::ECDHE_PSK;	1✔
75	}
76
77	if(str == "DHE_PSK") {	×
78	return Kex_Algo::DHE_PSK;	×
79	}
80
81	if(str == "KEM") {	×
82	return Kex_Algo::KEM;	×
83	}
84
85	if(str == "KEM_PSK") {	×
86	return Kex_Algo::KEM_PSK;	×
87	}
88
89	if(str == "HYBRID") {	×
90	return Kex_Algo::HYBRID;	×
91	}
92
93	if(str == "HYBRID_PSK") {	×
94	return Kex_Algo::HYBRID_PSK;	×
95	}
96
97	if(str == "UNDEFINED") {	×
98	return Kex_Algo::UNDEFINED;	×
99	}
100
101	throw Invalid_Argument(fmt("Unknown kex method '{}'", str));	×
102	}
103
104	std::string auth_method_to_string(Auth_Method method) {	9,952✔
105	switch(method) {	9,952✔
106	case Auth_Method::RSA:	6,813✔
107	return "RSA";	6,813✔
108	case Auth_Method::ECDSA:	2,974✔
109	return "ECDSA";	2,974✔
110	case Auth_Method::IMPLICIT:	165✔
111	return "IMPLICIT";	165✔
112	case Auth_Method::UNDEFINED:	×
113	return "UNDEFINED";	×
114	}
115
116	throw Invalid_State("auth_method_to_string unknown enum value");	×
117	}
118
119	Auth_Method auth_method_from_string(std::string_view str) {	3✔
120	if(str == "RSA") {	3✔
121	return Auth_Method::RSA;	1✔
122	}
123	if(str == "ECDSA") {	2✔
124	return Auth_Method::ECDSA;	1✔
125	}
126	if(str == "IMPLICIT") {	1✔
127	return Auth_Method::IMPLICIT;	1✔
128	}
129	if(str == "UNDEFINED") {	×
130	return Auth_Method::UNDEFINED;	×
131	}
132
133	throw Invalid_Argument(fmt("Unknown TLS signature method '{}'", str));	×
134	}
135
136	bool Group_Params::is_available() const {	633✔
137	#if !defined(BOTAN_HAS_X25519)
138	if(is_x25519()) {
139	return false;
140	}
141	if(is_pqc_hybrid() && pqc_hybrid_ecc() == Group_Params_Code::X25519) {
142	return false;
143	}
144	#endif
145
146	#if !defined(BOTAN_HAS_X448)
147	if(is_x448()) {
148	return false;
149	}
150	if(is_pqc_hybrid() && pqc_hybrid_ecc() == Group_Params_Code::X448) {
151	return false;
152	}
153	#endif
154
155	#if !defined(BOTAN_HAS_DIFFIE_HELLMAN)
156	if(is_in_ffdhe_range()) {
157	return false;
158	}
159	#endif
160
161	#if !defined(BOTAN_HAS_ML_KEM)
162	if(is_pure_ml_kem() \|\| is_pqc_hybrid_ml_kem()) {
163	return false;
164	}
165	#endif
166
167	#if !defined(BOTAN_HAS_FRODOKEM)
168	if(is_pure_frodokem() \|\| is_pqc_hybrid_frodokem()) {
169	return false;
170	}
171	#endif
172
173	return true;	633✔
174	}
175
176	std::optional<Group_Params_Code> Group_Params::pqc_hybrid_ecc() const {	×
177	switch(m_code) {	×
178	case Group_Params_Code::HYBRID_X25519_ML_KEM_768:	×
179
180	case Group_Params_Code::HYBRID_X25519_eFRODOKEM_640_SHAKE_OQS:	×
181	case Group_Params_Code::HYBRID_X25519_eFRODOKEM_640_AES_OQS:	×
182	return Group_Params_Code::X25519;	×
183
184	case Group_Params_Code::HYBRID_X448_eFRODOKEM_976_SHAKE_OQS:	×
185	case Group_Params_Code::HYBRID_X448_eFRODOKEM_976_AES_OQS:	×
186	return Group_Params_Code::X448;	×
187
188	case Group_Params_Code::HYBRID_SECP256R1_ML_KEM_768:	×
189	case Group_Params_Code::HYBRID_SECP256R1_eFRODOKEM_640_SHAKE_OQS:	×
190	case Group_Params_Code::HYBRID_SECP256R1_eFRODOKEM_640_AES_OQS:	×
191	return Group_Params_Code::SECP256R1;	×
192
193	case Group_Params_Code::HYBRID_SECP384R1_ML_KEM_1024:	×
194	case Group_Params_Code::HYBRID_SECP384R1_eFRODOKEM_976_SHAKE_OQS:	×
195	case Group_Params_Code::HYBRID_SECP384R1_eFRODOKEM_976_AES_OQS:	×
196	return Group_Params_Code::SECP384R1;	×
197
198	case Group_Params_Code::HYBRID_SECP521R1_eFRODOKEM_1344_SHAKE_OQS:	×
199	case Group_Params_Code::HYBRID_SECP521R1_eFRODOKEM_1344_AES_OQS:	×
200	return Group_Params_Code::SECP521R1;	×
201
202	default:	×
203	return {};	×
204	}
205	}
206
207	std::optional<Group_Params> Group_Params::from_string(std::string_view group_name) {	633✔
208	if(group_name == "secp256r1") {	633✔
209	return Group_Params::SECP256R1;	90✔
210	}
211	if(group_name == "secp384r1") {	543✔
212	return Group_Params::SECP384R1;	49✔
213	}
214	if(group_name == "secp521r1") {	494✔
215	return Group_Params::SECP521R1;	44✔
216	}
217	if(group_name == "brainpool256r1") {	450✔
218	return Group_Params::BRAINPOOL256R1;	28✔
219	}
220	if(group_name == "brainpool384r1") {	422✔
221	return Group_Params::BRAINPOOL384R1;	12✔
222	}
223	if(group_name == "brainpool512r1") {	410✔
224	return Group_Params::BRAINPOOL512R1;	12✔
225	}
226	if(group_name == "x25519") {	398✔
227	return Group_Params::X25519;	103✔
228	}
229	if(group_name == "x448") {	295✔
230	return Group_Params::X448;	41✔
231	}
232
233	if(group_name == "ffdhe/ietf/2048") {	254✔
234	return Group_Params::FFDHE_2048;	69✔
235	}
236	if(group_name == "ffdhe/ietf/3072") {	185✔
237	return Group_Params::FFDHE_3072;	28✔
238	}
239	if(group_name == "ffdhe/ietf/4096") {	157✔
240	return Group_Params::FFDHE_4096;	22✔
241	}
242	if(group_name == "ffdhe/ietf/6144") {	135✔
243	return Group_Params::FFDHE_6144;	16✔
244	}
245	if(group_name == "ffdhe/ietf/8192") {	119✔
246	return Group_Params::FFDHE_8192;	16✔
247	}
248
249	if(group_name == "ML-KEM-512") {	103✔
250	return Group_Params::ML_KEM_512;	×
251	}
252	if(group_name == "ML-KEM-768") {	103✔
253	return Group_Params::ML_KEM_768;	30✔
254	}
255	if(group_name == "ML-KEM-1024") {	73✔
256	return Group_Params::ML_KEM_1024;	×
257	}
258
259	if(group_name == "eFrodoKEM-640-SHAKE") {	73✔
260	return Group_Params::eFRODOKEM_640_SHAKE_OQS;	×
261	}
262	if(group_name == "eFrodoKEM-976-SHAKE") {	73✔
263	return Group_Params::eFRODOKEM_976_SHAKE_OQS;	×
264	}
265	if(group_name == "eFrodoKEM-1344-SHAKE") {	73✔
266	return Group_Params::eFRODOKEM_1344_SHAKE_OQS;	×
267	}
268	if(group_name == "eFrodoKEM-640-AES") {	73✔
269	return Group_Params::eFRODOKEM_640_AES_OQS;	×
270	}
271	if(group_name == "eFrodoKEM-976-AES") {	73✔
272	return Group_Params::eFRODOKEM_976_AES_OQS;	×
273	}
274	if(group_name == "eFrodoKEM-1344-AES") {	73✔
275	return Group_Params::eFRODOKEM_1344_AES_OQS;	×
276	}
277
278	if(group_name == "x25519/ML-KEM-768") {	73✔
279	return Group_Params::HYBRID_X25519_ML_KEM_768;	39✔
280	}
281	if(group_name == "secp256r1/ML-KEM-768") {	34✔
282	return Group_Params::HYBRID_SECP256R1_ML_KEM_768;	9✔
283	}
284	if(group_name == "secp384r1/ML-KEM-1024") {	25✔
285	return Group_Params::HYBRID_SECP384R1_ML_KEM_1024;	9✔
286	}
287
288	if(group_name == "x25519/eFrodoKEM-640-SHAKE") {	16✔
289	return Group_Params::HYBRID_X25519_eFRODOKEM_640_SHAKE_OQS;	×
290	}
291	if(group_name == "x25519/eFrodoKEM-640-AES") {	16✔
292	return Group_Params::HYBRID_X25519_eFRODOKEM_640_AES_OQS;	×
293	}
294	if(group_name == "x448/eFrodoKEM-976-SHAKE") {	16✔
295	return Group_Params::HYBRID_X448_eFRODOKEM_976_SHAKE_OQS;	×
296	}
297	if(group_name == "x448/eFrodoKEM-976-AES") {	16✔
298	return Group_Params::HYBRID_X448_eFRODOKEM_976_AES_OQS;	×
299	}
300
301	if(group_name == "secp256r1/eFrodoKEM-640-SHAKE") {	16✔
302	return Group_Params::HYBRID_SECP256R1_eFRODOKEM_640_SHAKE_OQS;	×
303	}
304	if(group_name == "secp256r1/eFrodoKEM-640-AES") {	16✔
305	return Group_Params::HYBRID_SECP256R1_eFRODOKEM_640_AES_OQS;	×
306	}
307
308	if(group_name == "secp384r1/eFrodoKEM-976-SHAKE") {	16✔
309	return Group_Params::HYBRID_SECP384R1_eFRODOKEM_976_SHAKE_OQS;	×
310	}
311	if(group_name == "secp384r1/eFrodoKEM-976-AES") {	16✔
312	return Group_Params::HYBRID_SECP384R1_eFRODOKEM_976_AES_OQS;	×
313	}
314
315	if(group_name == "secp521r1/eFrodoKEM-1344-SHAKE") {	16✔
316	return Group_Params::HYBRID_SECP521R1_eFRODOKEM_1344_SHAKE_OQS;	×
317	}
318	if(group_name == "secp521r1/eFrodoKEM-1344-AES") {	16✔
319	return Group_Params::HYBRID_SECP521R1_eFRODOKEM_1344_AES_OQS;	×
320	}
321
322	return std::nullopt;	16✔
323	}
324
325	std::optional<std::string> Group_Params::to_string() const {	1,017✔
326	switch(m_code) {	1,017✔
327	case Group_Params::SECP256R1:	118✔
328	return "secp256r1";	118✔
329	case Group_Params::SECP384R1:	121✔
330	return "secp384r1";	121✔
331	case Group_Params::SECP521R1:	60✔
332	return "secp521r1";	60✔
333	case Group_Params::BRAINPOOL256R1:	31✔
334	return "brainpool256r1";	31✔
335	case Group_Params::BRAINPOOL384R1:	10✔
336	return "brainpool384r1";	10✔
337	case Group_Params::BRAINPOOL512R1:	17✔
338	return "brainpool512r1";	17✔
339	case Group_Params::X25519:	558✔
340	return "x25519";	558✔
341	case Group_Params::X448:	8✔
342	return "x448";	8✔
343
344	case Group_Params::FFDHE_2048:	22✔
345	return "ffdhe/ietf/2048";	22✔
346	case Group_Params::FFDHE_3072:	10✔
347	return "ffdhe/ietf/3072";	10✔
348	case Group_Params::FFDHE_4096:	4✔
349	return "ffdhe/ietf/4096";	4✔
350	case Group_Params::FFDHE_6144:	2✔
351	return "ffdhe/ietf/6144";	2✔
352	case Group_Params::FFDHE_8192:	2✔
353	return "ffdhe/ietf/8192";	2✔
354
355	case Group_Params::ML_KEM_512:	×
356	return "ML-KEM-512";	×
357	case Group_Params::ML_KEM_768:	4✔
358	return "ML-KEM-768";	4✔
359	case Group_Params::ML_KEM_1024:	×
360	return "ML-KEM-1024";	×
361
362	case Group_Params::eFRODOKEM_640_SHAKE_OQS:	×
363	return "eFrodoKEM-640-SHAKE";	×
364	case Group_Params::eFRODOKEM_976_SHAKE_OQS:	×
365	return "eFrodoKEM-976-SHAKE";	×
366	case Group_Params::eFRODOKEM_1344_SHAKE_OQS:	×
367	return "eFrodoKEM-1344-SHAKE";	×
368	case Group_Params::eFRODOKEM_640_AES_OQS:	×
369	return "eFrodoKEM-640-AES";	×
370	case Group_Params::eFRODOKEM_976_AES_OQS:	×
371	return "eFrodoKEM-976-AES";	×
372	case Group_Params::eFRODOKEM_1344_AES_OQS:	×
373	return "eFrodoKEM-1344-AES";	×
374
375	case Group_Params::HYBRID_X25519_eFRODOKEM_640_SHAKE_OQS:	×
376	return "x25519/eFrodoKEM-640-SHAKE";	×
377	case Group_Params::HYBRID_X25519_eFRODOKEM_640_AES_OQS:	×
378	return "x25519/eFrodoKEM-640-AES";	×
379	case Group_Params::HYBRID_X448_eFRODOKEM_976_SHAKE_OQS:	×
380	return "x448/eFrodoKEM-976-SHAKE";	×
381	case Group_Params::HYBRID_X448_eFRODOKEM_976_AES_OQS:	×
382	return "x448/eFrodoKEM-976-AES";	×
383	case Group_Params::HYBRID_SECP256R1_eFRODOKEM_640_SHAKE_OQS:	×
384	return "secp256r1/eFrodoKEM-640-SHAKE";	×
385	case Group_Params::HYBRID_SECP256R1_eFRODOKEM_640_AES_OQS:	×
386	return "secp256r1/eFrodoKEM-640-AES";	×
387	case Group_Params::HYBRID_SECP384R1_eFRODOKEM_976_SHAKE_OQS:	×
388	return "secp384r1/eFrodoKEM-976-SHAKE";	×
389	case Group_Params::HYBRID_SECP384R1_eFRODOKEM_976_AES_OQS:	×
390	return "secp384r1/eFrodoKEM-976-AES";	×
391	case Group_Params::HYBRID_SECP521R1_eFRODOKEM_1344_SHAKE_OQS:	×
392	return "secp521r1/eFrodoKEM-1344-SHAKE";	×
393	case Group_Params::HYBRID_SECP521R1_eFRODOKEM_1344_AES_OQS:	×
394	return "secp521r1/eFrodoKEM-1344-AES";	×
395
396	case Group_Params::HYBRID_X25519_ML_KEM_768:	38✔
397	return "x25519/ML-KEM-768";	38✔
398	case Group_Params::HYBRID_SECP256R1_ML_KEM_768:	6✔
399	return "secp256r1/ML-KEM-768";	6✔
400	case Group_Params::HYBRID_SECP384R1_ML_KEM_1024:	6✔
401	return "secp384r1/ML-KEM-1024";	6✔
402
403	default:	×
404	return std::nullopt;	×
405	}
406	}
407
408	} // namespace Botan::TLS

randombit / botan / 19012754211

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