dropbear: pre_gen/mpi.c comparison

comparison pre_gen/mpi.c @ 142:d29b64170cf0 libtommath-orig

import of libtommath 0.32

author	Matt Johnston <matt@ucc.asn.au>
date	Sun, 19 Dec 2004 11:33:56 +0000
parents	86e0b50a9b58
children	d8254fc979e9

comparison

equal deleted inserted replaced

-:e1037a1e12e7
+:d29b64170cf0
 /* Start: bn_error.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_ERROR_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 static const struct {
 int code;
 char *msg;
 } msgs[] = {
 /* generic reply for invalid code */
 return "Invalid error code";
 }
+#endif
 /* End: bn_error.c */
 /* Start: bn_fast_mp_invmod.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_FAST_MP_INVMOD_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* computes the modular inverse via binary extended euclidean algorithm,
 * that is c = 1/a mod b
 *
-* Based on mp_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
 */
 int
 fast_mp_invmod (mp_int * a, mp_int * b, mp_int * c)
 {
 res = MP_OKAY;
 __ERR:mp_clear_multi (&x, &y, &u, &v, &B, &D, NULL);
 return res;
 }
+#endif
 /* End: bn_fast_mp_invmod.c */
 /* Start: bn_fast_mp_montgomery_reduce.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_FAST_MP_MONTGOMERY_REDUCE_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* computes xR**-1 == x (mod N) via Montgomery Reduction
 *
-* This is an optimized implementation of mp_montgomery_reduce
+* This is an optimized implementation of montgomery_reduce
 * which uses the comba method to quickly calculate the columns of the
 * reduction.
 *
 * Based on Algorithm 14.32 on pp.601 of HAC.
 */
 if (mp_cmp_mag (x, n) != MP_LT) {
 return s_mp_sub (x, n, x);
 }
 return MP_OKAY;
 }
