mirrors/bitcoin
1
0
Fork 0
mirror of https://github.com/bitcoin/bitcoin.git synced 2025-02-22 06:52:36 +01:00
Code Issues Projects Releases Wiki Activity

fuzz: Introduce CallOneOf helper to replace switch-case

Browse source 
Can be reviewed with --ignore-all-space
This commit is contained in:
MarcoFalke 2021-01-02 13:38:14 +01:00
parent 9c0b76c709
commit fa75d40ef8
No known key found for this signature in database
GPG key ID: CE2B75697E69A548
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({FeeEstimateHorizon::SHORT_HALFLIFE, FeeEstimateHorizon::MED_HALFLIFE, FeeEstimateHorizon::LONG_HALFLIFE}), 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({FeeEstimateHorizon::SHORT_HALFLIFE, FeeEstimateHorizon::MED_HALFLIFE, FeeEstimateHorizon::LONG_HALFLIFE}), 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;
} }