Botan::Montgomery_Params Class Reference

#include <monty.h>

Public Member Functions
	Montgomery_Params (const BigInt &p)
	Montgomery_Params (const BigInt &p, const Barrett_Reduction &mod_p)
void	mul (BigInt &z, const BigInt &x, const BigInt &y, secure_vector< word > &ws) const
void	mul (BigInt &z, const BigInt &x, std::span< const word > y, secure_vector< word > &ws) const
BigInt	mul (const BigInt &x, const BigInt &y, secure_vector< word > &ws) const
void	mul_by (BigInt &x, const BigInt &y, secure_vector< word > &ws) const
bool	operator!= (const Montgomery_Params &other) const
bool	operator== (const Montgomery_Params &other) const
const BigInt &	p () const
word	p_dash () const
size_t	p_words () const
const BigInt &	R1 () const
const BigInt &	R2 () const
const BigInt &	R3 () const
BigInt	redc (const BigInt &x, secure_vector< word > &ws) const
void	sqr (BigInt &z, const BigInt &x, secure_vector< word > &ws) const
void	sqr (BigInt &z, std::span< const word > x, secure_vector< word > &ws) const
BigInt	sqr (const BigInt &x, secure_vector< word > &ws) const

Detailed Description

Parameters for Montgomery Reduction

Definition at line 23 of file monty.h.

Constructor & Destructor Documentation

Montgomery_Params() [1/2]

Botan::Montgomery_Params::Montgomery_Params	(	const BigInt &	p,
		const Barrett_Reduction &	mod_p )

Initialize a set of Montgomery reduction parameters. These values can be shared by all values in a specific Montgomery domain.

Definition at line 61 of file monty.cpp.

                                                                                    :
      m_data(std::make_shared<Data>(p, mod_p)) {}

References p().

Referenced by Montgomery_Params(), operator!=(), and operator==().

Montgomery_Params() [2/2]

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

explicit

Initialize a set of Montgomery reduction parameters. These values can be shared by all values in a specific Montgomery domain.

Definition at line 64 of file monty.cpp.

                                                    :
      Montgomery_Params(p, Barrett_Reduction::for_secret_modulus(p)) {}

References Montgomery_Params(), and p().

Member Function Documentation

mul() [1/3]

void Botan::Montgomery_Params::mul	(	BigInt &	z,
		const BigInt &	x,
		const BigInt &	y,
		secure_vector< word > &	ws ) const

Definition at line 97 of file monty.cpp.

                                                                                                      {
   BOTAN_ARG_CHECK(&z != &x && &z != &y, "Montgomery_Params::mul output must not alias inputs");
 
   const size_t p_size = this->p_words();
 
   if(ws.size() < 2 * p_size) {
      ws.resize(2 * p_size);
   }
 
   BOTAN_DEBUG_ASSERT(x.sig_words() <= p_size);
   BOTAN_DEBUG_ASSERT(y.sig_words() <= p_size);
 
   if(z.size() < 2 * p_size) {
      z.grow_to(2 * p_size);
   }
 
   bigint_mul(z.mutable_data(),
              z.size(),
              x._data(),
              x.size(),
              std::min(p_size, x.size()),
              y._data(),
              y.size(),
              std::min(p_size, y.size()),
              ws.data(),
              ws.size());
 
   bigint_monty_redc_inplace(z.mutable_data(), this->p()._data(), p_size, this->p_dash(), ws.data(), ws.size());
}

References Botan::BigInt::_data(), Botan::bigint_monty_redc_inplace(), Botan::bigint_mul(), BOTAN_ARG_CHECK, BOTAN_DEBUG_ASSERT, Botan::BigInt::grow_to(), Botan::BigInt::mutable_data(), p_words(), Botan::BigInt::sig_words(), and Botan::BigInt::size().

Referenced by Botan::Montgomery_Int::from_wide_int(), and mul().

mul() [2/3]

void Botan::Montgomery_Params::mul	(	BigInt &	z,
		const BigInt &	x,
		std::span< const word >	y,
		secure_vector< word > &	ws ) const