+#endif
 /* End: bn_fast_mp_montgomery_reduce.c */
 /* Start: bn_fast_s_mp_mul_digs.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_FAST_S_MP_MUL_DIGS_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* Fast (comba) multiplier
 *
 * This is the fast column-array [comba] multiplier.  It is
 * designed to compute the columns of the product first
 *
 */
 int
 fast_s_mp_mul_digs (mp_int * a, mp_int * b, mp_int * c, int digs)
 {
-int     olduse, res, pa, ix;
+int     olduse, res, pa, ix, iz;
-mp_word W[MP_WARRAY];
+mp_digit W[MP_WARRAY];
+register mp_word  _W;
 /* grow the destination as required */
 if (c->alloc < digs) {
 if ((res = mp_grow (c, digs)) != MP_OKAY) {
 return res;
 }
 }
-/* clear temp buf (the columns) */
+/* number of output digits to produce */
-memset (W, 0, sizeof (mp_word) * digs);
+pa = MIN(digs, a->used + b->used);
-/* calculate the columns */
+/* clear the carry */
-pa = a->used;
+_W = 0;
-for (ix = 0; ix < pa; ix++) {
+for (ix = 0; ix <= pa; ix++) {
-/* this multiplier has been modified to allow you to
+int      tx, ty;
-* control how many digits of output are produced.
+int      iy;
-* So at most we want to make upto "digs" digits of output.
+mp_digit *tmpx, *tmpy;
-*
-* this adds products to distinct columns (at ix+iy) of W
+/* get offsets into the two bignums */
-* note that each step through the loop is not dependent on
+ty = MIN(b->used-1, ix);
-* the previous which means the compiler can easily unroll
+tx = ix - ty;
-* the loop without scheduling problems
-*/
+/* setup temp aliases */
-{
+tmpx = a->dp + tx;
-register mp_digit tmpx, *tmpy;
+tmpy = b->dp + ty;
-register mp_word *_W;
-register int iy, pb;
+/* this is the number of times the loop will iterrate, essentially its
+while (tx++ < a->used && ty-- >= 0) { ... }
-/* alias for the the word on the left e.g. A[ix] * A[iy] */
-tmpx = a->dp[ix];
-/* alias for the right side */
-tmpy = b->dp;
-/* alias for the columns, each step through the loop adds a new
-term to each column
 */
-_W = W + ix;
+iy = MIN(a->used-tx, ty+1);
-/* the number of digits is limited by their placement.  E.g.
+/* execute loop */
-we avoid multiplying digits that will end up above the # of
+for (iz = 0; iz < iy; ++iz) {
-digits of precision requested
+_W += ((mp_word)*tmpx++)*((mp_word)*tmpy--);
-*/
-pb = MIN (b->used, digs - ix);
-for (iy = 0; iy < pb; iy++) {
-*_W++ += ((mp_word)tmpx) * ((mp_word)*tmpy++);
 }
-}
+/* store term */
+W[ix] = ((mp_digit)_W) & MP_MASK;
+/* make next carry */
+_W = _W >> ((mp_word)DIGIT_BIT);
 }
 /* setup dest */
-olduse = c->used;
+olduse  = c->used;
 c->used = digs;
 {
 register mp_digit *tmpc;
-/* At this point W[] contains the sums of each column.  To get the
-* correct result we must take the extra bits from each column and
-* carry them down
-*
-* Note that while this adds extra code to the multiplier it
-* saves time since the carry propagation is removed from the
-* above nested loop.This has the effect of reducing the work
-* from N*(N+N*c)==N**2 + c*N**2 to N**2 + N*c where c is the
-* cost of the shifting.  On very small numbers this is slower
-* but on most cryptographic size numbers it is faster.
-*
-* In this particular implementation we feed the carries from
-* behind which means when the loop terminates we still have one
-* last digit to copy
-*/
 tmpc = c->dp;
-for (ix = 1; ix < digs; ix++) {
+for (ix = 0; ix < digs; ix++) {
-/* forward the carry from the previous temp */
-W[ix] += (W[ix - 1] >> ((mp_word) DIGIT_BIT));
 /* now extract the previous digit [below the carry] */
-*tmpc++ = (mp_digit) (W[ix - 1] & ((mp_word) MP_MASK));
+*tmpc++ = W[ix];
 }
-/* fetch the last digit */
-*tmpc++ = (mp_digit) (W[digs - 1] & ((mp_word) MP_MASK));
 /* clear unused digits [that existed in the old copy of c] */
 for (; ix < olduse; ix++) {
 *tmpc++ = 0;
 }
 }
 mp_clamp (c);
 return MP_OKAY;
 }
+#endif
 /* End: bn_fast_s_mp_mul_digs.c */
 /* Start: bn_fast_s_mp_mul_high_digs.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_FAST_S_MP_MUL_HIGH_DIGS_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
-/* this is a modified version of fast_s_mp_mul_digs that only produces
-* output digits *above* digs.  See the comments for fast_s_mp_mul_digs
+/* this is a modified version of fast_s_mul_digs that only produces
+* output digits *above* digs.  See the comments for fast_s_mul_digs
 * to see how it works.
 *
 * This is used in the Barrett reduction since for one of the multiplications
 * only the higher digits were needed.  This essentially halves the work.
 *
 * 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     oldused, newused, res, pa, pb, ix;
+int     olduse, res, pa, ix, iz;
-mp_word W[MP_WARRAY];
+mp_digit W[MP_WARRAY];
+mp_word  _W;
-/* calculate size of product and allocate more space if required */
-newused = a->used + b->used + 1;
+/* grow the destination as required */
-if (c->alloc < newused) {
+pa = a->used + b->used;
-if ((res = mp_grow (c, newused)) != MP_OKAY) {
+if (c->alloc < pa) {
+if ((res = mp_grow (c, pa)) != MP_OKAY) {
 return res;
 }
 }
-/* like the other comba method we compute the columns first */
+/* number of output digits to produce */
-pa = a->used;
+pa = a->used + b->used;
-pb = b->used;
+_W = 0;
-memset (W + digs, 0, (pa + pb + 1 - digs) * sizeof (mp_word));
+for (ix = digs; ix <= pa; ix++) {
-for (ix = 0; ix < pa; ix++) {
+int      tx, ty, iy;
-{
+mp_digit *tmpx, *tmpy;
-register mp_digit tmpx, *tmpy;
-register int iy;
+/* get offsets into the two bignums */
-register mp_word *_W;
+ty = MIN(b->used-1, ix);
+tx = ix - ty;
-/* work todo, that is we only calculate digits that are at "digs" or above  */
-iy = digs - ix;
+/* setup temp aliases */
+tmpx = a->dp + tx;
-/* copy of word on the left of A[ix] * B[iy] */
+tmpy = b->dp + ty;
-tmpx = a->dp[ix];
+/* this is the number of times the loop will iterrate, essentially its
-/* alias for right side */
+while (tx++ < a->used && ty-- >= 0) { ... }
-tmpy = b->dp + iy;
-/* alias for the columns of output.  Offset to be equal to or above the
-* smallest digit place requested
 */
-_W = W + digs;
+iy = MIN(a->used-tx, ty+1);
-/* skip cases below zero where ix > digs */
+/* execute loop */
-if (iy < 0) {
+for (iz = 0; iz < iy; iz++) {
-iy    = abs(iy);
+_W += ((mp_word)*tmpx++)*((mp_word)*tmpy--);
-tmpy += iy;
-_W   += iy;
-iy    = 0;
 }
-/* compute column products for digits above the minimum */
+/* store term */
-for (; iy < pb; iy++) {
+W[ix] = ((mp_digit)_W) & MP_MASK;
-*_W++ += ((mp_word) tmpx) * ((mp_word)*tmpy++);
-}
+/* make next carry */
-}
+_W = _W >> ((mp_word)DIGIT_BIT);
 }
 /* setup dest */
-oldused = c->used;
+olduse  = c->used;
-c->used = newused;
+c->used = pa;
-/* now convert the array W downto what we need
+{
-*
+register mp_digit *tmpc;
-* See comments in bn_fast_s_mp_mul_digs.c
-*/
+tmpc = c->dp + digs;
-for (ix = digs + 1; ix < newused; ix++) {
+for (ix = digs; ix <= pa; ix++) {
-W[ix] += (W[ix - 1] >> ((mp_word) DIGIT_BIT));
+/* now extract the previous digit [below the carry] */
-c->dp[ix - 1] = (mp_digit) (W[ix - 1] & ((mp_word) MP_MASK));
+*tmpc++ = W[ix];
 }
-c->dp[newused - 1] = (mp_digit) (W[newused - 1] & ((mp_word) MP_MASK));
+/* clear unused digits [that existed in the old copy of c] */
-for (; ix < oldused; ix++) {
+for (; ix < olduse; ix++) {
-c->dp[ix] = 0;
+*tmpc++ = 0;
+}
 }
 mp_clamp (c);
 return MP_OKAY;
 }
+#endif
 /* End: bn_fast_s_mp_mul_high_digs.c */
 /* Start: bn_fast_s_mp_sqr.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_FAST_S_MP_SQR_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* fast squaring
 *
 * This is the comba method where the columns of the product
 * are computed first then the carries are computed.  This
 * because 64-bit shifts are slow!
 *
 * Based on Algorithm 14.16 on pp.597 of HAC.
 *
 */
+/* the jist of squaring...
+you do like mult except the offset of the tmpx [one that starts closer to zero]
+can't equal the offset of tmpy.  So basically you set up iy like before then you min it with
+(ty-tx) so that it never happens.  You double all those you add in the inner loop
+After that loop you do the squares and add them in.
+Remove W2 and don't memset W
+*/
 int fast_s_mp_sqr (mp_int * a, mp_int * b)
 {
-int     olduse, newused, res, ix, pa;
+int       olduse, res, pa, ix, iz;
-mp_word W2[MP_WARRAY], W[MP_WARRAY];
+mp_digit   W[MP_WARRAY], *tmpx;
+mp_word   W1;
-/* calculate size of product and allocate as required */
-pa = a->used;
+/* grow the destination as required */
-newused = pa + pa + 1;
+pa = a->used + a->used;
-if (b->alloc < newused) {
+if (b->alloc < pa) {
-if ((res = mp_grow (b, newused)) != MP_OKAY) {
+if ((res = mp_grow (b, pa)) != MP_OKAY) {
 return res;
 }
 }
-/* zero temp buffer (columns)
+/* number of output digits to produce */
-* Note that there are two buffers.  Since squaring requires
+W1 = 0;
-* a outer and inner product and the inner product requires
+for (ix = 0; ix <= pa; ix++) {
-* computing a product and doubling it (a relatively expensive
+int      tx, ty, iy;
-* op to perform n**2 times if you don't have to) the inner and
+mp_word  _W;
-* outer products are computed in different buffers.  This way
+mp_digit *tmpy;
-* the inner product can be doubled using n doublings instead of
-* n**2
+/* clear counter */
-*/
+_W = 0;
-memset (W,  0, newused * sizeof (mp_word));
-memset (W2, 0, newused * sizeof (mp_word));
+/* get offsets into the two bignums */
+ty = MIN(a->used-1, ix);
-/* This computes the inner product.  To simplify the inner N**2 loop
+tx = ix - ty;
-* the multiplication by two is done afterwards in the N loop.
-*/
+/* setup temp aliases */
-for (ix = 0; ix < pa; ix++) {
+tmpx = a->dp + tx;
-/* compute the outer product
+tmpy = a->dp + ty;
-*
-* Note that every outer product is computed
+/* this is the number of times the loop will iterrate, essentially its
-* for a particular column only once which means that
+while (tx++ < a->used && ty-- >= 0) { ... }
-* there is no need todo a double precision addition
+*/
-* into the W2[] array.
+iy = MIN(a->used-tx, ty+1);
-*/
-W2[ix + ix] = ((mp_word)a->dp[ix]) * ((mp_word)a->dp[ix]);
+/* now for squaring tx can never equal ty
+* we halve the distance since they approach at a rate of 2x
-{
+* and we have to round because odd cases need to be executed
-register mp_digit tmpx, *tmpy;
+*/
-register mp_word *_W;
+iy = MIN(iy, (ty-tx+1)>>1);
-register int iy;
+/* execute loop */
-/* copy of left side */
+for (iz = 0; iz < iy; iz++) {
-tmpx = a->dp[ix];
+_W += ((mp_word)*tmpx++)*((mp_word)*tmpy--);
-/* alias for right side */
-tmpy = a->dp + (ix + 1);
-/* the column to store the result in */
-_W = W + (ix + ix + 1);
-/* inner products */
-for (iy = ix + 1; iy < pa; iy++) {
-*_W++ += ((mp_word)tmpx) * ((mp_word)*tmpy++);
 }
-}
+/* double the inner product and add carry */
+_W = _W + _W + W1;
+/* even columns have the square term in them */
+if ((ix&1) == 0) {
+_W += ((mp_word)a->dp[ix>>1])*((mp_word)a->dp[ix>>1]);
+}
+/* store it */
+W[ix] = _W;
+/* make next carry */
+W1 = _W >> ((mp_word)DIGIT_BIT);
 }
 /* setup dest */
 olduse  = b->used;
-b->used = newused;
+b->used = a->used+a->used;
-/* now compute digits
-*
-* We have to double the inner product sums, add in the
-* outer product sums, propagate carries and convert
-* to single precision.
-*/
 {
-register mp_digit *tmpb;
+mp_digit *tmpb;
-/* double first value, since the inner products are
-* half of what they should be
-*/
-W[0] += W[0] + W2[0];
 tmpb = b->dp;
-for (ix = 1; ix < newused; ix++) {
+for (ix = 0; ix < pa; ix++) {
-/* double/add next digit */
+*tmpb++ = W[ix] & MP_MASK;
-W[ix] += W[ix] + W2[ix];
+}
-/* propagate carry forwards [from the previous digit] */
+/* clear unused digits [that existed in the old copy of c] */
-W[ix] = W[ix] + (W[ix - 1] >> ((mp_word) DIGIT_BIT));
-/* store the current digit now that the carry isn't
-* needed
-*/
-*tmpb++ = (mp_digit) (W[ix - 1] & ((mp_word) MP_MASK));
-}
-/* set the last value.  Note even if the carry is zero
-* this is required since the next step will not zero
-* it if b originally had a value at b->dp[2*a.used]
-*/
-*tmpb++ = (mp_digit) (W[(newused) - 1] & ((mp_word) MP_MASK));
-/* clear high digits of b if there were any originally */
 for (; ix < olduse; ix++) {
 *tmpb++ = 0;
 }
 }
 mp_clamp (b);
 return MP_OKAY;
 }
+#endif
 /* End: bn_fast_s_mp_sqr.c */
 /* Start: bn_mp_2expt.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_2EXPT_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* computes a = 2**b
 *
 * Simple algorithm which zeroes the int, grows it then just sets one bit
 * as required.
 /* set the used count of where the bit will go */
 a->used = b / DIGIT_BIT + 1;
 /* put the single bit in its place */
-a->dp[b / DIGIT_BIT] = 1 << (b % DIGIT_BIT);
+a->dp[b / DIGIT_BIT] = ((mp_digit)1) << (b % DIGIT_BIT);
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_2expt.c */
 /* Start: bn_mp_abs.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_ABS_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* b = |a|
 *
 * Simple function copies the input and fixes the sign to positive
 */
 /* force the sign of b to positive */
 b->sign = MP_ZPOS;
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_abs.c */
 /* Start: bn_mp_add.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_ADD_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* high level addition (handles signs) */
 int mp_add (mp_int * a, mp_int * b, mp_int * c)
 {
 int     sa, sb, res;
 }
 }
 return res;
 }
+#endif
 /* End: bn_mp_add.c */
 /* Start: bn_mp_add_d.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_ADD_D_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* single digit addition */
 int
 mp_add_d (mp_int * a, mp_digit b, mp_int * c)
 {
 mp_clamp(c);
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_add_d.c */
 /* Start: bn_mp_addmod.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_ADDMOD_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* d = a + b (mod c) */
 int
 mp_addmod (mp_int * a, mp_int * b, mp_int * c, mp_int * d)
 {
 }
 res = mp_mod (&t, c, d);
 mp_clear (&t);
 return res;
 }
+#endif
 /* End: bn_mp_addmod.c */
 /* Start: bn_mp_and.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_AND_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* AND two ints together */
 int
 mp_and (mp_int * a, mp_int * b, mp_int * c)
 {
 mp_clamp (&t);
 mp_exch (c, &t);
 mp_clear (&t);
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_and.c */
 /* Start: bn_mp_clamp.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_CLAMP_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* trim unused digits
 *
 * This is used to ensure that leading zero digits are
 * trimed and the leading "used" digit will be non-zero
 /* reset the sign flag if used == 0 */
 if (a->used == 0) {
 a->sign = MP_ZPOS;
 }
 }
+#endif
 /* End: bn_mp_clamp.c */
 /* Start: bn_mp_clear.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_CLEAR_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* clear one (frees)  */
 void
 mp_clear (mp_int * a)
 {
+int i;
 /* only do anything if a hasn't been freed previously */
 if (a->dp != NULL) {
 /* first zero the digits */
-memset (a->dp, 0, sizeof (mp_digit) * a->used);
+for (i = 0; i < a->used; i++) {
+a->dp[i] = 0;
+}
 /* free ram */
 XFREE(a->dp);
 /* reset members to make debugging easier */
 a->dp    = NULL;
 a->alloc = a->used = 0;
 a->sign  = MP_ZPOS;
 }
 }
+#endif
 /* End: bn_mp_clear.c */
 /* Start: bn_mp_clear_multi.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_CLEAR_MULTI_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 #include <stdarg.h>
 void mp_clear_multi(mp_int *mp, ...)
 {
 mp_int* next_mp = mp;
 mp_clear(next_mp);
 next_mp = va_arg(args, mp_int*);
 }
 va_end(args);
 }
+#endif
 /* End: bn_mp_clear_multi.c */
 /* Start: bn_mp_cmp.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_CMP_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* compare two ints (signed)*/
 int
 mp_cmp (mp_int * a, mp_int * b)
 {
 return mp_cmp_mag(b, a);
 } else {
 return mp_cmp_mag(a, b);
 }
 }
+#endif
 /* End: bn_mp_cmp.c */
 /* Start: bn_mp_cmp_d.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_CMP_D_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* compare a digit */
 int mp_cmp_d(mp_int * a, mp_digit b)
 {
 /* compare based on sign */
 return MP_LT;
 } else {
 return MP_EQ;
 }
 }
+#endif
 /* End: bn_mp_cmp_d.c */
 /* Start: bn_mp_cmp_mag.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_CMP_MAG_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* compare maginitude of two ints (unsigned) */
 int mp_cmp_mag (mp_int * a, mp_int * b)
 {
 int     n;
 return MP_LT;
 }
 }
 return MP_EQ;
 }
+#endif
 /* End: bn_mp_cmp_mag.c */
 /* Start: bn_mp_cnt_lsb.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_CNT_LSB_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 static const int lnz[16] = {
 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0
 };
 } while (qq == 0);
 }
 return x;
 }
+#endif
 /* End: bn_mp_cnt_lsb.c */
 /* Start: bn_mp_copy.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_COPY_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* copy, b = a */
 int
 mp_copy (mp_int * a, mp_int * b)
 {
 /* copy used count and sign */
 b->used = a->used;
 b->sign = a->sign;
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_copy.c */
 /* Start: bn_mp_count_bits.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_COUNT_BITS_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* returns the number of bits in an int */
 int
 mp_count_bits (mp_int * a)
 {
 ++r;
 q >>= ((mp_digit) 1);
 }
 return r;
 }
+#endif
 /* End: bn_mp_count_bits.c */
 /* Start: bn_mp_div.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_DIV_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
+#ifdef BN_MP_DIV_SMALL
+/* slower bit-bang division... also smaller */
+int mp_div(mp_int * a, mp_int * b, mp_int * c, mp_int * d)
+{
+mp_int ta, tb, tq, q;
+int    res, n, n2;
+/* is divisor zero ? */
+if (mp_iszero (b) == 1) {
+return MP_VAL;
+}
+/* if a < b then q=0, r = a */
+if (mp_cmp_mag (a, b) == MP_LT) {
+if (d != NULL) {
+res = mp_copy (a, d);
+} else {
+res = MP_OKAY;
+}
+if (c != NULL) {
+mp_zero (c);
+}
+return res;
+}
+/* init our temps */
+if ((res = mp_init_multi(&ta, &tb, &tq, &q, NULL) != MP_OKAY)) {
+return res;
+}
+mp_set(&tq, 1);
+n = mp_count_bits(a) - mp_count_bits(b);
+if (((res = mp_copy(a, &ta)) != MP_OKAY) ||
+((res = mp_copy(b, &tb)) != MP_OKAY) ||
+((res = mp_mul_2d(&tb, n, &tb)) != MP_OKAY) ||
+((res = mp_mul_2d(&tq, n, &tq)) != MP_OKAY)) {
+goto __ERR;
+}
+while (n-- >= 0) {
+if (mp_cmp(&tb, &ta) != MP_GT) {
+if (((res = mp_sub(&ta, &tb, &ta)) != MP_OKAY) ||
+((res = mp_add(&q, &tq, &q)) != MP_OKAY)) {
+goto __ERR;
+}
+}
+if (((res = mp_div_2d(&tb, 1, &tb, NULL)) != MP_OKAY) ||
+((res = mp_div_2d(&tq, 1, &tq, NULL)) != MP_OKAY)) {
+goto __ERR;
+}
+}
+/* now q == quotient and ta == remainder */
+n  = a->sign;
+n2 = (a->sign == b->sign ? MP_ZPOS : MP_NEG);
+if (c != NULL) {
+mp_exch(c, &q);
+c->sign  = n2;
+}
+if (d != NULL) {
+mp_exch(d, &ta);
+d->sign = n;
+}
+__ERR:
+mp_clear_multi(&ta, &tb, &tq, &q, NULL);
+return res;
+}
+#else
 /* integer signed division.
 * c*b + d == a [e.g. a/b, c=quotient, d=remainder]
 * HAC pp.598 Algorithm 14.20
 *
 /* now q is the quotient and x is the remainder
 * [which we have to normalize]
 */
 /* get sign before writing to c */
-x.sign = a->sign;
+x.sign = x.used == 0 ? MP_ZPOS : a->sign;
 if (c != NULL) {
 mp_clamp (&q);
 mp_exch (&q, c);
 c->sign = neg;
 __T1:mp_clear (&t1);
 __Q:mp_clear (&q);
 return res;
 }
+#endif
+#endif
 /* End: bn_mp_div.c */
 /* Start: bn_mp_div_2.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_DIV_2_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* b = a/2 */
 int mp_div_2(mp_int * a, mp_int * b)
 {
 int     x, res, oldused;
 }
 b->sign = a->sign;
 mp_clamp (b);
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_div_2.c */
 /* Start: bn_mp_div_2d.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_DIV_2D_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* 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)
 {
 mp_digit D, r, rr;
 mp_exch (&t, d);
 }
 mp_clear (&t);
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_div_2d.c */
 /* Start: bn_mp_div_3.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_DIV_3_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* divide by three (based on routine from MPI and the GMP manual) */
 int
 mp_div_3 (mp_int * a, mp_int *c, mp_digit * d)
 {
 mp_clear(&q);
 return res;
 }
+#endif
 /* End: bn_mp_div_3.c */
 /* Start: bn_mp_div_d.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_DIV_D_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 static int s_is_power_of_two(mp_digit b, int *p)
 {
 int x;
 }
 /* power of two ? */
 if (s_is_power_of_two(b, &ix) == 1) {
 if (d != NULL) {
-*d = a->dp[0] & ((1<<ix) - 1);
+*d = a->dp[0] & ((((mp_digit)1)<<ix) - 1);
 }
 if (c != NULL) {
 return mp_div_2d(a, ix, c, NULL);
 }
 return MP_OKAY;
 }
+#ifdef BN_MP_DIV_3_C
 /* three? */
 if (b == 3) {
 return mp_div_3(a, c, d);
 }
+#endif
 /* no easy answer [c'est la vie].  Just division */
 if ((res = mp_init_size(&q, a->used)) != MP_OKAY) {
 return res;
 }
 mp_clear(&q);
 return res;
 }
+#endif
 /* End: bn_mp_div_d.c */
 /* Start: bn_mp_dr_is_modulus.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_DR_IS_MODULUS_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* determines if a number is a valid DR modulus */
 int mp_dr_is_modulus(mp_int *a)
 {
 int ix;
 }
 }
 return 1;
 }
+#endif
 /* End: bn_mp_dr_is_modulus.c */
 /* Start: bn_mp_dr_reduce.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_DR_REDUCE_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* reduce "x" in place modulo "n" using the Diminished Radix algorithm.
 *
 * Based on algorithm from the paper
 *
 s_mp_sub(x, n, x);
 goto top;
 }
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_dr_reduce.c */
 /* Start: bn_mp_dr_setup.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_DR_SETUP_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* determines the setup value */
 void mp_dr_setup(mp_int *a, mp_digit *d)
 {
 /* the casts are required if DIGIT_BIT is one less than
 */
 *d = (mp_digit)((((mp_word)1) << ((mp_word)DIGIT_BIT)) -
 ((mp_word)a->dp[0]));
 }
+#endif
 /* End: bn_mp_dr_setup.c */
 /* Start: bn_mp_exch.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_EXCH_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* swap the elements of two integers, for cases where you can't simply swap the
 * mp_int pointers around
 */
 void
 t  = *a;
 *a = *b;
 *b = t;
 }
+#endif
 /* End: bn_mp_exch.c */
 /* Start: bn_mp_expt_d.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_EXPT_D_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* calculate c = a**b  using a square-multiply algorithm */
 int mp_expt_d (mp_int * a, mp_digit b, mp_int * c)
 {
 int     res, x;
 }
 mp_clear (&g);
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_expt_d.c */
 /* Start: bn_mp_exptmod.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_EXPTMOD_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* this is a shell function that calls either the normal or Montgomery
 * exptmod functions.  Originally the call to the montgomery code was
 * embedded in the normal function but that wasted alot of stack space
 return MP_VAL;
 }
 /* if exponent X is negative we have to recurse */
 if (X->sign == MP_NEG) {
+#ifdef BN_MP_INVMOD_C
 mp_int tmpG, tmpX;
 int err;
 /* first compute 1/G mod P */
 if ((err = mp_init(&tmpG)) != MP_OKAY) {
 /* and now compute (1/G)**|X| instead of G**X [X < 0] */
 err = mp_exptmod(&tmpG, &tmpX, P, Y);
 mp_clear_multi(&tmpG, &tmpX, NULL);
 return err;
-}
+#else
+/* no invmod */
+return MP_VAL
+#endif
+}
+#ifdef BN_MP_DR_IS_MODULUS_C
 /* is it a DR modulus? */
 dr = mp_dr_is_modulus(P);
+#else
+dr = 0;
+#endif
+#ifdef BN_MP_REDUCE_IS_2K_C
 /* if not, is it a uDR modulus? */
 if (dr == 0) {
 dr = mp_reduce_is_2k(P) << 1;
 }
+#endif
 /* if the modulus is odd or dr != 0 use the fast method */
+#ifdef BN_MP_EXPTMOD_FAST_C
 if (mp_isodd (P) == 1 || dr !=  0) {
 return mp_exptmod_fast (G, X, P, Y, dr);
 } else {
+#endif
+#ifdef BN_S_MP_EXPTMOD_C
 /* otherwise use the generic Barrett reduction technique */
 return s_mp_exptmod (G, X, P, Y);
-}
+#else
-}
+/* no exptmod for evens */
+return MP_VAL;
+#endif
+#ifdef BN_MP_EXPTMOD_FAST_C
+}
+#endif
+}
+#endif
 /* End: bn_mp_exptmod.c */
 /* Start: bn_mp_exptmod_fast.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_EXPTMOD_FAST_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* computes Y == G**X mod P, HAC pp.616, Algorithm 14.85
 *
 * Uses a left-to-right k-ary sliding window to compute the modular exponentiation.
 * The value of k changes based on the size of the exponent.
 }
 }
 /* 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 __M;
 }
+#else
+err = MP_VAL;
+goto __M;
+#endif
 /* automatically pick the comba one if available (saves quite a few calls/ifs) */
