#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_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

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

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 EC_Group_Data &other) const

const PCurve::PrimeOrderCurve &	pcurve () const

std::unique_ptr< EC_AffinePoint_Data >	point_deserialize (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_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 125 of file ec_inner_data.h.

Constructor & Destructor Documentation

◆ ~EC_Group_Data()

Botan::EC_Group_Data::~EC_Group_Data ( )

default

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

◆ EC_Group_Data()

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 28 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) {
   // 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);
 
      const std::string name = m_oid.human_name_or_empty();
      if(!name.empty()) {
         // 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(), g_x(), g_y(), oid(), order(), p(), and source().

Referenced by params_match(), and ~EC_Group_Data().

Member Function Documentation

◆ a()

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

inline

Definition at line 157 of file ec_inner_data.h.

157{ return m_a; }

Referenced by create(), EC_Group_Data(), params_match(), params_match(), and ~EC_Group_Data().

◆ a_is_minus_3()

bool Botan::EC_Group_Data::a_is_minus_3 ( ) const

inline

Definition at line 197 of file ec_inner_data.h.

197{ return m_a_is_minus_3; }

◆ a_is_zero()

bool Botan::EC_Group_Data::a_is_zero ( ) const

inline

Definition at line 199 of file ec_inner_data.h.

199{ 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 437 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 affine_add(), Botan::EC_AffinePoint_Data_PC::checked_ref(), and p().

Referenced by affine_add().

◆ affine_neg()

std::unique_ptr< EC_AffinePoint_Data > Botan::EC_Group_Data::affine_neg ( const EC_AffinePoint_Data & p ) const

Definition at line 454 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 affine_neg(), Botan::EC_AffinePoint_Data_PC::checked_ref(), and p().

Referenced by affine_neg().

◆ b()

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

inline

Definition at line 159 of file ec_inner_data.h.

159{ return m_b; }

Referenced by create(), EC_Group_Data(), params_match(), params_match(), and ~EC_Group_Data().

◆ cofactor()

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

inline

Definition at line 163 of file ec_inner_data.h.

163{ return m_cofactor; }

Referenced by create(), EC_Group_Data(), params_match(), params_match(), and ~EC_Group_Data().

◆ 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 103 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(), create(), g_x(), g_y(), oid(), order(), p(), and source().

Referenced by create().

◆ der_named_curve()

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

inline

Definition at line 153 of file ec_inner_data.h.

153{ return m_der_named_curve; }

◆ engine()

EC_Group_Engine Botan::EC_Group_Data::engine ( ) const

inline

Definition at line 203 of file ec_inner_data.h.

203{ return m_engine; }

◆ g_x()

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

inline

Definition at line 183 of file ec_inner_data.h.

183{ return m_g_x; }

Referenced by create(), EC_Group_Data(), params_match(), params_match(), and ~EC_Group_Data().

◆ g_y()

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

inline

Definition at line 185 of file ec_inner_data.h.

185{ return m_g_y; }

Referenced by create(), EC_Group_Data(), params_match(), params_match(), and ~EC_Group_Data().

◆ 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 240 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 181 of file ec_inner_data.h.

181{ return m_has_cofactor; }

◆ 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 469 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)
      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
   }
}

References make_mul2_table().

Referenced by make_mul2_table().

◆ 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 392 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!
      EC_Point_Var_Point_Precompute p_mul(p.to_legacy_point(), rng, ws);
      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(), mul_px_qy(), order(), and p().

Referenced by mul_px_qy().

◆ oid()

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

inline

Definition at line 151 of file ec_inner_data.h.

151{ return m_oid; }

Referenced by create(), EC_Group_Data(), set_oid(), and ~EC_Group_Data().

◆ order()

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

inline

Definition at line 161 of file ec_inner_data.h.

161{ return m_order; }

Referenced by create(), EC_Group_Data(), mul_px_qy(), params_match(), params_match(), and ~EC_Group_Data().

◆ order_bits()

size_t Botan::EC_Group_Data::order_bits ( ) const

inline

Definition at line 193 of file ec_inner_data.h.

193{ return m_order_bits; }

Referenced by scalar_from_bytes_with_trunc().

◆ order_bytes()

size_t Botan::EC_Group_Data::order_bytes ( ) const

inline

Definition at line 195 of file ec_inner_data.h.

