init commit
This commit is contained in:
@@ -0,0 +1,156 @@
|
||||
namespace Org.BouncyCastle.Math.Raw;
|
||||
|
||||
internal abstract class Interleave
|
||||
{
|
||||
private const ulong M32 = 1431655765uL;
|
||||
|
||||
private const ulong M64 = 6148914691236517205uL;
|
||||
|
||||
private const ulong M64R = 12297829382473034410uL;
|
||||
|
||||
internal static uint Expand8to16(uint x)
|
||||
{
|
||||
x &= 0xFF;
|
||||
x = (x | (x << 4)) & 0xF0F;
|
||||
x = (x | (x << 2)) & 0x3333;
|
||||
x = (x | (x << 1)) & 0x5555;
|
||||
return x;
|
||||
}
|
||||
|
||||
internal static uint Expand16to32(uint x)
|
||||
{
|
||||
x &= 0xFFFF;
|
||||
x = (x | (x << 8)) & 0xFF00FF;
|
||||
x = (x | (x << 4)) & 0xF0F0F0F;
|
||||
x = (x | (x << 2)) & 0x33333333;
|
||||
x = (x | (x << 1)) & 0x55555555;
|
||||
return x;
|
||||
}
|
||||
|
||||
internal static ulong Expand32to64(uint x)
|
||||
{
|
||||
uint num = (x ^ (x >> 8)) & 0xFF00;
|
||||
x ^= num ^ (num << 8);
|
||||
num = (x ^ (x >> 4)) & 0xF000F0;
|
||||
x ^= num ^ (num << 4);
|
||||
num = (x ^ (x >> 2)) & 0xC0C0C0C;
|
||||
x ^= num ^ (num << 2);
|
||||
num = (x ^ (x >> 1)) & 0x22222222;
|
||||
x ^= num ^ (num << 1);
|
||||
return (((ulong)(x >> 1) & 0x55555555uL) << 32) | ((ulong)x & 0x55555555uL);
|
||||
}
|
||||
|
||||
internal static void Expand64To128(ulong x, ulong[] z, int zOff)
|
||||
{
|
||||
ulong num = (x ^ (x >> 16)) & 0xFFFF0000u;
|
||||
x ^= num ^ (num << 16);
|
||||
num = (x ^ (x >> 8)) & 0xFF000000FF00L;
|
||||
x ^= num ^ (num << 8);
|
||||
num = (x ^ (x >> 4)) & 0xF000F000F000F0L;
|
||||
x ^= num ^ (num << 4);
|
||||
num = (x ^ (x >> 2)) & 0xC0C0C0C0C0C0C0CL;
|
||||
x ^= num ^ (num << 2);
|
||||
num = (x ^ (x >> 1)) & 0x2222222222222222L;
|
||||
x ^= num ^ (num << 1);
|
||||
z[zOff] = x & 0x5555555555555555L;
|
||||
z[zOff + 1] = (x >> 1) & 0x5555555555555555L;
|
||||
}
|
||||
|
||||
internal static void Expand64To128Rev(ulong x, ulong[] z, int zOff)
|
||||
{
|
||||
ulong num = (x ^ (x >> 16)) & 0xFFFF0000u;
|
||||
x ^= num ^ (num << 16);
|
||||
num = (x ^ (x >> 8)) & 0xFF000000FF00L;
|
||||
x ^= num ^ (num << 8);
|
||||
num = (x ^ (x >> 4)) & 0xF000F000F000F0L;
|
||||
x ^= num ^ (num << 4);
|
||||
num = (x ^ (x >> 2)) & 0xC0C0C0C0C0C0C0CL;
|
||||
x ^= num ^ (num << 2);
|
||||
num = (x ^ (x >> 1)) & 0x2222222222222222L;
|
||||
x ^= num ^ (num << 1);
|
||||
z[zOff] = x & 0xAAAAAAAAAAAAAAAAuL;
|
||||
z[zOff + 1] = (x << 1) & 0xAAAAAAAAAAAAAAAAuL;
|
||||
}
|
||||
|
||||
internal static uint Shuffle(uint x)
|
||||
{
|
||||
uint num = (x ^ (x >> 8)) & 0xFF00;
|
||||
x ^= num ^ (num << 8);
|
||||
num = (x ^ (x >> 4)) & 0xF000F0;
|
||||
x ^= num ^ (num << 4);
|
||||
num = (x ^ (x >> 2)) & 0xC0C0C0C;
|
||||
x ^= num ^ (num << 2);
|
||||
num = (x ^ (x >> 1)) & 0x22222222;
|
||||
x ^= num ^ (num << 1);
|
||||
return x;
|
||||
}
|
||||
|
||||
internal static ulong Shuffle(ulong x)
|
||||
{
|
||||
ulong num = (x ^ (x >> 16)) & 0xFFFF0000u;
|
||||
x ^= num ^ (num << 16);
|
||||
num = (x ^ (x >> 8)) & 0xFF000000FF00L;
|
||||
x ^= num ^ (num << 8);
|
||||
num = (x ^ (x >> 4)) & 0xF000F000F000F0L;
|
||||
x ^= num ^ (num << 4);
|
||||
num = (x ^ (x >> 2)) & 0xC0C0C0C0C0C0C0CL;
|
||||
x ^= num ^ (num << 2);
|
||||
num = (x ^ (x >> 1)) & 0x2222222222222222L;
|
||||
x ^= num ^ (num << 1);
|
||||
return x;
|
||||
}
|
||||
|
||||
internal static uint Shuffle2(uint x)
|
||||
{
|
||||
uint num = (x ^ (x >> 7)) & 0xAA00AA;
|
||||
x ^= num ^ (num << 7);
|
||||
num = (x ^ (x >> 14)) & 0xCCCC;
|
||||
x ^= num ^ (num << 14);
|
||||
num = (x ^ (x >> 4)) & 0xF000F0;
|
||||
x ^= num ^ (num << 4);
|
||||
num = (x ^ (x >> 8)) & 0xFF00;
|
||||
x ^= num ^ (num << 8);
|
||||
return x;
|
||||
}
|
||||
|
||||
internal static uint Unshuffle(uint x)
|
||||
{
|
||||
uint num = (x ^ (x >> 1)) & 0x22222222;
|
||||
x ^= num ^ (num << 1);
|
||||
num = (x ^ (x >> 2)) & 0xC0C0C0C;
|
||||
x ^= num ^ (num << 2);
|
||||
num = (x ^ (x >> 4)) & 0xF000F0;
|
||||
x ^= num ^ (num << 4);
|
||||
num = (x ^ (x >> 8)) & 0xFF00;
|
||||
x ^= num ^ (num << 8);
|
||||
return x;
|
||||
}
|
||||
|
||||
internal static ulong Unshuffle(ulong x)
|
||||
{
|
||||
ulong num = (x ^ (x >> 1)) & 0x2222222222222222L;
|
||||
x ^= num ^ (num << 1);
|
||||
num = (x ^ (x >> 2)) & 0xC0C0C0C0C0C0C0CL;
|
||||
x ^= num ^ (num << 2);
|
||||
num = (x ^ (x >> 4)) & 0xF000F000F000F0L;
|
||||
x ^= num ^ (num << 4);
|
||||
num = (x ^ (x >> 8)) & 0xFF000000FF00L;
|
||||
x ^= num ^ (num << 8);
|
||||
num = (x ^ (x >> 16)) & 0xFFFF0000u;
|
||||
x ^= num ^ (num << 16);
|
||||
return x;
|
||||
}
|
||||
|
||||
internal static uint Unshuffle2(uint x)
|
||||
{
|
||||
uint num = (x ^ (x >> 8)) & 0xFF00;
|
||||
x ^= num ^ (num << 8);
|
||||
num = (x ^ (x >> 4)) & 0xF000F0;
|
||||
x ^= num ^ (num << 4);
|
||||
num = (x ^ (x >> 14)) & 0xCCCC;
|
||||
x ^= num ^ (num << 14);
|
||||
num = (x ^ (x >> 7)) & 0xAA00AA;
|
||||
x ^= num ^ (num << 7);
|
||||
return x;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,168 @@
|
||||
using System;
|
||||
using Org.BouncyCastle.Crypto.Utilities;
|
||||
using Org.BouncyCastle.Security;
|
||||
|
||||
namespace Org.BouncyCastle.Math.Raw;
|
||||
|
||||
internal abstract class Mod
|
||||
{
|
||||
private static readonly SecureRandom RandomSource = new SecureRandom();
|
||||
|
||||
public static void Invert(uint[] p, uint[] x, uint[] z)
|
||||
{
|
||||
int num = p.Length;
|
||||
if (Nat.IsZero(num, x))
|
||||
{
|
||||
throw new ArgumentException("cannot be 0", "x");
|
||||
}
|
||||
if (Nat.IsOne(num, x))
|
||||
{
|
||||
Array.Copy(x, 0, z, 0, num);
|
||||
return;
|
||||
}
|
||||
uint[] array = Nat.Copy(num, x);
|
||||
uint[] array2 = Nat.Create(num);
|
||||
array2[0] = 1u;
|
||||
int xc = 0;
|
||||
if ((array[0] & 1) == 0)
|
||||
{
|
||||
InversionStep(p, array, num, array2, ref xc);
|
||||
}
|
||||
if (Nat.IsOne(num, array))
|
||||
{
|
||||
InversionResult(p, xc, array2, z);
|
||||
return;
|
||||
}
|
||||
uint[] array3 = Nat.Copy(num, p);
|
||||
uint[] array4 = Nat.Create(num);
|
||||
int xc2 = 0;
|
||||
int num2 = num;
|
||||
while (true)
|
||||
{
|
||||
if (array[num2 - 1] == 0 && array3[num2 - 1] == 0)
|
||||
{
|
||||
num2--;
|
||||
}
|
||||
else if (Nat.Gte(num, array, array3))
|
||||
{
|
||||
Nat.SubFrom(num, array3, array);
|
||||
xc += Nat.SubFrom(num, array4, array2) - xc2;
|
||||
InversionStep(p, array, num2, array2, ref xc);
|
||||
if (Nat.IsOne(num, array))
|
||||
{
|
||||
InversionResult(p, xc, array2, z);
|
||||
return;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
Nat.SubFrom(num, array, array3);
|
||||
xc2 += Nat.SubFrom(num, array2, array4) - xc;
|
||||
InversionStep(p, array3, num2, array4, ref xc2);
|
||||
if (Nat.IsOne(num, array3))
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
InversionResult(p, xc2, array4, z);
|
||||
}
|
||||
|
||||
public static uint[] Random(uint[] p)
|
||||
{
|
||||
int num = p.Length;
|
||||
uint[] array = Nat.Create(num);
|
||||
uint num2 = p[num - 1];
|
||||
num2 |= num2 >> 1;
|
||||
num2 |= num2 >> 2;
|
||||
num2 |= num2 >> 4;
|
||||
num2 |= num2 >> 8;
|
||||
num2 |= num2 >> 16;
|
||||
do
|
||||
{
|
||||
byte[] array2 = new byte[num << 2];
|
||||
RandomSource.NextBytes(array2);
|
||||
Pack.BE_To_UInt32(array2, 0, array);
|
||||
uint[] array4;
|
||||
uint[] array3 = (array4 = array);
|
||||
int num3 = num - 1;
|
||||
nint num4 = num3;
|
||||
array3[num3] = array4[num4] & num2;
|
||||
}
|
||||
while (Nat.Gte(num, array, p));
|
||||
return array;
|
||||
}
|
||||
|
||||
public static void Add(uint[] p, uint[] x, uint[] y, uint[] z)
|
||||
{
|
||||
int len = p.Length;
|
||||
if (Nat.Add(len, x, y, z) != 0)
|
||||
{
|
||||
Nat.SubFrom(len, p, z);
|
||||
}
|
||||
}
|
||||
|
||||
public static void Subtract(uint[] p, uint[] x, uint[] y, uint[] z)
|
||||
{
|
||||
int len = p.Length;
|
||||
if (Nat.Sub(len, x, y, z) != 0)
|
||||
{
|
||||
Nat.AddTo(len, p, z);
|
||||
}
|
||||
}
|
||||
|
||||
private static void InversionResult(uint[] p, int ac, uint[] a, uint[] z)
|
||||
{
|
||||
if (ac < 0)
|
||||
{
|
||||
Nat.Add(p.Length, a, p, z);
|
||||
}
|
||||
else
|
||||
{
|
||||
Array.Copy(a, 0, z, 0, p.Length);
|
||||
}
|
||||
}
|
||||
|
||||
private static void InversionStep(uint[] p, uint[] u, int uLen, uint[] x, ref int xc)
|
||||
{
|
||||
int len = p.Length;
|
||||
int num = 0;
|
||||
while (u[0] == 0)
|
||||
{
|
||||
Nat.ShiftDownWord(uLen, u, 0u);
|
||||
num += 32;
|
||||
}
|
||||
int trailingZeroes = GetTrailingZeroes(u[0]);
|
||||
if (trailingZeroes > 0)
|
||||
{
|
||||
Nat.ShiftDownBits(uLen, u, trailingZeroes, 0u);
|
||||
num += trailingZeroes;
|
||||
}
|
||||
for (int i = 0; i < num; i++)
|
||||
{
|
||||
if ((x[0] & 1) != 0)
|
||||
{
|
||||
if (xc < 0)
|
||||
{
|
||||
xc += (int)Nat.AddTo(len, p, x);
|
||||
}
|
||||
else
|
||||
{
|
||||
xc += Nat.SubFrom(len, p, x);
|
||||
}
|
||||
}
|
||||
Nat.ShiftDownBit(len, x, (uint)xc);
|
||||
}
|
||||
}
|
||||
|
||||
private static int GetTrailingZeroes(uint x)
|
||||
{
|
||||
int num = 0;
|
||||
while ((x & 1) == 0)
|
||||
{
|
||||
x >>= 1;
|
||||
num++;
|
||||
}
|
||||
return num;
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,856 @@
|
||||
using System;
|
||||
using Org.BouncyCastle.Crypto.Utilities;
|
||||
|
||||
namespace Org.BouncyCastle.Math.Raw;
|
||||
|
||||
internal abstract class Nat128
|
||||
{
|
||||
private const ulong M = 4294967295uL;
|
||||
|
||||
public static uint Add(uint[] x, uint[] y, uint[] z)
|
||||
{
|
||||
ulong num = 0uL;
|
||||
num += (ulong)((long)x[0] + (long)y[0]);
|
||||
z[0] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[1] + (long)y[1]);
|
||||
z[1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[2] + (long)y[2]);
|
||||
z[2] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[3] + (long)y[3]);
|
||||
z[3] = (uint)num;
|
||||
num >>= 32;
|
||||
return (uint)num;
|
||||
}
|
||||
|
||||
public static uint AddBothTo(uint[] x, uint[] y, uint[] z)
|
||||
{
|
||||
ulong num = 0uL;
|
||||
num += (ulong)((long)x[0] + (long)y[0] + z[0]);
|
||||
z[0] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[1] + (long)y[1] + z[1]);
|
||||
z[1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[2] + (long)y[2] + z[2]);
|
||||
z[2] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[3] + (long)y[3] + z[3]);
|
||||
z[3] = (uint)num;
|
||||
num >>= 32;
|
||||
return (uint)num;
|
||||
}
|
||||
|
||||
public static uint AddTo(uint[] x, uint[] z)
|
||||
{
|
||||
ulong num = 0uL;
|
||||
num += (ulong)((long)x[0] + (long)z[0]);
|
||||
z[0] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[1] + (long)z[1]);
|
||||
z[1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[2] + (long)z[2]);
|
||||
z[2] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[3] + (long)z[3]);
|
||||
z[3] = (uint)num;
|
||||
num >>= 32;
|
||||
return (uint)num;
|
||||
}
|
||||
|
||||
public static uint AddTo(uint[] x, int xOff, uint[] z, int zOff, uint cIn)
|
||||
{
|
||||
ulong num = cIn;
|
||||
num += (ulong)((long)x[xOff] + (long)z[zOff]);
|
||||
z[zOff] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[xOff + 1] + (long)z[zOff + 1]);
|
||||
z[zOff + 1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[xOff + 2] + (long)z[zOff + 2]);
|
||||
z[zOff + 2] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[xOff + 3] + (long)z[zOff + 3]);
|
||||
z[zOff + 3] = (uint)num;
|
||||
num >>= 32;
|
||||
return (uint)num;
|
||||
}
|
||||
|
||||
public static uint AddToEachOther(uint[] u, int uOff, uint[] v, int vOff)
|
||||
{
|
||||
ulong num = 0uL;
|
||||
num += (ulong)((long)u[uOff] + (long)v[vOff]);
|
||||
u[uOff] = (uint)num;
|
||||
v[vOff] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)u[uOff + 1] + (long)v[vOff + 1]);
|
||||
u[uOff + 1] = (uint)num;
|
||||
v[vOff + 1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)u[uOff + 2] + (long)v[vOff + 2]);
|
||||
u[uOff + 2] = (uint)num;
|
||||
v[vOff + 2] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)u[uOff + 3] + (long)v[vOff + 3]);
|
||||
u[uOff + 3] = (uint)num;
|
||||
v[vOff + 3] = (uint)num;
|
||||
num >>= 32;
|
||||
return (uint)num;
|
||||
}
|
||||
|
||||
public static void Copy(uint[] x, uint[] z)
|
||||
{
|
||||
z[0] = x[0];
|
||||
z[1] = x[1];
|
||||
z[2] = x[2];
|
||||
z[3] = x[3];
|
||||
}
|
||||
|
||||
public static void Copy(uint[] x, int xOff, uint[] z, int zOff)
|
||||
{
|
||||
z[zOff] = x[xOff];
|
||||
z[zOff + 1] = x[xOff + 1];
|
||||
z[zOff + 2] = x[xOff + 2];
|
||||
z[zOff + 3] = x[xOff + 3];
|
||||
}
|
||||
|
||||
public static void Copy64(ulong[] x, ulong[] z)
|
||||
{
|
||||
z[0] = x[0];
|
||||
z[1] = x[1];
|
||||
}
|
||||
|
||||
public static void Copy64(ulong[] x, int xOff, ulong[] z, int zOff)
|
||||
{
|
||||
z[zOff] = x[xOff];
|
||||
z[zOff + 1] = x[xOff + 1];
|
||||
}
|
||||
|
||||
public static uint[] Create()
|
||||
{
|
||||
return new uint[4];
|
||||
}
|
||||
|
||||
public static ulong[] Create64()
|
||||
{
|
||||
return new ulong[2];
|
||||
}
|
||||
|
||||
public static uint[] CreateExt()
|
||||
{
|
||||
return new uint[8];
|
||||
}
|
||||
|
||||
public static ulong[] CreateExt64()
|
||||
{
|
||||
return new ulong[4];
|
||||
}
|
||||
|
||||
public static bool Diff(uint[] x, int xOff, uint[] y, int yOff, uint[] z, int zOff)
|
||||
{
|
||||
bool flag = Gte(x, xOff, y, yOff);
|
||||
if (flag)
|
||||
{
|
||||
Sub(x, xOff, y, yOff, z, zOff);
|
||||
}
|
||||
else
|
||||
{
|
||||
Sub(y, yOff, x, xOff, z, zOff);
|
||||
}
|
||||
return flag;
|
||||
}
|
||||
|
||||
public static bool Eq(uint[] x, uint[] y)
|
||||
{
|
||||
for (int num = 3; num >= 0; num--)
|
||||
{
|
||||
if (x[num] != y[num])
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static bool Eq64(ulong[] x, ulong[] y)
|
||||
{
|
||||
for (int num = 1; num >= 0; num--)
|
||||
{
|
||||
if (x[num] != y[num])
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static uint[] FromBigInteger(BigInteger x)
|
||||
{
|
||||
if (x.SignValue < 0 || x.BitLength > 128)
|
||||
{
|
||||
throw new ArgumentException();
|
||||
}
|
||||
uint[] array = Create();
|
||||
int num = 0;
|
||||
while (x.SignValue != 0)
|
||||
{
|
||||
array[num++] = (uint)x.IntValue;
|
||||
x = x.ShiftRight(32);
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
public static ulong[] FromBigInteger64(BigInteger x)
|
||||
{
|
||||
if (x.SignValue < 0 || x.BitLength > 128)
|
||||
{
|
||||
throw new ArgumentException();
|
||||
}
|
||||
ulong[] array = Create64();
|
||||
int num = 0;
|
||||
while (x.SignValue != 0)
|
||||
{
|
||||
array[num++] = (ulong)x.LongValue;
|
||||
x = x.ShiftRight(64);
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
public static uint GetBit(uint[] x, int bit)
|
||||
{
|
||||
if (bit == 0)
|
||||
{
|
||||
return x[0] & 1;
|
||||
}
|
||||
if ((bit & 0x7F) != bit)
|
||||
{
|
||||
return 0u;
|
||||
}
|
||||
int num = bit >> 5;
|
||||
int num2 = bit & 0x1F;
|
||||
return (x[num] >> num2) & 1;
|
||||
}
|
||||
|
||||
public static bool Gte(uint[] x, uint[] y)
|
||||
{
|
||||
for (int num = 3; num >= 0; num--)
|
||||
{
|
||||
uint num2 = x[num];
|
||||
uint num3 = y[num];
|
||||
if (num2 < num3)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (num2 > num3)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static bool Gte(uint[] x, int xOff, uint[] y, int yOff)
|
||||
{
|
||||
for (int num = 3; num >= 0; num--)
|
||||
{
|
||||
uint num2 = x[xOff + num];
|
||||
uint num3 = y[yOff + num];
|
||||
if (num2 < num3)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (num2 > num3)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static bool IsOne(uint[] x)
|
||||
{
|
||||
if (x[0] != 1)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
for (int i = 1; i < 4; i++)
|
||||
{
|
||||
if (x[i] != 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static bool IsOne64(ulong[] x)
|
||||
{
|
||||
if (x[0] != 1)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
for (int i = 1; i < 2; i++)
|
||||
{
|
||||
if (x[i] != 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static bool IsZero(uint[] x)
|
||||
{
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
if (x[i] != 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static bool IsZero64(ulong[] x)
|
||||
{
|
||||
for (int i = 0; i < 2; i++)
|
||||
{
|
||||
if (x[i] != 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static void Mul(uint[] x, uint[] y, uint[] zz)
|
||||
{
|
||||
ulong num = y[0];
|
||||
ulong num2 = y[1];
|
||||
ulong num3 = y[2];
|
||||
ulong num4 = y[3];
|
||||
ulong num5 = 0uL;
|
||||
ulong num6 = x[0];
|
||||
num5 += num6 * num;
|
||||
zz[0] = (uint)num5;
|
||||
num5 >>= 32;
|
||||
num5 += num6 * num2;
|
||||
zz[1] = (uint)num5;
|
||||
num5 >>= 32;
|
||||
num5 += num6 * num3;
|
||||
zz[2] = (uint)num5;
|
||||
num5 >>= 32;
|
||||
num5 += num6 * num4;
|
||||
zz[3] = (uint)num5;
|
||||
num5 >>= 32;
|
||||
zz[4] = (uint)num5;
|
||||
for (int i = 1; i < 4; i++)
|
||||
{
|
||||
ulong num7 = 0uL;
|
||||
ulong num8 = x[i];
|
||||
num7 += num8 * num + zz[i];
|
||||
zz[i] = (uint)num7;
|
||||
num7 >>= 32;
|
||||
num7 += num8 * num2 + zz[i + 1];
|
||||
zz[i + 1] = (uint)num7;
|
||||
num7 >>= 32;
|
||||
num7 += num8 * num3 + zz[i + 2];
|
||||
zz[i + 2] = (uint)num7;
|
||||
num7 >>= 32;
|
||||
num7 += num8 * num4 + zz[i + 3];
|
||||
zz[i + 3] = (uint)num7;
|
||||
num7 >>= 32;
|
||||
zz[i + 4] = (uint)num7;
|
||||
}
|
||||
}
|
||||
|
||||
public static void Mul(uint[] x, int xOff, uint[] y, int yOff, uint[] zz, int zzOff)
|
||||
{
|
||||
ulong num = y[yOff];
|
||||
ulong num2 = y[yOff + 1];
|
||||
ulong num3 = y[yOff + 2];
|
||||
ulong num4 = y[yOff + 3];
|
||||
ulong num5 = 0uL;
|
||||
ulong num6 = x[xOff];
|
||||
num5 += num6 * num;
|
||||
zz[zzOff] = (uint)num5;
|
||||
num5 >>= 32;
|
||||
num5 += num6 * num2;
|
||||
zz[zzOff + 1] = (uint)num5;
|
||||
num5 >>= 32;
|
||||
num5 += num6 * num3;
|
||||
zz[zzOff + 2] = (uint)num5;
|
||||
num5 >>= 32;
|
||||
num5 += num6 * num4;
|
||||
zz[zzOff + 3] = (uint)num5;
|
||||
num5 >>= 32;
|
||||
zz[zzOff + 4] = (uint)num5;
|
||||
for (int i = 1; i < 4; i++)
|
||||
{
|
||||
zzOff++;
|
||||
ulong num7 = 0uL;
|
||||
ulong num8 = x[xOff + i];
|
||||
num7 += num8 * num + zz[zzOff];
|
||||
zz[zzOff] = (uint)num7;
|
||||
num7 >>= 32;
|
||||
num7 += num8 * num2 + zz[zzOff + 1];
|
||||
zz[zzOff + 1] = (uint)num7;
|
||||
num7 >>= 32;
|
||||
num7 += num8 * num3 + zz[zzOff + 2];
|
||||
zz[zzOff + 2] = (uint)num7;
|
||||
num7 >>= 32;
|
||||
num7 += num8 * num4 + zz[zzOff + 3];
|
||||
zz[zzOff + 3] = (uint)num7;
|
||||
num7 >>= 32;
|
||||
zz[zzOff + 4] = (uint)num7;
|
||||
}
|
||||
}
|
||||
|
||||
public static uint MulAddTo(uint[] x, uint[] y, uint[] zz)
|
||||
{
|
||||
ulong num = y[0];
|
||||
ulong num2 = y[1];
|
||||
ulong num3 = y[2];
|
||||
ulong num4 = y[3];
|
||||
ulong num5 = 0uL;
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
ulong num6 = 0uL;
|
||||
ulong num7 = x[i];
|
||||
num6 += num7 * num + zz[i];
|
||||
zz[i] = (uint)num6;
|
||||
num6 >>= 32;
|
||||
num6 += num7 * num2 + zz[i + 1];
|
||||
zz[i + 1] = (uint)num6;
|
||||
num6 >>= 32;
|
||||
num6 += num7 * num3 + zz[i + 2];
|
||||
zz[i + 2] = (uint)num6;
|
||||
num6 >>= 32;
|
||||
num6 += num7 * num4 + zz[i + 3];
|
||||
zz[i + 3] = (uint)num6;
|
||||
num6 >>= 32;
|
||||
num6 += num5 + zz[i + 4];
|
||||
zz[i + 4] = (uint)num6;
|
||||
num5 = num6 >> 32;
|
||||
}
|
||||
return (uint)num5;
|
||||
}
|
||||
|
||||
public static uint MulAddTo(uint[] x, int xOff, uint[] y, int yOff, uint[] zz, int zzOff)
|
||||
{
|
||||
ulong num = y[yOff];
|
||||
ulong num2 = y[yOff + 1];
|
||||
ulong num3 = y[yOff + 2];
|
||||
ulong num4 = y[yOff + 3];
|
||||
ulong num5 = 0uL;
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
ulong num6 = 0uL;
|
||||
ulong num7 = x[xOff + i];
|
||||
num6 += num7 * num + zz[zzOff];
|
||||
zz[zzOff] = (uint)num6;
|
||||
num6 >>= 32;
|
||||
num6 += num7 * num2 + zz[zzOff + 1];
|
||||
zz[zzOff + 1] = (uint)num6;
|
||||
num6 >>= 32;
|
||||
num6 += num7 * num3 + zz[zzOff + 2];
|
||||
zz[zzOff + 2] = (uint)num6;
|
||||
num6 >>= 32;
|
||||
num6 += num7 * num4 + zz[zzOff + 3];
|
||||
zz[zzOff + 3] = (uint)num6;
|
||||
num6 >>= 32;
|
||||
num6 += num5 + zz[zzOff + 4];
|
||||
zz[zzOff + 4] = (uint)num6;
|
||||
num5 = num6 >> 32;
|
||||
zzOff++;
|
||||
}
|
||||
return (uint)num5;
|
||||
}
|
||||
|
||||
public static ulong Mul33Add(uint w, uint[] x, int xOff, uint[] y, int yOff, uint[] z, int zOff)
|
||||
{
|
||||
ulong num = 0uL;
|
||||
ulong num2 = w;
|
||||
ulong num3 = x[xOff];
|
||||
num += num2 * num3 + y[yOff];
|
||||
z[zOff] = (uint)num;
|
||||
num >>= 32;
|
||||
ulong num4 = x[xOff + 1];
|
||||
num += num2 * num4 + num3 + y[yOff + 1];
|
||||
z[zOff + 1] = (uint)num;
|
||||
num >>= 32;
|
||||
ulong num5 = x[xOff + 2];
|
||||
num += num2 * num5 + num4 + y[yOff + 2];
|
||||
z[zOff + 2] = (uint)num;
|
||||
num >>= 32;
|
||||
ulong num6 = x[xOff + 3];
|
||||
num += num2 * num6 + num5 + y[yOff + 3];
|
||||
z[zOff + 3] = (uint)num;
|
||||
num >>= 32;
|
||||
return num + num6;
|
||||
}
|
||||
|
||||
public static uint MulWordAddExt(uint x, uint[] yy, int yyOff, uint[] zz, int zzOff)
|
||||
{
|
||||
ulong num = 0uL;
|
||||
ulong num2 = x;
|
||||
num += num2 * yy[yyOff] + zz[zzOff];
|
||||
zz[zzOff] = (uint)num;
|
||||
num >>= 32;
|
||||
num += num2 * yy[yyOff + 1] + zz[zzOff + 1];
|
||||
zz[zzOff + 1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += num2 * yy[yyOff + 2] + zz[zzOff + 2];
|
||||
zz[zzOff + 2] = (uint)num;
|
||||
num >>= 32;
|
||||
num += num2 * yy[yyOff + 3] + zz[zzOff + 3];
|
||||
zz[zzOff + 3] = (uint)num;
|
||||
num >>= 32;
|
||||
return (uint)num;
|
||||
}
|
||||
|
||||
public static uint Mul33DWordAdd(uint x, ulong y, uint[] z, int zOff)
|
||||
{
|
||||
ulong num = 0uL;
|
||||
ulong num2 = x;
|
||||
ulong num3 = y & 0xFFFFFFFFu;
|
||||
num += num2 * num3 + z[zOff];
|
||||
z[zOff] = (uint)num;
|
||||
num >>= 32;
|
||||
ulong num4 = y >> 32;
|
||||
num += num2 * num4 + num3 + z[zOff + 1];
|
||||
z[zOff + 1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += num4 + z[zOff + 2];
|
||||
z[zOff + 2] = (uint)num;
|
||||
num >>= 32;
|
||||
num += z[zOff + 3];
|
||||
z[zOff + 3] = (uint)num;
|
||||
num >>= 32;
|
||||
return (uint)num;
|
||||
}
|
||||
|
||||
public static uint Mul33WordAdd(uint x, uint y, uint[] z, int zOff)
|
||||
{
|
||||
ulong num = 0uL;
|
||||
ulong num2 = y;
|
||||
num += num2 * x + z[zOff];
|
||||
z[zOff] = (uint)num;
|
||||
num >>= 32;
|
||||
num += num2 + z[zOff + 1];
|
||||
z[zOff + 1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += z[zOff + 2];
|
||||
z[zOff + 2] = (uint)num;
|
||||
num >>= 32;
|
||||
if (num != 0)
|
||||
{
|
||||
return Nat.IncAt(4, z, zOff, 3);
|
||||
}
|
||||
return 0u;
|
||||
}
|
||||
|
||||
public static uint MulWordDwordAdd(uint x, ulong y, uint[] z, int zOff)
|
||||
{
|
||||
ulong num = 0uL;
|
||||
ulong num2 = x;
|
||||
num += num2 * y + z[zOff];
|
||||
z[zOff] = (uint)num;
|
||||
num >>= 32;
|
||||
num += num2 * (y >> 32) + z[zOff + 1];
|
||||
z[zOff + 1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += z[zOff + 2];
|
||||
z[zOff + 2] = (uint)num;
|
||||
num >>= 32;
|
||||
if (num != 0)
|
||||
{
|
||||
return Nat.IncAt(4, z, zOff, 3);
|
||||
}
|
||||
return 0u;
|
||||
}
|
||||
|
||||
public static uint MulWordsAdd(uint x, uint y, uint[] z, int zOff)
|
||||
{
|
||||
ulong num = 0uL;
|
||||
ulong num2 = x;
|
||||
ulong num3 = y;
|
||||
num += num3 * num2 + z[zOff];
|
||||
z[zOff] = (uint)num;
|
||||
num >>= 32;
|
||||
num += z[zOff + 1];
|
||||
z[zOff + 1] = (uint)num;
|
||||
num >>= 32;
|
||||
if (num != 0)
|
||||
{
|
||||
return Nat.IncAt(4, z, zOff, 2);
|
||||
}
|
||||
return 0u;
|
||||
}
|
||||
|
||||
public static uint MulWord(uint x, uint[] y, uint[] z, int zOff)
|
||||
{
|
||||
ulong num = 0uL;
|
||||
ulong num2 = x;
|
||||
int num3 = 0;
|
||||
do
|
||||
{
|
||||
num += num2 * y[num3];
|
||||
z[zOff + num3] = (uint)num;
|
||||
num >>= 32;
|
||||
}
|
||||
while (++num3 < 4);
|
||||
return (uint)num;
|
||||
}
|
||||
|
||||
public static void Square(uint[] x, uint[] zz)
|
||||
{
|
||||
ulong num = x[0];
|
||||
uint num2 = 0u;
|
||||
int num3 = 3;
|
||||
int num4 = 8;
|
||||
do
|
||||
{
|
||||
ulong num5 = x[num3--];
|
||||
ulong num6 = num5 * num5;
|
||||
zz[--num4] = (num2 << 31) | (uint)(int)(num6 >> 33);
|
||||
zz[--num4] = (uint)(num6 >> 1);
|
||||
num2 = (uint)num6;
|
||||
}
|
||||
while (num3 > 0);
|
||||
ulong num7 = num * num;
|
||||
ulong num8 = (num2 << 31) | (num7 >> 33);
|
||||
zz[0] = (uint)num7;
|
||||
num2 = (uint)((int)(num7 >> 32) & 1);
|
||||
ulong num9 = x[1];
|
||||
ulong num10 = zz[2];
|
||||
num8 += num9 * num;
|
||||
uint num11 = (uint)num8;
|
||||
zz[1] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num10 += num8 >> 32;
|
||||
ulong num12 = x[2];
|
||||
ulong num13 = zz[3];
|
||||
ulong num14 = zz[4];
|
||||
num10 += num12 * num;
|
||||
num11 = (uint)num10;
|
||||
zz[2] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num13 += (num10 >> 32) + num12 * num9;
|
||||
num14 += num13 >> 32;
|
||||
num13 &= 0xFFFFFFFFu;
|
||||
ulong num15 = x[3];
|
||||
ulong num16 = zz[5] + (num14 >> 32);
|
||||
num14 &= 0xFFFFFFFFu;
|
||||
ulong num17 = zz[6] + (num16 >> 32);
|
||||
num16 &= 0xFFFFFFFFu;
|
||||
num13 += num15 * num;
|
||||
num11 = (uint)num13;
|
||||
zz[3] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num14 += (num13 >> 32) + num15 * num9;
|
||||
num16 += (num14 >> 32) + num15 * num12;
|
||||
num17 += num16 >> 32;
|
||||
num11 = (uint)num14;
|
||||
zz[4] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num11 = (uint)num16;
|
||||
zz[5] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num11 = (uint)num17;
|
||||
zz[6] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num11 = zz[7] + (uint)(int)(num17 >> 32);
|
||||
zz[7] = (num11 << 1) | num2;
|
||||
}
|
||||
|
||||
public static void Square(uint[] x, int xOff, uint[] zz, int zzOff)
|
||||
{
|
||||
ulong num = x[xOff];
|
||||
uint num2 = 0u;
|
||||
int num3 = 3;
|
||||
int num4 = 8;
|
||||
do
|
||||
{
|
||||
ulong num5 = x[xOff + num3--];
|
||||
ulong num6 = num5 * num5;
|
||||
zz[zzOff + --num4] = (num2 << 31) | (uint)(int)(num6 >> 33);
|
||||
zz[zzOff + --num4] = (uint)(num6 >> 1);
|
||||
num2 = (uint)num6;
|
||||
}
|
||||
while (num3 > 0);
|
||||
ulong num7 = num * num;
|
||||
ulong num8 = (num2 << 31) | (num7 >> 33);
|
||||
zz[zzOff] = (uint)num7;
|
||||
num2 = (uint)((int)(num7 >> 32) & 1);
|
||||
ulong num9 = x[xOff + 1];
|
||||
ulong num10 = zz[zzOff + 2];
|
||||
num8 += num9 * num;
|
||||
uint num11 = (uint)num8;
|
||||
zz[zzOff + 1] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num10 += num8 >> 32;
|
||||
ulong num12 = x[xOff + 2];
|
||||
ulong num13 = zz[zzOff + 3];
|
||||
ulong num14 = zz[zzOff + 4];
|
||||
num10 += num12 * num;
|
||||
num11 = (uint)num10;
|
||||
zz[zzOff + 2] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num13 += (num10 >> 32) + num12 * num9;
|
||||
num14 += num13 >> 32;
|
||||
num13 &= 0xFFFFFFFFu;
|
||||
ulong num15 = x[xOff + 3];
|
||||
ulong num16 = zz[zzOff + 5] + (num14 >> 32);
|
||||
num14 &= 0xFFFFFFFFu;
|
||||
ulong num17 = zz[zzOff + 6] + (num16 >> 32);
|
||||
num16 &= 0xFFFFFFFFu;
|
||||
num13 += num15 * num;
|
||||
num11 = (uint)num13;
|
||||
zz[zzOff + 3] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num14 += (num13 >> 32) + num15 * num9;
|
||||
num16 += (num14 >> 32) + num15 * num12;
|
||||
num17 += num16 >> 32;
|
||||
num11 = (uint)num14;
|
||||
zz[zzOff + 4] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num11 = (uint)num16;
|
||||
zz[zzOff + 5] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num11 = (uint)num17;
|
||||
zz[zzOff + 6] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num11 = zz[zzOff + 7] + (uint)(int)(num17 >> 32);
|
||||
zz[zzOff + 7] = (num11 << 1) | num2;
|
||||
}
|
||||
|
||||
public static int Sub(uint[] x, uint[] y, uint[] z)
|
||||
{
|
||||
long num = 0L;
|
||||
num += (long)x[0] - (long)y[0];
|
||||
z[0] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)x[1] - (long)y[1];
|
||||
z[1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)x[2] - (long)y[2];
|
||||
z[2] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)x[3] - (long)y[3];
|
||||
z[3] = (uint)num;
|
||||
num >>= 32;
|
||||
return (int)num;
|
||||
}
|
||||
|
||||
public static int Sub(uint[] x, int xOff, uint[] y, int yOff, uint[] z, int zOff)
|
||||
{
|
||||
long num = 0L;
|
||||
num += (long)x[xOff] - (long)y[yOff];
|
||||
z[zOff] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)x[xOff + 1] - (long)y[yOff + 1];
|
||||
z[zOff + 1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)x[xOff + 2] - (long)y[yOff + 2];
|
||||
z[zOff + 2] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)x[xOff + 3] - (long)y[yOff + 3];
|
||||
z[zOff + 3] = (uint)num;
|
||||
num >>= 32;
|
||||
return (int)num;
|
||||
}
|
||||
|
||||
public static int SubBothFrom(uint[] x, uint[] y, uint[] z)
|
||||
{
|
||||
long num = 0L;
|
||||
num += (long)z[0] - (long)x[0] - y[0];
|
||||
z[0] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)z[1] - (long)x[1] - y[1];
|
||||
z[1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)z[2] - (long)x[2] - y[2];
|
||||
z[2] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)z[3] - (long)x[3] - y[3];
|
||||
z[3] = (uint)num;
|
||||
num >>= 32;
|
||||
return (int)num;
|
||||
}
|
||||
|
||||
public static int SubFrom(uint[] x, uint[] z)
|
||||
{
|
||||
long num = 0L;
|
||||
num += (long)z[0] - (long)x[0];
|
||||
z[0] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)z[1] - (long)x[1];
|
||||
z[1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)z[2] - (long)x[2];
|
||||
z[2] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)z[3] - (long)x[3];
|
||||
z[3] = (uint)num;
|
||||
num >>= 32;
|
||||
return (int)num;
|
||||
}
|
||||
|
||||
public static int SubFrom(uint[] x, int xOff, uint[] z, int zOff)
|
||||
{
|
||||
long num = 0L;
|
||||
num += (long)z[zOff] - (long)x[xOff];
|
||||
z[zOff] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)z[zOff + 1] - (long)x[xOff + 1];
|
||||
z[zOff + 1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)z[zOff + 2] - (long)x[xOff + 2];
|
||||
z[zOff + 2] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)z[zOff + 3] - (long)x[xOff + 3];
|
||||
z[zOff + 3] = (uint)num;
|
||||
num >>= 32;
|
||||
return (int)num;
|
||||
}
|
||||
|
||||
public static BigInteger ToBigInteger(uint[] x)
|
||||
{
|
||||
byte[] array = new byte[16];
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
uint num = x[i];
|
||||
if (num != 0)
|
||||
{
|
||||
Pack.UInt32_To_BE(num, array, 3 - i << 2);
|
||||
}
|
||||
}
|
||||
return new BigInteger(1, array);
|
||||
}
|
||||
|
||||
public static BigInteger ToBigInteger64(ulong[] x)
|
||||
{
|
||||
byte[] array = new byte[16];
|
||||
for (int i = 0; i < 2; i++)
|
||||
{
|
||||
ulong num = x[i];
|
||||
if (num != 0)
|
||||
{
|
||||
Pack.UInt64_To_BE(num, array, 1 - i << 3);
|
||||
}
|
||||
}
|
||||
return new BigInteger(1, array);
|
||||
}
|
||||
|
||||
public static void Zero(uint[] z)
|
||||
{
|
||||
z[0] = 0u;
|
||||
z[1] = 0u;
|
||||
z[2] = 0u;
|
||||
z[3] = 0u;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,868 @@
|
||||
using System;
|
||||
using Org.BouncyCastle.Crypto.Utilities;
|
||||
|
||||
namespace Org.BouncyCastle.Math.Raw;
|
||||
|
||||
internal abstract class Nat160
|
||||
{
|
||||
private const ulong M = 4294967295uL;
|
||||
|
||||
public static uint Add(uint[] x, uint[] y, uint[] z)
|
||||
{
|
||||
ulong num = 0uL;
|
||||
num += (ulong)((long)x[0] + (long)y[0]);
|
||||
z[0] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[1] + (long)y[1]);
|
||||
z[1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[2] + (long)y[2]);
|
||||
z[2] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[3] + (long)y[3]);
|
||||
z[3] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[4] + (long)y[4]);
|
||||
z[4] = (uint)num;
|
||||
num >>= 32;
|
||||
return (uint)num;
|
||||
}
|
||||
|
||||
public static uint AddBothTo(uint[] x, uint[] y, uint[] z)
|
||||
{
|
||||
ulong num = 0uL;
|
||||
num += (ulong)((long)x[0] + (long)y[0] + z[0]);
|
||||
z[0] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[1] + (long)y[1] + z[1]);
|
||||
z[1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[2] + (long)y[2] + z[2]);
|
||||
z[2] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[3] + (long)y[3] + z[3]);
|
||||
z[3] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[4] + (long)y[4] + z[4]);
|
||||
z[4] = (uint)num;
|
||||
num >>= 32;
|
||||
return (uint)num;
|
||||
}
|
||||
|
||||
public static uint AddTo(uint[] x, uint[] z)
|
||||
{
|
||||
ulong num = 0uL;
|
||||
num += (ulong)((long)x[0] + (long)z[0]);
|
||||
z[0] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[1] + (long)z[1]);
|
||||
z[1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[2] + (long)z[2]);
|
||||
z[2] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[3] + (long)z[3]);
|
||||
z[3] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[4] + (long)z[4]);
|
||||
z[4] = (uint)num;
|
||||
num >>= 32;
|
||||
return (uint)num;
|
||||
}
|
||||
|
||||
public static uint AddTo(uint[] x, int xOff, uint[] z, int zOff, uint cIn)
|
||||
{
|
||||
ulong num = cIn;
|
||||
num += (ulong)((long)x[xOff] + (long)z[zOff]);
|
||||
z[zOff] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[xOff + 1] + (long)z[zOff + 1]);
|
||||
z[zOff + 1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[xOff + 2] + (long)z[zOff + 2]);
|
||||
z[zOff + 2] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[xOff + 3] + (long)z[zOff + 3]);
|
||||
z[zOff + 3] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[xOff + 4] + (long)z[zOff + 4]);
|
||||
z[zOff + 4] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)x[xOff + 5] + (long)z[zOff + 5]);
|
||||
return (uint)num;
|
||||
}
|
||||
|
||||
public static uint AddToEachOther(uint[] u, int uOff, uint[] v, int vOff)
|
||||
{
|
||||
ulong num = 0uL;
|
||||
num += (ulong)((long)u[uOff] + (long)v[vOff]);
|
||||
u[uOff] = (uint)num;
|
||||
v[vOff] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)u[uOff + 1] + (long)v[vOff + 1]);
|
||||
u[uOff + 1] = (uint)num;
|
||||
v[vOff + 1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)u[uOff + 2] + (long)v[vOff + 2]);
|
||||
u[uOff + 2] = (uint)num;
|
||||
v[vOff + 2] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)u[uOff + 3] + (long)v[vOff + 3]);
|
||||
u[uOff + 3] = (uint)num;
|
||||
v[vOff + 3] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (ulong)((long)u[uOff + 4] + (long)v[vOff + 4]);
|
||||
u[uOff + 4] = (uint)num;
|
||||
v[vOff + 4] = (uint)num;
|
||||
num >>= 32;
|
||||
return (uint)num;
|
||||
}
|
||||
|
||||
public static void Copy(uint[] x, uint[] z)
|
||||
{
|
||||
z[0] = x[0];
|
||||
z[1] = x[1];
|
||||
z[2] = x[2];
|
||||
z[3] = x[3];
|
||||
z[4] = x[4];
|
||||
}
|
||||
|
||||
public static void Copy(uint[] x, int xOff, uint[] z, int zOff)
|
||||
{
|
||||
z[zOff] = x[xOff];
|
||||
z[zOff + 1] = x[xOff + 1];
|
||||
z[zOff + 2] = x[xOff + 2];
|
||||
z[zOff + 3] = x[xOff + 3];
|
||||
z[zOff + 4] = x[xOff + 4];
|
||||
}
|
||||
|
||||
public static uint[] Create()
|
||||
{
|
||||
return new uint[5];
|
||||
}
|
||||
|
||||
public static uint[] CreateExt()
|
||||
{
|
||||
return new uint[10];
|
||||
}
|
||||
|
||||
public static bool Diff(uint[] x, int xOff, uint[] y, int yOff, uint[] z, int zOff)
|
||||
{
|
||||
bool flag = Gte(x, xOff, y, yOff);
|
||||
if (flag)
|
||||
{
|
||||
Sub(x, xOff, y, yOff, z, zOff);
|
||||
}
|
||||
else
|
||||
{
|
||||
Sub(y, yOff, x, xOff, z, zOff);
|
||||
}
|
||||
return flag;
|
||||
}
|
||||
|
||||
public static bool Eq(uint[] x, uint[] y)
|
||||
{
|
||||
for (int num = 4; num >= 0; num--)
|
||||
{
|
||||
if (x[num] != y[num])
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static uint[] FromBigInteger(BigInteger x)
|
||||
{
|
||||
if (x.SignValue < 0 || x.BitLength > 160)
|
||||
{
|
||||
throw new ArgumentException();
|
||||
}
|
||||
uint[] array = Create();
|
||||
int num = 0;
|
||||
while (x.SignValue != 0)
|
||||
{
|
||||
array[num++] = (uint)x.IntValue;
|
||||
x = x.ShiftRight(32);
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
public static uint GetBit(uint[] x, int bit)
|
||||
{
|
||||
if (bit == 0)
|
||||
{
|
||||
return x[0] & 1;
|
||||
}
|
||||
int num = bit >> 5;
|
||||
if (num < 0 || num >= 5)
|
||||
{
|
||||
return 0u;
|
||||
}
|
||||
int num2 = bit & 0x1F;
|
||||
return (x[num] >> num2) & 1;
|
||||
}
|
||||
|
||||
public static bool Gte(uint[] x, uint[] y)
|
||||
{
|
||||
for (int num = 4; num >= 0; num--)
|
||||
{
|
||||
uint num2 = x[num];
|
||||
uint num3 = y[num];
|
||||
if (num2 < num3)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (num2 > num3)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static bool Gte(uint[] x, int xOff, uint[] y, int yOff)
|
||||
{
|
||||
for (int num = 4; num >= 0; num--)
|
||||
{
|
||||
uint num2 = x[xOff + num];
|
||||
uint num3 = y[yOff + num];
|
||||
if (num2 < num3)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (num2 > num3)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static bool IsOne(uint[] x)
|
||||
{
|
||||
if (x[0] != 1)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
for (int i = 1; i < 5; i++)
|
||||
{
|
||||
if (x[i] != 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static bool IsZero(uint[] x)
|
||||
{
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
if (x[i] != 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static void Mul(uint[] x, uint[] y, uint[] zz)
|
||||
{
|
||||
ulong num = y[0];
|
||||
ulong num2 = y[1];
|
||||
ulong num3 = y[2];
|
||||
ulong num4 = y[3];
|
||||
ulong num5 = y[4];
|
||||
ulong num6 = 0uL;
|
||||
ulong num7 = x[0];
|
||||
num6 += num7 * num;
|
||||
zz[0] = (uint)num6;
|
||||
num6 >>= 32;
|
||||
num6 += num7 * num2;
|
||||
zz[1] = (uint)num6;
|
||||
num6 >>= 32;
|
||||
num6 += num7 * num3;
|
||||
zz[2] = (uint)num6;
|
||||
num6 >>= 32;
|
||||
num6 += num7 * num4;
|
||||
zz[3] = (uint)num6;
|
||||
num6 >>= 32;
|
||||
num6 += num7 * num5;
|
||||
zz[4] = (uint)num6;
|
||||
num6 >>= 32;
|
||||
zz[5] = (uint)num6;
|
||||
for (int i = 1; i < 5; i++)
|
||||
{
|
||||
ulong num8 = 0uL;
|
||||
ulong num9 = x[i];
|
||||
num8 += num9 * num + zz[i];
|
||||
zz[i] = (uint)num8;
|
||||
num8 >>= 32;
|
||||
num8 += num9 * num2 + zz[i + 1];
|
||||
zz[i + 1] = (uint)num8;
|
||||
num8 >>= 32;
|
||||
num8 += num9 * num3 + zz[i + 2];
|
||||
zz[i + 2] = (uint)num8;
|
||||
num8 >>= 32;
|
||||
num8 += num9 * num4 + zz[i + 3];
|
||||
zz[i + 3] = (uint)num8;
|
||||
num8 >>= 32;
|
||||
num8 += num9 * num5 + zz[i + 4];
|
||||
zz[i + 4] = (uint)num8;
|
||||
num8 >>= 32;
|
||||
zz[i + 5] = (uint)num8;
|
||||
}
|
||||
}
|
||||
|
||||
public static void Mul(uint[] x, int xOff, uint[] y, int yOff, uint[] zz, int zzOff)
|
||||
{
|
||||
ulong num = y[yOff];
|
||||
ulong num2 = y[yOff + 1];
|
||||
ulong num3 = y[yOff + 2];
|
||||
ulong num4 = y[yOff + 3];
|
||||
ulong num5 = y[yOff + 4];
|
||||
ulong num6 = 0uL;
|
||||
ulong num7 = x[xOff];
|
||||
num6 += num7 * num;
|
||||
zz[zzOff] = (uint)num6;
|
||||
num6 >>= 32;
|
||||
num6 += num7 * num2;
|
||||
zz[zzOff + 1] = (uint)num6;
|
||||
num6 >>= 32;
|
||||
num6 += num7 * num3;
|
||||
zz[zzOff + 2] = (uint)num6;
|
||||
num6 >>= 32;
|
||||
num6 += num7 * num4;
|
||||
zz[zzOff + 3] = (uint)num6;
|
||||
num6 >>= 32;
|
||||
num6 += num7 * num5;
|
||||
zz[zzOff + 4] = (uint)num6;
|
||||
num6 >>= 32;
|
||||
zz[zzOff + 5] = (uint)num6;
|
||||
for (int i = 1; i < 5; i++)
|
||||
{
|
||||
zzOff++;
|
||||
ulong num8 = 0uL;
|
||||
ulong num9 = x[xOff + i];
|
||||
num8 += num9 * num + zz[zzOff];
|
||||
zz[zzOff] = (uint)num8;
|
||||
num8 >>= 32;
|
||||
num8 += num9 * num2 + zz[zzOff + 1];
|
||||
zz[zzOff + 1] = (uint)num8;
|
||||
num8 >>= 32;
|
||||
num8 += num9 * num3 + zz[zzOff + 2];
|
||||
zz[zzOff + 2] = (uint)num8;
|
||||
num8 >>= 32;
|
||||
num8 += num9 * num4 + zz[zzOff + 3];
|
||||
zz[zzOff + 3] = (uint)num8;
|
||||
num8 >>= 32;
|
||||
num8 += num9 * num5 + zz[zzOff + 4];
|
||||
zz[zzOff + 4] = (uint)num8;
|
||||
num8 >>= 32;
|
||||
zz[zzOff + 5] = (uint)num8;
|
||||
}
|
||||
}
|
||||
|
||||
public static uint MulAddTo(uint[] x, uint[] y, uint[] zz)
|
||||
{
|
||||
ulong num = y[0];
|
||||
ulong num2 = y[1];
|
||||
ulong num3 = y[2];
|
||||
ulong num4 = y[3];
|
||||
ulong num5 = y[4];
|
||||
ulong num6 = 0uL;
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
ulong num7 = 0uL;
|
||||
ulong num8 = x[i];
|
||||
num7 += num8 * num + zz[i];
|
||||
zz[i] = (uint)num7;
|
||||
num7 >>= 32;
|
||||
num7 += num8 * num2 + zz[i + 1];
|
||||
zz[i + 1] = (uint)num7;
|
||||
num7 >>= 32;
|
||||
num7 += num8 * num3 + zz[i + 2];
|
||||
zz[i + 2] = (uint)num7;
|
||||
num7 >>= 32;
|
||||
num7 += num8 * num4 + zz[i + 3];
|
||||
zz[i + 3] = (uint)num7;
|
||||
num7 >>= 32;
|
||||
num7 += num8 * num5 + zz[i + 4];
|
||||
zz[i + 4] = (uint)num7;
|
||||
num7 >>= 32;
|
||||
num7 += num6 + zz[i + 5];
|
||||
zz[i + 5] = (uint)num7;
|
||||
num6 = num7 >> 32;
|
||||
}
|
||||
return (uint)num6;
|
||||
}
|
||||
|
||||
public static uint MulAddTo(uint[] x, int xOff, uint[] y, int yOff, uint[] zz, int zzOff)
|
||||
{
|
||||
ulong num = y[yOff];
|
||||
ulong num2 = y[yOff + 1];
|
||||
ulong num3 = y[yOff + 2];
|
||||
ulong num4 = y[yOff + 3];
|
||||
ulong num5 = y[yOff + 4];
|
||||
ulong num6 = 0uL;
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
ulong num7 = 0uL;
|
||||
ulong num8 = x[xOff + i];
|
||||
num7 += num8 * num + zz[zzOff];
|
||||
zz[zzOff] = (uint)num7;
|
||||
num7 >>= 32;
|
||||
num7 += num8 * num2 + zz[zzOff + 1];
|
||||
zz[zzOff + 1] = (uint)num7;
|
||||
num7 >>= 32;
|
||||
num7 += num8 * num3 + zz[zzOff + 2];
|
||||
zz[zzOff + 2] = (uint)num7;
|
||||
num7 >>= 32;
|
||||
num7 += num8 * num4 + zz[zzOff + 3];
|
||||
zz[zzOff + 3] = (uint)num7;
|
||||
num7 >>= 32;
|
||||
num7 += num8 * num5 + zz[zzOff + 4];
|
||||
zz[zzOff + 4] = (uint)num7;
|
||||
num7 >>= 32;
|
||||
num7 += num6 + zz[zzOff + 5];
|
||||
zz[zzOff + 5] = (uint)num7;
|
||||
num6 = num7 >> 32;
|
||||
zzOff++;
|
||||
}
|
||||
return (uint)num6;
|
||||
}
|
||||
|
||||
public static ulong Mul33Add(uint w, uint[] x, int xOff, uint[] y, int yOff, uint[] z, int zOff)
|
||||
{
|
||||
ulong num = 0uL;
|
||||
ulong num2 = w;
|
||||
ulong num3 = x[xOff];
|
||||
num += num2 * num3 + y[yOff];
|
||||
z[zOff] = (uint)num;
|
||||
num >>= 32;
|
||||
ulong num4 = x[xOff + 1];
|
||||
num += num2 * num4 + num3 + y[yOff + 1];
|
||||
z[zOff + 1] = (uint)num;
|
||||
num >>= 32;
|
||||
ulong num5 = x[xOff + 2];
|
||||
num += num2 * num5 + num4 + y[yOff + 2];
|
||||
z[zOff + 2] = (uint)num;
|
||||
num >>= 32;
|
||||
ulong num6 = x[xOff + 3];
|
||||
num += num2 * num6 + num5 + y[yOff + 3];
|
||||
z[zOff + 3] = (uint)num;
|
||||
num >>= 32;
|
||||
ulong num7 = x[xOff + 4];
|
||||
num += num2 * num7 + num6 + y[yOff + 4];
|
||||
z[zOff + 4] = (uint)num;
|
||||
num >>= 32;
|
||||
return num + num7;
|
||||
}
|
||||
|
||||
public static uint MulWordAddExt(uint x, uint[] yy, int yyOff, uint[] zz, int zzOff)
|
||||
{
|
||||
ulong num = 0uL;
|
||||
ulong num2 = x;
|
||||
num += num2 * yy[yyOff] + zz[zzOff];
|
||||
zz[zzOff] = (uint)num;
|
||||
num >>= 32;
|
||||
num += num2 * yy[yyOff + 1] + zz[zzOff + 1];
|
||||
zz[zzOff + 1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += num2 * yy[yyOff + 2] + zz[zzOff + 2];
|
||||
zz[zzOff + 2] = (uint)num;
|
||||
num >>= 32;
|
||||
num += num2 * yy[yyOff + 3] + zz[zzOff + 3];
|
||||
zz[zzOff + 3] = (uint)num;
|
||||
num >>= 32;
|
||||
num += num2 * yy[yyOff + 4] + zz[zzOff + 4];
|
||||
zz[zzOff + 4] = (uint)num;
|
||||
num >>= 32;
|
||||
return (uint)num;
|
||||
}
|
||||
|
||||
public static uint Mul33DWordAdd(uint x, ulong y, uint[] z, int zOff)
|
||||
{
|
||||
ulong num = 0uL;
|
||||
ulong num2 = x;
|
||||
ulong num3 = y & 0xFFFFFFFFu;
|
||||
num += num2 * num3 + z[zOff];
|
||||
z[zOff] = (uint)num;
|
||||
num >>= 32;
|
||||
ulong num4 = y >> 32;
|
||||
num += num2 * num4 + num3 + z[zOff + 1];
|
||||
z[zOff + 1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += num4 + z[zOff + 2];
|
||||
z[zOff + 2] = (uint)num;
|
||||
num >>= 32;
|
||||
num += z[zOff + 3];
|
||||
z[zOff + 3] = (uint)num;
|
||||
num >>= 32;
|
||||
if (num != 0)
|
||||
{
|
||||
return Nat.IncAt(5, z, zOff, 4);
|
||||
}
|
||||
return 0u;
|
||||
}
|
||||
|
||||
public static uint Mul33WordAdd(uint x, uint y, uint[] z, int zOff)
|
||||
{
|
||||
ulong num = 0uL;
|
||||
ulong num2 = y;
|
||||
num += num2 * x + z[zOff];
|
||||
z[zOff] = (uint)num;
|
||||
num >>= 32;
|
||||
num += num2 + z[zOff + 1];
|
||||
z[zOff + 1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += z[zOff + 2];
|
||||
z[zOff + 2] = (uint)num;
|
||||
num >>= 32;
|
||||
if (num != 0)
|
||||
{
|
||||
return Nat.IncAt(5, z, zOff, 3);
|
||||
}
|
||||
return 0u;
|
||||
}
|
||||
|
||||
public static uint MulWordDwordAdd(uint x, ulong y, uint[] z, int zOff)
|
||||
{
|
||||
ulong num = 0uL;
|
||||
ulong num2 = x;
|
||||
num += num2 * y + z[zOff];
|
||||
z[zOff] = (uint)num;
|
||||
num >>= 32;
|
||||
num += num2 * (y >> 32) + z[zOff + 1];
|
||||
z[zOff + 1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += z[zOff + 2];
|
||||
z[zOff + 2] = (uint)num;
|
||||
num >>= 32;
|
||||
if (num != 0)
|
||||
{
|
||||
return Nat.IncAt(5, z, zOff, 3);
|
||||
}
|
||||
return 0u;
|
||||
}
|
||||
|
||||
public static uint MulWordsAdd(uint x, uint y, uint[] z, int zOff)
|
||||
{
|
||||
ulong num = 0uL;
|
||||
ulong num2 = x;
|
||||
ulong num3 = y;
|
||||
num += num3 * num2 + z[zOff];
|
||||
z[zOff] = (uint)num;
|
||||
num >>= 32;
|
||||
num += z[zOff + 1];
|
||||
z[zOff + 1] = (uint)num;
|
||||
num >>= 32;
|
||||
if (num != 0)
|
||||
{
|
||||
return Nat.IncAt(5, z, zOff, 2);
|
||||
}
|
||||
return 0u;
|
||||
}
|
||||
|
||||
public static uint MulWord(uint x, uint[] y, uint[] z, int zOff)
|
||||
{
|
||||
ulong num = 0uL;
|
||||
ulong num2 = x;
|
||||
int num3 = 0;
|
||||
do
|
||||
{
|
||||
num += num2 * y[num3];
|
||||
z[zOff + num3] = (uint)num;
|
||||
num >>= 32;
|
||||
}
|
||||
while (++num3 < 5);
|
||||
return (uint)num;
|
||||
}
|
||||
|
||||
public static void Square(uint[] x, uint[] zz)
|
||||
{
|
||||
ulong num = x[0];
|
||||
uint num2 = 0u;
|
||||
int num3 = 4;
|
||||
int num4 = 10;
|
||||
do
|
||||
{
|
||||
ulong num5 = x[num3--];
|
||||
ulong num6 = num5 * num5;
|
||||
zz[--num4] = (num2 << 31) | (uint)(int)(num6 >> 33);
|
||||
zz[--num4] = (uint)(num6 >> 1);
|
||||
num2 = (uint)num6;
|
||||
}
|
||||
while (num3 > 0);
|
||||
ulong num7 = num * num;
|
||||
ulong num8 = (num2 << 31) | (num7 >> 33);
|
||||
zz[0] = (uint)num7;
|
||||
num2 = (uint)((int)(num7 >> 32) & 1);
|
||||
ulong num9 = x[1];
|
||||
ulong num10 = zz[2];
|
||||
num8 += num9 * num;
|
||||
uint num11 = (uint)num8;
|
||||
zz[1] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num10 += num8 >> 32;
|
||||
ulong num12 = x[2];
|
||||
ulong num13 = zz[3];
|
||||
ulong num14 = zz[4];
|
||||
num10 += num12 * num;
|
||||
num11 = (uint)num10;
|
||||
zz[2] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num13 += (num10 >> 32) + num12 * num9;
|
||||
num14 += num13 >> 32;
|
||||
num13 &= 0xFFFFFFFFu;
|
||||
ulong num15 = x[3];
|
||||
ulong num16 = zz[5] + (num14 >> 32);
|
||||
num14 &= 0xFFFFFFFFu;
|
||||
ulong num17 = zz[6] + (num16 >> 32);
|
||||
num16 &= 0xFFFFFFFFu;
|
||||
num13 += num15 * num;
|
||||
num11 = (uint)num13;
|
||||
zz[3] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num14 += (num13 >> 32) + num15 * num9;
|
||||
num16 += (num14 >> 32) + num15 * num12;
|
||||
num14 &= 0xFFFFFFFFu;
|
||||
num17 += num16 >> 32;
|
||||
num16 &= 0xFFFFFFFFu;
|
||||
ulong num18 = x[4];
|
||||
ulong num19 = zz[7] + (num17 >> 32);
|
||||
num17 &= 0xFFFFFFFFu;
|
||||
ulong num20 = zz[8] + (num19 >> 32);
|
||||
num19 &= 0xFFFFFFFFu;
|
||||
num14 += num18 * num;
|
||||
num11 = (uint)num14;
|
||||
zz[4] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num16 += (num14 >> 32) + num18 * num9;
|
||||
num17 += (num16 >> 32) + num18 * num12;
|
||||
num19 += (num17 >> 32) + num18 * num15;
|
||||
num20 += num19 >> 32;
|
||||
num11 = (uint)num16;
|
||||
zz[5] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num11 = (uint)num17;
|
||||
zz[6] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num11 = (uint)num19;
|
||||
zz[7] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num11 = (uint)num20;
|
||||
zz[8] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num11 = zz[9] + (uint)(int)(num20 >> 32);
|
||||
zz[9] = (num11 << 1) | num2;
|
||||
}
|
||||
|
||||
public static void Square(uint[] x, int xOff, uint[] zz, int zzOff)
|
||||
{
|
||||
ulong num = x[xOff];
|
||||
uint num2 = 0u;
|
||||
int num3 = 4;
|
||||
int num4 = 10;
|
||||
do
|
||||
{
|
||||
ulong num5 = x[xOff + num3--];
|
||||
ulong num6 = num5 * num5;
|
||||
zz[zzOff + --num4] = (num2 << 31) | (uint)(int)(num6 >> 33);
|
||||
zz[zzOff + --num4] = (uint)(num6 >> 1);
|
||||
num2 = (uint)num6;
|
||||
}
|
||||
while (num3 > 0);
|
||||
ulong num7 = num * num;
|
||||
ulong num8 = (num2 << 31) | (num7 >> 33);
|
||||
zz[zzOff] = (uint)num7;
|
||||
num2 = (uint)((int)(num7 >> 32) & 1);
|
||||
ulong num9 = x[xOff + 1];
|
||||
ulong num10 = zz[zzOff + 2];
|
||||
num8 += num9 * num;
|
||||
uint num11 = (uint)num8;
|
||||
zz[zzOff + 1] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num10 += num8 >> 32;
|
||||
ulong num12 = x[xOff + 2];
|
||||
ulong num13 = zz[zzOff + 3];
|
||||
ulong num14 = zz[zzOff + 4];
|
||||
num10 += num12 * num;
|
||||
num11 = (uint)num10;
|
||||
zz[zzOff + 2] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num13 += (num10 >> 32) + num12 * num9;
|
||||
num14 += num13 >> 32;
|
||||
num13 &= 0xFFFFFFFFu;
|
||||
ulong num15 = x[xOff + 3];
|
||||
ulong num16 = zz[zzOff + 5] + (num14 >> 32);
|
||||
num14 &= 0xFFFFFFFFu;
|
||||
ulong num17 = zz[zzOff + 6] + (num16 >> 32);
|
||||
num16 &= 0xFFFFFFFFu;
|
||||
num13 += num15 * num;
|
||||
num11 = (uint)num13;
|
||||
zz[zzOff + 3] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num14 += (num13 >> 32) + num15 * num9;
|
||||
num16 += (num14 >> 32) + num15 * num12;
|
||||
num14 &= 0xFFFFFFFFu;
|
||||
num17 += num16 >> 32;
|
||||
num16 &= 0xFFFFFFFFu;
|
||||
ulong num18 = x[xOff + 4];
|
||||
ulong num19 = zz[zzOff + 7] + (num17 >> 32);
|
||||
num17 &= 0xFFFFFFFFu;
|
||||
ulong num20 = zz[zzOff + 8] + (num19 >> 32);
|
||||
num19 &= 0xFFFFFFFFu;
|
||||
num14 += num18 * num;
|
||||
num11 = (uint)num14;
|
||||
zz[zzOff + 4] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num16 += (num14 >> 32) + num18 * num9;
|
||||
num17 += (num16 >> 32) + num18 * num12;
|
||||
num19 += (num17 >> 32) + num18 * num15;
|
||||
num20 += num19 >> 32;
|
||||
num11 = (uint)num16;
|
||||
zz[zzOff + 5] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num11 = (uint)num17;
|
||||
zz[zzOff + 6] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num11 = (uint)num19;
|
||||
zz[zzOff + 7] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num11 = (uint)num20;
|
||||
zz[zzOff + 8] = (num11 << 1) | num2;
|
||||
num2 = num11 >> 31;
|
||||
num11 = zz[zzOff + 9] + (uint)(int)(num20 >> 32);
|
||||
zz[zzOff + 9] = (num11 << 1) | num2;
|
||||
}
|
||||
|
||||
public static int Sub(uint[] x, uint[] y, uint[] z)
|
||||
{
|
||||
long num = 0L;
|
||||
num += (long)x[0] - (long)y[0];
|
||||
z[0] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)x[1] - (long)y[1];
|
||||
z[1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)x[2] - (long)y[2];
|
||||
z[2] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)x[3] - (long)y[3];
|
||||
z[3] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)x[4] - (long)y[4];
|
||||
z[4] = (uint)num;
|
||||
num >>= 32;
|
||||
return (int)num;
|
||||
}
|
||||
|
||||
public static int Sub(uint[] x, int xOff, uint[] y, int yOff, uint[] z, int zOff)
|
||||
{
|
||||
long num = 0L;
|
||||
num += (long)x[xOff] - (long)y[yOff];
|
||||
z[zOff] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)x[xOff + 1] - (long)y[yOff + 1];
|
||||
z[zOff + 1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)x[xOff + 2] - (long)y[yOff + 2];
|
||||
z[zOff + 2] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)x[xOff + 3] - (long)y[yOff + 3];
|
||||
z[zOff + 3] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)x[xOff + 4] - (long)y[yOff + 4];
|
||||
z[zOff + 4] = (uint)num;
|
||||
num >>= 32;
|
||||
return (int)num;
|
||||
}
|
||||
|
||||
public static int SubBothFrom(uint[] x, uint[] y, uint[] z)
|
||||
{
|
||||
long num = 0L;
|
||||
num += (long)z[0] - (long)x[0] - y[0];
|
||||
z[0] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)z[1] - (long)x[1] - y[1];
|
||||
z[1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)z[2] - (long)x[2] - y[2];
|
||||
z[2] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)z[3] - (long)x[3] - y[3];
|
||||
z[3] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)z[4] - (long)x[4] - y[4];
|
||||
z[4] = (uint)num;
|
||||
num >>= 32;
|
||||
return (int)num;
|
||||
}
|
||||
|
||||
public static int SubFrom(uint[] x, uint[] z)
|
||||
{
|
||||
long num = 0L;
|
||||
num += (long)z[0] - (long)x[0];
|
||||
z[0] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)z[1] - (long)x[1];
|
||||
z[1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)z[2] - (long)x[2];
|
||||
z[2] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)z[3] - (long)x[3];
|
||||
z[3] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)z[4] - (long)x[4];
|
||||
z[4] = (uint)num;
|
||||
num >>= 32;
|
||||
return (int)num;
|
||||
}
|
||||
|
||||
public static int SubFrom(uint[] x, int xOff, uint[] z, int zOff)
|
||||
{
|
||||
long num = 0L;
|
||||
num += (long)z[zOff] - (long)x[xOff];
|
||||
z[zOff] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)z[zOff + 1] - (long)x[xOff + 1];
|
||||
z[zOff + 1] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)z[zOff + 2] - (long)x[xOff + 2];
|
||||
z[zOff + 2] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)z[zOff + 3] - (long)x[xOff + 3];
|
||||
z[zOff + 3] = (uint)num;
|
||||
num >>= 32;
|
||||
num += (long)z[zOff + 4] - (long)x[xOff + 4];
|
||||
z[zOff + 4] = (uint)num;
|
||||
num >>= 32;
|
||||
return (int)num;
|
||||
}
|
||||
|
||||
public static BigInteger ToBigInteger(uint[] x)
|
||||
{
|
||||
byte[] array = new byte[20];
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
uint num = x[i];
|
||||
if (num != 0)
|
||||
{
|
||||
Pack.UInt32_To_BE(num, array, 4 - i << 2);
|
||||
}
|
||||
}
|
||||
return new BigInteger(1, array);
|
||||
}
|
||||
|
||||
public static void Zero(uint[] z)
|
||||
{
|
||||
z[0] = 0u;
|
||||
z[1] = 0u;
|
||||
z[2] = 0u;
|
||||
z[3] = 0u;
|
||||
z[4] = 0u;
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,105 @@
|
||||
using System;
|
||||
using Org.BouncyCastle.Crypto.Utilities;
|
||||
|
||||
namespace Org.BouncyCastle.Math.Raw;
|
||||
|
||||
internal abstract class Nat320
|
||||
{
|
||||
public static void Copy64(ulong[] x, ulong[] z)
|
||||
{
|
||||
z[0] = x[0];
|
||||
z[1] = x[1];
|
||||
z[2] = x[2];
|
||||
z[3] = x[3];
|
||||
z[4] = x[4];
|
||||
}
|
||||
|
||||
public static void Copy64(ulong[] x, int xOff, ulong[] z, int zOff)
|
||||
{
|
||||
z[zOff] = x[xOff];
|
||||
z[zOff + 1] = x[xOff + 1];
|
||||
z[zOff + 2] = x[xOff + 2];
|
||||
z[zOff + 3] = x[xOff + 3];
|
||||
z[zOff + 4] = x[xOff + 4];
|
||||
}
|
||||
|
||||
public static ulong[] Create64()
|
||||
{
|
||||
return new ulong[5];
|
||||
}
|
||||
|
||||
public static ulong[] CreateExt64()
|
||||
{
|
||||
return new ulong[10];
|
||||
}
|
||||
|
||||
public static bool Eq64(ulong[] x, ulong[] y)
|
||||
{
|
||||
for (int num = 4; num >= 0; num--)
|
||||
{
|
||||
if (x[num] != y[num])
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static ulong[] FromBigInteger64(BigInteger x)
|
||||
{
|
||||
if (x.SignValue < 0 || x.BitLength > 320)
|
||||
{
|
||||
throw new ArgumentException();
|
||||
}
|
||||
ulong[] array = Create64();
|
||||
int num = 0;
|
||||
while (x.SignValue != 0)
|
||||
{
|
||||
array[num++] = (ulong)x.LongValue;
|
||||
x = x.ShiftRight(64);
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
public static bool IsOne64(ulong[] x)
|
||||
{
|
||||
if (x[0] != 1)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
for (int i = 1; i < 5; i++)
|
||||
{
|
||||
if (x[i] != 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static bool IsZero64(ulong[] x)
|
||||
{
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
if (x[i] != 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static BigInteger ToBigInteger64(ulong[] x)
|
||||
{
|
||||
byte[] array = new byte[40];
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
ulong num = x[i];
|
||||
if (num != 0)
|
||||
{
|
||||
Pack.UInt64_To_BE(num, array, 4 - i << 3);
|
||||
}
|
||||
}
|
||||
return new BigInteger(1, array);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
namespace Org.BouncyCastle.Math.Raw;
|
||||
|
||||
internal abstract class Nat384
|
||||
{
|
||||
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);
|
||||
}
|
||||
|
||||
public static void Square(uint[] x, uint[] zz)
|
||||
{
|
||||
Nat192.Square(x, zz);
|
||||
Nat192.Square(x, 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();
|
||||
Nat192.Diff(x, 6, x, 0, array, 0);
|
||||
uint[] array2 = Nat192.CreateExt();
|
||||
Nat192.Square(array, array2);
|
||||
num += (uint)Nat.SubFrom(12, array2, 0, zz, 6);
|
||||
Nat.AddWordAt(24, num, zz, 18);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,109 @@
|
||||
using System;
|
||||
using Org.BouncyCastle.Crypto.Utilities;
|
||||
|
||||
namespace Org.BouncyCastle.Math.Raw;
|
||||
|
||||
internal abstract class Nat448
|
||||
{
|
||||
public static void Copy64(ulong[] x, ulong[] z)
|
||||
{
|
||||
z[0] = x[0];
|
||||
z[1] = x[1];
|
||||
z[2] = x[2];
|
||||
z[3] = x[3];
|
||||
z[4] = x[4];
|
||||
z[5] = x[5];
|
||||
z[6] = x[6];
|
||||
}
|
||||
|
||||
public static void Copy64(ulong[] x, int xOff, ulong[] z, int zOff)
|
||||
{
|
||||
z[zOff] = x[xOff];
|
||||
z[zOff + 1] = x[xOff + 1];
|
||||
z[zOff + 2] = x[xOff + 2];
|
||||
z[zOff + 3] = x[xOff + 3];
|
||||
z[zOff + 4] = x[xOff + 4];
|
||||
z[zOff + 5] = x[xOff + 5];
|
||||
z[zOff + 6] = x[xOff + 6];
|
||||
}
|
||||
|
||||
public static ulong[] Create64()
|
||||
{
|
||||
return new ulong[7];
|
||||
}
|
||||
|
||||
public static ulong[] CreateExt64()
|
||||
{
|
||||
return new ulong[14];
|
||||
}
|
||||
|
||||
public static bool Eq64(ulong[] x, ulong[] y)
|
||||
{
|
||||
for (int num = 6; num >= 0; num--)
|
||||
{
|
||||
if (x[num] != y[num])
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static ulong[] FromBigInteger64(BigInteger x)
|
||||
{
|
||||
if (x.SignValue < 0 || x.BitLength > 448)
|
||||
{
|
||||
throw new ArgumentException();
|
||||
}
|
||||
ulong[] array = Create64();
|
||||
int num = 0;
|
||||
while (x.SignValue != 0)
|
||||
{
|
||||
array[num++] = (ulong)x.LongValue;
|
||||
x = x.ShiftRight(64);
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
public static bool IsOne64(ulong[] x)
|
||||
{
|
||||
if (x[0] != 1)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
for (int i = 1; i < 7; i++)
|
||||
{
|
||||
if (x[i] != 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static bool IsZero64(ulong[] x)
|
||||
{
|
||||
for (int i = 0; i < 7; i++)
|
||||
{
|
||||
if (x[i] != 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static BigInteger ToBigInteger64(ulong[] x)
|
||||
{
|
||||
byte[] array = new byte[56];
|
||||
for (int i = 0; i < 7; i++)
|
||||
{
|
||||
ulong num = x[i];
|
||||
if (num != 0)
|
||||
{
|
||||
Pack.UInt64_To_BE(num, array, 6 - i << 3);
|
||||
}
|
||||
}
|
||||
return new BigInteger(1, array);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
namespace Org.BouncyCastle.Math.Raw;
|
||||
|
||||
internal abstract class Nat512
|
||||
{
|
||||
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)(flag ? ((int)Nat.AddTo(16, array3, 0, zz, 8)) : Nat.SubFrom(16, array3, 0, zz, 8));
|
||||
Nat.AddWordAt(32, num, zz, 24);
|
||||
}
|
||||
|
||||
public static void Square(uint[] x, uint[] zz)
|
||||
{
|
||||
Nat256.Square(x, zz);
|
||||
Nat256.Square(x, 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();
|
||||
Nat256.Diff(x, 8, x, 0, array, 0);
|
||||
uint[] array2 = Nat256.CreateExt();
|
||||
Nat256.Square(array, array2);
|
||||
num += (uint)Nat.SubFrom(16, array2, 0, zz, 8);
|
||||
Nat.AddWordAt(32, num, zz, 24);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,113 @@
|
||||
using System;
|
||||
using Org.BouncyCastle.Crypto.Utilities;
|
||||
|
||||
namespace Org.BouncyCastle.Math.Raw;
|
||||
|
||||
internal abstract class Nat576
|
||||
{
|
||||
public static void Copy64(ulong[] x, ulong[] z)
|
||||
{
|
||||
z[0] = x[0];
|
||||
z[1] = x[1];
|
||||
z[2] = x[2];
|
||||
z[3] = x[3];
|
||||
z[4] = x[4];
|
||||
z[5] = x[5];
|
||||
z[6] = x[6];
|
||||
z[7] = x[7];
|
||||
z[8] = x[8];
|
||||
}
|
||||
|
||||
public static void Copy64(ulong[] x, int xOff, ulong[] z, int zOff)
|
||||
{
|
||||
z[zOff] = x[xOff];
|
||||
z[zOff + 1] = x[xOff + 1];
|
||||
z[zOff + 2] = x[xOff + 2];
|
||||
z[zOff + 3] = x[xOff + 3];
|
||||
z[zOff + 4] = x[xOff + 4];
|
||||
z[zOff + 5] = x[xOff + 5];
|
||||
z[zOff + 6] = x[xOff + 6];
|
||||
z[zOff + 7] = x[xOff + 7];
|
||||
z[zOff + 8] = x[xOff + 8];
|
||||
}
|
||||
|
||||
public static ulong[] Create64()
|
||||
{
|
||||
return new ulong[9];
|
||||
}
|
||||
|
||||
public static ulong[] CreateExt64()
|
||||
{
|
||||
return new ulong[18];
|
||||
}
|
||||
|
||||
public static bool Eq64(ulong[] x, ulong[] y)
|
||||
{
|
||||
for (int num = 8; num >= 0; num--)
|
||||
{
|
||||
if (x[num] != y[num])
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static ulong[] FromBigInteger64(BigInteger x)
|
||||
{
|
||||
if (x.SignValue < 0 || x.BitLength > 576)
|
||||
{
|
||||
throw new ArgumentException();
|
||||
}
|
||||
ulong[] array = Create64();
|
||||
int num = 0;
|
||||
while (x.SignValue != 0)
|
||||
{
|
||||
array[num++] = (ulong)x.LongValue;
|
||||
x = x.ShiftRight(64);
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
public static bool IsOne64(ulong[] x)
|
||||
{
|
||||
if (x[0] != 1)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
for (int i = 1; i < 9; i++)
|
||||
{
|
||||
if (x[i] != 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static bool IsZero64(ulong[] x)
|
||||
{
|
||||
for (int i = 0; i < 9; i++)
|
||||
{
|
||||
if (x[i] != 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public static BigInteger ToBigInteger64(ulong[] x)
|
||||
{
|
||||
byte[] array = new byte[72];
|
||||
for (int i = 0; i < 9; i++)
|
||||
{
|
||||
ulong num = x[i];
|
||||
if (num != 0)
|
||||
{
|
||||
Pack.UInt64_To_BE(num, array, 8 - i << 3);
|
||||
}
|
||||
}
|
||||
return new BigInteger(1, array);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user