Make SimpleRandom faster by using Chacha20 as underlying primitive.

This does alter the output of the RNG, but that's a one-time cost, and one SHA-1 call per byte is highly suboptimal for anything but very short unit tests.

gfe-relnote: n/a (test-only change)
PiperOrigin-RevId: 245501012
Change-Id: I16d9f5b174ef65cfb4ece3ef0699bf1b29b81de5

quic/test_tools/quic_test_utils.cc

diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index cacb28a..52634b7 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -5,8 +5,10 @@
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
 
 #include <algorithm>
+#include <cstdint>
 #include <memory>
 
+#include "third_party/boringssl/src/include/openssl/chacha.h"
 #include "third_party/boringssl/src/include/openssl/sha.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_framer.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake.h"
@@ -152,20 +154,42 @@
 }
 
 uint64_t SimpleRandom::RandUint64() {
-  std::string hash =
-      Sha1Hash(QuicStringPiece(reinterpret_cast<char*>(&seed_), sizeof(seed_)));
-  DCHECK_EQ(static_cast<size_t>(SHA_DIGEST_LENGTH), hash.length());
-  memcpy(&seed_, hash.data(), sizeof(seed_));
-  return seed_;
+  uint64_t result;
+  RandBytes(&result, sizeof(result));
+  return result;
 }
 
 void SimpleRandom::RandBytes(void* data, size_t len) {
-  uint8_t* real_data = static_cast<uint8_t*>(data);
-  for (size_t offset = 0; offset < len; offset++) {
-    real_data[offset] = RandUint64() & 0xff;
+  uint8_t* data_bytes = reinterpret_cast<uint8_t*>(data);
+  while (len > 0) {
+    const size_t buffer_left = sizeof(buffer_) - buffer_offset_;
+    const size_t to_copy = std::min(buffer_left, len);
+    memcpy(data_bytes, buffer_ + buffer_offset_, to_copy);
+    data_bytes += to_copy;
+    buffer_offset_ += to_copy;
+    len -= to_copy;
+
+    if (buffer_offset_ == sizeof(buffer_)) {
+      FillBuffer();
+    }
   }
 }
 
+void SimpleRandom::FillBuffer() {
+  uint8_t nonce[12];
+  memcpy(nonce, buffer_, sizeof(nonce));
+  CRYPTO_chacha_20(buffer_, buffer_, sizeof(buffer_), key_, nonce, 0);
+  buffer_offset_ = 0;
+}
+
+void SimpleRandom::set_seed(uint64_t seed) {
+  static_assert(sizeof(key_) == SHA256_DIGEST_LENGTH, "Key has to be 256 bits");
+  SHA256(reinterpret_cast<const uint8_t*>(&seed), sizeof(seed), key_);
+
+  memset(buffer_, 0, sizeof(buffer_));
+  FillBuffer();
+}
+
 MockFramerVisitor::MockFramerVisitor() {
   // By default, we want to accept packets.
   ON_CALL(*this, OnProtocolVersionMismatch(_, _))

quic/test_tools/quic_test_utils.h

diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index 57831ab..c9db3e5 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -213,12 +213,10 @@
 std::string Sha1Hash(QuicStringPiece data);
 
 // Simple random number generator used to compute random numbers suitable
-// for pseudo-randomly dropping packets in tests.  It works by computing
-// the sha1 hash of the current seed, and using the first 64 bits as
-// the next random number, and the next seed.
+// for pseudo-randomly dropping packets in tests.
 class SimpleRandom : public QuicRandom {
  public:
-  SimpleRandom() : seed_(0) {}
+  SimpleRandom() { set_seed(0); }
   SimpleRandom(const SimpleRandom&) = delete;
   SimpleRandom& operator=(const SimpleRandom&) = delete;
   ~SimpleRandom() override {}
@@ -228,10 +226,14 @@
 
   void RandBytes(void* data, size_t len) override;
 
-  void set_seed(uint64_t seed) { seed_ = seed; }
+  void set_seed(uint64_t seed);
 
  private:
-  uint64_t seed_;
+  uint8_t buffer_[4096];
+  size_t buffer_offset_;
+  uint8_t key_[32];
+
+  void FillBuffer();
 };
 
 class MockFramerVisitor : public QuicFramerVisitorInterface {

quic/test_tools/quic_test_utils_test.cc

diff --git a/quic/test_tools/quic_test_utils_test.cc b/quic/test_tools/quic_test_utils_test.cc
index aeccc70..8c30335 100644
--- a/quic/test_tools/quic_test_utils_test.cc
+++ b/quic/test_tools/quic_test_utils_test.cc
@@ -52,8 +52,27 @@
 TEST_F(QuicTestUtilsTest, SimpleRandomStability) {
   SimpleRandom rng;
   rng.set_seed(UINT64_C(0x1234567800010001));
-  EXPECT_EQ(UINT64_C(14865409841904857791), rng.RandUint64());
-  EXPECT_EQ(UINT64_C(12139094019410129741), rng.RandUint64());
+  EXPECT_EQ(UINT64_C(12589383305231984671), rng.RandUint64());
+  EXPECT_EQ(UINT64_C(17775425089941798664), rng.RandUint64());
+}
+
+// Ensure that the output of SimpleRandom does not depend on the size of the
+// read calls.
+TEST_F(QuicTestUtilsTest, SimpleRandomChunks) {
+  SimpleRandom rng;
+  std::string reference(16 * 1024, '\0');
+  rng.RandBytes(&reference[0], reference.size());
+
+  for (size_t chunk_size : {3, 4, 7, 4096}) {
+    rng.set_seed(0);
+    size_t chunks = reference.size() / chunk_size;
+    std::string buffer(chunks * chunk_size, '\0');
+    for (size_t i = 0; i < chunks; i++) {
+      rng.RandBytes(&buffer[i * chunk_size], chunk_size);
+    }
+    EXPECT_EQ(reference.substr(0, buffer.size()), buffer)
+        << "Failed for chunk_size = " << chunk_size;
+  }
 }
 
 }  // namespace test