public void ModInverseTest(int a, int n, int expected)
{
var actual = BigIntegerExt.ModInverse(a, n);
Assert.AreEqual(new BigInteger(expected), actual);
Assert.IsTrue(BigIntegerExt.ModEqual(1, actual * a, n));
}
//public string onnAddrStr = string.Empty;
public void Import(string key)
{
BigInteger num = BigIntegerExt.ParseHexUnsigned(key);
secKey = new ECPrivateKey(num, curve);
Init();
}
//static methods
static BigInteger computeFinite(BigInteger num, BigInteger denom, List <BigInteger> subQuotients)
{
var g = BigIntegerExt.Gcd(num, denom);
if (g != BigInteger.One)
{
num /= g;
denom /= g;
}
if (denom.Sign < 0)
{
num = -num;
denom = -denom;
}
var t = num.Mod(denom);
var quotient = (num - t) / denom;
num = t;
while (num.Sign > 0 && denom.Sign > 0)
{
denom = BigInteger.DivRem(denom, num, out t);
subQuotients.Add(denom);
denom = num;
num = t;
}
return(quotient);
}
void parabolic(BigInteger a, BigInteger b, BigInteger c, BigInteger d, BigInteger e, BigInteger f)
{
var g = BigIntegerExt.Gcd(a, c);
c = (c / g).Abs().Sqrt();
if (b.Sign > 0 == a.Sign < 0)
{
c = -c;
}
a = (a / g).Abs().Sqrt();
var m = c * d - a * e;
if (m.IsZero)
{
var u = MathExt2.DeriveQuadratic(a * g, d, a * f, true);
if (u.Length > 0)
{
linearWithGcd(a, c, -u[0]);
if (u.Length > 1 && u[0] != u[1])
{
linearWithGcd(a, c, -u[1]);
}
}
}
else
{
parabolic2(a, -c, m, a * g, d, a * f);
}
}
public void CreatePointXTest(string xHex, bool yOdd)
{
var x = BigIntegerExt.ParseHexUnsigned(xHex);
var curve = ECCurve.Secp256k1;
var point = curve.CreatePoint(x, yOdd);
Assert.IsTrue(point.Valid);
}
public void EuclidExtendedTest()
{
var res = BigIntegerExt.EuclidExtended(51051, 21483);
Assert.AreEqual(new BigInteger(51051), res.A);
Assert.AreEqual(new BigInteger(21483), res.B);
Assert.AreEqual(new BigInteger(8), res.X);
Assert.AreEqual(new BigInteger(-19), res.Y);
Assert.AreEqual(new BigInteger(231), res.Gcd);
}
void linearWithGcd(BigInteger d, BigInteger e, BigInteger f)
{
var g = BigIntegerExt.Gcd(d, e);
if (!g.IsZero && g != BigInteger.One)
{
d /= g;
e /= g;
f /= g;
}
linear(d, e, f);
}
public void VerifySignatureTest()
{
var curve = ECCurve.Secp256k1;
var publicKey = curve.CreatePublicKey("0474938fcc21b40cd1fcb3e98df92c4239af59ef46f404a7d15ed659dcbdcda1326a7cd3040a023919418014d1b2c96b3b32467787938e82994b050d9968a8c5d2");
var msg = BigIntegerExt.ParseHexUnsigned("7846e3be8abd2e089ed812475be9b51c3cfcc1a04fafa2ddb6ca6869bf272715");
var random = BigIntegerExt.ParseHexUnsigned("cd6f06360fa5af8415f7a678ab45d8c1d435f8cf054b0f5902237e8cb9ee5fe5");
var signature = new ECSignature(
BigIntegerExt.ParseHexUnsigned("2794dd08b1dfa958552bc37916515a3accb0527e40f9291d62cc4316047d24dd"),
BigIntegerExt.ParseHexUnsigned("5dd1f95f962bb6871967dc17b22217100daa00a3756feb1e16be3e6936fd8594"),
curve
);
var result = publicKey.VerifySignature(msg, signature);
Assert.IsTrue(result);
}
public ECCurve Build()
{
var ecc = new ECCurve {
Name = Name,
A = BigIntegerExt.ParseHexUnsigned(A),
B = BigIntegerExt.ParseHexUnsigned(B),
Modulus = BigIntegerExt.ParseHexUnsigned(P),
Order = BigIntegerExt.ParseHexUnsigned(N),
Cofactor = BigIntegerExt.ParseHexUnsigned(H),
};
var g = ecc.CreatePoint(BigIntegerExt.ParseHexUnsigned(Gx), BigIntegerExt.ParseHexUnsigned(Gy));
ecc.G = g;
return(ecc);
}
public ECCurve Build()
{
var ecc = new ECCurve(
name: Name,
a: BigIntegerExt.ParseHexUnsigned(A),
b: BigIntegerExt.ParseHexUnsigned(B),
modulus: BigIntegerExt.ParseHexUnsigned(P),
order: BigIntegerExt.ParseHexUnsigned(N),
cofactor: BigIntegerExt.ParseHexUnsigned(H),
gx: BigIntegerExt.ParseHexUnsigned(Gx),
gy: BigIntegerExt.ParseHexUnsigned(Gy)
);
return(ecc);
}
public void CreateBase64XTest(string dString, string xString, string yString)
{
var d = BigIntegerExt.ParseBase64UrlUnsigned(dString);
var x = BigIntegerExt.ParseBase64UrlUnsigned(xString);
var y = BigIntegerExt.ParseBase64UrlUnsigned(yString);
var curve = ECCurve.NistP256;
Assert.IsTrue(curve.Has(new ECPoint(x, y, curve)));
var point = curve.G * d;
var mod = curve.Modulus.ToBase64UrlUnsigned(curve.KeySize8);
var actualX = point.X.ToBase64UrlUnsigned(curve.KeySize8);
var actualY = point.Y.ToBase64UrlUnsigned(curve.KeySize8);
Assert.AreEqual(xString, actualX);
Assert.AreEqual(yString, actualY);
}
void linear2(BigInteger d, BigInteger e, BigInteger f)
{
var g = BigIntegerExt.ExtGcd(d, e);
g[1] *= f;
g[2] *= f;
d = -d;
var k = (g[1] / e + g[2] / d) / 2;
if (!k.IsZero)
{
g[1] -= k * e;
g[2] -= k * d;
}
_solutions.Add(
new DiophantineSolution(
DiophantineType.Linear, g[1], g[2],
(t, x, y) => g[1] + e * t,
(t, x, y) => g[2] + d * t));
}
void hyperbolic3(BigInteger a, BigInteger b, BigInteger c, BigInteger f,
List <Expression <Func <BigInteger, BigInteger, BigInteger, BigInteger> >[]> explist,
Func <Rational[], Rational[]>[] selectors)
{
if (explist.Count == 0)
{
return;
}
var funcList = explist.Select(exp =>
new[]
{
(exp[0] != null) ? exp[0].Compile() : null,
(exp[1] != null) ? exp[1].Compile() : null
}).ToList();
foreach (var sd in squareDivisor(f.Abs()))
{
var fnew = -f / (sd * sd);
var g = BigIntegerExt.Gcd(a, fnew).Abs();
foreach (var d in new BigDivisor(g))
{
foreach (var set in quadraticDivisor(a / d, b, c * d, fnew / d))
{
foreach (var selector in selectors)
{
foreach (var rt in computeQuadratic(set[4], set[3], set[2], 1, (s1, s2) =>
selector(new[]
{
(set[0] * s1 + set[1] * s2) * sd,
s1 * d * sd
})))
{
addQuadraticSolutions(rt[0], rt[1], explist, funcList);
}
}
}
}
}
}
public void ModAbsTest(int a, int n, int res)
{
Assert.IsTrue(BigIntegerExt.ModAbs(a, n) == res);
}
public void ModSqrtTest(int a, int n, int res)
{
Assert.AreEqual(new BigInteger(res), BigIntegerExt.ModSqrt(a, n));
}
public void ModMulTest(int a, int b, int n, int res)
{
Assert.AreEqual(new BigInteger(res), BigIntegerExt.ModMul(a, b, n));
}
public void ModEqualTest(int a, int b, int n, bool res)
{
Assert.AreEqual(res, BigIntegerExt.ModEqual(a, b, n));
}
void complexHyperbolic(BigInteger a, BigInteger b, BigInteger c, BigInteger d, BigInteger e, BigInteger f)
{
//refactor to form ax^2 + cy^2 + f = 0
var m = 4 * a;
var ba = m * c - b * b;
var bb = m * e - 2 * b * d;
var bc = m * f - d * d;
var c2 = BigIntegerExt.Gcd(ba, bb).Abs();
ba /= c2;
bb /= c2;
var a2 = ba;
if ((bb % 2).IsZero)
{
bb /= 2;
}
else
{
c2 /= 4;
ba *= 2;
}
m = 2 * a;
var f2 = bc * a2 - c2 * bb * bb;
//reduce & precheck
var g = BigIntegerExt.Gcd(a2, c2);
if (g != BigInteger.One)
{
BigInteger r;
f2 = BigInteger.DivRem(f2, g, out r);
if (!r.IsZero)
{
return;
}
a2 /= g;
c2 /= g;
}
//declare
var selectors = new Func <Rational[], Rational[]>[]
{
r =>
{
var y0 = (r[1] - bb) / ba;
return(new[]
{
(r[0] - y0 * b - d) / m,
y0
});
},
r =>
{
var y0 = (r[1] - bb) / ba;
return(new[]
{
(-r[0] - y0 * b - d) / m,
y0
});
},
r =>
{
var y0 = (-r[1] - bb) / ba;
return(new[]
{
(r[0] - y0 * b - d) / m,
y0
});
},
r =>
{
var y0 = (-r[1] - bb) / ba;
return(new[]
{
(-r[0] - y0 * b - d) / m,
y0
});
}
};
var p = -4 * a2 * c2;
var q = p.Sqrt();
if (f2.IsZero)
{
if (q * q == p)
{
a2 *= 2;
var m2 = a2 * m;
var q2 = a2 * d + a2 * b * bb;
var set = new[]
{
Tuple.Create(m2, ba * (a2 * b + q), q2 + q * bb),
Tuple.Create(m2, ba * (a2 * b - q), q2 - q * bb),
Tuple.Create(-m2, ba * (a2 * b + q), q2 + q * bb),
Tuple.Create(-m2, ba * (a2 * b - q), q2 - q * bb),
Tuple.Create(m2, -ba * (a2 * b + q), q2 + q * bb),
Tuple.Create(m2, -ba * (a2 * b - q), q2 - q * bb),
Tuple.Create(-m2, -ba * (a2 * b + q), q2 + q * bb),
Tuple.Create(-m2, -ba * (a2 * b - q), q2 - q * bb)
};
foreach (var item in set.Distinct())
{
linearWithGcd(item.Item1, item.Item2, item.Item3);
}
}
else
{
addStaticSolution(selectors, BigInteger.Zero, BigInteger.Zero);
}
}
else if (q * q == p)
{
hyperbolic2(a2 * 2, q, 4 * a2 * f2, q * 2, selectors);
}
else
{
hyperbolic3(a2, BigInteger.Zero, c2, f2, createFunction2(a, b, c, d, e), selectors);
}
}
