SERVER-43641 upgrade random.h

This reverts commit a40b196.

Author: BillyDonahue

src/mongo/bson/oid.cpp

@@ -54,9 +54,9 @@ OID::InstanceUnique _instanceUnique;
 
 MONGO_INITIALIZER_GENERAL(OIDGeneration, MONGO_NO_PREREQUISITES, ("default"))
 (InitializerContext* context) {
-    std::unique_ptr<SecureRandom> entropy(SecureRandom::create());
-    counter = std::make_unique<AtomicWord<int64_t>>(entropy->nextInt64());
-    _instanceUnique = OID::InstanceUnique::generate(*entropy);
+    SecureRandom entropy;
+    counter = std::make_unique<AtomicWord<int64_t>>(entropy.nextInt64());
+    _instanceUnique = OID::InstanceUnique::generate(entropy);
     return Status::OK();
 }
 
@@ -72,9 +72,8 @@ OID::Increment OID::Increment::next() {
 }
 
 OID::InstanceUnique OID::InstanceUnique::generate(SecureRandom& entropy) {
-    int64_t rand = entropy.nextInt64();
     OID::InstanceUnique u;
-    std::memcpy(u.bytes, &rand, kInstanceUniqueSize);
+    entropy.fill(u.bytes, kInstanceUniqueSize);
     return u;
 }
 
