Avoid fallback to weak entropy for the PRNGs on Windows.

src/utils/random-number-generator.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 10 matching lines @@
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "utils/random-number-generator.h"
 
 #include <cstdio>
+#include <cstdlib>
 
 #include "flags.h"
 #include "platform/mutex.h"
 #include "platform/time.h"
 #include "utils.h"
 
 namespace v8 {
 namespace internal {
 
 static LazyMutex entropy_mutex = LAZY_MUTEX_INITIALIZER;
@@ skipping 19 matching lines @@
     if (entropy_source != NULL) {
       int64_t seed;
       if (entropy_source(reinterpret_cast<unsigned char*>(&seed),
                          sizeof(seed))) {
         SetSeed(seed);
         return;
       }
     }
   }
 
+#if V8_OS_CYGWIN || V8_OS_WIN
+  // Use rand_s() to gather entropy on Windows. See:
+  // https://code.google.com/p/v8/issues/detail?id=2905
+  unsigned first_half, second_half;
+  errno_t result = rand_s(&first_half);
+  ASSERT_EQ(0, result);
+  result = rand_s(&second_half);
+  ASSERT_EQ(0, result);
+  SetSeed((static_cast<int64_t>(first_half) << 32) + second_half);
+#else
   // Gather entropy from /dev/urandom if available.
   FILE* fp = fopen("/dev/urandom", "rb");
   if (fp != NULL) {
     int64_t seed;
     size_t n = fread(&seed, sizeof(seed), 1, fp);
     fclose(fp);
     if (n == 1) {
       SetSeed(seed);
       return;
     }
   }
 
   // We cannot assume that random() or rand() were seeded
   // properly, so instead of relying on random() or rand(),
   // we just seed our PRNG using timing data as fallback.
   // This is weak entropy, but it's sufficient, because
   // it is the responsibility of the embedder to install
   // an entropy source using v8::V8::SetEntropySource(),
   // which provides reasonable entropy, see:
   // https://code.google.com/p/v8/issues/detail?id=2905
   int64_t seed = Time::NowFromSystemTime().ToInternalValue() << 24;
   seed ^= TimeTicks::HighResNow().ToInternalValue() << 16;
   seed ^= TimeTicks::Now().ToInternalValue() << 8;
   SetSeed(seed);
+#endif  // V8_OS_CYGWIN || V8_OS_WIN
 }
 
 
 int RandomNumberGenerator::NextInt(int max) {
   ASSERT_LE(0, max);
 
   // Fast path if max is a power of 2.
   if (IsPowerOf2(max)) {
     return static_cast<int>((max * static_cast<int64_t>(Next(31))) >> 31);
   }
@@ skipping 28 matching lines @@
   seed_ = seed;
   return static_cast<int>(seed >> (48 - bits));
 }
 
 
 void RandomNumberGenerator::SetSeed(int64_t seed) {
   seed_ = (seed ^ kMultiplier) & kMask;
 }
 
 } }  // namespace v8::internal