Merge remote-tracking branch 'trevp/pemfix' into trev-pem-fix
[openssl.git] / crypto / ec / ec2_mult.c
index 41b4c95..f41665a 100644 (file)
@@ -9,25 +9,12 @@
  * The ECC Code is licensed pursuant to the OpenSSL open source
  * license provided below.
  *
- * In addition, Sun covenants to all licensees who provide a reciprocal
- * covenant with respect to their own patents if any, not to sue under
- * current and future patent claims necessarily infringed by the making,
- * using, practicing, selling, offering for sale and/or otherwise
- * disposing of the ECC Code as delivered hereunder (or portions thereof),
- * provided that such covenant shall not apply:
- *  1) for code that a licensee deletes from the ECC Code;
- *  2) separates from the ECC Code; or
- *  3) for infringements caused by:
- *       i) the modification of the ECC Code or
- *      ii) the combination of the ECC Code with other software or
- *          devices where such combination causes the infringement.
- *
  * The software is originally written by Sheueling Chang Shantz and
  * Douglas Stebila of Sun Microsystems Laboratories.
  *
  */
 /* ====================================================================
- * Copyright (c) 1998-2002 The OpenSSL Project.  All rights reserved.
+ * Copyright (c) 1998-2003 The OpenSSL Project.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  *
  */
 
+#define OPENSSL_FIPSAPI
+
 #include <openssl/err.h>
 
 #include "ec_lcl.h"
 
+#ifndef OPENSSL_NO_EC2M
+
 
 /* Compute the x-coordinate x/z for the point 2*(x/z) in Montgomery projective 
  * coordinates.
  * Uses algorithm Mdouble in appendix of 
  *     Lopez, J. and Dahab, R.  "Fast multiplication on elliptic curves over 
- *     GF(2^m) without precomputation".
+ *     GF(2^m) without precomputation" (CHES '99, LNCS 1717).
  * modified to not require precomputation of c=b^{2^{m-1}}.
  */
