Merge bitcoin#8914: Kill insecure_random and associated global state

laanwj · codablock · commit 239ce534c2a4 · 2018-01-12T09:58:14.000+01:00
5eaaa83 Kill insecure_random and associated global state (Wladimir J. van der Laan)
diff --git a/src/addrman.cpp b/src/addrman.cpp
@@ -358,8 +358,8 @@ CAddrInfo CAddrMan::Select_(bool newOnly)
             int nKBucket = RandomInt(ADDRMAN_TRIED_BUCKET_COUNT);
             int nKBucketPos = RandomInt(ADDRMAN_BUCKET_SIZE);
             while (vvTried[nKBucket][nKBucketPos] == -1) {
-                nKBucket = (nKBucket + insecure_rand()) % ADDRMAN_TRIED_BUCKET_COUNT;
-                nKBucketPos = (nKBucketPos + insecure_rand()) % ADDRMAN_BUCKET_SIZE;
+                nKBucket = (nKBucket + insecure_rand.rand32()) % ADDRMAN_TRIED_BUCKET_COUNT;
+                nKBucketPos = (nKBucketPos + insecure_rand.rand32()) % ADDRMAN_BUCKET_SIZE;
             }
             int nId = vvTried[nKBucket][nKBucketPos];
             assert(mapInfo.count(nId) == 1);
@@ -375,8 +375,8 @@ CAddrInfo CAddrMan::Select_(bool newOnly)
             int nUBucket = RandomInt(ADDRMAN_NEW_BUCKET_COUNT);
             int nUBucketPos = RandomInt(ADDRMAN_BUCKET_SIZE);
             while (vvNew[nUBucket][nUBucketPos] == -1) {
-                nUBucket = (nUBucket + insecure_rand()) % ADDRMAN_NEW_BUCKET_COUNT;
-                nUBucketPos = (nUBucketPos + insecure_rand()) % ADDRMAN_BUCKET_SIZE;
+                nUBucket = (nUBucket + insecure_rand.rand32()) % ADDRMAN_NEW_BUCKET_COUNT;
+                nUBucketPos = (nUBucketPos + insecure_rand.rand32()) % ADDRMAN_BUCKET_SIZE;
             }
             int nId = vvNew[nUBucket][nUBucketPos];
             assert(mapInfo.count(nId) == 1);
diff --git a/src/addrman.h b/src/addrman.h
@@ -211,6 +211,9 @@ class CAddrMan
     //! secret key to randomize bucket select with
     uint256 nKey;
 
+    //! Source of random numbers for randomization in inner loops
+    FastRandomContext insecure_rand;
+
     //! Find an entry.
     CAddrInfo* Find(const CNetAddr& addr, int *pnId = NULL);
 
diff --git a/src/init.cpp b/src/init.cpp
@@ -1163,9 +1163,6 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
 
     // ********************************************************* Step 4: application initialization: dir lock, daemonize, pidfile, debug log, seed insecure_rand()
 
-    // Initialize fast PRNG
-    seed_insecure_rand(false);
-
     // Initialize elliptic curve code
     ECC_Start();
     globalVerifyHandle.reset(new ECCVerifyHandle());
diff --git a/src/net.cpp b/src/net.cpp
@@ -194,7 +194,8 @@ void AdvertiseLocal(CNode *pnode)
         if (addrLocal.IsRoutable())
         {
             LogPrint("net", "AdvertiseLocal: advertising address %s\n", addrLocal.ToString());
-            pnode->PushAddress(addrLocal);
+            FastRandomContext insecure_rand;
+            pnode->PushAddress(addrLocal, insecure_rand);
         }
     }
 }
diff --git a/src/net.h b/src/net.h
@@ -867,14 +867,14 @@ class CNode
         addrKnown.insert(_addr.GetKey());
     }
 
