/src/botan/src/lib/tls/tls_algos.cpp

Source (jump to first uncovered line)
/*
* (C) 2017 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include <botan/tls_algos.h>
#include <botan/exceptn.h>

namespace Botan {

namespace 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::CECPQ1:
         return "CECPQ1";
      case Kex_Algo::PSK:
         return "PSK";
      case Kex_Algo::ECDHE_PSK:
         return "ECDHE_PSK";
      }

   throw Invalid_State("kex_method_to_string unknown enum value");
   }

Kex_Algo kex_method_from_string(const std::string& 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 == "CECPQ1")
      return Kex_Algo::CECPQ1;

   if(str == "PSK")
      return Kex_Algo::PSK;

   if(str == "ECDHE_PSK")
      return Kex_Algo::ECDHE_PSK;

   throw Invalid_Argument("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";
      }

    throw Invalid_State("auth_method_to_string unknown enum value");
   }

Auth_Method auth_method_from_string(const std::string& str)
   {
   if(str == "RSA")
      return Auth_Method::RSA;
   if(str == "ECDSA")
      return Auth_Method::ECDSA;
   if(str == "IMPLICIT")
      return Auth_Method::IMPLICIT;

   throw Invalid_Argument("Bad 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(const std::string& 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 "";
      }
   }


std::string hash_function_of_scheme(Signature_Scheme scheme)
   {
   switch(scheme)
      {
      case Signature_Scheme::ECDSA_SHA1:
      case Signature_Scheme::RSA_PKCS1_SHA1:
         return "SHA-1";

      case Signature_Scheme::ECDSA_SHA256:
      case Signature_Scheme::RSA_PKCS1_SHA256:
      case Signature_Scheme::RSA_PSS_SHA256:
         return "SHA-256";

      case Signature_Scheme::ECDSA_SHA384:
      case Signature_Scheme::RSA_PKCS1_SHA384:
      case Signature_Scheme::RSA_PSS_SHA384:
         return "SHA-384";

      case Signature_Scheme::ECDSA_SHA512:
      case Signature_Scheme::RSA_PKCS1_SHA512:
      case Signature_Scheme::RSA_PSS_SHA512:
         return "SHA-512";

      case Signature_Scheme::EDDSA_25519:
      case Signature_Scheme::EDDSA_448:
         return "Pure";

      case Signature_Scheme::NONE:
         return "";
      }

   throw Invalid_State("hash_function_of_scheme: Unknown signature algorithm enum");
   }

const std::vector<Signature_Scheme>& all_signature_schemes()
   {
   /*
   * This is ordered in some approximate order of preference
   */
   static const std::vector<Signature_Scheme> all_schemes = {
      //Signature_Scheme::EDDSA_448,
      //Signature_Scheme::EDDSA_25519,

      Signature_Scheme::RSA_PSS_SHA384,
      Signature_Scheme::RSA_PSS_SHA256,
      Signature_Scheme::RSA_PSS_SHA512,

      Signature_Scheme::RSA_PKCS1_SHA384,
      Signature_Scheme::RSA_PKCS1_SHA512,
      Signature_Scheme::RSA_PKCS1_SHA256,

      Signature_Scheme::ECDSA_SHA384,
      Signature_Scheme::ECDSA_SHA512,
      Signature_Scheme::ECDSA_SHA256,

      Signature_Scheme::RSA_PKCS1_SHA1,
      Signature_Scheme::ECDSA_SHA1,
   };

   return all_schemes;
   }

bool signature_scheme_is_known(Signature_Scheme scheme)
   {
   switch(scheme)
      {
      case Signature_Scheme::RSA_PKCS1_SHA1:
      case Signature_Scheme::RSA_PKCS1_SHA256:
      case Signature_Scheme::RSA_PKCS1_SHA384:
      case Signature_Scheme::RSA_PKCS1_SHA512:
      case Signature_Scheme::RSA_PSS_SHA256:
      case Signature_Scheme::RSA_PSS_SHA384:
      case Signature_Scheme::RSA_PSS_SHA512:

      case Signature_Scheme::ECDSA_SHA1:
      case Signature_Scheme::ECDSA_SHA256:
      case Signature_Scheme::ECDSA_SHA384:
      case Signature_Scheme::ECDSA_SHA512:
         return true;

      default:
         return false;
      }

   }

