Coverage Report

Created: 2021-02-21 07:20

/src/botan/src/lib/tls/tls_algos.cpp
Line
Count
Source (jump to first uncovered line)
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
#include <botan/exceptn.h>
9
10
namespace Botan {
11
12
namespace TLS {
13
14
std::string kdf_algo_to_string(KDF_Algo algo)
15
14.7k
   {
16
14.7k
   switch(algo)
17
14.7k
      {
18
2.87k
      case KDF_Algo::SHA_1:
19
2.87k
         return "SHA-1";
20
7.41k
      case KDF_Algo::SHA_256:
21
7.41k
         return "SHA-256";
22
4.43k
      case KDF_Algo::SHA_384:
23
4.43k
         return "SHA-384";
24
0
      }
25
26
0
   throw Invalid_State("kdf_algo_to_string unknown enum value");
27
0
   }
28
29
std::string kex_method_to_string(Kex_Algo method)
30
0
   {
31
0
   switch(method)
32
0
      {
33
0
      case Kex_Algo::STATIC_RSA:
34
0
         return "RSA";
35
0
      case Kex_Algo::DH:
36
0
         return "DH";
37
0
      case Kex_Algo::ECDH:
38
0
         return "ECDH";
39
0
      case Kex_Algo::CECPQ1:
40
0
         return "CECPQ1";
41
0
      case Kex_Algo::PSK:
42
0
         return "PSK";
43
0
      case Kex_Algo::ECDHE_PSK:
44
0
         return "ECDHE_PSK";
45
0
      }
46
47
0
   throw Invalid_State("kex_method_to_string unknown enum value");
48
0
   }
49
50
Kex_Algo kex_method_from_string(const std::string& str)
51
0
   {
52
0
   if(str == "RSA")
53
0
      return Kex_Algo::STATIC_RSA;
54
55
0
   if(str == "DH")
56
0
      return Kex_Algo::DH;
57
58
0
   if(str == "ECDH")
59
0
      return Kex_Algo::ECDH;
60
61
0
   if(str == "CECPQ1")
62
0
      return Kex_Algo::CECPQ1;
63
64
0
   if(str == "PSK")
65
0
      return Kex_Algo::PSK;
66
67
0
   if(str == "ECDHE_PSK")
68
0
      return Kex_Algo::ECDHE_PSK;
69
70
0
   throw Invalid_Argument("Unknown kex method " + str);
71
0
   }
72
73
std::string auth_method_to_string(Auth_Method method)
74
1.52k
   {
75
1.52k
   switch(method)
76
1.52k
      {
77
969
      case Auth_Method::RSA:
78
969
         return "RSA";
79
560
      case Auth_Method::ECDSA:
80
560
         return "ECDSA";
81
0
      case Auth_Method::IMPLICIT:
82
0
         return "IMPLICIT";
83
0
      }
84
85
0
    throw Invalid_State("auth_method_to_string unknown enum value");
86
0
   }
87
88
Auth_Method auth_method_from_string(const std::string& str)
89
0
   {
90
0
   if(str == "RSA")
91
0
      return Auth_Method::RSA;
92
0
   if(str == "ECDSA")
93
0
      return Auth_Method::ECDSA;
94
0
   if(str == "IMPLICIT")
95
0
      return Auth_Method::IMPLICIT;
96
97
0
   throw Invalid_Argument("Bad signature method " + str);
98
0
   }
99
100
bool group_param_is_dh(Group_Params group)
101
248k
   {
102
248k
   uint16_t group_id = static_cast<uint16_t>(group);
103
248k
   return (group_id >= 256 && group_id < 512);
104
248k
   }
105
106
Group_Params group_param_from_string(const std::string& group_name)
107
0
   {
108
0
   if(group_name == "secp256r1")
109
0
      return Group_Params::SECP256R1;
110
0
   if(group_name == "secp384r1")
111
0
      return Group_Params::SECP384R1;
112
0
   if(group_name == "secp521r1")
113
0
      return Group_Params::SECP521R1;
114
0
   if(group_name == "brainpool256r1")
115
0
      return Group_Params::BRAINPOOL256R1;
116
0
   if(group_name == "brainpool384r1")
117
0
      return Group_Params::BRAINPOOL384R1;
118
0
   if(group_name == "brainpool512r1")
119
0
      return Group_Params::BRAINPOOL512R1;
120
0
   if(group_name == "x25519")
121
0
      return Group_Params::X25519;
122
123
0
   if(group_name == "ffdhe/ietf/2048")
124
0
      return Group_Params::FFDHE_2048;
125
0
   if(group_name == "ffdhe/ietf/3072")
126
0
      return Group_Params::FFDHE_3072;
127
0
   if(group_name == "ffdhe/ietf/4096")
128
0
      return Group_Params::FFDHE_4096;
129
0
   if(group_name == "ffdhe/ietf/6144")
130
0
      return Group_Params::FFDHE_6144;
131
0
   if(group_name == "ffdhe/ietf/8192")
132
0
      return Group_Params::FFDHE_8192;
133
134
0
   return Group_Params::NONE; // unknown
135
0
   }
136
137
std::string group_param_to_string(Group_Params group)
138
21.0k
   {
139
21.0k
   switch(group)
140
21.0k
      {
141
1.59k
      case Group_Params::SECP256R1:
142
1.59k
         return "secp256r1";
143
2.14k
      case Group_Params::SECP384R1:
144
2.14k
         return "secp384r1";
145
10.4k
      case Group_Params::SECP521R1:
146
10.4k
         return "secp521r1";
147
1.59k
      case Group_Params::BRAINPOOL256R1:
148
1.59k
         return "brainpool256r1";
149
1.64k
      case Group_Params::BRAINPOOL384R1:
150
1.64k
         return "brainpool384r1";
151
3.60k
      case Group_Params::BRAINPOOL512R1:
152
3.60k
         return "brainpool512r1";
153
11
      case Group_Params::X25519:
154
11
         return "x25519";
155
156
2
      case Group_Params::FFDHE_2048:
157
2
         return "ffdhe/ietf/2048";
158
1
      case Group_Params::FFDHE_3072:
159
1
         return "ffdhe/ietf/3072";
160
1
      case Group_Params::FFDHE_4096:
161
1
         return "ffdhe/ietf/4096";
162
1
      case Group_Params::FFDHE_6144:
163
1
         return "ffdhe/ietf/6144";
164
1
      case Group_Params::FFDHE_8192:
165
1
         return "ffdhe/ietf/8192";
166
167
1
      default:
168
1
         return "";
169
21.0k
      }
170
21.0k
   }
171
172
173
std::string hash_function_of_scheme(Signature_Scheme scheme)
174
59.1k
   {
175
59.1k
   switch(scheme)
176
59.1k
      {
177
6.53k
      case Signature_Scheme::ECDSA_SHA256:
178
13.1k
      case Signature_Scheme::RSA_PKCS1_SHA256:
179
19.7k
      case Signature_Scheme::RSA_PSS_SHA256:
180
19.7k
         return "SHA-256";
181
182
6.58k
      case Signature_Scheme::ECDSA_SHA384:
183
13.2k
      case Signature_Scheme::RSA_PKCS1_SHA384:
184
19.8k
      case Signature_Scheme::RSA_PSS_SHA384:
185
19.8k
         return "SHA-384";
186
187
6.46k
      case Signature_Scheme::ECDSA_SHA512:
188
13.0k
      case Signature_Scheme::RSA_PKCS1_SHA512:
189
19.5k
      case Signature_Scheme::RSA_PSS_SHA512:
190
19.5k
         return "SHA-512";
191
192
0
      case Signature_Scheme::EDDSA_25519:
193
0
      case Signature_Scheme::EDDSA_448:
194
0
         return "Pure";
195
196
0
      case Signature_Scheme::NONE:
197
0
         return "";
198
0
      }
199
200
0
   throw Invalid_State("hash_function_of_scheme: Unknown signature algorithm enum");
201
0
   }
202
203
const std::vector<Signature_Scheme>& all_signature_schemes()
204
6.31k
   {
205
   /*
206
   * This is ordered in some approximate order of preference
207
   */
208
6.31k
   static const std::vector<Signature_Scheme> all_schemes = {
209
      //Signature_Scheme::EDDSA_448,
210
      //Signature_Scheme::EDDSA_25519,
211
212
6.31k
      Signature_Scheme::RSA_PSS_SHA384,
213
6.31k
      Signature_Scheme::RSA_PSS_SHA256,
214
6.31k
      Signature_Scheme::RSA_PSS_SHA512,
215
216
6.31k
      Signature_Scheme::RSA_PKCS1_SHA384,
217
6.31k
      Signature_Scheme::RSA_PKCS1_SHA512,
218
6.31k
      Signature_Scheme::RSA_PKCS1_SHA256,
219
220
6.31k
      Signature_Scheme::ECDSA_SHA384,
221
6.31k
      Signature_Scheme::ECDSA_SHA512,
222
6.31k
      Signature_Scheme::ECDSA_SHA256,
223
6.31k
   };
224
225
6.31k
   return all_schemes;
226
6.31k
   }
227
228
bool signature_scheme_is_known(Signature_Scheme scheme)
229
62.8k
   {
230
62.8k
   switch(scheme)
231
62.8k
      {
232
6.63k
      case Signature_Scheme::RSA_PKCS1_SHA256:
233
13.2k
      case Signature_Scheme::RSA_PKCS1_SHA384:
234
19.8k
      case Signature_Scheme::RSA_PKCS1_SHA512:
235
26.4k
      case Signature_Scheme::RSA_PSS_SHA256:
236
32.9k
      case Signature_Scheme::RSA_PSS_SHA384:
237
39.5k
      case Signature_Scheme::RSA_PSS_SHA512:
238
239
46.1k
      case Signature_Scheme::ECDSA_SHA256:
240
52.7k
      case Signature_Scheme::ECDSA_SHA384:
241
59.2k
      case Signature_Scheme::ECDSA_SHA512:
242
59.2k
         return true;
243
244
3.60k
      default:
245
3.60k
         return false;
246
62.8k
      }
247
248
62.8k
   }
249
250
std::string signature_algorithm_of_scheme(Signature_Scheme scheme)
251
58.2k
   {
252
58.2k
   switch(scheme)
253
58.2k
      {
254
6.54k
      case Signature_Scheme::RSA_PKCS1_SHA256:
255
13.0k
      case Signature_Scheme::RSA_PKCS1_SHA384:
256
19.4k
      case Signature_Scheme::RSA_PKCS1_SHA512:
257
25.9k
      case Signature_Scheme::RSA_PSS_SHA256:
258
32.3k
      case Signature_Scheme::RSA_PSS_SHA384:
259
38.7k
      case Signature_Scheme::RSA_PSS_SHA512:
260
38.7k
         return "RSA";
261
262
6.56k
      case Signature_Scheme::ECDSA_SHA256:
263
13.0k
      case Signature_Scheme::ECDSA_SHA384:
264
19.5k
      case Signature_Scheme::ECDSA_SHA512:
265
19.5k
         return "ECDSA";
266
267
1
      case Signature_Scheme::EDDSA_25519:
268
1
         return "Ed25519";
269
270
1
      case Signature_Scheme::EDDSA_448:
271
1
         return "Ed448";
272
273
0
      case Signature_Scheme::NONE:
274
0
         return "";
275
63
      }
276
277
63
   throw Invalid_State("signature_algorithm_of_scheme: Unknown signature algorithm enum");
278
63
   }
279
280
std::string sig_scheme_to_string(Signature_Scheme scheme)
281
0
   {
282
0
   switch(scheme)
283
0
      {
284
0
      case Signature_Scheme::RSA_PKCS1_SHA256:
285
0
         return "RSA_PKCS1_SHA256";
286
0
      case Signature_Scheme::RSA_PKCS1_SHA384:
287
0
         return "RSA_PKCS1_SHA384";
288
0
      case Signature_Scheme::RSA_PKCS1_SHA512:
289
0
         return "RSA_PKCS1_SHA512";
290
291
0
      case Signature_Scheme::ECDSA_SHA256:
292
0
         return "ECDSA_SHA256";
293
0
      case Signature_Scheme::ECDSA_SHA384:
294
0
         return "ECDSA_SHA384";
295
0
      case Signature_Scheme::ECDSA_SHA512:
296
0
         return "ECDSA_SHA512";
297
298
0
      case Signature_Scheme::RSA_PSS_SHA256:
299
0
         return "RSA_PSS_SHA256";
300
0
      case Signature_Scheme::RSA_PSS_SHA384:
301
0
         return "RSA_PSS_SHA384";
302
0
      case Signature_Scheme::RSA_PSS_SHA512:
303
0
         return "RSA_PSS_SHA512";
304
305
0
      case Signature_Scheme::EDDSA_25519:
306
0
         return "EDDSA_25519";
307
0
      case Signature_Scheme::EDDSA_448:
308
0
         return "EDDSA_448";
309
310
0
      case Signature_Scheme::NONE:
311
0
         return "";
312
0
      }
313
314
0
   throw Invalid_State("sig_scheme_to_string: Unknown signature algorithm enum");
315
0
   }
316
317
std::string padding_string_for_scheme(Signature_Scheme scheme)
318
229
   {
319
229
   switch(scheme)
320
229
      {
321
1
      case Signature_Scheme::RSA_PKCS1_SHA256:
322
1
         return "EMSA_PKCS1(SHA-256)";
323
2
      case Signature_Scheme::RSA_PKCS1_SHA384:
324
2
         return "EMSA_PKCS1(SHA-384)";
325
2
      case Signature_Scheme::RSA_PKCS1_SHA512:
326
2
         return "EMSA_PKCS1(SHA-512)";
327
328
110
      case Signature_Scheme::ECDSA_SHA256:
329
110
         return "EMSA1(SHA-256)";
330
68
      case Signature_Scheme::ECDSA_SHA384:
331
68
         return "EMSA1(SHA-384)";
332
20
      case Signature_Scheme::ECDSA_SHA512:
333
20
         return "EMSA1(SHA-512)";
334
335
8
      case Signature_Scheme::RSA_PSS_SHA256:
336
8
         return "PSSR(SHA-256,MGF1,32)";
337
8
      case Signature_Scheme::RSA_PSS_SHA384:
338
8
         return "PSSR(SHA-384,MGF1,48)";
339
10
      case Signature_Scheme::RSA_PSS_SHA512:
340
10
         return "PSSR(SHA-512,MGF1,64)";
341
342
0
      case Signature_Scheme::EDDSA_25519:
343
0
         return "Pure";
344
0
      case Signature_Scheme::EDDSA_448:
345
0
         return "Pure";
346
347
0
      case Signature_Scheme::NONE:
348
0
         return "";
349
0
      }
350
351
0
   throw Invalid_State("padding_string_for_scheme: Unknown signature algorithm enum");
352
0
   }
353
354
}
355
356
}