#include <pcurves_generic.h>

Inheritance diagram for Botan::PCurve::GenericPrimeOrderCurve:

Public Types
typedef std::shared_ptr< const PrimeOrderCurve >	CurvePtr
typedef std::array< word, StorageWords >	StorageUnit

Public Member Functions
const GenericCurveParams &	_params () const
void	_precompute_base_mul ()
bool	affine_point_is_identity (const AffinePoint &pt) const override
Scalar	base_point_mul_x_mod_order (const Scalar &scalar, RandomNumberGenerator &rng) const override
std::optional< AffinePoint >	deserialize_point (std::span< const uint8_t > bytes) const override
std::optional< Scalar >	deserialize_scalar (std::span< const uint8_t > bytes) const override
size_t	field_element_bytes () const override
AffinePoint	generator () const override
	Return the standard generator.
	GenericPrimeOrderCurve (const BigInt &p, const BigInt &a, const BigInt &b, const BigInt &base_x, const BigInt &base_y, const BigInt &order)
AffinePoint	hash_to_curve_nu (std::function< void(std::span< uint8_t >)> expand_message) const override
ProjectivePoint	hash_to_curve_ro (std::function< void(std::span< uint8_t >)> expand_message) const override
ProjectivePoint	mul (const AffinePoint &pt, const Scalar &scalar, RandomNumberGenerator &rng) const override
std::unique_ptr< const PrecomputedMul2Table >	mul2_setup_g (const AffinePoint &q) const override
	Setup a table for 2-ary multiplication where the first point is the generator.
std::optional< ProjectivePoint >	mul2_vartime (const PrecomputedMul2Table &tableb, const Scalar &x, const Scalar &y) const override
bool	mul2_vartime_x_mod_order_eq (const PrecomputedMul2Table &tableb, const Scalar &v, const Scalar &s1, const Scalar &s2) const override
ProjectivePoint	mul_by_g (const Scalar &scalar, RandomNumberGenerator &rng) const override
std::optional< ProjectivePoint >	mul_px_qy (const AffinePoint &p, const Scalar &x, const AffinePoint &q, const Scalar &y, RandomNumberGenerator &rng) const override
secure_vector< uint8_t >	mul_x_only (const AffinePoint &pt, const Scalar &scalar, RandomNumberGenerator &rng) const override
size_t	order_bits () const override
	Return the bit length of the group order.
ProjectivePoint	point_add (const AffinePoint &a, const AffinePoint &b) const override
AffinePoint	point_negate (const AffinePoint &pt) const override
AffinePoint	point_to_affine (const ProjectivePoint &pt) const override
Scalar	random_scalar (RandomNumberGenerator &rng) const override
Scalar	scalar_add (const Scalar &a, const Scalar &b) const override
	Scalar addition.
size_t	scalar_bytes () const override
	Return the byte length of the scalar element.
bool	scalar_equal (const Scalar &a, const Scalar &b) const override
	Test if two scalars are equal.
std::optional< Scalar >	scalar_from_wide_bytes (std::span< const uint8_t > bytes) const override
Scalar	scalar_invert (const Scalar &s) const override
	Scalar inversion.
Scalar	scalar_invert_vartime (const Scalar &s) const override
	Scalar inversion (variable time)
bool	scalar_is_zero (const Scalar &s) const override
	Test if scalar is zero.
Scalar	scalar_mul (const Scalar &a, const Scalar &b) const override
	Scalar multiplication.
Scalar	scalar_negate (const Scalar &s) const override
	Scalar negation.
Scalar	scalar_one () const override
Scalar	scalar_square (const Scalar &s) const override
	Scalar squaring.
Scalar	scalar_sub (const Scalar &a, const Scalar &b) const override
	Scalar subtraction.
void	serialize_point (std::span< uint8_t > bytes, const AffinePoint &pt) const override
void	serialize_scalar (std::span< uint8_t > bytes, const Scalar &scalar) const override

Static Public Member Functions
static std::shared_ptr< const PrimeOrderCurve >	for_named_curve (std::string_view name)
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)

Static Public Attributes
static constexpr size_t	MaximumBitLength = 521
static constexpr size_t	MaximumByteLength = (MaximumBitLength + 7) / 8
static constexpr size_t	StorageWords = (MaximumByteLength + sizeof(word) - 1) / sizeof(word)
	Number of words used to store MaximumByteLength.

