Botan::EC_Group_Data Class Reference

#include <ec_inner_data.h>

Inheritance diagram for Botan::EC_Group_Data:

Public Member Functions
const BigInt &	a () const
bool	a_is_minus_3 () const
bool	a_is_zero () const
std::unique_ptr< EC_AffinePoint_Data >	affine_add (const EC_AffinePoint_Data &p, const EC_AffinePoint_Data &q) const
std::unique_ptr< EC_AffinePoint_Data >	affine_neg (const EC_AffinePoint_Data &p) const
const BigInt &	b () const
const BigInt &	cofactor () const
const std::vector< uint8_t > &	der_named_curve () const
	EC_Group_Data (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)
	EC_Group_Data (const EC_Group_Data &other)=delete
	EC_Group_Data (EC_Group_Data &&other)=delete
EC_Group_Engine	engine () const
const BigInt &	g_x () const
const BigInt &	g_y () const
std::unique_ptr< EC_Scalar_Data >	gk_x_mod_order (const EC_Scalar_Data &scalar, RandomNumberGenerator &rng) const
bool	has_cofactor () const
bool	hash_to_curve_supported (std::string_view hash_fn) 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
const OID &	oid () const
EC_Group_Data &	operator= (const EC_Group_Data &other)=delete
EC_Group_Data &	operator= (EC_Group_Data &&other)=delete
const BigInt &	order () const
size_t	order_bits () const
size_t	order_bytes () const
bool	order_is_less_than_p () const
const BigInt &	p () const
size_t	p_bits () const
size_t	p_bytes () const
size_t	p_words () 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
bool	params_match (const BigInt &p, const BigInt &a, const BigInt &b, std::span< const uint8_t > base_pt, const BigInt &order, const BigInt &cofactor) const
bool	params_match (const EC_Group_Data &other) const
const PCurve::PrimeOrderCurve &	pcurve () const
std::unique_ptr< EC_AffinePoint_Data >	point_deserialize_compressed (std::span< const uint8_t > bytes) const
std::unique_ptr< EC_AffinePoint_Data >	point_deserialize_uncompressed (std::span< const uint8_t > bytes) const
std::unique_ptr< EC_AffinePoint_Data >	point_g_mul (const EC_Scalar_Data &scalar, RandomNumberGenerator &rng) 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
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
std::unique_ptr< EC_AffinePoint_Data >	point_identity () const
	Return the identity element (aka the point at infinity).
std::unique_ptr< EC_Scalar_Data >	scalar_deserialize (std::span< const uint8_t > bytes) const
std::unique_ptr< EC_Scalar_Data >	scalar_from_bigint (const BigInt &bn) 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_from_bytes_with_trunc (std::span< const uint8_t > bytes) const
std::unique_ptr< EC_Scalar_Data >	scalar_one () const
std::unique_ptr< EC_Scalar_Data >	scalar_random (RandomNumberGenerator &rng) const
void	set_oid (const OID &oid)
EC_Group_Source	source () const
	~EC_Group_Data ()

Static Public Member Functions
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)

Detailed Description

Definition at line 127 of file ec_inner_data.h.

Constructor & Destructor Documentation

~EC_Group_Data()

Botan::EC_Group_Data::~EC_Group_Data ( )

default

EC_Group_Data() [1/3]

Botan::EC_Group_Data::EC_Group_Data ( const EC_Group_Data & other )

delete

References EC_Group_Data().

Referenced by EC_Group_Data(), EC_Group_Data(), operator=(), operator=(), and params_match().

EC_Group_Data() [2/3]

Botan::EC_Group_Data::EC_Group_Data ( EC_Group_Data && other )

delete

References EC_Group_Data().

EC_Group_Data() [3/3]

Botan::EC_Group_Data::EC_Group_Data	(	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 )

Note this constructor should only be called by EC_Group_Data::create.

It is only public to allow use of std::make_shared

Definition at line 31 of file ec_inner_data.cpp.

                                                     :
      m_p(p),
      m_a(a),
      m_b(b),
      m_g_x(g_x),
      m_g_y(g_y),
      m_order(order),
      m_cofactor(cofactor),
#if defined(BOTAN_HAS_LEGACY_EC_POINT)
      m_mod_field(Barrett_Reduction::for_public_modulus(p)),
      m_mod_order(Barrett_Reduction::for_public_modulus(order)),
      m_monty(m_p, m_mod_field),
