Retropex/bitcoin
1
0
Fork 0
mirror of https://github.com/Retropex/bitcoin.git synced 2025-06-02 23:42:33 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge #20828: fuzz: Introduce CallOneOf helper to replace switch-case

Browse Source 
fa75d40ef8 fuzz: Introduce CallOneOf helper to replace switch-case (MarcoFalke)

Pull request description:

  The current `switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, nn)) { case 0: ... case 1: ... case nn: ...` has several problems:

  * It makes it hard to review newly added targets, because it requires manual counting of cases
  * It makes it hard to update a target, because updating all case labels is trivial, but tedious to review and causes merge conflicts
  * ~~Updating the target raises the question whether the case labels should be preserved to not invalidate the existing fuzz inputs format. Fuzz input format might already change implicitly on every commit, so this isn't something worthwhile to pursue.~~ Edit: This pull doesn't fix this problem.

  Fix all issues by adding a new `CallOneOf` helper

ACKs for top commit:
  ajtowns:
    ACK fa75d40ef8 - code review only
  jnewbery:
    utACK fa75d40ef8

Tree-SHA512: 2daa602b240b86c8e85a024e008f03a57ba60349377eed771f4d21a97a9dba9b66e93fff16ff1992018d4330be7a1a276944c3dfdf698748ce135626c380e563
This commit is contained in:
MarcoFalke 2021-01-14 11:07:10 +01:00
commit 29d2aeb4a2
No known key found for this signature in database
GPG Key ID: D2EA4850E7528B25
19 changed files with 1097 additions and 1217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

138
src/test/fuzz/addrman.cpp
View File

@ -45,83 +45,71 @@ FUZZ_TARGET_INIT(addrman, initialize_addrman)
} }
} }
while (fuzzed_data_provider.ConsumeBool()) { while (fuzzed_data_provider.ConsumeBool()) {
switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 11)) { CallOneOf(
case 0: { fuzzed_data_provider,
addr_man.Clear(); [&] {
break; addr_man.Clear();
} },
case 1: { [&] {
addr_man.ResolveCollisions(); addr_man.ResolveCollisions();
break; },
} [&] {
case 2: { (void)addr_man.SelectTriedCollision();
(void)addr_man.SelectTriedCollision(); },
break; [&] {
} (void)addr_man.Select(fuzzed_data_provider.ConsumeBool());
case 3: { },
(void)addr_man.Select(fuzzed_data_provider.ConsumeBool()); [&] {
break; (void)addr_man.GetAddr(fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096), fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096));
} },
case 4: { [&] {
(void)addr_man.GetAddr(fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096), fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096));
break;
}
case 5: {
const std::optional<CAddress> opt_address = ConsumeDeserializable<CAddress>(fuzzed_data_provider);
const std::optional<CNetAddr> opt_net_addr = ConsumeDeserializable<CNetAddr>(fuzzed_data_provider);
if (opt_address && opt_net_addr) {
addr_man.Add(*opt_address, *opt_net_addr, fuzzed_data_provider.ConsumeIntegralInRange<int64_t>(0, 100000000));
}
break;
}
case 6: {
std::vector<CAddress> addresses;
while (fuzzed_data_provider.ConsumeBool()) {
const std::optional<CAddress> opt_address = ConsumeDeserializable<CAddress>(fuzzed_data_provider); const std::optional<CAddress> opt_address = ConsumeDeserializable<CAddress>(fuzzed_data_provider);
if (!opt_address) { const std::optional<CNetAddr> opt_net_addr = ConsumeDeserializable<CNetAddr>(fuzzed_data_provider);
break; if (opt_address && opt_net_addr) {
addr_man.Add(*opt_address, *opt_net_addr, fuzzed_data_provider.ConsumeIntegralInRange<int64_t>(0, 100000000));
} }
addresses.push_back(*opt_address); },
} [&] {
const std::optional<CNetAddr> opt_net_addr = ConsumeDeserializable<CNetAddr>(fuzzed_data_provider); std::vector<CAddress> addresses;
if (opt_net_addr) { while (fuzzed_data_provider.ConsumeBool()) {
addr_man.Add(addresses, *opt_net_addr, fuzzed_data_provider.ConsumeIntegralInRange<int64_t>(0, 100000000)); const std::optional<CAddress> opt_address = ConsumeDeserializable<CAddress>(fuzzed_data_provider);
} if (!opt_address) {
break; break;
} }
case 7: { addresses.push_back(*opt_address);
const std::optional<CService> opt_service = ConsumeDeserializable<CService>(fuzzed_data_provider); }
if (opt_service) { const std::optional<CNetAddr> opt_net_addr = ConsumeDeserializable<CNetAddr>(fuzzed_data_provider);
addr_man.Good(*opt_service, fuzzed_data_provider.ConsumeBool(), ConsumeTime(fuzzed_data_provider)); if (opt_net_addr) {
} addr_man.Add(addresses, *opt_net_addr, fuzzed_data_provider.ConsumeIntegralInRange<int64_t>(0, 100000000));
break; }
} },
case 8: { [&] {
const std::optional<CService> opt_service = ConsumeDeserializable<CService>(fuzzed_data_provider); const std::optional<CService> opt_service = ConsumeDeserializable<CService>(fuzzed_data_provider);
if (opt_service) { if (opt_service) {
addr_man.Attempt(*opt_service, fuzzed_data_provider.ConsumeBool(), ConsumeTime(fuzzed_data_provider)); addr_man.Good(*opt_service, fuzzed_data_provider.ConsumeBool(), ConsumeTime(fuzzed_data_provider));
} }
break; },
} [&] {
case 9: { const std::optional<CService> opt_service = ConsumeDeserializable<CService>(fuzzed_data_provider);
const std::optional<CService> opt_service = ConsumeDeserializable<CService>(fuzzed_data_provider); if (opt_service) {
if (opt_service) { addr_man.Attempt(*opt_service, fuzzed_data_provider.ConsumeBool(), ConsumeTime(fuzzed_data_provider));
addr_man.Connected(*opt_service, ConsumeTime(fuzzed_data_provider)); }
} },
break; [&] {
} const std::optional<CService> opt_service = ConsumeDeserializable<CService>(fuzzed_data_provider);
case 10: { if (opt_service) {
const std::optional<CService> opt_service = ConsumeDeserializable<CService>(fuzzed_data_provider); addr_man.Connected(*opt_service, ConsumeTime(fuzzed_data_provider));
if (opt_service) { }
addr_man.SetServices(*opt_service, ServiceFlags{fuzzed_data_provider.ConsumeIntegral<uint64_t>()}); },
} [&] {
break; const std::optional<CService> opt_service = ConsumeDeserializable<CService>(fuzzed_data_provider);
} if (opt_service) {
case 11: { addr_man.SetServices(*opt_service, ServiceFlags{fuzzed_data_provider.ConsumeIntegral<uint64_t>()});
(void)addr_man.Check(); }
break; },
} [&] {
} (void)addr_man.Check();
});
} }
(void)addr_man.size(); (void)addr_man.size();
CDataStream data_stream(SER_NETWORK, PROTOCOL_VERSION); CDataStream data_stream(SER_NETWORK, PROTOCOL_VERSION);

68
src/test/fuzz/autofile.cpp
View File

@ -21,43 +21,37 @@ FUZZ_TARGET(autofile)
FuzzedAutoFileProvider fuzzed_auto_file_provider = ConsumeAutoFile(fuzzed_data_provider); FuzzedAutoFileProvider fuzzed_auto_file_provider = ConsumeAutoFile(fuzzed_data_provider);
CAutoFile auto_file = fuzzed_auto_file_provider.open(); CAutoFile auto_file = fuzzed_auto_file_provider.open();
while (fuzzed_data_provider.ConsumeBool()) { while (fuzzed_data_provider.ConsumeBool()) {
switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 5)) { CallOneOf(
case 0: { fuzzed_data_provider,
std::array<uint8_t, 4096> arr{}; [&] {
try { std::array<uint8_t, 4096> arr{};
auto_file.read((char*)arr.data(), fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096)); try {
} catch (const std::ios_base::failure&) { auto_file.read((char*)arr.data(), fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096));
} } catch (const std::ios_base::failure&) {
break; }
} },
case 1: { [&] {
const std::array<uint8_t, 4096> arr{}; const std::array<uint8_t, 4096> arr{};
try { try {
auto_file.write((const char*)arr.data(), fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096)); auto_file.write((const char*)arr.data(), fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096));
} catch (const std::ios_base::failure&) { } catch (const std::ios_base::failure&) {
} }
break; },
} [&] {
case 2: { try {
try { auto_file.ignore(fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096));
auto_file.ignore(fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096)); } catch (const std::ios_base::failure&) {
} catch (const std::ios_base::failure&) { }
} },
break; [&] {
} auto_file.fclose();
case 3: { },
auto_file.fclose(); [&] {
break; ReadFromStream(fuzzed_data_provider, auto_file);
} },
case 4: { [&] {
ReadFromStream(fuzzed_data_provider, auto_file); WriteToStream(fuzzed_data_provider, auto_file);
break; });
}
case 5: {
WriteToStream(fuzzed_data_provider, auto_file);
break;
}
}
} }
(void)auto_file.Get(); (void)auto_file.Get();
(void)auto_file.GetType(); (void)auto_file.GetType();

82
src/test/fuzz/banman.cpp
View File

@ -38,51 +38,43 @@ FUZZ_TARGET_INIT(banman, initialize_banman)
{ {
BanMan ban_man{banlist_file, nullptr, ConsumeBanTimeOffset(fuzzed_data_provider)}; BanMan ban_man{banlist_file, nullptr, ConsumeBanTimeOffset(fuzzed_data_provider)};
while (fuzzed_data_provider.ConsumeBool()) { while (fuzzed_data_provider.ConsumeBool()) {
switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 11)) { CallOneOf(
case 0: { fuzzed_data_provider,
ban_man.Ban(ConsumeNetAddr(fuzzed_data_provider), [&] {
ConsumeBanTimeOffset(fuzzed_data_provider), fuzzed_data_provider.ConsumeBool()); ban_man.Ban(ConsumeNetAddr(fuzzed_data_provider),
break; ConsumeBanTimeOffset(fuzzed_data_provider), fuzzed_data_provider.ConsumeBool());
} },
case 1: { [&] {
ban_man.Ban(ConsumeSubNet(fuzzed_data_provider), ban_man.Ban(ConsumeSubNet(fuzzed_data_provider),
ConsumeBanTimeOffset(fuzzed_data_provider), fuzzed_data_provider.ConsumeBool()); ConsumeBanTimeOffset(fuzzed_data_provider), fuzzed_data_provider.ConsumeBool());
break; },
} [&] {
case 2: { ban_man.ClearBanned();
ban_man.ClearBanned(); },
break; [] {},
} [&] {
case 4: { ban_man.IsBanned(ConsumeNetAddr(fuzzed_data_provider));
ban_man.IsBanned(ConsumeNetAddr(fuzzed_data_provider)); },
break; [&] {
} ban_man.IsBanned(ConsumeSubNet(fuzzed_data_provider));
case 5: { },
ban_man.IsBanned(ConsumeSubNet(fuzzed_data_provider)); [&] {
break; ban_man.Unban(ConsumeNetAddr(fuzzed_data_provider));
} },
case 6: { [&] {
ban_man.Unban(ConsumeNetAddr(fuzzed_data_provider)); ban_man.Unban(ConsumeSubNet(fuzzed_data_provider));
break; },
} [&] {
case 7: { banmap_t banmap;
ban_man.Unban(ConsumeSubNet(fuzzed_data_provider)); ban_man.GetBanned(banmap);
break; },
} [&] {
case 8: { ban_man.DumpBanlist();
banmap_t banmap; },
ban_man.GetBanned(banmap); [] {},
break; [&] {
} ban_man.Discourage(ConsumeNetAddr(fuzzed_data_provider));
case 9: { });
ban_man.DumpBanlist();
break;
}
case 11: {
ban_man.Discourage(ConsumeNetAddr(fuzzed_data_provider));
break;
}
}
} }
} }
fs::remove(banlist_file); fs::remove(banlist_file);

78
src/test/fuzz/bloom_filter.cpp
View File

