niko
2919 lines
71 KiB
C#
2919 lines
71 KiB
C#
using System;
|
|
|
|
namespace Photon.SocketServer.Numeric
|
|
{
|
|
// Token: 0x02000005 RID: 5
|
|
internal class BigInteger
|
|
{
|
|
// Token: 0x06000018 RID: 24 RVA: 0x000023A6 File Offset: 0x000005A6
|
|
public BigInteger()
|
|
{
|
|
this.data = new uint[70];
|
|
this.dataLength = 1;
|
|
}
|
|
|
|
// Token: 0x06000019 RID: 25 RVA: 0x000023CC File Offset: 0x000005CC
|
|
public BigInteger(long value)
|
|
{
|
|
this.data = new uint[70];
|
|
long num = value;
|
|
this.dataLength = 0;
|
|
while (value != 0L && this.dataLength < 70)
|
|
{
|
|
this.data[this.dataLength] = (uint)(value & (long)((ulong)(-1)));
|
|
value >>= 32;
|
|
this.dataLength++;
|
|
}
|
|
bool flag = num > 0L;
|
|
if (flag)
|
|
{
|
|
bool flag2 = value != 0L || (this.data[69] & 2147483648U) > 0U;
|
|
if (flag2)
|
|
{
|
|
throw new ArithmeticException("Positive overflow in constructor.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool flag3 = num < 0L;
|
|
if (flag3)
|
|
{
|
|
bool flag4 = value != -1L || (this.data[this.dataLength - 1] & 2147483648U) == 0U;
|
|
if (flag4)
|
|
{
|
|
throw new ArithmeticException("Negative underflow in constructor.");
|
|
}
|
|
}
|
|
}
|
|
bool flag5 = this.dataLength == 0;
|
|
if (flag5)
|
|
{
|
|
this.dataLength = 1;
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600001A RID: 26 RVA: 0x000024C4 File Offset: 0x000006C4
|
|
public BigInteger(ulong value)
|
|
{
|
|
this.data = new uint[70];
|
|
this.dataLength = 0;
|
|
while (value != 0UL && this.dataLength < 70)
|
|
{
|
|
this.data[this.dataLength] = (uint)(value & (ulong)(-1));
|
|
value >>= 32;
|
|
this.dataLength++;
|
|
}
|
|
bool flag = value != 0UL || (this.data[69] & 2147483648U) > 0U;
|
|
if (flag)
|
|
{
|
|
throw new ArithmeticException("Positive overflow in constructor.");
|
|
}
|
|
bool flag2 = this.dataLength == 0;
|
|
if (flag2)
|
|
{
|
|
this.dataLength = 1;
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600001B RID: 27 RVA: 0x00002570 File Offset: 0x00000770
|
|
public BigInteger(BigInteger bi)
|
|
{
|
|
this.data = new uint[70];
|
|
this.dataLength = bi.dataLength;
|
|
for (int i = 0; i < this.dataLength; i++)
|
|
{
|
|
this.data[i] = bi.data[i];
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600001C RID: 28 RVA: 0x000025CC File Offset: 0x000007CC
|
|
public BigInteger(string value, int radix)
|
|
{
|
|
BigInteger bigInteger = new BigInteger(1L);
|
|
BigInteger bigInteger2 = new BigInteger();
|
|
value = value.ToUpper().Trim();
|
|
int num = 0;
|
|
bool flag = value[0] == '-';
|
|
if (flag)
|
|
{
|
|
num = 1;
|
|
}
|
|
for (int i = value.Length - 1; i >= num; i--)
|
|
{
|
|
int num2 = (int)value[i];
|
|
bool flag2 = num2 >= 48 && num2 <= 57;
|
|
if (flag2)
|
|
{
|
|
num2 -= 48;
|
|
}
|
|
else
|
|
{
|
|
bool flag3 = num2 >= 65 && num2 <= 90;
|
|
if (flag3)
|
|
{
|
|
num2 = num2 - 65 + 10;
|
|
}
|
|
else
|
|
{
|
|
num2 = 9999999;
|
|
}
|
|
}
|
|
bool flag4 = num2 >= radix;
|
|
if (flag4)
|
|
{
|
|
throw new ArithmeticException("Invalid string in constructor.");
|
|
}
|
|
bool flag5 = value[0] == '-';
|
|
if (flag5)
|
|
{
|
|
num2 = -num2;
|
|
}
|
|
bigInteger2 += bigInteger * num2;
|
|
bool flag6 = i - 1 >= num;
|
|
if (flag6)
|
|
{
|
|
bigInteger *= radix;
|
|
}
|
|
}
|
|
bool flag7 = value[0] == '-';
|
|
if (flag7)
|
|
{
|
|
bool flag8 = (bigInteger2.data[69] & 2147483648U) == 0U;
|
|
if (flag8)
|
|
{
|
|
throw new ArithmeticException("Negative underflow in constructor.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool flag9 = (bigInteger2.data[69] & 2147483648U) > 0U;
|
|
if (flag9)
|
|
{
|
|
throw new ArithmeticException("Positive overflow in constructor.");
|
|
}
|
|
}
|
|
this.data = new uint[70];
|
|
for (int j = 0; j < bigInteger2.dataLength; j++)
|
|
{
|
|
this.data[j] = bigInteger2.data[j];
|
|
}
|
|
this.dataLength = bigInteger2.dataLength;
|
|
}
|
|
|
|
// Token: 0x0600001D RID: 29 RVA: 0x0000279C File Offset: 0x0000099C
|
|
public BigInteger(byte[] inData)
|
|
{
|
|
this.dataLength = inData.Length >> 2;
|
|
int num = inData.Length & 3;
|
|
bool flag = num != 0;
|
|
if (flag)
|
|
{
|
|
this.dataLength++;
|
|
}
|
|
bool flag2 = this.dataLength > 70;
|
|
if (flag2)
|
|
{
|
|
throw new ArithmeticException("Byte overflow in constructor.");
|
|
}
|
|
this.data = new uint[70];
|
|
int i = inData.Length - 1;
|
|
int num2 = 0;
|
|
while (i >= 3)
|
|
{
|
|
this.data[num2] = (uint)(((int)inData[i - 3] << 24) + ((int)inData[i - 2] << 16) + ((int)inData[i - 1] << 8) + (int)inData[i]);
|
|
i -= 4;
|
|
num2++;
|
|
}
|
|
bool flag3 = num == 1;
|
|
if (flag3)
|
|
{
|
|
this.data[this.dataLength - 1] = (uint)inData[0];
|
|
}
|
|
else
|
|
{
|
|
bool flag4 = num == 2;
|
|
if (flag4)
|
|
{
|
|
this.data[this.dataLength - 1] = (uint)(((int)inData[0] << 8) + (int)inData[1]);
|
|
}
|
|
else
|
|
{
|
|
bool flag5 = num == 3;
|
|
if (flag5)
|
|
{
|
|
this.data[this.dataLength - 1] = (uint)(((int)inData[0] << 16) + ((int)inData[1] << 8) + (int)inData[2]);
|
|
}
|
|
}
|
|
}
|
|
while (this.dataLength > 1 && this.data[this.dataLength - 1] == 0U)
|
|
{
|
|
this.dataLength--;
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600001E RID: 30 RVA: 0x000028F0 File Offset: 0x00000AF0
|
|
public BigInteger(byte[] inData, int inLen)
|
|
{
|
|
this.dataLength = inLen >> 2;
|
|
int num = inLen & 3;
|
|
bool flag = num != 0;
|
|
if (flag)
|
|
{
|
|
this.dataLength++;
|
|
}
|
|
bool flag2 = this.dataLength > 70 || inLen > inData.Length;
|
|
if (flag2)
|
|
{
|
|
throw new ArithmeticException("Byte overflow in constructor.");
|
|
}
|
|
this.data = new uint[70];
|
|
int i = inLen - 1;
|
|
int num2 = 0;
|
|
while (i >= 3)
|
|
{
|
|
this.data[num2] = (uint)(((int)inData[i - 3] << 24) + ((int)inData[i - 2] << 16) + ((int)inData[i - 1] << 8) + (int)inData[i]);
|
|
i -= 4;
|
|
num2++;
|
|
}
|
|
bool flag3 = num == 1;
|
|
if (flag3)
|
|
{
|
|
this.data[this.dataLength - 1] = (uint)inData[0];
|
|
}
|
|
else
|
|
{
|
|
bool flag4 = num == 2;
|
|
if (flag4)
|
|
{
|
|
this.data[this.dataLength - 1] = (uint)(((int)inData[0] << 8) + (int)inData[1]);
|
|
}
|
|
else
|
|
{
|
|
bool flag5 = num == 3;
|
|
if (flag5)
|
|
{
|
|
this.data[this.dataLength - 1] = (uint)(((int)inData[0] << 16) + ((int)inData[1] << 8) + (int)inData[2]);
|
|
}
|
|
}
|
|
}
|
|
bool flag6 = this.dataLength == 0;
|
|
if (flag6)
|
|
{
|
|
this.dataLength = 1;
|
|
}
|
|
while (this.dataLength > 1 && this.data[this.dataLength - 1] == 0U)
|
|
{
|
|
this.dataLength--;
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600001F RID: 31 RVA: 0x00002A5C File Offset: 0x00000C5C
|
|
public BigInteger(uint[] inData)
|
|
{
|
|
this.dataLength = inData.Length;
|
|
bool flag = this.dataLength > 70;
|
|
if (flag)
|
|
{
|
|
throw new ArithmeticException("Byte overflow in constructor.");
|
|
}
|
|
this.data = new uint[70];
|
|
int i = this.dataLength - 1;
|
|
int num = 0;
|
|
while (i >= 0)
|
|
{
|
|
this.data[num] = inData[i];
|
|
i--;
|
|
num++;
|
|
}
|
|
while (this.dataLength > 1 && this.data[this.dataLength - 1] == 0U)
|
|
{
|
|
this.dataLength--;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000020 RID: 32 RVA: 0x00002B08 File Offset: 0x00000D08
|
|
public static implicit operator BigInteger(long value)
|
|
{
|
|
return new BigInteger(value);
|
|
}
|
|
|
|
// Token: 0x06000021 RID: 33 RVA: 0x00002B20 File Offset: 0x00000D20
|
|
public static implicit operator BigInteger(ulong value)
|
|
{
|
|
return new BigInteger(value);
|
|
}
|
|
|
|
// Token: 0x06000022 RID: 34 RVA: 0x00002B38 File Offset: 0x00000D38
|
|
public static implicit operator BigInteger(int value)
|
|
{
|
|
return new BigInteger((long)value);
|
|
}
|
|
|
|
// Token: 0x06000023 RID: 35 RVA: 0x00002B54 File Offset: 0x00000D54
|
|
public static implicit operator BigInteger(uint value)
|
|
{
|
|
return new BigInteger((ulong)value);
|
|
}
|
|
|
|
// Token: 0x06000024 RID: 36 RVA: 0x00002B70 File Offset: 0x00000D70
|
|
public static BigInteger operator +(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
BigInteger bigInteger = new BigInteger();
|
|
bigInteger.dataLength = ((bi1.dataLength > bi2.dataLength) ? bi1.dataLength : bi2.dataLength);
|
|
long num = 0L;
|
|
for (int i = 0; i < bigInteger.dataLength; i++)
|
|
{
|
|
long num2 = (long)((ulong)bi1.data[i] + (ulong)bi2.data[i] + (ulong)num);
|
|
num = num2 >> 32;
|
|
bigInteger.data[i] = (uint)(num2 & (long)((ulong)(-1)));
|
|
}
|
|
bool flag = num != 0L && bigInteger.dataLength < 70;
|
|
if (flag)
|
|
{
|
|
bigInteger.data[bigInteger.dataLength] = (uint)num;
|
|
bigInteger.dataLength++;
|
|
}
|
|
while (bigInteger.dataLength > 1 && bigInteger.data[bigInteger.dataLength - 1] == 0U)
|
|
{
|
|
bigInteger.dataLength--;
|
|
}
|
|
int num3 = 69;
|
|
bool flag2 = (bi1.data[num3] & 2147483648U) == (bi2.data[num3] & 2147483648U) && (bigInteger.data[num3] & 2147483648U) != (bi1.data[num3] & 2147483648U);
|
|
if (flag2)
|
|
{
|
|
throw new ArithmeticException();
|
|
}
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x06000025 RID: 37 RVA: 0x00002CB0 File Offset: 0x00000EB0
|
|
public static BigInteger operator ++(BigInteger bi1)
|
|
{
|
|
BigInteger bigInteger = new BigInteger(bi1);
|
|
long num = 1L;
|
|
int num2 = 0;
|
|
while (num != 0L && num2 < 70)
|
|
{
|
|
long num3 = (long)((ulong)bigInteger.data[num2]);
|
|
num3 += 1L;
|
|
bigInteger.data[num2] = (uint)(num3 & (long)((ulong)(-1)));
|
|
num = num3 >> 32;
|
|
num2++;
|
|
}
|
|
bool flag = num2 > bigInteger.dataLength;
|
|
if (flag)
|
|
{
|
|
bigInteger.dataLength = num2;
|
|
}
|
|
else
|
|
{
|
|
while (bigInteger.dataLength > 1 && bigInteger.data[bigInteger.dataLength - 1] == 0U)
|
|
{
|
|
bigInteger.dataLength--;
|
|
}
|
|
}
|
|
int num4 = 69;
|
|
bool flag2 = (bi1.data[num4] & 2147483648U) == 0U && (bigInteger.data[num4] & 2147483648U) != (bi1.data[num4] & 2147483648U);
|
|
if (flag2)
|
|
{
|
|
throw new ArithmeticException("Overflow in ++.");
|
|
}
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x06000026 RID: 38 RVA: 0x00002DA8 File Offset: 0x00000FA8
|
|
public static BigInteger operator -(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
BigInteger bigInteger = new BigInteger();
|
|
bigInteger.dataLength = ((bi1.dataLength > bi2.dataLength) ? bi1.dataLength : bi2.dataLength);
|
|
long num = 0L;
|
|
for (int i = 0; i < bigInteger.dataLength; i++)
|
|
{
|
|
long num2 = (long)((ulong)bi1.data[i] - (ulong)bi2.data[i] - (ulong)num);
|
|
bigInteger.data[i] = (uint)(num2 & (long)((ulong)(-1)));
|
|
bool flag = num2 < 0L;
|
|
if (flag)
|
|
{
|
|
num = 1L;
|
|
}
|
|
else
|
|
{
|
|
num = 0L;
|
|
}
|
|
}
|
|
bool flag2 = num != 0L;
|
|
if (flag2)
|
|
{
|
|
for (int j = bigInteger.dataLength; j < 70; j++)
|
|
{
|
|
bigInteger.data[j] = uint.MaxValue;
|
|
}
|
|
bigInteger.dataLength = 70;
|
|
}
|
|
while (bigInteger.dataLength > 1 && bigInteger.data[bigInteger.dataLength - 1] == 0U)
|
|
{
|
|
bigInteger.dataLength--;
|
|
}
|
|
int num3 = 69;
|
|
bool flag3 = (bi1.data[num3] & 2147483648U) != (bi2.data[num3] & 2147483648U) && (bigInteger.data[num3] & 2147483648U) != (bi1.data[num3] & 2147483648U);
|
|
if (flag3)
|
|
{
|
|
throw new ArithmeticException();
|
|
}
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x06000027 RID: 39 RVA: 0x00002EFC File Offset: 0x000010FC
|
|
public static BigInteger operator --(BigInteger bi1)
|
|
{
|
|
BigInteger bigInteger = new BigInteger(bi1);
|
|
bool flag = true;
|
|
int num = 0;
|
|
while (flag && num < 70)
|
|
{
|
|
long num2 = (long)((ulong)bigInteger.data[num]);
|
|
num2 -= 1L;
|
|
bigInteger.data[num] = (uint)(num2 & (long)((ulong)(-1)));
|
|
bool flag2 = num2 >= 0L;
|
|
if (flag2)
|
|
{
|
|
flag = false;
|
|
}
|
|
num++;
|
|
}
|
|
bool flag3 = num > bigInteger.dataLength;
|
|
if (flag3)
|
|
{
|
|
bigInteger.dataLength = num;
|
|
}
|
|
while (bigInteger.dataLength > 1 && bigInteger.data[bigInteger.dataLength - 1] == 0U)
|
|
{
|
|
bigInteger.dataLength--;
|
|
}
|
|
int num3 = 69;
|
|
bool flag4 = (bi1.data[num3] & 2147483648U) != 0U && (bigInteger.data[num3] & 2147483648U) != (bi1.data[num3] & 2147483648U);
|
|
if (flag4)
|
|
{
|
|
throw new ArithmeticException("Underflow in --.");
|
|
}
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x06000028 RID: 40 RVA: 0x00002FF8 File Offset: 0x000011F8
|
|
public static BigInteger operator *(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
int num = 69;
|
|
bool flag = false;
|
|
bool flag2 = false;
|
|
try
|
|
{
|
|
bool flag3 = (bi1.data[num] & 2147483648U) > 0U;
|
|
if (flag3)
|
|
{
|
|
flag = true;
|
|
bi1 = -bi1;
|
|
}
|
|
bool flag4 = (bi2.data[num] & 2147483648U) > 0U;
|
|
if (flag4)
|
|
{
|
|
flag2 = true;
|
|
bi2 = -bi2;
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
BigInteger bigInteger = new BigInteger();
|
|
try
|
|
{
|
|
for (int i = 0; i < bi1.dataLength; i++)
|
|
{
|
|
bool flag5 = bi1.data[i] == 0U;
|
|
if (!flag5)
|
|
{
|
|
ulong num2 = 0UL;
|
|
int j = 0;
|
|
int num3 = i;
|
|
while (j < bi2.dataLength)
|
|
{
|
|
ulong num4 = (ulong)bi1.data[i] * (ulong)bi2.data[j] + (ulong)bigInteger.data[num3] + num2;
|
|
bigInteger.data[num3] = (uint)(num4 & (ulong)(-1));
|
|
num2 = num4 >> 32;
|
|
j++;
|
|
num3++;
|
|
}
|
|
bool flag6 = num2 > 0UL;
|
|
if (flag6)
|
|
{
|
|
bigInteger.data[i + bi2.dataLength] = (uint)num2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new ArithmeticException("Multiplication overflow.");
|
|
}
|
|
bigInteger.dataLength = bi1.dataLength + bi2.dataLength;
|
|
bool flag7 = bigInteger.dataLength > 70;
|
|
if (flag7)
|
|
{
|
|
bigInteger.dataLength = 70;
|
|
}
|
|
while (bigInteger.dataLength > 1 && bigInteger.data[bigInteger.dataLength - 1] == 0U)
|
|
{
|
|
bigInteger.dataLength--;
|
|
}
|
|
bool flag8 = (bigInteger.data[num] & 2147483648U) > 0U;
|
|
if (flag8)
|
|
{
|
|
bool flag9 = flag != flag2 && bigInteger.data[num] == 2147483648U;
|
|
if (flag9)
|
|
{
|
|
bool flag10 = bigInteger.dataLength == 1;
|
|
if (flag10)
|
|
{
|
|
return bigInteger;
|
|
}
|
|
bool flag11 = true;
|
|
int num5 = 0;
|
|
while (num5 < bigInteger.dataLength - 1 && flag11)
|
|
{
|
|
bool flag12 = bigInteger.data[num5] > 0U;
|
|
if (flag12)
|
|
{
|
|
flag11 = false;
|
|
}
|
|
num5++;
|
|
}
|
|
bool flag13 = flag11;
|
|
if (flag13)
|
|
{
|
|
return bigInteger;
|
|
}
|
|
}
|
|
throw new ArithmeticException("Multiplication overflow.");
|
|
}
|
|
bool flag14 = flag != flag2;
|
|
BigInteger bigInteger2;
|
|
if (flag14)
|
|
{
|
|
bigInteger2 = -bigInteger;
|
|
}
|
|
else
|
|
{
|
|
bigInteger2 = bigInteger;
|
|
}
|
|
return bigInteger2;
|
|
}
|
|
|
|
// Token: 0x06000029 RID: 41 RVA: 0x0000326C File Offset: 0x0000146C
|
|
public static BigInteger operator <<(BigInteger bi1, int shiftVal)
|
|
{
|
|
BigInteger bigInteger = new BigInteger(bi1);
|
|
bigInteger.dataLength = BigInteger.shiftLeft(bigInteger.data, shiftVal);
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x0600002A RID: 42 RVA: 0x00003298 File Offset: 0x00001498
|
|
private static int shiftLeft(uint[] buffer, int shiftVal)
|
|
{
|
|
int num = 32;
|
|
int num2 = buffer.Length;
|
|
while (num2 > 1 && buffer[num2 - 1] == 0U)
|
|
{
|
|
num2--;
|
|
}
|
|
for (int i = shiftVal; i > 0; i -= num)
|
|
{
|
|
bool flag = i < num;
|
|
if (flag)
|
|
{
|
|
num = i;
|
|
}
|
|
ulong num3 = 0UL;
|
|
for (int j = 0; j < num2; j++)
|
|
{
|
|
ulong num4 = (ulong)buffer[j] << num;
|
|
num4 |= num3;
|
|
buffer[j] = (uint)(num4 & (ulong)(-1));
|
|
num3 = num4 >> 32;
|
|
}
|
|
bool flag2 = num3 > 0UL;
|
|
if (flag2)
|
|
{
|
|
bool flag3 = num2 + 1 <= buffer.Length;
|
|
if (flag3)
|
|
{
|
|
buffer[num2] = (uint)num3;
|
|
num2++;
|
|
}
|
|
}
|
|
}
|
|
return num2;
|
|
}
|
|
|
|
// Token: 0x0600002B RID: 43 RVA: 0x0000335C File Offset: 0x0000155C
|
|
public static BigInteger operator >>(BigInteger bi1, int shiftVal)
|
|
{
|
|
BigInteger bigInteger = new BigInteger(bi1);
|
|
bigInteger.dataLength = BigInteger.shiftRight(bigInteger.data, shiftVal);
|
|
bool flag = (bi1.data[69] & 2147483648U) > 0U;
|
|
if (flag)
|
|
{
|
|
for (int i = 69; i >= bigInteger.dataLength; i--)
|
|
{
|
|
bigInteger.data[i] = uint.MaxValue;
|
|
}
|
|
uint num = 2147483648U;
|
|
for (int j = 0; j < 32; j++)
|
|
{
|
|
bool flag2 = (bigInteger.data[bigInteger.dataLength - 1] & num) > 0U;
|
|
if (flag2)
|
|
{
|
|
break;
|
|
}
|
|
bigInteger.data[bigInteger.dataLength - 1] |= num;
|
|
num >>= 1;
|
|
}
|
|
bigInteger.dataLength = 70;
|
|
}
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x0600002C RID: 44 RVA: 0x00003428 File Offset: 0x00001628
|
|
private static int shiftRight(uint[] buffer, int shiftVal)
|
|
{
|
|
int num = 32;
|
|
int num2 = 0;
|
|
int num3 = buffer.Length;
|
|
while (num3 > 1 && buffer[num3 - 1] == 0U)
|
|
{
|
|
num3--;
|
|
}
|
|
for (int i = shiftVal; i > 0; i -= num)
|
|
{
|
|
bool flag = i < num;
|
|
if (flag)
|
|
{
|
|
num = i;
|
|
num2 = 32 - num;
|
|
}
|
|
ulong num4 = 0UL;
|
|
for (int j = num3 - 1; j >= 0; j--)
|
|
{
|
|
ulong num5 = (ulong)buffer[j] >> num;
|
|
num5 |= num4;
|
|
num4 = (ulong)buffer[j] << num2;
|
|
buffer[j] = (uint)num5;
|
|
}
|
|
}
|
|
while (num3 > 1 && buffer[num3 - 1] == 0U)
|
|
{
|
|
num3--;
|
|
}
|
|
return num3;
|
|
}
|
|
|
|
// Token: 0x0600002D RID: 45 RVA: 0x000034F0 File Offset: 0x000016F0
|
|
public static BigInteger operator ~(BigInteger bi1)
|
|
{
|
|
BigInteger bigInteger = new BigInteger(bi1);
|
|
for (int i = 0; i < 70; i++)
|
|
{
|
|
bigInteger.data[i] = ~bi1.data[i];
|
|
}
|
|
bigInteger.dataLength = 70;
|
|
while (bigInteger.dataLength > 1 && bigInteger.data[bigInteger.dataLength - 1] == 0U)
|
|
{
|
|
bigInteger.dataLength--;
|
|
}
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x0600002E RID: 46 RVA: 0x00003568 File Offset: 0x00001768
|
|
public static BigInteger operator -(BigInteger bi1)
|
|
{
|
|
bool flag = bi1.dataLength == 1 && bi1.data[0] == 0U;
|
|
BigInteger bigInteger;
|
|
if (flag)
|
|
{
|
|
bigInteger = new BigInteger();
|
|
}
|
|
else
|
|
{
|
|
BigInteger bigInteger2 = new BigInteger(bi1);
|
|
for (int i = 0; i < 70; i++)
|
|
{
|
|
bigInteger2.data[i] = ~bi1.data[i];
|
|
}
|
|
long num = 1L;
|
|
int num2 = 0;
|
|
while (num != 0L && num2 < 70)
|
|
{
|
|
long num3 = (long)((ulong)bigInteger2.data[num2]);
|
|
num3 += 1L;
|
|
bigInteger2.data[num2] = (uint)(num3 & (long)((ulong)(-1)));
|
|
num = num3 >> 32;
|
|
num2++;
|
|
}
|
|
bool flag2 = (bi1.data[69] & 2147483648U) == (bigInteger2.data[69] & 2147483648U);
|
|
if (flag2)
|
|
{
|
|
throw new ArithmeticException("Overflow in negation.\n");
|
|
}
|
|
bigInteger2.dataLength = 70;
|
|
while (bigInteger2.dataLength > 1 && bigInteger2.data[bigInteger2.dataLength - 1] == 0U)
|
|
{
|
|
bigInteger2.dataLength--;
|
|
}
|
|
bigInteger = bigInteger2;
|
|
}
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x0600002F RID: 47 RVA: 0x00003684 File Offset: 0x00001884
|
|
public static bool operator ==(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
return bi1.Equals(bi2);
|
|
}
|
|
|
|
// Token: 0x06000030 RID: 48 RVA: 0x000036A0 File Offset: 0x000018A0
|
|
public static bool operator !=(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
return !bi1.Equals(bi2);
|
|
}
|
|
|
|
// Token: 0x06000031 RID: 49 RVA: 0x000036BC File Offset: 0x000018BC
|
|
public override bool Equals(object o)
|
|
{
|
|
BigInteger bigInteger = (BigInteger)o;
|
|
bool flag = this.dataLength != bigInteger.dataLength;
|
|
bool flag2;
|
|
if (flag)
|
|
{
|
|
flag2 = false;
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < this.dataLength; i++)
|
|
{
|
|
bool flag3 = this.data[i] != bigInteger.data[i];
|
|
if (flag3)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
flag2 = true;
|
|
}
|
|
return flag2;
|
|
}
|
|
|
|
// Token: 0x06000032 RID: 50 RVA: 0x00003728 File Offset: 0x00001928
|
|
public override int GetHashCode()
|
|
{
|
|
return this.ToString().GetHashCode();
|
|
}
|
|
|
|
// Token: 0x06000033 RID: 51 RVA: 0x00003748 File Offset: 0x00001948
|
|
public static bool operator >(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
int num = 69;
|
|
bool flag = (bi1.data[num] & 2147483648U) != 0U && (bi2.data[num] & 2147483648U) == 0U;
|
|
bool flag2;
|
|
if (flag)
|
|
{
|
|
flag2 = false;
|
|
}
|
|
else
|
|
{
|
|
bool flag3 = (bi1.data[num] & 2147483648U) == 0U && (bi2.data[num] & 2147483648U) > 0U;
|
|
if (flag3)
|
|
{
|
|
flag2 = true;
|
|
}
|
|
else
|
|
{
|
|
int num2 = ((bi1.dataLength > bi2.dataLength) ? bi1.dataLength : bi2.dataLength);
|
|
num = num2 - 1;
|
|
while (num >= 0 && bi1.data[num] == bi2.data[num])
|
|
{
|
|
num--;
|
|
}
|
|
bool flag4 = num >= 0;
|
|
if (flag4)
|
|
{
|
|
bool flag5 = bi1.data[num] > bi2.data[num];
|
|
flag2 = flag5;
|
|
}
|
|
else
|
|
{
|
|
flag2 = false;
|
|
}
|
|
}
|
|
}
|
|
return flag2;
|
|
}
|
|
|
|
// Token: 0x06000034 RID: 52 RVA: 0x00003830 File Offset: 0x00001A30
|
|
public static bool operator <(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
int num = 69;
|
|
bool flag = (bi1.data[num] & 2147483648U) != 0U && (bi2.data[num] & 2147483648U) == 0U;
|
|
bool flag2;
|
|
if (flag)
|
|
{
|
|
flag2 = true;
|
|
}
|
|
else
|
|
{
|
|
bool flag3 = (bi1.data[num] & 2147483648U) == 0U && (bi2.data[num] & 2147483648U) > 0U;
|
|
if (flag3)
|
|
{
|
|
flag2 = false;
|
|
}
|
|
else
|
|
{
|
|
int num2 = ((bi1.dataLength > bi2.dataLength) ? bi1.dataLength : bi2.dataLength);
|
|
num = num2 - 1;
|
|
while (num >= 0 && bi1.data[num] == bi2.data[num])
|
|
{
|
|
num--;
|
|
}
|
|
bool flag4 = num >= 0;
|
|
if (flag4)
|
|
{
|
|
bool flag5 = bi1.data[num] < bi2.data[num];
|
|
flag2 = flag5;
|
|
}
|
|
else
|
|
{
|
|
flag2 = false;
|
|
}
|
|
}
|
|
}
|
|
return flag2;
|
|
}
|
|
|
|
// Token: 0x06000035 RID: 53 RVA: 0x00003918 File Offset: 0x00001B18
|
|
public static bool operator >=(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
return bi1 == bi2 || bi1 > bi2;
|
|
}
|
|
|
|
// Token: 0x06000036 RID: 54 RVA: 0x00003940 File Offset: 0x00001B40
|
|
public static bool operator <=(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
return bi1 == bi2 || bi1 < bi2;
|
|
}
|
|
|
|
// Token: 0x06000037 RID: 55 RVA: 0x00003968 File Offset: 0x00001B68
|
|
private static void multiByteDivide(BigInteger bi1, BigInteger bi2, BigInteger outQuotient, BigInteger outRemainder)
|
|
{
|
|
uint[] array = new uint[70];
|
|
int num = bi1.dataLength + 1;
|
|
uint[] array2 = new uint[num];
|
|
uint num2 = 2147483648U;
|
|
uint num3 = bi2.data[bi2.dataLength - 1];
|
|
int num4 = 0;
|
|
int num5 = 0;
|
|
while (num2 != 0U && (num3 & num2) == 0U)
|
|
{
|
|
num4++;
|
|
num2 >>= 1;
|
|
}
|
|
for (int i = 0; i < bi1.dataLength; i++)
|
|
{
|
|
array2[i] = bi1.data[i];
|
|
}
|
|
BigInteger.shiftLeft(array2, num4);
|
|
bi2 <<= num4;
|
|
int j = num - bi2.dataLength;
|
|
int num6 = num - 1;
|
|
ulong num7 = (ulong)bi2.data[bi2.dataLength - 1];
|
|
ulong num8 = (ulong)bi2.data[bi2.dataLength - 2];
|
|
int num9 = bi2.dataLength + 1;
|
|
uint[] array3 = new uint[num9];
|
|
while (j > 0)
|
|
{
|
|
ulong num10 = ((ulong)array2[num6] << 32) + (ulong)array2[num6 - 1];
|
|
ulong num11 = num10 / num7;
|
|
ulong num12 = num10 % num7;
|
|
bool flag = false;
|
|
while (!flag)
|
|
{
|
|
flag = true;
|
|
bool flag2 = num11 == 4294967296UL || num11 * num8 > (num12 << 32) + (ulong)array2[num6 - 2];
|
|
if (flag2)
|
|
{
|
|
num11 -= 1UL;
|
|
num12 += num7;
|
|
bool flag3 = num12 < 4294967296UL;
|
|
if (flag3)
|
|
{
|
|
flag = false;
|
|
}
|
|
}
|
|
}
|
|
for (int k = 0; k < num9; k++)
|
|
{
|
|
array3[k] = array2[num6 - k];
|
|
}
|
|
BigInteger bigInteger = new BigInteger(array3);
|
|
BigInteger bigInteger2 = bi2 * (long)num11;
|
|
while (bigInteger2 > bigInteger)
|
|
{
|
|
num11 -= 1UL;
|
|
bigInteger2 -= bi2;
|
|
}
|
|
BigInteger bigInteger3 = bigInteger - bigInteger2;
|
|
for (int l = 0; l < num9; l++)
|
|
{
|
|
array2[num6 - l] = bigInteger3.data[bi2.dataLength - l];
|
|
}
|
|
array[num5++] = (uint)num11;
|
|
num6--;
|
|
j--;
|
|
}
|
|
outQuotient.dataLength = num5;
|
|
int m = 0;
|
|
int n = outQuotient.dataLength - 1;
|
|
while (n >= 0)
|
|
{
|
|
outQuotient.data[m] = array[n];
|
|
n--;
|
|
m++;
|
|
}
|
|
while (m < 70)
|
|
{
|
|
outQuotient.data[m] = 0U;
|
|
m++;
|
|
}
|
|
while (outQuotient.dataLength > 1 && outQuotient.data[outQuotient.dataLength - 1] == 0U)
|
|
{
|
|
outQuotient.dataLength--;
|
|
}
|
|
bool flag4 = outQuotient.dataLength == 0;
|
|
if (flag4)
|
|
{
|
|
outQuotient.dataLength = 1;
|
|
}
|
|
outRemainder.dataLength = BigInteger.shiftRight(array2, num4);
|
|
for (m = 0; m < outRemainder.dataLength; m++)
|
|
{
|
|
outRemainder.data[m] = array2[m];
|
|
}
|
|
while (m < 70)
|
|
{
|
|
outRemainder.data[m] = 0U;
|
|
m++;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000038 RID: 56 RVA: 0x00003C94 File Offset: 0x00001E94
|
|
private static void singleByteDivide(BigInteger bi1, BigInteger bi2, BigInteger outQuotient, BigInteger outRemainder)
|
|
{
|
|
uint[] array = new uint[70];
|
|
int num = 0;
|
|
for (int i = 0; i < 70; i++)
|
|
{
|
|
outRemainder.data[i] = bi1.data[i];
|
|
}
|
|
outRemainder.dataLength = bi1.dataLength;
|
|
while (outRemainder.dataLength > 1 && outRemainder.data[outRemainder.dataLength - 1] == 0U)
|
|
{
|
|
outRemainder.dataLength--;
|
|
}
|
|
ulong num2 = (ulong)bi2.data[0];
|
|
int j = outRemainder.dataLength - 1;
|
|
ulong num3 = (ulong)outRemainder.data[j];
|
|
bool flag = num3 >= num2;
|
|
if (flag)
|
|
{
|
|
ulong num4 = num3 / num2;
|
|
array[num++] = (uint)num4;
|
|
outRemainder.data[j] = (uint)(num3 % num2);
|
|
}
|
|
j--;
|
|
while (j >= 0)
|
|
{
|
|
num3 = ((ulong)outRemainder.data[j + 1] << 32) + (ulong)outRemainder.data[j];
|
|
ulong num5 = num3 / num2;
|
|
array[num++] = (uint)num5;
|
|
outRemainder.data[j + 1] = 0U;
|
|
outRemainder.data[j--] = (uint)(num3 % num2);
|
|
}
|
|
outQuotient.dataLength = num;
|
|
int k = 0;
|
|
int l = outQuotient.dataLength - 1;
|
|
while (l >= 0)
|
|
{
|
|
outQuotient.data[k] = array[l];
|
|
l--;
|
|
k++;
|
|
}
|
|
while (k < 70)
|
|
{
|
|
outQuotient.data[k] = 0U;
|
|
k++;
|
|
}
|
|
while (outQuotient.dataLength > 1 && outQuotient.data[outQuotient.dataLength - 1] == 0U)
|
|
{
|
|
outQuotient.dataLength--;
|
|
}
|
|
bool flag2 = outQuotient.dataLength == 0;
|
|
if (flag2)
|
|
{
|
|
outQuotient.dataLength = 1;
|
|
}
|
|
while (outRemainder.dataLength > 1 && outRemainder.data[outRemainder.dataLength - 1] == 0U)
|
|
{
|
|
outRemainder.dataLength--;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000039 RID: 57 RVA: 0x00003E94 File Offset: 0x00002094
|
|
public static BigInteger operator /(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
BigInteger bigInteger = new BigInteger();
|
|
BigInteger bigInteger2 = new BigInteger();
|
|
int num = 69;
|
|
bool flag = false;
|
|
bool flag2 = false;
|
|
bool flag3 = (bi1.data[num] & 2147483648U) > 0U;
|
|
if (flag3)
|
|
{
|
|
bi1 = -bi1;
|
|
flag2 = true;
|
|
}
|
|
bool flag4 = (bi2.data[num] & 2147483648U) > 0U;
|
|
if (flag4)
|
|
{
|
|
bi2 = -bi2;
|
|
flag = true;
|
|
}
|
|
bool flag5 = bi1 < bi2;
|
|
BigInteger bigInteger3;
|
|
if (flag5)
|
|
{
|
|
bigInteger3 = bigInteger;
|
|
}
|
|
else
|
|
{
|
|
bool flag6 = bi2.dataLength == 1;
|
|
if (flag6)
|
|
{
|
|
BigInteger.singleByteDivide(bi1, bi2, bigInteger, bigInteger2);
|
|
}
|
|
else
|
|
{
|
|
BigInteger.multiByteDivide(bi1, bi2, bigInteger, bigInteger2);
|
|
}
|
|
bool flag7 = flag2 != flag;
|
|
if (flag7)
|
|
{
|
|
bigInteger3 = -bigInteger;
|
|
}
|
|
else
|
|
{
|
|
bigInteger3 = bigInteger;
|
|
}
|
|
}
|
|
return bigInteger3;
|
|
}
|
|
|
|
// Token: 0x0600003A RID: 58 RVA: 0x00003F58 File Offset: 0x00002158
|
|
public static BigInteger operator %(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
BigInteger bigInteger = new BigInteger();
|
|
BigInteger bigInteger2 = new BigInteger(bi1);
|
|
int num = 69;
|
|
bool flag = false;
|
|
bool flag2 = (bi1.data[num] & 2147483648U) > 0U;
|
|
if (flag2)
|
|
{
|
|
bi1 = -bi1;
|
|
flag = true;
|
|
}
|
|
bool flag3 = (bi2.data[num] & 2147483648U) > 0U;
|
|
if (flag3)
|
|
{
|
|
bi2 = -bi2;
|
|
}
|
|
bool flag4 = bi1 < bi2;
|
|
BigInteger bigInteger3;
|
|
if (flag4)
|
|
{
|
|
bigInteger3 = bigInteger2;
|
|
}
|
|
else
|
|
{
|
|
bool flag5 = bi2.dataLength == 1;
|
|
if (flag5)
|
|
{
|
|
BigInteger.singleByteDivide(bi1, bi2, bigInteger, bigInteger2);
|
|
}
|
|
else
|
|
{
|
|
BigInteger.multiByteDivide(bi1, bi2, bigInteger, bigInteger2);
|
|
}
|
|
bool flag6 = flag;
|
|
if (flag6)
|
|
{
|
|
bigInteger3 = -bigInteger2;
|
|
}
|
|
else
|
|
{
|
|
bigInteger3 = bigInteger2;
|
|
}
|
|
}
|
|
return bigInteger3;
|
|
}
|
|
|
|
// Token: 0x0600003B RID: 59 RVA: 0x0000400C File Offset: 0x0000220C
|
|
public static BigInteger operator &(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
BigInteger bigInteger = new BigInteger();
|
|
int num = ((bi1.dataLength > bi2.dataLength) ? bi1.dataLength : bi2.dataLength);
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
uint num2 = bi1.data[i] & bi2.data[i];
|
|
bigInteger.data[i] = num2;
|
|
}
|
|
bigInteger.dataLength = 70;
|
|
while (bigInteger.dataLength > 1 && bigInteger.data[bigInteger.dataLength - 1] == 0U)
|
|
{
|
|
bigInteger.dataLength--;
|
|
}
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x0600003C RID: 60 RVA: 0x000040B0 File Offset: 0x000022B0
|
|
public static BigInteger operator |(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
BigInteger bigInteger = new BigInteger();
|
|
int num = ((bi1.dataLength > bi2.dataLength) ? bi1.dataLength : bi2.dataLength);
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
uint num2 = bi1.data[i] | bi2.data[i];
|
|
bigInteger.data[i] = num2;
|
|
}
|
|
bigInteger.dataLength = 70;
|
|
while (bigInteger.dataLength > 1 && bigInteger.data[bigInteger.dataLength - 1] == 0U)
|
|
{
|
|
bigInteger.dataLength--;
|
|
}
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x0600003D RID: 61 RVA: 0x00004154 File Offset: 0x00002354
|
|
public static BigInteger operator ^(BigInteger bi1, BigInteger bi2)
|
|
{
|
|
BigInteger bigInteger = new BigInteger();
|
|
int num = ((bi1.dataLength > bi2.dataLength) ? bi1.dataLength : bi2.dataLength);
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
uint num2 = bi1.data[i] ^ bi2.data[i];
|
|
bigInteger.data[i] = num2;
|
|
}
|
|
bigInteger.dataLength = 70;
|
|
while (bigInteger.dataLength > 1 && bigInteger.data[bigInteger.dataLength - 1] == 0U)
|
|
{
|
|
bigInteger.dataLength--;
|
|
}
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x0600003E RID: 62 RVA: 0x000041F8 File Offset: 0x000023F8
|
|
public BigInteger max(BigInteger bi)
|
|
{
|
|
bool flag = this > bi;
|
|
BigInteger bigInteger;
|
|
if (flag)
|
|
{
|
|
bigInteger = new BigInteger(this);
|
|
}
|
|
else
|
|
{
|
|
bigInteger = new BigInteger(bi);
|
|
}
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x0600003F RID: 63 RVA: 0x00004224 File Offset: 0x00002424
|
|
public BigInteger min(BigInteger bi)
|
|
{
|
|
bool flag = this < bi;
|
|
BigInteger bigInteger;
|
|
if (flag)
|
|
{
|
|
bigInteger = new BigInteger(this);
|
|
}
|
|
else
|
|
{
|
|
bigInteger = new BigInteger(bi);
|
|
}
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x06000040 RID: 64 RVA: 0x00004250 File Offset: 0x00002450
|
|
public BigInteger abs()
|
|
{
|
|
bool flag = (this.data[69] & 2147483648U) > 0U;
|
|
BigInteger bigInteger;
|
|
if (flag)
|
|
{
|
|
bigInteger = -this;
|
|
}
|
|
else
|
|
{
|
|
bigInteger = new BigInteger(this);
|
|
}
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x06000041 RID: 65 RVA: 0x00004288 File Offset: 0x00002488
|
|
public override string ToString()
|
|
{
|
|
return this.ToString(10);
|
|
}
|
|
|
|
// Token: 0x06000042 RID: 66 RVA: 0x000042A4 File Offset: 0x000024A4
|
|
public string ToString(int radix)
|
|
{
|
|
bool flag = radix < 2 || radix > 36;
|
|
if (flag)
|
|
{
|
|
throw new ArgumentException("Radix must be >= 2 and <= 36");
|
|
}
|
|
string text = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
|
string text2 = "";
|
|
BigInteger bigInteger = this;
|
|
bool flag2 = false;
|
|
bool flag3 = (bigInteger.data[69] & 2147483648U) > 0U;
|
|
if (flag3)
|
|
{
|
|
flag2 = true;
|
|
try
|
|
{
|
|
bigInteger = -bigInteger;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
}
|
|
BigInteger bigInteger2 = new BigInteger();
|
|
BigInteger bigInteger3 = new BigInteger();
|
|
BigInteger bigInteger4 = new BigInteger((long)radix);
|
|
bool flag4 = bigInteger.dataLength == 1 && bigInteger.data[0] == 0U;
|
|
if (flag4)
|
|
{
|
|
text2 = "0";
|
|
}
|
|
else
|
|
{
|
|
while (bigInteger.dataLength > 1 || (bigInteger.dataLength == 1 && bigInteger.data[0] > 0U))
|
|
{
|
|
BigInteger.singleByteDivide(bigInteger, bigInteger4, bigInteger2, bigInteger3);
|
|
bool flag5 = bigInteger3.data[0] < 10U;
|
|
if (flag5)
|
|
{
|
|
text2 = bigInteger3.data[0] + text2;
|
|
}
|
|
else
|
|
{
|
|
text2 = text[(int)(bigInteger3.data[0] - 10U)].ToString() + text2;
|
|
}
|
|
bigInteger = bigInteger2;
|
|
}
|
|
bool flag6 = flag2;
|
|
if (flag6)
|
|
{
|
|
text2 = "-" + text2;
|
|
}
|
|
}
|
|
return text2;
|
|
}
|
|
|
|
// Token: 0x06000043 RID: 67 RVA: 0x00004404 File Offset: 0x00002604
|
|
public string ToHexString()
|
|
{
|
|
string text = this.data[this.dataLength - 1].ToString("X");
|
|
for (int i = this.dataLength - 2; i >= 0; i--)
|
|
{
|
|
text += this.data[i].ToString("X8");
|
|
}
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x06000044 RID: 68 RVA: 0x00004470 File Offset: 0x00002670
|
|
public BigInteger ModPow(BigInteger exp, BigInteger n)
|
|
{
|
|
bool flag = (exp.data[69] & 2147483648U) > 0U;
|
|
if (flag)
|
|
{
|
|
throw new ArithmeticException("Positive exponents only.");
|
|
}
|
|
BigInteger bigInteger = 1;
|
|
bool flag2 = false;
|
|
bool flag3 = (this.data[69] & 2147483648U) > 0U;
|
|
BigInteger bigInteger2;
|
|
if (flag3)
|
|
{
|
|
bigInteger2 = -this % n;
|
|
flag2 = true;
|
|
}
|
|
else
|
|
{
|
|
bigInteger2 = this % n;
|
|
}
|
|
bool flag4 = (n.data[69] & 2147483648U) > 0U;
|
|
if (flag4)
|
|
{
|
|
n = -n;
|
|
}
|
|
BigInteger bigInteger3 = new BigInteger();
|
|
int num = n.dataLength << 1;
|
|
bigInteger3.data[num] = 1U;
|
|
bigInteger3.dataLength = num + 1;
|
|
bigInteger3 /= n;
|
|
int num2 = exp.bitCount();
|
|
int num3 = 0;
|
|
for (int i = 0; i < exp.dataLength; i++)
|
|
{
|
|
uint num4 = 1U;
|
|
int j = 0;
|
|
while (j < 32)
|
|
{
|
|
bool flag5 = (exp.data[i] & num4) > 0U;
|
|
if (flag5)
|
|
{
|
|
bigInteger = this.BarrettReduction(bigInteger * bigInteger2, n, bigInteger3);
|
|
}
|
|
num4 <<= 1;
|
|
bigInteger2 = this.BarrettReduction(bigInteger2 * bigInteger2, n, bigInteger3);
|
|
bool flag6 = bigInteger2.dataLength == 1 && bigInteger2.data[0] == 1U;
|
|
if (flag6)
|
|
{
|
|
bool flag7 = flag2 && (exp.data[0] & 1U) > 0U;
|
|
if (flag7)
|
|
{
|
|
return -bigInteger;
|
|
}
|
|
return bigInteger;
|
|
}
|
|
else
|
|
{
|
|
num3++;
|
|
bool flag8 = num3 == num2;
|
|
if (flag8)
|
|
{
|
|
break;
|
|
}
|
|
j++;
|
|
}
|
|
}
|
|
}
|
|
bool flag9 = flag2 && (exp.data[0] & 1U) > 0U;
|
|
if (flag9)
|
|
{
|
|
return -bigInteger;
|
|
}
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x06000045 RID: 69 RVA: 0x00004638 File Offset: 0x00002838
|
|
private BigInteger BarrettReduction(BigInteger x, BigInteger n, BigInteger constant)
|
|
{
|
|
int num = n.dataLength;
|
|
int num2 = num + 1;
|
|
int num3 = num - 1;
|
|
BigInteger bigInteger = new BigInteger();
|
|
int i = num3;
|
|
int num4 = 0;
|
|
while (i < x.dataLength)
|
|
{
|
|
bigInteger.data[num4] = x.data[i];
|
|
i++;
|
|
num4++;
|
|
}
|
|
bigInteger.dataLength = x.dataLength - num3;
|
|
bool flag = bigInteger.dataLength <= 0;
|
|
if (flag)
|
|
{
|
|
bigInteger.dataLength = 1;
|
|
}
|
|
BigInteger bigInteger2 = bigInteger * constant;
|
|
BigInteger bigInteger3 = new BigInteger();
|
|
int j = num2;
|
|
int num5 = 0;
|
|
while (j < bigInteger2.dataLength)
|
|
{
|
|
bigInteger3.data[num5] = bigInteger2.data[j];
|
|
j++;
|
|
num5++;
|
|
}
|
|
bigInteger3.dataLength = bigInteger2.dataLength - num2;
|
|
bool flag2 = bigInteger3.dataLength <= 0;
|
|
if (flag2)
|
|
{
|
|
bigInteger3.dataLength = 1;
|
|
}
|
|
BigInteger bigInteger4 = new BigInteger();
|
|
int num6 = ((x.dataLength > num2) ? num2 : x.dataLength);
|
|
for (int k = 0; k < num6; k++)
|
|
{
|
|
bigInteger4.data[k] = x.data[k];
|
|
}
|
|
bigInteger4.dataLength = num6;
|
|
BigInteger bigInteger5 = new BigInteger();
|
|
for (int l = 0; l < bigInteger3.dataLength; l++)
|
|
{
|
|
bool flag3 = bigInteger3.data[l] == 0U;
|
|
if (!flag3)
|
|
{
|
|
ulong num7 = 0UL;
|
|
int num8 = l;
|
|
int num9 = 0;
|
|
while (num9 < n.dataLength && num8 < num2)
|
|
{
|
|
ulong num10 = (ulong)bigInteger3.data[l] * (ulong)n.data[num9] + (ulong)bigInteger5.data[num8] + num7;
|
|
bigInteger5.data[num8] = (uint)(num10 & (ulong)(-1));
|
|
num7 = num10 >> 32;
|
|
num9++;
|
|
num8++;
|
|
}
|
|
bool flag4 = num8 < num2;
|
|
if (flag4)
|
|
{
|
|
bigInteger5.data[num8] = (uint)num7;
|
|
}
|
|
}
|
|
}
|
|
bigInteger5.dataLength = num2;
|
|
while (bigInteger5.dataLength > 1 && bigInteger5.data[bigInteger5.dataLength - 1] == 0U)
|
|
{
|
|
bigInteger5.dataLength--;
|
|
}
|
|
bigInteger4 -= bigInteger5;
|
|
bool flag5 = (bigInteger4.data[69] & 2147483648U) > 0U;
|
|
if (flag5)
|
|
{
|
|
BigInteger bigInteger6 = new BigInteger();
|
|
bigInteger6.data[num2] = 1U;
|
|
bigInteger6.dataLength = num2 + 1;
|
|
bigInteger4 += bigInteger6;
|
|
}
|
|
while (bigInteger4 >= n)
|
|
{
|
|
bigInteger4 -= n;
|
|
}
|
|
return bigInteger4;
|
|
}
|
|
|
|
// Token: 0x06000046 RID: 70 RVA: 0x000048F4 File Offset: 0x00002AF4
|
|
public BigInteger gcd(BigInteger bi)
|
|
{
|
|
bool flag = (this.data[69] & 2147483648U) > 0U;
|
|
BigInteger bigInteger;
|
|
if (flag)
|
|
{
|
|
bigInteger = -this;
|
|
}
|
|
else
|
|
{
|
|
bigInteger = this;
|
|
}
|
|
bool flag2 = (bi.data[69] & 2147483648U) > 0U;
|
|
BigInteger bigInteger2;
|
|
if (flag2)
|
|
{
|
|
bigInteger2 = -bi;
|
|
}
|
|
else
|
|
{
|
|
bigInteger2 = bi;
|
|
}
|
|
BigInteger bigInteger3 = bigInteger2;
|
|
while (bigInteger.dataLength > 1 || (bigInteger.dataLength == 1 && bigInteger.data[0] > 0U))
|
|
{
|
|
bigInteger3 = bigInteger;
|
|
bigInteger = bigInteger2 % bigInteger;
|
|
bigInteger2 = bigInteger3;
|
|
}
|
|
return bigInteger3;
|
|
}
|
|
|
|
// Token: 0x06000047 RID: 71 RVA: 0x00004988 File Offset: 0x00002B88
|
|
public static BigInteger GenerateRandom(int bits)
|
|
{
|
|
BigInteger bigInteger = new BigInteger();
|
|
bigInteger.genRandomBits(bits, new Random());
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x06000048 RID: 72 RVA: 0x000049B0 File Offset: 0x00002BB0
|
|
public void genRandomBits(int bits, Random rand)
|
|
{
|
|
int num = bits >> 5;
|
|
int num2 = bits & 31;
|
|
bool flag = num2 != 0;
|
|
if (flag)
|
|
{
|
|
num++;
|
|
}
|
|
bool flag2 = num > 70;
|
|
if (flag2)
|
|
{
|
|
throw new ArithmeticException("Number of required bits > maxLength.");
|
|
}
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
this.data[i] = (uint)(rand.NextDouble() * 4294967296.0);
|
|
}
|
|
for (int j = num; j < 70; j++)
|
|
{
|
|
this.data[j] = 0U;
|
|
}
|
|
bool flag3 = num2 != 0;
|
|
if (flag3)
|
|
{
|
|
uint num3 = 1U << num2 - 1;
|
|
this.data[num - 1] |= num3;
|
|
num3 = uint.MaxValue >> 32 - num2;
|
|
this.data[num - 1] &= num3;
|
|
}
|
|
else
|
|
{
|
|
this.data[num - 1] |= 2147483648U;
|
|
}
|
|
this.dataLength = num;
|
|
bool flag4 = this.dataLength == 0;
|
|
if (flag4)
|
|
{
|
|
this.dataLength = 1;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000049 RID: 73 RVA: 0x00004AB8 File Offset: 0x00002CB8
|
|
public int bitCount()
|
|
{
|
|
while (this.dataLength > 1 && this.data[this.dataLength - 1] == 0U)
|
|
{
|
|
this.dataLength--;
|
|
}
|
|
uint num = this.data[this.dataLength - 1];
|
|
uint num2 = 2147483648U;
|
|
int num3 = 32;
|
|
while (num3 > 0 && (num & num2) == 0U)
|
|
{
|
|
num3--;
|
|
num2 >>= 1;
|
|
}
|
|
return num3 + (this.dataLength - 1 << 5);
|
|
}
|
|
|
|
// Token: 0x0600004A RID: 74 RVA: 0x00004B44 File Offset: 0x00002D44
|
|
public bool FermatLittleTest(int confidence)
|
|
{
|
|
bool flag = (this.data[69] & 2147483648U) > 0U;
|
|
BigInteger bigInteger;
|
|
if (flag)
|
|
{
|
|
bigInteger = -this;
|
|
}
|
|
else
|
|
{
|
|
bigInteger = this;
|
|
}
|
|
bool flag2 = bigInteger.dataLength == 1;
|
|
if (flag2)
|
|
{
|
|
bool flag3 = bigInteger.data[0] == 0U || bigInteger.data[0] == 1U;
|
|
if (flag3)
|
|
{
|
|
return false;
|
|
}
|
|
bool flag4 = bigInteger.data[0] == 2U || bigInteger.data[0] == 3U;
|
|
if (flag4)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
bool flag5 = (bigInteger.data[0] & 1U) == 0U;
|
|
bool flag6;
|
|
if (flag5)
|
|
{
|
|
flag6 = false;
|
|
}
|
|
else
|
|
{
|
|
int num = bigInteger.bitCount();
|
|
BigInteger bigInteger2 = new BigInteger();
|
|
BigInteger bigInteger3 = bigInteger - new BigInteger(1L);
|
|
Random random = new Random();
|
|
for (int i = 0; i < confidence; i++)
|
|
{
|
|
bool flag7 = false;
|
|
while (!flag7)
|
|
{
|
|
int j;
|
|
for (j = 0; j < 2; j = (int)(random.NextDouble() * (double)num))
|
|
{
|
|
}
|
|
bigInteger2.genRandomBits(j, random);
|
|
int num2 = bigInteger2.dataLength;
|
|
bool flag8 = num2 > 1 || (num2 == 1 && bigInteger2.data[0] != 1U);
|
|
if (flag8)
|
|
{
|
|
flag7 = true;
|
|
}
|
|
}
|
|
BigInteger bigInteger4 = bigInteger2.gcd(bigInteger);
|
|
bool flag9 = bigInteger4.dataLength == 1 && bigInteger4.data[0] != 1U;
|
|
if (flag9)
|
|
{
|
|
return false;
|
|
}
|
|
BigInteger bigInteger5 = bigInteger2.ModPow(bigInteger3, bigInteger);
|
|
int num3 = bigInteger5.dataLength;
|
|
bool flag10 = num3 > 1 || (num3 == 1 && bigInteger5.data[0] != 1U);
|
|
if (flag10)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
flag6 = true;
|
|
}
|
|
return flag6;
|
|
}
|
|
|
|
// Token: 0x0600004B RID: 75 RVA: 0x00004D0C File Offset: 0x00002F0C
|
|
public bool RabinMillerTest(int confidence)
|
|
{
|
|
bool flag = (this.data[69] & 2147483648U) > 0U;
|
|
BigInteger bigInteger;
|
|
if (flag)
|
|
{
|
|
bigInteger = -this;
|
|
}
|
|
else
|
|
{
|
|
bigInteger = this;
|
|
}
|
|
bool flag2 = bigInteger.dataLength == 1;
|
|
if (flag2)
|
|
{
|
|
bool flag3 = bigInteger.data[0] == 0U || bigInteger.data[0] == 1U;
|
|
if (flag3)
|
|
{
|
|
return false;
|
|
}
|
|
bool flag4 = bigInteger.data[0] == 2U || bigInteger.data[0] == 3U;
|
|
if (flag4)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
bool flag5 = (bigInteger.data[0] & 1U) == 0U;
|
|
bool flag6;
|
|
if (flag5)
|
|
{
|
|
flag6 = false;
|
|
}
|
|
else
|
|
{
|
|
BigInteger bigInteger2 = bigInteger - new BigInteger(1L);
|
|
int num = 0;
|
|
for (int i = 0; i < bigInteger2.dataLength; i++)
|
|
{
|
|
uint num2 = 1U;
|
|
for (int j = 0; j < 32; j++)
|
|
{
|
|
bool flag7 = (bigInteger2.data[i] & num2) > 0U;
|
|
if (flag7)
|
|
{
|
|
i = bigInteger2.dataLength;
|
|
break;
|
|
}
|
|
num2 <<= 1;
|
|
num++;
|
|
}
|
|
}
|
|
BigInteger bigInteger3 = bigInteger2 >> num;
|
|
int num3 = bigInteger.bitCount();
|
|
BigInteger bigInteger4 = new BigInteger();
|
|
Random random = new Random();
|
|
for (int k = 0; k < confidence; k++)
|
|
{
|
|
bool flag8 = false;
|
|
while (!flag8)
|
|
{
|
|
int l;
|
|
for (l = 0; l < 2; l = (int)(random.NextDouble() * (double)num3))
|
|
{
|
|
}
|
|
bigInteger4.genRandomBits(l, random);
|
|
int num4 = bigInteger4.dataLength;
|
|
bool flag9 = num4 > 1 || (num4 == 1 && bigInteger4.data[0] != 1U);
|
|
if (flag9)
|
|
{
|
|
flag8 = true;
|
|
}
|
|
}
|
|
BigInteger bigInteger5 = bigInteger4.gcd(bigInteger);
|
|
bool flag10 = bigInteger5.dataLength == 1 && bigInteger5.data[0] != 1U;
|
|
if (flag10)
|
|
{
|
|
return false;
|
|
}
|
|
BigInteger bigInteger6 = bigInteger4.ModPow(bigInteger3, bigInteger);
|
|
bool flag11 = false;
|
|
bool flag12 = bigInteger6.dataLength == 1 && bigInteger6.data[0] == 1U;
|
|
if (flag12)
|
|
{
|
|
flag11 = true;
|
|
}
|
|
int num5 = 0;
|
|
while (!flag11 && num5 < num)
|
|
{
|
|
bool flag13 = bigInteger6 == bigInteger2;
|
|
if (flag13)
|
|
{
|
|
flag11 = true;
|
|
break;
|
|
}
|
|
bigInteger6 = bigInteger6 * bigInteger6 % bigInteger;
|
|
num5++;
|
|
}
|
|
bool flag14 = !flag11;
|
|
if (flag14)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
flag6 = true;
|
|
}
|
|
return flag6;
|
|
}
|
|
|
|
// Token: 0x0600004C RID: 76 RVA: 0x00004F94 File Offset: 0x00003194
|
|
public bool SolovayStrassenTest(int confidence)
|
|
{
|
|
bool flag = (this.data[69] & 2147483648U) > 0U;
|
|
BigInteger bigInteger;
|
|
if (flag)
|
|
{
|
|
bigInteger = -this;
|
|
}
|
|
else
|
|
{
|
|
bigInteger = this;
|
|
}
|
|
bool flag2 = bigInteger.dataLength == 1;
|
|
if (flag2)
|
|
{
|
|
bool flag3 = bigInteger.data[0] == 0U || bigInteger.data[0] == 1U;
|
|
if (flag3)
|
|
{
|
|
return false;
|
|
}
|
|
bool flag4 = bigInteger.data[0] == 2U || bigInteger.data[0] == 3U;
|
|
if (flag4)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
bool flag5 = (bigInteger.data[0] & 1U) == 0U;
|
|
bool flag6;
|
|
if (flag5)
|
|
{
|
|
flag6 = false;
|
|
}
|
|
else
|
|
{
|
|
int num = bigInteger.bitCount();
|
|
BigInteger bigInteger2 = new BigInteger();
|
|
BigInteger bigInteger3 = bigInteger - 1;
|
|
BigInteger bigInteger4 = bigInteger3 >> 1;
|
|
Random random = new Random();
|
|
for (int i = 0; i < confidence; i++)
|
|
{
|
|
bool flag7 = false;
|
|
while (!flag7)
|
|
{
|
|
int j;
|
|
for (j = 0; j < 2; j = (int)(random.NextDouble() * (double)num))
|
|
{
|
|
}
|
|
bigInteger2.genRandomBits(j, random);
|
|
int num2 = bigInteger2.dataLength;
|
|
bool flag8 = num2 > 1 || (num2 == 1 && bigInteger2.data[0] != 1U);
|
|
if (flag8)
|
|
{
|
|
flag7 = true;
|
|
}
|
|
}
|
|
BigInteger bigInteger5 = bigInteger2.gcd(bigInteger);
|
|
bool flag9 = bigInteger5.dataLength == 1 && bigInteger5.data[0] != 1U;
|
|
if (flag9)
|
|
{
|
|
return false;
|
|
}
|
|
BigInteger bigInteger6 = bigInteger2.ModPow(bigInteger4, bigInteger);
|
|
bool flag10 = bigInteger6 == bigInteger3;
|
|
if (flag10)
|
|
{
|
|
bigInteger6 = -1;
|
|
}
|
|
BigInteger bigInteger7 = BigInteger.Jacobi(bigInteger2, bigInteger);
|
|
bool flag11 = bigInteger6 != bigInteger7;
|
|
if (flag11)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
flag6 = true;
|
|
}
|
|
return flag6;
|
|
}
|
|
|
|
// Token: 0x0600004D RID: 77 RVA: 0x0000516C File Offset: 0x0000336C
|
|
public bool LucasStrongTest()
|
|
{
|
|
bool flag = (this.data[69] & 2147483648U) > 0U;
|
|
BigInteger bigInteger;
|
|
if (flag)
|
|
{
|
|
bigInteger = -this;
|
|
}
|
|
else
|
|
{
|
|
bigInteger = this;
|
|
}
|
|
bool flag2 = bigInteger.dataLength == 1;
|
|
if (flag2)
|
|
{
|
|
bool flag3 = bigInteger.data[0] == 0U || bigInteger.data[0] == 1U;
|
|
if (flag3)
|
|
{
|
|
return false;
|
|
}
|
|
bool flag4 = bigInteger.data[0] == 2U || bigInteger.data[0] == 3U;
|
|
if (flag4)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
bool flag5 = (bigInteger.data[0] & 1U) == 0U;
|
|
return !flag5 && this.LucasStrongTestHelper(bigInteger);
|
|
}
|
|
|
|
// Token: 0x0600004E RID: 78 RVA: 0x00005214 File Offset: 0x00003414
|
|
private bool LucasStrongTestHelper(BigInteger thisVal)
|
|
{
|
|
long num = 5L;
|
|
long num2 = -1L;
|
|
long num3 = 0L;
|
|
bool flag = false;
|
|
while (!flag)
|
|
{
|
|
int num4 = BigInteger.Jacobi(num, thisVal);
|
|
bool flag2 = num4 == -1;
|
|
if (!flag2)
|
|
{
|
|
bool flag3 = num4 == 0 && Math.Abs(num) < thisVal;
|
|
if (!flag3)
|
|
{
|
|
bool flag4 = num3 == 20L;
|
|
if (flag4)
|
|
{
|
|
BigInteger bigInteger = thisVal.sqrt();
|
|
bool flag5 = bigInteger * bigInteger == thisVal;
|
|
if (flag5)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
num = (Math.Abs(num) + 2L) * num2;
|
|
num2 = -num2;
|
|
goto IL_99;
|
|
}
|
|
return false;
|
|
}
|
|
flag = true;
|
|
IL_99:
|
|
num3 += 1L;
|
|
}
|
|
long num5 = 1L - num >> 2;
|
|
BigInteger bigInteger2 = thisVal + 1;
|
|
int num6 = 0;
|
|
for (int i = 0; i < bigInteger2.dataLength; i++)
|
|
{
|
|
uint num7 = 1U;
|
|
for (int j = 0; j < 32; j++)
|
|
{
|
|
bool flag6 = (bigInteger2.data[i] & num7) > 0U;
|
|
if (flag6)
|
|
{
|
|
i = bigInteger2.dataLength;
|
|
break;
|
|
}
|
|
num7 <<= 1;
|
|
num6++;
|
|
}
|
|
}
|
|
BigInteger bigInteger3 = bigInteger2 >> num6;
|
|
BigInteger bigInteger4 = new BigInteger();
|
|
int num8 = thisVal.dataLength << 1;
|
|
bigInteger4.data[num8] = 1U;
|
|
bigInteger4.dataLength = num8 + 1;
|
|
bigInteger4 /= thisVal;
|
|
BigInteger[] array = BigInteger.LucasSequenceHelper(1, num5, bigInteger3, thisVal, bigInteger4, 0);
|
|
bool flag7 = false;
|
|
bool flag8 = (array[0].dataLength == 1 && array[0].data[0] == 0U) || (array[1].dataLength == 1 && array[1].data[0] == 0U);
|
|
if (flag8)
|
|
{
|
|
flag7 = true;
|
|
}
|
|
for (int k = 1; k < num6; k++)
|
|
{
|
|
bool flag9 = !flag7;
|
|
if (flag9)
|
|
{
|
|
array[1] = thisVal.BarrettReduction(array[1] * array[1], thisVal, bigInteger4);
|
|
array[1] = (array[1] - (array[2] << 1)) % thisVal;
|
|
bool flag10 = array[1].dataLength == 1 && array[1].data[0] == 0U;
|
|
if (flag10)
|
|
{
|
|
flag7 = true;
|
|
}
|
|
}
|
|
array[2] = thisVal.BarrettReduction(array[2] * array[2], thisVal, bigInteger4);
|
|
}
|
|
bool flag11 = flag7;
|
|
if (flag11)
|
|
{
|
|
BigInteger bigInteger5 = thisVal.gcd(num5);
|
|
bool flag12 = bigInteger5.dataLength == 1 && bigInteger5.data[0] == 1U;
|
|
if (flag12)
|
|
{
|
|
bool flag13 = (array[2].data[69] & 2147483648U) > 0U;
|
|
if (flag13)
|
|
{
|
|
BigInteger[] array2 = array;
|
|
int num9 = 2;
|
|
array2[num9] += thisVal;
|
|
}
|
|
BigInteger bigInteger6 = num5 * (long)BigInteger.Jacobi(num5, thisVal) % thisVal;
|
|
bool flag14 = (bigInteger6.data[69] & 2147483648U) > 0U;
|
|
if (flag14)
|
|
{
|
|
bigInteger6 += thisVal;
|
|
}
|
|
bool flag15 = array[2] != bigInteger6;
|
|
if (flag15)
|
|
{
|
|
flag7 = false;
|
|
}
|
|
}
|
|
}
|
|
return flag7;
|
|
}
|
|
|
|
// Token: 0x0600004F RID: 79 RVA: 0x00005558 File Offset: 0x00003758
|
|
public bool isProbablePrime(int confidence)
|
|
{
|
|
bool flag = (this.data[69] & 2147483648U) > 0U;
|
|
BigInteger bigInteger;
|
|
if (flag)
|
|
{
|
|
bigInteger = -this;
|
|
}
|
|
else
|
|
{
|
|
bigInteger = this;
|
|
}
|
|
for (int i = 0; i < BigInteger.primesBelow2000.Length; i++)
|
|
{
|
|
BigInteger bigInteger2 = BigInteger.primesBelow2000[i];
|
|
bool flag2 = bigInteger2 >= bigInteger;
|
|
if (flag2)
|
|
{
|
|
break;
|
|
}
|
|
BigInteger bigInteger3 = bigInteger % bigInteger2;
|
|
bool flag3 = bigInteger3.IntValue() == 0;
|
|
if (flag3)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return bigInteger.RabinMillerTest(confidence);
|
|
}
|
|
|
|
// Token: 0x06000050 RID: 80 RVA: 0x000055F8 File Offset: 0x000037F8
|
|
public bool isProbablePrime()
|
|
{
|
|
bool flag = (this.data[69] & 2147483648U) > 0U;
|
|
BigInteger bigInteger;
|
|
if (flag)
|
|
{
|
|
bigInteger = -this;
|
|
}
|
|
else
|
|
{
|
|
bigInteger = this;
|
|
}
|
|
bool flag2 = bigInteger.dataLength == 1;
|
|
if (flag2)
|
|
{
|
|
bool flag3 = bigInteger.data[0] == 0U || bigInteger.data[0] == 1U;
|
|
if (flag3)
|
|
{
|
|
return false;
|
|
}
|
|
bool flag4 = bigInteger.data[0] == 2U || bigInteger.data[0] == 3U;
|
|
if (flag4)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
bool flag5 = (bigInteger.data[0] & 1U) == 0U;
|
|
bool flag6;
|
|
if (flag5)
|
|
{
|
|
flag6 = false;
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < BigInteger.primesBelow2000.Length; i++)
|
|
{
|
|
BigInteger bigInteger2 = BigInteger.primesBelow2000[i];
|
|
bool flag7 = bigInteger2 >= bigInteger;
|
|
if (flag7)
|
|
{
|
|
break;
|
|
}
|
|
BigInteger bigInteger3 = bigInteger % bigInteger2;
|
|
bool flag8 = bigInteger3.IntValue() == 0;
|
|
if (flag8)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
BigInteger bigInteger4 = bigInteger - new BigInteger(1L);
|
|
int num = 0;
|
|
for (int j = 0; j < bigInteger4.dataLength; j++)
|
|
{
|
|
uint num2 = 1U;
|
|
for (int k = 0; k < 32; k++)
|
|
{
|
|
bool flag9 = (bigInteger4.data[j] & num2) > 0U;
|
|
if (flag9)
|
|
{
|
|
j = bigInteger4.dataLength;
|
|
break;
|
|
}
|
|
num2 <<= 1;
|
|
num++;
|
|
}
|
|
}
|
|
BigInteger bigInteger5 = bigInteger4 >> num;
|
|
int num3 = bigInteger.bitCount();
|
|
BigInteger bigInteger6 = 2;
|
|
BigInteger bigInteger7 = bigInteger6.ModPow(bigInteger5, bigInteger);
|
|
bool flag10 = false;
|
|
bool flag11 = bigInteger7.dataLength == 1 && bigInteger7.data[0] == 1U;
|
|
if (flag11)
|
|
{
|
|
flag10 = true;
|
|
}
|
|
int num4 = 0;
|
|
while (!flag10 && num4 < num)
|
|
{
|
|
bool flag12 = bigInteger7 == bigInteger4;
|
|
if (flag12)
|
|
{
|
|
flag10 = true;
|
|
break;
|
|
}
|
|
bigInteger7 = bigInteger7 * bigInteger7 % bigInteger;
|
|
num4++;
|
|
}
|
|
bool flag13 = flag10;
|
|
if (flag13)
|
|
{
|
|
flag10 = this.LucasStrongTestHelper(bigInteger);
|
|
}
|
|
flag6 = flag10;
|
|
}
|
|
return flag6;
|
|
}
|
|
|
|
// Token: 0x06000051 RID: 81 RVA: 0x0000581C File Offset: 0x00003A1C
|
|
public int IntValue()
|
|
{
|
|
return (int)this.data[0];
|
|
}
|
|
|
|
// Token: 0x06000052 RID: 82 RVA: 0x00005838 File Offset: 0x00003A38
|
|
public long LongValue()
|
|
{
|
|
long num = 0L;
|
|
num = (long)((ulong)this.data[0]);
|
|
try
|
|
{
|
|
num |= (long)((long)((ulong)this.data[1]) << 32);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
bool flag = (this.data[0] & 2147483648U) > 0U;
|
|
if (flag)
|
|
{
|
|
num = (long)this.data[0];
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x06000053 RID: 83 RVA: 0x000058A0 File Offset: 0x00003AA0
|
|
public static int Jacobi(BigInteger a, BigInteger b)
|
|
{
|
|
bool flag = (b.data[0] & 1U) == 0U;
|
|
if (flag)
|
|
{
|
|
throw new ArgumentException("Jacobi defined only for odd integers.");
|
|
}
|
|
bool flag2 = a >= b;
|
|
if (flag2)
|
|
{
|
|
a %= b;
|
|
}
|
|
bool flag3 = a.dataLength == 1 && a.data[0] == 0U;
|
|
int num;
|
|
if (flag3)
|
|
{
|
|
num = 0;
|
|
}
|
|
else
|
|
{
|
|
bool flag4 = a.dataLength == 1 && a.data[0] == 1U;
|
|
if (flag4)
|
|
{
|
|
num = 1;
|
|
}
|
|
else
|
|
{
|
|
bool flag5 = a < 0;
|
|
if (flag5)
|
|
{
|
|
bool flag6 = ((b - 1).data[0] & 2U) == 0U;
|
|
if (flag6)
|
|
{
|
|
num = BigInteger.Jacobi(-a, b);
|
|
}
|
|
else
|
|
{
|
|
num = -BigInteger.Jacobi(-a, b);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int num2 = 0;
|
|
for (int i = 0; i < a.dataLength; i++)
|
|
{
|
|
uint num3 = 1U;
|
|
for (int j = 0; j < 32; j++)
|
|
{
|
|
bool flag7 = (a.data[i] & num3) > 0U;
|
|
if (flag7)
|
|
{
|
|
i = a.dataLength;
|
|
break;
|
|
}
|
|
num3 <<= 1;
|
|
num2++;
|
|
}
|
|
}
|
|
BigInteger bigInteger = a >> num2;
|
|
int num4 = 1;
|
|
bool flag8 = (num2 & 1) != 0 && ((b.data[0] & 7U) == 3U || (b.data[0] & 7U) == 5U);
|
|
if (flag8)
|
|
{
|
|
num4 = -1;
|
|
}
|
|
bool flag9 = (b.data[0] & 3U) == 3U && (bigInteger.data[0] & 3U) == 3U;
|
|
if (flag9)
|
|
{
|
|
num4 = -num4;
|
|
}
|
|
bool flag10 = bigInteger.dataLength == 1 && bigInteger.data[0] == 1U;
|
|
if (flag10)
|
|
{
|
|
num = num4;
|
|
}
|
|
else
|
|
{
|
|
num = num4 * BigInteger.Jacobi(b % bigInteger, bigInteger);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x06000054 RID: 84 RVA: 0x00005A7C File Offset: 0x00003C7C
|
|
public static BigInteger genPseudoPrime(int bits, int confidence, Random rand)
|
|
{
|
|
BigInteger bigInteger = new BigInteger();
|
|
bool flag = false;
|
|
while (!flag)
|
|
{
|
|
bigInteger.genRandomBits(bits, rand);
|
|
bigInteger.data[0] |= 1U;
|
|
flag = bigInteger.isProbablePrime(confidence);
|
|
}
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x06000055 RID: 85 RVA: 0x00005AC8 File Offset: 0x00003CC8
|
|
public BigInteger genCoPrime(int bits, Random rand)
|
|
{
|
|
bool flag = false;
|
|
BigInteger bigInteger = new BigInteger();
|
|
while (!flag)
|
|
{
|
|
bigInteger.genRandomBits(bits, rand);
|
|
BigInteger bigInteger2 = bigInteger.gcd(this);
|
|
bool flag2 = bigInteger2.dataLength == 1 && bigInteger2.data[0] == 1U;
|
|
if (flag2)
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x06000056 RID: 86 RVA: 0x00005B24 File Offset: 0x00003D24
|
|
public BigInteger modInverse(BigInteger modulus)
|
|
{
|
|
BigInteger[] array = new BigInteger[] { 0, 1 };
|
|
BigInteger[] array2 = new BigInteger[2];
|
|
BigInteger[] array3 = new BigInteger[] { 0, 0 };
|
|
int num = 0;
|
|
BigInteger bigInteger = modulus;
|
|
BigInteger bigInteger2 = this;
|
|
while (bigInteger2.dataLength > 1 || (bigInteger2.dataLength == 1 && bigInteger2.data[0] > 0U))
|
|
{
|
|
BigInteger bigInteger3 = new BigInteger();
|
|
BigInteger bigInteger4 = new BigInteger();
|
|
bool flag = num > 1;
|
|
if (flag)
|
|
{
|
|
BigInteger bigInteger5 = (array[0] - array[1] * array2[0]) % modulus;
|
|
array[0] = array[1];
|
|
array[1] = bigInteger5;
|
|
}
|
|
bool flag2 = bigInteger2.dataLength == 1;
|
|
if (flag2)
|
|
{
|
|
BigInteger.singleByteDivide(bigInteger, bigInteger2, bigInteger3, bigInteger4);
|
|
}
|
|
else
|
|
{
|
|
BigInteger.multiByteDivide(bigInteger, bigInteger2, bigInteger3, bigInteger4);
|
|
}
|
|
array2[0] = array2[1];
|
|
array3[0] = array3[1];
|
|
array2[1] = bigInteger3;
|
|
array3[1] = bigInteger4;
|
|
bigInteger = bigInteger2;
|
|
bigInteger2 = bigInteger4;
|
|
num++;
|
|
}
|
|
bool flag3 = array3[0].dataLength > 1 || (array3[0].dataLength == 1 && array3[0].data[0] != 1U);
|
|
if (flag3)
|
|
{
|
|
throw new ArithmeticException("No inverse!");
|
|
}
|
|
BigInteger bigInteger6 = (array[0] - array[1] * array2[0]) % modulus;
|
|
bool flag4 = (bigInteger6.data[69] & 2147483648U) > 0U;
|
|
if (flag4)
|
|
{
|
|
bigInteger6 += modulus;
|
|
}
|
|
return bigInteger6;
|
|
}
|
|
|
|
// Token: 0x06000057 RID: 87 RVA: 0x00005CBC File Offset: 0x00003EBC
|
|
public byte[] GetBytes()
|
|
{
|
|
bool flag = this == 0;
|
|
byte[] array;
|
|
if (flag)
|
|
{
|
|
array = new byte[1];
|
|
}
|
|
else
|
|
{
|
|
int num = this.bitCount();
|
|
int num2 = num >> 3;
|
|
bool flag2 = (num & 7) != 0;
|
|
if (flag2)
|
|
{
|
|
num2++;
|
|
}
|
|
byte[] array2 = new byte[num2];
|
|
int num3 = num2 & 3;
|
|
bool flag3 = num3 == 0;
|
|
if (flag3)
|
|
{
|
|
num3 = 4;
|
|
}
|
|
int num4 = 0;
|
|
for (int i = this.dataLength - 1; i >= 0; i--)
|
|
{
|
|
uint num5 = this.data[i];
|
|
for (int j = num3 - 1; j >= 0; j--)
|
|
{
|
|
array2[num4 + j] = (byte)(num5 & 255U);
|
|
num5 >>= 8;
|
|
}
|
|
num4 += num3;
|
|
num3 = 4;
|
|
}
|
|
array = array2;
|
|
}
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x06000058 RID: 88 RVA: 0x00005D94 File Offset: 0x00003F94
|
|
public void setBit(uint bitNum)
|
|
{
|
|
uint num = bitNum >> 5;
|
|
byte b = (byte)(bitNum & 31U);
|
|
uint num2 = 1U << (int)b;
|
|
this.data[(int)num] |= num2;
|
|
bool flag = (ulong)num >= (ulong)((long)this.dataLength);
|
|
if (flag)
|
|
{
|
|
this.dataLength = (int)(num + 1U);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000059 RID: 89 RVA: 0x00005DE0 File Offset: 0x00003FE0
|
|
public void unsetBit(uint bitNum)
|
|
{
|
|
uint num = bitNum >> 5;
|
|
bool flag = (ulong)num < (ulong)((long)this.dataLength);
|
|
if (flag)
|
|
{
|
|
byte b = (byte)(bitNum & 31U);
|
|
uint num2 = 1U << (int)b;
|
|
uint num3 = uint.MaxValue ^ num2;
|
|
this.data[(int)num] &= num3;
|
|
bool flag2 = this.dataLength > 1 && this.data[this.dataLength - 1] == 0U;
|
|
if (flag2)
|
|
{
|
|
this.dataLength--;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600005A RID: 90 RVA: 0x00005E5C File Offset: 0x0000405C
|
|
public BigInteger sqrt()
|
|
{
|
|
uint num = (uint)this.bitCount();
|
|
bool flag = (num & 1U) > 0U;
|
|
if (flag)
|
|
{
|
|
num = (num >> 1) + 1U;
|
|
}
|
|
else
|
|
{
|
|
num >>= 1;
|
|
}
|
|
uint num2 = num >> 5;
|
|
byte b = (byte)(num & 31U);
|
|
BigInteger bigInteger = new BigInteger();
|
|
bool flag2 = b == 0;
|
|
uint num3;
|
|
if (flag2)
|
|
{
|
|
num3 = 2147483648U;
|
|
}
|
|
else
|
|
{
|
|
num3 = 1U << (int)b;
|
|
num2 += 1U;
|
|
}
|
|
bigInteger.dataLength = (int)num2;
|
|
for (int i = (int)(num2 - 1U); i >= 0; i--)
|
|
{
|
|
while (num3 > 0U)
|
|
{
|
|
bigInteger.data[i] ^= num3;
|
|
bool flag3 = bigInteger * bigInteger > this;
|
|
if (flag3)
|
|
{
|
|
bigInteger.data[i] ^= num3;
|
|
}
|
|
num3 >>= 1;
|
|
}
|
|
num3 = 2147483648U;
|
|
}
|
|
return bigInteger;
|
|
}
|
|
|
|
// Token: 0x0600005B RID: 91 RVA: 0x00005F3C File Offset: 0x0000413C
|
|
public static BigInteger[] LucasSequence(BigInteger P, BigInteger Q, BigInteger k, BigInteger n)
|
|
{
|
|
bool flag = k.dataLength == 1 && k.data[0] == 0U;
|
|
BigInteger[] array;
|
|
if (flag)
|
|
{
|
|
array = new BigInteger[]
|
|
{
|
|
0,
|
|
2 % n,
|
|
1 % n
|
|
};
|
|
}
|
|
else
|
|
{
|
|
BigInteger bigInteger = new BigInteger();
|
|
int num = n.dataLength << 1;
|
|
bigInteger.data[num] = 1U;
|
|
bigInteger.dataLength = num + 1;
|
|
bigInteger /= n;
|
|
int num2 = 0;
|
|
for (int i = 0; i < k.dataLength; i++)
|
|
{
|
|
uint num3 = 1U;
|
|
for (int j = 0; j < 32; j++)
|
|
{
|
|
bool flag2 = (k.data[i] & num3) > 0U;
|
|
if (flag2)
|
|
{
|
|
i = k.dataLength;
|
|
break;
|
|
}
|
|
num3 <<= 1;
|
|
num2++;
|
|
}
|
|
}
|
|
BigInteger bigInteger2 = k >> num2;
|
|
array = BigInteger.LucasSequenceHelper(P, Q, bigInteger2, n, bigInteger, num2);
|
|
}
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x0600005C RID: 92 RVA: 0x0000604C File Offset: 0x0000424C
|
|
private static BigInteger[] LucasSequenceHelper(BigInteger P, BigInteger Q, BigInteger k, BigInteger n, BigInteger constant, int s)
|
|
{
|
|
BigInteger[] array = new BigInteger[3];
|
|
bool flag = (k.data[0] & 1U) == 0U;
|
|
if (flag)
|
|
{
|
|
throw new ArgumentException("Argument k must be odd.");
|
|
}
|
|
int num = k.bitCount();
|
|
uint num2 = 1U << (num & 31) - 1;
|
|
BigInteger bigInteger = 2 % n;
|
|
BigInteger bigInteger2 = 1 % n;
|
|
BigInteger bigInteger3 = P % n;
|
|
BigInteger bigInteger4 = bigInteger2;
|
|
bool flag2 = true;
|
|
for (int i = k.dataLength - 1; i >= 0; i--)
|
|
{
|
|
while (num2 > 0U)
|
|
{
|
|
bool flag3 = i == 0 && num2 == 1U;
|
|
if (flag3)
|
|
{
|
|
break;
|
|
}
|
|
bool flag4 = (k.data[i] & num2) > 0U;
|
|
if (flag4)
|
|
{
|
|
bigInteger4 = bigInteger4 * bigInteger3 % n;
|
|
bigInteger = (bigInteger * bigInteger3 - P * bigInteger2) % n;
|
|
bigInteger3 = n.BarrettReduction(bigInteger3 * bigInteger3, n, constant);
|
|
bigInteger3 = (bigInteger3 - (bigInteger2 * Q << 1)) % n;
|
|
bool flag5 = flag2;
|
|
if (flag5)
|
|
{
|
|
flag2 = false;
|
|
}
|
|
else
|
|
{
|
|
bigInteger2 = n.BarrettReduction(bigInteger2 * bigInteger2, n, constant);
|
|
}
|
|
bigInteger2 = bigInteger2 * Q % n;
|
|
}
|
|
else
|
|
{
|
|
bigInteger4 = (bigInteger4 * bigInteger - bigInteger2) % n;
|
|
bigInteger3 = (bigInteger * bigInteger3 - P * bigInteger2) % n;
|
|
bigInteger = n.BarrettReduction(bigInteger * bigInteger, n, constant);
|
|
bigInteger = (bigInteger - (bigInteger2 << 1)) % n;
|
|
bool flag6 = flag2;
|
|
if (flag6)
|
|
{
|
|
bigInteger2 = Q % n;
|
|
flag2 = false;
|
|
}
|
|
else
|
|
{
|
|
bigInteger2 = n.BarrettReduction(bigInteger2 * bigInteger2, n, constant);
|
|
}
|
|
}
|
|
num2 >>= 1;
|
|
}
|
|
num2 = 2147483648U;
|
|
}
|
|
bigInteger4 = (bigInteger4 * bigInteger - bigInteger2) % n;
|
|
bigInteger = (bigInteger * bigInteger3 - P * bigInteger2) % n;
|
|
bool flag7 = flag2;
|
|
if (flag7)
|
|
{
|
|
flag2 = false;
|
|
}
|
|
else
|
|
{
|
|
bigInteger2 = n.BarrettReduction(bigInteger2 * bigInteger2, n, constant);
|
|
}
|
|
bigInteger2 = bigInteger2 * Q % n;
|
|
for (int j = 0; j < s; j++)
|
|
{
|
|
bigInteger4 = bigInteger4 * bigInteger % n;
|
|
bigInteger = (bigInteger * bigInteger - (bigInteger2 << 1)) % n;
|
|
bool flag8 = flag2;
|
|
if (flag8)
|
|
{
|
|
bigInteger2 = Q % n;
|
|
flag2 = false;
|
|
}
|
|
else
|
|
{
|
|
bigInteger2 = n.BarrettReduction(bigInteger2 * bigInteger2, n, constant);
|
|
}
|
|
}
|
|
array[0] = bigInteger4;
|
|
array[1] = bigInteger;
|
|
array[2] = bigInteger2;
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x0600005D RID: 93 RVA: 0x00006338 File Offset: 0x00004538
|
|
public static void MulDivTest(int rounds)
|
|
{
|
|
Random random = new Random();
|
|
byte[] array = new byte[64];
|
|
byte[] array2 = new byte[64];
|
|
for (int i = 0; i < rounds; i++)
|
|
{
|
|
int num;
|
|
for (num = 0; num == 0; num = (int)(random.NextDouble() * 65.0))
|
|
{
|
|
}
|
|
int num2;
|
|
for (num2 = 0; num2 == 0; num2 = (int)(random.NextDouble() * 65.0))
|
|
{
|
|
}
|
|
bool flag = false;
|
|
while (!flag)
|
|
{
|
|
for (int j = 0; j < 64; j++)
|
|
{
|
|
bool flag2 = j < num;
|
|
if (flag2)
|
|
{
|
|
array[j] = (byte)(random.NextDouble() * 256.0);
|
|
}
|
|
else
|
|
{
|
|
array[j] = 0;
|
|
}
|
|
bool flag3 = array[j] > 0;
|
|
if (flag3)
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
}
|
|
flag = false;
|
|
while (!flag)
|
|
{
|
|
for (int k = 0; k < 64; k++)
|
|
{
|
|
bool flag4 = k < num2;
|
|
if (flag4)
|
|
{
|
|
array2[k] = (byte)(random.NextDouble() * 256.0);
|
|
}
|
|
else
|
|
{
|
|
array2[k] = 0;
|
|
}
|
|
bool flag5 = array2[k] > 0;
|
|
if (flag5)
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
}
|
|
while (array[0] == 0)
|
|
{
|
|
array[0] = (byte)(random.NextDouble() * 256.0);
|
|
}
|
|
while (array2[0] == 0)
|
|
{
|
|
array2[0] = (byte)(random.NextDouble() * 256.0);
|
|
}
|
|
Console.WriteLine(i);
|
|
BigInteger bigInteger = new BigInteger(array, num);
|
|
BigInteger bigInteger2 = new BigInteger(array2, num2);
|
|
BigInteger bigInteger3 = bigInteger / bigInteger2;
|
|
BigInteger bigInteger4 = bigInteger % bigInteger2;
|
|
BigInteger bigInteger5 = bigInteger3 * bigInteger2 + bigInteger4;
|
|
bool flag6 = bigInteger5 != bigInteger;
|
|
if (flag6)
|
|
{
|
|
Console.WriteLine("Error at " + i);
|
|
Console.WriteLine(bigInteger + "\n");
|
|
Console.WriteLine(bigInteger2 + "\n");
|
|
Console.WriteLine(bigInteger3 + "\n");
|
|
Console.WriteLine(bigInteger4 + "\n");
|
|
Console.WriteLine(bigInteger5 + "\n");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600005E RID: 94 RVA: 0x0000658C File Offset: 0x0000478C
|
|
public static void RSATest(int rounds)
|
|
{
|
|
Random random = new Random(1);
|
|
byte[] array = new byte[64];
|
|
BigInteger bigInteger = new BigInteger("a932b948feed4fb2b692609bd22164fc9edb59fae7880cc1eaff7b3c9626b7e5b241c27a974833b2622ebe09beb451917663d47232488f23a117fc97720f1e7", 16);
|
|
BigInteger bigInteger2 = new BigInteger("4adf2f7a89da93248509347d2ae506d683dd3a16357e859a980c4f77a4e2f7a01fae289f13a851df6e9db5adaa60bfd2b162bbbe31f7c8f828261a6839311929d2cef4f864dde65e556ce43c89bbbf9f1ac5511315847ce9cc8dc92470a747b8792d6a83b0092d2e5ebaf852c85cacf34278efa99160f2f8aa7ee7214de07b7", 16);
|
|
BigInteger bigInteger3 = new BigInteger("e8e77781f36a7b3188d711c2190b560f205a52391b3479cdb99fa010745cbeba5f2adc08e1de6bf38398a0487c4a73610d94ec36f17f3f46ad75e17bc1adfec99839589f45f95ccc94cb2a5c500b477eb3323d8cfab0c8458c96f0147a45d27e45a4d11d54d77684f65d48f15fafcc1ba208e71e921b9bd9017c16a5231af7f", 16);
|
|
Console.WriteLine("e =\n" + bigInteger.ToString(10));
|
|
Console.WriteLine("\nd =\n" + bigInteger2.ToString(10));
|
|
Console.WriteLine("\nn =\n" + bigInteger3.ToString(10) + "\n");
|
|
for (int i = 0; i < rounds; i++)
|
|
{
|
|
int num;
|
|
for (num = 0; num == 0; num = (int)(random.NextDouble() * 65.0))
|
|
{
|
|
}
|
|
bool flag = false;
|
|
while (!flag)
|
|
{
|
|
for (int j = 0; j < 64; j++)
|
|
{
|
|
bool flag2 = j < num;
|
|
if (flag2)
|
|
{
|
|
array[j] = (byte)(random.NextDouble() * 256.0);
|
|
}
|
|
else
|
|
{
|
|
array[j] = 0;
|
|
}
|
|
bool flag3 = array[j] > 0;
|
|
if (flag3)
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
}
|
|
while (array[0] == 0)
|
|
{
|
|
array[0] = (byte)(random.NextDouble() * 256.0);
|
|
}
|
|
Console.Write("Round = " + i);
|
|
BigInteger bigInteger4 = new BigInteger(array, num);
|
|
BigInteger bigInteger5 = bigInteger4.ModPow(bigInteger, bigInteger3);
|
|
BigInteger bigInteger6 = bigInteger5.ModPow(bigInteger2, bigInteger3);
|
|
bool flag4 = bigInteger6 != bigInteger4;
|
|
if (flag4)
|
|
{
|
|
Console.WriteLine("\nError at round " + i);
|
|
Console.WriteLine(bigInteger4 + "\n");
|
|
break;
|
|
}
|
|
Console.WriteLine(" <PASSED>.");
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600005F RID: 95 RVA: 0x00006764 File Offset: 0x00004964
|
|
public static void RSATest2(int rounds)
|
|
{
|
|
Random random = new Random();
|
|
byte[] array = new byte[64];
|
|
byte[] array2 = new byte[]
|
|
{
|
|
133, 132, 100, 253, 112, 106, 159, 240, 148, 12,
|
|
62, 44, 116, 52, 5, 201, 85, 179, 133, 50,
|
|
152, 113, 249, 65, 33, 95, 2, 158, 234, 86,
|
|
141, 140, 68, 204, 238, 238, 61, 44, 157, 44,
|
|
18, 65, 30, 241, 197, 50, 195, 170, 49, 74,
|
|
82, 216, 232, 175, 66, 244, 114, 161, 42, 13,
|
|
151, 177, 49, 179
|
|
};
|
|
byte[] array3 = new byte[]
|
|
{
|
|
153, 152, 202, 184, 94, 215, 229, 220, 40, 92,
|
|
111, 14, 21, 9, 89, 110, 132, 243, 129, 205,
|
|
222, 66, 220, 147, 194, 122, 98, 172, 108, 175,
|
|
222, 116, 227, 203, 96, 32, 56, 156, 33, 195,
|
|
220, 200, 162, 77, 198, 42, 53, 127, 243, 169,
|
|
232, 29, 123, 44, 120, 250, 184, 2, 85, 128,
|
|
155, 194, 165, 203
|
|
};
|
|
BigInteger bigInteger = new BigInteger(array2);
|
|
BigInteger bigInteger2 = new BigInteger(array3);
|
|
BigInteger bigInteger3 = (bigInteger - 1) * (bigInteger2 - 1);
|
|
BigInteger bigInteger4 = bigInteger * bigInteger2;
|
|
for (int i = 0; i < rounds; i++)
|
|
{
|
|
BigInteger bigInteger5 = bigInteger3.genCoPrime(512, random);
|
|
BigInteger bigInteger6 = bigInteger5.modInverse(bigInteger3);
|
|
Console.WriteLine("\ne =\n" + bigInteger5.ToString(10));
|
|
Console.WriteLine("\nd =\n" + bigInteger6.ToString(10));
|
|
Console.WriteLine("\nn =\n" + bigInteger4.ToString(10) + "\n");
|
|
int num;
|
|
for (num = 0; num == 0; num = (int)(random.NextDouble() * 65.0))
|
|
{
|
|
}
|
|
bool flag = false;
|
|
while (!flag)
|
|
{
|
|
for (int j = 0; j < 64; j++)
|
|
{
|
|
bool flag2 = j < num;
|
|
if (flag2)
|
|
{
|
|
array[j] = (byte)(random.NextDouble() * 256.0);
|
|
}
|
|
else
|
|
{
|
|
array[j] = 0;
|
|
}
|
|
bool flag3 = array[j] > 0;
|
|
if (flag3)
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
}
|
|
while (array[0] == 0)
|
|
{
|
|
array[0] = (byte)(random.NextDouble() * 256.0);
|
|
}
|
|
Console.Write("Round = " + i);
|
|
BigInteger bigInteger7 = new BigInteger(array, num);
|
|
BigInteger bigInteger8 = bigInteger7.ModPow(bigInteger5, bigInteger4);
|
|
BigInteger bigInteger9 = bigInteger8.ModPow(bigInteger6, bigInteger4);
|
|
bool flag4 = bigInteger9 != bigInteger7;
|
|
if (flag4)
|
|
{
|
|
Console.WriteLine("\nError at round " + i);
|
|
Console.WriteLine(bigInteger7 + "\n");
|
|
break;
|
|
}
|
|
Console.WriteLine(" <PASSED>.");
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000060 RID: 96 RVA: 0x00006994 File Offset: 0x00004B94
|
|
public static void SqrtTest(int rounds)
|
|
{
|
|
Random random = new Random();
|
|
for (int i = 0; i < rounds; i++)
|
|
{
|
|
int num;
|
|
for (num = 0; num == 0; num = (int)(random.NextDouble() * 1024.0))
|
|
{
|
|
}
|
|
Console.Write("Round = " + i);
|
|
BigInteger bigInteger = new BigInteger();
|
|
bigInteger.genRandomBits(num, random);
|
|
BigInteger bigInteger2 = bigInteger.sqrt();
|
|
BigInteger bigInteger3 = (bigInteger2 + 1) * (bigInteger2 + 1);
|
|
bool flag = bigInteger3 <= bigInteger;
|
|
if (flag)
|
|
{
|
|
Console.WriteLine("\nError at round " + i);
|
|
Console.WriteLine(bigInteger + "\n");
|
|
break;
|
|
}
|
|
Console.WriteLine(" <PASSED>.");
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000061 RID: 97 RVA: 0x00006A74 File Offset: 0x00004C74
|
|
public static void Main(string[] args)
|
|
{
|
|
byte[] array = new byte[]
|
|
{
|
|
0, 133, 132, 100, 253, 112, 106, 159, 240, 148,
|
|
12, 62, 44, 116, 52, 5, 201, 85, 179, 133,
|
|
50, 152, 113, 249, 65, 33, 95, 2, 158, 234,
|
|
86, 141, 140, 68, 204, 238, 238, 61, 44, 157,
|
|
44, 18, 65, 30, 241, 197, 50, 195, 170, 49,
|
|
74, 82, 216, 232, 175, 66, 244, 114, 161, 42,
|
|
13, 151, 177, 49, 179
|
|
};
|
|
byte[] array2 = new byte[]
|
|
{
|
|
0, 153, 152, 202, 184, 94, 215, 229, 220, 40,
|
|
92, 111, 14, 21, 9, 89, 110, 132, 243, 129,
|
|
205, 222, 66, 220, 147, 194, 122, 98, 172, 108,
|
|
175, 222, 116, 227, 203, 96, 32, 56, 156, 33,
|
|
195, 220, 200, 162, 77, 198, 42, 53, 127, 243,
|
|
169, 232, 29, 123, 44, 120, 250, 184, 2, 85,
|
|
128, 155, 194, 165, 203
|
|
};
|
|
Console.WriteLine("List of primes < 2000\n---------------------");
|
|
int num = 100;
|
|
int num2 = 0;
|
|
for (int i = 0; i < 2000; i++)
|
|
{
|
|
bool flag = i >= num;
|
|
if (flag)
|
|
{
|
|
Console.WriteLine();
|
|
num += 100;
|
|
}
|
|
BigInteger bigInteger = new BigInteger((long)(-(long)i));
|
|
bool flag2 = bigInteger.isProbablePrime();
|
|
if (flag2)
|
|
{
|
|
Console.Write(i + ", ");
|
|
num2++;
|
|
}
|
|
}
|
|
Console.WriteLine("\nCount = " + num2);
|
|
BigInteger bigInteger2 = new BigInteger(array);
|
|
Console.WriteLine("\n\nPrimality testing for\n" + bigInteger2.ToString() + "\n");
|
|
Console.WriteLine("SolovayStrassenTest(5) = " + bigInteger2.SolovayStrassenTest(5).ToString());
|
|
Console.WriteLine("RabinMillerTest(5) = " + bigInteger2.RabinMillerTest(5).ToString());
|
|
Console.WriteLine("FermatLittleTest(5) = " + bigInteger2.FermatLittleTest(5).ToString());
|
|
Console.WriteLine("isProbablePrime() = " + bigInteger2.isProbablePrime().ToString());
|
|
Console.Write("\nGenerating 512-bits random pseudoprime. . .");
|
|
Random random = new Random();
|
|
BigInteger bigInteger3 = BigInteger.genPseudoPrime(512, 5, random);
|
|
Console.WriteLine("\n" + bigInteger3);
|
|
}
|
|
|
|
// Token: 0x0400000B RID: 11
|
|
private const int maxLength = 70;
|
|
|
|
// Token: 0x0400000C RID: 12
|
|
public static readonly int[] primesBelow2000 = new int[]
|
|
{
|
|
2, 3, 5, 7, 11, 13, 17, 19, 23, 29,
|
|
31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
|
|
73, 79, 83, 89, 97, 101, 103, 107, 109, 113,
|
|
127, 131, 137, 139, 149, 151, 157, 163, 167, 173,
|
|
179, 181, 191, 193, 197, 199, 211, 223, 227, 229,
|
|
233, 239, 241, 251, 257, 263, 269, 271, 277, 281,
|
|
283, 293, 307, 311, 313, 317, 331, 337, 347, 349,
|
|
353, 359, 367, 373, 379, 383, 389, 397, 401, 409,
|
|
419, 421, 431, 433, 439, 443, 449, 457, 461, 463,
|
|
467, 479, 487, 491, 499, 503, 509, 521, 523, 541,
|
|
547, 557, 563, 569, 571, 577, 587, 593, 599, 601,
|
|
607, 613, 617, 619, 631, 641, 643, 647, 653, 659,
|
|
661, 673, 677, 683, 691, 701, 709, 719, 727, 733,
|
|
739, 743, 751, 757, 761, 769, 773, 787, 797, 809,
|
|
811, 821, 823, 827, 829, 839, 853, 857, 859, 863,
|
|
877, 881, 883, 887, 907, 911, 919, 929, 937, 941,
|
|
947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013,
|
|
1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069,
|
|
1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151,
|
|
1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223,
|
|
1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291,
|
|
1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373,
|
|
1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451,
|
|
1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511,
|
|
1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583,
|
|
1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657,
|
|
1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733,
|
|
1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811,
|
|
1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889,
|
|
1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987,
|
|
1993, 1997, 1999
|
|
};
|
|
|
|
// Token: 0x0400000D RID: 13
|
|
private uint[] data = null;
|
|
|
|
// Token: 0x0400000E RID: 14
|
|
public int dataLength;
|
|
}
|
|
}
|