Detailed Description

Definition at line 23 of file pcurves_generic.h.

Member Typedef Documentation

◆ CurvePtr

typedef std::shared_ptr<const PrimeOrderCurve> Botan::PCurve::PrimeOrderCurve::CurvePtr

inherited

Definition at line 61 of file pcurves.h.

◆ StorageUnit

typedef std::array<word, StorageWords> Botan::PCurve::PrimeOrderCurve::StorageUnit

inherited

Definition at line 60 of file pcurves.h.

Constructor & Destructor Documentation

◆ GenericPrimeOrderCurve()

Botan::PCurve::GenericPrimeOrderCurve::GenericPrimeOrderCurve	(	const BigInt &	p,
		const BigInt &	a,
		const BigInt &	b,
		const BigInt &	base_x,
		const BigInt &	base_y,
		const BigInt &	order )

Definition at line 1397 of file pcurves_generic.cpp.

1398 :

1399 m_params(std::make_unique<GenericCurveParams>(p, a, b, base_x, base_y, order)) {}

Member Function Documentation

◆ _params()

const GenericCurveParams & Botan::PCurve::GenericPrimeOrderCurve::_params ( ) const

inline

Definition at line 113 of file pcurves_generic.h.

113{ return *m_params; }

Referenced by field_element_bytes(), generator(), mul2_vartime_x_mod_order_eq(), order_bits(), scalar_bytes(), and serialize_scalar().

◆ _precompute_base_mul()

void Botan::PCurve::GenericPrimeOrderCurve::_precompute_base_mul ( )

Definition at line 1401 of file pcurves_generic.cpp.

                                                  {
   BOTAN_STATE_CHECK(m_basemul == nullptr);
   m_basemul = std::make_unique<GenericBaseMulTable>(from_stash(generator()));
}

References BOTAN_STATE_CHECK, and generator().

◆ affine_point_is_identity()

bool Botan::PCurve::GenericPrimeOrderCurve::affine_point_is_identity ( const AffinePoint & pt ) const

overridevirtual

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1535 of file pcurves_generic.cpp.

                                                                                 {
   return from_stash(pt).is_identity().as_bool();
}

◆ base_point_mul_x_mod_order()

PrimeOrderCurve::Scalar Botan::PCurve::GenericPrimeOrderCurve::base_point_mul_x_mod_order	(	const Scalar &	scalar,
		RandomNumberGenerator &	rng ) const

overridevirtual

Base point multiplication, returning only the x coordinate modulo the group order

Multiply by the standard generator point g, then extract the x coordinate as an integer, then reduce the x coordinate modulo the group order

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1424 of file pcurves_generic.cpp.

                                                                                                             {
   BOTAN_STATE_CHECK(m_basemul != nullptr);
   auto pt_s = m_basemul->mul(from_stash(scalar), rng);
   const auto x_bytes = to_affine_x<GenericCurve>(pt_s).serialize<secure_vector<uint8_t>>();
   if(auto s = GenericScalar::from_wide_bytes(this, x_bytes)) {
      return stash(*s);
   } else {
      throw Internal_Error("Failed to convert x coordinate to integer modulo scalar");
   }
}

References BOTAN_STATE_CHECK, and Botan::to_affine_x().

◆ deserialize_point()

std::optional< PrimeOrderCurve::AffinePoint > Botan::PCurve::GenericPrimeOrderCurve::deserialize_point ( std::span< const uint8_t > bytes ) const

overridevirtual

Deserialize a point

Both compressed and uncompressed encodings are accepted

Note that the deprecated "hybrid" encoding is not supported here

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1566 of file pcurves_generic.cpp.

                                       {
   if(auto pt = GenericAffinePoint::deserialize(this, bytes)) {
      return stash(pt.value());
   } else {
      return {};
   }
}

◆ deserialize_scalar()

std::optional< PrimeOrderCurve::Scalar > Botan::PCurve::GenericPrimeOrderCurve::deserialize_scalar ( std::span< const uint8_t > bytes ) const

overridevirtual

Deserialize a scalar in [1,p)

This function requires the input length be exactly scalar_bytes long; it does not accept inputs that are shorter, or with excess leading zero padding bytes.

