-// Copyright (c) 2013 Pieter Wuille
-// Distributed under the MIT/X11 software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
#ifndef _SECP256K1_ECMULT_IMPL_H_
#define _SECP256K1_ECMULT_IMPL_H_
-#include <assert.h>
-#include "num.h"
#include "group.h"
+#include "scalar.h"
#include "ecmult.h"
-// optimal for 128-bit and 256-bit exponents.
+/* optimal for 128-bit and 256-bit exponents. */
#define WINDOW_A 5
-// larger numbers may result in slightly better performance, at the cost of
-// exponentially larger precomputed tables. WINDOW_G == 14 results in 640 KiB.
-#define WINDOW_G 14
+/** larger numbers may result in slightly better performance, at the cost of
+ exponentially larger precomputed tables. */
+#ifdef USE_ENDOMORPHISM
+/** Two tables for window size 15: 1.375 MiB. */
+#define WINDOW_G 15
+#else
+/** One table for window size 16: 1.375 MiB. */
+#define WINDOW_G 16
+#endif
+
+/** The number of entries a table with precomputed multiples needs to have. */
+#define ECMULT_TABLE_SIZE(w) (1 << ((w)-2))
+
+/** Fill a table 'prej' with precomputed odd multiples of a. Prej will contain
+ * the values [1*a,3*a,...,(2*n-1)*a], so it space for n values. zr[0] will
+ * contain prej[0].z / a.z. The other zr[i] values = prej[i].z / prej[i-1].z.
+ * Prej's Z values are undefined, except for the last value.
+ */
+static void secp256k1_ecmult_odd_multiples_table(int n, secp256k1_gej *prej, secp256k1_fe *zr, const secp256k1_gej *a) {
+ secp256k1_gej d;
+ secp256k1_ge a_ge, d_ge;
+ int i;
+
+ VERIFY_CHECK(!a->infinity);
+
+ secp256k1_gej_double_var(&d, a, NULL);
+
+ /*
+ * Perform the additions on an isomorphism where 'd' is affine: drop the z coordinate
+ * of 'd', and scale the 1P starting value's x/y coordinates without changing its z.
+ */
+ d_ge.x = d.x;
+ d_ge.y = d.y;
+ d_ge.infinity = 0;
+
+ secp256k1_ge_set_gej_zinv(&a_ge, a, &d.z);
+ prej[0].x = a_ge.x;
+ prej[0].y = a_ge.y;
+ prej[0].z = a->z;
+ prej[0].infinity = 0;
+
+ zr[0] = d.z;
+ for (i = 1; i < n; i++) {
+ secp256k1_gej_add_ge_var(&prej[i], &prej[i-1], &d_ge, &zr[i]);
+ }
+
+ /*
+ * Each point in 'prej' has a z coordinate too small by a factor of 'd.z'. Only
+ * the final point's z coordinate is actually used though, so just update that.
+ */
+ secp256k1_fe_mul(&prej[n-1].z, &prej[n-1].z, &d.z);
+}
-/** Fill a table 'pre' with precomputed odd multiples of a. W determines the size of the table.
- * pre will contains the values [1*a,3*a,5*a,...,(2^(w-1)-1)*a], so it needs place for
- * 2^(w-2) entries.
+/** Fill a table 'pre' with precomputed odd multiples of a.
*
* There are two versions of this function:
- * - secp256k1_ecmult_precomp_wnaf_gej, which operates on group elements in jacobian notation,
- * fast to precompute, but slower to use in later additions.
- * - secp256k1_ecmult_precomp_wnaf_ge, which operates on group elements in affine notations,
- * (much) slower to precompute, but a bit faster to use in later additions.
- * To compute a*P + b*G, we use the jacobian version for P, and the affine version for G, as
- * G is constant, so it only needs to be done once in advance.
+ * - secp256k1_ecmult_odd_multiples_table_globalz_windowa which brings its
+ * resulting point set to a single constant Z denominator, stores the X and Y
+ * coordinates as ge_storage points in pre, and stores the global Z in rz.
+ * It only operates on tables sized for WINDOW_A wnaf multiples.
+ * - secp256k1_ecmult_odd_multiples_table_storage_var, which converts its
+ * resulting point set to actually affine points, and stores those in pre.
+ * It operates on tables of any size, but uses heap-allocated temporaries.
+ *
+ * To compute a*P + b*G, we compute a table for P using the first function,
+ * and for G using the second (which requires an inverse, but it only needs to
+ * happen once).
*/
-void static secp256k1_ecmult_table_precomp_gej(secp256k1_gej_t *pre, const secp256k1_gej_t *a, int w) {
- pre[0] = *a;
- secp256k1_gej_t d; secp256k1_gej_double(&d, &pre[0]);
- for (int i=1; i<(1 << (w-2)); i++)
- secp256k1_gej_add(&pre[i], &d, &pre[i-1]);
+static void secp256k1_ecmult_odd_multiples_table_globalz_windowa(secp256k1_ge *pre, secp256k1_fe *globalz, const secp256k1_gej *a) {
+ secp256k1_gej prej[ECMULT_TABLE_SIZE(WINDOW_A)];
+ secp256k1_fe zr[ECMULT_TABLE_SIZE(WINDOW_A)];
+
+ /* Compute the odd multiples in Jacobian form. */
+ secp256k1_ecmult_odd_multiples_table(ECMULT_TABLE_SIZE(WINDOW_A), prej, zr, a);
+ /* Bring them to the same Z denominator. */
+ secp256k1_ge_globalz_set_table_gej(ECMULT_TABLE_SIZE(WINDOW_A), pre, globalz, prej, zr);
}
-void static secp256k1_ecmult_table_precomp_ge(secp256k1_ge_t *pre, const secp256k1_gej_t *a, int w) {
- const int table_size = 1 << (w-2);
- secp256k1_gej_t prej[table_size];
- prej[0] = *a;
- secp256k1_gej_t d; secp256k1_gej_double(&d, a);
- for (int i=1; i<table_size; i++) {
- secp256k1_gej_add(&prej[i], &d, &prej[i-1]);
+static void secp256k1_ecmult_odd_multiples_table_storage_var(int n, secp256k1_ge_storage *pre, const secp256k1_gej *a, const secp256k1_callback *cb) {
+ secp256k1_gej *prej = (secp256k1_gej*)checked_malloc(cb, sizeof(secp256k1_gej) * n);
+ secp256k1_ge *prea = (secp256k1_ge*)checked_malloc(cb, sizeof(secp256k1_ge) * n);
+ secp256k1_fe *zr = (secp256k1_fe*)checked_malloc(cb, sizeof(secp256k1_fe) * n);
+ int i;
+
+ /* Compute the odd multiples in Jacobian form. */
+ secp256k1_ecmult_odd_multiples_table(n, prej, zr, a);
+ /* Convert them in batch to affine coordinates. */
+ secp256k1_ge_set_table_gej_var(prea, prej, zr, n);
+ /* Convert them to compact storage form. */
+ for (i = 0; i < n; i++) {
+ secp256k1_ge_to_storage(&pre[i], &prea[i]);
}
- secp256k1_ge_set_all_gej(table_size, pre, prej);
-}
-/** The number of entries a table with precomputed multiples needs to have. */
-#define ECMULT_TABLE_SIZE(w) (1 << ((w)-2))
+ free(prea);
+ free(prej);
+ free(zr);
+}
/** The following two macro retrieves a particular odd multiple from a table
* of precomputed multiples. */
-#define ECMULT_TABLE_GET(r,pre,n,w,neg) do { \
- assert(((n) & 1) == 1); \
- assert((n) >= -((1 << ((w)-1)) - 1)); \
- assert((n) <= ((1 << ((w)-1)) - 1)); \
- if ((n) > 0) \
+#define ECMULT_TABLE_GET_GE(r,pre,n,w) do { \
+ VERIFY_CHECK(((n) & 1) == 1); \
+ VERIFY_CHECK((n) >= -((1 << ((w)-1)) - 1)); \
+ VERIFY_CHECK((n) <= ((1 << ((w)-1)) - 1)); \
+ if ((n) > 0) { \
*(r) = (pre)[((n)-1)/2]; \
- else \
- (neg)((r), &(pre)[(-(n)-1)/2]); \
+ } else { \
+ secp256k1_ge_neg((r), &(pre)[(-(n)-1)/2]); \
+ } \
+} while(0)
+
+#define ECMULT_TABLE_GET_GE_STORAGE(r,pre,n,w) do { \
+ VERIFY_CHECK(((n) & 1) == 1); \
+ VERIFY_CHECK((n) >= -((1 << ((w)-1)) - 1)); \
+ VERIFY_CHECK((n) <= ((1 << ((w)-1)) - 1)); \
+ if ((n) > 0) { \
+ secp256k1_ge_from_storage((r), &(pre)[((n)-1)/2]); \
+ } else { \
+ secp256k1_ge_from_storage((r), &(pre)[(-(n)-1)/2]); \
+ secp256k1_ge_neg((r), (r)); \
+ } \
} while(0)
-#define ECMULT_TABLE_GET_GEJ(r,pre,n,w) ECMULT_TABLE_GET((r),(pre),(n),(w),secp256k1_gej_neg)
-#define ECMULT_TABLE_GET_GE(r,pre,n,w) ECMULT_TABLE_GET((r),(pre),(n),(w),secp256k1_ge_neg)
-
-typedef struct {
- // For accelerating the computation of a*P + b*G:
- secp256k1_ge_t pre_g[ECMULT_TABLE_SIZE(WINDOW_G)]; // odd multiples of the generator
- secp256k1_ge_t pre_g_128[ECMULT_TABLE_SIZE(WINDOW_G)]; // odd multiples of 2^128*generator
-
- // For accelerating the computation of a*G:
- // To harden against timing attacks, use the following mechanism:
- // * Break up the multiplicand into groups of 4 bits, called n_0, n_1, n_2, ..., n_63.
- // * Compute sum((n_i + 1) * 16^i * G, i=0..63).
- // * Subtract sum(1 * 16^i * G, i=0..63).
- // For each i, and each of the 16 possible values of n_i, ((n_i + 1) * 16^i * G) is
- // precomputed (call it prec(i,n_i), as well as -sum(1 * 16^i * G) (called fin).
- // The formula now becomes sum(prec(i, n_i), i=0..63) + fin.
- // To make memory access uniform, the bytes of prec(i,n_i) are sliced per value of n_i.
- unsigned char prec[64][sizeof(secp256k1_ge_t)][16]; // prec[j][k][i] = k'th byte of (16^j * (i+1) * G)
- secp256k1_ge_t fin; // -(sum(prec[j][0], j=0..63))
-} secp256k1_ecmult_consts_t;
-
-static const secp256k1_ecmult_consts_t *secp256k1_ecmult_consts = NULL;
-
-static void secp256k1_ecmult_start(void) {
- if (secp256k1_ecmult_consts != NULL)
+static void secp256k1_ecmult_context_init(secp256k1_ecmult_context *ctx) {
+ ctx->pre_g = NULL;
+#ifdef USE_ENDOMORPHISM
+ ctx->pre_g_128 = NULL;
+#endif
+}
+
+static void secp256k1_ecmult_context_build(secp256k1_ecmult_context *ctx, const secp256k1_callback *cb) {
+ secp256k1_gej gj;
+
+ if (ctx->pre_g != NULL) {
return;
+ }
+
+ /* get the generator */
+ secp256k1_gej_set_ge(&gj, &secp256k1_ge_const_g);
+
+ ctx->pre_g = (secp256k1_ge_storage (*)[])checked_malloc(cb, sizeof((*ctx->pre_g)[0]) * ECMULT_TABLE_SIZE(WINDOW_G));
+
+ /* precompute the tables with odd multiples */
+ secp256k1_ecmult_odd_multiples_table_storage_var(ECMULT_TABLE_SIZE(WINDOW_G), *ctx->pre_g, &gj, cb);
+
+#ifdef USE_ENDOMORPHISM
+ {
+ secp256k1_gej g_128j;
+ int i;
+
+ ctx->pre_g_128 = (secp256k1_ge_storage (*)[])checked_malloc(cb, sizeof((*ctx->pre_g_128)[0]) * ECMULT_TABLE_SIZE(WINDOW_G));
- secp256k1_ecmult_consts_t *ret = (secp256k1_ecmult_consts_t*)malloc(sizeof(secp256k1_ecmult_consts_t));
- secp256k1_ecmult_consts = ret;
-
- // get the generator
- const secp256k1_ge_t *g = &secp256k1_ge_consts->g;
- secp256k1_gej_t gj; secp256k1_gej_set_ge(&gj, g);
-
- // calculate 2^128*generator
- secp256k1_gej_t g_128j = gj;
- for (int i=0; i<128; i++)
- secp256k1_gej_double(&g_128j, &g_128j);
-
- // precompute the tables with odd multiples
- secp256k1_ecmult_table_precomp_ge(ret->pre_g, &gj, WINDOW_G);
- secp256k1_ecmult_table_precomp_ge(ret->pre_g_128, &g_128j, WINDOW_G);
-
- // compute prec and fin
- secp256k1_gej_t tj[961];
- int pos = 0;
- secp256k1_gej_t fn; secp256k1_gej_set_infinity(&fn);
- for (int j=0; j<64; j++) {
- secp256k1_gej_add(&fn, &fn, &gj);
- secp256k1_gej_t adj = gj;
- for (int i=1; i<16; i++) {
- secp256k1_gej_add(&gj, &gj, &adj);
- tj[pos++] = gj;
+ /* calculate 2^128*generator */
+ g_128j = gj;
+ for (i = 0; i < 128; i++) {
+ secp256k1_gej_double_var(&g_128j, &g_128j, NULL);
}
+ secp256k1_ecmult_odd_multiples_table_storage_var(ECMULT_TABLE_SIZE(WINDOW_G), *ctx->pre_g_128, &g_128j, cb);
}
- assert(pos == 960);
- tj[pos] = fn;
- secp256k1_ge_t t[961]; secp256k1_ge_set_all_gej(961, t, tj);
- pos = 0;
- const unsigned char *raw = (const unsigned char*)g;
- for (int j=0; j<64; j++) {
- for (int k=0; k<sizeof(secp256k1_ge_t); k++)
- ret->prec[j][k][0] = raw[k];
- for (int i=1; i<16; i++) {
- raw = (const unsigned char*)(&t[pos++]);
- for (int k=0; k<sizeof(secp256k1_ge_t); k++)
- ret->prec[j][k][i] = raw[k];
- }
+#endif
+}
+
+static void secp256k1_ecmult_context_clone(secp256k1_ecmult_context *dst,
+ const secp256k1_ecmult_context *src, const secp256k1_callback *cb) {
+ if (src->pre_g == NULL) {
+ dst->pre_g = NULL;
+ } else {
+ size_t size = sizeof((*dst->pre_g)[0]) * ECMULT_TABLE_SIZE(WINDOW_G);
+ dst->pre_g = (secp256k1_ge_storage (*)[])checked_malloc(cb, size);
+ memcpy(dst->pre_g, src->pre_g, size);
+ }
+#ifdef USE_ENDOMORPHISM
+ if (src->pre_g_128 == NULL) {
+ dst->pre_g_128 = NULL;
+ } else {
+ size_t size = sizeof((*dst->pre_g_128)[0]) * ECMULT_TABLE_SIZE(WINDOW_G);
+ dst->pre_g_128 = (secp256k1_ge_storage (*)[])checked_malloc(cb, size);
+ memcpy(dst->pre_g_128, src->pre_g_128, size);
}
- assert(pos == 960);
- secp256k1_ge_neg(&ret->fin, &t[pos]);
+#endif
}
-static void secp256k1_ecmult_stop(void) {
- if (secp256k1_ecmult_consts == NULL)
- return;
+static int secp256k1_ecmult_context_is_built(const secp256k1_ecmult_context *ctx) {
+ return ctx->pre_g != NULL;
+}
- secp256k1_ecmult_consts_t *c = (secp256k1_ecmult_consts_t*)secp256k1_ecmult_consts;
- free(c);
- secp256k1_ecmult_consts = NULL;
+static void secp256k1_ecmult_context_clear(secp256k1_ecmult_context *ctx) {
+ free(ctx->pre_g);
+#ifdef USE_ENDOMORPHISM
+ free(ctx->pre_g_128);
+#endif
+ secp256k1_ecmult_context_init(ctx);
}
/** Convert a number to WNAF notation. The number becomes represented by sum(2^i * wnaf[i], i=0..bits),
* with the following guarantees:
* - each wnaf[i] is either 0, or an odd integer between -(1<<(w-1) - 1) and (1<<(w-1) - 1)
* - two non-zero entries in wnaf are separated by at least w-1 zeroes.
- * - the index of the highest non-zero entry in wnaf (=return value-1) is at most bits, where
- * bits is the number of bits necessary to represent the absolute value of the input.
+ * - the number of set values in wnaf is returned. This number is at most 256, and at most one more
+ * than the number of bits in the (absolute value) of the input.
*/
-static int secp256k1_ecmult_wnaf(int *wnaf, const secp256k1_num_t *a, int w) {
- int ret = 0;
- int zeroes = 0;
- secp256k1_num_t x;
- secp256k1_num_init(&x);
- secp256k1_num_copy(&x, a);
+static int secp256k1_ecmult_wnaf(int *wnaf, int len, const secp256k1_scalar *a, int w) {
+ secp256k1_scalar s = *a;
+ int last_set_bit = -1;
+ int bit = 0;
int sign = 1;
- if (secp256k1_num_is_neg(&x)) {
+ int carry = 0;
+
+ VERIFY_CHECK(wnaf != NULL);
+ VERIFY_CHECK(0 <= len && len <= 256);
+ VERIFY_CHECK(a != NULL);
+ VERIFY_CHECK(2 <= w && w <= 31);
+
+ memset(wnaf, 0, len * sizeof(wnaf[0]));
+
+ if (secp256k1_scalar_get_bits(&s, 255, 1)) {
+ secp256k1_scalar_negate(&s, &s);
sign = -1;
- secp256k1_num_negate(&x);
}
- while (!secp256k1_num_is_zero(&x)) {
- while (!secp256k1_num_is_odd(&x)) {
- zeroes++;
- secp256k1_num_shift(&x, 1);
- }
- int word = secp256k1_num_shift(&x, w);
- while (zeroes) {
- wnaf[ret++] = 0;
- zeroes--;
+
+ while (bit < len) {
+ int now;
+ int word;
+ if (secp256k1_scalar_get_bits(&s, bit, 1) == (unsigned int)carry) {
+ bit++;
+ continue;
}
- if (word & (1 << (w-1))) {
- secp256k1_num_inc(&x);
- wnaf[ret++] = sign * (word - (1 << w));
- } else {
- wnaf[ret++] = sign * word;
+
+ now = w;
+ if (now > len - bit) {
+ now = len - bit;
}
- zeroes = w-1;
- }
- secp256k1_num_free(&x);
- return ret;
-}
-void static secp256k1_ecmult_gen(secp256k1_gej_t *r, const secp256k1_num_t *gn) {
- secp256k1_num_t n;
- secp256k1_num_init(&n);
- secp256k1_num_copy(&n, gn);
- const secp256k1_ecmult_consts_t *c = secp256k1_ecmult_consts;
- secp256k1_gej_set_infinity(r);
- secp256k1_ge_t add;
- int bits;
- for (int j=0; j<64; j++) {
- bits = secp256k1_num_shift(&n, 4);
- for (int k=0; k<sizeof(secp256k1_ge_t); k++)
- ((unsigned char*)(&add))[k] = c->prec[j][k][bits];
- secp256k1_gej_add_ge(r, r, &add);
+ word = secp256k1_scalar_get_bits_var(&s, bit, now) + carry;
+
+ carry = (word >> (w-1)) & 1;
+ word -= carry << w;
+
+ wnaf[bit] = sign * word;
+ last_set_bit = bit;
+
+ bit += now;
}
- bits = 0;
- secp256k1_ge_clear(&add);
- secp256k1_num_clear(&n);
- secp256k1_num_free(&n);
- secp256k1_gej_add_ge(r, r, &c->fin);
+#ifdef VERIFY
+ CHECK(carry == 0);
+ while (bit < 256) {
+ CHECK(secp256k1_scalar_get_bits(&s, bit++, 1) == 0);
+ }
+#endif
+ return last_set_bit + 1;
}
-void static secp256k1_ecmult(secp256k1_gej_t *r, const secp256k1_gej_t *a, const secp256k1_num_t *na, const secp256k1_num_t *ng) {
- const secp256k1_ecmult_consts_t *c = secp256k1_ecmult_consts;
-
+static void secp256k1_ecmult(const secp256k1_ecmult_context *ctx, secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_scalar *na, const secp256k1_scalar *ng) {
+ secp256k1_ge pre_a[ECMULT_TABLE_SIZE(WINDOW_A)];
+ secp256k1_ge tmpa;
+ secp256k1_fe Z;
#ifdef USE_ENDOMORPHISM
- secp256k1_num_t na_1, na_lam;
- secp256k1_num_init(&na_1);
- secp256k1_num_init(&na_lam);
- // split na into na_1 and na_lam (where na = na_1 + na_lam*lambda, and na_1 and na_lam are ~128 bit)
- secp256k1_gej_split_exp(&na_1, &na_lam, na);
-
- // build wnaf representation for na_1 and na_lam.
- int wnaf_na_1[129]; int bits_na_1 = secp256k1_ecmult_wnaf(wnaf_na_1, &na_1, WINDOW_A);
- int wnaf_na_lam[129]; int bits_na_lam = secp256k1_ecmult_wnaf(wnaf_na_lam, &na_lam, WINDOW_A);
- int bits = bits_na_1;
- if (bits_na_lam > bits) bits = bits_na_lam;
+ secp256k1_ge pre_a_lam[ECMULT_TABLE_SIZE(WINDOW_A)];
+ secp256k1_scalar na_1, na_lam;
+ /* Splitted G factors. */
+ secp256k1_scalar ng_1, ng_128;
+ int wnaf_na_1[130];
+ int wnaf_na_lam[130];
+ int bits_na_1;
+ int bits_na_lam;
+ int wnaf_ng_1[129];
+ int bits_ng_1;
+ int wnaf_ng_128[129];
+ int bits_ng_128;
#else
- // build wnaf representation for na.
- int wnaf_na[257]; int bits_na = secp256k1_ecmult_wnaf(wnaf_na, na, WINDOW_A);
- int bits = bits_na;
+ int wnaf_na[256];
+ int bits_na;
+ int wnaf_ng[256];
+ int bits_ng;
#endif
-
- // calculate odd multiples of a
- secp256k1_gej_t pre_a[ECMULT_TABLE_SIZE(WINDOW_A)];
- secp256k1_ecmult_table_precomp_gej(pre_a, a, WINDOW_A);
+ int i;
+ int bits;
#ifdef USE_ENDOMORPHISM
- secp256k1_gej_t pre_a_lam[ECMULT_TABLE_SIZE(WINDOW_A)];
- for (int i=0; i<ECMULT_TABLE_SIZE(WINDOW_A); i++)
- secp256k1_gej_mul_lambda(&pre_a_lam[i], &pre_a[i]);
+ /* split na into na_1 and na_lam (where na = na_1 + na_lam*lambda, and na_1 and na_lam are ~128 bit) */
+ secp256k1_scalar_split_lambda(&na_1, &na_lam, na);
+
+ /* build wnaf representation for na_1 and na_lam. */
+ bits_na_1 = secp256k1_ecmult_wnaf(wnaf_na_1, 130, &na_1, WINDOW_A);
+ bits_na_lam = secp256k1_ecmult_wnaf(wnaf_na_lam, 130, &na_lam, WINDOW_A);
+ VERIFY_CHECK(bits_na_1 <= 130);
+ VERIFY_CHECK(bits_na_lam <= 130);
+ bits = bits_na_1;
+ if (bits_na_lam > bits) {
+ bits = bits_na_lam;
+ }
+#else
+ /* build wnaf representation for na. */
+ bits_na = secp256k1_ecmult_wnaf(wnaf_na, 256, na, WINDOW_A);
+ bits = bits_na;
#endif
- // Splitted G factors.
- secp256k1_num_t ng_1, ng_128;
- secp256k1_num_init(&ng_1);
- secp256k1_num_init(&ng_128);
+ /* Calculate odd multiples of a.
+ * All multiples are brought to the same Z 'denominator', which is stored
+ * in Z. Due to secp256k1' isomorphism we can do all operations pretending
+ * that the Z coordinate was 1, use affine addition formulae, and correct
+ * the Z coordinate of the result once at the end.
+ * The exception is the precomputed G table points, which are actually
+ * affine. Compared to the base used for other points, they have a Z ratio
+ * of 1/Z, so we can use secp256k1_gej_add_zinv_var, which uses the same
+ * isomorphism to efficiently add with a known Z inverse.
+ */
+ secp256k1_ecmult_odd_multiples_table_globalz_windowa(pre_a, &Z, a);
- // split ng into ng_1 and ng_128 (where gn = gn_1 + gn_128*2^128, and gn_1 and gn_128 are ~128 bit)
- secp256k1_num_split(&ng_1, &ng_128, ng, 128);
+#ifdef USE_ENDOMORPHISM
+ for (i = 0; i < ECMULT_TABLE_SIZE(WINDOW_A); i++) {
+ secp256k1_ge_mul_lambda(&pre_a_lam[i], &pre_a[i]);
+ }
+
+ /* split ng into ng_1 and ng_128 (where gn = gn_1 + gn_128*2^128, and gn_1 and gn_128 are ~128 bit) */
+ secp256k1_scalar_split_128(&ng_1, &ng_128, ng);
- // Build wnaf representation for ng_1 and ng_128
- int wnaf_ng_1[129]; int bits_ng_1 = secp256k1_ecmult_wnaf(wnaf_ng_1, &ng_1, WINDOW_G);
- int wnaf_ng_128[129]; int bits_ng_128 = secp256k1_ecmult_wnaf(wnaf_ng_128, &ng_128, WINDOW_G);
- if (bits_ng_1 > bits) bits = bits_ng_1;
- if (bits_ng_128 > bits) bits = bits_ng_128;
+ /* Build wnaf representation for ng_1 and ng_128 */
+ bits_ng_1 = secp256k1_ecmult_wnaf(wnaf_ng_1, 129, &ng_1, WINDOW_G);
+ bits_ng_128 = secp256k1_ecmult_wnaf(wnaf_ng_128, 129, &ng_128, WINDOW_G);
+ if (bits_ng_1 > bits) {
+ bits = bits_ng_1;
+ }
+ if (bits_ng_128 > bits) {
+ bits = bits_ng_128;
+ }
+#else
+ bits_ng = secp256k1_ecmult_wnaf(wnaf_ng, 256, ng, WINDOW_G);
+ if (bits_ng > bits) {
+ bits = bits_ng;
+ }
+#endif
secp256k1_gej_set_infinity(r);
- secp256k1_gej_t tmpj;
- secp256k1_ge_t tmpa;
- for (int i=bits-1; i>=0; i--) {
- secp256k1_gej_double(r, r);
+ for (i = bits - 1; i >= 0; i--) {
int n;
+ secp256k1_gej_double_var(r, r, NULL);
#ifdef USE_ENDOMORPHISM
if (i < bits_na_1 && (n = wnaf_na_1[i])) {
- ECMULT_TABLE_GET_GEJ(&tmpj, pre_a, n, WINDOW_A);
- secp256k1_gej_add(r, r, &tmpj);
+ ECMULT_TABLE_GET_GE(&tmpa, pre_a, n, WINDOW_A);
+ secp256k1_gej_add_ge_var(r, r, &tmpa, NULL);
}
if (i < bits_na_lam && (n = wnaf_na_lam[i])) {
- ECMULT_TABLE_GET_GEJ(&tmpj, pre_a_lam, n, WINDOW_A);
- secp256k1_gej_add(r, r, &tmpj);
- }
-#else
- if (i < bits_na && (n = wnaf_na[i])) {
- ECMULT_TABLE_GET_GEJ(&tmpj, pre_a, n, WINDOW_A);
- secp256k1_gej_add(r, r, &tmpj);
+ ECMULT_TABLE_GET_GE(&tmpa, pre_a_lam, n, WINDOW_A);
+ secp256k1_gej_add_ge_var(r, r, &tmpa, NULL);
}
-#endif
if (i < bits_ng_1 && (n = wnaf_ng_1[i])) {
- ECMULT_TABLE_GET_GE(&tmpa, c->pre_g, n, WINDOW_G);
- secp256k1_gej_add_ge(r, r, &tmpa);
+ ECMULT_TABLE_GET_GE_STORAGE(&tmpa, *ctx->pre_g, n, WINDOW_G);
+ secp256k1_gej_add_zinv_var(r, r, &tmpa, &Z);
}
if (i < bits_ng_128 && (n = wnaf_ng_128[i])) {
- ECMULT_TABLE_GET_GE(&tmpa, c->pre_g_128, n, WINDOW_G);
- secp256k1_gej_add_ge(r, r, &tmpa);
+ ECMULT_TABLE_GET_GE_STORAGE(&tmpa, *ctx->pre_g_128, n, WINDOW_G);
+ secp256k1_gej_add_zinv_var(r, r, &tmpa, &Z);
+ }
+#else
+ if (i < bits_na && (n = wnaf_na[i])) {
+ ECMULT_TABLE_GET_GE(&tmpa, pre_a, n, WINDOW_A);
+ secp256k1_gej_add_ge_var(r, r, &tmpa, NULL);
}
+ if (i < bits_ng && (n = wnaf_ng[i])) {
+ ECMULT_TABLE_GET_GE_STORAGE(&tmpa, *ctx->pre_g, n, WINDOW_G);
+ secp256k1_gej_add_zinv_var(r, r, &tmpa, &Z);
+ }
+#endif
}
-#ifdef USE_ENDOMORPHISM
- secp256k1_num_free(&na_1);
- secp256k1_num_free(&na_lam);
-#endif
- secp256k1_num_free(&ng_1);
- secp256k1_num_free(&ng_128);
+ if (!r->infinity) {
+ secp256k1_fe_mul(&r->z, &r->z, &Z);
+ }
}
#endif
projects / secp256k1.git / blobdiff