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

runtime/lib/math.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include <ctype.h>  // isspace.
 
 #include "vm/bootstrap_natives.h"
 
 #include "vm/exceptions.h"
 #include "vm/native_entry.h"
@@ skipping 75 matching lines @@
   ASSERT(!state_field_value.IsNull());
   ASSERT(state_field_value.IsTypedData());
   const TypedData& array = TypedData::Cast(state_field_value);
   ASSERT(array.Length() == 2);
   ASSERT(array.ElementType() == kUint32ArrayElement);
   return array.raw();
 }
 
 
 // Implements:
-//   var state = ((_A * (_state[kSTATE_LO])) + _state[kSTATE_HI]) & _MASK_64;
-//   _state[kSTATE_LO] = state & _MASK_32;
-//   _state[kSTATE_HI] = state >> 32;
+//   var state =
+//       ((_A * (_state[_kSTATE_LO])) + _state[_kSTATE_HI]) & (1 << 64) - 1);
+//   _state[_kSTATE_LO] = state & (1 << 32) - 1);
+//   _state[_kSTATE_HI] = state >> 32;
 DEFINE_NATIVE_ENTRY(Random_nextState, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, receiver, arguments->NativeArgAt(0));
   const TypedData& array = TypedData::Handle(GetRandomStateArray(receiver));
   const uint64_t state_lo = array.GetUint32(0);
   const uint64_t state_hi = array.GetUint32(array.ElementSizeInBytes());
   const uint64_t A = 0xffffda61;
   uint64_t state = (A * state_lo) + state_hi;
   array.SetUint32(0, static_cast<uint32_t>(state));
   array.SetUint32(array.ElementSizeInBytes(),
       static_cast<uint32_t>(state >> 32));
@@ skipping 29 matching lines @@
 // Implements:
 //   uint64_t hash = 0;
 //   do {
 //      hash = hash * 1037 ^ mix64((uint64_t)seed);
 //      seed >>= 64;
 //   } while (seed != 0 && seed != -1);  // Limits if seed positive or negative.
 //   if (hash == 0) {
 //     hash = 0x5A17;
 //   }
 //   var result = new Uint32List(2);
-//   result[kSTATE_LO] = seed & _MASK_32;
-//   result[kSTATE_HI] = seed >> 32;
+//   result[_kSTATE_LO] = seed & ((1 << 32) - 1);
+//   result[_kSTATE_HI] = seed >> 32;
 //   return result;
 DEFINE_NATIVE_ENTRY(Random_setupSeed, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(Integer, seed_int, arguments->NativeArgAt(0));
   uint64_t seed = 0;
   if (seed_int.IsBigint()) {
     Bigint& big_seed = Bigint::Handle();
     big_seed ^= seed_int.raw();
     uint64_t negate_mask = 0;
     uint64_t borrow = 0;
     if (big_seed.IsNegative()) {
@@ skipping 31 matching lines @@
 }
 
 
 DEFINE_NATIVE_ENTRY(Random_initialSeed, 0) {
   Random* rnd = isolate->random();
   uint64_t seed = rnd->NextUInt32();
   seed |= (static_cast<uint64_t>(rnd->NextUInt32()) << 32);
   return CreateRandomState(zone, seed);
 }
 
+
+DEFINE_NATIVE_ENTRY(SecureRandom_getBytes, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Smi, count, arguments->NativeArgAt(0));
+  const intptr_t n = count.Value();
+  ASSERT((n > 0) && (n <= 8));
+  uint8_t buffer[8];
+  Dart_EntropySource entropy_source = isolate->entropy_source_callback();
+  if ((entropy_source == NULL) || !entropy_source(buffer, n)) {
+    const String& error = String::Handle(String::New(
+        "No source of cryptographically secure random numbers available."));
+    const Array& args = Array::Handle(Array::New(1));
+    args.SetAt(0, error);
+    Exceptions::ThrowByType(Exceptions::kUnsupported, args);
+  }
+  uint64_t result = 0;
+  for (intptr_t i = 0; i < n; i++) {
+    result = (result << 8) | buffer[i];
+  }
+  return Integer::New(result);
+}
+
 }  // namespace dart