This function also rejects zero as an input, since in normal usage scalars are integers in Z_p*

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1548 of file pcurves_generic.cpp.

                                       {
   if(auto s = GenericScalar::deserialize(this, bytes)) {
      return stash(s.value());
   } else {
      return {};
   }
}

◆ field_element_bytes()

size_t Botan::PCurve::GenericPrimeOrderCurve::field_element_bytes ( ) const

overridevirtual

Return the byte length of a field element

Each point consists of two field elements

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1414 of file pcurves_generic.cpp.

                                                         {
   return _params().field_bytes();
}

References _params().

◆ for_named_curve()

std::shared_ptr< const PrimeOrderCurve > Botan::PCurve::PrimeOrderCurve::for_named_curve ( std::string_view name )

staticinherited

Returns: nullptr if the curve specified is not available

Definition at line 26 of file pcurves.cpp.

                                                                                         {
#if defined(BOTAN_HAS_PCURVES_SECP256R1)
   if(name == "secp256r1") {
      return PCurveInstance::secp256r1();
   }
#endif
 
#if defined(BOTAN_HAS_PCURVES_SECP384R1)
   if(name == "secp384r1") {
      return PCurveInstance::secp384r1();
   }
#endif
 
#if defined(BOTAN_HAS_PCURVES_SECP521R1)
   if(name == "secp521r1") {
      return PCurveInstance::secp521r1();
   }
#endif
 
#if defined(BOTAN_HAS_PCURVES_BRAINPOOL256R1)
   if(name == "brainpool256r1") {
      return PCurveInstance::brainpool256r1();
   }
#endif
 
#if defined(BOTAN_HAS_PCURVES_BRAINPOOL384R1)
   if(name == "brainpool384r1") {
      return PCurveInstance::brainpool384r1();
   }
#endif
 
#if defined(BOTAN_HAS_PCURVES_BRAINPOOL512R1)
   if(name == "brainpool512r1") {
      return PCurveInstance::brainpool512r1();
   }
#endif
 
#if defined(BOTAN_HAS_PCURVES_FRP256V1)
   if(name == "frp256v1") {
      return PCurveInstance::frp256v1();
   }
#endif
 
#if defined(BOTAN_HAS_PCURVES_SECP192R1)
   if(name == "secp192r1") {
      return PCurveInstance::secp192r1();
   }
#endif
 
#if defined(BOTAN_HAS_PCURVES_SECP224R1)
   if(name == "secp224r1") {
      return PCurveInstance::secp224r1();
   }
#endif
 
#if defined(BOTAN_HAS_PCURVES_SECP256K1)
   if(name == "secp256k1") {
      return PCurveInstance::secp256k1();
   }
#endif
 
#if defined(BOTAN_HAS_PCURVES_SM2P256V1)
   if(name == "sm2p256v1") {
      return PCurveInstance::sm2p256v1();
   }
#endif
 
#if defined(BOTAN_HAS_PCURVES_NUMSP512D1)
   if(name == "numsp512d1") {
      return PCurveInstance::numsp512d1();
   }
#endif
 
   BOTAN_UNUSED(name);
   return {};
}

References BOTAN_UNUSED.

◆ from_params()

std::shared_ptr< const PrimeOrderCurve > Botan::PCurve::PrimeOrderCurve::from_params	(	const BigInt &	p,
		const BigInt &	a,
		const BigInt &	b,
		const BigInt &	base_x,
		const BigInt &	base_y,
		const BigInt &	order )

staticinherited

Returns: nullptr if the parameters seem unsuitable for pcurves for example if the prime is too large

This function should accept the same subset of curves as the EC_Group constructor that accepts BigInts.

Definition at line 15 of file pcurves.cpp.

                                                                                                                       {
#if defined(BOTAN_HAS_PCURVES_GENERIC)
   return PCurveInstance::from_params(p, a, b, base_x, base_y, order);
#endif
 
   BOTAN_UNUSED(p, a, b, base_x, base_y, order);
   return {};
}

References BOTAN_UNUSED.

◆ generator()

PrimeOrderCurve::AffinePoint Botan::PCurve::GenericPrimeOrderCurve::generator ( ) const

overridevirtual

Return the standard generator.

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1511 of file pcurves_generic.cpp.

                                                                   {
   return PrimeOrderCurve::AffinePoint::_create(shared_from_this(), _params().base_x(), _params().base_y());
}

