Branch data Line data Source code
1 : : // Copyright (c) 2020-2022 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 <addrdb.h>
6 : : #include <addrman.h>
7 : : #include <addrman_impl.h>
8 : : #include <chainparams.h>
9 : : #include <common/args.h>
10 : : #include <merkleblock.h>
11 : : #include <random.h>
12 : : #include <test/fuzz/FuzzedDataProvider.h>
13 : : #include <test/fuzz/fuzz.h>
14 : : #include <test/fuzz/util.h>
15 : : #include <test/fuzz/util/net.h>
16 : : #include <test/util/setup_common.h>
17 : : #include <time.h>
18 : : #include <util/asmap.h>
19 : : #include <util/chaintype.h>
20 : :
21 : : #include <cassert>
22 : : #include <cstdint>
23 : : #include <optional>
24 : : #include <string>
25 : : #include <vector>
26 : :
27 : : namespace {
28 : : const BasicTestingSetup* g_setup;
29 : :
30 : 7099 : int32_t GetCheckRatio()
31 : : {
32 [ + - + - ]: 14198 : return std::clamp<int32_t>(g_setup->m_node.args->GetIntArg("-checkaddrman", 0), 0, 1000000);
33 : : }
34 : : } // namespace
35 : :
36 : 3 : void initialize_addrman()
37 : : {
38 [ + - + - ]: 6 : static const auto testing_setup = MakeNoLogFileContext<>(ChainType::REGTEST);
39 : 3 : g_setup = testing_setup.get();
40 [ + - ]: 6 : }
41 : :
42 [ + - ]: 2023 : FUZZ_TARGET(data_stream_addr_man, .init = initialize_addrman)
43 : : {
44 : 1609 : SeedRandomStateForTest(SeedRand::ZEROS);
45 : 1609 : FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
46 : 1609 : DataStream data_stream = ConsumeDataStream(fuzzed_data_provider);
47 : 1609 : NetGroupManager netgroupman{ConsumeNetGroupManager(fuzzed_data_provider)};
48 [ + - + - ]: 1609 : AddrMan addr_man(netgroupman, /*deterministic=*/false, GetCheckRatio());
49 : 1609 : try {
50 [ + + ]: 1609 : ReadFromStream(addr_man, data_stream);
51 [ - + ]: 960 : } catch (const std::exception&) {
52 : 960 : }
53 : 1609 : }
54 : :
55 : : /**
56 : : * Generate a random address. Always returns a valid address.
57 : : */
58 : 10073007 : CNetAddr RandAddr(FuzzedDataProvider& fuzzed_data_provider, FastRandomContext& fast_random_context)
59 : : {
60 : 10073007 : CNetAddr addr;
61 [ + - + - ]: 10073007 : assert(!addr.IsValid());
62 [ + + + - : 22010588 : for (size_t i = 0; i < 8 && !addr.IsValid(); ++i) {
+ + ]
63 [ + + + + ]: 14157789 : if (fuzzed_data_provider.remaining_bytes() > 1 && fuzzed_data_provider.ConsumeBool()) {
64 : 1727219 : addr = ConsumeNetAddr(fuzzed_data_provider);
65 : : } else {
66 : 10210362 : addr = ConsumeNetAddr(fuzzed_data_provider, &fast_random_context);
67 : : }
68 : : }
69 : :
70 : : // Return a dummy IPv4 5.5.5.5 if we generated an invalid address.
71 [ + - + + ]: 10073007 : if (!addr.IsValid()) {
72 : 8626 : in_addr v4_addr = {};
73 : 8626 : v4_addr.s_addr = 0x05050505;
74 [ + - ]: 17252 : addr = CNetAddr{v4_addr};
75 : : }
76 : :
77 : 10073007 : return addr;
78 : 0 : }
79 : :
80 : : /** Fill addrman with lots of addresses from lots of sources. */
81 : 1341 : void FillAddrman(AddrMan& addrman, FuzzedDataProvider& fuzzed_data_provider)
82 : : {
83 : : // Add a fraction of the addresses to the "tried" table.
84 : : // 0, 1, 2, 3 corresponding to 0%, 100%, 50%, 33%
85 : 1341 : const size_t n = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 3);
86 : :
87 : 1341 : const size_t num_sources = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(1, 50);
88 : 1341 : CNetAddr prev_source;
89 : : // Generate a FastRandomContext seed to use inside the loops instead of
90 : : // fuzzed_data_provider. When fuzzed_data_provider is exhausted it
91 : : // just returns 0.
92 : 1341 : FastRandomContext fast_random_context{ConsumeUInt256(fuzzed_data_provider)};
93 [ + + ]: 41616 : for (size_t i = 0; i < num_sources; ++i) {
94 [ + - ]: 40275 : const auto source = RandAddr(fuzzed_data_provider, fast_random_context);
95 : 40275 : const size_t num_addresses = fast_random_context.randrange(500) + 1; // [1..500]
96 : :
97 [ + + ]: 10073007 : for (size_t j = 0; j < num_addresses; ++j) {
98 [ + - + - ]: 10032732 : const auto addr = CAddress{CService{RandAddr(fuzzed_data_provider, fast_random_context), 8333}, NODE_NETWORK};
99 : 10032732 : const std::chrono::seconds time_penalty{fast_random_context.randrange(100000001)};
100 [ + - + - : 20065464 : addrman.Add({addr}, source, time_penalty);
+ + - - ]
101 : :
102 [ + + + - : 10032732 : if (n > 0 && addrman.Size() % n == 0) {
+ + ]
103 [ + - ]: 5994743 : addrman.Good(addr, Now<NodeSeconds>());
104 : : }
105 : :
106 : : // Add 10% of the addresses from more than one source.
107 [ + + + - : 10032732 : if (fast_random_context.randrange(10) == 0 && prev_source.IsValid()) {
+ + ]
108 [ + - + - : 1954702 : addrman.Add({addr}, prev_source, time_penalty);
+ + - - ]
109 : : }
110 : 10032732 : }
111 : 80550 : prev_source = source;
112 : 40275 : }
113 : 11011424 : }
114 : :
115 [ + - ]: 2325 : FUZZ_TARGET(addrman, .init = initialize_addrman)
116 : : {
117 : 1911 : SeedRandomStateForTest(SeedRand::ZEROS);
118 : 1911 : FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
119 : 1911 : SetMockTime(ConsumeTime(fuzzed_data_provider));
120 : 1911 : NetGroupManager netgroupman{ConsumeNetGroupManager(fuzzed_data_provider)};
121 [ + - + - ]: 1911 : auto addr_man_ptr = std::make_unique<AddrManDeterministic>(netgroupman, fuzzed_data_provider, GetCheckRatio());
122 [ + + ]: 1911 : if (fuzzed_data_provider.ConsumeBool()) {
123 : 1192 : const std::vector<uint8_t> serialized_data{ConsumeRandomLengthByteVector(fuzzed_data_provider)};
124 [ + - ]: 1192 : DataStream ds{serialized_data};
125 : 1192 : try {
126 [ + + ]: 2384 : ds >> *addr_man_ptr;
127 [ - + ]: 897 : } catch (const std::ios_base::failure&) {
128 [ + - + - ]: 1794 : addr_man_ptr = std::make_unique<AddrManDeterministic>(netgroupman, fuzzed_data_provider, GetCheckRatio());
129 : 897 : }
130 : 1192 : }
131 : 1911 : AddrManDeterministic& addr_man = *addr_man_ptr;
132 [ + + + + ]: 551745 : LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 10000) {
133 [ + - ]: 549834 : CallOneOf(
134 : : fuzzed_data_provider,
135 : 7560 : [&] {
136 : 7560 : addr_man.ResolveCollisions();
137 : 7560 : },
138 : 91762 : [&] {
139 : 91762 : (void)addr_man.SelectTriedCollision();
140 : 91762 : },
141 : 11726 : [&] {
142 : 11726 : std::vector<CAddress> addresses;
143 [ + + + + ]: 3427955 : LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 10000) {
144 [ + - ]: 3416229 : addresses.push_back(ConsumeAddress(fuzzed_data_provider));
145 : : }
146 : 11726 : auto net_addr = ConsumeNetAddr(fuzzed_data_provider);
147 [ + - ]: 11726 : auto time_penalty = std::chrono::seconds{ConsumeTime(fuzzed_data_provider, 0, 100000000)};
148 [ + - ]: 11726 : addr_man.Add(addresses, net_addr, time_penalty);
149 : 11726 : },
150 : 387853 : [&] {
151 : 387853 : auto addr = ConsumeService(fuzzed_data_provider);
152 [ + - ]: 387853 : auto time = NodeSeconds{std::chrono::seconds{ConsumeTime(fuzzed_data_provider)}};
153 [ + - ]: 387853 : addr_man.Good(addr, time);
154 : 387853 : },
155 : 6365 : [&] {
156 : 6365 : auto addr = ConsumeService(fuzzed_data_provider);
157 : 6365 : auto count_failure = fuzzed_data_provider.ConsumeBool();
158 [ + - ]: 6365 : auto time = NodeSeconds{std::chrono::seconds{ConsumeTime(fuzzed_data_provider)}};
159 [ + - ]: 6365 : addr_man.Attempt(addr, count_failure, time);
160 : 6365 : },
161 : 17093 : [&] {
162 : 17093 : auto addr = ConsumeService(fuzzed_data_provider);
163 [ + - ]: 17093 : auto time = NodeSeconds{std::chrono::seconds{ConsumeTime(fuzzed_data_provider)}};
164 [ + - ]: 17093 : addr_man.Connected(addr, time);
165 : 17093 : },
166 : 27475 : [&] {
167 : 27475 : auto addr = ConsumeService(fuzzed_data_provider);
168 : 27475 : auto n_services = ConsumeWeakEnum(fuzzed_data_provider, ALL_SERVICE_FLAGS);
169 [ + - ]: 27475 : addr_man.SetServices(addr, n_services);
170 : 27475 : });
171 : : }
172 : 1911 : const AddrMan& const_addr_man{addr_man};
173 : 1911 : std::optional<Network> network;
174 [ + + ]: 1911 : if (fuzzed_data_provider.ConsumeBool()) {
175 : 213 : network = fuzzed_data_provider.PickValueInArray(ALL_NETWORKS);
176 : : }
177 : 1911 : auto max_addresses = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096);
178 : 1911 : auto max_pct = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 100);
179 : 1911 : auto filtered = fuzzed_data_provider.ConsumeBool();
180 [ + - ]: 1911 : (void)const_addr_man.GetAddr(max_addresses, max_pct, network, filtered);
181 : :
182 : 1911 : std::unordered_set<Network> nets;
183 [ + + ]: 15288 : for (const auto& net : ALL_NETWORKS) {
184 [ + + ]: 13377 : if (fuzzed_data_provider.ConsumeBool()) {
185 [ + - ]: 1607 : nets.insert(net);
186 : : }
187 : : }
188 [ + - ]: 1911 : (void)const_addr_man.Select(fuzzed_data_provider.ConsumeBool(), nets);
189 : :
190 : 1911 : std::optional<bool> in_new;
191 [ + + ]: 1911 : if (fuzzed_data_provider.ConsumeBool()) {
192 : 219 : in_new = fuzzed_data_provider.ConsumeBool();
193 : : }
194 [ + - ]: 1911 : (void)const_addr_man.Size(network, in_new);
195 : 1911 : DataStream data_stream{};
196 [ + - ]: 3822 : data_stream << const_addr_man;
197 : 1911 : }
198 : :
199 : : // Check that serialize followed by unserialize produces the same addrman.
200 [ + - ]: 1755 : FUZZ_TARGET(addrman_serdeser, .init = initialize_addrman)
201 : : {
202 : 1341 : SeedRandomStateForTest(SeedRand::ZEROS);
203 : 1341 : FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
204 : 1341 : SetMockTime(ConsumeTime(fuzzed_data_provider));
205 : :
206 : 1341 : NetGroupManager netgroupman{ConsumeNetGroupManager(fuzzed_data_provider)};
207 [ + - + - ]: 1341 : AddrManDeterministic addr_man1{netgroupman, fuzzed_data_provider, GetCheckRatio()};
208 [ + - + - ]: 1341 : AddrManDeterministic addr_man2{netgroupman, fuzzed_data_provider, GetCheckRatio()};
209 : :
210 : 1341 : DataStream data_stream{};
211 : :
212 [ + - ]: 1341 : FillAddrman(addr_man1, fuzzed_data_provider);
213 [ + - ]: 1341 : data_stream << addr_man1;
214 [ + - ]: 1341 : data_stream >> addr_man2;
215 [ + - - + ]: 1341 : assert(addr_man1 == addr_man2);
216 : 1341 : }
|