#endif
      m_oid(oid),
      m_p_words(p.sig_words()),
      m_p_bits(p.bits()),
      m_order_bits(order.bits()),
      m_order_bytes((m_order_bits + 7) / 8),
      m_a_is_minus_3(a == p - 3),
      m_a_is_zero(a.is_zero()),
      m_has_cofactor(m_cofactor != 1),
      m_order_is_less_than_p(m_order < p),
      m_source(source) {
   // Verify the generator (x, y) satisfies y^2 = x^3 + a*x + b (mod p)
   auto mod_p = Barrett_Reduction::for_public_modulus(p);
   const BigInt y2 = mod_p.square(g_y);
   const BigInt x3_ax_b = mod_p.reduce(mod_p.cube(g_x) + mod_p.multiply(a, g_x) + b);
   if(y2 != x3_ax_b) {
      throw Invalid_Argument("EC_Group generator is not on the curve");
   }
 
   // TODO(Botan4) we can assume/assert the OID is set
   if(!m_oid.empty()) {
      DER_Encoder der(m_der_named_curve);
      der.encode(m_oid);
 
      if(const auto name = m_oid.registered_name()) {
         // returns nullptr if unknown or not supported
         m_pcurve = PCurve::PrimeOrderCurve::for_named_curve(*name);
      }
      if(m_pcurve) {
         m_engine = EC_Group_Engine::Optimized;
      }
   }
 
   // Try a generic pcurves instance
   if(!m_pcurve && !m_has_cofactor) {
      m_pcurve = PCurve::PrimeOrderCurve::from_params(p, a, b, g_x, g_y, order);
      if(m_pcurve) {
         m_engine = EC_Group_Engine::Generic;
      }
      // possibly still null here, if parameters unsuitable or if the
      // pcurves_generic module wasn't included in the build
   }
 
#if defined(BOTAN_HAS_LEGACY_EC_POINT)
   secure_vector<word> ws;
   m_a_r = m_monty.mul(a, m_monty.R2(), ws);
   m_b_r = m_monty.mul(b, m_monty.R2(), ws);
   if(!m_pcurve) {
      m_engine = EC_Group_Engine::Legacy;
   }
#else
   if(!m_pcurve) {
      if(m_oid.empty()) {
         throw Not_Implemented("EC_Group this group is not supported in this build configuration");
      } else {
         throw Not_Implemented(
            fmt("EC_Group the group {} is not supported in this build configuration", oid.to_string()));
      }
   }
#endif
}

References a(), b(), BOTAN_HAS_LEGACY_EC_POINT, cofactor(), Botan::DER_Encoder::encode(), Botan::fmt(), Botan::PCurve::PrimeOrderCurve::for_named_curve(), Botan::Barrett_Reduction::for_public_modulus(), Botan::PCurve::PrimeOrderCurve::from_params(), g_x(), g_y(), Botan::Generic, Botan::Legacy, oid(), Botan::Optimized, order(), p(), source(), and Botan::BigInt::square().

Member Function Documentation

a()

const BigInt & Botan::EC_Group_Data::a ( ) const

inline

Definition at line 172 of file ec_inner_data.h.

{ return m_a; }

Referenced by create(), EC_Group_Data(), operator=(), params_match(), params_match(), and params_match().

a_is_minus_3()

bool Botan::EC_Group_Data::a_is_minus_3 ( ) const

inline

Definition at line 212 of file ec_inner_data.h.

{ return m_a_is_minus_3; }

a_is_zero()

bool Botan::EC_Group_Data::a_is_zero ( ) const

inline

Definition at line 214 of file ec_inner_data.h.

{ return m_a_is_zero; }

affine_add()

std::unique_ptr< EC_AffinePoint_Data > Botan::EC_Group_Data::affine_add	(	const EC_AffinePoint_Data &	p,
		const EC_AffinePoint_Data &	q ) const

Definition at line 604 of file ec_inner_data.cpp.

                                                                                                   {
   if(m_pcurve) {
      auto pt = m_pcurve->point_add(EC_AffinePoint_Data_PC::checked_ref(p).value(),
                                    EC_AffinePoint_Data_PC::checked_ref(q).value());
 
      return std::make_unique<EC_AffinePoint_Data_PC>(shared_from_this(), m_pcurve->point_to_affine(pt));
   } else {
#if defined(BOTAN_HAS_LEGACY_EC_POINT)
      auto pt = p.to_legacy_point() + q.to_legacy_point();
      return std::make_unique<EC_AffinePoint_Data_BN>(shared_from_this(), std::move(pt));
#else
      throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
#endif
   }
}

References Botan::EC_AffinePoint_Data_PC::checked_ref(), and p().

affine_neg()

std::unique_ptr< EC_AffinePoint_Data > Botan::EC_Group_Data::affine_neg

(

const EC_AffinePoint_Data &

p

)

const

