Fix self-assignment, endianness, and strict-aliasing UB in randen_engine. `randen_engine` and its backends previously relied on undefined behavior and host-endian assumptions: * Self-assigning a `randen_engine` passed identical source and destination pointers to `std::memcpy`. * Reinterpreting a single state array across `uint32_t`, `uint64_t`, and SIMD vector types in `discard()` and `RandenSlow` violated strict-aliasing and array-bounds rules. * Seeding on big-endian hosts stored state words in host byte order or applied little-endian PowerPC byte swaps unconditionally, diverging from little-endian Randen streams. PiperOrigin-RevId: 1022535896
diff --git a/absl/random/internal/randen_engine.h b/absl/random/internal/randen_engine.h index c2a8f54..91a6025 100644 --- a/absl/random/internal/randen_engine.h +++ b/absl/random/internal/randen_engine.h
@@ -25,6 +25,7 @@ #include <limits> #include <ostream> #include <type_traits> +#include <utility> #include "absl/base/config.h" #include "absl/base/internal/endian.h" @@ -62,7 +63,7 @@ return (std::numeric_limits<result_type>::max)(); } - randen_engine() : randen_engine(0) {} + randen_engine() : randen_engine(result_type{0}) {} explicit randen_engine(result_type seed_value) { seed(seed_value); } template <class SeedSequence, @@ -78,6 +79,9 @@ std::memcpy(state(), other.state(), kStateSizeT * sizeof(result_type)); } randen_engine& operator=(const randen_engine& other) { + if (this == &other) { + return *this; + } next_ = other.next_; impl_ = other.impl_; std::memcpy(state(), other.state(), kStateSizeT * sizeof(result_type)); @@ -103,13 +107,14 @@ reseed(seq); } - void seed(result_type seed_value = 0) { + void seed(result_type seed_value = result_type{0}) { next_ = kStateSizeT; // Zeroes the inner state and fills the outer state with seed_value to // mimic the behaviour of reseed auto* begin = state(); - std::fill(begin, begin + kCapacityT, 0); - std::fill(begin + kCapacityT, begin + kStateSizeT, seed_value); + std::fill(begin, begin + kCapacityT, result_type{0}); + std::fill(begin + kCapacityT, begin + kStateSizeT, + little_endian::FromHost(seed_value)); } // Inserts entropy into (part of) the state. Calling this periodically with @@ -135,13 +140,6 @@ const size_t requested_entropy = (entropy_size == 0) ? 8u : entropy_size; std::fill(buffer + requested_entropy, buffer + kBufferSize, 0); seq.generate(buffer, buffer + requested_entropy); -#ifdef ABSL_IS_BIG_ENDIAN - // Randen expects the seed buffer to be in Little Endian; reverse it on - // Big Endian platforms. - for (sequence_result_type& e : buffer) { - e = absl::little_endian::FromHost(e); - } -#endif // The Randen paper suggests preferentially initializing even-numbered // 128-bit vectors of the randen state (there are 16 such vectors). // The seed data is merged into the state offset by 128-bits, which @@ -162,6 +160,13 @@ } else { seq.generate(buffer, buffer + kBufferSize); } +#ifdef ABSL_IS_BIG_ENDIAN + // Randen expects the seed buffer to be in Little Endian; reverse it on + // Big Endian platforms. + for (sequence_result_type& e : buffer) { + e = absl::little_endian::FromHost(e); + } +#endif impl_.Absorb(buffer, state()); // Generate will be called when operator() is called @@ -169,15 +174,16 @@ } void discard(uint64_t count) { - uint64_t step = std::min<uint64_t>(kStateSizeT - next_, count); + uint64_t step = + (std::min)(static_cast<uint64_t>(kStateSizeT - next_), count); count -= step; constexpr uint64_t kRateT = kStateSizeT - kCapacityT; auto* begin = state(); while (count > 0) { next_ = kCapacityT; - impl_.Generate(*reinterpret_cast<result_type(*)[kStateSizeT]>(begin)); - step = std::min<uint64_t>(kRateT, count); + impl_.Generate(begin); + step = (std::min)(kRateT, count); count -= step; } next_ += step; @@ -255,7 +261,7 @@ // raw state array, manually aligned in state(). This overallocates // by 8 bytes since C++ does not guarantee extended heap alignment. - alignas(8) char raw_state_[Randen::kStateBytes + 8]; + alignas(8) unsigned char raw_state_[Randen::kStateBytes + 8]; size_t next_; // index within state() Randen impl_; };
diff --git a/absl/random/internal/randen_engine_test.cc b/absl/random/internal/randen_engine_test.cc index 5488bd5..73afaf3 100644 --- a/absl/random/internal/randen_engine_test.cc +++ b/absl/random/internal/randen_engine_test.cc
@@ -22,6 +22,7 @@ #include <random> #include <sstream> #include <type_traits> +#include <utility> #include "gtest/gtest.h" #include "absl/log/log.h" @@ -234,6 +235,26 @@ "return type of operator== must be bool"); } +TYPED_TEST(RandenEngineTypedTest, SelfAssignmentPreservesState) { + using randen = typename absl::random_internal::randen_engine<TypeParam>; + + ExplicitSeedSeq seed_sequence{12, 34, 56}; + randen engine(seed_sequence); + engine.discard(5); + randen expected = engine; + + randen* self_ptr = &engine; + engine = *self_ptr; + EXPECT_TRUE(engine == expected); + + engine = std::move(*self_ptr); + EXPECT_TRUE(engine == expected); + + for (int i = 0; i < 16; ++i) { + EXPECT_EQ(engine(), expected()); + } +} + TYPED_TEST(RandenEngineTypedTest, RandenEngineSFINAETest) { using randen = typename absl::random_internal::randen_engine<TypeParam>; using result_type = typename randen::result_type;
diff --git a/absl/random/internal/randen_hwaes.cc b/absl/random/internal/randen_hwaes.cc index b632aa9..291b049 100644 --- a/absl/random/internal/randen_hwaes.cc +++ b/absl/random/internal/randen_hwaes.cc
@@ -134,12 +134,14 @@ using Vector128 = __vector unsigned long long; // NOLINT(runtime/int) namespace { +#if defined(ABSL_IS_LITTLE_ENDIAN) ABSL_TARGET_CRYPTO inline Vector128 ReverseBytes(const Vector128& v) { // Reverses the bytes of the vector. const __vector unsigned char perm = {15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}; return vec_perm(v, v, perm); } +#endif // WARNING: these load/store in native byte order. It is OK to load and then // store an unchanged vector, but interpreting the bits as a number or input @@ -159,11 +161,17 @@ return Vector128(__builtin_crypto_vcipher(state, round_key)); } -// Enables native loads in the round loop by pre-swapping. +// Enables native loads in the round loop by pre-swapping on little-endian PPC. +// On big-endian PPC, vec_vsx_ld already loads bytes in the big-endian order +// expected by __builtin_crypto_vcipher. ABSL_TARGET_CRYPTO inline void SwapEndian(absl::uint128* state) { +#if defined(ABSL_IS_LITTLE_ENDIAN) for (uint32_t block = 0; block < RandenTraits::kFeistelBlocks; ++block) { Vector128Store(ReverseBytes(Vector128Load(state + block)), state + block); } +#else + (void)state; +#endif } } // namespace @@ -418,7 +426,7 @@ ABSL_TARGET_CRYPTO const void* RandenHwAes::GetKeys() { // Round keys for one AES per Feistel round and branch. // The canonical implementation uses first digits of Pi. -#if defined(ABSL_ARCH_PPC) +#if defined(ABSL_ARCH_PPC) && defined(ABSL_IS_LITTLE_ENDIAN) return kRandenRoundKeysBE; #else return kRandenRoundKeys;
diff --git a/absl/random/internal/randen_slow.cc b/absl/random/internal/randen_slow.cc index 12aa4b1..f8dd87c 100644 --- a/absl/random/internal/randen_slow.cc +++ b/absl/random/internal/randen_slow.cc
@@ -346,14 +346,14 @@ // per 16 bytes (vs. 10 for AES-CTR). Computing eight round functions in // parallel hides the 7-cycle AESNI latency on HSW. Note that the Feistel // XORs are 'free' (included in the second AES instruction). -ABSL_ATTRIBUTE_ALWAYS_INLINE inline const absl::uint128* FeistelRound( +ABSL_ATTRIBUTE_ALWAYS_INLINE inline const uint8_t* FeistelRound( absl::uint128* ABSL_RANDOM_INTERNAL_RESTRICT state, - const absl::uint128* ABSL_RANDOM_INTERNAL_RESTRICT keys) { + const uint8_t* ABSL_RANDOM_INTERNAL_RESTRICT keys) { for (size_t branch = 0; branch < RandenTraits::kFeistelBlocks; branch += 4) { const Vector128 s0 = Vector128Load(state + branch); const Vector128 s1 = Vector128Load(state + branch + 1); const Vector128 f0 = AesRound(s0, Vector128Load(keys)); - keys++; + keys += sizeof(Vector128); const Vector128 o1 = AesRound(f0, s1); Vector128Store(o1, state + branch + 1); @@ -361,7 +361,7 @@ const Vector128 s2 = Vector128Load(state + branch + 2); const Vector128 s3 = Vector128Load(state + branch + 3); const Vector128 f2 = AesRound(s2, Vector128Load(keys)); - keys++; + keys += sizeof(Vector128); const Vector128 o3 = AesRound(f2, s3); Vector128Store(o3, state + branch + 3); } @@ -373,8 +373,7 @@ // 2^64 queries if the round function is a PRF. This is similar to the b=8 case // of Simpira v2, but more efficient than its generic construction for b=16. ABSL_ATTRIBUTE_ALWAYS_INLINE inline void Permute( - absl::uint128* state, - const absl::uint128* ABSL_RANDOM_INTERNAL_RESTRICT keys) { + absl::uint128* state, const uint8_t* ABSL_RANDOM_INTERNAL_RESTRICT keys) { for (size_t round = 0; round < RandenTraits::kFeistelRounds; ++round) { keys = FeistelRound(state, keys); BlockShuffle(state); @@ -414,30 +413,38 @@ } void RandenSlow::Absorb(const void* seed_void, void* state_void) { - auto* state = - reinterpret_cast<uint64_t * ABSL_RANDOM_INTERNAL_RESTRICT>(state_void); - const auto* seed = - reinterpret_cast<const uint64_t * ABSL_RANDOM_INTERNAL_RESTRICT>( - seed_void); + uint8_t* ABSL_RANDOM_INTERNAL_RESTRICT state_bytes = + static_cast<uint8_t*>(state_void); + const uint8_t* ABSL_RANDOM_INTERNAL_RESTRICT seed_bytes = + static_cast<const uint8_t*>(seed_void); - constexpr size_t kCapacityBlocks = - RandenTraits::kCapacityBytes / sizeof(uint64_t); - static_assert( - kCapacityBlocks * sizeof(uint64_t) == RandenTraits::kCapacityBytes, - "Not i*V"); + static_assert(RandenTraits::kCapacityBytes % sizeof(uint64_t) == 0, + "kCapacityBytes must be a multiple of 8"); + static_assert(RandenTraits::kStateBytes % sizeof(uint64_t) == 0, + "kStateBytes must be a multiple of 8"); - for (size_t i = kCapacityBlocks; - i < RandenTraits::kStateBytes / sizeof(uint64_t); ++i) { - state[i] ^= seed[i - kCapacityBlocks]; + for (size_t offset = RandenTraits::kCapacityBytes; + offset < RandenTraits::kStateBytes; offset += sizeof(uint64_t)) { + uint64_t s; + uint64_t k; + std::memcpy(&s, state_bytes + offset, sizeof(s)); + std::memcpy(&k, seed_bytes + (offset - RandenTraits::kCapacityBytes), + sizeof(k)); + s ^= k; + std::memcpy(state_bytes + offset, &s, sizeof(s)); } } void RandenSlow::Generate(const void* keys_void, void* state_void) { static_assert(RandenTraits::kCapacityBytes == sizeof(absl::uint128), "Capacity mismatch"); + static_assert(RandenTraits::kFeistelBlocks * sizeof(absl::uint128) == + RandenTraits::kStateBytes, + "State size mismatch"); - auto* state = reinterpret_cast<absl::uint128*>(state_void); - const auto* keys = reinterpret_cast<const absl::uint128*>(keys_void); + alignas(16) absl::uint128 state[RandenTraits::kFeistelBlocks]; + std::memcpy(state, state_void, sizeof(state)); + const auto* keys = static_cast<const uint8_t*>(keys_void); const absl::uint128 prev_inner = state[0]; @@ -448,7 +455,8 @@ SwapEndian(state); // Ensure backtracking resistance. - *state ^= prev_inner; + state[0] ^= prev_inner; + std::memcpy(state_void, state, sizeof(state)); } } // namespace random_internal