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