5504576341

Committed 10 Jul 2023 05:54AM UTC coverage: 91.659% (-0.08%) from 91.738%

Build # 5504576341

Build Type

Pull #3609

github

Committed by

web-flow

Commit Message

Merge e4af46f07 into 3a70598f9

Pull Request Pull Request #3609: [TLS 1.3] Hybrid PQ/T key establishment

Run Details

78666 of 85825 relevant lines covered (91.66%)

12304734.65 hits per line

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

72.96

/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::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 == "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_param_is_dh(Group_Params group) {
   uint16_t group_id = static_cast<uint16_t>(group);
   return (group_id >= 256 && group_id < 512);
}

Group_Params group_param_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 == "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;
   }
   if(group_name == "Kyber-768-r3") {
      return Group_Params::KYBER_768_R3;
   }
   if(group_name == "Kyber-1024-r3") {
      return Group_Params::KYBER_1024_R3;
   }

   if(group_name == "x25519/Kyber-512-r3/cloudflare") {
      return Group_Params::HYBRID_X25519_KYBER_512_R3_CLOUDFLARE;
   }
   if(group_name == "x25519/Kyber-768-r3/cloudflare") {
      return Group_Params::HYBRID_X25519_KYBER_768_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 == "secp256r1/Kyber-512-r3") {
      return Group_Params::HYBRID_SECP256R1_KYBER_512_R3_OQS;
   }
   if(group_name == "secp384r1/Kyber-768-r3") {
      return Group_Params::HYBRID_SECP384R1_KYBER_768_R3_OQS;
   }
   if(group_name == "secp521r1/Kyber-1024-r3") {
      return Group_Params::HYBRID_SECP521R1_KYBER_1024_R3_OQS;
   }

   return Group_Params::NONE;  // unknown
}

