Validate stream deserialization invariants across absl/random.

Deserializing malformed or out-of-range text via `operator>>` into
`absl/random` distributions and engines previously bypassed constructor
preconditions:
* Invalid parameters (such as negative probabilities, inverted bounds,
  non-finite weights, oversized `discrete_distribution` weight counts, or
  out-of-range `randen_engine` buffer indices) were accepted without setting
  `failbit`, leaving objects with violated invariants, unbounded allocations,
  or out-of-bounds state reads on subsequent draws.
* Unsigned integer stream reads accepted negative tokens via wraparound, 1-byte
  integer reads truncated out-of-range values, failed floating-point reads left
  uninitialized outputs, and engine `operator>>` leaked stream formatting
  flags.

Reject invalid serialized inputs with `failbit` while leaving the target
distribution or engine unchanged.

PiperOrigin-RevId: 1022532452
diff --git a/absl/random/BUILD.bazel b/absl/random/BUILD.bazel
index 42b59d3..162e328 100644
--- a/absl/random/BUILD.bazel
+++ b/absl/random/BUILD.bazel
@@ -202,6 +202,7 @@
     deps = [
         ":distributions",
         ":random",
+        "//absl/random/internal:distribution_test_util",
         "//absl/random/internal:pcg_engine",
         "//absl/random/internal:sequence_urbg",
         "@googletest//:gtest",
diff --git a/absl/random/CMakeLists.txt b/absl/random/CMakeLists.txt
index 700c271..cef4ab5 100644
--- a/absl/random/CMakeLists.txt
+++ b/absl/random/CMakeLists.txt
@@ -268,6 +268,7 @@
     ${ABSL_DEFAULT_LINKOPTS}
   DEPS
     absl::random_distributions
+    absl::random_internal_distribution_test_util
     absl::random_internal_pcg_engine
     absl::random_internal_sequence_urbg
     absl::random_random
@@ -1263,6 +1264,7 @@
     ${ABSL_DEFAULT_LINKOPTS}
   DEPS
     absl::random_internal_iostream_state_saver
+    GTest::gmock
     GTest::gtest_main
 )
 
diff --git a/absl/random/bernoulli_distribution.h b/absl/random/bernoulli_distribution.h
index 10c24e6..efe1990 100644
--- a/absl/random/bernoulli_distribution.h
+++ b/absl/random/bernoulli_distribution.h
@@ -17,6 +17,7 @@
 
 #include <cassert>
 #include <cstdint>
+#include <ios>
 #include <istream>
 #include <ostream>
 
@@ -123,7 +124,11 @@
   auto saver = random_internal::make_istream_state_saver(is);
   auto p = random_internal::read_floating_point<double>(is);
   if (!is.fail()) {
-    x.param(bernoulli_distribution::param_type(p));
+    if (p >= 0.0 && p <= 1.0) {
+      x.param(bernoulli_distribution::param_type(p));
+    } else {
+      is.setstate(std::ios_base::failbit);
+    }
   }
   return is;
 }
diff --git a/absl/random/bernoulli_distribution_test.cc b/absl/random/bernoulli_distribution_test.cc
index 9c04bf6..ae2c846 100644
--- a/absl/random/bernoulli_distribution_test.cc
+++ b/absl/random/bernoulli_distribution_test.cc
@@ -22,7 +22,9 @@
 #include <string>
 #include <utility>
 
+#include "gmock/gmock.h"
 #include "gtest/gtest.h"
+#include "absl/random/internal/distribution_test_util.h"
 #include "absl/random/internal/pcg_engine.h"
 #include "absl/random/internal/sequence_urbg.h"
 #include "absl/random/random.h"
@@ -216,4 +218,47 @@
   }
 }
 
+MATCHER(FailsLeavingUnchanged,
+        "fails stream extraction and leaves target and stream flags "
+        "unchanged") {
+  return arg.failed && arg.flags_preserved && arg.value == arg.initial;
+}
+
+MATCHER_P(ParsesEqualTo, expected,
+          "succeeds, updates target, and preserves stream flags") {
+  return !arg.failed && arg.flags_preserved && arg.value == expected;
+}
+
+TEST(BernoulliTest, StreamRejectsInvalidParameters) {
+  using absl::random_internal::ParseFromStream;
+  const absl::bernoulli_distribution kInitial(0.25);
+
+  // Valid boundary and subnormal probabilities.
+  EXPECT_THAT(ParseFromStream(kInitial, "0.0"),
+              ParsesEqualTo(absl::bernoulli_distribution(0.0)));
+  EXPECT_THAT(ParseFromStream(kInitial, "0.5"),
+              ParsesEqualTo(absl::bernoulli_distribution(0.5)));
+  EXPECT_THAT(ParseFromStream(kInitial, "1.0"),
+              ParsesEqualTo(absl::bernoulli_distribution(1.0)));
+  EXPECT_THAT(ParseFromStream(kInitial, "1e-320"),
+              ParsesEqualTo(absl::bernoulli_distribution(1e-320)));
+
+  // Empty, out-of-range, and non-finite inputs under the default locale.
+  EXPECT_THAT(ParseFromStream(kInitial, ""), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "   "), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-0.1"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "1.5"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "nan"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "inf"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-inf"), FailsLeavingUnchanged());
+
+  // Non-finite values delivered with goodbit by a custom num_get facet.
+  EXPECT_THAT(ParseFromStream(kInitial, "nan", /*use_non_finite_facet=*/true),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "inf", /*use_non_finite_facet=*/true),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-inf", /*use_non_finite_facet=*/true),
+              FailsLeavingUnchanged());
+}
+
 }  // namespace
diff --git a/absl/random/beta_distribution.h b/absl/random/beta_distribution.h
index a2cdd25..b2d0f8f 100644
--- a/absl/random/beta_distribution.h
+++ b/absl/random/beta_distribution.h
@@ -18,6 +18,7 @@
 #include <cassert>
 #include <cmath>
 #include <cstdint>
+#include <ios>
 #include <istream>
 #include <limits>
 #include <ostream>
@@ -409,14 +410,21 @@
     beta_distribution<RealType>& x) {       // NOLINT(runtime/references)
   using result_type = typename beta_distribution<RealType>::result_type;
   using param_type = typename beta_distribution<RealType>::param_type;
-  result_type alpha, beta;
 
   auto saver = random_internal::make_istream_state_saver(is);
-  alpha = random_internal::read_floating_point<result_type>(is);
+  const result_type alpha =
+      random_internal::read_floating_point<result_type>(is);
   if (is.fail()) return is;
-  beta = random_internal::read_floating_point<result_type>(is);
+  const result_type beta =
+      random_internal::read_floating_point<result_type>(is);
   if (!is.fail()) {
-    x.param(param_type(alpha, beta));
+    constexpr result_type kMax = (std::numeric_limits<result_type>::max)();
+    if (alpha >= result_type(0) && beta >= result_type(0) && alpha <= kMax &&
+        beta <= kMax) {
+      x.param(param_type(alpha, beta));
+    } else {
+      is.setstate(std::ios_base::failbit);
+    }
   }
   return is;
 }
diff --git a/absl/random/beta_distribution_test.cc b/absl/random/beta_distribution_test.cc
index 7e06cb2..b44bde0 100644
--- a/absl/random/beta_distribution_test.cc
+++ b/absl/random/beta_distribution_test.cc
@@ -617,4 +617,67 @@
   }
 }
 