+#ifdef BN_FAST_MP_MONTGOMERY_REDUCE_C
 if (((P->used * 2 + 1) < MP_WARRAY) &&
 P->used < (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) {
 redux = fast_mp_montgomery_reduce;
-} else {
+} else
+#endif
+{
+#ifdef BN_MP_MONTGOMERY_REDUCE_C
 /* use slower baseline Montgomery method */
 redux = mp_montgomery_reduce;
+#else
+err = MP_VAL;
+goto __M;
+#endif
 }
 } else if (redmode == 1) {
+#if defined(BN_MP_DR_SETUP_C) && defined(BN_MP_DR_REDUCE_C)
 /* setup DR reduction for moduli of the form B**k - b */
 mp_dr_setup(P, &mp);
 redux = mp_dr_reduce;
+#else
+err = MP_VAL;
+goto __M;
+#endif
 } else {
+#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 */
 if ((err = mp_reduce_2k_setup(P, &mp)) != MP_OKAY) {
 goto __M;
 }
 redux = mp_reduce_2k;
+#else
+err = MP_VAL;
+goto __M;
+#endif
 }
 /* setup result */
 if ((err = mp_init (&res)) != MP_OKAY) {
 goto __M;
 }
 /* create M table
 *
-* The M table contains powers of the input base, e.g. M[x] = G^x mod P
 *
 * The first half of the table is not computed though accept for M[0] and M[1]
 */
 if (redmode == 0) {
+#ifdef BN_MP_MONTGOMERY_CALC_NORMALIZATION_C
 /* now we need R mod m */
 if ((err = mp_montgomery_calc_normalization (&res, P)) != MP_OKAY) {
 goto __RES;
 }
+#else
+err = MP_VAL;
+goto __RES;
+#endif
 /* now set M[1] to G * R mod m */
 if ((err = mp_mulmod (G, &res, P, &M[1])) != MP_OKAY) {
 goto __RES;
 }
 * 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 = mp_montgomery_reduce (&res, P, mp)) != MP_OKAY) {
+if ((err = redux(&res, P, mp)) != MP_OKAY) {
 goto __RES;
 }
 }
 /* swap res with Y */
 for (x = 1<<(winsize-1); x < (1 << winsize); x++) {
 mp_clear (&M[x]);
 }
 return err;
 }
