11#include <botan/ec_group.h>
12#include <botan/internal/point_mul.h>
13#include <botan/internal/primality.h>
14#include <botan/internal/fmt.h>
15#include <botan/ber_dec.h>
16#include <botan/der_enc.h>
18#include <botan/reducer.h>
19#include <botan/mutex.h>
23#if defined(BOTAN_HAS_EC_HASH_TO_CURVE)
24 #include <botan/internal/ec_h2c.h>
29class EC_Group_Data
final
33 EC_Group_Data(
const BigInt& p,
39 const BigInt& cofactor,
43 m_base_point(m_curve, g_x, g_y),
49 m_base_mult(m_base_point, m_mod_order),
52 m_order_bits(order.bits()),
53 m_a_is_minus_3(a == p - 3),
54 m_a_is_zero(a.is_zero()),
59 bool params_match(
const BigInt& p,
const BigInt& a,
const BigInt& b,
60 const BigInt& g_x,
const BigInt& g_y,
61 const BigInt& order,
const BigInt& cofactor)
const
63 return (this->p() == p &&
66 this->order() == order &&
67 this->cofactor() == cofactor &&
72 bool params_match(
const EC_Group_Data& other)
const
74 return params_match(other.p(), other.a(), other.b(),
75 other.g_x(), other.g_y(),
76 other.order(), other.cofactor());
79 void set_oid(
const OID& oid)
85 const OID& oid()
const {
return m_oid; }
86 const BigInt& p()
const {
return m_curve.get_p(); }
87 const BigInt& a()
const {
return m_curve.get_a(); }
88 const BigInt& b()
const {
return m_curve.get_b(); }
89 const BigInt& order()
const {
return m_order; }
90 const BigInt& cofactor()
const {
return m_cofactor; }
91 const BigInt& g_x()
const {
return m_g_x; }
92 const BigInt& g_y()
const {
return m_g_y; }
94 size_t p_bits()
const {
return m_p_bits; }
95 size_t p_bytes()
const {
return (m_p_bits + 7) / 8; }
97 size_t order_bits()
const {
return m_order_bits; }
98 size_t order_bytes()
const {
return (m_order_bits + 7) / 8; }
100 const CurveGFp& curve()
const {
return m_curve; }
101 const EC_Point& base_point()
const {
return m_base_point; }
103 bool a_is_minus_3()
const {
return m_a_is_minus_3; }
104 bool a_is_zero()
const {
return m_a_is_zero; }
106 BigInt mod_order(
const BigInt& x)
const {
return m_mod_order.reduce(x); }
108 BigInt square_mod_order(
const BigInt& x)
const
110 return m_mod_order.square(x);
113 BigInt multiply_mod_order(
const BigInt& x,
const BigInt&
y)
const
115 return m_mod_order.multiply(x,
y);
118 BigInt multiply_mod_order(
const BigInt& x,
const BigInt&
y,
const BigInt& z)
const
120 return m_mod_order.multiply(m_mod_order.multiply(x,
y), z);
123 BigInt inverse_mod_order(
const BigInt& x)
const
128 EC_Point blinded_base_point_multiply(
const BigInt& k,
129 RandomNumberGenerator& rng,
130 std::vector<BigInt>& ws)
const
132 return m_base_mult.mul(k, rng, m_order, ws);
139 EC_Point m_base_point;
145 Modular_Reducer m_mod_order;
146 EC_Point_Base_Point_Precompute m_base_mult;
155class EC_Group_Data_Map
final
158 EC_Group_Data_Map() =
default;
162 lock_guard_type<mutex_type>
lock(m_mutex);
163 size_t count = m_registered_curves.size();
164 m_registered_curves.clear();
168 std::shared_ptr<EC_Group_Data>
lookup(
const OID& oid)
170 lock_guard_type<mutex_type>
lock(m_mutex);
172 for(
auto i : m_registered_curves)
183 for(
auto curve : m_registered_curves)
185 if(curve->oid().empty() ==
true && curve->params_match(*data))
192 m_registered_curves.push_back(data);
197 return std::shared_ptr<EC_Group_Data>();
200 std::shared_ptr<EC_Group_Data> lookup_or_create(
const BigInt& p,
206 const BigInt& cofactor,
210 lock_guard_type<mutex_type>
lock(m_mutex);
212 for(
auto i : m_registered_curves)
219 if(!oid.empty() && !i->oid().empty() && i->oid() != oid)
224 const bool same_oid = !oid.empty() && i->oid() == oid;
225 const bool same_params = i->params_match(p, a, b, g_x, g_y, order, cofactor);
231 if(same_params && same_oid)
239 if(same_params && oid.empty())
247 if(same_oid && !same_params)
249 throw Invalid_Argument(
"Attempting to register a curve using OID " + oid.to_string() +
250 " but a distinct curve is already registered using that OID");
257 if(same_params && i->oid().empty() && !oid.empty())
271 std::shared_ptr<EC_Group_Data> new_group =
272 std::make_shared<EC_Group_Data>(p, a, b, g_x, g_y, order, cofactor, oid, source);
277 if(data !=
nullptr && !new_group->params_match(*data))
278 throw Invalid_Argument(
"Attempting to register an EC group under OID of hardcoded group");
284 if(oid_from_store.has_value())
299 if(new_group->params_match(*data))
301 new_group->set_oid(oid_from_store);
306 m_registered_curves.push_back(new_group);
312 std::vector<std::shared_ptr<EC_Group_Data>> m_registered_curves;
316EC_Group_Data_Map& EC_Group::ec_group_data()
323 static Allocator_Initializer g_init_allocator;
324 static EC_Group_Data_Map g_ec_data;
331 return ec_group_data().clear();
335std::shared_ptr<EC_Group_Data>
336EC_Group::load_EC_group_info(
const char* p_str,
341 const char* order_str,
347 const BigInt g_x(g_x_str);
348 const BigInt g_y(g_y_str);
349 const BigInt order(order_str);
356std::shared_ptr<EC_Group_Data> EC_Group::BER_decode_EC_group(
const uint8_t bits[],
size_t len,
359 BER_Decoder ber(bits, len);
360 BER_Object obj = ber.get_next_object();
364 throw Decoding_Error(
"Cannot handle ImplicitCA ECC parameters");
369 BER_Decoder(bits, len).decode(dom_par_oid);
370 return ec_group_data().lookup(dom_par_oid);
374 BigInt p, a, b, order, cofactor;
375 std::vector<uint8_t> base_pt;
376 std::vector<uint8_t> seed;
378 BER_Decoder(bits, len)
380 .decode_and_check<
size_t>(1,
"Unknown ECC param version code")
382 .decode_and_check(OID(
"1.2.840.10045.1.1"),
383 "Only prime ECC fields supported")
387 .decode_octet_string_bigint(a)
388 .decode_octet_string_bigint(b)
398 throw Decoding_Error(
"Invalid ECC p parameter");
400 if(a.is_negative() || a >= p)
401 throw Decoding_Error(
"Invalid ECC a parameter");
404 throw Decoding_Error(
"Invalid ECC b parameter");
407 throw Decoding_Error(
"Invalid ECC order parameter");
409 if(cofactor <= 0 || cofactor >= 16)
410 throw Decoding_Error(
"Invalid ECC cofactor parameter");
412 std::pair<BigInt, BigInt> base_xy =
Botan::OS2ECP(base_pt.data(), base_pt.size(), p, a, b);
414 return ec_group_data().lookup_or_create(p, a, b, base_xy.first, base_xy.second,
415 order, cofactor, OID(),
source);
419 throw Decoding_Error(
"Unexpected tag while decoding ECC domain params");
429 this->m_data = ec_group_data().lookup(domain_oid);
443 m_data = ec_group_data().lookup(oid);
449 if(m_data ==
nullptr)
451 if(str.size() > 30 && str.substr(0, 29) ==
"-----BEGIN EC PARAMETERS-----")
459 if(m_data ==
nullptr)
467 return EC_Group(ber.data(), ber.size());
479 m_data = ec_group_data().lookup_or_create(p, a, b, base_x, base_y, order, cofactor, oid,
488const EC_Group_Data& EC_Group::data()
const
490 if(m_data ==
nullptr)
497 return data().a_is_minus_3();
502 return data().a_is_zero();
507 return data().p_bits();
512 return data().p_bytes();
517 return data().order_bits();
522 return data().order_bytes();
542 return data().base_point();
547 return data().order();
562 return data().cofactor();
567 return data().mod_order(k);
572 return data().square_mod_order(x);
577 return data().multiply_mod_order(x,
y);
582 return data().multiply_mod_order(x,
y, z);
587 return data().inverse_mod_order(x);
597 return data().source();
628 std::vector<BigInt>& ws)
const
630 return data().blinded_base_point_multiply(k, rng, ws);
635 std::vector<BigInt>& ws)
const
637 const EC_Point pt = data().blinded_base_point_multiply(k, rng, ws);
652 std::vector<BigInt>& ws)
const
664 const uint8_t input[],
666 std::string_view domain,
667 bool random_oracle)
const
672 reinterpret_cast<const uint8_t*
>(domain.data()),
678 const uint8_t input[],
680 const uint8_t domain_sep[],
681 size_t domain_sep_len,
682 bool random_oracle)
const
684#if defined(BOTAN_HAS_EC_HASH_TO_CURVE)
689 throw Not_Implemented(
"EC_Group::hash_to_curve not available for this curve type");
694 domain_sep, domain_sep_len,
698 BOTAN_UNUSED(hash_fn, random_oracle, input, input_len, domain_sep, domain_sep_len);
699 throw Not_Implemented(
"EC_Group::hash_to_curve functionality not available in this configuration");
706 std::vector<uint8_t> output;
712 const size_t ecpVers1 = 1;
713 const OID curve_type(
"1.2.840.10045.1.1");
739 throw Encoding_Error(
"Cannot encode EC_Group as OID because OID not set");
763 if(m_data == other.m_data)
803 if(is_builtin && !strong)
812 if(p <= 3 || order <= 0)
819 const size_t test_prob = 128;
820 const bool is_randomly_generated = is_builtin;
823 if(!
is_prime(p, rng, test_prob, is_randomly_generated))
829 if(!
is_prime(order, rng, test_prob, is_randomly_generated))
841 if(discriminant == 0)
862 if(!(base_point * order).is_zero())
#define BOTAN_ASSERT_NOMSG(expr)
#define BOTAN_STATE_CHECK(expr)
#define BOTAN_UNUSED(...)
static BigInt random_integer(RandomNumberGenerator &rng, const BigInt &min, const BigInt &max)
static secure_vector< uint8_t > encode_1363(const BigInt &n, size_t bytes)
DER_Encoder & start_sequence()
DER_Encoder & encode_null()
DER_Encoder & encode(bool b)
bool a_is_minus_3() const
BigInt blinded_base_point_multiply_x(const BigInt &k, RandomNumberGenerator &rng, std::vector< BigInt > &ws) const
const BigInt & get_b() const
const BigInt & get_a() const
const BigInt & get_g_y() const
const BigInt & get_cofactor() const
BigInt mod_order(const BigInt &x) const
bool operator==(const EC_Group &other) const
BigInt multiply_mod_order(const BigInt &x, const BigInt &y) const
EC_Point zero_point() const
EC_Group_Source source() const
bool verify_public_element(const EC_Point &y) const
static EC_Group EC_Group_from_PEM(std::string_view pem)
const BigInt & get_p() const
bool verify_group(RandomNumberGenerator &rng, bool strong=false) const
const BigInt & get_order() const
size_t get_p_bits() const
const EC_Point & get_base_point() const
EC_Point point(const BigInt &x, const BigInt &y) const
EC_Point blinded_base_point_multiply(const BigInt &k, RandomNumberGenerator &rng, std::vector< BigInt > &ws) const
static std::shared_ptr< EC_Group_Data > EC_group_info(const OID &oid)
std::string PEM_encode() const
const BigInt & get_g_x() const
const OID & get_curve_oid() const
BigInt square_mod_order(const BigInt &x) const
EC_Point blinded_var_point_multiply(const EC_Point &point, const BigInt &k, RandomNumberGenerator &rng, std::vector< BigInt > &ws) const
static size_t clear_registered_curve_data()
std::vector< uint8_t > DER_encode(EC_Group_Encoding form) const
BigInt inverse_mod_order(const BigInt &x) const
EC_Point hash_to_curve(std::string_view hash_fn, const uint8_t input[], size_t input_len, const uint8_t domain_sep[], size_t domain_sep_len, bool random_oracle=true) const
size_t point_size(EC_Point_Format format) const
size_t get_p_bytes() const
EC_Point point_multiply(const BigInt &x, const EC_Point &pt, const BigInt &y) const
static OID EC_group_identity_from_order(const BigInt &order)
EC_Point OS2ECP(const uint8_t bits[], size_t len) const
BigInt random_scalar(RandomNumberGenerator &rng) const
size_t get_order_bits() const
size_t get_order_bytes() const
EC_Point multi_exp(const BigInt &k1, const BigInt &k2) const
EC_Point mul(const BigInt &k, RandomNumberGenerator &rng, const BigInt &group_order, std::vector< BigInt > &ws) const
BigInt get_affine_x() const
bool on_the_curve() const
BigInt cube(const BigInt &x) const
BigInt square(const BigInt &x) const
BigInt multiply(const BigInt &x, const BigInt &y) const
BigInt reduce(const BigInt &x) const
std::string to_string() const
static OID from_string(std::string_view str)
int(* final)(unsigned char *, CTX *)
std::string lookup(const OID &oid)
std::string encode(const uint8_t der[], size_t length, std::string_view label, size_t width)
secure_vector< uint8_t > decode_check_label(DataSource &source, std::string_view label_want)
secure_vector< uint8_t > decode(DataSource &source, std::string &label)
std::string fmt(std::string_view format, const T &... args)
secure_vector< T > lock(const std::vector< T > &in)
bool is_prime(const BigInt &n, RandomNumberGenerator &rng, size_t prob, bool is_random)
EC_Point hash_to_curve_sswu(const EC_Group &group, std::string_view hash_fn, const uint8_t input[], size_t input_len, const uint8_t domain_sep[], size_t domain_sep_len, bool random_oracle)
bool is_bailie_psw_probable_prime(const BigInt &n, const Modular_Reducer &mod_n)
EC_Point OS2ECP(const uint8_t data[], size_t data_len, const CurveGFp &curve)
BigInt inverse_mod(const BigInt &n, const BigInt &mod)
std::vector< T, secure_allocator< T > > secure_vector