12548935066

Committed 30 Dec 2024 04:04PM UTC coverage: 91.262% (+0.05%) from 91.208%

Build # 12548935066

Build Type

Pull #4507

github

Committed by

web-flow

Commit Message

Merge 3aca433ed into 9b8f3cc80

Pull Request Pull Request #4507: Remove support for Kyber r3 key exchange in TLS

Run Details

93394 of 102336 relevant lines covered (91.26%)

11408572.15 hits per line

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

56.15

/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/ec_group.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_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 == "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";

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

randombit / botan / 12548935066

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