12777311287

Committed 14 Jan 2025 10:12PM UTC coverage: 91.203% (-0.04%) from 91.247%

Build # 12777311287

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #4549 from randombit/jack/pcurves-test-cleanup

Remove the pcurves specific tests

Run Details

93416 of 102426 relevant lines covered (91.2%)

11527204.15 hits per line

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

65.17

/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::vector<PrimeOrderCurveId> PrimeOrderCurveId::all() {
   return {
      PrimeOrderCurveId::secp192r1,
      PrimeOrderCurveId::secp224r1,
      PrimeOrderCurveId::secp256r1,
      PrimeOrderCurveId::secp384r1,
      PrimeOrderCurveId::secp521r1,
      PrimeOrderCurveId::secp256k1,
      PrimeOrderCurveId::brainpool256r1,
      PrimeOrderCurveId::brainpool384r1,
      PrimeOrderCurveId::brainpool512r1,
      PrimeOrderCurveId::frp256v1,
      PrimeOrderCurveId::sm2p256v1,
      PrimeOrderCurveId::numsp512d1,
   };
}

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) {	910✔
102	switch(id.code()) {	910✔
103	case PrimeOrderCurveId::secp192r1:	6✔
104	return PCurveInstance::secp192r1();	6✔
105	case PrimeOrderCurveId::secp224r1:	124✔
106	return PCurveInstance::secp224r1();	124✔
107	case PrimeOrderCurveId::secp256r1:	312✔
108	return PCurveInstance::secp256r1();	312✔
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::vector<PrimeOrderCurveId> PrimeOrderCurveId::all() {	×
132	return {	×
133	PrimeOrderCurveId::secp192r1,
134	PrimeOrderCurveId::secp224r1,
135	PrimeOrderCurveId::secp256r1,
136	PrimeOrderCurveId::secp384r1,
137	PrimeOrderCurveId::secp521r1,
138	PrimeOrderCurveId::secp256k1,
139	PrimeOrderCurveId::brainpool256r1,
140	PrimeOrderCurveId::brainpool384r1,
141	PrimeOrderCurveId::brainpool512r1,
142	PrimeOrderCurveId::frp256v1,
143	PrimeOrderCurveId::sm2p256v1,
144	PrimeOrderCurveId::numsp512d1,
145	};	×
146	}
147
148	std::string PrimeOrderCurveId::to_string() const {	×
149	switch(this->code()) {	×
150	case PrimeOrderCurveId::secp192r1:	×
151	return "secp192r1";	×
152	case PrimeOrderCurveId::secp224r1:	×
153	return "secp224r1";	×
154	case PrimeOrderCurveId::secp256r1:	×
155	return "secp256r1";	×
156	case PrimeOrderCurveId::secp384r1:	×
157	return "secp384r1";	×
158	case PrimeOrderCurveId::secp521r1:	×
159	return "secp521r1";	×
160	case PrimeOrderCurveId::secp256k1:	×
161	return "secp256k1";	×
162	case PrimeOrderCurveId::brainpool256r1:	×
163	return "brainpool256r1";	×
164	case PrimeOrderCurveId::brainpool384r1:	×
165	return "brainpool384r1";	×
166	case PrimeOrderCurveId::brainpool512r1:	×
167	return "brainpool512r1";	×
168	case PrimeOrderCurveId::frp256v1:	×
169	return "frp256v1";	×
170	case PrimeOrderCurveId::sm2p256v1:	×
171	return "sm2p256v1";	×
172	case PrimeOrderCurveId::numsp512d1:	×
173	return "numsp512d1";	×
174	}
175
176	return "unknown";	×
177	}
178
179	//static
180	std::optional<PrimeOrderCurveId> PrimeOrderCurveId::from_string(std::string_view name) {	1,146✔
181	if(name == "secp192r1") {	1,146✔
182	return PCurve::PrimeOrderCurveId::secp192r1;	6✔
183	} else if(name == "secp224r1") {	1,140✔
184	return PCurve::PrimeOrderCurveId::secp224r1;	124✔
185	} else if(name == "secp256r1") {	1,016✔
186	return PCurve::PrimeOrderCurveId::secp256r1;	312✔
187	} else if(name == "secp384r1") {	704✔
188	return PCurve::PrimeOrderCurveId::secp384r1;	152✔
189	} else if(name == "secp521r1") {	552✔
190	return PCurve::PrimeOrderCurveId::secp521r1;	283✔
191	} else if(name == "secp256k1") {	269✔
192	return PCurve::PrimeOrderCurveId::secp256k1;	4✔
193	} else if(name == "brainpool256r1") {	265✔
194	return PCurve::PrimeOrderCurveId::brainpool256r1;	9✔
195	} else if(name == "brainpool384r1") {	256✔
196	return PCurve::PrimeOrderCurveId::brainpool384r1;	5✔
197	} else if(name == "brainpool512r1") {	251✔
198	return PCurve::PrimeOrderCurveId::brainpool512r1;	7✔
199	} else if(name == "frp256v1") {	244✔
200	return PCurve::PrimeOrderCurveId::frp256v1;	2✔
201	} else if(name == "sm2p256v1") {	242✔
202	return PCurve::PrimeOrderCurveId::sm2p256v1;	4✔
203	} else if(name == "numsp512d1") {	238✔
204	return PCurve::PrimeOrderCurveId::numsp512d1;	2✔
205	} else {
206	return {};	236✔
207	}
208	}
209
210	#if defined(BOTAN_HAS_ASN1)
211
212	//static
213	std::optional<PrimeOrderCurveId> PrimeOrderCurveId::from_oid(const OID& oid) {	1,150✔
214	const std::string name = oid.human_name_or_empty();	1,150✔
215	if(name.empty()) {	1,150✔
216	return {};	4✔
217	} else {
218	return PrimeOrderCurveId::from_string(name);	1,146✔
219	}
220	}	1,150✔
221
222	#endif
223
224	} // namespace Botan::PCurve

randombit / botan / 12777311287

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