Replace calls to rand_s with calls to RtlGenRandom

sandbox/win/src/interception_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file contains unit tests for InterceptionManager.
 // The tests require private information so the whole interception.cc file is
 // included from this file.
 
+#include <algorithm>
+#include <set>
+
 #include <windows.h>
 
+#include "base/bits.h"
 #include "base/memory/scoped_ptr.h"
 #include "sandbox/win/src/interception.h"
 #include "sandbox/win/src/interceptors.h"
 #include "sandbox/win/src/interception_internal.h"
 #include "sandbox/win/src/target_process.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace sandbox {
 
+namespace internal {
+size_t GetGranularAlignedRandomOffset(size_t size);
+}
+
 // Walks the settings buffer, verifying that the values make sense and counting
 // objects.
 // Arguments:
 // buffer (in): the buffer to walk.
 // size (in): buffer size
 // num_dlls (out): count of the dlls on the buffer.
 // num_function (out): count of intercepted functions.
 // num_names (out): count of named interceptor functions.
 void WalkBuffer(void* buffer, size_t size, int* num_dlls, int* num_functions,
                 int* num_names) {
@@ skipping 38 matching lines @@
       function = reinterpret_cast<FunctionInfo*>(
         reinterpret_cast<char*>(function) + function->record_bytes);
     }
 
     (*num_dlls)++;
     dll = reinterpret_cast<DllPatchInfo*>(reinterpret_cast<char*>(dll) +
                                           dll->record_bytes);
   }
 }
 
+TEST(InterceptionManagerTest, GetGranularAlignedRandomOffset) {
+  std::set<size_t> sizes;
+
+  // 544 is current value of interceptions_.size() * sizeof(ThunkData) +
+  // sizeof(DllInterceptionData).
+  const size_t kThunkBytes = 544;
+
+  // ciel(log2(544)) = 10.
+  // Alignment must be 2^10 = 1024.
+  const size_t kAlignmentBits = base::bits::Log2Ceiling(kThunkBytes);
+  const size_t kAlignment = 1 << kAlignmentBits;
+
+  const size_t kAllocGranularity = 65536;
+
+  // Generate enough sample data to ensure there is at least one value in each
+  // potential bucket.
+  for (size_t i = 0; i < 1000000; i++)
+    sizes.insert(internal::GetGranularAlignedRandomOffset(kThunkBytes));
+
+  size_t prev_val = 0;
+  size_t min_val = kAllocGranularity;
+  size_t min_nonzero_val = kAllocGranularity;
+  size_t max_val = 0;
+
+  for (size_t val : sizes) {
+    ASSERT_LT(val, kAllocGranularity);
+    if (prev_val)
+      ASSERT_EQ(val - prev_val, kAlignment);
+    if (val)
+      min_nonzero_val = std::min(val, min_nonzero_val);
+    min_val = std::min(val, min_val);
+    prev_val = val;
+    max_val = std::max(val, max_val);
+  }
+  ASSERT_EQ(max_val, kAllocGranularity - kAlignment);
+  ASSERT_EQ(min_val, 0);
+  ASSERT_EQ(min_nonzero_val, kAlignment);
+}
+
 TEST(InterceptionManagerTest, BufferLayout1) {
   wchar_t exe_name[MAX_PATH];
   ASSERT_NE(0u, GetModuleFileName(NULL, exe_name, MAX_PATH - 1));
 
   TargetProcess *target = MakeTestTargetProcess(::GetCurrentProcess(),
                                                 ::GetModuleHandle(exe_name));
 
   InterceptionManager interceptions(target, true);
 
   // Any pointer will do for a function pointer.
@@ skipping 115 matching lines @@
   int num_dlls, num_functions, num_names;
   WalkBuffer(local_buffer.get(), buffer_size, &num_dlls, &num_functions,
              &num_names);
 
   EXPECT_EQ(3, num_dlls);
   EXPECT_EQ(4, num_functions);
   EXPECT_EQ(0, num_names);
 }
 
 }  // namespace sandbox