protected internal bool SatisfiesCofactor()
{
BigInteger cofactor = Curve.Cofactor;
if (cofactor != null && !cofactor.Equals(BigInteger.One))
{
return(!ECAlgorithms.ReferenceMultiply(this, cofactor).IsInfinity);
}
return(true);
}
/**
* Normalization ensures that any projective coordinate is 1, and therefore that the x, y
* coordinates reflect those of the equivalent point in an affine coordinate system. Where more
* than one point is to be normalized, this method will generally be more efficient than
* normalizing each point separately. An (optional) z-scaling factor can be applied; effectively
* each z coordinate is scaled by this value prior to normalization (but only one
* actual multiplication is needed).
*
* @param points
* An array of points that will be updated in place with their normalized versions,
* where necessary
* @param off
* The start of the range of points to normalize
* @param len
* The length of the range of points to normalize
* @param iso
* The (optional) z-scaling factor - can be null
*/
public virtual void NormalizeAll(ECPoint[] points, int off, int len, ECFieldElement iso)
{
CheckPoints(points, off, len);
switch (this.CoordinateSystem)
{
case ECCurve.COORD_AFFINE:
case ECCurve.COORD_LAMBDA_AFFINE:
{
if (iso != null)
{
throw new ArgumentException("not valid for affine coordinates", "iso");
}
return;
}
}
/*
* Figure out which of the points actually need to be normalized
*/
ECFieldElement[] zs = new ECFieldElement[len];
int[] indices = new int[len];
int count = 0;
for (int i = 0; i < len; ++i)
{
ECPoint p = points[off + i];
if (null != p && (iso != null || !p.IsNormalized()))
{
zs[count] = p.GetZCoord(0);
indices[count++] = off + i;
}
}
if (count == 0)
{
return;
}
ECAlgorithms.MontgomeryTrick(zs, 0, count, iso);
for (int j = 0; j < count; ++j)
{
int index = indices[j];
points[index] = points[index].Normalize(zs[j]);
}
}
internal static ECPoint ImplSumOfMultiplies(ECPoint[] ps, BigInteger[] ks)
{
int num = ps.Length;
bool[] array = new bool[num];
WNafPreCompInfo[] array2 = new WNafPreCompInfo[num];
byte[][] array3 = new byte[num][];
for (int i = 0; i < num; i++)
{
BigInteger bigInteger = ks[i];
array[i] = (bigInteger.SignValue < 0);
bigInteger = bigInteger.Abs();
int width = Math.Max(2, Math.Min(16, WNafUtilities.GetWindowSize(bigInteger.BitLength)));
array2[i] = WNafUtilities.Precompute(ps[i], width, true);
array3[i] = WNafUtilities.GenerateWindowNaf(width, bigInteger);
}
return(ECAlgorithms.ImplSumOfMultiplies(array, array2, array3));
}
internal static ECPoint ImplShamirsTrickWNaf(ECPoint P, BigInteger k, ECPointMap pointMapQ, BigInteger l)
{
bool flag = k.SignValue < 0;
bool flag2 = l.SignValue < 0;
k = k.Abs();
l = l.Abs();
int width = Math.Max(2, Math.Min(16, WNafUtilities.GetWindowSize(Math.Max(k.BitLength, l.BitLength))));
ECPoint p = WNafUtilities.MapPointWithPrecomp(P, width, true, pointMapQ);
WNafPreCompInfo wNafPreCompInfo = WNafUtilities.GetWNafPreCompInfo(P);
WNafPreCompInfo wNafPreCompInfo2 = WNafUtilities.GetWNafPreCompInfo(p);
ECPoint[] preCompP = flag ? wNafPreCompInfo.PreCompNeg : wNafPreCompInfo.PreComp;
ECPoint[] preCompQ = flag2 ? wNafPreCompInfo2.PreCompNeg : wNafPreCompInfo2.PreComp;
ECPoint[] preCompNegP = flag ? wNafPreCompInfo.PreComp : wNafPreCompInfo.PreCompNeg;
ECPoint[] preCompNegQ = flag2 ? wNafPreCompInfo2.PreComp : wNafPreCompInfo2.PreCompNeg;
byte[] wnafP = WNafUtilities.GenerateWindowNaf(width, k);
byte[] wnafQ = WNafUtilities.GenerateWindowNaf(width, l);
return(ECAlgorithms.ImplShamirsTrickWNaf(preCompP, preCompNegP, wnafP, preCompQ, preCompNegQ, wnafQ));
}
public virtual void NormalizeAll(ECPoint[] points, int off, int len, ECFieldElement iso)
{
this.CheckPoints(points, off, len);
int coordinateSystem = this.CoordinateSystem;
if (coordinateSystem == 0 || coordinateSystem == 5)
{
if (iso != null)
{
throw new ArgumentException("not valid for affine coordinates", "iso");
}
return;
}
else
{
ECFieldElement[] array = new ECFieldElement[len];
int[] array2 = new int[len];
int num = 0;
for (int i = 0; i < len; i++)
{
ECPoint eCPoint = points[off + i];
if (eCPoint != null && (iso != null || !eCPoint.IsNormalized()))
{
array[num] = eCPoint.GetZCoord(0);
array2[num++] = off + i;
}
}
if (num == 0)
{
return;
}
ECAlgorithms.MontgomeryTrick(array, 0, num, iso);
for (int j = 0; j < num; j++)
{
int num2 = array2[j];
points[num2] = points[num2].Normalize(array[j]);
}
return;
}
}
/**
* Normalization ensures that any projective coordinate is 1, and therefore that the x, y
* coordinates reflect those of the equivalent point in an affine coordinate system. Where more
* than one point is to be normalized, this method will generally be more efficient than
* normalizing each point separately.
*
* @param points
* An array of points that will be updated in place with their normalized versions,
* where necessary
*/
public virtual void NormalizeAll(ECPoint[] points)
{
CheckPoints(points);
if (this.CoordinateSystem == ECCurve.COORD_AFFINE)
{
return;
}
/*
* Figure out which of the points actually need to be normalized
*/
ECFieldElement[] zs = new ECFieldElement[points.Length];
int[] indices = new int[points.Length];
int count = 0;
for (int i = 0; i < points.Length; ++i)
{
ECPoint p = points[i];
if (null != p && !p.IsNormalized())
{
zs[count] = p.GetZCoord(0);
indices[count++] = i;
}
}
if (count == 0)
{
return;
}
ECAlgorithms.MontgomeryTrick(zs, 0, count);
for (int j = 0; j < count; ++j)
{
int index = indices[j];
points[index] = points[index].Normalize(zs[j]);
}
}
public virtual void NormalizeAll(ECPoint[] points, int off, int len, ECFieldElement iso)
{
this.CheckPoints(points, off, len);
switch (this.CoordinateSystem)
{
case 0:
case 5:
if (iso != null)
{
throw new ArgumentException("not valid for affine coordinates", "iso");
}
return;
}
ECFieldElement[] zs = new ECFieldElement[len];
int[] numArray = new int[len];
int index = 0;
for (int i = 0; i < len; i++)
{
ECPoint point = points[off + i];
if ((point != null) && ((iso != null) || !point.IsNormalized()))
{
zs[index] = point.GetZCoord(0);
numArray[index++] = off + i;
}
}
if (index != 0)
{
ECAlgorithms.MontgomeryTrick(zs, 0, index, iso);
for (int j = 0; j < index; j++)
{
int num5 = numArray[j];
points[num5] = points[num5].Normalize(zs[j]);
}
}
}
internal static ECPoint ImplSumOfMultipliesGlv(ECPoint[] ps, BigInteger[] ks, GlvEndomorphism glvEndomorphism)
{
BigInteger order = ps[0].Curve.Order;
int num = ps.Length;
BigInteger[] array = new BigInteger[num << 1];
int i = 0;
int num2 = 0;
while (i < num)
{
BigInteger[] array2 = glvEndomorphism.DecomposeScalar(ks[i].Mod(order));
array[num2++] = array2[0];
array[num2++] = array2[1];
i++;
}
ECPointMap pointMap = glvEndomorphism.PointMap;
if (glvEndomorphism.HasEfficientPointMap)
{
return(ECAlgorithms.ImplSumOfMultiplies(ps, pointMap, array));
}
ECPoint[] array3 = new ECPoint[num << 1];
int j = 0;
int num3 = 0;
while (j < num)
{
ECPoint eCPoint = ps[j];
ECPoint eCPoint2 = pointMap.Map(eCPoint);
array3[num3++] = eCPoint;
array3[num3++] = eCPoint2;
j++;
}
return(ECAlgorithms.ImplSumOfMultiplies(array3, array));
}
protected internal bool SatisfiesCofactor()
{
BigInteger cofactor = Curve.Cofactor;
return(cofactor == null || cofactor.Equals(BigInteger.One) || !ECAlgorithms.ReferenceMultiply(this, cofactor).IsInfinity);
}
public static void MontgomeryTrick(ECFieldElement[] zs, int off, int len)
{
ECAlgorithms.MontgomeryTrick(zs, off, len, null);
}
