5079590438

Committed 25 May 2023 12:28PM UTC coverage: 92.228% (+0.5%) from 91.723%

Build # 5079590438

Build Type

Pull #3502

github

Pull Request Pull Request #3502: Apply clang-format to the codebase

Run Details

75589 of 81959 relevant lines covered (92.23%)

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

}

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,932✔
16	switch(algo) {	196,932✔
17	case KDF_Algo::SHA_1:	36,439✔
18	return "SHA-1";	36,439✔
19	case KDF_Algo::SHA_256:	118,852✔
20	return "SHA-256";	118,852✔
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,462✔
29	switch(method) {	7,462✔
30	case Kex_Algo::STATIC_RSA:	719✔
31	return "RSA";	719✔
32	case Kex_Algo::DH:	1,057✔
33	return "DH";	1,057✔
34	case Kex_Algo::ECDH:	4,028✔
35	return "ECDH";	4,028✔
36	case Kex_Algo::PSK:	824✔
37	return "PSK";	824✔
38	case Kex_Algo::ECDHE_PSK:	834✔
39	return "ECDHE_PSK";	834✔
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	if(str == "DH")	4✔
54	return Kex_Algo::DH;	1✔
55
56	if(str == "ECDH")	3✔
57	return Kex_Algo::ECDH;	1✔
58
59	if(str == "PSK")	2✔
60	return Kex_Algo::PSK;	1✔
61
62	if(str == "ECDHE_PSK")	1✔
63	return Kex_Algo::ECDHE_PSK;	1✔
64
65	if(str == "DHE_PSK")	×
66	return Kex_Algo::DHE_PSK;	×
67
68	if(str == "UNDEFINED")	×
69	return Kex_Algo::UNDEFINED;	×
70
71	throw Invalid_Argument(fmt("Unknown kex method '{}'", str));	×
72	}
73
74	std::string auth_method_to_string(Auth_Method method) {	7,119✔
75	switch(method) {	7,119✔
76	case Auth_Method::RSA:	4,410✔
77	return "RSA";	4,410✔
78	case Auth_Method::ECDSA:	2,560✔
79	return "ECDSA";	2,560✔
80	case Auth_Method::IMPLICIT:	149✔
81	return "IMPLICIT";	149✔
82	case Auth_Method::UNDEFINED:	×
83	return "UNDEFINED";	×
84	}
85
86	throw Invalid_State("auth_method_to_string unknown enum value");	×
87	}
88
89	Auth_Method auth_method_from_string(std::string_view str) {	3✔
90	if(str == "RSA")	3✔
91	return Auth_Method::RSA;	1✔
92	if(str == "ECDSA")	2✔
93	return Auth_Method::ECDSA;	1✔
94	if(str == "IMPLICIT")	1✔
95	return Auth_Method::IMPLICIT;	1✔
96	if(str == "UNDEFINED")	×
97	return Auth_Method::UNDEFINED;	×
98
99	throw Invalid_Argument(fmt("Unknown TLS signature method '{}'", str));	×
100	}
101
102	bool group_param_is_dh(Group_Params group) {	49,020✔
103	uint16_t group_id = static_cast<uint16_t>(group);	49,020✔
104	return (group_id >= 256 && group_id < 512);	49,020✔
105	}
106
107	Group_Params group_param_from_string(std::string_view group_name) {	390✔
108	if(group_name == "secp256r1")	467✔
109	return Group_Params::SECP256R1;	51✔
110	if(group_name == "secp384r1")	380✔
111	return Group_Params::SECP384R1;	36✔
112	if(group_name == "secp521r1")	303✔
113	return Group_Params::SECP521R1;	41✔
114	if(group_name == "brainpool256r1")	278✔
115	return Group_Params::BRAINPOOL256R1;	21✔
116	if(group_name == "brainpool384r1")	249✔
117	return Group_Params::BRAINPOOL384R1;	8✔
118	if(group_name == "brainpool512r1")	233✔
119	return Group_Params::BRAINPOOL512R1;	8✔
120	if(group_name == "x25519")	241✔
121	return Group_Params::X25519;	60✔
122
123	if(group_name == "ffdhe/ietf/2048")	272✔
124	return Group_Params::FFDHE_2048;	42✔
125	if(group_name == "ffdhe/ietf/3072")	203✔
126	return Group_Params::FFDHE_3072;	27✔
127	if(group_name == "ffdhe/ietf/4096")	146✔
128	return Group_Params::FFDHE_4096;	30✔
129	if(group_name == "ffdhe/ietf/6144")	91✔
130	return Group_Params::FFDHE_6144;	25✔
131	if(group_name == "ffdhe/ietf/8192")	82✔
132	return Group_Params::FFDHE_8192;	25✔
133
134	return Group_Params::NONE; // unknown
135	}
136
137	std::string group_param_to_string(Group_Params group) {	647✔
138	switch(group) {	647✔
139	case Group_Params::SECP256R1:	450✔
140	return "secp256r1";	450✔
141	case Group_Params::SECP384R1:	67✔
142	return "secp384r1";	67✔
143	case Group_Params::SECP521R1:	30✔
144	return "secp521r1";	30✔
145	case Group_Params::BRAINPOOL256R1:	20✔
146	return "brainpool256r1";	20✔
147	case Group_Params::BRAINPOOL384R1:	8✔
148	return "brainpool384r1";	8✔
149	case Group_Params::BRAINPOOL512R1:	10✔
150	return "brainpool512r1";	10✔
151	case Group_Params::X25519:	12✔
152	return "x25519";	12✔
153
154	case Group_Params::FFDHE_2048:	22✔
155	return "ffdhe/ietf/2048";	22✔
156	case Group_Params::FFDHE_3072:	8✔
157	return "ffdhe/ietf/3072";	8✔
158	case Group_Params::FFDHE_4096:	8✔
159	return "ffdhe/ietf/4096";	8✔
160	case Group_Params::FFDHE_6144:	6✔
161	return "ffdhe/ietf/6144";	6✔
162	case Group_Params::FFDHE_8192:	6✔
163	return "ffdhe/ietf/8192";	6✔
164
165	default:	×
166	return "";	×
167	}
168	}
169
170	}

randombit / botan / 5079590438

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