7#include <botan/internal/monty.h>
8#include <botan/reducer.h>
9#include <botan/internal/mp_core.h>
30 const word bi = b % 2;
88 const size_t output_size = m_p_words + 1;
90 if(ws.size() < output_size)
91 ws.resize(output_size);
97 m_p.
data(), m_p_words, m_p_dash,
98 ws.data(), ws.size());
106 const size_t output_size = 2*m_p_words + 2;
108 if(ws.size() < output_size)
109 ws.resize(output_size);
117 y.data(),
y.size(), std::min(m_p_words,
y.size()),
118 ws.data(), ws.size());
121 m_p.
data(), m_p_words, m_p_dash,
122 ws.data(), ws.size());
131 const size_t output_size = 2*m_p_words + 2;
132 if(ws.size() < output_size)
133 ws.resize(output_size);
140 y.data(),
y.size(), std::min(m_p_words,
y.size()),
141 ws.data(), ws.size());
144 m_p.
data(), m_p_words, m_p_dash,
145 ws.data(), ws.size());
154 const size_t output_size = 2*m_p_words;
156 if(ws.size() < 2*output_size)
157 ws.resize(2*output_size);
159 word* z_data = &ws[0];
160 word* ws_data = &ws[output_size];
166 y.data(),
y.size(), std::min(m_p_words,
y.size()),
167 ws_data, output_size);
170 m_p.
data(), m_p_words, m_p_dash,
171 ws_data, output_size);
173 if(x.
size() < output_size)
182 const size_t output_size = 2*m_p_words;
184 if(ws.size() < 2*output_size)
185 ws.resize(2*output_size);
187 word* z_data = &ws[0];
188 word* ws_data = &ws[output_size];
194 y.data(),
y.size(), std::min(m_p_words,
y.size()),
195 ws_data, output_size);
198 m_p.
data(), m_p_words, m_p_dash,
199 ws_data, output_size);
201 if(x.
size() < output_size)
208 const size_t output_size = 2*m_p_words;
210 if(ws.size() < output_size)
211 ws.resize(output_size);
219 ws.data(), ws.size());
222 m_p.
data(), m_p_words, m_p_dash,
223 ws.data(), ws.size());
231 const size_t output_size = 2*m_p_words;
233 if(ws.size() < 2*output_size)
234 ws.resize(2*output_size);
236 word* z_data = &ws[0];
237 word* ws_data = &ws[output_size];
243 ws_data, output_size);
246 m_p.
data(), m_p_words, m_p_dash,
247 ws_data, output_size);
249 if(x.
size() < output_size)
259 if(redc_needed ==
false)
267 m_v = m_params->mul(v, m_params->R2(), ws);
272 const uint8_t bits[],
size_t len,
281 m_v = m_params->mul(m_v, m_params->R2(), ws);
286 const word words[],
size_t len,
288 m_params(
std::move(params))
296 m_v = m_params->mul(m_v, m_params->R2(), ws);
302 const size_t p_words = m_params->p_words();
312 return m_v == other.m_v && m_params->p() == other.m_params->p();
317 std::vector<uint8_t> v(
size());
324 return m_params->p().bytes();
329 return m_v == m_params->R1();
340 return m_params->redc(m_v, ws);
347 z.
mod_add(other.m_v, m_params->p(), ws);
355 z.
mod_sub(other.m_v, m_params->p(), ws);
362 return this->
add(other, ws);
367 m_v.
mod_add(other.m_v, m_params->p(), ws);
374 return this->
sub(other, ws);
379 m_v.
mod_sub(other.m_v, m_params->p(), ws);
386 return Montgomery_Int(m_params, m_params->mul(m_v, other.m_v, ws),
false);
392 return Montgomery_Int(m_params, m_params->mul(m_v, other.m_v, ws),
false);
398 m_params->mul_by(m_v, other.m_v, ws);
405 m_params->mul_by(m_v, other, ws);
423 for(
size_t i = 0; i != n; ++i)
424 m_params->square_this(m_v, ws);
430 m_params->square_this(m_v, ws);
447 const BigInt iv = m_params->mul(m_params->inv_mod_p(m_v), m_params->R3(), ws);
458 m_v.
mod_mul(2, m_params->p(), ws);
464 m_v.
mod_mul(3, m_params->p(), ws);
470 m_v.
mod_mul(4, m_params->p(), ws);
476 m_v.
mod_mul(8, m_params->p(), ws);
#define BOTAN_ASSERT_NOMSG(expr)
#define BOTAN_DEBUG_ASSERT(expr)
BigInt & mod_mul(uint8_t y, const BigInt &mod, secure_vector< word > &ws)
void grow_to(size_t n) const
void set_words(const word w[], size_t len)
BigInt & mod_add(const BigInt &y, const BigInt &mod, secure_vector< word > &ws)
const word * data() const
word word_at(size_t n) const
BigInt & mod_sub(const BigInt &y, const BigInt &mod, secure_vector< word > &ws)
static BigInt power_of_2(size_t n)
static secure_vector< uint8_t > encode_1363(const BigInt &n, size_t bytes)
static BigInt with_capacity(size_t n)
BigInt square(const BigInt &x) const
BigInt multiply(const BigInt &x, const BigInt &y) const
BigInt reduce(const BigInt &x) const
Montgomery_Int & operator*=(const Montgomery_Int &other)
Montgomery_Int(std::shared_ptr< const Montgomery_Params > params)
bool operator==(const Montgomery_Int &other) const
Montgomery_Int & add(const Montgomery_Int &other, secure_vector< word > &ws)
Montgomery_Int & operator+=(const Montgomery_Int &other)
Montgomery_Int & operator-=(const Montgomery_Int &other)
Montgomery_Int square(secure_vector< word > &ws) const
Montgomery_Int cube(secure_vector< word > &ws) const
Montgomery_Int additive_inverse() const
Montgomery_Int operator*(const Montgomery_Int &other) const
Montgomery_Int & mul_by_3(secure_vector< word > &ws)
Montgomery_Int & mul_by_8(secure_vector< word > &ws)
Montgomery_Int & mul_by_2(secure_vector< word > &ws)
Montgomery_Int & sub(const Montgomery_Int &other, secure_vector< word > &ws)
Montgomery_Int operator-(const Montgomery_Int &other) const
Montgomery_Int operator+(const Montgomery_Int &other) const
Montgomery_Int & square_this_n_times(secure_vector< word > &ws, size_t n)
Montgomery_Int & mul_by_4(secure_vector< word > &ws)
Montgomery_Int & square_this(secure_vector< word > &ws)
Montgomery_Int multiplicative_inverse() const
Montgomery_Int mul(const Montgomery_Int &other, secure_vector< word > &ws) const
Montgomery_Int & mul_by(const Montgomery_Int &other, secure_vector< word > &ws)
std::vector< uint8_t > serialize() const
BigInt redc(const BigInt &x, secure_vector< word > &ws) const
void mul_by(BigInt &x, const secure_vector< word > &y, secure_vector< word > &ws) const
BigInt mul(const BigInt &x, const BigInt &y, secure_vector< word > &ws) const
BigInt sqr(const BigInt &x, secure_vector< word > &ws) const
BigInt inv_mod_p(const BigInt &x) const
Montgomery_Params(const BigInt &p, const Modular_Reducer &mod_p)
void square_this(BigInt &x, secure_vector< word > &ws) const
#define BOTAN_MP_WORD_BITS
void bigint_monty_redc(word z[], const word p[], size_t p_size, word p_dash, word ws[], size_t ws_size)
void bigint_sqr(word z[], size_t z_size, const word x[], size_t x_size, size_t x_sw, word workspace[], size_t ws_size)
void bigint_mul(word z[], size_t z_size, const word x[], size_t x_size, size_t x_sw, const word y[], size_t y_size, size_t y_sw, word workspace[], size_t ws_size)
word monty_inverse(word a)
constexpr void copy_mem(T *out, const T *in, size_t n)
BigInt inverse_mod(const BigInt &n, const BigInt &mod)
std::vector< T, secure_allocator< T > > secure_vector