@ -25,47 +25,43 @@ FUZZ_TARGET(bloom_filter)
fuzzed_data_provider.ConsumeIntegral<unsigned int>(), fuzzed_data_provider.ConsumeIntegral<unsigned int>(),
static_cast<unsigned char>(fuzzed_data_provider.PickValueInArray({BLOOM_UPDATE_NONE, BLOOM_UPDATE_ALL, BLOOM_UPDATE_P2PUBKEY_ONLY, BLOOM_UPDATE_MASK}))}; static_cast<unsigned char>(fuzzed_data_provider.PickValueInArray({BLOOM_UPDATE_NONE, BLOOM_UPDATE_ALL, BLOOM_UPDATE_P2PUBKEY_ONLY, BLOOM_UPDATE_MASK}))};
while (fuzzed_data_provider.remaining_bytes() > 0) { while (fuzzed_data_provider.remaining_bytes() > 0) {
switch (fuzzed_data_provider.ConsumeIntegralInRange(0, 3)) { CallOneOf(
case 0: { fuzzed_data_provider,
const std::vector<unsigned char> b = ConsumeRandomLengthByteVector(fuzzed_data_provider); [&] {
(void)bloom_filter.contains(b); const std::vector<unsigned char> b = ConsumeRandomLengthByteVector(fuzzed_data_provider);
bloom_filter.insert(b); (void)bloom_filter.contains(b);
const bool present = bloom_filter.contains(b); bloom_filter.insert(b);
assert(present); const bool present = bloom_filter.contains(b);
break; assert(present);
} },
case 1: { [&] {
const std::optional<COutPoint> out_point = ConsumeDeserializable<COutPoint>(fuzzed_data_provider); const std::optional<COutPoint> out_point = ConsumeDeserializable<COutPoint>(fuzzed_data_provider);
if (!out_point) { if (!out_point) {
break; return;
} }
(void)bloom_filter.contains(*out_point); (void)bloom_filter.contains(*out_point);
bloom_filter.insert(*out_point); bloom_filter.insert(*out_point);
const bool present = bloom_filter.contains(*out_point); const bool present = bloom_filter.contains(*out_point);
assert(present); assert(present);
break; },
} [&] {
case 2: { const std::optional<uint256> u256 = ConsumeDeserializable<uint256>(fuzzed_data_provider);
const std::optional<uint256> u256 = ConsumeDeserializable<uint256>(fuzzed_data_provider); if (!u256) {
if (!u256) { return;
break; }
} (void)bloom_filter.contains(*u256);
(void)bloom_filter.contains(*u256); bloom_filter.insert(*u256);
bloom_filter.insert(*u256); const bool present = bloom_filter.contains(*u256);
const bool present = bloom_filter.contains(*u256); assert(present);
assert(present); },
break; [&] {
} const std::optional<CMutableTransaction> mut_tx = ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider);
case 3: { if (!mut_tx) {
const std::optional<CMutableTransaction> mut_tx = ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider); return;
if (!mut_tx) { }
break; const CTransaction tx{*mut_tx};
} (void)bloom_filter.IsRelevantAndUpdate(tx);
const CTransaction tx{*mut_tx}; });
(void)bloom_filter.IsRelevantAndUpdate(tx);
break;
}
}
(void)bloom_filter.IsWithinSizeConstraints(); (void)bloom_filter.IsWithinSizeConstraints();
} }
} }

65
src/test/fuzz/buffered_file.cpp
View File

@ -31,41 +31,36 @@ FUZZ_TARGET(buffered_file)
if (opt_buffered_file && fuzzed_file != nullptr) { if (opt_buffered_file && fuzzed_file != nullptr) {
bool setpos_fail = false; bool setpos_fail = false;
while (fuzzed_data_provider.ConsumeBool()) { while (fuzzed_data_provider.ConsumeBool()) {
switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 4)) { CallOneOf(
case 0: { fuzzed_data_provider,
std::array<uint8_t, 4096> arr{}; [&] {
try { std::array<uint8_t, 4096> arr{};
opt_buffered_file->read((char*)arr.data(), fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096)); try {
} catch (const std::ios_base::failure&) { opt_buffered_file->read((char*)arr.data(), fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096));
} } catch (const std::ios_base::failure&) {
break; }
} },
case 1: { [&] {
opt_buffered_file->SetLimit(fuzzed_data_provider.ConsumeIntegralInRange<uint64_t>(0, 4096)); opt_buffered_file->SetLimit(fuzzed_data_provider.ConsumeIntegralInRange<uint64_t>(0, 4096));
break; },
} [&] {
case 2: { if (!opt_buffered_file->SetPos(fuzzed_data_provider.ConsumeIntegralInRange<uint64_t>(0, 4096))) {
if (!opt_buffered_file->SetPos(fuzzed_data_provider.ConsumeIntegralInRange<uint64_t>(0, 4096))) { setpos_fail = true;
setpos_fail = true; }
} },
break; [&] {
} if (setpos_fail) {
case 3: { // Calling FindByte(...) after a failed SetPos(...) call may result in an infinite loop.
if (setpos_fail) { return;
// Calling FindByte(...) after a failed SetPos(...) call may result in an infinite loop. }
break; try {
} opt_buffered_file->FindByte(fuzzed_data_provider.ConsumeIntegral<char>());
try { } catch (const std::ios_base::failure&) {
opt_buffered_file->FindByte(fuzzed_data_provider.ConsumeIntegral<char>()); }
} catch (const std::ios_base::failure&) { },
} [&] {
break; ReadFromStream(fuzzed_data_provider, *opt_buffered_file);
} });
case 4: {
ReadFromStream(fuzzed_data_provider, *opt_buffered_file);
break;
}
}
} }
opt_buffered_file->GetPos(); opt_buffered_file->GetPos();
opt_buffered_file->GetType(); opt_buffered_file->GetType();

345
src/test/fuzz/coins_view.cpp
View File

@ -50,103 +50,93 @@ FUZZ_TARGET_INIT(coins_view, initialize_coins_view)
Coin random_coin; Coin random_coin;
CMutableTransaction random_mutable_transaction; CMutableTransaction random_mutable_transaction;
while (fuzzed_data_provider.ConsumeBool()) { while (fuzzed_data_provider.ConsumeBool()) {
switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 9)) { CallOneOf(
case 0: { fuzzed_data_provider,
if (random_coin.IsSpent()) { [&] {
break; if (random_coin.IsSpent()) {
} return;
Coin coin = random_coin;
bool expected_code_path = false;
const bool possible_overwrite = fuzzed_data_provider.ConsumeBool();
try {
coins_view_cache.AddCoin(random_out_point, std::move(coin), possible_overwrite);
expected_code_path = true;
} catch (const std::logic_error& e) {
if (e.what() == std::string{"Attempted to overwrite an unspent coin (when possible_overwrite is false)"}) {
assert(!possible_overwrite);
expected_code_path = true;
} }
} Coin coin = random_coin;
assert(expected_code_path); bool expected_code_path = false;
break; const bool possible_overwrite = fuzzed_data_provider.ConsumeBool();
} try {
case 1: { coins_view_cache.AddCoin(random_out_point, std::move(coin), possible_overwrite);
(void)coins_view_cache.Flush(); expected_code_path = true;
break; } catch (const std::logic_error& e) {
} if (e.what() == std::string{"Attempted to overwrite an unspent coin (when possible_overwrite is false)"}) {
case 2: { assert(!possible_overwrite);
coins_view_cache.SetBestBlock(ConsumeUInt256(fuzzed_data_provider)); expected_code_path = true;
break;
}
case 3: {
Coin move_to;
(void)coins_view_cache.SpendCoin(random_out_point, fuzzed_data_provider.ConsumeBool() ? &move_to : nullptr);
break;
}
case 4: {
coins_view_cache.Uncache(random_out_point);
break;
}
case 5: {
if (fuzzed_data_provider.ConsumeBool()) {
backend_coins_view = CCoinsView{};
}
coins_view_cache.SetBackend(backend_coins_view);
break;
}
case 6: {
const std::optional<COutPoint> opt_out_point = ConsumeDeserializable<COutPoint>(fuzzed_data_provider);
if (!opt_out_point) {
break;
}
random_out_point = *opt_out_point;
break;
}
case 7: {
const std::optional<Coin> opt_coin = ConsumeDeserializable<Coin>(fuzzed_data_provider);
if (!opt_coin) {
break;
}
random_coin = *opt_coin;
break;
}
case 8: {
const std::optional<CMutableTransaction> opt_mutable_transaction = ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider);
if (!opt_mutable_transaction) {
break;
}
random_mutable_transaction = *opt_mutable_transaction;
break;
}
case 9: {
CCoinsMap coins_map;
while (fuzzed_data_provider.ConsumeBool()) {
CCoinsCacheEntry coins_cache_entry;
coins_cache_entry.flags = fuzzed_data_provider.ConsumeIntegral<unsigned char>();
if (fuzzed_data_provider.ConsumeBool()) {
coins_cache_entry.coin = random_coin;
} else {
const std::optional<Coin> opt_coin = ConsumeDeserializable<Coin>(fuzzed_data_provider);
if (!opt_coin) {
break;
} }
coins_cache_entry.coin = *opt_coin;
} }
coins_map.emplace(random_out_point, std::move(coins_cache_entry)); assert(expected_code_path);
} },
bool expected_code_path = false; [&] {
try { (void)coins_view_cache.Flush();
coins_view_cache.BatchWrite(coins_map, fuzzed_data_provider.ConsumeBool() ? ConsumeUInt256(fuzzed_data_provider) : coins_view_cache.GetBestBlock()); },
expected_code_path = true; [&] {
} catch (const std::logic_error& e) { coins_view_cache.SetBestBlock(ConsumeUInt256(fuzzed_data_provider));
if (e.what() == std::string{"FRESH flag misapplied to coin that exists in parent cache"}) { },
[&] {
Coin move_to;
(void)coins_view_cache.SpendCoin(random_out_point, fuzzed_data_provider.ConsumeBool() ? &move_to : nullptr);
},
[&] {
coins_view_cache.Uncache(random_out_point);
},
[&] {
if (fuzzed_data_provider.ConsumeBool()) {
backend_coins_view = CCoinsView{};
}
coins_view_cache.SetBackend(backend_coins_view);
},
[&] {
const std::optional<COutPoint> opt_out_point = ConsumeDeserializable<COutPoint>(fuzzed_data_provider);
if (!opt_out_point) {
return;
}
random_out_point = *opt_out_point;
},
[&] {
const std::optional<Coin> opt_coin = ConsumeDeserializable<Coin>(fuzzed_data_provider);
if (!opt_coin) {
return;
}
random_coin = *opt_coin;
},
[&] {
const std::optional<CMutableTransaction> opt_mutable_transaction = ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider);
if (!opt_mutable_transaction) {
return;
}
random_mutable_transaction = *opt_mutable_transaction;
},
[&] {
CCoinsMap coins_map;
while (fuzzed_data_provider.ConsumeBool()) {
CCoinsCacheEntry coins_cache_entry;
coins_cache_entry.flags = fuzzed_data_provider.ConsumeIntegral<unsigned char>();
if (fuzzed_data_provider.ConsumeBool()) {
coins_cache_entry.coin = random_coin;
} else {
const std::optional<Coin> opt_coin = ConsumeDeserializable<Coin>(fuzzed_data_provider);
if (!opt_coin) {
return;
}
coins_cache_entry.coin = *opt_coin;
}
coins_map.emplace(random_out_point, std::move(coins_cache_entry));
}
bool expected_code_path = false;
try {
coins_view_cache.BatchWrite(coins_map, fuzzed_data_provider.ConsumeBool() ? ConsumeUInt256(fuzzed_data_provider) : coins_view_cache.GetBestBlock());
expected_code_path = true; expected_code_path = true;
} catch (const std::logic_error& e) {
if (e.what() == std::string{"FRESH flag misapplied to coin that exists in parent cache"}) {
expected_code_path = true;
}
} }
} assert(expected_code_path);
assert(expected_code_path); });
break;
}
}
} }
{ {
@ -199,97 +189,90 @@ FUZZ_TARGET_INIT(coins_view, initialize_coins_view)
} }
if (fuzzed_data_provider.ConsumeBool()) { if (fuzzed_data_provider.ConsumeBool()) {
switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 6)) { CallOneOf(
case 0: { fuzzed_data_provider,
const CTransaction transaction{random_mutable_transaction}; [&] {
bool is_spent = false; const CTransaction transaction{random_mutable_transaction};
for (const CTxOut& tx_out : transaction.vout) { bool is_spent = false;
if (Coin{tx_out, 0, transaction.IsCoinBase()}.IsSpent()) { for (const CTxOut& tx_out : transaction.vout) {
is_spent = true; if (Coin{tx_out, 0, transaction.IsCoinBase()}.IsSpent()) {
is_spent = true;
}
} }
} if (is_spent) {
if (is_spent) { // Avoid:
// Avoid: // coins.cpp:69: void CCoinsViewCache::AddCoin(const COutPoint &, Coin &&, bool): Assertion `!coin.IsSpent()' failed.
// coins.cpp:69: void CCoinsViewCache::AddCoin(const COutPoint &, Coin &&, bool): Assertion `!coin.IsSpent()' failed. return;
break; }
} bool expected_code_path = false;
bool expected_code_path = false; const int height = fuzzed_data_provider.ConsumeIntegral<int>();
const int height = fuzzed_data_provider.ConsumeIntegral<int>(); const bool possible_overwrite = fuzzed_data_provider.ConsumeBool();
const bool possible_overwrite = fuzzed_data_provider.ConsumeBool(); try {
try { AddCoins(coins_view_cache, transaction, height, possible_overwrite);
AddCoins(coins_view_cache, transaction, height, possible_overwrite); expected_code_path = true;
expected_code_path = true; } catch (const std::logic_error& e) {
} catch (const std::logic_error& e) { if (e.what() == std::string{"Attempted to overwrite an unspent coin (when possible_overwrite is false)"}) {
if (e.what() == std::string{"Attempted to overwrite an unspent coin (when possible_overwrite is false)"}) { assert(!possible_overwrite);
assert(!possible_overwrite); expected_code_path = true;
}
}
assert(expected_code_path);
},
[&] {
(void)AreInputsStandard(CTransaction{random_mutable_transaction}, coins_view_cache, false);
(void)AreInputsStandard(CTransaction{random_mutable_transaction}, coins_view_cache, true);
},
[&] {
TxValidationState state;
CAmount tx_fee_out;
const CTransaction transaction{random_mutable_transaction};
if (ContainsSpentInput(transaction, coins_view_cache)) {
// Avoid:
// consensus/tx_verify.cpp:171: bool Consensus::CheckTxInputs(const CTransaction &, TxValidationState &, const CCoinsViewCache &, int, CAmount &): Assertion `!coin.IsSpent()' failed.
return;
}
try {
(void)Consensus::CheckTxInputs(transaction, state, coins_view_cache, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), tx_fee_out);
assert(MoneyRange(tx_fee_out));
} catch (const std::runtime_error&) {
}
},
[&] {
const CTransaction transaction{random_mutable_transaction};
if (ContainsSpentInput(transaction, coins_view_cache)) {
// Avoid:
// consensus/tx_verify.cpp:130: unsigned int GetP2SHSigOpCount(const CTransaction &, const CCoinsViewCache &): Assertion `!coin.IsSpent()' failed.
return;
}
(void)GetP2SHSigOpCount(transaction, coins_view_cache);
},
[&] {
const CTransaction transaction{random_mutable_transaction};
if (ContainsSpentInput(transaction, coins_view_cache)) {
// Avoid:
// consensus/tx_verify.cpp:130: unsigned int GetP2SHSigOpCount(const CTransaction &, const CCoinsViewCache &): Assertion `!coin.IsSpent()' failed.
return;
}
const int flags = fuzzed_data_provider.ConsumeIntegral<int>();
if (!transaction.vin.empty() && (flags & SCRIPT_VERIFY_WITNESS) != 0 && (flags & SCRIPT_VERIFY_P2SH) == 0) {
// Avoid:
// script/interpreter.cpp:1705: size_t CountWitnessSigOps(const CScript &, const CScript &, const CScriptWitness *, unsigned int): Assertion `(flags & SCRIPT_VERIFY_P2SH) != 0' failed.
return;
}
(void)GetTransactionSigOpCost(transaction, coins_view_cache, flags);
},
[&] {
CCoinsStats stats;
bool expected_code_path = false;
try {
(void)GetUTXOStats(&coins_view_cache, stats, CoinStatsHashType::HASH_SERIALIZED);
} catch (const std::logic_error&) {
expected_code_path = true; expected_code_path = true;
} }
} assert(expected_code_path);
assert(expected_code_path); },
break; [&] {
} (void)IsWitnessStandard(CTransaction{random_mutable_transaction}, coins_view_cache);
case 1: { });
(void)AreInputsStandard(CTransaction{random_mutable_transaction}, coins_view_cache, false);
(void)AreInputsStandard(CTransaction{random_mutable_transaction}, coins_view_cache, true);
break;
}
case 2: {
TxValidationState state;
CAmount tx_fee_out;
const CTransaction transaction{random_mutable_transaction};
if (ContainsSpentInput(transaction, coins_view_cache)) {
// Avoid:
// consensus/tx_verify.cpp:171: bool Consensus::CheckTxInputs(const CTransaction &, TxValidationState &, const CCoinsViewCache &, int, CAmount &): Assertion `!coin.IsSpent()' failed.
break;
}
try {
(void)Consensus::CheckTxInputs(transaction, state, coins_view_cache, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), tx_fee_out);
assert(MoneyRange(tx_fee_out));
} catch (const std::runtime_error&) {
}
break;
}
case 3: {
const CTransaction transaction{random_mutable_transaction};
if (ContainsSpentInput(transaction, coins_view_cache)) {
// Avoid:
// consensus/tx_verify.cpp:130: unsigned int GetP2SHSigOpCount(const CTransaction &, const CCoinsViewCache &): Assertion `!coin.IsSpent()' failed.
break;
}
(void)GetP2SHSigOpCount(transaction, coins_view_cache);
break;
}
case 4: {
const CTransaction transaction{random_mutable_transaction};
if (ContainsSpentInput(transaction, coins_view_cache)) {
// Avoid:
// consensus/tx_verify.cpp:130: unsigned int GetP2SHSigOpCount(const CTransaction &, const CCoinsViewCache &): Assertion `!coin.IsSpent()' failed.
break;
}
const int flags = fuzzed_data_provider.ConsumeIntegral<int>();
if (!transaction.vin.empty() && (flags & SCRIPT_VERIFY_WITNESS) != 0 && (flags & SCRIPT_VERIFY_P2SH) == 0) {
// Avoid:
// script/interpreter.cpp:1705: size_t CountWitnessSigOps(const CScript &, const CScript &, const CScriptWitness *, unsigned int): Assertion `(flags & SCRIPT_VERIFY_P2SH) != 0' failed.
break;
}
(void)GetTransactionSigOpCost(transaction, coins_view_cache, flags);
break;
}
case 5: {
CCoinsStats stats;
bool expected_code_path = false;
try {
(void)GetUTXOStats(&coins_view_cache, stats, CoinStatsHashType::HASH_SERIALIZED);
} catch (const std::logic_error&) {
expected_code_path = true;
}
assert(expected_code_path);
break;
}
case 6: {
(void)IsWitnessStandard(CTransaction{random_mutable_transaction}, coins_view_cache);
break;
}
}
} }
} }

