Botan 3.14.1
Crypto and TLS for C&
ec_inner_data.cpp
Go to the documentation of this file.
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/ec_inner_data.h>
8
9#include <botan/der_enc.h>
10#include <botan/internal/barrett.h>
11#include <botan/internal/ec_inner_pc.h>
12#include <botan/internal/fmt.h>
13#include <botan/internal/pcurves.h>
14#include <algorithm>
15
16#if defined(BOTAN_HAS_LEGACY_EC_POINT)
17 #include <botan/internal/ec_inner_bn.h>
18 #include <botan/internal/point_mul.h>
19#endif
20
21#if defined(BOTAN_HAS_XMD)
22 #include <botan/hash.h>
23 #include <botan/internal/xmd.h>
24#endif
25
26namespace Botan {
27
29
30// Note this constructor *does not* initialize m_curve, m_base_point or m_base_mult
32 const BigInt& a,
33 const BigInt& b,
34 const BigInt& g_x,
35 const BigInt& g_y,
36 const BigInt& order,
37 const BigInt& cofactor,
38 const OID& oid,
40 m_p(p),
41 m_a(a),
42 m_b(b),
43 m_g_x(g_x),
44 m_g_y(g_y),
45 m_order(order),
46 m_cofactor(cofactor),
48 m_mod_field(Barrett_Reduction::for_public_modulus(p)),
49 m_mod_order(Barrett_Reduction::for_public_modulus(order)),
50 m_monty(m_p, m_mod_field),
51#endif
52 m_oid(oid),
53 m_p_words(p.sig_words()),
54 m_p_bits(p.bits()),
55 m_order_bits(order.bits()),
56 m_order_bytes((m_order_bits + 7) / 8),
57 m_a_is_minus_3(a == p - 3),
58 m_a_is_zero(a.is_zero()),
59 m_has_cofactor(m_cofactor != 1),
60 m_order_is_less_than_p(m_order < p),
61 m_source(source) {
62 // Verify the generator (x, y) satisfies y^2 = x^3 + a*x + b (mod p)
63 const auto mod_p = Barrett_Reduction::for_public_modulus(p);
64 const BigInt y2 = mod_p.square(g_y);
65 const BigInt x3_ax_b = mod_p.reduce(mod_p.cube(g_x) + mod_p.multiply(a, g_x) + b);
66 if(y2 != x3_ax_b) {
67 throw Invalid_Argument("EC_Group generator is not on the curve");
68 }
69
70 // TODO(Botan4) we can assume/assert the OID is set
71 if(!m_oid.empty()) {
72 DER_Encoder der(m_der_named_curve);
73 der.encode(m_oid);
74
75 if(const auto name = m_oid.registered_name()) {
77 const bool same_params = [&]() {
78 if(m_source == EC_Group_Source::Builtin) {
79 return true;
80 }
81
82 if(const auto group_oid = OID::from_name(*name)) {
83 if(const auto group_info = EC_Group::EC_group_info(*group_oid)) {
84 return group_info->params_match(p, a, b, g_x, g_y, order, cofactor);
85 }
86 }
87
88 return false;
89 }();
90
91 if(same_params) {
92 m_pcurve = std::move(pcurve);
93 }
94 }
95 }
96 if(m_pcurve) {
98 }
99 }
100
101 // Try a generic pcurves instance
102 if(!m_pcurve && !m_has_cofactor) {
104 if(m_pcurve) {
105 m_engine = EC_Group_Engine::Generic;
106 }
107 // possibly still null here, if parameters unsuitable or if the
108 // pcurves_generic module wasn't included in the build
109 }
110
111#if defined(BOTAN_HAS_LEGACY_EC_POINT)
113 m_a_r = m_monty.mul(a, m_monty.R2(), ws);
114 m_b_r = m_monty.mul(b, m_monty.R2(), ws);
115 if(!m_pcurve) {
116 m_engine = EC_Group_Engine::Legacy;
117 }
118#else
119 if(!m_pcurve) {
120 if(m_oid.empty()) {
121 throw Not_Implemented("EC_Group this group is not supported in this build configuration");
122 } else {
123 throw Not_Implemented(
124 fmt("EC_Group the group {} is not supported in this build configuration", oid.to_string()));
125 }
126 }
127#endif
128}
129
130std::shared_ptr<EC_Group_Data> EC_Group_Data::create(const BigInt& p,
131 const BigInt& a,
132 const BigInt& b,
133 const BigInt& g_x,
134 const BigInt& g_y,
135 const BigInt& order,
136 const BigInt& cofactor,
137 const OID& oid,
139 auto group = std::make_shared<EC_Group_Data>(p, a, b, g_x, g_y, order, cofactor, oid, source);
140
141#if defined(BOTAN_HAS_LEGACY_EC_POINT)
142 group->m_curve = CurveGFp(group.get());
143 group->m_base_point = EC_Point(group->m_curve, g_x, g_y);
144 if(!group->m_pcurve) {
145 group->m_base_mult = std::make_unique<EC_Point_Base_Point_Precompute>(group->m_base_point, group->m_mod_order);
146 }
147#endif
148
149 return group;
150}
151
153 const BigInt& a,
154 const BigInt& b,
155 const BigInt& g_x,
156 const BigInt& g_y,
157 const BigInt& order,
158 const BigInt& cofactor) const {
159 if(p != this->p()) {
160 return false;
161 }
162 if(a != this->a()) {
163 return false;
164 }
165 if(b != this->b()) {
166 return false;
167 }
168 if(order != this->order()) {
169 return false;
170 }
171 if(cofactor != this->cofactor()) {
172 return false;
173 }
174 if(g_x != this->g_x()) {
175 return false;
176 }
177 if(g_y != this->g_y()) {
178 return false;
179 }
180
181 return true;
182}
183
185 const BigInt& a,
186 const BigInt& b,
187 std::span<const uint8_t> base_pt,
188 const BigInt& order,
189 const BigInt& cofactor) const {
190 if(p != this->p()) {
191 return false;
192 }
193 if(a != this->a()) {
194 return false;
195 }
196 if(b != this->b()) {
197 return false;
198 }
199 if(order != this->order()) {
200 return false;
201 }
202 if(cofactor != this->cofactor()) {
203 return false;
204 }
205
206 const size_t field_len = this->p_bytes();
207
208 if(base_pt.size() == 1 + field_len && (base_pt[0] == 0x02 || base_pt[0] == 0x03)) {
209 // compressed
210
211 const auto g_x = m_g_x.serialize(field_len);
212 const auto g_y = m_g_y.is_odd();
213
214 const auto sec1_x = base_pt.subspan(1, field_len);
215 const bool sec1_y = (base_pt[0] == 0x03);
216
217 if(!std::ranges::equal(sec1_x, g_x)) {
218 return false;
219 }
220
221 if(sec1_y != g_y) {
222 return false;
223 }
224
225 return true;
226 } else if(base_pt.size() == 1 + 2 * field_len && base_pt[0] == 0x04) {
227 const auto g_x = m_g_x.serialize(field_len);
228 const auto g_y = m_g_y.serialize(field_len);
229
230 const auto sec1_x = base_pt.subspan(1, field_len);
231 const auto sec1_y = base_pt.subspan(1 + field_len, field_len);
232
233 if(!std::ranges::equal(sec1_x, g_x)) {
234 return false;
235 }
236
237 if(!std::ranges::equal(sec1_y, g_y)) {
238 return false;
239 }
240
241 return true;
242 } else {
243 throw Decoding_Error("Invalid base point encoding in explicit group");
244 }
245}
246
248 return params_match(other.p(), other.a(), other.b(), other.g_x(), other.g_y(), other.order(), other.cofactor());
249}
250
252 BOTAN_ARG_CHECK(!oid.empty(), "OID should be set");
253 BOTAN_STATE_CHECK(m_oid.empty() && m_der_named_curve.empty());
254 m_oid = oid;
255
256 DER_Encoder der(m_der_named_curve);
257 der.encode(m_oid);
258}
259
260std::unique_ptr<EC_Scalar_Data> EC_Group_Data::scalar_from_bytes_with_trunc(std::span<const uint8_t> bytes) const {
261 const size_t bit_length = 8 * bytes.size();
262
263 if(bit_length < order_bits()) {
264 // No shifting required, but might still need to reduce by modulus
265 return this->scalar_from_bytes_mod_order(bytes);
266 } else {
267 const size_t shift = bit_length - order_bits();
268
269 const size_t new_length = bytes.size() - (shift / 8);
270 const size_t bit_shift = shift % 8;
271
272 if(bit_shift == 0) {
273 // Easy case just read different bytes
274 return this->scalar_from_bytes_mod_order(bytes.first(new_length));
275 } else {
276 std::vector<uint8_t> sbytes(new_length);
277
278 uint8_t carry = 0;
279 for(size_t i = 0; i != new_length; ++i) {
280 const uint8_t w = bytes[i];
281 sbytes[i] = (w >> bit_shift) | carry;
282 carry = w << (8 - bit_shift);
283 }
284
285 return this->scalar_from_bytes_mod_order(sbytes);
286 }
287 }
288}
289
290std::unique_ptr<EC_Scalar_Data> EC_Group_Data::scalar_from_bytes_mod_order(std::span<const uint8_t> bytes) const {
291 if(bytes.size() > 2 * order_bytes()) {
292 return {};
293 }
294
295 if(m_pcurve) {
296 if(auto s = m_pcurve->scalar_from_wide_bytes(bytes)) {
297 return std::make_unique<EC_Scalar_Data_PC>(shared_from_this(), std::move(*s));
298 } else {
299 return {};
300 }
301 } else {
302#if defined(BOTAN_HAS_LEGACY_EC_POINT)
303 return std::make_unique<EC_Scalar_Data_BN>(shared_from_this(), m_mod_order.reduce(BigInt(bytes)));
304#else
305 throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
306#endif
307 }
308}
309
310std::unique_ptr<EC_Scalar_Data> EC_Group_Data::scalar_random(RandomNumberGenerator& rng) const {
311 if(m_pcurve) {
312 return std::make_unique<EC_Scalar_Data_PC>(shared_from_this(), m_pcurve->random_scalar(rng));
313 } else {
314#if defined(BOTAN_HAS_LEGACY_EC_POINT)
315 return std::make_unique<EC_Scalar_Data_BN>(shared_from_this(),
316 BigInt::random_integer(rng, BigInt::one(), m_order));
317#else
318 throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
319#endif
320 }
321}
322
323std::unique_ptr<EC_Scalar_Data> EC_Group_Data::scalar_one() const {
324 if(m_pcurve) {
325 return std::make_unique<EC_Scalar_Data_PC>(shared_from_this(), m_pcurve->scalar_one());
326 } else {
327#if defined(BOTAN_HAS_LEGACY_EC_POINT)
328 return std::make_unique<EC_Scalar_Data_BN>(shared_from_this(), BigInt::one());
329#else
330 throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
331#endif
332 }
333}
334
335std::unique_ptr<EC_Scalar_Data> EC_Group_Data::scalar_from_bigint(const BigInt& bn) const {
336 if(bn <= 0 || bn >= m_order) {
337 return {};
338 }
339
340 if(m_pcurve) {
341 return this->scalar_deserialize(bn.serialize(m_order_bytes));
342 } else {
343#if defined(BOTAN_HAS_LEGACY_EC_POINT)
344 return std::make_unique<EC_Scalar_Data_BN>(shared_from_this(), bn);
345#else
346 throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
347#endif
348 }
349}
350
351std::unique_ptr<EC_Scalar_Data> EC_Group_Data::gk_x_mod_order(const EC_Scalar_Data& scalar,
352 RandomNumberGenerator& rng) const {
353 if(m_pcurve) {
354 const auto& k = EC_Scalar_Data_PC::checked_ref(scalar);
355 const auto gk_x_mod_order = m_pcurve->base_point_mul_x_mod_order(k.value(), rng);
356 return std::make_unique<EC_Scalar_Data_PC>(shared_from_this(), gk_x_mod_order);
357 } else {
358#if defined(BOTAN_HAS_LEGACY_EC_POINT)
359 const auto& k = EC_Scalar_Data_BN::checked_ref(scalar);
360 BOTAN_STATE_CHECK(m_base_mult != nullptr);
361 std::vector<BigInt> ws;
362 const auto pt = m_base_mult->mul(k.value(), rng, m_order, ws);
363
364 if(pt.is_zero()) {
365 return std::make_unique<EC_Scalar_Data_BN>(shared_from_this(), BigInt::zero());
366 } else {
367 return std::make_unique<EC_Scalar_Data_BN>(shared_from_this(), m_mod_order.reduce(pt.get_affine_x()));
368 }
369#else
370 throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
371#endif
372 }
373}
374
375std::unique_ptr<EC_Scalar_Data> EC_Group_Data::scalar_deserialize(std::span<const uint8_t> bytes) const {
376 if(bytes.size() != m_order_bytes) {
377 return nullptr;
378 }
379
380 if(m_pcurve) {
381 if(auto s = m_pcurve->deserialize_scalar(bytes)) {
382 return std::make_unique<EC_Scalar_Data_PC>(shared_from_this(), *s);
383 } else {
384 return nullptr;
385 }
386 } else {
387#if defined(BOTAN_HAS_LEGACY_EC_POINT)
388 BigInt r(bytes);
389
390 if(r.is_zero() || r >= m_order) {
391 return nullptr;
392 }
393
394 return std::make_unique<EC_Scalar_Data_BN>(shared_from_this(), std::move(r));
395#else
396 throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
397#endif
398 }
399}
400
401std::unique_ptr<EC_AffinePoint_Data> EC_Group_Data::point_deserialize_uncompressed(
402 std::span<const uint8_t> bytes) const {
403 if(bytes.size() != 1 + 2 * p_bytes() || bytes[0] != 0x04) {
404 return {};
405 }
406
407 if(m_pcurve) {
408 if(auto pt = m_pcurve->deserialize_point_uncompressed(bytes)) {
409 return std::make_unique<EC_AffinePoint_Data_PC>(shared_from_this(), std::move(*pt));
410 } else {
411 return {};
412 }
413 } else {
414#if defined(BOTAN_HAS_LEGACY_EC_POINT)
415 try {
416 auto pt = Botan::OS2ECP(bytes, m_curve);
417 return std::make_unique<EC_AffinePoint_Data_BN>(shared_from_this(), std::move(pt));
418 } catch(...) {
419 return {};
420 }
421#else
422 throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
423#endif
424 }
425}
426
427std::unique_ptr<EC_AffinePoint_Data> EC_Group_Data::point_deserialize_compressed(std::span<const uint8_t> bytes) const {
428 if(bytes.size() != 1 + p_bytes() || (bytes[0] != 0x02 && bytes[0] != 0x03)) {
429 return {};
430 }
431
432 if(m_pcurve) {
433 if(auto pt = m_pcurve->deserialize_point_compressed(bytes)) {
434 return std::make_unique<EC_AffinePoint_Data_PC>(shared_from_this(), std::move(*pt));
435 } else {
436 return {};
437 }
438 } else {
439#if defined(BOTAN_HAS_LEGACY_EC_POINT)
440 try {
441 auto pt = Botan::OS2ECP(bytes, m_curve);
442 return std::make_unique<EC_AffinePoint_Data_BN>(shared_from_this(), std::move(pt));
443 } catch(...) {
444 return {};
445 }
446#else
447 throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
448#endif
449 }
450}
451
452std::unique_ptr<EC_AffinePoint_Data> EC_Group_Data::point_identity() const {
453 if(m_pcurve) {
454 return std::make_unique<EC_AffinePoint_Data_PC>(shared_from_this(), m_pcurve->point_identity());
455 } else {
456#if defined(BOTAN_HAS_LEGACY_EC_POINT)
457 return std::make_unique<EC_AffinePoint_Data_BN>(shared_from_this(), EC_Point(m_curve));
458#else
459 throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
460#endif
461 }
462}
463
464std::function<void(std::span<uint8_t>)> h2c_expand_message(std::string_view hash_fn,
465 size_t order_bits,
466 std::span<const uint8_t> input,
467 std::span<const uint8_t> domain_sep) {
468 /*
469 * This could be extended to support expand_message_xof or a MHF like Argon2
470 */
471
472 if(hash_fn.starts_with("SHAKE")) {
473 throw Not_Implemented("Hash to curve currently does not support expand_message_xof");
474 }
475
476#if defined(BOTAN_HAS_XMD)
477 // Here we capture the HashFunction by shared_ptr because it will be owned by
478 // the returned std::function
479 const std::shared_ptr<HashFunction> hash = HashFunction::create_or_throw(hash_fn);
480
481 /*
482 * RFC 9380 Section 5.3.1: "The number of bits output by H MUST be b >= 2 * k,
483 * where k is the target security level in bits", as this "ensures k-bit
484 * collision resistance". Checking the hash's collision resistance estimate
485 * covers this, and also rejects hashes with known collision attacks. The
486 * target level is capped at 256 since the RFC 9380 suites for P-521 use k = 256.
487 */
488 const size_t k = std::min<size_t>((order_bits + 1) / 2, 256);
489
490 if(hash->security_level() < k) {
491 throw Invalid_Argument(fmt("Hash {} is too weak for use with a {} bit group", hash->name(), order_bits));
492 }
493
494 return [hash, input, domain_sep](std::span<uint8_t> uniform_bytes) {
495 expand_message_xmd(*hash, uniform_bytes, input, domain_sep);
496 };
497#else
498 BOTAN_UNUSED(order_bits, input, domain_sep);
499 throw Not_Implemented("Hash to curve is not implemented due to XMD being disabled");
500#endif
501}
502
503bool EC_Group_Data::hash_to_curve_supported(std::string_view hash_fn) const {
504#if defined(BOTAN_HAS_XMD)
505 if(!m_pcurve || !m_pcurve->supports_hash_to_curve()) {
506 return false;
507 }
508
509 // Consistent with h2c_expand_message; XOF based expansion is not implemented
510 if(hash_fn.starts_with("SHAKE")) {
511 return false;
512 }
513
514 auto hash = HashFunction::create(hash_fn);
515 if(hash == nullptr) {
516 return false;
517 }
518
519 // The same hash strength requirement enforced by h2c_expand_message
520 const size_t k = std::min<size_t>((order_bits() + 1) / 2, 256);
521 if(hash->security_level() < k) {
522 return false;
523 }
524
525 // The same requirements enforced by expand_message_xmd
526 return hash->hash_block_size() > 0 && hash->output_length() <= hash->hash_block_size();
527#else
528 BOTAN_UNUSED(hash_fn);
529 return false;
530#endif
531}
532
533std::unique_ptr<EC_AffinePoint_Data> EC_Group_Data::point_hash_to_curve_ro(std::string_view hash_fn,
534 std::span<const uint8_t> input,
535 std::span<const uint8_t> domain_sep) const {
536 if(m_pcurve && m_pcurve->supports_hash_to_curve()) {
537 const auto pt = m_pcurve->hash_to_curve_ro(h2c_expand_message(hash_fn, order_bits(), input, domain_sep));
538 return std::make_unique<EC_AffinePoint_Data_PC>(shared_from_this(), m_pcurve->point_to_affine(pt));
539 } else {
540 throw Not_Implemented("Hash to curve is not implemented for this curve");
541 }
542}
543
544std::unique_ptr<EC_AffinePoint_Data> EC_Group_Data::point_hash_to_curve_nu(std::string_view hash_fn,
545 std::span<const uint8_t> input,
546 std::span<const uint8_t> domain_sep) const {
547 if(m_pcurve && m_pcurve->supports_hash_to_curve()) {
548 auto pt = m_pcurve->hash_to_curve_nu(h2c_expand_message(hash_fn, order_bits(), input, domain_sep));
549 return std::make_unique<EC_AffinePoint_Data_PC>(shared_from_this(), std::move(pt));
550 } else {
551 throw Not_Implemented("Hash to curve is not implemented for this curve");
552 }
553}
554
555std::unique_ptr<EC_AffinePoint_Data> EC_Group_Data::point_g_mul(const EC_Scalar_Data& scalar,
556 RandomNumberGenerator& rng) const {
557 if(m_pcurve) {
558 const auto& k = EC_Scalar_Data_PC::checked_ref(scalar);
559 auto pt = m_pcurve->point_to_affine(m_pcurve->mul_by_g(k.value(), rng));
560 return std::make_unique<EC_AffinePoint_Data_PC>(shared_from_this(), std::move(pt));
561 } else {
562#if defined(BOTAN_HAS_LEGACY_EC_POINT)
563 const auto& group = scalar.group();
564 const auto& bn = EC_Scalar_Data_BN::checked_ref(scalar);
565
566 BOTAN_STATE_CHECK(group->m_base_mult != nullptr);
567 std::vector<BigInt> ws;
568 auto pt = group->m_base_mult->mul(bn.value(), rng, m_order, ws);
569 return std::make_unique<EC_AffinePoint_Data_BN>(shared_from_this(), std::move(pt));
570#else
571 throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
572#endif
573 }
574}
575
576std::unique_ptr<EC_AffinePoint_Data> EC_Group_Data::mul_px_qy(const EC_AffinePoint_Data& p,
577 const EC_Scalar_Data& x,
578 const EC_AffinePoint_Data& q,
579 const EC_Scalar_Data& y,
580 RandomNumberGenerator& rng) const {
581 if(m_pcurve) {
582 auto pt = m_pcurve->mul_px_qy(EC_AffinePoint_Data_PC::checked_ref(p).value(),
586 rng);
587
588 if(pt) {
589 return std::make_unique<EC_AffinePoint_Data_PC>(shared_from_this(), m_pcurve->point_to_affine(*pt));
590 } else {
591 return nullptr;
592 }
593 } else {
594#if defined(BOTAN_HAS_LEGACY_EC_POINT)
595 std::vector<BigInt> ws;
596 const auto& group = p.group();
597
598 // TODO this could be better!
599 const EC_Point_Var_Point_Precompute p_mul(p.to_legacy_point(), rng, ws);
600 const EC_Point_Var_Point_Precompute q_mul(q.to_legacy_point(), rng, ws);
601
602 const auto order = group->order() * group->cofactor(); // See #3800
603
604 const auto px = p_mul.mul(EC_Scalar_Data_BN::checked_ref(x).value(), rng, order, ws);
605 const auto qy = q_mul.mul(EC_Scalar_Data_BN::checked_ref(y).value(), rng, order, ws);
606
607 auto px_qy = px + qy;
608
609 if(!px_qy.is_zero()) {
610 px_qy.force_affine();
611 return std::make_unique<EC_AffinePoint_Data_BN>(shared_from_this(), std::move(px_qy));
612 } else {
613 return nullptr;
614 }
615#else
616 throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
617#endif
618 }
619}
620
621std::unique_ptr<EC_AffinePoint_Data> EC_Group_Data::affine_add(const EC_AffinePoint_Data& p,
622 const EC_AffinePoint_Data& q) const {
623 if(m_pcurve) {
624 const auto pt = m_pcurve->point_add(EC_AffinePoint_Data_PC::checked_ref(p).value(),
626
627 return std::make_unique<EC_AffinePoint_Data_PC>(shared_from_this(), m_pcurve->point_to_affine(pt));
628 } else {
629#if defined(BOTAN_HAS_LEGACY_EC_POINT)
630 auto pt = p.to_legacy_point() + q.to_legacy_point();
631 return std::make_unique<EC_AffinePoint_Data_BN>(shared_from_this(), std::move(pt));
632#else
633 throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
634#endif
635 }
636}
637
638std::unique_ptr<EC_AffinePoint_Data> EC_Group_Data::affine_neg(const EC_AffinePoint_Data& p) const {
639 if(m_pcurve) {
640 const auto pt = m_pcurve->point_negate(EC_AffinePoint_Data_PC::checked_ref(p).value());
641 return std::make_unique<EC_AffinePoint_Data_PC>(shared_from_this(), pt);
642 } else {
643#if defined(BOTAN_HAS_LEGACY_EC_POINT)
644 auto pt = p.to_legacy_point();
645 pt.negate(); // negates in place
646 return std::make_unique<EC_AffinePoint_Data_BN>(shared_from_this(), std::move(pt));
647#else
648 throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
649#endif
650 }
651}
652
653std::unique_ptr<EC_Mul2Table_Data> EC_Group_Data::make_mul2_table(const EC_AffinePoint_Data& h) const {
654 if(m_pcurve) {
655 return std::make_unique<EC_Mul2Table_Data_PC>(h);
656 } else {
657#if defined(BOTAN_HAS_LEGACY_EC_POINT)
658 const EC_AffinePoint_Data_BN g(shared_from_this(), this->base_point());
659 return std::make_unique<EC_Mul2Table_Data_BN>(g, h);
660#else
661 throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
662#endif
663 }
664}
665
666} // namespace Botan
#define BOTAN_UNUSED
Definition assert.h:151
#define BOTAN_STATE_CHECK(expr)
Definition assert.h:49
#define BOTAN_ARG_CHECK(expr, msg)
Definition assert.h:33
static Barrett_Reduction for_public_modulus(const BigInt &m)
Definition barrett.cpp:33
static BigInt zero()
Definition bigint.h:50
static BigInt random_integer(RandomNumberGenerator &rng, const BigInt &min, const BigInt &max)
Definition big_rand.cpp:45
static BigInt one()
Definition bigint.h:55
bool is_zero() const
Definition bigint.h:510
BigInt & square(secure_vector< word > &ws)
Definition big_ops2.cpp:192
T serialize(size_t len) const
Definition bigint.h:790
DER_Encoder & encode(bool b)
Definition der_enc.cpp:313
static const EC_AffinePoint_Data_PC & checked_ref(const EC_AffinePoint_Data &data)
std::unique_ptr< EC_Scalar_Data > gk_x_mod_order(const EC_Scalar_Data &scalar, RandomNumberGenerator &rng) const
const BigInt & p() const
const BigInt & g_x() const
std::unique_ptr< EC_AffinePoint_Data > affine_neg(const EC_AffinePoint_Data &p) const
const BigInt & a() const
std::unique_ptr< EC_Scalar_Data > scalar_from_bytes_mod_order(std::span< const uint8_t > bytes) const
std::unique_ptr< EC_Scalar_Data > scalar_random(RandomNumberGenerator &rng) const
std::unique_ptr< EC_Scalar_Data > scalar_deserialize(std::span< const uint8_t > bytes) const
bool params_match(const BigInt &p, const BigInt &a, const BigInt &b, const BigInt &g_x, const BigInt &g_y, const BigInt &order, const BigInt &cofactor) const
const PCurve::PrimeOrderCurve & pcurve() const
static std::shared_ptr< EC_Group_Data > create(const BigInt &p, const BigInt &a, const BigInt &b, const BigInt &g_x, const BigInt &g_y, const BigInt &order, const BigInt &cofactor, const OID &oid, EC_Group_Source source)
std::unique_ptr< EC_AffinePoint_Data > affine_add(const EC_AffinePoint_Data &p, const EC_AffinePoint_Data &q) const
std::unique_ptr< EC_Scalar_Data > scalar_from_bytes_with_trunc(std::span< const uint8_t > bytes) const
std::unique_ptr< EC_Mul2Table_Data > make_mul2_table(const EC_AffinePoint_Data &pt) const
std::unique_ptr< EC_AffinePoint_Data > mul_px_qy(const EC_AffinePoint_Data &p, const EC_Scalar_Data &x, const EC_AffinePoint_Data &q, const EC_Scalar_Data &y, RandomNumberGenerator &rng) const
std::unique_ptr< EC_AffinePoint_Data > point_deserialize_compressed(std::span< const uint8_t > bytes) const
std::unique_ptr< EC_Scalar_Data > scalar_one() const
const OID & oid() const
std::unique_ptr< EC_AffinePoint_Data > point_g_mul(const EC_Scalar_Data &scalar, RandomNumberGenerator &rng) const
size_t order_bits() const
const BigInt & cofactor() const
std::unique_ptr< EC_AffinePoint_Data > point_identity() const
Return the identity element (aka the point at infinity).
std::unique_ptr< EC_AffinePoint_Data > point_deserialize_uncompressed(std::span< const uint8_t > bytes) const
EC_Group_Data(const EC_Group_Data &other)=delete
size_t p_bytes() const
EC_Group_Source source() const
void set_oid(const OID &oid)
bool hash_to_curve_supported(std::string_view hash_fn) const
const BigInt & g_y() const
size_t order_bytes() const
std::unique_ptr< EC_Scalar_Data > scalar_from_bigint(const BigInt &bn) const
std::unique_ptr< EC_AffinePoint_Data > point_hash_to_curve_ro(std::string_view hash_fn, std::span< const uint8_t > input, std::span< const uint8_t > domain_sep) const
const BigInt & b() const
std::unique_ptr< EC_AffinePoint_Data > point_hash_to_curve_nu(std::string_view hash_fn, std::span< const uint8_t > input, std::span< const uint8_t > domain_sep) const
const BigInt & order() const
static std::shared_ptr< EC_Group_Data > EC_group_info(const OID &oid)
Definition ec_named.cpp:16
EC_Point mul(const BigInt &k, RandomNumberGenerator &rng, const BigInt &group_order, std::vector< BigInt > &ws) const
static const EC_Scalar_Data_BN & checked_ref(const EC_Scalar_Data &data)
static const EC_Scalar_Data_PC & checked_ref(const EC_Scalar_Data &data)
virtual const std::shared_ptr< const EC_Group_Data > & group() const =0
static std::unique_ptr< HashFunction > create_or_throw(std::string_view algo_spec, std::string_view provider="")
Definition hash.cpp:311
static std::unique_ptr< HashFunction > create(std::string_view algo_spec, std::string_view provider="")
Definition hash.cpp:112
static std::optional< OID > from_name(std::string_view name)
Definition asn1_oid.cpp:66
static std::shared_ptr< const PrimeOrderCurve > from_params(const BigInt &p, const BigInt &a, const BigInt &b, const BigInt &base_x, const BigInt &base_y, const BigInt &order)
Definition pcurves.cpp:21
static std::shared_ptr< const PrimeOrderCurve > for_named_curve(std::string_view name)
Definition pcurves.cpp:32
const char * name
Definition ffi_tls.h:59
#define BOTAN_HAS_LEGACY_EC_POINT
Definition build.h:240
std::string fmt(std::string_view format, const T &... args)
Definition fmt.h:53
std::function< void(std::span< uint8_t >)> h2c_expand_message(std::string_view hash_fn, size_t order_bits, std::span< const uint8_t > input, std::span< const uint8_t > domain_sep)
void expand_message_xmd(HashFunction &hash, std::span< uint8_t > output, std::span< const uint8_t > input, std::span< const uint8_t > domain_sep)
Definition xmd.cpp:17
@ Optimized
Using per curve implementation; fastest available.
Definition ec_group.h:50
@ Generic
A generic implementation that handles many curves in one implementation.
Definition ec_group.h:52
std::vector< T, secure_allocator< T > > secure_vector
Definition secmem.h:128
EC_Group_Source
Definition ec_group.h:38
EC_Point OS2ECP(std::span< const uint8_t > data, const CurveGFp &curve)
Definition ec_point.cpp:866