/** 
  * Create a System.Random object from this RandomNumberGenerator
  */
 public SecureRandom(RandomNumberGenerator rng) {
   _rng = rng;
   _sample_buffer = new byte[4];
   _state = new Sample();
   _state.Val = 0;
   _state.Max = 1;
 }

 private byte[] HashPasswordV3(string password, RandomNumberGenerator rng) {
   return HashPasswordV3(password, rng,
     prf: KeyDerivationPrf.HMACSHA256,
     iterCount: _iterCount,
     saltSize: 128 / 8,
     numBytesRequested: 256 / 8);
 }

 private PasswordHasher() {
   _iterCount = 10000;
   if (_iterCount < 1) {
     throw new InvalidOperationException("InvalidPasswordHasherIterationCount");
   }
   _rng = RandomNumberGenerator.Create();
 }

 public override byte[] CreateKeyExchange(byte[] rgbData)
 {
     if (this._rsaKey == null)
     {
         throw new CryptographicUnexpectedOperationException(Environment.GetResourceString("Cryptography_MissingKey"));
     }
     if (this._rsaKey is RSACryptoServiceProvider)
     {
         return ((RSACryptoServiceProvider) this._rsaKey).Encrypt(rgbData, false);
     }
     int num = this._rsaKey.KeySize / 8;
     if ((rgbData.Length + 11) > num)
     {
         throw new CryptographicException(Environment.GetResourceString("Cryptography_Padding_EncDataTooBig", new object[] { num - 11 }));
     }
     byte[] data = new byte[num];
     if (this.RngValue == null)
     {
         this.RngValue = RandomNumberGenerator.Create();
     }
     this.Rng.GetNonZeroBytes(data);
     data[0] = 0;
     data[1] = 2;
     data[(num - rgbData.Length) - 1] = 0;
     Buffer.InternalBlockCopy(rgbData, 0, data, num - rgbData.Length, rgbData.Length);
     return this._rsaKey.EncryptValue(data);
 }

        private void SetUp(long length) {
            this.transmission = new Transmission(TransmissionType.DOWNLOAD_NEW_FILE, "testfile");
            this.transmission.AddDefaultConstraints();
            if (this.localFileStream != null) {
                this.localFileStream.Dispose();
            }

            this.localFileStream = new MemoryStream();
            if (this.hashAlg != null) {
                this.hashAlg.Dispose();
            }

            this.hashAlg = new SHA1Managed();
            this.remoteLength = length;
            this.remoteContent = new byte[this.remoteLength];
            if (this.random != null) {
                this.random.Dispose();
            }

            this.random = RandomNumberGenerator.Create();
            this.random.GetBytes(this.remoteContent);
            this.mockedMemStream = new Mock<MemoryStream>(this.remoteContent) { CallBase = true };
            this.mockedStream = new Mock<IContentStream>();
            this.mockedStream.Setup(stream => stream.Length).Returns(this.remoteLength);
            this.mockedStream.Setup(stream => stream.Stream).Returns(this.mockedMemStream.Object);
            this.mockedDocument = new Mock<IDocument>();
            this.mockedDocument.Setup(doc => doc.ContentStreamLength).Returns(this.remoteLength);
            this.mockedDocument.Setup(doc => doc.GetContentStream()).Returns(this.mockedStream.Object);
        }

 private static int GenerateRandomInt32Value(RandomNumberGenerator randomNumberGenerator)
 {
     var fourRandomBytes = new byte[4]; // 4 bytes = 32 bits = Int32
     randomNumberGenerator.GetBytes(fourRandomBytes);
     var randomInt32Value = BitConverter.ToInt32(fourRandomBytes, 0);
     return randomInt32Value;
 }

 /**
  * Return a random AHAddress initialized from the given rng
  */
 public AHAddress(RandomNumberGenerator rng)
 {
   byte[] buffer = new byte[MemSize];
   rng.GetBytes(buffer);
   SetClass(buffer, this.Class);
   _buffer = MemBlock.Reference(buffer, 0, MemSize);
   _prefix = (uint)NumberSerializer.ReadInt(_buffer, 0);
 }

 /// <summary>
 /// Construct a new random number generator with random seed.
 /// </summary>
 /// <param name="rng">The <see cref="RandomNumberGenerator"/> to use.</param>
 /// <param name="threadSafe">if set to <c>true</c> , the class is thread safe.</param>
 public SystemCryptoRandomNumberGenerator(RandomNumberGenerator rng, bool threadSafe) : base(threadSafe)
 {
     if (rng == null)
     {
         throw new ArgumentNullException("rng");
     }
     mRandom = rng;
 }

        public RNGCryptoServiceProvider(CspParameters cspParams)
        {
            if (cspParams != null)
                throw new PlatformNotSupportedException();

            // This class wraps RandomNumberGenerator.Create() from Algorithms assembly
            _impl = Create();
        }

        /// <summary>
        /// Initializes a new instance of the RandomNumberGeneratorWrapper class, wrapping a given <see cref="System.Security.Cryptography.RandomNumberGenerator"/> instance.
        /// </summary>
        /// <param name="rand">The instance of <see cref="System.Security.Cryptography.RandomNumberGenerator"/> to wrap.</param>
        /// <exception cref="System.ArgumentNullException"><paramref name="rand"/> is null.</exception>
        public RandomNumberGeneratorWrapper(RandomNumberGenerator rand)
        {
            if (rand == null) {
                throw new ArgumentNullException("rand");
            }

            this.rand = rand;
        }

        public CryptoApiEntropySourceProvider(RandomNumberGenerator rng, bool isPredictionResistant)
        {
            if (rng == null)
                throw new ArgumentNullException("rng");

            mRng = rng;
            mPredictionResistant = isPredictionResistant;
        }

		static public byte[] IV (int size) 
		{
			if (rng == null)
				rng = RandomNumberGenerator.Create ();

			byte[] iv = new byte [size];
			rng.GetBytes (iv);
			return iv;
		}

 public PatchworkTransformService(
     RandomNumberGenerator randomNumberGenerator,
     byte delta = 4,
     int iterationNumber = 20000)
 {
     this._randomNumberGenerator = randomNumberGenerator;
     this._delta = delta;
     this._iterationNumber = iterationNumber;
 }

		static public byte[] Key (int size) 
		{
			if (rng == null)
				rng = RandomNumberGenerator.Create ();

			byte[] key = new byte [size];
			rng.GetBytes (key);
			return key;
		}

        public static RandomNumberGenerator GetRandom()
        {
            if (_random == null)
            {
                _random = new RNGCryptoServiceProvider();
            }

            return _random;
        }

 public TokenManager()
 {
     sha1 = SHA1.Create();
     random = RandomNumberGenerator.Create();
     LastSecretGeneration = DateTime.MinValue; //in order to force the update
     secret = new byte[10];
     previousSecret = new byte[10];
     random.GetNonZeroBytes(secret);
     random.GetNonZeroBytes(previousSecret);
 }

 internal static string Create(ref RandomNumberGenerator randgen)
 {
     if (randgen == null)
     {
         randgen = new RNGCryptoServiceProvider();
     }
     byte[] data = new byte[15];
     randgen.GetBytes(data);
     return Encode(data);
 }

        protected Spritz()
        {
#if !DOTNET5_4
            LegalBlockSizesValue = s_legalBlockSizes;
            LegalKeySizesValue = s_legalKeySizes;
#endif
            this.BlockSize = 256;
            this.KeySize = 128;
            this.rng = RandomNumberGenerator.Create();
        }

        protected Salsa20()
        {
#if NET451
            LegalBlockSizesValue = s_legalBlockSizes;
            LegalKeySizesValue = s_legalKeySizes;
#endif
            this.BlockSize = 64;
            this.KeySize = 256;
            this.Rounds = Salsa20Rounds.Twenty;
            this.rng = RandomNumberGenerator.Create();
        }

 public CumulativeRandom(int maxTimes)
 {
     rnd = RNGCryptoServiceProvider.Create();
     //rnd = new Random();
     basis = 1.0/maxTimes;
     buff = 0.0;
 }