200
src/test/fuzz/connman.cpp
View File

@ -32,108 +32,104 @@ FUZZ_TARGET_INIT(connman, initialize_connman)
CSubNet random_subnet; CSubNet random_subnet;
std::string random_string; std::string random_string;
while (fuzzed_data_provider.ConsumeBool()) { while (fuzzed_data_provider.ConsumeBool()) {
switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 27)) { CallOneOf(
case 0: fuzzed_data_provider,
random_address = ConsumeAddress(fuzzed_data_provider); [&] {
break; random_address = ConsumeAddress(fuzzed_data_provider);
case 1: },
random_netaddr = ConsumeNetAddr(fuzzed_data_provider); [&] {
break; random_netaddr = ConsumeNetAddr(fuzzed_data_provider);
case 2: },
random_service = ConsumeService(fuzzed_data_provider); [&] {
break; random_service = ConsumeService(fuzzed_data_provider);
case 3: },
random_subnet = ConsumeSubNet(fuzzed_data_provider); [&] {
break; random_subnet = ConsumeSubNet(fuzzed_data_provider);
case 4: },
random_string = fuzzed_data_provider.ConsumeRandomLengthString(64); [&] {
break; random_string = fuzzed_data_provider.ConsumeRandomLengthString(64);
case 5: { },
std::vector<CAddress> addresses; [&] {
while (fuzzed_data_provider.ConsumeBool()) { std::vector<CAddress> addresses;
addresses.push_back(ConsumeAddress(fuzzed_data_provider)); while (fuzzed_data_provider.ConsumeBool()) {
} addresses.push_back(ConsumeAddress(fuzzed_data_provider));
// Limit nTimePenalty to int32_t to avoid signed integer overflow }
(void)connman.AddNewAddresses(addresses, ConsumeAddress(fuzzed_data_provider), fuzzed_data_provider.ConsumeIntegral<int32_t>()); // Limit nTimePenalty to int32_t to avoid signed integer overflow
break; (void)connman.AddNewAddresses(addresses, ConsumeAddress(fuzzed_data_provider), fuzzed_data_provider.ConsumeIntegral<int32_t>());
} },
case 6: [&] {
connman.AddNode(random_string); connman.AddNode(random_string);
break; },
case 7: [&] {
connman.CheckIncomingNonce(fuzzed_data_provider.ConsumeIntegral<uint64_t>()); connman.CheckIncomingNonce(fuzzed_data_provider.ConsumeIntegral<uint64_t>());
break; },
case 8: [&] {
connman.DisconnectNode(fuzzed_data_provider.ConsumeIntegral<NodeId>()); connman.DisconnectNode(fuzzed_data_provider.ConsumeIntegral<NodeId>());
break; },
case 9: [&] {
connman.DisconnectNode(random_netaddr); connman.DisconnectNode(random_netaddr);
break; },
case 10: [&] {
connman.DisconnectNode(random_string); connman.DisconnectNode(random_string);
break; },
case 11: [&] {
connman.DisconnectNode(random_subnet); connman.DisconnectNode(random_subnet);
break; },
case 12: [&] {
connman.ForEachNode([](auto) {}); connman.ForEachNode([](auto) {});
break; },
case 13: [&] {
connman.ForEachNodeThen([](auto) {}, []() {}); connman.ForEachNodeThen([](auto) {}, []() {});
break; },
case 14: [&] {
(void)connman.ForNode(fuzzed_data_provider.ConsumeIntegral<NodeId>(), [&](auto) { return fuzzed_data_provider.ConsumeBool(); }); (void)connman.ForNode(fuzzed_data_provider.ConsumeIntegral<NodeId>(), [&](auto) { return fuzzed_data_provider.ConsumeBool(); });
break; },
case 15: [&] {
(void)connman.GetAddresses(fuzzed_data_provider.ConsumeIntegral<size_t>(), fuzzed_data_provider.ConsumeIntegral<size_t>()); (void)connman.GetAddresses(fuzzed_data_provider.ConsumeIntegral<size_t>(), fuzzed_data_provider.ConsumeIntegral<size_t>());
break; },
case 16: { [&] {
(void)connman.GetAddresses(random_node, fuzzed_data_provider.ConsumeIntegral<size_t>(), fuzzed_data_provider.ConsumeIntegral<size_t>()); (void)connman.GetAddresses(random_node, fuzzed_data_provider.ConsumeIntegral<size_t>(), fuzzed_data_provider.ConsumeIntegral<size_t>());
break; },
} [&] {
case 17: (void)connman.GetDeterministicRandomizer(fuzzed_data_provider.ConsumeIntegral<uint64_t>());
(void)connman.GetDeterministicRandomizer(fuzzed_data_provider.ConsumeIntegral<uint64_t>()); },
break; [&] {
case 18: (void)connman.GetNodeCount(fuzzed_data_provider.PickValueInArray({CConnman::CONNECTIONS_NONE, CConnman::CONNECTIONS_IN, CConnman::CONNECTIONS_OUT, CConnman::CONNECTIONS_ALL}));
(void)connman.GetNodeCount(fuzzed_data_provider.PickValueInArray({CConnman::CONNECTIONS_NONE, CConnman::CONNECTIONS_IN, CConnman::CONNECTIONS_OUT, CConnman::CONNECTIONS_ALL})); },
break; [&] {
case 19: connman.MarkAddressGood(random_address);
connman.MarkAddressGood(random_address); },
break; [&] {
case 20: (void)connman.OutboundTargetReached(fuzzed_data_provider.ConsumeBool());
(void)connman.OutboundTargetReached(fuzzed_data_provider.ConsumeBool()); },
break; [&] {
case 21: // Limit now to int32_t to avoid signed integer overflow
// Limit now to int32_t to avoid signed integer overflow (void)connman.PoissonNextSendInbound(fuzzed_data_provider.ConsumeIntegral<int32_t>(), fuzzed_data_provider.ConsumeIntegral<int>());
(void)connman.PoissonNextSendInbound(fuzzed_data_provider.ConsumeIntegral<int32_t>(), fuzzed_data_provider.ConsumeIntegral<int>()); },
break; [&] {
case 22: { CSerializedNetMsg serialized_net_msg;
CSerializedNetMsg serialized_net_msg; serialized_net_msg.m_type = fuzzed_data_provider.ConsumeRandomLengthString(CMessageHeader::COMMAND_SIZE);
serialized_net_msg.m_type = fuzzed_data_provider.ConsumeRandomLengthString(CMessageHeader::COMMAND_SIZE); serialized_net_msg.data = ConsumeRandomLengthByteVector(fuzzed_data_provider);
serialized_net_msg.data = ConsumeRandomLengthByteVector(fuzzed_data_provider); connman.PushMessage(&random_node, std::move(serialized_net_msg));
connman.PushMessage(&random_node, std::move(serialized_net_msg)); },
break; [&] {
} connman.RemoveAddedNode(random_string);
case 23: },
connman.RemoveAddedNode(random_string); [&] {
break; const std::vector<bool> asmap = ConsumeRandomLengthBitVector(fuzzed_data_provider);
case 24: { if (SanityCheckASMap(asmap)) {
const std::vector<bool> asmap = ConsumeRandomLengthBitVector(fuzzed_data_provider); connman.SetAsmap(asmap);
if (SanityCheckASMap(asmap)) { }
connman.SetAsmap(asmap); },
} [&] {
break; connman.SetNetworkActive(fuzzed_data_provider.ConsumeBool());
} },
case 25: [&] {
connman.SetNetworkActive(fuzzed_data_provider.ConsumeBool()); connman.SetServices(random_service, ConsumeWeakEnum(fuzzed_data_provider, ALL_SERVICE_FLAGS));
break; },
case 26: [&] {
connman.SetServices(random_service, ConsumeWeakEnum(fuzzed_data_provider, ALL_SERVICE_FLAGS)); connman.SetTryNewOutboundPeer(fuzzed_data_provider.ConsumeBool());
break; });
case 27:
connman.SetTryNewOutboundPeer(fuzzed_data_provider.ConsumeBool());
break;
}
} }
(void)connman.GetAddedNodeInfo(); (void)connman.GetAddedNodeInfo();
(void)connman.GetExtraFullOutboundCount(); (void)connman.GetExtraFullOutboundCount();