-static int Mdouble(const EC_GROUP *group, BIGNUM *x, BIGNUM *z, BN_CTX *ctx)
+static int gf2m_Mdouble(const EC_GROUP *group, BIGNUM *x, BIGNUM *z, BN_CTX *ctx)
        {
        BIGNUM *t1;
        int ret = 0;
@@ -120,10 +111,10 @@ static int Mdouble(const EC_GROUP *group, BIGNUM *x, BIGNUM *z, BN_CTX *ctx)
 /* Compute the x-coordinate x1/z1 for the point (x1/z1)+(x2/x2) in Montgomery 
  * projective coordinates.
  * Uses algorithm Madd in appendix of 
- *     Lopex, J. and Dahab, R.  "Fast multiplication on elliptic curves over 
- *     GF(2^m) without precomputation".
+ *     Lopez, J. and Dahab, R.  "Fast multiplication on elliptic curves over 
+ *     GF(2^m) without precomputation" (CHES '99, LNCS 1717).
  */
-static int Madd(const EC_GROUP *group, const BIGNUM *x, BIGNUM *x1, BIGNUM *z1, 
+static int gf2m_Madd(const EC_GROUP *group, const BIGNUM *x, BIGNUM *x1, BIGNUM *z1, 
        const BIGNUM *x2, const BIGNUM *z2, BN_CTX *ctx)
        {
        BIGNUM *t1, *t2;
@@ -151,17 +142,16 @@ static int Madd(const EC_GROUP *group, const BIGNUM *x, BIGNUM *x1, BIGNUM *z1,
        return ret;
        }
 
-/* Compute the affine coordinates x2, y2=z2 for the point (x1/z1) and (x2/x2) in
- * Montgomery projective coordinates.
- * Uses algorithm Mxy in appendix of 
- *     Lopex, J. and Dahab, R.  "Fast multiplication on elliptic curves over 
- *     GF(2^m) without precomputation".
+/* Compute the x, y affine coordinates from the point (x1, z1) (x2, z2) 
+ * using Montgomery point multiplication algorithm Mxy() in appendix of 
+ *     Lopez, J. and Dahab, R.  "Fast multiplication on elliptic curves over 
+ *     GF(2^m) without precomputation" (CHES '99, LNCS 1717).
  * Returns:
  *     0 on error
  *     1 if return value should be the point at infinity
  *     2 otherwise
  */
-static int Mxy(const EC_GROUP *group, const BIGNUM *x, const BIGNUM *y, BIGNUM *x1, 
+static int gf2m_Mxy(const EC_GROUP *group, const BIGNUM *x, const BIGNUM *y, BIGNUM *x1, 
        BIGNUM *z1, BIGNUM *x2, BIGNUM *z2, BN_CTX *ctx)
        {
        BIGNUM *t3, *t4, *t5;
@@ -169,8 +159,8 @@ static int Mxy(const EC_GROUP *group, const BIGNUM *x, const BIGNUM *y, BIGNUM *
        
        if (BN_is_zero(z1))
                {
-               if (!BN_zero(x2)) return 0;
-               if (!BN_zero(z2)) return 0;
+               BN_zero(x2);
+               BN_zero(z2);
                return 1;
                }
        
@@ -223,19 +213,19 @@ static int Mxy(const EC_GROUP *group, const BIGNUM *x, const BIGNUM *y, BIGNUM *
 /* Computes scalar*point and stores the result in r.
  * point can not equal r.
  * Uses algorithm 2P of
- *     Lopex, J. and Dahab, R.  "Fast multiplication on elliptic curves over 
- *     GF(2^m) without precomputation".
+ *     Lopez, J. and Dahab, R.  "Fast multiplication on elliptic curves over 
+ *     GF(2^m) without precomputation" (CHES '99, LNCS 1717).
  */
-static int point_multiply(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
+static int ec_GF2m_montgomery_point_multiply(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
        const EC_POINT *point, BN_CTX *ctx)
        {
        BIGNUM *x1, *x2, *z1, *z2;
-       int ret = 0, i, j;
-       BN_ULONG mask;
+       int ret = 0, i;
+       BN_ULONG mask,word;
 
        if (r == point)
                {
-               ECerr(EC_F_EC_POINT_MUL, EC_R_INVALID_ARGUMENT);
+               ECerr(EC_F_EC_GF2M_MONTGOMERY_POINT_MULTIPLY, EC_R_INVALID_ARGUMENT);
                return 0;
                }
        
@@ -265,39 +255,40 @@ static int point_multiply(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scal
        if (!BN_GF2m_add(x2, x2, &group->b)) goto err; /* x2 = x^4 + b */
 
        /* find top most bit and go one past it */
-       i = scalar->top - 1; j = BN_BITS2 - 1;
+       i = scalar->top - 1;
        mask = BN_TBIT;
-       while (!(scalar->d[i] & mask)) { mask >>= 1; j--; }
-       mask >>= 1; j--;
+       word = scalar->d[i];
+       while (!(word & mask)) mask >>= 1;
+       mask >>= 1;
        /* if top most bit was at word break, go to next word */
        if (!mask) 
                {
-               i--; j = BN_BITS2 - 1;
+               i--;
                mask = BN_TBIT;
                }
 
        for (; i >= 0; i--)
                {
-               for (; j >= 0; j--)
+               word = scalar->d[i];
+               while (mask)
                        {
-                       if (scalar->d[i] & mask)
+                       if (word & mask)
                                {
-                               if (!Madd(group, &point->X, x1, z1, x2, z2, ctx)) goto err;
-                               if (!Mdouble(group, x2, z2, ctx)) goto err;
+                               if (!gf2m_Madd(group, &point->X, x1, z1, x2, z2, ctx)) goto err;
+                               if (!gf2m_Mdouble(group, x2, z2, ctx)) goto err;
                                }
                        else
                                {
-                               if (!Madd(group, &point->X, x2, z2, x1, z1, ctx)) goto err;
-                               if (!Mdouble(group, x1, z1, ctx)) goto err;
+                               if (!gf2m_Madd(group, &point->X, x2, z2, x1, z1, ctx)) goto err;
+                               if (!gf2m_Mdouble(group, x1, z1, ctx)) goto err;
                                }
                        mask >>= 1;
                        }
-               j = BN_BITS2 - 1;
                mask = BN_TBIT;
                }
 
        /* convert out of "projective" coordinates */
-       i = Mxy(group, &point->X, &point->Y, x1, z1, x2, z2, ctx);
+       i = gf2m_Mxy(group, &point->X, &point->Y, x1, z1, x2, z2, ctx);
        if (i == 0) goto err;
        else if (i == 1) 
                {
@@ -310,8 +301,8 @@ static int point_multiply(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scal
                }
 
        /* GF(2^m) field elements should always have BIGNUM::neg = 0 */
-       r->X.neg = 0;
-       r->Y.neg = 0;
+       BN_set_negative(&r->X, 0);
+       BN_set_negative(&r->Y, 0);
 
        ret = 1;
 
@@ -325,12 +316,14 @@ static int point_multiply(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scal
  *     scalar*group->generator + scalars[0]*points[0] + ... + scalars[num-1]*points[num-1]
  * gracefully ignoring NULL scalar values.
  */
-int ec_GF2m_mont_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
+int ec_GF2m_simple_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
        size_t num, const EC_POINT *points[], const BIGNUM *scalars[], BN_CTX *ctx)
        {
        BN_CTX *new_ctx = NULL;
-       int ret = 0, i;
+       int ret = 0;
+       size_t i;
        EC_POINT *p=NULL;
+       EC_POINT *acc = NULL;
 
        if (ctx == NULL)
                {
@@ -340,48 +333,60 @@ int ec_GF2m_mont_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
                }
 
        /* This implementation is more efficient than the wNAF implementation for 2
-        * or fewer points.  Use the ec_wNAF_mul implementation for 3 or more points.
+        * or fewer points.  Use the ec_wNAF_mul implementation for 3 or more points,
+        * or if we can perform a fast multiplication based on precomputation.
         */
-       if ((scalar && (num > 1)) || (num > 2))
+       if ((scalar && (num > 1)) || (num > 2) || (num == 0 && EC_GROUP_have_precompute_mult(group)))
                {
                ret = ec_wNAF_mul(group, r, scalar, num, points, scalars, ctx);
                goto err;
                }
 
        if ((p = EC_POINT_new(group)) == NULL) goto err;
+       if ((acc = EC_POINT_new(group)) == NULL) goto err;
 
-       if (!EC_POINT_set_to_infinity(group, r)) goto err;
+       if (!EC_POINT_set_to_infinity(group, acc)) goto err;
 
        if (scalar)
                {
-               if (!point_multiply(group, p, scalar, group->generator, ctx)) goto err;
-               if (scalar->neg) if (!group->meth->invert(group, p, ctx)) goto err;
-               if (!group->meth->add(group, r, r, p, ctx)) goto err;
+               if (!ec_GF2m_montgomery_point_multiply(group, p, scalar, group->generator, ctx)) goto err;
+               if (BN_is_negative(scalar))
+                       if (!group->meth->invert(group, p, ctx)) goto err;
+               if (!group->meth->add(group, acc, acc, p, ctx)) goto err;
                }
 
        for (i = 0; i < num; i++)
                {
-               if (!point_multiply(group, p, scalars[i], points[i], ctx)) goto err;
-               if (scalars[i]->neg) if (!group->meth->invert(group, p, ctx)) goto err;
-               if (!group->meth->add(group, r, r, p, ctx)) goto err;
+               if (!ec_GF2m_montgomery_point_multiply(group, p, scalars[i], points[i], ctx)) goto err;
+               if (BN_is_negative(scalars[i]))
+                       if (!group->meth->invert(group, p, ctx)) goto err;
+               if (!group->meth->add(group, acc, acc, p, ctx)) goto err;
                }
 
+       if (!EC_POINT_copy(r, acc)) goto err;
+
        ret = 1;
 
   err:
        if (p) EC_POINT_free(p);
+       if (acc) EC_POINT_free(acc);
        if (new_ctx != NULL)
                BN_CTX_free(new_ctx);
        return ret;
        }
 
 
-/* Precomputation for point multiplication. */ 
-int ec_GF2m_mont_precompute_mult(EC_GROUP *group, BN_CTX *ctx)
+/* Precomputation for point multiplication: fall back to wNAF methods
+ * because ec_GF2m_simple_mul() uses ec_wNAF_mul() if appropriate */
+
+int ec_GF2m_precompute_mult(EC_GROUP *group, BN_CTX *ctx)
        {
-       /* There is no precomputation to do for Montgomery scalar multiplication but
-        * since this implementation falls back to the wNAF multiplication for more than
-        * two points, call the wNAF implementation's precompute.
-        */
        return ec_wNAF_precompute_mult(group, ctx);
-       }
+       }
+
+int ec_GF2m_have_precompute_mult(const EC_GROUP *group)
+       {
+       return ec_wNAF_have_precompute_mult(group);
+       }
+
+#endif