Esempio n. 1
0
 public override ECFieldElement Sqrt()
 {
     uint[] y = this.x;
     if (Nat160.IsZero(y) || Nat160.IsOne(y))
     {
         return(this);
     }
     uint[] array = Nat160.Create();
     SecP160R2Field.Square(y, array);
     SecP160R2Field.Multiply(array, y, array);
     uint[] array2 = Nat160.Create();
     SecP160R2Field.Square(array, array2);
     SecP160R2Field.Multiply(array2, y, array2);
     uint[] array3 = Nat160.Create();
     SecP160R2Field.Square(array2, array3);
     SecP160R2Field.Multiply(array3, y, array3);
     uint[] array4 = Nat160.Create();
     SecP160R2Field.SquareN(array3, 3, array4);
     SecP160R2Field.Multiply(array4, array2, array4);
     uint[] array5 = array3;
     SecP160R2Field.SquareN(array4, 7, array5);
     SecP160R2Field.Multiply(array5, array4, array5);
     uint[] array6 = array4;
     SecP160R2Field.SquareN(array5, 3, array6);
     SecP160R2Field.Multiply(array6, array2, array6);
     uint[] array7 = Nat160.Create();
     SecP160R2Field.SquareN(array6, 14, array7);
     SecP160R2Field.Multiply(array7, array5, array7);
     uint[] array8 = array5;
     SecP160R2Field.SquareN(array7, 31, array8);
     SecP160R2Field.Multiply(array8, array7, array8);
     uint[] z = array7;
     SecP160R2Field.SquareN(array8, 62, z);
     SecP160R2Field.Multiply(z, array8, z);
     uint[] array9 = array8;
     SecP160R2Field.SquareN(z, 3, array9);
     SecP160R2Field.Multiply(array9, array2, array9);
     uint[] z2 = array9;
     SecP160R2Field.SquareN(z2, 18, z2);
     SecP160R2Field.Multiply(z2, array6, z2);
     SecP160R2Field.SquareN(z2, 2, z2);
     SecP160R2Field.Multiply(z2, y, z2);
     SecP160R2Field.SquareN(z2, 3, z2);
     SecP160R2Field.Multiply(z2, array, z2);
     SecP160R2Field.SquareN(z2, 6, z2);
     SecP160R2Field.Multiply(z2, array2, z2);
     SecP160R2Field.SquareN(z2, 2, z2);
     SecP160R2Field.Multiply(z2, y, z2);
     uint[] array10 = array;
     SecP160R2Field.Square(z2, array10);
     if (!Nat160.Eq(y, array10))
     {
         return(null);
     }
     return(new SecP160R2FieldElement(z2));
 }