184
src/test/fuzz/crypto.cpp
View File

@ -39,109 +39,95 @@ FUZZ_TARGET(crypto)
MuHash3072 muhash; MuHash3072 muhash;
while (fuzzed_data_provider.ConsumeBool()) { while (fuzzed_data_provider.ConsumeBool()) {
switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 2)) { CallOneOf(
case 0: { fuzzed_data_provider,
if (fuzzed_data_provider.ConsumeBool()) { [&] {
data = ConsumeRandomLengthByteVector(fuzzed_data_provider); if (fuzzed_data_provider.ConsumeBool()) {
if (data.empty()) { data = ConsumeRandomLengthByteVector(fuzzed_data_provider);
data.resize(fuzzed_data_provider.ConsumeIntegralInRange<size_t>(1, 4096), fuzzed_data_provider.ConsumeIntegral<uint8_t>()); if (data.empty()) {
data.resize(fuzzed_data_provider.ConsumeIntegralInRange<size_t>(1, 4096), fuzzed_data_provider.ConsumeIntegral<uint8_t>());
}
} }
}
(void)hash160.Write(data); (void)hash160.Write(data);
(void)hash256.Write(data); (void)hash256.Write(data);
(void)hmac_sha256.Write(data.data(), data.size()); (void)hmac_sha256.Write(data.data(), data.size());
(void)hmac_sha512.Write(data.data(), data.size()); (void)hmac_sha512.Write(data.data(), data.size());
(void)ripemd160.Write(data.data(), data.size()); (void)ripemd160.Write(data.data(), data.size());
(void)sha1.Write(data.data(), data.size()); (void)sha1.Write(data.data(), data.size());
(void)sha256.Write(data.data(), data.size()); (void)sha256.Write(data.data(), data.size());
(void)sha3.Write(data); (void)sha3.Write(data);
(void)sha512.Write(data.data(), data.size()); (void)sha512.Write(data.data(), data.size());
(void)sip_hasher.Write(data.data(), data.size()); (void)sip_hasher.Write(data.data(), data.size());
(void)Hash(data); (void)Hash(data);
(void)Hash160(data); (void)Hash160(data);
(void)sha512.Size(); (void)sha512.Size();
if (fuzzed_data_provider.ConsumeBool()) { if (fuzzed_data_provider.ConsumeBool()) {
muhash *= MuHash3072(data); muhash *= MuHash3072(data);
} else { } else {
muhash /= MuHash3072(data); muhash /= MuHash3072(data);
} }
break; },
} [&] {
case 1: { (void)hash160.Reset();
(void)hash160.Reset(); (void)hash256.Reset();
(void)hash256.Reset(); (void)ripemd160.Reset();
(void)ripemd160.Reset(); (void)sha1.Reset();
(void)sha1.Reset(); (void)sha256.Reset();
(void)sha256.Reset(); (void)sha3.Reset();
(void)sha3.Reset(); (void)sha512.Reset();
(void)sha512.Reset(); muhash = MuHash3072();
muhash = MuHash3072(); },
break; [&] {
} CallOneOf(
case 2: { fuzzed_data_provider,
switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 10)) { [&] {
case 0: { data.resize(CHash160::OUTPUT_SIZE);
data.resize(CHash160::OUTPUT_SIZE); hash160.Finalize(data);
hash160.Finalize(data); },
break; [&] {
} data.resize(CHash256::OUTPUT_SIZE);
case 1: { hash256.Finalize(data);
data.resize(CHash256::OUTPUT_SIZE); },
hash256.Finalize(data); [&] {
break; data.resize(CHMAC_SHA256::OUTPUT_SIZE);
} hmac_sha256.Finalize(data.data());
case 2: { },
data.resize(CHMAC_SHA256::OUTPUT_SIZE); [&] {
hmac_sha256.Finalize(data.data()); data.resize(CHMAC_SHA512::OUTPUT_SIZE);
break; hmac_sha512.Finalize(data.data());
} },
case 3: { [&] {
data.resize(CHMAC_SHA512::OUTPUT_SIZE); data.resize(CRIPEMD160::OUTPUT_SIZE);
hmac_sha512.Finalize(data.data()); ripemd160.Finalize(data.data());
break; },
} [&] {
case 4: { data.resize(CSHA1::OUTPUT_SIZE);
data.resize(CRIPEMD160::OUTPUT_SIZE); sha1.Finalize(data.data());
ripemd160.Finalize(data.data()); },
break; [&] {
} data.resize(CSHA256::OUTPUT_SIZE);
case 5: { sha256.Finalize(data.data());
data.resize(CSHA1::OUTPUT_SIZE); },
sha1.Finalize(data.data()); [&] {
break; data.resize(CSHA512::OUTPUT_SIZE);
} sha512.Finalize(data.data());
case 6: { },
data.resize(CSHA256::OUTPUT_SIZE); [&] {
sha256.Finalize(data.data()); data.resize(1);
break; data[0] = sip_hasher.Finalize() % 256;
} },
case 7: { [&] {
data.resize(CSHA512::OUTPUT_SIZE); data.resize(SHA3_256::OUTPUT_SIZE);
sha512.Finalize(data.data()); sha3.Finalize(data);
break; },
} [&] {
case 8: { uint256 out;
data.resize(1); muhash.Finalize(out);
data[0] = sip_hasher.Finalize() % 256; });
break; });
}
case 9: {
data.resize(SHA3_256::OUTPUT_SIZE);
sha3.Finalize(data);
break;
}
case 10: {
uint256 out;
muhash.Finalize(out);
break;
}
}
break;
}
}
} }
if (fuzzed_data_provider.ConsumeBool()) { if (fuzzed_data_provider.ConsumeBool()) {
uint64_t state[25]; uint64_t state[25];

47
src/test/fuzz/crypto_chacha20.cpp
View File

@ -20,31 +20,26 @@ FUZZ_TARGET(crypto_chacha20)
chacha20 = ChaCha20{key.data(), key.size()}; chacha20 = ChaCha20{key.data(), key.size()};
} }
while (fuzzed_data_provider.ConsumeBool()) { while (fuzzed_data_provider.ConsumeBool()) {
switch (fuzzed_data_provider.ConsumeIntegralInRange(0, 4)) { CallOneOf(
case 0: { fuzzed_data_provider,
const std::vector<unsigned char> key = ConsumeFixedLengthByteVector(fuzzed_data_provider, fuzzed_data_provider.ConsumeIntegralInRange<size_t>(16, 32)); [&] {
chacha20.SetKey(key.data(), key.size()); const std::vector<unsigned char> key = ConsumeFixedLengthByteVector(fuzzed_data_provider, fuzzed_data_provider.ConsumeIntegralInRange<size_t>(16, 32));
break; chacha20.SetKey(key.data(), key.size());
} },
case 1: { [&] {
chacha20.SetIV(fuzzed_data_provider.ConsumeIntegral<uint64_t>()); chacha20.SetIV(fuzzed_data_provider.ConsumeIntegral<uint64_t>());
break; },
} [&] {
case 2: { chacha20.Seek(fuzzed_data_provider.ConsumeIntegral<uint64_t>());
chacha20.Seek(fuzzed_data_provider.ConsumeIntegral<uint64_t>()); },
break; [&] {
} std::vector<uint8_t> output(fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096));
case 3: { chacha20.Keystream(output.data(), output.size());
std::vector<uint8_t> output(fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096)); },
chacha20.Keystream(output.data(), output.size()); [&] {
break; std::vector<uint8_t> output(fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096));
} const std::vector<uint8_t> input = ConsumeFixedLengthByteVector(fuzzed_data_provider, output.size());
case 4: { chacha20.Crypt(input.data(), output.data(), input.size());
std::vector<uint8_t> output(fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096)); });
const std::vector<uint8_t> input = ConsumeFixedLengthByteVector(fuzzed_data_provider, output.size());
chacha20.Crypt(input.data(), output.data(), input.size());
break;
}
}
} }
} }

71
src/test/fuzz/crypto_chacha20_poly1305_aead.cpp
View File

@ -29,44 +29,37 @@ FUZZ_TARGET(crypto_chacha20_poly1305_aead)
std::vector<uint8_t> out(buffer_size + CHACHA20_POLY1305_AEAD_AAD_LEN + POLY1305_TAGLEN, 0); std::vector<uint8_t> out(buffer_size + CHACHA20_POLY1305_AEAD_AAD_LEN + POLY1305_TAGLEN, 0);
bool is_encrypt = fuzzed_data_provider.ConsumeBool(); bool is_encrypt = fuzzed_data_provider.ConsumeBool();
while (fuzzed_data_provider.ConsumeBool()) { while (fuzzed_data_provider.ConsumeBool()) {
switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 6)) { CallOneOf(
case 0: { fuzzed_data_provider,
buffer_size = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(64, 4096); [&] {
in = std::vector<uint8_t>(buffer_size + CHACHA20_POLY1305_AEAD_AAD_LEN + POLY1305_TAGLEN, 0); buffer_size = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(64, 4096);
out = std::vector<uint8_t>(buffer_size + CHACHA20_POLY1305_AEAD_AAD_LEN + POLY1305_TAGLEN, 0); in = std::vector<uint8_t>(buffer_size + CHACHA20_POLY1305_AEAD_AAD_LEN + POLY1305_TAGLEN, 0);
break; out = std::vector<uint8_t>(buffer_size + CHACHA20_POLY1305_AEAD_AAD_LEN + POLY1305_TAGLEN, 0);
} },
case 1: { [&] {
(void)aead.Crypt(seqnr_payload, seqnr_aad, aad_pos, out.data(), out.size(), in.data(), buffer_size, is_encrypt); (void)aead.Crypt(seqnr_payload, seqnr_aad, aad_pos, out.data(), out.size(), in.data(), buffer_size, is_encrypt);
break; },
} [&] {
case 2: { uint32_t len = 0;
uint32_t len = 0; const bool ok = aead.GetLength(&len, seqnr_aad, aad_pos, in.data());
const bool ok = aead.GetLength(&len, seqnr_aad, aad_pos, in.data()); assert(ok);
assert(ok); },
break; [&] {
} seqnr_payload += 1;
case 3: { aad_pos += CHACHA20_POLY1305_AEAD_AAD_LEN;
seqnr_payload += 1; if (aad_pos + CHACHA20_POLY1305_AEAD_AAD_LEN > CHACHA20_ROUND_OUTPUT) {
aad_pos += CHACHA20_POLY1305_AEAD_AAD_LEN; aad_pos = 0;
if (aad_pos + CHACHA20_POLY1305_AEAD_AAD_LEN > CHACHA20_ROUND_OUTPUT) { seqnr_aad += 1;
aad_pos = 0; }
seqnr_aad += 1; },
} [&] {
break; seqnr_payload = fuzzed_data_provider.ConsumeIntegral<int>();
} },
case 4: { [&] {
seqnr_payload = fuzzed_data_provider.ConsumeIntegral<int>(); seqnr_aad = fuzzed_data_provider.ConsumeIntegral<int>();
break; },
} [&] {
case 5: { is_encrypt = fuzzed_data_provider.ConsumeBool();
seqnr_aad = fuzzed_data_provider.ConsumeIntegral<int>(); });
break;
}
case 6: {
is_encrypt = fuzzed_data_provider.ConsumeBool();
break;
}
}
} }
} }

