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); }