+MATCHER(FailsLeavingUnchanged,
+        "fails stream extraction and leaves target and stream flags "
+        "unchanged") {
+  return arg.failed && arg.flags_preserved && arg.value == arg.initial;
+}
+
+MATCHER_P(ParsesEqualTo, expected,
+          "succeeds, updates target, and preserves stream flags") {
+  return !arg.failed && arg.flags_preserved && arg.value == expected;
+}
+
+TEST(BetaDistributionTest, StreamRejectsInvalidParameters) {
+  using absl::random_internal::ParseFromStream;
+  const absl::beta_distribution<double> kInitial(2.0, 3.0);
+  const absl::beta_distribution<float> kFloatInitial(2.0f, 3.0f);
+
+  EXPECT_THAT(ParseFromStream(kInitial, ""), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "2.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-1.0 2.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "2.0 -1.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "nan 2.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "2.0 nan"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "inf 2.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "2.0 inf"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-inf 2.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "2.0 -inf"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "1e500 3.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "2.0 1e500"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kFloatInitial, "1e40 1.0"),
+              FailsLeavingUnchanged());
+
+  // Non-finite values delivered with goodbit by a custom num_get facet.
+  EXPECT_THAT(
+      ParseFromStream(kInitial, "nan 2.0", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kInitial, "2.0 nan", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kInitial, "inf 2.0", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kInitial, "2.0 inf", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kInitial, "-inf 2.0", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kInitial, "2.0 -inf", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kFloatInitial, "nan 2.0", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kFloatInitial, "2.0 inf", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+
+  EXPECT_THAT(ParseFromStream(kInitial, "0.0 0.0"),
+              ParsesEqualTo(absl::beta_distribution<double>(0.0, 0.0)));
+  EXPECT_THAT(ParseFromStream(kInitial, "1.5 2.5"),
+              ParsesEqualTo(absl::beta_distribution<double>(1.5, 2.5)));
+}
+
 }  // namespace
diff --git a/absl/random/discrete_distribution.h b/absl/random/discrete_distribution.h
index 35d42c8..de710a9 100644
--- a/absl/random/discrete_distribution.h
+++ b/absl/random/discrete_distribution.h
@@ -15,9 +15,12 @@
 #ifndef ABSL_RANDOM_DISCRETE_DISTRIBUTION_H_
 #define ABSL_RANDOM_DISCRETE_DISTRIBUTION_H_
 
+#include <algorithm>
 #include <cassert>
+#include <cmath>
 #include <cstddef>
 #include <initializer_list>
+#include <ios>
 #include <istream>
 #include <limits>
 #include <ostream>
@@ -226,19 +229,42 @@
   using param_type = typename discrete_distribution<IntType>::param_type;
   auto saver = random_internal::make_istream_state_saver(is);
 
-  size_t n;
-  std::vector<double> p;
-
-  is >> n;
-  if (is.fail()) return is;
-  if (n > 0) {
-    p.reserve(n);
-    for (IntType i = 0; i < n && !is.fail(); ++i) {
-      auto tmp = random_internal::read_floating_point<double>(is);
-      if (is.fail()) return is;
-      p.push_back(tmp);
+  size_t n = 0;
+  if (!random_internal::read_integral(is, n)) {
+    return is;
+  }
+  if (n == 0) {
+    is.setstate(std::ios_base::failbit);
+    return is;
+  }
+  if constexpr (std::numeric_limits<IntType>::digits <
+                std::numeric_limits<size_t>::digits) {
+    if (n - 1 > static_cast<size_t>((std::numeric_limits<IntType>::max)())) {
+      is.setstate(std::ios_base::failbit);
+      return is;
     }
   }
+  std::vector<double> p;
+  p.reserve((std::min)(n, size_t{1024}));
+  double sum = 0.0;
+  for (size_t i = 0; i < n; ++i) {
+    auto tmp = random_internal::read_floating_point<double>(is);
+    if (is.fail()) return is;
+    if (!(tmp >= 0.0 && std::isfinite(tmp))) {
+      is.setstate(std::ios_base::failbit);
+      return is;
+    }
+    sum += tmp;
+    if (!std::isfinite(sum)) {
+      is.setstate(std::ios_base::failbit);
+      return is;
+    }
+    p.push_back(tmp);
+  }
+  if (!(sum > 0.0)) {
+    is.setstate(std::ios_base::failbit);
+    return is;
+  }
   x.param(param_type(p.begin(), p.end()));
   return is;
 }
diff --git a/absl/random/discrete_distribution_test.cc b/absl/random/discrete_distribution_test.cc
index 9d961f7..8fffb41 100644
--- a/absl/random/discrete_distribution_test.cc
+++ b/absl/random/discrete_distribution_test.cc
@@ -249,4 +249,104 @@
   EXPECT_THAT(output, testing::ElementsAre(3, 3, 0, 3, 0, 4));
 }
 
+MATCHER(FailsLeavingUnchanged,
+        "fails stream extraction and leaves target and stream flags "
+        "unchanged") {
+  return arg.failed && arg.flags_preserved && arg.value == arg.initial;
+}
+
+MATCHER_P(ParsesEqualTo, expected,
+          "succeeds, updates target, and preserves stream flags") {
+  return !arg.failed && arg.flags_preserved && arg.value == expected;
+}
+
+TEST(DiscreteDistributionTest, MaxNarrowTypeSerializationRoundTrips) {
+  // 256 weights for uint8_t (max == 255) previously wrapped uint8_t loop index
+  // at 255 -> 0; 128 weights for int8_t (max == 127) overflowed signed int8_t.
+  {
+    std::vector<double> weights(256, 1.0);
+    const absl::discrete_distribution<uint8_t> expected(weights.begin(),
+                                                        weights.end());
+    std::ostringstream oss;
+    oss << expected;
+    EXPECT_THAT(absl::random_internal::ParseFromStream(
+                    absl::discrete_distribution<uint8_t>(), oss.str()),
+                ParsesEqualTo(expected));
+  }
+  {
+    std::vector<double> weights(128, 1.0);
+    const absl::discrete_distribution<int8_t> expected(weights.begin(),
+                                                       weights.end());
+    std::ostringstream oss;
+    oss << expected;
+    EXPECT_THAT(absl::random_internal::ParseFromStream(
+                    absl::discrete_distribution<int8_t>(), oss.str()),
+                ParsesEqualTo(expected));
+  }
+}
+
+TEST(DiscreteDistributionTest, StreamRejectsInvalidParameters) {
+  using absl::random_internal::ParseFromStream;
+  const absl::discrete_distribution<int> kInitial({1.0, 2.0});
+  const absl::discrete_distribution<int8_t> kI8Initial({1.0, 2.0});
+  const absl::discrete_distribution<uint8_t> kU8Initial({1.0, 2.0});
+
+  // Valid streams including subnormal positive weight.
+  EXPECT_THAT(ParseFromStream(kInitial, "2 0.25 0.75"),
+              ParsesEqualTo(absl::discrete_distribution<int>({0.25, 0.75})));
+  EXPECT_THAT(ParseFromStream(kInitial, "2 1e-320 1.0"),
+              ParsesEqualTo(absl::discrete_distribution<int>({1e-320, 1.0})));
+
+  // Empty, malformed, zero, and negative counts (including unsigned wraparound
+  // to n == 2 on 64-bit platforms).
+  EXPECT_THAT(ParseFromStream(kInitial, ""), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "abc"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-1 1.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-2 0.5 0.5"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-18446744073709551614 0.25 0.75"),
+              FailsLeavingUnchanged());
+
+  // Count exceeding IntType::max() + 1 or huge truncated count (must not OOM).
+  EXPECT_THAT(ParseFromStream(kI8Initial, "129 1.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kU8Initial, "257 1.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "1000000000000 1.0"),
+              FailsLeavingUnchanged());
+
+  // Truncated, all-zero, negative, overflowing-sum, and non-finite weights.
+  EXPECT_THAT(ParseFromStream(kInitial, "2 1.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "1 0.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "3 0.0 0.0 0.0"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "2 -1.0 1.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "2 1.0 -1.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "2 1e308 1e308"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "3 1e308 1e308 1.0"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "2 nan 1.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "2 1.0 nan"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "2 inf 1.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "2 1.0 inf"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "2 1.0 -inf"), FailsLeavingUnchanged());
+
+  // Non-finite weights delivered with goodbit by a custom num_get facet.
+  EXPECT_THAT(
+      ParseFromStream(kInitial, "2 nan 1.0", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kInitial, "2 1.0 nan", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kInitial, "2 inf 1.0", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kInitial, "2 1.0 inf", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kInitial, "2 1.0 -inf", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+}
+
 }  // namespace
diff --git a/absl/random/exponential_distribution.h b/absl/random/exponential_distribution.h
index 21a0279..507a362 100644
--- a/absl/random/exponential_distribution.h
+++ b/absl/random/exponential_distribution.h
@@ -18,6 +18,7 @@
 #include <cassert>
 #include <cmath>
 #include <cstdint>
+#include <ios>
 #include <istream>
 #include <limits>
 #include <ostream>
@@ -152,12 +153,16 @@
     exponential_distribution<RealType>& x) {  // NOLINT(runtime/references)
   using result_type = typename exponential_distribution<RealType>::result_type;
   using param_type = typename exponential_distribution<RealType>::param_type;
-  result_type lambda;
 
   auto saver = random_internal::make_istream_state_saver(is);
-  lambda = random_internal::read_floating_point<result_type>(is);
+  const result_type lambda =
+      random_internal::read_floating_point<result_type>(is);
   if (!is.fail()) {
-    x.param(param_type(lambda));
+    if (lambda > 0 && lambda <= (std::numeric_limits<result_type>::max)()) {
+      x.param(param_type(lambda));
+    } else {
+      is.setstate(std::ios_base::failbit);
+    }
   }
   return is;
 }
diff --git a/absl/random/exponential_distribution_test.cc b/absl/random/exponential_distribution_test.cc
index 71be99e..ea167c9 100644
--- a/absl/random/exponential_distribution_test.cc
+++ b/absl/random/exponential_distribution_test.cc
@@ -423,4 +423,50 @@
   }
 }
 
+MATCHER(FailsLeavingUnchanged,
+        "fails stream extraction and leaves target and stream flags "
+        "unchanged") {
+  return arg.failed && arg.flags_preserved && arg.value == arg.initial;
+}
+
+MATCHER_P(ParsesEqualTo, expected,
+          "succeeds, updates target, and preserves stream flags") {
+  return !arg.failed && arg.flags_preserved && arg.value == expected;
+}
+
+TEST(ExponentialDistributionTest, StreamRejectsInvalidParameters) {
+  using absl::random_internal::ParseFromStream;
+  const absl::exponential_distribution<double> kInitial(2.5);
+  const absl::exponential_distribution<float> kFloatInitial(2.5f);
+
+  // Valid positive and subnormal lambdas.
+  EXPECT_THAT(ParseFromStream(kInitial, "1.0"),
+              ParsesEqualTo(absl::exponential_distribution<double>(1.0)));
+  EXPECT_THAT(ParseFromStream(kInitial, "1e-320"),
+              ParsesEqualTo(absl::exponential_distribution<double>(1e-320)));
+
+  // Empty, non-positive, overflowing, and non-finite inputs.
+  EXPECT_THAT(ParseFromStream(kInitial, ""), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "0.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-1.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "nan"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "inf"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-inf"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "1e400"), FailsLeavingUnchanged());
+
+  // Non-finite values delivered with goodbit by a custom num_get facet.
+  EXPECT_THAT(ParseFromStream(kInitial, "nan", /*use_non_finite_facet=*/true),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "inf", /*use_non_finite_facet=*/true),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-inf", /*use_non_finite_facet=*/true),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kFloatInitial, "nan", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kFloatInitial, "inf", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+}
+
 }  // namespace
diff --git a/absl/random/gaussian_distribution.h b/absl/random/gaussian_distribution.h
index d14de0b..9511b3d 100644
--- a/absl/random/gaussian_distribution.h
+++ b/absl/random/gaussian_distribution.h
@@ -24,6 +24,7 @@
 
 #include <cmath>
 #include <cstdint>
+#include <ios>
 #include <istream>
 #include <limits>
 #include <ostream>
@@ -197,11 +198,15 @@
   using param_type = typename gaussian_distribution<RealType>::param_type;
 
   auto saver = random_internal::make_istream_state_saver(is);
-  auto mean = random_internal::read_floating_point<result_type>(is);
+  const auto mean = random_internal::read_floating_point<result_type>(is);
   if (is.fail()) return is;
-  auto stddev = random_internal::read_floating_point<result_type>(is);
+  const auto stddev = random_internal::read_floating_point<result_type>(is);
   if (!is.fail()) {
-    x.param(param_type(mean, stddev));
+    if (std::isfinite(mean) && std::isfinite(stddev)) {
+      x.param(param_type(mean, stddev));
+    } else {
+      is.setstate(std::ios_base::failbit);
+    }
   }
   return is;
 }
diff --git a/absl/random/gaussian_distribution_test.cc b/absl/random/gaussian_distribution_test.cc
index 65fd85a..c876f94 100644
--- a/absl/random/gaussian_distribution_test.cc
+++ b/absl/random/gaussian_distribution_test.cc
@@ -561,4 +561,69 @@
   }
 }
 
+MATCHER(FailsLeavingUnchanged,
+        "fails stream extraction and leaves target and stream flags "
+        "unchanged") {
+  return arg.failed && arg.flags_preserved && arg.value == arg.initial;
+}
+
+MATCHER_P(ParsesEqualTo, expected,
+          "succeeds, updates target, and preserves stream flags") {
+  return !arg.failed && arg.flags_preserved && arg.value == expected;
+}
+
+TEST(GaussianDistributionTest, StreamRejectsInvalidParameters) {
+  using absl::random_internal::ParseFromStream;
+  const absl::gaussian_distribution<double> kInitial(1.0, 2.0);
+  const absl::gaussian_distribution<float> kFloatInitial(1.0f, 2.0f);
+
+  // Valid streams including zero/negative stddev and subnormal values.
+  EXPECT_THAT(ParseFromStream(kInitial, "0.0 1.0"),
+              ParsesEqualTo(absl::gaussian_distribution<double>(0.0, 1.0)));
+  EXPECT_THAT(ParseFromStream(kInitial, "2.5 -1.5"),
+              ParsesEqualTo(absl::gaussian_distribution<double>(2.5, -1.5)));
+  EXPECT_THAT(ParseFromStream(kInitial, "0.0 0.0"),
+              ParsesEqualTo(absl::gaussian_distribution<double>(0.0, 0.0)));
+  EXPECT_THAT(ParseFromStream(kInitial, "1e-320 1.0"),
+              ParsesEqualTo(absl::gaussian_distribution<double>(1e-320, 1.0)));
+
+  // Truncated, overflowing, and non-finite inputs under the default locale.
+  EXPECT_THAT(ParseFromStream(kInitial, ""), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "1.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "nan 1.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "0.0 nan"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "inf 1.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "0.0 inf"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-inf 1.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "0.0 -inf"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "1e400 1.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "0.0 1e400"), FailsLeavingUnchanged());
+
+  // Non-finite values delivered with goodbit by a custom num_get facet.
+  EXPECT_THAT(
+      ParseFromStream(kInitial, "nan 1.0", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kInitial, "0.0 nan", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kInitial, "inf 1.0", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kInitial, "0.0 inf", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kInitial, "-inf 1.0", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kInitial, "0.0 -inf", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kFloatInitial, "nan 1.0", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kFloatInitial, "0.0 inf", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+}
+
 }  // namespace