50
src/test/fuzz/merkleblock.cpp
View File

@ -17,33 +17,31 @@ FUZZ_TARGET(merkleblock)
{ {
FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size()); FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
CPartialMerkleTree partial_merkle_tree; CPartialMerkleTree partial_merkle_tree;
switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 1)) { CallOneOf(
case 0: { fuzzed_data_provider,
const std::optional<CPartialMerkleTree> opt_partial_merkle_tree = ConsumeDeserializable<CPartialMerkleTree>(fuzzed_data_provider); [&] {
if (opt_partial_merkle_tree) { const std::optional<CPartialMerkleTree> opt_partial_merkle_tree = ConsumeDeserializable<CPartialMerkleTree>(fuzzed_data_provider);
partial_merkle_tree = *opt_partial_merkle_tree; if (opt_partial_merkle_tree) {
} partial_merkle_tree = *opt_partial_merkle_tree;
break;
}
case 1: {
CMerkleBlock merkle_block;
const std::optional<CBlock> opt_block = ConsumeDeserializable<CBlock>(fuzzed_data_provider);
CBloomFilter bloom_filter;
std::set<uint256> txids;
if (opt_block && !opt_block->vtx.empty()) {
if (fuzzed_data_provider.ConsumeBool()) {
merkle_block = CMerkleBlock{*opt_block, bloom_filter};
} else if (fuzzed_data_provider.ConsumeBool()) {
while (fuzzed_data_provider.ConsumeBool()) {
txids.insert(ConsumeUInt256(fuzzed_data_provider));
}
merkle_block = CMerkleBlock{*opt_block, txids};
} }
} },
partial_merkle_tree = merkle_block.txn; [&] {
break; CMerkleBlock merkle_block;
} const std::optional<CBlock> opt_block = ConsumeDeserializable<CBlock>(fuzzed_data_provider);
} CBloomFilter bloom_filter;
std::set<uint256> txids;
if (opt_block && !opt_block->vtx.empty()) {
if (fuzzed_data_provider.ConsumeBool()) {
merkle_block = CMerkleBlock{*opt_block, bloom_filter};
} else if (fuzzed_data_provider.ConsumeBool()) {
while (fuzzed_data_provider.ConsumeBool()) {
txids.insert(ConsumeUInt256(fuzzed_data_provider));
}
merkle_block = CMerkleBlock{*opt_block, txids};
}
}
partial_merkle_tree = merkle_block.txn;
});
(void)partial_merkle_tree.GetNumTransactions(); (void)partial_merkle_tree.GetNumTransactions();
std::vector<uint256> matches; std::vector<uint256> matches;
std::vector<unsigned int> indices; std::vector<unsigned int> indices;

147
src/test/fuzz/net.cpp
View File

@ -32,85 +32,74 @@ FUZZ_TARGET_INIT(net, initialize_net)
CNode node{ConsumeNode(fuzzed_data_provider)}; CNode node{ConsumeNode(fuzzed_data_provider)};
node.SetCommonVersion(fuzzed_data_provider.ConsumeIntegral<int>()); node.SetCommonVersion(fuzzed_data_provider.ConsumeIntegral<int>());
while (fuzzed_data_provider.ConsumeBool()) { while (fuzzed_data_provider.ConsumeBool()) {
switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 10)) { CallOneOf(
case 0: { fuzzed_data_provider,
node.CloseSocketDisconnect(); [&] {
break; node.CloseSocketDisconnect();
} },
case 1: { [&] {
node.MaybeSetAddrName(fuzzed_data_provider.ConsumeRandomLengthString(32)); node.MaybeSetAddrName(fuzzed_data_provider.ConsumeRandomLengthString(32));
break; },
} [&] {
case 2: { const std::vector<bool> asmap = ConsumeRandomLengthBitVector(fuzzed_data_provider);
const std::vector<bool> asmap = ConsumeRandomLengthBitVector(fuzzed_data_provider); if (!SanityCheckASMap(asmap)) {
if (!SanityCheckASMap(asmap)) { return;
break; }
} CNodeStats stats;
CNodeStats stats; node.copyStats(stats, asmap);
node.copyStats(stats, asmap); },
break; [&] {
} const CNode* add_ref_node = node.AddRef();
case 3: { assert(add_ref_node == &node);
const CNode* add_ref_node = node.AddRef(); },
assert(add_ref_node == &node); [&] {
break; if (node.GetRefCount() > 0) {
} node.Release();
case 4: { }
if (node.GetRefCount() > 0) { },
node.Release(); [&] {
} if (node.m_addr_known == nullptr) {
break; return;
} }
case 5: { const std::optional<CAddress> addr_opt = ConsumeDeserializable<CAddress>(fuzzed_data_provider);
if (node.m_addr_known == nullptr) { if (!addr_opt) {
break; return;
} }
const std::optional<CAddress> addr_opt = ConsumeDeserializable<CAddress>(fuzzed_data_provider); node.AddAddressKnown(*addr_opt);
if (!addr_opt) { },
break; [&] {
} if (node.m_addr_known == nullptr) {
node.AddAddressKnown(*addr_opt); return;
break; }
} const std::optional<CAddress> addr_opt = ConsumeDeserializable<CAddress>(fuzzed_data_provider);
case 6: { if (!addr_opt) {
if (node.m_addr_known == nullptr) { return;
break; }
} FastRandomContext fast_random_context{ConsumeUInt256(fuzzed_data_provider)};
const std::optional<CAddress> addr_opt = ConsumeDeserializable<CAddress>(fuzzed_data_provider); node.PushAddress(*addr_opt, fast_random_context);
if (!addr_opt) { },
break; [&] {
} const std::optional<CInv> inv_opt = ConsumeDeserializable<CInv>(fuzzed_data_provider);
FastRandomContext fast_random_context{ConsumeUInt256(fuzzed_data_provider)}; if (!inv_opt) {
node.PushAddress(*addr_opt, fast_random_context); return;
break; }
} node.AddKnownTx(inv_opt->hash);
case 7: { },
const std::optional<CInv> inv_opt = ConsumeDeserializable<CInv>(fuzzed_data_provider); [&] {
if (!inv_opt) { node.PushTxInventory(ConsumeUInt256(fuzzed_data_provider));
break; },
} [&] {
node.AddKnownTx(inv_opt->hash); const std::optional<CService> service_opt = ConsumeDeserializable<CService>(fuzzed_data_provider);
break; if (!service_opt) {
} return;
case 8: { }
node.PushTxInventory(ConsumeUInt256(fuzzed_data_provider)); node.SetAddrLocal(*service_opt);
break; },
} [&] {
case 9: { const std::vector<uint8_t> b = ConsumeRandomLengthByteVector(fuzzed_data_provider);
const std::optional<CService> service_opt = ConsumeDeserializable<CService>(fuzzed_data_provider); bool complete;
if (!service_opt) { node.ReceiveMsgBytes(b, complete);
break; });
}
node.SetAddrLocal(*service_opt);
break;
}
case 10: {
const std::vector<uint8_t> b = ConsumeRandomLengthByteVector(fuzzed_data_provider);
bool complete;
node.ReceiveMsgBytes(b, complete);
break;
}
}
} }
(void)node.GetAddrLocal(); (void)node.GetAddrLocal();

68
src/test/fuzz/policy_estimator.cpp
View File

@ -24,46 +24,42 @@ FUZZ_TARGET_INIT(policy_estimator, initialize_policy_estimator)
FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size()); FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
CBlockPolicyEstimator block_policy_estimator; CBlockPolicyEstimator block_policy_estimator;
while (fuzzed_data_provider.ConsumeBool()) { while (fuzzed_data_provider.ConsumeBool()) {
switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 3)) { CallOneOf(
case 0: { fuzzed_data_provider,
const std::optional<CMutableTransaction> mtx = ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider); [&] {
if (!mtx) {
break;
}
const CTransaction tx{*mtx};
block_policy_estimator.processTransaction(ConsumeTxMemPoolEntry(fuzzed_data_provider, tx), fuzzed_data_provider.ConsumeBool());
if (fuzzed_data_provider.ConsumeBool()) {
(void)block_policy_estimator.removeTx(tx.GetHash(), /* inBlock */ fuzzed_data_provider.ConsumeBool());
}
break;
}
case 1: {
std::vector<CTxMemPoolEntry> mempool_entries;
while (fuzzed_data_provider.ConsumeBool()) {
const std::optional<CMutableTransaction> mtx = ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider); const std::optional<CMutableTransaction> mtx = ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider);
if (!mtx) { if (!mtx) {
break; return;
} }
const CTransaction tx{*mtx}; const CTransaction tx{*mtx};
mempool_entries.push_back(ConsumeTxMemPoolEntry(fuzzed_data_provider, tx)); block_policy_estimator.processTransaction(ConsumeTxMemPoolEntry(fuzzed_data_provider, tx), fuzzed_data_provider.ConsumeBool());
} if (fuzzed_data_provider.ConsumeBool()) {
std::vector<const CTxMemPoolEntry*> ptrs; (void)block_policy_estimator.removeTx(tx.GetHash(), /* inBlock */ fuzzed_data_provider.ConsumeBool());
ptrs.reserve(mempool_entries.size()); }
for (const CTxMemPoolEntry& mempool_entry : mempool_entries) { },
ptrs.push_back(&mempool_entry); [&] {
} std::vector<CTxMemPoolEntry> mempool_entries;
block_policy_estimator.processBlock(fuzzed_data_provider.ConsumeIntegral<unsigned int>(), ptrs); while (fuzzed_data_provider.ConsumeBool()) {
break; const std::optional<CMutableTransaction> mtx = ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider);
} if (!mtx) {
case 2: { break;
(void)block_policy_estimator.removeTx(ConsumeUInt256(fuzzed_data_provider), /* inBlock */ fuzzed_data_provider.ConsumeBool()); }
break; const CTransaction tx{*mtx};
} mempool_entries.push_back(ConsumeTxMemPoolEntry(fuzzed_data_provider, tx));
case 3: { }
block_policy_estimator.FlushUnconfirmed(); std::vector<const CTxMemPoolEntry*> ptrs;
break; ptrs.reserve(mempool_entries.size());
} for (const CTxMemPoolEntry& mempool_entry : mempool_entries) {
} ptrs.push_back(&mempool_entry);
}
block_policy_estimator.processBlock(fuzzed_data_provider.ConsumeIntegral<unsigned int>(), ptrs);
},
[&] {
(void)block_policy_estimator.removeTx(ConsumeUInt256(fuzzed_data_provider), /* inBlock */ fuzzed_data_provider.ConsumeBool());
},
[&] {
block_policy_estimator.FlushUnconfirmed();
});
(void)block_policy_estimator.estimateFee(fuzzed_data_provider.ConsumeIntegral<int>()); (void)block_policy_estimator.estimateFee(fuzzed_data_provider.ConsumeIntegral<int>());
EstimationResult result; EstimationResult result;
(void)block_policy_estimator.estimateRawFee(fuzzed_data_provider.ConsumeIntegral<int>(), fuzzed_data_provider.ConsumeFloatingPoint<double>(), fuzzed_data_provider.PickValueInArray(ALL_FEE_ESTIMATE_HORIZONS), fuzzed_data_provider.ConsumeBool() ? &result : nullptr); (void)block_policy_estimator.estimateRawFee(fuzzed_data_provider.ConsumeIntegral<int>(), fuzzed_data_provider.ConsumeFloatingPoint<double>(), fuzzed_data_provider.PickValueInArray(ALL_FEE_ESTIMATE_HORIZONS), fuzzed_data_provider.ConsumeBool() ? &result : nullptr);