-    void PushAddress(const CAddress& _addr)
+    void PushAddress(const CAddress& _addr, FastRandomContext &insecure_rand)
     {
         // Known checking here is only to save space from duplicates.
         // SendMessages will filter it again for knowns that were added
         // after addresses were pushed.
         if (_addr.IsValid() && !addrKnown.contains(_addr.GetKey())) {
             if (vAddrToSend.size() >= MAX_ADDR_TO_SEND) {
-                vAddrToSend[insecure_rand() % vAddrToSend.size()] = _addr;
+                vAddrToSend[insecure_rand.rand32() % vAddrToSend.size()] = _addr;
             } else {
                 vAddrToSend.push_back(_addr);
             }
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
@@ -820,6 +820,7 @@ static void RelayAddress(const CAddress& addr, bool fReachable, CConnman& connma
     uint64_t hashAddr = addr.GetHash();
     multimap<uint64_t, CNode*> mapMix;
     const CSipHasher hasher = connman.GetDeterministicRandomizer(RANDOMIZER_ID_ADDRESS_RELAY).Write(hashAddr << 32).Write((GetTime() + hashAddr) / (24*60*60));
+    FastRandomContext insecure_rand;
 
     auto sortfunc = [&mapMix, &hasher](CNode* pnode) {
         if (pnode->nVersion >= CADDR_TIME_VERSION) {
@@ -828,9 +829,9 @@ static void RelayAddress(const CAddress& addr, bool fReachable, CConnman& connma
         }
     };
 
-    auto pushfunc = [&addr, &mapMix, &nRelayNodes] {
+    auto pushfunc = [&addr, &mapMix, &nRelayNodes, &insecure_rand] {
         for (auto mi = mapMix.begin(); mi != mapMix.end() && nRelayNodes-- > 0; ++mi)
-            mi->second->PushAddress(addr);
+            mi->second->PushAddress(addr, insecure_rand);
     };
 
     connman.ForEachNodeThen(std::move(sortfunc), std::move(pushfunc));
@@ -1248,14 +1249,15 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,
             if (fListen && !IsInitialBlockDownload())
             {
                 CAddress addr = GetLocalAddress(&pfrom->addr, pfrom->GetLocalServices());
+                FastRandomContext insecure_rand;
                 if (addr.IsRoutable())
                 {
                     LogPrint("net", "ProcessMessages: advertising address %s\n", addr.ToString());
-                    pfrom->PushAddress(addr);
+                    pfrom->PushAddress(addr, insecure_rand);
                 } else if (IsPeerAddrLocalGood(pfrom)) {
                     addr.SetIP(pfrom->addrLocal);
                     LogPrint("net", "ProcessMessages: advertising address %s\n", addr.ToString());
-                    pfrom->PushAddress(addr);
+                    pfrom->PushAddress(addr, insecure_rand);
                 }
             }
 
@@ -2022,8 +2024,9 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,
 
         pfrom->vAddrToSend.clear();
         vector<CAddress> vAddr = connman.GetAddresses();
+        FastRandomContext insecure_rand;
         BOOST_FOREACH(const CAddress &addr, vAddr)
-            pfrom->PushAddress(addr);
+            pfrom->PushAddress(addr, insecure_rand);
     }
 
 
@@ -2935,7 +2938,7 @@ bool SendMessages(CNode* pto, CConnman& connman, std::atomic<bool>& interruptMsg
             // until scheduled broadcast, then move the broadcast to within MAX_FEEFILTER_CHANGE_DELAY.
             else if (timeNow + MAX_FEEFILTER_CHANGE_DELAY * 1000000 < pto->nextSendTimeFeeFilter &&
                      (currentFilter < 3 * pto->lastSentFeeFilter / 4 || currentFilter > 4 * pto->lastSentFeeFilter / 3)) {
-                pto->nextSendTimeFeeFilter = timeNow + (insecure_rand() % MAX_FEEFILTER_CHANGE_DELAY) * 1000000;
+                pto->nextSendTimeFeeFilter = timeNow + GetRandInt(MAX_FEEFILTER_CHANGE_DELAY) * 1000000;
             }
         }
     }
diff --git a/src/netbase.cpp b/src/netbase.cpp
@@ -592,8 +592,8 @@ static bool ConnectThroughProxy(const proxyType &proxy, const std::string& strDe
     // do socks negotiation
     if (proxy.randomize_credentials) {
         ProxyCredentials random_auth;
-        random_auth.username = strprintf("%i", insecure_rand());
-        random_auth.password = strprintf("%i", insecure_rand());
+        static std::atomic_int counter;
+        random_auth.username = random_auth.password = strprintf("%i", counter++);
         if (!Socks5(strDest, (unsigned short)port, &random_auth, hSocket))
             return false;
     } else {
diff --git a/src/policy/fees.cpp b/src/policy/fees.cpp
@@ -592,7 +592,7 @@ FeeFilterRounder::FeeFilterRounder(const CFeeRate& minIncrementalFee)
 CAmount FeeFilterRounder::round(CAmount currentMinFee)
 {
     std::set<double>::iterator it = feeset.lower_bound(currentMinFee);
-    if ((it != feeset.begin() && insecure_rand() % 3 != 0) || it == feeset.end()) {
+    if ((it != feeset.begin() && insecure_rand.rand32() % 3 != 0) || it == feeset.end()) {
         it--;
     }
     return *it;
diff --git a/src/policy/fees.h b/src/policy/fees.h
@@ -7,6 +7,7 @@
 
 #include "amount.h"
 #include "uint256.h"
+#include "random.h"
 
 #include <map>
 #include <string>
@@ -298,5 +299,6 @@ class FeeFilterRounder
 
 private:
     std::set<double> feeset;
+    FastRandomContext insecure_rand;
 };
 #endif /*BITCOIN_POLICYESTIMATOR_H */
diff --git a/src/random.cpp b/src/random.cpp
@@ -178,23 +178,21 @@ uint256 GetRandHash()
     return hash;
 }
 
-uint32_t insecure_rand_Rz = 11;
-uint32_t insecure_rand_Rw = 11;
-void seed_insecure_rand(bool fDeterministic)
+FastRandomContext::FastRandomContext(bool fDeterministic)
 {
     // The seed values have some unlikely fixed points which we avoid.
     if (fDeterministic) {
-        insecure_rand_Rz = insecure_rand_Rw = 11;
+        Rz = Rw = 11;
     } else {
         uint32_t tmp;
         do {
             GetRandBytes((unsigned char*)&tmp, 4);
         } while (tmp == 0 || tmp == 0x9068ffffU);
-        insecure_rand_Rz = tmp;
+        Rz = tmp;
         do {
             GetRandBytes((unsigned char*)&tmp, 4);
         } while (tmp == 0 || tmp == 0x464fffffU);
-        insecure_rand_Rw = tmp;
+        Rw = tmp;
     }
 }
 
diff --git a/src/random.h b/src/random.h
@@ -28,26 +28,23 @@ uint256 GetRandHash();
 void GetStrongRandBytes(unsigned char* buf, int num);
 
 /**
- * Seed insecure_rand using the random pool.
- * @param Deterministic Use a deterministic seed
+ * Fast randomness source. This is seeded once with secure random data, but
+ * is completely deterministic and insecure after that.
+ * This class is not thread-safe.
  */
-void seed_insecure_rand(bool fDeterministic = false);
+class FastRandomContext {
+public:
+    explicit FastRandomContext(bool fDeterministic=false);
 
-/**
- * MWC RNG of George Marsaglia
- * This is intended to be fast. It has a period of 2^59.3, though the
- * least significant 16 bits only have a period of about 2^30.1.
- *
- * @return random value
- */
-extern uint32_t insecure_rand_Rz;
-extern uint32_t insecure_rand_Rw;
-static inline uint32_t insecure_rand(void)
-{
-    insecure_rand_Rz = 36969 * (insecure_rand_Rz & 65535) + (insecure_rand_Rz >> 16);
-    insecure_rand_Rw = 18000 * (insecure_rand_Rw & 65535) + (insecure_rand_Rw >> 16);
-    return (insecure_rand_Rw << 16) + insecure_rand_Rz;
-}
+    uint32_t rand32() {
+        Rz = 36969 * (Rz & 65535) + (Rz >> 16);
+        Rw = 18000 * (Rw & 65535) + (Rw >> 16);
+        return (Rw << 16) + Rz;
+    }
+
+    uint32_t Rz;
+    uint32_t Rw;
+};
 
 /**
  * PRNG initialized from secure entropy based RNG
diff --git a/src/test/addrman_tests.cpp b/src/test/addrman_tests.cpp
@@ -26,7 +26,7 @@ class CAddrManTest : public CAddrMan
     void MakeDeterministic()
     {
         nKey.SetNull();
-        seed_insecure_rand(true);
+        insecure_rand = FastRandomContext(true);
     }
 
     int RandomInt(int nMax)
diff --git a/src/test/coins_tests.cpp b/src/test/coins_tests.cpp
@@ -3,7 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include "coins.h"
-#include "random.h"
+#include "test_random.h"
 #include "script/standard.h"
 #include "uint256.h"
 #include "undo.h"
diff --git a/src/test/crypto_tests.cpp b/src/test/crypto_tests.cpp
@@ -9,7 +9,7 @@
 #include "crypto/sha512.h"
 #include "crypto/hmac_sha256.h"
 #include "crypto/hmac_sha512.h"
-#include "random.h"
+#include "test_random.h"
 #include "utilstrencodings.h"
 #include "test/test_dash.h"
 
diff --git a/src/test/merkle_tests.cpp b/src/test/merkle_tests.cpp
@@ -4,7 +4,7 @@
 
 #include "consensus/merkle.h"
 #include "test/test_dash.h"
-#include "random.h"
+#include "test_random.h"
 
 #include <boost/test/unit_test.hpp>
 
diff --git a/src/test/net_tests.cpp b/src/test/net_tests.cpp
@@ -23,7 +23,7 @@ class CAddrManSerializationMock : public CAddrMan
     void MakeDeterministic()
     {
         nKey.SetNull();
-        seed_insecure_rand(true);
+        insecure_rand = FastRandomContext(true);
     }
 };
 
diff --git a/src/test/pmt_tests.cpp b/src/test/pmt_tests.cpp
@@ -9,7 +9,7 @@
 #include "uint256.h"
 #include "arith_uint256.h"
 #include "version.h"
-#include "random.h"
+#include "test_random.h"
 #include "test/test_dash.h"
 
 #include <vector>
diff --git a/src/test/prevector_tests.cpp b/src/test/prevector_tests.cpp
@@ -4,7 +4,7 @@
 
 #include <vector>
 #include "prevector.h"
-#include "random.h"
+#include "test_random.h"
 
 #include "serialize.h"
 #include "streams.h"
@@ -27,8 +27,7 @@ class prevector_tester {
 
     typedef typename pretype::size_type Size;
     bool passed = true;
-    uint32_t insecure_rand_Rz_cache;
-    uint32_t insecure_rand_Rw_cache;
+    FastRandomContext rand_cache;
 
 
     template <typename A, typename B>
@@ -171,15 +170,14 @@ class prevector_tester {
         test();
     }
     ~prevector_tester() {
-        BOOST_CHECK_MESSAGE(passed, "insecure_rand_Rz: " 
-                << insecure_rand_Rz_cache 
+        BOOST_CHECK_MESSAGE(passed, "insecure_rand_Rz: "
+                << rand_cache.Rz
                 << ", insecure_rand_Rw: "
-                << insecure_rand_Rw_cache);
+                << rand_cache.Rw);
     }
     prevector_tester() {
         seed_insecure_rand();
-        insecure_rand_Rz_cache = insecure_rand_Rz;
-        insecure_rand_Rw_cache = insecure_rand_Rw;
+        rand_cache = insecure_rand_ctx;
     }
 };
 
diff --git a/src/test/scheduler_tests.cpp b/src/test/scheduler_tests.cpp
@@ -42,8 +42,6 @@ static void MicroSleep(uint64_t n)
 
 BOOST_AUTO_TEST_CASE(manythreads)
 {
-    seed_insecure_rand(false);
-
     // Stress test: hundreds of microsecond-scheduled tasks,
     // serviced by 10 threads.
     //
@@ -58,7 +56,7 @@ BOOST_AUTO_TEST_CASE(manythreads)
 
     boost::mutex counterMutex[10];
     int counter[10] = { 0 };
-    boost::random::mt19937 rng(insecure_rand());
+    boost::random::mt19937 rng(42);
     boost::random::uniform_int_distribution<> zeroToNine(0, 9);
     boost::random::uniform_int_distribution<> randomMsec(-11, 1000);
     boost::random::uniform_int_distribution<> randomDelta(-1000, 1000);
diff --git a/src/test/sighash_tests.cpp b/src/test/sighash_tests.cpp
@@ -6,7 +6,7 @@
 #include "data/sighash.json.h"
 #include "hash.h"
 #include "validation.h" // For CheckTransaction
-#include "random.h"
+#include "test_random.h"
 #include "script/interpreter.h"
 #include "script/script.h"
 #include "serialize.h"
diff --git a/src/test/skiplist_tests.cpp b/src/test/skiplist_tests.cpp
@@ -3,7 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include "chain.h"
-#include "random.h"
+#include "test_random.h"
 #include "util.h"
 #include "test/test_dash.h"
 
diff --git a/src/test/test_dash.cpp b/src/test/test_dash.cpp
@@ -27,8 +27,9 @@
 #include <boost/test/unit_test.hpp>
 #include <boost/thread.hpp>
 
-
 std::unique_ptr<CConnman> g_connman;
+FastRandomContext insecure_rand_ctx(true);
+
 extern bool fPrintToConsole;
 extern void noui_connect();
 
diff --git a/src/test/test_random.h b/src/test/test_random.h
@@ -0,0 +1,23 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2014 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_TEST_RANDOM_H
+#define BITCOIN_TEST_RANDOM_H
+
+#include "random.h"
+
+extern FastRandomContext insecure_rand_ctx;
+
+static inline void seed_insecure_rand(bool fDeterministic = false)
+{
+    insecure_rand_ctx = FastRandomContext(fDeterministic);
+}
+
+static inline uint32_t insecure_rand(void)
+{
+    return insecure_rand_ctx.rand32();
+}
+
+#endif
diff --git a/src/test/util_tests.cpp b/src/test/util_tests.cpp
diff --git a/src/test/versionbits_tests.cpp b/src/test/versionbits_tests.cpp
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
diff --git a/src/txmempool.h b/src/txmempool.h
diff --git a/src/wallet/test/crypto_tests.cpp b/src/wallet/test/crypto_tests.cpp
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp

Original file line number	Diff line number	Diff line change
`@@ -194,7 +194,8 @@ void AdvertiseLocal(CNode *pnode)`
`194`	`194`	`if (addrLocal.IsRoutable())`
`195`	`195`	`{`
`196`	`196`	`LogPrint("net", "AdvertiseLocal: advertising address %s\n", addrLocal.ToString());`
`197`		`- pnode->PushAddress(addrLocal);`
	`197`	`+ FastRandomContext insecure_rand;`
	`198`	`+ pnode->PushAddress(addrLocal, insecure_rand);`
`198`	`199`	`}`
`199`	`200`	`}`
`200`	`201`	`}`
Original file line number	Diff line number	Diff line change
`@@ -867,14 +867,14 @@ class CNode`
`867`	`867`	`addrKnown.insert(_addr.GetKey());`
`868`	`868`	`}`
`869`	`869`
`870`		`- void PushAddress(const CAddress& _addr)`
	`870`	`+ void PushAddress(const CAddress& _addr, FastRandomContext &insecure_rand)`
`871`	`871`	`{`
`872`	`872`	`// Known checking here is only to save space from duplicates.`
`873`	`873`	`// SendMessages will filter it again for knowns that were added`
`874`	`874`	`// after addresses were pushed.`
`875`	`875`	`if (_addr.IsValid() && !addrKnown.contains(_addr.GetKey())) {`
`876`	`876`	`if (vAddrToSend.size() >= MAX_ADDR_TO_SEND) {`
`877`		`- vAddrToSend[insecure_rand() % vAddrToSend.size()] = _addr;`
	`877`	`+ vAddrToSend[insecure_rand.rand32() % vAddrToSend.size()] = _addr;`
`878`	`878`	`} else {`
`879`	`879`	`vAddrToSend.push_back(_addr);`
`880`	`880`	`}`
Original file line number	Diff line number	Diff line change
`@@ -820,6 +820,7 @@ static void RelayAddress(const CAddress& addr, bool fReachable, CConnman& connma`
`820`	`820`	`uint64_t hashAddr = addr.GetHash();`
`821`	`821`	`multimap<uint64_t, CNode*> mapMix;`
`822`	`822`	`const CSipHasher hasher = connman.GetDeterministicRandomizer(RANDOMIZER_ID_ADDRESS_RELAY).Write(hashAddr << 32).Write((GetTime() + hashAddr) / (246060));`
	`823`	`+ FastRandomContext insecure_rand;`
`823`	`824`
`824`	`825`	`auto sortfunc = [&mapMix, &hasher](CNode* pnode) {`
`825`	`826`	`if (pnode->nVersion >= CADDR_TIME_VERSION) {`
`@@ -828,9 +829,9 @@ static void RelayAddress(const CAddress& addr, bool fReachable, CConnman& connma`
`828`	`829`	`}`
`829`	`830`	`};`
`830`	`831`
`831`		`- auto pushfunc = [&addr, &mapMix, &nRelayNodes] {`
	`832`	`+ auto pushfunc = [&addr, &mapMix, &nRelayNodes, &insecure_rand] {`
`832`	`833`	`for (auto mi = mapMix.begin(); mi != mapMix.end() && nRelayNodes-- > 0; ++mi)`
`833`		`- mi->second->PushAddress(addr);`
	`834`	`+ mi->second->PushAddress(addr, insecure_rand);`
`834`	`835`	`};`
`835`	`836`
`836`	`837`	`connman.ForEachNodeThen(std::move(sortfunc), std::move(pushfunc));`
`@@ -1248,14 +1249,15 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,`
`1248`	`1249`	`if (fListen && !IsInitialBlockDownload())`
`1249`	`1250`	`{`
`1250`	`1251`	`CAddress addr = GetLocalAddress(&pfrom->addr, pfrom->GetLocalServices());`
	`1252`	`+ FastRandomContext insecure_rand;`
`1251`	`1253`	`if (addr.IsRoutable())`
`1252`	`1254`	`{`
`1253`	`1255`	`LogPrint("net", "ProcessMessages: advertising address %s\n", addr.ToString());`
`1254`		`- pfrom->PushAddress(addr);`
	`1256`	`+ pfrom->PushAddress(addr, insecure_rand);`
`1255`	`1257`	`} else if (IsPeerAddrLocalGood(pfrom)) {`
`1256`	`1258`	`addr.SetIP(pfrom->addrLocal);`
`1257`	`1259`	`LogPrint("net", "ProcessMessages: advertising address %s\n", addr.ToString());`
`1258`		`- pfrom->PushAddress(addr);`
	`1260`	`+ pfrom->PushAddress(addr, insecure_rand);`
`1259`	`1261`	`}`
`1260`	`1262`	`}`
`1261`	`1263`
`@@ -2022,8 +2024,9 @@ bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv,`
`2022`	`2024`
`2023`	`2025`	`pfrom->vAddrToSend.clear();`
`2024`	`2026`	`vector<CAddress> vAddr = connman.GetAddresses();`
	`2027`	`+ FastRandomContext insecure_rand;`
`2025`	`2028`	`BOOST_FOREACH(const CAddress &addr, vAddr)`
`2026`		`- pfrom->PushAddress(addr);`
	`2029`	`+ pfrom->PushAddress(addr, insecure_rand);`
`2027`	`2030`	`}`
`2028`	`2031`
`2029`	`2032`
`@@ -2935,7 +2938,7 @@ bool SendMessages(CNode* pto, CConnman& connman, std::atomic<bool>& interruptMsg`
`2935`	`2938`	`// until scheduled broadcast, then move the broadcast to within MAX_FEEFILTER_CHANGE_DELAY.`
`2936`	`2939`	`else if (timeNow + MAX_FEEFILTER_CHANGE_DELAY * 1000000 < pto->nextSendTimeFeeFilter &&`
`2937`	`2940`	`(currentFilter < 3 * pto->lastSentFeeFilter / 4 \|\| currentFilter > 4 * pto->lastSentFeeFilter / 3)) {`
`2938`		`- pto->nextSendTimeFeeFilter = timeNow + (insecure_rand() % MAX_FEEFILTER_CHANGE_DELAY) * 1000000;`
	`2941`	`+ pto->nextSendTimeFeeFilter = timeNow + GetRandInt(MAX_FEEFILTER_CHANGE_DELAY) * 1000000;`
`2939`	`2942`	`}`
`2940`	`2943`	`}`
`2941`	`2944`	`}`
Original file line number	Diff line number	Diff line change
`@@ -592,7 +592,7 @@ FeeFilterRounder::FeeFilterRounder(const CFeeRate& minIncrementalFee)`
`592`	`592`	`CAmount FeeFilterRounder::round(CAmount currentMinFee)`
`593`	`593`	`{`
`594`	`594`	`std::set<double>::iterator it = feeset.lower_bound(currentMinFee);`
`595`		`- if ((it != feeset.begin() && insecure_rand() % 3 != 0) \|\| it == feeset.end()) {`
	`595`	`+ if ((it != feeset.begin() && insecure_rand.rand32() % 3 != 0) \|\| it == feeset.end()) {`
`596`	`596`	`it--;`
`597`	`597`	`}`
`598`	`598`	`return *it;`