+#endif
 /* End: bn_mp_exptmod_fast.c */
 /* Start: bn_mp_exteuclid.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_EXTEUCLID_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* Extended euclidean algorithm of (a, b) produces
 a*u1 + b*u2 = u3
 */
 int mp_exteuclid(mp_int *a, mp_int *b, mp_int *U1, mp_int *U2, mp_int *U3)
 err = MP_OKAY;
 _ERR: mp_clear_multi(&u1, &u2, &u3, &v1, &v2, &v3, &t1, &t2, &t3, &q, &tmp, NULL);
 return err;
 }
+#endif
 /* End: bn_mp_exteuclid.c */
 /* Start: bn_mp_fread.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_FREAD_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* read a bigint from a file stream in ASCII */
 int mp_fread(mp_int *a, int radix, FILE *stream)
 {
 int err, ch, neg, y;
 }
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_fread.c */
 /* Start: bn_mp_fwrite.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_FWRITE_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 int mp_fwrite(mp_int *a, int radix, FILE *stream)
 {
 char *buf;
 int err, len, x;
 XFREE (buf);
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_fwrite.c */
 /* Start: bn_mp_gcd.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_GCD_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* Greatest Common Divisor using the binary method */
 int mp_gcd (mp_int * a, mp_int * b, mp_int * c)
 {
 mp_int  u, v;
 res = MP_OKAY;
 __V:mp_clear (&u);
 __U:mp_clear (&v);
 return res;
 }
+#endif
 /* End: bn_mp_gcd.c */
 /* Start: bn_mp_get_int.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_GET_INT_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* get the lower 32-bits of an mp_int */
 unsigned long mp_get_int(mp_int * a)
 {
 int i;
 }
 /* force result to 32-bits always so it is consistent on non 32-bit platforms */
 return res & 0xFFFFFFFFUL;
 }
+#endif
 /* End: bn_mp_get_int.c */
 /* Start: bn_mp_grow.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_GROW_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* grow as required */
 int mp_grow (mp_int * a, int size)
 {
 int     i;
 a->dp[i] = 0;
 }
 }
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_grow.c */
 /* Start: bn_mp_init.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_INIT_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
-/* init a new bigint */
+/* init a new mp_int */
 int mp_init (mp_int * a)
 {
+int i;
 /* allocate memory required and clear it */
-a->dp = OPT_CAST(mp_digit) XCALLOC (sizeof (mp_digit), MP_PREC);
+a->dp = OPT_CAST(mp_digit) XMALLOC (sizeof (mp_digit) * MP_PREC);
 if (a->dp == NULL) {
 return MP_MEM;
+}
+/* set the digits to zero */
+for (i = 0; i < MP_PREC; i++) {
+a->dp[i] = 0;
 }
 /* set the used to zero, allocated digits to the default precision
 * and sign to positive */
 a->used  = 0;
 a->alloc = MP_PREC;
 a->sign  = MP_ZPOS;
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_init.c */
 /* Start: bn_mp_init_copy.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_INIT_COPY_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* creates "a" then copies b into it */
 int mp_init_copy (mp_int * a, mp_int * b)
 {
 int     res;
 if ((res = mp_init (a)) != MP_OKAY) {
 return res;
 }
 return mp_copy (b, a);
 }
+#endif
 /* End: bn_mp_init_copy.c */
 /* Start: bn_mp_init_multi.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_INIT_MULTI_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 #include <stdarg.h>
 int mp_init_multi(mp_int *mp, ...)
 {
 mp_err res = MP_OKAY;      /* Assume ok until proven otherwise */
 }
 va_end(args);
 return res;                /* Assumed ok, if error flagged above. */
 }
+#endif
 /* End: bn_mp_init_multi.c */
 /* Start: bn_mp_init_set.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_INIT_SET_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* initialize and set a digit */
 int mp_init_set (mp_int * a, mp_digit b)
 {
 int err;
 return err;
 }
 mp_set(a, b);
 return err;
 }
+#endif
 /* End: bn_mp_init_set.c */
 /* Start: bn_mp_init_set_int.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_INIT_SET_INT_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* initialize and set a digit */
 int mp_init_set_int (mp_int * a, unsigned long b)
 {
 int err;
 if ((err = mp_init(a)) != MP_OKAY) {
 return err;
 }
 return mp_set_int(a, b);
 }