diff --git a/absl/random/internal/distribution_test_util.cc b/absl/random/internal/distribution_test_util.cc
index e342499..237a1c8 100644
--- a/absl/random/internal/distribution_test_util.cc
+++ b/absl/random/internal/distribution_test_util.cc
@@ -16,7 +16,9 @@
 
 #include <cassert>
 #include <cmath>
+#include <ios>
 #include <limits>
+#include <locale>
 #include <ostream>
 #include <string>
 
@@ -497,6 +499,96 @@
   return max_err;
 }
 
+namespace {
+
+class NonFiniteNumGet final : public std::num_get<char> {
+ protected:
+  using std::num_get<char>::do_get;
+
+  iter_type do_get(iter_type in, iter_type end,
+                   std::ios_base& str,           // NOLINT(runtime/references)
+                   std::ios_base::iostate& err,  // NOLINT(runtime/references)
+                   float& v) const override {    // NOLINT(runtime/references)
+    return ParseFloat(in, end, str, err, v);
+  }
+
+  iter_type do_get(iter_type in, iter_type end,
+                   std::ios_base& str,           // NOLINT(runtime/references)
+                   std::ios_base::iostate& err,  // NOLINT(runtime/references)
+                   double& v) const override {   // NOLINT(runtime/references)
+    return ParseFloat(in, end, str, err, v);
+  }
+
+  iter_type do_get(
+      iter_type in, iter_type end,
+      std::ios_base& str,               // NOLINT(runtime/references)
+      std::ios_base::iostate& err,      // NOLINT(runtime/references)
+      long double& v) const override {  // NOLINT(runtime/references)
+    return ParseFloat(in, end, str, err, v);
+  }
+
+ private:
+  template <typename T>
+  iter_type ParseFloat(
+      iter_type in, iter_type end,
+      std::ios_base& str,           // NOLINT(runtime/references)
+      std::ios_base::iostate& err,  // NOLINT(runtime/references)
+      T& v) const {                 // NOLINT(runtime/references)
+    if (in == end) {
+      return std::num_get<char>::do_get(in, end, str, err, v);
+    }
+    bool negative = false;
+    if (*in == '-' || *in == '+') {
+      negative = (*in == '-');
+      ++in;
+      if (in == end || *in == '-' || *in == '+') {
+        v = T{0};
+        err |= std::ios_base::failbit;
+        if (in == end) err |= std::ios_base::eofbit;
+        return in;
+      }
+    }
+    auto match_literal = [&](const char* literal, T result) {
+      for (const char* p = literal; *p != '\0'; ++p) {
+        if (in == end || *in != *p) {
+          v = T{0};
+          err |= std::ios_base::failbit;
+          if (in == end) err |= std::ios_base::eofbit;
+          return in;
+        }
+        ++in;
+      }
+      if (in == end) {
+        err |= std::ios_base::eofbit;
+      } else if (*in != ' ' && *in != '\t' && *in != '\n' && *in != '\r') {
+        v = T{0};
+        err |= std::ios_base::failbit;
+        return in;
+      }
+      v = negative ? -result : result;
+      return in;
+    };
+    if (*in == 'n') {
+      return match_literal("nan", std::numeric_limits<T>::quiet_NaN());
+    }
+    if (*in == 'i') {
+      return match_literal("inf", std::numeric_limits<T>::infinity());
+    }
+    in = std::num_get<char>::do_get(in, end, str, err, v);
+    if (negative) {
+      v = -v;
+    }
+    return in;
+  }
+};
+
+}  // namespace
+
+void ImbueNonFiniteLocale(std::ios* stream) {
+  ABSL_ASSERT(stream != nullptr);
+  stream->imbue(std::locale(stream->getloc(), new NonFiniteNumGet()));
+}
+
 }  // namespace random_internal
 ABSL_NAMESPACE_END
 }  // namespace absl
diff --git a/absl/random/internal/distribution_test_util.h b/absl/random/internal/distribution_test_util.h
index e6e3544..b7afbf4 100644
--- a/absl/random/internal/distribution_test_util.h
+++ b/absl/random/internal/distribution_test_util.h
@@ -16,7 +16,11 @@
 #define ABSL_RANDOM_INTERNAL_DISTRIBUTION_TEST_UTIL_H_
 
 #include <cstddef>
+#include <ios>
 #include <ostream>
+#include <sstream>
+#include <string>
+#include <utility>
 
 #include "absl/base/config.h"
 #include "absl/strings/string_view.h"
@@ -105,6 +109,60 @@
 // not flat to double precision.
 double BetaIncompleteInv(double p, double q, double alpha);
 
+// Imbues `stream` with a test-only `std::num_get<char>` facet that parses
+// "nan", "inf", and "-inf" with goodbit so stream deserialization tests can
+// exercise distribution `std::isfinite()` and range guards even on libc++ and
+// libstdc++, where the default `num_get` facet already sets failbit on those
+// tokens.
+void ImbueNonFiniteLocale(std::ios* stream);
+
+// Result of extracting a distribution from a test stream via `ParseFromStream`.
+template <typename T>
+struct StreamParseResult {
+  bool failed = false;
+  bool flags_preserved = false;
+  T value;
+  T initial;
+};
+
+template <typename T>
+void PrintTo(const StreamParseResult<T>& result, std::ostream* os) {
+  *os << "{failed=" << (result.failed ? "true" : "false")
+      << ", flags_preserved=" << (result.flags_preserved ? "true" : "false")
+      << ", value=" << result.value << "}";
+}
+
+// Extracts a `T` from `input` into a copy of `initial`, setting non-default
+// stream formatting flags (`hex | left | scientific`) beforehand to verify
+// `istream_state_saver` flag restoration and optionally imbuing a non-finite
+// `num_get` facet to exercise non-finite parameter validation.
+template <typename T>
+StreamParseResult<T> ParseFromStream(const T& initial, const std::string& input,
+                                     bool use_non_finite_facet = false) {
+  const std::ios_base::fmtflags kInitFlags =
+      std::ios_base::hex | std::ios_base::left | std::ios_base::scientific;
+  T value = initial;
+  std::istringstream is(input);
+  if (use_non_finite_facet) {
+    ImbueNonFiniteLocale(&is);
+  }
+  is.flags(kInitFlags);
+  is >> value;
+  return {is.fail(), is.flags() == kInitFlags, std::move(value), initial};
+}
+
+template <typename T>
+StreamParseResult<T> ParseFromStream(const T& initial,
+                                     const std::wstring& input) {
+  const std::ios_base::fmtflags kInitFlags =
+      std::ios_base::hex | std::ios_base::left | std::ios_base::scientific;
+  T value = initial;
+  std::wistringstream is(input);
+  is.flags(kInitFlags);
+  is >> value;
+  return {is.fail(), is.flags() == kInitFlags, std::move(value), initial};
+}
+
 }  // namespace random_internal
 ABSL_NAMESPACE_END
 }  // namespace absl
diff --git a/absl/random/internal/distribution_test_util_test.cc b/absl/random/internal/distribution_test_util_test.cc
index f614e42..4a77774 100644
--- a/absl/random/internal/distribution_test_util_test.cc
+++ b/absl/random/internal/distribution_test_util_test.cc
@@ -16,6 +16,9 @@
 
 #include <cmath>
 #include <limits>
+#include <ostream>
+#include <sstream>
+#include <string>
 #include <utility>
 #include <vector>
 
@@ -27,6 +30,7 @@
 using absl::random_internal::BetaIncomplete;
 using absl::random_internal::BetaIncompleteInv;
 using absl::random_internal::erfinv;
+using absl::random_internal::ImbueNonFiniteLocale;
 using absl::random_internal::InverseNormalSurvival;
 using absl::random_internal::MaxErrorTolerance;
 using absl::random_internal::RequiredSuccessProbability;
@@ -416,4 +420,94 @@
   EXPECT_THAT(erfinv(kNan), IsNan());
 }
 
+template <typename T>
+struct ImbuedParseResult {
+  bool failed = false;
+  T value = T{0};
+};
+
+template <typename T>
+void PrintTo(const ImbuedParseResult<T>& r, std::ostream* os) {
+  *os << "{failed=" << (r.failed ? "true" : "false") << ", value=" << r.value
+      << "}";
+}
+
+template <typename T>
+ImbuedParseResult<T> ParseImbued(const std::string& input) {
+  std::istringstream is(input);
+  ImbueNonFiniteLocale(&is);
+  T v = T{42};
+  is >> v;
+  return {is.fail(), v};
+}
+
+MATCHER_P(ParsesFinite, expected, "") {
+  return !arg.failed && arg.value == expected &&
+         std::signbit(arg.value) == std::signbit(expected);
+}
+
+MATCHER(ParsesNan, "") { return !arg.failed && std::isnan(arg.value); }
+
+MATCHER_P(ParsesInf, positive, "") {
+  return !arg.failed && std::isinf(arg.value) &&
+         (positive ? arg.value > 0 : arg.value < 0);
+}
+
+MATCHER(FailsImbuedParse, "") { return arg.failed; }
+
+TEST(ImbueNonFiniteLocale, ParsesNonFiniteAndDelegatesFiniteValues) {
+  EXPECT_THAT(ParseImbued<float>("nan"), ParsesNan());
+  EXPECT_THAT(ParseImbued<float>("inf"), ParsesInf(true));
+  EXPECT_THAT(ParseImbued<float>("-inf"), ParsesInf(false));
+  EXPECT_THAT(ParseImbued<float>("+inf"), ParsesInf(true));
+  EXPECT_THAT(ParseImbued<float>("1.5"), ParsesFinite(1.5f));
+  EXPECT_THAT(ParseImbued<float>("-1.5"), ParsesFinite(-1.5f));
+  EXPECT_THAT(ParseImbued<float>("-0.0"), ParsesFinite(-0.0f));
+  EXPECT_THAT(ParseImbued<float>("-3.402823466e+38"),
+              ParsesFinite(std::numeric_limits<float>::lowest()));
+
+  EXPECT_THAT(ParseImbued<double>("nan"), ParsesNan());
+  EXPECT_THAT(ParseImbued<double>("inf"), ParsesInf(true));
+  EXPECT_THAT(ParseImbued<double>("-inf"), ParsesInf(false));
+  EXPECT_THAT(ParseImbued<double>("1.5"), ParsesFinite(1.5));
+  EXPECT_THAT(ParseImbued<double>("-1.5"), ParsesFinite(-1.5));
+  EXPECT_THAT(ParseImbued<double>("-0.0"), ParsesFinite(-0.0));
+  EXPECT_THAT(ParseImbued<double>("-1.7976931348623157e+308"),
+              ParsesFinite(std::numeric_limits<double>::lowest()));
+
+  EXPECT_THAT(ParseImbued<long double>("nan"), ParsesNan());
+  EXPECT_THAT(ParseImbued<long double>("inf"), ParsesInf(true));
+  EXPECT_THAT(ParseImbued<long double>("-inf"), ParsesInf(false));
+  EXPECT_THAT(ParseImbued<long double>("1.5"), ParsesFinite(1.5L));
+  EXPECT_THAT(ParseImbued<long double>("-1.5"), ParsesFinite(-1.5L));
+
+  // Multi-token extraction preserves stream position across non-finite and
+  // finite tokens, including integral extractions on the same stream.
+  std::istringstream seq("2 nan 1.5 -inf -2.25");
+  ImbueNonFiniteLocale(&seq);
+  int count = 0;
+  double a = 0.0;
+  double b = 0.0;
+  double c = 0.0;
+  double d = 0.0;
+  seq >> count >> a >> b >> c >> d;
+  ASSERT_FALSE(seq.fail());
+  EXPECT_EQ(count, 2);
+  EXPECT_TRUE(std::isnan(a));
+  EXPECT_EQ(b, 1.5);
+  EXPECT_TRUE(std::isinf(c) && c < 0.0);
+  EXPECT_EQ(d, -2.25);
+
+  EXPECT_THAT(ParseImbued<double>(""), FailsImbuedParse());
+  EXPECT_THAT(ParseImbued<double>("-"), FailsImbuedParse());
+  EXPECT_THAT(ParseImbued<double>("+"), FailsImbuedParse());
+  EXPECT_THAT(ParseImbued<double>("--1.5"), FailsImbuedParse());
+  EXPECT_THAT(ParseImbued<double>("+-1.5"), FailsImbuedParse());
+  EXPECT_THAT(ParseImbued<double>("not_a_number"), FailsImbuedParse());
+  EXPECT_THAT(ParseImbued<double>("infxyz"), FailsImbuedParse());
+  EXPECT_THAT(ParseImbued<double>("nan1"), FailsImbuedParse());
+  EXPECT_THAT(ParseImbued<double>("1e400"), FailsImbuedParse());
+  EXPECT_THAT(ParseImbued<double>("-1e400"), FailsImbuedParse());
+}
+
 }  // namespace
