+++ /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.
- ***************************************************************************
-
- elliptic.c - Library for Apple-proprietary Fast Elliptic
- Encryption. The algebra in this module ignores elliptic point's
- y-coordinates.
-
- Patent information:
-
- FEE is patented, U.S. Patents #5159632 (1992), #5271061 (1993),
- #5463690 (1994). These patents are implemented
- in various elliptic algebra functions such as
- numer/denom_plus/times(), and in the fact of special
- forms for primes: p = 2^q-k.
-
- Digital signature using fast elliptic addition, in
- U. S. Patent #5581616 (1996), is implemented in the
- signature_compare() function.
-
- FEED (Fast Elliptic Encryption) is patent pending (as of Jan 1998).
- Various functions such as elliptic_add() implement the patent ideas.
-
-
- Modification history since the U.S. Patent:
- -------------------------------------------
- 10/06/98 ap
- Changed to compile with C++.
- 9 Sep 98 at Apple
- cp->curveType optimizations.
- Removed code which handled "unknown" curve orders.
- elliptic() now exported for timing measurements.
- 21 Apr 98 at Apple
- Used inline platform-dependent giant arithmetic.
- 20 Jan 98 at Apple
- feemod now handles PT_MERSENNE, PT_FEE, PT_GENERAL.
- Added calcGiantSizes(), rewrote giantMinBytes(), giantMaxShorts().
- Updated heading comments on FEE curve algebra.
- 11 Jan 98 at Apple
- Microscopic feemod optimization.
- 10 Jan 98 at Apple
- ell_odd, ell_even() Montgomery optimization.
- 09 Jan 98 at Apple
- ell_odd, ell_even() Atkin3 optimization.
- 08 Jan 97 at Apple
- Cleaned up some debugging code; added gsquareTime
- 11 Jun 97 at Apple
- Mods for modg_via_recip(), divg_via_recip() math
- Deleted a lot of obsolete code (previously ifdef'd out)
- Added lesserX1OrderJustify(), x1OrderPlusJustify()
- Added binvg_cp(), avoiding general modg in favor of feemod
- 05 Feb 97 at Apple
- New optimized numer_plus(), denom_double(), and numer_times()
- All calls to borrowGiant() and newGiant have explicit giant size
- 08 Jan 97 at NeXT
- Major mods to accomodate IEEE-style curve parameters.
- New functions feepowermodg() and curveOrderJustify();
- elliptic_add(), elliptic(), signature_compare(), and
- which_curve() completely rewritten.
- 19 Dec 96 at NeXT
- Added mersennePrimes[24..26]
- 08 Aug 96 at NeXT
- Fixed giant leak in elliptic_add()
- 05 Aug 96 at NeXT
- Removed dead code
- 24 Jul 96 at NeXT
- Added ENGINE_127_BITS dependency for use of security engine
- 24 Oct 92 at NeXT
- Modified new_public_from_private()
- Created.
-
-
- FEE curve algebra, Jan 1997.
-
- Curves are:
-
- y^2 = x^3 + c x^2 + a x + b
-
- where useful parameterizations for practical purposes are:
-
- Montgomery: a = 1, b = 0. (The original 1991 FEE system.)
- Weierstrass: c = 0. (The basic IEEE form.)
- Atkin3: c = a = 0.
- Atkin4: c = b = 0.
-
- However, the code is set up to work with any a, b, c.
- The underlying fields F_{p^m} are of odd characteristic,
- with all operations are (mod p). The special FEE-class
- primes p are of the form:
-
- p = 2^q - k = 3 (mod 4)
-
- where k is single-precision. For such p, the mod operations
- are especially fast (asymptotically vanishing time with respect
- to a multiply). Note that the whole system
- works equally well (except for slower execution) for arbitrary
- primes p = 3 (mod 4) of the same bit length (q or q+1).
-
- The elliptic arithmetic now proceeds on the basis of
- five fundamental operations that calculate various
- numerator/denominator parts of the elliptic terms:
-
- numer_double(giant x, giant z, giant res, curveParams *par)
- res := (x^2 - a z^2)^2 - 4 b (2 x + c z) z^3.
-
- numer_plus(giant x1, giant x2, giant res, curveParams *par)
- res = (x1 x2 + a)(x1 + x2) + 2(c x1 x2 + b).
-
- denom_double(giant x, giant z, giant res, curveParams *par)
- res = 4 z (x^3 + c x^2 z + a x z^2 + b z^3).
-
- denom_times(giant x1, giant z1, giant x2, giant z2, giant res,
- curveParams *par)
- res := (x1 z2 - x2 z1)^2
-
- numer_times(giant x1, giant z1, giant x2, giant z2, giant res,
- curveParams *par)
- res := (x1 x2 - a z1 z2)^2 - 4 b(x1 z2 + x2 z1 + c z1 z2) z1 z2
-
- If x(+-) represent the sum and difference x-coordinates
- respectively, then, in pseudocode,
-
- For unequal starting coords:
- x(+) + x(-) = U = 2 numer_plus/denom_times
- x(+) x(-) = V = numer_times/denom_times
-
- and for equal starting coords:
- x(+) = numer_double/denom_double
-
- The elliptic_add() function uses the fact that
-
- x(+) = U/2 + s*Sqrt[U^2/4 - V]
-
- where the sign s = +-1.
-
-*/
-
-#include "ckconfig.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "platform.h"
-
-#include "giantIntegers.h"
-#include "elliptic.h"
-#include "ellipticProj.h"
-#include "ckutilities.h"
-#include "curveParams.h"
-#include "feeDebug.h"
-#include "ellipticMeasure.h"
-#include "falloc.h"
-#include "giantPortCommon.h"
-
-#if FEE_PROFILE
-
-unsigned numerDoubleTime;
-unsigned numerPlusTime;
-unsigned numerTimesTime;
-unsigned denomDoubleTime;
-unsigned denomTimesTime;
-unsigned ellipticTime;
-unsigned sigCompTime;
-unsigned powerModTime;
-unsigned ellAddTime;
-unsigned whichCurveTime;
-unsigned modgTime;
-unsigned mulgTime;
-unsigned binvauxTime;
-unsigned gsquareTime;
-
-unsigned numMulg;
-unsigned numFeemod;
-unsigned numGsquare;
-unsigned numBorrows;
-
-void clearProfile()
-{
- numerDoubleTime = 0;
- numerPlusTime = 0;
- numerTimesTime = 0;
- denomDoubleTime = 0;
- denomTimesTime = 0;
- ellipticTime = 0;
- sigCompTime = 0;
- powerModTime = 0;
- ellAddTime = 0;
- whichCurveTime = 0;
- modgTime = 0;
- mulgTime = 0;
- binvauxTime = 0;
- gsquareTime = 0;
- numMulg = 0;
- numFeemod = 0;
- numGsquare = 0;
- numBorrows = 0;
-}
-
-#endif // FEE_PROFILE
-
-#if ELL_PROFILE
-unsigned ellOddTime;
-unsigned ellEvenTime;
-unsigned numEllOdds;
-unsigned numEllEvens;
-
-void clearEllProfile()
-{
- ellOddTime = 0;
- ellEvenTime = 0;
- numEllOdds = 0;
- numEllEvens = 0;
-}
-
-#endif /* ELL_PROFILE */
-#if ELLIPTIC_MEASURE
-
-int doEllMeasure; // gather stats on/off */
-int bitsInN;
-int numFeeMods;
-int numMulgs;
-
-void dumpEll()
-{
- printf("\nbitlen(n) : %d\n", bitsInN);
- printf("feemods : %d\n", numFeeMods);
- printf("mulgs : %d\n", numMulgs);
-}
-
-#endif // ELLIPTIC_MEASURE
-
-/********** Globals ********************************/
-
-static void make_base(curveParams *par, giant result); // result = with 2^q-k
-static int keys_inconsistent(key pub1, key pub2);
-/* Return non-zero if pub1, pub2 have inconsistent parameters.
- */
-
-
-static void ell_even(giant x1, giant z1, giant x2, giant z2, curveParams *par);
-static void ell_odd(giant x1, giant z1, giant x2, giant z2, giant xxor,
- giant zor, curveParams *par);
-static void numer_double(giant x, giant z, giant res, curveParams *par);
-static void numer_plus(giant x1, giant x2, giant res, curveParams *par);
-static void denom_double(giant x, giant z, giant res, curveParams *par);
-static void denom_times(giant x1, giant z1, giant x2, giant z2, giant res,
- curveParams *par);
-static void numer_times(giant x1, giant z1, giant x2, giant z2, giant res,
- curveParams *par);
-static void feepowermodg(curveParams *par, giant x, giant n);
-static void curveOrderJustifyWithRecip(giant g, giant curveOrder, giant recip);
-
-/*
- * Completely rewritten in CryptKit-18, 13 Jan 1997, for new IEEE-style
- * curveParameters.
- */
-int which_curve(giant x, curveParams *par)
- /* Returns (+-1) depending on whether x is on curve
- (+-)y^2 = x^3 + c x^2 + a x + b.
- */
-{
- giant t1;
- giant t2;
- giant t3;
- int result;
- PROF_START;
-
- t1 = borrowGiant(par->maxDigits);
- t2 = borrowGiant(par->maxDigits);
- t3 = borrowGiant(par->maxDigits);
-
- /* First, set t2:= x^3 + c x^2 + a x + b. */
- gtog(x, t2); addg(par->c, t2);
- mulg(x, t2); addg(par->a, t2); /* t2 := x^2 + c x + a. */
- feemod(par, t2);
- mulg(x, t2); addg(par->b, t2);
- feemod(par, t2);
- /* Next, test whether t2 is a square. */
- gtog(t2, t1);
- make_base(par, t3); iaddg(1, t3); gshiftright(1, t3); /* t3 = (p+1)/2. */
- feepowermodg(par, t1, t3); /* t1 := t2^((p+1)/2) (mod p). */
- if(gcompg(t1, t2) == 0)
- result = CURVE_PLUS;
- else
- result = CURVE_MINUS;
- returnGiant(t1);
- returnGiant(t2);
- returnGiant(t3);
- PROF_END(whichCurveTime);
- return result;
-}
-
-key new_public(curveParams *cp, int twist) {
- key k;
-
- k = (key) fmalloc(sizeof(keystruct));
- k->cp = cp;
- k->twist = twist;
-
- k->x = newGiant(cp->maxDigits);
- if((twist == CURVE_PLUS) && (cp->curveType == FCT_Weierstrass)) {
- k->y = newGiant(cp->maxDigits);
- }
- else {
- /*
- * no projective algebra. We could optimize and save a few bytes
- * here by setting y to NULL, but that really complicates things
- * in may other places. Best to have a real giant.
- */
- k->y = newGiant(1);
- }
- return(k);
-}
-
-key new_public_with_key(key old_key, curveParams *cp)
-{
- key result;
-
- result = new_public(cp, old_key->twist);
- CKASSERT((old_key->x != NULL) && (old_key->y != NULL));
- CKASSERT((result->x != NULL) && (result->y != NULL));
- gtog(old_key->x, result->x);
- gtog(old_key->y, result->y);
- return result;
-}
-
-void free_key(key pub) {
- if(!pub) {
- return;
- }
- if (pub->x) {
- freeGiant(pub->x);
- }
- if (pub->y) {
- freeGiant(pub->y);
- }
- ffree(pub);
-}
-
-/*
- * Specify private data for key created by new_public().
- * Generates k->x.
- */
-void set_priv_key_giant(key k, giant privGiant)
-{
- curveParams *cp = k->cp;
-
- /* elliptiy multiply of initial public point times private key */
- #if CRYPTKIT_ELL_PROJ_ENABLE
- if((k->twist == CURVE_PLUS) && (cp->curveType == FCT_Weierstrass)) {
- /* projective */
-
- pointProj pt1 = newPointProj(cp->maxDigits);
-
- CKASSERT((cp->y1Plus != NULL) && (!isZero(cp->y1Plus)));
- CKASSERT(k->y != NULL);
-
- /* pt1 := {x1Plus, y1Plus, 1} */
- gtog(cp->x1Plus, pt1->x);
- gtog(cp->y1Plus, pt1->y);
- int_to_giant(1, pt1->z);
-
- /* pt1 := pt1 * privateKey */
- ellMulProjSimple(pt1, privGiant, cp);
-
- /* result back to {k->x, k->y} */
- gtog(pt1->x, k->x);
- gtog(pt1->y, k->y);
- freePointProj(pt1); // FIXME - clear the giants
- }
- else {
- #else
- {
- #endif /* CRYPTKIT_ELL_PROJ_ENABLE */
- /* FEE */
- if(k->twist == CURVE_PLUS) {
- gtog(cp->x1Plus, k->x);
- }
- else {
- gtog(cp->x1Minus, k->x);
- }
- elliptic_simple(k->x, privGiant, k->cp);
- }
-}
-
-int key_equal(key one, key two) {
- if (keys_inconsistent(one, two)) return 0;
- return !gcompg(one->x, two->x);
-}
-
-static void make_base(curveParams *par, giant result)
-/* Jams result with 2^q-k. */
-{
- gtog(par->basePrime, result);
-}
-
-void make_base_prim(curveParams *cp)
-/* Jams cp->basePrime with 2^q-k. Assumes valid maxDigits, q, k. */
-{
- giant tmp = borrowGiant(cp->maxDigits);
-
- CKASSERT(cp->primeType != FPT_General);
- int_to_giant(1, cp->basePrime);
- gshiftleft((int)cp->q, cp->basePrime);
- int_to_giant(cp->k, tmp);
- subg(tmp, cp->basePrime);
- returnGiant(tmp);
-}
-
-static int sequalg(int n, giant g) {
- if((g->sign == 1) && (g->n[0] == n)) return(1);
- return(0);
-}
-
-
-/*
- * Elliptic multiply: x := n * {x, 1}
- */
-void elliptic_simple(giant x, giant n, curveParams *par) {
- giant ztmp = borrowGiant(par->maxDigits);
- giant cur_n = borrowGiant(par->maxDigits);
-
- START_ELL_MEASURE(n);
- int_to_giant(1, ztmp);
- elliptic(x, ztmp, n, par);
- binvg_cp(par, ztmp);
- mulg(ztmp, x);
- feemod(par, x);
- END_ELL_MEASURE;
-
- returnGiant(cur_n);
- returnGiant(ztmp);
-}
-
-/*
- * General elliptic multiply.
- *
- * {xx, zz} := k * {xx, zz}
- */
-void elliptic(giant xx, giant zz, giant k, curveParams *par) {
- int len = bitlen(k);
- int pos = len - 2;
- giant xs;
- giant zs;
- giant xorg;
- giant zorg;
-
- PROF_START;
- if(sequalg(1,k)) return;
- if(sequalg(2,k)) {
- ell_even(xx, zz, xx, zz, par);
- goto out;
- }
- zs = borrowGiant(par->maxDigits);
- xs = borrowGiant(par->maxDigits);
- zorg = borrowGiant(par->maxDigits);
- xorg = borrowGiant(par->maxDigits);
- gtog(xx, xorg); gtog(zz, zorg);
- ell_even(xx, zz, xs, zs, par);
- do {
- if(bitval(k, pos--)) {
- ell_odd(xs, zs, xx, zz, xorg, zorg, par);
- ell_even(xs, zs, xs, zs, par);
- } else {
- ell_odd(xx, zz, xs, zs, xorg, zorg, par);
- ell_even(xx, zz, xx, zz, par);
- }
- } while (pos >= 0); // REC fix 9/23/94
- returnGiant(xs);
- returnGiant(zs);
- returnGiant(xorg);
- returnGiant(zorg);
-out:
- PROF_END(ellipticTime);
-}
-
-/*
- * Completely rewritten in CryptKit-18, 13 Jan 1997, for new IEEE-style
- * curveParameters.
- */
-void elliptic_add(giant x1, giant x2, giant x3, curveParams *par, int s) {
-
- /* Addition algorithm for x3 = x1 + x2 on the curve, with sign ambiguity s.
- From theory, we know that if {x1,1} and {x2,1} are on a curve, then
- their elliptic sum (x1,1} + {x2,1} = {x3,1} must have x3 as one of two
- values:
-
- x3 = U/2 + s*Sqrt[U^2/4 - V]
-
- where sign s = +-1, and U,V are functions of x1,x2. Tho present function
- is called a maximum of twice, to settle which of +- is s. When a call
- is made, it is guaranteed already that x1, x2 both lie on the same curve
- (+- curve); i.e., which curve (+-) is not connected at all with sign s of
- the x3 relation.
- */
-
- giant cur_n;
- giant t1;
- giant t2;
- giant t3;
- giant t4;
- giant t5;
-
- PROF_START;
- cur_n = borrowGiant(par->maxDigits);
- t1 = borrowGiant(par->maxDigits);
- t2 = borrowGiant(par->maxDigits);
- t3 = borrowGiant(par->maxDigits);
- t4 = borrowGiant(par->maxDigits);
- t5 = borrowGiant(par->maxDigits);
-
- if(gcompg(x1, x2)==0) {
- int_to_giant(1, t1);
- numer_double(x1, t1, x3, par);
- denom_double(x1, t1, t2, par);
- binvg_cp(par, t2);
- mulg(t2, x3); feemod(par, x3);
- goto out;
- }
- numer_plus(x1, x2, t1, par);
- int_to_giant(1, t3);
- numer_times(x1, t3, x2, t3, t2, par);
- int_to_giant(1, t4); int_to_giant(1, t5);
- denom_times(x1, t4, x2, t5, t3, par);
- binvg_cp(par, t3);
- mulg(t3, t1); feemod(par, t1); /* t1 := U/2. */
- mulg(t3, t2); feemod(par, t2); /* t2 := V. */
- /* Now x3 will be t1 +- Sqrt[t1^2 - t2]. */
- gtog(t1, t4); gsquare(t4); feemod(par, t4);
- subg(t2, t4);
- make_base(par, cur_n); iaddg(1, cur_n); gshiftright(2, cur_n);
- /* cur_n := (p+1)/4. */
- feepowermodg(par, t4, cur_n); /* t4 := t2^((p+1)/4) (mod p). */
- gtog(t1, x3);
- if(s != SIGN_PLUS) negg(t4);
- addg(t4, x3);
- feemod(par, x3);
-
-out:
- returnGiant(cur_n);
- returnGiant(t1);
- returnGiant(t2);
- returnGiant(t3);
- returnGiant(t4);
- returnGiant(t5);
-
- PROF_END(ellAddTime);
-}
-
-/*
- * Key exchange atom.
- */
-giant make_pad(giant privGiant, key publicKey) {
- curveParams *par = publicKey->cp;
- giant result = newGiant(par->maxDigits);
-
- gtog(publicKey->x, result);
- elliptic_simple(result, privGiant, par);
- return result;
-}
-
-static void ell_even(giant x1, giant z1, giant x2, giant z2, curveParams *par) {
- giant t1;
- giant t2;
- giant t3;
-
- EPROF_START;
-
- t1 = borrowGiant(par->maxDigits);
- t2 = borrowGiant(par->maxDigits);
- t3 = borrowGiant(par->maxDigits);
-
- if(par->curveType == FCT_Montgomery) {
- /* Begin Montgomery OPT: 10 Jan 98 REC. */
- gtog(x1, t1); gsquare(t1); feemod(par, t1); /* t1 := x1^2. */
- gtog(z1, t2); gsquare(t2); feemod(par, t2); /* t2 := z1^2. */
-
- gtog(x1, t3); mulg(z1, t3); feemod(par, t3);
- gtog(t3, z2); mulg(par->c, z2); feemod(par, z2);
- addg(t1, z2); addg(t2, z2); mulg(t3, z2); gshiftleft(2, z2);
- feemod(par, z2); /* z2 := 4 x1 z1 (x1^2 + c x1 z1 + z1^2). */
- gtog(t1, x2); subg(t2, x2); gsquare(x2); feemod(par, x2);
- /* x2 := (x1^2 - z1^2)^2. */
- /* End OPT: 10 Jan 98 REC. */
- }
- else if((par->curveType == FCT_Weierstrass) && isZero(par->a)) {
- /* Begin Atkin3 OPT: 9 Jan 98 REC. */
- gtog(x1, t1);
- gsquare(t1); feemod(par, t1);
- mulg(x1, t1); feemod(par, t1); /* t1 := x^3. */
- gtog(z1, t2);
- gsquare(t2); feemod(par, t2);
- mulg(z1, t2); feemod(par, t2); /* t2 := z1^3 */
- mulg(par->b, t2); feemod(par, t2); /* t2 := b z1^3. */
- gtog(t1, t3); addg(t2, t3); /* t3 := x^3 + b z1^3 */
- mulg(z1, t3); feemod(par, t3); /* t3 *= z1
- * = z1 ( x^3 + b z1^3 ) */
- gshiftleft(2, t3); feemod(par, t3); /* t3 = 4 z1 (x1^3 + b z1^3) */
-
- gshiftleft(3, t2); /* t2 = 8 b z1^3 */
- subg(t2, t1); /* t1 = x^3 - 8 b z1^3 */
- mulg(x1, t1); feemod(par, t1); /* t1 = x1 (x1^3 - 8 b z1^3) */
-
- gtog(t3, z2);
- gtog(t1, x2);
- /* End OPT: 9 Jan 98 REC. */
- }
- else {
- numer_double(x1, z1, t1, par);
- denom_double(x1, z1, t2, par);
- gtog(t1, x2); gtog(t2, z2);
- }
- returnGiant(t1);
- returnGiant(t2);
- returnGiant(t3);
-
- EPROF_END(ellEvenTime);
- EPROF_INCR(numEllEvens);
-
- /*
- printf("ell_even end\n");
- printf(" x1 : "); printGiant(x1);
- printf(" z1 : "); printGiant(z1);
- printf(" x2 : "); printGiant(x2);
- printf(" z2 : "); printGiant(z2);
- */
-}
-
-static void ell_odd(giant x1, giant z1, giant x2, giant z2, giant xxor,
- giant zor, curveParams *par)
-{
-
- giant t1;
- giant t2;
-
- EPROF_START;
- t1 = borrowGiant(par->maxDigits);
- t2 = borrowGiant(par->maxDigits);
-
- if(par->curveType == FCT_Montgomery) {
- /* Begin Montgomery OPT: 10 Jan 98 REC. */
- giant t3 = borrowGiant(par->maxDigits);
- giant t4 = borrowGiant(par->maxDigits);
-
- gtog(x1, t1); addg(z1, t1); /* t1 := x1 + z1. */
- gtog(x2, t2); subg(z2, t2); /* t2 := x2 - z2. */
- gtog(x1, t3); subg(z1, t3); /* t3 := x1 - z1. */
- gtog(x2, t4); addg(z2, t4); /* t4 := x2 + z2. */
- mulg(t2, t1); feemod(par, t1); /* t1 := (x1 + z1)(x2 - z2) */
- mulg(t4, t3); feemod(par, t3); /* t4 := (x2 + z2)(x1 - z1) */
- gtog(t1, z2); subg(t3, z2); /*???gshiftright(1, z2);*/
- /* z2 := ((x1 + z1)(x2 - z2) - x2)/2 */
- gsquare(z2); feemod(par, z2);
- mulg(xxor, z2); feemod(par, z2);
- gtog(t1, x2); addg(t3, x2); /*????gshiftright(1, x2);*/
- gsquare(x2); feemod(par, x2);
- mulg(zor, x2); feemod(par, x2);
-
- returnGiant(t3);
- returnGiant(t4);
- }
- else if((par->curveType == FCT_Weierstrass) && isZero(par->a)) {
- /* Begin Atkin3 OPT: 9 Jan 98 REC. */
-
- giant t3 = borrowGiant(par->maxDigits);
- giant t4 = borrowGiant(par->maxDigits);
-
- gtog(x1, t1); mulg(x2, t1); feemod(par, t1); /* t1 := x1 x2. */
- gtog(z1, t2); mulg(z2, t2); feemod(par, t2); /* t2 := z1 z2. */
- gtog(x1, t3); mulg(z2, t3); feemod(par, t3); /* t3 := x1 z2. */
- gtog(z1, t4); mulg(x2, t4); feemod(par, t4); /* t4 := x2 z1. */
- gtog(t3, z2); subg(t4, z2); gsquare(z2); feemod(par, z2);
- mulg(xxor, z2); feemod(par, z2);
- gtog(t1, x2); gsquare(x2); feemod(par, x2);
- addg(t4, t3); mulg(t2, t3); feemod(par, t3);
- mulg(par->b, t3); feemod(par, t3);
- addg(t3, t3); addg(t3, t3);
- subg(t3, x2); mulg(zor, x2); feemod(par, x2);
-
- returnGiant(t3);
- returnGiant(t4);
- /* End OPT: 9 Jan 98 REC. */
- }
- else {
- numer_times(x1, z1, x2, z2, t1, par);
- mulg(zor, t1); feemod(par, t1);
- denom_times(x1, z1, x2, z2, t2, par);
- mulg(xxor, t2); feemod(par, t2);
-
- gtog(t1, x2); gtog(t2, z2);
- }
-
- returnGiant(t1);
- returnGiant(t2);
-
- EPROF_END(ellOddTime);
- EPROF_INCR(numEllOdds);
-
- /*
- printf("ell_odd end\n");
- printf(" x2 : "); printGiant(x2);
- printf(" z2 : "); printGiant(z2);
- */
-}
-
-/*
- * return codes from keys_inconsistent() and signature_compare(). The actual
- * values are not public; they are defined here for debugging.
- */
-#define CURVE_PARAM_MISMATCH 1
-#define TWIST_PARAM_MISMATCH 2
-#define SIGNATURE_INVALID 3
-
-
-/*
- * Determine whether two keystructs have compatible parameters (i.e., same
- * twist and curveParams). Return 0 if compatible, else non-zero.
- */
-static int keys_inconsistent(key pub1, key pub2){
- if(!curveParamsEquivalent(pub1->cp, pub2->cp)) {
- return CURVE_PARAM_MISMATCH;
- }
- if(pub1->twist != pub2->twist) {
- return TWIST_PARAM_MISMATCH;
- }
- return 0;
-}
-
-int signature_compare(giant p0x, giant p1x, giant p2x, curveParams *par)
-/* Returns non-zero iff p0x cannot be the x-coordinate of the sum of two points whose respective x-coordinates are p1x, p2x. */
-{
- int ret = 0;
- giant t1;
- giant t2;
- giant t3;
- giant t4;
- giant t5;
-
- PROF_START;
-
- t1 = borrowGiant(par->maxDigits);
- t2 = borrowGiant(par->maxDigits);
- t3 = borrowGiant(par->maxDigits);
- t4 = borrowGiant(par->maxDigits);
- t5 = borrowGiant(par->maxDigits);
-
- if(gcompg(p1x, p2x) == 0) {
- int_to_giant(1, t1);
- numer_double(p1x, t1, t2, par);
- denom_double(p1x, t1, t3, par);
- mulg(p0x, t3); subg(t3, t2);
- feemod(par, t2);
- } else {
- numer_plus(p1x, p2x, t1, par);
- gshiftleft(1, t1); feemod(par, t1);
- int_to_giant(1, t3);
- numer_times(p1x, t3, p2x, t3, t2, par);
- int_to_giant(1, t4); int_to_giant(1, t5);
- denom_times(p1x, t4 , p2x, t5, t3, par);
- /* Now we require t3 x0^2 - t1 x0 + t2 == 0. */
- mulg(p0x, t3); feemod(par, t3);
- subg(t1, t3); mulg(p0x, t3);
- feemod(par, t3);
- addg(t3, t2);
- feemod(par, t2);
- }
-
- if(!isZero(t2)) ret = SIGNATURE_INVALID;
- returnGiant(t1);
- returnGiant(t2);
- returnGiant(t3);
- returnGiant(t4);
- returnGiant(t5);
- PROF_END(sigCompTime);
- return(ret);
-}
-
-
-static void numer_double(giant x, giant z, giant res, curveParams *par)
-/* Numerator algebra.
- res := (x^2 - a z^2)^2 - 4 b (2 x + c z) z^3.
- */
-{
- giant t1;
- giant t2;
-
- PROF_START;
- t1 = borrowGiant(par->maxDigits);
- t2 = borrowGiant(par->maxDigits);
-
- gtog(x, t1); gsquare(t1); feemod(par, t1);
- gtog(z, res); gsquare(res); feemod(par, res);
- gtog(res, t2);
- if(!isZero(par->a) ) {
- if(!isone(par->a)) { /* Speedup - REC 17 Jan 1997. */
- mulg(par->a, res); feemod(par, res);
- }
- subg(res, t1); feemod(par, t1);
- }
- gsquare(t1); feemod(par, t1);
- /* t1 := (x^2 - a z^2)^2. */
- if(isZero(par->b)) { /* Speedup - REC 17 Jan 1997. */
- gtog(t1, res);
- goto done;
- }
- if(par->curveType != FCT_Weierstrass) { // i.e., !isZero(par->c)
- // Speedup - REC 17 Jan 1997.
- gtog(z, res); mulg(par->c, res); feemod(par, res);
- } else {
- int_to_giant(0, res);
- }
- addg(x, res); addg(x, res); mulg(par->b, res);
- feemod(par, res);
- gshiftleft(2, res); mulg(z, res); feemod(par, res);
- mulg(t2, res); feemod(par, res);
- negg(res); addg(t1, res);
- feemod(par, res);
-
-done:
- returnGiant(t1);
- returnGiant(t2);
- PROF_END(numerDoubleTime);
-}
-
-static void numer_plus(giant x1, giant x2, giant res, curveParams *par)
-/* Numerator algebra.
- res = (x1 x2 + a)(x1 + x2) + 2(c x1 x2 + b).
- */
-{
- giant t1;
- giant t2;
-
- PROF_START;
- t1 = borrowGiant(par->maxDigits);
- t2 = borrowGiant(par->maxDigits);
-
- gtog(x1, t1); mulg(x2, t1); feemod(par, t1);
- gtog(x2, t2); addg(x1, t2); feemod(par, t2);
- gtog(t1, res);
- if(!isZero(par->a))
- addg(par->a, res);
- mulg(t2, res); feemod(par, res);
- if(par->curveType == FCT_Weierstrass) { // i.e., isZero(par->c)
- int_to_giant(0, t1);
- }
- else {
- mulg(par->c, t1); feemod(par, t1);
- }
- if(!isZero(par->b))
- addg(par->b, t1);
- gshiftleft(1, t1);
- addg(t1, res); feemod(par, res);
-
- returnGiant(t1);
- returnGiant(t2);
- PROF_END(numerPlusTime);
-}
-
-static void denom_double(giant x, giant z, giant res, curveParams *par)
-/* Denominator algebra.
- res = 4 z (x^3 + c x^2 z + a x z^2 + b z^3). */
-{
- giant t1;
- giant t2;
-
- PROF_START;
- t1 = borrowGiant(par->maxDigits);
- t2 = borrowGiant(par->maxDigits);
-
- gtog(x, res); gtog(z, t1);
- if(par->curveType != FCT_Weierstrass) { // i.e., !isZero(par->c)
- gtog(par->c, t2); mulg(t1, t2); feemod(par, t2);
- addg(t2, res);
- }
- mulg(x, res); feemod(par, res);
- gsquare(t1); feemod(par, t1);
- if(!isZero(par->a)) {
- gtog(t1, t2);
- mulg(par->a, t2); feemod(par, t2);
- addg(t2, res);
- }
- mulg(x, res); feemod(par, res);
- if(!isZero(par->b)) {
- mulg(z, t1); feemod(par, t1);
- mulg(par->b, t1); feemod(par, t1);
- addg(t1, res);
- }
- mulg(z, res); gshiftleft(2, res);
- feemod(par, res);
-
- returnGiant(t1);
- returnGiant(t2);
- PROF_END(denomDoubleTime);
-}
-
-
-
-static void denom_times(giant x1, giant z1, giant x2, giant z2, giant res,
- curveParams *par)
-/* Denominator algebra.
- res := (x1 z2 - x2 z1)^2
- */
-{
- giant t1;
-
- PROF_START;
- t1 = borrowGiant(par->maxDigits);
-
- gtog(x1, res); mulg(z2, res); feemod(par, res);
- gtog(z1, t1); mulg(x2, t1); feemod(par, t1);
- subg(t1, res); gsquare(res); feemod(par, res);
-
- returnGiant(t1);
- PROF_END(denomTimesTime);
-}
-
-static void numer_times(giant x1, giant z1, giant x2, giant z2, giant res,
- curveParams *par)
-/* Numerator algebra.
- res := (x1 x2 - a z1 z2)^2 -
- 4 b(x1 z2 + x2 z1 + c z1 z2) z1 z2
- */
-{
- giant t1;
- giant t2;
- giant t3;
- giant t4;
-
- PROF_START;
- t1 = borrowGiant(par->maxDigits);
- t2 = borrowGiant(par->maxDigits);
- t3 = borrowGiant(par->maxDigits);
- t4 = borrowGiant(par->maxDigits);
-
- gtog(x1, t1); mulg(x2, t1); feemod(par, t1);
- gtog(z1, t2); mulg(z2, t2); feemod(par, t2);
- gtog(t1, res);
- if(!isZero(par->a)) {
- gtog(par->a, t3);
- mulg(t2, t3); feemod(par, t3);
- subg(t3, res);
- }
- gsquare(res); feemod(par, res);
- if(isZero(par->b))
- goto done;
- if(par->curveType != FCT_Weierstrass) { // i.e., !isZero(par->c)
- gtog(par->c, t3);
- mulg(t2, t3); feemod(par, t3);
- } else int_to_giant(0, t3);
- gtog(z1, t4); mulg(x2, t4); feemod(par, t4);
- addg(t4, t3);
- gtog(x1, t4); mulg(z2, t4); feemod(par, t4);
- addg(t4, t3); mulg(par->b, t3); feemod(par, t3);
- mulg(t2, t3); gshiftleft(2, t3); feemod(par, t3);
- subg(t3, res);
- feemod(par, res);
-
-done:
- returnGiant(t1);
- returnGiant(t2);
- returnGiant(t3);
- returnGiant(t4);
- PROF_END(numerTimesTime);
-}
-
-/*
- * New, 13 Jan 1997.
- */
-static void feepowermodg(curveParams *par, giant x, giant n)
-/* Power ladder.
- x := x^n (mod 2^q-k)
- */
-{
- int len, pos;
- giant t1;
-
- PROF_START;
- t1 = borrowGiant(par->maxDigits);
- gtog(x, t1);
- int_to_giant(1, x);
- len = bitlen(n);
- pos = 0;
- while(1) {
- if(bitval(n, pos++)) {
- mulg(t1, x);
- feemod(par, x);
- }
- if(pos>=len) break;
- gsquare(t1);
- feemod(par, t1);
- }
- returnGiant(t1);
- PROF_END(powerModTime);
-}
-
-/*
- * Set g := g mod curveOrder;
- * force g to be between 2 and (curveOrder-2), inclusive.
- *
- * Tolerates zero curve orders (indicating "not known").
- */
-
-/*
- * This version is not normally used; it's for when the reciprocal of
- * curveOrder is not known and won't be used again.
- */
-void curveOrderJustify(giant g, giant curveOrder)
-{
- giant recip;
-
- CKASSERT(!isZero(curveOrder));
-
- recip = borrowGiant(2 * abs(g->sign));
- make_recip(curveOrder, recip);
- curveOrderJustifyWithRecip(g, curveOrder, recip);
- returnGiant(recip);
-}
-
-/*
- * New optimzation of curveOrderJustify using known reciprocal, 11 June 1997.
- * g is set to be within [2, curveOrder-2].
- */
-static void curveOrderJustifyWithRecip(giant g, giant curveOrder, giant recip)
-{
- giant tmp;
-
- CKASSERT(!isZero(curveOrder));
-
- modg_via_recip(curveOrder, recip, g); // g now in [0, curveOrder-1]
-
- if(isZero(g)) {
- /*
- * First degenerate case - (g == 0) : set g := 2
- */
- dbgLog(("curveOrderJustify: case 1\n"));
- int_to_giant(2, g);
- return;
- }
- if(isone(g)) {
- /*
- * Second case - (g == 1) : set g := 2
- */
- dbgLog(("curveOrderJustify: case 2\n"));
- int_to_giant(2, g);
- return;
- }
- tmp = borrowGiant(g->capacity);
- gtog(g, tmp);
- iaddg(1, tmp);
- if(gcompg(tmp, curveOrder) == 0) {
- /*
- * Third degenerate case - (g == (curveOrder-1)) : set g -= 1
- */
- dbgLog(("curveOrderJustify: case 3\n"));
- int_to_giant(1, tmp);
- subg(tmp, g);
- }
- returnGiant(tmp);
- return;
-}
-
-#define RECIP_DEBUG 0
-#if RECIP_DEBUG
-#define recipLog(x) printf x
-#else // RECIP_DEBUG
-#define recipLog(x)
-#endif // RECIP_DEBUG
-
-/*
- * curveOrderJustify routines with specific orders, using (and possibly
- * generating) associated reciprocals.
- */
-void lesserX1OrderJustify(giant g, curveParams *cp)
-{
- /*
- * Note this is a pointer to a giant in *cp, not a newly
- * malloc'd giant!
- */
- giant lesserX1Ord = lesserX1Order(cp);
-
- if(isZero(lesserX1Ord)) {
- return;
- }
-
- /*
- * Calculate reciprocal if we don't have it
- */
- if(isZero(cp->lesserX1OrderRecip)) {
- if((lesserX1Ord == cp->x1OrderPlus) &&
- (!isZero(cp->x1OrderPlusRecip))) {
- /*
- * lesserX1Ord happens to be x1OrderPlus, and we
- * have a reciprocal for x1OrderPlus. Copy it over.
- */
- recipLog((
- "x1OrderPlusRecip --> lesserX1OrderRecip\n"));
- gtog(cp->x1OrderPlusRecip, cp->lesserX1OrderRecip);
- }
- else {
- /* Calculate the reciprocal. */
- recipLog(("calc lesserX1OrderRecip\n"));
- make_recip(lesserX1Ord, cp->lesserX1OrderRecip);
- }
- }
- else {
- recipLog(("using existing lesserX1OrderRecip\n"));
- }
- curveOrderJustifyWithRecip(g, lesserX1Ord, cp->lesserX1OrderRecip);
-}
-
-/*
- * Common code used by x1OrderPlusJustify() and x1OrderPlusMod() to generate
- * reciprocal of x1OrderPlus.
- * 8 Sep 1998 - also used by feeSigSign().
- */
-void calcX1OrderPlusRecip(curveParams *cp)
-{
- if(isZero(cp->x1OrderPlusRecip)) {
- if((cp->x1OrderPlus == lesserX1Order(cp)) &&
- (!isZero(cp->lesserX1OrderRecip))) {
- /*
- * lesserX1Order happens to be x1OrderPlus, and we
- * have a reciprocal for lesserX1Order. Copy it over.
- */
- recipLog((
- "lesserX1OrderRecip --> x1OrderPlusRecip\n"));
- gtog(cp->lesserX1OrderRecip, cp->x1OrderPlusRecip);
- }
- else {
- /* Calculate the reciprocal. */
- recipLog(("calc x1OrderPlusRecip\n"));
- make_recip(cp->x1OrderPlus, cp->x1OrderPlusRecip);
- }
- }
- else {
- recipLog(("using existing x1OrderPlusRecip\n"));
- }
-}
-
-void x1OrderPlusJustify(giant g, curveParams *cp)
-{
- CKASSERT(!isZero(cp->x1OrderPlus));
-
- /*
- * Calculate reciprocal if we don't have it
- */
- calcX1OrderPlusRecip(cp);
- curveOrderJustifyWithRecip(g, cp->x1OrderPlus, cp->x1OrderPlusRecip);
-}
-
-/*
- * g := g mod x1OrderPlus. Result may be zero.
- */
-void x1OrderPlusMod(giant g, curveParams *cp)
-{
- CKASSERT(!isZero(cp->x1OrderPlus));
-
- /*
- * Calculate reciprocal if we don't have it
- */
- calcX1OrderPlusRecip(cp);
- modg_via_recip(cp->x1OrderPlus, cp->x1OrderPlusRecip, g);
-}
-
-/*
- * New general-purpose giant mod routine, 8 Jan 97.
- * x := x mod basePrime.
- */
-
-/*
- * This stuff is used to analyze the critical loop behavior inside feemod().
- */
-#define FEEMOD_LOOP_TEST 0
-#if FEEMOD_LOOP_TEST
-/*
- * these two are only examined via debugger
- */
-unsigned feemodCalls = 0; // calls to feemod()
-unsigned feemodMultLoops = 0; // times while() loop runs > once
-#define FEEMOD_LOOP_INCR feemodLoops++
-#define FEEMOD_CALL_INCR feemodCalls++
-#else // FEEMOD_LOOP_TEST
-#define FEEMOD_LOOP_INCR
-#define FEEMOD_CALL_INCR
-#endif // FEEMOD_LOOP_TEST
-
-
-void
-feemod(curveParams *par, giant x)
-{
- int sign, sign2;
- giant t1;
- giant t3;
- giant t4;
- giant t5;
- #if FEEMOD_LOOP_TEST
- unsigned feemodLoops = 0;
- #endif // FEEMOD_LOOP_TEST
-
- FEEMOD_CALL_INCR; // for FEEMOD_LOOP_TEST
- INCR_FEEMODS; // for ellipticMeasure
- PROF_INCR(numFeemod); // for general profiling
-
- switch(par->primeType) {
- case FPT_Mersenne:
- /*
- * Super-optimized Mersenne prime modulus case
- */
- gmersennemod(par->q, x);
- break;
-
- case FPT_FEE:
- /*
- * General 2**q-k case
- */
- sign = (x->sign < 0) ? -1 : 1;
- sign2 = 1;
- x->sign = abs(x->sign);
- if(gcompg(par->basePrime, x) >= 0) {
- goto outFee;
- }
- t1 = borrowGiant(par->maxDigits);
- t3 = borrowGiant(par->maxDigits);
- t4 = borrowGiant(par->maxDigits);
- t5 = borrowGiant(par->maxDigits);
-
- /* Begin OPT: 11 Jan 98 REC. */
- if( ((par->q & (GIANT_BITS_PER_DIGIT - 1)) == 0) &&
- (par->k >= 0) &&
- (par->k < GIANT_DIGIT_MASK)) {
-
- /*
- * Microscopic mod for certain regions of {q,k}
- * parameter space.
- */
- int j, digits, excess, max;
- giantDigit carry;
- giantDigit termHi; // double precision
- giantDigit termLo;
- giantDigit *p1, *p2;
-
- digits = par->q >> GIANT_LOG2_BITS_PER_DIGIT;
- while(bitlen(x) > par->q) {
- excess = (x->sign) - digits;
- max = (excess > digits) ? excess : digits;
- carry = 0;
-
- p1 = &x->n[0];
- p2 = &x->n[digits];
-
- if(excess <= digits) {
- carry = VectorMultiply(par->k,
- p2,
- excess,
- p1);
-
- /* propagate final carry */
- p1 += excess;
- for(j = excess; j < digits; j++) {
-
- /*
- * term = *p1 + carry;
- * *p1++ = term & 65535;
- * carry = term >> 16;
- */
- termLo = giantAddDigits(*p1, carry, &carry);
- *p1++ = termLo;
- }
- } else {
- carry = VectorMultiply(par->k,
- p2,
- digits,
- p1);
- p1 += digits;
- p2 += digits;
- for(j = digits; j < excess; j++) {
- /*
- * term = (par->k)*(*p2++) + carry;
- */
- giantMulDigits(par->k,
- *p2++,
- &termLo,
- &termHi);
- giantAddDouble(&termLo, &termHi, carry);
-
- /*
- * *p1++ = term & 65535;
- * carry = term >> 16;
- */
- *p1++ = termLo;
- carry = termHi;
- }
- }
-
- if(carry > 0) {
- x->n[max] = carry;
- } else {
- while(--max){
- if(x->n[max] != 0) break;
- }
- }
- x->sign = max + 1;
- FEEMOD_LOOP_INCR;
- }
- } else { /* Macroscopic mod for general PT_FEE case. */
- int_to_giant(par->k, t4);
- while(bitlen(x) > par->q) {
- /* Enter fast loop, as in FEE patent. */
- int_to_giant(1, t5);
- gtog(x, t3);
- extractbits(par->q, t3, x);
- while(bitlen(t3) > par->q) {
- gshiftright(par->q, t3);
- extractbits(par->q, t3, t1);
- PAUSE_ELL_MEASURE;
- mulg(t4, t5);
- mulg(t5, t1);
- RESUME_ELL_MEASURE;
- addg(t1, x);
- }
- FEEMOD_LOOP_INCR;
- }
- }
- /* End OPT: 11 Jan 98 REC. */
-
- sign2 = (x->sign < 0)? -1: 1;
- x->sign = abs(x->sign);
- returnGiant(t1);
- returnGiant(t3);
- returnGiant(t4);
- returnGiant(t5);
- outFee:
- if(gcompg(x, par->basePrime) >=0) subg(par->basePrime, x);
- if(sign != sign2) {
- giant t2 = borrowGiant(par->maxDigits);
- gtog(par->basePrime, t2);
- subg(x, t2);
- gtog(t2, x);
- returnGiant(t2);
- }
- break;
- /* end case PT_FEE */
-
- case FPT_General:
- /*
- * Use brute-force modg.
- */
- #if FEE_DEBUG
- if(par->basePrimeRecip == NULL) {
- CKRaise("feemod(PT_GENERAL): No basePrimeRecip!\n");
- }
- #endif /* FEE_DEBUG */
- modg_via_recip(par->basePrime, par->basePrimeRecip, x);
- break;
-
- case FPT_Default:
- /* never appears here */
- CKASSERT(0);
- break;
- } /* switch primeType */
-
- #if FEEMOD_LOOP_TEST
- if(feemodLoops > 1) {
- feemodMultLoops++;
- if(feemodLoops > 2) {
- printf("feemod while loop executed %d times\n", feemodLoops);
- }
- }
- #endif // FEEMOD_LOOP_TEST
-
- return;
-}
-
-/*
- * For a given curveParams, calculate minBytes and maxDigits.
- * Assumes valid primeType, and also a valid basePrime for PT_GENERAL.
- */
-void calcGiantSizes(curveParams *cp)
-{
-
- if(cp->primeType == FPT_General) {
- cp->minBytes = (bitlen(cp->basePrime) + 7) / 8;
- }
- else {
- cp->minBytes = giantMinBytes(cp->q, cp->k);
- }
- cp->maxDigits = giantMaxDigits(cp->minBytes);
-}
-
-unsigned giantMinBytes(unsigned q, int k)
-{
- unsigned kIsNeg = (k < 0) ? 1 : 0;
-
- return (q + 7 + kIsNeg) / 8;
-}
-
-/*
- * min value for "extra" bytes. Derived from the fact that during sig verify,
- * we have to multiply a giant representing a digest - which may be
- * 20 bytes for SHA1 - by a giant of minBytes.
- */
-#define MIN_EXTRA_BYTES 20
-
-unsigned giantMaxDigits(unsigned minBytes)
-{
- unsigned maxBytes = 4 * minBytes;
-
- if((maxBytes - minBytes) < MIN_EXTRA_BYTES) {
- maxBytes = minBytes + MIN_EXTRA_BYTES;
- }
- return BYTES_TO_GIANT_DIGITS(maxBytes);
-}
-
-
-/*
- * Optimized binvg(basePrime, x). Avoids the general modg() in favor of
- * feemod.
- */
-int binvg_cp(curveParams *cp, giant x)
-{
- feemod(cp, x);
- return(binvaux(cp->basePrime, x));
-}
-
-/*
- * Optimized binvg(x1OrderPlus, x). Uses x1OrderPlusMod().
- */
-int binvg_x1OrderPlus(curveParams *cp, giant x)
-{
- x1OrderPlusMod(x, cp);
- return(binvaux(cp->x1OrderPlus, x));
-}
projects / apple / security.git / blobdiff