Definition at line 621 of file ec_inner_data.cpp.

                                                                                               {
   if(m_pcurve) {
      auto pt = m_pcurve->point_negate(EC_AffinePoint_Data_PC::checked_ref(p).value());
      return std::make_unique<EC_AffinePoint_Data_PC>(shared_from_this(), pt);
   } else {
#if defined(BOTAN_HAS_LEGACY_EC_POINT)
      auto pt = p.to_legacy_point();
      pt.negate();  // negates in place
      return std::make_unique<EC_AffinePoint_Data_BN>(shared_from_this(), std::move(pt));
#else
      throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
#endif
   }
}

References Botan::EC_AffinePoint_Data_PC::checked_ref(), and p().

b()

const BigInt & Botan::EC_Group_Data::b ( ) const

inline

Definition at line 174 of file ec_inner_data.h.

{ return m_b; }

Referenced by create(), EC_Group_Data(), operator=(), params_match(), params_match(), and params_match().

cofactor()

const BigInt & Botan::EC_Group_Data::cofactor ( ) const

inline

Definition at line 178 of file ec_inner_data.h.

{ return m_cofactor; }

Referenced by create(), EC_Group_Data(), operator=(), params_match(), params_match(), and params_match().

create()

std::shared_ptr< EC_Group_Data > Botan::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 )

static

Definition at line 113 of file ec_inner_data.cpp.

                                                                             {
   auto group = std::make_shared<EC_Group_Data>(p, a, b, g_x, g_y, order, cofactor, oid, source);
 
#if defined(BOTAN_HAS_LEGACY_EC_POINT)
   group->m_curve = CurveGFp(group.get());
   group->m_base_point = EC_Point(group->m_curve, g_x, g_y);
   if(!group->m_pcurve) {
      group->m_base_mult = std::make_unique<EC_Point_Base_Point_Precompute>(group->m_base_point, group->m_mod_order);
   }
#endif
 
   return group;
}

References a(), b(), cofactor(), g_x(), g_y(), oid(), order(), p(), and source().

der_named_curve()

const std::vector< uint8_t > & Botan::EC_Group_Data::der_named_curve ( ) const

inline

Definition at line 168 of file ec_inner_data.h.

{ return m_der_named_curve; }

engine()

EC_Group_Engine Botan::EC_Group_Data::engine ( ) const

inline

Definition at line 218 of file ec_inner_data.h.

{ return m_engine; }

g_x()

const BigInt & Botan::EC_Group_Data::g_x ( ) const

inline

Definition at line 198 of file ec_inner_data.h.

{ return m_g_x; }

Referenced by create(), EC_Group_Data(), operator=(), params_match(), params_match(), and params_match().

g_y()

const BigInt & Botan::EC_Group_Data::g_y ( ) const

inline

Definition at line 200 of file ec_inner_data.h.

{ return m_g_y; }

Referenced by create(), EC_Group_Data(), operator=(), params_match(), params_match(), and params_match().

gk_x_mod_order()

std::unique_ptr< EC_Scalar_Data > Botan::EC_Group_Data::gk_x_mod_order	(	const EC_Scalar_Data &	scalar,
		RandomNumberGenerator &	rng ) const

Definition at line 334 of file ec_inner_data.cpp.

                                                                                                {
   if(m_pcurve) {
      const auto& k = EC_Scalar_Data_PC::checked_ref(scalar);
      auto gk_x_mod_order = m_pcurve->base_point_mul_x_mod_order(k.value(), rng);
      return std::make_unique<EC_Scalar_Data_PC>(shared_from_this(), gk_x_mod_order);
   } else {
#if defined(BOTAN_HAS_LEGACY_EC_POINT)
      const auto& k = EC_Scalar_Data_BN::checked_ref(scalar);
      BOTAN_STATE_CHECK(m_base_mult != nullptr);
      std::vector<BigInt> ws;
      const auto pt = m_base_mult->mul(k.value(), rng, m_order, ws);
 
      if(pt.is_zero()) {
         return std::make_unique<EC_Scalar_Data_BN>(shared_from_this(), BigInt::zero());
      } else {
         return std::make_unique<EC_Scalar_Data_BN>(shared_from_this(), m_mod_order.reduce(pt.get_affine_x()));
      }
#else
      throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
#endif
   }
}

References BOTAN_STATE_CHECK, Botan::EC_Scalar_Data_BN::checked_ref(), Botan::EC_Scalar_Data_PC::checked_ref(), gk_x_mod_order(), and Botan::BigInt::zero().

Referenced by gk_x_mod_order().

has_cofactor()

bool Botan::EC_Group_Data::has_cofactor ( ) const