diff --git a/absl/random/internal/iostream_state_saver.h b/absl/random/internal/iostream_state_saver.h
index 05d9f83..985e0f8 100644
--- a/absl/random/internal/iostream_state_saver.h
+++ b/absl/random/internal/iostream_state_saver.h
@@ -177,6 +177,55 @@
 struct stream_format_type
     : public std::conditional<(sizeof(T) == sizeof(char)), int, T> {};
 
+// Extracts an integral value of type `IntType` from `is`, storing it in `out`
+// on success and returning `true`. On failure, sets `std::ios_base::failbit`
+// (if not already failed) and returns `false` without modifying `out`.
+//
+// Rejects leading '-' for unsigned `IntType` (preventing standard `num_get`
+// modular wraparound) and validates range bounds for 1-byte types widened to
+// `int` via `stream_format_type`.
+template <typename IntType, typename CharT, typename Traits>
+inline bool read_integral(
+    std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
+    IntType& out) {                         // NOLINT(runtime/references)
+  static_assert(std::numeric_limits<IntType>::is_integer);
+  using stream_type = typename stream_format_type<IntType>::type;
+  if constexpr (!std::numeric_limits<IntType>::is_signed) {
+    {
+      typename std::basic_istream<CharT, Traits>::sentry ok(is);
+      if (!ok) {
+        return false;
+      }
+    }
+    const typename Traits::int_type ch = is.peek();
+    if (is.fail()) {
+      return false;
+    }
+    if (!Traits::eq_int_type(ch, Traits::eof()) &&
+        Traits::eq(Traits::to_char_type(ch), is.widen('-'))) {
+      is.setstate(std::ios_base::failbit);
+      return false;
+    }
+  }
+  stream_type val = 0;
+  is >> val;
+  if (is.fail()) {
+    return false;
+  }
+  if constexpr (!std::is_same_v<stream_type, IntType>) {
+    constexpr stream_type kMin =
+        static_cast<stream_type>((std::numeric_limits<IntType>::min)());
+    constexpr stream_type kMax =
+        static_cast<stream_type>((std::numeric_limits<IntType>::max)());
+    if (val < kMin || val > kMax) {
+      is.setstate(std::ios_base::failbit);
+      return false;
+    }
+  }
+  out = static_cast<IntType>(val);
+  return true;
+}
+
 // stream_u128_helper allows us to write out either absl::uint128 or
 // __uint128_t types in the same way, which enables their use as internal
 // state of PRNG engines.
@@ -189,7 +238,9 @@
   absl::uint128 read(IStream& in) {
     uint64_t h = 0;
     uint64_t l = 0;
-    in >> h >> l;
+    if (!read_integral(in, h) || !read_integral(in, l)) {
+      return absl::uint128{0};
+    }
     return absl::MakeUint128(h, l);
   }
 
@@ -208,7 +259,9 @@
   __uint128_t read(IStream& in) {
     uint64_t h = 0;
     uint64_t l = 0;
-    in >> h >> l;
+    if (!read_integral(in, h) || !read_integral(in, l)) {
+      return 0;
+    }
     return (static_cast<__uint128_t>(h) << 64) | l;
   }
 
@@ -224,7 +277,10 @@
 template <typename FloatType, typename IStream>
 inline FloatType read_floating_point(IStream& is) {
   static_assert(std::is_floating_point_v<FloatType>);
-  FloatType dest;
+  if (is.fail()) {
+    return FloatType{0};
+  }
+  FloatType dest = 0;
   is >> dest;
   // Parsing a double value may report a subnormal value as an error
   // despite being able to represent it.
@@ -233,7 +289,7 @@
   // ERANGE error, as the parsed value may be smaller than DOUBLE_MIN
   // and rounded up.
   // See: https://stackoverflow.com/q/42005462
-  if (is.fail() &&
+  if (is.fail() && !is.bad() &&
       (std::fabs(dest) == (std::numeric_limits<FloatType>::min)() ||
        std::fpclassify(dest) == FP_SUBNORMAL)) {
     is.clear(is.rdstate() & (~std::ios_base::failbit));
diff --git a/absl/random/internal/iostream_state_saver_test.cc b/absl/random/internal/iostream_state_saver_test.cc
index a196ace..8edbfe7 100644
--- a/absl/random/internal/iostream_state_saver_test.cc
+++ b/absl/random/internal/iostream_state_saver_test.cc
@@ -20,11 +20,14 @@
 #include <cstdint>
 #include <cstdlib>
 #include <ios>
+#include <istream>
 #include <limits>
+#include <ostream>
 #include <sstream>
 #include <string>
 #include <type_traits>
 
+#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 namespace {
@@ -375,4 +378,200 @@
   // errno may equal ERANGE.
 }
 
+template <typename FloatType>
+struct FloatReadResult {
+  bool ok = false;
+  bool failed = false;
+  FloatType out = 0;
+  FloatType initial = 0;
+};
+
+template <typename FloatType>
+void PrintTo(const FloatReadResult<FloatType>& r, std::ostream* os) {
+  *os << "{ok=" << (r.ok ? "true" : "false")
+      << ", failed=" << (r.failed ? "true" : "false") << ", out=" << r.out
+      << "}";
+}
+
+template <typename FloatType>
+FloatReadResult<FloatType> ReadFloat(const std::string& input) {
+  std::istringstream is(input);
+  const FloatType val =
+      absl::random_internal::read_floating_point<FloatType>(is);
+  return {!is.fail(), is.fail(), val, FloatType{0}};
+}
+
+template <typename IntType>
+struct IntReadResult {
+  bool ok = false;
+  bool failed = false;
+  IntType out;
+  IntType initial;
+};
+
+template <typename IntType>
+void PrintTo(const IntReadResult<IntType>& r, std::ostream* os) {
+  using format_type =
+      typename absl::random_internal::stream_format_type<IntType>::type;
+  *os << "{ok=" << (r.ok ? "true" : "false")
+      << ", failed=" << (r.failed ? "true" : "false")
+      << ", out=" << static_cast<format_type>(r.out)
+      << ", initial=" << static_cast<format_type>(r.initial) << "}";
+}
+
+template <typename IntType>
+IntReadResult<IntType> ReadInt(const std::string& input, IntType sentinel) {
+  IntType out = sentinel;
+  std::istringstream is(input);
+  const bool ok = absl::random_internal::read_integral(is, out);
+  return {ok, is.fail(), out, sentinel};
+}
+
+template <typename IntType>
+IntReadResult<IntType> ReadInt(const std::wstring& input, IntType sentinel) {
+  IntType out = sentinel;
+  std::wistringstream is(input);
+  const bool ok = absl::random_internal::read_integral(is, out);
+  return {ok, is.fail(), out, sentinel};
+}
+
+MATCHER(FailsPreservingOut,
+        "fails extraction and leaves output equal to initial value") {
+  return !arg.ok && arg.failed && arg.out == arg.initial;
+}
+
+MATCHER_P(ReadsValue, expected,
+          "succeeds without failbit and extracts expected value") {
+  return arg.ok && !arg.failed && arg.out == expected;
+}
+
+TEST(ReadFloatingPointTest, EmptyAndInvalidStreamsPreserveFailbit) {
+  using absl::random_internal::read_floating_point;
+
+  EXPECT_THAT(ReadFloat<double>(""), FailsPreservingOut());
+  EXPECT_THAT(ReadFloat<double>("   "), FailsPreservingOut());
+  EXPECT_THAT(ReadFloat<double>("invalid"), FailsPreservingOut());
+
+  // Underflow to 0.0: preserve whatever failbit std::num_get sets (libc++ and
+  // MSVC fail on ERANGE underflow; libstdc++ succeeds with 0.0).
+  {
+    std::istringstream raw("1e-400");
+    double raw_val = 1.0;
+    raw >> raw_val;
+
+    std::istringstream is("1e-400");
+    const double val = read_floating_point<double>(is);
+    EXPECT_EQ(is.fail(), raw.fail());
+    EXPECT_EQ(val, 0.0);
+  }
+  // Overflow: all standard libraries set failbit (assigning +inf or DBL_MAX).
+  {
+    std::istringstream is("1e400");
+    const double val = read_floating_point<double>(is);
+    EXPECT_TRUE(is.fail());
+    EXPECT_TRUE(std::isinf(val) || val == (std::numeric_limits<double>::max)());
+  }
+
+  // Pre-failed stream returns 0 without consuming input or clearing failbit.
+  {
+    std::istringstream is("1.5");
+    is.setstate(std::ios_base::failbit);
+    const double val = read_floating_point<double>(is);
+    EXPECT_TRUE(is.fail());
+    EXPECT_EQ(val, 0.0);
+    is.clear();
+    double remaining = 0.0;
+    is >> remaining;
+    EXPECT_EQ(remaining, 1.5);
+  }
+
+  // Pre-failed badbit streams short-circuit, preserving badbit and failbit.
+  {
+    std::istream null_is(nullptr);
+    const double val = read_floating_point<double>(null_is);
+    EXPECT_TRUE(null_is.bad());
+    EXPECT_TRUE(null_is.fail());
+    EXPECT_EQ(val, 0.0);
+  }
+  {
+    std::istringstream is("4.94065645841246544e-324");
+    is.setstate(std::ios_base::badbit);
+    const double val = read_floating_point<double>(is);
+    EXPECT_TRUE(is.bad());
+    EXPECT_TRUE(is.fail());
+    EXPECT_EQ(val, 0.0);
+  }
+
+  // Subnormal and min values continue to succeed without failbit.
+  EXPECT_THAT(ReadFloat<double>("4.94065645841246544e-324"),
+              ReadsValue(std::numeric_limits<double>::denorm_min()));
+}
+
+TEST(ReadIntegralTest, UnsignedRejectsNegativeAndPreservesOut) {
+  using absl::random_internal::read_integral;
+
+  EXPECT_THAT(ReadInt<uint64_t>("", 77), FailsPreservingOut());
+  EXPECT_THAT(ReadInt<uint64_t>("   ", 77), FailsPreservingOut());
+  EXPECT_THAT(ReadInt<uint64_t>("-", 77), FailsPreservingOut());
+  EXPECT_THAT(ReadInt<uint64_t>("-0", 77), FailsPreservingOut());
+  EXPECT_THAT(ReadInt<uint64_t>("-1", 77), FailsPreservingOut());
+  EXPECT_THAT(ReadInt<uint64_t>("  -42", 77), FailsPreservingOut());
+  EXPECT_THAT(ReadInt<uint64_t>("abc", 77), FailsPreservingOut());
+  EXPECT_THAT(ReadInt<uint64_t>("99999999999999999999999", 77),
+              FailsPreservingOut());
+
+  EXPECT_THAT(ReadInt<uint8_t>("-0", 77), FailsPreservingOut());
+  EXPECT_THAT(ReadInt<uint8_t>("-1", 77), FailsPreservingOut());
+  EXPECT_THAT(ReadInt<uint8_t>("256", 77), FailsPreservingOut());
+  EXPECT_THAT(ReadInt<uint8_t>("300", 77), FailsPreservingOut());
+
+  EXPECT_THAT(ReadInt<bool>("-0", true), FailsPreservingOut());
+  EXPECT_THAT(ReadInt<bool>("-1", true), FailsPreservingOut());
+  EXPECT_THAT(ReadInt<bool>("2", true), FailsPreservingOut());
+
+  EXPECT_THAT(ReadInt<uint32_t>(L"  -5", 99), FailsPreservingOut());
+  EXPECT_THAT(ReadInt<uint32_t>(L"  42", 0), ReadsValue(42u));
+
+  uint32_t out = 55;
+  std::istream null_is(nullptr);
+  EXPECT_FALSE(read_integral(null_is, out));
+  EXPECT_TRUE(null_is.bad());
+  EXPECT_EQ(out, 55u);
+}
+
+TEST(ReadIntegralTest, SignedAndNarrowBounds) {
+  using absl::random_internal::read_integral;
+
+  EXPECT_THAT(ReadInt<int8_t>("", 11), FailsPreservingOut());
+  EXPECT_THAT(ReadInt<int8_t>("abc", 11), FailsPreservingOut());
+  EXPECT_THAT(ReadInt<int8_t>("-129", 11), FailsPreservingOut());
+  EXPECT_THAT(ReadInt<int8_t>("128", 11), FailsPreservingOut());
+  EXPECT_THAT(ReadInt<int8_t>("-254", 11), FailsPreservingOut());
+  EXPECT_THAT(ReadInt<int8_t>("258", 11), FailsPreservingOut());
+
+  EXPECT_THAT(ReadInt<int8_t>("-128", 0), ReadsValue(int8_t{-128}));
+  EXPECT_THAT(ReadInt<int8_t>("127", 0), ReadsValue(int8_t{127}));
+  EXPECT_THAT(ReadInt<uint8_t>("0", 1), ReadsValue(uint8_t{0}));
+  EXPECT_THAT(ReadInt<uint8_t>("255", 1), ReadsValue(uint8_t{255}));
+
+  {
+    int8_t lo = 0;
+    int8_t hi = 0;
+    std::istringstream is("-128 127");
+    EXPECT_TRUE(read_integral(is, lo));
+    EXPECT_TRUE(read_integral(is, hi));
+    EXPECT_EQ(lo, -128);
+    EXPECT_EQ(hi, 127);
+  }
+  {
+    uint8_t lo = 1;
+    uint8_t hi = 1;
+    std::istringstream is("0 255");
+    EXPECT_TRUE(read_integral(is, lo));
+    EXPECT_TRUE(read_integral(is, hi));
+    EXPECT_EQ(lo, 0u);
+    EXPECT_EQ(hi, 255u);
+  }
+}
+
 }  // namespace
diff --git a/absl/random/internal/pcg_engine.h b/absl/random/internal/pcg_engine.h
index f85a1ac..e785392 100644
--- a/absl/random/internal/pcg_engine.h
+++ b/absl/random/internal/pcg_engine.h
@@ -144,18 +144,21 @@
   operator>>(
       std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
       pcg_engine& engine) {                   // NOLINT(runtime/references)
+    auto saver = random_internal::make_istream_state_saver(is);
     random_internal::stream_u128_helper<state_type> helper;
     auto mult = helper.read(is);
     auto inc = helper.read(is);
     auto tmp = helper.read(is);
+    if (is.fail()) {
+      return is;
+    }
     if (mult != pcg_engine::params_type::multiplier() ||
         inc != pcg_engine::params_type::increment()) {
       // signal failure by setting the failbit.
-      is.setstate(is.rdstate() | std::ios_base::failbit);
+      is.setstate(std::ios_base::failbit);
+      return is;
     }
-    if (!is.fail()) {
-      engine.state_ = tmp;
-    }
+    engine.state_ = tmp;
     return is;
   }
 
@@ -165,16 +168,20 @@
   operator>>(
       std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
       pcg_engine& engine) {                   // NOLINT(runtime/references)
+    auto saver = random_internal::make_istream_state_saver(is);
     state_type mult{}, inc{}, tmp{};
-    is >> mult >> inc >> tmp;
+    if (!random_internal::read_integral(is, mult) ||
+        !random_internal::read_integral(is, inc) ||
+        !random_internal::read_integral(is, tmp)) {
+      return is;
+    }
     if (mult != pcg_engine::params_type::multiplier() ||
         inc != pcg_engine::params_type::increment()) {
       // signal failure by setting the failbit.
-      is.setstate(is.rdstate() | std::ios_base::failbit);
+      is.setstate(std::ios_base::failbit);
+      return is;
     }
-    if (!is.fail()) {
-      engine.state_ = tmp;
-    }
+    engine.state_ = tmp;
     return is;
   }
 
diff --git a/absl/random/internal/pcg_engine_test.cc b/absl/random/internal/pcg_engine_test.cc
index 9b34cfe..938dc85 100644
--- a/absl/random/internal/pcg_engine_test.cc
+++ b/absl/random/internal/pcg_engine_test.cc
@@ -19,10 +19,15 @@
 #include <cmath>
 #include <cstddef>
 #include <cstdint>
+#include <ios>
+#include <ostream>
 #include <random>
 #include <sstream>
+#include <string>
 #include <type_traits>
+#include <vector>
 
+#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "absl/random/internal/explicit_seed_seq.h"
 
@@ -271,6 +276,137 @@
   }
 }
 