Esempio n. 2
0
 public override ECFieldElement Sqrt()
 {
     uint[] x = this.x;
     if (Nat160.IsZero(x) || Nat160.IsOne(x))
     {
         return(this);
     }
     uint[] z = Nat160.Create();
     SecP160R2Field.Square(x, z);
     SecP160R2Field.Multiply(z, x, z);
     uint[] numArray3 = Nat160.Create();
     SecP160R2Field.Square(z, numArray3);
     SecP160R2Field.Multiply(numArray3, x, numArray3);
     uint[] numArray4 = Nat160.Create();
     SecP160R2Field.Square(numArray3, numArray4);
     SecP160R2Field.Multiply(numArray4, x, numArray4);
     uint[] numArray5 = Nat160.Create();
     SecP160R2Field.SquareN(numArray4, 3, numArray5);
     SecP160R2Field.Multiply(numArray5, numArray3, numArray5);
     uint[] numArray6 = numArray4;
     SecP160R2Field.SquareN(numArray5, 7, numArray6);
     SecP160R2Field.Multiply(numArray6, numArray5, numArray6);
     uint[] numArray7 = numArray5;
     SecP160R2Field.SquareN(numArray6, 3, numArray7);
     SecP160R2Field.Multiply(numArray7, numArray3, numArray7);
     uint[] numArray8 = Nat160.Create();
     SecP160R2Field.SquareN(numArray7, 14, numArray8);
     SecP160R2Field.Multiply(numArray8, numArray6, numArray8);
     uint[] numArray9 = numArray6;
     SecP160R2Field.SquareN(numArray8, 0x1f, numArray9);
     SecP160R2Field.Multiply(numArray9, numArray8, numArray9);
     uint[] numArray10 = numArray8;
     SecP160R2Field.SquareN(numArray9, 0x3e, numArray10);
     SecP160R2Field.Multiply(numArray10, numArray9, numArray10);
     uint[] numArray11 = numArray9;
     SecP160R2Field.SquareN(numArray10, 3, numArray11);
     SecP160R2Field.Multiply(numArray11, numArray3, numArray11);
     uint[] numArray12 = numArray11;
     SecP160R2Field.SquareN(numArray12, 0x12, numArray12);
     SecP160R2Field.Multiply(numArray12, numArray7, numArray12);
     SecP160R2Field.SquareN(numArray12, 2, numArray12);
     SecP160R2Field.Multiply(numArray12, x, numArray12);
     SecP160R2Field.SquareN(numArray12, 3, numArray12);
     SecP160R2Field.Multiply(numArray12, z, numArray12);
     SecP160R2Field.SquareN(numArray12, 6, numArray12);
     SecP160R2Field.Multiply(numArray12, numArray3, numArray12);
     SecP160R2Field.SquareN(numArray12, 2, numArray12);
     SecP160R2Field.Multiply(numArray12, x, numArray12);
     uint[] numArray13 = z;
     SecP160R2Field.Square(numArray12, numArray13);
     return(!Nat160.Eq(x, numArray13) ? null : new SecP160R2FieldElement(numArray12));
 }
        // D.1.4 91

        /**
         * return a sqrt root - the routine verifies that the calculation returns the right value - if
         * none exists it returns null.
         */
        public override ECFieldElement Sqrt()
        {
            /*
             * Raise this element to the exponent 2^158 - 2^30 - 2^12 - 2^10 - 2^7 - 2^6 - 2^5 - 2^1 - 2^0
             *
             * Breaking up the exponent's binary representation into "repunits", we get: { 127 1s } { 1
             * 0s } { 17 1s } { 1 0s } { 1 1s } { 1 0s } { 2 1s } { 3 0s } { 3 1s } { 1 0s } { 1 1s }
             *
             * Therefore we need an Addition chain containing 1, 2, 3, 17, 127 (the lengths of the repunits)
             * We use: [1], [2], [3], 4, 7, 14, [17], 31, 62, 124, [127]
             */

            uint[] x1 = this.x;
            if (Nat160.IsZero(x1) || Nat160.IsOne(x1))
            {
                return(this);
            }

            uint[] x2 = Nat160.Create();
            SecP160R2Field.Square(x1, x2);
            SecP160R2Field.Multiply(x2, x1, x2);
            uint[] x3 = Nat160.Create();
            SecP160R2Field.Square(x2, x3);
            SecP160R2Field.Multiply(x3, x1, x3);
            uint[] x4 = Nat160.Create();
            SecP160R2Field.Square(x3, x4);
            SecP160R2Field.Multiply(x4, x1, x4);
            uint[] x7 = Nat160.Create();
            SecP160R2Field.SquareN(x4, 3, x7);
            SecP160R2Field.Multiply(x7, x3, x7);
            uint[] x14 = x4;
            SecP160R2Field.SquareN(x7, 7, x14);
            SecP160R2Field.Multiply(x14, x7, x14);
            uint[] x17 = x7;
            SecP160R2Field.SquareN(x14, 3, x17);
            SecP160R2Field.Multiply(x17, x3, x17);
            uint[] x31 = Nat160.Create();
            SecP160R2Field.SquareN(x17, 14, x31);
            SecP160R2Field.Multiply(x31, x14, x31);
            uint[] x62 = x14;
            SecP160R2Field.SquareN(x31, 31, x62);
            SecP160R2Field.Multiply(x62, x31, x62);
            uint[] x124 = x31;
            SecP160R2Field.SquareN(x62, 62, x124);
            SecP160R2Field.Multiply(x124, x62, x124);
            uint[] x127 = x62;
            SecP160R2Field.SquareN(x124, 3, x127);
            SecP160R2Field.Multiply(x127, x3, x127);

            uint[] t1 = x127;
            SecP160R2Field.SquareN(t1, 18, t1);
            SecP160R2Field.Multiply(t1, x17, t1);
            SecP160R2Field.SquareN(t1, 2, t1);
            SecP160R2Field.Multiply(t1, x1, t1);
            SecP160R2Field.SquareN(t1, 3, t1);
            SecP160R2Field.Multiply(t1, x2, t1);
            SecP160R2Field.SquareN(t1, 6, t1);
            SecP160R2Field.Multiply(t1, x3, t1);
            SecP160R2Field.SquareN(t1, 2, t1);
            SecP160R2Field.Multiply(t1, x1, t1);

            uint[] t2 = x2;
            SecP160R2Field.Square(t1, t2);

            return(Nat160.Eq(x1, t2) ? new SecP160R2FieldElement(t1) : null);
        }