inline

Definition at line 196 of file ec_inner_data.h.

{ return m_has_cofactor; }

hash_to_curve_supported()

bool Botan::EC_Group_Data::hash_to_curve_supported

(

std::string_view

hash_fn

)

const

Return true if point_hash_to_curve_ro/point_hash_to_curve_nu will work for this group when using the specified hash function

Definition at line 486 of file ec_inner_data.cpp.

                                                                        {
#if defined(BOTAN_HAS_XMD)
   if(!m_pcurve || !m_pcurve->supports_hash_to_curve()) {
      return false;
   }
 
   // Consistent with h2c_expand_message; XOF based expansion is not implemented
   if(hash_fn.starts_with("SHAKE")) {
      return false;
   }
 
   auto hash = HashFunction::create(hash_fn);
   if(hash == nullptr) {
      return false;
   }
 
   // The same hash strength requirement enforced by h2c_expand_message
   const size_t k = std::min<size_t>((order_bits() + 1) / 2, 256);
   if(hash->security_level() < k) {
      return false;
   }
 
   // The same requirements enforced by expand_message_xmd
   return hash->hash_block_size() > 0 && hash->output_length() <= hash->hash_block_size();
#else
   BOTAN_UNUSED(hash_fn);
   return false;
#endif
}

References BOTAN_UNUSED, Botan::HashFunction::create(), and order_bits().

make_mul2_table()

std::unique_ptr< EC_Mul2Table_Data > Botan::EC_Group_Data::make_mul2_table

(

const EC_AffinePoint_Data &

pt

)

const

Definition at line 636 of file ec_inner_data.cpp.

                                                                                                  {
   if(m_pcurve) {
      return std::make_unique<EC_Mul2Table_Data_PC>(h);
   } else {
#if defined(BOTAN_HAS_LEGACY_EC_POINT)
      const EC_AffinePoint_Data_BN g(shared_from_this(), this->base_point());
      return std::make_unique<EC_Mul2Table_Data_BN>(g, h);
#else
      throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
#endif
   }
}

mul_px_qy()

std::unique_ptr< EC_AffinePoint_Data > Botan::EC_Group_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

Definition at line 559 of file ec_inner_data.cpp.

                                                                                                {
   if(m_pcurve) {
      auto pt = m_pcurve->mul_px_qy(EC_AffinePoint_Data_PC::checked_ref(p).value(),
                                    EC_Scalar_Data_PC::checked_ref(x).value(),
                                    EC_AffinePoint_Data_PC::checked_ref(q).value(),
                                    EC_Scalar_Data_PC::checked_ref(y).value(),
                                    rng);
 
      if(pt) {
         return std::make_unique<EC_AffinePoint_Data_PC>(shared_from_this(), m_pcurve->point_to_affine(*pt));
      } else {
         return nullptr;
      }
   } else {
#if defined(BOTAN_HAS_LEGACY_EC_POINT)
      std::vector<BigInt> ws;
      const auto& group = p.group();
 
      // TODO this could be better!
      const EC_Point_Var_Point_Precompute p_mul(p.to_legacy_point(), rng, ws);
      const EC_Point_Var_Point_Precompute q_mul(q.to_legacy_point(), rng, ws);
 
      const auto order = group->order() * group->cofactor();  // See #3800
 
      auto px = p_mul.mul(EC_Scalar_Data_BN::checked_ref(x).value(), rng, order, ws);
      auto qy = q_mul.mul(EC_Scalar_Data_BN::checked_ref(y).value(), rng, order, ws);
 
      auto px_qy = px + qy;
 
      if(!px_qy.is_zero()) {
         px_qy.force_affine();
         return std::make_unique<EC_AffinePoint_Data_BN>(shared_from_this(), std::move(px_qy));
      } else {
         return nullptr;
      }
#else
      throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
#endif
   }
}

References Botan::EC_AffinePoint_Data_PC::checked_ref(), Botan::EC_Scalar_Data_BN::checked_ref(), Botan::EC_Scalar_Data_PC::checked_ref(), Botan::EC_Point_Var_Point_Precompute::mul(), order(), and p().

oid()

const OID & Botan::EC_Group_Data::oid ( ) const

inline

Definition at line 166 of file ec_inner_data.h.

{ return m_oid; }

Referenced by create(), EC_Group_Data(), operator=(), and set_oid().

operator=() [1/2]

EC_Group_Data & Botan::EC_Group_Data::operator= ( const EC_Group_Data & other )

delete

References EC_Group_Data().

operator=() [2/2]

EC_Group_Data & Botan::EC_Group_Data::operator= ( EC_Group_Data && other )

