Botan::PointGFp Class Reference

#include <point_gfp.h>

Public Types
enum	Compression_Type { UNCOMPRESSED = 0 , COMPRESSED = 1 , HYBRID = 2 }

Public Member Functions
BigInt	get_affine_x () const
BigInt	get_affine_y () const
const CurveGFp &	get_curve () const
bool	is_zero () const
PointGFp &	negate ()
bool	on_the_curve () const
PointGFp &	operator*= (const BigInt &scalar)
PointGFp &	operator+= (const PointGFp &rhs)
PointGFp &	operator-= (const PointGFp &rhs)
bool	operator== (const PointGFp &other) const
	PointGFp ()
	PointGFp (const CurveGFp &curve)
	PointGFp (const CurveGFp &curve, const BigInt &x, const BigInt &y)
void	swap (PointGFp &other)

Friends
BOTAN_DLL PointGFp	multi_exponentiate (const PointGFp &p1, const BigInt &z1, const PointGFp &p2, const BigInt &z2)
BOTAN_DLL PointGFp	operator* (const BigInt &scalar, const PointGFp &point)

Detailed Description

This class represents one point on a curve of GF(p)

Definition at line 41 of file point_gfp.h.

Member Enumeration Documentation

Compression_Type

enum Botan::PointGFp::Compression_Type

Enumerator
UNCOMPRESSED
COMPRESSED
HYBRID

Definition at line 44 of file point_gfp.h.

                            {
         UNCOMPRESSED = 0,
         COMPRESSED   = 1,
         HYBRID       = 2
      };

Constructor & Destructor Documentation

PointGFp() [1/3]

Botan::PointGFp::PointGFp ( )

inline

Construct an uninitialized PointGFp

Definition at line 53 of file point_gfp.h.

{}

Referenced by multi_exponentiate, negate(), operator*, operator*=(), operator+=(), Botan::operator-(), operator-=(), operator==(), Botan::OS2ECP(), and swap().

PointGFp() [2/3]

Botan::PointGFp::PointGFp

(

const CurveGFp &

curve

)

Construct the zero point

Parameters

curve

The base curve

Definition at line 18 of file point_gfp.cpp.

                                        :
   curve(curve), ws(2 * (curve.get_p_words() + 2))
   {
   coord_x = 0;
   coord_y = monty_mult(1, curve.get_r2());
   coord_z = 0;
   }

PointGFp() [3/3]

Botan::PointGFp::PointGFp	(	const CurveGFp &	curve,
		const BigInt &	x,
		const BigInt &	y )

Construct a point from its affine coordinates

Parameters

curve	the base curve
x	affine x coordinate
y	affine y coordinate

Definition at line 26 of file point_gfp.cpp.

                                                                          :
   curve(curve), ws(2 * (curve.get_p_words() + 2))
   {
   if(x <= 0 || x >= curve.get_p())
      throw Invalid_Argument("Invalid PointGFp x");
   if(y <= 0 || y >= curve.get_p())
      throw Invalid_Argument("Invalid PointGFp y");
   coord_x = monty_mult(x, curve.get_r2());
   coord_y = monty_mult(y, curve.get_r2());
   coord_z = monty_mult(1, curve.get_r2());
   }

Member Function Documentation

get_affine_x()

BigInt Botan::PointGFp::get_affine_x

(

)

const

get affine x coordinate

Returns

affine x coordinate

Definition at line 400 of file point_gfp.cpp.

   {
   if(is_zero())
      throw Illegal_Transformation("Cannot convert zero point to affine");
 
   const BigInt& r2 = curve.get_r2();
 
   BigInt z2 = monty_sqr(coord_z);
   z2 = inverse_mod(z2, curve.get_p());
 
   z2 = monty_mult(z2, r2);
   return monty_mult(coord_x, z2);
   }

References Botan::Illegal_Transformation::Illegal_Transformation(), Botan::inverse_mod(), and is_zero().

Referenced by Botan::ECDH_KA_Operation::agree(), Botan::EC2OSP(), operator==(), Botan::ECDSA_Signature_Operation::sign(), and Botan::ECDSA_Verification_Operation::verify().

get_affine_y()

BigInt Botan::PointGFp::get_affine_y

(

)

const

get affine y coordinate

Returns

affine y coordinate

Definition at line 414 of file point_gfp.cpp.

   {
   if(is_zero())
      throw Illegal_Transformation("Cannot convert zero point to affine");
 
   const BigInt& r2 = curve.get_r2();
 
   BigInt z3 = monty_mult(coord_z, monty_sqr(coord_z));
   z3 = inverse_mod(z3, curve.get_p());
   z3 = monty_mult(z3, r2);
   return monty_mult(coord_y, z3);
   }

