public bool Equals(IEllipticCurvePoint obj)
{
if (obj as object == null)
{
return(false);
}
if (obj as object == this)
{
return(true);
}
EllipticCurvePointC obj1 = obj as EllipticCurvePointC;
if (obj1 as object == null)
{
return(false);
}
if (m_X == obj1.m_X)
{
if (m_Y == obj1.m_Y)
{
if (m_Z == obj1.m_Z)
{
return(true);
}
}
}
return(false);
}
/// <summary>
/// Multiplies the this value at IntBig value
/// </summary>
/// <param name="value">IntBig multiplier</param>
/// <returns>Result of operation</returns>
public IEllipticCurvePoint Multiply(IntBig value2)
{
EllipticCurvePointC tempPoint = null;
EllipticCurvePointC[] points = new EllipticCurvePointC[16];
points[0] = GetInfinity() as EllipticCurvePointC;
points[1] = this;
points[2] = points[1].Doubling() as EllipticCurvePointC;
points[3] = points[1].Addition(points[2]) as EllipticCurvePointC;
points[4] = points[2].Doubling() as EllipticCurvePointC;
points[5] = points[1].Addition(points[4]) as EllipticCurvePointC;
points[6] = points[3].Doubling() as EllipticCurvePointC;
points[7] = points[1].Addition(points[6]) as EllipticCurvePointC;
points[8] = points[4].Doubling() as EllipticCurvePointC;
points[9] = points[1].Addition(points[8]) as EllipticCurvePointC;
points[10] = points[5].Doubling() as EllipticCurvePointC;
points[11] = points[1].Addition(points[10]) as EllipticCurvePointC;
points[12] = points[6].Doubling() as EllipticCurvePointC;
points[13] = points[1].Addition(points[12]) as EllipticCurvePointC;
points[14] = points[7].Doubling() as EllipticCurvePointC;
points[15] = points[1].Addition(points[14]) as EllipticCurvePointC;
// First index
int index = BigHelper.MaxNonZeroBitIndex(value2.m_Value);
int howManyDouble = 0;
int howMuchAdd = 0;
//if (index < 0)
// break;
index = GetWindow(value2, index, out howManyDouble, out howMuchAdd);
tempPoint = points[howMuchAdd];
while (true)
{
if (index < 0)
{
break;
}
index = GetWindow(value2, index, out howManyDouble, out howMuchAdd);
if (howManyDouble > 0)
{
for (int t = 0; t < howManyDouble; ++t)
{
tempPoint = tempPoint.Doubling() as EllipticCurvePointC;
}
}
if (howMuchAdd > 0)
{
tempPoint = tempPoint.Addition(points[howMuchAdd]) as EllipticCurvePointC;
}
}
return(tempPoint);
}
internal EllipticCurvePointC(IntBig x, IntBig y, IntBig z, EllipticCurvePointC point)
{
m_Modulo = point.m_Modulo;
m_a4 = point.m_a4;
m_a6 = point.m_a6;
m_X = x % m_Modulo;
m_Y = y % m_Modulo;
m_Z = z % m_Modulo;
if (!IsValid(m_X, m_Y, m_Z, m_a4, m_a6, m_Modulo))
{
throw new Exception("Point is not from elliptic curve");
}
}
internal EllipticCurvePointC(uint[] x, uint[] y, uint[] z, EllipticCurvePointC point)
{
m_Modulo = point.m_Modulo;
m_a4 = point.m_a4;
m_a6 = point.m_a6;
m_X = new IntBig(x) % m_Modulo;
m_Y = new IntBig(y) % m_Modulo;
m_Z = new IntBig(z) % m_Modulo;
if (!IsValid(m_X, m_Y, m_Z, m_a4, m_a6, m_Modulo))
{
throw new Exception("Point is not from elliptic curve");
}
}
public override bool Equals(object obj)
{
if (obj == null)
{
return(false);
}
EllipticCurvePointC obj1 = obj as EllipticCurvePointC;
if (obj1 == null)
{
return(false);
}
return(Equals(obj1));
}
public EllipticCurvePointC(IntBig x, IntBig y, EllipticCurvePointC point)
{
m_x = x;
m_y = y;
m_Modulo = point.m_Modulo;
m_a4 = point.m_a4;
m_a6 = point.m_a6;
m_X = new IntBig(x.m_Value) % m_Modulo;
m_Y = new IntBig(y.m_Value) % m_Modulo;
m_Z = new IntBig(1);
if (!IsValid(m_X, m_Y, m_Z, m_a4, m_a6, m_Modulo))
{
throw new Exception("Point is not from elliptic curve");
}
}
/// <summary>
/// Invert value at elliptic curve
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static EllipticCurvePointC Invert(EllipticCurvePointC value)
{
return(value.Invert() as EllipticCurvePointC);
}
/// <summary>
/// Multiplies the value at IntBig value
/// </summary>
/// <param name="value1">Elliptic curve point</param>
/// <param name="value2">IntBig multiplier</param>
/// <returns>Result</returns>
public static EllipticCurvePointC Multiply(EllipticCurvePointC value1, IntBig value2)
{
return(value1.Multiply(value2) as EllipticCurvePointC);
}
/// <summary>
/// Adds the value with another value in elliptic curve
/// </summary>
/// <param name="value1"></param>
/// <param name="value2"></param>
/// <returns></returns>
public static EllipticCurvePointC Addition(EllipticCurvePointC value1, EllipticCurvePointC value2)
{
return(value1.Addition(value2) as EllipticCurvePointC);
}
/// <summary>
/// Doubling the point in elliptic curve
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static EllipticCurvePointC Doubling(EllipticCurvePointC value)
{
return(value.Doubling() as EllipticCurvePointC);
}
/// <summary>
/// Get the infinity point
/// </summary>
/// <returns>Infinity point</returns>
public static EllipticCurvePointC GetInfinity(EllipticCurvePointC other)
{
return(new EllipticCurvePointC(1, 0, 0, other));
}
/// <summary>
/// Adds the this value with another value in elliptic curve
/// </summary>
/// <param name="value">The value to add with this value</param>
/// <returns>The sum of values</returns>
public IEllipticCurvePoint Addition(IEllipticCurvePoint value)
{
EllipticCurvePointC value2 = value as EllipticCurvePointC;
if (value2 as object == null)
{
throw new Exception("Incorrect point type!");
}
if (m_a4 != value2.m_a4 || m_a6 != value2.m_a6 || m_Modulo != value2.m_Modulo)
{
throw new Exception("Incorrect value elliptic curve parameters!");
}
if (value2.Infinity)
{
return(new EllipticCurvePointC(m_X, m_Y, m_Z, this));
}
if (Infinity)
{
return(new EllipticCurvePointC(value2.m_X, value2.m_Y, value2.m_Z, value2));
}
if (Equals(value2))
{
return(Doubling());
}
// Coordinates
uint[] a = m_a4.m_Value;
uint[] x1 = m_X.m_Value;
uint[] y1 = m_Y.m_Value;
uint[] z1 = m_Z.m_Value;
uint[] x2 = value2.m_X.m_Value;
uint[] y2 = value2.m_Y.m_Value;
uint[] z2 = value2.m_Z.m_Value;
uint[] modulo = m_Modulo.m_Value;
int maxModuloBitIndex = BigHelper.MaxNonZeroBitIndex(modulo);
int length = modulo.Length;
// Get the cache
uint[] cache = new uint[length * 2];
uint[] A = new uint[length];
uint[] D = new uint[length];
uint[] B = new uint[length];
uint[] C = new uint[length];
uint[] xr = new uint[length];
uint[] yr = new uint[length];
uint[] zr = new uint[length];
// Z1^2
ModuloOperations.Multiply(z1, z1, modulo, A, cache);
// Z1^2 * a
ModuloOperations.Multiply(z1, a, modulo, D, cache);
// X2 * Z1
ModuloOperations.Multiply(x2, z1, modulo, B, cache);
// B = X2 * Z1 + X1
ModuloOperations.Addition(B, x1, modulo);
// C = Z1*B
ModuloOperations.Multiply(z1, B, modulo, C, cache);
// C + Z1^2 * a
ModuloOperations.Addition(D, C, modulo);
// B * (C + Z1^2 * a)
ModuloOperations.Multiply(D, B, modulo, D, cache);
// D = B^2 * (C + Z1^2 * a)
ModuloOperations.Multiply(D, B, modulo, D, cache);
// Y2 * Z1^2
ModuloOperations.Multiply(A, y2, modulo, A, cache);
// A = Y2 * Z1^2 + Y1
ModuloOperations.Addition(A, y1, modulo);
if (BigHelper.IfZero(B))
{
if (BigHelper.IfZero(A))
{
return(value2.Doubling());
}
else
{
return(GetInfinity());
}
}
// Z3 = C^2
ModuloOperations.Multiply(C, C, modulo, zr, cache);
// E = A * C
ModuloOperations.Multiply(C, A, modulo, C, cache);
// A^2
ModuloOperations.Multiply(A, A, modulo, xr, cache);
// A^2 + D
ModuloOperations.Addition(xr, D, modulo);
// X3 = A^2 + D + E
ModuloOperations.Addition(xr, C, modulo);
// X2 * Z3
ModuloOperations.Multiply(x2, zr, modulo, A, cache);
// F = X3 + X2 * Z3
ModuloOperations.Addition(A, xr, modulo);
// X2 + Y2
ModuloOperations.Addition(x2, y2, modulo, B);
// (X2 + Y2) * Z3
ModuloOperations.Multiply(B, zr, modulo, B, cache);
// G = (X2 + Y2) * Z3^2
ModuloOperations.Multiply(B, zr, modulo, B, cache);
// E + Z3
ModuloOperations.Addition(C, zr, modulo, yr);
// (E + Z3) * F
ModuloOperations.Multiply(yr, A, modulo, yr, cache);
// (E + Z3) * F + G
ModuloOperations.Addition(yr, B, modulo, yr);
return(new EllipticCurvePointC(xr, yr, zr, this));
}