195{ 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 179 of file ec_inner_data.h.

179{ return m_order_is_less_than_p; }

◆ p()

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

inline

Definition at line 155 of file ec_inner_data.h.

155{ return m_p; }

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

◆ p_bits()

size_t Botan::EC_Group_Data::p_bits ( ) const

inline

Definition at line 189 of file ec_inner_data.h.

189{ return m_p_bits; }

◆ p_bytes()

size_t Botan::EC_Group_Data::p_bytes ( ) const

inline

Definition at line 191 of file ec_inner_data.h.

191{ return (m_p_bits + 7) / 8; }

◆ p_words()

size_t Botan::EC_Group_Data::p_words ( ) const

inline

Definition at line 187 of file ec_inner_data.h.

187{ return m_p_words; }

◆ params_match() [1/2]

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 125 of file ec_inner_data.cpp.

                                                               {
   return (this->p() == p && this->a() == a && this->b() == b && this->order() == order &&
           this->cofactor() == cofactor && this->g_x() == g_x && this->g_y() == g_y);
}

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

Referenced by params_match(), and params_match().

◆ params_match() [2/2]

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

Definition at line 136 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 268 of file ec_inner_data.h.

                                                  {
         BOTAN_ASSERT_NONNULL(m_pcurve);
         return *m_pcurve;
      }

References BOTAN_ASSERT_NONNULL.

◆ point_deserialize()

std::unique_ptr< EC_AffinePoint_Data > Botan::EC_Group_Data::point_deserialize ( std::span< const uint8_t > bytes ) const

Deserialize a point

Returns nullptr if the point encoding was invalid or not on the curve

Definition at line 290 of file ec_inner_data.cpp.

                                                                                                      {
   // The deprecated "hybrid" point format
   // TODO(Botan4) remove this
   if(bytes.size() >= 1 + 2 * 4 && (bytes[0] == 0x06 || bytes[0] == 0x07)) {
      bool hdr_y_is_even = bytes[0] == 0x06;
      bool y_is_even = (bytes.back() & 0x01) == 0;
 
      if(hdr_y_is_even == y_is_even) {
         std::vector<uint8_t> sec1(bytes.begin(), bytes.end());
         sec1[0] = 0x04;
         return this->point_deserialize(sec1);
      }
   }
 
   try {
      if(m_pcurve) {
         if(auto pt = m_pcurve->deserialize_point(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)
         auto pt = Botan::OS2ECP(bytes, m_curve);
         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
      }
   } catch(...) {
      return {};
   }
}

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

Referenced by point_deserialize().

◆ 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 371 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(), Botan::EC_Scalar_Data::group(), and point_g_mul().

Referenced by point_g_mul().

◆ 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 360 of file ec_inner_data.cpp.

                                                                                                                    {
   if(m_pcurve) {
      auto pt = m_pcurve->hash_to_curve_nu(h2c_expand_message(hash_fn, 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 point_hash_to_curve_nu().

Referenced by point_hash_to_curve_nu().

◆ 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 349 of file ec_inner_data.cpp.

                                                                                                                    {
   if(m_pcurve) {
      auto pt = m_pcurve->hash_to_curve_ro(h2c_expand_message(hash_fn, 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 point_hash_to_curve_ro().

Referenced by point_hash_to_curve_ro().

◆ 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 264 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(), and scalar_deserialize().

Referenced by scalar_deserialize(), and 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 224 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(), scalar_from_bigint(), and Botan::BigInt::serialize().

Referenced by scalar_from_bigint().

◆ 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 179 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(), and scalar_from_bytes_mod_order().

Referenced by scalar_from_bytes_mod_order(), and 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 trunction

This should always succeed

Definition at line 149 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(), scalar_from_bytes_mod_order(), and scalar_from_bytes_with_trunc().

Referenced by scalar_from_bytes_with_trunc().

◆ scalar_one()

std::unique_ptr< EC_Scalar_Data > Botan::EC_Group_Data::scalar_one ( ) const

Definition at line 212 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(), and scalar_one().

Referenced by scalar_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 199 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(), Botan::BigInt::random_integer(), and scalar_random().

Referenced by scalar_random().

◆ set_oid()

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

Definition at line 140 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(), oid(), and set_oid().

Referenced by set_oid().

◆ source()

EC_Group_Source Botan::EC_Group_Data::source ( ) const

inline

Definition at line 201 of file ec_inner_data.h.

201{ 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

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ ~EC_Group_Data()

◆ EC_Group_Data()

Member Function Documentation

◆ a()

◆ a_is_minus_3()

◆ a_is_zero()

◆ affine_add()

◆ affine_neg()

◆ b()

◆ cofactor()

◆ create()

◆ der_named_curve()

◆ engine()

◆ g_x()

◆ g_y()

◆ gk_x_mod_order()

◆ has_cofactor()

◆ make_mul2_table()

◆ mul_px_qy()

◆ oid()

◆ order()

◆ order_bits()

◆ order_bytes()

◆ order_is_less_than_p()

◆ p()

◆ p_bits()

◆ p_bytes()

◆ p_words()

◆ params_match() [1/2]

◆ params_match() [2/2]

◆ pcurve()

◆ point_deserialize()

◆ point_g_mul()

◆ point_hash_to_curve_nu()

◆ point_hash_to_curve_ro()

◆ scalar_deserialize()

◆ scalar_from_bigint()

◆ scalar_from_bytes_mod_order()

◆ scalar_from_bytes_with_trunc()

◆ scalar_one()

◆ scalar_random()

◆ set_oid()

◆ source()