1 // Copyright (c) 2009-2022 The Limenka 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 LIMENKA_TEST_FUZZ_UTIL_NET_H
6 #define LIMENKA_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 class AddrManDeterministic : public AddrMan
41 {
42 public:
43 explicit AddrManDeterministic(const NetGroupManager& netgroupman, FuzzedDataProvider& fuzzed_data_provider, int32_t check_ratio)
44 : AddrMan(netgroupman, /*deterministic=*/true, check_ratio)
45 {
46 WITH_LOCK(m_impl->cs, m_impl->insecure_rand.Reseed(ConsumeUInt256(fuzzed_data_provider)));
47 }
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 bool operator==(const AddrManDeterministic& other) const
57 {
58 LOCK2(m_impl->cs, other.m_impl->cs);
59
60 if (m_impl->mapInfo.size() != other.m_impl->mapInfo.size() || m_impl->nNew != other.m_impl->nNew ||
61 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 auto addrinfo_hasher = [](const AddrInfo& a) {
69 CSipHasher hasher(0, 0);
70 auto addr_key = a.GetKey();
71 auto source_key = a.source.GetAddrBytes();
72 hasher.Write(TicksSinceEpoch<std::chrono::seconds>(a.m_last_success));
73 hasher.Write(a.nAttempts);
74 hasher.Write(a.nRefCount);
75 hasher.Write(a.fInTried);
76 hasher.Write(a.GetNetwork());
77 hasher.Write(a.source.GetNetwork());
78 hasher.Write(addr_key.size());
79 hasher.Write(source_key.size());
80 hasher.Write(addr_key);
81 hasher.Write(source_key);
82 return (size_t)hasher.Finalize();
83 };
84
85 auto addrinfo_eq = [](const AddrInfo& lhs, const AddrInfo& rhs) {
86 return std::tie(static_cast<const CService&>(lhs), lhs.source, lhs.m_last_success, lhs.nAttempts, lhs.nRefCount, lhs.fInTried) ==
87 std::tie(static_cast<const CService&>(rhs), rhs.source, rhs.m_last_success, rhs.nAttempts, rhs.nRefCount, rhs.fInTried);
88 };
89
90 using Addresses = std::unordered_set<AddrInfo, decltype(addrinfo_hasher), decltype(addrinfo_eq)>;
91
92 const size_t num_addresses{m_impl->mapInfo.size()};
93
94 Addresses addresses{num_addresses, addrinfo_hasher, addrinfo_eq};
95 for (const auto& [id, addr] : m_impl->mapInfo) {
96 addresses.insert(addr);
97 }
98
99 Addresses other_addresses{num_addresses, addrinfo_hasher, addrinfo_eq};
100 for (const auto& [id, addr] : other.m_impl->mapInfo) {
101 other_addresses.insert(addr);
102 }
103
104 if (addresses != other_addresses) {
105 return false;
106 }
107
108 auto IdsReferToSameAddress = [&](nid_type id, nid_type other_id) EXCLUSIVE_LOCKS_REQUIRED(m_impl->cs, other.m_impl->cs) {
109 if (id == -1 && other_id == -1) {
110 return true;
111 }
112 if ((id == -1 && other_id != -1) || (id != -1 && other_id == -1)) {
113 return false;
114 }
115 return m_impl->mapInfo.at(id) == other.m_impl->mapInfo.at(other_id);
116 };
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 for (size_t i = 0; i < ADDRMAN_NEW_BUCKET_COUNT; ++i) {
122 for (size_t j = 0; j < ADDRMAN_BUCKET_SIZE; ++j) {
123 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 for (size_t i = 0; i < ADDRMAN_TRIED_BUCKET_COUNT; ++i) {
131 for (size_t j = 0; j < ADDRMAN_BUCKET_SIZE; ++j) {
132 if (!IdsReferToSameAddress(m_impl->vvTried[i][j], other.m_impl->vvTried[i][j])) {
133 return false;
134 }
135 }
136 }
137
138 return true;
139 }
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 /**
161 * Used to mock the steady clock in methods waiting for a given duration.
162 */
163 mutable std::chrono::milliseconds m_time;
164
165 /**
166 * Set the value of the mocked steady clock such as that many ms have passed.
167 */
168 void ElapseTime(std::chrono::milliseconds duration) const;
169
170 public:
171 explicit FuzzedSock(FuzzedDataProvider& fuzzed_data_provider);
172
173 ~FuzzedSock() override;
174
175 FuzzedSock& operator=(Sock&& other) override;
176
177 ssize_t Send(const void* data, size_t len, int flags) const override;
178
179 ssize_t Recv(void* buf, size_t len, int flags) const override;
180
181 int Connect(const sockaddr*, socklen_t) const override;
182
183 int Bind(const sockaddr*, socklen_t) const override;
184
185 int Listen(int backlog) const override;
186
187 std::unique_ptr<Sock> Accept(sockaddr* addr, socklen_t* addr_len) const override;
188
189 int GetSockOpt(int level, int opt_name, void* opt_val, socklen_t* opt_len) const override;
190
191 int SetSockOpt(int level, int opt_name, const void* opt_val, socklen_t opt_len) const override;
192
193 int GetSockName(sockaddr* name, socklen_t* name_len) const override;
194
195 bool SetNonBlocking() const override;
196
197 bool IsSelectable() const override;
198
199 bool Wait(std::chrono::milliseconds timeout, Event requested, Event* occurred = nullptr) const override;
200
201 bool WaitMany(std::chrono::milliseconds timeout, EventsPerSock& events_per_sock) const override;
202
203 bool IsConnected(std::string& errmsg) const override;
204 };
205
206 [[nodiscard]] inline FuzzedSock ConsumeSock(FuzzedDataProvider& fuzzed_data_provider)
207 {
208 return FuzzedSock{fuzzed_data_provider};
209 }
210
211 [[nodiscard]] inline NetGroupManager ConsumeNetGroupManager(FuzzedDataProvider& fuzzed_data_provider) noexcept
212 {
213 std::vector<bool> asmap = ConsumeRandomLengthBitVector(fuzzed_data_provider);
214 if (!SanityCheckASMap(asmap, 128)) asmap.clear();
215 return NetGroupManager(asmap);
216 }
217
218 inline CSubNet ConsumeSubNet(FuzzedDataProvider& fuzzed_data_provider) noexcept
219 {
220 return {ConsumeNetAddr(fuzzed_data_provider), fuzzed_data_provider.ConsumeIntegral<uint8_t>()};
221 }
222
223 inline CService ConsumeService(FuzzedDataProvider& fuzzed_data_provider) noexcept
224 {
225 return {ConsumeNetAddr(fuzzed_data_provider), fuzzed_data_provider.ConsumeIntegral<uint16_t>()};
226 }
227
228 CAddress ConsumeAddress(FuzzedDataProvider& fuzzed_data_provider) noexcept;
229
230 template <bool ReturnUniquePtr = false>
231 auto ConsumeNode(FuzzedDataProvider& fuzzed_data_provider, const std::optional<NodeId>& node_id_in = std::nullopt) noexcept
232 {
233 const NodeId node_id = node_id_in.value_or(fuzzed_data_provider.ConsumeIntegralInRange<NodeId>(0, std::numeric_limits<NodeId>::max()));
234 const auto sock = std::make_shared<FuzzedSock>(fuzzed_data_provider);
235 const CAddress address = ConsumeAddress(fuzzed_data_provider);
236 const uint64_t keyed_net_group = fuzzed_data_provider.ConsumeIntegral<uint64_t>();
237 const uint64_t local_host_nonce = fuzzed_data_provider.ConsumeIntegral<uint64_t>();
238 const CAddress addr_bind = ConsumeAddress(fuzzed_data_provider);
239 const std::string addr_name = fuzzed_data_provider.ConsumeRandomLengthString(64);
240 const ConnectionType conn_type = fuzzed_data_provider.PickValueInArray(ALL_CONNECTION_TYPES);
241 const bool inbound_onion{conn_type == ConnectionType::INBOUND ? fuzzed_data_provider.ConsumeBool() : false};
242 const uint64_t network_id = fuzzed_data_provider.ConsumeIntegral<uint64_t>();
243
244 NetPermissionFlags permission_flags = ConsumeWeakEnum(fuzzed_data_provider, ALL_NET_PERMISSION_FLAGS);
245 if constexpr (ReturnUniquePtr) {
246 return std::make_unique<CNode>(node_id,
247 sock,
248 address,
249 keyed_net_group,
250 local_host_nonce,
251 addr_bind,
252 addr_name,
253 conn_type,
254 inbound_onion,
255 network_id,
256 CNodeOptions{ .permission_flags = permission_flags });
257 } else {
258 return CNode{node_id,
259 sock,
260 address,
261 keyed_net_group,
262 local_host_nonce,
263 addr_bind,
264 addr_name,
265 conn_type,
266 inbound_onion,
267 network_id,
268 CNodeOptions{ .permission_flags = permission_flags }};
269 }
270 }
271 inline std::unique_ptr<CNode> ConsumeNodeAsUniquePtr(FuzzedDataProvider& fdp, const std::optional<NodeId>& node_id_in = std::nullopt) { return ConsumeNode<true>(fdp, node_id_in); }
272
273 void FillNode(FuzzedDataProvider& fuzzed_data_provider, ConnmanTestMsg& connman, CNode& node) noexcept EXCLUSIVE_LOCKS_REQUIRED(NetEventsInterface::g_msgproc_mutex);
274
275 #endif // LIMENKA_TEST_FUZZ_UTIL_NET_H
276