std::string signature_algorithm_of_scheme(Signature_Scheme scheme)
   {
   switch(scheme)
      {
      case Signature_Scheme::RSA_PKCS1_SHA1:
      case Signature_Scheme::RSA_PKCS1_SHA256:
      case Signature_Scheme::RSA_PKCS1_SHA384:
      case Signature_Scheme::RSA_PKCS1_SHA512:
      case Signature_Scheme::RSA_PSS_SHA256:
      case Signature_Scheme::RSA_PSS_SHA384:
      case Signature_Scheme::RSA_PSS_SHA512:
         return "RSA";

      case Signature_Scheme::ECDSA_SHA1:
      case Signature_Scheme::ECDSA_SHA256:
      case Signature_Scheme::ECDSA_SHA384:
      case Signature_Scheme::ECDSA_SHA512:
         return "ECDSA";

      case Signature_Scheme::EDDSA_25519:
         return "Ed25519";

      case Signature_Scheme::EDDSA_448:
         return "Ed448";

      case Signature_Scheme::NONE:
         return "";
      }

   throw Invalid_State("signature_algorithm_of_scheme: Unknown signature algorithm enum");
   }

std::string sig_scheme_to_string(Signature_Scheme scheme)
   {
   switch(scheme)
      {
      case Signature_Scheme::RSA_PKCS1_SHA1:
         return "RSA_PKCS1_SHA1";
      case Signature_Scheme::RSA_PKCS1_SHA256:
         return "RSA_PKCS1_SHA256";
      case Signature_Scheme::RSA_PKCS1_SHA384:
         return "RSA_PKCS1_SHA384";
      case Signature_Scheme::RSA_PKCS1_SHA512:
         return "RSA_PKCS1_SHA512";

      case Signature_Scheme::ECDSA_SHA1:
         return "ECDSA_SHA1";
      case Signature_Scheme::ECDSA_SHA256:
         return "ECDSA_SHA256";
      case Signature_Scheme::ECDSA_SHA384:
         return "ECDSA_SHA384";
      case Signature_Scheme::ECDSA_SHA512:
         return "ECDSA_SHA512";

      case Signature_Scheme::RSA_PSS_SHA256:
         return "RSA_PSS_SHA256";
      case Signature_Scheme::RSA_PSS_SHA384:
         return "RSA_PSS_SHA384";
      case Signature_Scheme::RSA_PSS_SHA512:
         return "RSA_PSS_SHA512";

      case Signature_Scheme::EDDSA_25519:
         return "EDDSA_25519";
      case Signature_Scheme::EDDSA_448:
         return "EDDSA_448";

      case Signature_Scheme::NONE:
         return "";
      }

   throw Invalid_State("sig_scheme_to_string: Unknown signature algorithm enum");
   }