Definition at line 127 of file monty.cpp.

                                                                                                            {
   BOTAN_ARG_CHECK(&z != &x, "Montgomery_Params::mul output must not alias x");
   BOTAN_ARG_CHECK(!ranges_overlap(z._data(), z.size(), y.data(), y.size()),
                   "Montgomery_Params::mul output must not overlap y");
 
   const size_t p_size = this->p_words();
 
   if(ws.size() < 2 * p_size) {
      ws.resize(2 * p_size);
   }
   if(z.size() < 2 * p_size) {
      z.grow_to(2 * p_size);
   }
 
   BOTAN_DEBUG_ASSERT(x.sig_words() <= p_size);
 
   bigint_mul(z.mutable_data(),
              z.size(),
              x._data(),
              x.size(),
              std::min(p_size, x.size()),
              y.data(),
              y.size(),
              std::min(p_size, y.size()),
              ws.data(),
              ws.size());
 
   bigint_monty_redc_inplace(z.mutable_data(), this->p()._data(), p_size, this->p_dash(), ws.data(), ws.size());
}

References Botan::BigInt::_data(), Botan::bigint_monty_redc_inplace(), Botan::bigint_mul(), BOTAN_ARG_CHECK, BOTAN_DEBUG_ASSERT, Botan::BigInt::grow_to(), Botan::BigInt::mutable_data(), p_words(), Botan::BigInt::sig_words(), and Botan::BigInt::size().

mul() [3/3]

BigInt Botan::Montgomery_Params::mul	(	const BigInt &	x,
		const BigInt &	y,
		secure_vector< word > &	ws ) const

Definition at line 90 of file monty.cpp.

                                                                                             {
   const size_t p_size = this->p_words();
   BigInt z = BigInt::with_capacity(2 * p_size);
   this->mul(z, x, y, ws);
   return z;
}

References mul(), p_words(), and Botan::BigInt::with_capacity().

mul_by()

void Botan::Montgomery_Params::mul_by	(	BigInt &	x,
		const BigInt &	y,
		secure_vector< word > &	ws ) const

Definition at line 157 of file monty.cpp.

                                                                                        {
   const size_t p_size = this->p_words();
 
   if(ws.size() < 4 * p_size) {
      ws.resize(4 * p_size);
   }
 
   word* z_data = ws.data();
   word* ws_data = &ws[2 * p_size];
 
   BOTAN_DEBUG_ASSERT(x.sig_words() <= p_size);
 
   bigint_mul(z_data,
              2 * p_size,
              x._data(),
              x.size(),
              std::min(p_size, x.size()),
              y._data(),
              y.size(),
              std::min(p_size, y.size()),
              ws_data,
              2 * p_size);
 
   bigint_monty_redc_inplace(z_data, this->p()._data(), p_size, this->p_dash(), ws_data, 2 * p_size);
 
   if(x.size() < 2 * p_size) {
      x.grow_to(2 * p_size);
   }
   copy_mem(x.mutable_data(), z_data, 2 * p_size);
}

References Botan::BigInt::_data(), Botan::bigint_monty_redc_inplace(), Botan::bigint_mul(), BOTAN_DEBUG_ASSERT, Botan::copy_mem(), Botan::BigInt::grow_to(), Botan::BigInt::mutable_data(), p(), p_dash(), p_words(), Botan::BigInt::sig_words(), and Botan::BigInt::size().

operator!=()

bool Botan::Montgomery_Params::operator!= ( const Montgomery_Params & other ) const

inline

Definition at line 39 of file monty.h.

{ return !((*this) == other); }

References Montgomery_Params().

operator==()

bool Botan::Montgomery_Params::operator==

(

const Montgomery_Params &

other

)

const

Definition at line 67 of file monty.cpp.

                                                                     {
   if(this->m_data == other.m_data) {
      return true;
   }
 
   return (this->m_data->p() == other.m_data->p());
}

References Montgomery_Params().

p()

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

inline

Definition at line 41 of file monty.h.

{ return m_data->p(); }

Referenced by Montgomery_Params(), Montgomery_Params(), Botan::monty_precompute(), and mul_by().

p_dash()

word Botan::Montgomery_Params::p_dash ( ) const

inline

Definition at line 49 of file monty.h.

