/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::SRP_SHA:
         return "SRP_SHA";
      case Kex_Algo::PSK:
         return "PSK";
      case Kex_Algo::DHE_PSK:
         return "DHE_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 == "SRP_SHA")
      return Kex_Algo::SRP_SHA;

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

   if(str == "DHE_PSK")
      return Kex_Algo::DHE_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::DSA:
         return "DSA";
      case Auth_Method::ECDSA:
         return "ECDSA";
      case Auth_Method::IMPLICIT:
         return "IMPLICIT";
      case Auth_Method::ANONYMOUS:
         return "ANONYMOUS";
      }

    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 == "DSA")
      return Auth_Method::DSA;
   if(str == "ECDSA")
      return Auth_Method::ECDSA;
   if(str == "IMPLICIT")
      return Auth_Method::IMPLICIT;
   if(str == "ANONYMOUS" || str == "")
      return Auth_Method::ANONYMOUS;

   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::DSA_SHA1:
      case Signature_Scheme::ECDSA_SHA1:
      case Signature_Scheme::RSA_PKCS1_SHA1:
         return "SHA-1";

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

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

      case Signature_Scheme::DSA_SHA512:
      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::DSA_SHA384,
      Signature_Scheme::DSA_SHA512,
      Signature_Scheme::DSA_SHA256,

      Signature_Scheme::RSA_PKCS1_SHA1,
      Signature_Scheme::ECDSA_SHA1,
      Signature_Scheme::DSA_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::DSA_SHA1:
      case Signature_Scheme::DSA_SHA256:
      case Signature_Scheme::DSA_SHA384:
      case Signature_Scheme::DSA_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::DSA_SHA1:
      case Signature_Scheme::DSA_SHA256:
      case Signature_Scheme::DSA_SHA384:
      case Signature_Scheme::DSA_SHA512:
         return "DSA";

      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::DSA_SHA1:
         return "DSA_SHA1";
      case Signature_Scheme::DSA_SHA256:
         return "DSA_SHA256";
      case Signature_Scheme::DSA_SHA384:
         return "DSA_SHA384";
      case Signature_Scheme::DSA_SHA512:
         return "DSA_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::DSA_SHA1:
      case Signature_Scheme::ECDSA_SHA1:
         return "EMSA1(SHA-1)";
      case Signature_Scheme::DSA_SHA256:
      case Signature_Scheme::ECDSA_SHA256:
         return "EMSA1(SHA-256)";
      case Signature_Scheme::DSA_SHA384:
      case Signature_Scheme::ECDSA_SHA384:
         return "EMSA1(SHA-384)";
      case Signature_Scheme::DSA_SHA512:
      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: 2020-02-14 15:38

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	19.2k	{
16	19.2k	switch(algo)
17	19.2k	{
18	19.2k	case KDF_Algo::SHA_1:
19	4.93k	return "SHA-1";
20	19.2k	case KDF_Algo::SHA_256:
21	6.61k	return "SHA-256";
22	19.2k	case KDF_Algo::SHA_384:
23	7.73k	return "SHA-384";
24	0	}
25	0
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::SRP_SHA:
42	0	return "SRP_SHA";
43	0	case Kex_Algo::PSK:
44	0	return "PSK";
45	0	case Kex_Algo::DHE_PSK:
46	0	return "DHE_PSK";
47	0	case Kex_Algo::ECDHE_PSK:
48	0	return "ECDHE_PSK";
49	0	}
50	0
51	0	throw Invalid_State("kex_method_to_string unknown enum value");
52	0	}
53
54		Kex_Algo kex_method_from_string(const std::string& str)
55	0	{
56	0	if(str == "RSA")
57	0	return Kex_Algo::STATIC_RSA;
58	0
59	0	if(str == "DH")
60	0	return Kex_Algo::DH;
61	0
62	0	if(str == "ECDH")
63	0	return Kex_Algo::ECDH;
64	0
65	0	if(str == "CECPQ1")
66	0	return Kex_Algo::CECPQ1;
67	0
68	0	if(str == "SRP_SHA")
69	0	return Kex_Algo::SRP_SHA;
70	0
71	0	if(str == "PSK")
72	0	return Kex_Algo::PSK;
73	0
74	0	if(str == "DHE_PSK")
75	0	return Kex_Algo::DHE_PSK;
76	0
77	0	if(str == "ECDHE_PSK")
78	0	return Kex_Algo::ECDHE_PSK;
79	0
80	0	throw Invalid_Argument("Unknown kex method " + str);
81	0	}
82
83		std::string auth_method_to_string(Auth_Method method)
84	4.16k	{
85	4.16k	switch(method)
86	4.16k	{
87	4.16k	case Auth_Method::RSA:
88	2.94k	return "RSA";
89	4.16k	case Auth_Method::DSA:
90	504	return "DSA";
91	4.16k	case Auth_Method::ECDSA:
92	718	return "ECDSA";
93	4.16k	case Auth_Method::IMPLICIT:
94	0	return "IMPLICIT";
95	4.16k	case Auth_Method::ANONYMOUS:
96	0	return "ANONYMOUS";
97	0	}
98	0
99	0	throw Invalid_State("auth_method_to_string unknown enum value");
100	0	}
101
102		Auth_Method auth_method_from_string(const std::string& str)
103	0	{
104	0	if(str == "RSA")
105	0	return Auth_Method::RSA;
106	0	if(str == "DSA")
107	0	return Auth_Method::DSA;
108	0	if(str == "ECDSA")
109	0	return Auth_Method::ECDSA;
110	0	if(str == "IMPLICIT")
111	0	return Auth_Method::IMPLICIT;
112	0	if(str == "ANONYMOUS" \|\| str == "")
113	0	return Auth_Method::ANONYMOUS;
114	0
115	0	throw Invalid_Argument("Bad signature method " + str);
116	0	}
117
118		bool group_param_is_dh(Group_Params group)
119	264k	{
120	264k	uint16_t group_id = static_cast<uint16_t>(group);
121	264k	return (group_id >= 256 && group_id < 512);
122	264k	}
123
124		Group_Params group_param_from_string(const std::string& group_name)
125	0	{
126	0	if(group_name == "secp256r1")
127	0	return Group_Params::SECP256R1;
128	0	if(group_name == "secp384r1")
129	0	return Group_Params::SECP384R1;
130	0	if(group_name == "secp521r1")
131	0	return Group_Params::SECP521R1;
132	0	if(group_name == "brainpool256r1")
133	0	return Group_Params::BRAINPOOL256R1;
134	0	if(group_name == "brainpool384r1")
135	0	return Group_Params::BRAINPOOL384R1;
136	0	if(group_name == "brainpool512r1")
137	0	return Group_Params::BRAINPOOL512R1;
138	0	if(group_name == "x25519")
139	0	return Group_Params::X25519;
140	0
141	0	if(group_name == "ffdhe/ietf/2048")
142	0	return Group_Params::FFDHE_2048;
143	0	if(group_name == "ffdhe/ietf/3072")
144	0	return Group_Params::FFDHE_3072;
145	0	if(group_name == "ffdhe/ietf/4096")
146	0	return Group_Params::FFDHE_4096;
147	0	if(group_name == "ffdhe/ietf/6144")
148	0	return Group_Params::FFDHE_6144;
149	0	if(group_name == "ffdhe/ietf/8192")
150	0	return Group_Params::FFDHE_8192;
151	0
152	0	return Group_Params::NONE; // unknown
153	0	}
154
155		std::string group_param_to_string(Group_Params group)
156	22.5k	{
157	22.5k	switch(group)
158	22.5k	{
159	22.5k	case Group_Params::SECP256R1:
160	2.61k	return "secp256r1";
161	22.5k	case Group_Params::SECP384R1:
162	2.23k	return "secp384r1";
163	22.5k	case Group_Params::SECP521R1:
164	7.36k	return "secp521r1";
165	22.5k	case Group_Params::BRAINPOOL256R1:
166	1.07k	return "brainpool256r1";
167	22.5k	case Group_Params::BRAINPOOL384R1:
168	884	return "brainpool384r1";
169	22.5k	case Group_Params::BRAINPOOL512R1:
170	1.75k	return "brainpool512r1";
171	22.5k	case Group_Params::X25519:
172	9	return "x25519";
173	22.5k
174	22.5k	case Group_Params::FFDHE_2048:
175	4.46k	return "ffdhe/ietf/2048";
176	22.5k	case Group_Params::FFDHE_3072:
177	885	return "ffdhe/ietf/3072";
178	22.5k	case Group_Params::FFDHE_4096:
179	905	return "ffdhe/ietf/4096";
180	22.5k	case Group_Params::FFDHE_6144:
181	155	return "ffdhe/ietf/6144";
182	22.5k	case Group_Params::FFDHE_8192:
183	177	return "ffdhe/ietf/8192";
184	22.5k
185	22.5k	default:
186	1	return "";
187	22.5k	}
188	22.5k	}
189
190
191		std::string hash_function_of_scheme(Signature_Scheme scheme)
192	95.2k	{
193	95.2k	switch(scheme)
194	95.2k	{
195	95.2k	case Signature_Scheme::DSA_SHA1:
196	19.6k	case Signature_Scheme::ECDSA_SHA1:
197	19.6k	case Signature_Scheme::RSA_PKCS1_SHA1:
198	19.6k	return "SHA-1";
199	19.6k
200	25.3k	case Signature_Scheme::DSA_SHA256:
201	25.3k	case Signature_Scheme::ECDSA_SHA256:
202	25.3k	case Signature_Scheme::RSA_PKCS1_SHA256:
203	25.3k	case Signature_Scheme::RSA_PSS_SHA256:
204	25.3k	return "SHA-256";
205	25.3k
206	25.3k	case Signature_Scheme::DSA_SHA384:
207	25.3k	case Signature_Scheme::ECDSA_SHA384:
208	25.3k	case Signature_Scheme::RSA_PKCS1_SHA384:
209	25.3k	case Signature_Scheme::RSA_PSS_SHA384:
210	25.3k	return "SHA-384";
211	25.3k
212	25.3k	case Signature_Scheme::DSA_SHA512:
213	24.9k	case Signature_Scheme::ECDSA_SHA512:
214	24.9k	case Signature_Scheme::RSA_PKCS1_SHA512:
215	24.9k	case Signature_Scheme::RSA_PSS_SHA512:
216	24.9k	return "SHA-512";
217	24.9k
218	24.9k	case Signature_Scheme::EDDSA_25519:
219	0	case Signature_Scheme::EDDSA_448:
220	0	return "Pure";
221	0
222	0	case Signature_Scheme::NONE:
223	0	return "";
224	0	}
225	0
226	0	throw Invalid_State("hash_function_of_scheme: Unknown signature algorithm enum");
227	0	}
228
229		const std::vector<Signature_Scheme>& all_signature_schemes()
230	6.05k	{
231	6.05k	/*
232	6.05k	* This is ordered in some approximate order of preference
233	6.05k	*/
234	6.05k	static const std::vector<Signature_Scheme> all_schemes = {
235	6.05k	//Signature_Scheme::EDDSA_448,
236	6.05k	//Signature_Scheme::EDDSA_25519,
237	6.05k
238	6.05k	Signature_Scheme::RSA_PSS_SHA384,
239	6.05k	Signature_Scheme::RSA_PSS_SHA256,
240	6.05k	Signature_Scheme::RSA_PSS_SHA512,
241	6.05k
242	6.05k	Signature_Scheme::RSA_PKCS1_SHA384,
243	6.05k	Signature_Scheme::RSA_PKCS1_SHA512,
244	6.05k	Signature_Scheme::RSA_PKCS1_SHA256,
245	6.05k
246	6.05k	Signature_Scheme::ECDSA_SHA384,
247	6.05k	Signature_Scheme::ECDSA_SHA512,
248	6.05k	Signature_Scheme::ECDSA_SHA256,
249	6.05k
250	6.05k	Signature_Scheme::DSA_SHA384,
251	6.05k	Signature_Scheme::DSA_SHA512,
252	6.05k	Signature_Scheme::DSA_SHA256,
253	6.05k
254	6.05k	Signature_Scheme::RSA_PKCS1_SHA1,
255	6.05k	Signature_Scheme::ECDSA_SHA1,
256	6.05k	Signature_Scheme::DSA_SHA1,
257	6.05k	};
258	6.05k
259	6.05k	return all_schemes;
260	6.05k	}
261
262		bool signature_scheme_is_known(Signature_Scheme scheme)
263	100k	{
264	100k	switch(scheme)
265	100k	{
266	100k	case Signature_Scheme::RSA_PKCS1_SHA1:
267	95.7k	case Signature_Scheme::RSA_PKCS1_SHA256:
268	95.7k	case Signature_Scheme::RSA_PKCS1_SHA384:
269	95.7k	case Signature_Scheme::RSA_PKCS1_SHA512:
270	95.7k	case Signature_Scheme::RSA_PSS_SHA256:
271	95.7k	case Signature_Scheme::RSA_PSS_SHA384:
272	95.7k	case Signature_Scheme::RSA_PSS_SHA512:
273	95.7k
274	95.7k	case Signature_Scheme::DSA_SHA1:
275	95.7k	case Signature_Scheme::DSA_SHA256:
276	95.7k	case Signature_Scheme::DSA_SHA384:
277	95.7k	case Signature_Scheme::DSA_SHA512:
278	95.7k
279	95.7k	case Signature_Scheme::ECDSA_SHA1:
280	95.7k	case Signature_Scheme::ECDSA_SHA256:
281	95.7k	case Signature_Scheme::ECDSA_SHA384:
282	95.7k	case Signature_Scheme::ECDSA_SHA512:
283	95.7k	return true;
284	95.7k
285	95.7k	default:
286	4.90k	return false;
287	100k	}
288	100k
289	100k	}
290
291		std::string signature_algorithm_of_scheme(Signature_Scheme scheme)
292	94.4k	{
293	94.4k	switch(scheme)
294	94.4k	{
295	94.4k	case Signature_Scheme::RSA_PKCS1_SHA1:
296	44.9k	case Signature_Scheme::RSA_PKCS1_SHA256:
297	44.9k	case Signature_Scheme::RSA_PKCS1_SHA384:
298	44.9k	case Signature_Scheme::RSA_PKCS1_SHA512:
299	44.9k	case Signature_Scheme::RSA_PSS_SHA256:
300	44.9k	case Signature_Scheme::RSA_PSS_SHA384:
301	44.9k	case Signature_Scheme::RSA_PSS_SHA512:
302	44.9k	return "RSA";
303	44.9k
304	44.9k	case Signature_Scheme::DSA_SHA1:
305	24.5k	case Signature_Scheme::DSA_SHA256:
306	24.5k	case Signature_Scheme::DSA_SHA384:
307	24.5k	case Signature_Scheme::DSA_SHA512:
308	24.5k	return "DSA";
309	24.5k
310	24.8k	case Signature_Scheme::ECDSA_SHA1:
311	24.8k	case Signature_Scheme::ECDSA_SHA256:
312	24.8k	case Signature_Scheme::ECDSA_SHA384:
313	24.8k	case Signature_Scheme::ECDSA_SHA512:
314	24.8k	return "ECDSA";
315	24.8k
316	24.8k	case Signature_Scheme::EDDSA_25519:
317	1	return "Ed25519";
318	24.8k
319	24.8k	case Signature_Scheme::EDDSA_448:
320	1	return "Ed448";
321	24.8k
322	24.8k	case Signature_Scheme::NONE:
323	0	return "";
324	68	}
325	68
326	68	throw Invalid_State("signature_algorithm_of_scheme: Unknown signature algorithm enum");
327	68	}
328
329		std::string sig_scheme_to_string(Signature_Scheme scheme)
330	0	{
331	0	switch(scheme)
332	0	{
333	0	case Signature_Scheme::RSA_PKCS1_SHA1:
334	0	return "RSA_PKCS1_SHA1";
335	0	case Signature_Scheme::RSA_PKCS1_SHA256:
336	0	return "RSA_PKCS1_SHA256";
337	0	case Signature_Scheme::RSA_PKCS1_SHA384:
338	0	return "RSA_PKCS1_SHA384";
339	0	case Signature_Scheme::RSA_PKCS1_SHA512:
340	0	return "RSA_PKCS1_SHA512";
341	0
342	0	case Signature_Scheme::DSA_SHA1:
343	0	return "DSA_SHA1";
344	0	case Signature_Scheme::DSA_SHA256:
345	0	return "DSA_SHA256";
346	0	case Signature_Scheme::DSA_SHA384:
347	0	return "DSA_SHA384";
348	0	case Signature_Scheme::DSA_SHA512:
349	0	return "DSA_SHA512";
350	0
351	0	case Signature_Scheme::ECDSA_SHA1:
352	0	return "ECDSA_SHA1";
353	0	case Signature_Scheme::ECDSA_SHA256:
354	0	return "ECDSA_SHA256";
355	0	case Signature_Scheme::ECDSA_SHA384:
356	0	return "ECDSA_SHA384";
357	0	case Signature_Scheme::ECDSA_SHA512:
358	0	return "ECDSA_SHA512";
359	0
360	0	case Signature_Scheme::RSA_PSS_SHA256:
361	0	return "RSA_PSS_SHA256";
362	0	case Signature_Scheme::RSA_PSS_SHA384:
363	0	return "RSA_PSS_SHA384";
364	0	case Signature_Scheme::RSA_PSS_SHA512:
365	0	return "RSA_PSS_SHA512";
366	0
367	0	case Signature_Scheme::EDDSA_25519:
368	0	return "EDDSA_25519";
369	0	case Signature_Scheme::EDDSA_448:
370	0	return "EDDSA_448";
371	0
372	0	case Signature_Scheme::NONE:
373	0	return "";
374	0	}
375	0
376	0	throw Invalid_State("sig_scheme_to_string: Unknown signature algorithm enum");
377	0	}
378
379		std::string padding_string_for_scheme(Signature_Scheme scheme)
380	280	{
381	280	switch(scheme)
382	280	{
383	280	case Signature_Scheme::RSA_PKCS1_SHA1:
384	0	return "EMSA_PKCS1(SHA-1)";
385	280	case Signature_Scheme::RSA_PKCS1_SHA256:
386	1	return "EMSA_PKCS1(SHA-256)";
387	280	case Signature_Scheme::RSA_PKCS1_SHA384:
388	1	return "EMSA_PKCS1(SHA-384)";
389	280	case Signature_Scheme::RSA_PKCS1_SHA512:
390	16	return "EMSA_PKCS1(SHA-512)";
391	280
392	280	case Signature_Scheme::DSA_SHA1:
393	0	case Signature_Scheme::ECDSA_SHA1:
394	0	return "EMSA1(SHA-1)";
395	177	case Signature_Scheme::DSA_SHA256:
396	177	case Signature_Scheme::ECDSA_SHA256:
397	177	return "EMSA1(SHA-256)";
398	177	case Signature_Scheme::DSA_SHA384:
399	54	case Signature_Scheme::ECDSA_SHA384:
400	54	return "EMSA1(SHA-384)";
401	54	case Signature_Scheme::DSA_SHA512:
402	5	case Signature_Scheme::ECDSA_SHA512:
403	5	return "EMSA1(SHA-512)";
404	5
405	7	case Signature_Scheme::RSA_PSS_SHA256:
406	7	return "PSSR(SHA-256,MGF1,32)";
407	14	case Signature_Scheme::RSA_PSS_SHA384:
408	14	return "PSSR(SHA-384,MGF1,48)";
409	5	case Signature_Scheme::RSA_PSS_SHA512:
410	5	return "PSSR(SHA-512,MGF1,64)";
411	5
412	5	case Signature_Scheme::EDDSA_25519:
413	0	return "Pure";
414	5	case Signature_Scheme::EDDSA_448:
415	0	return "Pure";
416	5
417	5	case Signature_Scheme::NONE:
418	0	return "";
419	0	}
420	0
421	0	throw Invalid_State("padding_string_for_scheme: Unknown signature algorithm enum");
422	0	}
423
424		}
425
426		}