std::string group_param_to_string(Group_Params group) {
   switch(group) {
      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::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:
         return "Kyber-512-r3";
      case Group_Params::KYBER_768_R3:
         return "Kyber-768-r3";
      case Group_Params::KYBER_1024_R3:
         return "Kyber-1024-r3";

      case Group_Params::HYBRID_X25519_KYBER_512_R3_CLOUDFLARE:
         return "x25519/Kyber-512-r3/cloudflare";
      case Group_Params::HYBRID_X25519_KYBER_768_R3_CLOUDFLARE:
         return "x25519/Kyber-768-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_SECP256R1_KYBER_512_R3_OQS:
         return "secp256r1/Kyber-512-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 "";
   }
}

}  // 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) {	197,920✔
16	switch(algo) {	197,920✔
17	case KDF_Algo::SHA_1:	36,637✔
18	return "SHA-1";	36,637✔
19	case KDF_Algo::SHA_256:	119,480✔
20	return "SHA-256";	119,480✔
21	case KDF_Algo::SHA_384:	41,803✔
22	return "SHA-384";	41,803✔
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,498✔
29	switch(method) {	7,498✔
30	case Kex_Algo::STATIC_RSA:	723✔
31	return "RSA";	723✔
32	case Kex_Algo::DH:	1,061✔
33	return "DH";	1,061✔
34	case Kex_Algo::ECDH:	4,042✔
35	return "ECDH";	4,042✔
36	case Kex_Algo::PSK:	829✔
37	return "PSK";	829✔
38	case Kex_Algo::ECDHE_PSK:	839✔
39	return "ECDHE_PSK";	839✔
40	case Kex_Algo::DHE_PSK:	×
41	return "DHE_PSK";	×
42	case Kex_Algo::UNDEFINED:	4✔
43	return "UNDEFINED";	4✔
44	}
45
46	throw Invalid_State("kex_method_to_string unknown enum value");	×
47	}
48
49	Kex_Algo kex_method_from_string(std::string_view str) {	5✔
50	if(str == "RSA") {	6✔
51	return Kex_Algo::STATIC_RSA;	1✔
52	}
53
54	if(str == "DH") {	4✔
55	return Kex_Algo::DH;	1✔
56	}
57
58	if(str == "ECDH") {	3✔
59	return Kex_Algo::ECDH;	1✔
60	}
61
62	if(str == "PSK") {	2✔
63	return Kex_Algo::PSK;	1✔
64	}
65
66	if(str == "ECDHE_PSK") {	1✔
67	return Kex_Algo::ECDHE_PSK;	1✔
68	}
69
70	if(str == "DHE_PSK") {	×
71	return Kex_Algo::DHE_PSK;	×
72	}
73
74	if(str == "UNDEFINED") {	×
75	return Kex_Algo::UNDEFINED;	×
76	}
77
78	throw Invalid_Argument(fmt("Unknown kex method '{}'", str));	×
79	}
80
81	std::string auth_method_to_string(Auth_Method method) {	8,913✔
82	switch(method) {	8,913✔
83	case Auth_Method::RSA:	6,087✔
84	return "RSA";	6,087✔
85	case Auth_Method::ECDSA:	2,675✔
86	return "ECDSA";	2,675✔
87	case Auth_Method::IMPLICIT:	151✔
88	return "IMPLICIT";	151✔
89	case Auth_Method::UNDEFINED:	×
90	return "UNDEFINED";	×
91	}
92
93	throw Invalid_State("auth_method_to_string unknown enum value");	×
94	}
95
96	Auth_Method auth_method_from_string(std::string_view str) {	3✔
97	if(str == "RSA") {	3✔
98	return Auth_Method::RSA;	1✔
99	}
100	if(str == "ECDSA") {	2✔
101	return Auth_Method::ECDSA;	1✔
102	}
103	if(str == "IMPLICIT") {	1✔
104	return Auth_Method::IMPLICIT;	1✔
105	}
106	if(str == "UNDEFINED") {	×
107	return Auth_Method::UNDEFINED;	×
108	}
109
110	throw Invalid_Argument(fmt("Unknown TLS signature method '{}'", str));	×
111	}
112
113	bool group_param_is_dh(Group_Params group) {	49,924✔
114	uint16_t group_id = static_cast<uint16_t>(group);	49,924✔
115	return (group_id >= 256 && group_id < 512);	49,924✔
116	}
117
118	Group_Params group_param_from_string(std::string_view group_name) {	422✔
119	if(group_name == "secp256r1") {	492✔
120	return Group_Params::SECP256R1;	59✔
121	}
122	if(group_name == "secp384r1") {	401✔
123	return Group_Params::SECP384R1;	32✔
124	}
125	if(group_name == "secp521r1") {	331✔
126	return Group_Params::SECP521R1;	38✔
127	}
128	if(group_name == "brainpool256r1") {	309✔
129	return Group_Params::BRAINPOOL256R1;	24✔
130	}
131	if(group_name == "brainpool384r1") {	546✔
132	return Group_Params::BRAINPOOL384R1;	8✔
133	}
134	if(group_name == "brainpool512r1") {	261✔
135	return Group_Params::BRAINPOOL512R1;	8✔
136	}
137	if(group_name == "x25519") {	257✔
138	return Group_Params::X25519;	74✔
139	}
140
141	if(group_name == "ffdhe/ietf/2048") {	274✔
142	return Group_Params::FFDHE_2048;	50✔
143	}
144	if(group_name == "ffdhe/ietf/3072") {	200✔
145	return Group_Params::FFDHE_3072;	24✔
146	}
147	if(group_name == "ffdhe/ietf/4096") {	149✔
148	return Group_Params::FFDHE_4096;	27✔
149	}
150	if(group_name == "ffdhe/ietf/6144") {	100✔
151	return Group_Params::FFDHE_6144;	22✔
152	}
153	if(group_name == "ffdhe/ietf/8192") {	56✔
154	return Group_Params::FFDHE_8192;	22✔
155	}
156
157	if(group_name == "Kyber-512-r3") {	34✔
158	return Group_Params::KYBER_512_R3;	15✔
159	}
160	if(group_name == "Kyber-768-r3") {	19✔
161	return Group_Params::KYBER_768_R3;	×
162	}
163	if(group_name == "Kyber-1024-r3") {	19✔
164	return Group_Params::KYBER_1024_R3;	×
165	}
166
167	if(group_name == "x25519/Kyber-512-r3/cloudflare") {	19✔
168	return Group_Params::HYBRID_X25519_KYBER_512_R3_CLOUDFLARE;	×
169	}
170	if(group_name == "x25519/Kyber-768-r3/cloudflare") {	19✔
171	return Group_Params::HYBRID_X25519_KYBER_768_R3_CLOUDFLARE;	×
172	}
173
174	if(group_name == "x25519/Kyber-512-r3") {	19✔
175	return Group_Params::HYBRID_X25519_KYBER_512_R3_OQS;	15✔
176	}
177	if(group_name == "x25519/Kyber-768-r3") {	4✔
178	return Group_Params::HYBRID_X25519_KYBER_768_R3_OQS;	×
179	}
180
181	if(group_name == "secp256r1/Kyber-512-r3") {	4✔
182	return Group_Params::HYBRID_SECP256R1_KYBER_512_R3_OQS;	×
183	}
184	if(group_name == "secp384r1/Kyber-768-r3") {	4✔
185	return Group_Params::HYBRID_SECP384R1_KYBER_768_R3_OQS;	×
186	}
187	if(group_name == "secp521r1/Kyber-1024-r3") {	4✔
188	return Group_Params::HYBRID_SECP521R1_KYBER_1024_R3_OQS;	×
189	}
190
191	return Group_Params::NONE; // unknown
192	}
193
194	std::string group_param_to_string(Group_Params group) {	261✔
195	switch(group) {	261✔
196	case Group_Params::SECP256R1:	60✔
197	return "secp256r1";	60✔
198	case Group_Params::SECP384R1:	67✔
199	return "secp384r1";	67✔
200	case Group_Params::SECP521R1:	30✔
201	return "secp521r1";	30✔
202	case Group_Params::BRAINPOOL256R1:	24✔
203	return "brainpool256r1";	24✔
204	case Group_Params::BRAINPOOL384R1:	8✔
205	return "brainpool384r1";	8✔
206	case Group_Params::BRAINPOOL512R1:	10✔
207	return "brainpool512r1";	10✔
208	case Group_Params::X25519:	12✔
209	return "x25519";	12✔
210
211	case Group_Params::FFDHE_2048:	20✔
212	return "ffdhe/ietf/2048";	20✔
213	case Group_Params::FFDHE_3072:	8✔
214	return "ffdhe/ietf/3072";	8✔
215	case Group_Params::FFDHE_4096:	8✔
216	return "ffdhe/ietf/4096";	8✔
217	case Group_Params::FFDHE_6144:	6✔
218	return "ffdhe/ietf/6144";	6✔
219	case Group_Params::FFDHE_8192:	6✔
220	return "ffdhe/ietf/8192";	6✔
221
222	case Group_Params::KYBER_512_R3:	2✔
223	return "Kyber-512-r3";	2✔
224	case Group_Params::KYBER_768_R3:	×
225	return "Kyber-768-r3";	×
226	case Group_Params::KYBER_1024_R3:	×
227	return "Kyber-1024-r3";	×
228
229	case Group_Params::HYBRID_X25519_KYBER_512_R3_CLOUDFLARE:	×
230	return "x25519/Kyber-512-r3/cloudflare";	×
231	case Group_Params::HYBRID_X25519_KYBER_768_R3_CLOUDFLARE:	×
232	return "x25519/Kyber-768-r3/cloudflare";	×
233
234	case Group_Params::HYBRID_X25519_KYBER_512_R3_OQS:	×
235	return "x25519/Kyber-512-r3";	×
236	case Group_Params::HYBRID_X25519_KYBER_768_R3_OQS:	×
237	return "x25519/Kyber-768-r3";	×
238
239	case Group_Params::HYBRID_SECP256R1_KYBER_512_R3_OQS:	×
240	return "secp256r1/Kyber-512-r3";	×
241	case Group_Params::HYBRID_SECP384R1_KYBER_768_R3_OQS:	×
242	return "secp384r1/Kyber-768-r3";	×
243	case Group_Params::HYBRID_SECP521R1_KYBER_1024_R3_OQS:	×
244	return "secp521r1/Kyber-1024-r3";	×
245
246	default:	×
247	return "";	×
248	}
249	}
250
251	} // namespace Botan::TLS

randombit / botan / 5504576341

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