13134654179

Committed 04 Feb 2025 11:40AM UTC coverage: 91.254% (+0.02%) from 91.236%

Build # 13134654179

Build Type

Pull #4554

github

Committed by

web-flow

Commit Message

Merge 4660b7e50 into 6711c7c93

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

Run Details

95119 of 104235 relevant lines covered (91.25%)

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

randombit / botan / 13134654179

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