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 2 : #include <time.h>
18 2 : #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 0 : int32_t GetCheckRatio()
31 : {
32 0 : return std::clamp<int32_t>(g_setup->m_node.args->GetIntArg("-checkaddrman", 0), 0, 1000000);
33 0 : }
34 : } // namespace
35 :
36 0 : void initialize_addrman()
37 : {
38 0 : static const auto testing_setup = MakeNoLogFileContext<>(ChainType::REGTEST);
39 0 : g_setup = testing_setup.get();
40 0 : }
41 :
42 0 : [[nodiscard]] inline NetGroupManager ConsumeNetGroupManager(FuzzedDataProvider& fuzzed_data_provider) noexcept
43 : {
44 0 : std::vector<bool> asmap = ConsumeRandomLengthBitVector(fuzzed_data_provider);
45 0 : if (!SanityCheckASMap(asmap, 128)) asmap.clear();
46 0 : return NetGroupManager(asmap);
47 0 : }
48 :
49 4 : FUZZ_TARGET(data_stream_addr_man, .init = initialize_addrman)
50 : {
51 0 : FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
52 0 : DataStream data_stream = ConsumeDataStream(fuzzed_data_provider);
53 0 : NetGroupManager netgroupman{ConsumeNetGroupManager(fuzzed_data_provider)};
54 0 : AddrMan addr_man(netgroupman, /*deterministic=*/false, GetCheckRatio());
55 : try {
56 0 : ReadFromStream(addr_man, data_stream);
57 0 : } catch (const std::exception&) {
58 0 : }
59 0 : }
60 :
61 : /**
62 : * Generate a random address. Always returns a valid address.
63 : */
64 0 : CNetAddr RandAddr(FuzzedDataProvider& fuzzed_data_provider, FastRandomContext& fast_random_context)
65 : {
66 0 : CNetAddr addr;
67 0 : if (fuzzed_data_provider.remaining_bytes() > 1 && fuzzed_data_provider.ConsumeBool()) {
68 0 : addr = ConsumeNetAddr(fuzzed_data_provider);
69 0 : } else {
70 : // The networks [1..6] correspond to CNetAddr::BIP155Network (private).
71 0 : static const std::map<uint8_t, uint8_t> net_len_map = {{1, ADDR_IPV4_SIZE},
72 0 : {2, ADDR_IPV6_SIZE},
73 0 : {4, ADDR_TORV3_SIZE},
74 2 : {5, ADDR_I2P_SIZE},
75 0 : {6, ADDR_CJDNS_SIZE}};
76 0 : uint8_t net = fast_random_context.randrange(5) + 1; // [1..5]
77 0 : if (net == 3) {
78 0 : net = 6;
79 0 : }
80 :
81 0 : DataStream s{};
82 :
83 2 : s << net;
84 0 : s << fast_random_context.randbytes(net_len_map.at(net));
85 :
86 0 : s >> CAddress::V2_NETWORK(addr);
87 0 : }
88 :
89 : // Return a dummy IPv4 5.5.5.5 if we generated an invalid address.
90 0 : if (!addr.IsValid()) {
91 0 : in_addr v4_addr = {};
92 0 : v4_addr.s_addr = 0x05050505;
93 0 : addr = CNetAddr{v4_addr};
94 0 : }
95 :
96 0 : return addr;
97 0 : }
98 :
99 : /** Fill addrman with lots of addresses from lots of sources. */
100 0 : void FillAddrman(AddrMan& addrman, FuzzedDataProvider& fuzzed_data_provider)
101 : {
102 : // Add a fraction of the addresses to the "tried" table.
103 : // 0, 1, 2, 3 corresponding to 0%, 100%, 50%, 33%
104 0 : const size_t n = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 3);
105 :
106 0 : const size_t num_sources = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(1, 50);
107 0 : CNetAddr prev_source;
108 : // Generate a FastRandomContext seed to use inside the loops instead of
109 : // fuzzed_data_provider. When fuzzed_data_provider is exhausted it
110 : // just returns 0.
111 0 : FastRandomContext fast_random_context{ConsumeUInt256(fuzzed_data_provider)};
112 0 : for (size_t i = 0; i < num_sources; ++i) {
113 0 : const auto source = RandAddr(fuzzed_data_provider, fast_random_context);
114 0 : const size_t num_addresses = fast_random_context.randrange(500) + 1; // [1..500]
115 :
116 0 : for (size_t j = 0; j < num_addresses; ++j) {
117 0 : const auto addr = CAddress{CService{RandAddr(fuzzed_data_provider, fast_random_context), 8333}, NODE_NETWORK};
118 0 : const std::chrono::seconds time_penalty{fast_random_context.randrange(100000001)};
119 0 : addrman.Add({addr}, source, time_penalty);
120 :
121 0 : if (n > 0 && addrman.Size() % n == 0) {
122 0 : addrman.Good(addr, Now<NodeSeconds>());
123 0 : }
124 :
125 : // Add 10% of the addresses from more than one source.
126 0 : if (fast_random_context.randrange(10) == 0 && prev_source.IsValid()) {
127 0 : addrman.Add({addr}, prev_source, time_penalty);
128 0 : }
129 0 : }
130 0 : prev_source = source;
131 0 : }
132 0 : }
133 :
134 : class AddrManDeterministic : public AddrMan
135 : {
136 : public:
137 0 : explicit AddrManDeterministic(const NetGroupManager& netgroupman, FuzzedDataProvider& fuzzed_data_provider)
138 0 : : AddrMan(netgroupman, /*deterministic=*/true, GetCheckRatio())
139 : {
140 0 : WITH_LOCK(m_impl->cs, m_impl->insecure_rand = FastRandomContext{ConsumeUInt256(fuzzed_data_provider)});
141 0 : }
142 :
143 : /**
144 : * Compare with another AddrMan.
145 : * This compares:
146 : * - the values in `mapInfo` (the keys aka ids are ignored)
147 : * - vvNew entries refer to the same addresses
148 : * - vvTried entries refer to the same addresses
149 : */
150 0 : bool operator==(const AddrManDeterministic& other) const
151 : {
152 0 : LOCK2(m_impl->cs, other.m_impl->cs);
153 :
154 0 : if (m_impl->mapInfo.size() != other.m_impl->mapInfo.size() || m_impl->nNew != other.m_impl->nNew ||
155 0 : m_impl->nTried != other.m_impl->nTried) {
156 0 : return false;
157 : }
158 :
159 : // Check that all values in `mapInfo` are equal to all values in `other.mapInfo`.
160 : // Keys may be different.
161 :
162 0 : auto addrinfo_hasher = [](const AddrInfo& a) {
163 0 : CSipHasher hasher(0, 0);
164 0 : auto addr_key = a.GetKey();
165 0 : auto source_key = a.source.GetAddrBytes();
166 0 : hasher.Write(TicksSinceEpoch<std::chrono::seconds>(a.m_last_success));
167 0 : hasher.Write(a.nAttempts);
168 0 : hasher.Write(a.nRefCount);
169 0 : hasher.Write(a.fInTried);
170 0 : hasher.Write(a.GetNetwork());
171 0 : hasher.Write(a.source.GetNetwork());
172 0 : hasher.Write(addr_key.size());
173 0 : hasher.Write(source_key.size());
174 0 : hasher.Write(addr_key);
175 0 : hasher.Write(source_key);
176 0 : return (size_t)hasher.Finalize();
177 0 : };
178 :
179 0 : auto addrinfo_eq = [](const AddrInfo& lhs, const AddrInfo& rhs) {
180 0 : return std::tie(static_cast<const CService&>(lhs), lhs.source, lhs.m_last_success, lhs.nAttempts, lhs.nRefCount, lhs.fInTried) ==
181 0 : std::tie(static_cast<const CService&>(rhs), rhs.source, rhs.m_last_success, rhs.nAttempts, rhs.nRefCount, rhs.fInTried);
182 : };
183 :
184 : using Addresses = std::unordered_set<AddrInfo, decltype(addrinfo_hasher), decltype(addrinfo_eq)>;
185 :
186 0 : const size_t num_addresses{m_impl->mapInfo.size()};
187 :
188 0 : Addresses addresses{num_addresses, addrinfo_hasher, addrinfo_eq};
189 0 : for (const auto& [id, addr] : m_impl->mapInfo) {
190 0 : addresses.insert(addr);
191 : }
192 :
193 0 : Addresses other_addresses{num_addresses, addrinfo_hasher, addrinfo_eq};
194 0 : for (const auto& [id, addr] : other.m_impl->mapInfo) {
195 0 : other_addresses.insert(addr);
196 : }
197 :
198 0 : if (addresses != other_addresses) {
199 0 : return false;
200 : }
201 :
202 0 : auto IdsReferToSameAddress = [&](int id, int other_id) EXCLUSIVE_LOCKS_REQUIRED(m_impl->cs, other.m_impl->cs) {
203 0 : if (id == -1 && other_id == -1) {
204 0 : return true;
205 : }
206 0 : if ((id == -1 && other_id != -1) || (id != -1 && other_id == -1)) {
207 0 : return false;
208 : }
209 0 : return m_impl->mapInfo.at(id) == other.m_impl->mapInfo.at(other_id);
210 0 : };
211 :
212 : // Check that `vvNew` contains the same addresses as `other.vvNew`. Notice - `vvNew[i][j]`
213 : // contains just an id and the address is to be found in `mapInfo.at(id)`. The ids
214 : // themselves may differ between `vvNew` and `other.vvNew`.
215 0 : for (size_t i = 0; i < ADDRMAN_NEW_BUCKET_COUNT; ++i) {
216 0 : for (size_t j = 0; j < ADDRMAN_BUCKET_SIZE; ++j) {
217 0 : if (!IdsReferToSameAddress(m_impl->vvNew[i][j], other.m_impl->vvNew[i][j])) {
218 0 : return false;
219 : }
220 0 : }
221 0 : }
222 :
223 : // Same for `vvTried`.
224 0 : for (size_t i = 0; i < ADDRMAN_TRIED_BUCKET_COUNT; ++i) {
225 0 : for (size_t j = 0; j < ADDRMAN_BUCKET_SIZE; ++j) {
226 0 : if (!IdsReferToSameAddress(m_impl->vvTried[i][j], other.m_impl->vvTried[i][j])) {
227 0 : return false;
228 : }
229 0 : }
230 0 : }
231 :
232 0 : return true;
233 0 : }
234 : };
235 :
236 4 : FUZZ_TARGET(addrman, .init = initialize_addrman)
237 : {
238 0 : FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
239 0 : SetMockTime(ConsumeTime(fuzzed_data_provider));
240 0 : NetGroupManager netgroupman{ConsumeNetGroupManager(fuzzed_data_provider)};
241 0 : auto addr_man_ptr = std::make_unique<AddrManDeterministic>(netgroupman, fuzzed_data_provider);
242 0 : if (fuzzed_data_provider.ConsumeBool()) {
243 0 : const std::vector<uint8_t> serialized_data{ConsumeRandomLengthByteVector(fuzzed_data_provider)};
244 0 : DataStream ds{serialized_data};
245 : try {
246 0 : ds >> *addr_man_ptr;
247 0 : } catch (const std::ios_base::failure&) {
248 0 : addr_man_ptr = std::make_unique<AddrManDeterministic>(netgroupman, fuzzed_data_provider);
249 0 : }
250 0 : }
251 0 : AddrManDeterministic& addr_man = *addr_man_ptr;
252 0 : LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 10000) {
253 0 : CallOneOf(
254 : fuzzed_data_provider,
255 0 : [&] {
256 0 : addr_man.ResolveCollisions();
257 0 : },
258 0 : [&] {
259 0 : (void)addr_man.SelectTriedCollision();
260 0 : },
261 0 : [&] {
262 0 : std::vector<CAddress> addresses;
263 0 : LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 10000) {
264 0 : addresses.push_back(ConsumeAddress(fuzzed_data_provider));
265 0 : }
266 0 : addr_man.Add(addresses, ConsumeNetAddr(fuzzed_data_provider), std::chrono::seconds{ConsumeTime(fuzzed_data_provider, 0, 100000000)});
267 0 : },
268 0 : [&] {
269 0 : addr_man.Good(ConsumeService(fuzzed_data_provider), NodeSeconds{std::chrono::seconds{ConsumeTime(fuzzed_data_provider)}});
270 0 : },
271 0 : [&] {
272 0 : addr_man.Attempt(ConsumeService(fuzzed_data_provider), fuzzed_data_provider.ConsumeBool(), NodeSeconds{std::chrono::seconds{ConsumeTime(fuzzed_data_provider)}});
273 0 : },
274 0 : [&] {
275 0 : addr_man.Connected(ConsumeService(fuzzed_data_provider), NodeSeconds{std::chrono::seconds{ConsumeTime(fuzzed_data_provider)}});
276 0 : },
277 0 : [&] {
278 0 : addr_man.SetServices(ConsumeService(fuzzed_data_provider), ConsumeWeakEnum(fuzzed_data_provider, ALL_SERVICE_FLAGS));
279 0 : });
280 0 : }
281 0 : const AddrMan& const_addr_man{addr_man};
282 0 : std::optional<Network> network;
283 0 : if (fuzzed_data_provider.ConsumeBool()) {
284 0 : network = fuzzed_data_provider.PickValueInArray(ALL_NETWORKS);
285 0 : }
286 0 : (void)const_addr_man.GetAddr(
287 0 : /*max_addresses=*/fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096),
288 0 : /*max_pct=*/fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096),
289 0 : network);
290 0 : (void)const_addr_man.Select(fuzzed_data_provider.ConsumeBool(), network);
291 0 : std::optional<bool> in_new;
292 0 : if (fuzzed_data_provider.ConsumeBool()) {
293 0 : in_new = fuzzed_data_provider.ConsumeBool();
294 0 : }
295 0 : (void)const_addr_man.Size(network, in_new);
296 0 : DataStream data_stream{};
297 0 : data_stream << const_addr_man;
298 0 : }
299 :
300 : // Check that serialize followed by unserialize produces the same addrman.
301 4 : FUZZ_TARGET(addrman_serdeser, .init = initialize_addrman)
302 : {
303 0 : FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
304 0 : SetMockTime(ConsumeTime(fuzzed_data_provider));
305 :
306 0 : NetGroupManager netgroupman{ConsumeNetGroupManager(fuzzed_data_provider)};
307 0 : AddrManDeterministic addr_man1{netgroupman, fuzzed_data_provider};
308 0 : AddrManDeterministic addr_man2{netgroupman, fuzzed_data_provider};
309 :
310 0 : DataStream data_stream{};
311 :
312 0 : FillAddrman(addr_man1, fuzzed_data_provider);
313 0 : data_stream << addr_man1;
314 0 : data_stream >> addr_man2;
315 0 : assert(addr_man1 == addr_man2);
316 0 : }
|