+#endif
 /* End: bn_mp_init_set_int.c */
 /* Start: bn_mp_init_size.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_INIT_SIZE_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* init an mp_init for a given size */
 int mp_init_size (mp_int * a, int size)
 {
+int x;
 /* pad size so there are always extra digits */
 size += (MP_PREC * 2) - (size % MP_PREC);
 /* alloc mem */
-a->dp = OPT_CAST(mp_digit) XCALLOC (sizeof (mp_digit), size);
+a->dp = OPT_CAST(mp_digit) XMALLOC (sizeof (mp_digit) * size);
 if (a->dp == NULL) {
 return MP_MEM;
 }
+/* set the members */
 a->used  = 0;
 a->alloc = size;
 a->sign  = MP_ZPOS;
+/* zero the digits */
+for (x = 0; x < size; x++) {
+a->dp[x] = 0;
+}
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_init_size.c */
 /* Start: bn_mp_invmod.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_INVMOD_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* hac 14.61, pp608 */
 int mp_invmod (mp_int * a, mp_int * b, mp_int * c)
 {
-mp_int  x, y, u, v, A, B, C, D;
-int     res;
 /* b cannot be negative */
 if (b->sign == MP_NEG || mp_iszero(b) == 1) {
 return MP_VAL;
 }
+#ifdef BN_FAST_MP_INVMOD_C
 /* if the modulus is odd we can use a faster routine instead */
 if (mp_isodd (b) == 1) {
 return fast_mp_invmod (a, b, c);
 }
+#endif
+#ifdef BN_MP_INVMOD_SLOW_C
+return mp_invmod_slow(a, b, c);
+#endif
+return MP_VAL;
+}
+#endif
+/* End: bn_mp_invmod.c */
+/* Start: bn_mp_invmod_slow.c */
+#include <tommath.h>
+#ifdef BN_MP_INVMOD_SLOW_C
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
+*
+* LibTomMath is a library that provides multiple-precision
+* integer arithmetic as well as number theoretic functionality.
+*
+* The library was designed directly after the MPI library by
+* Michael Fromberger but has been written from scratch with
+* additional optimizations in place.
+*
+* The library is free for all purposes without any express
+* guarantee it works.
+*
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
+/* hac 14.61, pp608 */
+int mp_invmod_slow (mp_int * a, mp_int * b, mp_int * c)
+{
+mp_int  x, y, u, v, A, B, C, D;
+int     res;
+/* b cannot be negative */
+if (b->sign == MP_NEG || mp_iszero(b) == 1) {
+return MP_VAL;
+}
 /* init temps */
 if ((res = mp_init_multi(&x, &y, &u, &v,
 &A, &B, &C, &D, NULL)) != MP_OKAY) {
 return res;
 }
 mp_exch (&C, c);
 res = MP_OKAY;
 __ERR:mp_clear_multi (&x, &y, &u, &v, &A, &B, &C, &D, NULL);
 return res;
 }
+#endif
-/* End: bn_mp_invmod.c */
+/* End: bn_mp_invmod_slow.c */
 /* Start: bn_mp_is_square.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_IS_SQUARE_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* Check if remainders are possible squares - fast exclude non-squares */
 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, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
 }
 if (rem_105[c] == 1) {
 return MP_OKAY;
 }
-/* product of primes less than 2^31 */
 if ((res = mp_init_set_int(&t,11L*13L*17L*19L*23L*29L*31L)) != MP_OKAY) {
 return res;
 }
 if ((res = mp_mod(arg,&t,&t)) != MP_OKAY) {
 goto ERR;
 *ret = (mp_cmp_mag(&t,arg) == MP_EQ) ? MP_YES : MP_NO;
 ERR:mp_clear(&t);
 return res;
 }
+#endif
 /* End: bn_mp_is_square.c */
 /* Start: bn_mp_jacobi.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_JACOBI_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* computes the jacobi c = (a | n) (or Legendre if n is prime)
 * HAC pp. 73 Algorithm 2.149
 */
 int mp_jacobi (mp_int * a, mp_int * p, int *c)
 res = MP_OKAY;
 __P1:mp_clear (&p1);
 __A1:mp_clear (&a1);
 return res;
 }
+#endif
 /* End: bn_mp_jacobi.c */
 /* Start: bn_mp_karatsuba_mul.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_KARATSUBA_MUL_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* c = |a| * |b| using Karatsuba Multiplication using
 * three half size multiplications
 *
 * Let B represent the radix [e.g. 2**DIGIT_BIT] and
 goto T1;
 if (mp_init_size (&x1y1, B * 2) != MP_OKAY)
 goto X0Y0;
 /* now shift the digits */
-x0.sign = x1.sign = a->sign;
-y0.sign = y1.sign = b->sign;
 x0.used = y0.used = B;
 x1.used = a->used - B;
 y1.used = b->used - B;
 {
 X1:mp_clear (&x1);
 X0:mp_clear (&x0);
 ERR:
 return err;
 }
+#endif
 /* End: bn_mp_karatsuba_mul.c */
 /* Start: bn_mp_karatsuba_sqr.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_KARATSUBA_SQR_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* Karatsuba squaring, computes b = a*a using three
 * half size squarings
 *
-* See comments of mp_karatsuba_mul for details.  It
+* See comments of karatsuba_mul for details.  It
 * is essentially the same algorithm but merely
 * tuned to perform recursive squarings.
 */
 int mp_karatsuba_sqr (mp_int * a, mp_int * b)
 {
 X1:mp_clear (&x1);
 X0:mp_clear (&x0);
 ERR:
 return err;
 }
+#endif
 /* End: bn_mp_karatsuba_sqr.c */
 /* Start: bn_mp_lcm.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_LCM_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* computes least common multiple as |a*b|/(a, b) */
 int mp_lcm (mp_int * a, mp_int * b, mp_int * c)
 {
 int     res;
 __T:
 mp_clear_multi (&t1, &t2, NULL);
 return res;
 }
+#endif
 /* End: bn_mp_lcm.c */
 /* Start: bn_mp_lshd.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_LSHD_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* shift left a certain amount of digits */
 int mp_lshd (mp_int * a, int b)
 {
 int     x, res;
 *top++ = 0;
 }
 }
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_lshd.c */
 /* Start: bn_mp_mod.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_MOD_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* c = a mod b, 0 <= c < b */
 int
 mp_mod (mp_int * a, mp_int * b, mp_int * c)
 {
 }
 mp_clear (&t);
 return res;
 }
+#endif
 /* End: bn_mp_mod.c */
 /* Start: bn_mp_mod_2d.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_MOD_2D_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* calc a value mod 2**b */
 int
 mp_mod_2d (mp_int * a, int b, mp_int * c)
 {
 c->dp[b / DIGIT_BIT] &=
 (mp_digit) ((((mp_digit) 1) << (((mp_digit) b) % DIGIT_BIT)) - ((mp_digit) 1));
 mp_clamp (c);
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_mod_2d.c */
 /* Start: bn_mp_mod_d.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_MOD_D_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 int
 mp_mod_d (mp_int * a, mp_digit b, mp_digit * c)
 {
 return mp_div_d(a, b, NULL, c);
 }
+#endif
 /* End: bn_mp_mod_d.c */
 /* Start: bn_mp_montgomery_calc_normalization.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_MONTGOMERY_CALC_NORMALIZATION_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
-/* calculates a = B^n mod b for Montgomery reduction
-* Where B is the base [e.g. 2^DIGIT_BIT].
+/*
-* B^n mod b is computed by first computing
-* A = B^(n-1) which doesn't require a reduction but a simple OR.
-* then C = A * B = B^n is computed by performing upto DIGIT_BIT
 * shifts with subtractions when the result is greater than b.
 *
 * The method is slightly modified to shift B unconditionally upto just under
 * the leading bit of b.  This saves alot of multiple precision shifting.
 */
-int
+int mp_montgomery_calc_normalization (mp_int * a, mp_int * b)
-mp_montgomery_calc_normalization (mp_int * a, mp_int * b)
 {
 int     x, bits, res;
 /* how many bits of last digit does b use */
 bits = mp_count_bits (b) % DIGIT_BIT;
-/* compute A = B^(n-1) * 2^(bits-1) */
-if ((res = mp_2expt (a, (b->used - 1) * DIGIT_BIT + bits - 1)) != MP_OKAY) {
+if (b->used > 1) {
-return res;
+if ((res = mp_2expt (a, (b->used - 1) * DIGIT_BIT + bits - 1)) != MP_OKAY) {
-}
+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;
 }
 }
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_montgomery_calc_normalization.c */
 /* Start: bn_mp_montgomery_reduce.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_MONTGOMERY_REDUCE_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* computes xR**-1 == x (mod N) via Montgomery Reduction */
 int
 mp_montgomery_reduce (mp_int * x, mp_int * n, mp_digit rho)
 {
 int     ix, res, digs;
 mp_digit mu;
 /* can the fast reduction [comba] method be used?
 *
-* Note that unlike in mp_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
 * are fixed up in the inner loop.
 */
 digs = n->used * 2 + 1;
 if ((digs < MP_WARRAY) &&
 for (ix = 0; ix < n->used; ix++) {
 /* mu = ai * rho mod b
 *
 * The value of rho must be precalculated via
-* bn_mp_montgomery_setup() such that
+* 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);
 return s_mp_sub (x, n, x);
 }
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_montgomery_reduce.c */
 /* Start: bn_mp_montgomery_setup.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_MONTGOMERY_SETUP_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* setups the montgomery reduction stuff */
 int
 mp_montgomery_setup (mp_int * n, mp_digit * rho)
 {
 #ifdef MP_64BIT
 x *= 2 - b * x;               /* here x*a==1 mod 2**64 */
 #endif
 /* rho = -1/m mod b */
-*rho = (((mp_digit) 1 << ((mp_digit) DIGIT_BIT)) - x) & MP_MASK;
+*rho = (((mp_word)1 << ((mp_word) DIGIT_BIT)) - x) & MP_MASK;
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_montgomery_setup.c */
 /* Start: bn_mp_mul.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_MUL_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* high level multiplication (handles sign) */
 int mp_mul (mp_int * a, mp_int * b, mp_int * c)
 {
 int     res, neg;
 neg = (a->sign == b->sign) ? MP_ZPOS : MP_NEG;
 /* use Toom-Cook? */
+#ifdef BN_MP_TOOM_MUL_C
 if (MIN (a->used, b->used) >= TOOM_MUL_CUTOFF) {
 res = mp_toom_mul(a, b, c);
+} else
+#endif
+#ifdef BN_MP_KARATSUBA_MUL_C
 /* use Karatsuba? */
-} else 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);
-} else {
+} else
+#endif
+{
 /* can we use the fast multiplier?
 *
 * The fast multiplier can be used if the output will
 * have less than MP_WARRAY digits and the number of
 * digits won't affect carry propagation
 */
 int     digs = a->used + b->used + 1;
+#ifdef BN_FAST_S_MP_MUL_DIGS_C
 if ((digs < MP_WARRAY) &&
 MIN(a->used, b->used) <=
 (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) {
 res = fast_s_mp_mul_digs (a, b, c, digs);
-} else {
+} else
-res = s_mp_mul (a, b, c);
+#endif
-}
+#ifdef BN_S_MP_MUL_DIGS_C
-}
+res = s_mp_mul (a, b, c); /* uses s_mp_mul_digs */
-c->sign = neg;
+#else
+res = MP_VAL;
+#endif
+}
+c->sign = (c->used > 0) ? neg : MP_ZPOS;
 return res;
 }
+#endif
 /* End: bn_mp_mul.c */
 /* Start: bn_mp_mul_2.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_MUL_2_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* b = a*2 */
 int mp_mul_2(mp_int * a, mp_int * b)
 {
 int     x, res, oldused;
 }
 }
 b->sign = a->sign;
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_mul_2.c */
 /* Start: bn_mp_mul_2d.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_MUL_2D_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* shift left by a certain bit count */
 int mp_mul_2d (mp_int * a, int b, mp_int * c)
 {
 mp_digit d;
 }
 }
 mp_clamp (c);
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_mul_2d.c */
 /* Start: bn_mp_mul_d.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_MUL_D_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* multiply by a digit */
 int
 mp_mul_d (mp_int * a, mp_digit b, mp_int * c)
 {
 c->used = a->used + 1;
 mp_clamp(c);
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_mul_d.c */
 /* Start: bn_mp_mulmod.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_MULMOD_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* d = a * b (mod c) */
 int
 mp_mulmod (mp_int * a, mp_int * b, mp_int * c, mp_int * d)
 {
 }
 res = mp_mod (&t, c, d);
 mp_clear (&t);
 return res;
 }
