Harden OS entropy reads in absl/random/internal/seed_material. OS entropy reads previously risked truncated or failed seeding across platforms: * Windows `BCryptGenRandom` took a 32-bit byte count, truncating requests `>= 4 GiB` modulo `2^32`. * POSIX and WASI fallbacks could fail on `EINTR`, leak `/dev/urandom` file descriptors across `exec`, or loop in 256-byte `getentropy()` chunks instead of using native `getrandom()` or `arc4random_buf`. PiperOrigin-RevId: 1022524360
diff --git a/absl/random/internal/seed_material.cc b/absl/random/internal/seed_material.cc index 75b9e29..c09e63f 100644 --- a/absl/random/internal/seed_material.cc +++ b/absl/random/internal/seed_material.cc
@@ -22,6 +22,7 @@ #include <cstdint> #include <cstdlib> #include <cstring> +#include <limits> #include <optional> #include <string> #include <vector> @@ -48,20 +49,52 @@ #elif defined(__Fuchsia__) #include <zircon/syscalls.h> +#elif defined(__APPLE__) +#if (!defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) || \ + __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101200) && \ + (!defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) || \ + __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 100000) && \ + (!defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) || \ + __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ >= 100000) && \ + (!defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) || \ + __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ >= 30000) +#include <stdlib.h> +#define ABSL_RANDOM_USE_ARC4RANDOM_BUF 1 #endif -#if defined(__GLIBC__) && \ - (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 25)) -// glibc >= 2.25 has getentropy() -#define ABSL_RANDOM_USE_GET_ENTROPY 1 +#elif defined(__OpenBSD__) || defined(__NetBSD__) || \ + (defined(__FreeBSD__) && __FreeBSD__ >= 12) +#include <stdlib.h> +#define ABSL_RANDOM_USE_ARC4RANDOM_BUF 1 + #endif -#if defined(__EMSCRIPTEN__) +#if !defined(_WIN32) && !defined(__Fuchsia__) && \ + !defined(ABSL_RANDOM_USE_ARC4RANDOM_BUF) + +#if (defined(__GLIBC__) && \ + (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 25))) || \ + (defined(__ANDROID__) && defined(__ANDROID_API__) && \ + __ANDROID_API__ >= 28) +// glibc >= 2.25 and Android API >= 28 provide getrandom() in <sys/random.h>. #include <sys/random.h> -// Emscripten has getentropy, but it resides in a different header. +#define ABSL_RANDOM_USE_GETRANDOM 1 +#elif defined(__linux__) +#include <sys/syscall.h> +#if !defined(SYS_getrandom) && defined(__NR_getrandom) +#define SYS_getrandom __NR_getrandom +#endif +#if defined(SYS_getrandom) +#define ABSL_RANDOM_USE_SYS_GETRANDOM 1 +#endif +#elif defined(__EMSCRIPTEN__) || defined(__wasi__) +#include <sys/random.h> +// Emscripten and WASI provide getentropy() in <sys/random.h>. #define ABSL_RANDOM_USE_GET_ENTROPY 1 #endif +#endif // !_WIN32 && !__Fuchsia__ && !ABSL_RANDOM_USE_ARC4RANDOM_BUF + #if defined(ABSL_RANDOM_USE_BCRYPT) #include <bcrypt.h> @@ -93,11 +126,19 @@ ABSL_RAW_LOG(ERROR, "Failed to open crypto provider."); return false; } - ret = BCryptGenRandom( - hProvider, // provider - reinterpret_cast<UCHAR*>(values.data()), // buffer - static_cast<ULONG>(sizeof(uint32_t) * values.size()), // bytes - 0); // flags + auto* buffer = reinterpret_cast<UCHAR*>(values.data()); + size_t buffer_size = sizeof(uint32_t) * values.size(); + constexpr size_t kMaxChunk = + static_cast<size_t>((std::numeric_limits<ULONG>::max)() & ~ULONG{3}); + while (buffer_size > 0) { + const ULONG chunk = static_cast<ULONG>((std::min)(buffer_size, kMaxChunk)); + ret = BCryptGenRandom(hProvider, buffer, chunk, 0); + if (!(BCRYPT_SUCCESS(ret))) { + break; + } + buffer += chunk; + buffer_size -= chunk; + } BCryptCloseAlgorithmProvider(hProvider, 0); return BCRYPT_SUCCESS(ret); } @@ -111,71 +152,126 @@ return true; } +#elif defined(ABSL_RANDOM_USE_ARC4RANDOM_BUF) + +bool ReadSeedMaterialFromOSEntropyImpl(absl::Span<uint32_t> values) { + auto* buffer = reinterpret_cast<uint8_t*>(values.data()); + size_t buffer_size = sizeof(uint32_t) * values.size(); + arc4random_buf(buffer, buffer_size); + ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(buffer, buffer_size); + return true; +} + #else -#if defined(ABSL_RANDOM_USE_GET_ENTROPY) -// On *nix, use getentropy() if supported. Note that libc may support -// getentropy(), but the kernel may not, in which case this function will return -// false. -bool ReadSeedMaterialFromGetEntropy(absl::Span<uint32_t> values) { - auto buffer = reinterpret_cast<uint8_t*>(values.data()); +constexpr size_t kMaxPosixRead = + static_cast<size_t>((std::numeric_limits<int>::max)()); + +// Fills `values` by repeatedly calling `read_fn(buffer, to_read)` in chunks of +// at most `max_chunk` bytes. `read_fn` follows the POSIX `read()` contract: +// returns bytes read (> 0), 0 on EOF/failure, or < 0 with `errno` set +// (retrying on `EINTR`). +template <typename ReadFn> +bool ReadEntropyBytes(absl::Span<uint32_t> values, size_t max_chunk, + ReadFn read_fn) { + auto* buffer = reinterpret_cast<uint8_t*>(values.data()); size_t buffer_size = sizeof(uint32_t) * values.size(); while (buffer_size > 0) { - // getentropy() has a maximum permitted length of 256. - size_t to_read = std::min<size_t>(buffer_size, 256); - int result = getentropy(buffer, to_read); - if (result < 0) { + const size_t to_read = (std::min)(buffer_size, max_chunk); + const ssize_t bytes_read = read_fn(buffer, to_read); + if (bytes_read < 0) { + if (errno == EINTR) { + continue; + } return false; } + if (bytes_read == 0) { + return false; + } + const size_t n = static_cast<size_t>(bytes_read); // https://github.com/google/sanitizers/issues/1173 - // MemorySanitizer can't see through getentropy(). - ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(buffer, to_read); - buffer += to_read; - buffer_size -= to_read; + // MemorySanitizer cannot always see through getentropy() or raw syscalls. + ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(buffer, n); + buffer += n; + buffer_size -= n; } return true; } -#endif // defined(ABSL_RANDOM_GETENTROPY) + +#if defined(ABSL_RANDOM_USE_GETRANDOM) || defined(ABSL_RANDOM_USE_SYS_GETRANDOM) +// On Linux and glibc/Android platforms with getrandom(), read entropy directly +// without opening /dev/urandom. Note that libc or kernel headers may declare +// getrandom() / SYS_getrandom while the running kernel or sandbox does not +// support it (e.g., ENOSYS/EPERM), in which case this function returns false +// and the caller falls back to /dev/urandom. +bool ReadSeedMaterialFromGetRandom(absl::Span<uint32_t> values) { + auto read_chunk = [](uint8_t* buffer, size_t to_read) -> ssize_t { +#if defined(ABSL_RANDOM_USE_GETRANDOM) + return getrandom(buffer, to_read, 0u); +#else + return static_cast<ssize_t>(syscall(SYS_getrandom, buffer, to_read, 0u)); +#endif + }; + return ReadEntropyBytes(values, kMaxPosixRead, read_chunk); +} +#endif // defined(ABSL_RANDOM_USE_GETRANDOM) || + // defined(ABSL_RANDOM_USE_SYS_GETRANDOM) + +#if defined(ABSL_RANDOM_USE_GET_ENTROPY) +// On *nix platforms without getrandom() (e.g., Emscripten, WASI), use +// getentropy() if supported. Note that libc may support getentropy(), but the +// runtime may not, in which case this function will return false. +bool ReadSeedMaterialFromGetEntropy(absl::Span<uint32_t> values) { + // getentropy() has a maximum permitted length of 256. + return ReadEntropyBytes(values, /*max_chunk=*/256, + [](uint8_t* buffer, size_t to_read) -> ssize_t { + return getentropy(buffer, to_read) == 0 + ? static_cast<ssize_t>(to_read) + : -1; + }); +} +#endif // defined(ABSL_RANDOM_USE_GET_ENTROPY) // On *nix, read entropy from /dev/urandom. bool ReadSeedMaterialFromDevURandom(absl::Span<uint32_t> values) { const char kEntropyFile[] = "/dev/urandom"; - auto buffer = reinterpret_cast<uint8_t*>(values.data()); - size_t buffer_size = sizeof(uint32_t) * values.size(); - - int dev_urandom = open(kEntropyFile, O_RDONLY); +#ifdef O_CLOEXEC + constexpr int kOpenFlags = O_RDONLY | O_CLOEXEC; +#else + constexpr int kOpenFlags = O_RDONLY; +#endif + int dev_urandom; + do { + dev_urandom = open(kEntropyFile, kOpenFlags); + } while (dev_urandom < 0 && errno == EINTR); if (dev_urandom < 0) { ABSL_RAW_LOG(ERROR, "Failed to open /dev/urandom."); return false; } - while (buffer_size > 0) { - ssize_t bytes_read = read(dev_urandom, buffer, buffer_size); - int read_error = errno; - if (bytes_read == -1 && read_error == EINTR) { - // Interrupted, try again. - continue; - } else if (bytes_read <= 0) { - // EOF, or error. - break; - } - buffer += bytes_read; - buffer_size -= static_cast<size_t>(bytes_read); - } + const bool success = ReadEntropyBytes( + values, kMaxPosixRead, + [dev_urandom](uint8_t* buffer, size_t to_read) -> ssize_t { + return read(dev_urandom, buffer, to_read); + }); close(dev_urandom); - return buffer_size == 0; + return success; } bool ReadSeedMaterialFromOSEntropyImpl(absl::Span<uint32_t> values) { -#if defined(ABSL_RANDOM_USE_GET_ENTROPY) +#if defined(ABSL_RANDOM_USE_GETRANDOM) || defined(ABSL_RANDOM_USE_SYS_GETRANDOM) + if (ReadSeedMaterialFromGetRandom(values)) { + return true; + } +#elif defined(ABSL_RANDOM_USE_GET_ENTROPY) if (ReadSeedMaterialFromGetEntropy(values)) { return true; } #endif - // Libc may support getentropy, but the kernel may not, so we still have - // to fallback to ReadSeedMaterialFromDevURandom(). + // Libc or the kernel may not support getrandom() or getentropy(), so we still + // fall back to ReadSeedMaterialFromDevURandom(). return ReadSeedMaterialFromDevURandom(values); }
diff --git a/absl/random/internal/seed_material_test.cc b/absl/random/internal/seed_material_test.cc index 45db765..c65c1bf 100644 --- a/absl/random/internal/seed_material_test.cc +++ b/absl/random/internal/seed_material_test.cc
@@ -18,6 +18,7 @@ #include <cstdint> #include <cstdlib> #include <cstring> +#include <optional> #include <random> #include <vector> @@ -38,9 +39,9 @@ namespace { using testing::Each; -using testing::ElementsAre; using testing::Eq; using testing::Ne; +using testing::Not; using testing::Pointwise; TEST(SeedBitsToBlocks, VerifyCases) { @@ -67,6 +68,49 @@ EXPECT_THAT(seed_material_1, Pointwise(Ne(), seed_material_2)); } +TEST(ReadSeedMaterialFromOSEntropy, LargeBufferAcrossChunks) { + constexpr size_t kChunkWords = 64; // 256 bytes (getentropy() chunk size). + constexpr size_t kNumChunks = 16; + constexpr size_t kSeedMaterialSize = kChunkWords * kNumChunks; + constexpr uint32_t kSentinel = 0xAAAAAAAAu; + std::vector<uint32_t> seed_material_1(kSeedMaterialSize, kSentinel); + std::vector<uint32_t> seed_material_2(kSeedMaterialSize, kSentinel); + + EXPECT_TRUE(absl::random_internal::ReadSeedMaterialFromOSEntropy( + absl::MakeSpan(seed_material_1))); + EXPECT_TRUE(absl::random_internal::ReadSeedMaterialFromOSEntropy( + absl::MakeSpan(seed_material_2))); + + const auto span_1 = absl::MakeConstSpan(seed_material_1); + const auto span_2 = absl::MakeConstSpan(seed_material_2); + const auto first_chunk_1 = span_1.first(kChunkWords); + const auto first_chunk_2 = span_2.first(kChunkWords); + for (size_t chunk = 0; chunk < kNumChunks; ++chunk) { + SCOPED_TRACE(chunk); + const size_t offset = chunk * kChunkWords; + const auto chunk_1 = span_1.subspan(offset, kChunkWords); + const auto chunk_2 = span_2.subspan(offset, kChunkWords); + EXPECT_THAT(chunk_1.first(16), Not(Each(Eq(kSentinel)))); + EXPECT_THAT(chunk_1.first(16), Not(Each(Eq(0u)))); + EXPECT_THAT(chunk_1.last(16), Not(Each(Eq(kSentinel)))); + EXPECT_THAT(chunk_1.last(16), Not(Each(Eq(0u)))); + EXPECT_THAT(chunk_2.first(16), Not(Each(Eq(kSentinel)))); + EXPECT_THAT(chunk_2.first(16), Not(Each(Eq(0u)))); + EXPECT_THAT(chunk_2.last(16), Not(Each(Eq(kSentinel)))); + EXPECT_THAT(chunk_2.last(16), Not(Each(Eq(0u)))); + EXPECT_THAT(chunk_1.first(16), Ne(chunk_2.first(16))); + EXPECT_THAT(chunk_1.last(16), Ne(chunk_2.last(16))); + if (chunk > 0) { + EXPECT_THAT(chunk_1, Ne(first_chunk_1)); + EXPECT_THAT(chunk_2, Ne(first_chunk_2)); + EXPECT_THAT(chunk_1, + Ne(span_1.subspan(offset - kChunkWords, kChunkWords))); + EXPECT_THAT(chunk_2, + Ne(span_2.subspan(offset - kChunkWords, kChunkWords))); + } + } +} + TEST(ReadSeedMaterialFromOSEntropy, ReadZeroBytesIsNoOp) { uint32_t seed_material[32] = {}; std::memset(seed_material, 0xAA, sizeof(seed_material));