mcs/class/corlib/corefx/RandomNumberGenerator.cs

   1 using System.Buffers;
   2 using System.Runtime.InteropServices;
   3
   4 namespace System.Security.Cryptography
   5 {
   6         partial class RandomNumberGenerator
   7         {
   8                 public static void Fill (Span<byte> data)
   9                 {
  10                         FillSpan (data);
  11                 }
  12
  13                 internal static unsafe void FillSpan (Span<byte> data)
  14                 {
  15                         if (data.Length > 0) {
  16                                 fixed (byte* ptr = data) Interop.GetRandomBytes (ptr, data.Length);
  17                         }
  18                 }
  19
  20                 public virtual void GetBytes(Span<byte> data)
  21                 {
  22                         byte[] array = ArrayPool<byte>.Shared.Rent(data.Length);
  23                         try
  24                         {
  25                                 GetBytes(array, 0, data.Length);
  26                                 new ReadOnlySpan<byte>(array, 0, data.Length).CopyTo(data);
  27                         }
  28                         finally
  29                         {
  30                                 Array.Clear(array, 0, data.Length);
  31                                 ArrayPool<byte>.Shared.Return(array);
  32                         }
  33                 }
  34
  35                 public virtual void GetNonZeroBytes(Span<byte> data)
  36                 {
  37                         byte[] array = ArrayPool<byte>.Shared.Rent(data.Length);
  38                         try
  39                         {
  40                                 // NOTE: There is no GetNonZeroBytes(byte[], int, int) overload, so this call
  41                                 // may end up retrieving more data than was intended, if the array pool
  42                                 // gives back a larger array than was actually needed.
  43                                 GetNonZeroBytes(array);
  44                                 new ReadOnlySpan<byte>(array, 0, data.Length).CopyTo(data);
  45                         }
  46                         finally
  47                         {
  48                                 Array.Clear(array, 0, data.Length);
  49                                 ArrayPool<byte>.Shared.Return(array);
  50                         }
  51                 }
  52
  53                 public static int GetInt32(int fromInclusive, int toExclusive)
  54                 {
  55                         if (fromInclusive >= toExclusive)
  56                                 throw new ArgumentException(SR.Argument_InvalidRandomRange);
  57
  58                         // The total possible range is [0, 4,294,967,295).
  59                         // Subtract one to account for zero being an actual possibility.
  60                         uint range = (uint)toExclusive - (uint)fromInclusive - 1;
  61
  62                         // If there is only one possible choice, nothing random will actually happen, so return
  63                         // the only possibility.
  64                         if (range == 0)
  65                         {
  66                                 return fromInclusive;
  67                         }
  68
  69                         // Create a mask for the bits that we care about for the range. The other bits will be
  70                         // masked away.
  71                         uint mask = range;
  72                         mask |= mask >> 1;
  73                         mask |= mask >> 2;
  74                         mask |= mask >> 4;
  75                         mask |= mask >> 8;
  76                         mask |= mask >> 16;
  77
  78                         Span<uint> resultSpan = stackalloc uint[1];
  79                         uint result;
  80
  81                         do
  82                         {
  83                                 FillSpan(MemoryMarshal.AsBytes(resultSpan));
  84                                 result = mask & resultSpan[0];
  85                         }
  86                         while (result > range);
  87
  88                         return (int)result + fromInclusive;
  89                 }
  90
  91                 public static int GetInt32(int toExclusive)
  92                 {
  93                         if (toExclusive <= 0)
  94                                 throw new ArgumentOutOfRangeException(nameof(toExclusive), SR.ArgumentOutOfRange_NeedPosNum);
  95
  96                         return GetInt32(0, toExclusive);
  97                 }
  98         }
  99 }