public bool Equals(IEllipticCurvePoint obj)
{
if (obj as object == null)
{
return(false);
}
if (obj as object == this)
{
return(true);
}
EllipticCurvePointB obj1 = obj as EllipticCurvePointB;
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>
/// Умножить точку на число на эллиптической кривой
/// </summary>
/// <param name="value1">Точка на эллиптической кривой</param>
/// <param name="value2">Множитель к точке</param>
/// <returns></returns>
public IEllipticCurvePoint Multiply(IntBig value2)
{
EllipticCurvePointB tempPoint = null;
// Массив значений для этапа "предвычислений"
// !!!!!!!!!!!!!!Занимательная задачка: надо подумать над графом вычислений, ибо почти стопроцентная уверенность, что не все значения массива понадобятся... Налицо оптимизация
EllipticCurvePointB[] points = new EllipticCurvePointB[16];
points[0] = GetInfinity() as EllipticCurvePointB;
points[1] = this;
points[2] = points[1].Doubling() as EllipticCurvePointB;
points[3] = points[1].Addition(points[2]) as EllipticCurvePointB;
points[4] = points[2].Doubling() as EllipticCurvePointB;
points[5] = points[1].Addition(points[4]) as EllipticCurvePointB;
points[6] = points[3].Doubling() as EllipticCurvePointB;
points[7] = points[1].Addition(points[6]) as EllipticCurvePointB;
points[8] = points[4].Doubling() as EllipticCurvePointB;
points[9] = points[1].Addition(points[8]) as EllipticCurvePointB;
points[10] = points[5].Doubling() as EllipticCurvePointB;
points[11] = points[1].Addition(points[10]) as EllipticCurvePointB;
points[12] = points[6].Doubling() as EllipticCurvePointB;
points[13] = points[1].Addition(points[12]) as EllipticCurvePointB;
points[14] = points[7].Doubling() as EllipticCurvePointB;
points[15] = points[1].Addition(points[14]) as EllipticCurvePointB;
// Начальный индекс множителя, от него начинается движение по двоичному представлению большого числа
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 EllipticCurvePointB;
}
}
if (howMuchAdd > 0)
{
tempPoint = tempPoint.Addition(points[howMuchAdd]) as EllipticCurvePointB;
}
}
return(tempPoint);
}
/// <summary>
/// Parse the curve and points parameters
/// </summary>
/// <param name="x">The X value in affine coordinate</param>
/// <param name="y">The Y value in affine coordinate</param>
/// <param name="a1">The a1 elliptic curve parameter in the Weierstrass equation</param>
/// <param name="a2">The a2 elliptic curve parameter in the Weierstrass equation</param>
/// <param name="a3">The a3 elliptic curve parameter in the Weierstrass equation</param>
/// <param name="a4">The a4 elliptic curve parameter in the Weierstrass equation</param>
/// <param name="a6">The a6 elliptic curve parameter in the Weierstrass equation</param>
/// <param name="modulo">The modulo for finite field operations</param>
internal EllipticCurvePoint(IntBig x, IntBig y, IntBig a1, IntBig a2, IntBig a3, IntBig a4, IntBig a6, IntBig modulo)
{
// Set resolver for different types of elliptic curve
if (a1 == null && a2 == null && a3 == null && a4 != null && a6 != null)
{
m_Resolver = new EllipticCurvePointB(x, y, a4, a6, modulo);
}
else
{
throw new Exception("Unknown type of elliptic curve.");
}
}
internal EllipticCurvePointB(uint x, uint y, uint z, EllipticCurvePointB point)
{
m_Modulo = point.m_Modulo;
m_a4 = point.m_a4;
m_a6 = point.m_a6;
m_X = new IntBig(x);
m_Y = new IntBig(y);
m_Z = new IntBig(z);
if (!IsValid(m_X, m_Y, m_Z, m_a4, m_a6, m_Modulo))
{
throw new Exception("Point is not from elliptic curve");
}
}
internal EllipticCurvePointB(IntBig x, IntBig y, IntBig z, EllipticCurvePointB 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");
}
}
public override bool Equals(object obj)
{
if (obj == null)
{
return(false);
}
EllipticCurvePointB obj1 = obj as EllipticCurvePointB;
if (obj1 == null)
{
return(false);
}
return(Equals(obj1));
}
public EllipticCurvePointB(IntBig x, IntBig y, EllipticCurvePointB point)
{
m_x = x;
m_y = y;
m_Modulo = point.m_Modulo;
m_a4 = point.m_a4;
m_a6 = point.m_a6;
if (!IsValid(m_x, m_y, m_a4, m_a6, m_Modulo))
{
throw new Exception("Point is not from elliptic curve");
}
m_X = new IntBig(x.m_Value) % m_Modulo;
m_Y = new IntBig(y.m_Value) % m_Modulo;
m_Z = new IntBig(1);
}
public static EllipticCurvePointB Invert(EllipticCurvePointB value)
{
return(value.Invert() as EllipticCurvePointB);
}
/// <summary>
/// Умножить точку на число на эллиптической кривой
/// </summary>
/// <param name="value1">Точка на эллиптической кривой</param>
/// <param name="value2">Множитель к точке</param>
/// <returns></returns>
public static EllipticCurvePointB Multiply(EllipticCurvePointB value1, IntBig value2)
{
return(value1.Multiply(value2) as EllipticCurvePointB);
}
/// <summary>
/// Сложить две точки на кривой
/// </summary>
/// <param name="value1"></param>
/// <param name="value2"></param>
/// <returns></returns>
public static EllipticCurvePointB Addition(EllipticCurvePointB value1, EllipticCurvePointB value2)
{
return(value1.Addition(value2) as EllipticCurvePointB);
}
/// <summary>
/// Удвоить точку на кривой
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static EllipticCurvePointB Doubling(EllipticCurvePointB value)
{
return(value.Doubling() as EllipticCurvePointB);
}
public static EllipticCurvePointB GetInfinity(EllipticCurvePointB other)
{
return(new EllipticCurvePointB(1, 1, 0, other));
}
/// <summary>
/// Сложить две точки на кривой
/// </summary>
/// <param name="value1"></param>
/// <param name="value2"></param>
/// <returns></returns>
public IEllipticCurvePoint Addition(IEllipticCurvePoint value)
{
EllipticCurvePointB value2 = value as EllipticCurvePointB;
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 (Equals(value2))
{
return(Doubling());
}
// Исходные координаты
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;
// Выделим кэш операций умножения
uint[] cache = new uint[length * 2];
// Временные переменные
uint[] u1 = new uint[length];
uint[] u2 = new uint[length];
uint[] s1 = new uint[length];
uint[] s2 = new uint[length];
uint[] xr = new uint[length];
uint[] yr = new uint[length];
uint[] zr = new uint[length];
// Вычислить U1, U2, S1, S2
ModuloOperations.Multiply(z2, z2, modulo, u1, cache);
ModuloOperations.Multiply(z1, z1, modulo, u2, cache);
ModuloOperations.Multiply(u1, z2, modulo, s1, cache);
ModuloOperations.Multiply(u2, z1, modulo, s2, cache);
ModuloOperations.Multiply(u1, x1, modulo, u1, cache);
ModuloOperations.Multiply(u2, x2, modulo, u2, cache);
ModuloOperations.Multiply(s1, y1, modulo, s1, cache);
ModuloOperations.Multiply(s2, y2, modulo, s2, cache);
// Проверим, может расчет
if (Eguals(u1, u2))
{
if (Eguals(s1, s2))
{
return(Doubling());
}
else
{
return(GetInfinity());
}
}
ModuloOperations.Substraction(u2, u1, modulo);
ModuloOperations.Substraction(s2, s1, modulo);
//H^2
ModuloOperations.Multiply(u2, u2, modulo, yr, cache);
//H^3
ModuloOperations.Multiply(yr, u2, modulo, zr, cache);
//R^2
ModuloOperations.Multiply(s2, s2, modulo, xr, cache);
//R^2 - H^3
ModuloOperations.Substraction(xr, zr, modulo);
//U1*H^2
ModuloOperations.Multiply(u1, yr, modulo, yr, cache);
//2*U1*H^2
ModuloOperations.Multiply(yr, 2, modulo, u1, cache);
//X3 = R^2 - H^3 - 2*U1*H^2
ModuloOperations.Substraction(xr, u1, modulo);
//U1*H^2 - X3
ModuloOperations.Substraction(yr, xr, modulo);
//R*(U1*H^2 - X3)
ModuloOperations.Multiply(yr, s2, modulo, yr, cache);
//S1*H^3
ModuloOperations.Multiply(s1, zr, modulo, zr, cache);
//R*(U1*H^2 - X3) - S1*H^3
ModuloOperations.Substraction(yr, zr, modulo);
//Z1*Z2
ModuloOperations.Multiply(z1, z2, modulo, zr, cache);
//Z3 = H*Z1*Z2
ModuloOperations.Multiply(zr, u2, modulo, zr, cache);
return(new EllipticCurvePointB(xr, yr, zr, this));
}
internal EllipticCurvePoint(uint x, uint y, uint z, IEllipticCurvePoint resolver)
{
m_Resolver = new EllipticCurvePointB(x, y, z, resolver as EllipticCurvePointB);
}
internal EllipticCurvePoint(IntBig x, IntBig y, IntBig z, IEllipticCurvePoint resolver)
{
m_Resolver = new EllipticCurvePointB(x, y, z, resolver as EllipticCurvePointB);
}
