Beispiel #1
0
        public static void AddExt(uint[] xx, uint[] yy, uint[] zz)
        {
            uint c = Nat.Add(14, xx, yy, zz);

            if (c != 0 || (zz[13] == PExt13 && Nat.Gte(14, zz, PExt)))
            {
                if (Nat.AddTo(PExtInv.Length, PExtInv, zz) != 0)
                {
                    Nat.IncAt(14, zz, PExtInv.Length);
                }
            }
        }
Beispiel #2
0
        public static void MultiplyAddToExt(uint[] x, uint[] y, uint[] zz)
        {
            uint c = Nat224.MulAddTo(x, y, zz);

            if (c != 0 || (zz[13] == PExt13 && Nat.Gte(14, zz, PExt)))
            {
                if (Nat.AddTo(PExtInv.Length, PExtInv, zz) != 0)
                {
                    Nat.IncAt(14, zz, PExtInv.Length);
                }
            }
        }
Beispiel #3
0
        public static void Reduce(uint[] xx, uint[] z)
        {
            uint num  = xx[32];
            uint num2 = Nat.ShiftDownBits(16, xx, 16, 9, num, z, 0) >> 23;

            num2 += num >> 9;
            num2 += Nat.AddTo(16, xx, z);
            if (num2 > 511 || (num2 == 511 && Nat.Eq(16, z, P)))
            {
                num2 += Nat.Inc(16, z);
                num2 &= 0x1FF;
            }
            z[16] = num2;
        }
        public static void Reduce(uint[] xx, uint[] z)
        {
            uint c    = xx[0x20];
            uint num2 = Nat.ShiftDownBits(0x10, xx, 0x10, 9, c, z, 0) >> 0x17;

            num2 += c >> 9;
            num2 += Nat.AddTo(0x10, xx, z);
            if ((num2 > 0x1ff) || ((num2 == 0x1ff) && Nat.Eq(0x10, z, P)))
            {
                num2 += Nat.Inc(0x10, z);
                num2 &= 0x1ff;
            }
            z[0x10] = num2;
        }
Beispiel #5
0
        public static void Reduce(uint[] xx, uint[] z)
        {
            Debug.Assert(xx[32] >> 18 == 0);
            uint xx32 = xx[32];
            uint c    = Nat.ShiftDownBits(16, xx, 16, 9, xx32, z, 0) >> 23;

            c += xx32 >> 9;
            c += Nat.AddTo(16, xx, z);
            if (c > P16 || (c == P16 && Nat.Eq(16, z, P)))
            {
                c += Nat.Inc(16, z);
                c &= P16;
            }
            z[16] = c;
        }
Beispiel #6
0
    public static void Mul(uint[] x, uint[] y, uint[] zz)
    {
        Nat256.Mul(x, y, zz);
        Nat256.Mul(x, 8, y, 8, zz, 16);
        uint num = Nat256.AddToEachOther(zz, 8, zz, 16);
        uint cIn = num + Nat256.AddTo(zz, 0, zz, 8, 0u);

        num += Nat256.AddTo(zz, 24, zz, 16, cIn);
        uint[] array  = Nat256.Create();
        uint[] array2 = Nat256.Create();
        bool   flag   = Nat256.Diff(x, 8, x, 0, array, 0) != Nat256.Diff(y, 8, y, 0, array2, 0);

        uint[] array3 = Nat256.CreateExt();
        Nat256.Mul(array, array2, array3);
        num = (uint)((int)num + (flag ? ((int)Nat.AddTo(16, array3, 0, zz, 8)) : Nat.SubFrom(16, array3, 0, zz, 8)));
        Nat.AddWordAt(32, num, zz, 24);
    }
Beispiel #7
0
        public static void Mul(uint[] x, uint[] y, uint[] zz)
        {
            Nat192.Mul(x, y, zz);
            Nat192.Mul(x, 6, y, 6, zz, 12);
            uint num = Nat192.AddToEachOther(zz, 6, zz, 12);
            uint cIn = num + Nat192.AddTo(zz, 0, zz, 6, 0u);

            num += Nat192.AddTo(zz, 18, zz, 12, cIn);
            uint[] array  = Nat192.Create();
            uint[] array2 = Nat192.Create();
            bool   flag   = Nat192.Diff(x, 6, x, 0, array, 0) != Nat192.Diff(y, 6, y, 0, array2, 0);

            uint[] array3 = Nat192.CreateExt();
            Nat192.Mul(array, array2, array3);
            num += (uint)(flag ? ((int)Nat.AddTo(12, array3, 0, zz, 6)) : Nat.SubFrom(12, array3, 0, zz, 6));
            Nat.AddWordAt(24, num, zz, 18);
        }
Beispiel #8
0
        public static void Mul(uint[] x, uint[] y, uint[] zz)
        {
            Nat192.Mul(x, y, zz);
            Nat192.Mul(x, 6, y, 6, zz, 12);

            uint c18 = Nat192.AddToEachOther(zz, 6, zz, 12);
            uint c12 = c18 + Nat192.AddTo(zz, 0, zz, 6, 0);

            c18 += Nat192.AddTo(zz, 18, zz, 12, c12);

            uint[] dx  = Nat192.Create(), dy = Nat192.Create();
            bool   neg = Nat192.Diff(x, 6, x, 0, dx, 0) != Nat192.Diff(y, 6, y, 0, dy, 0);

            uint[] tt = Nat192.CreateExt();
            Nat192.Mul(dx, dy, tt);

            c18 += neg ? Nat.AddTo(12, tt, 0, zz, 6) : (uint)Nat.SubFrom(12, tt, 0, zz, 6);
            Nat.AddWordAt(24, c18, zz, 18);
        }