46
src/test/fuzz/rolling_bloom_filter.cpp
View File

@ -22,29 +22,27 @@ FUZZ_TARGET(rolling_bloom_filter)
fuzzed_data_provider.ConsumeIntegralInRange<unsigned int>(1, 1000), fuzzed_data_provider.ConsumeIntegralInRange<unsigned int>(1, 1000),
0.999 / fuzzed_data_provider.ConsumeIntegralInRange<unsigned int>(1, std::numeric_limits<unsigned int>::max())}; 0.999 / fuzzed_data_provider.ConsumeIntegralInRange<unsigned int>(1, std::numeric_limits<unsigned int>::max())};
while (fuzzed_data_provider.remaining_bytes() > 0) { while (fuzzed_data_provider.remaining_bytes() > 0) {
switch (fuzzed_data_provider.ConsumeIntegralInRange(0, 2)) { CallOneOf(
case 0: { fuzzed_data_provider,
const std::vector<unsigned char> b = ConsumeRandomLengthByteVector(fuzzed_data_provider); [&] {
(void)rolling_bloom_filter.contains(b); const std::vector<unsigned char> b = ConsumeRandomLengthByteVector(fuzzed_data_provider);
rolling_bloom_filter.insert(b); (void)rolling_bloom_filter.contains(b);
const bool present = rolling_bloom_filter.contains(b); rolling_bloom_filter.insert(b);
assert(present); const bool present = rolling_bloom_filter.contains(b);
break; assert(present);
} },
case 1: { [&] {
const std::optional<uint256> u256 = ConsumeDeserializable<uint256>(fuzzed_data_provider); const std::optional<uint256> u256 = ConsumeDeserializable<uint256>(fuzzed_data_provider);
if (!u256) { if (!u256) {
break; return;
} }
(void)rolling_bloom_filter.contains(*u256); (void)rolling_bloom_filter.contains(*u256);
rolling_bloom_filter.insert(*u256); rolling_bloom_filter.insert(*u256);
const bool present = rolling_bloom_filter.contains(*u256); const bool present = rolling_bloom_filter.contains(*u256);
assert(present); assert(present);
break; },
} [&] {
case 2: rolling_bloom_filter.reset();
rolling_bloom_filter.reset(); });
break;
}
} }
} }

99
src/test/fuzz/script_ops.cpp
View File

@ -16,56 +16,53 @@ FUZZ_TARGET(script_ops)
FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size()); FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
CScript script = ConsumeScript(fuzzed_data_provider); CScript script = ConsumeScript(fuzzed_data_provider);
while (fuzzed_data_provider.remaining_bytes() > 0) { while (fuzzed_data_provider.remaining_bytes() > 0) {
switch (fuzzed_data_provider.ConsumeIntegralInRange(0, 7)) { CallOneOf(
case 0: { fuzzed_data_provider,
CScript s = ConsumeScript(fuzzed_data_provider); [&] {
script = std::move(s); CScript s = ConsumeScript(fuzzed_data_provider);
break; script = std::move(s);
} },
case 1: { [&] {
const CScript& s = ConsumeScript(fuzzed_data_provider); const CScript& s = ConsumeScript(fuzzed_data_provider);
script = s; script = s;
break; },
} [&] {
case 2: script << fuzzed_data_provider.ConsumeIntegral<int64_t>();
script << fuzzed_data_provider.ConsumeIntegral<int64_t>(); },
break; [&] {
case 3: script << ConsumeOpcodeType(fuzzed_data_provider);
script << ConsumeOpcodeType(fuzzed_data_provider); },
break; [&] {
case 4: script << ConsumeScriptNum(fuzzed_data_provider);
script << ConsumeScriptNum(fuzzed_data_provider); },
break; [&] {
case 5: script << ConsumeRandomLengthByteVector(fuzzed_data_provider);
script << ConsumeRandomLengthByteVector(fuzzed_data_provider); },
break; [&] {
case 6: script.clear();
script.clear(); },
break; [&] {
case 7: { (void)script.GetSigOpCount(false);
(void)script.GetSigOpCount(false); (void)script.GetSigOpCount(true);
(void)script.GetSigOpCount(true); (void)script.GetSigOpCount(script);
(void)script.GetSigOpCount(script); (void)script.HasValidOps();
(void)script.HasValidOps(); (void)script.IsPayToScriptHash();
(void)script.IsPayToScriptHash(); (void)script.IsPayToWitnessScriptHash();
(void)script.IsPayToWitnessScriptHash(); (void)script.IsPushOnly();
(void)script.IsPushOnly(); (void)script.IsUnspendable();
(void)script.IsUnspendable(); {
{ CScript::const_iterator pc = script.begin();
CScript::const_iterator pc = script.begin(); opcodetype opcode;
opcodetype opcode; (void)script.GetOp(pc, opcode);
(void)script.GetOp(pc, opcode); std::vector<uint8_t> data;
std::vector<uint8_t> data; (void)script.GetOp(pc, opcode, data);
(void)script.GetOp(pc, opcode, data); (void)script.IsPushOnly(pc);
(void)script.IsPushOnly(pc); }
} {
{ int version;
int version; std::vector<uint8_t> program;
std::vector<uint8_t> program; (void)script.IsWitnessProgram(version, program);
(void)script.IsWitnessProgram(version, program); }
} });
break;
}
}
} }
} }

192
src/test/fuzz/scriptnum_ops.cpp
View File