References Botan::PCurve::PrimeOrderCurve::AffinePoint::_create(), and _params().

Referenced by _precompute_base_mul(), and mul2_setup_g().

◆ hash_to_curve_nu()

PrimeOrderCurve::AffinePoint Botan::PCurve::GenericPrimeOrderCurve::hash_to_curve_nu ( std::function< void(std::span< uint8_t >)> expand_message ) const

overridevirtual

RFC 9380 hash to curve (NU variant)

This is currently only supported for a few specific curves

Parameters

expand_message is a callback which must fill the provided output span with a sequence of uniform bytes, or if this is not possible due to length limitations or some other issue, throw an exception. It is invoked to produce the uniform_bytes value; see RFC 9380 section 5.2

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1656 of file pcurves_generic.cpp.

                                                             {
   BOTAN_UNUSED(expand_message);
   throw Not_Implemented("Hash to curve is not implemented for this curve");
}

References BOTAN_UNUSED.

◆ hash_to_curve_ro()

PrimeOrderCurve::ProjectivePoint Botan::PCurve::GenericPrimeOrderCurve::hash_to_curve_ro ( std::function< void(std::span< uint8_t >)> expand_message ) const

overridevirtual

RFC 9380 hash to curve (RO variant)

This is currently only supported for a few specific curves

Parameters

expand_message is a callback which must fill the provided output span with a sequence of uniform bytes, or if this is not possible due to length limitations or some other issue, throw an exception. It is invoked to produce the uniform_bytes value; see RFC 9380 section 5.2

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1662 of file pcurves_generic.cpp.

                                                             {
   BOTAN_UNUSED(expand_message);
   throw Not_Implemented("Hash to curve is not implemented for this curve");
}

References BOTAN_UNUSED.

◆ mul()

PrimeOrderCurve::ProjectivePoint Botan::PCurve::GenericPrimeOrderCurve::mul	(	const AffinePoint &	pt,
		const Scalar &	scalar,
		RandomNumberGenerator &	rng ) const

overridevirtual

Generic point multiplication

Multiply an arbitrary point by a scalar

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1436 of file pcurves_generic.cpp.

                                                                                               {
   GenericWindowedMul pt_table(from_stash(pt));
   return stash(pt_table.mul(from_stash(scalar), rng));
}

◆ mul2_setup_g()

std::unique_ptr< const PrimeOrderCurve::PrecomputedMul2Table > Botan::PCurve::GenericPrimeOrderCurve::mul2_setup_g ( const AffinePoint & q ) const

overridevirtual

Setup a table for 2-ary multiplication where the first point is the generator.

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1451 of file pcurves_generic.cpp.

                               {
   return std::make_unique<GenericVartimeWindowedMul2>(from_stash(generator()), from_stash(q));
}

References generator().

◆ mul2_vartime()

std::optional< PrimeOrderCurve::ProjectivePoint > Botan::PCurve::GenericPrimeOrderCurve::mul2_vartime	(	const PrecomputedMul2Table &	table,
		const Scalar &	x,
		const Scalar &	y ) const

overridevirtual

Perform 2-ary multiplication (variable time)

Compute p*x + q*y in variable time

Returns nullopt if the produced point is the point at infinity

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1456 of file pcurves_generic.cpp.

                                                                                                             {
   const auto& tbl = dynamic_cast<const GenericVartimeWindowedMul2&>(tableb);
   auto pt = tbl.mul2_vartime(from_stash(s1), from_stash(s2));
   if(pt.is_identity().as_bool()) {
      return {};
   } else {
      return stash(pt);
   }
}

◆ mul2_vartime_x_mod_order_eq()

bool Botan::PCurve::GenericPrimeOrderCurve::mul2_vartime_x_mod_order_eq	(	const PrecomputedMul2Table &	table,
		const Scalar &	v,
		const Scalar &	x,
		const Scalar &	y ) const

overridevirtual

Perform 2-ary multiplication (variable time), reducing x modulo order

