TeaSpeak/tommath
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #85 from fperrad/20170830_format

Browse Source 
rebase formating code
This commit is contained in:
Steffen Jaeckel 2017-09-15 12:46:38 +02:00 committed by GitHub
commit fedc15b625
129 changed files with 5706 additions and 5579 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
astylerc Normal file
View File

@ -0,0 +1,27 @@
# Artistic Style, see http://astyle.sourceforge.net/
# full documentation, see: http://astyle.sourceforge.net/astyle.html
#
# usage:
# astyle --options=astylerc *.[ch]
## Bracket Style Options
style=kr
## Tab Options
indent=spaces=3
## Bracket Modify Options
## Indentation Options
min-conditional-indent=0
## Padding Options
pad-header
unpad-paren
align-pointer=name
## Formatting Options
break-after-logical
max-code-length=120
convert-tabs
mode=c

16
bn_error.c
View File

@ -16,12 +16,12 @@
*/ */
static const struct { static const struct {
int code; int code;
const char *msg; const char *msg;
} msgs[] = { } msgs[] = {
{ MP_OKAY, "Successful" }, { MP_OKAY, "Successful" },
{ MP_MEM, "Out of heap" }, { MP_MEM, "Out of heap" },
{ MP_VAL, "Value out of range" } { MP_VAL, "Value out of range" }
}; };
/* return a char * string for a given code */ /* return a char * string for a given code */
@ -31,9 +31,9 @@ const char *mp_error_to_string(int code)
/* scan the lookup table for the given message */ /* scan the lookup table for the given message */
for (x = 0; x < (int)(sizeof(msgs) / sizeof(msgs[0])); x++) { for (x = 0; x < (int)(sizeof(msgs) / sizeof(msgs[0])); x++) {
if (msgs[x].code == code) { if (msgs[x].code == code) {
return msgs[x].msg; return msgs[x].msg;
} }
} }
/* generic reply for invalid code */ /* generic reply for invalid code */

219
bn_fast_mp_invmod.c
View File

@ -15,131 +15,132 @@
* Tom St Denis, tstdenis82@gmail.com, http://libtom.org * Tom St Denis, tstdenis82@gmail.com, http://libtom.org
*/ */
/* computes the modular inverse via binary extended euclidean algorithm, /* computes the modular inverse via binary extended euclidean algorithm,
* that is c = 1/a mod b * that is c = 1/a mod b
* *
* Based on slow invmod except this is optimized for the case where b is * Based on slow invmod except this is optimized for the case where b is
* odd as per HAC Note 14.64 on pp. 610 * odd as per HAC Note 14.64 on pp. 610
*/ */
int fast_mp_invmod (mp_int * a, mp_int * b, mp_int * c) int fast_mp_invmod(mp_int *a, mp_int *b, mp_int *c)
{ {
mp_int x, y, u, v, B, D; mp_int x, y, u, v, B, D;
int res, neg; int res, neg;
/* 2. [modified] b must be odd */ /* 2. [modified] b must be odd */
if (mp_iseven (b) == MP_YES) { if (mp_iseven(b) == MP_YES) {
return MP_VAL; return MP_VAL;
} }
/* init all our temps */ /* init all our temps */
if ((res = mp_init_multi(&x, &y, &u, &v, &B, &D, NULL)) != MP_OKAY) { if ((res = mp_init_multi(&x, &y, &u, &v, &B, &D, NULL)) != MP_OKAY) {
return res; return res;
} }
/* x == modulus, y == value to invert */ /* x == modulus, y == value to invert */
if ((res = mp_copy (b, &x)) != MP_OKAY) { if ((res = mp_copy(b, &x)) != MP_OKAY) {
goto LBL_ERR; goto LBL_ERR;
} }
/* we need y = |a| */ /* we need y = |a| */
if ((res = mp_mod (a, b, &y)) != MP_OKAY) { if ((res = mp_mod(a, b, &y)) != MP_OKAY) {
goto LBL_ERR; goto LBL_ERR;
} }
/* 3. u=x, v=y, A=1, B=0, C=0,D=1 */ /* 3. u=x, v=y, A=1, B=0, C=0,D=1 */
if ((res = mp_copy (&x, &u)) != MP_OKAY) { if ((res = mp_copy(&x, &u)) != MP_OKAY) {
goto LBL_ERR; goto LBL_ERR;
} }
if ((res = mp_copy (&y, &v)) != MP_OKAY) { if ((res = mp_copy(&y, &v)) != MP_OKAY) {
goto LBL_ERR; goto LBL_ERR;
} }
mp_set (&D, 1); mp_set(&D, 1);
top: top:
/* 4. while u is even do */ /* 4. while u is even do */
while (mp_iseven (&u) == MP_YES) { while (mp_iseven(&u) == MP_YES) {
/* 4.1 u = u/2 */ /* 4.1 u = u/2 */
if ((res = mp_div_2 (&u, &u)) != MP_OKAY) { if ((res = mp_div_2(&u, &u)) != MP_OKAY) {
goto LBL_ERR; goto LBL_ERR;
}
/* 4.2 if B is odd then */
if (mp_isodd (&B) == MP_YES) {
if ((res = mp_sub (&B, &x, &B)) != MP_OKAY) {
goto LBL_ERR;
} }
} /* 4.2 if B is odd then */
/* B = B/2 */ if (mp_isodd(&B) == MP_YES) {
if ((res = mp_div_2 (&B, &B)) != MP_OKAY) { if ((res = mp_sub(&B, &x, &B)) != MP_OKAY) {
goto LBL_ERR; goto LBL_ERR;
} }
}
/* 5. while v is even do */
while (mp_iseven (&v) == MP_YES) {
/* 5.1 v = v/2 */
if ((res = mp_div_2 (&v, &v)) != MP_OKAY) {
goto LBL_ERR;
}
/* 5.2 if D is odd then */
if (mp_isodd (&D) == MP_YES) {
/* D = (D-x)/2 */
if ((res = mp_sub (&D, &x, &D)) != MP_OKAY) {
goto LBL_ERR;
} }
} /* B = B/2 */
/* D = D/2 */ if ((res = mp_div_2(&B, &B)) != MP_OKAY) {
if ((res = mp_div_2 (&D, &D)) != MP_OKAY) { goto LBL_ERR;
}
}
/* 5. while v is even do */
while (mp_iseven(&v) == MP_YES) {
/* 5.1 v = v/2 */
if ((res = mp_div_2(&v, &v)) != MP_OKAY) {
goto LBL_ERR;
}
/* 5.2 if D is odd then */
if (mp_isodd(&D) == MP_YES) {
/* D = (D-x)/2 */
if ((res = mp_sub(&D, &x, &D)) != MP_OKAY) {
goto LBL_ERR;
}
}
/* D = D/2 */
if ((res = mp_div_2(&D, &D)) != MP_OKAY) {
goto LBL_ERR;
}
}
/* 6. if u >= v then */
if (mp_cmp(&u, &v) != MP_LT) {
/* u = u - v, B = B - D */
if ((res = mp_sub(&u, &v, &u)) != MP_OKAY) {
goto LBL_ERR;
}
if ((res = mp_sub(&B, &D, &B)) != MP_OKAY) {
goto LBL_ERR;
}
} else {
/* v - v - u, D = D - B */
if ((res = mp_sub(&v, &u, &v)) != MP_OKAY) {
goto LBL_ERR;
}
if ((res = mp_sub(&D, &B, &D)) != MP_OKAY) {
goto LBL_ERR;
}
}
/* if not zero goto step 4 */
if (mp_iszero(&u) == MP_NO) {
goto top;
}
/* now a = C, b = D, gcd == g*v */
/* if v != 1 then there is no inverse */
if (mp_cmp_d(&v, 1) != MP_EQ) {
res = MP_VAL;
goto LBL_ERR; goto LBL_ERR;
} }
}
/* 6. if u >= v then */ /* b is now the inverse */
if (mp_cmp (&u, &v) != MP_LT) { neg = a->sign;
/* u = u - v, B = B - D */ while (D.sign == MP_NEG) {
if ((res = mp_sub (&u, &v, &u)) != MP_OKAY) { if ((res = mp_add(&D, b, &D)) != MP_OKAY) {
goto LBL_ERR; goto LBL_ERR;
} }
}
mp_exch(&D, c);
c->sign = neg;
res = MP_OKAY;
if ((res = mp_sub (&B, &D, &B)) != MP_OKAY) { LBL_ERR:
goto LBL_ERR; mp_clear_multi(&x, &y, &u, &v, &B, &D, NULL);
} return res;
} else {
/* v - v - u, D = D - B */
if ((res = mp_sub (&v, &u, &v)) != MP_OKAY) {
goto LBL_ERR;
}
if ((res = mp_sub (&D, &B, &D)) != MP_OKAY) {
goto LBL_ERR;
}
}
/* if not zero goto step 4 */
if (mp_iszero (&u) == MP_NO) {
goto top;
}
/* now a = C, b = D, gcd == g*v */
/* if v != 1 then there is no inverse */
if (mp_cmp_d (&v, 1) != MP_EQ) {
res = MP_VAL;
goto LBL_ERR;
}
/* b is now the inverse */
neg = a->sign;
while (D.sign == MP_NEG) {
if ((res = mp_add (&D, b, &D)) != MP_OKAY) {
goto LBL_ERR;
}
}
mp_exch (&D, c);
c->sign = neg;
res = MP_OKAY;
LBL_ERR:mp_clear_multi (&x, &y, &u, &v, &B, &D, NULL);
return res;
} }
#endif #endif

248
bn_fast_mp_montgomery_reduce.c
View File