+template <typename Engine>
+std::vector<std::string> SerializeTokens(const Engine& engine) {
+  std::ostringstream oss;
+  oss << engine;
+  std::istringstream iss(oss.str());
+  std::vector<std::string> tokens;
+  std::string token;
+  while (iss >> token) {
+    tokens.push_back(token);
+  }
+  return tokens;
+}
+
+std::string JoinTokens(const std::vector<std::string>& tokens) {
+  std::ostringstream oss;
+  for (size_t i = 0; i < tokens.size(); ++i) {
+    if (i > 0) oss << ' ';
+    oss << tokens[i];
+  }
+  return oss.str();
+}
+
+std::string ReplaceToken(std::vector<std::string> tokens, size_t index,
+                         const std::string& value) {
+  tokens[index] = value;
+  return JoinTokens(tokens);
+}
+
+std::string TruncateTokens(std::vector<std::string> tokens, size_t count) {
+  tokens.resize(count);
+  return JoinTokens(tokens);
+}
+
+template <typename Engine>
+struct EngineParseResult {
+  bool failed = false;
+  bool flags_preserved = false;
+  Engine value;
+  Engine initial;
+};
+
+template <typename Engine>
+void PrintTo(const EngineParseResult<Engine>& r, std::ostream* os) {
+  *os << "{failed=" << (r.failed ? "true" : "false")
+      << ", flags_preserved=" << (r.flags_preserved ? "true" : "false")
+      << ", unchanged=" << (r.value == r.initial ? "true" : "false") << "}";
+}
+
+template <typename Engine>
+EngineParseResult<Engine> ParseEngine(const Engine& initial,
+                                      const std::string& input) {
+  const std::ios_base::fmtflags kInitFlags =
+      std::ios_base::hex | std::ios_base::showbase | std::ios_base::skipws;
+  Engine target = initial;
+  std::istringstream iss(input);
+  iss.flags(kInitFlags);
+  iss >> target;
+  return {iss.fail(), iss.flags() == kInitFlags, target, initial};
+}
+
+MATCHER(FailsLeavingUnchanged,
+        "fails extraction while preserving engine state and stream flags") {
+  return arg.failed && arg.flags_preserved && arg.value == arg.initial;
+}
+
+MATCHER_P(ParsesEqualToPtr, expected,
+          "succeeds, restores expected engine state, and preserves flags") {
+  return !arg.failed && arg.flags_preserved && arg.value == *expected;
+}
+
+template <typename Engine>
+auto ParsesEqualTo(const Engine& expected) {
+  return ParsesEqualToPtr(&expected);
+}
+
+TYPED_TEST(PCGEngineTest, StreamDeserializationValidation) {
+  using engine_type = TypeParam;
+  engine_type expected(42);
+  expected.discard(3);
+  const engine_type initial(7);
+  ASSERT_FALSE(initial == expected);
+
+  const std::vector<std::string> tokens = SerializeTokens(expected);
+  ASSERT_TRUE(tokens.size() == 3u || tokens.size() == 6u);
+  const std::string valid_stream = JoinTokens(tokens);
+  const size_t n = tokens.size();
+
+  // Valid round-trip succeeds in decimal and restores caller stream flags.
+  EXPECT_THAT(ParseEngine(initial, valid_stream), ParsesEqualTo(expected));
+
+  // Mismatched multiplier and increment fail without modifying engine state.
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, 0, "0")),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, n / 3, "0")),
+              FailsLeavingUnchanged());
+
+  // Negative tokens (including "-0") are rejected at every field position
+  // (covering both 64-bit state_type and both words of 128-bit state_type).
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, 0, "-1")),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, 0, "-0")),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, 1, "-1")),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, 2, "-1")),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, n - 3, "-1")),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, n - 2, "-1")),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, n - 1, "-1")),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, n - 1, "-0")),
+              FailsLeavingUnchanged());
+
+  // Overflow, malformed, empty, and truncated streams fail and preserve flags.
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, 0,
+                                                "99999999999999999999999999")),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, n - 1,
+                                                "99999999999999999999999999")),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, n - 1, "abc")),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseEngine(initial, ""), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseEngine(initial, TruncateTokens(tokens, 1)),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseEngine(initial, TruncateTokens(tokens, n - 1)),
+              FailsLeavingUnchanged());
+}
+
 // ------------------------------------------------------------------
 // Stability tests for pcg64_2018_engine
 // ------------------------------------------------------------------
diff --git a/absl/random/internal/randen_engine.h b/absl/random/internal/randen_engine.h
index 91a6025..0f51462 100644
--- a/absl/random/internal/randen_engine.h
+++ b/absl/random/internal/randen_engine.h
@@ -20,6 +20,7 @@
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
+#include <ios>
 #include <istream>
 #include <iterator>
 #include <limits>
