13320766952

Committed 14 Feb 2025 01:44AM UTC coverage: 91.675% (+0.03%) from 91.645%

Build # 13320766952

Build Type

Pull #4554

github

Committed by

web-flow

Commit Message

Merge 715013209 into 1cce93244

Pull Request Pull Request #4554: Add generic pcurves for application specific curves

Run Details

95655 of 104341 relevant lines covered (91.68%)

10981667.89 hits per line

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

68.18

/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/assert.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_GENERIC)
//static
std::shared_ptr<const PrimeOrderCurve> PCurveInstance::from_params(
   const BigInt& p, const BigInt& a, const BigInt& b, const BigInt& base_x, const BigInt& base_y, const BigInt& order) {
   BOTAN_UNUSED(p, a, b, base_x, base_y, order);
   return nullptr;
}
#endif

#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

//static
std::shared_ptr<const PrimeOrderCurve> PrimeOrderCurve::from_params(
   const BigInt& p, const BigInt& a, const BigInt& b, const BigInt& base_x, const BigInt& base_y, const BigInt& order) {
   return PCurveInstance::from_params(p, a, b, base_x, base_y, order);
}

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

randombit / botan / 13320766952

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