@ -29,105 +29,99 @@ FUZZ_TARGET(scriptnum_ops)
FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size()); FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
CScriptNum script_num = ConsumeScriptNum(fuzzed_data_provider); CScriptNum script_num = ConsumeScriptNum(fuzzed_data_provider);
while (fuzzed_data_provider.remaining_bytes() > 0) { while (fuzzed_data_provider.remaining_bytes() > 0) {
switch (fuzzed_data_provider.ConsumeIntegralInRange(0, 11)) { CallOneOf(
case 0: { fuzzed_data_provider,
const int64_t i = fuzzed_data_provider.ConsumeIntegral<int64_t>(); [&] {
assert((script_num == i) != (script_num != i)); const int64_t i = fuzzed_data_provider.ConsumeIntegral<int64_t>();
assert((script_num <= i) != (script_num > i)); assert((script_num == i) != (script_num != i));
assert((script_num >= i) != (script_num < i)); assert((script_num <= i) != (script_num > i));
// Avoid signed integer overflow: assert((script_num >= i) != (script_num < i));
// script/script.h:264:93: runtime error: signed integer overflow: -2261405121394637306 + -9223372036854775802 cannot be represented in type 'long' // Avoid signed integer overflow:
if (IsValidAddition(script_num, CScriptNum{i})) { // script/script.h:264:93: runtime error: signed integer overflow: -2261405121394637306 + -9223372036854775802 cannot be represented in type 'long'
assert((script_num + i) - i == script_num); if (IsValidAddition(script_num, CScriptNum{i})) {
} assert((script_num + i) - i == script_num);
// Avoid signed integer overflow: }
// script/script.h:265:93: runtime error: signed integer overflow: 9223371895120855039 - -9223372036854710486 cannot be represented in type 'long' // Avoid signed integer overflow:
if (IsValidSubtraction(script_num, CScriptNum{i})) { // script/script.h:265:93: runtime error: signed integer overflow: 9223371895120855039 - -9223372036854710486 cannot be represented in type 'long'
assert((script_num - i) + i == script_num); if (IsValidSubtraction(script_num, CScriptNum{i})) {
} assert((script_num - i) + i == script_num);
break; }
} },
case 1: { [&] {
const CScriptNum random_script_num = ConsumeScriptNum(fuzzed_data_provider); const CScriptNum random_script_num = ConsumeScriptNum(fuzzed_data_provider);
assert((script_num == random_script_num) != (script_num != random_script_num)); assert((script_num == random_script_num) != (script_num != random_script_num));
assert((script_num <= random_script_num) != (script_num > random_script_num)); assert((script_num <= random_script_num) != (script_num > random_script_num));
assert((script_num >= random_script_num) != (script_num < random_script_num)); assert((script_num >= random_script_num) != (script_num < random_script_num));
// Avoid signed integer overflow: // Avoid signed integer overflow:
// script/script.h:264:93: runtime error: signed integer overflow: -9223126527765971126 + -9223372036854756825 cannot be represented in type 'long' // script/script.h:264:93: runtime error: signed integer overflow: -9223126527765971126 + -9223372036854756825 cannot be represented in type 'long'
if (IsValidAddition(script_num, random_script_num)) { if (IsValidAddition(script_num, random_script_num)) {
assert((script_num + random_script_num) - random_script_num == script_num); assert((script_num + random_script_num) - random_script_num == script_num);
} }
// Avoid signed integer overflow: // Avoid signed integer overflow:
// script/script.h:265:93: runtime error: signed integer overflow: 6052837899185946624 - -9223372036854775808 cannot be represented in type 'long' // script/script.h:265:93: runtime error: signed integer overflow: 6052837899185946624 - -9223372036854775808 cannot be represented in type 'long'
if (IsValidSubtraction(script_num, random_script_num)) { if (IsValidSubtraction(script_num, random_script_num)) {
assert((script_num - random_script_num) + random_script_num == script_num); assert((script_num - random_script_num) + random_script_num == script_num);
} }
break; },
} [&] {
case 2: { const CScriptNum random_script_num = ConsumeScriptNum(fuzzed_data_provider);
const CScriptNum random_script_num = ConsumeScriptNum(fuzzed_data_provider); if (!IsValidAddition(script_num, random_script_num)) {
if (!IsValidAddition(script_num, random_script_num)) { // Avoid assertion failure:
// Avoid assertion failure: // ./script/script.h:292: CScriptNum &CScriptNum::operator+=(const int64_t &): Assertion `rhs == 0 || (rhs > 0 && m_value <= std::numeric_limits<int64_t>::max() - rhs) || (rhs < 0 && m_value >= std::numeric_limits<int64_t>::min() - rhs)' failed.
// ./script/script.h:292: CScriptNum &CScriptNum::operator+=(const int64_t &): Assertion `rhs == 0 || (rhs > 0 && m_value <= std::numeric_limits<int64_t>::max() - rhs) || (rhs < 0 && m_value >= std::numeric_limits<int64_t>::min() - rhs)' failed. return;
break; }
} script_num += random_script_num;
script_num += random_script_num; },
break; [&] {
} const CScriptNum random_script_num = ConsumeScriptNum(fuzzed_data_provider);
case 3: { if (!IsValidSubtraction(script_num, random_script_num)) {
const CScriptNum random_script_num = ConsumeScriptNum(fuzzed_data_provider); // Avoid assertion failure:
if (!IsValidSubtraction(script_num, random_script_num)) { // ./script/script.h:300: CScriptNum &CScriptNum::operator-=(const int64_t &): Assertion `rhs == 0 || (rhs > 0 && m_value >= std::numeric_limits<int64_t>::min() + rhs) || (rhs < 0 && m_value <= std::numeric_limits<int64_t>::max() + rhs)' failed.
// Avoid assertion failure: return;
// ./script/script.h:300: CScriptNum &CScriptNum::operator-=(const int64_t &): Assertion `rhs == 0 || (rhs > 0 && m_value >= std::numeric_limits<int64_t>::min() + rhs) || (rhs < 0 && m_value <= std::numeric_limits<int64_t>::max() + rhs)' failed. }
break; script_num -= random_script_num;
} },
script_num -= random_script_num; [&] {
break; script_num = script_num & fuzzed_data_provider.ConsumeIntegral<int64_t>();
} },
case 4: [&] {
script_num = script_num & fuzzed_data_provider.ConsumeIntegral<int64_t>(); script_num = script_num & ConsumeScriptNum(fuzzed_data_provider);
break; },
case 5: [&] {
script_num = script_num & ConsumeScriptNum(fuzzed_data_provider); script_num &= ConsumeScriptNum(fuzzed_data_provider);
break; },
case 6: [&] {
script_num &= ConsumeScriptNum(fuzzed_data_provider); if (script_num == CScriptNum{std::numeric_limits<int64_t>::min()}) {
break; // Avoid assertion failure:
case 7: // ./script/script.h:279: CScriptNum CScriptNum::operator-() const: Assertion `m_value != std::numeric_limits<int64_t>::min()' failed.
if (script_num == CScriptNum{std::numeric_limits<int64_t>::min()}) { return;
// Avoid assertion failure: }
// ./script/script.h:279: CScriptNum CScriptNum::operator-() const: Assertion `m_value != std::numeric_limits<int64_t>::min()' failed. script_num = -script_num;
break; },
} [&] {
script_num = -script_num; script_num = fuzzed_data_provider.ConsumeIntegral<int64_t>();
break; },
case 8: [&] {
script_num = fuzzed_data_provider.ConsumeIntegral<int64_t>(); const int64_t random_integer = fuzzed_data_provider.ConsumeIntegral<int64_t>();
break; if (!IsValidAddition(script_num, CScriptNum{random_integer})) {
case 9: { // Avoid assertion failure:
const int64_t random_integer = fuzzed_data_provider.ConsumeIntegral<int64_t>(); // ./script/script.h:292: CScriptNum &CScriptNum::operator+=(const int64_t &): Assertion `rhs == 0 || (rhs > 0 && m_value <= std::numeric_limits<int64_t>::max() - rhs) || (rhs < 0 && m_value >= std::numeric_limits<int64_t>::min() - rhs)' failed.
if (!IsValidAddition(script_num, CScriptNum{random_integer})) { return;
// Avoid assertion failure: }
// ./script/script.h:292: CScriptNum &CScriptNum::operator+=(const int64_t &): Assertion `rhs == 0 || (rhs > 0 && m_value <= std::numeric_limits<int64_t>::max() - rhs) || (rhs < 0 && m_value >= std::numeric_limits<int64_t>::min() - rhs)' failed. script_num += random_integer;
break; },
} [&] {
script_num += random_integer; const int64_t random_integer = fuzzed_data_provider.ConsumeIntegral<int64_t>();
break; if (!IsValidSubtraction(script_num, CScriptNum{random_integer})) {
} // Avoid assertion failure:
case 10: { // ./script/script.h:300: CScriptNum &CScriptNum::operator-=(const int64_t &): Assertion `rhs == 0 || (rhs > 0 && m_value >= std::numeric_limits<int64_t>::min() + rhs) || (rhs < 0 && m_value <= std::numeric_limits<int64_t>::max() + rhs)' failed.
const int64_t random_integer = fuzzed_data_provider.ConsumeIntegral<int64_t>(); return;
if (!IsValidSubtraction(script_num, CScriptNum{random_integer})) { }
// Avoid assertion failure: script_num -= random_integer;
// ./script/script.h:300: CScriptNum &CScriptNum::operator-=(const int64_t &): Assertion `rhs == 0 || (rhs > 0 && m_value >= std::numeric_limits<int64_t>::min() + rhs) || (rhs < 0 && m_value <= std::numeric_limits<int64_t>::max() + rhs)' failed. },
break; [&] {
} script_num &= fuzzed_data_provider.ConsumeIntegral<int64_t>();
script_num -= random_integer; });
break;
}
case 11:
script_num &= fuzzed_data_provider.ConsumeIntegral<int64_t>();
break;
}
(void)script_num.getint(); (void)script_num.getint();
(void)script_num.getvch(); (void)script_num.getvch();
} }

121
src/test/fuzz/strprintf.cpp
View File

@ -4,6 +4,7 @@
#include <test/fuzz/FuzzedDataProvider.h> #include <test/fuzz/FuzzedDataProvider.h>
#include <test/fuzz/fuzz.h> #include <test/fuzz/fuzz.h>
#include <test/fuzz/util.h>
#include <tinyformat.h> #include <tinyformat.h>
#include <util/strencodings.h> #include <util/strencodings.h>
#include <util/translation.h> #include <util/translation.h>
@ -109,32 +110,32 @@ FUZZ_TARGET(str_printf)
} }
try { try {
switch (fuzzed_data_provider.ConsumeIntegralInRange(0, 5)) { CallOneOf(
case 0: fuzzed_data_provider,
(void)strprintf(format_string, fuzzed_data_provider.ConsumeRandomLengthString(32)); [&] {
(void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeRandomLengthString(32)); (void)strprintf(format_string, fuzzed_data_provider.ConsumeRandomLengthString(32));
break; (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeRandomLengthString(32));
case 1: },
(void)strprintf(format_string, fuzzed_data_provider.ConsumeRandomLengthString(32).c_str()); [&] {
(void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeRandomLengthString(32).c_str()); (void)strprintf(format_string, fuzzed_data_provider.ConsumeRandomLengthString(32).c_str());
break; (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeRandomLengthString(32).c_str());
case 2: },
(void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<signed char>()); [&] {
(void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<signed char>()); (void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<signed char>());
break; (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<signed char>());
case 3: },
(void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<unsigned char>()); [&] {
(void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<unsigned char>()); (void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<unsigned char>());
break; (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<unsigned char>());
case 4: },
(void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<char>()); [&] {
(void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<char>()); (void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<char>());
break; (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<char>());
case 5: },
(void)strprintf(format_string, fuzzed_data_provider.ConsumeBool()); [&] {
(void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeBool()); (void)strprintf(format_string, fuzzed_data_provider.ConsumeBool());
break; (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeBool());
} });
} catch (const tinyformat::format_error&) { } catch (const tinyformat::format_error&) {
} }
@ -155,40 +156,40 @@ FUZZ_TARGET(str_printf)
} }
try { try {
switch (fuzzed_data_provider.ConsumeIntegralInRange(0, 7)) { CallOneOf(
case 0: fuzzed_data_provider,
(void)strprintf(format_string, fuzzed_data_provider.ConsumeFloatingPoint<float>()); [&] {
(void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeFloatingPoint<float>()); (void)strprintf(format_string, fuzzed_data_provider.ConsumeFloatingPoint<float>());
break; (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeFloatingPoint<float>());
case 1: },
(void)strprintf(format_string, fuzzed_data_provider.ConsumeFloatingPoint<double>()); [&] {
(void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeFloatingPoint<double>()); (void)strprintf(format_string, fuzzed_data_provider.ConsumeFloatingPoint<double>());
break; (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeFloatingPoint<double>());
case 2: },
(void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<int16_t>()); [&] {
(void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<int16_t>()); (void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<int16_t>());
break; (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<int16_t>());
case 3: },
(void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<uint16_t>()); [&] {
(void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<uint16_t>()); (void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<uint16_t>());
break; (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<uint16_t>());
case 4: },
(void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<int32_t>()); [&] {
(void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<int32_t>()); (void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<int32_t>());
break; (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<int32_t>());
case 5: },
(void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<uint32_t>()); [&] {
(void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<uint32_t>()); (void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<uint32_t>());
break; (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<uint32_t>());
case 6: },
(void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<int64_t>()); [&] {
(void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<int64_t>()); (void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<int64_t>());
break; (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<int64_t>());
case 7: },
(void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<uint64_t>()); [&] {
(void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<uint64_t>()); (void)strprintf(format_string, fuzzed_data_provider.ConsumeIntegral<uint64_t>());
break; (void)tinyformat::format(bilingual_string, fuzzed_data_provider.ConsumeIntegral<uint64_t>());
} });
} catch (const tinyformat::format_error&) { } catch (const tinyformat::format_error&) {
} }
} }

118
src/test/fuzz/system.cpp
View File

@ -32,71 +32,63 @@ FUZZ_TARGET(system)
} }
while (fuzzed_data_provider.ConsumeBool()) { while (fuzzed_data_provider.ConsumeBool()) {
switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 7)) { CallOneOf(
case 0: { fuzzed_data_provider,
args_manager.SelectConfigNetwork(fuzzed_data_provider.ConsumeRandomLengthString(16)); [&] {
break; args_manager.SelectConfigNetwork(fuzzed_data_provider.ConsumeRandomLengthString(16));
} },
case 1: { [&] {
args_manager.SoftSetArg(fuzzed_data_provider.ConsumeRandomLengthString(16), fuzzed_data_provider.ConsumeRandomLengthString(16)); args_manager.SoftSetArg(fuzzed_data_provider.ConsumeRandomLengthString(16), fuzzed_data_provider.ConsumeRandomLengthString(16));
break; },
} [&] {
case 2: { args_manager.ForceSetArg(fuzzed_data_provider.ConsumeRandomLengthString(16), fuzzed_data_provider.ConsumeRandomLengthString(16));
args_manager.ForceSetArg(fuzzed_data_provider.ConsumeRandomLengthString(16), fuzzed_data_provider.ConsumeRandomLengthString(16)); },
break; [&] {
} args_manager.SoftSetBoolArg(fuzzed_data_provider.ConsumeRandomLengthString(16), fuzzed_data_provider.ConsumeBool());
case 3: { },
args_manager.SoftSetBoolArg(fuzzed_data_provider.ConsumeRandomLengthString(16), fuzzed_data_provider.ConsumeBool()); [&] {
break; const OptionsCategory options_category = fuzzed_data_provider.PickValueInArray<OptionsCategory>({OptionsCategory::OPTIONS, OptionsCategory::CONNECTION, OptionsCategory::WALLET, OptionsCategory::WALLET_DEBUG_TEST, OptionsCategory::ZMQ, OptionsCategory::DEBUG_TEST, OptionsCategory::CHAINPARAMS, OptionsCategory::NODE_RELAY, OptionsCategory::BLOCK_CREATION, OptionsCategory::RPC, OptionsCategory::GUI, OptionsCategory::COMMANDS, OptionsCategory::REGISTER_COMMANDS, OptionsCategory::HIDDEN});
} // Avoid hitting:
case 4: { // util/system.cpp:425: void ArgsManager::AddArg(const std::string &, const std::string &, unsigned int, const OptionsCategory &): Assertion `ret.second' failed.
const OptionsCategory options_category = fuzzed_data_provider.PickValueInArray<OptionsCategory>({OptionsCategory::OPTIONS, OptionsCategory::CONNECTION, OptionsCategory::WALLET, OptionsCategory::WALLET_DEBUG_TEST, OptionsCategory::ZMQ, OptionsCategory::DEBUG_TEST, OptionsCategory::CHAINPARAMS, OptionsCategory::NODE_RELAY, OptionsCategory::BLOCK_CREATION, OptionsCategory::RPC, OptionsCategory::GUI, OptionsCategory::COMMANDS, OptionsCategory::REGISTER_COMMANDS, OptionsCategory::HIDDEN}); const std::string argument_name = GetArgumentName(fuzzed_data_provider.ConsumeRandomLengthString(16));
// Avoid hitting: if (args_manager.GetArgFlags(argument_name) != nullopt) {
// util/system.cpp:425: void ArgsManager::AddArg(const std::string &, const std::string &, unsigned int, const OptionsCategory &): Assertion `ret.second' failed. return;
const std::string argument_name = GetArgumentName(fuzzed_data_provider.ConsumeRandomLengthString(16));
if (args_manager.GetArgFlags(argument_name) != nullopt) {
break;
}
args_manager.AddArg(argument_name, fuzzed_data_provider.ConsumeRandomLengthString(16), fuzzed_data_provider.ConsumeIntegral<unsigned int>(), options_category);
break;
}
case 5: {
// Avoid hitting:
// util/system.cpp:425: void ArgsManager::AddArg(const std::string &, const std::string &, unsigned int, const OptionsCategory &): Assertion `ret.second' failed.
const std::vector<std::string> names = ConsumeRandomLengthStringVector(fuzzed_data_provider);
std::vector<std::string> hidden_arguments;
for (const std::string& name : names) {
const std::string hidden_argument = GetArgumentName(name);
if (args_manager.GetArgFlags(hidden_argument) != nullopt) {
continue;
} }
if (std::find(hidden_arguments.begin(), hidden_arguments.end(), hidden_argument) != hidden_arguments.end()) { args_manager.AddArg(argument_name, fuzzed_data_provider.ConsumeRandomLengthString(16), fuzzed_data_provider.ConsumeIntegral<unsigned int>(), options_category);
continue; },
[&] {
// Avoid hitting:
// util/system.cpp:425: void ArgsManager::AddArg(const std::string &, const std::string &, unsigned int, const OptionsCategory &): Assertion `ret.second' failed.
const std::vector<std::string> names = ConsumeRandomLengthStringVector(fuzzed_data_provider);
std::vector<std::string> hidden_arguments;
for (const std::string& name : names) {
const std::string hidden_argument = GetArgumentName(name);
if (args_manager.GetArgFlags(hidden_argument) != nullopt) {
continue;
}
if (std::find(hidden_arguments.begin(), hidden_arguments.end(), hidden_argument) != hidden_arguments.end()) {
continue;
}
hidden_arguments.push_back(hidden_argument);
} }
hidden_arguments.push_back(hidden_argument); args_manager.AddHiddenArgs(hidden_arguments);
} },
args_manager.AddHiddenArgs(hidden_arguments); [&] {
break; args_manager.ClearArgs();
} },
case 6: { [&] {
args_manager.ClearArgs(); const std::vector<std::string> random_arguments = ConsumeRandomLengthStringVector(fuzzed_data_provider);
break; std::vector<const char*> argv;
} argv.reserve(random_arguments.size());
case 7: { for (const std::string& random_argument : random_arguments) {
const std::vector<std::string> random_arguments = ConsumeRandomLengthStringVector(fuzzed_data_provider); argv.push_back(random_argument.c_str());
std::vector<const char*> argv; }
argv.reserve(random_arguments.size()); try {
for (const std::string& random_argument : random_arguments) { std::string error;
argv.push_back(random_argument.c_str()); (void)args_manager.ParseParameters(argv.size(), argv.data(), error);
} } catch (const std::logic_error&) {
try { }
std::string error; });
(void)args_manager.ParseParameters(argv.size(), argv.data(), error);
} catch (const std::logic_error&) {
}
break;
}
}
} }
const std::string s1 = fuzzed_data_provider.ConsumeRandomLengthString(16); const std::string s1 = fuzzed_data_provider.ConsumeRandomLengthString(16);