delete

References a(), b(), cofactor(), EC_Group_Data(), g_x(), g_y(), oid(), order(), and p().

order()

const BigInt & Botan::EC_Group_Data::order ( ) const

inline

Definition at line 176 of file ec_inner_data.h.

{ return m_order; }

Referenced by create(), EC_Group_Data(), mul_px_qy(), operator=(), params_match(), params_match(), and params_match().

order_bits()

size_t Botan::EC_Group_Data::order_bits ( ) const

inline

Definition at line 208 of file ec_inner_data.h.

{ return m_order_bits; }

Referenced by hash_to_curve_supported(), point_hash_to_curve_nu(), point_hash_to_curve_ro(), and scalar_from_bytes_with_trunc().

order_bytes()

size_t Botan::EC_Group_Data::order_bytes ( ) const

inline

Definition at line 210 of file ec_inner_data.h.

{ return m_order_bytes; }

Referenced by scalar_from_bytes_mod_order().

order_is_less_than_p()

bool Botan::EC_Group_Data::order_is_less_than_p ( ) const

inline

Definition at line 194 of file ec_inner_data.h.

{ return m_order_is_less_than_p; }

p()

const BigInt & Botan::EC_Group_Data::p ( ) const

inline

Definition at line 170 of file ec_inner_data.h.

{ return m_p; }

Referenced by affine_add(), affine_neg(), create(), EC_Group_Data(), mul_px_qy(), operator=(), params_match(), params_match(), and params_match().

p_bits()

size_t Botan::EC_Group_Data::p_bits ( ) const

inline

Definition at line 204 of file ec_inner_data.h.

{ return m_p_bits; }

p_bytes()

size_t Botan::EC_Group_Data::p_bytes ( ) const

inline

Definition at line 206 of file ec_inner_data.h.

{ return (m_p_bits + 7) / 8; }

Referenced by params_match(), point_deserialize_compressed(), and point_deserialize_uncompressed().

p_words()

size_t Botan::EC_Group_Data::p_words ( ) const

inline

Definition at line 202 of file ec_inner_data.h.

{ return m_p_words; }

params_match() [1/3]

bool Botan::EC_Group_Data::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

Definition at line 135 of file ec_inner_data.cpp.

                                                               {
   if(p != this->p()) {
      return false;
   }
   if(a != this->a()) {
      return false;
   }
   if(b != this->b()) {
      return false;
   }
   if(order != this->order()) {
      return false;
   }
   if(cofactor != this->cofactor()) {
      return false;
   }
   if(g_x != this->g_x()) {
      return false;
   }
   if(g_y != this->g_y()) {
      return false;
   }
 
   return true;
}

References a(), b(), cofactor(), g_x(), g_y(), order(), and p().

Referenced by params_match().

params_match() [2/3]

bool Botan::EC_Group_Data::params_match	(	const BigInt &	p,
		const BigInt &	a,
		const BigInt &	b,
		std::span< const uint8_t >	base_pt,
		const BigInt &	order,
		const BigInt &	cofactor ) const

Definition at line 167 of file ec_inner_data.cpp.

                                                               {
   if(p != this->p()) {
      return false;
   }
   if(a != this->a()) {
      return false;
   }
   if(b != this->b()) {
      return false;
   }
   if(order != this->order()) {
      return false;
   }
   if(cofactor != this->cofactor()) {
      return false;
   }
 
   const size_t field_len = this->p_bytes();
 
   if(base_pt.size() == 1 + field_len && (base_pt[0] == 0x02 || base_pt[0] == 0x03)) {
      // compressed
 
      const auto g_x = m_g_x.serialize(field_len);
      const auto g_y = m_g_y.is_odd();
 
      const auto sec1_x = base_pt.subspan(1, field_len);
      const bool sec1_y = (base_pt[0] == 0x03);
 
      if(!std::ranges::equal(sec1_x, g_x)) {
         return false;
      }
 
      if(sec1_y != g_y) {
         return false;
      }
 
      return true;
   } else if(base_pt.size() == 1 + 2 * field_len && base_pt[0] == 0x04) {
      const auto g_x = m_g_x.serialize(field_len);
      const auto g_y = m_g_y.serialize(field_len);
 
      const auto sec1_x = base_pt.subspan(1, field_len);
      const auto sec1_y = base_pt.subspan(1 + field_len, field_len);
 
      if(!std::ranges::equal(sec1_x, g_x)) {
         return false;
      }
 
      if(!std::ranges::equal(sec1_y, g_y)) {
         return false;
      }
 
      return true;
   } else {
      throw Decoding_Error("Invalid base point encoding in explicit group");
   }
}

