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 : 6064 : int32_t GetCheckRatio()
31 : : {
32 [ + - + - ]: 12128 : 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 [ + - ]: 1779 : FUZZ_TARGET(data_stream_addr_man, .init = initialize_addrman)
43 : : {
44 : 1367 : FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
45 : 1367 : DataStream data_stream = ConsumeDataStream(fuzzed_data_provider);
46 : 1367 : NetGroupManager netgroupman{ConsumeNetGroupManager(fuzzed_data_provider)};
47 [ + - + - ]: 1367 : AddrMan addr_man(netgroupman, /*deterministic=*/false, GetCheckRatio());
48 : 1367 : try {
49 [ + + ]: 1367 : ReadFromStream(addr_man, data_stream);
50 [ - + ]: 799 : } catch (const std::exception&) {
51 : 799 : }
52 : 1367 : }
53 : :
54 : : /**
55 : : * Generate a random address. Always returns a valid address.
56 : : */
57 : 8790004 : CNetAddr RandAddr(FuzzedDataProvider& fuzzed_data_provider, FastRandomContext& fast_random_context)
58 : : {
59 : 8790004 : CNetAddr addr;
60 [ + - + - ]: 8790004 : assert(!addr.IsValid());
61 [ + + + - : 19199369 : for (size_t i = 0; i < 8 && !addr.IsValid(); ++i) {
+ + ]
62 [ + + + + ]: 12483811 : if (fuzzed_data_provider.remaining_bytes() > 1 && fuzzed_data_provider.ConsumeBool()) {
63 : 1605281 : addr = ConsumeNetAddr(fuzzed_data_provider);
64 : : } else {
65 : 8804084 : addr = ConsumeNetAddr(fuzzed_data_provider, &fast_random_context);
66 : : }
67 : : }
68 : :
69 : : // Return a dummy IPv4 5.5.5.5 if we generated an invalid address.
70 [ + - + + ]: 8790004 : if (!addr.IsValid()) {
71 : 8082 : in_addr v4_addr = {};
72 : 8082 : v4_addr.s_addr = 0x05050505;
73 [ + - ]: 16164 : addr = CNetAddr{v4_addr};
74 : : }
75 : :
76 : 8790004 : return addr;
77 : 0 : }
78 : :
79 : : /** Fill addrman with lots of addresses from lots of sources. */
80 : 1182 : void FillAddrman(AddrMan& addrman, FuzzedDataProvider& fuzzed_data_provider)
81 : : {
82 : : // Add a fraction of the addresses to the "tried" table.
83 : : // 0, 1, 2, 3 corresponding to 0%, 100%, 50%, 33%
84 : 1182 : const size_t n = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 3);
85 : :
86 : 1182 : const size_t num_sources = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(1, 50);
87 : 1182 : CNetAddr prev_source;
88 : : // Generate a FastRandomContext seed to use inside the loops instead of
89 : : // fuzzed_data_provider. When fuzzed_data_provider is exhausted it
90 : : // just returns 0.
91 : 1182 : FastRandomContext fast_random_context{ConsumeUInt256(fuzzed_data_provider)};
92 [ + + ]: 36392 : for (size_t i = 0; i < num_sources; ++i) {
93 [ + - ]: 35210 : const auto source = RandAddr(fuzzed_data_provider, fast_random_context);
94 : 35210 : const size_t num_addresses = fast_random_context.randrange(500) + 1; // [1..500]
95 : :
96 [ + + ]: 8790004 : for (size_t j = 0; j < num_addresses; ++j) {
97 [ + - + - ]: 8754794 : const auto addr = CAddress{CService{RandAddr(fuzzed_data_provider, fast_random_context), 8333}, NODE_NETWORK};
98 : 8754794 : const std::chrono::seconds time_penalty{fast_random_context.randrange(100000001)};
99 [ + - + - : 17509588 : addrman.Add({addr}, source, time_penalty);
+ + - - ]
100 : :
101 [ + + + - : 8754794 : if (n > 0 && addrman.Size() % n == 0) {
+ + ]
102 [ + - ]: 5262542 : addrman.Good(addr, Now<NodeSeconds>());
103 : : }
104 : :
105 : : // Add 10% of the addresses from more than one source.
106 [ + + + - : 8754794 : if (fast_random_context.randrange(10) == 0 && prev_source.IsValid()) {
+ + ]
107 [ + - + - : 1705140 : addrman.Add({addr}, prev_source, time_penalty);
+ + - - ]
108 : : }
109 : 8754794 : }
110 : 35210 : prev_source = source;
111 : : }
112 : 9608546 : }
113 : :
114 [ + - ]: 1986 : FUZZ_TARGET(addrman, .init = initialize_addrman)
115 : : {
116 : 1574 : FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
117 : 1574 : SetMockTime(ConsumeTime(fuzzed_data_provider));
118 : 1574 : NetGroupManager netgroupman{ConsumeNetGroupManager(fuzzed_data_provider)};
119 [ + - + - ]: 1574 : auto addr_man_ptr = std::make_unique<AddrManDeterministic>(netgroupman, fuzzed_data_provider, GetCheckRatio());
120 [ + + ]: 1574 : if (fuzzed_data_provider.ConsumeBool()) {
121 : 1019 : const std::vector<uint8_t> serialized_data{ConsumeRandomLengthByteVector(fuzzed_data_provider)};
122 [ + - ]: 1019 : DataStream ds{serialized_data};
123 : 1019 : try {
124 [ + + ]: 2038 : ds >> *addr_man_ptr;
125 [ - + ]: 759 : } catch (const std::ios_base::failure&) {
126 [ + - + - ]: 1518 : addr_man_ptr = std::make_unique<AddrManDeterministic>(netgroupman, fuzzed_data_provider, GetCheckRatio());
127 : 759 : }
128 : 1019 : }
129 : 1574 : AddrManDeterministic& addr_man = *addr_man_ptr;
130 [ + + + + ]: 419308 : LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 10000) {
131 [ + - ]: 417734 : CallOneOf(
132 : : fuzzed_data_provider,
133 : 6040 : [&] {
134 : 6040 : addr_man.ResolveCollisions();
135 : 6040 : },
136 : 67890 : [&] {
137 : 67890 : (void)addr_man.SelectTriedCollision();
138 : 67890 : },
139 : 9084 : [&] {
140 : 9084 : std::vector<CAddress> addresses;
141 [ + + + + ]: 2402645 : LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 10000) {
142 [ + - ]: 2393561 : addresses.push_back(ConsumeAddress(fuzzed_data_provider));
143 : : }
144 : 9084 : auto net_addr = ConsumeNetAddr(fuzzed_data_provider);
145 [ + - ]: 9084 : auto time_penalty = std::chrono::seconds{ConsumeTime(fuzzed_data_provider, 0, 100000000)};
146 [ + - ]: 9084 : addr_man.Add(addresses, net_addr, time_penalty);
147 : 9084 : },
148 : 292433 : [&] {
149 : 292433 : auto addr = ConsumeService(fuzzed_data_provider);
150 [ + - ]: 292433 : auto time = NodeSeconds{std::chrono::seconds{ConsumeTime(fuzzed_data_provider)}};
151 [ + - ]: 292433 : addr_man.Good(addr, time);
152 : 292433 : },
153 : 5521 : [&] {
154 : 5521 : auto addr = ConsumeService(fuzzed_data_provider);
155 : 5521 : auto count_failure = fuzzed_data_provider.ConsumeBool();
156 [ + - ]: 5521 : auto time = NodeSeconds{std::chrono::seconds{ConsumeTime(fuzzed_data_provider)}};
157 [ + - ]: 5521 : addr_man.Attempt(addr, count_failure, time);
158 : 5521 : },
159 : 16433 : [&] {
160 : 16433 : auto addr = ConsumeService(fuzzed_data_provider);
161 [ + - ]: 16433 : auto time = NodeSeconds{std::chrono::seconds{ConsumeTime(fuzzed_data_provider)}};
162 [ + - ]: 16433 : addr_man.Connected(addr, time);
163 : 16433 : },
164 : 20333 : [&] {
165 : 20333 : auto addr = ConsumeService(fuzzed_data_provider);
166 : 20333 : auto n_services = ConsumeWeakEnum(fuzzed_data_provider, ALL_SERVICE_FLAGS);
167 [ + - ]: 20333 : addr_man.SetServices(addr, n_services);
168 : 20333 : });
169 : : }
170 : 1574 : const AddrMan& const_addr_man{addr_man};
171 : 1574 : std::optional<Network> network;
172 [ + + ]: 1574 : if (fuzzed_data_provider.ConsumeBool()) {
173 : 174 : network = fuzzed_data_provider.PickValueInArray(ALL_NETWORKS);
174 : : }
175 : 1574 : auto max_addresses = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096);
176 : 1574 : auto max_pct = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 100);
177 : 1574 : auto filtered = fuzzed_data_provider.ConsumeBool();
178 [ + - ]: 1574 : (void)const_addr_man.GetAddr(max_addresses, max_pct, network, filtered);
179 : :
180 : 1574 : std::unordered_set<Network> nets;
181 [ + + ]: 12592 : for (const auto& net : ALL_NETWORKS) {
182 [ + + ]: 11018 : if (fuzzed_data_provider.ConsumeBool()) {
183 [ + - ]: 1298 : nets.insert(net);
184 : : }
185 : : }
186 [ + - ]: 1574 : (void)const_addr_man.Select(fuzzed_data_provider.ConsumeBool(), nets);
187 : :
188 : 1574 : std::optional<bool> in_new;
189 [ + + ]: 1574 : if (fuzzed_data_provider.ConsumeBool()) {
190 : 176 : in_new = fuzzed_data_provider.ConsumeBool();
191 : : }
192 [ + - ]: 1574 : (void)const_addr_man.Size(network, in_new);
193 : 1574 : DataStream data_stream{};
194 [ + - ]: 3148 : data_stream << const_addr_man;
195 : 1574 : }
196 : :
197 : : // Check that serialize followed by unserialize produces the same addrman.
198 [ + - ]: 1594 : FUZZ_TARGET(addrman_serdeser, .init = initialize_addrman)
199 : : {
200 : 1182 : FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
201 : 1182 : SetMockTime(ConsumeTime(fuzzed_data_provider));
202 : :
203 : 1182 : NetGroupManager netgroupman{ConsumeNetGroupManager(fuzzed_data_provider)};
204 [ + - + - ]: 1182 : AddrManDeterministic addr_man1{netgroupman, fuzzed_data_provider, GetCheckRatio()};
205 [ + - + - ]: 1182 : AddrManDeterministic addr_man2{netgroupman, fuzzed_data_provider, GetCheckRatio()};
206 : :
207 : 1182 : DataStream data_stream{};
208 : :
209 [ + - ]: 1182 : FillAddrman(addr_man1, fuzzed_data_provider);
210 [ + - ]: 1182 : data_stream << addr_man1;
211 [ + - ]: 1182 : data_stream >> addr_man2;
212 [ + - - + ]: 1182 : assert(addr_man1 == addr_man2);
213 : 1182 : }
|