@@ -222,19 +223,21 @@
   friend std::basic_istream<CharT, Traits>& operator>>(
       std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
       randen_engine<T>& engine) {             // NOLINT(runtime/references)
-    using numeric_type =
-        typename random_internal::stream_format_type<result_type>::type;
+    auto saver = random_internal::make_istream_state_saver(is);
     result_type state[kStateSizeT];
-    size_t next;
     for (auto& elem : state) {
-      // It is not possible to read uint8_t from wide streams, so it is
-      // necessary to read a wider type and then cast it to uint8_t.
-      numeric_type value;
-      is >> value;
-      elem = little_endian::ToHost(static_cast<result_type>(value));
+      result_type value = 0;
+      if (!random_internal::read_integral(is, value)) {
+        return is;
+      }
+      elem = little_endian::ToHost(value);
     }
-    is >> next;
-    if (is.fail()) {
+    size_t next = 0;
+    if (!random_internal::read_integral(is, next)) {
+      return is;
+    }
+    if (next < kCapacityT || next > kStateSizeT) {
+      is.setstate(std::ios_base::failbit);
       return is;
     }
     std::memcpy(engine.state(), state, sizeof(state));
diff --git a/absl/random/internal/randen_engine_test.cc b/absl/random/internal/randen_engine_test.cc
index 73afaf3..3f58184 100644
--- a/absl/random/internal/randen_engine_test.cc
+++ b/absl/random/internal/randen_engine_test.cc
@@ -19,11 +19,16 @@
 #include <cmath>
 #include <cstddef>
 #include <cstdint>
+#include <ios>
+#include <ostream>
 #include <random>
 #include <sstream>
+#include <string>
 #include <type_traits>
 #include <utility>
+#include <vector>
 
+#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "absl/log/log.h"
 #include "absl/random/internal/explicit_seed_seq.h"
@@ -293,6 +298,165 @@
   }
 }
 
+template <typename Engine>
+std::vector<std::string> SerializeTokens(const Engine& engine) {
+  std::ostringstream oss;
+  oss << engine;
+  std::istringstream iss(oss.str());
+  std::vector<std::string> tokens;
+  std::string token;
+  while (iss >> token) {
+    tokens.push_back(token);
+  }
+  return tokens;
+}
+
+std::string JoinTokens(const std::vector<std::string>& tokens) {
+  std::ostringstream oss;
+  for (size_t i = 0; i < tokens.size(); ++i) {
+    if (i > 0) oss << ' ';
+    oss << tokens[i];
+  }
+  return oss.str();
+}
+
+std::string ReplaceToken(std::vector<std::string> tokens, size_t index,
+                         const std::string& value) {
+  tokens[index] = value;
+  return JoinTokens(tokens);
+}
+
+std::string TruncateTokens(std::vector<std::string> tokens, size_t count) {
+  tokens.resize(count);
+  return JoinTokens(tokens);
+}
+
+template <typename Engine>
+struct EngineParseResult {
+  bool failed = false;
+  bool flags_preserved = false;
+  Engine value;
+  Engine initial;
+};
+
+template <typename Engine>
+void PrintTo(const EngineParseResult<Engine>& r, std::ostream* os) {
+  *os << "{failed=" << (r.failed ? "true" : "false")
+      << ", flags_preserved=" << (r.flags_preserved ? "true" : "false")
+      << ", unchanged=" << (r.value == r.initial ? "true" : "false") << "}";
+}
+
+template <typename Engine>
+EngineParseResult<Engine> ParseEngine(const Engine& initial,
+                                      const std::string& input) {
+  const std::ios_base::fmtflags kInitFlags =
+      std::ios_base::hex | std::ios_base::showbase | std::ios_base::skipws;
+  Engine target = initial;
+  std::istringstream iss(input);
+  iss.flags(kInitFlags);
+  iss >> target;
+  return {iss.fail(), iss.flags() == kInitFlags, target, initial};
+}
+
+MATCHER(FailsLeavingUnchanged,
+        "fails extraction while preserving engine state and stream flags") {
+  return arg.failed && arg.flags_preserved && arg.value == arg.initial;
+}
+
+MATCHER(ParsesSuccessfully, "succeeds and preserves stream flags") {
+  return !arg.failed && arg.flags_preserved;
+}
+
+MATCHER_P(ParsesEqualToPtr, expected,
+          "succeeds, restores expected engine state, and preserves flags") {
+  return !arg.failed && arg.flags_preserved && arg.value == *expected;
+}
+
+template <typename Engine>
+auto ParsesEqualTo(const Engine& expected) {
+  return ParsesEqualToPtr(&expected);
+}
+
+TYPED_TEST(RandenEngineTypedTest, StreamDeserializationValidation) {
+  using randen = absl::random_internal::randen_engine<TypeParam>;
+  constexpr size_t kStateSizeT = 256 / sizeof(TypeParam);
+  constexpr size_t kCapacityT = 16 / sizeof(TypeParam);
+
+  randen expected(static_cast<TypeParam>(123u));
+  expected.discard(5);
+  const randen initial(static_cast<TypeParam>(99u));
+  ASSERT_FALSE(initial == expected);
+
+  const std::vector<std::string> tokens = SerializeTokens(expected);
+  ASSERT_EQ(tokens.size(), kStateSizeT + 1);
+  const std::string valid_stream = JoinTokens(tokens);
+
+  // Valid round-trip must succeed in decimal and restore caller stream flags.
+  EXPECT_THAT(ParseEngine(initial, valid_stream), ParsesEqualTo(expected));
+
+  // Boundary next values kCapacityT and kStateSizeT are valid.
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, kStateSizeT,
+                                                std::to_string(kCapacityT))),
+              ParsesSuccessfully());
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, kStateSizeT,
+                                                std::to_string(kStateSizeT))),
+              ParsesSuccessfully());
+
+  // Reject next outside [kCapacityT, kStateSizeT], negative, or overflowing.
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, kStateSizeT, "0")),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseEngine(initial, ReplaceToken(tokens, kStateSizeT,
+                                        std::to_string(kCapacityT - 1))),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseEngine(initial, ReplaceToken(tokens, kStateSizeT,
+                                        std::to_string(kStateSizeT + 1))),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, kStateSizeT, "1000")),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, kStateSizeT, "-1")),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, kStateSizeT, "-0")),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, kStateSizeT,
+                                                "99999999999999999999999999")),
+              FailsLeavingUnchanged());
+
+  // Reject negative or overflowing state words.
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, 0, "-1")),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, 0, "-0")),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, kStateSizeT - 1, "-1")),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, 0,
+                                                "99999999999999999999999999")),
+              FailsLeavingUnchanged());
+
+  // Reject empty and truncated streams.
+  EXPECT_THAT(ParseEngine(initial, ""), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseEngine(initial, TruncateTokens(tokens, 1)),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseEngine(initial, TruncateTokens(tokens, kStateSizeT)),
+              FailsLeavingUnchanged());
+}
+
+TEST(RandenTest, StreamRejectsInvalidParameters) {
+  using randen_u8 = absl::random_internal::randen_engine<uint8_t>;
+  const randen_u8 expected(7u);
+  const randen_u8 initial(13u);
+  const std::vector<std::string> tokens = SerializeTokens(expected);
+  ASSERT_EQ(tokens.size(), 257u);
+
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, 0, "256")),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, 0, "300")),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, 255, "256")),
+              FailsLeavingUnchanged());
+}
+
 TEST(RandenTest, VerifyGoldenRanden64Default) {
   constexpr uint64_t kGolden[kNumGoldenOutputs] = {
       0xc3c14f134e433977, 0xdda9f47cd90410ee, 0x887bf3087fd8ca10,
diff --git a/absl/random/log_uniform_int_distribution.h b/absl/random/log_uniform_int_distribution.h
index 99abe05..8bcb60e 100644
--- a/absl/random/log_uniform_int_distribution.h
+++ b/absl/random/log_uniform_int_distribution.h
@@ -234,26 +234,22 @@
   using param_type = typename log_uniform_int_distribution<IntType>::param_type;
   using result_type =
       typename log_uniform_int_distribution<IntType>::result_type;
-  using stream_type =
-      typename random_internal::stream_format_type<IntType>::type;
-
-  stream_type min;
-  stream_type max;
-  stream_type base;
 
   auto saver = random_internal::make_istream_state_saver(is);
-  is >> min >> max >> base;
-  if (!is.fail()) {
-    const result_type min_val = static_cast<result_type>(min);
-    const result_type max_val = static_cast<result_type>(max);
-    const result_type base_val = static_cast<result_type>(base);
-    if (max_val < min_val || base_val <= 1) {
-      // The input violates the param_type preconditions; signal failure by
-      // setting the failbit instead of constructing an invalid param_type.
-      is.setstate(is.rdstate() | std::ios_base::failbit);
-    } else {
-      x.param(param_type(min_val, max_val, base_val));
-    }
+  result_type min_val = 0;
+  result_type max_val = 0;
+  result_type base_val = 0;
+  if (!random_internal::read_integral(is, min_val) ||
+      !random_internal::read_integral(is, max_val) ||
+      !random_internal::read_integral(is, base_val)) {
+    return is;
+  }
+  if (max_val < min_val || base_val <= 1) {
+    // The input violates the param_type preconditions; signal failure by
+    // setting the failbit instead of constructing an invalid param_type.
+    is.setstate(std::ios_base::failbit);
+  } else {
+    x.param(param_type(min_val, max_val, base_val));
   }
   return is;
 }
diff --git a/absl/random/log_uniform_int_distribution_test.cc b/absl/random/log_uniform_int_distribution_test.cc
index 4404111..403aaea 100644
--- a/absl/random/log_uniform_int_distribution_test.cc
+++ b/absl/random/log_uniform_int_distribution_test.cc
@@ -298,4 +298,123 @@
   }
 }
 
