Branch data Line data Source code
1 : : // Copyright (c) 2009-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 : : #ifndef BITCOIN_TEST_FUZZ_UTIL_NET_H
6 : : #define BITCOIN_TEST_FUZZ_UTIL_NET_H
7 : :
8 : : #include <addrman.h>
9 : : #include <addrman_impl.h>
10 : : #include <net.h>
11 : : #include <net_permissions.h>
12 : : #include <netaddress.h>
13 : : #include <node/connection_types.h>
14 : : #include <node/eviction.h>
15 : : #include <protocol.h>
16 : : #include <test/fuzz/FuzzedDataProvider.h>
17 : : #include <test/fuzz/util.h>
18 : : #include <test/util/net.h>
19 : : #include <threadsafety.h>
20 : : #include <util/asmap.h>
21 : : #include <util/sock.h>
22 : :
23 : : #include <chrono>
24 : : #include <cstdint>
25 : : #include <limits>
26 : : #include <memory>
27 : : #include <optional>
28 : : #include <string>
29 : :
30 : : /**
31 : : * Create a CNetAddr. It may have `addr.IsValid() == false`.
32 : : * @param[in,out] fuzzed_data_provider Take data for the address from this, if `rand` is `nullptr`.
33 : : * @param[in,out] rand If not nullptr, take data from it instead of from `fuzzed_data_provider`.
34 : : * Prefer generating addresses using `fuzzed_data_provider` because it is not uniform. Only use
35 : : * `rand` if `fuzzed_data_provider` is exhausted or its data is needed for other things.
36 : : * @return a "random" network address.
37 : : */
38 : : CNetAddr ConsumeNetAddr(FuzzedDataProvider& fuzzed_data_provider, FastRandomContext* rand = nullptr) noexcept;
39 : :
40 : 8280 : class AddrManDeterministic : public AddrMan
41 : : {
42 : : public:
43 : 9462 : explicit AddrManDeterministic(const NetGroupManager& netgroupman, FuzzedDataProvider& fuzzed_data_provider, int32_t check_ratio)
44 : 9462 : : AddrMan(netgroupman, /*deterministic=*/true, check_ratio)
45 : : {
46 [ + - + - ]: 18924 : WITH_LOCK(m_impl->cs, m_impl->insecure_rand.Reseed(ConsumeUInt256(fuzzed_data_provider)));
47 : 9462 : }
48 : :
49 : : /**
50 : : * Compare with another AddrMan.
51 : : * This compares:
52 : : * - the values in `mapInfo` (the keys aka ids are ignored)
53 : : * - vvNew entries refer to the same addresses
54 : : * - vvTried entries refer to the same addresses
55 : : */
56 : 1182 : bool operator==(const AddrManDeterministic& other) const
57 : : {
58 [ + - ]: 1182 : LOCK2(m_impl->cs, other.m_impl->cs);
59 : :
60 [ + - + - : 1182 : if (m_impl->mapInfo.size() != other.m_impl->mapInfo.size() || m_impl->nNew != other.m_impl->nNew ||
+ - ]
61 [ + - ]: 1182 : m_impl->nTried != other.m_impl->nTried) {
62 : : return false;
63 : : }
64 : :
65 : : // Check that all values in `mapInfo` are equal to all values in `other.mapInfo`.
66 : : // Keys may be different.
67 : :
68 : 12808932 : auto addrinfo_hasher = [](const AddrInfo& a) {
69 : 12807750 : CSipHasher hasher(0, 0);
70 : 12807750 : auto addr_key = a.GetKey();
71 [ + - ]: 12807750 : auto source_key = a.source.GetAddrBytes();
72 [ + - ]: 12807750 : hasher.Write(TicksSinceEpoch<std::chrono::seconds>(a.m_last_success));
73 [ + - ]: 12807750 : hasher.Write(a.nAttempts);
74 [ + - ]: 12807750 : hasher.Write(a.nRefCount);
75 [ + - ]: 12807750 : hasher.Write(a.fInTried);
76 [ + - + - ]: 12807750 : hasher.Write(a.GetNetwork());
77 [ + - + - ]: 12807750 : hasher.Write(a.source.GetNetwork());
78 [ + - ]: 12807750 : hasher.Write(addr_key.size());
79 [ + - ]: 12807750 : hasher.Write(source_key.size());
80 [ + - ]: 12807750 : hasher.Write(addr_key);
81 [ + - ]: 12807750 : hasher.Write(source_key);
82 [ + - ]: 12807750 : return (size_t)hasher.Finalize();
83 : 12807750 : };
84 : :
85 : 1182 : auto addrinfo_eq = [](const AddrInfo& lhs, const AddrInfo& rhs) {
86 : 0 : return std::tie(static_cast<const CService&>(lhs), lhs.source, lhs.m_last_success, lhs.nAttempts, lhs.nRefCount, lhs.fInTried) ==
87 : 0 : std::tie(static_cast<const CService&>(rhs), rhs.source, rhs.m_last_success, rhs.nAttempts, rhs.nRefCount, rhs.fInTried);
88 : : };
89 : :
90 : 1182 : using Addresses = std::unordered_set<AddrInfo, decltype(addrinfo_hasher), decltype(addrinfo_eq)>;
91 : :
92 [ + - ]: 1182 : const size_t num_addresses{m_impl->mapInfo.size()};
93 : :
94 [ + - ]: 2364 : Addresses addresses{num_addresses, addrinfo_hasher, addrinfo_eq};
95 [ + - + + ]: 6405057 : for (const auto& [id, addr] : m_impl->mapInfo) {
96 [ + - ]: 6403875 : addresses.insert(addr);
97 : : }
98 : :
99 [ + - ]: 2364 : Addresses other_addresses{num_addresses, addrinfo_hasher, addrinfo_eq};
100 [ + - + + ]: 6405057 : for (const auto& [id, addr] : other.m_impl->mapInfo) {
101 [ + - ]: 6403875 : other_addresses.insert(addr);
102 : : }
103 : :
104 [ + - + - ]: 1182 : if (addresses != other_addresses) {
105 : : return false;
106 : : }
107 : :
108 : 96830622 : auto IdsReferToSameAddress = [&](nid_type id, nid_type other_id) EXCLUSIVE_LOCKS_REQUIRED(m_impl->cs, other.m_impl->cs) {
109 [ + + - + ]: 96829440 : if (id == -1 && other_id == -1) {
110 : : return true;
111 : : }
112 [ - + - - : 6540697 : if ((id == -1 && other_id != -1) || (id != -1 && other_id == -1)) {
+ - + - ]
113 : : return false;
114 : : }
115 : 6540697 : return m_impl->mapInfo.at(id) == other.m_impl->mapInfo.at(other_id);
116 : 1182 : };
117 : :
118 : : // Check that `vvNew` contains the same addresses as `other.vvNew`. Notice - `vvNew[i][j]`
119 : : // contains just an id and the address is to be found in `mapInfo.at(id)`. The ids
120 : : // themselves may differ between `vvNew` and `other.vvNew`.
121 [ + + ]: 1211550 : for (size_t i = 0; i < ADDRMAN_NEW_BUCKET_COUNT; ++i) {
122 [ + + ]: 78673920 : for (size_t j = 0; j < ADDRMAN_BUCKET_SIZE; ++j) {
123 [ + - + - ]: 77463552 : if (!IdsReferToSameAddress(m_impl->vvNew[i][j], other.m_impl->vvNew[i][j])) {
124 : : return false;
125 : : }
126 : : }
127 : : }
128 : :
129 : : // Same for `vvTried`.
130 [ + + ]: 303774 : for (size_t i = 0; i < ADDRMAN_TRIED_BUCKET_COUNT; ++i) {
131 [ + + ]: 19668480 : for (size_t j = 0; j < ADDRMAN_BUCKET_SIZE; ++j) {
132 [ + - + - ]: 19365888 : if (!IdsReferToSameAddress(m_impl->vvTried[i][j], other.m_impl->vvTried[i][j])) {
133 : : return false;
134 : : }
135 : : }
136 : : }
137 : :
138 : : return true;
139 [ + - ]: 3546 : }
140 : : };
141 : :
142 : : class FuzzedSock : public Sock
143 : : {
144 : : FuzzedDataProvider& m_fuzzed_data_provider;
145 : :
146 : : /**
147 : : * Data to return when `MSG_PEEK` is used as a `Recv()` flag.
148 : : * If `MSG_PEEK` is used, then our `Recv()` returns some random data as usual, but on the next
149 : : * `Recv()` call we must return the same data, thus we remember it here.
150 : : */
151 : : mutable std::vector<uint8_t> m_peek_data;
152 : :
153 : : /**
154 : : * Whether to pretend that the socket is select(2)-able. This is randomly set in the
155 : : * constructor. It should remain constant so that repeated calls to `IsSelectable()`
156 : : * return the same value.
157 : : */
158 : : const bool m_selectable;
159 : :
160 : : public:
161 : : explicit FuzzedSock(FuzzedDataProvider& fuzzed_data_provider);
162 : :
163 : : ~FuzzedSock() override;
164 : :
165 : : FuzzedSock& operator=(Sock&& other) override;
166 : :
167 : : ssize_t Send(const void* data, size_t len, int flags) const override;
168 : :
169 : : ssize_t Recv(void* buf, size_t len, int flags) const override;
170 : :
171 : : int Connect(const sockaddr*, socklen_t) const override;
172 : :
173 : : int Bind(const sockaddr*, socklen_t) const override;
174 : :
175 : : int Listen(int backlog) const override;
176 : :
177 : : std::unique_ptr<Sock> Accept(sockaddr* addr, socklen_t* addr_len) const override;
178 : :
179 : : int GetSockOpt(int level, int opt_name, void* opt_val, socklen_t* opt_len) const override;
180 : :
181 : : int SetSockOpt(int level, int opt_name, const void* opt_val, socklen_t opt_len) const override;
182 : :
183 : : int GetSockName(sockaddr* name, socklen_t* name_len) const override;
184 : :
185 : : bool SetNonBlocking() const override;
186 : :
187 : : bool IsSelectable() const override;
188 : :
189 : : bool Wait(std::chrono::milliseconds timeout, Event requested, Event* occurred = nullptr) const override;
190 : :
191 : : bool WaitMany(std::chrono::milliseconds timeout, EventsPerSock& events_per_sock) const override;
192 : :
193 : : bool IsConnected(std::string& errmsg) const override;
194 : : };
195 : :
196 : 65 : [[nodiscard]] inline FuzzedSock ConsumeSock(FuzzedDataProvider& fuzzed_data_provider)
197 : : {
198 [ + - ]: 65 : return FuzzedSock{fuzzed_data_provider};
199 : : }
200 : :
201 : 7255 : [[nodiscard]] inline NetGroupManager ConsumeNetGroupManager(FuzzedDataProvider& fuzzed_data_provider) noexcept
202 : : {
203 : 7255 : std::vector<bool> asmap = ConsumeRandomLengthBitVector(fuzzed_data_provider);
204 [ + + ]: 7255 : if (!SanityCheckASMap(asmap, 128)) asmap.clear();
205 : 7255 : return NetGroupManager(asmap);
206 : 7255 : }
207 : :
208 : 95906 : inline CSubNet ConsumeSubNet(FuzzedDataProvider& fuzzed_data_provider) noexcept
209 : : {
210 : 95906 : return {ConsumeNetAddr(fuzzed_data_provider), fuzzed_data_provider.ConsumeIntegral<uint8_t>()};
211 : : }
212 : :
213 : 2855212 : inline CService ConsumeService(FuzzedDataProvider& fuzzed_data_provider) noexcept
214 : : {
215 : 2855212 : return {ConsumeNetAddr(fuzzed_data_provider), fuzzed_data_provider.ConsumeIntegral<uint16_t>()};
216 : : }
217 : :
218 : : CAddress ConsumeAddress(FuzzedDataProvider& fuzzed_data_provider) noexcept;
219 : :
220 : : template <bool ReturnUniquePtr = false>
221 : 40174 : auto ConsumeNode(FuzzedDataProvider& fuzzed_data_provider, const std::optional<NodeId>& node_id_in = std::nullopt) noexcept
222 : : {
223 [ + + ]: 49702 : const NodeId node_id = node_id_in.value_or(fuzzed_data_provider.ConsumeIntegralInRange<NodeId>(0, std::numeric_limits<NodeId>::max()));
224 : 40174 : const auto sock = std::make_shared<FuzzedSock>(fuzzed_data_provider);
225 : 40174 : const CAddress address = ConsumeAddress(fuzzed_data_provider);
226 : 40174 : const uint64_t keyed_net_group = fuzzed_data_provider.ConsumeIntegral<uint64_t>();
227 : 40174 : const uint64_t local_host_nonce = fuzzed_data_provider.ConsumeIntegral<uint64_t>();
228 : 40174 : const CAddress addr_bind = ConsumeAddress(fuzzed_data_provider);
229 : 40174 : const std::string addr_name = fuzzed_data_provider.ConsumeRandomLengthString(64);
230 : 40174 : const ConnectionType conn_type = fuzzed_data_provider.PickValueInArray(ALL_CONNECTION_TYPES);
231 [ + + + + ]: 49184 : const bool inbound_onion{conn_type == ConnectionType::INBOUND ? fuzzed_data_provider.ConsumeBool() : false};
232 : 40174 : NetPermissionFlags permission_flags = ConsumeWeakEnum(fuzzed_data_provider, ALL_NET_PERMISSION_FLAGS);
233 : : if constexpr (ReturnUniquePtr) {
234 : : return std::make_unique<CNode>(node_id,
235 : : sock,
236 : : address,
237 : : keyed_net_group,
238 : : local_host_nonce,
239 : : addr_bind,
240 : : addr_name,
241 : : conn_type,
242 : : inbound_onion,
243 : 34736 : CNodeOptions{ .permission_flags = permission_flags });
244 : : } else {
245 : 5438 : return CNode{node_id,
246 : : sock,
247 : : address,
248 : : keyed_net_group,
249 : : local_host_nonce,
250 : : addr_bind,
251 : : addr_name,
252 : : conn_type,
253 : : inbound_onion,
254 [ + - + - ]: 10876 : CNodeOptions{ .permission_flags = permission_flags }};
255 : : }
256 [ + - ]: 80348 : }
257 : 34736 : inline std::unique_ptr<CNode> ConsumeNodeAsUniquePtr(FuzzedDataProvider& fdp, const std::optional<NodeId>& node_id_in = std::nullopt) { return ConsumeNode<true>(fdp, node_id_in); }
258 : :
259 : : void FillNode(FuzzedDataProvider& fuzzed_data_provider, ConnmanTestMsg& connman, CNode& node) noexcept EXCLUSIVE_LOCKS_REQUIRED(NetEventsInterface::g_msgproc_mutex);
260 : :
261 : : #endif // BITCOIN_TEST_FUZZ_UTIL_NET_H
|
