/// <summary> /// Initialize class with Prime and State Seed values. Values must be probable primes. /// </summary> /// /// <param name="P">Random Prime with probability < 2 ** -100</param> /// <param name="G">Random Generator State</param> /// /// <exception cref="CryptoRandomException">Thrown if P is not a valid prime</exception> public QCG2(BigInteger P, BigInteger G) { if (!P.IsProbablePrime(90)) throw new CryptoRandomException("QCG2:Ctor", "P is not a valid prime number!", new ArgumentOutOfRangeException()); _secRand = new SecureRandom(); _P = P; _G = G; _G0 = G; }
/// <summary> /// A convenience method that generates a random salt vector for key pair generation. /// </summary> /// /// <param name="Size">Byte length of the new salt</param> /// /// <returns>A new salt vector</returns> public byte[] GenerateSalt(int Size = 16) { using (SecureRandom rnd = new SecureRandom()) return rnd.GetBytes(Size); }
/// <summary> /// Initialize the class /// </summary> /// /// <param name="BitLength">Length of integers used in equations; must be at least 512 bits</param> public QCG2(int BitLength) { _secRand = new SecureRandom(); if (BitLength < G_BITS) Initialize(G_BITS); else Initialize(BitLength); }
/// <summary> /// Create a random BigInteger /// </summary> /// /// <param name="UpperBound">The upper bound</param> /// /// <returns>A random BigInteger</returns> public static BigInteger Randomize(BigInteger UpperBound) { if (_secRnd == null) _secRnd = new SecureRandom(); return Randomize(UpperBound, _secRnd); }
/// <summary> /// Create a random BigInteger /// </summary> /// /// <param name="UpperBound">The upper bound</param> /// <param name="SecRnd">An instance of the SecureRandom class</param> /// /// <returns>A random BigInteger</returns> public static BigInteger Randomize(BigInteger UpperBound, SecureRandom SecRnd) { int blen = UpperBound.BitLength; BigInteger randomNum = BigInteger.ValueOf(0); if (SecRnd == null) SecRnd = _secRnd != null ? _secRnd : new SecureRandom(); for (int i = 0; i < 20; i++) { randomNum = new BigInteger(blen, SecRnd); if (randomNum.CompareTo(UpperBound) < 0) return randomNum; } return randomNum.Mod(UpperBound); }
/// <summary> /// Initialize the class /// </summary> public QCG2() { m_secRand = new SecureRandom(); Initialize(G_BITS); }
private void SecRandTest() { using (SecureRandom rnd = new SecureRandom()) { double x1 = 0.0; for (int i = 0; i < 1000; i++) { x1 = rnd.NextDouble(); if (x1 > 1.0) throw new Exception("SecureRandom: NextDouble returned a value outside of the expected range."); } short x2 = 0; for (int i = 0; i < 1000; i++) { x2 = rnd.NextInt16(1, 6); if (x2 > 6) throw new Exception("SecureRandom: NextInt16 returned a value outside of the expected range."); if (x2 < 1) throw new Exception("SecureRandom: NextInt16 returned a value outside of the expected range."); } ushort x3 = 0; for (int i = 0; i < 1000; i++) { x3 = rnd.NextUInt16(1, 52); if (x3 > 52) throw new Exception("SecureRandom: NextUInt16 returned a value outside of the expected range."); if (x3 < 1) throw new Exception("SecureRandom: NextUInt16 returned a value outside of the expected range."); } int x4 = 0; for (int i = 0; i < 1000; i++) { x4 = rnd.NextInt32(3371, 16777216); if (x4 > 16777216) throw new Exception("SecureRandom: NextInt32 returned a value outside of the expected range."); if (x4 < 3371) throw new Exception("SecureRandom: NextInt32 returned a value outside of the expected range."); } uint x5 = 0; for (int i = 0; i < 1000; i++) { x5 = rnd.NextUInt32(77721, 777216); if (x5 > 777216) throw new Exception("SecureRandom: NextUInt32 returned a value outside of the expected range."); if (x5 < 77721) throw new Exception("SecureRandom: NextUInt32 returned a value outside of the expected range."); } long x6 = 0; for (int i = 0; i < 1000; i++) { x6 = rnd.NextInt64(2814749767, 281474976710653); if (x6 > 281474976710656) throw new Exception("SecureRandom: NextInt64 returned a value outside of the expected range."); if (x6 < 2814749767) throw new Exception("SecureRandom: NextInt64 returned a value outside of the expected range."); } ulong x7 = 0; for (int i = 0; i < 1000; i++) { x7 = rnd.NextUInt64(5759403792, 72057594037927934); if (x7 > 72057594037927936) throw new Exception("SecureRandom: NextUInt64 returned a value outside of the expected range."); if (x7 < 5759403792) throw new Exception("SecureRandom: NextUInt64 returned a value outside of the expected range."); } } }
/// <summary> /// Initialize class with Primes, and State Seed values. Values must be probable primes. /// </summary> /// /// <param name="X">Random Generator State (X = X ** 2 mod N)</param> /// <param name="P">P Random Prime</param> /// <param name="Q">Q Random Prime</param> /// <param name="N">Random Prime (N = P * Q)</param> /// /// <exception cref="CryptoRandomException">Thrown if P or Q is not a valid prime</exception> public BBSG(BigInteger X, BigInteger P, BigInteger Q, BigInteger N) { if (!P.IsProbablePrime(90)) throw new CryptoRandomException("BBSG:Ctor", "P is not a valid prime number!", new ArgumentOutOfRangeException()); if (!Q.IsProbablePrime(90)) throw new CryptoRandomException("BBSG:Ctor", "Q is not a valid prime number!", new ArgumentOutOfRangeException()); _secRand = new SecureRandom(); _P = P; _X = X; _N = N; _Q = Q; _X0 = X; }
private void Dispose(bool Disposing) { if (!_isDisposed && Disposing) { try { if (_secRand != null) { _secRand.Dispose(); _secRand = null; } if (_N != null) _N = null; if (_P != null) _P = null; if (_Q != null) _Q = null; if (_X != null) _X = null; if (_X0 != null) _X0 = null; } finally { _isDisposed = true; } } }
/// <summary> /// Initialize the class /// </summary> public MODEXPG() { _secRand = new SecureRandom(); Initialize(G_BITS); }
/// <summary> /// Initialize the class /// </summary> /// /// <param name="BitLength">Length of integers used in equations, must be at least 512 bits</param> public BBSG(int BitLength) { _secRand = new SecureRandom(); if (BitLength < N_BITS) Initialize(N_BITS); else Initialize(BitLength); }
/// <summary> /// /// </summary> /// /// <param name="Rng"></param> /// <param name="Param"></param> public McElieceKeyGenerationParameters(SecureRandom Rng, MPKCParameters Param) : base(Rng, 256) { // XXX key size? _param = Param; }
private static bool MillerRabin(BigInteger X, int T) { // The Miller-Rabin primality test // n >= 0, t >= 0 BigInteger x; // x := UNIFORM{2...n-1} BigInteger y; // y := x^(q * 2^j) mod n BigInteger n_minus_1 = X.Subtract(BigInteger.One); // n-1 int bitLength = n_minus_1.BitLength; // ~ log2(n-1) // (q,k) such that: n-1 = q * 2^k and q is odd int k = n_minus_1.LowestSetBit; BigInteger q = n_minus_1.ShiftRight(k); SecureRandom rnd = new SecureRandom(); for (int i = 0; i < T; i++) { // To generate a witness 'x', first it use the primes of table if (i < _primes.Length) { x = _biPrimes[i]; } else { // It generates random witness only if it's necesssary. // Note that all methods would call Miller-Rabin with t <= 50 so this part is only to do more robust the algorithm do { x = new BigInteger(bitLength, rnd); } while ((x.CompareTo(X) >= BigInteger.EQUALS) || (x._sign == 0) || x.IsOne()); } y = x.ModPow(q, X); if (y.IsOne() || y.Equals(n_minus_1)) continue; for (int j = 1; j < k; j++) { if (y.Equals(n_minus_1)) continue; y = y.Multiply(y).Mod(X); if (y.IsOne()) return false; } if (!y.Equals(n_minus_1)) return false; } return true; }
/// <summary> /// A random number is generated until a probable prime number is found /// </summary> internal static BigInteger ConsBigInteger(int BitLength, int Certainty, SecureRandom Rnd) { // PRE: bitLength >= 2; // For small numbers get a random prime from the prime table if (BitLength <= 10) { int[] rp = _offsetPrimes[BitLength]; return _biPrimes[rp[0] + Rnd.NextInt32(rp[1])]; } int shiftCount = (-BitLength) & 31; int last = (BitLength + 31) >> 5; BigInteger n = new BigInteger(1, last, new int[last]); last--; do {// To fill the array with random integers for (int i = 0; i < n._numberLength; i++) n._digits[i] = Rnd.Next(); // To fix to the correct bitLength // n.digits[last] |= 0x80000000; n._digits[last] |= Int32.MinValue; n._digits[last] = IntUtils.URShift(n._digits[last], shiftCount); // To create an odd number n._digits[0] |= 1; } while (!IsProbablePrime(n, Certainty)); return n; }
private void Dispose(bool Disposing) { if (!_isDisposed && Disposing) { try { if (_secRand != null) { _secRand.Dispose(); _secRand = null; } if (_BI3 != null) _BI3 = null; if (_G != null) _G = null; if (_G0 != null) _G0 = null; if (_P != null) _P = null; } finally { _isDisposed = true; } } }
/// <summary> /// Initialize the class /// </summary> public BBSG() { _secRand = new SecureRandom(); Initialize(N_BITS); }
/// <summary> /// Initialize the class /// </summary> public QCG2() { _secRand = new SecureRandom(); Initialize(G_BITS); }
/// <summary> /// Initialize the class /// </summary> public CCG() { _secRand = new SecureRandom(); Initialize(G_BITS); }