Branch data Line data Source code
1 : : // Copyright (c) 2020-present The Bitcoin Core developers
2 : : // Distributed under the MIT software license, see the accompanying
3 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 : :
5 : : #include <banman.h>
6 : : #include <common/args.h>
7 : : #include <netaddress.h>
8 : : #include <test/fuzz/FuzzedDataProvider.h>
9 : : #include <test/fuzz/fuzz.h>
10 : : #include <test/fuzz/util.h>
11 : : #include <test/fuzz/util/net.h>
12 : : #include <test/util/setup_common.h>
13 : : #include <test/util/time.h>
14 : : #include <util/fs.h>
15 : : #include <util/readwritefile.h>
16 : :
17 : : #include <cassert>
18 : : #include <cstdint>
19 : : #include <limits>
20 : : #include <string>
21 : : #include <vector>
22 : :
23 : : namespace {
24 : 21521 : int64_t ConsumeBanTimeOffset(FuzzedDataProvider& fuzzed_data_provider) noexcept
25 : : {
26 : : // Avoid signed integer overflow by capping to int32_t max:
27 : : // banman.cpp:137:73: runtime error: signed integer overflow: 1591700817 + 9223372036854775807 cannot be represented in type 'long'
28 : 21521 : return fuzzed_data_provider.ConsumeIntegralInRange<int64_t>(std::numeric_limits<int64_t>::min(), std::numeric_limits<int32_t>::max());
29 : : }
30 : : } // namespace
31 : :
32 : 1 : void initialize_banman()
33 : : {
34 [ + - + - : 1 : static const auto testing_setup = MakeNoLogFileContext<>();
+ - ]
35 : 1 : }
36 : :
37 : 4771 : static bool operator==(const CBanEntry& lhs, const CBanEntry& rhs)
38 : : {
39 : 9542 : return lhs.nVersion == rhs.nVersion &&
40 [ + - + - ]: 4771 : lhs.nCreateTime == rhs.nCreateTime &&
41 [ - + ]: 4771 : lhs.nBanUntil == rhs.nBanUntil;
42 : : }
43 : :
44 [ + - ]: 1553 : FUZZ_TARGET(banman, .init = initialize_banman)
45 : : {
46 : 1077 : SeedRandomStateForTest(SeedRand::ZEROS);
47 : 1077 : FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
48 : 1077 : FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
49 [ + - ]: 2154 : fs::path banlist_file = gArgs.GetDataDirNet() / "fuzzed_banlist";
50 : :
51 : 1077 : const bool start_with_corrupted_banlist{fuzzed_data_provider.ConsumeBool()};
52 : 1077 : bool force_read_and_write_to_err{false};
53 [ + + ]: 1077 : if (start_with_corrupted_banlist) {
54 [ + - + - : 2776 : assert(WriteBinaryFile(banlist_file + ".json",
+ - + - -
+ ]
55 : : fuzzed_data_provider.ConsumeRandomLengthString()));
56 : : } else {
57 : 383 : force_read_and_write_to_err = fuzzed_data_provider.ConsumeBool();
58 [ + + ]: 383 : if (force_read_and_write_to_err) {
59 [ + - + - : 984 : banlist_file = fs::path{"path"} / "to" / "inaccessible" / "fuzzed_banlist";
+ - + - ]
60 : : }
61 : : }
62 : :
63 : 1077 : {
64 [ + - + - ]: 1077 : BanMan ban_man{banlist_file, /*client_interface=*/nullptr, /*default_ban_time=*/ConsumeBanTimeOffset(fuzzed_data_provider)};
65 : : // The complexity is O(N^2), where N is the input size, because each call
66 : : // might call DumpBanlist (or other methods that are at least linear
67 : : // complexity of the input size).
68 : 1077 : bool contains_invalid{false};
69 [ + + + + ]: 40548 : LIMITED_WHILE (fuzzed_data_provider.ConsumeBool(), 300) {
70 [ + - ]: 39471 : CallOneOf(
71 : : fuzzed_data_provider,
72 : 17294 : [&] {
73 : 17294 : CNetAddr net_addr{ConsumeNetAddr(fuzzed_data_provider)};
74 [ + + + - : 17294 : if (!net_addr.IsCJDNS() || !net_addr.IsValid()) {
- + ]
75 [ + - + - : 33200 : const std::optional<CNetAddr>& addr{LookupHost(net_addr.ToStringAddr(), /*fAllowLookup=*/false)};
+ - ]
76 [ + + + - : 16600 : if (addr.has_value() && addr->IsValid()) {
+ + ]
77 : 14223 : net_addr = *addr;
78 : : } else {
79 : 2377 : contains_invalid = true;
80 : : }
81 : : }
82 : 17294 : auto ban_time_offset = ConsumeBanTimeOffset(fuzzed_data_provider);
83 : 17294 : auto since_unix_epoch = fuzzed_data_provider.ConsumeBool();
84 [ + - ]: 17294 : ban_man.Ban(net_addr, ban_time_offset, since_unix_epoch);
85 : 17294 : },
86 : 3150 : [&] {
87 : 3150 : CSubNet subnet{ConsumeSubNet(fuzzed_data_provider)};
88 [ + - + - ]: 3150 : subnet = LookupSubNet(subnet.ToString());
89 [ + - + + ]: 3150 : if (!subnet.IsValid()) {
90 : 70 : contains_invalid = true;
91 : : }
92 : 3150 : auto ban_time_offset = ConsumeBanTimeOffset(fuzzed_data_provider);
93 : 3150 : auto since_unix_epoch = fuzzed_data_provider.ConsumeBool();
94 [ + - ]: 3150 : ban_man.Ban(subnet, ban_time_offset, since_unix_epoch);
95 : 3150 : },
96 : 3054 : [&] {
97 : 3054 : ban_man.ClearBanned();
98 : 3054 : },
99 : 2514 : [&] {
100 [ + - ]: 2514 : ban_man.IsBanned(ConsumeNetAddr(fuzzed_data_provider));
101 : 2514 : },
102 : 1772 : [&] {
103 [ + - ]: 1772 : ban_man.IsBanned(ConsumeSubNet(fuzzed_data_provider));
104 : 1772 : },
105 : 2162 : [&] {
106 [ + - ]: 2162 : ban_man.Unban(ConsumeNetAddr(fuzzed_data_provider));
107 : 2162 : },
108 : 1059 : [&] {
109 [ + - ]: 1059 : ban_man.Unban(ConsumeSubNet(fuzzed_data_provider));
110 : 1059 : },
111 : 978 : [&] {
112 [ + - ]: 978 : banmap_t banmap;
113 [ + - ]: 978 : ban_man.GetBanned(banmap);
114 : 978 : },
115 : 3098 : [&] {
116 : 3098 : ban_man.DumpBanlist();
117 : 3098 : },
118 : 1652 : [&] {
119 [ + - ]: 1652 : ban_man.Discourage(ConsumeNetAddr(fuzzed_data_provider));
120 : 1652 : },
121 : 2738 : [&] {
122 [ + - ]: 2738 : ban_man.IsDiscouraged(ConsumeNetAddr(fuzzed_data_provider));
123 : 2738 : });
124 : : }
125 [ + + ]: 1077 : if (!force_read_and_write_to_err) {
126 [ + - ]: 954 : ban_man.DumpBanlist();
127 [ + - ]: 954 : clock.set(ConsumeTime(fuzzed_data_provider));
128 [ + - ]: 954 : banmap_t banmap;
129 [ + - ]: 954 : ban_man.GetBanned(banmap);
130 [ + - + - ]: 954 : BanMan ban_man_read{banlist_file, /*client_interface=*/nullptr, /*default_ban_time=*/0};
131 [ + - ]: 954 : banmap_t banmap_read;
132 [ + - ]: 954 : ban_man_read.GetBanned(banmap_read);
133 [ + + ]: 954 : if (!contains_invalid) {
134 [ + - - + ]: 805 : assert(banmap == banmap_read);
135 : : }
136 : 954 : }
137 : 1077 : }
138 [ + - + - : 6462 : fs::remove(fs::PathToString(banlist_file + ".json"));
- + + - +
- ]
139 : 1077 : }
|