References Botan::Illegal_Transformation::Illegal_Transformation(), Botan::inverse_mod(), and is_zero().

Referenced by Botan::EC2OSP(), and operator==().

get_curve()

const CurveGFp & Botan::PointGFp::get_curve ( ) const

inline

Return base curve of this point

Returns

the curve over GF(p) of this point

Definition at line 128 of file point_gfp.h.

{ return curve; }

Referenced by Botan::EC2OSP(), operator*, and operator==().

is_zero()

bool Botan::PointGFp::is_zero ( ) const

inline

Is this the point at infinity?

Returns

true, if this point is at infinity, false otherwise.

Definition at line 146 of file point_gfp.h.

         { return (coord_x.is_zero() && coord_z.is_zero()); }

Referenced by Botan::EC2OSP(), get_affine_x(), get_affine_y(), negate(), on_the_curve(), operator-=(), operator==(), and Botan::ECDSA_Verification_Operation::verify().

negate()

PointGFp & Botan::PointGFp::negate ( )

inline

Negate this point

Returns

*this

Definition at line 117 of file point_gfp.h.

         {
         if(!is_zero())
            coord_y = curve.get_p() - coord_y;
         return *this;
         }

References is_zero(), and PointGFp().

Referenced by multi_exponentiate, and operator*.

on_the_curve()

bool Botan::PointGFp::on_the_curve

(

)

const

Checks whether the point is to be found on the underlying curve; used to prevent fault attacks.

Returns

if the point is on the curve

Definition at line 427 of file point_gfp.cpp.

   {
   /*
   Is the point still on the curve?? (If everything is correct, the
   point is always on its curve; then the function will return true.
   If somehow the state is corrupted, which suggests a fault attack
   (or internal computational error), then return false.
   */
 
   if(is_zero())
      return true;
 
   BigInt y2 = monty_mult(monty_sqr(coord_y), 1);
   BigInt x3 = monty_mult(coord_x, monty_sqr(coord_x));
 
   BigInt ax = monty_mult(coord_x, curve.get_a_r());
 
   const BigInt& b_r = curve.get_b_r();
 
   BigInt z2 = monty_sqr(coord_z);
 
   if(coord_z == z2) // Is z equal to 1 (in Montgomery form)?
      {
      if(y2 != monty_mult(x3 + ax + b_r, 1))
         return false;
      }
 
   BigInt z3 = monty_mult(coord_z, z2);
 
   BigInt ax_z4 = monty_mult(ax, monty_sqr(z2));
 
   BigInt b_z6 = monty_mult(b_r, monty_sqr(z3));
 
   if(y2 != monty_mult(x3 + ax_z4 + b_z6, 1))
      return false;
 
   return true;
   }

References is_zero().

Referenced by Botan::ECDH_KA_Operation::agree(), Botan::EC_PublicKey::check_key(), Botan::EC_PrivateKey::EC_PrivateKey(), Botan::EC_PrivateKey::EC_PrivateKey(), and Botan::OS2ECP().

operator*=()

PointGFp & Botan::PointGFp::operator*=

(

const BigInt &

scalar

)

*= Operator

Parameters

scalar

the PointGFp to multiply with *this

Returns

resulting PointGFp

Definition at line 259 of file point_gfp.cpp.

   {
   *this = scalar * *this;
   return *this;
   }

References PointGFp().

operator+=()

PointGFp & Botan::PointGFp::operator+=

(

const PointGFp &

rhs

)

+= Operator

Parameters

rhs	the PointGFp to add to the local value

Returns

resulting PointGFp

Definition at line 240 of file point_gfp.cpp.

   {
   std::vector<BigInt> ws(9);
   add(rhs, ws);
   return *this;
   }

References PointGFp().

operator-=()

PointGFp & Botan::PointGFp::operator-=

(

const PointGFp &

rhs

)

-= Operator

Parameters

rhs	the PointGFp to subtract from the local value

Returns

resulting PointGFp

Definition at line 247 of file point_gfp.cpp.

   {
   PointGFp minus_rhs = PointGFp(rhs).negate();
 
   if(is_zero())
      *this = minus_rhs;
   else
      *this += minus_rhs;
 
   return *this;
   }

References is_zero(), and PointGFp().

operator==()

bool Botan::PointGFp::operator==

(

const PointGFp &

other

)

const

Equality operator

Definition at line 476 of file point_gfp.cpp.

   {
   if(get_curve() != other.get_curve())
      return false;
 
   // If this is zero, only equal if other is also zero
   if(is_zero())
      return other.is_zero();
 
   return (get_affine_x() == other.get_affine_x() &&
           get_affine_y() == other.get_affine_y());
   }

References get_affine_x(), get_affine_y(), get_curve(), is_zero(), and PointGFp().

swap()

