5123321399

Committed 30 May 2023 04:06PM UTC coverage: 92.213% (+0.004%) from 92.209%

Build # 5123321399

Build Type

Pull #3558

github

Committed by

web-flow

Commit Message

Merge dd72f7389 into 057bcbc35

Pull Request Pull Request #3558: Add braces around all if/else statements

Run Details

75602 of 81986 relevant lines covered (92.21%)

11859779.3 hits per line

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

84.03

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

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

      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) {	196,938✔
16	switch(algo) {	196,938✔
17	case KDF_Algo::SHA_1:	36,439✔
18	return "SHA-1";	36,439✔
19	case KDF_Algo::SHA_256:	118,858✔
20	return "SHA-256";	118,858✔
21	case KDF_Algo::SHA_384:	41,641✔
22	return "SHA-384";	41,641✔
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,486✔
29	switch(method) {	7,486✔
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,036✔
35	return "ECDH";	4,036✔
36	case Kex_Algo::PSK:	828✔
37	return "PSK";	828✔
38	case Kex_Algo::ECDHE_PSK:	838✔
39	return "ECDHE_PSK";	838✔
40	case Kex_Algo::DHE_PSK:	×
41	return "DHE_PSK";	×
42	case Kex_Algo::UNDEFINED:	×
43	return "UNDEFINED";	×
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) {	7,162✔
82	switch(method) {	7,162✔
83	case Auth_Method::RSA:	4,406✔
84	return "RSA";	4,406✔
85	case Auth_Method::ECDSA:	2,605✔
86	return "ECDSA";	2,605✔
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,035✔
114	uint16_t group_id = static_cast<uint16_t>(group);	49,035✔
115	return (group_id >= 256 && group_id < 512);	49,035✔
116	}
117
118	Group_Params group_param_from_string(std::string_view group_name) {	398✔
119	if(group_name == "secp256r1") {	475✔
120	return Group_Params::SECP256R1;	51✔
121	}
122	if(group_name == "secp384r1") {	388✔
123	return Group_Params::SECP384R1;	36✔
124	}
125	if(group_name == "secp521r1") {	311✔
126	return Group_Params::SECP521R1;	41✔
127	}
128	if(group_name == "brainpool256r1") {	286✔
129	return Group_Params::BRAINPOOL256R1;	24✔
130	}
131	if(group_name == "brainpool384r1") {	500✔
132	return Group_Params::BRAINPOOL384R1;	8✔
133	}
134	if(group_name == "brainpool512r1") {	238✔
135	return Group_Params::BRAINPOOL512R1;	8✔
136	}
137	if(group_name == "x25519") {	246✔
138	return Group_Params::X25519;	66✔
139	}
140
141	if(group_name == "ffdhe/ietf/2048") {	271✔
142	return Group_Params::FFDHE_2048;	41✔
143	}
144	if(group_name == "ffdhe/ietf/3072") {	203✔
145	return Group_Params::FFDHE_3072;	27✔
146	}
147	if(group_name == "ffdhe/ietf/4096") {	146✔
148	return Group_Params::FFDHE_4096;	30✔
149	}
150	if(group_name == "ffdhe/ietf/6144") {	91✔
151	return Group_Params::FFDHE_6144;	25✔
152	}
153	if(group_name == "ffdhe/ietf/8192") {	41✔
154	return Group_Params::FFDHE_8192;	25✔
155	}
156
157	return Group_Params::NONE; // unknown
158	}
159
160	std::string group_param_to_string(Group_Params group) {	649✔
161	switch(group) {	649✔
162	case Group_Params::SECP256R1:	450✔
163	return "secp256r1";	450✔
164	case Group_Params::SECP384R1:	67✔
165	return "secp384r1";	67✔
166	case Group_Params::SECP521R1:	30✔
167	return "secp521r1";	30✔
168	case Group_Params::BRAINPOOL256R1:	24✔
169	return "brainpool256r1";	24✔
170	case Group_Params::BRAINPOOL384R1:	8✔
171	return "brainpool384r1";	8✔
172	case Group_Params::BRAINPOOL512R1:	10✔
173	return "brainpool512r1";	10✔
174	case Group_Params::X25519:	12✔
175	return "x25519";	12✔
176
177	case Group_Params::FFDHE_2048:	20✔
178	return "ffdhe/ietf/2048";	20✔
179	case Group_Params::FFDHE_3072:	8✔
180	return "ffdhe/ietf/3072";	8✔
181	case Group_Params::FFDHE_4096:	8✔
182	return "ffdhe/ietf/4096";	8✔
183	case Group_Params::FFDHE_6144:	6✔
184	return "ffdhe/ietf/6144";	6✔
185	case Group_Params::FFDHE_8192:	6✔
186	return "ffdhe/ietf/8192";	6✔
187
188	default:	×
189	return "";	×
190	}
191	}
192
193	} // namespace Botan::TLS

randombit / botan / 5123321399

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