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 : :
7 : : #include <common/args.h>
8 : : #include <netaddress.h>
9 : : #include <test/fuzz/FuzzedDataProvider.h>
10 : : #include <test/fuzz/fuzz.h>
11 : : #include <test/fuzz/util.h>
12 : : #include <test/fuzz/util/net.h>
13 : : #include <test/util/setup_common.h>
14 : : #include <test/util/time.h>
15 : : #include <util/check.h>
16 : : #include <util/fs.h>
17 : : #include <util/readwritefile.h>
18 : :
19 : : #include <cstdint>
20 : : #include <limits>
21 : : #include <string>
22 : : #include <vector>
23 : :
24 : : namespace {
25 : 30404 : int64_t ConsumeBanTimeOffset(FuzzedDataProvider& fuzzed_data_provider) noexcept
26 : : {
27 : : // Avoid signed integer overflow by capping to int32_t max:
28 : : // banman.cpp:137:73: runtime error: signed integer overflow: 1591700817 + 9223372036854775807 cannot be represented in type 'long'
29 : 30404 : return fuzzed_data_provider.ConsumeIntegralInRange<int64_t>(std::numeric_limits<int64_t>::min(), std::numeric_limits<int32_t>::max());
30 : : }
31 : : } // namespace
32 : :
33 : 1 : void initialize_banman()
34 : : {
35 [ + - + - : 1 : static const auto testing_setup = MakeNoLogFileContext<>();
+ - ]
36 : 1 : }
37 : :
38 : 6349 : static bool operator==(const CBanEntry& lhs, const CBanEntry& rhs)
39 : : {
40 : 12698 : return lhs.nVersion == rhs.nVersion &&
41 [ + - + - ]: 6349 : lhs.nCreateTime == rhs.nCreateTime &&
42 [ - + ]: 6349 : lhs.nBanUntil == rhs.nBanUntil;
43 : : }
44 : :
45 [ + - ]: 2035 : FUZZ_TARGET(banman, .init = initialize_banman)
46 : : {
47 : 1559 : SeedRandomStateForTest(SeedRand::ZEROS);
48 : 1559 : FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
49 : 1559 : FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
50 [ + - ]: 3118 : fs::path banlist_file = gArgs.GetDataDirNet() / "fuzzed_banlist";
51 : :
52 : 1559 : const bool start_with_corrupted_banlist{fuzzed_data_provider.ConsumeBool()};
53 : 1559 : bool force_read_and_write_to_err{false};
54 [ + + ]: 1559 : if (start_with_corrupted_banlist) {
55 [ + - + - : 4196 : assert(WriteBinaryFile(banlist_file + ".json",
+ - + - -
+ ]
56 : : fuzzed_data_provider.ConsumeRandomLengthString()));
57 : : } else {
58 : 510 : force_read_and_write_to_err = fuzzed_data_provider.ConsumeBool();
59 [ + + ]: 510 : if (force_read_and_write_to_err) {
60 [ + - + - : 1272 : banlist_file = fs::path{"path"} / "to" / "inaccessible" / "fuzzed_banlist";
+ - + - ]
61 : : }
62 : : }
63 : :
64 : 1559 : {
65 [ + - + - ]: 1559 : BanMan ban_man{banlist_file, /*client_interface=*/nullptr, /*default_ban_time=*/ConsumeBanTimeOffset(fuzzed_data_provider)};
66 : : // The complexity is O(N^2), where N is the input size, because each call
67 : : // might call DumpBanlist (or other methods that are at least linear
68 : : // complexity of the input size).
69 : 1559 : bool contains_invalid{false};
70 [ + + + + ]: 57907 : LIMITED_WHILE (fuzzed_data_provider.ConsumeBool(), 300) {
71 [ + - ]: 56348 : CallOneOf(
72 : : fuzzed_data_provider,
73 : 24439 : [&] {
74 : 24439 : CNetAddr net_addr{ConsumeNetAddr(fuzzed_data_provider)};
75 [ + + + - : 24439 : if (!net_addr.IsCJDNS() || !net_addr.IsValid()) {
- + ]
76 [ + - + - : 23382 : const std::optional<CNetAddr>& addr{LookupHost(net_addr.ToStringAddr(), /*fAllowLookup=*/false)};
+ - ]
77 [ + + + - : 23382 : if (addr.has_value() && addr->IsValid()) {
+ + ]
78 : 20073 : net_addr = *addr;
79 : : } else {
80 : 3309 : contains_invalid = true;
81 : : }
82 : 23382 : }
83 : 24439 : auto ban_time_offset = ConsumeBanTimeOffset(fuzzed_data_provider);
84 : 24439 : auto since_unix_epoch = fuzzed_data_provider.ConsumeBool();
85 [ + - ]: 24439 : ban_man.Ban(net_addr, ban_time_offset, since_unix_epoch);
86 : 24439 : },
87 : 4406 : [&] {
88 : 4406 : CSubNet subnet{ConsumeSubNet(fuzzed_data_provider)};
89 [ + - + - ]: 4406 : subnet = LookupSubNet(subnet.ToString());
90 [ + - + + ]: 4406 : if (!subnet.IsValid()) {
91 : 74 : contains_invalid = true;
92 : : }
93 : 4406 : auto ban_time_offset = ConsumeBanTimeOffset(fuzzed_data_provider);
94 : 4406 : auto since_unix_epoch = fuzzed_data_provider.ConsumeBool();
95 [ + - ]: 4406 : ban_man.Ban(subnet, ban_time_offset, since_unix_epoch);
96 : 4406 : },
97 : 3966 : [&] {
98 : 3966 : ban_man.ClearBanned();
99 : 3966 : },
100 : 4006 : [&] {
101 [ + - ]: 4006 : ban_man.IsBanned(ConsumeNetAddr(fuzzed_data_provider));
102 : 4006 : },
103 : 2926 : [&] {
104 [ + - ]: 2926 : ban_man.IsBanned(ConsumeSubNet(fuzzed_data_provider));
105 : 2926 : },
106 : 3372 : [&] {
107 [ + - ]: 3372 : ban_man.Unban(ConsumeNetAddr(fuzzed_data_provider));
108 : 3372 : },
109 : 1708 : [&] {
110 [ + - ]: 1708 : ban_man.Unban(ConsumeSubNet(fuzzed_data_provider));
111 : 1708 : },
112 : 1309 : [&] {
113 [ + - ]: 1309 : banmap_t banmap;
114 [ + - ]: 1309 : ban_man.GetBanned(banmap);
115 : 1309 : },
116 : 4042 : [&] {
117 : 4042 : ban_man.DumpBanlist();
118 : 4042 : },
119 : 2605 : [&] {
120 [ + - ]: 2605 : ban_man.Discourage(ConsumeNetAddr(fuzzed_data_provider));
121 : 2605 : },
122 : 3569 : [&] {
123 [ + - ]: 3569 : ban_man.IsDiscouraged(ConsumeNetAddr(fuzzed_data_provider));
124 : 3569 : });
125 : : }
126 [ + + ]: 1559 : if (!force_read_and_write_to_err) {
127 [ + - ]: 1400 : ban_man.DumpBanlist();
128 [ + - ]: 1400 : clock.set(ConsumeTime(fuzzed_data_provider));
129 [ + - ]: 1400 : banmap_t banmap;
130 [ + - ]: 1400 : ban_man.GetBanned(banmap);
131 [ + - + - ]: 1400 : BanMan ban_man_read{banlist_file, /*client_interface=*/nullptr, /*default_ban_time=*/0};
132 [ + - ]: 1400 : banmap_t banmap_read;
133 [ + - ]: 1400 : ban_man_read.GetBanned(banmap_read);
134 [ + + ]: 1400 : if (!contains_invalid) {
135 [ + - - + ]: 1182 : assert(banmap == banmap_read);
136 : : }
137 : 1400 : }
138 : 1559 : }
139 [ + - + - : 9354 : fs::remove(fs::PathToString(banlist_file + ".json"));
- + + - +
- ]
140 : 1559 : }
|