Compute p*x + q*y in variable time, then extract the x coordinate of the result, and reduce x modulo the group order. Compare that value with v. If equal, returns true. Otherwise returns false, including if the produced point is the point at infinity

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1479 of file pcurves_generic.cpp.

                                                                                 {
   const auto& tbl = dynamic_cast<const GenericVartimeWindowedMul2&>(tableb);
   auto pt = tbl.mul2_vartime(from_stash(s1), from_stash(s2));
 
   if(!pt.is_identity().as_bool()) {
      const auto z2 = pt.z().square();
 
      const auto v_bytes = from_stash(v).serialize<std::vector<uint8_t>>();
 
      if(auto fe_v = GenericField::deserialize(this, v_bytes)) {
         if((*fe_v * z2 == pt.x()).as_bool()) {
            return true;
         }
 
         if(_params().order_is_less_than_field()) {
            const auto n = GenericField::from_words(this, _params().order());
            const auto neg_n = n.negate().to_words();
 
            const auto vw = fe_v->to_words();
            if(bigint_ct_is_lt(vw.data(), vw.size(), neg_n.data(), neg_n.size()).as_bool()) {
               return (((*fe_v + n) * z2) == pt.x()).as_bool();
            }
         }
      }
   }
 
   return false;
}

References _params(), and Botan::bigint_ct_is_lt().

◆ mul_by_g()

PrimeOrderCurve::ProjectivePoint Botan::PCurve::GenericPrimeOrderCurve::mul_by_g	(	const Scalar &	scalar,
		RandomNumberGenerator &	rng ) const

overridevirtual

Base point multiplication

Multiply by the standard generator point g

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1418 of file pcurves_generic.cpp.

                                                                                                    {
   BOTAN_STATE_CHECK(m_basemul != nullptr);
   return stash(m_basemul->mul(from_stash(scalar), rng));
}

References BOTAN_STATE_CHECK.

◆ mul_px_qy()

std::optional< PrimeOrderCurve::ProjectivePoint > Botan::PCurve::GenericPrimeOrderCurve::mul_px_qy	(	const AffinePoint &	p,
		const Scalar &	x,
		const AffinePoint &	q,
		const Scalar &	y,
		RandomNumberGenerator &	rng ) const

overridevirtual

Perform 2-ary multiplication (constant time)

Compute p*x + q*y

Returns nullopt if the produced point is the point at infinity

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1468 of file pcurves_generic.cpp.

                                                                                                                   {
   GenericWindowedMul2 table(from_stash(p), from_stash(q));
   auto pt = table.mul2(from_stash(x), from_stash(y), rng);
   if(pt.is_identity().as_bool()) {
      return {};
   } else {
      return stash(pt);
   }
}

◆ mul_x_only()

secure_vector< uint8_t > Botan::PCurve::GenericPrimeOrderCurve::mul_x_only	(	const AffinePoint &	pt,
		const Scalar &	scalar,
		RandomNumberGenerator &	rng ) const

overridevirtual

Generic x-only point multiplication

Multiply an arbitrary point by a scalar, returning only the x coordinate

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1443 of file pcurves_generic.cpp.

                                                                                            {
   GenericWindowedMul pt_table(from_stash(pt));
   auto pt_s = pt_table.mul(from_stash(scalar), rng);
   return to_affine_x<GenericCurve>(pt_s).serialize<secure_vector<uint8_t>>();
}

References Botan::to_affine_x().

◆ order_bits()

size_t Botan::PCurve::GenericPrimeOrderCurve::order_bits ( ) const

overridevirtual

Return the bit length of the group order.

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1406 of file pcurves_generic.cpp.

                                                {
   return _params().order_bits();
}

References _params().

◆ point_add()

PrimeOrderCurve::ProjectivePoint Botan::PCurve::GenericPrimeOrderCurve::point_add	(	const AffinePoint &	a,
		const AffinePoint &	b ) const

overridevirtual

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1527 of file pcurves_generic.cpp.

                                                                                                                 {
   return stash(GenericProjectivePoint::from_affine(from_stash(a)) + from_stash(b));
}

◆ point_negate()

PrimeOrderCurve::AffinePoint Botan::PCurve::GenericPrimeOrderCurve::point_negate ( const AffinePoint & pt ) const

overridevirtual

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1531 of file pcurves_generic.cpp.

                                                                                           {
   return stash(from_stash(pt).negate());
}

◆ point_to_affine()

PrimeOrderCurve::AffinePoint Botan::PCurve::GenericPrimeOrderCurve::point_to_affine ( const ProjectivePoint & pt ) const

