13089611303

Committed 01 Feb 2025 02:39PM UTC coverage: 91.236% (+0.01%) from 91.224%

Build # 13089611303

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #4624 from randombit/jack/remove-pcurve-id-all

Remove PrimeorderCurveId::all

Run Details

94178 of 103225 relevant lines covered (91.24%)

11253695.07 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

67.44

/src/lib/math/pcurves/pcurves.cpp

/*
* (C) 2024 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include <botan/internal/pcurves.h>

#include <botan/internal/pcurves_instance.h>

#if defined(BOTAN_HAS_ASN1)
   #include <botan/asn1_obj.h>
#endif

namespace Botan::PCurve {

#if !defined(BOTAN_HAS_PCURVES_SECP192R1)
//static
std::shared_ptr<const PrimeOrderCurve> PCurveInstance::secp192r1() {
   return nullptr;
}
#endif

#if !defined(BOTAN_HAS_PCURVES_SECP224R1)
//static
std::shared_ptr<const PrimeOrderCurve> PCurveInstance::secp224r1() {
   return nullptr;
}
#endif

#if !defined(BOTAN_HAS_PCURVES_SECP256R1)
//static
std::shared_ptr<const PrimeOrderCurve> PCurveInstance::secp256r1() {
   return nullptr;
}
#endif

#if !defined(BOTAN_HAS_PCURVES_SECP384R1)
//static
std::shared_ptr<const PrimeOrderCurve> PCurveInstance::secp384r1() {
   return nullptr;
}
#endif

#if !defined(BOTAN_HAS_PCURVES_SECP521R1)
//static
std::shared_ptr<const PrimeOrderCurve> PCurveInstance::secp521r1() {
   return nullptr;
}
#endif

#if !defined(BOTAN_HAS_PCURVES_SECP256K1)
//static
std::shared_ptr<const PrimeOrderCurve> PCurveInstance::secp256k1() {
   return nullptr;
}
#endif

#if !defined(BOTAN_HAS_PCURVES_BRAINPOOL256R1)
//static
std::shared_ptr<const PrimeOrderCurve> PCurveInstance::brainpool256r1() {
   return nullptr;
}
#endif

#if !defined(BOTAN_HAS_PCURVES_BRAINPOOL384R1)
//static
std::shared_ptr<const PrimeOrderCurve> PCurveInstance::brainpool384r1() {
   return nullptr;
}
#endif

#if !defined(BOTAN_HAS_PCURVES_BRAINPOOL512R1)
//static
std::shared_ptr<const PrimeOrderCurve> PCurveInstance::brainpool512r1() {
   return nullptr;
}
#endif

#if !defined(BOTAN_HAS_PCURVES_FRP256V1)
//static
std::shared_ptr<const PrimeOrderCurve> PCurveInstance::frp256v1() {
   return nullptr;
}
#endif

#if !defined(BOTAN_HAS_PCURVES_SM2P256V1)
//static
std::shared_ptr<const PrimeOrderCurve> PCurveInstance::sm2p256v1() {
   return nullptr;
}
#endif

#if !defined(BOTAN_HAS_PCURVES_NUMSP512D1)
//static
std::shared_ptr<const PrimeOrderCurve> PCurveInstance::numsp512d1() {
   return nullptr;
}
#endif

std::shared_ptr<const PrimeOrderCurve> PrimeOrderCurve::from_id(PrimeOrderCurveId id) {
   switch(id.code()) {
      case PrimeOrderCurveId::secp192r1:
         return PCurveInstance::secp192r1();
      case PrimeOrderCurveId::secp224r1:
         return PCurveInstance::secp224r1();
      case PrimeOrderCurveId::secp256r1:
         return PCurveInstance::secp256r1();
      case PrimeOrderCurveId::secp384r1:
         return PCurveInstance::secp384r1();
      case PrimeOrderCurveId::secp521r1:
         return PCurveInstance::secp521r1();
      case PrimeOrderCurveId::secp256k1:
         return PCurveInstance::secp256k1();
      case PrimeOrderCurveId::brainpool256r1:
         return PCurveInstance::brainpool256r1();
      case PrimeOrderCurveId::brainpool384r1:
         return PCurveInstance::brainpool384r1();
      case PrimeOrderCurveId::brainpool512r1:
         return PCurveInstance::brainpool512r1();
      case PrimeOrderCurveId::frp256v1:
         return PCurveInstance::frp256v1();
      case PrimeOrderCurveId::sm2p256v1:
         return PCurveInstance::sm2p256v1();
      case PrimeOrderCurveId::numsp512d1:
         return PCurveInstance::numsp512d1();
   }
   return {};
}

std::string PrimeOrderCurveId::to_string() const {
   switch(this->code()) {
      case PrimeOrderCurveId::secp192r1:
         return "secp192r1";
      case PrimeOrderCurveId::secp224r1:
         return "secp224r1";
      case PrimeOrderCurveId::secp256r1:
         return "secp256r1";
      case PrimeOrderCurveId::secp384r1:
         return "secp384r1";
      case PrimeOrderCurveId::secp521r1:
         return "secp521r1";
      case PrimeOrderCurveId::secp256k1:
         return "secp256k1";
      case PrimeOrderCurveId::brainpool256r1:
         return "brainpool256r1";
      case PrimeOrderCurveId::brainpool384r1:
         return "brainpool384r1";
      case PrimeOrderCurveId::brainpool512r1:
         return "brainpool512r1";
      case PrimeOrderCurveId::frp256v1:
         return "frp256v1";
      case PrimeOrderCurveId::sm2p256v1:
         return "sm2p256v1";
      case PrimeOrderCurveId::numsp512d1:
         return "numsp512d1";
   }

   return "unknown";
}

//static
std::optional<PrimeOrderCurveId> PrimeOrderCurveId::from_string(std::string_view name) {
   if(name == "secp192r1") {
      return PCurve::PrimeOrderCurveId::secp192r1;
   } else if(name == "secp224r1") {
      return PCurve::PrimeOrderCurveId::secp224r1;
   } else if(name == "secp256r1") {
      return PCurve::PrimeOrderCurveId::secp256r1;
   } else if(name == "secp384r1") {
      return PCurve::PrimeOrderCurveId::secp384r1;
   } else if(name == "secp521r1") {
      return PCurve::PrimeOrderCurveId::secp521r1;
   } else if(name == "secp256k1") {
      return PCurve::PrimeOrderCurveId::secp256k1;
   } else if(name == "brainpool256r1") {
      return PCurve::PrimeOrderCurveId::brainpool256r1;
   } else if(name == "brainpool384r1") {
      return PCurve::PrimeOrderCurveId::brainpool384r1;
   } else if(name == "brainpool512r1") {
      return PCurve::PrimeOrderCurveId::brainpool512r1;
   } else if(name == "frp256v1") {
      return PCurve::PrimeOrderCurveId::frp256v1;
   } else if(name == "sm2p256v1") {
      return PCurve::PrimeOrderCurveId::sm2p256v1;
   } else if(name == "numsp512d1") {
      return PCurve::PrimeOrderCurveId::numsp512d1;
   } else {
      return {};
   }
}

#if defined(BOTAN_HAS_ASN1)

//static
std::optional<PrimeOrderCurveId> PrimeOrderCurveId::from_oid(const OID& oid) {
   const std::string name = oid.human_name_or_empty();
   if(name.empty()) {
      return {};
   } else {
      return PrimeOrderCurveId::from_string(name);
   }
}

#endif

}  // namespace Botan::PCurve

1	/*
2	* (C) 2024 Jack Lloyd
3	*
4	* Botan is released under the Simplified BSD License (see license.txt)
5	*/
6
7	#include <botan/internal/pcurves.h>
8
9	#include <botan/internal/pcurves_instance.h>
10
11	#if defined(BOTAN_HAS_ASN1)
12	#include <botan/asn1_obj.h>
13	#endif
14
15	namespace Botan::PCurve {
16
17	#if !defined(BOTAN_HAS_PCURVES_SECP192R1)
18	//static
19	std::shared_ptr<const PrimeOrderCurve> PCurveInstance::secp192r1() {
20	return nullptr;
21	}
22	#endif
23
24	#if !defined(BOTAN_HAS_PCURVES_SECP224R1)
25	//static
26	std::shared_ptr<const PrimeOrderCurve> PCurveInstance::secp224r1() {
27	return nullptr;
28	}
29	#endif
30
31	#if !defined(BOTAN_HAS_PCURVES_SECP256R1)
32	//static
33	std::shared_ptr<const PrimeOrderCurve> PCurveInstance::secp256r1() {
34	return nullptr;
35	}
36	#endif
37
38	#if !defined(BOTAN_HAS_PCURVES_SECP384R1)
39	//static
40	std::shared_ptr<const PrimeOrderCurve> PCurveInstance::secp384r1() {
41	return nullptr;
42	}
43	#endif
44
45	#if !defined(BOTAN_HAS_PCURVES_SECP521R1)
46	//static
47	std::shared_ptr<const PrimeOrderCurve> PCurveInstance::secp521r1() {
48	return nullptr;
49	}
50	#endif
51
52	#if !defined(BOTAN_HAS_PCURVES_SECP256K1)
53	//static
54	std::shared_ptr<const PrimeOrderCurve> PCurveInstance::secp256k1() {
55	return nullptr;
56	}
57	#endif
58
59	#if !defined(BOTAN_HAS_PCURVES_BRAINPOOL256R1)
60	//static
61	std::shared_ptr<const PrimeOrderCurve> PCurveInstance::brainpool256r1() {
62	return nullptr;
63	}
64	#endif
65
66	#if !defined(BOTAN_HAS_PCURVES_BRAINPOOL384R1)
67	//static
68	std::shared_ptr<const PrimeOrderCurve> PCurveInstance::brainpool384r1() {
69	return nullptr;
70	}
71	#endif
72
73	#if !defined(BOTAN_HAS_PCURVES_BRAINPOOL512R1)
74	//static
75	std::shared_ptr<const PrimeOrderCurve> PCurveInstance::brainpool512r1() {
76	return nullptr;
77	}
78	#endif
79
80	#if !defined(BOTAN_HAS_PCURVES_FRP256V1)
81	//static
82	std::shared_ptr<const PrimeOrderCurve> PCurveInstance::frp256v1() {
83	return nullptr;
84	}
85	#endif
86
87	#if !defined(BOTAN_HAS_PCURVES_SM2P256V1)
88	//static
89	std::shared_ptr<const PrimeOrderCurve> PCurveInstance::sm2p256v1() {
90	return nullptr;
91	}
92	#endif
93
94	#if !defined(BOTAN_HAS_PCURVES_NUMSP512D1)
95	//static
96	std::shared_ptr<const PrimeOrderCurve> PCurveInstance::numsp512d1() {
97	return nullptr;
98	}
99	#endif
100
101	std::shared_ptr<const PrimeOrderCurve> PrimeOrderCurve::from_id(PrimeOrderCurveId id) {	913✔
102	switch(id.code()) {	913✔
103	case PrimeOrderCurveId::secp192r1:	6✔
104	return PCurveInstance::secp192r1();	6✔
105	case PrimeOrderCurveId::secp224r1:	124✔
106	return PCurveInstance::secp224r1();	124✔
107	case PrimeOrderCurveId::secp256r1:	315✔
108	return PCurveInstance::secp256r1();	315✔
109	case PrimeOrderCurveId::secp384r1:	152✔
110	return PCurveInstance::secp384r1();	152✔
111	case PrimeOrderCurveId::secp521r1:	283✔
112	return PCurveInstance::secp521r1();	283✔
113	case PrimeOrderCurveId::secp256k1:	4✔
114	return PCurveInstance::secp256k1();	4✔
115	case PrimeOrderCurveId::brainpool256r1:	9✔
116	return PCurveInstance::brainpool256r1();	9✔
117	case PrimeOrderCurveId::brainpool384r1:	5✔
118	return PCurveInstance::brainpool384r1();	5✔
119	case PrimeOrderCurveId::brainpool512r1:	7✔
120	return PCurveInstance::brainpool512r1();	7✔
121	case PrimeOrderCurveId::frp256v1:	2✔
122	return PCurveInstance::frp256v1();	2✔
123	case PrimeOrderCurveId::sm2p256v1:	4✔
124	return PCurveInstance::sm2p256v1();	4✔
125	case PrimeOrderCurveId::numsp512d1:	2✔
126	return PCurveInstance::numsp512d1();	2✔
127	}
128	return {};	×
129	}
130
131	std::string PrimeOrderCurveId::to_string() const {	×
132	switch(this->code()) {	×
133	case PrimeOrderCurveId::secp192r1:	×
134	return "secp192r1";	×
135	case PrimeOrderCurveId::secp224r1:	×
136	return "secp224r1";	×
137	case PrimeOrderCurveId::secp256r1:	×
138	return "secp256r1";	×
139	case PrimeOrderCurveId::secp384r1:	×
140	return "secp384r1";	×
141	case PrimeOrderCurveId::secp521r1:	×
142	return "secp521r1";	×
143	case PrimeOrderCurveId::secp256k1:	×
144	return "secp256k1";	×
145	case PrimeOrderCurveId::brainpool256r1:	×
146	return "brainpool256r1";	×
147	case PrimeOrderCurveId::brainpool384r1:	×
148	return "brainpool384r1";	×
149	case PrimeOrderCurveId::brainpool512r1:	×
150	return "brainpool512r1";	×
151	case PrimeOrderCurveId::frp256v1:	×
152	return "frp256v1";	×
153	case PrimeOrderCurveId::sm2p256v1:	×
154	return "sm2p256v1";	×
155	case PrimeOrderCurveId::numsp512d1:	×
156	return "numsp512d1";	×
157	}
158
159	return "unknown";	×
160	}
161
162	//static
163	std::optional<PrimeOrderCurveId> PrimeOrderCurveId::from_string(std::string_view name) {	1,148✔
164	if(name == "secp192r1") {	1,148✔
165	return PCurve::PrimeOrderCurveId::secp192r1;	6✔
166	} else if(name == "secp224r1") {	1,142✔
167	return PCurve::PrimeOrderCurveId::secp224r1;	124✔
168	} else if(name == "secp256r1") {	1,018✔
169	return PCurve::PrimeOrderCurveId::secp256r1;	315✔
170	} else if(name == "secp384r1") {	703✔
171	return PCurve::PrimeOrderCurveId::secp384r1;	152✔
172	} else if(name == "secp521r1") {	551✔
173	return PCurve::PrimeOrderCurveId::secp521r1;	283✔
174	} else if(name == "secp256k1") {	268✔
175	return PCurve::PrimeOrderCurveId::secp256k1;	4✔
176	} else if(name == "brainpool256r1") {	264✔
177	return PCurve::PrimeOrderCurveId::brainpool256r1;	9✔
178	} else if(name == "brainpool384r1") {	255✔
179	return PCurve::PrimeOrderCurveId::brainpool384r1;	5✔
180	} else if(name == "brainpool512r1") {	250✔
181	return PCurve::PrimeOrderCurveId::brainpool512r1;	7✔
182	} else if(name == "frp256v1") {	243✔
183	return PCurve::PrimeOrderCurveId::frp256v1;	2✔
184	} else if(name == "sm2p256v1") {	241✔
185	return PCurve::PrimeOrderCurveId::sm2p256v1;	4✔
186	} else if(name == "numsp512d1") {	237✔
187	return PCurve::PrimeOrderCurveId::numsp512d1;	2✔
188	} else {
189	return {};	235✔
190	}
191	}
192
193	#if defined(BOTAN_HAS_ASN1)
194
195	//static
196	std::optional<PrimeOrderCurveId> PrimeOrderCurveId::from_oid(const OID& oid) {	1,152✔
197	const std::string name = oid.human_name_or_empty();	1,152✔
198	if(name.empty()) {	1,152✔
199	return {};	4✔
200	} else {
201	return PrimeOrderCurveId::from_string(name);	1,148✔
202	}
203	}	1,152✔
204
205	#endif
206
207	} // namespace Botan::PCurve

randombit / botan / 13089611303

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