+#endif
 /* End: bn_mp_mulmod.c */
 /* Start: bn_mp_n_root.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_N_ROOT_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* find the n'th root of an integer
 *
 * Result found such that (c)**b <= a and (c+1)**b > a
 *
 __T3:mp_clear (&t3);
 __T2:mp_clear (&t2);
 __T1:mp_clear (&t1);
 return res;
 }
+#endif
 /* End: bn_mp_n_root.c */
 /* Start: bn_mp_neg.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_NEG_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* b = -a */
 int mp_neg (mp_int * a, mp_int * b)
 {
 int     res;
 if (mp_iszero(b) != MP_YES) {
 b->sign = (a->sign == MP_ZPOS) ? MP_NEG : MP_ZPOS;
 }
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_neg.c */
 /* Start: bn_mp_or.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_OR_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* OR two ints together */
 int mp_or (mp_int * a, mp_int * b, mp_int * c)
 {
 int     res, ix, px;
 mp_clamp (&t);
 mp_exch (c, &t);
 mp_clear (&t);
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_or.c */
 /* Start: bn_mp_prime_fermat.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_PRIME_FERMAT_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* performs one Fermat test.
 *
 * 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
 err = MP_OKAY;
 __T:mp_clear (&t);
 return err;
 }
+#endif
 /* End: bn_mp_prime_fermat.c */
 /* Start: bn_mp_prime_is_divisible.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_PRIME_IS_DIVISIBLE_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* determines if an integers is divisible by one
 * of the first PRIME_SIZE primes or not
 *
 * sets result to 0 if not, 1 if yes
 }
 }
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_prime_is_divisible.c */
 /* Start: bn_mp_prime_is_prime.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_PRIME_IS_PRIME_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* performs a variable number of rounds of Miller-Rabin
 *
 * Probability of error after t rounds is no more than
-* (1/4)^t when 1 <= t <= PRIME_SIZE
 *
 * Sets result to 1 if probably prime, 0 otherwise
 */
 int mp_prime_is_prime (mp_int * a, int t, int *result)
 {
 /* passed the test */
 *result = MP_YES;
 __B:mp_clear (&b);
 return err;
 }
+#endif
 /* End: bn_mp_prime_is_prime.c */
 /* Start: bn_mp_prime_miller_rabin.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_PRIME_MILLER_RABIN_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* Miller-Rabin test of "a" to the base of "b" as described in
 * HAC pp. 139 Algorithm 4.24
 *
 * Sets result to 0 if definitely composite or 1 if probably prime.
 __Y:mp_clear (&y);
 __R:mp_clear (&r);
 __N1:mp_clear (&n1);
 return err;
 }
+#endif
 /* End: bn_mp_prime_miller_rabin.c */
 /* Start: bn_mp_prime_next_prime.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_PRIME_NEXT_PRIME_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* finds the next prime after the number "a" using "t" trials
 * of Miller-Rabin.
 *
 * bbs_style = 1 means the prime must be congruent to 3 mod 4
 __ERR:
 mp_clear(&b);
 return err;
 }
+#endif
 /* End: bn_mp_prime_next_prime.c */
+/* Start: bn_mp_prime_rabin_miller_trials.c */
+#include <tommath.h>
+#ifdef BN_MP_PRIME_RABIN_MILLER_TRIALS_C
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
+*
+* LibTomMath is a library that provides multiple-precision
+* integer arithmetic as well as number theoretic functionality.
+*
+* The library was designed directly after the MPI library by
+* Michael Fromberger but has been written from scratch with
+* additional optimizations in place.
+*
+* The library is free for all purposes without any express
+* guarantee it works.
+*
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
+static const struct {
+int k, t;
+} sizes[] = {
+{   128,    28 },
+{   256,    16 },
+{   384,    10 },
+{   512,     7 },
+{   640,     6 },
+{   768,     5 },
+{   896,     4 },
+{  1024,     4 }
+};
+/* returns # of RM trials required for a given bit size */
+int mp_prime_rabin_miller_trials(int size)
+{
+int x;
+for (x = 0; x < (int)(sizeof(sizes)/(sizeof(sizes[0]))); x++) {
+if (sizes[x].k == size) {
+return sizes[x].t;
+} else if (sizes[x].k > size) {
+return (x == 0) ? sizes[0].t : sizes[x - 1].t;
+}
+}
+return sizes[x-1].t + 1;
+}
+#endif
+/* End: bn_mp_prime_rabin_miller_trials.c */
 /* Start: bn_mp_prime_random_ex.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_PRIME_RANDOM_EX_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* makes a truly random prime of a given size (bits),
 *
 * Flags are as follows:
 *
 /* read it in */
 if ((err = mp_read_unsigned_bin(a, tmp, bsize)) != MP_OKAY)     { goto error; }
 /* is it prime? */
 if ((err = mp_prime_is_prime(a, t, &res)) != MP_OKAY)           { goto error; }
+if (res == MP_NO) {
+continue;
+}
 if (flags & LTM_PRIME_SAFE) {
 /* see if (a-1)/2 is prime */
 if ((err = mp_sub_d(a, 1, a)) != MP_OKAY)                    { goto error; }
 if ((err = mp_div_2(a, a)) != MP_OKAY)                       { goto error; }
 XFREE(tmp);
 return err;
 }
+#endif
 /* End: bn_mp_prime_random_ex.c */
 /* Start: bn_mp_radix_size.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_RADIX_SIZE_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* returns size of ASCII reprensentation */
 int mp_radix_size (mp_int * a, int radix, int *size)
 {
 int     res, digs;
 /* return digs + 1, the 1 is for the NULL byte that would be required. */
 *size = digs + 1;
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_radix_size.c */
 /* Start: bn_mp_radix_smap.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_RADIX_SMAP_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* chars used in radix conversions */
 const char *mp_s_rmap = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/";
+#endif
 /* End: bn_mp_radix_smap.c */
 /* Start: bn_mp_rand.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_RAND_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* makes a pseudo-random int of a given size */
 int
 mp_rand (mp_int * a, int digits)
 {
 }
 }
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_rand.c */
 /* Start: bn_mp_read_radix.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_READ_RADIX_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* read a string [ASCII] in a given radix */
 int mp_read_radix (mp_int * a, char *str, int radix)
 {
 int     y, res, neg;
 if (mp_iszero(a) != 1) {
 a->sign = neg;
 }
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_read_radix.c */
 /* Start: bn_mp_read_signed_bin.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_READ_SIGNED_BIN_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* read signed bin, big endian, first byte is 0==positive or 1==negative */
 int
 mp_read_signed_bin (mp_int * a, unsigned char *b, int c)
 {
 a->sign = MP_NEG;
 }
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_read_signed_bin.c */
 /* Start: bn_mp_read_unsigned_bin.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_READ_UNSIGNED_BIN_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* reads a unsigned char array, assumes the msb is stored first [big endian] */
 int
 mp_read_unsigned_bin (mp_int * a, unsigned char *b, int c)
 {
 #endif
 }
 mp_clamp (a);
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_read_unsigned_bin.c */
 /* Start: bn_mp_reduce.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_REDUCE_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* reduces x mod m, assumes 0 < x < m**2, mu is
 * precomputed via mp_reduce_setup.
 * From HAC pp.604 Algorithm 14.42
 */
 if (((unsigned long) um) > (((mp_digit)1) << (DIGIT_BIT - 1))) {
 if ((res = mp_mul (&q, mu, &q)) != MP_OKAY) {
 goto CLEANUP;
 }
 } else {
+#ifdef BN_S_MP_MUL_HIGH_DIGS_C
 if ((res = s_mp_mul_high_digs (&q, mu, &q, um - 1)) != MP_OKAY) {
 goto CLEANUP;
 }
+#elif defined(BN_FAST_S_MP_MUL_HIGH_DIGS_C)
+if ((res = fast_s_mp_mul_high_digs (&q, mu, &q, um - 1)) != MP_OKAY) {
+goto CLEANUP;
+}
+#else
+{
+res = MP_VAL;
+goto CLEANUP;
+}
+#endif
 }
 /* q3 = q2 / b**(k+1) */
 mp_rshd (&q, um + 1);
 CLEANUP:
 mp_clear (&q);
 return res;
 }
+#endif
 /* End: bn_mp_reduce.c */
 /* Start: bn_mp_reduce_2k.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_REDUCE_2K_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* reduces a modulo n where n is of the form 2**p - d */
 int
 mp_reduce_2k(mp_int *a, mp_int *n, mp_digit d)
 {
 ERR:
 mp_clear(&q);
 return res;
 }
+#endif
 /* End: bn_mp_reduce_2k.c */
 /* Start: bn_mp_reduce_2k_setup.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_REDUCE_2K_SETUP_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* determines the setup value */
 int
 mp_reduce_2k_setup(mp_int *a, mp_digit *d)
 {
 *d = tmp.dp[0];
 mp_clear(&tmp);
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_reduce_2k_setup.c */
 /* Start: bn_mp_reduce_is_2k.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_REDUCE_IS_2K_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* determines if mp_reduce_2k can be used */
 int mp_reduce_is_2k(mp_int *a)
 {
-int ix, iy, iz, iw;
+int ix, iy, iw;
+mp_digit iz;
 if (a->used == 0) {
 return 0;
 } else if (a->used == 1) {
 return 1;
 for (ix = DIGIT_BIT; ix < iy; ix++) {
 if ((a->dp[iw] & iz) == 0) {
 return 0;
 }
 iz <<= 1;
-if (iz > (int)MP_MASK) {
+if (iz > (mp_digit)MP_MASK) {
 ++iw;
 iz = 1;
 }
 }
 }
 return 1;
 }
+#endif
 /* End: bn_mp_reduce_is_2k.c */
 /* Start: bn_mp_reduce_setup.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_REDUCE_SETUP_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* pre-calculate the value required for Barrett reduction
 * For a given modulus "b" it calulates the value required in "a"
 */
-int
+int mp_reduce_setup (mp_int * a, mp_int * b)
-mp_reduce_setup (mp_int * a, mp_int * b)
 {
 int     res;
 if ((res = mp_2expt (a, b->used * 2 * DIGIT_BIT)) != MP_OKAY) {
 return res;
 }
 return mp_div (a, b, a, NULL);
 }
+#endif
 /* End: bn_mp_reduce_setup.c */
 /* Start: bn_mp_rshd.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_RSHD_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* shift right a certain amount of digits */
 void mp_rshd (mp_int * a, int b)
 {
 int     x;
 }
 /* remove excess digits */
 a->used -= b;
 }
+#endif
 /* End: bn_mp_rshd.c */
 /* Start: bn_mp_set.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_SET_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* set to a digit */
 void mp_set (mp_int * a, mp_digit b)
 {
 mp_zero (a);
 a->dp[0] = b & MP_MASK;
 a->used  = (a->dp[0] != 0) ? 1 : 0;
 }
+#endif
 /* End: bn_mp_set.c */
 /* Start: bn_mp_set_int.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_SET_INT_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* set a 32-bit const */
 int mp_set_int (mp_int * a, unsigned long b)
 {
 int     x, res;
 a->used += 1;
 }
 mp_clamp (a);
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_set_int.c */
 /* Start: bn_mp_shrink.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_SHRINK_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* shrink a bignum */
 int mp_shrink (mp_int * a)
 {
 mp_digit *tmp;
 a->dp    = tmp;
 a->alloc = a->used;
 }
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_shrink.c */
 /* Start: bn_mp_signed_bin_size.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_SIGNED_BIN_SIZE_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* get the size for an signed equivalent */
 int mp_signed_bin_size (mp_int * a)
 {
 return 1 + mp_unsigned_bin_size (a);
 }
+#endif
 /* End: bn_mp_signed_bin_size.c */
 /* Start: bn_mp_sqr.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_SQR_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* computes b = a*a */
 int
 mp_sqr (mp_int * a, mp_int * b)
 {
 int     res;
+#ifdef BN_MP_TOOM_SQR_C
 /* use Toom-Cook? */
 if (a->used >= TOOM_SQR_CUTOFF) {
 res = mp_toom_sqr(a, b);
 /* Karatsuba? */
-} else if (a->used >= KARATSUBA_SQR_CUTOFF) {
+} else
+#endif
+#ifdef BN_MP_KARATSUBA_SQR_C
+if (a->used >= KARATSUBA_SQR_CUTOFF) {
 res = mp_karatsuba_sqr (a, b);
-} else {
+} else
+#endif
+{
+#ifdef BN_FAST_S_MP_SQR_C
 /* can we use the fast comba multiplier? */
 if ((a->used * 2 + 1) < MP_WARRAY &&
 a->used <
 (1 << (sizeof(mp_word) * CHAR_BIT - 2*DIGIT_BIT - 1))) {
 res = fast_s_mp_sqr (a, b);
-} else {
+} else
+#endif
+#ifdef BN_S_MP_SQR_C
 res = s_mp_sqr (a, b);
-}
+#else
+res = MP_VAL;
+#endif
 }
 b->sign = MP_ZPOS;
 return res;
 }
+#endif
 /* End: bn_mp_sqr.c */
 /* Start: bn_mp_sqrmod.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_SQRMOD_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* c = a * a (mod b) */
 int
 mp_sqrmod (mp_int * a, mp_int * b, mp_int * c)
 {
 }
 res = mp_mod (&t, b, c);
 mp_clear (&t);
 return res;
 }
+#endif
 /* End: bn_mp_sqrmod.c */
 /* Start: bn_mp_sqrt.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_SQRT_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* this function is less generic than mp_n_root, simpler and faster */
 int mp_sqrt(mp_int *arg, mp_int *ret)
 {
 int res;
 E1: mp_clear(&t2);
 E2: mp_clear(&t1);
 return res;
 }
+#endif
 /* End: bn_mp_sqrt.c */
 /* Start: bn_mp_sub.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_SUB_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* high level subtraction (handles signs) */
 int
 mp_sub (mp_int * a, mp_int * b, mp_int * c)
 {
 }
 }
 return res;
 }