std::string padding_string_for_scheme(Signature_Scheme scheme)
   {
   switch(scheme)
      {
      case Signature_Scheme::RSA_PKCS1_SHA1:
         return "EMSA_PKCS1(SHA-1)";
      case Signature_Scheme::RSA_PKCS1_SHA256:
         return "EMSA_PKCS1(SHA-256)";
      case Signature_Scheme::RSA_PKCS1_SHA384:
         return "EMSA_PKCS1(SHA-384)";
      case Signature_Scheme::RSA_PKCS1_SHA512:
         return "EMSA_PKCS1(SHA-512)";

      case Signature_Scheme::ECDSA_SHA1:
         return "EMSA1(SHA-1)";
      case Signature_Scheme::ECDSA_SHA256:
         return "EMSA1(SHA-256)";
      case Signature_Scheme::ECDSA_SHA384:
         return "EMSA1(SHA-384)";
      case Signature_Scheme::ECDSA_SHA512:
         return "EMSA1(SHA-512)";

      case Signature_Scheme::RSA_PSS_SHA256:
         return "PSSR(SHA-256,MGF1,32)";
      case Signature_Scheme::RSA_PSS_SHA384:
         return "PSSR(SHA-384,MGF1,48)";
      case Signature_Scheme::RSA_PSS_SHA512:
         return "PSSR(SHA-512,MGF1,64)";

      case Signature_Scheme::EDDSA_25519:
         return "Pure";
      case Signature_Scheme::EDDSA_448:
         return "Pure";

      case Signature_Scheme::NONE:
         return "";
      }

   throw Invalid_State("padding_string_for_scheme: Unknown signature algorithm enum");
   }

}

}

Coverage Report

