public static void secp256k1_ge_set_all_gej_var(Ge[] r, GeJ[] a, int len, EventHandler <Callback> cb)
{
Fe[] a1 = new Fe[len];
int len1 = 0;
for (int index = 0; index < len; ++index)
{
if (!a[index].Infinity)
{
a1[len1++] = a[index].Z.Clone();
}
}
Fe[] r1 = new Fe[len1];
Field.InvAllVar(r1, a1, len1);
int num = 0;
for (int index = 0; index < len; ++index)
{
r[index].Infinity = a[index].Infinity;
if (!a[index].Infinity)
{
Group.secp256k1_ge_set_gej_zinv(r[index], a[index], r1[num++]);
}
}
}
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);
}
public static void secp256k1_gej_rescale(GeJ r, Fe s)
{
Fe fe = new Fe();
Field.Sqr(fe, s);
Field.Mul(r.X, r.X, fe);
Field.Mul(r.Y, r.Y, fe);
Field.Mul(r.Y, r.Y, s);
Field.Mul(r.Z, r.Z, s);
}
public static void secp256k1_ge_set_gej_zinv(Ge r, GeJ a, Fe zi)
{
Fe fe1 = new Fe();
Fe fe2 = new Fe();
Field.Sqr(fe1, zi);
Field.Mul(fe2, fe1, zi);
Field.Mul(r.X, a.X, fe1);
Field.Mul(r.Y, a.Y, fe2);
r.Infinity = a.Infinity;
}
private static bool LoadPubKey(Ge ge, PubKey pubkey)
{
var x = new Fe();
Field.SetB32(x, pubkey.Data);
var y = new Fe();
Field.SetB32(y, pubkey.Data, 32);
Group.SetXY(ge, x, y);
return(true);
}
private static bool LoadPubKey(Ge ge, PubKey pubkey)
{
Fe fe1 = new Fe();
Field.SetB32(fe1, pubkey.Data);
Fe fe2 = new Fe();
Field.SetB32(fe2, pubkey.Data, 32);
Group.SetXY(ge, fe1, fe2);
return(true);
}
public static void ToStorage(GeStorage r, Ge a)
{
Fe fe1 = a.X.Clone();
Field.Normalize(fe1);
Fe fe2 = a.Y.Clone();
Field.Normalize(fe2);
Field.ToStorage(r.X, fe1);
Field.ToStorage(r.Y, fe2);
}
public static bool secp256k1_ge_set_xo_var(Ge r, Fe x, bool odd)
{
if (!Group.secp256k1_ge_set_xquad(r, x))
{
return(false);
}
Field.NormalizeVar(r.Y);
if (Field.IsOdd(r.Y) != odd)
{
Field.Negate(r.Y, r.Y, 1U);
}
return(true);
}
public static void SetGeJ(Ge r, GeJ a)
{
Fe fe1 = new Fe();
Fe fe2 = new Fe();
r.Infinity = a.Infinity;
Field.Inv(a.Z, a.Z);
Field.Sqr(fe1, a.Z);
Field.Mul(fe2, a.Z, fe1);
Field.Mul(a.X, a.X, fe1);
Field.Mul(a.Y, a.Y, fe2);
Field.SetInt(a.Z, 1U);
r.X = a.X.Clone();
r.Y = a.Y.Clone();
}
public static bool secp256k1_ge_set_xquad(Ge r, Fe x)
{
r.X = x.Clone();
Fe fe1 = new Fe();
Field.Sqr(fe1, x);
Fe fe2 = new Fe();
Field.Mul(fe2, x, fe1);
r.Infinity = false;
Fe fe3 = new Fe();
Field.SetInt(fe3, 7U);
Field.Add(fe3, fe2);
return(Field.Sqrt(r.Y, fe3));
}
public static void Blind(EcmultGenContext ctx, byte[] seed32)
{
Scalar scalar = new Scalar();
Fe fe = new Fe();
Rfc6979HmacSha256T rng = new Rfc6979HmacSha256T();
byte[] numArray = new byte[64];
if (seed32 == null)
{
Group.secp256k1_gej_set_ge(ctx.Initial, Group.Secp256K1GeConstG);
Group.secp256k1_gej_neg(ctx.Initial, ctx.Initial);
ctx.Blind.SetInt(1U);
}
byte[] b32 = Scalar.GetB32(ctx.Blind);
Util.Memcpy((Array)b32, 0, (Array)numArray, 0, 32);
if (seed32 != null)
{
Util.Memcpy((Array)seed32, 0, (Array)numArray, 32, 32);
}
Hash.Rfc6979HmacSha256Initialize(rng, numArray, seed32 != null ? 64U : 32U);
Util.MemSet(numArray, (byte)0, numArray.Length);
bool overflow;
do
{
Hash.Rfc6979HmacSha256Generate(rng, b32, 32);
overflow = !Field.SetB32(fe, b32) | Field.IsZero(fe);
}while (overflow);
Group.secp256k1_gej_rescale(ctx.Initial, fe);
Field.Clear(fe);
do
{
Hash.Rfc6979HmacSha256Generate(rng, b32, 32);
Scalar.SetB32(scalar, b32, ref overflow);
overflow |= Scalar.IsZero(scalar);
}while (overflow);
Hash.Rfc6979HmacSha256Finalize(rng);
Util.MemSet(b32, (byte)0, 32);
GeJ r;
EcMultGen.secp256k1_ecmult_gen(ctx, out r, scalar);
Scalar.Negate(scalar, scalar);
ctx.Blind = scalar.Clone();
ctx.Initial = r.Clone();
Scalar.Clear(scalar);
Group.secp256k1_gej_clear(r);
}
public static void secp256k1_gej_double_var(GeJ r, GeJ a, Fe rzr)
{
r.Infinity = a.Infinity;
if (r.Infinity)
{
if (rzr == null)
{
return;
}
Field.SetInt(rzr, 1U);
}
else
{
if (rzr != null)
{
rzr = a.Y.Clone();
Field.NormalizeWeak(rzr);
Field.MulInt(rzr, 2U);
}
Field.Mul(r.Z, a.Z, a.Y);
Field.MulInt(r.Z, 2U);
Fe fe1 = new Fe();
Field.Sqr(fe1, a.X);
Field.MulInt(fe1, 3U);
Fe fe2 = new Fe();
Field.Sqr(fe2, fe1);
Fe fe3 = new Fe();
Field.Sqr(fe3, a.Y);
Field.MulInt(fe3, 2U);
Fe fe4 = new Fe();
Field.Sqr(fe4, fe3);
Field.MulInt(fe4, 2U);
Field.Mul(fe3, fe3, a.X);
r.X = fe3.Clone();
Field.MulInt(r.X, 4U);
Field.Negate(r.X, r.X, 4U);
Field.Add(r.X, fe2);
Field.Negate(fe2, fe2, 1U);
Field.MulInt(fe3, 6U);
Field.Add(fe3, fe2);
Field.Mul(r.Y, fe1, fe3);
Field.Negate(fe2, fe4, 2U);
Field.Add(r.Y, fe2);
}
}
public static void secp256k1_ecmult_odd_multiples_table_storage_var(int n, GeStorage[] pre, GeJ a, EventHandler <Callback> cb)
{
GeJ[] geJArray = new GeJ[n];
Ge[] r = new Ge[n];
Fe[] zr = new Fe[n];
for (int index = 0; index < n; ++index)
{
geJArray[index] = new GeJ();
r[index] = new Ge();
zr[index] = new Fe();
}
EcMult.secp256k1_ecmult_odd_multiples_table(n, geJArray, zr, a);
Group.secp256k1_ge_set_table_gej_var(r, geJArray, zr, n);
for (int index = 0; index < n; ++index)
{
Group.ToStorage(pre[index], r[index]);
}
}
public static void secp256k1_ge_set_table_gej_var(Ge[] r, GeJ[] a, Fe[] zr, int len)
{
int index = len - 1;
Fe fe = new Fe();
if (len <= 0)
{
return;
}
Field.Inv(fe, a[index].Z);
Group.secp256k1_ge_set_gej_zinv(r[index], a[index], fe);
while (index > 0)
{
Field.Mul(fe, fe, zr[index]);
--index;
Group.secp256k1_ge_set_gej_zinv(r[index], a[index], fe);
}
}
///** Fill a table 'pre' with precomputed odd multiples of a.
// *
// * There are two versions of this function:
// * - 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).
// */
//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);
//}
public static void secp256k1_ecmult_odd_multiples_table_storage_var(int n, GeStorage[] pre, GeJ a, EventHandler <Callback> cb)
{
GeJ[] prej = new GeJ[n];
Ge[] prea = new Ge[n];
Fe[] zr = new Fe[n];
for (int i = 0; i < n; i++)
{
prej[i] = new GeJ();
prea[i] = new Ge();
zr[i] = new Fe();
}
/* Compute the odd multiples in Jacobian form. */
secp256k1_ecmult_odd_multiples_table(n, prej, zr, a);
/* Convert them in batch to affine coordinates. */
Group.secp256k1_ge_set_table_gej_var(prea, prej, zr, n);
/* Convert them to compact storage form. */
for (var i = 0; i < n; i++)
{
Group.ToStorage(pre[i], prea[i]);
}
}
public Fe(Fe other)
{
this.N = new uint[other.N.Length];
Array.Copy((Array)other.N, (Array)this.N, other.N.Length);
}
public Fe(Fe other)
{
N = new uint[other.N.Length];
Array.Copy(other.N, N, other.N.Length);
}
public static void GeJAddGe(GeJ r, GeJ a, Ge b)
{
uint[] arr = new uint[10];
arr[0] = 1U;
Fe a1 = new Fe(arr);
if (b.Infinity)
{
throw new ArithmeticException();
}
Fe fe1 = new Fe();
Field.Sqr(fe1, a.Z);
Fe fe2 = a.X.Clone();
Field.NormalizeWeak(fe2);
Fe fe3 = new Fe();
Field.Mul(fe3, b.X, fe1);
Fe r1 = a.Y.Clone();
Field.NormalizeWeak(r1);
Fe fe4 = new Fe();
Field.Mul(fe4, b.Y, fe1);
Field.Mul(fe4, fe4, a.Z);
Fe fe5 = fe2.Clone();
Field.Add(fe5, fe3);
Fe fe6 = r1.Clone();
Field.Add(fe6, fe4);
Fe fe7 = new Fe();
Field.Sqr(fe7, fe5);
Fe fe8 = new Fe();
Field.Negate(fe8, fe3, 1U);
Fe fe9 = new Fe();
Field.Mul(fe9, fe2, fe8);
Field.Add(fe7, fe9);
bool flag1 = Field.NormalizesToZero(fe6) && Field.NormalizesToZero(fe7);
Fe fe10 = r1.Clone();
Field.MulInt(fe10, 2U);
Field.Add(fe8, fe2);
Field.Cmov(fe10, fe7, !flag1);
Field.Cmov(fe8, fe6, !flag1);
Fe fe11 = new Fe();
Field.Sqr(fe11, fe8);
Fe fe12 = new Fe();
Field.Mul(fe12, fe11, fe5);
Field.Sqr(fe11, fe11);
Field.Cmov(fe11, fe6, flag1);
Field.Sqr(fe5, fe10);
Field.Mul(r.Z, a.Z, fe8);
bool flag2 = !a.Infinity && Field.NormalizesToZero(r.Z);
Field.MulInt(r.Z, 2U);
Field.Negate(fe12, fe12, 1U);
Field.Add(fe5, fe12);
Field.NormalizeWeak(fe5);
r.X = fe5.Clone();
Field.MulInt(fe5, 2U);
Field.Add(fe5, fe12);
Field.Mul(fe5, fe5, fe10);
Field.Add(fe5, fe11);
Field.Negate(r.Y, fe5, 3U);
Field.NormalizeWeak(r.Y);
Field.MulInt(r.X, 4U);
Field.MulInt(r.Y, 4U);
Field.Cmov(r.X, b.X, a.Infinity);
Field.Cmov(r.Y, b.Y, a.Infinity);
Field.Cmov(r.Z, a1, a.Infinity);
r.Infinity = flag2;
}
public Ge(UInt32[] xarr, UInt32[] yarr)
{
X = new Fe(xarr);
Y = new Fe(yarr);
}
public static void secp256k1_gej_add_ge_var(GeJ r, GeJ a, Ge b, Fe rzr)
{
if (a.Infinity)
{
Group.secp256k1_gej_set_ge(r, b);
}
else if (b.Infinity)
{
if (rzr != null)
{
Field.SetInt(rzr, 1U);
}
r = a.Clone();
}
else
{
r.Infinity = false;
Fe fe1 = new Fe();
Field.Sqr(fe1, a.Z);
Fe fe2 = a.X.Clone();
Field.NormalizeWeak(fe2);
Fe fe3 = new Fe();
Field.Mul(fe3, b.X, fe1);
Fe fe4 = a.Y.Clone();
Field.NormalizeWeak(fe4);
Fe fe5 = new Fe();
Field.Mul(fe5, b.Y, fe1);
Field.Mul(fe5, fe5, a.Z);
Fe fe6 = new Fe();
Field.Negate(fe6, fe2, 1U);
Field.Add(fe6, fe3);
Fe fe7 = new Fe();
Field.Negate(fe7, fe4, 1U);
Field.Add(fe7, fe5);
if (Field.NormalizesToZeroVar(fe6))
{
if (Field.NormalizesToZeroVar(fe7))
{
Group.secp256k1_gej_double_var(r, a, rzr);
}
else
{
if (rzr != null)
{
Field.SetInt(rzr, 0U);
}
r.Infinity = true;
}
}
else
{
Fe fe8 = new Fe();
Field.Sqr(fe8, fe7);
Fe fe9 = new Fe();
Field.Sqr(fe9, fe6);
Fe fe10 = new Fe();
Field.Mul(fe10, fe6, fe9);
if (rzr != null)
{
rzr = fe6.Clone();
}
Field.Mul(r.Z, a.Z, fe6);
Fe fe11 = new Fe();
Field.Mul(fe11, fe2, fe9);
r.X = fe11.Clone();
Field.MulInt(r.X, 2U);
Field.Add(r.X, fe10);
Field.Negate(r.X, r.X, 3U);
Field.Add(r.X, fe8);
Field.Negate(r.Y, r.X, 5U);
Field.Add(r.Y, fe11);
Field.Mul(r.Y, r.Y, fe7);
Field.Mul(fe10, fe10, fe4);
Field.Negate(fe10, fe10, 1U);
Field.Add(r.Y, fe10);
}
}
}
///** Set a group element equal to the point with given X and Y coordinates */
public static void SetXY(Ge r, Fe x, Fe y)
{
r.Infinity = false;
r.X = x;
r.Y = y;
}
public bool Infinity; // whether this represents the point at infinity
public Ge()
{
X = new Fe();
Y = new Fe();
}
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;
