Pool 64 bits of entropy instead of calling OpenSSL's RNG for one bit

net/quic/quic_packet_creator.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/quic_packet_creator.h"
 
 #include "base/logging.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/quic_ack_notifier.h"
 #include "net/quic/quic_fec_group.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 using std::make_pair;
 using std::max;
 using std::min;
 using std::pair;
 using std::vector;
 
 // If true, then QUIC handshake packets will be padded to the maximium packet
 // size.
 bool FLAGS_pad_quic_handshake_packets = true;
 
 namespace net {
 
+// A QuicRandom wrapper that gets a bucket of entropy and distributes it
+// bit-by-bit. Replenishes the bucket as needed. Not thread-safe. Expose this
+// class if single bit randomness is needed elsewhere.
+class QuicRandomBoolSource {
+ public:
+  // random: Source of entropy. Not owned.
+  explicit QuicRandomBoolSource(QuicRandom* random)
+      : random_(random),
+        bit_bucket_(0),
+        bit_mask_(0) {}
+
+  ~QuicRandomBoolSource() {}
+
+  // Returns the next random bit from the bucket.
+  bool RandBool() {
+    if (bit_mask_ == 0) {
+      bit_bucket_ = random_->RandUint64();
+      bit_mask_ = 1;
+    }
+    bool result = ((bit_bucket_ & bit_mask_) != 0);
+    bit_mask_ <<= 1;
+    return result;
+  }
+
+ private:
+  // Source of entropy.
+  QuicRandom* random_;
+  // Stored random bits.
+  uint64 bit_bucket_;
+  // The next available bit has "1" in the mask. Zero means empty bucket.
+  uint64 bit_mask_;
+
+  DISALLOW_COPY_AND_ASSIGN(QuicRandomBoolSource);
+};
+
 QuicPacketCreator::QuicPacketCreator(QuicGuid guid,
                                      QuicFramer* framer,
                                      QuicRandom* random_generator,
                                      bool is_server)
     : guid_(guid),
       framer_(framer),
-      random_generator_(random_generator),
+      random_bool_source_(new QuicRandomBoolSource(random_generator)),
       sequence_number_(0),
       fec_group_number_(0),
       is_server_(is_server),
       send_version_in_packet_(!is_server),
       sequence_number_length_(options_.send_sequence_number_length),
       packet_size_(0) {
   framer_->set_fec_builder(this);
 }
 
 QuicPacketCreator::~QuicPacketCreator() {
@@ skipping 322 matching lines @@
                                          bool fec_entropy_flag,
                                          QuicPacketHeader* header) {
   header->public_header.guid = guid_;
   header->public_header.reset_flag = false;
   header->public_header.version_flag = send_version_in_packet_;
   header->fec_flag = fec_flag;
   header->packet_sequence_number = ++sequence_number_;
   header->public_header.sequence_number_length = sequence_number_length_;
 
   bool entropy_flag;
-  if (header->packet_sequence_number == 1) {
-    DCHECK(!fec_flag);
-    // TODO(satyamshekhar): No entropy in the first message.
-    // For crypto tests to pass. Fix this by using deterministic QuicRandom.
-    entropy_flag = 0;
-  } else if (fec_flag) {
+  if (fec_flag) {
     // FEC packets don't have an entropy of their own. Entropy flag for FEC
     // packets is the XOR of entropy of previous packets.
     entropy_flag = fec_entropy_flag;
   } else {
-    entropy_flag = random_generator_->RandBool();
+    entropy_flag = random_bool_source_->RandBool();
   }
   header->entropy_flag = entropy_flag;
   header->is_in_fec_group = fec_group == 0 ? NOT_IN_FEC_GROUP : IN_FEC_GROUP;
   header->fec_group = fec_group;
 }
 
 bool QuicPacketCreator::ShouldRetransmit(const QuicFrame& frame) {
   return frame.type != ACK_FRAME && frame.type != CONGESTION_FEEDBACK_FRAME &&
       frame.type != PADDING_FRAME;
 }
@@ skipping 50 matching lines @@
   if (!is_handshake) {
     return;
   }
 
   QuicPaddingFrame padding;
   bool success = AddFrame(QuicFrame(&padding), false);
   DCHECK(success);
 }
 
 }  // namespace net