tommath/bn_mp_montgomery_reduce.c

116 lines
3.1 KiB
C
Raw Normal View History

#include "tommath_private.h"
2004-10-29 18:07:18 -04:00
#ifdef BN_MP_MONTGOMERY_REDUCE_C
2003-02-28 11:08:34 -05:00
/* LibTomMath, multiple-precision integer library -- Tom St Denis
*
2003-08-04 21:24:44 -04:00
* LibTomMath is a library that provides multiple-precision
2003-02-28 11:08:34 -05:00
* integer arithmetic as well as number theoretic functionality.
*
2003-08-04 21:24:44 -04:00
* The library was designed directly after the MPI library by
2003-02-28 11:08:34 -05:00
* Michael Fromberger but has been written from scratch with
* additional optimizations in place.
*
2018-12-29 11:56:20 -05:00
* SPDX-License-Identifier: Unlicense
2003-02-28 11:08:34 -05:00
*/
2003-05-29 09:35:26 -04:00
/* computes xR**-1 == x (mod N) via Montgomery Reduction */
2017-09-20 10:59:43 -04:00
int mp_montgomery_reduce(mp_int *x, const mp_int *n, mp_digit rho)
2003-02-28 11:08:34 -05:00
{
2017-08-30 14:23:46 -04:00
int ix, res, digs;
mp_digit mu;
/* can the fast reduction [comba] method be used?
*
* Note that unlike in mul you're safely allowed *less*
* than the available columns [255 per default] since carries
* are fixed up in the inner loop.
*/
digs = (n->used * 2) + 1;
2017-10-15 13:58:35 -04:00
if ((digs < (int)MP_WARRAY) &&
(x->used <= (int)MP_WARRAY) &&
2017-08-30 14:23:46 -04:00
(n->used <
2017-10-15 13:57:12 -04:00
(int)(1u << (((size_t)CHAR_BIT * sizeof(mp_word)) - (2u * (size_t)DIGIT_BIT))))) {
2017-08-30 14:23:46 -04:00
return fast_mp_montgomery_reduce(x, n, rho);
}
/* grow the input as required */
if (x->alloc < digs) {
if ((res = mp_grow(x, digs)) != MP_OKAY) {
return res;
2003-02-28 11:08:34 -05:00
}
2017-08-30 14:23:46 -04:00
}
x->used = digs;
for (ix = 0; ix < n->used; ix++) {
/* mu = ai * rho mod b
*
* The value of rho must be precalculated via
* montgomery_setup() such that
* it equals -1/n0 mod b this allows the
* following inner loop to reduce the
* input one digit at a time
*/
mu = (mp_digit)(((mp_word)x->dp[ix] * (mp_word)rho) & MP_MASK);
/* a = a + mu * m * b**i */
{
int iy;
mp_digit *tmpn, *tmpx, u;
mp_word r;
/* alias for digits of the modulus */
tmpn = n->dp;
/* alias for the digits of x [the input] */
tmpx = x->dp + ix;
/* set the carry to zero */
u = 0;
/* Multiply and add in place */
for (iy = 0; iy < n->used; iy++) {
/* compute product and sum */
r = ((mp_word)mu * (mp_word)*tmpn++) +
2017-10-15 13:58:35 -04:00
(mp_word)u + (mp_word)*tmpx;
2017-08-30 14:23:46 -04:00
/* get carry */
2017-10-15 13:58:35 -04:00
u = (mp_digit)(r >> (mp_word)DIGIT_BIT);
2017-08-30 14:23:46 -04:00
/* fix digit */
2017-10-15 13:58:35 -04:00
*tmpx++ = (mp_digit)(r & (mp_word)MP_MASK);
2017-08-30 14:23:46 -04:00
}
/* At this point the ix'th digit of x should be zero */
/* propagate carries upwards as required*/
2017-10-15 13:57:12 -04:00
while (u != 0u) {
2017-08-30 14:23:46 -04:00
*tmpx += u;
u = *tmpx >> DIGIT_BIT;
*tmpx++ &= MP_MASK;
}
}
}
2003-08-29 10:06:56 -04:00
2017-08-30 14:23:46 -04:00
/* at this point the n.used'th least
* significant digits of x are all zero
* which means we can shift x to the
* right by n.used digits and the
* residue is unchanged.
*/
2003-08-29 10:06:56 -04:00
2017-08-30 14:23:46 -04:00
/* x = x/b**n.used */
mp_clamp(x);
mp_rshd(x, n->used);
/* if x >= n then x = x - n */
if (mp_cmp_mag(x, n) != MP_LT) {
return s_mp_sub(x, n, x);
}
return MP_OKAY;
2003-02-28 11:08:34 -05:00
}
2004-10-29 18:07:18 -04:00
#endif
2005-08-01 12:37:28 -04:00
2017-08-28 10:27:26 -04:00
/* ref: $Format:%D$ */
/* git commit: $Format:%H$ */
/* commit time: $Format:%ai$ */