public static BigInteger CreateRandomInRange(BigInteger min, BigInteger max, SecureRandom random) { int num = min.CompareTo(max); if (num >= 0) { if (num > 0) { throw new ArgumentException("'min' may not be greater than 'max'"); } return min; } if (min.BitLength > (max.BitLength / 2)) { return CreateRandomInRange(BigInteger.Zero, max.Subtract(min), random).Add(min); } for (int i = 0; i < 0x3e8; i++) { BigInteger integer = new BigInteger(max.BitLength, random); if ((integer.CompareTo(min) >= 0) && (integer.CompareTo(max) <= 0)) { return integer; } } return new BigInteger(max.Subtract(min).BitLength - 1, random).Add(min); }
public virtual BigInteger GenerateClientCredentials(byte[] salt, byte[] identity, byte[] password) { this.x = Srp6Utilities.CalculateX(this.digest, this.N, salt, identity, password); this.privA = this.SelectPrivateValue(); this.pubA = this.g.ModPow(this.privA, this.N); return this.pubA; }
public virtual BigInteger CalculateSecret(BigInteger serverB) { this.B = Srp6Utilities.ValidatePublicValue(this.N, serverB); this.u = Srp6Utilities.CalculateU(this.digest, this.N, this.pubA, this.B); this.S = this.CalculateS(); return this.S; }
public virtual BigInteger CalculateSecret(BigInteger clientA) { this.A = Srp6Utilities.ValidatePublicValue(this.N, clientA); this.u = Srp6Utilities.CalculateU(this.digest, this.N, this.A, this.pubB); this.S = this.CalculateS(); return this.S; }
public virtual void Init(BigInteger N, BigInteger g, IDigest digest, SecureRandom random) { this.N = N; this.g = g; this.digest = digest; this.random = random; }
public static BigInteger GeneratePrivateValue(IDigest digest, BigInteger N, BigInteger g, SecureRandom random) { int num = Math.Min(0x100, N.BitLength / 2); BigInteger min = BigInteger.One.ShiftLeft(num - 1); BigInteger max = N.Subtract(BigInteger.One); return BigIntegers.CreateRandomInRange(min, max, random); }
public virtual BigInteger GenerateServerCredentials() { BigInteger integer = Srp6Utilities.CalculateK(this.digest, this.N, this.g); this.privB = this.SelectPrivateValue(); this.pubB = integer.Multiply(this.v).Mod(this.N).Add(this.g.ModPow(this.privB, this.N)).Mod(this.N); return this.pubB; }
public static BigInteger ValidatePublicValue(BigInteger N, BigInteger val) { val = val.Mod(N); if (val.Equals(BigInteger.Zero)) { throw new Exception("Invalid public value: 0"); } return val; }
private static BigInteger HashPaddedPair(IDigest digest, BigInteger N, BigInteger n1, BigInteger n2) { int length = (N.BitLength + 7) / 8; byte[] padded = GetPadded(n1, length); byte[] input = GetPadded(n2, length); digest.BlockUpdate(padded, 0, padded.Length); digest.BlockUpdate(input, 0, input.Length); byte[] output = new byte[digest.GetDigestSize()]; digest.DoFinal(output, 0); return new BigInteger(1, output).Mod(N); }
private static byte[] GetPadded(BigInteger n, int length) { byte[] sourceArray = BigIntegers.AsUnsignedByteArray(n); if (sourceArray.Length < length) { byte[] destinationArray = new byte[length]; Array.Copy(sourceArray, 0, destinationArray, length - sourceArray.Length, sourceArray.Length); sourceArray = destinationArray; } return sourceArray; }
public static BigInteger CalculateX(IDigest digest, BigInteger N, byte[] salt, byte[] identity, byte[] password) { byte[] output = new byte[digest.GetDigestSize()]; digest.BlockUpdate(identity, 0, identity.Length); digest.Update(0x3a); digest.BlockUpdate(password, 0, password.Length); digest.DoFinal(output, 0); digest.BlockUpdate(salt, 0, salt.Length); digest.BlockUpdate(output, 0, output.Length); digest.DoFinal(output, 0); return new BigInteger(1, output).Mod(N); }
internal bool RabinMillerTest(int certainty, Random random) { BigInteger integer4; BigInteger m = this; BigInteger integer2 = m.Subtract(One); int lowestSetBit = integer2.GetLowestSetBit(); BigInteger exponent = integer2.ShiftRight(lowestSetBit); Label_001D: integer4 = new BigInteger(m.BitLength, random); if ((integer4.CompareTo(One) <= 0) || (integer4.CompareTo(integer2) >= 0)) { goto Label_001D; } BigInteger integer5 = integer4.ModPow(exponent, m); if (!integer5.Equals(One)) { int num2 = 0; while (!integer5.Equals(integer2)) { if (++num2 == lowestSetBit) { return false; } integer5 = integer5.ModPow(Two, m); if (integer5.Equals(One)) { return false; } } } certainty -= 2; if (certainty > 0) { goto Label_001D; } return true; }
public BigInteger Subtract(BigInteger n) { BigInteger integer; BigInteger integer2; if (n.sign == 0) { return this; } if (this.sign == 0) { return n.Negate(); } if (this.sign != n.sign) { return this.Add(n.Negate()); } int num = CompareNoLeadingZeroes(0, this.magnitude, 0, n.magnitude); if (num == 0) { return Zero; } if (num < 0) { integer = n; integer2 = this; } else { integer = this; integer2 = n; } return new BigInteger(this.sign * num, doSubBigLil(integer.magnitude, integer2.magnitude), true); }
public BigInteger ModPow(BigInteger exponent, BigInteger m) { if (m.sign < 1) { throw new ArithmeticException("Modulus must be positive"); } if (m.Equals(One)) { return Zero; } if (exponent.sign == 0) { return One; } if (this.sign == 0) { return Zero; } int[] array = null; int[] a = null; bool flag = (m.magnitude[m.magnitude.Length - 1] & 1) == 1; long mQuote = 0L; if (flag) { mQuote = m.GetMQuote(); array = this.ShiftLeft(0x20 * m.magnitude.Length).Mod(m).magnitude; flag = array.Length <= m.magnitude.Length; if (flag) { a = new int[m.magnitude.Length + 1]; if (array.Length < m.magnitude.Length) { int[] numArray4 = new int[m.magnitude.Length]; array.CopyTo(numArray4, (int)(numArray4.Length - array.Length)); array = numArray4; } } } if (!flag) { if (this.magnitude.Length <= m.magnitude.Length) { array = new int[m.magnitude.Length]; this.magnitude.CopyTo(array, (int)(array.Length - this.magnitude.Length)); } else { BigInteger integer2 = this.Remainder(m); array = new int[m.magnitude.Length]; integer2.magnitude.CopyTo(array, (int)(array.Length - integer2.magnitude.Length)); } a = new int[m.magnitude.Length * 2]; } int[] numArray3 = new int[m.magnitude.Length]; for (int i = 0; i < exponent.magnitude.Length; i++) { int num3 = exponent.magnitude[i]; int num4 = 0; if (i == 0) { while (num3 > 0) { num3 = num3 << 1; num4++; } array.CopyTo(numArray3, 0); num3 = num3 << 1; num4++; } while (num3 != 0) { if (flag) { MultiplyMonty(a, numArray3, numArray3, m.magnitude, mQuote); } else { Square(a, numArray3); this.Remainder(a, m.magnitude); Array.Copy(a, a.Length - numArray3.Length, numArray3, 0, numArray3.Length); ZeroOut(a); } num4++; if (num3 < 0) { if (flag) { MultiplyMonty(a, numArray3, array, m.magnitude, mQuote); } else { Multiply(a, numArray3, array); this.Remainder(a, m.magnitude); Array.Copy(a, a.Length - numArray3.Length, numArray3, 0, numArray3.Length); ZeroOut(a); } } num3 = num3 << 1; } while (num4 < 0x20) { if (flag) { MultiplyMonty(a, numArray3, numArray3, m.magnitude, mQuote); } else { Square(a, numArray3); this.Remainder(a, m.magnitude); Array.Copy(a, a.Length - numArray3.Length, numArray3, 0, numArray3.Length); ZeroOut(a); } num4++; } } if (flag) { ZeroOut(array); array[array.Length - 1] = 1; MultiplyMonty(a, numArray3, array, m.magnitude, mQuote); } BigInteger integer3 = new BigInteger(1, numArray3, true); if (exponent.sign <= 0) { return integer3.ModInverse(m); } return integer3; }
public static byte[] AsUnsignedByteArray(BigInteger n) { return n.ToByteArrayUnsigned(); }
public BigInteger Add(BigInteger value) { if (this.sign == 0) { return value; } if (this.sign == value.sign) { return this.AddToMagnitude(value.magnitude); } if (value.sign == 0) { return this; } if (value.sign < 0) { return this.Subtract(value.Negate()); } return value.Subtract(this.Negate()); }
public BigInteger ModInverse(BigInteger m) { if (m.sign < 1) { throw new ArithmeticException("Modulus must be positive"); } BigInteger integer = new BigInteger(); if (!ExtEuclid(this.Mod(m), m, integer, null).Equals(One)) { throw new ArithmeticException("Numbers not relatively prime."); } if (integer.sign < 0) { integer.sign = 1; integer.magnitude = doSubBigLil(m.magnitude, integer.magnitude); } return integer; }
public BigInteger Gcd(BigInteger value) { BigInteger integer; if (value.sign == 0) { return this.Abs(); } if (this.sign == 0) { return value.Abs(); } BigInteger integer2 = this; for (BigInteger integer3 = value; integer3.sign != 0; integer3 = integer) { integer = integer2.Mod(integer3); integer2 = integer3; } return integer2; }
public BigInteger Multiply(BigInteger val) { if ((this.sign == 0) || (val.sign == 0)) { return Zero; } if (val.QuickPow2Check()) { BigInteger integer = this.ShiftLeft(val.Abs().BitLength - 1); if (val.sign <= 0) { return integer.Negate(); } return integer; } if (this.QuickPow2Check()) { BigInteger integer2 = val.ShiftLeft(this.Abs().BitLength - 1); if (this.sign <= 0) { return integer2.Negate(); } return integer2; } int num = ((this.BitLength + val.BitLength) / 0x20) + 1; int[] w = new int[num]; if (val == this) { Square(w, this.magnitude); } else { Multiply(w, this.magnitude, val.magnitude); } return new BigInteger(this.sign * val.sign, w, true); }
public BigInteger Divide(BigInteger val) { if (val.sign == 0) { throw new ArithmeticException("Division by zero error"); } if (this.sign == 0) { return Zero; } if (val.QuickPow2Check()) { BigInteger integer = this.Abs().ShiftRight(val.Abs().BitLength - 1); if (val.sign != this.sign) { return integer.Negate(); } return integer; } int[] x = (int[])this.magnitude.Clone(); return new BigInteger(this.sign * val.sign, this.Divide(x, val.magnitude), true); }
public BigInteger[] DivideAndRemainder(BigInteger val) { if (val.sign == 0) { throw new ArithmeticException("Division by zero error"); } BigInteger[] integerArray = new BigInteger[2]; if (this.sign == 0) { integerArray[0] = Zero; integerArray[1] = Zero; return integerArray; } if (val.QuickPow2Check()) { int n = val.Abs().BitLength - 1; BigInteger integer = this.Abs().ShiftRight(n); int[] numArray = this.LastNBits(n); integerArray[0] = (val.sign == this.sign) ? integer : integer.Negate(); integerArray[1] = new BigInteger(this.sign, numArray, true); return integerArray; } int[] x = (int[])this.magnitude.Clone(); int[] mag = this.Divide(x, val.magnitude); integerArray[0] = new BigInteger(this.sign * val.sign, mag, true); integerArray[1] = new BigInteger(this.sign, x, true); return integerArray; }
private static BigInteger createUValueOf(ulong value) { int num = (int)(value >> 0x20); int num2 = (int)value; if (num != 0) { return new BigInteger(1, new int[] { num, num2 }, false); } if (num2 == 0) { return Zero; } BigInteger integer = new BigInteger(1, new int[] { num2 }, false); if ((num2 & -num2) == num2) { integer.nBits = 1; } return integer; }
public BigInteger AndNot(BigInteger val) { return this.And(val.Not()); }
public BigInteger And(BigInteger value) { if ((this.sign == 0) || (value.sign == 0)) { return Zero; } int[] numArray = (this.sign > 0) ? this.magnitude : this.Add(One).magnitude; int[] numArray2 = (value.sign > 0) ? value.magnitude : value.Add(One).magnitude; bool flag = (this.sign < 0) && (value.sign < 0); int[] mag = new int[Math.Max(numArray.Length, numArray2.Length)]; int num2 = mag.Length - numArray.Length; int num3 = mag.Length - numArray2.Length; for (int i = 0; i < mag.Length; i++) { int num5 = (i >= num2) ? numArray[i - num2] : 0; int num6 = (i >= num3) ? numArray2[i - num3] : 0; if (this.sign < 0) { num5 = ~num5; } if (value.sign < 0) { num6 = ~num6; } mag[i] = num5 & num6; if (flag) { mag[i] = ~mag[i]; } } BigInteger integer = new BigInteger(1, mag, true); if (flag) { integer = integer.Not(); } return integer; }
public BigInteger ShiftLeft(int n) { if ((this.sign == 0) || (this.magnitude.Length == 0)) { return Zero; } if (n == 0) { return this; } if (n < 0) { return this.ShiftRight(-n); } BigInteger integer = new BigInteger(this.sign, ShiftLeft(this.magnitude, n), true); if (this.nBits != -1) { integer.nBits = (this.sign > 0) ? this.nBits : (this.nBits + n); } if (this.nBitLength != -1) { integer.nBitLength = this.nBitLength + n; } return integer; }
public BigInteger Min(BigInteger value) { if (this.CompareTo(value) >= 0) { return value; } return this; }
public BigInteger Remainder(BigInteger n) { int[] numArray; if (n.sign == 0) { throw new ArithmeticException("Division by zero error"); } if (this.sign == 0) { return Zero; } if (n.magnitude.Length == 1) { int m = n.magnitude[0]; if (m > 0) { if (m != 1) { int num2 = this.Remainder(m); if (num2 != 0) { return new BigInteger(this.sign, new int[] { num2 }, false); } } return Zero; } } if (CompareNoLeadingZeroes(0, this.magnitude, 0, n.magnitude) < 0) { return this; } if (n.QuickPow2Check()) { numArray = this.LastNBits(n.Abs().BitLength - 1); } else { numArray = (int[])this.magnitude.Clone(); numArray = this.Remainder(numArray, n.magnitude); } return new BigInteger(this.sign, numArray, true); }
public BigInteger Mod(BigInteger m) { if (m.sign < 1) { throw new ArithmeticException("Modulus must be positive"); } BigInteger integer = this.Remainder(m); if (integer.sign < 0) { return integer.Add(m); } return integer; }
public int CompareTo(BigInteger value) { if (this.sign < value.sign) { return -1; } if (this.sign > value.sign) { return 1; } if (this.sign != 0) { return (this.sign * CompareNoLeadingZeroes(0, this.magnitude, 0, value.magnitude)); } return 0; }
private static BigInteger ExtEuclid(BigInteger a, BigInteger b, BigInteger u1Out, BigInteger u2Out) { BigInteger[] integerArray; BigInteger one = One; BigInteger integer2 = a; BigInteger zero = Zero; for (BigInteger integer4 = b; integer4.sign > 0; integer4 = integerArray[1]) { integerArray = integer2.DivideAndRemainder(integer4); BigInteger n = zero.Multiply(integerArray[0]); BigInteger integer6 = one.Subtract(n); one = zero; zero = integer6; integer2 = integer4; } if (u1Out != null) { u1Out.sign = one.sign; u1Out.magnitude = one.magnitude; } if (u2Out != null) { BigInteger integer7 = one.Multiply(a); BigInteger integer8 = integer2.Subtract(integer7).Divide(b); u2Out.sign = integer8.sign; u2Out.magnitude = integer8.magnitude; } return integer2; }