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 <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 <test/util/time.h>
18 : : #include <util/asmap.h>
19 : : #include <util/chaintype.h>
20 : :
21 : : #include <cassert>
22 : : #include <cstdint>
23 : : #include <ctime>
24 : : #include <optional>
25 : : #include <string>
26 : : #include <vector>
27 : :
28 : : namespace {
29 : : const BasicTestingSetup* g_setup;
30 : :
31 : 8738 : int32_t GetCheckRatio()
32 : : {
33 [ + - ]: 26214 : return std::clamp<int32_t>(g_setup->m_node.args->GetIntArg("-checkaddrman", 0), 0, 1000000);
34 : : }
35 : : } // namespace
36 : :
37 : 3 : void initialize_addrman()
38 : : {
39 [ + - + - : 3 : static const auto testing_setup = MakeNoLogFileContext<>(ChainType::REGTEST);
+ - ]
40 : 3 : g_setup = testing_setup.get();
41 : 3 : }
42 : :
43 [ + - ]: 2366 : FUZZ_TARGET(data_stream_addr_man, .init = initialize_addrman)
44 : : {
45 : 1892 : SeedRandomStateForTest(SeedRand::ZEROS);
46 : 1892 : FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
47 : 1892 : DataStream data_stream = ConsumeDataStream(fuzzed_data_provider);
48 : 1892 : NetGroupManager netgroupman{ConsumeNetGroupManager(fuzzed_data_provider)};
49 [ + - + - ]: 1892 : AddrMan addr_man(netgroupman, /*deterministic=*/false, GetCheckRatio());
50 : 1892 : try {
51 [ + + ]: 1892 : ReadFromStream(addr_man, data_stream);
52 [ - + ]: 1180 : } catch (const std::exception&) {
53 : 1180 : }
54 : 1892 : }
55 : :
56 : : /**
57 : : * Generate a random address. Always returns a valid address.
58 : : */
59 : 11198472 : CNetAddr RandAddr(FuzzedDataProvider& fuzzed_data_provider, FastRandomContext& fast_random_context)
60 : : {
61 : 11198472 : CNetAddr addr;
62 [ + - + - ]: 11198472 : assert(!addr.IsValid());
63 [ + + + - : 24503709 : for (size_t i = 0; i < 8 && !addr.IsValid(); ++i) {
+ + ]
64 [ + + + + ]: 15293436 : if (fuzzed_data_provider.remaining_bytes() > 1 && fuzzed_data_provider.ConsumeBool()) {
65 : 1542771 : addr = ConsumeNetAddr(fuzzed_data_provider);
66 : : } else {
67 : 11762466 : addr = ConsumeNetAddr(fuzzed_data_provider, &fast_random_context);
68 : : }
69 : : }
70 : :
71 : : // Return a dummy IPv4 5.5.5.5 if we generated an invalid address.
72 [ + - + + ]: 11198472 : if (!addr.IsValid()) {
73 : 8225 : in_addr v4_addr = {};
74 : 8225 : v4_addr.s_addr = 0x05050505;
75 [ + - ]: 16450 : addr = CNetAddr{v4_addr};
76 : : }
77 : :
78 : 11198472 : return addr;
79 : 0 : }
80 : :
81 : : /** Fill addrman with lots of addresses from lots of sources. */
82 : 1640 : void FillAddrman(AddrMan& addrman, FuzzedDataProvider& fuzzed_data_provider)
83 : : {
84 : : // Add a fraction of the addresses to the "tried" table.
85 : : // 0, 1, 2, 3 corresponding to 0%, 100%, 50%, 33%
86 : 1640 : const size_t n = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 3);
87 : :
88 : 1640 : const size_t num_sources = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(1, 50);
89 : 1640 : CNetAddr prev_source;
90 : : // Generate a FastRandomContext seed to use inside the loops instead of
91 : : // fuzzed_data_provider. When fuzzed_data_provider is exhausted it
92 : : // just returns 0.
93 : 1640 : FastRandomContext fast_random_context{ConsumeUInt256(fuzzed_data_provider)};
94 [ + + ]: 46263 : for (size_t i = 0; i < num_sources; ++i) {
95 [ + - ]: 44623 : const auto source = RandAddr(fuzzed_data_provider, fast_random_context);
96 : 44623 : const size_t num_addresses = fast_random_context.randrange(500) + 1; // [1..500]
97 : :
98 [ + + ]: 11198472 : for (size_t j = 0; j < num_addresses; ++j) {
99 [ + - + - ]: 22307698 : const auto addr = CAddress{CService{RandAddr(fuzzed_data_provider, fast_random_context), 8333}, NODE_NETWORK};
100 : 11153849 : const std::chrono::seconds time_penalty{fast_random_context.randrange(100000001)};
101 [ + - + - : 22307698 : addrman.Add({addr}, source, time_penalty);
+ + - - ]
102 : :
103 [ + + + - : 11153849 : if (n > 0 && addrman.Size() % n == 0) {
+ + ]
104 [ + - ]: 6618315 : addrman.Good(addr, Now<NodeSeconds>());
105 : : }
106 : :
107 : : // Add 10% of the addresses from more than one source.
108 [ + + + - : 11153849 : if (fast_random_context.randrange(10) == 0 && prev_source.IsValid()) {
+ + ]
109 [ + - + - : 2169894 : addrman.Add({addr}, prev_source, time_penalty);
+ + - - ]
110 : : }
111 : 11153849 : }
112 : 89246 : prev_source = source;
113 : 44623 : }
114 : 12240436 : }
115 : :
116 [ + - ]: 2947 : FUZZ_TARGET(addrman, .init = initialize_addrman)
117 : : {
118 : 2473 : SeedRandomStateForTest(SeedRand::ZEROS);
119 : 2473 : FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
120 : 2473 : FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
121 : 2473 : NetGroupManager netgroupman{ConsumeNetGroupManager(fuzzed_data_provider)};
122 [ + - + - ]: 2473 : auto addr_man_ptr = std::make_unique<AddrManDeterministic>(netgroupman, fuzzed_data_provider, GetCheckRatio());
123 [ + + ]: 2473 : if (fuzzed_data_provider.ConsumeBool()) {
124 : 1488 : const std::vector<uint8_t> serialized_data{ConsumeRandomLengthByteVector(fuzzed_data_provider)};
125 [ - + + - ]: 1488 : DataStream ds{serialized_data};
126 : 1488 : try {
127 [ + + ]: 2976 : ds >> *addr_man_ptr;
128 [ - + ]: 1093 : } catch (const std::ios_base::failure&) {
129 [ + - + - ]: 2186 : addr_man_ptr = std::make_unique<AddrManDeterministic>(netgroupman, fuzzed_data_provider, GetCheckRatio());
130 : 1093 : }
131 : 1488 : }
132 : 2473 : AddrManDeterministic& addr_man = *addr_man_ptr;
133 [ + + + + ]: 719801 : LIMITED_WHILE (fuzzed_data_provider.ConsumeBool(), 10000) {
134 [ + - ]: 717328 : CallOneOf(
135 : : fuzzed_data_provider,
136 : 14699 : [&] {
137 : 14699 : addr_man.ResolveCollisions();
138 : 14699 : },
139 : 96165 : [&] {
140 : 96165 : (void)addr_man.SelectTriedCollision();
141 : 96165 : },
142 : 14487 : [&] {
143 : 14487 : std::vector<CAddress> addresses;
144 [ + + + + ]: 3888702 : LIMITED_WHILE (fuzzed_data_provider.ConsumeBool(), 10000) {
145 [ + - ]: 3874215 : addresses.push_back(ConsumeAddress(fuzzed_data_provider));
146 : : }
147 : 14487 : auto net_addr = ConsumeNetAddr(fuzzed_data_provider);
148 : 14487 : auto time_penalty = ConsumeDuration<std::chrono::seconds>(fuzzed_data_provider, /*min=*/0s, /*max=*/100000000s);
149 [ + - ]: 14487 : addr_man.Add(addresses, net_addr, time_penalty);
150 : 14487 : },
151 : 498155 : [&] {
152 : 498155 : auto addr = ConsumeService(fuzzed_data_provider);
153 : 498155 : auto time = ConsumeTime(fuzzed_data_provider);
154 [ + - ]: 498155 : addr_man.Good(addr, time);
155 : 498155 : },
156 : 11088 : [&] {
157 : 11088 : auto addr = ConsumeService(fuzzed_data_provider);
158 : 11088 : auto count_failure = fuzzed_data_provider.ConsumeBool();
159 : 11088 : auto time = ConsumeTime(fuzzed_data_provider);
160 [ + - ]: 11088 : addr_man.Attempt(addr, count_failure, time);
161 : 11088 : },
162 : 10378 : [&] {
163 : 10378 : auto addr = ConsumeService(fuzzed_data_provider);
164 : 10378 : auto time = ConsumeTime(fuzzed_data_provider);
165 [ + - ]: 10378 : addr_man.Connected(addr, time);
166 : 10378 : },
167 : 72356 : [&] {
168 : 72356 : auto addr = ConsumeService(fuzzed_data_provider);
169 : 72356 : auto n_services = ConsumeWeakEnum(fuzzed_data_provider, ALL_SERVICE_FLAGS);
170 [ + - ]: 72356 : addr_man.SetServices(addr, n_services);
171 : 72356 : });
172 : : }
173 : 2473 : const AddrMan& const_addr_man{addr_man};
174 : 2473 : std::optional<Network> network;
175 [ + + ]: 2473 : if (fuzzed_data_provider.ConsumeBool()) {
176 : 236 : network = fuzzed_data_provider.PickValueInArray(ALL_NETWORKS);
177 : : }
178 : 2473 : auto max_addresses = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096);
179 : 2473 : auto max_pct = fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 100);
180 : 2473 : auto filtered = fuzzed_data_provider.ConsumeBool();
181 [ + - ]: 2473 : (void)const_addr_man.GetAddr(max_addresses, max_pct, network, filtered);
182 : :
183 : 2473 : std::unordered_set<Network> nets;
184 [ + + ]: 19784 : for (const auto& net : ALL_NETWORKS) {
185 [ + + ]: 17311 : if (fuzzed_data_provider.ConsumeBool()) {
186 [ + - ]: 1604 : nets.insert(net);
187 : : }
188 : : }
189 [ + - ]: 2473 : (void)const_addr_man.Select(fuzzed_data_provider.ConsumeBool(), nets);
190 : :
191 : 2473 : std::optional<bool> in_new;
192 [ + + ]: 2473 : if (fuzzed_data_provider.ConsumeBool()) {
193 : 223 : in_new = fuzzed_data_provider.ConsumeBool();
194 : : }
195 [ + - ]: 2473 : (void)const_addr_man.Size(network, in_new);
196 : 2473 : DataStream data_stream{};
197 [ + - ]: 4946 : data_stream << const_addr_man;
198 : 2473 : }
199 : :
200 : : // Check that serialize followed by unserialize produces the same addrman.
201 [ + - ]: 2114 : FUZZ_TARGET(addrman_serdeser, .init = initialize_addrman)
202 : : {
203 : 1640 : SeedRandomStateForTest(SeedRand::ZEROS);
204 : 1640 : FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
205 : 1640 : FakeNodeClock clock{ConsumeTime(fuzzed_data_provider)};
206 : :
207 : 1640 : NetGroupManager netgroupman{ConsumeNetGroupManager(fuzzed_data_provider)};
208 [ + - + - ]: 1640 : AddrManDeterministic addr_man1{netgroupman, fuzzed_data_provider, GetCheckRatio()};
209 [ + - + - ]: 1640 : AddrManDeterministic addr_man2{netgroupman, fuzzed_data_provider, GetCheckRatio()};
210 : :
211 : 1640 : DataStream data_stream{};
212 : :
213 [ + - ]: 1640 : FillAddrman(addr_man1, fuzzed_data_provider);
214 [ + - ]: 1640 : data_stream << addr_man1;
215 [ + - ]: 1640 : data_stream >> addr_man2;
216 [ + - - + ]: 1640 : assert(addr_man1 == addr_man2);
217 : 1640 : }
|
