Add a 'secure' constructor to Random in dart:math returning a cryptographically

sdk/lib/math/random.dart

Index: sdk/lib/math/random.dart
diff --git a/sdk/lib/math/random.dart b/sdk/lib/math/random.dart
index 0c1c76cf81c85c0fa5d8c57efc63271e568f5a86..a4bb895ee1b292b267e0485fa0bbfdc7cf11ee1d 100644
--- a/sdk/lib/math/random.dart
+++ b/sdk/lib/math/random.dart
@@ -9,18 +9,29 @@ part of dart.math;
  *
  * The default implementation supplies a stream of
  * pseudo-random bits that are not suitable for cryptographic purposes.
+ *
+ * Use the Random.secure() constructor for cryptographic
+ * purposes.
  */
 abstract class Random {
   /**
    * Creates a random number generator.
    *
-   * The optional parameter [seed] is used
-   * to initialize the internal state of the generator. The implementation of
-   * the random stream can change between releases of the library.
+   * The optional parameter [seed] is used to initialize the
+   * internal state of the generator. The implementation of the
+   * random stream can change between releases of the library.
    */
   external factory Random([int seed]);
 
   /**
+   * Creates a cryptographically secure random number generator.
+   *
+   * The generator reads from the entropy source to generate every

[Lasse Reichstein Nielsen, 2015/10/14 11:08:45]

the entropy source -> an entropy source
(there is no description of which entropy source it is, so using a definite
pronoun is confusing - it makes me think I should know what it is talking
about).
Or better, drop the entire sentence - it's an implementation detail.
The user does no need to know that you are using "entropy" from somewhere (which
is just a fancy word for "random bits"). The returned random number generator is
cryptographically secure, that's all you need to know.
Well, maybe we should say what "cryptographically secure" means in this context
- I wouldn't trust something just because it calls itself cryptographically
secure, for all I know it could be implemented by amateurs who thinks xoring
with timestamps is safe. What are the guarantees provided by using this RNG?

I'm not sure an embedded device is able to implement this safely.
What should an implementation do if it doesn't have access to cryptographically
secure entropy? Should it throw an UnsupportedError?
That seems safer than falling back on something insecure.
So, maybe add to docs: If the program cannot provide a cryptographically secure
source of random numbers, it throws an [UnsupportedError].


Are we absolutely sure we want this in dart:math.

[regis, 2015/10/14 20:22:35]

Dropped.
Added.
It is what the bug report wanted.
Now, the plan is to expand the crypto package. We may revisit then.
But it is good to have a hook here, since people looking for a random generator
may see the secure one and use it for their cryptographic application.

+   * random value.
+   */
+  external factory Random.secure();
+
+  /**
    * Generates a non-negative random integer uniformly distributed in the range
    * from 0, inclusive, to [max], exclusive.
    *