public static void ContextBuild(EcmultGenContext ctx, EventHandler <Callback> cb) { Ge[] r1 = new Ge[1024]; GeJ r2 = new GeJ(); GeJ geJ1 = new GeJ(); if (ctx.Prec != null) { return; } ctx.PrecInit(); Group.secp256k1_gej_set_ge(r2, Group.Secp256K1GeConstG); byte[] bytes = Encoding.UTF8.GetBytes("The scalar for this x is unknown"); Fe fe = new Fe(); Ge ge = new Ge(); Field.SetB32(fe, bytes); Group.secp256k1_ge_set_xo_var(ge, fe, false); Group.secp256k1_gej_set_ge(geJ1, ge); Group.secp256k1_gej_add_ge_var(geJ1, geJ1, Group.Secp256K1GeConstG, (Fe)null); GeJ[] a = new GeJ[1024]; for (int index = 0; index < a.Length; ++index) { a[index] = new GeJ(); } GeJ geJ2 = r2.Clone(); GeJ geJ3 = geJ1.Clone(); for (int index1 = 0; index1 < 64; ++index1) { a[index1 * 16] = geJ3.Clone(); for (int index2 = 1; index2 < 16; ++index2) { Group.secp256k1_gej_add_var(a[index1 * 16 + index2], a[index1 * 16 + index2 - 1], geJ2, (Fe)null); } for (int index2 = 0; index2 < 4; ++index2) { Group.secp256k1_gej_double_var(geJ2, geJ2, (Fe)null); } Group.secp256k1_gej_double_var(geJ3, geJ3, (Fe)null); if (index1 == 62) { Group.secp256k1_gej_neg(geJ3, geJ3); Group.secp256k1_gej_add_var(geJ3, geJ3, geJ1, (Fe)null); } } for (int index = 0; index < r1.Length; ++index) { r1[index] = new Ge(); } Group.secp256k1_ge_set_all_gej_var(r1, a, 1024, cb); for (int index1 = 0; index1 < 64; ++index1) { for (int index2 = 0; index2 < 16; ++index2) { Group.ToStorage(ctx.Prec[index1][index2], r1[index1 * 16 + index2]); } } EcMultGen.Blind(ctx, (byte[])null); }
// // /** Double multiply: R = na*A + ng*G */ // // static void secp256k1_ecmult(const secp256k1_ecmult_context* ctx, secp256k1_gej* r, const secp256k1_gej* a, const secp256k1_scalar* na, const secp256k1_scalar* ng); //#if defined(EXHAUSTIVE_TEST_ORDER) ///* We need to lower these values for exhaustive tests because // * the tables cannot have infinities in them (this breaks the // * affine-isomorphism stuff which tracks z-ratios) */ //#if EXHAUSTIVE_TEST_ORDER > 128 //#define WINDOW_A 5 //#define WINDOW_G 8 //#elif EXHAUSTIVE_TEST_ORDER > 8 //#define WINDOW_A 4 //#define WINDOW_G 4 //#else //#define WINDOW_A 2 //#define WINDOW_G 2 //#endif //#else // /* 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. */ //# 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 //#endif /** The number of entries a table with precomputed multiples needs to have. */ //#define ECMULT_TABLE_SIZE(w) (1 << ((w)-2)) /// <summary> /// 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. /// </summary> /// <param name="n"></param> /// <param name="prej"></param> /// <param name="zr"></param> /// <param name="a"></param> static void secp256k1_ecmult_odd_multiples_table(int n, GeJ[] prej, Fe[] zr, GeJ a) { Debug.Assert(!a.Infinity); GeJ d = new GeJ(); Group.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. */ Ge dGe = new Ge(); dGe.X = d.X.Clone(); dGe.Y = d.Y.Clone(); dGe.Infinity = false; Ge aGe = new Ge(); Group.secp256k1_ge_set_gej_zinv(aGe, a, d.Z); prej[0].X = aGe.X.Clone(); prej[0].Y = aGe.Y.Clone(); prej[0].Z = a.Z.Clone(); prej[0].Infinity = false; zr[0] = d.Z.Clone(); for (var i = 1; i < n; i++) { Group.secp256k1_gej_add_ge_var(prej[i], prej[i - 1], dGe, 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. */ Field.Mul(prej[n - 1].Z, prej[n - 1].Z, d.Z); }
private static void secp256k1_ecmult_odd_multiples_table(int n, GeJ[] prej, Fe[] zr, GeJ a) { GeJ r1 = new GeJ(); Group.secp256k1_gej_double_var(r1, a, (Fe)null); Ge b = new Ge(); b.X = r1.X.Clone(); b.Y = r1.Y.Clone(); b.Infinity = false; Ge r2 = new Ge(); Group.secp256k1_ge_set_gej_zinv(r2, a, r1.Z); prej[0].X = r2.X.Clone(); prej[0].Y = r2.Y.Clone(); prej[0].Z = a.Z.Clone(); prej[0].Infinity = false; zr[0] = r1.Z.Clone(); for (int index = 1; index < n; ++index) { Group.secp256k1_gej_add_ge_var(prej[index], prej[index - 1], b, zr[index]); } Field.Mul(prej[n - 1].Z, prej[n - 1].Z, r1.Z); }
public static void ContextBuild(EcmultGenContext ctx, EventHandler <Callback> cb) { #if !USE_ECMULT_STATIC_PRECOMPUTATION Ge[] prec = new Ge[1024]; GeJ gj = new GeJ(); GeJ numsGej = new GeJ(); int i, j; #endif if (ctx.Prec != null) { return; } #if !USE_ECMULT_STATIC_PRECOMPUTATION ctx.PrecInit(); /* get the generator */ Group.secp256k1_gej_set_ge(gj, Group.Secp256K1GeConstG); /* Construct a group element with no known corresponding scalar (nothing up my sleeve). */ { var numsB32 = Encoding.UTF8.GetBytes("The scalar for this x is unknown"); Fe numsX = new Fe(); Ge numsGe = new Ge(); var r = Field.SetB32(numsX, numsB32); //(void)r; Util.VERIFY_CHECK(r); r = Group.secp256k1_ge_set_xo_var(numsGe, numsX, false); //(void)r; Util.VERIFY_CHECK(r); Group.secp256k1_gej_set_ge(numsGej, numsGe); /* Add G to make the bits in x uniformly distributed. */ Group.secp256k1_gej_add_ge_var(numsGej, numsGej, Group.Secp256K1GeConstG, null); } /* compute prec. */ { GeJ[] precj = new GeJ[1024]; /* Jacobian versions of prec. */ for (int k = 0; k < precj.Length; k++) { precj[k] = new GeJ(); } GeJ gbase; GeJ numsbase; gbase = gj.Clone(); /* 16^j * G */ numsbase = numsGej.Clone(); /* 2^j * nums. */ for (j = 0; j < 64; j++) { /* Set precj[j*16 .. j*16+15] to (numsbase, numsbase + gbase, ..., numsbase + 15*gbase). */ precj[j * 16] = numsbase.Clone(); for (i = 1; i < 16; i++) { Group.secp256k1_gej_add_var(precj[j * 16 + i], precj[j * 16 + i - 1], gbase, null); } /* Multiply gbase by 16. */ for (i = 0; i < 4; i++) { Group.secp256k1_gej_double_var(gbase, gbase, null); } /* Multiply numbase by 2. */ Group.secp256k1_gej_double_var(numsbase, numsbase, null); if (j == 62) { /* In the last iteration, numsbase is (1 - 2^j) * nums instead. */ Group.secp256k1_gej_neg(numsbase, numsbase); Group.secp256k1_gej_add_var(numsbase, numsbase, numsGej, null); } } for (int k = 0; k < prec.Length; k++) { prec[k] = new Ge(); } Group.secp256k1_ge_set_all_gej_var(prec, precj, 1024, cb); } for (j = 0; j < 64; j++) { for (i = 0; i < 16; i++) { Group.ToStorage(ctx.Prec[j][i], prec[j * 16 + i]); } } #else (void)cb; ctx.prec = (secp256k1_ge_storage(*)[64][16])secp256k1_ecmult_static_context;