@ -23,147 +23,147 @@
* *
* Based on Algorithm 14.32 on pp.601 of HAC. * Based on Algorithm 14.32 on pp.601 of HAC.
*/ */
int fast_mp_montgomery_reduce (mp_int * x, mp_int * n, mp_digit rho) int fast_mp_montgomery_reduce(mp_int *x, mp_int *n, mp_digit rho)
{ {
int ix, res, olduse; int ix, res, olduse;
mp_word W[MP_WARRAY]; mp_word W[MP_WARRAY];
/* get old used count */ /* get old used count */
olduse = x->used; olduse = x->used;
/* grow a as required */ /* grow a as required */
if (x->alloc < (n->used + 1)) { if (x->alloc < (n->used + 1)) {
if ((res = mp_grow (x, n->used + 1)) != MP_OKAY) { if ((res = mp_grow(x, n->used + 1)) != MP_OKAY) {
return res; return res;
}
}
/* first we have to get the digits of the input into
* an array of double precision words W[...]
*/
{
mp_word *_W;
mp_digit *tmpx;
/* alias for the W[] array */
_W = W;
/* alias for the digits of x*/
tmpx = x->dp;
/* copy the digits of a into W[0..a->used-1] */
for (ix = 0; ix < x->used; ix++) {
*_W++ = *tmpx++;
}
/* zero the high words of W[a->used..m->used*2] */
for (; ix < ((n->used * 2) + 1); ix++) {
*_W++ = 0;
}
}
/* now we proceed to zero successive digits
* from the least significant upwards
*/
for (ix = 0; ix < n->used; ix++) {
/* mu = ai * m' mod b
*
* We avoid a double precision multiplication (which isn't required)
* by casting the value down to a mp_digit. Note this requires
* that W[ix-1] have the carry cleared (see after the inner loop)
*/
mp_digit mu;
mu = (mp_digit) (((W[ix] & MP_MASK) * rho) & MP_MASK);
/* a = a + mu * m * b**i
*
* This is computed in place and on the fly. The multiplication
* by b**i is handled by offseting which columns the results
* are added to.
*
* Note the comba method normally doesn't handle carries in the
* inner loop In this case we fix the carry from the previous
* column since the Montgomery reduction requires digits of the
* result (so far) [see above] to work. This is
* handled by fixing up one carry after the inner loop. The
* carry fixups are done in order so after these loops the
* first m->used words of W[] have the carries fixed
*/
{
int iy;
mp_digit *tmpn;
mp_word *_W;
/* alias for the digits of the modulus */
tmpn = n->dp;
/* Alias for the columns set by an offset of ix */
_W = W + ix;
/* inner loop */
for (iy = 0; iy < n->used; iy++) {
*_W++ += ((mp_word)mu) * ((mp_word)*tmpn++);
} }
} }
/* now fix carry for next digit, W[ix+1] */ /* first we have to get the digits of the input into
W[ix + 1] += W[ix] >> ((mp_word) DIGIT_BIT); * an array of double precision words W[...]
} */
{
mp_word *_W;
mp_digit *tmpx;
/* now we have to propagate the carries and /* alias for the W[] array */
* shift the words downward [all those least _W = W;
* significant digits we zeroed].
*/
{
mp_digit *tmpx;
mp_word *_W, *_W1;
/* nox fix rest of carries */ /* alias for the digits of x*/
tmpx = x->dp;
/* alias for current word */ /* copy the digits of a into W[0..a->used-1] */
_W1 = W + ix; for (ix = 0; ix < x->used; ix++) {
*_W++ = *tmpx++;
}
/* alias for next word, where the carry goes */ /* zero the high words of W[a->used..m->used*2] */
_W = W + ++ix; for (; ix < ((n->used * 2) + 1); ix++) {
*_W++ = 0;
}
}
for (; ix <= ((n->used * 2) + 1); ix++) { /* now we proceed to zero successive digits
*_W++ += *_W1++ >> ((mp_word) DIGIT_BIT); * from the least significant upwards
} */
for (ix = 0; ix < n->used; ix++) {
/* mu = ai * m' mod b
*
* We avoid a double precision multiplication (which isn't required)
* by casting the value down to a mp_digit. Note this requires
* that W[ix-1] have the carry cleared (see after the inner loop)
*/
mp_digit mu;
mu = (mp_digit)(((W[ix] & MP_MASK) * rho) & MP_MASK);
/* copy out, A = A/b**n /* a = a + mu * m * b**i
* *
* The result is A/b**n but instead of converting from an * This is computed in place and on the fly. The multiplication
* array of mp_word to mp_digit than calling mp_rshd * by b**i is handled by offseting which columns the results
* we just copy them in the right order * are added to.
*/ *
* Note the comba method normally doesn't handle carries in the
* inner loop In this case we fix the carry from the previous
* column since the Montgomery reduction requires digits of the
* result (so far) [see above] to work. This is
* handled by fixing up one carry after the inner loop. The
* carry fixups are done in order so after these loops the
* first m->used words of W[] have the carries fixed
*/
{
int iy;
mp_digit *tmpn;
mp_word *_W;
/* alias for destination word */ /* alias for the digits of the modulus */
tmpx = x->dp; tmpn = n->dp;
/* alias for shifted double precision result */ /* Alias for the columns set by an offset of ix */
_W = W + n->used; _W = W + ix;
for (ix = 0; ix < (n->used + 1); ix++) { /* inner loop */
*tmpx++ = (mp_digit)(*_W++ & ((mp_word) MP_MASK)); for (iy = 0; iy < n->used; iy++) {
} *_W++ += ((mp_word)mu) * ((mp_word)*tmpn++);
}
}
/* zero oldused digits, if the input a was larger than /* now fix carry for next digit, W[ix+1] */
* m->used+1 we'll have to clear the digits W[ix + 1] += W[ix] >> ((mp_word) DIGIT_BIT);
*/ }
for (; ix < olduse; ix++) {
*tmpx++ = 0;
}
}
/* set the max used and clamp */ /* now we have to propagate the carries and
x->used = n->used + 1; * shift the words downward [all those least
mp_clamp (x); * significant digits we zeroed].
*/
{
mp_digit *tmpx;
mp_word *_W, *_W1;
/* if A >= m then A = A - m */ /* nox fix rest of carries */
if (mp_cmp_mag (x, n) != MP_LT) {
return s_mp_sub (x, n, x); /* alias for current word */
} _W1 = W + ix;
return MP_OKAY;
/* alias for next word, where the carry goes */
_W = W + ++ix;
for (; ix <= ((n->used * 2) + 1); ix++) {
*_W++ += *_W1++ >> ((mp_word) DIGIT_BIT);
}
/* copy out, A = A/b**n
*
* The result is A/b**n but instead of converting from an
* array of mp_word to mp_digit than calling mp_rshd
* we just copy them in the right order
*/
/* alias for destination word */
tmpx = x->dp;
/* alias for shifted double precision result */
_W = W + n->used;
for (ix = 0; ix < (n->used + 1); ix++) {
*tmpx++ = (mp_digit)(*_W++ & ((mp_word) MP_MASK));
}
/* zero oldused digits, if the input a was larger than
* m->used+1 we'll have to clear the digits
*/
for (; ix < olduse; ix++) {
*tmpx++ = 0;
}
}
/* set the max used and clamp */
x->used = n->used + 1;
mp_clamp(x);
/* if A >= m then A = A - m */
if (mp_cmp_mag(x, n) != MP_LT) {
return s_mp_sub(x, n, x);
}
return MP_OKAY;
} }
#endif #endif

80
bn_fast_s_mp_mul_digs.c
View File

@ -17,39 +17,39 @@
/* Fast (comba) multiplier /* Fast (comba) multiplier
* *
* This is the fast column-array [comba] multiplier. It is * This is the fast column-array [comba] multiplier. It is
* designed to compute the columns of the product first * designed to compute the columns of the product first
* then handle the carries afterwards. This has the effect * then handle the carries afterwards. This has the effect
* of making the nested loops that compute the columns very * of making the nested loops that compute the columns very
* simple and schedulable on super-scalar processors. * simple and schedulable on super-scalar processors.
* *
* This has been modified to produce a variable number of * This has been modified to produce a variable number of
* digits of output so if say only a half-product is required * digits of output so if say only a half-product is required
* you don't have to compute the upper half (a feature * you don't have to compute the upper half (a feature
* required for fast Barrett reduction). * required for fast Barrett reduction).
* *
* Based on Algorithm 14.12 on pp.595 of HAC. * Based on Algorithm 14.12 on pp.595 of HAC.
* *
*/ */
int fast_s_mp_mul_digs (mp_int * a, mp_int * b, mp_int * c, int digs) int fast_s_mp_mul_digs(mp_int *a, mp_int *b, mp_int *c, int digs)
{ {
int olduse, res, pa, ix, iz; int olduse, res, pa, ix, iz;
mp_digit W[MP_WARRAY]; mp_digit W[MP_WARRAY];
mp_word _W; mp_word _W;
/* grow the destination as required */ /* grow the destination as required */
if (c->alloc < digs) { if (c->alloc < digs) {
if ((res = mp_grow (c, digs)) != MP_OKAY) { if ((res = mp_grow(c, digs)) != MP_OKAY) {
return res; return res;
} }
} }
/* number of output digits to produce */ /* number of output digits to produce */
pa = MIN(digs, a->used + b->used); pa = MIN(digs, a->used + b->used);
/* clear the carry */ /* clear the carry */
_W = 0; _W = 0;
for (ix = 0; ix < pa; ix++) { for (ix = 0; ix < pa; ix++) {
int tx, ty; int tx, ty;
int iy; int iy;
mp_digit *tmpx, *tmpy; mp_digit *tmpx, *tmpy;
@ -62,7 +62,7 @@ int fast_s_mp_mul_digs (mp_int * a, mp_int * b, mp_int * c, int digs)
tmpx = a->dp + tx; tmpx = a->dp + tx;
tmpy = b->dp + ty; tmpy = b->dp + ty;
/* this is the number of times the loop will iterrate, essentially /* this is the number of times the loop will iterrate, essentially
while (tx++ < a->used && ty-- >= 0) { ... } while (tx++ < a->used && ty-- >= 0) { ... }
*/ */
iy = MIN(a->used-tx, ty+1); iy = MIN(a->used-tx, ty+1);
@ -78,27 +78,27 @@ int fast_s_mp_mul_digs (mp_int * a, mp_int * b, mp_int * c, int digs)
/* make next carry */ /* make next carry */
_W = _W >> ((mp_word)DIGIT_BIT); _W = _W >> ((mp_word)DIGIT_BIT);
} }
/* setup dest */ /* setup dest */
olduse = c->used; olduse = c->used;
c->used = pa; c->used = pa;
{ {
mp_digit *tmpc; mp_digit *tmpc;
tmpc = c->dp; tmpc = c->dp;
for (ix = 0; ix < (pa + 1); ix++) { for (ix = 0; ix < (pa + 1); ix++) {
/* now extract the previous digit [below the carry] */ /* now extract the previous digit [below the carry] */
*tmpc++ = W[ix]; *tmpc++ = W[ix];
} }
/* clear unused digits [that existed in the old copy of c] */ /* clear unused digits [that existed in the old copy of c] */
for (; ix < olduse; ix++) { for (; ix < olduse; ix++) {
*tmpc++ = 0; *tmpc++ = 0;
} }
} }
mp_clamp (c); mp_clamp(c);
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

70
bn_fast_s_mp_mul_high_digs.c
View File

@ -24,24 +24,24 @@
* *
* Based on Algorithm 14.12 on pp.595 of HAC. * Based on Algorithm 14.12 on pp.595 of HAC.
*/ */
int fast_s_mp_mul_high_digs (mp_int * a, mp_int * b, mp_int * c, int digs) int fast_s_mp_mul_high_digs(mp_int *a, mp_int *b, mp_int *c, int digs)
{ {
int olduse, res, pa, ix, iz; int olduse, res, pa, ix, iz;
mp_digit W[MP_WARRAY]; mp_digit W[MP_WARRAY];
mp_word _W; mp_word _W;
/* grow the destination as required */ /* grow the destination as required */
pa = a->used + b->used; pa = a->used + b->used;
if (c->alloc < pa) { if (c->alloc < pa) {
if ((res = mp_grow (c, pa)) != MP_OKAY) { if ((res = mp_grow(c, pa)) != MP_OKAY) {
return res; return res;
} }
} }
/* number of output digits to produce */ /* number of output digits to produce */
pa = a->used + b->used; pa = a->used + b->used;
_W = 0; _W = 0;
for (ix = digs; ix < pa; ix++) { for (ix = digs; ix < pa; ix++) {
int tx, ty, iy; int tx, ty, iy;
mp_digit *tmpx, *tmpy; mp_digit *tmpx, *tmpy;
@ -53,7 +53,7 @@ int fast_s_mp_mul_high_digs (mp_int * a, mp_int * b, mp_int * c, int digs)
tmpx = a->dp + tx; tmpx = a->dp + tx;
tmpy = b->dp + ty; tmpy = b->dp + ty;
/* this is the number of times the loop will iterrate, essentially its /* this is the number of times the loop will iterrate, essentially its
while (tx++ < a->used && ty-- >= 0) { ... } while (tx++ < a->used && ty-- >= 0) { ... }
*/ */
iy = MIN(a->used-tx, ty+1); iy = MIN(a->used-tx, ty+1);
@ -68,28 +68,28 @@ int fast_s_mp_mul_high_digs (mp_int * a, mp_int * b, mp_int * c, int digs)
/* make next carry */ /* make next carry */
_W = _W >> ((mp_word)DIGIT_BIT); _W = _W >> ((mp_word)DIGIT_BIT);
} }
/* setup dest */
olduse = c->used;
c->used = pa;
{ /* setup dest */
mp_digit *tmpc; olduse = c->used;
c->used = pa;
tmpc = c->dp + digs; {
for (ix = digs; ix < pa; ix++) { mp_digit *tmpc;
/* now extract the previous digit [below the carry] */
*tmpc++ = W[ix];
}
/* clear unused digits [that existed in the old copy of c] */ tmpc = c->dp + digs;
for (; ix < olduse; ix++) { for (ix = digs; ix < pa; ix++) {
*tmpc++ = 0; /* now extract the previous digit [below the carry] */
} *tmpc++ = W[ix];
} }
mp_clamp (c);
return MP_OKAY; /* clear unused digits [that existed in the old copy of c] */
for (; ix < olduse; ix++) {
*tmpc++ = 0;
}
}
mp_clamp(c);
return MP_OKAY;
} }
#endif #endif

70
bn_fast_s_mp_sqr.c
View File

@ -16,32 +16,32 @@
*/ */
/* the jist of squaring... /* the jist of squaring...
* you do like mult except the offset of the tmpx [one that * you do like mult except the offset of the tmpx [one that
* starts closer to zero] can't equal the offset of tmpy. * starts closer to zero] can't equal the offset of tmpy.
* So basically you set up iy like before then you min it with * So basically you set up iy like before then you min it with
* (ty-tx) so that it never happens. You double all those * (ty-tx) so that it never happens. You double all those
* you add in the inner loop * you add in the inner loop
After that loop you do the squares and add them in. After that loop you do the squares and add them in.
*/ */
int fast_s_mp_sqr (mp_int * a, mp_int * b) int fast_s_mp_sqr(mp_int *a, mp_int *b)
{ {
int olduse, res, pa, ix, iz; int olduse, res, pa, ix, iz;
mp_digit W[MP_WARRAY], *tmpx; mp_digit W[MP_WARRAY], *tmpx;
mp_word W1; mp_word W1;
/* grow the destination as required */ /* grow the destination as required */
pa = a->used + a->used; pa = a->used + a->used;
if (b->alloc < pa) { if (b->alloc < pa) {
if ((res = mp_grow (b, pa)) != MP_OKAY) { if ((res = mp_grow(b, pa)) != MP_OKAY) {
return res; return res;
} }
} }
/* number of output digits to produce */ /* number of output digits to produce */
W1 = 0; W1 = 0;
for (ix = 0; ix < pa; ix++) { for (ix = 0; ix < pa; ix++) {
int tx, ty, iy; int tx, ty, iy;
mp_word _W; mp_word _W;
mp_digit *tmpy; mp_digit *tmpy;
@ -62,7 +62,7 @@ int fast_s_mp_sqr (mp_int * a, mp_int * b)
*/ */
iy = MIN(a->used-tx, ty+1); iy = MIN(a->used-tx, ty+1);
/* now for squaring tx can never equal ty /* now for squaring tx can never equal ty
* we halve the distance since they approach at a rate of 2x * we halve the distance since they approach at a rate of 2x
* and we have to round because odd cases need to be executed * and we have to round because odd cases need to be executed
*/ */
@ -86,26 +86,26 @@ int fast_s_mp_sqr (mp_int * a, mp_int * b)
/* make next carry */ /* make next carry */
W1 = _W >> ((mp_word)DIGIT_BIT); W1 = _W >> ((mp_word)DIGIT_BIT);
} }
/* setup dest */ /* setup dest */
olduse = b->used; olduse = b->used;
b->used = a->used+a->used; b->used = a->used+a->used;
{ {
mp_digit *tmpb; mp_digit *tmpb;
tmpb = b->dp; tmpb = b->dp;
for (ix = 0; ix < pa; ix++) { for (ix = 0; ix < pa; ix++) {
*tmpb++ = W[ix] & MP_MASK; *tmpb++ = W[ix] & MP_MASK;
} }
/* clear unused digits [that existed in the old copy of c] */ /* clear unused digits [that existed in the old copy of c] */
for (; ix < olduse; ix++) { for (; ix < olduse; ix++) {
*tmpb++ = 0; *tmpb++ = 0;
} }
} }
mp_clamp (b); mp_clamp(b);
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

29
bn_mp_2expt.c
View File

@ -15,31 +15,30 @@
* Tom St Denis, tstdenis82@gmail.com, http://libtom.org * Tom St Denis, tstdenis82@gmail.com, http://libtom.org
*/ */
/* computes a = 2**b /* computes a = 2**b
* *
* Simple algorithm which zeroes the int, grows it then just sets one bit * Simple algorithm which zeroes the int, grows it then just sets one bit
* as required. * as required.
*/ */
int int mp_2expt(mp_int *a, int b)
mp_2expt (mp_int * a, int b)
{ {
int res; int res;
/* zero a as per default */ /* zero a as per default */
mp_zero (a); mp_zero(a);
/* grow a to accomodate the single bit */ /* grow a to accomodate the single bit */
if ((res = mp_grow (a, (b / DIGIT_BIT) + 1)) != MP_OKAY) { if ((res = mp_grow(a, (b / DIGIT_BIT) + 1)) != MP_OKAY) {
return res; return res;
} }
/* set the used count of where the bit will go */ /* set the used count of where the bit will go */
a->used = (b / DIGIT_BIT) + 1; a->used = (b / DIGIT_BIT) + 1;
/* put the single bit in its place */ /* put the single bit in its place */
a->dp[b / DIGIT_BIT] = ((mp_digit)1) << (b % DIGIT_BIT); a->dp[b / DIGIT_BIT] = ((mp_digit)1) << (b % DIGIT_BIT);
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

25
bn_mp_abs.c
View File

@ -15,26 +15,25 @@
* Tom St Denis, tstdenis82@gmail.com, http://libtom.org * Tom St Denis, tstdenis82@gmail.com, http://libtom.org
*/ */
/* b = |a| /* b = |a|
* *
* Simple function copies the input and fixes the sign to positive * Simple function copies the input and fixes the sign to positive
*/ */
int int mp_abs(mp_int *a, mp_int *b)
mp_abs (mp_int * a, mp_int * b)
{ {
int res; int res;
/* copy a to b */ /* copy a to b */
if (a != b) { if (a != b) {
if ((res = mp_copy (a, b)) != MP_OKAY) { if ((res = mp_copy(a, b)) != MP_OKAY) {
return res; return res;
} }
} }
/* force the sign of b to positive */ /* force the sign of b to positive */
b->sign = MP_ZPOS; b->sign = MP_ZPOS;
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

48
bn_mp_add.c
View File

@ -16,34 +16,34 @@
*/ */
/* high level addition (handles signs) */ /* high level addition (handles signs) */
int mp_add (mp_int * a, mp_int * b, mp_int * c) int mp_add(mp_int *a, mp_int *b, mp_int *c)
{ {
int sa, sb, res; int sa, sb, res;
/* get sign of both inputs */ /* get sign of both inputs */
sa = a->sign; sa = a->sign;
sb = b->sign; sb = b->sign;
/* handle two cases, not four */ /* handle two cases, not four */
if (sa == sb) { if (sa == sb) {
/* both positive or both negative */ /* both positive or both negative */
/* add their magnitudes, copy the sign */ /* add their magnitudes, copy the sign */
c->sign = sa;
res = s_mp_add (a, b, c);
} else {
/* one positive, the other negative */
/* subtract the one with the greater magnitude from */
/* the one of the lesser magnitude. The result gets */
/* the sign of the one with the greater magnitude. */
if (mp_cmp_mag (a, b) == MP_LT) {
c->sign = sb;
res = s_mp_sub (b, a, c);
} else {
c->sign = sa; c->sign = sa;
res = s_mp_sub (a, b, c); res = s_mp_add(a, b, c);
} } else {
} /* one positive, the other negative */
return res; /* subtract the one with the greater magnitude from */
/* the one of the lesser magnitude. The result gets */
/* the sign of the one with the greater magnitude. */
if (mp_cmp_mag(a, b) == MP_LT) {
c->sign = sb;
res = s_mp_sub(b, a, c);
} else {
c->sign = sa;
res = s_mp_sub(a, b, c);
}
}
return res;
} }
#endif #endif

137
bn_mp_add_d.c
View File

@ -16,93 +16,92 @@
*/ */
/* single digit addition */ /* single digit addition */
int int mp_add_d(mp_int *a, mp_digit b, mp_int *c)
mp_add_d (mp_int * a, mp_digit b, mp_int * c)
{ {
int res, ix, oldused; int res, ix, oldused;
mp_digit *tmpa, *tmpc, mu; mp_digit *tmpa, *tmpc, mu;
/* grow c as required */ /* grow c as required */
if (c->alloc < (a->used + 1)) { if (c->alloc < (a->used + 1)) {
if ((res = mp_grow(c, a->used + 1)) != MP_OKAY) { if ((res = mp_grow(c, a->used + 1)) != MP_OKAY) {
return res; return res;
} }
} }
/* if a is negative and |a| >= b, call c = |a| - b */ /* if a is negative and |a| >= b, call c = |a| - b */
if ((a->sign == MP_NEG) && ((a->used > 1) || (a->dp[0] >= b))) { if ((a->sign == MP_NEG) && ((a->used > 1) || (a->dp[0] >= b))) {
/* temporarily fix sign of a */ /* temporarily fix sign of a */
a->sign = MP_ZPOS; a->sign = MP_ZPOS;
/* c = |a| - b */ /* c = |a| - b */
res = mp_sub_d(a, b, c); res = mp_sub_d(a, b, c);
/* fix sign */ /* fix sign */
a->sign = c->sign = MP_NEG; a->sign = c->sign = MP_NEG;
/* clamp */ /* clamp */
mp_clamp(c); mp_clamp(c);
return res; return res;
} }
/* old number of used digits in c */ /* old number of used digits in c */
oldused = c->used; oldused = c->used;
/* source alias */ /* source alias */
tmpa = a->dp; tmpa = a->dp;
/* destination alias */ /* destination alias */
tmpc = c->dp; tmpc = c->dp;
/* if a is positive */ /* if a is positive */
if (a->sign == MP_ZPOS) { if (a->sign == MP_ZPOS) {
/* add digit, after this we're propagating /* add digit, after this we're propagating
* the carry. * the carry.
*/ */
*tmpc = *tmpa++ + b; *tmpc = *tmpa++ + b;
mu = *tmpc >> DIGIT_BIT; mu = *tmpc >> DIGIT_BIT;
*tmpc++ &= MP_MASK; *tmpc++ &= MP_MASK;
/* now handle rest of the digits */ /* now handle rest of the digits */
for (ix = 1; ix < a->used; ix++) { for (ix = 1; ix < a->used; ix++) {
*tmpc = *tmpa++ + mu; *tmpc = *tmpa++ + mu;
mu = *tmpc >> DIGIT_BIT; mu = *tmpc >> DIGIT_BIT;
*tmpc++ &= MP_MASK; *tmpc++ &= MP_MASK;
} }
/* set final carry */ /* set final carry */
ix++; ix++;
*tmpc++ = mu; *tmpc++ = mu;
/* setup size */ /* setup size */
c->used = a->used + 1; c->used = a->used + 1;
} else { } else {
/* a was negative and |a| < b */ /* a was negative and |a| < b */
c->used = 1; c->used = 1;
/* the result is a single digit */ /* the result is a single digit */
if (a->used == 1) { if (a->used == 1) {
*tmpc++ = b - a->dp[0]; *tmpc++ = b - a->dp[0];
} else { } else {
*tmpc++ = b; *tmpc++ = b;
} }
/* setup count so the clearing of oldused /* setup count so the clearing of oldused
* can fall through correctly * can fall through correctly
*/ */
ix = 1; ix = 1;
} }
/* sign always positive */ /* sign always positive */
c->sign = MP_ZPOS; c->sign = MP_ZPOS;
/* now zero to oldused */ /* now zero to oldused */
while (ix++ < oldused) { while (ix++ < oldused) {
*tmpc++ = 0; *tmpc++ = 0;
} }
mp_clamp(c); mp_clamp(c);
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

27
bn_mp_addmod.c
View File

@ -16,23 +16,22 @@
*/ */
/* d = a + b (mod c) */ /* d = a + b (mod c) */
int int mp_addmod(mp_int *a, mp_int *b, mp_int *c, mp_int *d)
mp_addmod (mp_int * a, mp_int * b, mp_int * c, mp_int * d)
{ {
int res; int res;
mp_int t; mp_int t;
if ((res = mp_init (&t)) != MP_OKAY) { if ((res = mp_init(&t)) != MP_OKAY) {
return res; return res;
} }
if ((res = mp_add (a, b, &t)) != MP_OKAY) { if ((res = mp_add(a, b, &t)) != MP_OKAY) {
mp_clear (&t); mp_clear(&t);
return res; return res;
} }
res = mp_mod (&t, c, d); res = mp_mod(&t, c, d);
mp_clear (&t); mp_clear(&t);
return res; return res;
} }
#endif #endif

55
bn_mp_and.c
View File

@ -16,39 +16,38 @@
*/ */
/* AND two ints together */ /* AND two ints together */
int int mp_and(mp_int *a, mp_int *b, mp_int *c)
mp_and (mp_int * a, mp_int * b, mp_int * c)
{ {
int res, ix, px; int res, ix, px;
mp_int t, *x; mp_int t, *x;
if (a->used > b->used) { if (a->used > b->used) {
if ((res = mp_init_copy (&t, a)) != MP_OKAY) { if ((res = mp_init_copy(&t, a)) != MP_OKAY) {
return res; return res;
} }
px = b->used; px = b->used;
x = b; x = b;
} else { } else {
if ((res = mp_init_copy (&t, b)) != MP_OKAY) { if ((res = mp_init_copy(&t, b)) != MP_OKAY) {
return res; return res;
} }
px = a->used; px = a->used;
x = a; x = a;
} }
for (ix = 0; ix < px; ix++) { for (ix = 0; ix < px; ix++) {
t.dp[ix] &= x->dp[ix]; t.dp[ix] &= x->dp[ix];
} }
/* zero digits above the last from the smallest mp_int */ /* zero digits above the last from the smallest mp_int */
for (; ix < t.used; ix++) { for (; ix < t.used; ix++) {
t.dp[ix] = 0; t.dp[ix] = 0;
} }
mp_clamp (&t); mp_clamp(&t);
mp_exch (c, &t); mp_exch(c, &t);
mp_clear (&t); mp_clear(&t);
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

25
bn_mp_clamp.c
View File

@ -15,27 +15,26 @@
* Tom St Denis, tstdenis82@gmail.com, http://libtom.org * Tom St Denis, tstdenis82@gmail.com, http://libtom.org
*/ */
/* trim unused digits /* trim unused digits
* *
* This is used to ensure that leading zero digits are * This is used to ensure that leading zero digits are
* trimed and the leading "used" digit will be non-zero * trimed and the leading "used" digit will be non-zero
* Typically very fast. Also fixes the sign if there * Typically very fast. Also fixes the sign if there
* are no more leading digits * are no more leading digits
*/ */
void void mp_clamp(mp_int *a)
mp_clamp (mp_int * a)
{ {
/* decrease used while the most significant digit is /* decrease used while the most significant digit is
* zero. * zero.
*/ */
while ((a->used > 0) && (a->dp[a->used - 1] == 0)) { while ((a->used > 0) && (a->dp[a->used - 1] == 0)) {
--(a->used); --(a->used);
} }
/* reset the sign flag if used == 0 */ /* reset the sign flag if used == 0 */
if (a->used == 0) { if (a->used == 0) {
a->sign = MP_ZPOS; a->sign = MP_ZPOS;
} }
} }
#endif #endif

31
bn_mp_clear.c
View File

@ -16,26 +16,25 @@
*/ */
/* clear one (frees) */ /* clear one (frees) */
void void mp_clear(mp_int *a)
mp_clear (mp_int * a)
{ {
int i; int i;
/* only do anything if a hasn't been freed previously */ /* only do anything if a hasn't been freed previously */
if (a->dp != NULL) { if (a->dp != NULL) {
/* first zero the digits */ /* first zero the digits */
for (i = 0; i < a->used; i++) { for (i = 0; i < a->used; i++) {
a->dp[i] = 0; a->dp[i] = 0;
} }
/* free ram */ /* free ram */
XFREE(a->dp); XFREE(a->dp);
/* reset members to make debugging easier */ /* reset members to make debugging easier */
a->dp = NULL; a->dp = NULL;
a->alloc = a->used = 0; a->alloc = a->used = 0;
a->sign = MP_ZPOS; a->sign = MP_ZPOS;
} }
} }
#endif #endif

18
bn_mp_clear_multi.c
View File

@ -16,16 +16,16 @@
*/ */
#include <stdarg.h> #include <stdarg.h>
void mp_clear_multi(mp_int *mp, ...) void mp_clear_multi(mp_int *mp, ...)
{ {
mp_int* next_mp = mp; mp_int *next_mp = mp;
va_list args; va_list args;
va_start(args, mp); va_start(args, mp);
while (next_mp != NULL) { while (next_mp != NULL) {
mp_clear(next_mp); mp_clear(next_mp);
next_mp = va_arg(args, mp_int*); next_mp = va_arg(args, mp_int *);
} }
va_end(args); va_end(args);
} }
#endif #endif

35
bn_mp_cmp.c
View File

@ -16,25 +16,24 @@
*/ */
/* compare two ints (signed)*/ /* compare two ints (signed)*/
int int mp_cmp(mp_int *a, mp_int *b)
mp_cmp (mp_int * a, mp_int * b)
{ {
/* compare based on sign */ /* compare based on sign */
if (a->sign != b->sign) { if (a->sign != b->sign) {
if (a->sign == MP_NEG) { if (a->sign == MP_NEG) {
return MP_LT; return MP_LT;
} else { } else {
return MP_GT; return MP_GT;
} }
} }
/* compare digits */ /* compare digits */
if (a->sign == MP_NEG) { if (a->sign == MP_NEG) {
/* if negative compare opposite direction */ /* if negative compare opposite direction */
return mp_cmp_mag(b, a); return mp_cmp_mag(b, a);
} else { } else {
return mp_cmp_mag(a, b); return mp_cmp_mag(a, b);
} }
} }
#endif #endif

34
bn_mp_cmp_d.c
View File

@ -16,26 +16,26 @@
*/ */
/* compare a digit */ /* compare a digit */
int mp_cmp_d(mp_int * a, mp_digit b) int mp_cmp_d(mp_int *a, mp_digit b)
{ {
/* compare based on sign */ /* compare based on sign */
if (a->sign == MP_NEG) { if (a->sign == MP_NEG) {
return MP_LT; return MP_LT;
} }
/* compare based on magnitude */ /* compare based on magnitude */
if (a->used > 1) { if (a->used > 1) {
return MP_GT; return MP_GT;
} }
/* compare the only digit of a to b */ /* compare the only digit of a to b */
if (a->dp[0] > b) { if (a->dp[0] > b) {
return MP_GT; return MP_GT;
} else if (a->dp[0] < b) { } else if (a->dp[0] < b) {
return MP_LT; return MP_LT;
} else { } else {
return MP_EQ; return MP_EQ;
} }
} }
#endif #endif

52
bn_mp_cmp_mag.c
View File

@ -16,37 +16,37 @@
*/ */
/* compare maginitude of two ints (unsigned) */ /* compare maginitude of two ints (unsigned) */
int mp_cmp_mag (mp_int * a, mp_int * b) int mp_cmp_mag(mp_int *a, mp_int *b)
{ {
int n; int n;
mp_digit *tmpa, *tmpb; mp_digit *tmpa, *tmpb;
/* compare based on # of non-zero digits */ /* compare based on # of non-zero digits */
if (a->used > b->used) { if (a->used > b->used) {
return MP_GT;
}
if (a->used < b->used) {
return MP_LT;
}
/* alias for a */
tmpa = a->dp + (a->used - 1);
/* alias for b */
tmpb = b->dp + (a->used - 1);
/* compare based on digits */
for (n = 0; n < a->used; ++n, --tmpa, --tmpb) {
if (*tmpa > *tmpb) {
return MP_GT; return MP_GT;
} }
if (*tmpa < *tmpb) { if (a->used < b->used) {
return MP_LT; return MP_LT;
} }
}
return MP_EQ; /* alias for a */
tmpa = a->dp + (a->used - 1);
/* alias for b */
tmpb = b->dp + (a->used - 1);
/* compare based on digits */
for (n = 0; n < a->used; ++n, --tmpa, --tmpb) {
if (*tmpa > *tmpb) {
return MP_GT;
}
if (*tmpa < *tmpb) {
return MP_LT;
}
}
return MP_EQ;
} }
#endif #endif

2
bn_mp_cnt_lsb.c
View File

@ -15,7 +15,7 @@
* Tom St Denis, tstdenis82@gmail.com, http://libtom.org * Tom St Denis, tstdenis82@gmail.com, http://libtom.org
*/ */
static const int lnz[16] = { static const int lnz[16] = {
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0
}; };

67
bn_mp_copy.c
View File

@ -16,50 +16,49 @@
*/ */
/* copy, b = a */ /* copy, b = a */
int int mp_copy(mp_int *a, mp_int *b)
mp_copy (mp_int * a, mp_int * b)
{ {
int res, n; int res, n;
/* if dst == src do nothing */ /* if dst == src do nothing */
if (a == b) { if (a == b) {
return MP_OKAY; return MP_OKAY;
} }
/* grow dest */ /* grow dest */
if (b->alloc < a->used) { if (b->alloc < a->used) {
if ((res = mp_grow (b, a->used)) != MP_OKAY) { if ((res = mp_grow(b, a->used)) != MP_OKAY) {
return res; return res;
} }
} }
/* zero b and copy the parameters over */ /* zero b and copy the parameters over */
{ {
mp_digit *tmpa, *tmpb; mp_digit *tmpa, *tmpb;
/* pointer aliases */ /* pointer aliases */
/* source */ /* source */
tmpa = a->dp; tmpa = a->dp;
/* destination */ /* destination */
tmpb = b->dp; tmpb = b->dp;
/* copy all the digits */ /* copy all the digits */
for (n = 0; n < a->used; n++) { for (n = 0; n < a->used; n++) {
*tmpb++ = *tmpa++; *tmpb++ = *tmpa++;
} }
/* clear high digits */ /* clear high digits */
for (; n < b->used; n++) { for (; n < b->used; n++) {
*tmpb++ = 0; *tmpb++ = 0;
} }
} }
/* copy used count and sign */ /* copy used count and sign */
b->used = a->used; b->used = a->used;
b->sign = a->sign; b->sign = a->sign;
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

35
bn_mp_count_bits.c
View File

@ -16,27 +16,26 @@
*/ */
/* returns the number of bits in an int */ /* returns the number of bits in an int */
int int mp_count_bits(mp_int *a)
mp_count_bits (mp_int * a)
{ {
int r; int r;
mp_digit q; mp_digit q;
/* shortcut */ /* shortcut */
if (a->used == 0) { if (a->used == 0) {
return 0; return 0;
} }
/* get number of digits and add that */ /* get number of digits and add that */
r = (a->used - 1) * DIGIT_BIT; r = (a->used - 1) * DIGIT_BIT;
/* take the last digit and count the bits in it */ /* take the last digit and count the bits in it */
q = a->dp[a->used - 1]; q = a->dp[a->used - 1];
while (q > ((mp_digit) 0)) { while (q > ((mp_digit) 0)) {
++r; ++r;
q >>= ((mp_digit) 1); q >>= ((mp_digit) 1);
} }
return r; return r;
} }
#endif #endif

453
bn_mp_div.c
View File

@ -18,68 +18,68 @@
#ifdef BN_MP_DIV_SMALL #ifdef BN_MP_DIV_SMALL
/* slower bit-bang division... also smaller */ /* slower bit-bang division... also smaller */
int mp_div(mp_int * a, mp_int * b, mp_int * c, mp_int * d) int mp_div(mp_int *a, mp_int *b, mp_int *c, mp_int *d)
{ {
mp_int ta, tb, tq, q; mp_int ta, tb, tq, q;
int res, n, n2; int res, n, n2;
/* is divisor zero ? */ /* is divisor zero ? */
if (mp_iszero (b) == MP_YES) { if (mp_iszero(b) == MP_YES) {
return MP_VAL; return MP_VAL;
} }
/* if a < b then q=0, r = a */ /* if a < b then q=0, r = a */
if (mp_cmp_mag (a, b) == MP_LT) { if (mp_cmp_mag(a, b) == MP_LT) {
if (d != NULL) { if (d != NULL) {
res = mp_copy (a, d); res = mp_copy(a, d);
} else { } else {
res = MP_OKAY; res = MP_OKAY;
} }
if (c != NULL) { if (c != NULL) {
mp_zero (c); mp_zero(c);
} }
return res; return res;
} }
/* init our temps */ /* init our temps */
if ((res = mp_init_multi(&ta, &tb, &tq, &q, NULL)) != MP_OKAY) { if ((res = mp_init_multi(&ta, &tb, &tq, &q, NULL)) != MP_OKAY) {
return res; return res;
} }
mp_set(&tq, 1); mp_set(&tq, 1);
n = mp_count_bits(a) - mp_count_bits(b); n = mp_count_bits(a) - mp_count_bits(b);
if (((res = mp_abs(a, &ta)) != MP_OKAY) || if (((res = mp_abs(a, &ta)) != MP_OKAY) ||
((res = mp_abs(b, &tb)) != MP_OKAY) || ((res = mp_abs(b, &tb)) != MP_OKAY) ||
((res = mp_mul_2d(&tb, n, &tb)) != MP_OKAY) || ((res = mp_mul_2d(&tb, n, &tb)) != MP_OKAY) ||
((res = mp_mul_2d(&tq, n, &tq)) != MP_OKAY)) { ((res = mp_mul_2d(&tq, n, &tq)) != MP_OKAY)) {
goto LBL_ERR; goto LBL_ERR;
} }
while (n-- >= 0) { while (n-- >= 0) {
if (mp_cmp(&tb, &ta) != MP_GT) { if (mp_cmp(&tb, &ta) != MP_GT) {
if (((res = mp_sub(&ta, &tb, &ta)) != MP_OKAY) || if (((res = mp_sub(&ta, &tb, &ta)) != MP_OKAY) ||
((res = mp_add(&q, &tq, &q)) != MP_OKAY)) { ((res = mp_add(&q, &tq, &q)) != MP_OKAY)) {
goto LBL_ERR; goto LBL_ERR;
} }
} }
if (((res = mp_div_2d(&tb, 1, &tb, NULL)) != MP_OKAY) || if (((res = mp_div_2d(&tb, 1, &tb, NULL)) != MP_OKAY) ||
((res = mp_div_2d(&tq, 1, &tq, NULL)) != MP_OKAY)) { ((res = mp_div_2d(&tq, 1, &tq, NULL)) != MP_OKAY)) {
goto LBL_ERR; goto LBL_ERR;
} }
} }
/* now q == quotient and ta == remainder */ /* now q == quotient and ta == remainder */
n = a->sign; n = a->sign;
n2 = (a->sign == b->sign) ? MP_ZPOS : MP_NEG; n2 = (a->sign == b->sign) ? MP_ZPOS : MP_NEG;
if (c != NULL) { if (c != NULL) {
mp_exch(c, &q); mp_exch(c, &q);
c->sign = (mp_iszero(c) == MP_YES) ? MP_ZPOS : n2; c->sign = (mp_iszero(c) == MP_YES) ? MP_ZPOS : n2;
} }
if (d != NULL) { if (d != NULL) {
mp_exch(d, &ta); mp_exch(d, &ta);
d->sign = (mp_iszero(d) == MP_YES) ? MP_ZPOS : n; d->sign = (mp_iszero(d) == MP_YES) ? MP_ZPOS : n;
} }
LBL_ERR: LBL_ERR:
mp_clear_multi(&ta, &tb, &tq, &q, NULL); mp_clear_multi(&ta, &tb, &tq, &q, NULL);
return res; return res;
@ -100,190 +100,195 @@ LBL_ERR:
* The overall algorithm is as described as * The overall algorithm is as described as
* 14.20 from HAC but fixed to treat these cases. * 14.20 from HAC but fixed to treat these cases.
*/ */
int mp_div (mp_int * a, mp_int * b, mp_int * c, mp_int * d) int mp_div(mp_int *a, mp_int *b, mp_int *c, mp_int *d)
{ {
mp_int q, x, y, t1, t2; mp_int q, x, y, t1, t2;
int res, n, t, i, norm, neg; int res, n, t, i, norm, neg;
/* is divisor zero ? */ /* is divisor zero ? */
if (mp_iszero (b) == MP_YES) { if (mp_iszero(b) == MP_YES) {
return MP_VAL; return MP_VAL;
} }
/* if a < b then q=0, r = a */ /* if a < b then q=0, r = a */
if (mp_cmp_mag (a, b) == MP_LT) { if (mp_cmp_mag(a, b) == MP_LT) {
if (d != NULL) { if (d != NULL) {
res = mp_copy (a, d); res = mp_copy(a, d);
} else { } else {
res = MP_OKAY; res = MP_OKAY;
}
if (c != NULL) {
mp_zero (c);
}
return res;
}
if ((res = mp_init_size (&q, a->used + 2)) != MP_OKAY) {
return res;
}
q.used = a->used + 2;
if ((res = mp_init (&t1)) != MP_OKAY) {
goto LBL_Q;
}
if ((res = mp_init (&t2)) != MP_OKAY) {
goto LBL_T1;
}
if ((res = mp_init_copy (&x, a)) != MP_OKAY) {
goto LBL_T2;
}
if ((res = mp_init_copy (&y, b)) != MP_OKAY) {
goto LBL_X;
}
/* fix the sign */
neg = (a->sign == b->sign) ? MP_ZPOS : MP_NEG;
x.sign = y.sign = MP_ZPOS;
/* normalize both x and y, ensure that y >= b/2, [b == 2**DIGIT_BIT] */
norm = mp_count_bits(&y) % DIGIT_BIT;
if (norm < (int)(DIGIT_BIT-1)) {
norm = (DIGIT_BIT-1) - norm;
if ((res = mp_mul_2d (&x, norm, &x)) != MP_OKAY) {
goto LBL_Y;
}
if ((res = mp_mul_2d (&y, norm, &y)) != MP_OKAY) {
goto LBL_Y;
}
} else {
norm = 0;
}
/* note hac does 0 based, so if used==5 then its 0,1,2,3,4, e.g. use 4 */
n = x.used - 1;
t = y.used - 1;
/* while (x >= y*b**n-t) do { q[n-t] += 1; x -= y*b**{n-t} } */
if ((res = mp_lshd (&y, n - t)) != MP_OKAY) { /* y = y*b**{n-t} */
goto LBL_Y;
}
while (mp_cmp (&x, &y) != MP_LT) {
++(q.dp[n - t]);
if ((res = mp_sub (&x, &y, &x)) != MP_OKAY) {
goto LBL_Y;
}
}
/* reset y by shifting it back down */
mp_rshd (&y, n - t);
/* step 3. for i from n down to (t + 1) */
for (i = n; i >= (t + 1); i--) {
if (i > x.used) {
continue;
}
/* step 3.1 if xi == yt then set q{i-t-1} to b-1,
* otherwise set q{i-t-1} to (xi*b + x{i-1})/yt */
if (x.dp[i] == y.dp[t]) {
q.dp[(i - t) - 1] = ((((mp_digit)1) << DIGIT_BIT) - 1);
} else {
mp_word tmp;
tmp = ((mp_word) x.dp[i]) << ((mp_word) DIGIT_BIT);
tmp |= ((mp_word) x.dp[i - 1]);
tmp /= ((mp_word) y.dp[t]);
if (tmp > (mp_word) MP_MASK) {
tmp = MP_MASK;
} }
q.dp[(i - t) - 1] = (mp_digit) (tmp & (mp_word) (MP_MASK)); if (c != NULL) {
} mp_zero(c);
}
return res;
}
/* while (q{i-t-1} * (yt * b + y{t-1})) > if ((res = mp_init_size(&q, a->used + 2)) != MP_OKAY) {
xi * b**2 + xi-1 * b + xi-2 return res;
}
q.used = a->used + 2;
do q{i-t-1} -= 1; if ((res = mp_init(&t1)) != MP_OKAY) {
goto LBL_Q;
}
if ((res = mp_init(&t2)) != MP_OKAY) {
goto LBL_T1;
}
if ((res = mp_init_copy(&x, a)) != MP_OKAY) {
goto LBL_T2;
}
if ((res = mp_init_copy(&y, b)) != MP_OKAY) {
goto LBL_X;
}
/* fix the sign */
neg = (a->sign == b->sign) ? MP_ZPOS : MP_NEG;
x.sign = y.sign = MP_ZPOS;
/* normalize both x and y, ensure that y >= b/2, [b == 2**DIGIT_BIT] */
norm = mp_count_bits(&y) % DIGIT_BIT;
if (norm < (int)(DIGIT_BIT-1)) {
norm = (DIGIT_BIT-1) - norm;
if ((res = mp_mul_2d(&x, norm, &x)) != MP_OKAY) {
goto LBL_Y;
}
if ((res = mp_mul_2d(&y, norm, &y)) != MP_OKAY) {
goto LBL_Y;
}
} else {
norm = 0;
}
/* note hac does 0 based, so if used==5 then its 0,1,2,3,4, e.g. use 4 */
n = x.used - 1;
t = y.used - 1;
/* while (x >= y*b**n-t) do { q[n-t] += 1; x -= y*b**{n-t} } */
if ((res = mp_lshd(&y, n - t)) != MP_OKAY) { /* y = y*b**{n-t} */
goto LBL_Y;
}
while (mp_cmp(&x, &y) != MP_LT) {
++(q.dp[n - t]);
if ((res = mp_sub(&x, &y, &x)) != MP_OKAY) {
goto LBL_Y;
}
}
/* reset y by shifting it back down */
mp_rshd(&y, n - t);
/* step 3. for i from n down to (t + 1) */
for (i = n; i >= (t + 1); i--) {
if (i > x.used) {
continue;
}
/* step 3.1 if xi == yt then set q{i-t-1} to b-1,
* otherwise set q{i-t-1} to (xi*b + x{i-1})/yt */
if (x.dp[i] == y.dp[t]) {
q.dp[(i - t) - 1] = ((((mp_digit)1) << DIGIT_BIT) - 1);
} else {
mp_word tmp;
tmp = ((mp_word) x.dp[i]) << ((mp_word) DIGIT_BIT);
tmp |= ((mp_word) x.dp[i - 1]);
tmp /= ((mp_word) y.dp[t]);
if (tmp > (mp_word) MP_MASK) {
tmp = MP_MASK;
}
q.dp[(i - t) - 1] = (mp_digit)(tmp & (mp_word)(MP_MASK));
}
/* while (q{i-t-1} * (yt * b + y{t-1})) >
xi * b**2 + xi-1 * b + xi-2
do q{i-t-1} -= 1;
*/
q.dp[(i - t) - 1] = (q.dp[(i - t) - 1] + 1) & MP_MASK;
do {
q.dp[(i - t) - 1] = (q.dp[(i - t) - 1] - 1) & MP_MASK;
/* find left hand */
mp_zero(&t1);
t1.dp[0] = ((t - 1) < 0) ? 0 : y.dp[t - 1];
t1.dp[1] = y.dp[t];
t1.used = 2;
if ((res = mp_mul_d(&t1, q.dp[(i - t) - 1], &t1)) != MP_OKAY) {
goto LBL_Y;
}
/* find right hand */
t2.dp[0] = ((i - 2) < 0) ? 0 : x.dp[i - 2];
t2.dp[1] = ((i - 1) < 0) ? 0 : x.dp[i - 1];
t2.dp[2] = x.dp[i];
t2.used = 3;
} while (mp_cmp_mag(&t1, &t2) == MP_GT);
/* step 3.3 x = x - q{i-t-1} * y * b**{i-t-1} */
if ((res = mp_mul_d(&y, q.dp[(i - t) - 1], &t1)) != MP_OKAY) {
goto LBL_Y;
}
if ((res = mp_lshd(&t1, (i - t) - 1)) != MP_OKAY) {
goto LBL_Y;
}
if ((res = mp_sub(&x, &t1, &x)) != MP_OKAY) {
goto LBL_Y;
}
/* if x < 0 then { x = x + y*b**{i-t-1}; q{i-t-1} -= 1; } */
if (x.sign == MP_NEG) {
if ((res = mp_copy(&y, &t1)) != MP_OKAY) {
goto LBL_Y;
}
if ((res = mp_lshd(&t1, (i - t) - 1)) != MP_OKAY) {
goto LBL_Y;
}
if ((res = mp_add(&x, &t1, &x)) != MP_OKAY) {
goto LBL_Y;
}
q.dp[(i - t) - 1] = (q.dp[(i - t) - 1] - 1UL) & MP_MASK;
}
}
/* now q is the quotient and x is the remainder
* [which we have to normalize]
*/ */
q.dp[(i - t) - 1] = (q.dp[(i - t) - 1] + 1) & MP_MASK;
do {
q.dp[(i - t) - 1] = (q.dp[(i - t) - 1] - 1) & MP_MASK;
/* find left hand */ /* get sign before writing to c */
mp_zero (&t1); x.sign = (x.used == 0) ? MP_ZPOS : a->sign;
t1.dp[0] = ((t - 1) < 0) ? 0 : y.dp[t - 1];
t1.dp[1] = y.dp[t]; if (c != NULL) {
t1.used = 2; mp_clamp(&q);
if ((res = mp_mul_d (&t1, q.dp[(i - t) - 1], &t1)) != MP_OKAY) { mp_exch(&q, c);
goto LBL_Y; c->sign = neg;
}
if (d != NULL) {
if ((res = mp_div_2d(&x, norm, &x, NULL)) != MP_OKAY) {
goto LBL_Y;
} }
mp_exch(&x, d);
}
/* find right hand */ res = MP_OKAY;
t2.dp[0] = ((i - 2) < 0) ? 0 : x.dp[i - 2];
t2.dp[1] = ((i - 1) < 0) ? 0 : x.dp[i - 1];
t2.dp[2] = x.dp[i];
t2.used = 3;
} while (mp_cmp_mag(&t1, &t2) == MP_GT);
/* step 3.3 x = x - q{i-t-1} * y * b**{i-t-1} */ LBL_Y:
if ((res = mp_mul_d (&y, q.dp[(i - t) - 1], &t1)) != MP_OKAY) { mp_clear(&y);
goto LBL_Y; LBL_X:
} mp_clear(&x);
LBL_T2:
if ((res = mp_lshd (&t1, (i - t) - 1)) != MP_OKAY) { mp_clear(&t2);
goto LBL_Y; LBL_T1:
} mp_clear(&t1);
LBL_Q:
if ((res = mp_sub (&x, &t1, &x)) != MP_OKAY) { mp_clear(&q);
goto LBL_Y; return res;
}
/* if x < 0 then { x = x + y*b**{i-t-1}; q{i-t-1} -= 1; } */
if (x.sign == MP_NEG) {
if ((res = mp_copy (&y, &t1)) != MP_OKAY) {
goto LBL_Y;
}
if ((res = mp_lshd (&t1, (i - t) - 1)) != MP_OKAY) {
goto LBL_Y;
}
if ((res = mp_add (&x, &t1, &x)) != MP_OKAY) {
goto LBL_Y;
}
q.dp[(i - t) - 1] = (q.dp[(i - t) - 1] - 1UL) & MP_MASK;
}
}
/* now q is the quotient and x is the remainder
* [which we have to normalize]
*/
/* get sign before writing to c */
x.sign = (x.used == 0) ? MP_ZPOS : a->sign;
if (c != NULL) {
mp_clamp (&q);
mp_exch (&q, c);
c->sign = neg;
}
if (d != NULL) {
if ((res = mp_div_2d (&x, norm, &x, NULL)) != MP_OKAY) {
goto LBL_Y;
}
mp_exch (&x, d);
}
res = MP_OKAY;
LBL_Y:mp_clear (&y);
LBL_X:mp_clear (&x);
LBL_T2:mp_clear (&t2);
LBL_T1:mp_clear (&t1);
LBL_Q:mp_clear (&q);
return res;
} }
#endif #endif

70
bn_mp_div_2.c
View File

@ -16,50 +16,50 @@
*/ */
/* b = a/2 */ /* b = a/2 */
int mp_div_2(mp_int * a, mp_int * b) int mp_div_2(mp_int *a, mp_int *b)
{ {
int x, res, oldused; int x, res, oldused;
/* copy */ /* copy */
if (b->alloc < a->used) { if (b->alloc < a->used) {
if ((res = mp_grow (b, a->used)) != MP_OKAY) { if ((res = mp_grow(b, a->used)) != MP_OKAY) {
return res; return res;
} }
} }
oldused = b->used; oldused = b->used;
b->used = a->used; b->used = a->used;
{ {
mp_digit r, rr, *tmpa, *tmpb; mp_digit r, rr, *tmpa, *tmpb;
/* source alias */ /* source alias */
tmpa = a->dp + b->used - 1; tmpa = a->dp + b->used - 1;
/* dest alias */ /* dest alias */
tmpb = b->dp + b->used - 1; tmpb = b->dp + b->used - 1;
/* carry */ /* carry */
r = 0; r = 0;
for (x = b->used - 1; x >= 0; x--) { for (x = b->used - 1; x >= 0; x--) {
/* get the carry for the next iteration */ /* get the carry for the next iteration */
rr = *tmpa & 1; rr = *tmpa & 1;
/* shift the current digit, add in carry and store */ /* shift the current digit, add in carry and store */
*tmpb-- = (*tmpa-- >> 1) | (r << (DIGIT_BIT - 1)); *tmpb-- = (*tmpa-- >> 1) | (r << (DIGIT_BIT - 1));
/* forward carry to next iteration */ /* forward carry to next iteration */
r = rr; r = rr;
} }
/* zero excess digits */ /* zero excess digits */
tmpb = b->dp + b->used; tmpb = b->dp + b->used;
for (x = b->used; x < oldused; x++) { for (x = b->used; x < oldused; x++) {
*tmpb++ = 0; *tmpb++ = 0;
} }
} }
b->sign = a->sign; b->sign = a->sign;
mp_clamp (b); mp_clamp(b);
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

102
bn_mp_div_2d.c
View File

@ -16,68 +16,68 @@
*/ */
/* shift right by a certain bit count (store quotient in c, optional remainder in d) */ /* shift right by a certain bit count (store quotient in c, optional remainder in d) */
int mp_div_2d (mp_int * a, int b, mp_int * c, mp_int * d) int mp_div_2d(mp_int *a, int b, mp_int *c, mp_int *d)
{ {
mp_digit D, r, rr; mp_digit D, r, rr;
int x, res; int x, res;
/* if the shift count is <= 0 then we do no work */ /* if the shift count is <= 0 then we do no work */
if (b <= 0) { if (b <= 0) {
res = mp_copy (a, c); res = mp_copy(a, c);
if (d != NULL) { if (d != NULL) {
mp_zero (d); mp_zero(d);
} }
return res;
}
/* copy */
if ((res = mp_copy (a, c)) != MP_OKAY) {
return res;
}
/* 'a' should not be used after here - it might be the same as d */
/* get the remainder */
if (d != NULL) {
if ((res = mp_mod_2d (a, b, d)) != MP_OKAY) {
return res; return res;
} }
}
/* shift by as many digits in the bit count */ /* copy */
if (b >= (int)DIGIT_BIT) { if ((res = mp_copy(a, c)) != MP_OKAY) {
mp_rshd (c, b / DIGIT_BIT); return res;
} }
/* 'a' should not be used after here - it might be the same as d */
/* shift any bit count < DIGIT_BIT */ /* get the remainder */
D = (mp_digit) (b % DIGIT_BIT); if (d != NULL) {
if (D != 0) { if ((res = mp_mod_2d(a, b, d)) != MP_OKAY) {
mp_digit *tmpc, mask, shift; return res;
}
}
/* mask */ /* shift by as many digits in the bit count */
mask = (((mp_digit)1) << D) - 1; if (b >= (int)DIGIT_BIT) {
mp_rshd(c, b / DIGIT_BIT);
}
/* shift for lsb */ /* shift any bit count < DIGIT_BIT */
shift = DIGIT_BIT - D; D = (mp_digit)(b % DIGIT_BIT);
if (D != 0) {
mp_digit *tmpc, mask, shift;
/* alias */ /* mask */
tmpc = c->dp + (c->used - 1); mask = (((mp_digit)1) << D) - 1;
/* carry */ /* shift for lsb */
r = 0; shift = DIGIT_BIT - D;
for (x = c->used - 1; x >= 0; x--) {
/* get the lower bits of this word in a temp */
rr = *tmpc & mask;
/* shift the current word and mix in the carry bits from the previous word */ /* alias */
*tmpc = (*tmpc >> D) | (r << shift); tmpc = c->dp + (c->used - 1);
--tmpc;
/* set the carry to the carry bits of the current word found above */ /* carry */
r = rr; r = 0;
} for (x = c->used - 1; x >= 0; x--) {
} /* get the lower bits of this word in a temp */
mp_clamp (c); rr = *tmpc & mask;
return MP_OKAY;
/* shift the current word and mix in the carry bits from the previous word */
*tmpc = (*tmpc >> D) | (r << shift);
--tmpc;
/* set the carry to the carry bits of the current word found above */
r = rr;
}
}
mp_clamp(c);
return MP_OKAY;
} }
#endif #endif

87
bn_mp_div_3.c
View File

@ -16,60 +16,59 @@
*/ */
/* divide by three (based on routine from MPI and the GMP manual) */ /* divide by three (based on routine from MPI and the GMP manual) */
int int mp_div_3(mp_int *a, mp_int *c, mp_digit *d)
mp_div_3 (mp_int * a, mp_int *c, mp_digit * d)
{ {
mp_int q; mp_int q;
mp_word w, t; mp_word w, t;
mp_digit b; mp_digit b;
int res, ix; int res, ix;
/* b = 2**DIGIT_BIT / 3 */
b = (((mp_word)1) << ((mp_word)DIGIT_BIT)) / ((mp_word)3);
if ((res = mp_init_size(&q, a->used)) != MP_OKAY) { /* b = 2**DIGIT_BIT / 3 */
return res; b = (((mp_word)1) << ((mp_word)DIGIT_BIT)) / ((mp_word)3);
}
q.used = a->used;
q.sign = a->sign;
w = 0;
for (ix = a->used - 1; ix >= 0; ix--) {
w = (w << ((mp_word)DIGIT_BIT)) | ((mp_word)a->dp[ix]);
if (w >= 3) { if ((res = mp_init_size(&q, a->used)) != MP_OKAY) {
/* multiply w by [1/3] */ return res;
t = (w * ((mp_word)b)) >> ((mp_word)DIGIT_BIT); }
/* now subtract 3 * [w/3] from w, to get the remainder */ q.used = a->used;
w -= t+t+t; q.sign = a->sign;
w = 0;
for (ix = a->used - 1; ix >= 0; ix--) {
w = (w << ((mp_word)DIGIT_BIT)) | ((mp_word)a->dp[ix]);
/* fixup the remainder as required since if (w >= 3) {
* the optimization is not exact. /* multiply w by [1/3] */
*/ t = (w * ((mp_word)b)) >> ((mp_word)DIGIT_BIT);
while (w >= 3) {
t += 1; /* now subtract 3 * [w/3] from w, to get the remainder */
w -= 3; w -= t+t+t;
}
/* fixup the remainder as required since
* the optimization is not exact.
*/
while (w >= 3) {
t += 1;
w -= 3;
}
} else { } else {
t = 0; t = 0;
} }
q.dp[ix] = (mp_digit)t; q.dp[ix] = (mp_digit)t;
} }
/* [optional] store the remainder */ /* [optional] store the remainder */
if (d != NULL) { if (d != NULL) {
*d = (mp_digit)w; *d = (mp_digit)w;
} }
/* [optional] store the quotient */ /* [optional] store the quotient */
if (c != NULL) { if (c != NULL) {
mp_clamp(&q); mp_clamp(&q);
mp_exch(&q, c); mp_exch(&q, c);
} }
mp_clear(&q); mp_clear(&q);
return res; return res;
} }
#endif #endif

122
bn_mp_div_d.c
View File

@ -34,78 +34,78 @@ static int s_is_power_of_two(mp_digit b, int *p)
} }
/* single digit division (based on routine from MPI) */ /* single digit division (based on routine from MPI) */
int mp_div_d (mp_int * a, mp_digit b, mp_int * c, mp_digit * d) int mp_div_d(mp_int *a, mp_digit b, mp_int *c, mp_digit *d)
{ {
mp_int q; mp_int q;
mp_word w; mp_word w;
mp_digit t; mp_digit t;
int res, ix; int res, ix;
/* cannot divide by zero */ /* cannot divide by zero */
if (b == 0) { if (b == 0) {
return MP_VAL; return MP_VAL;
} }
/* quick outs */ /* quick outs */
if ((b == 1) || (mp_iszero(a) == MP_YES)) { if ((b == 1) || (mp_iszero(a) == MP_YES)) {
if (d != NULL) { if (d != NULL) {
*d = 0; *d = 0;
} }
if (c != NULL) { if (c != NULL) {
return mp_copy(a, c); return mp_copy(a, c);
} }
return MP_OKAY; return MP_OKAY;
} }
/* power of two ? */ /* power of two ? */
if (s_is_power_of_two(b, &ix) == 1) { if (s_is_power_of_two(b, &ix) == 1) {
if (d != NULL) { if (d != NULL) {
*d = a->dp[0] & ((((mp_digit)1)<<ix) - 1); *d = a->dp[0] & ((((mp_digit)1)<<ix) - 1);
} }
if (c != NULL) { if (c != NULL) {
return mp_div_2d(a, ix, c, NULL); return mp_div_2d(a, ix, c, NULL);
} }
return MP_OKAY; return MP_OKAY;
} }
#ifdef BN_MP_DIV_3_C #ifdef BN_MP_DIV_3_C
/* three? */ /* three? */
if (b == 3) { if (b == 3) {
return mp_div_3(a, c, d); return mp_div_3(a, c, d);
} }
#endif #endif
/* no easy answer [c'est la vie]. Just division */ /* no easy answer [c'est la vie]. Just division */
if ((res = mp_init_size(&q, a->used)) != MP_OKAY) { if ((res = mp_init_size(&q, a->used)) != MP_OKAY) {
return res; return res;
} }
q.used = a->used; q.used = a->used;
q.sign = a->sign; q.sign = a->sign;
w = 0; w = 0;
for (ix = a->used - 1; ix >= 0; ix--) { for (ix = a->used - 1; ix >= 0; ix--) {
w = (w << ((mp_word)DIGIT_BIT)) | ((mp_word)a->dp[ix]); w = (w << ((mp_word)DIGIT_BIT)) | ((mp_word)a->dp[ix]);
if (w >= b) { if (w >= b) {
t = (mp_digit)(w / b); t = (mp_digit)(w / b);
w -= ((mp_word)t) * ((mp_word)b); w -= ((mp_word)t) * ((mp_word)b);
} else { } else {
t = 0; t = 0;
} }
q.dp[ix] = (mp_digit)t; q.dp[ix] = (mp_digit)t;
} }
if (d != NULL) { if (d != NULL) {
*d = (mp_digit)w; *d = (mp_digit)w;
} }
if (c != NULL) { if (c != NULL) {
mp_clamp(&q); mp_clamp(&q);
mp_exch(&q, c); mp_exch(&q, c);
} }
mp_clear(&q); mp_clear(&q);
return res; return res;
} }
#endif #endif

6
bn_mp_dr_is_modulus.c
View File

@ -29,9 +29,9 @@ int mp_dr_is_modulus(mp_int *a)
* but the first digit must be equal to -1 (mod b). * but the first digit must be equal to -1 (mod b).
*/ */
for (ix = 1; ix < a->used; ix++) { for (ix = 1; ix < a->used; ix++) {
if (a->dp[ix] != MP_MASK) { if (a->dp[ix] != MP_MASK) {
return 0; return 0;
} }
} }
return 1; return 1;
} }

85
bn_mp_dr_reduce.c
View File

@ -29,65 +29,64 @@
* *
* Input x must be in the range 0 <= x <= (n-1)**2 * Input x must be in the range 0 <= x <= (n-1)**2
*/ */
int int mp_dr_reduce(mp_int *x, mp_int *n, mp_digit k)
mp_dr_reduce (mp_int * x, mp_int * n, mp_digit k)
{ {
int err, i, m; int err, i, m;
mp_word r; mp_word r;
mp_digit mu, *tmpx1, *tmpx2; mp_digit mu, *tmpx1, *tmpx2;
/* m = digits in modulus */ /* m = digits in modulus */
m = n->used; m = n->used;
/* ensure that "x" has at least 2m digits */ /* ensure that "x" has at least 2m digits */
if (x->alloc < (m + m)) { if (x->alloc < (m + m)) {
if ((err = mp_grow (x, m + m)) != MP_OKAY) { if ((err = mp_grow(x, m + m)) != MP_OKAY) {
return err; return err;
} }
} }
/* top of loop, this is where the code resumes if /* top of loop, this is where the code resumes if
* another reduction pass is required. * another reduction pass is required.
*/ */
top: top:
/* aliases for digits */ /* aliases for digits */
/* alias for lower half of x */ /* alias for lower half of x */
tmpx1 = x->dp; tmpx1 = x->dp;
/* alias for upper half of x, or x/B**m */ /* alias for upper half of x, or x/B**m */
tmpx2 = x->dp + m; tmpx2 = x->dp + m;
/* set carry to zero */ /* set carry to zero */
mu = 0; mu = 0;
/* compute (x mod B**m) + k * [x/B**m] inline and inplace */ /* compute (x mod B**m) + k * [x/B**m] inline and inplace */
for (i = 0; i < m; i++) { for (i = 0; i < m; i++) {
r = (((mp_word)*tmpx2++) * (mp_word)k) + *tmpx1 + mu; r = (((mp_word)*tmpx2++) * (mp_word)k) + *tmpx1 + mu;
*tmpx1++ = (mp_digit)(r & MP_MASK); *tmpx1++ = (mp_digit)(r & MP_MASK);
mu = (mp_digit)(r >> ((mp_word)DIGIT_BIT)); mu = (mp_digit)(r >> ((mp_word)DIGIT_BIT));
} }
/* set final carry */ /* set final carry */
*tmpx1++ = mu; *tmpx1++ = mu;
/* zero words above m */ /* zero words above m */
for (i = m + 1; i < x->used; i++) { for (i = m + 1; i < x->used; i++) {
*tmpx1++ = 0; *tmpx1++ = 0;
} }
/* clamp, sub and return */ /* clamp, sub and return */
mp_clamp (x); mp_clamp(x);
/* if x >= n then subtract and reduce again /* if x >= n then subtract and reduce again
* Each successive "recursion" makes the input smaller and smaller. * Each successive "recursion" makes the input smaller and smaller.
*/ */
if (mp_cmp_mag (x, n) != MP_LT) { if (mp_cmp_mag(x, n) != MP_LT) {
if ((err = s_mp_sub(x, n, x)) != MP_OKAY) { if ((err = s_mp_sub(x, n, x)) != MP_OKAY) {
return err; return err;
} }
goto top; goto top;
} }
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

3
bn_mp_dr_setup.c
View File

@ -21,8 +21,7 @@ void mp_dr_setup(mp_int *a, mp_digit *d)
/* the casts are required if DIGIT_BIT is one less than /* the casts are required if DIGIT_BIT is one less than
* the number of bits in a mp_digit [e.g. DIGIT_BIT==31] * the number of bits in a mp_digit [e.g. DIGIT_BIT==31]
*/ */
*d = (mp_digit)((((mp_word)1) << ((mp_word)DIGIT_BIT)) - *d = (mp_digit)((((mp_word)1) << ((mp_word)DIGIT_BIT)) - ((mp_word)a->dp[0]));
((mp_word)a->dp[0]));
} }
#endif #endif

13
bn_mp_exch.c
View File

@ -15,17 +15,16 @@
* Tom St Denis, tstdenis82@gmail.com, http://libtom.org * Tom St Denis, tstdenis82@gmail.com, http://libtom.org
*/ */
/* swap the elements of two integers, for cases where you can't simply swap the /* swap the elements of two integers, for cases where you can't simply swap the
* mp_int pointers around * mp_int pointers around
*/ */
void void mp_exch(mp_int *a, mp_int *b)
mp_exch (mp_int * a, mp_int * b)
{ {
mp_int t; mp_int t;
t = *a; t = *a;
*a = *b; *a = *b;
*b = t; *b = t;
} }
#endif #endif

97
bn_mp_export.c
View File

@ -18,67 +18,66 @@
/* based on gmp's mpz_export. /* based on gmp's mpz_export.
* see http://gmplib.org/manual/Integer-Import-and-Export.html * see http://gmplib.org/manual/Integer-Import-and-Export.html
*/ */
int mp_export(void* rop, size_t* countp, int order, size_t size, int mp_export(void *rop, size_t *countp, int order, size_t size,
int endian, size_t nails, mp_int* op) { int endian, size_t nails, mp_int *op)
int result; {
size_t odd_nails, nail_bytes, i, j, bits, count; int result;
unsigned char odd_nail_mask; size_t odd_nails, nail_bytes, i, j, bits, count;
unsigned char odd_nail_mask;
mp_int t; mp_int t;
if ((result = mp_init_copy(&t, op)) != MP_OKAY) { if ((result = mp_init_copy(&t, op)) != MP_OKAY) {
return result; return result;
} }
if (endian == 0) { if (endian == 0) {
union { union {
unsigned int i; unsigned int i;
char c[4]; char c[4];
} lint; } lint;
lint.i = 0x01020304; lint.i = 0x01020304;
endian = (lint.c[0] == 4) ? -1 : 1;
}
odd_nails = (nails % 8); endian = (lint.c[0] == 4) ? -1 : 1;
odd_nail_mask = 0xff; }
for (i = 0; i < odd_nails; ++i) {
odd_nail_mask ^= (1 << (7 - i));
}
nail_bytes = nails / 8;
bits = mp_count_bits(&t); odd_nails = (nails % 8);
count = (bits / ((size * 8) - nails)) + (((bits % ((size * 8) - nails)) != 0) ? 1 : 0); odd_nail_mask = 0xff;
for (i = 0; i < odd_nails; ++i) {
odd_nail_mask ^= (1 << (7 - i));
}
nail_bytes = nails / 8;
for (i = 0; i < count; ++i) { bits = mp_count_bits(&t);
for (j = 0; j < size; ++j) { count = (bits / ((size * 8) - nails)) + (((bits % ((size * 8) - nails)) != 0) ? 1 : 0);
unsigned char* byte = (
(unsigned char*)rop +
(((order == -1) ? i : ((count - 1) - i)) * size) +
((endian == -1) ? j : ((size - 1) - j))
);
if (j >= (size - nail_bytes)) { for (i = 0; i < count; ++i) {
*byte = 0; for (j = 0; j < size; ++j) {
continue; unsigned char *byte = (unsigned char *)rop +
} (((order == -1) ? i : ((count - 1) - i)) * size) +
((endian == -1) ? j : ((size - 1) - j));
*byte = (unsigned char)((j == ((size - nail_bytes) - 1)) ? (t.dp[0] & odd_nail_mask) : (t.dp[0] & 0xFF)); if (j >= (size - nail_bytes)) {
*byte = 0;
continue;
}
if ((result = mp_div_2d(&t, ((j == ((size - nail_bytes) - 1)) ? (8 - odd_nails) : 8), &t, NULL)) != MP_OKAY) { *byte = (unsigned char)((j == ((size - nail_bytes) - 1)) ? (t.dp[0] & odd_nail_mask) : (t.dp[0] & 0xFF));
mp_clear(&t);
return result;
}
}
}
mp_clear(&t); if ((result = mp_div_2d(&t, ((j == ((size - nail_bytes) - 1)) ? (8 - odd_nails) : 8), &t, NULL)) != MP_OKAY) {
mp_clear(&t);
return result;
}
}
}
if (countp != NULL) { mp_clear(&t);
*countp = count;
}
return MP_OKAY; if (countp != NULL) {
*countp = count;
}
return MP_OKAY;
} }
#endif #endif

4
bn_mp_expt_d.c
View File

@ -16,9 +16,9 @@
*/ */
/* wrapper function for mp_expt_d_ex() */ /* wrapper function for mp_expt_d_ex() */
int mp_expt_d (mp_int * a, mp_digit b, mp_int * c) int mp_expt_d(mp_int *a, mp_digit b, mp_int *c)
{ {
return mp_expt_d_ex(a, b, c, 0); return mp_expt_d_ex(a, b, c, 0);
} }
#endif #endif

99
bn_mp_expt_d_ex.c
View File

@ -16,65 +16,64 @@
*/ */
/* calculate c = a**b using a square-multiply algorithm */ /* calculate c = a**b using a square-multiply algorithm */
int mp_expt_d_ex (mp_int * a, mp_digit b, mp_int * c, int fast) int mp_expt_d_ex(mp_int *a, mp_digit b, mp_int *c, int fast)
{ {
int res; int res;
unsigned int x; unsigned int x;
mp_int g; mp_int g;
if ((res = mp_init_copy (&g, a)) != MP_OKAY) { if ((res = mp_init_copy(&g, a)) != MP_OKAY) {
return res; return res;
} }
/* set initial result */ /* set initial result */
mp_set (c, 1); mp_set(c, 1);
if (fast != 0) { if (fast != 0) {
while (b > 0) { while (b > 0) {
/* if the bit is set multiply */ /* if the bit is set multiply */
if ((b & 1) != 0) { if ((b & 1) != 0) {
if ((res = mp_mul (c, &g, c)) != MP_OKAY) { if ((res = mp_mul(c, &g, c)) != MP_OKAY) {
mp_clear (&g); mp_clear(&g);
return res; return res;
} }
}
/* square */
if (b > 1) {
if ((res = mp_sqr(&g, &g)) != MP_OKAY) {
mp_clear(&g);
return res;
}
}
/* shift to next bit */
b >>= 1;
} }
} else {
for (x = 0; x < DIGIT_BIT; x++) {
/* square */
if ((res = mp_sqr(c, c)) != MP_OKAY) {
mp_clear(&g);
return res;
}
/* square */ /* if the bit is set multiply */
if (b > 1) { if ((b & (mp_digit)(((mp_digit)1) << (DIGIT_BIT - 1))) != 0) {
if ((res = mp_sqr (&g, &g)) != MP_OKAY) { if ((res = mp_mul(c, &g, c)) != MP_OKAY) {
mp_clear (&g); mp_clear(&g);
return res; return res;
} }
}
/* shift to next bit */
b <<= 1;
} }
} /* if ... else */
/* shift to next bit */ mp_clear(&g);
b >>= 1; return MP_OKAY;
}
}
else {
for (x = 0; x < DIGIT_BIT; x++) {
/* square */
if ((res = mp_sqr (c, c)) != MP_OKAY) {
mp_clear (&g);
return res;
}
/* if the bit is set multiply */
if ((b & (mp_digit) (((mp_digit)1) << (DIGIT_BIT - 1))) != 0) {
if ((res = mp_mul (c, &g, c)) != MP_OKAY) {
mp_clear (&g);
return res;
}
}
/* shift to next bit */
b <<= 1;
}
} /* if ... else */
mp_clear (&g);
return MP_OKAY;
} }
#endif #endif

114
bn_mp_exptmod.c
View File

@ -21,87 +21,87 @@
* embedded in the normal function but that wasted alot of stack space * embedded in the normal function but that wasted alot of stack space
* for nothing (since 99% of the time the Montgomery code would be called) * for nothing (since 99% of the time the Montgomery code would be called)
*/ */
int mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y) int mp_exptmod(mp_int *G, mp_int *X, mp_int *P, mp_int *Y)
{ {
int dr; int dr;
/* modulus P must be positive */ /* modulus P must be positive */
if (P->sign == MP_NEG) { if (P->sign == MP_NEG) {
return MP_VAL; return MP_VAL;
} }
/* if exponent X is negative we have to recurse */ /* if exponent X is negative we have to recurse */
if (X->sign == MP_NEG) { if (X->sign == MP_NEG) {
#ifdef BN_MP_INVMOD_C #ifdef BN_MP_INVMOD_C
mp_int tmpG, tmpX; mp_int tmpG, tmpX;
int err; int err;
/* first compute 1/G mod P */ /* first compute 1/G mod P */
if ((err = mp_init(&tmpG)) != MP_OKAY) { if ((err = mp_init(&tmpG)) != MP_OKAY) {
return err; return err;
} }
if ((err = mp_invmod(G, P, &tmpG)) != MP_OKAY) { if ((err = mp_invmod(G, P, &tmpG)) != MP_OKAY) {
mp_clear(&tmpG); mp_clear(&tmpG);
return err; return err;
} }
/* now get |X| */ /* now get |X| */
if ((err = mp_init(&tmpX)) != MP_OKAY) { if ((err = mp_init(&tmpX)) != MP_OKAY) {
mp_clear(&tmpG); mp_clear(&tmpG);
return err; return err;
} }
if ((err = mp_abs(X, &tmpX)) != MP_OKAY) { if ((err = mp_abs(X, &tmpX)) != MP_OKAY) {
mp_clear_multi(&tmpG, &tmpX, NULL); mp_clear_multi(&tmpG, &tmpX, NULL);
return err; return err;
} }
/* and now compute (1/G)**|X| instead of G**X [X < 0] */ /* and now compute (1/G)**|X| instead of G**X [X < 0] */
err = mp_exptmod(&tmpG, &tmpX, P, Y); err = mp_exptmod(&tmpG, &tmpX, P, Y);
mp_clear_multi(&tmpG, &tmpX, NULL); mp_clear_multi(&tmpG, &tmpX, NULL);
return err; return err;
#else #else
/* no invmod */ /* no invmod */
return MP_VAL; return MP_VAL;
#endif #endif
} }
/* modified diminished radix reduction */ /* modified diminished radix reduction */
#if defined(BN_MP_REDUCE_IS_2K_L_C) && defined(BN_MP_REDUCE_2K_L_C) && defined(BN_S_MP_EXPTMOD_C) #if defined(BN_MP_REDUCE_IS_2K_L_C) && defined(BN_MP_REDUCE_2K_L_C) && defined(BN_S_MP_EXPTMOD_C)
if (mp_reduce_is_2k_l(P) == MP_YES) { if (mp_reduce_is_2k_l(P) == MP_YES) {
return s_mp_exptmod(G, X, P, Y, 1); return s_mp_exptmod(G, X, P, Y, 1);
} }
#endif #endif
#ifdef BN_MP_DR_IS_MODULUS_C #ifdef BN_MP_DR_IS_MODULUS_C
/* is it a DR modulus? */ /* is it a DR modulus? */
dr = mp_dr_is_modulus(P); dr = mp_dr_is_modulus(P);
#else #else
/* default to no */ /* default to no */
dr = 0; dr = 0;
#endif #endif
#ifdef BN_MP_REDUCE_IS_2K_C #ifdef BN_MP_REDUCE_IS_2K_C
/* if not, is it a unrestricted DR modulus? */ /* if not, is it a unrestricted DR modulus? */
if (dr == 0) { if (dr == 0) {
dr = mp_reduce_is_2k(P) << 1; dr = mp_reduce_is_2k(P) << 1;
} }
#endif #endif
/* if the modulus is odd or dr != 0 use the montgomery method */ /* if the modulus is odd or dr != 0 use the montgomery method */
#ifdef BN_MP_EXPTMOD_FAST_C #ifdef BN_MP_EXPTMOD_FAST_C
if ((mp_isodd (P) == MP_YES) || (dr != 0)) { if ((mp_isodd(P) == MP_YES) || (dr != 0)) {
return mp_exptmod_fast (G, X, P, Y, dr); return mp_exptmod_fast(G, X, P, Y, dr);
} else { } else {
#endif #endif
#ifdef BN_S_MP_EXPTMOD_C #ifdef BN_S_MP_EXPTMOD_C
/* otherwise use the generic Barrett reduction technique */ /* otherwise use the generic Barrett reduction technique */
return s_mp_exptmod (G, X, P, Y, 0); return s_mp_exptmod(G, X, P, Y, 0);
#else #else
/* no exptmod for evens */ /* no exptmod for evens */
return MP_VAL; return MP_VAL;
#endif #endif
#ifdef BN_MP_EXPTMOD_FAST_C #ifdef BN_MP_EXPTMOD_FAST_C
} }
#endif #endif
} }

471
bn_mp_exptmod_fast.c
View File

@ -24,294 +24,295 @@
*/ */
#ifdef MP_LOW_MEM #ifdef MP_LOW_MEM
#define TAB_SIZE 32 # define TAB_SIZE 32
#else #else
#define TAB_SIZE 256 # define TAB_SIZE 256
#endif #endif
int mp_exptmod_fast (mp_int * G, mp_int * X, mp_int * P, mp_int * Y, int redmode) int mp_exptmod_fast(mp_int *G, mp_int *X, mp_int *P, mp_int *Y, int redmode)
{ {
mp_int M[TAB_SIZE], res; mp_int M[TAB_SIZE], res;
mp_digit buf, mp; mp_digit buf, mp;
int err, bitbuf, bitcpy, bitcnt, mode, digidx, x, y, winsize; int err, bitbuf, bitcpy, bitcnt, mode, digidx, x, y, winsize;
/* use a pointer to the reduction algorithm. This allows us to use /* use a pointer to the reduction algorithm. This allows us to use
* one of many reduction algorithms without modding the guts of * one of many reduction algorithms without modding the guts of
* the code with if statements everywhere. * the code with if statements everywhere.
*/ */
int (*redux)(mp_int*,mp_int*,mp_digit); int (*redux)(mp_int *,mp_int *,mp_digit);
/* find window size */ /* find window size */
x = mp_count_bits (X); x = mp_count_bits(X);
if (x <= 7) { if (x <= 7) {
winsize = 2; winsize = 2;
} else if (x <= 36) { } else if (x <= 36) {
winsize = 3; winsize = 3;
} else if (x <= 140) { } else if (x <= 140) {
winsize = 4; winsize = 4;
} else if (x <= 450) { } else if (x <= 450) {
winsize = 5; winsize = 5;
} else if (x <= 1303) { } else if (x <= 1303) {
winsize = 6; winsize = 6;
} else if (x <= 3529) { } else if (x <= 3529) {
winsize = 7; winsize = 7;
} else { } else {
winsize = 8; winsize = 8;
} }
#ifdef MP_LOW_MEM #ifdef MP_LOW_MEM
if (winsize > 5) { if (winsize > 5) {
winsize = 5; winsize = 5;
} }
#endif #endif
/* init M array */ /* init M array */
/* init first cell */ /* init first cell */
if ((err = mp_init_size(&M[1], P->alloc)) != MP_OKAY) { if ((err = mp_init_size(&M[1], P->alloc)) != MP_OKAY) {
return err;
}
/* now init the second half of the array */
for (x = 1<<(winsize-1); x < (1 << winsize); x++) {
if ((err = mp_init_size(&M[x], P->alloc)) != MP_OKAY) {
for (y = 1<<(winsize-1); y < x; y++) {
mp_clear (&M[y]);
}
mp_clear(&M[1]);
return err; return err;
} }
}
/* determine and setup reduction code */ /* now init the second half of the array */
if (redmode == 0) { for (x = 1<<(winsize-1); x < (1 << winsize); x++) {
#ifdef BN_MP_MONTGOMERY_SETUP_C if ((err = mp_init_size(&M[x], P->alloc)) != MP_OKAY) {
/* now setup montgomery */ for (y = 1<<(winsize-1); y < x; y++) {
if ((err = mp_montgomery_setup (P, &mp)) != MP_OKAY) { mp_clear(&M[y]);
goto LBL_M; }
} mp_clear(&M[1]);
return err;
}
}
/* determine and setup reduction code */
if (redmode == 0) {
#ifdef BN_MP_MONTGOMERY_SETUP_C
/* now setup montgomery */
if ((err = mp_montgomery_setup(P, &mp)) != MP_OKAY) {
goto LBL_M;
}
#else #else
err = MP_VAL; err = MP_VAL;
goto LBL_M; goto LBL_M;
#endif #endif
/* automatically pick the comba one if available (saves quite a few calls/ifs) */ /* automatically pick the comba one if available (saves quite a few calls/ifs) */
#ifdef BN_FAST_MP_MONTGOMERY_REDUCE_C #ifdef BN_FAST_MP_MONTGOMERY_REDUCE_C
if ((((P->used * 2) + 1) < MP_WARRAY) && if ((((P->used * 2) + 1) < MP_WARRAY) &&
(P->used < (1 << ((CHAR_BIT * sizeof(mp_word)) - (2 * DIGIT_BIT))))) { (P->used < (1 << ((CHAR_BIT * sizeof(mp_word)) - (2 * DIGIT_BIT))))) {
redux = fast_mp_montgomery_reduce; redux = fast_mp_montgomery_reduce;
} else } else
#endif #endif
{ {
#ifdef BN_MP_MONTGOMERY_REDUCE_C #ifdef BN_MP_MONTGOMERY_REDUCE_C
/* use slower baseline Montgomery method */ /* use slower baseline Montgomery method */
redux = mp_montgomery_reduce; redux = mp_montgomery_reduce;
#else #else
err = MP_VAL; err = MP_VAL;
goto LBL_M; goto LBL_M;
#endif #endif
} }
} else if (redmode == 1) { } else if (redmode == 1) {
#if defined(BN_MP_DR_SETUP_C) && defined(BN_MP_DR_REDUCE_C) #if defined(BN_MP_DR_SETUP_C) && defined(BN_MP_DR_REDUCE_C)
/* setup DR reduction for moduli of the form B**k - b */ /* setup DR reduction for moduli of the form B**k - b */
mp_dr_setup(P, &mp); mp_dr_setup(P, &mp);
redux = mp_dr_reduce; redux = mp_dr_reduce;
#else #else
err = MP_VAL; err = MP_VAL;
goto LBL_M; goto LBL_M;
#endif #endif
} else { } else {
#if defined(BN_MP_REDUCE_2K_SETUP_C) && defined(BN_MP_REDUCE_2K_C) #if defined(BN_MP_REDUCE_2K_SETUP_C) && defined(BN_MP_REDUCE_2K_C)
/* setup DR reduction for moduli of the form 2**k - b */ /* setup DR reduction for moduli of the form 2**k - b */
if ((err = mp_reduce_2k_setup(P, &mp)) != MP_OKAY) { if ((err = mp_reduce_2k_setup(P, &mp)) != MP_OKAY) {
goto LBL_M; goto LBL_M;
} }
redux = mp_reduce_2k; redux = mp_reduce_2k;
#else #else
err = MP_VAL; err = MP_VAL;
goto LBL_M; goto LBL_M;
#endif #endif
} }
/* setup result */ /* setup result */
if ((err = mp_init_size (&res, P->alloc)) != MP_OKAY) { if ((err = mp_init_size(&res, P->alloc)) != MP_OKAY) {
goto LBL_M; goto LBL_M;
} }
/* create M table /* create M table
* *
* *
* The first half of the table is not computed though accept for M[0] and M[1] * The first half of the table is not computed though accept for M[0] and M[1]
*/ */
if (redmode == 0) { if (redmode == 0) {
#ifdef BN_MP_MONTGOMERY_CALC_NORMALIZATION_C #ifdef BN_MP_MONTGOMERY_CALC_NORMALIZATION_C
/* now we need R mod m */ /* now we need R mod m */
if ((err = mp_montgomery_calc_normalization (&res, P)) != MP_OKAY) { if ((err = mp_montgomery_calc_normalization(&res, P)) != MP_OKAY) {
goto LBL_RES; goto LBL_RES;
} }
/* now set M[1] to G * R mod m */ /* now set M[1] to G * R mod m */
if ((err = mp_mulmod (G, &res, P, &M[1])) != MP_OKAY) { if ((err = mp_mulmod(G, &res, P, &M[1])) != MP_OKAY) {
goto LBL_RES; goto LBL_RES;
} }
#else #else
err = MP_VAL; err = MP_VAL;
goto LBL_RES; goto LBL_RES;
#endif #endif
} else { } else {
mp_set(&res, 1); mp_set(&res, 1);
if ((err = mp_mod(G, P, &M[1])) != MP_OKAY) { if ((err = mp_mod(G, P, &M[1])) != MP_OKAY) {
goto LBL_RES; goto LBL_RES;
} }
} }
/* compute the value at M[1<<(winsize-1)] by squaring M[1] (winsize-1) times */ /* compute the value at M[1<<(winsize-1)] by squaring M[1] (winsize-1) times */
if ((err = mp_copy (&M[1], &M[1 << (winsize - 1)])) != MP_OKAY) { if ((err = mp_copy(&M[1], &M[1 << (winsize - 1)])) != MP_OKAY) {
goto LBL_RES;
}
for (x = 0; x < (winsize - 1); x++) {
if ((err = mp_sqr (&M[1 << (winsize - 1)], &M[1 << (winsize - 1)])) != MP_OKAY) {
goto LBL_RES; goto LBL_RES;
} }
if ((err = redux (&M[1 << (winsize - 1)], P, mp)) != MP_OKAY) {
goto LBL_RES;
}
}
/* create upper table */ for (x = 0; x < (winsize - 1); x++) {
for (x = (1 << (winsize - 1)) + 1; x < (1 << winsize); x++) { if ((err = mp_sqr(&M[1 << (winsize - 1)], &M[1 << (winsize - 1)])) != MP_OKAY) {
if ((err = mp_mul (&M[x - 1], &M[1], &M[x])) != MP_OKAY) { goto LBL_RES;
goto LBL_RES;
}
if ((err = redux (&M[x], P, mp)) != MP_OKAY) {
goto LBL_RES;
}
}
/* set initial mode and bit cnt */
mode = 0;
bitcnt = 1;
buf = 0;
digidx = X->used - 1;
bitcpy = 0;
bitbuf = 0;
for (;;) {
/* grab next digit as required */
if (--bitcnt == 0) {
/* if digidx == -1 we are out of digits so break */
if (digidx == -1) {
break;
} }
/* read next digit and reset bitcnt */ if ((err = redux(&M[1 << (winsize - 1)], P, mp)) != MP_OKAY) {
buf = X->dp[digidx--]; goto LBL_RES;
bitcnt = (int)DIGIT_BIT;
}
/* grab the next msb from the exponent */
y = (mp_digit)(buf >> (DIGIT_BIT - 1)) & 1;
buf <<= (mp_digit)1;
/* if the bit is zero and mode == 0 then we ignore it
* These represent the leading zero bits before the first 1 bit
* in the exponent. Technically this opt is not required but it
* does lower the # of trivial squaring/reductions used
*/
if ((mode == 0) && (y == 0)) {
continue;
}
/* if the bit is zero and mode == 1 then we square */
if ((mode == 1) && (y == 0)) {
if ((err = mp_sqr (&res, &res)) != MP_OKAY) {
goto LBL_RES;
} }
if ((err = redux (&res, P, mp)) != MP_OKAY) { }
goto LBL_RES;
/* create upper table */
for (x = (1 << (winsize - 1)) + 1; x < (1 << winsize); x++) {
if ((err = mp_mul(&M[x - 1], &M[1], &M[x])) != MP_OKAY) {
goto LBL_RES;
} }
continue; if ((err = redux(&M[x], P, mp)) != MP_OKAY) {
} goto LBL_RES;
}
}
/* else we add it to the window */ /* set initial mode and bit cnt */
bitbuf |= (y << (winsize - ++bitcpy)); mode = 0;
mode = 2; bitcnt = 1;
buf = 0;
digidx = X->used - 1;
bitcpy = 0;
bitbuf = 0;
if (bitcpy == winsize) { for (;;) {
/* ok window is filled so square as required and multiply */ /* grab next digit as required */
/* square first */ if (--bitcnt == 0) {
for (x = 0; x < winsize; x++) { /* if digidx == -1 we are out of digits so break */
if ((err = mp_sqr (&res, &res)) != MP_OKAY) { if (digidx == -1) {
goto LBL_RES; break;
} }
if ((err = redux (&res, P, mp)) != MP_OKAY) { /* read next digit and reset bitcnt */
goto LBL_RES; buf = X->dp[digidx--];
} bitcnt = (int)DIGIT_BIT;
} }
/* then multiply */ /* grab the next msb from the exponent */
if ((err = mp_mul (&res, &M[bitbuf], &res)) != MP_OKAY) { y = (mp_digit)(buf >> (DIGIT_BIT - 1)) & 1;
goto LBL_RES; buf <<= (mp_digit)1;
}
if ((err = redux (&res, P, mp)) != MP_OKAY) { /* if the bit is zero and mode == 0 then we ignore it
goto LBL_RES; * These represent the leading zero bits before the first 1 bit
* in the exponent. Technically this opt is not required but it
* does lower the # of trivial squaring/reductions used
*/
if ((mode == 0) && (y == 0)) {
continue;
} }
/* empty window and reset */ /* if the bit is zero and mode == 1 then we square */
bitcpy = 0; if ((mode == 1) && (y == 0)) {
bitbuf = 0; if ((err = mp_sqr(&res, &res)) != MP_OKAY) {
mode = 1; goto LBL_RES;
} }
} if ((err = redux(&res, P, mp)) != MP_OKAY) {
goto LBL_RES;
/* if bits remain then square/multiply */ }
if ((mode == 2) && (bitcpy > 0)) { continue;
/* square then multiply if the bit is set */
for (x = 0; x < bitcpy; x++) {
if ((err = mp_sqr (&res, &res)) != MP_OKAY) {
goto LBL_RES;
}
if ((err = redux (&res, P, mp)) != MP_OKAY) {
goto LBL_RES;
} }
/* get next bit of the window */ /* else we add it to the window */
bitbuf <<= 1; bitbuf |= (y << (winsize - ++bitcpy));
if ((bitbuf & (1 << winsize)) != 0) { mode = 2;
/* then multiply */
if ((err = mp_mul (&res, &M[1], &res)) != MP_OKAY) { if (bitcpy == winsize) {
goto LBL_RES; /* ok window is filled so square as required and multiply */
} /* square first */
if ((err = redux (&res, P, mp)) != MP_OKAY) { for (x = 0; x < winsize; x++) {
goto LBL_RES; if ((err = mp_sqr(&res, &res)) != MP_OKAY) {
} goto LBL_RES;
}
if ((err = redux(&res, P, mp)) != MP_OKAY) {
goto LBL_RES;
}
}
/* then multiply */
if ((err = mp_mul(&res, &M[bitbuf], &res)) != MP_OKAY) {
goto LBL_RES;
}
if ((err = redux(&res, P, mp)) != MP_OKAY) {
goto LBL_RES;
}
/* empty window and reset */
bitcpy = 0;
bitbuf = 0;
mode = 1;
} }
} }
}
if (redmode == 0) { /* if bits remain then square/multiply */
/* fixup result if Montgomery reduction is used if ((mode == 2) && (bitcpy > 0)) {
* recall that any value in a Montgomery system is /* square then multiply if the bit is set */
* actually multiplied by R mod n. So we have for (x = 0; x < bitcpy; x++) {
* to reduce one more time to cancel out the factor if ((err = mp_sqr(&res, &res)) != MP_OKAY) {
* of R. goto LBL_RES;
*/ }
if ((err = redux(&res, P, mp)) != MP_OKAY) { if ((err = redux(&res, P, mp)) != MP_OKAY) {
goto LBL_RES; goto LBL_RES;
} }
}
/* swap res with Y */ /* get next bit of the window */
mp_exch (&res, Y); bitbuf <<= 1;
err = MP_OKAY; if ((bitbuf & (1 << winsize)) != 0) {
LBL_RES:mp_clear (&res); /* then multiply */
if ((err = mp_mul(&res, &M[1], &res)) != MP_OKAY) {
goto LBL_RES;
}
if ((err = redux(&res, P, mp)) != MP_OKAY) {
goto LBL_RES;
}
}
}
}
if (redmode == 0) {
/* fixup result if Montgomery reduction is used
* recall that any value in a Montgomery system is
* actually multiplied by R mod n. So we have
* to reduce one more time to cancel out the factor
* of R.
*/
if ((err = redux(&res, P, mp)) != MP_OKAY) {
goto LBL_RES;
}
}
/* swap res with Y */
mp_exch(&res, Y);
err = MP_OKAY;
LBL_RES:
mp_clear(&res);
LBL_M: LBL_M:
mp_clear(&M[1]); mp_clear(&M[1]);
for (x = 1<<(winsize-1); x < (1 << winsize); x++) { for (x = 1<<(winsize-1); x < (1 << winsize); x++) {
mp_clear (&M[x]); mp_clear(&M[x]);
} }
return err; return err;
} }
#endif #endif

94
bn_mp_exteuclid.c
View File

@ -20,7 +20,7 @@
*/ */
int mp_exteuclid(mp_int *a, mp_int *b, mp_int *U1, mp_int *U2, mp_int *U3) int mp_exteuclid(mp_int *a, mp_int *b, mp_int *U1, mp_int *U2, mp_int *U3)
{ {
mp_int u1,u2,u3,v1,v2,v3,t1,t2,t3,q,tmp; mp_int u1, u2, u3, v1, v2, v3, t1, t2, t3, q, tmp;
int err; int err;
if ((err = mp_init_multi(&u1, &u2, &u3, &v1, &v2, &v3, &t1, &t2, &t3, &q, &tmp, NULL)) != MP_OKAY) { if ((err = mp_init_multi(&u1, &u2, &u3, &v1, &v2, &v3, &t1, &t2, &t3, &q, &tmp, NULL)) != MP_OKAY) {
@ -29,47 +29,89 @@ int mp_exteuclid(mp_int *a, mp_int *b, mp_int *U1, mp_int *U2, mp_int *U3)
/* initialize, (u1,u2,u3) = (1,0,a) */ /* initialize, (u1,u2,u3) = (1,0,a) */
mp_set(&u1, 1); mp_set(&u1, 1);
if ((err = mp_copy(a, &u3)) != MP_OKAY) { goto LBL_ERR; } if ((err = mp_copy(a, &u3)) != MP_OKAY) {
goto LBL_ERR;
}
/* initialize, (v1,v2,v3) = (0,1,b) */ /* initialize, (v1,v2,v3) = (0,1,b) */
mp_set(&v2, 1); mp_set(&v2, 1);
if ((err = mp_copy(b, &v3)) != MP_OKAY) { goto LBL_ERR; } if ((err = mp_copy(b, &v3)) != MP_OKAY) {
goto LBL_ERR;
}
/* loop while v3 != 0 */ /* loop while v3 != 0 */
while (mp_iszero(&v3) == MP_NO) { while (mp_iszero(&v3) == MP_NO) {
/* q = u3/v3 */ /* q = u3/v3 */
if ((err = mp_div(&u3, &v3, &q, NULL)) != MP_OKAY) { goto LBL_ERR; } if ((err = mp_div(&u3, &v3, &q, NULL)) != MP_OKAY) {
goto LBL_ERR;
}
/* (t1,t2,t3) = (u1,u2,u3) - (v1,v2,v3)q */ /* (t1,t2,t3) = (u1,u2,u3) - (v1,v2,v3)q */
if ((err = mp_mul(&v1, &q, &tmp)) != MP_OKAY) { goto LBL_ERR; } if ((err = mp_mul(&v1, &q, &tmp)) != MP_OKAY) {
if ((err = mp_sub(&u1, &tmp, &t1)) != MP_OKAY) { goto LBL_ERR; } goto LBL_ERR;
if ((err = mp_mul(&v2, &q, &tmp)) != MP_OKAY) { goto LBL_ERR; } }
if ((err = mp_sub(&u2, &tmp, &t2)) != MP_OKAY) { goto LBL_ERR; } if ((err = mp_sub(&u1, &tmp, &t1)) != MP_OKAY) {
if ((err = mp_mul(&v3, &q, &tmp)) != MP_OKAY) { goto LBL_ERR; } goto LBL_ERR;
if ((err = mp_sub(&u3, &tmp, &t3)) != MP_OKAY) { goto LBL_ERR; } }
if ((err = mp_mul(&v2, &q, &tmp)) != MP_OKAY) {
goto LBL_ERR;
}
if ((err = mp_sub(&u2, &tmp, &t2)) != MP_OKAY) {
goto LBL_ERR;
}
if ((err = mp_mul(&v3, &q, &tmp)) != MP_OKAY) {
goto LBL_ERR;
}
if ((err = mp_sub(&u3, &tmp, &t3)) != MP_OKAY) {
goto LBL_ERR;
}
/* (u1,u2,u3) = (v1,v2,v3) */ /* (u1,u2,u3) = (v1,v2,v3) */
if ((err = mp_copy(&v1, &u1)) != MP_OKAY) { goto LBL_ERR; } if ((err = mp_copy(&v1, &u1)) != MP_OKAY) {
if ((err = mp_copy(&v2, &u2)) != MP_OKAY) { goto LBL_ERR; } goto LBL_ERR;
if ((err = mp_copy(&v3, &u3)) != MP_OKAY) { goto LBL_ERR; } }
if ((err = mp_copy(&v2, &u2)) != MP_OKAY) {
goto LBL_ERR;
}
if ((err = mp_copy(&v3, &u3)) != MP_OKAY) {
goto LBL_ERR;
}
/* (v1,v2,v3) = (t1,t2,t3) */ /* (v1,v2,v3) = (t1,t2,t3) */
if ((err = mp_copy(&t1, &v1)) != MP_OKAY) { goto LBL_ERR; } if ((err = mp_copy(&t1, &v1)) != MP_OKAY) {
if ((err = mp_copy(&t2, &v2)) != MP_OKAY) { goto LBL_ERR; } goto LBL_ERR;
if ((err = mp_copy(&t3, &v3)) != MP_OKAY) { goto LBL_ERR; } }
if ((err = mp_copy(&t2, &v2)) != MP_OKAY) {
goto LBL_ERR;
}
if ((err = mp_copy(&t3, &v3)) != MP_OKAY) {
goto LBL_ERR;
}
} }
/* make sure U3 >= 0 */ /* make sure U3 >= 0 */
if (u3.sign == MP_NEG) { if (u3.sign == MP_NEG) {
if ((err = mp_neg(&u1, &u1)) != MP_OKAY) { goto LBL_ERR; } if ((err = mp_neg(&u1, &u1)) != MP_OKAY) {
if ((err = mp_neg(&u2, &u2)) != MP_OKAY) { goto LBL_ERR; } goto LBL_ERR;
if ((err = mp_neg(&u3, &u3)) != MP_OKAY) { goto LBL_ERR; } }
if ((err = mp_neg(&u2, &u2)) != MP_OKAY) {
goto LBL_ERR;
}
if ((err = mp_neg(&u3, &u3)) != MP_OKAY) {
goto LBL_ERR;
}
} }
/* copy result out */ /* copy result out */
if (U1 != NULL) { mp_exch(U1, &u1); } if (U1 != NULL) {
if (U2 != NULL) { mp_exch(U2, &u2); } mp_exch(U1, &u1);
if (U3 != NULL) { mp_exch(U3, &u3); } }
if (U2 != NULL) {
mp_exch(U2, &u2);
}
if (U3 != NULL) {
mp_exch(U3, &u3);
}
err = MP_OKAY; err = MP_OKAY;
LBL_ERR: LBL_ERR:

18
bn_mp_fread.c
View File

@ -20,10 +20,10 @@
int mp_fread(mp_int *a, int radix, FILE *stream) int mp_fread(mp_int *a, int radix, FILE *stream)
{ {
int err, ch, neg, y; int err, ch, neg, y;
/* clear a */ /* clear a */
mp_zero(a); mp_zero(a);
/* if first digit is - then set negative */ /* if first digit is - then set negative */
ch = fgetc(stream); ch = fgetc(stream);
if (ch == '-') { if (ch == '-') {
@ -32,18 +32,18 @@ int mp_fread(mp_int *a, int radix, FILE *stream)
} else { } else {
neg = MP_ZPOS; neg = MP_ZPOS;
} }
for (;;) { for (;;) {
/* find y in the radix map */ /* find y in the radix map */
for (y = 0; y < radix; y++) { for (y = 0; y < radix; y++) {
if (mp_s_rmap[y] == ch) { if (mp_s_rmap[y] == ch) {
break; break;
} }
} }
if (y == radix) { if (y == radix) {
break; break;
} }
/* shift up and add */ /* shift up and add */
if ((err = mp_mul_d(a, radix, a)) != MP_OKAY) { if ((err = mp_mul_d(a, radix, a)) != MP_OKAY) {
return err; return err;
@ -51,13 +51,13 @@ int mp_fread(mp_int *a, int radix, FILE *stream)
if ((err = mp_add_d(a, y, a)) != MP_OKAY) { if ((err = mp_add_d(a, y, a)) != MP_OKAY) {
return err; return err;
} }
ch = fgetc(stream); ch = fgetc(stream);
} }
if (mp_cmp_d(a, 0) != MP_EQ) { if (mp_cmp_d(a, 0) != MP_EQ) {
a->sign = neg; a->sign = neg;
} }
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

22
bn_mp_fwrite.c
View File

@ -20,29 +20,29 @@ int mp_fwrite(mp_int *a, int radix, FILE *stream)
{ {
char *buf; char *buf;
int err, len, x; int err, len, x;
if ((err = mp_radix_size(a, radix, &len)) != MP_OKAY) { if ((err = mp_radix_size(a, radix, &len)) != MP_OKAY) {
return err; return err;
} }
buf = OPT_CAST(char) XMALLOC (len); buf = OPT_CAST(char) XMALLOC(len);
if (buf == NULL) { if (buf == NULL) {
return MP_MEM; return MP_MEM;
} }
if ((err = mp_toradix(a, buf, radix)) != MP_OKAY) { if ((err = mp_toradix(a, buf, radix)) != MP_OKAY) {
XFREE (buf); XFREE(buf);
return err; return err;
} }
for (x = 0; x < len; x++) { for (x = 0; x < len; x++) {
if (fputc(buf[x], stream) == EOF) { if (fputc(buf[x], stream) == EOF) {
XFREE (buf); XFREE(buf);
return MP_VAL; return MP_VAL;
} }
} }
XFREE (buf); XFREE(buf);
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

140
bn_mp_gcd.c
View File

@ -16,87 +16,89 @@
*/ */
/* Greatest Common Divisor using the binary method */ /* Greatest Common Divisor using the binary method */
int mp_gcd (mp_int * a, mp_int * b, mp_int * c) int mp_gcd(mp_int *a, mp_int *b, mp_int *c)
{ {
mp_int u, v; mp_int u, v;
int k, u_lsb, v_lsb, res; int k, u_lsb, v_lsb, res;
/* either zero than gcd is the largest */ /* either zero than gcd is the largest */
if (mp_iszero (a) == MP_YES) { if (mp_iszero(a) == MP_YES) {
return mp_abs (b, c); return mp_abs(b, c);
} }
if (mp_iszero (b) == MP_YES) { if (mp_iszero(b) == MP_YES) {
return mp_abs (a, c); return mp_abs(a, c);
} }
/* get copies of a and b we can modify */ /* get copies of a and b we can modify */
if ((res = mp_init_copy (&u, a)) != MP_OKAY) { if ((res = mp_init_copy(&u, a)) != MP_OKAY) {
return res; return res;
} }
if ((res = mp_init_copy (&v, b)) != MP_OKAY) { if ((res = mp_init_copy(&v, b)) != MP_OKAY) {
goto LBL_U; goto LBL_U;
} }
/* must be positive for the remainder of the algorithm */ /* must be positive for the remainder of the algorithm */
u.sign = v.sign = MP_ZPOS; u.sign = v.sign = MP_ZPOS;
/* B1. Find the common power of two for u and v */ /* B1. Find the common power of two for u and v */
u_lsb = mp_cnt_lsb(&u); u_lsb = mp_cnt_lsb(&u);
v_lsb = mp_cnt_lsb(&v); v_lsb = mp_cnt_lsb(&v);
k = MIN(u_lsb, v_lsb); k = MIN(u_lsb, v_lsb);
if (k > 0) { if (k > 0) {
/* divide the power of two out */ /* divide the power of two out */
if ((res = mp_div_2d(&u, k, &u, NULL)) != MP_OKAY) { if ((res = mp_div_2d(&u, k, &u, NULL)) != MP_OKAY) {
goto LBL_V; goto LBL_V;
} }
if ((res = mp_div_2d(&v, k, &v, NULL)) != MP_OKAY) { if ((res = mp_div_2d(&v, k, &v, NULL)) != MP_OKAY) {
goto LBL_V; goto LBL_V;
} }
} }
/* divide any remaining factors of two out */ /* divide any remaining factors of two out */
if (u_lsb != k) { if (u_lsb != k) {
if ((res = mp_div_2d(&u, u_lsb - k, &u, NULL)) != MP_OKAY) { if ((res = mp_div_2d(&u, u_lsb - k, &u, NULL)) != MP_OKAY) {
goto LBL_V; goto LBL_V;
} }
} }
if (v_lsb != k) { if (v_lsb != k) {
if ((res = mp_div_2d(&v, v_lsb - k, &v, NULL)) != MP_OKAY) { if ((res = mp_div_2d(&v, v_lsb - k, &v, NULL)) != MP_OKAY) {
goto LBL_V; goto LBL_V;
} }
} }
while (mp_iszero(&v) == MP_NO) { while (mp_iszero(&v) == MP_NO) {
/* make sure v is the largest */ /* make sure v is the largest */
if (mp_cmp_mag(&u, &v) == MP_GT) { if (mp_cmp_mag(&u, &v) == MP_GT) {
/* swap u and v to make sure v is >= u */ /* swap u and v to make sure v is >= u */
mp_exch(&u, &v); mp_exch(&u, &v);
} }
/* subtract smallest from largest */
if ((res = s_mp_sub(&v, &u, &v)) != MP_OKAY) {
goto LBL_V;
}
/* Divide out all factors of two */
if ((res = mp_div_2d(&v, mp_cnt_lsb(&v), &v, NULL)) != MP_OKAY) {
goto LBL_V;
}
}
/* multiply by 2**k which we divided out at the beginning */ /* subtract smallest from largest */
if ((res = mp_mul_2d (&u, k, c)) != MP_OKAY) { if ((res = s_mp_sub(&v, &u, &v)) != MP_OKAY) {
goto LBL_V; goto LBL_V;
} }
c->sign = MP_ZPOS;
res = MP_OKAY; /* Divide out all factors of two */
LBL_V:mp_clear (&u); if ((res = mp_div_2d(&v, mp_cnt_lsb(&v), &v, NULL)) != MP_OKAY) {
LBL_U:mp_clear (&v); goto LBL_V;
return res; }
}
/* multiply by 2**k which we divided out at the beginning */
if ((res = mp_mul_2d(&u, k, c)) != MP_OKAY) {
goto LBL_V;
}
c->sign = MP_ZPOS;
res = MP_OKAY;
LBL_V:
mp_clear(&u);
LBL_U:
mp_clear(&v);
return res;
} }
#endif #endif

30
bn_mp_get_int.c
View File

@ -16,27 +16,27 @@
*/ */
/* get the lower 32-bits of an mp_int */ /* get the lower 32-bits of an mp_int */
unsigned long mp_get_int(mp_int * a) unsigned long mp_get_int(mp_int *a)
{ {
int i; int i;
mp_min_u32 res; mp_min_u32 res;
if (a->used == 0) { if (a->used == 0) {
return 0; return 0;
} }
/* get number of digits of the lsb we have to read */ /* get number of digits of the lsb we have to read */
i = MIN(a->used,(int)(((sizeof(unsigned long) * CHAR_BIT) + DIGIT_BIT - 1) / DIGIT_BIT)) - 1; i = MIN(a->used, (int)(((sizeof(unsigned long) * CHAR_BIT) + DIGIT_BIT - 1) / DIGIT_BIT)) - 1;
/* get most significant digit of result */ /* get most significant digit of result */
res = DIGIT(a,i); res = DIGIT(a, i);
while (--i >= 0) { while (--i >= 0) {
res = (res << DIGIT_BIT) | DIGIT(a,i); res = (res << DIGIT_BIT) | DIGIT(a, i);
} }
/* force result to 32-bits always so it is consistent on non 32-bit platforms */ /* force result to 32-bits always so it is consistent on non 32-bit platforms */
return res & 0xFFFFFFFFUL; return res & 0xFFFFFFFFUL;
} }
#endif #endif

28
bn_mp_get_long.c
View File

@ -16,26 +16,26 @@
*/ */
/* get the lower unsigned long of an mp_int, platform dependent */ /* get the lower unsigned long of an mp_int, platform dependent */
unsigned long mp_get_long(mp_int * a) unsigned long mp_get_long(mp_int *a)
{ {
int i; int i;
unsigned long res; unsigned long res;
if (a->used == 0) { if (a->used == 0) {
return 0; return 0;
} }
/* get number of digits of the lsb we have to read */ /* get number of digits of the lsb we have to read */
i = MIN(a->used,(int)(((sizeof(unsigned long) * CHAR_BIT) + DIGIT_BIT - 1) / DIGIT_BIT)) - 1; i = MIN(a->used, (int)(((sizeof(unsigned long) * CHAR_BIT) + DIGIT_BIT - 1) / DIGIT_BIT)) - 1;
/* get most significant digit of result */ /* get most significant digit of result */
res = DIGIT(a,i); res = DIGIT(a, i);
#if (ULONG_MAX != 0xffffffffuL) || (DIGIT_BIT < 32) #if (ULONG_MAX != 0xffffffffuL) || (DIGIT_BIT < 32)
while (--i >= 0) { while (--i >= 0) {
res = (res << DIGIT_BIT) | DIGIT(a,i); res = (res << DIGIT_BIT) | DIGIT(a, i);
} }
#endif #endif
return res; return res;
} }
#endif #endif

28
bn_mp_get_long_long.c
View File

@ -16,26 +16,26 @@
*/ */
/* get the lower unsigned long long of an mp_int, platform dependent */ /* get the lower unsigned long long of an mp_int, platform dependent */
unsigned long long mp_get_long_long (mp_int * a) unsigned long long mp_get_long_long(mp_int *a)
{ {
int i; int i;
unsigned long long res; unsigned long long res;
if (a->used == 0) { if (a->used == 0) {
return 0; return 0;
} }
/* get number of digits of the lsb we have to read */ /* get number of digits of the lsb we have to read */
i = MIN(a->used,(int)(((sizeof(unsigned long long) * CHAR_BIT) + DIGIT_BIT - 1) / DIGIT_BIT)) - 1; i = MIN(a->used, (int)(((sizeof(unsigned long long) * CHAR_BIT) + DIGIT_BIT - 1) / DIGIT_BIT)) - 1;
/* get most significant digit of result */ /* get most significant digit of result */
res = DIGIT(a,i); res = DIGIT(a, i);
#if DIGIT_BIT < 64 #if DIGIT_BIT < 64
while (--i >= 0) { while (--i >= 0) {
res = (res << DIGIT_BIT) | DIGIT(a,i); res = (res << DIGIT_BIT) | DIGIT(a, i);
} }
#endif #endif
return res; return res;
} }
#endif #endif

56
bn_mp_grow.c
View File

@ -16,39 +16,39 @@
*/ */
/* grow as required */ /* grow as required */
int mp_grow (mp_int * a, int size) int mp_grow(mp_int *a, int size)
{ {
int i; int i;
mp_digit *tmp; mp_digit *tmp;
/* if the alloc size is smaller alloc more ram */ /* if the alloc size is smaller alloc more ram */
if (a->alloc < size) { if (a->alloc < size) {
/* ensure there are always at least MP_PREC digits extra on top */ /* ensure there are always at least MP_PREC digits extra on top */
size += (MP_PREC * 2) - (size % MP_PREC); size += (MP_PREC * 2) - (size % MP_PREC);
/* reallocate the array a->dp /* reallocate the array a->dp
* *
* We store the return in a temporary variable * We store the return in a temporary variable
* in case the operation failed we don't want * in case the operation failed we don't want
* to overwrite the dp member of a. * to overwrite the dp member of a.
*/ */
tmp = OPT_CAST(mp_digit) XREALLOC (a->dp, sizeof (mp_digit) * size); tmp = OPT_CAST(mp_digit) XREALLOC(a->dp, sizeof(mp_digit) * size);
if (tmp == NULL) { if (tmp == NULL) {
/* reallocation failed but "a" is still valid [can be freed] */ /* reallocation failed but "a" is still valid [can be freed] */
return MP_MEM; return MP_MEM;
} }
/* reallocation succeeded so set a->dp */ /* reallocation succeeded so set a->dp */
a->dp = tmp; a->dp = tmp;
/* zero excess digits */ /* zero excess digits */
i = a->alloc; i = a->alloc;
a->alloc = size; a->alloc = size;
for (; i < a->alloc; i++) { for (; i < a->alloc; i++) {
a->dp[i] = 0; a->dp[i] = 0;
} }
} }
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

74
bn_mp_import.c
View File

@ -18,52 +18,50 @@
/* based on gmp's mpz_import. /* based on gmp's mpz_import.
* see http://gmplib.org/manual/Integer-Import-and-Export.html * see http://gmplib.org/manual/Integer-Import-and-Export.html
*/ */
int mp_import(mp_int* rop, size_t count, int order, size_t size, int mp_import(mp_int *rop, size_t count, int order, size_t size,
int endian, size_t nails, const void* op) { int endian, size_t nails, const void *op)
int result; {
size_t odd_nails, nail_bytes, i, j; int result;
unsigned char odd_nail_mask; size_t odd_nails, nail_bytes, i, j;
unsigned char odd_nail_mask;
mp_zero(rop); mp_zero(rop);
if (endian == 0) { if (endian == 0) {
union { union {
unsigned int i; unsigned int i;
char c[4]; char c[4];
} lint; } lint;
lint.i = 0x01020304; lint.i = 0x01020304;
endian = (lint.c[0] == 4) ? -1 : 1;
}
odd_nails = (nails % 8); endian = (lint.c[0] == 4) ? -1 : 1;
odd_nail_mask = 0xff; }
for (i = 0; i < odd_nails; ++i) {
odd_nail_mask ^= (1 << (7 - i));
}
nail_bytes = nails / 8;
for (i = 0; i < count; ++i) { odd_nails = (nails % 8);
for (j = 0; j < (size - nail_bytes); ++j) { odd_nail_mask = 0xff;
unsigned char byte = *( for (i = 0; i < odd_nails; ++i) {
(unsigned char*)op + odd_nail_mask ^= (1 << (7 - i));
(((order == 1) ? i : ((count - 1) - i)) * size) + }
((endian == 1) ? (j + nail_bytes) : (((size - 1) - j) - nail_bytes)) nail_bytes = nails / 8;
);
if ( for (i = 0; i < count; ++i) {
(result = mp_mul_2d(rop, ((j == 0) ? (8 - odd_nails) : 8), rop)) != MP_OKAY) { for (j = 0; j < (size - nail_bytes); ++j) {
return result; unsigned char byte = *((unsigned char *)op +
} (((order == 1) ? i : ((count - 1) - i)) * size) +
((endian == 1) ? (j + nail_bytes) : (((size - 1) - j) - nail_bytes)));
rop->dp[0] |= (j == 0) ? (byte & odd_nail_mask) : byte; if ((result = mp_mul_2d(rop, ((j == 0) ? (8 - odd_nails) : 8), rop)) != MP_OKAY) {
rop->used += 1; return result;
} }
}
mp_clamp(rop); rop->dp[0] |= (j == 0) ? (byte & odd_nail_mask) : byte;
rop->used += 1;
}
}
return MP_OKAY; mp_clamp(rop);
return MP_OKAY;
} }
#endif #endif

32
bn_mp_init.c
View File

@ -16,28 +16,28 @@
*/ */
/* init a new mp_int */ /* init a new mp_int */
int mp_init (mp_int * a) int mp_init(mp_int *a)
{ {
int i; int i;
/* allocate memory required and clear it */ /* allocate memory required and clear it */
a->dp = OPT_CAST(mp_digit) XMALLOC (sizeof (mp_digit) * MP_PREC); a->dp = OPT_CAST(mp_digit) XMALLOC(sizeof(mp_digit) * MP_PREC);
if (a->dp == NULL) { if (a->dp == NULL) {
return MP_MEM; return MP_MEM;
} }
/* set the digits to zero */ /* set the digits to zero */
for (i = 0; i < MP_PREC; i++) { for (i = 0; i < MP_PREC; i++) {
a->dp[i] = 0; a->dp[i] = 0;
} }
/* set the used to zero, allocated digits to the default precision /* set the used to zero, allocated digits to the default precision
* and sign to positive */ * and sign to positive */
a->used = 0; a->used = 0;
a->alloc = MP_PREC; a->alloc = MP_PREC;
a->sign = MP_ZPOS; a->sign = MP_ZPOS;
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

18
bn_mp_init_copy.c
View File

@ -16,19 +16,19 @@
*/ */
/* creates "a" then copies b into it */ /* creates "a" then copies b into it */
int mp_init_copy (mp_int * a, mp_int * b) int mp_init_copy(mp_int *a, mp_int *b)
{ {
int res; int res;
if ((res = mp_init_size (a, b->used)) != MP_OKAY) { if ((res = mp_init_size(a, b->used)) != MP_OKAY) {
return res; return res;
} }
if((res = mp_copy (b, a)) != MP_OKAY) { if ((res = mp_copy(b, a)) != MP_OKAY) {
mp_clear(a); mp_clear(a);
} }
return res; return res;
} }
#endif #endif

58
bn_mp_init_multi.c
View File

@ -16,37 +16,37 @@
*/ */
#include <stdarg.h> #include <stdarg.h>
int mp_init_multi(mp_int *mp, ...) int mp_init_multi(mp_int *mp, ...)
{ {
mp_err res = MP_OKAY; /* Assume ok until proven otherwise */ mp_err res = MP_OKAY; /* Assume ok until proven otherwise */
int n = 0; /* Number of ok inits */ int n = 0; /* Number of ok inits */
mp_int* cur_arg = mp; mp_int *cur_arg = mp;
va_list args; va_list args;
va_start(args, mp); /* init args to next argument from caller */ va_start(args, mp); /* init args to next argument from caller */
while (cur_arg != NULL) { while (cur_arg != NULL) {
if (mp_init(cur_arg) != MP_OKAY) { if (mp_init(cur_arg) != MP_OKAY) {
/* Oops - error! Back-track and mp_clear what we already /* Oops - error! Back-track and mp_clear what we already
succeeded in init-ing, then return error. succeeded in init-ing, then return error.
*/ */
va_list clean_args; va_list clean_args;
/* now start cleaning up */ /* now start cleaning up */
cur_arg = mp; cur_arg = mp;
va_start(clean_args, mp); va_start(clean_args, mp);
while (n-- != 0) { while (n-- != 0) {
mp_clear(cur_arg); mp_clear(cur_arg);
cur_arg = va_arg(clean_args, mp_int*); cur_arg = va_arg(clean_args, mp_int *);
} }
va_end(clean_args); va_end(clean_args);
res = MP_MEM; res = MP_MEM;
break; break;
} }
n++; n++;
cur_arg = va_arg(args, mp_int*); cur_arg = va_arg(args, mp_int *);
} }
va_end(args); va_end(args);
return res; /* Assumed ok, if error flagged above. */ return res; /* Assumed ok, if error flagged above. */
} }
#endif #endif

14
bn_mp_init_set.c
View File

@ -16,14 +16,14 @@
*/ */
/* initialize and set a digit */ /* initialize and set a digit */
int mp_init_set (mp_int * a, mp_digit b) int mp_init_set(mp_int *a, mp_digit b)
{ {
int err; int err;
if ((err = mp_init(a)) != MP_OKAY) { if ((err = mp_init(a)) != MP_OKAY) {
return err; return err;
} }
mp_set(a, b); mp_set(a, b);
return err; return err;
} }
#endif #endif

12
bn_mp_init_set_int.c
View File

@ -16,13 +16,13 @@
*/ */
/* initialize and set a digit */ /* initialize and set a digit */
int mp_init_set_int (mp_int * a, unsigned long b) int mp_init_set_int(mp_int *a, unsigned long b)
{ {
int err; int err;
if ((err = mp_init(a)) != MP_OKAY) { if ((err = mp_init(a)) != MP_OKAY) {
return err; return err;
} }
return mp_set_int(a, b); return mp_set_int(a, b);
} }
#endif #endif

36
bn_mp_init_size.c
View File

@ -16,30 +16,30 @@
*/ */
/* init an mp_init for a given size */ /* init an mp_init for a given size */
int mp_init_size (mp_int * a, int size) int mp_init_size(mp_int *a, int size)
{ {
int x; int x;
/* pad size so there are always extra digits */ /* pad size so there are always extra digits */
size += (MP_PREC * 2) - (size % MP_PREC); size += (MP_PREC * 2) - (size % MP_PREC);
/* alloc mem */
a->dp = OPT_CAST(mp_digit) XMALLOC (sizeof (mp_digit) * size);
if (a->dp == NULL) {
return MP_MEM;
}
/* set the members */ /* alloc mem */
a->used = 0; a->dp = OPT_CAST(mp_digit) XMALLOC(sizeof(mp_digit) * size);
a->alloc = size; if (a->dp == NULL) {
a->sign = MP_ZPOS; return MP_MEM;
}
/* zero the digits */ /* set the members */
for (x = 0; x < size; x++) { a->used = 0;
a->alloc = size;
a->sign = MP_ZPOS;
/* zero the digits */
for (x = 0; x < size; x++) {
a->dp[x] = 0; a->dp[x] = 0;
} }
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

22
bn_mp_invmod.c
View File

@ -16,24 +16,24 @@
*/ */
/* hac 14.61, pp608 */ /* hac 14.61, pp608 */
int mp_invmod (mp_int * a, mp_int * b, mp_int * c) int mp_invmod(mp_int *a, mp_int *b, mp_int *c)
{ {
/* b cannot be negative */ /* b cannot be negative */
if ((b->sign == MP_NEG) || (mp_iszero(b) == MP_YES)) { if ((b->sign == MP_NEG) || (mp_iszero(b) == MP_YES)) {
return MP_VAL; return MP_VAL;
} }
#ifdef BN_FAST_MP_INVMOD_C #ifdef BN_FAST_MP_INVMOD_C
/* if the modulus is odd we can use a faster routine instead */ /* if the modulus is odd we can use a faster routine instead */
if ((mp_isodd(b) == MP_YES) && (mp_cmp_d(b, 1) != MP_EQ)) { if ((mp_isodd(b) == MP_YES) && (mp_cmp_d(b, 1) != MP_EQ)) {
return fast_mp_invmod (a, b, c); return fast_mp_invmod(a, b, c);
} }
#endif #endif
#ifdef BN_MP_INVMOD_SLOW_C #ifdef BN_MP_INVMOD_SLOW_C
return mp_invmod_slow(a, b, c); return mp_invmod_slow(a, b, c);
#else #else
return MP_VAL; return MP_VAL;
#endif #endif
} }
#endif #endif

253
bn_mp_invmod_slow.c
View File

@ -16,157 +16,158 @@
*/ */
/* hac 14.61, pp608 */ /* hac 14.61, pp608 */
int mp_invmod_slow (mp_int * a, mp_int * b, mp_int * c) int mp_invmod_slow(mp_int *a, mp_int *b, mp_int *c)
{ {
mp_int x, y, u, v, A, B, C, D; mp_int x, y, u, v, A, B, C, D;
int res; int res;
/* b cannot be negative */ /* b cannot be negative */
if ((b->sign == MP_NEG) || (mp_iszero(b) == MP_YES)) { if ((b->sign == MP_NEG) || (mp_iszero(b) == MP_YES)) {
return MP_VAL; return MP_VAL;
} }
/* init temps */ /* init temps */
if ((res = mp_init_multi(&x, &y, &u, &v, if ((res = mp_init_multi(&x, &y, &u, &v,
&A, &B, &C, &D, NULL)) != MP_OKAY) { &A, &B, &C, &D, NULL)) != MP_OKAY) {
return res; return res;
} }
/* x = a, y = b */ /* x = a, y = b */
if ((res = mp_mod(a, b, &x)) != MP_OKAY) { if ((res = mp_mod(a, b, &x)) != MP_OKAY) {
goto LBL_ERR; goto LBL_ERR;
} }
if ((res = mp_copy (b, &y)) != MP_OKAY) { if ((res = mp_copy(b, &y)) != MP_OKAY) {
goto LBL_ERR; goto LBL_ERR;
} }
/* 2. [modified] if x,y are both even then return an error! */ /* 2. [modified] if x,y are both even then return an error! */
if ((mp_iseven (&x) == MP_YES) && (mp_iseven (&y) == MP_YES)) { if ((mp_iseven(&x) == MP_YES) && (mp_iseven(&y) == MP_YES)) {
res = MP_VAL; res = MP_VAL;
goto LBL_ERR; goto LBL_ERR;
} }
/* 3. u=x, v=y, A=1, B=0, C=0,D=1 */ /* 3. u=x, v=y, A=1, B=0, C=0,D=1 */
if ((res = mp_copy (&x, &u)) != MP_OKAY) { if ((res = mp_copy(&x, &u)) != MP_OKAY) {
goto LBL_ERR; goto LBL_ERR;
} }
if ((res = mp_copy (&y, &v)) != MP_OKAY) { if ((res = mp_copy(&y, &v)) != MP_OKAY) {
goto LBL_ERR; goto LBL_ERR;
} }
mp_set (&A, 1); mp_set(&A, 1);
mp_set (&D, 1); mp_set(&D, 1);
top: top:
/* 4. while u is even do */ /* 4. while u is even do */
while (mp_iseven (&u) == MP_YES) { while (mp_iseven(&u) == MP_YES) {
/* 4.1 u = u/2 */ /* 4.1 u = u/2 */
if ((res = mp_div_2 (&u, &u)) != MP_OKAY) { if ((res = mp_div_2(&u, &u)) != MP_OKAY) {
goto LBL_ERR;
}
/* 4.2 if A or B is odd then */
if ((mp_isodd (&A) == MP_YES) || (mp_isodd (&B) == MP_YES)) {
/* A = (A+y)/2, B = (B-x)/2 */
if ((res = mp_add (&A, &y, &A)) != MP_OKAY) {
goto LBL_ERR; goto LBL_ERR;
} }
if ((res = mp_sub (&B, &x, &B)) != MP_OKAY) { /* 4.2 if A or B is odd then */
if ((mp_isodd(&A) == MP_YES) || (mp_isodd(&B) == MP_YES)) {
/* A = (A+y)/2, B = (B-x)/2 */
if ((res = mp_add(&A, &y, &A)) != MP_OKAY) {
goto LBL_ERR;
}
if ((res = mp_sub(&B, &x, &B)) != MP_OKAY) {
goto LBL_ERR;
}
}
/* A = A/2, B = B/2 */
if ((res = mp_div_2(&A, &A)) != MP_OKAY) {
goto LBL_ERR; goto LBL_ERR;
} }
} if ((res = mp_div_2(&B, &B)) != MP_OKAY) {
/* A = A/2, B = B/2 */
if ((res = mp_div_2 (&A, &A)) != MP_OKAY) {
goto LBL_ERR;
}
if ((res = mp_div_2 (&B, &B)) != MP_OKAY) {
goto LBL_ERR;
}
}
/* 5. while v is even do */
while (mp_iseven (&v) == MP_YES) {
/* 5.1 v = v/2 */
if ((res = mp_div_2 (&v, &v)) != MP_OKAY) {
goto LBL_ERR;
}
/* 5.2 if C or D is odd then */
if ((mp_isodd (&C) == MP_YES) || (mp_isodd (&D) == MP_YES)) {
/* C = (C+y)/2, D = (D-x)/2 */
if ((res = mp_add (&C, &y, &C)) != MP_OKAY) {
goto LBL_ERR; goto LBL_ERR;
} }
if ((res = mp_sub (&D, &x, &D)) != MP_OKAY) { }
/* 5. while v is even do */
while (mp_iseven(&v) == MP_YES) {
/* 5.1 v = v/2 */
if ((res = mp_div_2(&v, &v)) != MP_OKAY) {
goto LBL_ERR; goto LBL_ERR;
} }
} /* 5.2 if C or D is odd then */
/* C = C/2, D = D/2 */ if ((mp_isodd(&C) == MP_YES) || (mp_isodd(&D) == MP_YES)) {
if ((res = mp_div_2 (&C, &C)) != MP_OKAY) { /* C = (C+y)/2, D = (D-x)/2 */
if ((res = mp_add(&C, &y, &C)) != MP_OKAY) {
goto LBL_ERR;
}
if ((res = mp_sub(&D, &x, &D)) != MP_OKAY) {
goto LBL_ERR;
}
}
/* C = C/2, D = D/2 */
if ((res = mp_div_2(&C, &C)) != MP_OKAY) {
goto LBL_ERR;
}
if ((res = mp_div_2(&D, &D)) != MP_OKAY) {
goto LBL_ERR;
}
}
/* 6. if u >= v then */
if (mp_cmp(&u, &v) != MP_LT) {
/* u = u - v, A = A - C, B = B - D */
if ((res = mp_sub(&u, &v, &u)) != MP_OKAY) {
goto LBL_ERR;
}
if ((res = mp_sub(&A, &C, &A)) != MP_OKAY) {
goto LBL_ERR;
}
if ((res = mp_sub(&B, &D, &B)) != MP_OKAY) {
goto LBL_ERR;
}
} else {
/* v - v - u, C = C - A, D = D - B */
if ((res = mp_sub(&v, &u, &v)) != MP_OKAY) {
goto LBL_ERR;
}
if ((res = mp_sub(&C, &A, &C)) != MP_OKAY) {
goto LBL_ERR;
}
if ((res = mp_sub(&D, &B, &D)) != MP_OKAY) {
goto LBL_ERR;
}
}
/* if not zero goto step 4 */
if (mp_iszero(&u) == MP_NO)
goto top;
/* now a = C, b = D, gcd == g*v */
/* if v != 1 then there is no inverse */
if (mp_cmp_d(&v, 1) != MP_EQ) {
res = MP_VAL;
goto LBL_ERR; goto LBL_ERR;
} }
if ((res = mp_div_2 (&D, &D)) != MP_OKAY) {
goto LBL_ERR;
}
}
/* 6. if u >= v then */ /* if its too low */
if (mp_cmp (&u, &v) != MP_LT) { while (mp_cmp_d(&C, 0) == MP_LT) {
/* u = u - v, A = A - C, B = B - D */
if ((res = mp_sub (&u, &v, &u)) != MP_OKAY) {
goto LBL_ERR;
}
if ((res = mp_sub (&A, &C, &A)) != MP_OKAY) {
goto LBL_ERR;
}
if ((res = mp_sub (&B, &D, &B)) != MP_OKAY) {
goto LBL_ERR;
}
} else {
/* v - v - u, C = C - A, D = D - B */
if ((res = mp_sub (&v, &u, &v)) != MP_OKAY) {
goto LBL_ERR;
}
if ((res = mp_sub (&C, &A, &C)) != MP_OKAY) {
goto LBL_ERR;
}
if ((res = mp_sub (&D, &B, &D)) != MP_OKAY) {
goto LBL_ERR;
}
}
/* if not zero goto step 4 */
if (mp_iszero (&u) == MP_NO)
goto top;
/* now a = C, b = D, gcd == g*v */
/* if v != 1 then there is no inverse */
if (mp_cmp_d (&v, 1) != MP_EQ) {
res = MP_VAL;
goto LBL_ERR;
}
/* if its too low */
while (mp_cmp_d(&C, 0) == MP_LT) {
if ((res = mp_add(&C, b, &C)) != MP_OKAY) { if ((res = mp_add(&C, b, &C)) != MP_OKAY) {
goto LBL_ERR; goto LBL_ERR;
} }
} }
/* too big */ /* too big */
while (mp_cmp_mag(&C, b) != MP_LT) { while (mp_cmp_mag(&C, b) != MP_LT) {
if ((res = mp_sub(&C, b, &C)) != MP_OKAY) { if ((res = mp_sub(&C, b, &C)) != MP_OKAY) {
goto LBL_ERR; goto LBL_ERR;
} }
} }
/* C is now the inverse */ /* C is now the inverse */
mp_exch (&C, c); mp_exch(&C, c);
res = MP_OKAY; res = MP_OKAY;
LBL_ERR:mp_clear_multi (&x, &y, &u, &v, &A, &B, &C, &D, NULL); LBL_ERR:
return res; mp_clear_multi(&x, &y, &u, &v, &A, &B, &C, &D, NULL);
return res;
} }
#endif #endif

137
bn_mp_is_square.c
View File

@ -17,90 +17,91 @@
/* Check if remainders are possible squares - fast exclude non-squares */ /* Check if remainders are possible squares - fast exclude non-squares */
static const char rem_128[128] = { static const char rem_128[128] = {
0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1
}; };
static const char rem_105[105] = { static const char rem_105[105] = {
0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1,
0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1,
1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,
0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,
1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1,
1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1
}; };
/* Store non-zero to ret if arg is square, and zero if not */ /* Store non-zero to ret if arg is square, and zero if not */
int mp_is_square(mp_int *arg,int *ret) int mp_is_square(mp_int *arg, int *ret)
{ {
int res; int res;
mp_digit c; mp_digit c;
mp_int t; mp_int t;
unsigned long r; unsigned long r;
/* Default to Non-square :) */ /* Default to Non-square :) */
*ret = MP_NO; *ret = MP_NO;
if (arg->sign == MP_NEG) { if (arg->sign == MP_NEG) {
return MP_VAL; return MP_VAL;
} }
/* digits used? (TSD) */ /* digits used? (TSD) */
if (arg->used == 0) { if (arg->used == 0) {
return MP_OKAY; return MP_OKAY;
} }
/* First check mod 128 (suppose that DIGIT_BIT is at least 7) */ /* First check mod 128 (suppose that DIGIT_BIT is at least 7) */
if (rem_128[127 & DIGIT(arg,0)] == 1) { if (rem_128[127 & DIGIT(arg, 0)] == 1) {
return MP_OKAY; return MP_OKAY;
} }
/* Next check mod 105 (3*5*7) */ /* Next check mod 105 (3*5*7) */
if ((res = mp_mod_d(arg,105,&c)) != MP_OKAY) { if ((res = mp_mod_d(arg, 105, &c)) != MP_OKAY) {
return res; return res;
} }
if (rem_105[c] == 1) { if (rem_105[c] == 1) {
return MP_OKAY; return MP_OKAY;
} }
if ((res = mp_init_set_int(&t,11L*13L*17L*19L*23L*29L*31L)) != MP_OKAY) { if ((res = mp_init_set_int(&t, 11L*13L*17L*19L*23L*29L*31L)) != MP_OKAY) {
return res; return res;
} }
if ((res = mp_mod(arg,&t,&t)) != MP_OKAY) { if ((res = mp_mod(arg, &t, &t)) != MP_OKAY) {
goto ERR; goto ERR;
} }
r = mp_get_int(&t); r = mp_get_int(&t);
/* Check for other prime modules, note it's not an ERROR but we must /* Check for other prime modules, note it's not an ERROR but we must
* free "t" so the easiest way is to goto ERR. We know that res * free "t" so the easiest way is to goto ERR. We know that res
* is already equal to MP_OKAY from the mp_mod call * is already equal to MP_OKAY from the mp_mod call
*/ */
if (((1L<<(r%11)) & 0x5C4L) != 0L) goto ERR; if (((1L<<(r%11)) & 0x5C4L) != 0L) goto ERR;
if (((1L<<(r%13)) & 0x9E4L) != 0L) goto ERR; if (((1L<<(r%13)) & 0x9E4L) != 0L) goto ERR;
if (((1L<<(r%17)) & 0x5CE8L) != 0L) goto ERR; if (((1L<<(r%17)) & 0x5CE8L) != 0L) goto ERR;
if (((1L<<(r%19)) & 0x4F50CL) != 0L) goto ERR; if (((1L<<(r%19)) & 0x4F50CL) != 0L) goto ERR;
if (((1L<<(r%23)) & 0x7ACCA0L) != 0L) goto ERR; if (((1L<<(r%23)) & 0x7ACCA0L) != 0L) goto ERR;
if (((1L<<(r%29)) & 0xC2EDD0CL) != 0L) goto ERR; if (((1L<<(r%29)) & 0xC2EDD0CL) != 0L) goto ERR;
if (((1L<<(r%31)) & 0x6DE2B848L) != 0L) goto ERR; if (((1L<<(r%31)) & 0x6DE2B848L) != 0L) goto ERR;
/* Final check - is sqr(sqrt(arg)) == arg ? */ /* Final check - is sqr(sqrt(arg)) == arg ? */
if ((res = mp_sqrt(arg,&t)) != MP_OKAY) { if ((res = mp_sqrt(arg, &t)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_sqr(&t,&t)) != MP_OKAY) { if ((res = mp_sqr(&t, &t)) != MP_OKAY) {
goto ERR; goto ERR;
} }
*ret = (mp_cmp_mag(&t,arg) == MP_EQ) ? MP_YES : MP_NO; *ret = (mp_cmp_mag(&t, arg) == MP_EQ) ? MP_YES : MP_NO;
ERR:mp_clear(&t); ERR:
return res; mp_clear(&t);
return res;
} }
#endif #endif

152
bn_mp_jacobi.c
View File

@ -20,95 +20,97 @@
* HAC is wrong here, as the special case of (0 | 1) is not * HAC is wrong here, as the special case of (0 | 1) is not
* handled correctly. * handled correctly.
*/ */
int mp_jacobi (mp_int * a, mp_int * n, int *c) int mp_jacobi(mp_int *a, mp_int *n, int *c)
{ {
mp_int a1, p1; mp_int a1, p1;
int k, s, r, res; int k, s, r, res;
mp_digit residue; mp_digit residue;
/* if a < 0 return MP_VAL */ /* if a < 0 return MP_VAL */
if (mp_isneg(a) == MP_YES) { if (mp_isneg(a) == MP_YES) {
return MP_VAL; return MP_VAL;
} }
/* if n <= 0 return MP_VAL */ /* if n <= 0 return MP_VAL */
if (mp_cmp_d(n, 0) != MP_GT) { if (mp_cmp_d(n, 0) != MP_GT) {
return MP_VAL; return MP_VAL;
} }
/* step 1. handle case of a == 0 */ /* step 1. handle case of a == 0 */
if (mp_iszero (a) == MP_YES) { if (mp_iszero(a) == MP_YES) {
/* special case of a == 0 and n == 1 */ /* special case of a == 0 and n == 1 */
if (mp_cmp_d (n, 1) == MP_EQ) { if (mp_cmp_d(n, 1) == MP_EQ) {
*c = 1; *c = 1;
} else { } else {
*c = 0; *c = 0;
} }
return MP_OKAY; return MP_OKAY;
} }
/* step 2. if a == 1, return 1 */ /* step 2. if a == 1, return 1 */
if (mp_cmp_d (a, 1) == MP_EQ) { if (mp_cmp_d(a, 1) == MP_EQ) {
*c = 1; *c = 1;
return MP_OKAY; return MP_OKAY;
} }
/* default */ /* default */
s = 0; s = 0;
/* step 3. write a = a1 * 2**k */ /* step 3. write a = a1 * 2**k */
if ((res = mp_init_copy (&a1, a)) != MP_OKAY) { if ((res = mp_init_copy(&a1, a)) != MP_OKAY) {
return res; return res;
} }
if ((res = mp_init (&p1)) != MP_OKAY) { if ((res = mp_init(&p1)) != MP_OKAY) {
goto LBL_A1; goto LBL_A1;
} }
/* divide out larger power of two */ /* divide out larger power of two */
k = mp_cnt_lsb(&a1); k = mp_cnt_lsb(&a1);
if ((res = mp_div_2d(&a1, k, &a1, NULL)) != MP_OKAY) { if ((res = mp_div_2d(&a1, k, &a1, NULL)) != MP_OKAY) {
goto LBL_P1; goto LBL_P1;
} }
/* step 4. if e is even set s=1 */ /* step 4. if e is even set s=1 */
if ((k & 1) == 0) { if ((k & 1) == 0) {
s = 1;
} else {
/* else set s=1 if p = 1/7 (mod 8) or s=-1 if p = 3/5 (mod 8) */
residue = n->dp[0] & 7;
if ((residue == 1) || (residue == 7)) {
s = 1; s = 1;
} else if ((residue == 3) || (residue == 5)) { } else {
s = -1; /* else set s=1 if p = 1/7 (mod 8) or s=-1 if p = 3/5 (mod 8) */
} residue = n->dp[0] & 7;
}
/* step 5. if p == 3 (mod 4) *and* a1 == 3 (mod 4) then s = -s */ if ((residue == 1) || (residue == 7)) {
if ( ((n->dp[0] & 3) == 3) && ((a1.dp[0] & 3) == 3)) { s = 1;
s = -s; } else if ((residue == 3) || (residue == 5)) {
} s = -1;
}
}
/* if a1 == 1 we're done */ /* step 5. if p == 3 (mod 4) *and* a1 == 3 (mod 4) then s = -s */
if (mp_cmp_d (&a1, 1) == MP_EQ) { if (((n->dp[0] & 3) == 3) && ((a1.dp[0] & 3) == 3)) {
*c = s; s = -s;
} else { }
/* n1 = n mod a1 */
if ((res = mp_mod (n, &a1, &p1)) != MP_OKAY) {
goto LBL_P1;
}
if ((res = mp_jacobi (&p1, &a1, &r)) != MP_OKAY) {
goto LBL_P1;
}
*c = s * r;
}
/* done */ /* if a1 == 1 we're done */
res = MP_OKAY; if (mp_cmp_d(&a1, 1) == MP_EQ) {
LBL_P1:mp_clear (&p1); *c = s;
LBL_A1:mp_clear (&a1); } else {
return res; /* n1 = n mod a1 */
if ((res = mp_mod(n, &a1, &p1)) != MP_OKAY) {
goto LBL_P1;
}
if ((res = mp_jacobi(&p1, &a1, &r)) != MP_OKAY) {
goto LBL_P1;
}
*c = s * r;
}
/* done */
res = MP_OKAY;
LBL_P1:
mp_clear(&p1);
LBL_A1:
mp_clear(&a1);
return res;
} }
#endif #endif

225
bn_mp_karatsuba_mul.c
View File

@ -15,150 +15,157 @@
* Tom St Denis, tstdenis82@gmail.com, http://libtom.org * Tom St Denis, tstdenis82@gmail.com, http://libtom.org
*/ */
/* c = |a| * |b| using Karatsuba Multiplication using /* c = |a| * |b| using Karatsuba Multiplication using
* three half size multiplications * three half size multiplications
* *
* Let B represent the radix [e.g. 2**DIGIT_BIT] and * Let B represent the radix [e.g. 2**DIGIT_BIT] and
* let n represent half of the number of digits in * let n represent half of the number of digits in
* the min(a,b) * the min(a,b)
* *
* a = a1 * B**n + a0 * a = a1 * B**n + a0
* b = b1 * B**n + b0 * b = b1 * B**n + b0
* *
* Then, a * b => * Then, a * b =>
a1b1 * B**2n + ((a1 + a0)(b1 + b0) - (a0b0 + a1b1)) * B + a0b0 a1b1 * B**2n + ((a1 + a0)(b1 + b0) - (a0b0 + a1b1)) * B + a0b0
* *
* Note that a1b1 and a0b0 are used twice and only need to be * Note that a1b1 and a0b0 are used twice and only need to be
* computed once. So in total three half size (half # of * computed once. So in total three half size (half # of
* digit) multiplications are performed, a0b0, a1b1 and * digit) multiplications are performed, a0b0, a1b1 and
* (a1+b1)(a0+b0) * (a1+b1)(a0+b0)
* *
* Note that a multiplication of half the digits requires * Note that a multiplication of half the digits requires
* 1/4th the number of single precision multiplications so in * 1/4th the number of single precision multiplications so in
* total after one call 25% of the single precision multiplications * total after one call 25% of the single precision multiplications
* are saved. Note also that the call to mp_mul can end up back * are saved. Note also that the call to mp_mul can end up back
* in this function if the a0, a1, b0, or b1 are above the threshold. * in this function if the a0, a1, b0, or b1 are above the threshold.
* This is known as divide-and-conquer and leads to the famous * This is known as divide-and-conquer and leads to the famous
* O(N**lg(3)) or O(N**1.584) work which is asymptopically lower than * O(N**lg(3)) or O(N**1.584) work which is asymptopically lower than
* the standard O(N**2) that the baseline/comba methods use. * the standard O(N**2) that the baseline/comba methods use.
* Generally though the overhead of this method doesn't pay off * Generally though the overhead of this method doesn't pay off
* until a certain size (N ~ 80) is reached. * until a certain size (N ~ 80) is reached.
*/ */
int mp_karatsuba_mul (mp_int * a, mp_int * b, mp_int * c) int mp_karatsuba_mul(mp_int *a, mp_int *b, mp_int *c)
{ {
mp_int x0, x1, y0, y1, t1, x0y0, x1y1; mp_int x0, x1, y0, y1, t1, x0y0, x1y1;
int B, err; int B, err;
/* default the return code to an error */ /* default the return code to an error */
err = MP_MEM; err = MP_MEM;
/* min # of digits */ /* min # of digits */
B = MIN (a->used, b->used); B = MIN(a->used, b->used);
/* now divide in two */ /* now divide in two */
B = B >> 1; B = B >> 1;
/* init copy all the temps */ /* init copy all the temps */
if (mp_init_size (&x0, B) != MP_OKAY) if (mp_init_size(&x0, B) != MP_OKAY)
goto ERR; goto ERR;
if (mp_init_size (&x1, a->used - B) != MP_OKAY) if (mp_init_size(&x1, a->used - B) != MP_OKAY)
goto X0; goto X0;
if (mp_init_size (&y0, B) != MP_OKAY) if (mp_init_size(&y0, B) != MP_OKAY)
goto X1; goto X1;
if (mp_init_size (&y1, b->used - B) != MP_OKAY) if (mp_init_size(&y1, b->used - B) != MP_OKAY)
goto Y0; goto Y0;
/* init temps */ /* init temps */
if (mp_init_size (&t1, B * 2) != MP_OKAY) if (mp_init_size(&t1, B * 2) != MP_OKAY)
goto Y1; goto Y1;
if (mp_init_size (&x0y0, B * 2) != MP_OKAY) if (mp_init_size(&x0y0, B * 2) != MP_OKAY)
goto T1; goto T1;
if (mp_init_size (&x1y1, B * 2) != MP_OKAY) if (mp_init_size(&x1y1, B * 2) != MP_OKAY)
goto X0Y0; goto X0Y0;
/* now shift the digits */ /* now shift the digits */
x0.used = y0.used = B; x0.used = y0.used = B;
x1.used = a->used - B; x1.used = a->used - B;
y1.used = b->used - B; y1.used = b->used - B;
{ {
int x; int x;
mp_digit *tmpa, *tmpb, *tmpx, *tmpy; mp_digit *tmpa, *tmpb, *tmpx, *tmpy;
/* we copy the digits directly instead of using higher level functions /* we copy the digits directly instead of using higher level functions
* since we also need to shift the digits * since we also need to shift the digits
*/ */
tmpa = a->dp; tmpa = a->dp;
tmpb = b->dp; tmpb = b->dp;
tmpx = x0.dp; tmpx = x0.dp;
tmpy = y0.dp; tmpy = y0.dp;
for (x = 0; x < B; x++) { for (x = 0; x < B; x++) {
*tmpx++ = *tmpa++; *tmpx++ = *tmpa++;
*tmpy++ = *tmpb++; *tmpy++ = *tmpb++;
} }
tmpx = x1.dp; tmpx = x1.dp;
for (x = B; x < a->used; x++) { for (x = B; x < a->used; x++) {
*tmpx++ = *tmpa++; *tmpx++ = *tmpa++;
} }
tmpy = y1.dp; tmpy = y1.dp;
for (x = B; x < b->used; x++) { for (x = B; x < b->used; x++) {
*tmpy++ = *tmpb++; *tmpy++ = *tmpb++;
} }
} }
/* only need to clamp the lower words since by definition the /* only need to clamp the lower words since by definition the
* upper words x1/y1 must have a known number of digits * upper words x1/y1 must have a known number of digits
*/ */
mp_clamp (&x0); mp_clamp(&x0);
mp_clamp (&y0); mp_clamp(&y0);
/* now calc the products x0y0 and x1y1 */ /* now calc the products x0y0 and x1y1 */
/* after this x0 is no longer required, free temp [x0==t2]! */ /* after this x0 is no longer required, free temp [x0==t2]! */
if (mp_mul (&x0, &y0, &x0y0) != MP_OKAY) if (mp_mul(&x0, &y0, &x0y0) != MP_OKAY)
goto X1Y1; /* x0y0 = x0*y0 */ goto X1Y1; /* x0y0 = x0*y0 */
if (mp_mul (&x1, &y1, &x1y1) != MP_OKAY) if (mp_mul(&x1, &y1, &x1y1) != MP_OKAY)
goto X1Y1; /* x1y1 = x1*y1 */ goto X1Y1; /* x1y1 = x1*y1 */
/* now calc x1+x0 and y1+y0 */ /* now calc x1+x0 and y1+y0 */
if (s_mp_add (&x1, &x0, &t1) != MP_OKAY) if (s_mp_add(&x1, &x0, &t1) != MP_OKAY)
goto X1Y1; /* t1 = x1 - x0 */ goto X1Y1; /* t1 = x1 - x0 */
if (s_mp_add (&y1, &y0, &x0) != MP_OKAY) if (s_mp_add(&y1, &y0, &x0) != MP_OKAY)
goto X1Y1; /* t2 = y1 - y0 */ goto X1Y1; /* t2 = y1 - y0 */
if (mp_mul (&t1, &x0, &t1) != MP_OKAY) if (mp_mul(&t1, &x0, &t1) != MP_OKAY)
goto X1Y1; /* t1 = (x1 + x0) * (y1 + y0) */ goto X1Y1; /* t1 = (x1 + x0) * (y1 + y0) */
/* add x0y0 */ /* add x0y0 */
if (mp_add (&x0y0, &x1y1, &x0) != MP_OKAY) if (mp_add(&x0y0, &x1y1, &x0) != MP_OKAY)
goto X1Y1; /* t2 = x0y0 + x1y1 */ goto X1Y1; /* t2 = x0y0 + x1y1 */
if (s_mp_sub (&t1, &x0, &t1) != MP_OKAY) if (s_mp_sub(&t1, &x0, &t1) != MP_OKAY)
goto X1Y1; /* t1 = (x1+x0)*(y1+y0) - (x1y1 + x0y0) */ goto X1Y1; /* t1 = (x1+x0)*(y1+y0) - (x1y1 + x0y0) */
/* shift by B */ /* shift by B */
if (mp_lshd (&t1, B) != MP_OKAY) if (mp_lshd(&t1, B) != MP_OKAY)
goto X1Y1; /* t1 = (x0y0 + x1y1 - (x1-x0)*(y1-y0))<<B */ goto X1Y1; /* t1 = (x0y0 + x1y1 - (x1-x0)*(y1-y0))<<B */
if (mp_lshd (&x1y1, B * 2) != MP_OKAY) if (mp_lshd(&x1y1, B * 2) != MP_OKAY)
goto X1Y1; /* x1y1 = x1y1 << 2*B */ goto X1Y1; /* x1y1 = x1y1 << 2*B */
if (mp_add (&x0y0, &t1, &t1) != MP_OKAY) if (mp_add(&x0y0, &t1, &t1) != MP_OKAY)
goto X1Y1; /* t1 = x0y0 + t1 */ goto X1Y1; /* t1 = x0y0 + t1 */
if (mp_add (&t1, &x1y1, c) != MP_OKAY) if (mp_add(&t1, &x1y1, c) != MP_OKAY)
goto X1Y1; /* t1 = x0y0 + t1 + x1y1 */ goto X1Y1; /* t1 = x0y0 + t1 + x1y1 */
/* Algorithm succeeded set the return code to MP_OKAY */ /* Algorithm succeeded set the return code to MP_OKAY */
err = MP_OKAY; err = MP_OKAY;
X1Y1:mp_clear (&x1y1); X1Y1:
X0Y0:mp_clear (&x0y0); mp_clear(&x1y1);
T1:mp_clear (&t1); X0Y0:
Y1:mp_clear (&y1); mp_clear(&x0y0);
Y0:mp_clear (&y0); T1:
X1:mp_clear (&x1); mp_clear(&t1);
X0:mp_clear (&x0); Y1:
mp_clear(&y1);
Y0:
mp_clear(&y0);
X1:
mp_clear(&x1);
X0:
mp_clear(&x0);
ERR: ERR:
return err; return err;
} }
#endif #endif

154
bn_mp_karatsuba_sqr.c
View File

@ -15,104 +15,110 @@
* Tom St Denis, tstdenis82@gmail.com, http://libtom.org * Tom St Denis, tstdenis82@gmail.com, http://libtom.org
*/ */
/* Karatsuba squaring, computes b = a*a using three /* Karatsuba squaring, computes b = a*a using three
* half size squarings * half size squarings
* *
* See comments of karatsuba_mul for details. It * See comments of karatsuba_mul for details. It
* is essentially the same algorithm but merely * is essentially the same algorithm but merely
* tuned to perform recursive squarings. * tuned to perform recursive squarings.
*/ */
int mp_karatsuba_sqr (mp_int * a, mp_int * b) int mp_karatsuba_sqr(mp_int *a, mp_int *b)
{ {
mp_int x0, x1, t1, t2, x0x0, x1x1; mp_int x0, x1, t1, t2, x0x0, x1x1;
int B, err; int B, err;
err = MP_MEM; err = MP_MEM;
/* min # of digits */ /* min # of digits */
B = a->used; B = a->used;
/* now divide in two */ /* now divide in two */
B = B >> 1; B = B >> 1;
/* init copy all the temps */ /* init copy all the temps */
if (mp_init_size (&x0, B) != MP_OKAY) if (mp_init_size(&x0, B) != MP_OKAY)
goto ERR; goto ERR;
if (mp_init_size (&x1, a->used - B) != MP_OKAY) if (mp_init_size(&x1, a->used - B) != MP_OKAY)
goto X0; goto X0;
/* init temps */ /* init temps */
if (mp_init_size (&t1, a->used * 2) != MP_OKAY) if (mp_init_size(&t1, a->used * 2) != MP_OKAY)
goto X1; goto X1;
if (mp_init_size (&t2, a->used * 2) != MP_OKAY) if (mp_init_size(&t2, a->used * 2) != MP_OKAY)
goto T1; goto T1;
if (mp_init_size (&x0x0, B * 2) != MP_OKAY) if (mp_init_size(&x0x0, B * 2) != MP_OKAY)
goto T2; goto T2;
if (mp_init_size (&x1x1, (a->used - B) * 2) != MP_OKAY) if (mp_init_size(&x1x1, (a->used - B) * 2) != MP_OKAY)
goto X0X0; goto X0X0;
{ {
int x; int x;
mp_digit *dst, *src; mp_digit *dst, *src;
src = a->dp; src = a->dp;
/* now shift the digits */ /* now shift the digits */
dst = x0.dp; dst = x0.dp;
for (x = 0; x < B; x++) { for (x = 0; x < B; x++) {
*dst++ = *src++; *dst++ = *src++;
} }
dst = x1.dp; dst = x1.dp;
for (x = B; x < a->used; x++) { for (x = B; x < a->used; x++) {
*dst++ = *src++; *dst++ = *src++;
} }
} }
x0.used = B; x0.used = B;
x1.used = a->used - B; x1.used = a->used - B;
mp_clamp (&x0); mp_clamp(&x0);
/* now calc the products x0*x0 and x1*x1 */ /* now calc the products x0*x0 and x1*x1 */
if (mp_sqr (&x0, &x0x0) != MP_OKAY) if (mp_sqr(&x0, &x0x0) != MP_OKAY)
goto X1X1; /* x0x0 = x0*x0 */ goto X1X1; /* x0x0 = x0*x0 */
if (mp_sqr (&x1, &x1x1) != MP_OKAY) if (mp_sqr(&x1, &x1x1) != MP_OKAY)
goto X1X1; /* x1x1 = x1*x1 */ goto X1X1; /* x1x1 = x1*x1 */
/* now calc (x1+x0)**2 */ /* now calc (x1+x0)**2 */
if (s_mp_add (&x1, &x0, &t1) != MP_OKAY) if (s_mp_add(&x1, &x0, &t1) != MP_OKAY)
goto X1X1; /* t1 = x1 - x0 */ goto X1X1; /* t1 = x1 - x0 */
if (mp_sqr (&t1, &t1) != MP_OKAY) if (mp_sqr(&t1, &t1) != MP_OKAY)
goto X1X1; /* t1 = (x1 - x0) * (x1 - x0) */ goto X1X1; /* t1 = (x1 - x0) * (x1 - x0) */
/* add x0y0 */ /* add x0y0 */
if (s_mp_add (&x0x0, &x1x1, &t2) != MP_OKAY) if (s_mp_add(&x0x0, &x1x1, &t2) != MP_OKAY)
goto X1X1; /* t2 = x0x0 + x1x1 */ goto X1X1; /* t2 = x0x0 + x1x1 */
if (s_mp_sub (&t1, &t2, &t1) != MP_OKAY) if (s_mp_sub(&t1, &t2, &t1) != MP_OKAY)
goto X1X1; /* t1 = (x1+x0)**2 - (x0x0 + x1x1) */ goto X1X1; /* t1 = (x1+x0)**2 - (x0x0 + x1x1) */
/* shift by B */ /* shift by B */
if (mp_lshd (&t1, B) != MP_OKAY) if (mp_lshd(&t1, B) != MP_OKAY)
goto X1X1; /* t1 = (x0x0 + x1x1 - (x1-x0)*(x1-x0))<<B */ goto X1X1; /* t1 = (x0x0 + x1x1 - (x1-x0)*(x1-x0))<<B */
if (mp_lshd (&x1x1, B * 2) != MP_OKAY) if (mp_lshd(&x1x1, B * 2) != MP_OKAY)
goto X1X1; /* x1x1 = x1x1 << 2*B */ goto X1X1; /* x1x1 = x1x1 << 2*B */
if (mp_add (&x0x0, &t1, &t1) != MP_OKAY) if (mp_add(&x0x0, &t1, &t1) != MP_OKAY)
goto X1X1; /* t1 = x0x0 + t1 */ goto X1X1; /* t1 = x0x0 + t1 */
if (mp_add (&t1, &x1x1, b) != MP_OKAY) if (mp_add(&t1, &x1x1, b) != MP_OKAY)
goto X1X1; /* t1 = x0x0 + t1 + x1x1 */ goto X1X1; /* t1 = x0x0 + t1 + x1x1 */
err = MP_OKAY; err = MP_OKAY;
X1X1:mp_clear (&x1x1); X1X1:
X0X0:mp_clear (&x0x0); mp_clear(&x1x1);
T2:mp_clear (&t2); X0X0:
T1:mp_clear (&t1); mp_clear(&x0x0);
X1:mp_clear (&x1); T2:
X0:mp_clear (&x0); mp_clear(&t2);
T1:
mp_clear(&t1);
X1:
mp_clear(&x1);
X0:
mp_clear(&x0);
ERR: ERR:
return err; return err;
} }
#endif #endif

56
bn_mp_lcm.c
View File

@ -16,42 +16,42 @@
*/ */
/* computes least common multiple as |a*b|/(a, b) */ /* computes least common multiple as |a*b|/(a, b) */
int mp_lcm (mp_int * a, mp_int * b, mp_int * c) int mp_lcm(mp_int *a, mp_int *b, mp_int *c)
{ {
int res; int res;
mp_int t1, t2; mp_int t1, t2;
if ((res = mp_init_multi (&t1, &t2, NULL)) != MP_OKAY) { if ((res = mp_init_multi(&t1, &t2, NULL)) != MP_OKAY) {
return res; return res;
} }
/* t1 = get the GCD of the two inputs */ /* t1 = get the GCD of the two inputs */
if ((res = mp_gcd (a, b, &t1)) != MP_OKAY) { if ((res = mp_gcd(a, b, &t1)) != MP_OKAY) {
goto LBL_T; goto LBL_T;
} }
/* divide the smallest by the GCD */ /* divide the smallest by the GCD */
if (mp_cmp_mag(a, b) == MP_LT) { if (mp_cmp_mag(a, b) == MP_LT) {
/* store quotient in t2 such that t2 * b is the LCM */ /* store quotient in t2 such that t2 * b is the LCM */
if ((res = mp_div(a, &t1, &t2, NULL)) != MP_OKAY) { if ((res = mp_div(a, &t1, &t2, NULL)) != MP_OKAY) {
goto LBL_T; goto LBL_T;
} }
res = mp_mul(b, &t2, c); res = mp_mul(b, &t2, c);
} else { } else {
/* store quotient in t2 such that t2 * a is the LCM */ /* store quotient in t2 such that t2 * a is the LCM */
if ((res = mp_div(b, &t1, &t2, NULL)) != MP_OKAY) { if ((res = mp_div(b, &t1, &t2, NULL)) != MP_OKAY) {
goto LBL_T; goto LBL_T;
} }
res = mp_mul(a, &t2, c); res = mp_mul(a, &t2, c);
} }
/* fix the sign to positive */ /* fix the sign to positive */
c->sign = MP_ZPOS; c->sign = MP_ZPOS;
LBL_T: LBL_T:
mp_clear_multi (&t1, &t2, NULL); mp_clear_multi(&t1, &t2, NULL);
return res; return res;
} }
#endif #endif

68
bn_mp_lshd.c
View File

@ -16,49 +16,49 @@
*/ */
/* shift left a certain amount of digits */ /* shift left a certain amount of digits */
int mp_lshd (mp_int * a, int b) int mp_lshd(mp_int *a, int b)
{ {
int x, res; int x, res;
/* if its less than zero return */ /* if its less than zero return */
if (b <= 0) { if (b <= 0) {
return MP_OKAY; return MP_OKAY;
} }
/* grow to fit the new digits */ /* grow to fit the new digits */
if (a->alloc < (a->used + b)) { if (a->alloc < (a->used + b)) {
if ((res = mp_grow (a, a->used + b)) != MP_OKAY) { if ((res = mp_grow(a, a->used + b)) != MP_OKAY) {
return res; return res;
} }
} }
{ {
mp_digit *top, *bottom; mp_digit *top, *bottom;
/* increment the used by the shift amount then copy upwards */ /* increment the used by the shift amount then copy upwards */
a->used += b; a->used += b;
/* top */ /* top */
top = a->dp + a->used - 1; top = a->dp + a->used - 1;
/* base */ /* base */
bottom = (a->dp + a->used - 1) - b; bottom = (a->dp + a->used - 1) - b;
/* much like mp_rshd this is implemented using a sliding window /* much like mp_rshd this is implemented using a sliding window
* except the window goes the otherway around. Copying from * except the window goes the otherway around. Copying from
* the bottom to the top. see bn_mp_rshd.c for more info. * the bottom to the top. see bn_mp_rshd.c for more info.
*/ */
for (x = a->used - 1; x >= b; x--) { for (x = a->used - 1; x >= b; x--) {
*top-- = *bottom--; *top-- = *bottom--;
} }
/* zero the lower digits */ /* zero the lower digits */
top = a->dp; top = a->dp;
for (x = 0; x < b; x++) { for (x = 0; x < b; x++) {
*top++ = 0; *top++ = 0;
} }
} }
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

37
bn_mp_mod.c
View File

@ -16,30 +16,29 @@
*/ */
/* c = a mod b, 0 <= c < b if b > 0, b < c <= 0 if b < 0 */ /* c = a mod b, 0 <= c < b if b > 0, b < c <= 0 if b < 0 */
int int mp_mod(mp_int *a, mp_int *b, mp_int *c)
mp_mod (mp_int * a, mp_int * b, mp_int * c)
{ {
mp_int t; mp_int t;
int res; int res;
if ((res = mp_init_size (&t, b->used)) != MP_OKAY) { if ((res = mp_init_size(&t, b->used)) != MP_OKAY) {
return res; return res;
} }
if ((res = mp_div (a, b, NULL, &t)) != MP_OKAY) { if ((res = mp_div(a, b, NULL, &t)) != MP_OKAY) {
mp_clear (&t); mp_clear(&t);
return res; return res;
} }
if ((mp_iszero(&t) != MP_NO) || (t.sign == b->sign)) { if ((mp_iszero(&t) != MP_NO) || (t.sign == b->sign)) {
res = MP_OKAY; res = MP_OKAY;
mp_exch (&t, c); mp_exch(&t, c);
} else { } else {
res = mp_add (b, &t, c); res = mp_add(b, &t, c);
} }
mp_clear (&t); mp_clear(&t);
return res; return res;
} }
#endif #endif

51
bn_mp_mod_2d.c
View File

@ -16,37 +16,36 @@
*/ */
/* calc a value mod 2**b */ /* calc a value mod 2**b */
int int mp_mod_2d(mp_int *a, int b, mp_int *c)
mp_mod_2d (mp_int * a, int b, mp_int * c)
{ {
int x, res; int x, res;
/* if b is <= 0 then zero the int */ /* if b is <= 0 then zero the int */
if (b <= 0) { if (b <= 0) {
mp_zero (c); mp_zero(c);
return MP_OKAY; return MP_OKAY;
} }
/* if the modulus is larger than the value than return */ /* if the modulus is larger than the value than return */
if (b >= (int) (a->used * DIGIT_BIT)) { if (b >= (int)(a->used * DIGIT_BIT)) {
res = mp_copy (a, c); res = mp_copy(a, c);
return res; return res;
} }
/* copy */ /* copy */
if ((res = mp_copy (a, c)) != MP_OKAY) { if ((res = mp_copy(a, c)) != MP_OKAY) {
return res; return res;
} }
/* zero digits above the last digit of the modulus */ /* zero digits above the last digit of the modulus */
for (x = (b / DIGIT_BIT) + (((b % DIGIT_BIT) == 0) ? 0 : 1); x < c->used; x++) { for (x = (b / DIGIT_BIT) + (((b % DIGIT_BIT) == 0) ? 0 : 1); x < c->used; x++) {
c->dp[x] = 0; c->dp[x] = 0;
} }
/* clear the digit that is not completely outside/inside the modulus */ /* clear the digit that is not completely outside/inside the modulus */
c->dp[b / DIGIT_BIT] &= c->dp[b / DIGIT_BIT] &=
(mp_digit) ((((mp_digit) 1) << (((mp_digit) b) % DIGIT_BIT)) - ((mp_digit) 1)); (mp_digit)((((mp_digit) 1) << (((mp_digit) b) % DIGIT_BIT)) - ((mp_digit) 1));
mp_clamp (c); mp_clamp(c);
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

5
bn_mp_mod_d.c
View File

@ -15,10 +15,9 @@
* Tom St Denis, tstdenis82@gmail.com, http://libtom.org * Tom St Denis, tstdenis82@gmail.com, http://libtom.org
*/ */
int int mp_mod_d(mp_int *a, mp_digit b, mp_digit *c)
mp_mod_d (mp_int * a, mp_digit b, mp_digit * c)
{ {
return mp_div_d(a, b, NULL, c); return mp_div_d(a, b, NULL, c);
} }
#endif #endif

50
bn_mp_montgomery_calc_normalization.c
View File

@ -21,36 +21,36 @@
* The method is slightly modified to shift B unconditionally upto just under * The method is slightly modified to shift B unconditionally upto just under
* the leading bit of b. This saves alot of multiple precision shifting. * the leading bit of b. This saves alot of multiple precision shifting.
*/ */
int mp_montgomery_calc_normalization (mp_int * a, mp_int * b) int mp_montgomery_calc_normalization(mp_int *a, mp_int *b)
{ {
int x, bits, res; int x, bits, res;
/* how many bits of last digit does b use */ /* how many bits of last digit does b use */
bits = mp_count_bits (b) % DIGIT_BIT; bits = mp_count_bits(b) % DIGIT_BIT;
if (b->used > 1) { if (b->used > 1) {
if ((res = mp_2expt (a, ((b->used - 1) * DIGIT_BIT) + bits - 1)) != MP_OKAY) { if ((res = mp_2expt(a, ((b->used - 1) * DIGIT_BIT) + bits - 1)) != MP_OKAY) {
return res; return res;
}
} else {
mp_set(a, 1);
bits = 1;
}
/* now compute C = A * B mod b */
for (x = bits - 1; x < (int)DIGIT_BIT; x++) {
if ((res = mp_mul_2 (a, a)) != MP_OKAY) {
return res;
}
if (mp_cmp_mag (a, b) != MP_LT) {
if ((res = s_mp_sub (a, b, a)) != MP_OKAY) {
return res;
} }
} } else {
} mp_set(a, 1);
bits = 1;
}
return MP_OKAY;
/* now compute C = A * B mod b */
for (x = bits - 1; x < (int)DIGIT_BIT; x++) {
if ((res = mp_mul_2(a, a)) != MP_OKAY) {
return res;
}
if (mp_cmp_mag(a, b) != MP_LT) {
if ((res = s_mp_sub(a, b, a)) != MP_OKAY) {
return res;
}
}
}
return MP_OKAY;
} }
#endif #endif

165
bn_mp_montgomery_reduce.c
View File

@ -16,100 +16,99 @@
*/ */
/* computes xR**-1 == x (mod N) via Montgomery Reduction */ /* computes xR**-1 == x (mod N) via Montgomery Reduction */
int int mp_montgomery_reduce(mp_int *x, mp_int *n, mp_digit rho)
mp_montgomery_reduce (mp_int * x, mp_int * n, mp_digit rho)
{ {
int ix, res, digs; int ix, res, digs;
mp_digit mu; mp_digit mu;
/* can the fast reduction [comba] method be used? /* can the fast reduction [comba] method be used?
* *
* Note that unlike in mul you're safely allowed *less* * Note that unlike in mul you're safely allowed *less*
* than the available columns [255 per default] since carries * than the available columns [255 per default] since carries
* are fixed up in the inner loop. * are fixed up in the inner loop.
*/ */
digs = (n->used * 2) + 1; digs = (n->used * 2) + 1;
if ((digs < MP_WARRAY) && if ((digs < MP_WARRAY) &&
(n->used < (n->used <
(1 << ((CHAR_BIT * sizeof(mp_word)) - (2 * DIGIT_BIT))))) { (1 << ((CHAR_BIT * sizeof(mp_word)) - (2 * DIGIT_BIT))))) {
return fast_mp_montgomery_reduce (x, n, rho); return fast_mp_montgomery_reduce(x, n, rho);
} }
/* grow the input as required */ /* grow the input as required */
if (x->alloc < digs) { if (x->alloc < digs) {
if ((res = mp_grow (x, digs)) != MP_OKAY) { if ((res = mp_grow(x, digs)) != MP_OKAY) {
return res; return res;
}
}
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++) +
(mp_word) u + (mp_word) *tmpx;
/* get carry */
u = (mp_digit)(r >> ((mp_word) DIGIT_BIT));
/* fix digit */
*tmpx++ = (mp_digit)(r & ((mp_word) MP_MASK));
} }
/* At this point the ix'th digit of x should be zero */ }
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++) +
(mp_word) u + (mp_word) *tmpx;
/* get carry */
u = (mp_digit)(r >> ((mp_word) DIGIT_BIT));
/* fix digit */
*tmpx++ = (mp_digit)(r & ((mp_word) MP_MASK));
}
/* At this point the ix'th digit of x should be zero */
/* propagate carries upwards as required*/ /* propagate carries upwards as required*/
while (u != 0) { while (u != 0) {
*tmpx += u; *tmpx += u;
u = *tmpx >> DIGIT_BIT; u = *tmpx >> DIGIT_BIT;
*tmpx++ &= MP_MASK; *tmpx++ &= MP_MASK;
}
} }
} }
}
/* at this point the n.used'th least /* at this point the n.used'th least
* significant digits of x are all zero * significant digits of x are all zero
* which means we can shift x to the * which means we can shift x to the
* right by n.used digits and the * right by n.used digits and the
* residue is unchanged. * residue is unchanged.
*/ */
/* x = x/b**n.used */ /* x = x/b**n.used */
mp_clamp(x); mp_clamp(x);
mp_rshd (x, n->used); mp_rshd(x, n->used);
/* if x >= n then x = x - n */ /* if x >= n then x = x - n */
if (mp_cmp_mag (x, n) != MP_LT) { if (mp_cmp_mag(x, n) != MP_LT) {
return s_mp_sub (x, n, x); return s_mp_sub(x, n, x);
} }
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

45
bn_mp_montgomery_setup.c
View File

@ -16,41 +16,40 @@
*/ */
/* setups the montgomery reduction stuff */ /* setups the montgomery reduction stuff */
int int mp_montgomery_setup(mp_int *n, mp_digit *rho)
mp_montgomery_setup (mp_int * n, mp_digit * rho)
{ {
mp_digit x, b; mp_digit x, b;
/* fast inversion mod 2**k /* fast inversion mod 2**k
* *
* Based on the fact that * Based on the fact that
* *
* XA = 1 (mod 2**n) => (X(2-XA)) A = 1 (mod 2**2n) * XA = 1 (mod 2**n) => (X(2-XA)) A = 1 (mod 2**2n)
* => 2*X*A - X*X*A*A = 1 * => 2*X*A - X*X*A*A = 1
* => 2*(1) - (1) = 1 * => 2*(1) - (1) = 1
*/ */
b = n->dp[0]; b = n->dp[0];
if ((b & 1) == 0) { if ((b & 1) == 0) {
return MP_VAL; return MP_VAL;
} }
x = (((b + 2) & 4) << 1) + b; /* here x*a==1 mod 2**4 */ x = (((b + 2) & 4) << 1) + b; /* here x*a==1 mod 2**4 */
x *= 2 - (b * x); /* here x*a==1 mod 2**8 */ x *= 2 - (b * x); /* here x*a==1 mod 2**8 */
#if !defined(MP_8BIT) #if !defined(MP_8BIT)
x *= 2 - (b * x); /* here x*a==1 mod 2**16 */ x *= 2 - (b * x); /* here x*a==1 mod 2**16 */
#endif #endif
#if defined(MP_64BIT) || !(defined(MP_8BIT) || defined(MP_16BIT)) #if defined(MP_64BIT) || !(defined(MP_8BIT) || defined(MP_16BIT))
x *= 2 - (b * x); /* here x*a==1 mod 2**32 */ x *= 2 - (b * x); /* here x*a==1 mod 2**32 */
#endif #endif
#ifdef MP_64BIT #ifdef MP_64BIT
x *= 2 - (b * x); /* here x*a==1 mod 2**64 */ x *= 2 - (b * x); /* here x*a==1 mod 2**64 */
#endif #endif
/* rho = -1/m mod b */ /* rho = -1/m mod b */
*rho = (mp_digit)(((mp_word)1 << ((mp_word) DIGIT_BIT)) - x) & MP_MASK; *rho = (mp_digit)(((mp_word)1 << ((mp_word) DIGIT_BIT)) - x) & MP_MASK;
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

62
bn_mp_mul.c
View File

@ -16,49 +16,49 @@
*/ */
/* high level multiplication (handles sign) */ /* high level multiplication (handles sign) */
int mp_mul (mp_int * a, mp_int * b, mp_int * c) int mp_mul(mp_int *a, mp_int *b, mp_int *c)
{ {
int res, neg; int res, neg;
neg = (a->sign == b->sign) ? MP_ZPOS : MP_NEG; neg = (a->sign == b->sign) ? MP_ZPOS : MP_NEG;
/* use Toom-Cook? */ /* use Toom-Cook? */
#ifdef BN_MP_TOOM_MUL_C #ifdef BN_MP_TOOM_MUL_C
if (MIN (a->used, b->used) >= TOOM_MUL_CUTOFF) { if (MIN(a->used, b->used) >= TOOM_MUL_CUTOFF) {
res = mp_toom_mul(a, b, c); res = mp_toom_mul(a, b, c);
} else } else
#endif #endif
#ifdef BN_MP_KARATSUBA_MUL_C #ifdef BN_MP_KARATSUBA_MUL_C
/* use Karatsuba? */ /* use Karatsuba? */
if (MIN (a->used, b->used) >= KARATSUBA_MUL_CUTOFF) { if (MIN(a->used, b->used) >= KARATSUBA_MUL_CUTOFF) {
res = mp_karatsuba_mul (a, b, c); res = mp_karatsuba_mul(a, b, c);
} else } else
#endif #endif
{ {
/* can we use the fast multiplier? /* can we use the fast multiplier?
* *
* The fast multiplier can be used if the output will * The fast multiplier can be used if the output will
* have less than MP_WARRAY digits and the number of * have less than MP_WARRAY digits and the number of
* digits won't affect carry propagation * digits won't affect carry propagation
*/ */
int digs = a->used + b->used + 1; int digs = a->used + b->used + 1;
#ifdef BN_FAST_S_MP_MUL_DIGS_C #ifdef BN_FAST_S_MP_MUL_DIGS_C
if ((digs < MP_WARRAY) && if ((digs < MP_WARRAY) &&
(MIN(a->used, b->used) <= (MIN(a->used, b->used) <=
(1 << ((CHAR_BIT * sizeof(mp_word)) - (2 * DIGIT_BIT))))) { (1 << ((CHAR_BIT * sizeof(mp_word)) - (2 * DIGIT_BIT))))) {
res = fast_s_mp_mul_digs (a, b, c, digs); res = fast_s_mp_mul_digs(a, b, c, digs);
} else } else
#endif #endif
{ {
#ifdef BN_S_MP_MUL_DIGS_C #ifdef BN_S_MP_MUL_DIGS_C
res = s_mp_mul (a, b, c); /* uses s_mp_mul_digs */ res = s_mp_mul(a, b, c); /* uses s_mp_mul_digs */
#else #else
res = MP_VAL; res = MP_VAL;
#endif #endif
} }
} }
c->sign = (c->used > 0) ? neg : MP_ZPOS; c->sign = (c->used > 0) ? neg : MP_ZPOS;
return res; return res;
} }
#endif #endif

102
bn_mp_mul_2.c
View File

@ -16,64 +16,64 @@
*/ */
/* b = a*2 */ /* b = a*2 */
int mp_mul_2(mp_int * a, mp_int * b) int mp_mul_2(mp_int *a, mp_int *b)
{ {
int x, res, oldused; int x, res, oldused;
/* grow to accomodate result */ /* grow to accomodate result */
if (b->alloc < (a->used + 1)) { if (b->alloc < (a->used + 1)) {
if ((res = mp_grow (b, a->used + 1)) != MP_OKAY) { if ((res = mp_grow(b, a->used + 1)) != MP_OKAY) {
return res; return res;
} }
} }
oldused = b->used; oldused = b->used;
b->used = a->used; b->used = a->used;
{ {
mp_digit r, rr, *tmpa, *tmpb; mp_digit r, rr, *tmpa, *tmpb;
/* alias for source */ /* alias for source */
tmpa = a->dp; tmpa = a->dp;
/* alias for dest */
tmpb = b->dp;
/* carry */ /* alias for dest */
r = 0; tmpb = b->dp;
for (x = 0; x < a->used; x++) {
/* carry */
/* get what will be the *next* carry bit from the r = 0;
* MSB of the current digit for (x = 0; x < a->used; x++) {
/* get what will be the *next* carry bit from the
* MSB of the current digit
*/
rr = *tmpa >> ((mp_digit)(DIGIT_BIT - 1));
/* now shift up this digit, add in the carry [from the previous] */
*tmpb++ = ((*tmpa++ << ((mp_digit)1)) | r) & MP_MASK;
/* copy the carry that would be from the source
* digit into the next iteration
*/
r = rr;
}
/* new leading digit? */
if (r != 0) {
/* add a MSB which is always 1 at this point */
*tmpb = 1;
++(b->used);
}
/* now zero any excess digits on the destination
* that we didn't write to
*/ */
rr = *tmpa >> ((mp_digit)(DIGIT_BIT - 1)); tmpb = b->dp + b->used;
for (x = b->used; x < oldused; x++) {
/* now shift up this digit, add in the carry [from the previous] */ *tmpb++ = 0;
*tmpb++ = ((*tmpa++ << ((mp_digit)1)) | r) & MP_MASK; }
}
/* copy the carry that would be from the source b->sign = a->sign;
* digit into the next iteration return MP_OKAY;
*/
r = rr;
}
/* new leading digit? */
if (r != 0) {
/* add a MSB which is always 1 at this point */
*tmpb = 1;
++(b->used);
}
/* now zero any excess digits on the destination
* that we didn't write to
*/
tmpb = b->dp + b->used;
for (x = b->used; x < oldused; x++) {
*tmpb++ = 0;
}
}
b->sign = a->sign;
return MP_OKAY;
} }
#endif #endif

100
bn_mp_mul_2d.c
View File

@ -16,67 +16,67 @@
*/ */
/* shift left by a certain bit count */ /* shift left by a certain bit count */
int mp_mul_2d (mp_int * a, int b, mp_int * c) int mp_mul_2d(mp_int *a, int b, mp_int *c)
{ {
mp_digit d; mp_digit d;
int res; int res;
/* copy */ /* copy */
if (a != c) { if (a != c) {
if ((res = mp_copy (a, c)) != MP_OKAY) { if ((res = mp_copy(a, c)) != MP_OKAY) {
return res; return res;
} }
} }
if (c->alloc < (int)(c->used + (b / DIGIT_BIT) + 1)) { if (c->alloc < (int)(c->used + (b / DIGIT_BIT) + 1)) {
if ((res = mp_grow (c, c->used + (b / DIGIT_BIT) + 1)) != MP_OKAY) { if ((res = mp_grow(c, c->used + (b / DIGIT_BIT) + 1)) != MP_OKAY) {
return res; return res;
} }
} }
/* shift by as many digits in the bit count */ /* shift by as many digits in the bit count */
if (b >= (int)DIGIT_BIT) { if (b >= (int)DIGIT_BIT) {
if ((res = mp_lshd (c, b / DIGIT_BIT)) != MP_OKAY) { if ((res = mp_lshd(c, b / DIGIT_BIT)) != MP_OKAY) {
return res; return res;
} }
} }
/* shift any bit count < DIGIT_BIT */ /* shift any bit count < DIGIT_BIT */
d = (mp_digit) (b % DIGIT_BIT); d = (mp_digit)(b % DIGIT_BIT);
if (d != 0) { if (d != 0) {
mp_digit *tmpc, shift, mask, r, rr; mp_digit *tmpc, shift, mask, r, rr;
int x; int x;
/* bitmask for carries */ /* bitmask for carries */
mask = (((mp_digit)1) << d) - 1; mask = (((mp_digit)1) << d) - 1;
/* shift for msbs */ /* shift for msbs */
shift = DIGIT_BIT - d; shift = DIGIT_BIT - d;
/* alias */ /* alias */
tmpc = c->dp; tmpc = c->dp;
/* carry */ /* carry */
r = 0; r = 0;
for (x = 0; x < c->used; x++) { for (x = 0; x < c->used; x++) {
/* get the higher bits of the current word */ /* get the higher bits of the current word */
rr = (*tmpc >> shift) & mask; rr = (*tmpc >> shift) & mask;
/* shift the current word and OR in the carry */ /* shift the current word and OR in the carry */
*tmpc = ((*tmpc << d) | r) & MP_MASK; *tmpc = ((*tmpc << d) | r) & MP_MASK;
++tmpc; ++tmpc;
/* set the carry to the carry bits of the current word */ /* set the carry to the carry bits of the current word */
r = rr; r = rr;
} }
/* set final carry */ /* set final carry */
if (r != 0) { if (r != 0) {
c->dp[(c->used)++] = r; c->dp[(c->used)++] = r;
} }
} }
mp_clamp (c); mp_clamp(c);
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

81
bn_mp_mul_d.c
View File

@ -16,61 +16,60 @@
*/ */
/* multiply by a digit */ /* multiply by a digit */
int int mp_mul_d(mp_int *a, mp_digit b, mp_int *c)
mp_mul_d (mp_int * a, mp_digit b, mp_int * c)
{ {
mp_digit u, *tmpa, *tmpc; mp_digit u, *tmpa, *tmpc;
mp_word r; mp_word r;
int ix, res, olduse; int ix, res, olduse;
/* make sure c is big enough to hold a*b */ /* make sure c is big enough to hold a*b */
if (c->alloc < (a->used + 1)) { if (c->alloc < (a->used + 1)) {
if ((res = mp_grow (c, a->used + 1)) != MP_OKAY) { if ((res = mp_grow(c, a->used + 1)) != MP_OKAY) {
return res; return res;
} }
} }
/* get the original destinations used count */ /* get the original destinations used count */
olduse = c->used; olduse = c->used;
/* set the sign */ /* set the sign */
c->sign = a->sign; c->sign = a->sign;
/* alias for a->dp [source] */ /* alias for a->dp [source] */
tmpa = a->dp; tmpa = a->dp;
/* alias for c->dp [dest] */ /* alias for c->dp [dest] */
tmpc = c->dp; tmpc = c->dp;
/* zero carry */ /* zero carry */
u = 0; u = 0;
/* compute columns */ /* compute columns */
for (ix = 0; ix < a->used; ix++) { for (ix = 0; ix < a->used; ix++) {
/* compute product and carry sum for this term */ /* compute product and carry sum for this term */
r = (mp_word)u + ((mp_word)*tmpa++ * (mp_word)b); r = (mp_word)u + ((mp_word)*tmpa++ * (mp_word)b);
/* mask off higher bits to get a single digit */ /* mask off higher bits to get a single digit */
*tmpc++ = (mp_digit) (r & ((mp_word) MP_MASK)); *tmpc++ = (mp_digit)(r & ((mp_word)MP_MASK));
/* send carry into next iteration */ /* send carry into next iteration */
u = (mp_digit) (r >> ((mp_word) DIGIT_BIT)); u = (mp_digit)(r >> ((mp_word)DIGIT_BIT));
} }
/* store final carry [if any] and increment ix offset */ /* store final carry [if any] and increment ix offset */
*tmpc++ = u; *tmpc++ = u;
++ix; ++ix;
/* now zero digits above the top */ /* now zero digits above the top */
while (ix++ < olduse) { while (ix++ < olduse) {
*tmpc++ = 0; *tmpc++ = 0;
} }
/* set used count */ /* set used count */
c->used = a->used + 1; c->used = a->used + 1;
mp_clamp(c); mp_clamp(c);
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

26
bn_mp_mulmod.c
View File

@ -16,22 +16,22 @@
*/ */
/* d = a * b (mod c) */ /* d = a * b (mod c) */
int mp_mulmod (mp_int * a, mp_int * b, mp_int * c, mp_int * d) int mp_mulmod(mp_int *a, mp_int *b, mp_int *c, mp_int *d)
{ {
int res; int res;
mp_int t; mp_int t;
if ((res = mp_init_size (&t, c->used)) != MP_OKAY) { if ((res = mp_init_size(&t, c->used)) != MP_OKAY) {
return res; return res;
} }
if ((res = mp_mul (a, b, &t)) != MP_OKAY) { if ((res = mp_mul(a, b, &t)) != MP_OKAY) {
mp_clear (&t); mp_clear(&t);
return res; return res;
} }
res = mp_mod (&t, c, d); res = mp_mod(&t, c, d);
mp_clear (&t); mp_clear(&t);
return res; return res;
} }
#endif #endif

4
bn_mp_n_root.c
View File

@ -18,9 +18,9 @@
/* wrapper function for mp_n_root_ex() /* wrapper function for mp_n_root_ex()
* computes c = (a)**(1/b) such that (c)**b <= a and (c+1)**b > a * computes c = (a)**(1/b) such that (c)**b <= a and (c+1)**b > a
*/ */
int mp_n_root (mp_int * a, mp_digit b, mp_int * c) int mp_n_root(mp_int *a, mp_digit b, mp_int *c)
{ {
return mp_n_root_ex(a, b, c, 0); return mp_n_root_ex(a, b, c, 0);
} }
#endif #endif

171
bn_mp_n_root_ex.c
View File

@ -25,105 +25,108 @@
* each step involves a fair bit. This is not meant to * each step involves a fair bit. This is not meant to
* find huge roots [square and cube, etc]. * find huge roots [square and cube, etc].
*/ */
int mp_n_root_ex (mp_int * a, mp_digit b, mp_int * c, int fast) int mp_n_root_ex(mp_int *a, mp_digit b, mp_int *c, int fast)
{ {
mp_int t1, t2, t3; mp_int t1, t2, t3;
int res, neg; int res, neg;
/* input must be positive if b is even */ /* input must be positive if b is even */
if (((b & 1) == 0) && (a->sign == MP_NEG)) { if (((b & 1) == 0) && (a->sign == MP_NEG)) {
return MP_VAL; return MP_VAL;
} }
if ((res = mp_init (&t1)) != MP_OKAY) { if ((res = mp_init(&t1)) != MP_OKAY) {
return res; return res;
} }
if ((res = mp_init (&t2)) != MP_OKAY) { if ((res = mp_init(&t2)) != MP_OKAY) {
goto LBL_T1; goto LBL_T1;
} }
if ((res = mp_init (&t3)) != MP_OKAY) { if ((res = mp_init(&t3)) != MP_OKAY) {
goto LBL_T2; goto LBL_T2;
} }
/* if a is negative fudge the sign but keep track */ /* if a is negative fudge the sign but keep track */
neg = a->sign; neg = a->sign;
a->sign = MP_ZPOS; a->sign = MP_ZPOS;
/* t2 = 2 */ /* t2 = 2 */
mp_set (&t2, 2); mp_set(&t2, 2);
do { do {
/* t1 = t2 */ /* t1 = t2 */
if ((res = mp_copy (&t2, &t1)) != MP_OKAY) { if ((res = mp_copy(&t2, &t1)) != MP_OKAY) {
goto LBL_T3;
}
/* t2 = t1 - ((t1**b - a) / (b * t1**(b-1))) */
/* t3 = t1**(b-1) */
if ((res = mp_expt_d_ex (&t1, b - 1, &t3, fast)) != MP_OKAY) {
goto LBL_T3;
}
/* numerator */
/* t2 = t1**b */
if ((res = mp_mul (&t3, &t1, &t2)) != MP_OKAY) {
goto LBL_T3;
}
/* t2 = t1**b - a */
if ((res = mp_sub (&t2, a, &t2)) != MP_OKAY) {
goto LBL_T3;
}
/* denominator */
/* t3 = t1**(b-1) * b */
if ((res = mp_mul_d (&t3, b, &t3)) != MP_OKAY) {
goto LBL_T3;
}
/* t3 = (t1**b - a)/(b * t1**(b-1)) */
if ((res = mp_div (&t2, &t3, &t3, NULL)) != MP_OKAY) {
goto LBL_T3;
}
if ((res = mp_sub (&t1, &t3, &t2)) != MP_OKAY) {
goto LBL_T3;
}
} while (mp_cmp (&t1, &t2) != MP_EQ);
/* result can be off by a few so check */
for (;;) {
if ((res = mp_expt_d_ex (&t1, b, &t2, fast)) != MP_OKAY) {
goto LBL_T3;
}
if (mp_cmp (&t2, a) == MP_GT) {
if ((res = mp_sub_d (&t1, 1, &t1)) != MP_OKAY) {
goto LBL_T3; goto LBL_T3;
} }
} else {
break;
}
}
/* reset the sign of a first */ /* t2 = t1 - ((t1**b - a) / (b * t1**(b-1))) */
a->sign = neg;
/* set the result */ /* t3 = t1**(b-1) */
mp_exch (&t1, c); if ((res = mp_expt_d_ex(&t1, b - 1, &t3, fast)) != MP_OKAY) {
goto LBL_T3;
}
/* set the sign of the result */ /* numerator */
c->sign = neg; /* t2 = t1**b */
if ((res = mp_mul(&t3, &t1, &t2)) != MP_OKAY) {
goto LBL_T3;
}
res = MP_OKAY; /* t2 = t1**b - a */
if ((res = mp_sub(&t2, a, &t2)) != MP_OKAY) {
goto LBL_T3;
}
LBL_T3:mp_clear (&t3); /* denominator */
LBL_T2:mp_clear (&t2); /* t3 = t1**(b-1) * b */
LBL_T1:mp_clear (&t1); if ((res = mp_mul_d(&t3, b, &t3)) != MP_OKAY) {
return res; goto LBL_T3;
}
/* t3 = (t1**b - a)/(b * t1**(b-1)) */
if ((res = mp_div(&t2, &t3, &t3, NULL)) != MP_OKAY) {
goto LBL_T3;
}
if ((res = mp_sub(&t1, &t3, &t2)) != MP_OKAY) {
goto LBL_T3;
}
} while (mp_cmp(&t1, &t2) != MP_EQ);
/* result can be off by a few so check */
for (;;) {
if ((res = mp_expt_d_ex(&t1, b, &t2, fast)) != MP_OKAY) {
goto LBL_T3;
}
if (mp_cmp(&t2, a) == MP_GT) {
if ((res = mp_sub_d(&t1, 1, &t1)) != MP_OKAY) {
goto LBL_T3;
}
} else {
break;
}
}
/* reset the sign of a first */
a->sign = neg;
/* set the result */
mp_exch(&t1, c);
/* set the sign of the result */
c->sign = neg;
res = MP_OKAY;
LBL_T3:
mp_clear(&t3);
LBL_T2:
mp_clear(&t2);
LBL_T1:
mp_clear(&t1);
return res;
} }
#endif #endif

26
bn_mp_neg.c
View File

@ -16,22 +16,22 @@
*/ */
/* b = -a */ /* b = -a */
int mp_neg (mp_int * a, mp_int * b) int mp_neg(mp_int *a, mp_int *b)
{ {
int res; int res;
if (a != b) { if (a != b) {
if ((res = mp_copy (a, b)) != MP_OKAY) { if ((res = mp_copy(a, b)) != MP_OKAY) {
return res; return res;
} }
} }
if (mp_iszero(b) != MP_YES) { if (mp_iszero(b) != MP_YES) {
b->sign = (a->sign == MP_ZPOS) ? MP_NEG : MP_ZPOS; b->sign = (a->sign == MP_ZPOS) ? MP_NEG : MP_ZPOS;
} else { } else {
b->sign = MP_ZPOS; b->sign = MP_ZPOS;
} }
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

46
bn_mp_or.c
View File

@ -16,32 +16,32 @@
*/ */
/* OR two ints together */ /* OR two ints together */
int mp_or (mp_int * a, mp_int * b, mp_int * c) int mp_or(mp_int *a, mp_int *b, mp_int *c)
{ {
int res, ix, px; int res, ix, px;
mp_int t, *x; mp_int t, *x;
if (a->used > b->used) { if (a->used > b->used) {
if ((res = mp_init_copy (&t, a)) != MP_OKAY) { if ((res = mp_init_copy(&t, a)) != MP_OKAY) {
return res; return res;
} }
px = b->used; px = b->used;
x = b; x = b;
} else { } else {
if ((res = mp_init_copy (&t, b)) != MP_OKAY) { if ((res = mp_init_copy(&t, b)) != MP_OKAY) {
return res; return res;
} }
px = a->used; px = a->used;
x = a; x = a;
} }
for (ix = 0; ix < px; ix++) { for (ix = 0; ix < px; ix++) {
t.dp[ix] |= x->dp[ix]; t.dp[ix] |= x->dp[ix];
} }
mp_clamp (&t); mp_clamp(&t);
mp_exch (c, &t); mp_exch(c, &t);
mp_clear (&t); mp_clear(&t);
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

51
bn_mp_prime_fermat.c
View File

@ -16,44 +16,45 @@
*/ */
/* performs one Fermat test. /* performs one Fermat test.
* *
* If "a" were prime then b**a == b (mod a) since the order of * If "a" were prime then b**a == b (mod a) since the order of
* the multiplicative sub-group would be phi(a) = a-1. That means * the multiplicative sub-group would be phi(a) = a-1. That means
* it would be the same as b**(a mod (a-1)) == b**1 == b (mod a). * it would be the same as b**(a mod (a-1)) == b**1 == b (mod a).
* *
* Sets result to 1 if the congruence holds, or zero otherwise. * Sets result to 1 if the congruence holds, or zero otherwise.
*/ */
int mp_prime_fermat (mp_int * a, mp_int * b, int *result) int mp_prime_fermat(mp_int *a, mp_int *b, int *result)
{ {
mp_int t; mp_int t;
int err; int err;
/* default to composite */ /* default to composite */
*result = MP_NO; *result = MP_NO;
/* ensure b > 1 */ /* ensure b > 1 */
if (mp_cmp_d(b, 1) != MP_GT) { if (mp_cmp_d(b, 1) != MP_GT) {
return MP_VAL; return MP_VAL;
} }
/* init t */ /* init t */
if ((err = mp_init (&t)) != MP_OKAY) { if ((err = mp_init(&t)) != MP_OKAY) {
return err; return err;
} }
/* compute t = b**a mod a */ /* compute t = b**a mod a */
if ((err = mp_exptmod (b, a, a, &t)) != MP_OKAY) { if ((err = mp_exptmod(b, a, a, &t)) != MP_OKAY) {
goto LBL_T; goto LBL_T;
} }
/* is it equal to b? */ /* is it equal to b? */
if (mp_cmp (&t, b) == MP_EQ) { if (mp_cmp(&t, b) == MP_EQ) {
*result = MP_YES; *result = MP_YES;
} }
err = MP_OKAY; err = MP_OKAY;
LBL_T:mp_clear (&t); LBL_T:
return err; mp_clear(&t);
return err;
} }
#endif #endif

36
bn_mp_prime_is_divisible.c
View File

@ -15,33 +15,33 @@
* Tom St Denis, tstdenis82@gmail.com, http://libtom.org * Tom St Denis, tstdenis82@gmail.com, http://libtom.org
*/ */
/* determines if an integers is divisible by one /* determines if an integers is divisible by one
* of the first PRIME_SIZE primes or not * of the first PRIME_SIZE primes or not
* *
* sets result to 0 if not, 1 if yes * sets result to 0 if not, 1 if yes
*/ */
int mp_prime_is_divisible (mp_int * a, int *result) int mp_prime_is_divisible(mp_int *a, int *result)
{ {
int err, ix; int err, ix;
mp_digit res; mp_digit res;
/* default to not */ /* default to not */
*result = MP_NO; *result = MP_NO;
for (ix = 0; ix < PRIME_SIZE; ix++) { for (ix = 0; ix < PRIME_SIZE; ix++) {
/* what is a mod LBL_prime_tab[ix] */ /* what is a mod LBL_prime_tab[ix] */
if ((err = mp_mod_d (a, ltm_prime_tab[ix], &res)) != MP_OKAY) { if ((err = mp_mod_d(a, ltm_prime_tab[ix], &res)) != MP_OKAY) {
return err; return err;
} }
/* is the residue zero? */ /* is the residue zero? */
if (res == 0) { if (res == 0) {
*result = MP_YES; *result = MP_YES;
return MP_OKAY; return MP_OKAY;
} }
} }
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

77
bn_mp_prime_is_prime.c
View File

@ -22,59 +22,60 @@
* *
* Sets result to 1 if probably prime, 0 otherwise * Sets result to 1 if probably prime, 0 otherwise
*/ */
int mp_prime_is_prime (mp_int * a, int t, int *result) int mp_prime_is_prime(mp_int *a, int t, int *result)
{ {
mp_int b; mp_int b;
int ix, err, res; int ix, err, res;
/* default to no */ /* default to no */
*result = MP_NO; *result = MP_NO;
/* valid value of t? */ /* valid value of t? */
if ((t <= 0) || (t > PRIME_SIZE)) { if ((t <= 0) || (t > PRIME_SIZE)) {
return MP_VAL; return MP_VAL;
} }
/* is the input equal to one of the primes in the table? */ /* is the input equal to one of the primes in the table? */
for (ix = 0; ix < PRIME_SIZE; ix++) { for (ix = 0; ix < PRIME_SIZE; ix++) {
if (mp_cmp_d(a, ltm_prime_tab[ix]) == MP_EQ) { if (mp_cmp_d(a, ltm_prime_tab[ix]) == MP_EQ) {
*result = 1; *result = 1;
return MP_OKAY; return MP_OKAY;
} }
} }
/* first perform trial division */ /* first perform trial division */
if ((err = mp_prime_is_divisible (a, &res)) != MP_OKAY) { if ((err = mp_prime_is_divisible(a, &res)) != MP_OKAY) {
return err; return err;
} }
/* return if it was trivially divisible */ /* return if it was trivially divisible */
if (res == MP_YES) { if (res == MP_YES) {
return MP_OKAY; return MP_OKAY;
} }
/* now perform the miller-rabin rounds */ /* now perform the miller-rabin rounds */
if ((err = mp_init (&b)) != MP_OKAY) { if ((err = mp_init(&b)) != MP_OKAY) {
return err; return err;
} }
for (ix = 0; ix < t; ix++) { for (ix = 0; ix < t; ix++) {
/* set the prime */ /* set the prime */
mp_set (&b, ltm_prime_tab[ix]); mp_set(&b, ltm_prime_tab[ix]);
if ((err = mp_prime_miller_rabin (a, &b, &res)) != MP_OKAY) { if ((err = mp_prime_miller_rabin(a, &b, &res)) != MP_OKAY) {
goto LBL_B; goto LBL_B;
} }
if (res == MP_NO) { if (res == MP_NO) {
goto LBL_B; goto LBL_B;
} }
} }
/* passed the test */ /* passed the test */
*result = MP_YES; *result = MP_YES;
LBL_B:mp_clear (&b); LBL_B:
return err; mp_clear(&b);
return err;
} }
#endif #endif

133
bn_mp_prime_miller_rabin.c
View File

@ -15,86 +15,89 @@
* Tom St Denis, tstdenis82@gmail.com, http://libtom.org * Tom St Denis, tstdenis82@gmail.com, http://libtom.org
*/ */
/* Miller-Rabin test of "a" to the base of "b" as described in /* Miller-Rabin test of "a" to the base of "b" as described in
* HAC pp. 139 Algorithm 4.24 * HAC pp. 139 Algorithm 4.24
* *
* Sets result to 0 if definitely composite or 1 if probably prime. * Sets result to 0 if definitely composite or 1 if probably prime.
* Randomly the chance of error is no more than 1/4 and often * Randomly the chance of error is no more than 1/4 and often
* very much lower. * very much lower.
*/ */
int mp_prime_miller_rabin (mp_int * a, mp_int * b, int *result) int mp_prime_miller_rabin(mp_int *a, mp_int *b, int *result)
{ {
mp_int n1, y, r; mp_int n1, y, r;
int s, j, err; int s, j, err;
/* default */ /* default */
*result = MP_NO; *result = MP_NO;
/* ensure b > 1 */ /* ensure b > 1 */
if (mp_cmp_d(b, 1) != MP_GT) { if (mp_cmp_d(b, 1) != MP_GT) {
return MP_VAL; return MP_VAL;
} }
/* get n1 = a - 1 */ /* get n1 = a - 1 */
if ((err = mp_init_copy (&n1, a)) != MP_OKAY) { if ((err = mp_init_copy(&n1, a)) != MP_OKAY) {
return err; return err;
} }
if ((err = mp_sub_d (&n1, 1, &n1)) != MP_OKAY) { if ((err = mp_sub_d(&n1, 1, &n1)) != MP_OKAY) {
goto LBL_N1; goto LBL_N1;
} }
/* set 2**s * r = n1 */ /* set 2**s * r = n1 */
if ((err = mp_init_copy (&r, &n1)) != MP_OKAY) { if ((err = mp_init_copy(&r, &n1)) != MP_OKAY) {
goto LBL_N1; goto LBL_N1;
} }
/* count the number of least significant bits /* count the number of least significant bits
* which are zero * which are zero
*/ */
s = mp_cnt_lsb(&r); s = mp_cnt_lsb(&r);
/* now divide n - 1 by 2**s */ /* now divide n - 1 by 2**s */
if ((err = mp_div_2d (&r, s, &r, NULL)) != MP_OKAY) { if ((err = mp_div_2d(&r, s, &r, NULL)) != MP_OKAY) {
goto LBL_R; goto LBL_R;
} }
/* compute y = b**r mod a */ /* compute y = b**r mod a */
if ((err = mp_init (&y)) != MP_OKAY) { if ((err = mp_init(&y)) != MP_OKAY) {
goto LBL_R; goto LBL_R;
} }
if ((err = mp_exptmod (b, &r, a, &y)) != MP_OKAY) { if ((err = mp_exptmod(b, &r, a, &y)) != MP_OKAY) {
goto LBL_Y;
}
/* if y != 1 and y != n1 do */
if ((mp_cmp_d (&y, 1) != MP_EQ) && (mp_cmp (&y, &n1) != MP_EQ)) {
j = 1;
/* while j <= s-1 and y != n1 */
while ((j <= (s - 1)) && (mp_cmp (&y, &n1) != MP_EQ)) {
if ((err = mp_sqrmod (&y, a, &y)) != MP_OKAY) {
goto LBL_Y;
}
/* if y == 1 then composite */
if (mp_cmp_d (&y, 1) == MP_EQ) {
goto LBL_Y;
}
++j;
}
/* if y != n1 then composite */
if (mp_cmp (&y, &n1) != MP_EQ) {
goto LBL_Y; goto LBL_Y;
} }
}
/* probably prime now */ /* if y != 1 and y != n1 do */
*result = MP_YES; if ((mp_cmp_d(&y, 1) != MP_EQ) && (mp_cmp(&y, &n1) != MP_EQ)) {
LBL_Y:mp_clear (&y); j = 1;
LBL_R:mp_clear (&r); /* while j <= s-1 and y != n1 */
LBL_N1:mp_clear (&n1); while ((j <= (s - 1)) && (mp_cmp(&y, &n1) != MP_EQ)) {
return err; if ((err = mp_sqrmod(&y, a, &y)) != MP_OKAY) {
goto LBL_Y;
}
/* if y == 1 then composite */
if (mp_cmp_d(&y, 1) == MP_EQ) {
goto LBL_Y;
}
++j;
}
/* if y != n1 then composite */
if (mp_cmp(&y, &n1) != MP_EQ) {
goto LBL_Y;
}
}
/* probably prime now */
*result = MP_YES;
LBL_Y:
mp_clear(&y);
LBL_R:
mp_clear(&r);
LBL_N1:
mp_clear(&n1);
return err;
} }
#endif #endif

82
bn_mp_prime_next_prime.c
View File

@ -38,28 +38,28 @@ int mp_prime_next_prime(mp_int *a, int t, int bbs_style)
if (mp_cmp_d(a, ltm_prime_tab[PRIME_SIZE-1]) == MP_LT) { if (mp_cmp_d(a, ltm_prime_tab[PRIME_SIZE-1]) == MP_LT) {
/* find which prime it is bigger than */ /* find which prime it is bigger than */
for (x = PRIME_SIZE - 2; x >= 0; x--) { for (x = PRIME_SIZE - 2; x >= 0; x--) {
if (mp_cmp_d(a, ltm_prime_tab[x]) != MP_LT) { if (mp_cmp_d(a, ltm_prime_tab[x]) != MP_LT) {
if (bbs_style == 1) { if (bbs_style == 1) {
/* ok we found a prime smaller or /* ok we found a prime smaller or
* equal [so the next is larger] * equal [so the next is larger]
* *
* however, the prime must be * however, the prime must be
* congruent to 3 mod 4 * congruent to 3 mod 4
*/ */
if ((ltm_prime_tab[x + 1] & 3) != 3) { if ((ltm_prime_tab[x + 1] & 3) != 3) {
/* scan upwards for a prime congruent to 3 mod 4 */ /* scan upwards for a prime congruent to 3 mod 4 */
for (y = x + 1; y < PRIME_SIZE; y++) { for (y = x + 1; y < PRIME_SIZE; y++) {
if ((ltm_prime_tab[y] & 3) == 3) { if ((ltm_prime_tab[y] & 3) == 3) {
mp_set(a, ltm_prime_tab[y]); mp_set(a, ltm_prime_tab[y]);
return MP_OKAY; return MP_OKAY;
} }
} }
} }
} else { } else {
mp_set(a, ltm_prime_tab[x + 1]); mp_set(a, ltm_prime_tab[x + 1]);
return MP_OKAY; return MP_OKAY;
} }
} }
} }
/* at this point a maybe 1 */ /* at this point a maybe 1 */
if (mp_cmp_d(a, 1) == MP_EQ) { if (mp_cmp_d(a, 1) == MP_EQ) {
@ -81,7 +81,9 @@ int mp_prime_next_prime(mp_int *a, int t, int bbs_style)
if (bbs_style == 1) { if (bbs_style == 1) {
/* if a mod 4 != 3 subtract the correct value to make it so */ /* if a mod 4 != 3 subtract the correct value to make it so */
if ((a->dp[0] & 3) != 3) { if ((a->dp[0] & 3) != 3) {
if ((err = mp_sub_d(a, (a->dp[0] & 3) + 1, a)) != MP_OKAY) { return err; }; if ((err = mp_sub_d(a, (a->dp[0] & 3) + 1, a)) != MP_OKAY) {
return err;
};
} }
} else { } else {
if (mp_iseven(a) == MP_YES) { if (mp_iseven(a) == MP_YES) {
@ -116,18 +118,18 @@ int mp_prime_next_prime(mp_int *a, int t, int bbs_style)
/* compute the new residue without using division */ /* compute the new residue without using division */
for (x = 1; x < PRIME_SIZE; x++) { for (x = 1; x < PRIME_SIZE; x++) {
/* add the step to each residue */ /* add the step to each residue */
res_tab[x] += kstep; res_tab[x] += kstep;
/* subtract the modulus [instead of using division] */ /* subtract the modulus [instead of using division] */
if (res_tab[x] >= ltm_prime_tab[x]) { if (res_tab[x] >= ltm_prime_tab[x]) {
res_tab[x] -= ltm_prime_tab[x]; res_tab[x] -= ltm_prime_tab[x];
} }
/* set flag if zero */ /* set flag if zero */
if (res_tab[x] == 0) { if (res_tab[x] == 0) {
y = 1; y = 1;
} }
} }
} while ((y == 1) && (step < ((((mp_digit)1) << DIGIT_BIT) - kstep))); } while ((y == 1) && (step < ((((mp_digit)1) << DIGIT_BIT) - kstep)));
@ -143,13 +145,13 @@ int mp_prime_next_prime(mp_int *a, int t, int bbs_style)
/* is this prime? */ /* is this prime? */
for (x = 0; x < t; x++) { for (x = 0; x < t; x++) {
mp_set(&b, ltm_prime_tab[x]); mp_set(&b, ltm_prime_tab[x]);
if ((err = mp_prime_miller_rabin(a, &b, &res)) != MP_OKAY) { if ((err = mp_prime_miller_rabin(a, &b, &res)) != MP_OKAY) {
goto LBL_ERR; goto LBL_ERR;
} }
if (res == MP_NO) { if (res == MP_NO) {
break; break;
} }
} }
if (res == MP_YES) { if (res == MP_YES) {

26
bn_mp_prime_rabin_miller_trials.c
View File

@ -19,14 +19,14 @@
static const struct { static const struct {
int k, t; int k, t;
} sizes[] = { } sizes[] = {
{ 128, 28 }, { 128, 28 },
{ 256, 16 }, { 256, 16 },
{ 384, 10 }, { 384, 10 },
{ 512, 7 }, { 512, 7 },
{ 640, 6 }, { 640, 6 },
{ 768, 5 }, { 768, 5 },
{ 896, 4 }, { 896, 4 },
{ 1024, 4 } { 1024, 4 }
}; };
/* returns # of RM trials required for a given bit size */ /* returns # of RM trials required for a given bit size */
@ -35,11 +35,11 @@ int mp_prime_rabin_miller_trials(int size)
int x; int x;
for (x = 0; x < (int)(sizeof(sizes)/(sizeof(sizes[0]))); x++) { for (x = 0; x < (int)(sizeof(sizes)/(sizeof(sizes[0]))); x++) {
if (sizes[x].k == size) { if (sizes[x].k == size) {
return sizes[x].t; return sizes[x].t;
} else if (sizes[x].k > size) { } else if (sizes[x].k > size) {
return (x == 0) ? sizes[0].t : sizes[x - 1].t; return (x == 0) ? sizes[0].t : sizes[x - 1].t;
} }
} }
return sizes[x-1].t + 1; return sizes[x-1].t + 1;
} }

38
bn_mp_prime_random_ex.c
View File

@ -18,7 +18,7 @@
/* makes a truly random prime of a given size (bits), /* makes a truly random prime of a given size (bits),
* *
* Flags are as follows: * Flags are as follows:
* *
* LTM_PRIME_BBS - make prime congruent to 3 mod 4 * LTM_PRIME_BBS - make prime congruent to 3 mod 4
* LTM_PRIME_SAFE - make sure (p-1)/2 is prime as well (implies LTM_PRIME_BBS) * LTM_PRIME_SAFE - make sure (p-1)/2 is prime as well (implies LTM_PRIME_BBS)
* LTM_PRIME_2MSB_ON - make the 2nd highest bit one * LTM_PRIME_2MSB_ON - make the 2nd highest bit one
@ -62,7 +62,7 @@ int mp_prime_random_ex(mp_int *a, int t, int size, int flags, ltm_prime_callback
maskOR_msb_offset = ((size & 7) == 1) ? 1 : 0; maskOR_msb_offset = ((size & 7) == 1) ? 1 : 0;
if ((flags & LTM_PRIME_2MSB_ON) != 0) { if ((flags & LTM_PRIME_2MSB_ON) != 0) {
maskOR_msb |= 0x80 >> ((9 - size) & 7); maskOR_msb |= 0x80 >> ((9 - size) & 7);
} }
/* get the maskOR_lsb */ /* get the maskOR_lsb */
maskOR_lsb = 1; maskOR_lsb = 1;
@ -76,7 +76,7 @@ int mp_prime_random_ex(mp_int *a, int t, int size, int flags, ltm_prime_callback
err = MP_VAL; err = MP_VAL;
goto error; goto error;
} }
/* work over the MSbyte */ /* work over the MSbyte */
tmp[0] &= maskAND; tmp[0] &= maskAND;
tmp[0] |= 1 << ((size - 1) & 7); tmp[0] |= 1 << ((size - 1) & 7);
@ -86,28 +86,42 @@ int mp_prime_random_ex(mp_int *a, int t, int size, int flags, ltm_prime_callback
tmp[bsize-1] |= maskOR_lsb; tmp[bsize-1] |= maskOR_lsb;
/* read it in */ /* read it in */
if ((err = mp_read_unsigned_bin(a, tmp, bsize)) != MP_OKAY) { goto error; } if ((err = mp_read_unsigned_bin(a, tmp, bsize)) != MP_OKAY) {
goto error;
}
/* is it prime? */ /* is it prime? */
if ((err = mp_prime_is_prime(a, t, &res)) != MP_OKAY) { goto error; } if ((err = mp_prime_is_prime(a, t, &res)) != MP_OKAY) {
if (res == MP_NO) { goto error;
}
if (res == MP_NO) {
continue; continue;
} }
if ((flags & LTM_PRIME_SAFE) != 0) { if ((flags & LTM_PRIME_SAFE) != 0) {
/* see if (a-1)/2 is prime */ /* see if (a-1)/2 is prime */
if ((err = mp_sub_d(a, 1, a)) != MP_OKAY) { goto error; } if ((err = mp_sub_d(a, 1, a)) != MP_OKAY) {
if ((err = mp_div_2(a, a)) != MP_OKAY) { goto error; } goto error;
}
if ((err = mp_div_2(a, a)) != MP_OKAY) {
goto error;
}
/* is it prime? */ /* is it prime? */
if ((err = mp_prime_is_prime(a, t, &res)) != MP_OKAY) { goto error; } if ((err = mp_prime_is_prime(a, t, &res)) != MP_OKAY) {
goto error;
}
} }
} while (res == MP_NO); } while (res == MP_NO);
if ((flags & LTM_PRIME_SAFE) != 0) { if ((flags & LTM_PRIME_SAFE) != 0) {
/* restore a to the original value */ /* restore a to the original value */
if ((err = mp_mul_2(a, a)) != MP_OKAY) { goto error; } if ((err = mp_mul_2(a, a)) != MP_OKAY) {
if ((err = mp_add_d(a, 1, a)) != MP_OKAY) { goto error; } goto error;
}
if ((err = mp_add_d(a, 1, a)) != MP_OKAY) {
goto error;
}
} }
err = MP_OKAY; err = MP_OKAY;

86
bn_mp_radix_size.c
View File

@ -16,59 +16,59 @@
*/ */
/* returns size of ASCII reprensentation */ /* returns size of ASCII reprensentation */
int mp_radix_size (mp_int * a, int radix, int *size) int mp_radix_size(mp_int *a, int radix, int *size)
{ {
int res, digs; int res, digs;
mp_int t; mp_int t;
mp_digit d; mp_digit d;
*size = 0; *size = 0;
/* make sure the radix is in range */ /* make sure the radix is in range */
if ((radix < 2) || (radix > 64)) { if ((radix < 2) || (radix > 64)) {
return MP_VAL; return MP_VAL;
} }
if (mp_iszero(a) == MP_YES) { if (mp_iszero(a) == MP_YES) {
*size = 2; *size = 2;
return MP_OKAY; return MP_OKAY;
} }
/* special case for binary */ /* special case for binary */
if (radix == 2) { if (radix == 2) {
*size = mp_count_bits (a) + ((a->sign == MP_NEG) ? 1 : 0) + 1; *size = mp_count_bits(a) + ((a->sign == MP_NEG) ? 1 : 0) + 1;
return MP_OKAY; return MP_OKAY;
} }
/* digs is the digit count */ /* digs is the digit count */
digs = 0; digs = 0;
/* if it's negative add one for the sign */ /* if it's negative add one for the sign */
if (a->sign == MP_NEG) { if (a->sign == MP_NEG) {
++digs; ++digs;
} }
/* init a copy of the input */ /* init a copy of the input */
if ((res = mp_init_copy (&t, a)) != MP_OKAY) { if ((res = mp_init_copy(&t, a)) != MP_OKAY) {
return res;
}
/* force temp to positive */
t.sign = MP_ZPOS;
/* fetch out all of the digits */
while (mp_iszero (&t) == MP_NO) {
if ((res = mp_div_d (&t, (mp_digit) radix, &t, &d)) != MP_OKAY) {
mp_clear (&t);
return res; return res;
} }
++digs;
}
mp_clear (&t);
/* return digs + 1, the 1 is for the NULL byte that would be required. */ /* force temp to positive */
*size = digs + 1; t.sign = MP_ZPOS;
return MP_OKAY;
/* fetch out all of the digits */
while (mp_iszero(&t) == MP_NO) {
if ((res = mp_div_d(&t, (mp_digit)radix, &t, &d)) != MP_OKAY) {
mp_clear(&t);
return res;
}
++digs;
}
mp_clear(&t);
/* return digs + 1, the 1 is for the NULL byte that would be required. */
*size = digs + 1;
return MP_OKAY;
} }
#endif #endif

75
bn_mp_rand.c
View File

@ -16,13 +16,13 @@
*/ */
#if MP_GEN_RANDOM_MAX == 0xffffffff #if MP_GEN_RANDOM_MAX == 0xffffffff
#define MP_GEN_RANDOM_SHIFT 32 #define MP_GEN_RANDOM_SHIFT 32
#elif MP_GEN_RANDOM_MAX == 32767 #elif MP_GEN_RANDOM_MAX == 32767
/* SHRT_MAX */ /* SHRT_MAX */
#define MP_GEN_RANDOM_SHIFT 15 #define MP_GEN_RANDOM_SHIFT 15
#elif MP_GEN_RANDOM_MAX == 2147483647 #elif MP_GEN_RANDOM_MAX == 2147483647
/* INT_MAX */ /* INT_MAX */
#define MP_GEN_RANDOM_SHIFT 31 #define MP_GEN_RANDOM_SHIFT 31
#elif !defined(MP_GEN_RANDOM_SHIFT) #elif !defined(MP_GEN_RANDOM_SHIFT)
#error Thou shalt define their own valid MP_GEN_RANDOM_SHIFT #error Thou shalt define their own valid MP_GEN_RANDOM_SHIFT
#endif #endif
@ -30,48 +30,47 @@
/* makes a pseudo-random int of a given size */ /* makes a pseudo-random int of a given size */
static mp_digit s_gen_random(void) static mp_digit s_gen_random(void)
{ {
mp_digit d = 0, msk = 0; mp_digit d = 0, msk = 0;
do { do {
d <<= MP_GEN_RANDOM_SHIFT; d <<= MP_GEN_RANDOM_SHIFT;
d |= ((mp_digit) MP_GEN_RANDOM()); d |= ((mp_digit) MP_GEN_RANDOM());
msk <<= MP_GEN_RANDOM_SHIFT; msk <<= MP_GEN_RANDOM_SHIFT;
msk |= (MP_MASK & MP_GEN_RANDOM_MAX); msk |= (MP_MASK & MP_GEN_RANDOM_MAX);
} while ((MP_MASK & msk) != MP_MASK); } while ((MP_MASK & msk) != MP_MASK);
d &= MP_MASK; d &= MP_MASK;
return d; return d;
} }
int int mp_rand(mp_int *a, int digits)
mp_rand (mp_int * a, int digits)
{ {
int res; int res;
mp_digit d; mp_digit d;
mp_zero (a); mp_zero(a);
if (digits <= 0) { if (digits <= 0) {
return MP_OKAY; return MP_OKAY;
} }
/* first place a random non-zero digit */ /* first place a random non-zero digit */
do { do {
d = s_gen_random(); d = s_gen_random();
} while (d == 0); } while (d == 0);
if ((res = mp_add_d (a, d, a)) != MP_OKAY) { if ((res = mp_add_d(a, d, a)) != MP_OKAY) {
return res;
}
while (--digits > 0) {
if ((res = mp_lshd (a, 1)) != MP_OKAY) {
return res; return res;
} }
if ((res = mp_add_d (a, s_gen_random(), a)) != MP_OKAY) { while (--digits > 0) {
return res; if ((res = mp_lshd(a, 1)) != MP_OKAY) {
} return res;
} }
return MP_OKAY; if ((res = mp_add_d(a, s_gen_random(), a)) != MP_OKAY) {
return res;
}
}
return MP_OKAY;
} }
#endif #endif

112
bn_mp_read_radix.c
View File

@ -16,73 +16,73 @@
*/ */
/* read a string [ASCII] in a given radix */ /* read a string [ASCII] in a given radix */
int mp_read_radix (mp_int * a, const char *str, int radix) int mp_read_radix(mp_int *a, const char *str, int radix)
{ {
int y, res, neg; int y, res, neg;
char ch; char ch;
/* zero the digit bignum */ /* zero the digit bignum */
mp_zero(a); mp_zero(a);
/* make sure the radix is ok */ /* make sure the radix is ok */
if ((radix < 2) || (radix > 64)) { if ((radix < 2) || (radix > 64)) {
return MP_VAL; return MP_VAL;
} }
/* if the leading digit is a /* if the leading digit is a
* minus set the sign to negative. * minus set the sign to negative.
*/ */
if (*str == '-') { if (*str == '-') {
++str; ++str;
neg = MP_NEG; neg = MP_NEG;
} else { } else {
neg = MP_ZPOS; neg = MP_ZPOS;
} }
/* set the integer to the default of zero */ /* set the integer to the default of zero */
mp_zero (a); mp_zero(a);
/* process each digit of the string */ /* process each digit of the string */
while (*str != '\0') { while (*str != '\0') {
/* if the radix <= 36 the conversion is case insensitive /* if the radix <= 36 the conversion is case insensitive
* this allows numbers like 1AB and 1ab to represent the same value * this allows numbers like 1AB and 1ab to represent the same value
* [e.g. in hex] * [e.g. in hex]
*/ */
ch = (radix <= 36) ? (char)toupper((int)*str) : *str; ch = (radix <= 36) ? (char)toupper((int)*str) : *str;
for (y = 0; y < 64; y++) { for (y = 0; y < 64; y++) {
if (ch == mp_s_rmap[y]) { if (ch == mp_s_rmap[y]) {
break;
}
}
/* if the char was found in the map
* and is less than the given radix add it
* to the number, otherwise exit the loop.
*/
if (y < radix) {
if ((res = mp_mul_d(a, (mp_digit)radix, a)) != MP_OKAY) {
return res;
}
if ((res = mp_add_d(a, (mp_digit)y, a)) != MP_OKAY) {
return res;
}
} else {
break; break;
} }
} ++str;
}
/* if the char was found in the map /* if an illegal character was found, fail. */
* and is less than the given radix add it if (!(*str == '\0' || *str == '\r' || *str == '\n')) {
* to the number, otherwise exit the loop.
*/
if (y < radix) {
if ((res = mp_mul_d (a, (mp_digit) radix, a)) != MP_OKAY) {
return res;
}
if ((res = mp_add_d (a, (mp_digit) y, a)) != MP_OKAY) {
return res;
}
} else {
break;
}
++str;
}
/* if an illegal character was found, fail. */
if (!(*str == '\0' || *str == '\r' || *str == '\n')) {
mp_zero(a); mp_zero(a);
return MP_VAL; return MP_VAL;
} }
/* set the sign only if a != 0 */ /* set the sign only if a != 0 */
if (mp_iszero(a) != MP_YES) { if (mp_iszero(a) != MP_YES) {
a->sign = neg; a->sign = neg;
} }
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

26
bn_mp_read_signed_bin.c
View File

@ -16,23 +16,23 @@
*/ */
/* read signed bin, big endian, first byte is 0==positive or 1==negative */ /* read signed bin, big endian, first byte is 0==positive or 1==negative */
int mp_read_signed_bin (mp_int * a, const unsigned char *b, int c) int mp_read_signed_bin(mp_int *a, const unsigned char *b, int c)
{ {
int res; int res;
/* read magnitude */ /* read magnitude */
if ((res = mp_read_unsigned_bin (a, b + 1, c - 1)) != MP_OKAY) { if ((res = mp_read_unsigned_bin(a, b + 1, c - 1)) != MP_OKAY) {
return res; return res;
} }
/* first byte is 0 for positive, non-zero for negative */ /* first byte is 0 for positive, non-zero for negative */
if (b[0] == 0) { if (b[0] == 0) {
a->sign = MP_ZPOS; a->sign = MP_ZPOS;
} else { } else {
a->sign = MP_NEG; a->sign = MP_NEG;
} }
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

46
bn_mp_read_unsigned_bin.c
View File

@ -16,37 +16,37 @@
*/ */
/* reads a unsigned char array, assumes the msb is stored first [big endian] */ /* reads a unsigned char array, assumes the msb is stored first [big endian] */
int mp_read_unsigned_bin (mp_int * a, const unsigned char *b, int c) int mp_read_unsigned_bin(mp_int *a, const unsigned char *b, int c)
{ {
int res; int res;
/* make sure there are at least two digits */ /* make sure there are at least two digits */
if (a->alloc < 2) { if (a->alloc < 2) {
if ((res = mp_grow(a, 2)) != MP_OKAY) { if ((res = mp_grow(a, 2)) != MP_OKAY) {
return res; return res;
} }
} }
/* zero the int */ /* zero the int */
mp_zero (a); mp_zero(a);
/* read the bytes in */ /* read the bytes in */
while (c-- > 0) { while (c-- > 0) {
if ((res = mp_mul_2d (a, 8, a)) != MP_OKAY) { if ((res = mp_mul_2d(a, 8, a)) != MP_OKAY) {
return res; return res;
} }
#ifndef MP_8BIT #ifndef MP_8BIT
a->dp[0] |= *b++; a->dp[0] |= *b++;
a->used += 1; a->used += 1;
#else #else
a->dp[0] = (*b & MP_MASK); a->dp[0] = (*b & MP_MASK);
a->dp[1] |= ((*b++ >> 7U) & 1); a->dp[1] |= ((*b++ >> 7U) & 1);
a->used += 2; a->used += 2;
#endif #endif
} }
mp_clamp (a); mp_clamp(a);
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

114
bn_mp_reduce.c
View File

@ -19,79 +19,79 @@
* precomputed via mp_reduce_setup. * precomputed via mp_reduce_setup.
* From HAC pp.604 Algorithm 14.42 * From HAC pp.604 Algorithm 14.42
*/ */
int mp_reduce (mp_int * x, mp_int * m, mp_int * mu) int mp_reduce(mp_int *x, mp_int *m, mp_int *mu)
{ {
mp_int q; mp_int q;
int res, um = m->used; int res, um = m->used;
/* q = x */ /* q = x */
if ((res = mp_init_copy (&q, x)) != MP_OKAY) { if ((res = mp_init_copy(&q, x)) != MP_OKAY) {
return res; return res;
} }
/* q1 = x / b**(k-1) */ /* q1 = x / b**(k-1) */
mp_rshd (&q, um - 1); mp_rshd(&q, um - 1);
/* according to HAC this optimization is ok */ /* according to HAC this optimization is ok */
if (((mp_digit) um) > (((mp_digit)1) << (DIGIT_BIT - 1))) { if (((mp_digit) um) > (((mp_digit)1) << (DIGIT_BIT - 1))) {
if ((res = mp_mul (&q, mu, &q)) != MP_OKAY) { if ((res = mp_mul(&q, mu, &q)) != MP_OKAY) {
goto CLEANUP; goto CLEANUP;
} }
} else { } else {
#ifdef BN_S_MP_MUL_HIGH_DIGS_C #ifdef BN_S_MP_MUL_HIGH_DIGS_C
if ((res = s_mp_mul_high_digs (&q, mu, &q, um)) != MP_OKAY) { if ((res = s_mp_mul_high_digs(&q, mu, &q, um)) != MP_OKAY) {
goto CLEANUP; goto CLEANUP;
} }
#elif defined(BN_FAST_S_MP_MUL_HIGH_DIGS_C) #elif defined(BN_FAST_S_MP_MUL_HIGH_DIGS_C)
if ((res = fast_s_mp_mul_high_digs (&q, mu, &q, um)) != MP_OKAY) { if ((res = fast_s_mp_mul_high_digs(&q, mu, &q, um)) != MP_OKAY) {
goto CLEANUP; goto CLEANUP;
} }
#else #else
{ {
res = MP_VAL; res = MP_VAL;
goto CLEANUP; goto CLEANUP;
} }
#endif #endif
} }
/* q3 = q2 / b**(k+1) */ /* q3 = q2 / b**(k+1) */
mp_rshd (&q, um + 1); mp_rshd(&q, um + 1);
/* x = x mod b**(k+1), quick (no division) */ /* x = x mod b**(k+1), quick (no division) */
if ((res = mp_mod_2d (x, DIGIT_BIT * (um + 1), x)) != MP_OKAY) { if ((res = mp_mod_2d(x, DIGIT_BIT * (um + 1), x)) != MP_OKAY) {
goto CLEANUP;
}
/* q = q * m mod b**(k+1), quick (no division) */
if ((res = s_mp_mul_digs (&q, m, &q, um + 1)) != MP_OKAY) {
goto CLEANUP;
}
/* x = x - q */
if ((res = mp_sub (x, &q, x)) != MP_OKAY) {
goto CLEANUP;
}
/* If x < 0, add b**(k+1) to it */
if (mp_cmp_d (x, 0) == MP_LT) {
mp_set (&q, 1);
if ((res = mp_lshd (&q, um + 1)) != MP_OKAY)
goto CLEANUP; goto CLEANUP;
if ((res = mp_add (x, &q, x)) != MP_OKAY) }
goto CLEANUP;
}
/* Back off if it's too big */ /* q = q * m mod b**(k+1), quick (no division) */
while (mp_cmp (x, m) != MP_LT) { if ((res = s_mp_mul_digs(&q, m, &q, um + 1)) != MP_OKAY) {
if ((res = s_mp_sub (x, m, x)) != MP_OKAY) {
goto CLEANUP; goto CLEANUP;
} }
}
/* x = x - q */
if ((res = mp_sub(x, &q, x)) != MP_OKAY) {
goto CLEANUP;
}
/* If x < 0, add b**(k+1) to it */
if (mp_cmp_d(x, 0) == MP_LT) {
mp_set(&q, 1);
if ((res = mp_lshd(&q, um + 1)) != MP_OKAY)
goto CLEANUP;
if ((res = mp_add(x, &q, x)) != MP_OKAY)
goto CLEANUP;
}
/* Back off if it's too big */
while (mp_cmp(x, m) != MP_LT) {
if ((res = s_mp_sub(x, m, x)) != MP_OKAY) {
goto CLEANUP;
}
}
CLEANUP: CLEANUP:
mp_clear (&q); mp_clear(&q);
return res; return res;
} }
#endif #endif

8
bn_mp_reduce_2k_setup.c
View File

@ -20,22 +20,22 @@ int mp_reduce_2k_setup(mp_int *a, mp_digit *d)
{ {
int res, p; int res, p;
mp_int tmp; mp_int tmp;
if ((res = mp_init(&tmp)) != MP_OKAY) { if ((res = mp_init(&tmp)) != MP_OKAY) {
return res; return res;
} }
p = mp_count_bits(a); p = mp_count_bits(a);
if ((res = mp_2expt(&tmp, p)) != MP_OKAY) { if ((res = mp_2expt(&tmp, p)) != MP_OKAY) {
mp_clear(&tmp); mp_clear(&tmp);
return res; return res;
} }
if ((res = s_mp_sub(&tmp, a, &tmp)) != MP_OKAY) { if ((res = s_mp_sub(&tmp, a, &tmp)) != MP_OKAY) {
mp_clear(&tmp); mp_clear(&tmp);
return res; return res;
} }
*d = tmp.dp[0]; *d = tmp.dp[0];
mp_clear(&tmp); mp_clear(&tmp);
return MP_OKAY; return MP_OKAY;

8
bn_mp_reduce_2k_setup_l.c
View File

@ -20,19 +20,19 @@ int mp_reduce_2k_setup_l(mp_int *a, mp_int *d)
{ {
int res; int res;
mp_int tmp; mp_int tmp;
if ((res = mp_init(&tmp)) != MP_OKAY) { if ((res = mp_init(&tmp)) != MP_OKAY) {
return res; return res;
} }
if ((res = mp_2expt(&tmp, mp_count_bits(a))) != MP_OKAY) { if ((res = mp_2expt(&tmp, mp_count_bits(a))) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = s_mp_sub(&tmp, a, d)) != MP_OKAY) { if ((res = s_mp_sub(&tmp, a, d)) != MP_OKAY) {
goto ERR; goto ERR;
} }
ERR: ERR:
mp_clear(&tmp); mp_clear(&tmp);
return res; return res;

20
bn_mp_reduce_is_2k.c
View File

@ -20,7 +20,7 @@ int mp_reduce_is_2k(mp_int *a)
{ {
int ix, iy, iw; int ix, iy, iw;
mp_digit iz; mp_digit iz;
if (a->used == 0) { if (a->used == 0) {
return MP_NO; return MP_NO;
} else if (a->used == 1) { } else if (a->used == 1) {
@ -29,17 +29,17 @@ int mp_reduce_is_2k(mp_int *a)
iy = mp_count_bits(a); iy = mp_count_bits(a);
iz = 1; iz = 1;
iw = 1; iw = 1;
/* Test every bit from the second digit up, must be 1 */ /* Test every bit from the second digit up, must be 1 */
for (ix = DIGIT_BIT; ix < iy; ix++) { for (ix = DIGIT_BIT; ix < iy; ix++) {
if ((a->dp[iw] & iz) == 0) { if ((a->dp[iw] & iz) == 0) {
return MP_NO; return MP_NO;
} }
iz <<= 1; iz <<= 1;
if (iz > (mp_digit)MP_MASK) { if (iz > (mp_digit)MP_MASK) {
++iw; ++iw;
iz = 1; iz = 1;
} }
} }
} }
return MP_YES; return MP_YES;

10
bn_mp_reduce_is_2k_l.c
View File

@ -19,7 +19,7 @@
int mp_reduce_is_2k_l(mp_int *a) int mp_reduce_is_2k_l(mp_int *a)
{ {
int ix, iy; int ix, iy;
if (a->used == 0) { if (a->used == 0) {
return MP_NO; return MP_NO;
} else if (a->used == 1) { } else if (a->used == 1) {
@ -27,12 +27,12 @@ int mp_reduce_is_2k_l(mp_int *a)
} else if (a->used > 1) { } else if (a->used > 1) {
/* if more than half of the digits are -1 we're sold */ /* if more than half of the digits are -1 we're sold */
for (iy = ix = 0; ix < a->used; ix++) { for (iy = ix = 0; ix < a->used; ix++) {
if (a->dp[ix] == MP_MASK) { if (a->dp[ix] == MP_MASK) {
++iy; ++iy;
} }
} }
return (iy >= (a->used/2)) ? MP_YES : MP_NO; return (iy >= (a->used/2)) ? MP_YES : MP_NO;
} }
return MP_NO; return MP_NO;
} }

14
bn_mp_reduce_setup.c
View File

@ -18,14 +18,14 @@
/* pre-calculate the value required for Barrett reduction /* pre-calculate the value required for Barrett reduction
* For a given modulus "b" it calulates the value required in "a" * For a given modulus "b" it calulates the value required in "a"
*/ */
int mp_reduce_setup (mp_int * a, mp_int * b) int mp_reduce_setup(mp_int *a, mp_int *b)
{ {
int res; int res;
if ((res = mp_2expt (a, b->used * 2 * DIGIT_BIT)) != MP_OKAY) { if ((res = mp_2expt(a, b->used * 2 * DIGIT_BIT)) != MP_OKAY) {
return res; return res;
} }
return mp_div (a, b, a, NULL); return mp_div(a, b, a, NULL);
} }
#endif #endif

76
bn_mp_rshd.c
View File

@ -16,54 +16,54 @@
*/ */
/* shift right a certain amount of digits */ /* shift right a certain amount of digits */
void mp_rshd (mp_int * a, int b) void mp_rshd(mp_int *a, int b)
{ {
int x; int x;
/* if b <= 0 then ignore it */ /* if b <= 0 then ignore it */
if (b <= 0) { if (b <= 0) {
return; return;
} }
/* if b > used then simply zero it and return */ /* if b > used then simply zero it and return */
if (a->used <= b) { if (a->used <= b) {
mp_zero (a); mp_zero(a);
return; return;
} }
{ {
mp_digit *bottom, *top; mp_digit *bottom, *top;
/* shift the digits down */ /* shift the digits down */
/* bottom */ /* bottom */
bottom = a->dp; bottom = a->dp;
/* top [offset into digits] */ /* top [offset into digits] */
top = a->dp + b; top = a->dp + b;
/* this is implemented as a sliding window where /* this is implemented as a sliding window where
* the window is b-digits long and digits from * the window is b-digits long and digits from
* the top of the window are copied to the bottom * the top of the window are copied to the bottom
* *
* e.g. * e.g.
b-2 | b-1 | b0 | b1 | b2 | ... | bb | ----> b-2 | b-1 | b0 | b1 | b2 | ... | bb | ---->
/\ | ----> /\ | ---->
\-------------------/ ----> \-------------------/ ---->
*/ */
for (x = 0; x < (a->used - b); x++) { for (x = 0; x < (a->used - b); x++) {
*bottom++ = *top++; *bottom++ = *top++;
} }
/* zero the top digits */ /* zero the top digits */
for (; x < a->used; x++) { for (; x < a->used; x++) {
*bottom++ = 0; *bottom++ = 0;
} }
} }
/* remove excess digits */ /* remove excess digits */
a->used -= b; a->used -= b;
} }
#endif #endif

8
bn_mp_set.c
View File

@ -16,11 +16,11 @@
*/ */
/* set to a digit */ /* set to a digit */
void mp_set (mp_int * a, mp_digit b) void mp_set(mp_int *a, mp_digit b)
{ {
mp_zero (a); mp_zero(a);
a->dp[0] = b & MP_MASK; a->dp[0] = b & MP_MASK;
a->used = (a->dp[0] != 0) ? 1 : 0; a->used = (a->dp[0] != 0) ? 1 : 0;
} }
#endif #endif

38
bn_mp_set_int.c
View File

@ -16,30 +16,30 @@
*/ */
/* set a 32-bit const */ /* set a 32-bit const */
int mp_set_int (mp_int * a, unsigned long b) int mp_set_int(mp_int *a, unsigned long b)
{ {
int x, res; int x, res;
mp_zero (a); mp_zero(a);
/* set four bits at a time */
for (x = 0; x < 8; x++) {
/* shift the number up four bits */
if ((res = mp_mul_2d (a, 4, a)) != MP_OKAY) {
return res;
}
/* OR in the top four bits of the source */ /* set four bits at a time */
a->dp[0] |= (b >> 28) & 15; for (x = 0; x < 8; x++) {
/* shift the number up four bits */
if ((res = mp_mul_2d(a, 4, a)) != MP_OKAY) {
return res;
}
/* shift the source up to the next four bits */ /* OR in the top four bits of the source */
b <<= 4; a->dp[0] |= (b >> 28) & 15;
/* ensure that digits are not clamped off */ /* shift the source up to the next four bits */
a->used += 1; b <<= 4;
}
mp_clamp (a); /* ensure that digits are not clamped off */
return MP_OKAY; a->used += 1;
}
mp_clamp(a);
return MP_OKAY;
} }
#endif #endif

32
bn_mp_shrink.c
View File

@ -16,23 +16,23 @@
*/ */
/* shrink a bignum */ /* shrink a bignum */
int mp_shrink (mp_int * a) int mp_shrink(mp_int *a)
{ {
mp_digit *tmp; mp_digit *tmp;
int used = 1; int used = 1;
if(a->used > 0) { if (a->used > 0) {
used = a->used; used = a->used;
} }
if (a->alloc != used) { if (a->alloc != used) {
if ((tmp = OPT_CAST(mp_digit) XREALLOC (a->dp, sizeof (mp_digit) * used)) == NULL) { if ((tmp = OPT_CAST(mp_digit) XREALLOC(a->dp, sizeof(mp_digit) * used)) == NULL) {
return MP_MEM; return MP_MEM;
} }
a->dp = tmp; a->dp = tmp;
a->alloc = used; a->alloc = used;
} }
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

4
bn_mp_signed_bin_size.c
View File

@ -16,9 +16,9 @@
*/ */
/* get the size for an signed equivalent */ /* get the size for an signed equivalent */
int mp_signed_bin_size (mp_int * a) int mp_signed_bin_size(mp_int *a)
{ {
return 1 + mp_unsigned_bin_size (a); return 1 + mp_unsigned_bin_size(a);
} }
#endif #endif

49
bn_mp_sqr.c
View File

@ -16,42 +16,41 @@
*/ */
/* computes b = a*a */ /* computes b = a*a */
int int mp_sqr(mp_int *a, mp_int *b)
mp_sqr (mp_int * a, mp_int * b)
{ {
int res; int res;
#ifdef BN_MP_TOOM_SQR_C #ifdef BN_MP_TOOM_SQR_C
/* use Toom-Cook? */ /* use Toom-Cook? */
if (a->used >= TOOM_SQR_CUTOFF) { if (a->used >= TOOM_SQR_CUTOFF) {
res = mp_toom_sqr(a, b); res = mp_toom_sqr(a, b);
/* Karatsuba? */ /* Karatsuba? */
} else } else
#endif #endif
#ifdef BN_MP_KARATSUBA_SQR_C #ifdef BN_MP_KARATSUBA_SQR_C
if (a->used >= KARATSUBA_SQR_CUTOFF) { if (a->used >= KARATSUBA_SQR_CUTOFF) {
res = mp_karatsuba_sqr (a, b); res = mp_karatsuba_sqr(a, b);
} else } else
#endif #endif
{ {
#ifdef BN_FAST_S_MP_SQR_C #ifdef BN_FAST_S_MP_SQR_C
/* can we use the fast comba multiplier? */ /* can we use the fast comba multiplier? */
if ((((a->used * 2) + 1) < MP_WARRAY) && if ((((a->used * 2) + 1) < MP_WARRAY) &&
(a->used < (a->used <
(1 << (((sizeof(mp_word) * CHAR_BIT) - (2 * DIGIT_BIT)) - 1)))) { (1 << (((sizeof(mp_word) * CHAR_BIT) - (2 * DIGIT_BIT)) - 1)))) {
res = fast_s_mp_sqr (a, b); res = fast_s_mp_sqr(a, b);
} else } else
#endif #endif
{ {
#ifdef BN_S_MP_SQR_C #ifdef BN_S_MP_SQR_C
res = s_mp_sqr (a, b); res = s_mp_sqr(a, b);
#else #else
res = MP_VAL; res = MP_VAL;
#endif #endif
} }
} }
b->sign = MP_ZPOS; b->sign = MP_ZPOS;
return res; return res;
} }
#endif #endif

27
bn_mp_sqrmod.c
View File

@ -16,23 +16,22 @@
*/ */
/* c = a * a (mod b) */ /* c = a * a (mod b) */
int int mp_sqrmod(mp_int *a, mp_int *b, mp_int *c)
mp_sqrmod (mp_int * a, mp_int * b, mp_int * c)
{ {
int res; int res;
mp_int t; mp_int t;
if ((res = mp_init (&t)) != MP_OKAY) { if ((res = mp_init(&t)) != MP_OKAY) {
return res; return res;
} }
if ((res = mp_sqr (a, &t)) != MP_OKAY) { if ((res = mp_sqr(a, &t)) != MP_OKAY) {
mp_clear (&t); mp_clear(&t);
return res; return res;
} }
res = mp_mod (&t, b, c); res = mp_mod(&t, b, c);
mp_clear (&t); mp_clear(&t);
return res; return res;
} }
#endif #endif

90
bn_mp_sqrt.c
View File

@ -16,62 +16,64 @@
*/ */
/* this function is less generic than mp_n_root, simpler and faster */ /* this function is less generic than mp_n_root, simpler and faster */
int mp_sqrt(mp_int *arg, mp_int *ret) int mp_sqrt(mp_int *arg, mp_int *ret)
{ {
int res; int res;
mp_int t1,t2; mp_int t1, t2;
/* must be positive */ /* must be positive */
if (arg->sign == MP_NEG) { if (arg->sign == MP_NEG) {
return MP_VAL; return MP_VAL;
} }
/* easy out */ /* easy out */
if (mp_iszero(arg) == MP_YES) { if (mp_iszero(arg) == MP_YES) {
mp_zero(ret); mp_zero(ret);
return MP_OKAY; return MP_OKAY;
} }
if ((res = mp_init_copy(&t1, arg)) != MP_OKAY) { if ((res = mp_init_copy(&t1, arg)) != MP_OKAY) {
return res; return res;
} }
if ((res = mp_init(&t2)) != MP_OKAY) { if ((res = mp_init(&t2)) != MP_OKAY) {
goto E2; goto E2;
} }
/* First approx. (not very bad for large arg) */ /* First approx. (not very bad for large arg) */
mp_rshd (&t1,t1.used/2); mp_rshd(&t1, t1.used/2);
/* t1 > 0 */ /* t1 > 0 */
if ((res = mp_div(arg,&t1,&t2,NULL)) != MP_OKAY) { if ((res = mp_div(arg, &t1, &t2, NULL)) != MP_OKAY) {
goto E1;
}
if ((res = mp_add(&t1,&t2,&t1)) != MP_OKAY) {
goto E1;
}
if ((res = mp_div_2(&t1,&t1)) != MP_OKAY) {
goto E1;
}
/* And now t1 > sqrt(arg) */
do {
if ((res = mp_div(arg,&t1,&t2,NULL)) != MP_OKAY) {
goto E1; goto E1;
} }
if ((res = mp_add(&t1,&t2,&t1)) != MP_OKAY) { if ((res = mp_add(&t1, &t2, &t1)) != MP_OKAY) {
goto E1; goto E1;
} }
if ((res = mp_div_2(&t1,&t1)) != MP_OKAY) { if ((res = mp_div_2(&t1, &t1)) != MP_OKAY) {
goto E1; goto E1;
} }
/* t1 >= sqrt(arg) >= t2 at this point */ /* And now t1 > sqrt(arg) */
} while (mp_cmp_mag(&t1,&t2) == MP_GT); do {
if ((res = mp_div(arg, &t1, &t2, NULL)) != MP_OKAY) {
goto E1;
}
if ((res = mp_add(&t1, &t2, &t1)) != MP_OKAY) {
goto E1;
}
if ((res = mp_div_2(&t1, &t1)) != MP_OKAY) {
goto E1;
}
/* t1 >= sqrt(arg) >= t2 at this point */
} while (mp_cmp_mag(&t1, &t2) == MP_GT);
mp_exch(&t1,ret); mp_exch(&t1, ret);
E1: mp_clear(&t2); E1:
E2: mp_clear(&t1); mp_clear(&t2);
return res; E2:
mp_clear(&t1);
return res;
} }
#endif #endif

Some files were not shown because too many files have changed in this diff Show More