195
src/test/fuzz/util.h
View File

@ -36,6 +36,17 @@
#include <string> #include <string>
#include <vector> #include <vector>
template <typename... Callables>
void CallOneOf(FuzzedDataProvider& fuzzed_data_provider, Callables... callables)
{
constexpr size_t call_size{sizeof...(callables)};
static_assert(call_size >= 1);
const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, call_size - 1)};
size_t i{0};
return ((i++ == call_index ? callables() : void()), ...);
}
[[nodiscard]] inline std::vector<uint8_t> ConsumeRandomLengthByteVector(FuzzedDataProvider& fuzzed_data_provider, const size_t max_length = 4096) noexcept [[nodiscard]] inline std::vector<uint8_t> ConsumeRandomLengthByteVector(FuzzedDataProvider& fuzzed_data_provider, const size_t max_length = 4096) noexcept
{ {
const std::string s = fuzzed_data_provider.ConsumeRandomLengthString(max_length); const std::string s = fuzzed_data_provider.ConsumeRandomLengthString(max_length);
@ -165,37 +176,31 @@ template <typename WeakEnumType, size_t size>
[[nodiscard]] inline CTxDestination ConsumeTxDestination(FuzzedDataProvider& fuzzed_data_provider) noexcept [[nodiscard]] inline CTxDestination ConsumeTxDestination(FuzzedDataProvider& fuzzed_data_provider) noexcept
{ {
CTxDestination tx_destination; CTxDestination tx_destination;
switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 5)) { CallOneOf(
case 0: { fuzzed_data_provider,
tx_destination = CNoDestination{}; [&] {
break; tx_destination = CNoDestination{};
} },
case 1: { [&] {
tx_destination = PKHash{ConsumeUInt160(fuzzed_data_provider)}; tx_destination = PKHash{ConsumeUInt160(fuzzed_data_provider)};
break; },
} [&] {
case 2: { tx_destination = ScriptHash{ConsumeUInt160(fuzzed_data_provider)};
tx_destination = ScriptHash{ConsumeUInt160(fuzzed_data_provider)}; },
break; [&] {
} tx_destination = WitnessV0ScriptHash{ConsumeUInt256(fuzzed_data_provider)};
case 3: { },
tx_destination = WitnessV0ScriptHash{ConsumeUInt256(fuzzed_data_provider)}; [&] {
break; tx_destination = WitnessV0KeyHash{ConsumeUInt160(fuzzed_data_provider)};
} },
case 4: { [&] {
tx_destination = WitnessV0KeyHash{ConsumeUInt160(fuzzed_data_provider)}; WitnessUnknown witness_unknown{};
break; witness_unknown.version = fuzzed_data_provider.ConsumeIntegral<int>();
} const std::vector<uint8_t> witness_unknown_program_1 = fuzzed_data_provider.ConsumeBytes<uint8_t>(40);
case 5: { witness_unknown.length = witness_unknown_program_1.size();
WitnessUnknown witness_unknown{}; std::copy(witness_unknown_program_1.begin(), witness_unknown_program_1.end(), witness_unknown.program);
witness_unknown.version = fuzzed_data_provider.ConsumeIntegral<int>(); tx_destination = witness_unknown;
const std::vector<uint8_t> witness_unknown_program_1 = fuzzed_data_provider.ConsumeBytes<uint8_t>(40); });
witness_unknown.length = witness_unknown_program_1.size();
std::copy(witness_unknown_program_1.begin(), witness_unknown_program_1.end(), witness_unknown.program);
tx_destination = witness_unknown;
break;
}
}
return tx_destination; return tx_destination;
} }
@ -354,32 +359,26 @@ public:
return nullptr; return nullptr;
} }
std::string mode; std::string mode;
switch (m_fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 5)) { CallOneOf(
case 0: { m_fuzzed_data_provider,
mode = "r"; [&] {
break; mode = "r";
} },
case 1: { [&] {
mode = "r+"; mode = "r+";
break; },
} [&] {
case 2: { mode = "w";
mode = "w"; },
break; [&] {
} mode = "w+";
case 3: { },
mode = "w+"; [&] {
break; mode = "a";
} },
case 4: { [&] {
mode = "a"; mode = "a+";
break; });
}
case 5: {
mode = "a+";
break;
}
}
#ifdef _GNU_SOURCE #ifdef _GNU_SOURCE
const cookie_io_functions_t io_hooks = { const cookie_io_functions_t io_hooks = {
FuzzedFileProvider::read, FuzzedFileProvider::read,
@ -477,66 +476,64 @@ public:
return {fuzzed_data_provider}; return {fuzzed_data_provider};
} }
#define WRITE_TO_STREAM_CASE(id, type, consume) \ #define WRITE_TO_STREAM_CASE(type, consume) \
case id: { \ [&] { \
type o = consume; \ type o = consume; \
stream << o; \ stream << o; \
break; \
} }
template <typename Stream> template <typename Stream>
void WriteToStream(FuzzedDataProvider& fuzzed_data_provider, Stream& stream) noexcept void WriteToStream(FuzzedDataProvider& fuzzed_data_provider, Stream& stream) noexcept
{ {
while (fuzzed_data_provider.ConsumeBool()) { while (fuzzed_data_provider.ConsumeBool()) {
try { try {
switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 13)) { CallOneOf(
WRITE_TO_STREAM_CASE(0, bool, fuzzed_data_provider.ConsumeBool()) fuzzed_data_provider,
WRITE_TO_STREAM_CASE(1, char, fuzzed_data_provider.ConsumeIntegral<char>()) WRITE_TO_STREAM_CASE(bool, fuzzed_data_provider.ConsumeBool()),
WRITE_TO_STREAM_CASE(2, int8_t, fuzzed_data_provider.ConsumeIntegral<int8_t>()) WRITE_TO_STREAM_CASE(char, fuzzed_data_provider.ConsumeIntegral<char>()),
WRITE_TO_STREAM_CASE(3, uint8_t, fuzzed_data_provider.ConsumeIntegral<uint8_t>()) WRITE_TO_STREAM_CASE(int8_t, fuzzed_data_provider.ConsumeIntegral<int8_t>()),
WRITE_TO_STREAM_CASE(4, int16_t, fuzzed_data_provider.ConsumeIntegral<int16_t>()) WRITE_TO_STREAM_CASE(uint8_t, fuzzed_data_provider.ConsumeIntegral<uint8_t>()),
WRITE_TO_STREAM_CASE(5, uint16_t, fuzzed_data_provider.ConsumeIntegral<uint16_t>()) WRITE_TO_STREAM_CASE(int16_t, fuzzed_data_provider.ConsumeIntegral<int16_t>()),
WRITE_TO_STREAM_CASE(6, int32_t, fuzzed_data_provider.ConsumeIntegral<int32_t>()) WRITE_TO_STREAM_CASE(uint16_t, fuzzed_data_provider.ConsumeIntegral<uint16_t>()),
WRITE_TO_STREAM_CASE(7, uint32_t, fuzzed_data_provider.ConsumeIntegral<uint32_t>()) WRITE_TO_STREAM_CASE(int32_t, fuzzed_data_provider.ConsumeIntegral<int32_t>()),
WRITE_TO_STREAM_CASE(8, int64_t, fuzzed_data_provider.ConsumeIntegral<int64_t>()) WRITE_TO_STREAM_CASE(uint32_t, fuzzed_data_provider.ConsumeIntegral<uint32_t>()),
WRITE_TO_STREAM_CASE(9, uint64_t, fuzzed_data_provider.ConsumeIntegral<uint64_t>()) WRITE_TO_STREAM_CASE(int64_t, fuzzed_data_provider.ConsumeIntegral<int64_t>()),
WRITE_TO_STREAM_CASE(10, float, fuzzed_data_provider.ConsumeFloatingPoint<float>()) WRITE_TO_STREAM_CASE(uint64_t, fuzzed_data_provider.ConsumeIntegral<uint64_t>()),
WRITE_TO_STREAM_CASE(11, double, fuzzed_data_provider.ConsumeFloatingPoint<double>()) WRITE_TO_STREAM_CASE(float, fuzzed_data_provider.ConsumeFloatingPoint<float>()),
WRITE_TO_STREAM_CASE(12, std::string, fuzzed_data_provider.ConsumeRandomLengthString(32)) WRITE_TO_STREAM_CASE(double, fuzzed_data_provider.ConsumeFloatingPoint<double>()),
WRITE_TO_STREAM_CASE(13, std::vector<char>, ConsumeRandomLengthIntegralVector<char>(fuzzed_data_provider)) WRITE_TO_STREAM_CASE(std::string, fuzzed_data_provider.ConsumeRandomLengthString(32)),
} WRITE_TO_STREAM_CASE(std::vector<char>, ConsumeRandomLengthIntegralVector<char>(fuzzed_data_provider)));
} catch (const std::ios_base::failure&) { } catch (const std::ios_base::failure&) {
break; break;
} }
} }
} }
#define READ_FROM_STREAM_CASE(id, type) \ #define READ_FROM_STREAM_CASE(type) \
case id: { \ [&] { \
type o; \ type o; \
stream >> o; \ stream >> o; \
break; \
} }
template <typename Stream> template <typename Stream>
void ReadFromStream(FuzzedDataProvider& fuzzed_data_provider, Stream& stream) noexcept void ReadFromStream(FuzzedDataProvider& fuzzed_data_provider, Stream& stream) noexcept
{ {
while (fuzzed_data_provider.ConsumeBool()) { while (fuzzed_data_provider.ConsumeBool()) {
try { try {
switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 13)) { CallOneOf(
READ_FROM_STREAM_CASE(0, bool) fuzzed_data_provider,
READ_FROM_STREAM_CASE(1, char) READ_FROM_STREAM_CASE(bool),
READ_FROM_STREAM_CASE(2, int8_t) READ_FROM_STREAM_CASE(char),
READ_FROM_STREAM_CASE(3, uint8_t) READ_FROM_STREAM_CASE(int8_t),
READ_FROM_STREAM_CASE(4, int16_t) READ_FROM_STREAM_CASE(uint8_t),
READ_FROM_STREAM_CASE(5, uint16_t) READ_FROM_STREAM_CASE(int16_t),
READ_FROM_STREAM_CASE(6, int32_t) READ_FROM_STREAM_CASE(uint16_t),
READ_FROM_STREAM_CASE(7, uint32_t) READ_FROM_STREAM_CASE(int32_t),
READ_FROM_STREAM_CASE(8, int64_t) READ_FROM_STREAM_CASE(uint32_t),
READ_FROM_STREAM_CASE(9, uint64_t) READ_FROM_STREAM_CASE(int64_t),
READ_FROM_STREAM_CASE(10, float) READ_FROM_STREAM_CASE(uint64_t),
READ_FROM_STREAM_CASE(11, double) READ_FROM_STREAM_CASE(float),
READ_FROM_STREAM_CASE(12, std::string) READ_FROM_STREAM_CASE(double),
READ_FROM_STREAM_CASE(13, std::vector<char>) READ_FROM_STREAM_CASE(std::string),
} READ_FROM_STREAM_CASE(std::vector<char>));
} catch (const std::ios_base::failure&) { } catch (const std::ios_base::failure&) {
break; break;
} }