+#endif
 /* End: bn_mp_sub.c */
 /* Start: bn_mp_sub_d.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_SUB_D_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* single digit subtraction */
 int
 mp_sub_d (mp_int * a, mp_digit b, mp_int * c)
 {
 }
 mp_clamp(c);
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_sub_d.c */
 /* Start: bn_mp_submod.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_SUBMOD_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* d = a - b (mod c) */
 int
 mp_submod (mp_int * a, mp_int * b, mp_int * c, mp_int * d)
 {
 }
 res = mp_mod (&t, c, d);
 mp_clear (&t);
 return res;
 }
+#endif
 /* End: bn_mp_submod.c */
 /* Start: bn_mp_to_signed_bin.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_TO_SIGNED_BIN_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* store in signed [big endian] format */
 int
 mp_to_signed_bin (mp_int * a, unsigned char *b)
 {
 return res;
 }
 b[0] = (unsigned char) ((a->sign == MP_ZPOS) ? 0 : 1);
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_to_signed_bin.c */
 /* Start: bn_mp_to_unsigned_bin.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_TO_UNSIGNED_BIN_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* store in unsigned [big endian] format */
 int
 mp_to_unsigned_bin (mp_int * a, unsigned char *b)
 {
 }
 bn_reverse (b, x);
 mp_clear (&t);
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_to_unsigned_bin.c */
 /* Start: bn_mp_toom_mul.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_TOOM_MUL_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
-/* multiplication using the Toom-Cook 3-way algorithm */
+/* multiplication using the Toom-Cook 3-way algorithm
+*
+* Much more complicated than Karatsuba but has a lower asymptotic running time of
+* O(N**1.464).  This algorithm is only particularly useful on VERY large
+* inputs (we're talking 1000s of digits here...).
+*/
 int mp_toom_mul(mp_int *a, mp_int *b, mp_int *c)
 {
 mp_int w0, w1, w2, w3, w4, tmp1, tmp2, a0, a1, a2, b0, b1, b2;
 int res, B;
 &a0, &a1, &a2, &b0, &b1,
 &b2, &tmp1, &tmp2, NULL);
 return res;
 }
+#endif
 /* End: bn_mp_toom_mul.c */
 /* Start: bn_mp_toom_sqr.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_TOOM_SQR_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* squaring using Toom-Cook 3-way algorithm */
 int
 mp_toom_sqr(mp_int *a, mp_int *b)
 {
 ERR:
 mp_clear_multi(&w0, &w1, &w2, &w3, &w4, &a0, &a1, &a2, &tmp1, NULL);
 return res;
 }