References a(), b(), cofactor(), g_x(), g_y(), order(), p(), and p_bytes().

params_match() [3/3]

bool Botan::EC_Group_Data::params_match

(

const EC_Group_Data &

other

)

const

Definition at line 230 of file ec_inner_data.cpp.

                                                                 {
   return params_match(other.p(), other.a(), other.b(), other.g_x(), other.g_y(), other.order(), other.cofactor());
}

References a(), b(), cofactor(), EC_Group_Data(), g_x(), g_y(), order(), p(), and params_match().

pcurve()

const PCurve::PrimeOrderCurve & Botan::EC_Group_Data::pcurve ( ) const

inline

Definition at line 297 of file ec_inner_data.h.

                                                  {
         BOTAN_ASSERT_NONNULL(m_pcurve);
         return *m_pcurve;
      }

References BOTAN_ASSERT_NONNULL.

point_deserialize_compressed()

std::unique_ptr< EC_AffinePoint_Data > Botan::EC_Group_Data::point_deserialize_compressed

(

std::span< const uint8_t >

bytes

)

const

Deserialize a point in the SEC1 compressed format

Returns nullptr if the encoding was not in the compressed format, or if the point is not on the curve

Definition at line 410 of file ec_inner_data.cpp.

                                                                                                                 {
   if(bytes.size() != 1 + p_bytes() || (bytes[0] != 0x02 && bytes[0] != 0x03)) {
      return {};
   }
 
   if(m_pcurve) {
      if(auto pt = m_pcurve->deserialize_point_compressed(bytes)) {
         return std::make_unique<EC_AffinePoint_Data_PC>(shared_from_this(), std::move(*pt));
      } else {
         return {};
      }
   } else {
#if defined(BOTAN_HAS_LEGACY_EC_POINT)
      try {
         auto pt = Botan::OS2ECP(bytes, m_curve);
         return std::make_unique<EC_AffinePoint_Data_BN>(shared_from_this(), std::move(pt));
      } catch(...) {
         return {};
      }
#else
      throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
#endif
   }
}

References Botan::OS2ECP(), and p_bytes().

point_deserialize_uncompressed()

std::unique_ptr< EC_AffinePoint_Data > Botan::EC_Group_Data::point_deserialize_uncompressed

(

std::span< const uint8_t >

bytes

)

const

Deserialize a point in the SEC1 uncompressed format

Returns nullptr if the encoding was not in the uncompressed format, or if the point is not on the curve

Definition at line 384 of file ec_inner_data.cpp.

                                       {
   if(bytes.size() != 1 + 2 * p_bytes() || bytes[0] != 0x04) {
      return {};
   }
 
   if(m_pcurve) {
      if(auto pt = m_pcurve->deserialize_point_uncompressed(bytes)) {
         return std::make_unique<EC_AffinePoint_Data_PC>(shared_from_this(), std::move(*pt));
      } else {
         return {};
      }
   } else {
#if defined(BOTAN_HAS_LEGACY_EC_POINT)
      try {
         auto pt = Botan::OS2ECP(bytes, m_curve);
         return std::make_unique<EC_AffinePoint_Data_BN>(shared_from_this(), std::move(pt));
      } catch(...) {
         return {};
      }
#else
      throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
#endif
   }
}

References Botan::OS2ECP(), and p_bytes().

point_g_mul()

std::unique_ptr< EC_AffinePoint_Data > Botan::EC_Group_Data::point_g_mul	(	const EC_Scalar_Data &	scalar,
		RandomNumberGenerator &	rng ) const

Definition at line 538 of file ec_inner_data.cpp.

                                                                                                  {
   if(m_pcurve) {
      const auto& k = EC_Scalar_Data_PC::checked_ref(scalar);
      auto pt = m_pcurve->point_to_affine(m_pcurve->mul_by_g(k.value(), rng));
      return std::make_unique<EC_AffinePoint_Data_PC>(shared_from_this(), std::move(pt));
   } else {
#if defined(BOTAN_HAS_LEGACY_EC_POINT)
      const auto& group = scalar.group();
      const auto& bn = EC_Scalar_Data_BN::checked_ref(scalar);
 
      BOTAN_STATE_CHECK(group->m_base_mult != nullptr);
      std::vector<BigInt> ws;
      auto pt = group->m_base_mult->mul(bn.value(), rng, m_order, ws);
      return std::make_unique<EC_AffinePoint_Data_BN>(shared_from_this(), std::move(pt));
#else
      throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
#endif
   }
}

References BOTAN_STATE_CHECK, Botan::EC_Scalar_Data_BN::checked_ref(), Botan::EC_Scalar_Data_PC::checked_ref(), and Botan::EC_Scalar_Data::group().