+MATCHER(FailsLeavingUnchanged,
+        "fails stream extraction and leaves target and stream flags "
+        "unchanged") {
+  return arg.failed && arg.flags_preserved && arg.value == arg.initial;
+}
+
+MATCHER_P(ParsesEqualTo, expected,
+          "succeeds, updates target, and preserves stream flags") {
+  return !arg.failed && arg.flags_preserved && arg.value == expected;
+}
+
+TEST(LogUniformIntDistributionTest, StreamRejectsInvalidParameters) {
+  using absl::random_internal::ParseFromStream;
+  const absl::log_uniform_int_distribution<int8_t> kI8Initial(3, 6, 17);
+  const absl::log_uniform_int_distribution<uint8_t> kU8Initial(3, 6, 17);
+
+  EXPECT_THAT(
+      ParseFromStream(kI8Initial, "-128 127 2"),
+      ParsesEqualTo(absl::log_uniform_int_distribution<int8_t>(-128, 127, 2)));
+  EXPECT_THAT(
+      ParseFromStream(kU8Initial, "0 255 2"),
+      ParsesEqualTo(absl::log_uniform_int_distribution<uint8_t>(0, 255, 2)));
+
+  EXPECT_THAT(ParseFromStream(kI8Initial, "-254 10 2"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kI8Initial, "-129 10 2"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kI8Initial, "0 128 2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kI8Initial, "0 10 128"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kI8Initial, "0 10 258"), FailsLeavingUnchanged());
+
+  EXPECT_THAT(ParseFromStream(kU8Initial, "0 256 2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kU8Initial, "0 300 2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kU8Initial, "0 10 256"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kU8Initial, "0 10 258"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kU8Initial, "-5 10 2"), FailsLeavingUnchanged());
+}
+
+template <typename IntType>
+class LogUniformIntDistributionUnsignedTypeTest : public ::testing::Test {};
+
+using UnsignedIntTypes =
+    ::testing::Types<uint8_t, uint16_t, uint32_t, uint64_t>;
+TYPED_TEST_SUITE(LogUniformIntDistributionUnsignedTypeTest, UnsignedIntTypes);
+
+TYPED_TEST(LogUniformIntDistributionUnsignedTypeTest,
+           StreamDeserializationValidation) {
+  using absl::random_internal::ParseFromStream;
+  using Dist = absl::log_uniform_int_distribution<TypeParam>;
+  const Dist kInitial(3, 6, 17);
+
+  EXPECT_THAT(ParseFromStream(kInitial, "0 10 2"),
+              ParsesEqualTo(Dist(0, 10, 2)));
+  EXPECT_THAT(ParseFromStream(kInitial, "  0  10  2"),
+              ParsesEqualTo(Dist(0, 10, 2)));
+  EXPECT_THAT(ParseFromStream(kInitial, "+0 +10 +2"),
+              ParsesEqualTo(Dist(0, 10, 2)));
+  EXPECT_THAT(ParseFromStream(kInitial, "  +5  +20  +3"),
+              ParsesEqualTo(Dist(5, 20, 3)));
+  EXPECT_THAT(ParseFromStream(kInitial, L"  0 10 2"),
+              ParsesEqualTo(Dist(0, 10, 2)));
+
+  EXPECT_THAT(ParseFromStream(kInitial, "0 100 1"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "0 100 0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "100 0 2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-5 10 2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-5 -1 2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "0 -5 2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "0 -1 2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "0 10 -2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-0 10 2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "0 -0 2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "  -5 10 2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "\t\n-5 10 2"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "0   -5 2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "0 10   -2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, L"-5 10 2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, L"  0 -5 2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, L"0 10 -2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, ""), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "   "), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "0 10"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "0 10   "), FailsLeavingUnchanged());
+}
+
+template <typename IntType>
+class LogUniformIntDistributionSignedTypeTest : public ::testing::Test {};
+
+using SignedIntTypes = ::testing::Types<int8_t, int16_t, int32_t, int64_t>;
+TYPED_TEST_SUITE(LogUniformIntDistributionSignedTypeTest, SignedIntTypes);
+
+TYPED_TEST(LogUniformIntDistributionSignedTypeTest,
+           StreamDeserializationValidation) {
+  using absl::random_internal::ParseFromStream;
+  using Dist = absl::log_uniform_int_distribution<TypeParam>;
+  const Dist kInitial(3, 6, 17);
+
+  EXPECT_THAT(ParseFromStream(kInitial, "-10 -2 2"),
+              ParsesEqualTo(Dist(-10, -2, 2)));
+  EXPECT_THAT(ParseFromStream(kInitial, "  -10  -2  2"),
+              ParsesEqualTo(Dist(-10, -2, 2)));
+  EXPECT_THAT(ParseFromStream(kInitial, "-10 10 3"),
+              ParsesEqualTo(Dist(-10, 10, 3)));
+  EXPECT_THAT(ParseFromStream(kInitial, L"-10 -2 2"),
+              ParsesEqualTo(Dist(-10, -2, 2)));
+
+  EXPECT_THAT(ParseFromStream(kInitial, "0 100 1"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "0 100 0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "100 0 2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-2 -10 2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-10 -2 -2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-10 -2 1"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, ""), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "0 10"), FailsLeavingUnchanged());
+}
+
 }  // namespace
diff --git a/absl/random/poisson_distribution.h b/absl/random/poisson_distribution.h
index ae2e095..16ab7ab 100644
--- a/absl/random/poisson_distribution.h
+++ b/absl/random/poisson_distribution.h
@@ -18,6 +18,7 @@
 #include <cassert>
 #include <cmath>
 #include <cstdint>
+#include <ios>
 #include <istream>
 #include <limits>
 #include <ostream>
@@ -31,6 +32,12 @@
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+
+// Maximum supported mean for absl::poisson_distribution::param_type.
+inline constexpr double kPoissonMaxMean = 1e10;
+
+}  // namespace random_internal
 
 // absl::poisson_distribution:
 // Generates discrete variates conforming to a Poisson distribution.
@@ -140,7 +147,7 @@
   // As a defensive measure, avoid large values of the mean.  The rejection
   // algorithm used does not support very large values well.  It my be worth
   // changing algorithms to better deal with these cases.
-  assert(mean <= 1e10);
+  assert(mean <= random_internal::kPoissonMaxMean);
   if (mean_ < 10) {
     // For small lambda, use the knuth method.
     split_ = 1;
@@ -247,11 +254,19 @@
     std::basic_istream<CharT, Traits>& is,  // NOLINT(runtime/references)
     poisson_distribution<IntType>& x) {     // NOLINT(runtime/references)
   using param_type = typename poisson_distribution<IntType>::param_type;
+  using result_type = typename poisson_distribution<IntType>::result_type;
 
   auto saver = random_internal::make_istream_state_saver(is);
-  double mean = random_internal::read_floating_point<double>(is);
+  const double mean = random_internal::read_floating_point<double>(is);
   if (!is.fail()) {
-    x.param(param_type(mean));
+    constexpr double kMaxMean =
+        static_cast<double>((std::numeric_limits<result_type>::max)());
+    if (mean >= 0.0 && mean <= kMaxMean &&
+        mean <= random_internal::kPoissonMaxMean) {
+      x.param(param_type(mean));
+    } else {
+      is.setstate(std::ios_base::failbit);
+    }
   }
   return is;
 }
diff --git a/absl/random/poisson_distribution_test.cc b/absl/random/poisson_distribution_test.cc
index e8ee364..4bdcf72 100644
--- a/absl/random/poisson_distribution_test.cc
+++ b/absl/random/poisson_distribution_test.cc
@@ -568,4 +568,59 @@
   EXPECT_EQ(121, dist(urbg));
 }
 
+MATCHER(FailsLeavingUnchanged,
+        "fails stream extraction and leaves target and stream flags "
+        "unchanged") {
+  return arg.failed && arg.flags_preserved && arg.value == arg.initial;
+}
+
+MATCHER_P(ParsesEqualTo, expected,
+          "succeeds, updates target, and preserves stream flags") {
+  return !arg.failed && arg.flags_preserved && arg.value == expected;
+}
+
+TEST(PoissonDistributionTest, StreamRejectsInvalidParameters) {
+  using absl::random_internal::ParseFromStream;
+  const absl::poisson_distribution<int32_t> kInitial(4.5);
+  const absl::poisson_distribution<int8_t> kI8Initial(4.5);
+  const absl::poisson_distribution<uint8_t> kU8Initial(4.5);
+  const absl::poisson_distribution<int64_t> kI64Initial(4.5);
+
+  EXPECT_THAT(ParseFromStream(kInitial, ""), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "abc"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-1.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "nan"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "inf"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-inf"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "nan", /*use_non_finite_facet=*/true),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "inf", /*use_non_finite_facet=*/true),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-inf", /*use_non_finite_facet=*/true),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "1e20"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "1e400"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "0.0"),
+              ParsesEqualTo(absl::poisson_distribution<int32_t>(0.0)));
+  EXPECT_THAT(ParseFromStream(kInitial, "1e-320"),
+              ParsesEqualTo(absl::poisson_distribution<int32_t>(1e-320)));
+
+  EXPECT_THAT(ParseFromStream(kI8Initial, "128.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kI8Initial, "200.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kI8Initial, "127.0"),
+              ParsesEqualTo(absl::poisson_distribution<int8_t>(127.0)));
+
+  EXPECT_THAT(ParseFromStream(kU8Initial, "256.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kU8Initial, "300.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kU8Initial, "255.0"),
+              ParsesEqualTo(absl::poisson_distribution<uint8_t>(255.0)));
+
+  constexpr double kMaxMean = absl::random_internal::kPoissonMaxMean;
+  EXPECT_THAT(ParseFromStream(kI64Initial, absl::StrCat(kMaxMean)),
+              ParsesEqualTo(absl::poisson_distribution<int64_t>(kMaxMean)));
+  EXPECT_THAT(ParseFromStream(kI64Initial, absl::StrCat(kMaxMean * 10.0)),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kI64Initial, "1e20"), FailsLeavingUnchanged());
+}
+
 }  // namespace
diff --git a/absl/random/uniform_int_distribution.h b/absl/random/uniform_int_distribution.h
index 0dc7c62..f5c884f 100644
--- a/absl/random/uniform_int_distribution.h
+++ b/absl/random/uniform_int_distribution.h
@@ -29,6 +29,7 @@
 #define ABSL_RANDOM_UNIFORM_INT_DISTRIBUTION_H_
 
 #include <cassert>
+#include <ios>
 #include <istream>
 #include <limits>
 #include <ostream>
@@ -176,17 +177,18 @@
     uniform_int_distribution<IntType>& x) {
   using param_type = typename uniform_int_distribution<IntType>::param_type;
   using result_type = typename uniform_int_distribution<IntType>::result_type;
-  using stream_type =
-      typename random_internal::stream_format_type<IntType>::type;
-
-  stream_type a;
-  stream_type b;
 
   auto saver = random_internal::make_istream_state_saver(is);
-  is >> a >> b;
-  if (!is.fail()) {
-    x.param(
-        param_type(static_cast<result_type>(a), static_cast<result_type>(b)));
+  result_type a = 0;
+  result_type b = 0;
+  if (!random_internal::read_integral(is, a) ||
+      !random_internal::read_integral(is, b)) {
+    return is;
+  }
+  if (a <= b) {
+    x.param(param_type(a, b));
+  } else {
+    is.setstate(std::ios_base::failbit);
   }
   return is;
 }
diff --git a/absl/random/uniform_int_distribution_test.cc b/absl/random/uniform_int_distribution_test.cc
index b055833..4150c64 100644
--- a/absl/random/uniform_int_distribution_test.cc
+++ b/absl/random/uniform_int_distribution_test.cc
@@ -258,4 +258,56 @@
                                            3813, 9195, 6641, 2986, 7956, 3765));
 }
 
+MATCHER(FailsLeavingUnchanged,
+        "fails stream extraction and leaves target and stream flags "
+        "unchanged") {
+  return arg.failed && arg.flags_preserved && arg.value == arg.initial;
+}
+
+MATCHER_P(ParsesEqualTo, expected,
+          "succeeds, updates target, and preserves stream flags") {
+  return !arg.failed && arg.flags_preserved && arg.value == expected;
+}
+
+TEST(UniformIntDistributionTest, StreamRejectsInvalidParameters) {
+  using absl::random_internal::ParseFromStream;
+  const absl::uniform_int_distribution<int> kIntInitial(1, 5);
+  const absl::uniform_int_distribution<int8_t> kI8Initial(1, 5);
+  const absl::uniform_int_distribution<uint8_t> kU8Initial(1, 5);
+  const absl::uniform_int_distribution<uint16_t> kU16Initial(1, 5);
+  const absl::uniform_int_distribution<uint32_t> kU32Initial(1, 5);
+  const absl::uniform_int_distribution<uint64_t> kU64Initial(1, 5);
+
+  EXPECT_THAT(ParseFromStream(kIntInitial, "10 2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kIntInitial, ""), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kIntInitial, "1"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kIntInitial, "abc 5"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kIntInitial, "1 abc"), FailsLeavingUnchanged());
+
+  EXPECT_THAT(ParseFromStream(kI8Initial, "-254 10"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kI8Initial, "10 200"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kI8Initial, "-129 0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kI8Initial, "0 128"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kI8Initial, "-128 127"),
+              ParsesEqualTo(absl::uniform_int_distribution<int8_t>(-128, 127)));
+
+  EXPECT_THAT(ParseFromStream(kU8Initial, "300 310"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kU8Initial, "10 300"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kU8Initial, "-1 5"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kU8Initial, "-0 5"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kU8Initial, "0 255"),
+              ParsesEqualTo(absl::uniform_int_distribution<uint8_t>(0, 255)));
+
+  EXPECT_THAT(ParseFromStream(kU16Initial, "-10 -2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kU32Initial, "-10 -2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kU32Initial, "-1 5"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kU32Initial, "1 -2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kU32Initial, "-0 5"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kU64Initial, "-10 -2"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kU64Initial, "0 99999999999999999999999"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kU32Initial, "10 20"),
+              ParsesEqualTo(absl::uniform_int_distribution<uint32_t>(10, 20)));
+}
+
 }  // namespace
diff --git a/absl/random/uniform_real_distribution.h b/absl/random/uniform_real_distribution.h
index 79cf793..9ffb9c3 100644
--- a/absl/random/uniform_real_distribution.h
+++ b/absl/random/uniform_real_distribution.h
@@ -35,6 +35,7 @@
 #include <cassert>
 #include <cmath>
 #include <cstdint>
+#include <ios>
 #include <istream>
 #include <limits>
 #include <ostream>
@@ -194,7 +195,13 @@
   if (is.fail()) return is;
   auto b = random_internal::read_floating_point<result_type>(is);
   if (!is.fail()) {
-    x.param(param_type(a, b));
+    if (std::isfinite(a) && std::isfinite(b) && a <= b &&
+        static_cast<result_type>(b - a) <=
+            (std::numeric_limits<result_type>::max)()) {
+      x.param(param_type(a, b));
+    } else {
+      is.setstate(std::ios_base::failbit);
+    }
   }
   return is;
 }
diff --git a/absl/random/uniform_real_distribution_test.cc b/absl/random/uniform_real_distribution_test.cc
index 11e1d65..f42d1a5 100644
--- a/absl/random/uniform_real_distribution_test.cc
+++ b/absl/random/uniform_real_distribution_test.cc
@@ -393,4 +393,79 @@
   }
 }
 