void Botan::PointGFp::swap

(

PointGFp &

other

)

swaps the states of *this and other, does not throw!

Parameters

other

the object to swap values with

Definition at line 467 of file point_gfp.cpp.

   {
   curve.swap(other.curve);
   coord_x.swap(other.coord_x);
   coord_y.swap(other.coord_y);
   coord_z.swap(other.coord_z);
   ws.swap(other.ws);
   }

References PointGFp().

Referenced by std::swap< Botan::PointGFp >().

Friends And Related Symbol Documentation

multi_exponentiate

BOTAN_DLL PointGFp multi_exponentiate ( const PointGFp & p1, const BigInt & z1, const PointGFp & p2, const BigInt & z2 )

friend

Multiexponentiation

Parameters

p1	a point
z1	a scalar
p2	a point
z2	a scalar

Returns

(p1 * z1 + p2 * z2)

Definition at line 265 of file point_gfp.cpp.

   {
   const PointGFp p3 = p1 + p2;
 
   PointGFp H(p1.curve); // create as zero
   size_t bits_left = std::max(z1.bits(), z2.bits());
 
   std::vector<BigInt> ws(9);
 
   while(bits_left)
      {
      H.mult2(ws);
 
      const bool z1_b = z1.get_bit(bits_left - 1);
      const bool z2_b = z2.get_bit(bits_left - 1);
 
      if(z1_b == true && z2_b == true)
         H.add(p3, ws);
      else if(z1_b)
         H.add(p1, ws);
      else if(z2_b)
         H.add(p2, ws);
 
      --bits_left;
      }
 
   if(z1.is_negative() != z2.is_negative())
      H.negate();
 
   return H;
   }

References Botan::BigInt::bits(), Botan::BigInt::get_bit(), Botan::BigInt::is_negative(), multi_exponentiate, negate(), and PointGFp().

Referenced by multi_exponentiate.

operator*

BOTAN_DLL PointGFp operator* ( const BigInt & scalar, const PointGFp & point )

friend

Multiplication Operator

Parameters

scalar	the scalar value
point	the point value

Returns

scalar*point on the curve

Definition at line 298 of file point_gfp.cpp.

   {
   const CurveGFp& curve = point.get_curve();
 
   if(scalar.is_zero())
      return PointGFp(curve); // zero point
 
   std::vector<BigInt> ws(9);
 
   if(scalar.abs() <= 2) // special cases for small values
      {
      byte value = scalar.abs().byte_at(0);
 
      PointGFp result = point;
 
      if(value == 2)
         result.mult2(ws);
 
      if(scalar.is_negative())
         result.negate();
 
      return result;
      }
 
   const size_t scalar_bits = scalar.bits();
 
#if 0
 
   PointGFp x1 = PointGFp(curve);
   PointGFp x2 = point;
 
   size_t bits_left = scalar_bits;
 
   // Montgomery Ladder
   while(bits_left)
      {
      const bool bit_set = scalar.get_bit(bits_left - 1);
 
      if(bit_set)
         {
         x1.add(x2, ws);
         x2.mult2(ws);
         }
      else
         {
         x2.add(x1, ws);
         x1.mult2(ws);
         }
 
      --bits_left;
      }
 
   if(scalar.is_negative())
      x1.negate();
 
   return x1;
 
#else
   const size_t window_size = 4;
 
   std::vector<PointGFp> Ps(1 << window_size);
   Ps[0] = PointGFp(curve);
   Ps[1] = point;
 
   for(size_t i = 2; i != Ps.size(); ++i)
      {
      Ps[i] = Ps[i-1];
      Ps[i].add(point, ws);
      }
 
   PointGFp H(curve); // create as zero
   size_t bits_left = scalar_bits;
 
   while(bits_left >= window_size)
      {
      for(size_t i = 0; i != window_size; ++i)
         H.mult2(ws);
 
      const u32bit nibble = scalar.get_substring(bits_left - window_size,
                                                 window_size);
 
      H.add(Ps[nibble], ws);
 
      bits_left -= window_size;
      }
 
   while(bits_left)
      {
      H.mult2(ws);
      if(scalar.get_bit(bits_left-1))
         H.add(point, ws);
 
      --bits_left;
      }
 
   if(scalar.is_negative())
      H.negate();
 
   return H;
#endif
   }

References Botan::BigInt::abs(), Botan::BigInt::bits(), Botan::BigInt::byte_at(), Botan::BigInt::get_bit(), get_curve(), Botan::BigInt::get_substring(), Botan::BigInt::is_negative(), Botan::BigInt::is_zero(), negate(), operator*, and PointGFp().

Referenced by operator*.

---

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

• src/math/ec_gfp/point_gfp.h
• src/math/ec_gfp/point_gfp.cpp