point_hash_to_curve_nu()

std::unique_ptr< EC_AffinePoint_Data > Botan::EC_Group_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

Definition at line 527 of file ec_inner_data.cpp.

                                                                                                                    {
   if(m_pcurve && m_pcurve->supports_hash_to_curve()) {
      auto pt = m_pcurve->hash_to_curve_nu(h2c_expand_message(hash_fn, order_bits(), input, domain_sep));
      return std::make_unique<EC_AffinePoint_Data_PC>(shared_from_this(), std::move(pt));
   } else {
      throw Not_Implemented("Hash to curve is not implemented for this curve");
   }
}

References Botan::h2c_expand_message(), and order_bits().

point_hash_to_curve_ro()

std::unique_ptr< EC_AffinePoint_Data > Botan::EC_Group_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

Definition at line 516 of file ec_inner_data.cpp.

                                                                                                                    {
   if(m_pcurve && m_pcurve->supports_hash_to_curve()) {
      auto pt = m_pcurve->hash_to_curve_ro(h2c_expand_message(hash_fn, order_bits(), input, domain_sep));
      return std::make_unique<EC_AffinePoint_Data_PC>(shared_from_this(), m_pcurve->point_to_affine(pt));
   } else {
      throw Not_Implemented("Hash to curve is not implemented for this curve");
   }
}

References Botan::h2c_expand_message(), and order_bits().

point_identity()

std::unique_ptr< EC_AffinePoint_Data > Botan::EC_Group_Data::point_identity

(

)

const

Return the identity element (aka the point at infinity).

Definition at line 435 of file ec_inner_data.cpp.

                                                                       {
   if(m_pcurve) {
      return std::make_unique<EC_AffinePoint_Data_PC>(shared_from_this(), m_pcurve->point_identity());
   } else {
#if defined(BOTAN_HAS_LEGACY_EC_POINT)
      return std::make_unique<EC_AffinePoint_Data_BN>(shared_from_this(), EC_Point(m_curve));
#else
      throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
#endif
   }
}

scalar_deserialize()

std::unique_ptr< EC_Scalar_Data > Botan::EC_Group_Data::scalar_deserialize

(

std::span< const uint8_t >

bytes

)

const

Scalar from bytes

This returns a value only if the bytes represent (in big-endian encoding) an integer that is less than n, where n is the group order. It requires that the fixed length encoding (with zero prefix) be used. It also rejects inputs that encode zero. Thus the accepted range is [1,n)

If the input is rejected then nullptr is returned

Definition at line 358 of file ec_inner_data.cpp.

                                                                                                  {
   if(bytes.size() != m_order_bytes) {
      return nullptr;
   }
 
   if(m_pcurve) {
      if(auto s = m_pcurve->deserialize_scalar(bytes)) {
         return std::make_unique<EC_Scalar_Data_PC>(shared_from_this(), *s);
      } else {
         return nullptr;
      }
   } else {
#if defined(BOTAN_HAS_LEGACY_EC_POINT)
      BigInt r(bytes);
 
      if(r.is_zero() || r >= m_order) {
         return nullptr;
      }
 
      return std::make_unique<EC_Scalar_Data_BN>(shared_from_this(), std::move(r));
#else
      throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
#endif
   }
}

References Botan::BigInt::is_zero().

Referenced by scalar_from_bigint().

scalar_from_bigint()

std::unique_ptr< EC_Scalar_Data > Botan::EC_Group_Data::scalar_from_bigint

(

const BigInt &

bn

)

const

Scalar from BigInt

This returns a value only if bn is in [1,n) where n is the group order. Otherwise it returns nullptr

Definition at line 318 of file ec_inner_data.cpp.

                                                                                      {
   if(bn <= 0 || bn >= m_order) {
      return {};
   }
 
   if(m_pcurve) {
      return this->scalar_deserialize(bn.serialize(m_order_bytes));
   } else {
#if defined(BOTAN_HAS_LEGACY_EC_POINT)
      return std::make_unique<EC_Scalar_Data_BN>(shared_from_this(), bn);
#else
      throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
#endif
   }
}

References scalar_deserialize(), and Botan::BigInt::serialize().

scalar_from_bytes_mod_order()

std::unique_ptr< EC_Scalar_Data > Botan::EC_Group_Data::scalar_from_bytes_mod_order

(

std::span< const uint8_t >

bytes

)

const

Scalar from bytes with modular reduction

This returns a value only if bytes represents (in big-endian encoding) an integer that is at most the square of the scalar group size. Otherwise it returns nullptr.

