zecfoundation
/
zcashd
mirror of https://github.com/ZcashFoundation/zcashd.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

scripted-diff: use insecure_rand256/randrange more 

-BEGIN VERIFY SCRIPT-
sed -i "s/\<GetRandHash(/insecure_rand256(/" src/test/*_tests.cpp
sed -i "s/\<GetRand(/insecure_randrange(/" src/test/*_tests.cpp src/test/test_bitcoin.cpp
sed -i 's/\<insecure_rand() % \([0-9]\+\)/insecure_randrange(\1)/g' src/test/*_tests.cpp
-END VERIFY SCRIPT-

Zcash: Excludes changes to files we don't have.

(cherry picked from commit bitcoin/bitcoin@efee1db21a)
This commit is contained in:
Pieter Wuille 2017-05-23 15:28:45 -07:00 committed by Jack Grigg
parent eab53622f4
commit 5a1c450496
13 changed files with 82 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/test/DoS_tests.cpp
View File

@ -120,7 +120,7 @@ BOOST_AUTO_TEST_CASE(DoS_bantime)
CTransaction RandomOrphan()
{
std::map<uint256, COrphanTx>::iterator it;
it = mapOrphanTransactions.lower_bound(GetRandHash());
it = mapOrphanTransactions.lower_bound(insecure_rand256());
if (it == mapOrphanTransactions.end())
it = mapOrphanTransactions.begin();
return it->second.tx;
@ -141,7 +141,7 @@ BOOST_DATA_TEST_CASE(DoS_mapOrphans, boost::unit_test::data::xrange(static_cast<
CMutableTransaction tx;
tx.vin.resize(1);
tx.vin[0].prevout.n = 0;
tx.vin[0].prevout.hash = GetRandHash();
tx.vin[0].prevout.hash = insecure_rand256();
tx.vin[0].scriptSig << OP_1;
tx.vout.resize(1);
tx.vout[0].nValue = 1*CENT;

2
src/test/bloom_tests.cpp
View File

@ -460,7 +460,7 @@ BOOST_AUTO_TEST_CASE(merkle_block_4_test_update_none)
static std::vector<unsigned char> RandomData()
{
uint256 r = GetRandHash();
uint256 r = insecure_rand256();
return std::vector<unsigned char>(r.begin(), r.end());
}

10
src/test/checkqueue_tests.cpp
View File

@ -161,7 +161,7 @@ void Correct_Queue_range(std::vector<size_t> range)
FakeCheckCheckCompletion::n_calls = 0;
CCheckQueueControl<FakeCheckCheckCompletion> control(small_queue.get());
while (total) {
vChecks.resize(std::min(total, (size_t) GetRand(10)));
vChecks.resize(std::min(total, (size_t) insecure_randrange(10)));
total -= vChecks.size();
control.Add(vChecks);
}
@ -205,7 +205,7 @@ BOOST_AUTO_TEST_CASE(test_CheckQueue_Correct_Random)
{
std::vector<size_t> range;
range.reserve(100000/1000);
for (size_t i = 2; i < 100000; i += std::max((size_t)1, (size_t)GetRand(std::min((size_t)1000, ((size_t)100000) - i))))
for (size_t i = 2; i < 100000; i += std::max((size_t)1, (size_t)insecure_randrange(std::min((size_t)1000, ((size_t)100000) - i))))
range.push_back(i);
Correct_Queue_range(range);
}
@ -225,7 +225,7 @@ BOOST_AUTO_TEST_CASE(test_CheckQueue_Catches_Failure)
CCheckQueueControl<FailingCheck> control(fail_queue.get());
size_t remaining = i;
while (remaining) {
size_t r = GetRand(10);
size_t r = insecure_randrange(10);
std::vector<FailingCheck> vChecks;
vChecks.reserve(r);
@ -287,7 +287,7 @@ BOOST_AUTO_TEST_CASE(test_CheckQueue_UniqueCheck)
{
CCheckQueueControl<UniqueCheck> control(queue.get());
while (total) {
size_t r = GetRand(10);
size_t r = insecure_randrange(10);
std::vector<UniqueCheck> vChecks;
for (size_t k = 0; k < r && total; k++)
vChecks.emplace_back(--total);
@ -321,7 +321,7 @@ BOOST_AUTO_TEST_CASE(test_CheckQueue_Memory)
{
CCheckQueueControl<MemoryCheck> control(queue.get());
while (total) {
size_t r = GetRand(10);
size_t r = insecure_randrange(10);
std::vector<MemoryCheck> vChecks;
for (size_t k = 0; k < r && total; k++) {
total--;

36
src/test/coins_tests.cpp
View File

@ -143,7 +143,7 @@ public:
return false;
}
coins = it->second;
if (coins.IsPruned() && insecure_rand() % 2 == 0) {
if (coins.IsPruned() && insecure_randrange(2) == 0) {
// Randomly return false in case of an empty entry.
return false;
}
@ -209,7 +209,7 @@ public:
if (it->second.flags & CCoinsCacheEntry::DIRTY) {
// Same optimization used in CCoinsViewDB is to only write dirty entries.
map_[it->first] = it->second.coins;
if (it->second.coins.IsPruned() && insecure_rand() % 3 == 0) {
if (it->second.coins.IsPruned() && insecure_randrange(3) == 0) {
// Randomly delete empty entries on write.
map_.erase(it->first);
}
@ -275,12 +275,12 @@ public:
{
CMutableTransaction mutableTx;
sproutNullifier = GetRandHash();
sproutNullifier = insecure_rand256();
JSDescription jsd;
jsd.nullifiers[0] = sproutNullifier;
mutableTx.vJoinSplit.emplace_back(jsd);
saplingNullifier = GetRandHash();
saplingNullifier = insecure_rand256();
SpendDescription sd;
sd.nullifier = saplingNullifier;
mutableTx.vShieldedSpend.push_back(sd);
@ -312,8 +312,8 @@ uint256 appendRandomSproutCommitment(SproutMerkleTree &tree)
}
template<typename Tree> void AppendRandomLeaf(Tree &tree);
template<> void AppendRandomLeaf(SproutMerkleTree &tree) { tree.append(GetRandHash()); }
template<> void AppendRandomLeaf(SaplingMerkleTree &tree) { tree.append(GetRandHash()); }
template<> void AppendRandomLeaf(SproutMerkleTree &tree) { tree.append(insecure_rand256()); }
template<> void AppendRandomLeaf(SaplingMerkleTree &tree) { tree.append(insecure_rand256()); }
template<> void AppendRandomLeaf(OrchardMerkleFrontier &tree) {
// OrchardMerkleFrontier only has APIs to append entire bundles, but
// fortunately the tests only require that the tree root change.
@ -462,7 +462,7 @@ BOOST_AUTO_TEST_CASE(coins_cache_simulation_test)
std::vector<uint256> txids;
txids.resize(NUM_SIMULATION_ITERATIONS / 8);
for (unsigned int i = 0; i < txids.size(); i++) {
txids[i] = GetRandHash();
txids[i] = insecure_rand256();
}
for (unsigned int i = 0; i < NUM_SIMULATION_ITERATIONS; i++) {
@ -472,7 +472,7 @@ BOOST_AUTO_TEST_CASE(coins_cache_simulation_test)
CCoins& coins = result[txid];
CCoinsModifier entry = stack.back()->ModifyCoins(txid);
BOOST_CHECK(coins == *entry);
if (insecure_rand() % 5 == 0 || coins.IsPruned()) {
if (insecure_randrange(5) == 0 || coins.IsPruned()) {
if (coins.IsPruned()) {
added_an_entry = true;
} else {
@ -490,7 +490,7 @@ BOOST_AUTO_TEST_CASE(coins_cache_simulation_test)
}
// Once every 1000 iterations and at the end, verify the full cache.
if (insecure_rand() % 1000 == 1 || i == NUM_SIMULATION_ITERATIONS - 1) {
if (insecure_randrange(1000) == 1 || i == NUM_SIMULATION_ITERATIONS - 1) {
for (std::map<uint256, CCoins>::iterator it = result.begin(); it != result.end(); it++) {
const CCoins* coins = stack.back()->AccessCoins(it->first);
if (coins) {
@ -506,14 +506,14 @@ BOOST_AUTO_TEST_CASE(coins_cache_simulation_test)
}
}
if (insecure_rand() % 100 == 0) {
if (insecure_randrange(100) == 0) {
// Every 100 iterations, change the cache stack.
if (stack.size() > 0 && insecure_rand() % 2 == 0) {
if (stack.size() > 0 && insecure_randrange(2) == 0) {
stack.back()->Flush();
delete stack.back();
stack.pop_back();
}
if (stack.size() == 0 || (stack.size() < 4 && insecure_rand() % 2)) {
if (stack.size() == 0 || (stack.size() < 4 && insecure_randrange(2))) {
CCoinsView* tip = &base;
if (stack.size() > 0) {
tip = stack.back();
@ -614,7 +614,7 @@ BOOST_AUTO_TEST_CASE(updatecoins_simulation_test)
unsigned int height = insecure_rand();
// 1/10 times create a coinbase
if (insecure_rand() % 10 == 0 || coinbaseids.size() < 10) {
if (insecure_randrange(10) == 0 || coinbaseids.size() < 10) {
coinbaseids[tx.GetHash()] = tx.vout[0].nValue;
assert(CTransaction(tx).IsCoinBase());
}
@ -622,7 +622,7 @@ BOOST_AUTO_TEST_CASE(updatecoins_simulation_test)
else {
uint256 prevouthash;
// equally likely to spend coinbase or non coinbase
std::set<uint256>::iterator txIt = alltxids.lower_bound(GetRandHash());
std::set<uint256>::iterator txIt = alltxids.lower_bound(insecure_rand256());
if (txIt == alltxids.end()) {
txIt = alltxids.begin();
}
@ -652,7 +652,7 @@ BOOST_AUTO_TEST_CASE(updatecoins_simulation_test)
}
// Once every 1000 iterations and at the end, verify the full cache.
if (insecure_rand() % 1000 == 1 || i == NUM_SIMULATION_ITERATIONS - 1) {
if (insecure_randrange(1000) == 1 || i == NUM_SIMULATION_ITERATIONS - 1) {
for (std::map<uint256, CCoins>::iterator it = result.begin(); it != result.end(); it++) {
const CCoins* coins = stack.back()->AccessCoins(it->first);
if (coins) {
@ -663,14 +663,14 @@ BOOST_AUTO_TEST_CASE(updatecoins_simulation_test)
}
}
if (insecure_rand() % 100 == 0) {
if (insecure_randrange(100) == 0) {
// Every 100 iterations, change the cache stack.
if (stack.size() > 0 && insecure_rand() % 2 == 0) {
if (stack.size() > 0 && insecure_randrange(2) == 0) {
stack.back()->Flush();
delete stack.back();
stack.pop_back();
}
if (stack.size() == 0 || (stack.size() < 4 && insecure_rand() % 2)) {
if (stack.size() == 0 || (stack.size() < 4 && insecure_randrange(2))) {
CCoinsView* tip = &base;
if (stack.size() > 0) {
tip = stack.back();

12
src/test/dbwrapper_tests.cpp
View File

@ -34,7 +34,7 @@ BOOST_AUTO_TEST_CASE(dbwrapper)
path ph = temp_directory_path() / unique_path();
CDBWrapper dbw(ph, (1 << 20), true, false);
char key = 'k';
uint256 in = GetRandHash();
uint256 in = insecure_rand256();
uint256 res;
BOOST_CHECK(dbw.Write(key, in));
@ -51,11 +51,11 @@ BOOST_AUTO_TEST_CASE(dbwrapper_batch)
CDBWrapper dbw(ph, (1 << 20), true, false);
char key = 'i';
uint256 in = GetRandHash();
uint256 in = insecure_rand256();
char key2 = 'j';
uint256 in2 = GetRandHash();
uint256 in2 = insecure_rand256();
char key3 = 'k';
uint256 in3 = GetRandHash();
uint256 in3 = insecure_rand256();
uint256 res;
CDBBatch batch(dbw);
@ -87,10 +87,10 @@ BOOST_AUTO_TEST_CASE(dbwrapper_iterator)
// The two keys are intentionally chosen for ordering
char key = 'j';
uint256 in = GetRandHash();
uint256 in = insecure_rand256();
BOOST_CHECK(dbw.Write(key, in));
char key2 = 'k';
uint256 in2 = GetRandHash();
uint256 in2 = insecure_rand256();
BOOST_CHECK(dbw.Write(key2, in2));
boost::scoped_ptr<CDBIterator> it(const_cast<CDBWrapper*>(&dbw)->NewIterator());

2
src/test/merkle_tests.cpp
View File

@ -67,7 +67,7 @@ BOOST_AUTO_TEST_CASE(merkle_test)
{
for (int i = 0; i < 32; i++) {
// Try 32 block sizes: all sizes from 0 to 16 inclusive, and then 15 random sizes.
int ntx = (i <= 16) ? i : 17 + (insecure_rand() % 4000);
int ntx = (i <= 16) ? i : 17 + (insecure_randrange(4000));
// Try up to 3 mutations.
for (int mutate = 0; mutate <= 3; mutate++) {
int duplicate1 = mutate >= 1 ? 1 << ctz(ntx) : 0; // The last how many transactions to duplicate first.

2
src/test/pmt_tests.cpp
View File

@ -25,7 +25,7 @@ public:
// flip one bit in one of the hashes - this should break the authentication
void Damage() {
unsigned int n = insecure_rand() % vHash.size();
int bit = insecure_rand() % 256;
int bit = insecure_randrange(256);
*(vHash[n].begin() + (bit>>3)) ^= 1<<(bit&7);
}
};

6
src/test/pow_tests.cpp
View File

@ -144,9 +144,9 @@ void GetBlockProofEquivalentTimeImpl(const Consensus::Params& params) {
}
for (int j = 0; j < 1000; j++) {
CBlockIndex *p1 = &blocks[GetRand(10000)];
CBlockIndex *p2 = &blocks[GetRand(10000)];
CBlockIndex *p3 = &blocks[GetRand(10000)];
CBlockIndex *p1 = &blocks[insecure_randrange(10000)];
CBlockIndex *p2 = &blocks[insecure_randrange(10000)];
CBlockIndex *p3 = &blocks[insecure_randrange(10000)];
int64_t tdiff = GetBlockProofEquivalentTime(*p1, *p2, *p3, params);
BOOST_CHECK_EQUAL(tdiff, p1->GetBlockTime() - p2->GetBlockTime());

14
src/test/prevector_tests.cpp
View File

@ -195,14 +195,14 @@ BOOST_AUTO_TEST_CASE(PrevectorTestInt)
test.erase(insecure_rand() % test.size());
}
if (((r >> 4) % 8) == 2) {
int new_size = std::max<int>(0, std::min<int>(30, test.size() + (insecure_rand() % 5) - 2));
int new_size = std::max<int>(0, std::min<int>(30, test.size() + (insecure_randrange(5)) - 2));
test.resize(new_size);
}
if (((r >> 7) % 8) == 3) {
test.insert(insecure_rand() % (test.size() + 1), 1 + (insecure_rand() % 2), insecure_rand());
test.insert(insecure_rand() % (test.size() + 1), 1 + (insecure_randrange(2)), insecure_rand());
}
if (((r >> 10) % 8) == 4) {
int del = std::min<int>(test.size(), 1 + (insecure_rand() % 2));
int del = std::min<int>(test.size(), 1 + (insecure_randrange(2)));
int beg = insecure_rand() % (test.size() + 1 - del);
test.erase(beg, beg + del);
}
@ -214,20 +214,20 @@ BOOST_AUTO_TEST_CASE(PrevectorTestInt)
}
if (((r >> 21) % 32) == 7) {
int values[4];
int num = 1 + (insecure_rand() % 4);
int num = 1 + (insecure_randrange(4));
for (int i = 0; i < num; i++) {
values[i] = insecure_rand();
}
test.insert_range(insecure_rand() % (test.size() + 1), values, values + num);
}
if (((r >> 26) % 32) == 8) {
int del = std::min<int>(test.size(), 1 + (insecure_rand() % 4));
int del = std::min<int>(test.size(), 1 + (insecure_randrange(4)));
int beg = insecure_rand() % (test.size() + 1 - del);
test.erase(beg, beg + del);
}
r = insecure_rand();
if (r % 32 == 9) {
test.reserve(insecure_rand() % 32);
test.reserve(insecure_randrange(32));
}
if ((r >> 5) % 64 == 10) {
test.shrink_to_fit();
@ -239,7 +239,7 @@ BOOST_AUTO_TEST_CASE(PrevectorTestInt)
test.clear();
}
if (((r >> 21) % 512) == 12) {
test.assign(insecure_rand() % 32, insecure_rand());
test.assign(insecure_randrange(32), insecure_rand());
}
if (((r >> 15) % 64) == 3) {
test.swap();

52
src/test/sighash_tests.cpp
View File

@ -90,7 +90,7 @@ uint256 static SignatureHashOld(CScript scriptCode, const CTransaction& txTo, un
void static RandomScript(CScript &script) {
static const opcodetype oplist[] = {OP_FALSE, OP_1, OP_2, OP_3, OP_CHECKSIG, OP_IF, OP_VERIF, OP_RETURN};
script = CScript();
int ops = (insecure_rand() % 10);
int ops = (insecure_randrange(10));
for (int i=0; i<ops; i++)
script << oplist[insecure_rand() % (sizeof(oplist)/sizeof(oplist[0]))];
}
@ -108,16 +108,16 @@ std::uniform_int_distribution<int> sapling_version_dist(
CTransaction::SAPLING_MAX_CURRENT_VERSION);
void static RandomTransaction(CMutableTransaction &tx, bool fSingle, uint32_t consensusBranchId) {
tx.fOverwintered = insecure_rand() % 2;
tx.fOverwintered = insecure_randrange(2);
if (tx.fOverwintered) {
if (insecure_rand() % 2) {
if (insecure_randrange(2)) {
tx.nVersionGroupId = SAPLING_VERSION_GROUP_ID;
tx.nVersion = sapling_version_dist(rng);
} else {
tx.nVersionGroupId = OVERWINTER_VERSION_GROUP_ID;
tx.nVersion = overwinter_version_dist(rng);
}
tx.nExpiryHeight = (insecure_rand() % 2) ? insecure_rand() % TX_EXPIRY_HEIGHT_THRESHOLD : 0;
tx.nExpiryHeight = (insecure_randrange(2)) ? insecure_rand() % TX_EXPIRY_HEIGHT_THRESHOLD : 0;
} else {
tx.nVersion = insecure_rand() & 0x7FFFFFFF;
}
@ -126,33 +126,33 @@ void static RandomTransaction(CMutableTransaction &tx, bool fSingle, uint32_t co
tx.vShieldedSpend.clear();
tx.vShieldedOutput.clear();
tx.vJoinSplit.clear();
tx.nLockTime = (insecure_rand() % 2) ? insecure_rand() : 0;
int ins = (insecure_rand() % 4) + 1;
int outs = fSingle ? ins : (insecure_rand() % 4) + 1;
int shielded_spends = (insecure_rand() % 4) + 1;
int shielded_outs = (insecure_rand() % 4) + 1;
int joinsplits = (insecure_rand() % 4);
tx.nLockTime = (insecure_randrange(2)) ? insecure_rand() : 0;
int ins = (insecure_randrange(4)) + 1;
int outs = fSingle ? ins : (insecure_randrange(4)) + 1;
int shielded_spends = (insecure_randrange(4)) + 1;
int shielded_outs = (insecure_randrange(4)) + 1;
int joinsplits = (insecure_randrange(4));
for (int in = 0; in < ins; in++) {
tx.vin.push_back(CTxIn());
CTxIn &txin = tx.vin.back();
txin.prevout.hash = GetRandHash();
txin.prevout.n = insecure_rand() % 4;
txin.prevout.hash = insecure_rand256();
txin.prevout.n = insecure_randrange(4);
RandomScript(txin.scriptSig);
txin.nSequence = (insecure_rand() % 2) ? insecure_rand() : (unsigned int)-1;
txin.nSequence = (insecure_randrange(2)) ? insecure_rand() : (unsigned int)-1;
}
for (int out = 0; out < outs; out++) {
tx.vout.push_back(CTxOut());
CTxOut &txout = tx.vout.back();
txout.nValue = insecure_rand() % 100000000;
txout.nValue = insecure_randrange(100000000);
RandomScript(txout.scriptPubKey);
}
if (tx.nVersionGroupId == SAPLING_VERSION_GROUP_ID) {
tx.valueBalanceSapling = insecure_rand() % 100000000;
tx.valueBalanceSapling = insecure_randrange(100000000);
for (int spend = 0; spend < shielded_spends; spend++) {
SpendDescription sdesc;
zcash_test_harness_random_jubjub_point(sdesc.cv.begin());
zcash_test_harness_random_jubjub_base(sdesc.anchor.begin());
sdesc.nullifier = GetRandHash();
sdesc.nullifier = insecure_rand256();
zcash_test_harness_random_jubjub_point(sdesc.rk.begin());
GetRandBytes(sdesc.zkproof.begin(), sdesc.zkproof.size());
tx.vShieldedSpend.push_back(sdesc);
@ -172,17 +172,17 @@ void static RandomTransaction(CMutableTransaction &tx, bool fSingle, uint32_t co
if (tx.fOverwintered && tx.nVersion >= SAPLING_TX_VERSION) {
for (int js = 0; js < joinsplits; js++) {
JSDescription jsdesc;
if (insecure_rand() % 2 == 0) {
jsdesc.vpub_old = insecure_rand() % 100000000;
if (insecure_randrange(2) == 0) {
jsdesc.vpub_old = insecure_randrange(100000000);
} else {
jsdesc.vpub_new = insecure_rand() % 100000000;
jsdesc.vpub_new = insecure_randrange(100000000);
}
jsdesc.anchor = GetRandHash();
jsdesc.nullifiers[0] = GetRandHash();
jsdesc.nullifiers[1] = GetRandHash();
jsdesc.ephemeralKey = GetRandHash();
jsdesc.randomSeed = GetRandHash();
jsdesc.anchor = insecure_rand256();
jsdesc.nullifiers[0] = insecure_rand256();
jsdesc.nullifiers[1] = insecure_rand256();
jsdesc.ephemeralKey = insecure_rand256();
jsdesc.randomSeed = insecure_rand256();
GetRandBytes(jsdesc.ciphertexts[0].begin(), jsdesc.ciphertexts[0].size());
GetRandBytes(jsdesc.ciphertexts[1].begin(), jsdesc.ciphertexts[1].size());
{
@ -190,8 +190,8 @@ void static RandomTransaction(CMutableTransaction &tx, bool fSingle, uint32_t co
GetRandBytes(zkproof.begin(), zkproof.size());
jsdesc.proof = zkproof;
}
jsdesc.macs[0] = GetRandHash();
jsdesc.macs[1] = GetRandHash();
jsdesc.macs[0] = insecure_rand256();
jsdesc.macs[1] = insecure_rand256();
tx.vJoinSplit.push_back(jsdesc);
}

2
src/test/skiplist_tests.cpp
View File

@ -78,7 +78,7 @@ BOOST_AUTO_TEST_CASE(getlocator_test)
// Test 100 random starting points for locators.
for (int n=0; n<100; n++) {
int r = insecure_rand() % 150000;
int r = insecure_randrange(150000);
CBlockIndex* tip = (r < 100000) ? &vBlocksMain[r] : &vBlocksSide[r - 100000];
CBlockLocator locator = chain.GetLocator(tip);

2
src/test/test_bitcoin.cpp
View File

@ -110,7 +110,7 @@ TestingSetup::TestingSetup(const std::string& chainName) : BasicTestingSetup(cha
orig_current_path = fs::current_path();
ClearDatadirCache();
pathTemp = fs::temp_directory_path() / strprintf("test_bitcoin_%lu_%i", (unsigned long)GetTime(), (int)(GetRand(100000)));
pathTemp = fs::temp_directory_path() / strprintf("test_bitcoin_%lu_%i", (unsigned long)GetTime(), (int)(insecure_randrange(100000)));
fs::create_directories(pathTemp);
mapArgs["-datadir"] = pathTemp.string();
pblocktree = new CBlockTreeDB(1 << 20, true);

20
src/test/transaction_tests.cpp
View File

@ -310,7 +310,7 @@ void test_simple_sapling_invalidity(uint32_t consensusBranchId, CMutableTransact
CValidationState state;
newTx.vShieldedSpend.push_back(SpendDescription());
newTx.vShieldedSpend[0].nullifier = GetRandHash();
newTx.vShieldedSpend[0].nullifier = insecure_rand256();
BOOST_CHECK(!CheckTransactionWithoutProofVerification(newTx, state));
BOOST_CHECK(state.GetRejectReason() == "bad-txns-no-sink-of-funds");
@ -321,7 +321,7 @@ void test_simple_sapling_invalidity(uint32_t consensusBranchId, CMutableTransact
CValidationState state;
newTx.vShieldedSpend.push_back(SpendDescription());
newTx.vShieldedSpend[0].nullifier = GetRandHash();
newTx.vShieldedSpend[0].nullifier = insecure_rand256();
newTx.vShieldedOutput.push_back(OutputDescription());
@ -331,7 +331,7 @@ void test_simple_sapling_invalidity(uint32_t consensusBranchId, CMutableTransact
BOOST_CHECK(!CheckTransactionWithoutProofVerification(newTx, state));
BOOST_CHECK(state.GetRejectReason() == "bad-spend-description-nullifiers-duplicate");
newTx.vShieldedSpend[1].nullifier = GetRandHash();
newTx.vShieldedSpend[1].nullifier = insecure_rand256();
BOOST_CHECK(CheckTransactionWithoutProofVerification(newTx, state));
}
@ -382,8 +382,8 @@ void test_simple_joinsplit_invalidity(uint32_t consensusBranchId, CMutableTransa
newTx.vJoinSplit.push_back(JSDescription());
JSDescription *jsdesc = &newTx.vJoinSplit[0];
jsdesc->nullifiers[0] = GetRandHash();
jsdesc->nullifiers[1] = GetRandHash();
jsdesc->nullifiers[0] = insecure_rand256();
jsdesc->nullifiers[1] = insecure_rand256();
// Fake coins being spent.
std::vector<CTxOut> allPrevOutputs;
@ -474,19 +474,19 @@ void test_simple_joinsplit_invalidity(uint32_t consensusBranchId, CMutableTransa
newTx.vJoinSplit.push_back(JSDescription());
JSDescription *jsdesc = &newTx.vJoinSplit[0];
jsdesc->nullifiers[0] = GetRandHash();
jsdesc->nullifiers[0] = insecure_rand256();
jsdesc->nullifiers[1] = jsdesc->nullifiers[0];
BOOST_CHECK(!CheckTransaction(newTx, state, verifier));
BOOST_CHECK(state.GetRejectReason() == "bad-joinsplits-nullifiers-duplicate");
jsdesc->nullifiers[1] = GetRandHash();
jsdesc->nullifiers[1] = insecure_rand256();
newTx.vJoinSplit.push_back(JSDescription());
jsdesc = &newTx.vJoinSplit[0]; // Fixes #2026. Related PR #2078.
JSDescription *jsdesc2 = &newTx.vJoinSplit[1];
jsdesc2->nullifiers[0] = GetRandHash();
jsdesc2->nullifiers[0] = insecure_rand256();
jsdesc2->nullifiers[1] = jsdesc->nullifiers[0];
BOOST_CHECK(!CheckTransaction(newTx, state, verifier));
@ -499,8 +499,8 @@ void test_simple_joinsplit_invalidity(uint32_t consensusBranchId, CMutableTransa
newTx.vJoinSplit.push_back(JSDescription());
JSDescription *jsdesc = &newTx.vJoinSplit[0];
jsdesc->nullifiers[0] = GetRandHash();
jsdesc->nullifiers[1] = GetRandHash();
jsdesc->nullifiers[0] = insecure_rand256();
jsdesc->nullifiers[1] = insecure_rand256();
newTx.vin.push_back(CTxIn(uint256(), -1));