up
This commit is contained in:
483
Assets/BestHTTP/SecureProtocol/math/ec/ECAlgorithms.cs
Normal file
483
Assets/BestHTTP/SecureProtocol/math/ec/ECAlgorithms.cs
Normal file
@@ -0,0 +1,483 @@
|
||||
#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
|
||||
|
||||
using System;
|
||||
|
||||
using Org.BouncyCastle.Math.EC.Endo;
|
||||
using Org.BouncyCastle.Math.EC.Multiplier;
|
||||
using Org.BouncyCastle.Math.Field;
|
||||
|
||||
namespace Org.BouncyCastle.Math.EC
|
||||
{
|
||||
public class ECAlgorithms
|
||||
{
|
||||
public static bool IsF2mCurve(ECCurve c)
|
||||
{
|
||||
return IsF2mField(c.Field);
|
||||
}
|
||||
|
||||
public static bool IsF2mField(IFiniteField field)
|
||||
{
|
||||
return field.Dimension > 1 && field.Characteristic.Equals(BigInteger.Two)
|
||||
&& field is IPolynomialExtensionField;
|
||||
}
|
||||
|
||||
public static bool IsFpCurve(ECCurve c)
|
||||
{
|
||||
return IsFpField(c.Field);
|
||||
}
|
||||
|
||||
public static bool IsFpField(IFiniteField field)
|
||||
{
|
||||
return field.Dimension == 1;
|
||||
}
|
||||
|
||||
public static ECPoint SumOfMultiplies(ECPoint[] ps, BigInteger[] ks)
|
||||
{
|
||||
if (ps == null || ks == null || ps.Length != ks.Length || ps.Length < 1)
|
||||
throw new ArgumentException("point and scalar arrays should be non-null, and of equal, non-zero, length");
|
||||
|
||||
int count = ps.Length;
|
||||
switch (count)
|
||||
{
|
||||
case 1:
|
||||
return ps[0].Multiply(ks[0]);
|
||||
case 2:
|
||||
return SumOfTwoMultiplies(ps[0], ks[0], ps[1], ks[1]);
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
ECPoint p = ps[0];
|
||||
ECCurve c = p.Curve;
|
||||
|
||||
ECPoint[] imported = new ECPoint[count];
|
||||
imported[0] = p;
|
||||
for (int i = 1; i < count; ++i)
|
||||
{
|
||||
imported[i] = ImportPoint(c, ps[i]);
|
||||
}
|
||||
|
||||
GlvEndomorphism glvEndomorphism = c.GetEndomorphism() as GlvEndomorphism;
|
||||
if (glvEndomorphism != null)
|
||||
{
|
||||
return ValidatePoint(ImplSumOfMultipliesGlv(imported, ks, glvEndomorphism));
|
||||
}
|
||||
|
||||
return ValidatePoint(ImplSumOfMultiplies(imported, ks));
|
||||
}
|
||||
|
||||
public static ECPoint SumOfTwoMultiplies(ECPoint P, BigInteger a, ECPoint Q, BigInteger b)
|
||||
{
|
||||
ECCurve cp = P.Curve;
|
||||
Q = ImportPoint(cp, Q);
|
||||
|
||||
// Point multiplication for Koblitz curves (using WTNAF) beats Shamir's trick
|
||||
{
|
||||
AbstractF2mCurve f2mCurve = cp as AbstractF2mCurve;
|
||||
if (f2mCurve != null && f2mCurve.IsKoblitz)
|
||||
{
|
||||
return ValidatePoint(P.Multiply(a).Add(Q.Multiply(b)));
|
||||
}
|
||||
}
|
||||
|
||||
GlvEndomorphism glvEndomorphism = cp.GetEndomorphism() as GlvEndomorphism;
|
||||
if (glvEndomorphism != null)
|
||||
{
|
||||
return ValidatePoint(
|
||||
ImplSumOfMultipliesGlv(new ECPoint[] { P, Q }, new BigInteger[] { a, b }, glvEndomorphism));
|
||||
}
|
||||
|
||||
return ValidatePoint(ImplShamirsTrickWNaf(P, a, Q, b));
|
||||
}
|
||||
|
||||
/*
|
||||
* "Shamir's Trick", originally due to E. G. Straus
|
||||
* (Addition chains of vectors. American Mathematical Monthly,
|
||||
* 71(7):806-808, Aug./Sept. 1964)
|
||||
*
|
||||
* Input: The points P, Q, scalar k = (km?, ... , k1, k0)
|
||||
* and scalar l = (lm?, ... , l1, l0).
|
||||
* Output: R = k * P + l * Q.
|
||||
* 1: Z <- P + Q
|
||||
* 2: R <- O
|
||||
* 3: for i from m-1 down to 0 do
|
||||
* 4: R <- R + R {point doubling}
|
||||
* 5: if (ki = 1) and (li = 0) then R <- R + P end if
|
||||
* 6: if (ki = 0) and (li = 1) then R <- R + Q end if
|
||||
* 7: if (ki = 1) and (li = 1) then R <- R + Z end if
|
||||
* 8: end for
|
||||
* 9: return R
|
||||
*/
|
||||
public static ECPoint ShamirsTrick(ECPoint P, BigInteger k, ECPoint Q, BigInteger l)
|
||||
{
|
||||
ECCurve cp = P.Curve;
|
||||
Q = ImportPoint(cp, Q);
|
||||
|
||||
return ValidatePoint(ImplShamirsTrickJsf(P, k, Q, l));
|
||||
}
|
||||
|
||||
public static ECPoint ImportPoint(ECCurve c, ECPoint p)
|
||||
{
|
||||
ECCurve cp = p.Curve;
|
||||
if (!c.Equals(cp))
|
||||
throw new ArgumentException("Point must be on the same curve");
|
||||
|
||||
return c.ImportPoint(p);
|
||||
}
|
||||
|
||||
public static void MontgomeryTrick(ECFieldElement[] zs, int off, int len)
|
||||
{
|
||||
MontgomeryTrick(zs, off, len, null);
|
||||
}
|
||||
|
||||
public static void MontgomeryTrick(ECFieldElement[] zs, int off, int len, ECFieldElement scale)
|
||||
{
|
||||
/*
|
||||
* Uses the "Montgomery Trick" to invert many field elements, with only a single actual
|
||||
* field inversion. See e.g. the paper:
|
||||
* "Fast Multi-scalar Multiplication Methods on Elliptic Curves with Precomputation Strategy Using Montgomery Trick"
|
||||
* by Katsuyuki Okeya, Kouichi Sakurai.
|
||||
*/
|
||||
|
||||
ECFieldElement[] c = new ECFieldElement[len];
|
||||
c[0] = zs[off];
|
||||
|
||||
int i = 0;
|
||||
while (++i < len)
|
||||
{
|
||||
c[i] = c[i - 1].Multiply(zs[off + i]);
|
||||
}
|
||||
|
||||
--i;
|
||||
|
||||
if (scale != null)
|
||||
{
|
||||
c[i] = c[i].Multiply(scale);
|
||||
}
|
||||
|
||||
ECFieldElement u = c[i].Invert();
|
||||
|
||||
while (i > 0)
|
||||
{
|
||||
int j = off + i--;
|
||||
ECFieldElement tmp = zs[j];
|
||||
zs[j] = c[i].Multiply(u);
|
||||
u = u.Multiply(tmp);
|
||||
}
|
||||
|
||||
zs[off] = u;
|
||||
}
|
||||
|
||||
/**
|
||||
* Simple shift-and-add multiplication. Serves as reference implementation
|
||||
* to verify (possibly faster) implementations, and for very small scalars.
|
||||
*
|
||||
* @param p
|
||||
* The point to multiply.
|
||||
* @param k
|
||||
* The multiplier.
|
||||
* @return The result of the point multiplication <code>kP</code>.
|
||||
*/
|
||||
public static ECPoint ReferenceMultiply(ECPoint p, BigInteger k)
|
||||
{
|
||||
BigInteger x = k.Abs();
|
||||
ECPoint q = p.Curve.Infinity;
|
||||
int t = x.BitLength;
|
||||
if (t > 0)
|
||||
{
|
||||
if (x.TestBit(0))
|
||||
{
|
||||
q = p;
|
||||
}
|
||||
for (int i = 1; i < t; i++)
|
||||
{
|
||||
p = p.Twice();
|
||||
if (x.TestBit(i))
|
||||
{
|
||||
q = q.Add(p);
|
||||
}
|
||||
}
|
||||
}
|
||||
return k.SignValue < 0 ? q.Negate() : q;
|
||||
}
|
||||
|
||||
public static ECPoint ValidatePoint(ECPoint p)
|
||||
{
|
||||
if (!p.IsValid())
|
||||
throw new ArgumentException("Invalid point", "p");
|
||||
|
||||
return p;
|
||||
}
|
||||
|
||||
internal static ECPoint ImplShamirsTrickJsf(ECPoint P, BigInteger k, ECPoint Q, BigInteger l)
|
||||
{
|
||||
ECCurve curve = P.Curve;
|
||||
ECPoint infinity = curve.Infinity;
|
||||
|
||||
// TODO conjugate co-Z addition (ZADDC) can return both of these
|
||||
ECPoint PaddQ = P.Add(Q);
|
||||
ECPoint PsubQ = P.Subtract(Q);
|
||||
|
||||
ECPoint[] points = new ECPoint[] { Q, PsubQ, P, PaddQ };
|
||||
curve.NormalizeAll(points);
|
||||
|
||||
ECPoint[] table = new ECPoint[] {
|
||||
points[3].Negate(), points[2].Negate(), points[1].Negate(),
|
||||
points[0].Negate(), infinity, points[0],
|
||||
points[1], points[2], points[3] };
|
||||
|
||||
byte[] jsf = WNafUtilities.GenerateJsf(k, l);
|
||||
|
||||
ECPoint R = infinity;
|
||||
|
||||
int i = jsf.Length;
|
||||
while (--i >= 0)
|
||||
{
|
||||
int jsfi = jsf[i];
|
||||
|
||||
// NOTE: The shifting ensures the sign is extended correctly
|
||||
int kDigit = ((jsfi << 24) >> 28), lDigit = ((jsfi << 28) >> 28);
|
||||
|
||||
int index = 4 + (kDigit * 3) + lDigit;
|
||||
R = R.TwicePlus(table[index]);
|
||||
}
|
||||
|
||||
return R;
|
||||
}
|
||||
|
||||
internal static ECPoint ImplShamirsTrickWNaf(ECPoint P, BigInteger k,
|
||||
ECPoint Q, BigInteger l)
|
||||
{
|
||||
bool negK = k.SignValue < 0, negL = l.SignValue < 0;
|
||||
|
||||
k = k.Abs();
|
||||
l = l.Abs();
|
||||
|
||||
int widthP = System.Math.Max(2, System.Math.Min(16, WNafUtilities.GetWindowSize(k.BitLength)));
|
||||
int widthQ = System.Math.Max(2, System.Math.Min(16, WNafUtilities.GetWindowSize(l.BitLength)));
|
||||
|
||||
WNafPreCompInfo infoP = WNafUtilities.Precompute(P, widthP, true);
|
||||
WNafPreCompInfo infoQ = WNafUtilities.Precompute(Q, widthQ, true);
|
||||
|
||||
ECPoint[] preCompP = negK ? infoP.PreCompNeg : infoP.PreComp;
|
||||
ECPoint[] preCompQ = negL ? infoQ.PreCompNeg : infoQ.PreComp;
|
||||
ECPoint[] preCompNegP = negK ? infoP.PreComp : infoP.PreCompNeg;
|
||||
ECPoint[] preCompNegQ = negL ? infoQ.PreComp : infoQ.PreCompNeg;
|
||||
|
||||
byte[] wnafP = WNafUtilities.GenerateWindowNaf(widthP, k);
|
||||
byte[] wnafQ = WNafUtilities.GenerateWindowNaf(widthQ, l);
|
||||
|
||||
return ImplShamirsTrickWNaf(preCompP, preCompNegP, wnafP, preCompQ, preCompNegQ, wnafQ);
|
||||
}
|
||||
|
||||
internal static ECPoint ImplShamirsTrickWNaf(ECPoint P, BigInteger k, ECPointMap pointMapQ, BigInteger l)
|
||||
{
|
||||
bool negK = k.SignValue < 0, negL = l.SignValue < 0;
|
||||
|
||||
k = k.Abs();
|
||||
l = l.Abs();
|
||||
|
||||
int width = System.Math.Max(2, System.Math.Min(16, WNafUtilities.GetWindowSize(System.Math.Max(k.BitLength, l.BitLength))));
|
||||
|
||||
ECPoint Q = WNafUtilities.MapPointWithPrecomp(P, width, true, pointMapQ);
|
||||
WNafPreCompInfo infoP = WNafUtilities.GetWNafPreCompInfo(P);
|
||||
WNafPreCompInfo infoQ = WNafUtilities.GetWNafPreCompInfo(Q);
|
||||
|
||||
ECPoint[] preCompP = negK ? infoP.PreCompNeg : infoP.PreComp;
|
||||
ECPoint[] preCompQ = negL ? infoQ.PreCompNeg : infoQ.PreComp;
|
||||
ECPoint[] preCompNegP = negK ? infoP.PreComp : infoP.PreCompNeg;
|
||||
ECPoint[] preCompNegQ = negL ? infoQ.PreComp : infoQ.PreCompNeg;
|
||||
|
||||
byte[] wnafP = WNafUtilities.GenerateWindowNaf(width, k);
|
||||
byte[] wnafQ = WNafUtilities.GenerateWindowNaf(width, l);
|
||||
|
||||
return ImplShamirsTrickWNaf(preCompP, preCompNegP, wnafP, preCompQ, preCompNegQ, wnafQ);
|
||||
}
|
||||
|
||||
private static ECPoint ImplShamirsTrickWNaf(ECPoint[] preCompP, ECPoint[] preCompNegP, byte[] wnafP,
|
||||
ECPoint[] preCompQ, ECPoint[] preCompNegQ, byte[] wnafQ)
|
||||
{
|
||||
int len = System.Math.Max(wnafP.Length, wnafQ.Length);
|
||||
|
||||
ECCurve curve = preCompP[0].Curve;
|
||||
ECPoint infinity = curve.Infinity;
|
||||
|
||||
ECPoint R = infinity;
|
||||
int zeroes = 0;
|
||||
|
||||
for (int i = len - 1; i >= 0; --i)
|
||||
{
|
||||
int wiP = i < wnafP.Length ? (int)(sbyte)wnafP[i] : 0;
|
||||
int wiQ = i < wnafQ.Length ? (int)(sbyte)wnafQ[i] : 0;
|
||||
|
||||
if ((wiP | wiQ) == 0)
|
||||
{
|
||||
++zeroes;
|
||||
continue;
|
||||
}
|
||||
|
||||
ECPoint r = infinity;
|
||||
if (wiP != 0)
|
||||
{
|
||||
int nP = System.Math.Abs(wiP);
|
||||
ECPoint[] tableP = wiP < 0 ? preCompNegP : preCompP;
|
||||
r = r.Add(tableP[nP >> 1]);
|
||||
}
|
||||
if (wiQ != 0)
|
||||
{
|
||||
int nQ = System.Math.Abs(wiQ);
|
||||
ECPoint[] tableQ = wiQ < 0 ? preCompNegQ : preCompQ;
|
||||
r = r.Add(tableQ[nQ >> 1]);
|
||||
}
|
||||
|
||||
if (zeroes > 0)
|
||||
{
|
||||
R = R.TimesPow2(zeroes);
|
||||
zeroes = 0;
|
||||
}
|
||||
|
||||
R = R.TwicePlus(r);
|
||||
}
|
||||
|
||||
if (zeroes > 0)
|
||||
{
|
||||
R = R.TimesPow2(zeroes);
|
||||
}
|
||||
|
||||
return R;
|
||||
}
|
||||
|
||||
internal static ECPoint ImplSumOfMultiplies(ECPoint[] ps, BigInteger[] ks)
|
||||
{
|
||||
int count = ps.Length;
|
||||
bool[] negs = new bool[count];
|
||||
WNafPreCompInfo[] infos = new WNafPreCompInfo[count];
|
||||
byte[][] wnafs = new byte[count][];
|
||||
|
||||
for (int i = 0; i < count; ++i)
|
||||
{
|
||||
BigInteger ki = ks[i]; negs[i] = ki.SignValue < 0; ki = ki.Abs();
|
||||
|
||||
int width = System.Math.Max(2, System.Math.Min(16, WNafUtilities.GetWindowSize(ki.BitLength)));
|
||||
infos[i] = WNafUtilities.Precompute(ps[i], width, true);
|
||||
wnafs[i] = WNafUtilities.GenerateWindowNaf(width, ki);
|
||||
}
|
||||
|
||||
return ImplSumOfMultiplies(negs, infos, wnafs);
|
||||
}
|
||||
|
||||
internal static ECPoint ImplSumOfMultipliesGlv(ECPoint[] ps, BigInteger[] ks, GlvEndomorphism glvEndomorphism)
|
||||
{
|
||||
BigInteger n = ps[0].Curve.Order;
|
||||
|
||||
int len = ps.Length;
|
||||
|
||||
BigInteger[] abs = new BigInteger[len << 1];
|
||||
for (int i = 0, j = 0; i < len; ++i)
|
||||
{
|
||||
BigInteger[] ab = glvEndomorphism.DecomposeScalar(ks[i].Mod(n));
|
||||
abs[j++] = ab[0];
|
||||
abs[j++] = ab[1];
|
||||
}
|
||||
|
||||
ECPointMap pointMap = glvEndomorphism.PointMap;
|
||||
if (glvEndomorphism.HasEfficientPointMap)
|
||||
{
|
||||
return ECAlgorithms.ImplSumOfMultiplies(ps, pointMap, abs);
|
||||
}
|
||||
|
||||
ECPoint[] pqs = new ECPoint[len << 1];
|
||||
for (int i = 0, j = 0; i < len; ++i)
|
||||
{
|
||||
ECPoint p = ps[i], q = pointMap.Map(p);
|
||||
pqs[j++] = p;
|
||||
pqs[j++] = q;
|
||||
}
|
||||
|
||||
return ECAlgorithms.ImplSumOfMultiplies(pqs, abs);
|
||||
}
|
||||
|
||||
internal static ECPoint ImplSumOfMultiplies(ECPoint[] ps, ECPointMap pointMap, BigInteger[] ks)
|
||||
{
|
||||
int halfCount = ps.Length, fullCount = halfCount << 1;
|
||||
|
||||
bool[] negs = new bool[fullCount];
|
||||
WNafPreCompInfo[] infos = new WNafPreCompInfo[fullCount];
|
||||
byte[][] wnafs = new byte[fullCount][];
|
||||
|
||||
for (int i = 0; i < halfCount; ++i)
|
||||
{
|
||||
int j0 = i << 1, j1 = j0 + 1;
|
||||
|
||||
BigInteger kj0 = ks[j0]; negs[j0] = kj0.SignValue < 0; kj0 = kj0.Abs();
|
||||
BigInteger kj1 = ks[j1]; negs[j1] = kj1.SignValue < 0; kj1 = kj1.Abs();
|
||||
|
||||
int width = System.Math.Max(2, System.Math.Min(16, WNafUtilities.GetWindowSize(System.Math.Max(kj0.BitLength, kj1.BitLength))));
|
||||
|
||||
ECPoint P = ps[i], Q = WNafUtilities.MapPointWithPrecomp(P, width, true, pointMap);
|
||||
infos[j0] = WNafUtilities.GetWNafPreCompInfo(P);
|
||||
infos[j1] = WNafUtilities.GetWNafPreCompInfo(Q);
|
||||
wnafs[j0] = WNafUtilities.GenerateWindowNaf(width, kj0);
|
||||
wnafs[j1] = WNafUtilities.GenerateWindowNaf(width, kj1);
|
||||
}
|
||||
|
||||
return ImplSumOfMultiplies(negs, infos, wnafs);
|
||||
}
|
||||
|
||||
private static ECPoint ImplSumOfMultiplies(bool[] negs, WNafPreCompInfo[] infos, byte[][] wnafs)
|
||||
{
|
||||
int len = 0, count = wnafs.Length;
|
||||
for (int i = 0; i < count; ++i)
|
||||
{
|
||||
len = System.Math.Max(len, wnafs[i].Length);
|
||||
}
|
||||
|
||||
ECCurve curve = infos[0].PreComp[0].Curve;
|
||||
ECPoint infinity = curve.Infinity;
|
||||
|
||||
ECPoint R = infinity;
|
||||
int zeroes = 0;
|
||||
|
||||
for (int i = len - 1; i >= 0; --i)
|
||||
{
|
||||
ECPoint r = infinity;
|
||||
|
||||
for (int j = 0; j < count; ++j)
|
||||
{
|
||||
byte[] wnaf = wnafs[j];
|
||||
int wi = i < wnaf.Length ? (int)(sbyte)wnaf[i] : 0;
|
||||
if (wi != 0)
|
||||
{
|
||||
int n = System.Math.Abs(wi);
|
||||
WNafPreCompInfo info = infos[j];
|
||||
ECPoint[] table = (wi < 0 == negs[j]) ? info.PreComp : info.PreCompNeg;
|
||||
r = r.Add(table[n >> 1]);
|
||||
}
|
||||
}
|
||||
|
||||
if (r == infinity)
|
||||
{
|
||||
++zeroes;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (zeroes > 0)
|
||||
{
|
||||
R = R.TimesPow2(zeroes);
|
||||
zeroes = 0;
|
||||
}
|
||||
|
||||
R = R.TwicePlus(r);
|
||||
}
|
||||
|
||||
if (zeroes > 0)
|
||||
{
|
||||
R = R.TimesPow2(zeroes);
|
||||
}
|
||||
|
||||
return R;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user