{ return m_data->p_dash(); }

Referenced by mul_by().

p_words()

size_t Botan::Montgomery_Params::p_words ( ) const

inline

Definition at line 51 of file monty.h.

{ return m_data->p_size(); }

Referenced by Botan::monty_multi_exp(), mul(), mul(), mul(), mul_by(), redc(), and sqr().

R1()

const BigInt & Botan::Montgomery_Params::R1 ( ) const

inline

Definition at line 43 of file monty.h.

{ return m_data->r1(); }

Referenced by Botan::Montgomery_Int::one().

R2()

const BigInt & Botan::Montgomery_Params::R2 ( ) const

inline

Definition at line 45 of file monty.h.

{ return m_data->r2(); }

R3()

const BigInt & Botan::Montgomery_Params::R3 ( ) const

inline

Definition at line 47 of file monty.h.

{ return m_data->r3(); }

Referenced by Botan::Montgomery_Int::from_wide_int().

redc()

BigInt Botan::Montgomery_Params::redc	(	const BigInt &	x,
		secure_vector< word > &	ws ) const

Definition at line 75 of file monty.cpp.

                                                                             {
   const size_t p_size = this->p_words();
 
   if(ws.size() < p_size) {
      ws.resize(p_size);
   }
 
   BigInt z = x;
   z.grow_to(2 * p_size);
 
   bigint_monty_redc_inplace(z.mutable_data(), this->p()._data(), p_size, this->p_dash(), ws.data(), ws.size());
 
   return z;
}

References Botan::bigint_monty_redc_inplace(), Botan::BigInt::grow_to(), Botan::BigInt::mutable_data(), and p_words().

Referenced by Botan::Montgomery_Int::from_wide_int().

sqr() [1/3]

void Botan::Montgomery_Params::sqr	(	BigInt &	z,
		const BigInt &	x,
		secure_vector< word > &	ws ) const

Definition at line 200 of file monty.cpp.

                                                                                     {
   BOTAN_ARG_CHECK(&z != &x, "Montgomery_Params::sqr output must not alias input");
   this->sqr(z, std::span{x._data(), x.size()}, ws);
}

References Botan::BigInt::_data(), BOTAN_ARG_CHECK, Botan::BigInt::size(), and sqr().

sqr() [2/3]

void Botan::Montgomery_Params::sqr	(	BigInt &	z,
		std::span< const word >	x,
		secure_vector< word > &	ws ) const

Definition at line 205 of file monty.cpp.

                                                                                           {
   BOTAN_ARG_CHECK(!ranges_overlap(z._data(), z.size(), x.data(), x.size()),
                   "Montgomery_Params::sqr output must not overlap input");
 
   const size_t p_size = this->p_words();
 
   if(ws.size() < 2 * p_size) {
      ws.resize(2 * p_size);
   }
 
   if(z.size() < 2 * p_size) {
      z.grow_to(2 * p_size);
   }
 
   bigint_sqr(z.mutable_data(), z.size(), x.data(), x.size(), std::min(p_size, x.size()), ws.data(), ws.size());
 
   bigint_monty_redc_inplace(z.mutable_data(), this->p()._data(), p_size, this->p_dash(), ws.data(), ws.size());
}

References Botan::BigInt::_data(), Botan::bigint_monty_redc_inplace(), Botan::bigint_sqr(), BOTAN_ARG_CHECK, Botan::BigInt::grow_to(), Botan::BigInt::mutable_data(), p_words(), and Botan::BigInt::size().

sqr() [3/3]

BigInt Botan::Montgomery_Params::sqr	(	const BigInt &	x,
		secure_vector< word > &	ws ) const

Definition at line 188 of file monty.cpp.

                                                                            {
   BOTAN_DEBUG_ASSERT(x.sig_words() <= this->p_words());
   return this->sqr(std::span{x._data(), x.size()}, ws);
}

References Botan::BigInt::_data(), BOTAN_DEBUG_ASSERT, Botan::BigInt::sig_words(), Botan::BigInt::size(), and sqr().

Referenced by sqr(), and sqr().

---

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

• src/lib/math/numbertheory/monty.h
• src/lib/math/numbertheory/monty.cpp