@@ -119,8 +118,8 @@ size_t OID::Hasher::operator()(const OID& oid) const {
 }
 
 void OID::regenMachineId() {
-    std::unique_ptr<SecureRandom> entropy(SecureRandom::create());
-    _instanceUnique = InstanceUnique::generate(*entropy);
+    SecureRandom entropy;
+    _instanceUnique = InstanceUnique::generate(entropy);
 }
 
 unsigned OID::getMachineId() {

src/mongo/client/sasl_scram_client_conversation.cpp

@@ -82,14 +82,10 @@ StatusWith<bool> SaslSCRAMClientConversation::_firstStep(std::string* outputData
     }
 
     // Create text-based nonce as base64 encoding of a binary blob of length multiple of 3
-    const int nonceLenQWords = 3;
+    static constexpr size_t nonceLenQWords = 3;
     uint64_t binaryNonce[nonceLenQWords];
 
-    unique_ptr<SecureRandom> sr(SecureRandom::create());
-
-    binaryNonce[0] = sr->nextInt64();
-    binaryNonce[1] = sr->nextInt64();
-    binaryNonce[2] = sr->nextInt64();
+    SecureRandom().fill(binaryNonce, sizeof(binaryNonce));
 
     std::string user =
         _saslClientSession->getParameter(SaslClientSession::parameterUser).toString();

src/mongo/crypto/mechanism_scram.h

@@ -102,15 +102,9 @@ class Presecrets {
     }
 
     static std::vector<std::uint8_t> generateSecureRandomSalt() {
-        // Express salt length as a number of quad words, rounded up.
-        constexpr auto qwords = (saltLength() + sizeof(std::int64_t) - 1) / sizeof(std::int64_t);
-        std::array<std::int64_t, qwords> userSalt;
-
-        std::unique_ptr<SecureRandom> sr(SecureRandom::create());
-        std::generate(userSalt.begin(), userSalt.end(), [&sr] { return sr->nextInt64(); });
-        return std::vector<std::uint8_t>(reinterpret_cast<std::uint8_t*>(userSalt.data()),
-                                         reinterpret_cast<std::uint8_t*>(userSalt.data()) +
-                                             saltLength());
+        std::vector<std::uint8_t> salt(saltLength());
+        SecureRandom().fill(salt.data(), salt.size());
+        return salt;
     }
 
 private:

src/mongo/crypto/symmetric_crypto.cpp

@@ -48,12 +48,7 @@
 namespace mongo {
 namespace crypto {
 
-namespace {
-std::unique_ptr<SecureRandom> random;
-}  // namespace
-
 MONGO_INITIALIZER(CreateKeyEntropySource)(InitializerContext* context) {
-    random = std::unique_ptr<SecureRandom>(SecureRandom::create());
     return Status::OK();
 }
 
@@ -90,16 +85,8 @@ std::string getStringFromCipherMode(aesMode mode) {
 
 SymmetricKey aesGenerate(size_t keySize, SymmetricKeyId keyId) {
     invariant(keySize == sym256KeySize);
-
     SecureVector<uint8_t> key(keySize);
-
-    size_t offset = 0;
-    while (offset < keySize) {
-        std::uint64_t randomValue = random->nextInt64();
-        memcpy(key->data() + offset, &randomValue, sizeof(randomValue));
-        offset += sizeof(randomValue);
-    }
-
+    SecureRandom().fill(key->data(), key->size());
     return SymmetricKey(std::move(key), aesAlgorithm, std::move(keyId));
 }
 

src/mongo/db/auth/sasl_scram_server_conversation.cpp

@@ -235,11 +235,7 @@ StatusWith<std::tuple<bool, std::string>> SaslSCRAMServerMechanism<Policy>::_fir
     const int nonceLenQWords = 3;
     uint64_t binaryNonce[nonceLenQWords];
 
-    std::unique_ptr<SecureRandom> sr(SecureRandom::create());
-
-    binaryNonce[0] = sr->nextInt64();
-    binaryNonce[1] = sr->nextInt64();
-    binaryNonce[2] = sr->nextInt64();
+    SecureRandom().fill(binaryNonce, sizeof(binaryNonce));
 
     _nonce =
         clientNonce + base64::encode(reinterpret_cast<char*>(binaryNonce), sizeof(binaryNonce));

src/mongo/db/commands/authentication_commands.cpp

@@ -201,7 +201,7 @@ class CmdAuthenticate : public BasicCommand {
  */
 class CmdGetNonce : public BasicCommand {
 public:
-    CmdGetNonce() : BasicCommand("getnonce"), _random(SecureRandom::create()) {}
+    CmdGetNonce() : BasicCommand("getnonce") {}
 
     AllowedOnSecondary secondaryAllowed(ServiceContext*) const override {
         return AllowedOnSecondary::kAlways;
@@ -240,11 +240,11 @@ class CmdGetNonce : public BasicCommand {
 private:
     int64_t getNextNonce() {
         stdx::lock_guard<SimpleMutex> lk(_randMutex);
-        return _random->nextInt64();
+        return _random.nextInt64();
     }
 
     SimpleMutex _randMutex;  // Synchronizes accesses to _random.
-    std::unique_ptr<SecureRandom> _random;
+    SecureRandom _random;
 } cmdGetNonce;
 
 bool CmdAuthenticate::run(OperationContext* opCtx,

src/mongo/db/cursor_manager.cpp

@@ -100,7 +100,7 @@ std::pair<Status, int> CursorManager::killCursorsWithMatchingSessions(
 }
 
 CursorManager::CursorManager()
-    : _random(std::make_unique<PseudoRandom>(SecureRandom::create()->nextInt64())),
+    : _random(std::make_unique<PseudoRandom>(SecureRandom().nextInt64())),
       _cursorMap(std::make_unique<Partitioned<stdx::unordered_map<CursorId, ClientCursor*>>>()) {}
 
 CursorManager::~CursorManager() {

src/mongo/db/db.cpp

@@ -852,7 +852,7 @@ void setUpReplication(ServiceContext* serviceContext) {
         std::make_unique<repl::TopologyCoordinator>(topoCoordOptions),
         replicationProcess,
         storageInterface,
-        SecureRandom::create()->nextInt64());
+        SecureRandom().nextInt64());
     repl::ReplicationCoordinator::set(serviceContext, std::move(replCoord));
     repl::setOplogCollectionName(serviceContext);
 

src/mongo/db/free_mon/free_mon_controller_test.cpp

@@ -74,7 +74,7 @@ namespace mongo {
 namespace {
 
 auto makeRandom() {
-    auto seed = SecureRandom::create()->nextInt64();
+    auto seed = SecureRandom().nextInt64();
     unittest::log() << "PseudoRandom(" << std::showbase << std::hex << seed << std::dec
                     << std::noshowbase << ")";
     return PseudoRandom(seed);

src/mongo/db/repl/idempotency_test.cpp

@@ -165,7 +165,7 @@ void RandomizedIdempotencyTest::runIdempotencyTestCase() {
     const double kDocProbability = 0.375;
     const double kArrProbability = 0.0;
 
-    this->seed = SecureRandom::create()->nextInt64();
+    this->seed = SecureRandom().nextInt64();
     PseudoRandom seedGenerator(this->seed);
     RandomizedScalarGenerator scalarGenerator{PseudoRandom(seedGenerator.nextInt64())};
     UpdateSequenceGenerator updateGenerator(