--- /dev/null
+/* Copyright (c) 1998,2011-2014 Apple Inc. All Rights Reserved.
+ *
+ * NOTICE: USE OF THE MATERIALS ACCOMPANYING THIS NOTICE IS SUBJECT
+ * TO THE TERMS OF THE SIGNED "FAST ELLIPTIC ENCRYPTION (FEE) REFERENCE
+ * SOURCE CODE EVALUATION AGREEMENT" BETWEEN APPLE, INC. AND THE
+ * ORIGINAL LICENSEE THAT OBTAINED THESE MATERIALS FROM APPLE,
+ * INC. ANY USE OF THESE MATERIALS NOT PERMITTED BY SUCH AGREEMENT WILL
+ * EXPOSE YOU TO LIABILITY.
+ ***************************************************************************
+
+ giantIntegers.c - library for large-integer arithmetic.
+
+ Revision History
+ ----------------
+ Fixed a==b bug in addg().
+ 10/06/98 ap
+ Changed to compile with C++.
+ 13 Apr 98 Fixed shiftright(1) bug in modg_via_recip.
+ 09 Apr 98 at Apple
+ Major rewrite of core arithmetic routines to make this module
+ independent of size of giantDigit.
+ Removed idivg() and radixdiv().
+ 20 Jan 98 at Apple
+ Deleted FFT arithmetic; simplified mulg().
+ 09 Jan 98 at Apple
+ gshiftright() optimization.
+ 08 Jan 98 at Apple
+ newGiant() returns NULL on malloc failure
+ 24 Dec 97 at Apple
+ New grammarSquare(); optimized modg_via_recip()
+ 11 Jun 97 at Apple
+ Added modg_via_recip(), divg_via_recip(), make_recip()
+ Added new multiple giant stack mechanism
+ Fixed potential packing/alignment bug in copyGiant()
+ Added profiling for borrowGiant(), returnGiant()
+ Deleted obsolete ifdef'd code
+ Deleted newgiant()
+ All calls to borrowGiant() now specify required size (no more
+ borrowGiant(0) calls)
+ 08 May 97 at Apple
+ Changed size of giantstruct.n to 1 for Mac build
+ 05 Feb 97 at Apple
+ newGiant() no longer modifies CurrentMaxShorts or giant stack
+ Added modg profiling
+ 01 Feb 97 at NeXT
+ Added iszero() check in gcompg
+ 17 Jan 97 at NeXT
+ Fixed negation bug in gmersennemod()
+ Fixed n[words-1] == 0 bug in extractbits()
+ Cleaned up lots of static declarations
+ 19 Sep 96 at NeXT
+ Fixed --size underflow bug in normal_subg().
+ 4 Sep 96 at NeXT
+ Fixed (b<n), (sign<0) case in gmersennemod() to allow for arbitrary n.
+ 9 Aug 96 at NeXT
+ Fixed sign-extend bug in data_to_giant().
+ 7 Aug 96 at NeXT
+ Changed precision in newtondivide().
+ Removed #ifdef UNUSED code.
+ 24 Jul 96 at NeXT
+ Added scompg().
+ Created.
+
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "platform.h"
+#include "giantIntegers.h"
+#include "feeDebug.h"
+#include "ckconfig.h"
+#include "ellipticMeasure.h"
+#include "falloc.h"
+#include "giantPortCommon.h"
+
+#ifdef FEE_DEBUG
+#if (GIANT_LOG2_BITS_PER_DIGIT == 4)
+#warning Compiling with two-byte giantDigits
+#endif
+#endif
+
+#if 0
+#if FEE_DEBUG
+char printbuf1[200];
+char printbuf2[200];
+char printbuf3[200];
+void printGiantBuf(giant x)
+{
+ int i;
+
+ sprintf(printbuf2, "sign=%d cap=%d n[]=", x->sign, x->capacity);
+ for(i=0; i<abs(x->sign); i++) {
+ sprintf(printbuf3 + 10*i, "%u:", x->n[i]);
+ }
+}
+
+char printbuf4[200];
+char printbuf5[200];
+void printGiantBuf2(giant x)
+{
+ int i;
+
+ sprintf(printbuf4, "sign=%d cap=%d n[]=", x->sign, x->capacity);
+ for(i=0; i<abs(x->sign); i++) {
+ sprintf(printbuf5 + 10*i, "%u:", x->n[i]);
+ }
+}
+#endif /* FEE_DEBUG */
+#endif /* 0 */
+
+/******** debugging flags *********/
+
+/*
+ * Flag use of unoptimized divg, modg, binvg
+ */
+//#define WARN_UNOPTIMIZE FEE_DEBUG
+#define WARN_UNOPTIMIZE 0
+
+/*
+ * Log interesting giant stack events
+ */
+#define LOG_GIANT_STACK 0
+
+/*
+ * Log allocation of giant larger than stack size
+ */
+#define LOG_GIANT_STACK_OVERFLOW 1
+
+/*
+ * Flag newGiant(0) and borrowGiant(0) calls
+ */
+#define WARN_ZERO_GIANT_SIZE FEE_DEBUG
+
+/* temp mac-only giant initialization debug */
+#define GIANT_MAC_DEBUG 0
+#if GIANT_MAC_DEBUG
+
+#include <string.h>
+#include <TextUtils.h>
+
+/* this one needs a writable string */
+static void logCom(unsigned char *str) {
+ c2pstr((char *)str);
+ DebugStr(str);
+}
+
+/* constant strings */
+void dblog0(const char *str) {
+ Str255 outStr;
+ strcpy((char *)outStr, str);
+ logCom(outStr);
+}
+
+#else
+#define dblog0(s)
+
+#endif /* GIANT_MAC_DEBUG */
+
+#ifndef min
+#define min(a,b) ((a)<(b)? (a) : (b))
+#endif // min
+#ifndef max
+#define max(a,b) ((a)>(b)? (a) : (b))
+#endif // max
+
+#ifndef TRUE
+#define TRUE 1
+#endif // TRUE
+#ifndef FALSE
+#define FALSE 0
+#endif // FALSE
+
+static void absg(giant g); /* g := |g|. */
+
+/************** globals *******************/
+
+
+/* ------ giant stack package ------ */
+
+/*
+ * The giant stack package is a local cache which allows us to avoid calls
+ * to malloc() for borrowGiant(). On a 90 Mhz Pentium, enabling the
+ * giant stack package shows about a 1.35 speedup factor over an identical
+ * CryptKit without the giant stacks enabled.
+ */
+
+#if GIANTS_VIA_STACK
+
+#if LOG_GIANT_STACK
+#define gstackDbg(x) printf x
+#else // LOG_GIANT_STACK
+#define gstackDbg(x)
+#endif // LOG_GIANT_STACK
+
+typedef struct {
+ unsigned numDigits; // capacity of giants in this stack
+ unsigned numFree; // number of free giants in stack
+ unsigned totalGiants; // total number in *stack
+ giant *stack;
+} gstack;
+
+static gstack *gstacks = NULL; // array of stacks
+static unsigned numGstacks = 0; // # of elements in gstacks
+static int gstackInitd = 0; // this module has been init'd
+
+#define INIT_NUM_GIANTS 16 /* initial # of giants / stack */
+#define MIN_GIANT_SIZE 4 /* numDigits for gstack[0] */
+#define GIANT_SIZE_INCR 2 /* in << bits */
+
+/*
+ * Initialize giant stacks, with up to specified max giant size.
+ */
+void initGiantStacks(unsigned maxDigits)
+{
+ unsigned curSize = MIN_GIANT_SIZE;
+ unsigned sz;
+ unsigned i;
+
+ dblog0("initGiantStacks\n");
+
+ if(gstackInitd) {
+ /*
+ * Shouldn't be called more than once...
+ */
+ printf("multiple initGiantStacks calls\n");
+ return;
+ }
+ gstackDbg(("initGiantStacks(%d)\n", maxDigits));
+
+ /*
+ * How many stacks?
+ */
+ numGstacks = 1;
+ while(curSize<=maxDigits) {
+ curSize <<= GIANT_SIZE_INCR;
+ numGstacks++;
+ }
+
+ sz = sizeof(gstack) * numGstacks;
+ gstacks = (gstack*) fmalloc(sz);
+ bzero(gstacks, sz);
+
+ curSize = MIN_GIANT_SIZE;
+ for(i=0; i<numGstacks; i++) {
+ gstacks[i].numDigits = curSize;
+ curSize <<= GIANT_SIZE_INCR;
+ }
+
+ gstackInitd = 1;
+}
+
+/* called at shut down - free resources */
+void freeGiantStacks(void)
+{
+ int i;
+ int j;
+ gstack *gs;
+
+ if(!gstackInitd) {
+ return;
+ }
+ for(i=0; i<numGstacks; i++) {
+ gs = &gstacks[i];
+ for(j=0; j<gs->numFree; j++) {
+ freeGiant(gs->stack[j]);
+ gs->stack[j] = NULL;
+ }
+ /* and the stack itself - may be null if this was never used */
+ if(gs->stack != NULL) {
+ ffree(gs->stack);
+ gs->stack = NULL;
+ }
+ }
+ ffree(gstacks);
+ gstacks = NULL;
+ gstackInitd = 0;
+}
+
+#endif // GIANTS_VIA_STACK
+
+giant borrowGiant(unsigned numDigits)
+{
+ giant result;
+
+ #if GIANTS_VIA_STACK
+
+ unsigned stackNum;
+ gstack *gs = gstacks;
+
+ #if WARN_ZERO_GIANT_SIZE
+ if(numDigits == 0) {
+ printf("borrowGiant(0)\n");
+ numDigits = gstacks[numGstacks-1].numDigits;
+ }
+ #endif // WARN_ZERO_GIANT_SIZE
+
+ /*
+ * Find appropriate stack
+ */
+ if(numDigits <= MIN_GIANT_SIZE)
+ stackNum = 0;
+ else if (numDigits <= (MIN_GIANT_SIZE << GIANT_SIZE_INCR))
+ stackNum = 1;
+ else if (numDigits <= (MIN_GIANT_SIZE << (2 * GIANT_SIZE_INCR)))
+ stackNum = 2;
+ else if (numDigits <= (MIN_GIANT_SIZE << (3 * GIANT_SIZE_INCR)))
+ stackNum = 3;
+ else if (numDigits <= (MIN_GIANT_SIZE << (4 * GIANT_SIZE_INCR)))
+ stackNum = 4;
+ else
+ stackNum = numGstacks;
+
+ if(stackNum >= numGstacks) {
+ /*
+ * out of bounds; just malloc
+ */
+ #if LOG_GIANT_STACK_OVERFLOW
+ gstackDbg(("giantFromStack overflow; numDigits %d\n",
+ numDigits));
+ #endif // LOG_GIANT_STACK_OVERFLOW
+ return newGiant(numDigits);
+ }
+ gs = &gstacks[stackNum];
+
+ #if GIANT_MAC_DEBUG
+ if((gs->numFree != 0) && (gs->stack == NULL)) {
+ dblog0("borrowGiant: null stack!\n");
+ }
+ #endif
+
+ if(gs->numFree != 0) {
+ result = gs->stack[--gs->numFree];
+ }
+ else {
+ /*
+ * Stack empty; malloc
+ */
+ result = newGiant(gs->numDigits);
+ }
+
+ #else /* GIANTS_VIA_STACK */
+
+ result = newGiant(numDigits);
+
+ #endif /* GIANTS_VIA_STACK */
+
+ PROF_INCR(numBorrows);
+ return result;
+}
+
+void returnGiant(giant g)
+{
+
+ #if GIANTS_VIA_STACK
+
+ unsigned stackNum;
+ gstack *gs;
+ unsigned cap = g->capacity;
+
+
+ #if FEE_DEBUG
+ if(!gstackInitd) {
+ CKRaise("returnGiant before stacks initialized!");
+ }
+ #endif // FEE_DEBUG
+
+ #if GIANT_MAC_DEBUG
+ if(g == NULL) {
+ dblog0("returnGiant: null g!\n");
+ }
+ #endif
+
+ /*
+ * Find appropriate stack. Note we expect exact match of
+ * capacity and stack's giant size.
+ */
+ /*
+ * Optimized unrolled loop. Just make sure there are enough cases
+ * to handle all of the stacks. Errors in this case will be flagged
+ * via LOG_GIANT_STACK_OVERFLOW.
+ */
+ switch(cap) {
+ case MIN_GIANT_SIZE:
+ stackNum = 0;
+ break;
+ case MIN_GIANT_SIZE << GIANT_SIZE_INCR:
+ stackNum = 1;
+ break;
+ case MIN_GIANT_SIZE << (2 * GIANT_SIZE_INCR):
+ stackNum = 2;
+ break;
+ case MIN_GIANT_SIZE << (3 * GIANT_SIZE_INCR):
+ stackNum = 3;
+ break;
+ case MIN_GIANT_SIZE << (4 * GIANT_SIZE_INCR):
+ stackNum = 4;
+ break;
+ default:
+ stackNum = numGstacks;
+ break;
+ }
+
+ if(stackNum >= numGstacks) {
+ /*
+ * out of bounds; just free
+ */
+ #if LOG_GIANT_STACK_OVERFLOW
+ gstackDbg(("giantToStack overflow; numDigits %d\n", cap));
+ #endif // LOG_GIANT_STACK_OVERFLOW
+ freeGiant(g);
+ return;
+ }
+ gs = &gstacks[stackNum];
+ if(gs->numFree == gs->totalGiants) {
+ if(gs->totalGiants == 0) {
+ gstackDbg(("Initial alloc of gstack(%d)\n",
+ gs->numDigits));
+ gs->totalGiants = INIT_NUM_GIANTS;
+ }
+ else {
+ gs->totalGiants *= 2;
+ gstackDbg(("Bumping gstack(%d) to %d\n",
+ gs->numDigits, gs->totalGiants));
+ }
+ gs->stack = (giantstruct**) frealloc(gs->stack, gs->totalGiants*sizeof(giant));
+ }
+ g->sign = 0; // not sure this is important...
+ gs->stack[gs->numFree++] = g;
+
+ #if GIANT_MAC_DEBUG
+ if((gs->numFree != 0) && (gs->stack == NULL)) {
+ dblog0("borrowGiant: null stack!\n");
+ }
+ #endif
+
+ #else /* GIANTS_VIA_STACK */
+
+ freeGiant(g);
+
+ #endif /* GIANTS_VIA_STACK */
+}
+
+void freeGiant(giant x) {
+ ffree(x);
+}
+
+giant newGiant(unsigned numDigits) {
+ // giant sufficient for 2^numbits+16 sized ops
+ int size;
+ giant result;
+
+ #if WARN_ZERO_GIANT_SIZE
+ if(numDigits == 0) {
+ printf("newGiant(0)\n");
+ #if GIANTS_VIA_STACK
+ numDigits = gstacks[numGstacks-1].totalGiants;
+ #else
+ /* HACK */
+ numDigits = 20;
+ #endif
+ }
+ #endif // WARN_ZERO_GIANT_SIZE
+
+ size = (numDigits-1) * GIANT_BYTES_PER_DIGIT + sizeof(giantstruct);
+ result = (giant)fmalloc(size);
+ if(result == NULL) {
+ return NULL;
+ }
+ result->sign = 0;
+ result->capacity = numDigits;
+ return result;
+}
+
+giant copyGiant(giant x)
+{
+ int bytes;
+
+ giant result = newGiant(x->capacity);
+
+ /*
+ * 13 Jun 1997
+ * NO! this assumes packed alignment
+ */
+ bytes = sizeof(giantstruct) +
+ ((x->capacity - 1) * GIANT_BYTES_PER_DIGIT);
+ bcopy(x, result, bytes);
+ return result;
+}
+
+/* ------ initialization and utility routines ------ */
+
+
+unsigned bitlen(giant n) {
+ unsigned b = GIANT_BITS_PER_DIGIT;
+ giantDigit c = 1 << (GIANT_BITS_PER_DIGIT - 1);
+ giantDigit w;
+
+ if (isZero(n)) {
+ return(0);
+ }
+ w = n->n[abs(n->sign) - 1];
+ if (!w) {
+ CKRaise("bitlen - no bit set!");
+ }
+ while((w&c) == 0) {
+ b--;
+ c >>= 1;
+ }
+ return(GIANT_BITS_PER_DIGIT * (abs(n->sign)-1) + b);
+}
+
+int bitval(giant n, int pos) {
+ int i = abs(pos) >> GIANT_LOG2_BITS_PER_DIGIT;
+ giantDigit c = 1 << (pos & (GIANT_BITS_PER_DIGIT - 1));
+
+ return((n->n[i]) & c);
+}
+
+int gsign(giant g)
+/* returns the sign of g */
+{
+ if (isZero(g)) return(0);
+ if (g->sign > 0) return(1);
+ return(-1);
+}
+
+/*
+ * Adjust sign for possible leading (m.s.) zero digits
+ */
+void gtrimSign(giant g)
+{
+ int numDigits = abs(g->sign);
+ int i;
+
+ for(i=numDigits-1; i>=0; i--) {
+ if(g->n[i] == 0) {
+ numDigits--;
+ }
+ else {
+ break;
+ }
+ }
+ if(g->sign < 0) {
+ g->sign = -numDigits;
+ }
+ else {
+ g->sign = numDigits;
+ }
+}
+
+
+int isone(giant g) {
+ return((g->sign==1)&&(g->n[0]==1));
+}
+
+int isZero(giant thegiant) {
+/* Returns TRUE if thegiant == 0. */
+ int count;
+ int length = abs(thegiant->sign);
+ giantDigit *numpointer;
+
+ if (length) {
+ numpointer = thegiant->n;
+
+ for(count = 0; count<length; ++count,++numpointer)
+ if (*numpointer != 0 ) return(FALSE);
+ }
+ return(TRUE);
+}
+
+int gcompg(giant a, giant b)
+/* returns -1,0,1 if a<b, a=b, a>b, respectively */
+{
+ int sa = a->sign;
+ int j;
+ int sb = b->sign;
+ giantDigit va;
+ giantDigit vb;
+ int sgn;
+
+ if(isZero(a) && isZero(b)) return 0;
+ if(sa > sb) return(1);
+ if(sa < sb) return(-1);
+ if(sa < 0) {
+ sa = -sa; /* Take absolute value of sa */
+ sgn = -1;
+ } else sgn = 1;
+ for(j = sa-1; j >= 0; j--) {
+ va = a->n[j]; vb = b->n[j];
+ if (va > vb) return(sgn);
+ if (va < vb) return(-sgn);
+ }
+ return(0);
+}
+
+/* destgiant becomes equal to srcgiant */
+void gtog(giant srcgiant, giant destgiant) {
+
+ int numbytes;
+
+ CKASSERT(srcgiant != NULL);
+ numbytes = abs(srcgiant->sign) * GIANT_BYTES_PER_DIGIT;
+ if (destgiant->capacity < abs(srcgiant->sign))
+ CKRaise("gtog overflow!!");
+ memcpy((char *)destgiant->n, (char *)srcgiant->n, numbytes);
+ destgiant->sign = srcgiant->sign;
+}
+
+void int_to_giant(int i, giant g) {
+/* The giant g becomes set to the integer value i. */
+ int isneg = (i<0);
+ unsigned int j = abs(i);
+ unsigned dex;
+
+ g->sign = 0;
+ if (i==0) {
+ g->n[0] = 0;
+ return;
+ }
+
+ if(GIANT_BYTES_PER_DIGIT == sizeof(int)) {
+ g->n[0] = j;
+ g->sign = 1;
+ }
+ else {
+ /* one loop per digit */
+ unsigned scnt = GIANT_BITS_PER_DIGIT; // fool compiler
+
+ for(dex=0; dex<sizeof(int); dex++) {
+ g->n[dex] = j & GIANT_DIGIT_MASK;
+ j >>= scnt;
+ g->sign++;
+ if(j == 0) {
+ break;
+ }
+ }
+ }
+ if (isneg) {
+ g->sign = -(g->sign);
+ }
+}
+
+/*------------- Arithmetic --------------*/
+
+void negg(giant g) {
+/* g becomes -g */
+ g->sign = -g->sign;
+}
+
+void iaddg(int i, giant g) { /* positive g becomes g + (int)i */
+ int j;
+ giantDigit carry;
+ int size = abs(g->sign);
+
+ if (isZero(g)) {
+ int_to_giant(i,g);
+ }
+ else {
+ carry = i;
+ for(j=0; ((j<size) && (carry != 0)); j++) {
+ g->n[j] = giantAddDigits(g->n[j], carry, &carry);
+ }
+ if(carry) {
+ ++g->sign;
+ // realloc
+ if (g->sign > (int)g->capacity) CKRaise("iaddg overflow!");
+ g->n[size] = carry;
+ }
+ }
+}
+
+/*
+ * g *= (int n)
+ *
+ * FIXME - we can improve this...
+ */
+void imulg(unsigned n, giant g)
+{
+ giant tmp = borrowGiant(abs(g->sign) + sizeof(int));
+
+ int_to_giant(n, tmp);
+ mulg(tmp, g);
+ returnGiant(tmp);
+}
+
+static void normal_addg(giant a, giant b)
+/* b := a + b, both a,b assumed non-negative. */
+{
+ giantDigit carry1 = 0;
+ giantDigit carry2 = 0;
+ int asize = a->sign, bsize = b->sign;
+ giantDigit *an = a->n;
+ giantDigit *bn = b->n;
+ giantDigit tmp;
+ int j;
+ int comSize;
+ int maxSize;
+
+ if(asize < bsize) {
+ comSize = asize;
+ maxSize = bsize;
+ }
+ else {
+ comSize = bsize;
+ maxSize = asize;
+ }
+
+ /* first handle the common digits */
+ for(j=0; j<comSize; j++) {
+ /*
+ * first add the carry, then an[j] - either add could result
+ * in another carry
+ */
+ if(carry1 || carry2) {
+ tmp = giantAddDigits(bn[j], (giantDigit)1, &carry1);
+ }
+ else {
+ carry1 = 0;
+ tmp = bn[j];
+ }
+ bn[j] = giantAddDigits(tmp, an[j], &carry2);
+ }
+
+ if(asize < bsize) {
+
+ /* now propagate remaining carry beyond asize */
+ if(carry2) {
+ carry1 = 1;
+ }
+ if(carry1) {
+ for(; j<bsize; j++) {
+ bn[j] = giantAddDigits(bn[j], (giantDigit)1, &carry1);
+ if(carry1 == 0) {
+ break;
+ }
+ }
+ }
+ } else {
+ /* now propagate remaining an[] and carry beyond bsize */
+ if(carry2) {
+ carry1 = 1;
+ }
+ for(; j<asize; j++) {
+ if(carry1) {
+ bn[j] = giantAddDigits(an[j], (giantDigit)1, &carry1);
+ }
+ else {
+ bn[j] = an[j];
+ carry1 = 0;
+ }
+ }
+ }
+ b->sign = maxSize;
+ if(carry1) {
+ // realloc?
+ bn[j] = 1;
+ b->sign++;
+ if (b->sign > (int)b->capacity) CKRaise("iaddg overflow!");
+ }
+
+}
+
+static void normal_subg(giant a, giant b)
+/* b := b - a; requires b, a non-negative and b >= a. */
+{
+ int j;
+ int size = b->sign;
+ giantDigit tmp;
+ giantDigit borrow1 = 0;
+ giantDigit borrow2 = 0;
+ giantDigit *an = a->n;
+ giantDigit *bn = b->n;
+
+ if(a->sign == 0) {
+ return;
+ }
+
+ for (j=0; j<a->sign; ++j) {
+ if(borrow1 || borrow2) {
+ tmp = giantSubDigits(bn[j], (giantDigit)1, &borrow1);
+ }
+ else {
+ tmp = bn[j];
+ borrow1 = 0;
+ }
+ bn[j] = giantSubDigits(tmp, an[j], &borrow2);
+ }
+ if(borrow1 || borrow2) {
+ /* propagate borrow thru remainder of bn[] */
+ borrow1 = 1;
+ for (j=a->sign; j<size; ++j) {
+ if(borrow1) {
+ bn[j] = giantSubDigits(bn[j], (giantDigit)1, &borrow1);
+ }
+ else {
+ break;
+ }
+ }
+ }
+
+ /* adjust sign for leading zero digits */
+ while((size-- > 0) && (b->n[size] == 0))
+ ;
+ b->sign = (b->n[size] == 0)? 0 : size+1;
+}
+
+static void reverse_subg(giant a, giant b)
+/* b := a - b; requires b, a non-negative and a >= b. */
+{
+ int j;
+ int size = a->sign;
+ giantDigit tmp;
+ giantDigit borrow1 = 0;
+ giantDigit borrow2 = 0;
+ giantDigit *an = a->n;
+ giantDigit *bn = b->n;
+
+ if(b->sign == 0) {
+ gtog(a, b);
+ return;
+ }
+ for (j=0; j<b->sign; ++j) {
+ if(borrow1 || borrow2) {
+ tmp = giantSubDigits(an[j], (giantDigit)1, &borrow1);
+ }
+ else {
+ tmp = an[j];
+ borrow1 = 0;
+ }
+ bn[j] = giantSubDigits(tmp, bn[j], &borrow2);
+ }
+ if(borrow1 || borrow2) {
+ /* propagate borrow thru remainder of bn[] */
+ borrow1 = 1;
+ }
+ for (j=b->sign; j<size; ++j) {
+ if(borrow1) {
+ bn[j] = giantSubDigits(an[j], (giantDigit)1, &borrow1);
+ }
+ else {
+ bn[j] = an[j];
+ borrow1 = 0;
+ }
+ }
+
+ b->sign = size; /* REC, 21 Apr 1996. */
+ while(!b->n[--size]);
+ b->sign = size+1;
+}
+
+
+void addg(giant a, giant b)
+/* b := b + a, any signs any result. */
+{ int asgn = a->sign, bsgn = b->sign;
+ if(asgn == 0) return;
+ if(bsgn == 0) {
+ gtog(a,b);
+ return;
+ }
+ if((asgn < 0) == (bsgn < 0)) {
+ if(bsgn > 0) {
+ normal_addg(a,b);
+ return;
+ }
+ negg(a); if(a != b) negg(b); normal_addg(a,b); /* Fix REC 1 Dec 98. */
+ negg(a); if(a != b) negg(b); return; /* Fix REC 1 Dec 98. */
+ }
+ if(bsgn > 0) {
+ negg(a);
+ if(gcompg(b,a) >= 0) {
+ normal_subg(a,b);
+ negg(a);
+ return;
+ }
+ reverse_subg(a,b);
+ negg(a);
+ negg(b);
+ return;
+ }
+ negg(b);
+ if(gcompg(b,a) < 0) {
+ reverse_subg(a,b);
+ return;
+ }
+ normal_subg(a,b);
+ negg(b);
+ return;
+}
+
+void subg(giant a, giant b)
+/* b := b - a, any signs, any result. */
+{
+ int asgn = a->sign, bsgn = b->sign;
+ if(asgn == 0) return;
+ if(bsgn == 0) {
+ gtog(a,b);
+ negg(b);
+ return;
+ }
+ if((asgn < 0) != (bsgn < 0)) {
+ if(bsgn > 0) {
+ negg(a);
+ normal_addg(a,b);
+ negg(a);
+ return;
+ }
+ negg(b);
+ normal_addg(a,b);
+ negg(b);
+ return;
+ }
+ if(bsgn > 0) {
+ if(gcompg(b,a) >= 0) {
+ normal_subg(a,b);
+ return;
+ }
+ reverse_subg(a,b);
+ negg(b);
+ return;
+ }
+ negg(a); negg(b);
+ if(gcompg(b,a) >= 0) {
+ normal_subg(a,b);
+ negg(a);
+ negg(b);
+ return;
+ }
+ reverse_subg(a,b);
+ negg(a);
+ return;
+}
+
+static void bdivg(giant v, giant u)
+/* u becomes greatest power of two not exceeding u/v. */
+{
+ int diff = bitlen(u) - bitlen(v);
+ giant scratch7;
+
+ if (diff<0) {
+ int_to_giant(0,u);
+ return;
+ }
+ scratch7 = borrowGiant(u->capacity);
+ gtog(v, scratch7);
+ gshiftleft(diff,scratch7);
+ if(gcompg(u,scratch7) < 0) diff--;
+ if(diff<0) {
+ int_to_giant(0,u);
+ returnGiant(scratch7);
+ return;
+ }
+ int_to_giant(1,u);
+ gshiftleft(diff,u);
+ returnGiant(scratch7);
+}
+
+int binvaux(giant p, giant x)
+/* Binary inverse method.
+ Returns zero if no inverse exists, in which case x becomes
+ GCD(x,p). */
+{
+ giant scratch7;
+ giant u0;
+ giant u1;
+ giant v0;
+ giant v1;
+ int result = 1;
+ int giantSize;
+ PROF_START;
+
+ if(isone(x)) return(result);
+ giantSize = 4 * abs(p->sign);
+ scratch7 = borrowGiant(giantSize);
+ u0 = borrowGiant(giantSize);
+ u1 = borrowGiant(giantSize);
+ v0 = borrowGiant(giantSize);
+ v1 = borrowGiant(giantSize);
+ int_to_giant(1, v0); gtog(x, v1);
+ int_to_giant(0,x); gtog(p, u1);
+ while(!isZero(v1)) {
+ gtog(u1, u0); bdivg(v1, u0);
+ gtog(x, scratch7);
+ gtog(v0, x);
+ mulg(u0, v0);
+ subg(v0,scratch7);
+ gtog(scratch7, v0);
+
+ gtog(u1, scratch7);
+ gtog(v1, u1);
+ mulg(u0, v1);
+ subg(v1,scratch7);
+ gtog(scratch7, v1);
+ }
+ if (!isone(u1)) {
+ gtog(u1,x);
+ if(x->sign<0) addg(p, x);
+ result = 0;
+ goto done;
+ }
+ if (x->sign<0) addg(p, x);
+ done:
+ returnGiant(scratch7);
+ returnGiant(u0);
+ returnGiant(u1);
+ returnGiant(v0);
+ returnGiant(v1);
+ PROF_END(binvauxTime);
+ return(result);
+}
+
+/*
+ * Superceded by binvg_cp()
+ */
+#if 0
+int binvg(giant p, giant x)
+{
+ modg(p, x);
+ return(binvaux(p,x));
+}
+#endif
+
+static void absg(giant g) {
+/* g becomes the absolute value of g */
+ if (g->sign < 0) g->sign = -g->sign;
+}
+
+void gshiftleft(int bits, giant g) {
+/* shift g left bits bits. Equivalent to g = g*2^bits */
+ int rem = bits & (GIANT_BITS_PER_DIGIT - 1);
+ int crem = GIANT_BITS_PER_DIGIT - rem;
+ int digits = 1 + (bits >> GIANT_LOG2_BITS_PER_DIGIT);
+ int size = abs(g->sign);
+ int j;
+ int k;
+ int sign = gsign(g);
+ giantDigit carry;
+ giantDigit dat;
+
+ #if FEE_DEBUG
+ if(bits < 0) {
+ CKRaise("gshiftleft(-bits)\n");
+ }
+ #endif /* FEE_DEBUG */
+
+ if(!bits) return;
+ if(!size) return;
+ if((size+digits) > (int)g->capacity) {
+ CKRaise("gshiftleft overflow");
+ return;
+ }
+ k = size - 1 + digits; // (MSD of result + 1)
+ carry = 0;
+
+ /* bug fix for 32-bit giantDigits; this is also an optimization for
+ * other sizes. rem=0 means we're shifting strictly by digits, no
+ * bit shifts. */
+ if(rem == 0) {
+ g->n[k] = 0; // XXX hack - for sign fixup
+ for(j=size-1; j>=0; j--) {
+ g->n[--k] = g->n[j];
+ }
+ do{
+ g->n[--k] = 0;
+ } while(k>0);
+ }
+ else {
+ /*
+ * normal unaligned case
+ * FIXME - this writes past g->n[size-1] the first time thru!
+ */
+ for(j=size-1; j>=0; j--) {
+ dat = g->n[j];
+ g->n[k--] = (dat >> crem) | carry;
+ carry = (dat << rem);
+ }
+ do{
+ g->n[k--] = carry;
+ carry = 0;
+ } while(k>=0);
+ }
+ k = size - 1 + digits;
+ if(g->n[k] == 0) --k;
+ g->sign = sign * (k+1);
+ if (abs(g->sign) > g->capacity) {
+ CKRaise("gshiftleft overflow");
+ }
+}
+
+void gshiftright(int bits, giant g) {
+/* shift g right bits bits. Equivalent to g = g/2^bits */
+ int j;
+ int size=abs(g->sign);
+ giantDigit carry;
+ int digits = bits >> GIANT_LOG2_BITS_PER_DIGIT;
+ int remain = bits & (GIANT_BITS_PER_DIGIT - 1);
+ int cremain = GIANT_BITS_PER_DIGIT - remain;
+
+ #if FEE_DEBUG
+ if(bits < 0) {
+ CKRaise("gshiftright(-bits)\n");
+ }
+ #endif /* FEE_DEBUG */
+ if(bits==0) return;
+ if(isZero(g)) return;
+ if (digits >= size) {
+ g->sign = 0;
+ return;
+ }
+
+ size -= digits;
+
+/* Begin OPT: 9 Jan 98 REC. */
+ if(remain == 0) {
+ if(g->sign > 0) {
+ g->sign = size;
+ }
+ else {
+ g->sign = -size;
+ }
+ for(j=0; j < size; j++) {
+ g->n[j] = g->n[j+digits];
+ }
+ return;
+ }
+/* End OPT: 9 Jan 98 REC. */
+
+ for(j=0;j<size;++j) {
+ if (j==size-1) {
+ carry = 0;
+ }
+ else {
+ carry = (g->n[j+digits+1]) << cremain;
+ }
+ g->n[j] = ((g->n[j+digits]) >> remain ) | carry;
+ }
+ if (g->n[size-1] == 0) {
+ --size;
+ }
+ if(g->sign > 0) {
+ g->sign = size;
+ }
+ else {
+ g->sign = -size;
+ }
+ if (abs(g->sign) > g->capacity) {
+ CKRaise("gshiftright overflow");
+ }
+}
+
+
+void extractbits(unsigned n, giant src, giant dest) {
+/* dest becomes lowermost n bits of src. Equivalent to dest = src % 2^n */
+ int digits = n >> GIANT_LOG2_BITS_PER_DIGIT;
+ int numbytes = digits * GIANT_BYTES_PER_DIGIT;
+ int bits = n & (GIANT_BITS_PER_DIGIT - 1);
+
+ if (n <= 0) {
+ return;
+ }
+ if (dest->capacity * 8 * GIANT_BYTES_PER_DIGIT < n) {
+ CKRaise("extractbits - not enough room");
+ }
+ if (digits >= abs(src->sign)) {
+ gtog(src,dest);
+ }
+ else {
+ memcpy((char *)(dest->n), (char *)(src->n), numbytes);
+ if (bits) {
+ dest->n[digits] = src->n[digits] & ((1<<bits)-1);
+ ++digits;
+ }
+ /* Next, fix by REC, 12 Jan 97. */
+ // while((dest->n[words-1] == 0) && (words > 0)) --words;
+ while((digits > 0) && (dest->n[digits-1] == 0)) {
+ --digits;
+ }
+ if(src->sign < 0) {
+ dest->sign = -digits;
+ }
+ else {
+ dest->sign = digits;
+ }
+ }
+ if (abs(dest->sign) > dest->capacity) {
+ CKRaise("extractbits overflow");
+ }
+}
+
+#define NEW_MERSENNE 0
+
+/*
+ * New gmersennemod, 24 Dec 1997. This runs significantly slower than the
+ * original.
+ */
+#if NEW_MERSENNE
+
+void
+gmersennemod(
+ int n,
+ giant g
+)
+/* g := g (mod 2^n - 1) */
+{
+ int the_sign;
+ giant scratch3 = borrowGiant(g->capacity);
+ giant scratch4 = borrowGiant(1);
+
+ if ((the_sign = gsign(g)) < 0) absg(g);
+ while (bitlen(g) > n) {
+ gtog(g,scratch3);
+ gshiftright(n,scratch3);
+ addg(scratch3,g);
+ gshiftleft(n,scratch3);
+ subg(scratch3,g);
+ }
+ if(isZero(g)) goto out;
+ int_to_giant(1,scratch3);
+ gshiftleft(n,scratch3);
+ int_to_giant(1,scratch4);
+ subg(scratch4,scratch3);
+ if(gcompg(g,scratch3) >= 0) subg(scratch3,g);
+ if (the_sign < 0) {
+ g->sign = -g->sign;
+ addg(scratch3,g);
+ }
+out:
+ returnGiant(scratch3);
+ returnGiant(scratch4);
+}
+
+#else /* NEW_MERSENNE */
+
+void gmersennemod(int n, giant g) {
+/* g becomes g mod ((2^n)-1)
+ 31 Jul 96 modified REC.
+ 17 Jan 97 modified REC.
+*/
+ unsigned bits = n & (GIANT_BITS_PER_DIGIT - 1);
+ unsigned digits = 1 + ((n-1) >> GIANT_LOG2_BITS_PER_DIGIT);
+ int isPositive = (g->sign > 0);
+ int j;
+ int b;
+ int size;
+ int foundzero;
+ giantDigit mask = (bits == 0) ? GIANT_DIGIT_MASK : (giantDigit)((1<<bits)-1);
+ giant scratch1;
+
+ b = bitlen(g);
+ if(b < n) {
+ unsigned numDigits = (n + GIANT_BITS_PER_DIGIT - 1) >>
+ GIANT_LOG2_BITS_PER_DIGIT;
+ giantDigit lastWord = 0;
+ giantDigit bits = 1;
+
+ if(g->sign >= 0) return;
+
+ /*
+ * Cons up ((2**n)-1), add to g.
+ */
+ scratch1 = borrowGiant(numDigits + 1);
+ scratch1->sign = numDigits;
+ for(j=0; j<(int)(numDigits-1); j++) {
+ scratch1->n[j] = GIANT_DIGIT_MASK;
+ }
+
+ /*
+ * Last word has lower (n & (GIANT_BITS_PER_DIGIT-1)) bits set.
+ */
+ for(j=0; j < (int)(n & (GIANT_BITS_PER_DIGIT-1)); j++) {
+ lastWord |= bits;
+ bits <<= 1;
+ }
+ scratch1->n[numDigits-1] = lastWord;
+ addg(g, scratch1); /* One version. */
+ gtog(scratch1, g);
+ returnGiant(scratch1);
+ return;
+ }
+ if(b == n) {
+ for(foundzero=0, j=0; j<b; j++) {
+ if(bitval(g, j)==0) {
+ foundzero = 1;
+ break;
+ }
+ }
+ if (!foundzero) {
+ int_to_giant(0, g);
+ return;
+ }
+ }
+
+ absg(g);
+ scratch1 = borrowGiant(g->capacity);
+ while ( ((unsigned)(g->sign) > digits) ||
+ ( ((unsigned)(g->sign)==digits) && (g->n[digits-1] > mask))) {
+ extractbits(n, g, scratch1);
+ gshiftright(n, g);
+ addg(scratch1, g);
+ }
+ size = g->sign;
+
+/* Commence new negation routine - REC 17 Jan 1997. */
+ if (!isPositive) { /* Mersenne negation is just bitwise complement. */
+ for(j = digits-1; j >= size; j--) {
+ g->n[j] = GIANT_DIGIT_MASK;
+ }
+ for(j = size-1; j >= 0; j--) {
+ g->n[j] = ~g->n[j];
+ }
+ g->n[digits-1] &= mask;
+ j = digits-1;
+ while((g->n[j] == 0) && (j > 0)) {
+ --j;
+ }
+ size = j+1;
+ }
+/* End new negation routine. */
+
+ g->sign = size;
+ if (abs(g->sign) > g->capacity) {
+ CKRaise("gmersennemod overflow");
+ }
+ if (size < (int)digits) {
+ goto bye;
+ }
+ if (g->n[size-1] != mask) {
+ goto bye;
+ }
+ mask = GIANT_DIGIT_MASK;
+ for(j=0; j<(size-1); j++) {
+ if (g->n[j] != mask) {
+ goto bye;
+ }
+ }
+ g->sign = 0;
+ bye:
+ returnGiant(scratch1);
+}
+
+#endif /* NEW_MERSENNE */
+
+void mulg(giant a, giant b) { /* b becomes a*b. */
+
+ int i;
+ int asize, bsize;
+ giantDigit *bptr = b->n;
+ giantDigit mult;
+ giant scratch1;
+ giantDigit carry;
+ giantDigit *scrPtr;
+
+
+ if (isZero(b)) {
+ return;
+ }
+ if (isZero(a)) {
+ gtog(a, b);
+ return;
+ }
+ if(a == b) {
+ grammarSquare(b);
+ return;
+ }
+
+ bsize = abs(b->sign);
+ asize = abs(a->sign);
+ scratch1 = borrowGiant((asize+bsize));
+ scrPtr = scratch1->n;
+
+ for(i=0; i<asize+bsize; ++i) {
+ scrPtr[i]=0;
+ }
+
+ for(i=0; i<bsize; ++i, scrPtr++) {
+ mult = bptr[i];
+ if (mult != 0) {
+ carry = VectorMultiply(mult,
+ a->n,
+ asize,
+ scrPtr);
+ /* handle MSD carry */
+ scrPtr[asize] += carry;
+ }
+ }
+ bsize+=asize;
+ if(scratch1->n[bsize - 1] == 0) {
+ --bsize;
+ }
+ scratch1->sign = gsign(a) * gsign(b) * bsize;
+ if (abs(scratch1->sign) > scratch1->capacity) {
+ CKRaise("GiantGrammarMul overflow");
+ }
+ gtog(scratch1,b);
+ returnGiant(scratch1);
+
+ #if FEE_DEBUG
+ (void)bitlen(b); // Assertion....
+ #endif /* FEE_DEBUG */
+ PROF_INCR(numMulg); // for normal profiling
+ INCR_MULGS; // for ellipticMeasure
+}
+
+void grammarSquare(giant a) {
+ /*
+ * For now, we're going to match the old implementation line for
+ * line by maintaining prod, carry, and temp as double precision
+ * giantDigits. There is probably a much better implementation....
+ */
+ giantDigit prodLo;
+ giantDigit prodHi;
+ giantDigit carryLo = 0;
+ giantDigit carryHi = 0;
+ giantDigit tempLo;
+ giantDigit tempHi;
+ unsigned int cur_term;
+ unsigned asize;
+ unsigned max;
+ giantDigit *ptr = a->n;
+ giantDigit *ptr1;
+ giantDigit *ptr2;
+ giant scratch;
+
+ /* dmitch 11 Jan 1998 - special case for a == 0 */
+ if(a->sign == 0) {
+ goto end;
+ }
+ /* end a == 0 case */
+ asize = abs(a->sign);
+ max = asize * 2 - 1;
+ scratch = borrowGiant(2 * asize);
+ asize--;
+
+ /*
+ * temp = *ptr;
+ * temp *= temp;
+ * scratch->n[0] = temp;
+ * carry = temp >> 16;
+ */
+ giantMulDigits(*ptr, *ptr, &tempLo, &tempHi);
+ scratch->n[0] = tempLo;
+ carryLo = tempHi;
+ carryHi = 0;
+
+ for (cur_term = 1; cur_term < max; cur_term++) {
+ ptr1 = ptr2 = ptr;
+ if (cur_term <= asize) {
+ ptr2 += cur_term;
+ } else {
+ ptr1 += cur_term - asize;
+ ptr2 += asize;
+ }
+
+ /*
+ * prod = carry & 0xFFFF;
+ * carry >>= 16;
+ */
+ prodLo = carryLo;
+ prodHi = 0;
+ carryLo = carryHi;
+ carryHi = 0;
+ while(ptr1 < ptr2) {
+ /*
+ * temp = *ptr1++ * *ptr2--;
+ */
+ giantMulDigits(*ptr1++, *ptr2--, &tempLo, &tempHi);
+
+ /*
+ * prod += (temp << 1) & 0xFFFF;
+ */
+ giantAddDouble(&prodLo, &prodHi, (tempLo << 1));
+
+ /*
+ * carry += (temp >> 15);
+ * use bits from both product digits..
+ */
+ giantAddDouble(&carryLo, &carryHi,
+ (tempLo >> (GIANT_BITS_PER_DIGIT - 1)));
+ giantAddDouble(&carryLo, &carryHi, (tempHi << 1));
+
+ /* snag the msb from that last shift */
+ carryHi += (tempHi >> (GIANT_BITS_PER_DIGIT - 1));
+ }
+ if (ptr1 == ptr2) {
+ /*
+ * temp = *ptr1;
+ * temp *= temp;
+ */
+ giantMulDigits(*ptr1, *ptr1, &tempLo, &tempHi);
+
+ /*
+ * prod += temp & 0xFFFF;
+ */
+ giantAddDouble(&prodLo, &prodHi, tempLo);
+
+ /*
+ * carry += (temp >> 16);
+ */
+ giantAddDouble(&carryLo, &carryHi, tempHi);
+ }
+
+ /*
+ * carry += prod >> 16;
+ */
+ giantAddDouble(&carryLo, &carryHi, prodHi);
+
+ scratch->n[cur_term] = prodLo;
+ }
+ if (carryLo) {
+ scratch->n[cur_term] = carryLo;
+ scratch->sign = cur_term+1;
+ } else scratch->sign = cur_term;
+
+ gtog(scratch,a);
+ returnGiant(scratch);
+end:
+ PROF_INCR(numGsquare);
+}
+
+/*
+ * Clear all of a giant's data fields, for secure erasure of sensitive data.,
+ */
+void clearGiant(giant g)
+{
+ unsigned i;
+
+ for(i=0; i<g->capacity; i++) {
+ g->n[i] = 0;
+ }
+ g->sign = 0;
+}
+
+#if ENGINE_127_BITS
+/*
+ * only used by engineNSA127.c, which is obsolete as of 16 Jan 1997
+ */
+int
+scompg(int n, giant g) {
+ if((g->sign == 1) && (g->n[0] == n)) return(1);
+ return(0);
+}
+
+#endif // ENGINE_127_BITS
+
+/*
+ */
+
+/*
+ * Calculate the reciprocal of a demonimator used in divg_via_recip() and
+ * modg_via_recip().
+ */
+void
+make_recip(giant d, giant r)
+/* r becomes the steady-state reciprocal
+ 2^(2b)/d, where b = bit-length of d-1. */
+{
+ int b;
+ int giantSize = 4 * abs(d->sign);
+ giant tmp = borrowGiant(giantSize);
+ giant tmp2 = borrowGiant(giantSize);
+
+ if (isZero(d) || (d->sign < 0))
+ {
+ CKRaise("illegal argument to make_recip");
+ }
+ int_to_giant(1, r); subg(r, d); b = bitlen(d); addg(r, d);
+ gshiftleft(b, r); gtog(r, tmp2);
+ while(1) {
+ gtog(r, tmp);
+ gsquare(tmp);
+ gshiftright(b, tmp);
+ mulg(d, tmp);
+ gshiftright(b, tmp);
+ addg(r, r); subg(tmp, r);
+ if(gcompg(r, tmp2) <= 0) break;
+ gtog(r, tmp2);
+ }
+ int_to_giant(1, tmp);
+ gshiftleft(2*b, tmp);
+ gtog(r, tmp2); mulg(d, tmp2);
+ subg(tmp2, tmp);
+ int_to_giant(1, tmp2);
+ while(tmp->sign < 0) {
+ subg(tmp2, r);
+ addg(d, tmp);
+ }
+
+ returnGiant(tmp);
+ returnGiant(tmp2);
+ return;
+}
+
+/*
+ * Optimized divg, when reciprocal of denominator is known.
+ */
+void
+divg_via_recip(giant d, giant r, giant n)
+/* n := n/d, where r is the precalculated
+ steady-state reciprocal of d. */
+{
+ int s = 2*(bitlen(r)-1), sign = gsign(n);
+ int giantSize = (4 * abs(d->sign)) + abs(n->sign);
+ giant tmp = borrowGiant(giantSize);
+ giant tmp2 = borrowGiant(giantSize);
+
+ if (isZero(d) || (d->sign < 0))
+ {
+ CKRaise("illegal argument to divg_via_recip");
+ }
+ n->sign = abs(n->sign);
+ int_to_giant(0, tmp2);
+ while(1) {
+ gtog(n, tmp);
+ mulg(r, tmp);
+ gshiftright(s, tmp);
+ addg(tmp, tmp2);
+ mulg(d, tmp);
+ subg(tmp, n);
+ if(gcompg(n,d) >= 0) {
+ subg(d,n);
+ iaddg(1, tmp2);
+ }
+ if(gcompg(n,d) < 0) break;
+ }
+ gtog(tmp2, n);
+ n->sign *= sign;
+ returnGiant(tmp);
+ returnGiant(tmp2);
+ return;
+}
+
+/*
+ * Optimized modg, when reciprocal of denominator is known.
+ */
+
+/* New version, 24 Dec 1997. */
+
+void
+modg_via_recip(
+ giant d,
+ giant r,
+ giant n
+)
+/* This is the fastest mod of the present collection.
+ n := n % d, where r is the precalculated
+ steady-state reciprocal of d. */
+
+{
+ int s = (bitlen(r)-1), sign = n->sign;
+ int giantSize = (4 * abs(d->sign)) + abs(n->sign);
+ giant tmp, tmp2;
+
+ tmp = borrowGiant(giantSize);
+ tmp2 = borrowGiant(giantSize);
+ if (isZero(d) || (d->sign < 0))
+ {
+ CKRaise("illegal argument to modg_via_recip");
+ }
+ n->sign = abs(n->sign);
+ while (1)
+ {
+ gtog(n, tmp);
+ /* bug fix 13 Apr 1998 */
+ if(s == 0) {
+ gshiftleft(1, tmp);
+ }
+ else {
+ gshiftright(s-1, tmp);
+ }
+ /* end fix */
+ mulg(r, tmp);
+ gshiftright(s+1, tmp);
+ mulg(d, tmp);
+ subg(tmp, n);
+ if (gcompg(n,d) >= 0)
+ subg(d,n);
+ if (gcompg(n,d) < 0)
+ break;
+ }
+ if (sign >= 0)
+ goto done;
+ if (isZero(n))
+ goto done;
+ negg(n);
+ addg(d,n);
+done:
+ returnGiant(tmp);
+ returnGiant(tmp2);
+ return;
+}
+
+/*
+ * Unoptimized, inefficient general modg, when reciprocal of denominator
+ * is not known.
+ */
+void
+modg(
+ giant d,
+ giant n
+)
+{
+ /* n becomes n%d. n is arbitrary, but the denominator d must be
+ * positive! */
+
+ /*
+ * 4/9/2001: seeing overflow on this recip. Alloc per
+ * d->capacity, not d->sign.
+ */
+ //giant recip = borrowGiant(2 * abs(d->sign));
+ giant recip = borrowGiant(2 * d->capacity);
+
+ #if WARN_UNOPTIMIZE
+ dbgLog(("Warning: unoptimized modg!\n"));
+ #endif // WARN_UNOPTIMIZE
+
+ make_recip(d, recip);
+ modg_via_recip(d, recip, n);
+ returnGiant(recip);
+}
+
+/*
+ * Unoptimized, inefficient general divg, when reciprocal of denominator
+ * is not known.
+ */
+void
+divg(
+ giant d,
+ giant n
+)
+{
+ /* n becomes n/d. n is arbitrary, but the denominator d must be
+ * positive!
+ */
+
+ giant recip = borrowGiant(2 * abs(d->sign));
+
+ #if WARN_UNOPTIMIZE
+ dbgLog(("Warning: unoptimized divg!\n"));
+ #endif // WARN_UNOPTIMIZE
+
+ make_recip(d, recip);
+ divg_via_recip(d, recip, n);
+ returnGiant(recip);
+}
projects / apple / security.git / blobdiff