overridevirtual

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1515 of file pcurves_generic.cpp.

                                                                                                  {
   auto affine = to_affine<GenericCurve>(from_stash(pt));
 
   const auto y2 = affine.y().square();
   const auto x3_ax_b = GenericCurve::AffinePoint::x3_ax_b(affine.x());
   const auto valid_point = affine.is_identity() || (y2 == x3_ax_b);
 
   BOTAN_ASSERT(valid_point.as_bool(), "Computed point is on the curve");
 
   return stash(affine);
}

References BOTAN_ASSERT, and Botan::to_affine().

◆ random_scalar()

PrimeOrderCurve::Scalar Botan::PCurve::GenericPrimeOrderCurve::random_scalar ( RandomNumberGenerator & rng ) const

overridevirtual

Return a new random scalar

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1615 of file pcurves_generic.cpp.

                                                                                            {
   return stash(GenericScalar::random(this, rng));
}

◆ scalar_add()

PrimeOrderCurve::Scalar Botan::PCurve::GenericPrimeOrderCurve::scalar_add	(	const Scalar &	a,
		const Scalar &	b ) const

overridevirtual

Scalar addition.

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1575 of file pcurves_generic.cpp.

                                                                                               {
   return stash(from_stash(a) + from_stash(b));
}

◆ scalar_bytes()

size_t Botan::PCurve::GenericPrimeOrderCurve::scalar_bytes ( ) const

overridevirtual

Return the byte length of the scalar element.

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1410 of file pcurves_generic.cpp.

                                                  {
   return _params().order_bytes();
}

References _params().

◆ scalar_equal()

bool Botan::PCurve::GenericPrimeOrderCurve::scalar_equal	(	const Scalar &	a,
		const Scalar &	b ) const

overridevirtual

Test if two scalars are equal.

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1607 of file pcurves_generic.cpp.

                                                                                {
   return (from_stash(a) == from_stash(b)).as_bool();
}

◆ scalar_from_wide_bytes()

std::optional< PrimeOrderCurve::Scalar > Botan::PCurve::GenericPrimeOrderCurve::scalar_from_wide_bytes ( std::span< const uint8_t > bytes ) const

overridevirtual

Reduce an integer modulo the group order

The input can be at most twice the bit length of the order; if larger than this nullopt is returned

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1557 of file pcurves_generic.cpp.

                                       {
   if(auto s = GenericScalar::from_wide_bytes(this, bytes)) {
      return stash(s.value());
   } else {
      return {};
   }
}

◆ scalar_invert()

PrimeOrderCurve::Scalar Botan::PCurve::GenericPrimeOrderCurve::scalar_invert ( const Scalar & s ) const

overridevirtual

Scalar inversion.

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1591 of file pcurves_generic.cpp.

                                                                                 {
   return stash(from_stash(s).invert());
}

◆ scalar_invert_vartime()

PrimeOrderCurve::Scalar Botan::PCurve::GenericPrimeOrderCurve::scalar_invert_vartime ( const Scalar & s ) const

overridevirtual

Scalar inversion (variable time)

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1595 of file pcurves_generic.cpp.

                                                                                         {
   return stash(from_stash(s).invert_vartime());
}

◆ scalar_is_zero()

bool Botan::PCurve::GenericPrimeOrderCurve::scalar_is_zero ( const Scalar & s ) const

overridevirtual

Test if scalar is zero.

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1603 of file pcurves_generic.cpp.

                                                                 {
   return from_stash(s).is_zero().as_bool();
}

◆ scalar_mul()

PrimeOrderCurve::Scalar Botan::PCurve::GenericPrimeOrderCurve::scalar_mul	(	const Scalar &	a,
		const Scalar &	b ) const

overridevirtual

Scalar multiplication.

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1583 of file pcurves_generic.cpp.

                                                                                               {
   return stash(from_stash(a) * from_stash(b));
}

◆ scalar_negate()

PrimeOrderCurve::Scalar Botan::PCurve::GenericPrimeOrderCurve::scalar_negate ( const Scalar & s ) const

overridevirtual

Scalar negation.

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1599 of file pcurves_generic.cpp.

                                                                                 {
   return stash(from_stash(s).negate());
}

◆ scalar_one()