Beispiel #9
0
        public static void Mul(uint[] x, uint[] y, uint[] zz)
        {
            Nat256.Mul(x, y, zz);
            Nat256.Mul(x, 8, y, 8, zz, 16);

            uint c24 = Nat256.AddToEachOther(zz, 8, zz, 16);
            uint c16 = c24 + Nat256.AddTo(zz, 0, zz, 8, 0);

            c24 += Nat256.AddTo(zz, 24, zz, 16, c16);

            uint[] dx  = Nat256.Create(), dy = Nat256.Create();
            bool   neg = Nat256.Diff(x, 8, x, 0, dx, 0) != Nat256.Diff(y, 8, y, 0, dy, 0);

            uint[] tt = Nat256.CreateExt();
            Nat256.Mul(dx, dy, tt);

            c24 += neg ? Nat.AddTo(16, tt, 0, zz, 8) : (uint)Nat.SubFrom(16, tt, 0, zz, 8);
            Nat.AddWordAt(32, c24, zz, 24);
        }
Beispiel #10
0
 public static void MultiplyAddToExt(uint[] x, uint[] y, uint[] zz)
 {
     if (((Nat192.MulAddTo(x, y, zz) != 0) || ((zz[11] == uint.MaxValue) && Nat.Gte(12, zz, PExt))) && (Nat.AddTo(PExtInv.Length, PExtInv, zz) != 0))
     {
         Nat.IncAt(12, zz, PExtInv.Length);
     }
 }
Beispiel #11
0
 public static void AddExt(uint[] xx, uint[] yy, uint[] zz)
 {
     if (((Nat.Add(12, xx, yy, zz) != 0) || ((zz[11] == uint.MaxValue) && Nat.Gte(12, zz, PExt))) && (Nat.AddTo(PExtInv.Length, PExtInv, zz) != 0))
     {
         Nat.IncAt(12, zz, PExtInv.Length);
     }
 }
Beispiel #12
0
 public static void AddExt(uint[] xx, uint[] yy, uint[] zz)
 {
     if ((Nat.Add(10, xx, yy, zz) != 0 || (zz[9] == uint.MaxValue && Nat.Gte(10, zz, PExt))) && Nat.AddTo(PExtInv.Length, PExtInv, zz) != 0)
     {
         Nat.IncAt(10, zz, PExtInv.Length);
     }
 }
Beispiel #13
0
 public static void MultiplyAddToExt(uint[] x, uint[] y, uint[] zz)
 {
     if ((Nat160.MulAddTo(x, y, zz) != 0 || (zz[9] == uint.MaxValue && Nat.Gte(10, zz, PExt))) && Nat.AddTo(PExtInv.Length, PExtInv, zz) != 0)
     {
         Nat.IncAt(10, zz, PExtInv.Length);
     }
 }
Beispiel #14
0
 public static void AddExt(uint[] xx, uint[] yy, uint[] zz)
 {
     if ((Nat.Add(10, xx, yy, zz) != 0u || (zz[9] == 4294967295u && Nat.Gte(10, zz, SecP160R2Field.PExt))) && Nat.AddTo(SecP160R2Field.PExtInv.Length, SecP160R2Field.PExtInv, zz) != 0u)
     {
         Nat.IncAt(10, zz, SecP160R2Field.PExtInv.Length);
     }
 }
 public static void MultiplyAddToExt(uint[] x, uint[] y, uint[] zz)
 {
     if ((Nat192.MulAddTo(x, y, zz) != 0 || (zz[11] == 4294967295u && Nat.Gte(12, zz, PExt))) && Nat.AddTo(PExtInv.Length, PExtInv, zz) != 0)
     {
         Nat.IncAt(12, zz, PExtInv.Length);
     }
 }
 public static void AddExt(uint[] xx, uint[] yy, uint[] zz)
 {
     if ((Nat.Add(12, xx, yy, zz) != 0 || (zz[11] == 4294967295u && Nat.Gte(12, zz, PExt))) && Nat.AddTo(PExtInv.Length, PExtInv, zz) != 0)
     {
         Nat.IncAt(12, zz, PExtInv.Length);
     }
 }
Beispiel #17
0
 public static void MultiplyAddToExt(uint[] x, uint[] y, uint[] zz)
 {
     if ((Nat160.MulAddTo(x, y, zz) != 0u || (zz[9] == 4294967295u && Nat.Gte(10, zz, SecP160R2Field.PExt))) && Nat.AddTo(SecP160R2Field.PExtInv.Length, SecP160R2Field.PExtInv, zz) != 0u)
     {
         Nat.IncAt(10, zz, SecP160R2Field.PExtInv.Length);
     }
 }
 public static void AddExt(uint[] xx, uint[] yy, uint[] zz)
 {
     if ((Nat.Add(24, xx, yy, zz) != 0u || (zz[23] == 4294967295u && Nat.Gte(24, zz, SecP384R1Field.PExt))) && Nat.AddTo(SecP384R1Field.PExtInv.Length, SecP384R1Field.PExtInv, zz) != 0u)
     {
         Nat.IncAt(24, zz, SecP384R1Field.PExtInv.Length);
     }
 }