Created: 2021-01-13 07:05

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	12.1k	{
16	12.1k	switch(algo)
17	12.1k	{
18	2.69k	case KDF_Algo::SHA_1:
19	2.69k	return "SHA-1";
20	5.96k	case KDF_Algo::SHA_256:
21	5.96k	return "SHA-256";
22	3.47k	case KDF_Algo::SHA_384:
23	3.47k	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	3.96k	{
75	3.96k	switch(method)
76	3.96k	{
77	3.37k	case Auth_Method::RSA:
78	3.37k	return "RSA";
79	586	case Auth_Method::ECDSA:
80	586	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	251k	{
102	251k	uint16_t group_id = static_cast<uint16_t>(group);
103	251k	return (group_id >= 256 && group_id < 512);
104	251k	}
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.3k	{
139	21.3k	switch(group)
140	21.3k	{
141	1.19k	case Group_Params::SECP256R1:
142	1.19k	return "secp256r1";
143	1.43k	case Group_Params::SECP384R1:
144	1.43k	return "secp384r1";
145	11.6k	case Group_Params::SECP521R1:
146	11.6k	return "secp521r1";
147	1.86k	case Group_Params::BRAINPOOL256R1:
148	1.86k	return "brainpool256r1";
149	2.10k	case Group_Params::BRAINPOOL384R1:
150	2.10k	return "brainpool384r1";
151	3.07k	case Group_Params::BRAINPOOL512R1:
152	3.07k	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.3k	}
170	21.3k	}
171
172
173		std::string hash_function_of_scheme(Signature_Scheme scheme)
174	76.8k	{
175	76.8k	switch(scheme)
176	76.8k	{
177	14.9k	case Signature_Scheme::ECDSA_SHA1:
178	14.9k	case Signature_Scheme::RSA_PKCS1_SHA1:
179	14.9k	return "SHA-1";
180
181	20.8k	case Signature_Scheme::ECDSA_SHA256:
182	20.8k	case Signature_Scheme::RSA_PKCS1_SHA256:
183	20.8k	case Signature_Scheme::RSA_PSS_SHA256:
184	20.8k	return "SHA-256";
185
186	20.7k	case Signature_Scheme::ECDSA_SHA384:
187	20.7k	case Signature_Scheme::RSA_PKCS1_SHA384:
188	20.7k	case Signature_Scheme::RSA_PSS_SHA384:
189	20.7k	return "SHA-384";
190
191	20.3k	case Signature_Scheme::ECDSA_SHA512:
192	20.3k	case Signature_Scheme::RSA_PKCS1_SHA512:
193	20.3k	case Signature_Scheme::RSA_PSS_SHA512:
194	20.3k	return "SHA-512";
195
196	0	case Signature_Scheme::EDDSA_25519:
197	0	case Signature_Scheme::EDDSA_448:
198	0	return "Pure";
199
200	0	case Signature_Scheme::NONE:
201	0	return "";
202	0	}
203
204	0	throw Invalid_State("hash_function_of_scheme: Unknown signature algorithm enum");
205	0	}
206
207		const std::vector<Signature_Scheme>& all_signature_schemes()
208	6.56k	{
209		/*
210		* This is ordered in some approximate order of preference
211		*/
212	6.56k	static const std::vector<Signature_Scheme> all_schemes = {
213		//Signature_Scheme::EDDSA_448,
214		//Signature_Scheme::EDDSA_25519,
215
216	6.56k	Signature_Scheme::RSA_PSS_SHA384,
217	6.56k	Signature_Scheme::RSA_PSS_SHA256,
218	6.56k	Signature_Scheme::RSA_PSS_SHA512,
219
220	6.56k	Signature_Scheme::RSA_PKCS1_SHA384,
221	6.56k	Signature_Scheme::RSA_PKCS1_SHA512,
222	6.56k	Signature_Scheme::RSA_PKCS1_SHA256,
223
224	6.56k	Signature_Scheme::ECDSA_SHA384,
225	6.56k	Signature_Scheme::ECDSA_SHA512,
226	6.56k	Signature_Scheme::ECDSA_SHA256,
227
228	6.56k	Signature_Scheme::RSA_PKCS1_SHA1,
229	6.56k	Signature_Scheme::ECDSA_SHA1,
230	6.56k	};
231
232	6.56k	return all_schemes;
233	6.56k	}
234
235		bool signature_scheme_is_known(Signature_Scheme scheme)
236	81.9k	{
237	81.9k	switch(scheme)
238	81.9k	{
239	77.2k	case Signature_Scheme::RSA_PKCS1_SHA1:
240	77.2k	case Signature_Scheme::RSA_PKCS1_SHA256:
241	77.2k	case Signature_Scheme::RSA_PKCS1_SHA384:
242	77.2k	case Signature_Scheme::RSA_PKCS1_SHA512:
243	77.2k	case Signature_Scheme::RSA_PSS_SHA256:
244	77.2k	case Signature_Scheme::RSA_PSS_SHA384:
245	77.2k	case Signature_Scheme::RSA_PSS_SHA512:
246
247	77.2k	case Signature_Scheme::ECDSA_SHA1:
248	77.2k	case Signature_Scheme::ECDSA_SHA256:
249	77.2k	case Signature_Scheme::ECDSA_SHA384:
250	77.2k	case Signature_Scheme::ECDSA_SHA512:
251	77.2k	return true;
252
253	4.74k	default:
254	4.74k	return false;
255	81.9k	}
256
257	81.9k	}
258
259		std::string signature_algorithm_of_scheme(Signature_Scheme scheme)
260	76.0k	{
261	76.0k	switch(scheme)
262	76.0k	{
263	48.9k	case Signature_Scheme::RSA_PKCS1_SHA1:
264	48.9k	case Signature_Scheme::RSA_PKCS1_SHA256:
265	48.9k	case Signature_Scheme::RSA_PKCS1_SHA384:
266	48.9k	case Signature_Scheme::RSA_PKCS1_SHA512:
267	48.9k	case Signature_Scheme::RSA_PSS_SHA256:
268	48.9k	case Signature_Scheme::RSA_PSS_SHA384:
269	48.9k	case Signature_Scheme::RSA_PSS_SHA512:
270	48.9k	return "RSA";
271
272	27.0k	case Signature_Scheme::ECDSA_SHA1:
273	27.0k	case Signature_Scheme::ECDSA_SHA256:
274	27.0k	case Signature_Scheme::ECDSA_SHA384:
275	27.0k	case Signature_Scheme::ECDSA_SHA512:
276	27.0k	return "ECDSA";
277
278	1	case Signature_Scheme::EDDSA_25519:
279	1	return "Ed25519";
280
281	1	case Signature_Scheme::EDDSA_448:
282	1	return "Ed448";
283
284	0	case Signature_Scheme::NONE:
285	0	return "";
286	58	}
287
288	58	throw Invalid_State("signature_algorithm_of_scheme: Unknown signature algorithm enum");
289	58	}
290
291		std::string sig_scheme_to_string(Signature_Scheme scheme)
292	0	{
293	0	switch(scheme)
294	0	{
295	0	case Signature_Scheme::RSA_PKCS1_SHA1:
296	0	return "RSA_PKCS1_SHA1";
297	0	case Signature_Scheme::RSA_PKCS1_SHA256:
298	0	return "RSA_PKCS1_SHA256";
299	0	case Signature_Scheme::RSA_PKCS1_SHA384:
300	0	return "RSA_PKCS1_SHA384";
301	0	case Signature_Scheme::RSA_PKCS1_SHA512:
302	0	return "RSA_PKCS1_SHA512";
303
304	0	case Signature_Scheme::ECDSA_SHA1:
305	0	return "ECDSA_SHA1";
306	0	case Signature_Scheme::ECDSA_SHA256:
307	0	return "ECDSA_SHA256";
308	0	case Signature_Scheme::ECDSA_SHA384:
309	0	return "ECDSA_SHA384";
310	0	case Signature_Scheme::ECDSA_SHA512:
311	0	return "ECDSA_SHA512";
312
313	0	case Signature_Scheme::RSA_PSS_SHA256:
314	0	return "RSA_PSS_SHA256";
315	0	case Signature_Scheme::RSA_PSS_SHA384:
316	0	return "RSA_PSS_SHA384";
317	0	case Signature_Scheme::RSA_PSS_SHA512:
318	0	return "RSA_PSS_SHA512";
319
320	0	case Signature_Scheme::EDDSA_25519:
321	0	return "EDDSA_25519";
322	0	case Signature_Scheme::EDDSA_448:
323	0	return "EDDSA_448";
324
325	0	case Signature_Scheme::NONE:
326	0	return "";
327	0	}
328
329	0	throw Invalid_State("sig_scheme_to_string: Unknown signature algorithm enum");
330	0	}
331
332		std::string padding_string_for_scheme(Signature_Scheme scheme)
333	247	{
334	247	switch(scheme)
335	247	{
336	0	case Signature_Scheme::RSA_PKCS1_SHA1:
337	0	return "EMSA_PKCS1(SHA-1)";
338	1	case Signature_Scheme::RSA_PKCS1_SHA256:
339	1	return "EMSA_PKCS1(SHA-256)";
340	1	case Signature_Scheme::RSA_PKCS1_SHA384:
341	1	return "EMSA_PKCS1(SHA-384)";
342	1	case Signature_Scheme::RSA_PKCS1_SHA512:
343	1	return "EMSA_PKCS1(SHA-512)";
344
345	0	case Signature_Scheme::ECDSA_SHA1:
346	0	return "EMSA1(SHA-1)";
347	154	case Signature_Scheme::ECDSA_SHA256:
348	154	return "EMSA1(SHA-256)";
349	48	case Signature_Scheme::ECDSA_SHA384:
350	48	return "EMSA1(SHA-384)";
351	16	case Signature_Scheme::ECDSA_SHA512:
352	16	return "EMSA1(SHA-512)";
353
354	13	case Signature_Scheme::RSA_PSS_SHA256:
355	13	return "PSSR(SHA-256,MGF1,32)";
356	6	case Signature_Scheme::RSA_PSS_SHA384:
357	6	return "PSSR(SHA-384,MGF1,48)";
358	7	case Signature_Scheme::RSA_PSS_SHA512:
359	7	return "PSSR(SHA-512,MGF1,64)";
360
361	0	case Signature_Scheme::EDDSA_25519:
362	0	return "Pure";
363	0	case Signature_Scheme::EDDSA_448:
364	0	return "Pure";
365
366	0	case Signature_Scheme::NONE:
367	0	return "";
368	0	}
369
370	0	throw Invalid_State("padding_string_for_scheme: Unknown signature algorithm enum");
371	0	}
372
373		}
374
375		}