public byte[] GetEntropy() { lock (this) { byte[] nxt; if (buf == null) { buf = entropySource.GetEntropy(); } // FSM_STATE:5.1, "CONTINUOUS NDRBG TEST", "The module is performing Continuous NDRNG self-test" // FSM_TRANS:5.1, "CONDITIONAL TEST", "CONTINUOUS NDRNG TEST", "Invoke Continuous NDRNG test" nxt = entropySource.GetEntropy(); if (Arrays.AreEqual(nxt, buf)) { CryptoStatus.MoveToErrorStatus("Duplicate block detected in EntropySource output"); } // FSM_TRANS:5.2, "CONTINUOUS NDRNG TEST", "CONDITIONAL TEST", "Continuous NDRNG test successful" Array.Copy(nxt, 0, buf, 0, buf.Length); return(nxt); } }
internal int Generate(byte[] output, bool predictionResistant) { //IL_0041: Unknown result type (might be due to invalid IL or missing references) //IL_007d: Unknown result type (might be due to invalid IL or missing references) //IL_00b9: Unknown result type (might be due to invalid IL or missing references) if (mR.Length == 8) { if (mReseedCounter > 32768) { return(-1); } if (IsTooLarge(output, 512)) { throw new ArgumentException(string.Concat((object)"Number of bits per request limited to ", (object)4096), "output"); } } else { if (mReseedCounter > 8388608) { return(-1); } if (IsTooLarge(output, 32768)) { throw new ArgumentException(string.Concat((object)"Number of bits per request limited to ", (object)262144), "output"); } } if (predictionResistant || mV == null) { mV = mEntropySource.GetEntropy(); if (mV.Length != mEngine.GetBlockSize()) { throw new InvalidOperationException("Insufficient entropy returned"); } } int num = output.Length / mR.Length; for (int i = 0; i < num; i++) { mEngine.ProcessBlock(mDT, 0, mI, 0); Process(mR, mI, mV); Process(mV, mR, mI); global::System.Array.Copy((global::System.Array)mR, 0, (global::System.Array)output, i * mR.Length, mR.Length); Increment(mDT); } int num2 = output.Length - num * mR.Length; if (num2 > 0) { mEngine.ProcessBlock(mDT, 0, mI, 0); Process(mR, mI, mV); Process(mV, mR, mI); global::System.Array.Copy((global::System.Array)mR, 0, (global::System.Array)output, num * mR.Length, num2); Increment(mDT); } mReseedCounter++; return(output.Length); }
internal int Generate(byte[] output, bool predictionResistant) { if (mR.Length == 8) { if (mReseedCounter > 32768) { return(-1); } if (IsTooLarge(output, 512)) { throw new ArgumentException("Number of bits per request limited to " + 4096, "output"); } } else { if (mReseedCounter > 8388608) { return(-1); } if (IsTooLarge(output, 32768)) { throw new ArgumentException("Number of bits per request limited to " + 262144, "output"); } } if (predictionResistant || mV == null) { mV = mEntropySource.GetEntropy(); if (mV.Length != mEngine.GetBlockSize()) { throw new InvalidOperationException("Insufficient entropy returned"); } } int num = output.Length / mR.Length; for (int i = 0; i < num; i++) { mEngine.ProcessBlock(mDT, 0, mI, 0); Process(mR, mI, mV); Process(mV, mR, mI); Array.Copy(mR, 0, output, i * mR.Length, mR.Length); Increment(mDT); } int num2 = output.Length - num * mR.Length; if (num2 > 0) { mEngine.ProcessBlock(mDT, 0, mI, 0); Process(mR, mI, mV); Process(mV, mR, mI); Array.Copy(mR, 0, output, num * mR.Length, num2); Increment(mDT); } mReseedCounter++; return(output.Length); }
private byte[] GetEntropy() { byte[] entropy = mEntropySource.GetEntropy(); if (entropy.Length < (mSecurityStrength + 7) / 8) { throw new InvalidOperationException("Insufficient entropy provided by entropy source"); } return(entropy); }
private byte[] GetEntropy() { //IL_0020: Unknown result type (might be due to invalid IL or missing references) byte[] entropy = mEntropySource.GetEntropy(); if (entropy.Length < (mSecurityStrength + 7) / 8) { throw new InvalidOperationException("Insufficient entropy provided by entropy source"); } return(entropy); }
/** * Generate numBytes worth of entropy from the passed in entropy source. * * @param entropySource the entropy source to request the data from. * @param numBytes the number of bytes of entropy requested. * @return a byte array populated with the random data. */ public static byte[] GenerateSeed(IEntropySource entropySource, int numBytes) { byte[] bytes = new byte[numBytes]; int count = 0; while (count < numBytes) { byte[] entropy = entropySource.GetEntropy(); int toCopy = System.Math.Min(bytes.Length, numBytes - count); Array.Copy(entropy, 0, bytes, count, toCopy); count += toCopy; } return bytes; }
public static byte[] GenerateSeed(IEntropySource entropySource, int numBytes) { byte[] array = new byte[numBytes]; int num; for (int i = 0; i < numBytes; i += num) { byte[] entropy = entropySource.GetEntropy(); num = Math.Min(array.Length, numBytes - i); Array.Copy(entropy, 0, array, i, num); } return(array); }
/** * Generate numBytes worth of entropy from the passed in entropy source. * * @param entropySource the entropy source to request the data from. * @param numBytes the number of bytes of entropy requested. * @return a byte array populated with the random data. */ public static byte[] GenerateSeed(IEntropySource entropySource, int numBytes) { byte[] bytes = new byte[numBytes]; int count = 0; while (count < numBytes) { byte[] entropy = entropySource.GetEntropy(); int toCopy = System.Math.Min(bytes.Length, numBytes - count); Array.Copy(entropy, 0, bytes, count, toCopy); count += toCopy; } return(bytes); }
/** * Populate a passed in array with random data. * * @param output output array for generated bits. * @param predictionResistant true if a reseed should be forced, false otherwise. * * @return number of bits generated, -1 if a reseed required. */ internal int Generate(byte[] output, bool predictionResistant) { if (mR.Length == 8) // 64 bit block size { if (mReseedCounter > BLOCK64_RESEED_MAX) { return(-1); } if (IsTooLarge(output, BLOCK64_MAX_BITS_REQUEST / 8)) { throw new ArgumentException("Number of bits per request limited to " + BLOCK64_MAX_BITS_REQUEST, "output"); } } else { if (mReseedCounter > BLOCK128_RESEED_MAX) { return(-1); } if (IsTooLarge(output, BLOCK128_MAX_BITS_REQUEST / 8)) { throw new ArgumentException("Number of bits per request limited to " + BLOCK128_MAX_BITS_REQUEST, "output"); } } if (predictionResistant || mV == null) { mV = mEntropySource.GetEntropy(); if (mV.Length != mEngine.GetBlockSize()) { throw new InvalidOperationException("Insufficient entropy returned"); } } int m = output.Length / mR.Length; for (int i = 0; i < m; i++) { mEngine.ProcessBlock(mDT, 0, mI, 0); Process(mR, mI, mV); Process(mV, mR, mI); Array.Copy(mR, 0, output, i * mR.Length, mR.Length); Increment(mDT); } int bytesToCopy = (output.Length - m * mR.Length); if (bytesToCopy > 0) { mEngine.ProcessBlock(mDT, 0, mI, 0); Process(mR, mI, mV); Process(mV, mR, mI); Array.Copy(mR, 0, output, m * mR.Length, bytesToCopy); Increment(mDT); } mReseedCounter++; return(output.Length); }