// Copyright 2008 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.
|
|
#include "base/rand_util.h"
|
|
#include <fcntl.h>
|
#include <string.h>
|
|
#include <algorithm>
|
#include <cmath>
|
#include <limits>
|
|
#include "base/files/file_util.h"
|
#include "base/logging.h"
|
#include "build/build_config.h"
|
|
#if defined(OS_FUCHSIA)
|
#include <zircon/syscalls.h>
|
#include "base/fuchsia/fuchsia_logging.h"
|
#elif defined(OS_POSIX)
|
#include "base/posix/eintr_wrapper.h"
|
#elif defined(OS_WIN)
|
#include <windows.h>
|
|
// #define needed to link in RtlGenRandom(), a.k.a. SystemFunction036. See the
|
// "Community Additions" comment on MSDN here:
|
// http://msdn.microsoft.com/en-us/library/windows/desktop/aa387694.aspx
|
#define SystemFunction036 NTAPI SystemFunction036
|
#include <NTSecAPI.h>
|
#undef SystemFunction036
|
|
#endif // OS_WIN
|
|
#if defined(OS_POSIX) && !defined(OS_FUCHSIA)
|
|
namespace {
|
|
int GetUrandomFDInternal() {
|
int fd = HANDLE_EINTR(open("/dev/urandom", O_RDONLY | O_NOCTTY | O_CLOEXEC));
|
PCHECK(fd >= 0) << "open /dev/urandom";
|
return fd;
|
}
|
|
int GetUrandomFD() {
|
static int fd = GetUrandomFDInternal();
|
return fd;
|
}
|
|
} // namespace
|
|
#endif // OS_POSIX && !OS_FUCHSIA
|
|
namespace base {
|
|
uint64_t RandUint64() {
|
uint64_t number;
|
RandBytes(&number, sizeof(number));
|
return number;
|
}
|
|
int RandInt(int min, int max) {
|
DCHECK_LE(min, max);
|
|
uint64_t range = static_cast<uint64_t>(max) - min + 1;
|
int result = min + static_cast<int>(base::RandGenerator(range));
|
DCHECK_GE(result, min);
|
DCHECK_LE(result, max);
|
|
return result;
|
}
|
|
uint64_t RandGenerator(uint64_t range) {
|
DCHECK_GT(range, 0u);
|
|
uint64_t max_acceptable_value =
|
(std::numeric_limits<uint64_t>::max() / range) * range - 1;
|
|
uint64_t value;
|
do {
|
value = base::RandUint64();
|
} while (value > max_acceptable_value);
|
|
return value % range;
|
}
|
|
double RandDouble() {
|
static_assert(std::numeric_limits<double>::radix == 2,
|
"otherwise use scalbn");
|
static_assert(std::numeric_limits<double>::digits <
|
std::numeric_limits<uint64_t>::digits,
|
"integer type must be wider than floating-point mantissa");
|
|
uint64_t random_bits = RandUint64();
|
const int kMantissaBits = std::numeric_limits<double>::digits;
|
|
uint64_t mantissa = random_bits & ((UINT64_C(1) << kMantissaBits) - 1);
|
|
double result = std::ldexp(mantissa, -1 * kMantissaBits);
|
|
DCHECK_GE(result, 0.0);
|
DCHECK_LT(result, 1.0);
|
|
return result;
|
}
|
|
void RandBytes(void* output, size_t output_length) {
|
if (output_length == 0) {
|
return;
|
}
|
|
#if defined(OS_FUCHSIA)
|
zx_cprng_draw(output, output_length);
|
#elif defined(OS_POSIX)
|
int fd = GetUrandomFD();
|
bool success = ReadFromFD(fd, static_cast<char*>(output), output_length);
|
CHECK(success);
|
#elif defined(OS_WIN)
|
char* output_ptr = static_cast<char*>(output);
|
while (output_length > 0) {
|
const ULONG output_bytes_this_pass = static_cast<ULONG>(std::min(
|
output_length, static_cast<size_t>(std::numeric_limits<ULONG>::max())));
|
const bool success =
|
RtlGenRandom(output_ptr, output_bytes_this_pass) != FALSE;
|
CHECK(success);
|
output_length -= output_bytes_this_pass;
|
output_ptr += output_bytes_this_pass;
|
}
|
#endif
|
}
|
|
std::string RandBytesAsString(size_t length) {
|
if (length == 0) {
|
return std::string();
|
}
|
|
std::string result(length, std::string::value_type());
|
RandBytes(&result[0], length);
|
return result;
|
}
|
|
} // namespace base
|