Definition at line 273 of file ec_inner_data.cpp.

                                                                                                           {
   if(bytes.size() > 2 * order_bytes()) {
      return {};
   }
 
   if(m_pcurve) {
      if(auto s = m_pcurve->scalar_from_wide_bytes(bytes)) {
         return std::make_unique<EC_Scalar_Data_PC>(shared_from_this(), std::move(*s));
      } else {
         return {};
      }
   } else {
#if defined(BOTAN_HAS_LEGACY_EC_POINT)
      return std::make_unique<EC_Scalar_Data_BN>(shared_from_this(), m_mod_order.reduce(BigInt(bytes)));
#else
      throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
#endif
   }
}

References order_bytes().

Referenced by scalar_from_bytes_with_trunc().

scalar_from_bytes_with_trunc()

std::unique_ptr< EC_Scalar_Data > Botan::EC_Group_Data::scalar_from_bytes_with_trunc

(

std::span< const uint8_t >

bytes

)

const

Scalar from bytes with ECDSA style truncation

This should always succeed

Definition at line 243 of file ec_inner_data.cpp.

                                                                                                            {
   const size_t bit_length = 8 * bytes.size();
 
   if(bit_length < order_bits()) {
      // No shifting required, but might still need to reduce by modulus
      return this->scalar_from_bytes_mod_order(bytes);
   } else {
      const size_t shift = bit_length - order_bits();
 
      const size_t new_length = bytes.size() - (shift / 8);
      const size_t bit_shift = shift % 8;
 
      if(bit_shift == 0) {
         // Easy case just read different bytes
         return this->scalar_from_bytes_mod_order(bytes.first(new_length));
      } else {
         std::vector<uint8_t> sbytes(new_length);
 
         uint8_t carry = 0;
         for(size_t i = 0; i != new_length; ++i) {
            const uint8_t w = bytes[i];
            sbytes[i] = (w >> bit_shift) | carry;
            carry = w << (8 - bit_shift);
         }
 
         return this->scalar_from_bytes_mod_order(sbytes);
      }
   }
}

References Botan::carry(), order_bits(), and scalar_from_bytes_mod_order().

scalar_one()

std::unique_ptr< EC_Scalar_Data > Botan::EC_Group_Data::scalar_one

(

)

const

Definition at line 306 of file ec_inner_data.cpp.

                                                              {
   if(m_pcurve) {
      return std::make_unique<EC_Scalar_Data_PC>(shared_from_this(), m_pcurve->scalar_one());
   } else {
#if defined(BOTAN_HAS_LEGACY_EC_POINT)
      return std::make_unique<EC_Scalar_Data_BN>(shared_from_this(), BigInt::one());
#else
      throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
#endif
   }
}

References Botan::BigInt::one().

scalar_random()

std::unique_ptr< EC_Scalar_Data > Botan::EC_Group_Data::scalar_random

(

RandomNumberGenerator &

rng

)

const

Return a random scalar

This will be in the range [1,n) where n is the group order

Definition at line 293 of file ec_inner_data.cpp.

                                                                                           {
   if(m_pcurve) {
      return std::make_unique<EC_Scalar_Data_PC>(shared_from_this(), m_pcurve->random_scalar(rng));
   } else {
#if defined(BOTAN_HAS_LEGACY_EC_POINT)
      return std::make_unique<EC_Scalar_Data_BN>(shared_from_this(),
                                                 BigInt::random_integer(rng, BigInt::one(), m_order));
#else
      throw Not_Implemented("Legacy EC interfaces disabled in this build configuration");
#endif
   }
}

References Botan::BigInt::one(), and Botan::BigInt::random_integer().

set_oid()

void Botan::EC_Group_Data::set_oid

(

const OID &

oid

)

Definition at line 234 of file ec_inner_data.cpp.

                                          {
   BOTAN_ARG_CHECK(!oid.empty(), "OID should be set");
   BOTAN_STATE_CHECK(m_oid.empty() && m_der_named_curve.empty());
   m_oid = oid;
 
   DER_Encoder der(m_der_named_curve);
   der.encode(m_oid);
}

References BOTAN_ARG_CHECK, BOTAN_STATE_CHECK, Botan::DER_Encoder::encode(), and oid().

source()

EC_Group_Source Botan::EC_Group_Data::source ( ) const

inline

Definition at line 216 of file ec_inner_data.h.

{ return m_source; }

Referenced by create(), and EC_Group_Data().

---

The documentation for this class was generated from the following files:

• src/lib/pubkey/ec_group/ec_inner_data.h
• src/lib/pubkey/ec_group/ec_inner_data.cpp