+MATCHER(FailsLeavingUnchanged,
+        "fails stream extraction and leaves target and stream flags "
+        "unchanged") {
+  return arg.failed && arg.flags_preserved && arg.value == arg.initial;
+}
+
+MATCHER_P(ParsesEqualTo, expected,
+          "succeeds, updates target, and preserves stream flags") {
+  return !arg.failed && arg.flags_preserved && arg.value == expected;
+}
+
+TEST(UniformRealDistributionTest, StreamRejectsInvalidParameters) {
+  using absl::random_internal::ParseFromStream;
+  const absl::uniform_real_distribution<double> kInitial(1.0, 2.0);
+  const absl::uniform_real_distribution<float> kFloatInitial(1.0f, 2.0f);
+
+  // Valid streams including degenerate [a, a] and subnormal bounds.
+  EXPECT_THAT(ParseFromStream(kInitial, "0.0 1.0"),
+              ParsesEqualTo(absl::uniform_real_distribution<double>(0.0, 1.0)));
+  EXPECT_THAT(ParseFromStream(kInitial, "1.5 1.5"),
+              ParsesEqualTo(absl::uniform_real_distribution<double>(1.5, 1.5)));
+  EXPECT_THAT(
+      ParseFromStream(kInitial, "-1.0 1e-320"),
+      ParsesEqualTo(absl::uniform_real_distribution<double>(-1.0, 1e-320)));
+
+  // Truncated, inverted, overflowing-span, and non-finite inputs.
+  EXPECT_THAT(ParseFromStream(kInitial, ""), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "1.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "10.0 1.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "nan 1.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "0.0 nan"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "0.0 inf"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-inf 0.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "inf inf"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-inf -inf"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kInitial, "-1e308 1e308"),
+              FailsLeavingUnchanged());
+
+  // Non-finite values delivered with goodbit by a custom num_get facet.
+  EXPECT_THAT(
+      ParseFromStream(kInitial, "nan 1.0", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kInitial, "0.0 nan", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kInitial, "0.0 inf", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kInitial, "-inf 0.0", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kInitial, "inf inf", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kInitial, "-inf -inf", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kFloatInitial, "nan 1.0", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+  EXPECT_THAT(
+      ParseFromStream(kFloatInitial, "0.0 inf", /*use_non_finite_facet=*/true),
+      FailsLeavingUnchanged());
+
+  // A boundary interval whose IEEE-754 double difference rounds to DBL_MAX
+  // (b - a == DBL_MAX in double, though larger under x87 80-bit excess
+  // precision) round-trips cleanly without false rejection.
+  const double a = -std::ldexp(1.0, 969);
+  const double b = (std::numeric_limits<double>::max)();
+  const absl::uniform_real_distribution<double> kMaxSpan(a, b);
+  std::ostringstream oss;
+  oss << kMaxSpan;
+  EXPECT_THAT(ParseFromStream(kInitial, oss.str()), ParsesEqualTo(kMaxSpan));
+}
+
 }  // namespace
diff --git a/absl/random/zipf_distribution.h b/absl/random/zipf_distribution.h
index 21e3b70..50d9410 100644
--- a/absl/random/zipf_distribution.h
+++ b/absl/random/zipf_distribution.h
@@ -17,6 +17,7 @@
 
 #include <cassert>
 #include <cmath>
+#include <ios>
 #include <istream>
 #include <limits>
 #include <ostream>
@@ -253,16 +254,27 @@
     zipf_distribution<IntType>& x) {        // NOLINT(runtime/references)
   using result_type = typename zipf_distribution<IntType>::result_type;
   using param_type = typename zipf_distribution<IntType>::param_type;
-  using stream_type =
-      typename random_internal::stream_format_type<IntType>::type;
-  stream_type k;
-  double q;
-  double v;
 
   auto saver = random_internal::make_istream_state_saver(is);
-  is >> k >> q >> v;
-  if (!is.fail()) {
-    x.param(param_type(static_cast<result_type>(k), q, v));
+  result_type k = 0;
+  if (!random_internal::read_integral(is, k)) {
+    return is;
+  }
+  const double q = random_internal::read_floating_point<double>(is);
+  if (is.fail()) return is;
+  const double v = random_internal::read_floating_point<double>(is);
+  if (is.fail()) return is;
+
+  if constexpr (std::numeric_limits<result_type>::is_signed) {
+    if (k < result_type{0}) {
+      is.setstate(std::ios_base::failbit);
+      return is;
+    }
+  }
+  if (std::isfinite(q) && q > 1.0 && std::isfinite(v) && v > 0.0) {
+    x.param(param_type(k, q, v));
+  } else {
+    is.setstate(std::ios_base::failbit);
   }
   return is;
 }
diff --git a/absl/random/zipf_distribution_test.cc b/absl/random/zipf_distribution_test.cc
index f29aca5..fcdf110 100644
--- a/absl/random/zipf_distribution_test.cc
+++ b/absl/random/zipf_distribution_test.cc
@@ -31,6 +31,7 @@
 #include "gtest/gtest.h"
 #include "absl/log/log.h"
 #include "absl/random/internal/chi_square.h"
+#include "absl/random/internal/distribution_test_util.h"
 #include "absl/random/internal/pcg_engine.h"
 #include "absl/random/internal/sequence_urbg.h"
 #include "absl/random/random.h"
@@ -424,4 +425,108 @@
   }
 }
 
+MATCHER(FailsLeavingUnchanged,
+        "fails stream extraction and leaves target and stream flags "
+        "unchanged") {
+  return arg.failed && arg.flags_preserved && arg.value == arg.initial;
+}
+
+MATCHER_P(ParsesEqualTo, expected,
+          "succeeds, updates target, and preserves stream flags") {
+  return !arg.failed && arg.flags_preserved && arg.value == expected;
+}
+
+TEST(ZipfDistributionTest, StreamRejectsInvalidParameters) {
+  using absl::random_internal::ParseFromStream;
+  const absl::zipf_distribution<int> kIntSentinel(42, 3.0, 2.0);
+  const absl::zipf_distribution<int8_t> kI8Sentinel(42, 3.0, 2.0);
+  const absl::zipf_distribution<uint8_t> kU8Sentinel(42, 3.0, 2.0);
+  const absl::zipf_distribution<uint32_t> kU32Sentinel(42, 3.0, 2.0);
+
+  // Valid boundary values for 8-bit integer types and subnormal v.
+  EXPECT_THAT(ParseFromStream(kI8Sentinel, "0 2.0 1.0"),
+              ParsesEqualTo(absl::zipf_distribution<int8_t>(0, 2.0, 1.0)));
+  EXPECT_THAT(ParseFromStream(kI8Sentinel, "127 2.0 1.0"),
+              ParsesEqualTo(absl::zipf_distribution<int8_t>(127, 2.0, 1.0)));
+  EXPECT_THAT(ParseFromStream(kU8Sentinel, "255 2.0 1.0"),
+              ParsesEqualTo(absl::zipf_distribution<uint8_t>(255, 2.0, 1.0)));
+  EXPECT_THAT(ParseFromStream(kIntSentinel, "10 2.5 1e-320"),
+              ParsesEqualTo(absl::zipf_distribution<int>(10, 2.5, 1e-320)));
+
+  // Out-of-range, negative, or overflowing k.
+  EXPECT_THAT(ParseFromStream(kIntSentinel, "-5 2.0 1.0"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kI8Sentinel, "-5 2.0 1.0"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kU8Sentinel, "-5 2.0 1.0"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kU32Sentinel, "-5 2.0 1.0"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kU8Sentinel, "-0 2.0 1.0"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kU32Sentinel, "-0 2.0 1.0"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kI8Sentinel, "128 2.0 1.0"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kI8Sentinel, "300 2.0 1.0"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kU8Sentinel, "300 2.0 1.0"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kU32Sentinel, "5000000000 2.0 1.0"),
+              FailsLeavingUnchanged());
+
+  // Invalid q (must be finite and > 1.0).
+  EXPECT_THAT(ParseFromStream(kIntSentinel, "10 1.0 1.0"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kIntSentinel, "10 0.5 1.0"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kIntSentinel, "10 -2.0 1.0"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kIntSentinel, "10 nan 1.0"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kIntSentinel, "10 inf 1.0"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kIntSentinel, "10 -inf 1.0"),
+              FailsLeavingUnchanged());
+
+  // Invalid v (must be finite and > 0.0).
+  EXPECT_THAT(ParseFromStream(kIntSentinel, "10 2.0 0.0"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kIntSentinel, "10 2.0 -1.0"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kIntSentinel, "10 2.0 nan"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kIntSentinel, "10 2.0 inf"),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kIntSentinel, "10 2.0 -inf"),
+              FailsLeavingUnchanged());
+
+  // Non-finite q and v delivered with goodbit by a custom num_get facet.
+  EXPECT_THAT(ParseFromStream(kIntSentinel, "10 nan 1.0",
+                              /*use_non_finite_facet=*/true),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kIntSentinel, "10 inf 1.0",
+                              /*use_non_finite_facet=*/true),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kIntSentinel, "10 -inf 1.0",
+                              /*use_non_finite_facet=*/true),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kIntSentinel, "10 2.0 nan",
+                              /*use_non_finite_facet=*/true),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kIntSentinel, "10 2.0 inf",
+                              /*use_non_finite_facet=*/true),
+              FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kIntSentinel, "10 2.0 -inf",
+                              /*use_non_finite_facet=*/true),
+              FailsLeavingUnchanged());
+
+  // Truncated and malformed streams.
+  EXPECT_THAT(ParseFromStream(kIntSentinel, ""), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kIntSentinel, "10"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kIntSentinel, "10 2.0"), FailsLeavingUnchanged());
+  EXPECT_THAT(ParseFromStream(kIntSentinel, "abc 2.0 1.0"),
+              FailsLeavingUnchanged());
+}
+
 }  // namespace