11416543182

Committed 19 Oct 2024 09:45AM UTC coverage: 91.134% (-0.01%) from 91.146%

Build # 11416543182

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #4375 from Rohde-Schwarz/tls/ml_kem_hybrids

Run Details

91047 of 99905 relevant lines covered (91.13%)

9341966.63 hits per line

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

54.94

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

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 == "Kyber-512-r3") {
      return Group_Params::KYBER_512_R3_OQS;
   }
   if(group_name == "Kyber-768-r3") {
      return Group_Params::KYBER_768_R3_OQS;
   }
   if(group_name == "Kyber-1024-r3") {
      return Group_Params::KYBER_1024_R3_OQS;
   }

   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/Kyber-512-r3/cloudflare") {
      return Group_Params::HYBRID_X25519_KYBER_512_R3_CLOUDFLARE;
   }
   if(group_name == "x25519/Kyber-512-r3") {
      return Group_Params::HYBRID_X25519_KYBER_512_R3_OQS;
   }
   if(group_name == "x25519/Kyber-768-r3") {
      return Group_Params::HYBRID_X25519_KYBER_768_R3_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 == "x448/Kyber-768-r3") {
      return Group_Params::HYBRID_X448_KYBER_768_R3_OQS;
   }
   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/Kyber-512-r3") {
      return Group_Params::HYBRID_SECP256R1_KYBER_512_R3_OQS;
   }
   if(group_name == "secp256r1/Kyber-768-r3") {
      return Group_Params::HYBRID_SECP256R1_KYBER_768_R3_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/Kyber-768-r3") {
      return Group_Params::HYBRID_SECP384R1_KYBER_768_R3_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/Kyber-1024-r3") {
      return Group_Params::HYBRID_SECP521R1_KYBER_1024_R3_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::KYBER_512_R3_OQS:
         return "Kyber-512-r3";
      case Group_Params::KYBER_768_R3_OQS:
         return "Kyber-768-r3";
      case Group_Params::KYBER_1024_R3_OQS:
         return "Kyber-1024-r3";

      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_KYBER_512_R3_CLOUDFLARE:
         return "x25519/Kyber-512-r3/cloudflare";

      case Group_Params::HYBRID_X25519_KYBER_512_R3_OQS:
         return "x25519/Kyber-512-r3";
      case Group_Params::HYBRID_X25519_KYBER_768_R3_OQS:
         return "x25519/Kyber-768-r3";

      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_X448_KYBER_768_R3_OQS:
         return "x448/Kyber-768-r3";

      case Group_Params::HYBRID_SECP256R1_KYBER_512_R3_OQS:
         return "secp256r1/Kyber-512-r3";
      case Group_Params::HYBRID_SECP256R1_KYBER_768_R3_OQS:
         return "secp256r1/Kyber-768-r3";
      case Group_Params::HYBRID_SECP384R1_KYBER_768_R3_OQS:
         return "secp384r1/Kyber-768-r3";
      case Group_Params::HYBRID_SECP521R1_KYBER_1024_R3_OQS:
         return "secp521r1/Kyber-1024-r3";

      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) {	211,340✔
16	switch(algo) {	211,340✔
17	case KDF_Algo::SHA_1:	39,145✔
18	return "SHA-1";	39,145✔
19	case KDF_Algo::SHA_256:	127,428✔
20	return "SHA-256";	127,428✔
21	case KDF_Algo::SHA_384:	44,767✔
22	return "SHA-384";	44,767✔
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,819✔
29	switch(method) {	7,819✔
30	case Kex_Algo::STATIC_RSA:	741✔
31	return "RSA";	741✔
32	case Kex_Algo::DH:	1,110✔
33	return "DH";	1,110✔
34	case Kex_Algo::ECDH:	4,220✔
35	return "ECDH";	4,220✔
36	case Kex_Algo::PSK:	860✔
37	return "PSK";	860✔
38	case Kex_Algo::ECDHE_PSK:	874✔
39	return "ECDHE_PSK";	874✔
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:	12✔
47	return "HYBRID";	12✔
48	case Kex_Algo::HYBRID_PSK:	×
49	return "HYBRID_PSK";	×
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,648✔
106	switch(method) {	9,648✔
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:	154✔
112	return "IMPLICIT";	154✔
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	std::optional<Group_Params> Group_Params::from_string(std::string_view group_name) {	539✔
138	if(group_name == "secp256r1") {	539✔
139	return Group_Params::SECP256R1;	79✔
140	}
141	if(group_name == "secp384r1") {	460✔
142	return Group_Params::SECP384R1;	42✔
143	}
144	if(group_name == "secp521r1") {	418✔
145	return Group_Params::SECP521R1;	40✔
146	}
147	if(group_name == "brainpool256r1") {	378✔
148	return Group_Params::BRAINPOOL256R1;	24✔
149	}
150	if(group_name == "brainpool384r1") {	354✔
151	return Group_Params::BRAINPOOL384R1;	8✔
152	}
153	if(group_name == "brainpool512r1") {	346✔
154	return Group_Params::BRAINPOOL512R1;	8✔
155	}
156	if(group_name == "x25519") {	338✔
157	return Group_Params::X25519;	94✔
158	}
159	if(group_name == "x448") {	244✔
160	return Group_Params::X448;	33✔
161	}
162
163	if(group_name == "ffdhe/ietf/2048") {	211✔
164	return Group_Params::FFDHE_2048;	62✔
165	}
166	if(group_name == "ffdhe/ietf/3072") {	149✔
167	return Group_Params::FFDHE_3072;	24✔
168	}
169	if(group_name == "ffdhe/ietf/4096") {	125✔
170	return Group_Params::FFDHE_4096;	27✔
171	}
172	if(group_name == "ffdhe/ietf/6144") {	98✔
173	return Group_Params::FFDHE_6144;	22✔
174	}
175	if(group_name == "ffdhe/ietf/8192") {	76✔
176	return Group_Params::FFDHE_8192;	22✔
177	}
178
179	if(group_name == "Kyber-512-r3") {	54✔
180	return Group_Params::KYBER_512_R3_OQS;	25✔
181	}
182	if(group_name == "Kyber-768-r3") {	29✔
183	return Group_Params::KYBER_768_R3_OQS;	×
184	}
185	if(group_name == "Kyber-1024-r3") {	29✔
186	return Group_Params::KYBER_1024_R3_OQS;	×
187	}
188
189	if(group_name == "eFrodoKEM-640-SHAKE") {	29✔
190	return Group_Params::eFRODOKEM_640_SHAKE_OQS;	×
191	}
192	if(group_name == "eFrodoKEM-976-SHAKE") {	29✔
193	return Group_Params::eFRODOKEM_976_SHAKE_OQS;	×
194	}
195	if(group_name == "eFrodoKEM-1344-SHAKE") {	29✔
196	return Group_Params::eFRODOKEM_1344_SHAKE_OQS;	×
197	}
198	if(group_name == "eFrodoKEM-640-AES") {	29✔
199	return Group_Params::eFRODOKEM_640_AES_OQS;	×
200	}
201	if(group_name == "eFrodoKEM-976-AES") {	29✔
202	return Group_Params::eFRODOKEM_976_AES_OQS;	×
203	}
204	if(group_name == "eFrodoKEM-1344-AES") {	29✔
205	return Group_Params::eFRODOKEM_1344_AES_OQS;	×
206	}
207
208	if(group_name == "x25519/Kyber-512-r3/cloudflare") {	29✔
209	return Group_Params::HYBRID_X25519_KYBER_512_R3_CLOUDFLARE;	×
210	}
211	if(group_name == "x25519/Kyber-512-r3") {	29✔
212	return Group_Params::HYBRID_X25519_KYBER_512_R3_OQS;	25✔
213	}
214	if(group_name == "x25519/Kyber-768-r3") {	4✔
215	return Group_Params::HYBRID_X25519_KYBER_768_R3_OQS;	×
216	}
217
218	if(group_name == "x25519/ML-KEM-768") {	4✔
219	return Group_Params::HYBRID_X25519_ML_KEM_768;	×
220	}
221	if(group_name == "secp256r1/ML-KEM-768") {	4✔
222	return Group_Params::HYBRID_SECP256R1_ML_KEM_768;	×
223	}
224
225	if(group_name == "x448/Kyber-768-r3") {	4✔
226	return Group_Params::HYBRID_X448_KYBER_768_R3_OQS;	×
227	}
228	if(group_name == "x25519/eFrodoKEM-640-SHAKE") {	4✔
229	return Group_Params::HYBRID_X25519_eFRODOKEM_640_SHAKE_OQS;	×
230	}
231	if(group_name == "x25519/eFrodoKEM-640-AES") {	4✔
232	return Group_Params::HYBRID_X25519_eFRODOKEM_640_AES_OQS;	×
233	}
234	if(group_name == "x448/eFrodoKEM-976-SHAKE") {	4✔
235	return Group_Params::HYBRID_X448_eFRODOKEM_976_SHAKE_OQS;	×
236	}
237	if(group_name == "x448/eFrodoKEM-976-AES") {	4✔
238	return Group_Params::HYBRID_X448_eFRODOKEM_976_AES_OQS;	×
239	}
240
241	if(group_name == "secp256r1/Kyber-512-r3") {	4✔
242	return Group_Params::HYBRID_SECP256R1_KYBER_512_R3_OQS;	×
243	}
244	if(group_name == "secp256r1/Kyber-768-r3") {	4✔
245	return Group_Params::HYBRID_SECP256R1_KYBER_768_R3_OQS;	×
246	}
247	if(group_name == "secp256r1/eFrodoKEM-640-SHAKE") {	4✔
248	return Group_Params::HYBRID_SECP256R1_eFRODOKEM_640_SHAKE_OQS;	×
249	}
250	if(group_name == "secp256r1/eFrodoKEM-640-AES") {	4✔
251	return Group_Params::HYBRID_SECP256R1_eFRODOKEM_640_AES_OQS;	×
252	}
253
254	if(group_name == "secp384r1/Kyber-768-r3") {	4✔
255	return Group_Params::HYBRID_SECP384R1_KYBER_768_R3_OQS;	×
256	}
257	if(group_name == "secp384r1/eFrodoKEM-976-SHAKE") {	4✔
258	return Group_Params::HYBRID_SECP384R1_eFRODOKEM_976_SHAKE_OQS;	×
259	}
260	if(group_name == "secp384r1/eFrodoKEM-976-AES") {	4✔
261	return Group_Params::HYBRID_SECP384R1_eFRODOKEM_976_AES_OQS;	×
262	}
263
264	if(group_name == "secp521r1/Kyber-1024-r3") {	4✔
265	return Group_Params::HYBRID_SECP521R1_KYBER_1024_R3_OQS;	×
266	}
267	if(group_name == "secp521r1/eFrodoKEM-1344-SHAKE") {	4✔
268	return Group_Params::HYBRID_SECP521R1_eFRODOKEM_1344_SHAKE_OQS;	×
269	}
270	if(group_name == "secp521r1/eFrodoKEM-1344-AES") {	4✔
271	return Group_Params::HYBRID_SECP521R1_eFRODOKEM_1344_AES_OQS;	×
272	}
273
274	return std::nullopt;	4✔
275	}
276
277	std::optional<std::string> Group_Params::to_string() const {	399✔
278	switch(m_code) {	399✔
279	case Group_Params::SECP256R1:	111✔
280	return "secp256r1";	111✔
281	case Group_Params::SECP384R1:	99✔
282	return "secp384r1";	99✔
283	case Group_Params::SECP521R1:	58✔
284	return "secp521r1";	58✔
285	case Group_Params::BRAINPOOL256R1:	26✔
286	return "brainpool256r1";	26✔
287	case Group_Params::BRAINPOOL384R1:	10✔
288	return "brainpool384r1";	10✔
289	case Group_Params::BRAINPOOL512R1:	12✔
290	return "brainpool512r1";	12✔
291	case Group_Params::X25519:	15✔
292	return "x25519";	15✔
293	case Group_Params::X448:	6✔
294	return "x448";	6✔
295
296	case Group_Params::FFDHE_2048:	24✔
297	return "ffdhe/ietf/2048";	24✔
298	case Group_Params::FFDHE_3072:	10✔
299	return "ffdhe/ietf/3072";	10✔
300	case Group_Params::FFDHE_4096:	10✔
301	return "ffdhe/ietf/4096";	10✔
302	case Group_Params::FFDHE_6144:	8✔
303	return "ffdhe/ietf/6144";	8✔
304	case Group_Params::FFDHE_8192:	8✔
305	return "ffdhe/ietf/8192";	8✔
306
307	case Group_Params::KYBER_512_R3_OQS:	2✔
308	return "Kyber-512-r3";	2✔
309	case Group_Params::KYBER_768_R3_OQS:	×
310	return "Kyber-768-r3";	×
311	case Group_Params::KYBER_1024_R3_OQS:	×
312	return "Kyber-1024-r3";	×
313
314	case Group_Params::eFRODOKEM_640_SHAKE_OQS:	×
315	return "eFrodoKEM-640-SHAKE";	×
316	case Group_Params::eFRODOKEM_976_SHAKE_OQS:	×
317	return "eFrodoKEM-976-SHAKE";	×
318	case Group_Params::eFRODOKEM_1344_SHAKE_OQS:	×
319	return "eFrodoKEM-1344-SHAKE";	×
320	case Group_Params::eFRODOKEM_640_AES_OQS:	×
321	return "eFrodoKEM-640-AES";	×
322	case Group_Params::eFRODOKEM_976_AES_OQS:	×
323	return "eFrodoKEM-976-AES";	×
324	case Group_Params::eFRODOKEM_1344_AES_OQS:	×
325	return "eFrodoKEM-1344-AES";	×
326
327	case Group_Params::HYBRID_X25519_eFRODOKEM_640_SHAKE_OQS:	×
328	return "x25519/eFrodoKEM-640-SHAKE";	×
329	case Group_Params::HYBRID_X25519_eFRODOKEM_640_AES_OQS:	×
330	return "x25519/eFrodoKEM-640-AES";	×
331	case Group_Params::HYBRID_X448_eFRODOKEM_976_SHAKE_OQS:	×
332	return "x448/eFrodoKEM-976-SHAKE";	×
333	case Group_Params::HYBRID_X448_eFRODOKEM_976_AES_OQS:	×
334	return "x448/eFrodoKEM-976-AES";	×
335	case Group_Params::HYBRID_SECP256R1_eFRODOKEM_640_SHAKE_OQS:	×
336	return "secp256r1/eFrodoKEM-640-SHAKE";	×
337	case Group_Params::HYBRID_SECP256R1_eFRODOKEM_640_AES_OQS:	×
338	return "secp256r1/eFrodoKEM-640-AES";	×
339	case Group_Params::HYBRID_SECP384R1_eFRODOKEM_976_SHAKE_OQS:	×
340	return "secp384r1/eFrodoKEM-976-SHAKE";	×
341	case Group_Params::HYBRID_SECP384R1_eFRODOKEM_976_AES_OQS:	×
342	return "secp384r1/eFrodoKEM-976-AES";	×
343	case Group_Params::HYBRID_SECP521R1_eFRODOKEM_1344_SHAKE_OQS:	×
344	return "secp521r1/eFrodoKEM-1344-SHAKE";	×
345	case Group_Params::HYBRID_SECP521R1_eFRODOKEM_1344_AES_OQS:	×
346	return "secp521r1/eFrodoKEM-1344-AES";	×
347
348	case Group_Params::HYBRID_X25519_KYBER_512_R3_CLOUDFLARE:	×
349	return "x25519/Kyber-512-r3/cloudflare";	×
350
351	case Group_Params::HYBRID_X25519_KYBER_512_R3_OQS:	×
352	return "x25519/Kyber-512-r3";	×
353	case Group_Params::HYBRID_X25519_KYBER_768_R3_OQS:	×
354	return "x25519/Kyber-768-r3";	×
355
356	case Group_Params::HYBRID_X25519_ML_KEM_768:	×
357	return "x25519/ML-KEM-768";	×
358	case Group_Params::HYBRID_SECP256R1_ML_KEM_768:	×
359	return "secp256r1/ML-KEM-768";	×
360
361	case Group_Params::HYBRID_X448_KYBER_768_R3_OQS:	×
362	return "x448/Kyber-768-r3";	×
363
364	case Group_Params::HYBRID_SECP256R1_KYBER_512_R3_OQS:	×
365	return "secp256r1/Kyber-512-r3";	×
366	case Group_Params::HYBRID_SECP256R1_KYBER_768_R3_OQS:	×
367	return "secp256r1/Kyber-768-r3";	×
368	case Group_Params::HYBRID_SECP384R1_KYBER_768_R3_OQS:	×
369	return "secp384r1/Kyber-768-r3";	×
370	case Group_Params::HYBRID_SECP521R1_KYBER_1024_R3_OQS:	×
371	return "secp521r1/Kyber-1024-r3";	×
372
373	default:	×
374	return std::nullopt;	×
375	}
376	}
377
378	} // namespace Botan::TLS

randombit / botan / 11416543182

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