+#endif
 /* End: bn_mp_toom_sqr.c */
 /* Start: bn_mp_toradix.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_TORADIX_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* stores a bignum as a ASCII string in a given radix (2..64) */
 int mp_toradix (mp_int * a, char *str, int radix)
 {
 int     res, digs;
 mp_clear (&t);
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_toradix.c */
 /* Start: bn_mp_toradix_n.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_TORADIX_N_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* stores a bignum as a ASCII string in a given radix (2..64)
 *
 * Stores upto maxlen-1 chars and always a NULL byte
 */
 mp_clear (&t);
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_toradix_n.c */
 /* Start: bn_mp_unsigned_bin_size.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_UNSIGNED_BIN_SIZE_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* get the size for an unsigned equivalent */
 int
 mp_unsigned_bin_size (mp_int * a)
 {
 int     size = mp_count_bits (a);
 return (size / 8 + ((size & 7) != 0 ? 1 : 0));
 }
+#endif
 /* End: bn_mp_unsigned_bin_size.c */
 /* Start: bn_mp_xor.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_XOR_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* XOR two ints together */
 int
 mp_xor (mp_int * a, mp_int * b, mp_int * c)
 {
 px = a->used;
 x = a;
 }
 for (ix = 0; ix < px; ix++) {
-t.dp[ix] ^= x->dp[ix];
 }
 mp_clamp (&t);
 mp_exch (c, &t);
 mp_clear (&t);
 return MP_OKAY;
 }
+#endif
 /* End: bn_mp_xor.c */
 /* Start: bn_mp_zero.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_MP_ZERO_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* set to zero */
 void
 mp_zero (mp_int * a)
 {
 a->sign = MP_ZPOS;
 a->used = 0;
 memset (a->dp, 0, sizeof (mp_digit) * a->alloc);
 }
+#endif
 /* End: bn_mp_zero.c */
-/* Start: bn_prime_sizes_tab.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
-*
-* LibTomMath is a library that provides multiple-precision
-* integer arithmetic as well as number theoretic functionality.
-*
-* The library was designed directly after the MPI library by
-* Michael Fromberger but has been written from scratch with
-* additional optimizations in place.
-*
-* The library is free for all purposes without any express
-* guarantee it works.
-*
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
-*/
-#include <tommath.h>
-/* this table gives the # of rabin miller trials for a prob of failure lower than 2^-96 */
-static const struct {
-int k, t;
-} sizes[] = {
-{   128,    28 },
-{   256,    16 },
-{   384,    10 },
-{   512,     7 },
-{   640,     6 },
-{   768,     5 },
-{   896,     4 },
-{  1024,     4 },
-{  1152,     3 },
-{  1280,     3 },
-{  1408,     3 },
-{  1536,     3 },
-{  1664,     3 },
-{  1792,     2 } };
-/* returns # of RM trials required for a given bit size */
-int mp_prime_rabin_miller_trials(int size)
-{
-int x;
-for (x = 0; x < (int)(sizeof(sizes)/(sizeof(sizes[0]))); x++) {
-if (sizes[x].k == size) {
-return sizes[x].t;
-} else if (sizes[x].k > size) {
-return (x == 0) ? sizes[0].t : sizes[x - 1].t;
-}
-}
-return 1;
-}
-/* End: bn_prime_sizes_tab.c */
 /* Start: bn_prime_tab.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_PRIME_TAB_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 const mp_digit __prime_tab[] = {
 0x0002, 0x0003, 0x0005, 0x0007, 0x000B, 0x000D, 0x0011, 0x0013,
 0x0017, 0x001D, 0x001F, 0x0025, 0x0029, 0x002B, 0x002F, 0x0035,
 0x003B, 0x003D, 0x0043, 0x0047, 0x0049, 0x004F, 0x0053, 0x0059,
 0x0061, 0x0065, 0x0067, 0x006B, 0x006D, 0x0071, 0x007F,
 0x05BF, 0x05C9, 0x05CB, 0x05CF, 0x05D1, 0x05D5, 0x05DB, 0x05E7,
 0x05F3, 0x05FB, 0x0607, 0x060D, 0x0611, 0x0617, 0x061F, 0x0623,
 0x062B, 0x062F, 0x063D, 0x0641, 0x0647, 0x0649, 0x064D, 0x0653
 #endif
 };
+#endif
 /* End: bn_prime_tab.c */
 /* Start: bn_reverse.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_REVERSE_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* reverse an array, used for radix code */
 void
 bn_reverse (unsigned char *s, int len)
 {
 s[iy] = t;
 ++ix;
 --iy;
 }
 }
+#endif
 /* End: bn_reverse.c */
 /* Start: bn_s_mp_add.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_S_MP_ADD_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* low level addition, based on HAC pp.594, Algorithm 14.7 */
 int
 s_mp_add (mp_int * a, mp_int * b, mp_int * c)
 {
 }
 mp_clamp (c);
 return MP_OKAY;
 }
+#endif
 /* End: bn_s_mp_add.c */
 /* Start: bn_s_mp_exptmod.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_S_MP_EXPTMOD_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 #ifdef MP_LOW_MEM
 #define TAB_SIZE 32
 #else
 #define TAB_SIZE 256
 for (x = 1<<(winsize-1); x < (1 << winsize); x++) {
 mp_clear (&M[x]);
 }
 return err;
 }
+#endif
 /* End: bn_s_mp_exptmod.c */
 /* Start: bn_s_mp_mul_digs.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_S_MP_MUL_DIGS_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* multiplies |a| * |b| and only computes upto digs digits of result
 * HAC pp. 595, Algorithm 14.12  Modified so you can control how
 * many digits of output are created.
 */
 mp_exch (&t, c);
 mp_clear (&t);
 return MP_OKAY;
 }
+#endif
 /* End: bn_s_mp_mul_digs.c */
 /* Start: bn_s_mp_mul_high_digs.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_S_MP_MUL_HIGH_DIGS_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* multiplies |a| * |b| and does not compute the lower digs digits
 * [meant to get the higher part of the product]
 */
 int
 mp_digit u;
 mp_word r;
 mp_digit tmpx, *tmpt, *tmpy;
 /* can we use the fast multiplier? */
+#ifdef BN_FAST_S_MP_MUL_HIGH_DIGS_C
 if (((a->used + b->used + 1) < MP_WARRAY)
 && MIN (a->used, b->used) < (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) {
 return fast_s_mp_mul_high_digs (a, b, c, digs);
 }
+#endif
 if ((res = mp_init_size (&t, a->used + b->used + 1)) != MP_OKAY) {
 return res;
 }
 t.used = a->used + b->used + 1;
 mp_clamp (&t);
 mp_exch (&t, c);
 mp_clear (&t);
 return MP_OKAY;
 }
+#endif
 /* End: bn_s_mp_mul_high_digs.c */
 /* Start: bn_s_mp_sqr.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_S_MP_SQR_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* low level squaring, b = a*a, HAC pp.596-597, Algorithm 14.16 */
 int
 s_mp_sqr (mp_int * a, mp_int * b)
 {
 mp_clamp (&t);
 mp_exch (&t, b);
 mp_clear (&t);
 return MP_OKAY;
 }
+#endif
 /* End: bn_s_mp_sqr.c */
 /* Start: bn_s_mp_sub.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BN_S_MP_SUB_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* low level subtraction (assumes |a| > |b|), HAC pp.595 Algorithm 14.9 */
 int
 s_mp_sub (mp_int * a, mp_int * b, mp_int * c)
 {
 mp_clamp (c);
 return MP_OKAY;
 }
+#endif
 /* End: bn_s_mp_sub.c */
 /* Start: bncore.c */
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
+#include <tommath.h>
-*
+#ifdef BNCORE_C
-* LibTomMath is a library that provides multiple-precision
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
-* integer arithmetic as well as number theoretic functionality.
+*
-*
+* LibTomMath is a library that provides multiple-precision
-* The library was designed directly after the MPI library by
+* integer arithmetic as well as number theoretic functionality.
-* Michael Fromberger but has been written from scratch with
+*
-* additional optimizations in place.
+* The library was designed directly after the MPI library by
-*
+* Michael Fromberger but has been written from scratch with
-* The library is free for all purposes without any express
+* additional optimizations in place.
-* guarantee it works.
+*
-*
+* The library is free for all purposes without any express
-* Tom St Denis, [email protected], http://math.libtomcrypt.org
+* guarantee it works.
-*/
+*
-#include <tommath.h>
+* Tom St Denis, [email protected], http://math.libtomcrypt.org
+*/
 /* Known optimal configurations
 CPU                    /Compiler     /MUL CUTOFF/SQR CUTOFF
 -------------------------------------------------------------
-Intel P4               /GCC v3.2     /        70/       108
+Intel P4 Northwood     /GCC v3.4.1   /        88/       128/LTM 0.32 ;-)
-AMD Athlon XP          /GCC v3.2     /       109/       127
 */
-/* configured for a AMD XP Thoroughbred core with etc/tune.c */
+int     KARATSUBA_MUL_CUTOFF = 88,      /* Min. number of digits before Karatsuba multiplication is used. */
-int     KARATSUBA_MUL_CUTOFF = 109,      /* Min. number of digits before Karatsuba multiplication is used. */
+KARATSUBA_SQR_CUTOFF = 128,     /* Min. number of digits before Karatsuba squaring is used. */
-KARATSUBA_SQR_CUTOFF = 127,      /* Min. number of digits before Karatsuba squaring is used. */
 TOOM_MUL_CUTOFF      = 350,      /* no optimal values of these are known yet so set em high */
 TOOM_SQR_CUTOFF      = 400;
+#endif
 /* End: bncore.c */
 /* EOF */

Mercurial > dropbear

comparison pre_gen/mpi.c @ 142:d29b64170cf0 libtommath-orig