/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/ec_group.h>
#include <botan/oids.h>
#include <botan/tls_algos.h>
#include <botan/exceptn.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::UNDEFINED:
         return "UNDEFINED";
      }

   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 == "PSK")
      return Kex_Algo::PSK;

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

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

   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";
      case Auth_Method::UNDEFINED:
         return "UNDEFINED";
      }

    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;
   if(str == "UNDEFINED")
      return Auth_Method::UNDEFINED;

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

}

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/ec_group.h>
8		#include <botan/oids.h>
9		#include <botan/tls_algos.h>
10		#include <botan/exceptn.h>
11
12		namespace Botan::TLS {
13
14		std::string kdf_algo_to_string(KDF_Algo algo)
15	16.1k	{
16	16.1k	switch(algo)
17	16.1k	{
18	8.67k	case KDF_Algo::SHA_1:
19	8.67k	return "SHA-1";
20	4.78k	case KDF_Algo::SHA_256:
21	4.78k	return "SHA-256";
22	2.66k	case KDF_Algo::SHA_384:
23	2.66k	return "SHA-384";
24	16.1k	}
25
26	0	throw Invalid_State("kdf_algo_to_string unknown enum value");
27	16.1k	}
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::PSK:
40	0	return "PSK";
41	0	case Kex_Algo::ECDHE_PSK:
42	0	return "ECDHE_PSK";
43	0	case Kex_Algo::UNDEFINED:
44	0	return "UNDEFINED";
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 == "PSK")
62	0	return Kex_Algo::PSK;
63
64	0	if(str == "ECDHE_PSK")
65	0	return Kex_Algo::ECDHE_PSK;
66
67	0	if(str == "UNDEFINED")
68	0	return Kex_Algo::UNDEFINED;
69
70	0	throw Invalid_Argument("Unknown kex method " + str);
71	0	}
72
73		std::string auth_method_to_string(Auth_Method method)
74	5.18k	{
75	5.18k	switch(method)
76	5.18k	{
77	5.09k	case Auth_Method::RSA:
78	5.09k	return "RSA";
79	7	case Auth_Method::ECDSA:
80	7	return "ECDSA";
81	0	case Auth_Method::IMPLICIT:
82	0	return "IMPLICIT";
83	88	case Auth_Method::UNDEFINED:
84	88	return "UNDEFINED";
85	5.18k	}
86
87	0	throw Invalid_State("auth_method_to_string unknown enum value");
88	5.18k	}
89
90		Auth_Method auth_method_from_string(const std::string& str)
91	0	{
92	0	if(str == "RSA")
93	0	return Auth_Method::RSA;
94	0	if(str == "ECDSA")
95	0	return Auth_Method::ECDSA;
96	0	if(str == "IMPLICIT")
97	0	return Auth_Method::IMPLICIT;
98	0	if(str == "UNDEFINED")
99	0	return Auth_Method::UNDEFINED;
100
101	0	throw Invalid_Argument("Bad signature method " + str);
102	0	}
103
104		bool group_param_is_dh(Group_Params group)
105	178k	{
106	178k	uint16_t group_id = static_cast<uint16_t>(group);
107	178k	return (group_id >= 256 && group_id < 512);
108	178k	}
109
110		Group_Params group_param_from_string(const std::string& group_name)
111	0	{
112	0	if(group_name == "secp256r1")
113	0	return Group_Params::SECP256R1;
114	0	if(group_name == "secp384r1")
115	0	return Group_Params::SECP384R1;
116	0	if(group_name == "secp521r1")
117	0	return Group_Params::SECP521R1;
118	0	if(group_name == "brainpool256r1")
119	0	return Group_Params::BRAINPOOL256R1;
120	0	if(group_name == "brainpool384r1")
121	0	return Group_Params::BRAINPOOL384R1;
122	0	if(group_name == "brainpool512r1")
123	0	return Group_Params::BRAINPOOL512R1;
124	0	if(group_name == "x25519")
125	0	return Group_Params::X25519;
126
127	0	if(group_name == "ffdhe/ietf/2048")
128	0	return Group_Params::FFDHE_2048;
129	0	if(group_name == "ffdhe/ietf/3072")
130	0	return Group_Params::FFDHE_3072;
131	0	if(group_name == "ffdhe/ietf/4096")
132	0	return Group_Params::FFDHE_4096;
133	0	if(group_name == "ffdhe/ietf/6144")
134	0	return Group_Params::FFDHE_6144;
135	0	if(group_name == "ffdhe/ietf/8192")
136	0	return Group_Params::FFDHE_8192;
137
138	0	return Group_Params::NONE; // unknown
139	0	}
140
141		std::string group_param_to_string(Group_Params group)
142	17.9k	{
143	17.9k	switch(group)
144	17.9k	{
145	2.18k	case Group_Params::SECP256R1:
146	2.18k	return "secp256r1";
147	1.62k	case Group_Params::SECP384R1:
148	1.62k	return "secp384r1";
149	5.35k	case Group_Params::SECP521R1:
150	5.35k	return "secp521r1";
151	1.43k	case Group_Params::BRAINPOOL256R1:
152	1.43k	return "brainpool256r1";
153	3.10k	case Group_Params::BRAINPOOL384R1:
154	3.10k	return "brainpool384r1";
155	4.27k	case Group_Params::BRAINPOOL512R1:
156	4.27k	return "brainpool512r1";
157	0	case Group_Params::X25519:
158	0	return "x25519";
159
160	0	case Group_Params::FFDHE_2048:
161	0	return "ffdhe/ietf/2048";
162	0	case Group_Params::FFDHE_3072:
163	0	return "ffdhe/ietf/3072";
164	0	case Group_Params::FFDHE_4096:
165	0	return "ffdhe/ietf/4096";
166	0	case Group_Params::FFDHE_6144:
167	0	return "ffdhe/ietf/6144";
168	0	case Group_Params::FFDHE_8192:
169	0	return "ffdhe/ietf/8192";
170
171	0	default:
172	0	return "";
173	17.9k	}
174	17.9k	}
175
176		}

Coverage Report

Created: 2023-02-13 06:21