PrimeOrderCurve::Scalar Botan::PCurve::GenericPrimeOrderCurve::scalar_one ( ) const

overridevirtual

Return the scalar one

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1611 of file pcurves_generic.cpp.

                                                               {
   return stash(GenericScalar::one(this));
}

◆ scalar_square()

PrimeOrderCurve::Scalar Botan::PCurve::GenericPrimeOrderCurve::scalar_square ( const Scalar & s ) const

overridevirtual

Scalar squaring.

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1587 of file pcurves_generic.cpp.

                                                                                 {
   return stash(from_stash(s).square());
}

References Botan::square().

◆ scalar_sub()

PrimeOrderCurve::Scalar Botan::PCurve::GenericPrimeOrderCurve::scalar_sub	(	const Scalar &	a,
		const Scalar &	b ) const

overridevirtual

Scalar subtraction.

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1579 of file pcurves_generic.cpp.

                                                                                               {
   return stash(from_stash(a) - from_stash(b));
}

◆ serialize_point()

void Botan::PCurve::GenericPrimeOrderCurve::serialize_point	(	std::span< uint8_t >	bytes,
		const AffinePoint &	pt ) const

overridevirtual

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1539 of file pcurves_generic.cpp.

                                                                                                {
   from_stash(pt).serialize_to(bytes);
}

◆ serialize_scalar()

void Botan::PCurve::GenericPrimeOrderCurve::serialize_scalar	(	std::span< uint8_t >	bytes,
		const Scalar &	scalar ) const

overridevirtual

Implements Botan::PCurve::PrimeOrderCurve.

Definition at line 1543 of file pcurves_generic.cpp.

                                                                                                {
   BOTAN_ARG_CHECK(bytes.size() == _params().order_bytes(), "Invalid length to serialize_scalar");
   from_stash(scalar).serialize_to(bytes);
}

References _params(), and BOTAN_ARG_CHECK.

Member Data Documentation

◆ MaximumBitLength

size_t Botan::PCurve::PrimeOrderCurve::MaximumBitLength = 521

staticconstexprinherited

Somewhat arbitrary maximum size for a field or scalar

Sized to fit at least P-521

Definition at line 38 of file pcurves.h.

◆ MaximumByteLength

size_t Botan::PCurve::PrimeOrderCurve::MaximumByteLength = (MaximumBitLength + 7) / 8

staticconstexprinherited

Definition at line 40 of file pcurves.h.

◆ StorageWords

size_t Botan::PCurve::PrimeOrderCurve::StorageWords = (MaximumByteLength + sizeof(word) - 1) / sizeof(word)

staticconstexprinherited

Number of words used to store MaximumByteLength.

Definition at line 43 of file pcurves.h.

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

src/lib/math/pcurves/pcurves_generic/pcurves_generic.h
src/lib/math/pcurves/pcurves_generic/pcurves_generic.cpp

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Detailed Description

Member Typedef Documentation

◆ CurvePtr

◆ StorageUnit

Constructor & Destructor Documentation

◆ GenericPrimeOrderCurve()

Member Function Documentation

◆ _params()

◆ _precompute_base_mul()

◆ affine_point_is_identity()

◆ base_point_mul_x_mod_order()

◆ deserialize_point()

◆ deserialize_scalar()

◆ field_element_bytes()

◆ for_named_curve()

◆ from_params()

◆ generator()

◆ hash_to_curve_nu()

◆ hash_to_curve_ro()

◆ mul()

◆ mul2_setup_g()

◆ mul2_vartime()

◆ mul2_vartime_x_mod_order_eq()

◆ mul_by_g()

◆ mul_px_qy()

◆ mul_x_only()

◆ order_bits()

◆ point_add()

◆ point_negate()

◆ point_to_affine()

◆ random_scalar()

◆ scalar_add()

◆ scalar_bytes()

◆ scalar_equal()

◆ scalar_from_wide_bytes()

◆ scalar_invert()

◆ scalar_invert_vartime()

◆ scalar_is_zero()

◆ scalar_mul()

◆ scalar_negate()

◆ scalar_one()

◆ scalar_square()

◆ scalar_sub()

◆ serialize_point()

◆ serialize_scalar()

Member Data Documentation

◆ MaximumBitLength

◆ MaximumByteLength

◆ StorageWords