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 : #include <test/fuzz/util/net.h>
6 :
7 : #include <compat/compat.h>
8 : #include <netaddress.h>
9 : #include <protocol.h>
10 : #include <test/fuzz/FuzzedDataProvider.h>
11 : #include <test/fuzz/util.h>
12 : #include <test/util/net.h>
13 : #include <util/sock.h>
14 : #include <util/time.h>
15 : #include <version.h>
16 :
17 173 : #include <array>
18 173 : #include <cassert>
19 : #include <cerrno>
20 : #include <cstdint>
21 : #include <cstdlib>
22 : #include <cstring>
23 : #include <thread>
24 : #include <vector>
25 :
26 : class CNode;
27 :
28 4950 : CNetAddr ConsumeNetAddr(FuzzedDataProvider& fuzzed_data_provider) noexcept
29 : {
30 4950 : const Network network = fuzzed_data_provider.PickValueInArray({Network::NET_IPV4, Network::NET_IPV6, Network::NET_INTERNAL, Network::NET_ONION});
31 4950 : CNetAddr net_addr;
32 4950 : if (network == Network::NET_IPV4) {
33 1579 : in_addr v4_addr = {};
34 1579 : v4_addr.s_addr = fuzzed_data_provider.ConsumeIntegral<uint32_t>();
35 1579 : net_addr = CNetAddr{v4_addr};
36 4950 : } else if (network == Network::NET_IPV6) {
37 1425 : if (fuzzed_data_provider.remaining_bytes() >= 16) {
38 494 : in6_addr v6_addr = {};
39 494 : memcpy(v6_addr.s6_addr, fuzzed_data_provider.ConsumeBytes<uint8_t>(16).data(), 16);
40 494 : net_addr = CNetAddr{v6_addr, fuzzed_data_provider.ConsumeIntegral<uint32_t>()};
41 494 : }
42 3371 : } else if (network == Network::NET_INTERNAL) {
43 189 : net_addr.SetInternal(fuzzed_data_provider.ConsumeBytesAsString(32));
44 1946 : } else if (network == Network::NET_ONION) {
45 1757 : auto pub_key{fuzzed_data_provider.ConsumeBytes<uint8_t>(ADDR_TORV3_SIZE)};
46 1757 : pub_key.resize(ADDR_TORV3_SIZE);
47 1757 : const bool ok{net_addr.SetSpecial(OnionToString(pub_key))};
48 1757 : assert(ok);
49 1757 : }
50 4950 : return net_addr;
51 4950 : }
52 :
53 0 : CAddress ConsumeAddress(FuzzedDataProvider& fuzzed_data_provider) noexcept
54 : {
55 0 : return {ConsumeService(fuzzed_data_provider), ConsumeWeakEnum(fuzzed_data_provider, ALL_SERVICE_FLAGS), NodeSeconds{std::chrono::seconds{fuzzed_data_provider.ConsumeIntegral<uint32_t>()}}};
56 : }
57 :
58 : template <typename P>
59 0 : P ConsumeDeserializationParams(FuzzedDataProvider& fuzzed_data_provider) noexcept
60 : {
61 0 : constexpr std::array ADDR_ENCODINGS{
62 : CNetAddr::Encoding::V1,
63 : CNetAddr::Encoding::V2,
64 : };
65 0 : constexpr std::array ADDR_FORMATS{
66 : CAddress::Format::Disk,
67 : CAddress::Format::Network,
68 : };
69 : if constexpr (std::is_same_v<P, CNetAddr::SerParams>) {
70 0 : return P{PickValue(fuzzed_data_provider, ADDR_ENCODINGS)};
71 : }
72 : if constexpr (std::is_same_v<P, CAddress::SerParams>) {
73 0 : return P{{PickValue(fuzzed_data_provider, ADDR_ENCODINGS)}, PickValue(fuzzed_data_provider, ADDR_FORMATS)};
74 173 : }
75 : }
76 : template CNetAddr::SerParams ConsumeDeserializationParams(FuzzedDataProvider&) noexcept;
77 : template CAddress::SerParams ConsumeDeserializationParams(FuzzedDataProvider&) noexcept;
78 :
79 0 : FuzzedSock::FuzzedSock(FuzzedDataProvider& fuzzed_data_provider)
80 0 : : m_fuzzed_data_provider{fuzzed_data_provider}, m_selectable{fuzzed_data_provider.ConsumeBool()}
81 0 : {
82 0 : m_socket = fuzzed_data_provider.ConsumeIntegralInRange<SOCKET>(INVALID_SOCKET - 1, INVALID_SOCKET);
83 173 : }
84 :
85 0 : FuzzedSock::~FuzzedSock()
86 0 : {
87 : // Sock::~Sock() will be called after FuzzedSock::~FuzzedSock() and it will call
88 : // close(m_socket) if m_socket is not INVALID_SOCKET.
89 : // Avoid closing an arbitrary file descriptor (m_socket is just a random very high number which
90 : // theoretically may concide with a real opened file descriptor).
91 0 : m_socket = INVALID_SOCKET;
92 0 : }
93 :
94 0 : FuzzedSock& FuzzedSock::operator=(Sock&& other)
95 : {
96 0 : assert(false && "Move of Sock into FuzzedSock not allowed.");
97 : return *this;
98 : }
99 :
100 0 : ssize_t FuzzedSock::Send(const void* data, size_t len, int flags) const
101 : {
102 0 : constexpr std::array send_errnos{
103 : EACCES,
104 : EAGAIN,
105 : EALREADY,
106 : EBADF,
107 : ECONNRESET,
108 : EDESTADDRREQ,
109 : EFAULT,
110 : EINTR,
111 : EINVAL,
112 : EISCONN,
113 : EMSGSIZE,
114 : ENOBUFS,
115 : ENOMEM,
116 : ENOTCONN,
117 : ENOTSOCK,
118 : EOPNOTSUPP,
119 : EPIPE,
120 : EWOULDBLOCK,
121 : };
122 0 : if (m_fuzzed_data_provider.ConsumeBool()) {
123 0 : return len;
124 : }
125 0 : const ssize_t r = m_fuzzed_data_provider.ConsumeIntegralInRange<ssize_t>(-1, len);
126 0 : if (r == -1) {
127 0 : SetFuzzedErrNo(m_fuzzed_data_provider, send_errnos);
128 0 : }
129 0 : return r;
130 0 : }
131 :
132 0 : ssize_t FuzzedSock::Recv(void* buf, size_t len, int flags) const
133 : {
134 : // Have a permanent error at recv_errnos[0] because when the fuzzed data is exhausted
135 : // SetFuzzedErrNo() will always return the first element and we want to avoid Recv()
136 : // returning -1 and setting errno to EAGAIN repeatedly.
137 0 : constexpr std::array recv_errnos{
138 : ECONNREFUSED,
139 : EAGAIN,
140 : EBADF,
141 : EFAULT,
142 : EINTR,
143 : EINVAL,
144 : ENOMEM,
145 : ENOTCONN,
146 : ENOTSOCK,
147 : EWOULDBLOCK,
148 : };
149 0 : assert(buf != nullptr || len == 0);
150 0 : if (len == 0 || m_fuzzed_data_provider.ConsumeBool()) {
151 0 : const ssize_t r = m_fuzzed_data_provider.ConsumeBool() ? 0 : -1;
152 0 : if (r == -1) {
153 0 : SetFuzzedErrNo(m_fuzzed_data_provider, recv_errnos);
154 0 : }
155 0 : return r;
156 : }
157 0 : std::vector<uint8_t> random_bytes;
158 0 : bool pad_to_len_bytes{m_fuzzed_data_provider.ConsumeBool()};
159 0 : if (m_peek_data.has_value()) {
160 : // `MSG_PEEK` was used in the preceding `Recv()` call, return `m_peek_data`.
161 0 : random_bytes.assign({m_peek_data.value()});
162 0 : if ((flags & MSG_PEEK) == 0) {
163 0 : m_peek_data.reset();
164 0 : }
165 0 : pad_to_len_bytes = false;
166 0 : } else if ((flags & MSG_PEEK) != 0) {
167 : // New call with `MSG_PEEK`.
168 0 : random_bytes = m_fuzzed_data_provider.ConsumeBytes<uint8_t>(1);
169 0 : if (!random_bytes.empty()) {
170 0 : m_peek_data = random_bytes[0];
171 0 : pad_to_len_bytes = false;
172 0 : }
173 0 : } else {
174 0 : random_bytes = m_fuzzed_data_provider.ConsumeBytes<uint8_t>(
175 0 : m_fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, len));
176 : }
177 0 : if (random_bytes.empty()) {
178 0 : const ssize_t r = m_fuzzed_data_provider.ConsumeBool() ? 0 : -1;
179 0 : if (r == -1) {
180 0 : SetFuzzedErrNo(m_fuzzed_data_provider, recv_errnos);
181 0 : }
182 0 : return r;
183 : }
184 0 : std::memcpy(buf, random_bytes.data(), random_bytes.size());
185 0 : if (pad_to_len_bytes) {
186 0 : if (len > random_bytes.size()) {
187 0 : std::memset((char*)buf + random_bytes.size(), 0, len - random_bytes.size());
188 0 : }
189 0 : return len;
190 : }
191 0 : if (m_fuzzed_data_provider.ConsumeBool() && std::getenv("FUZZED_SOCKET_FAKE_LATENCY") != nullptr) {
192 0 : std::this_thread::sleep_for(std::chrono::milliseconds{2});
193 0 : }
194 0 : return random_bytes.size();
195 0 : }
196 :
197 0 : int FuzzedSock::Connect(const sockaddr*, socklen_t) const
198 : {
199 : // Have a permanent error at connect_errnos[0] because when the fuzzed data is exhausted
200 : // SetFuzzedErrNo() will always return the first element and we want to avoid Connect()
201 : // returning -1 and setting errno to EAGAIN repeatedly.
202 0 : constexpr std::array connect_errnos{
203 : ECONNREFUSED,
204 : EAGAIN,
205 : ECONNRESET,
206 : EHOSTUNREACH,
207 : EINPROGRESS,
208 : EINTR,
209 : ENETUNREACH,
210 : ETIMEDOUT,
211 : };
212 0 : if (m_fuzzed_data_provider.ConsumeBool()) {
213 0 : SetFuzzedErrNo(m_fuzzed_data_provider, connect_errnos);
214 0 : return -1;
215 : }
216 0 : return 0;
217 0 : }
218 :
219 0 : int FuzzedSock::Bind(const sockaddr*, socklen_t) const
220 : {
221 : // Have a permanent error at bind_errnos[0] because when the fuzzed data is exhausted
222 : // SetFuzzedErrNo() will always set the global errno to bind_errnos[0]. We want to
223 : // avoid this method returning -1 and setting errno to a temporary error (like EAGAIN)
224 : // repeatedly because proper code should retry on temporary errors, leading to an
225 : // infinite loop.
226 0 : constexpr std::array bind_errnos{
227 : EACCES,
228 : EADDRINUSE,
229 : EADDRNOTAVAIL,
230 : EAGAIN,
231 : };
232 0 : if (m_fuzzed_data_provider.ConsumeBool()) {
233 0 : SetFuzzedErrNo(m_fuzzed_data_provider, bind_errnos);
234 0 : return -1;
235 : }
236 0 : return 0;
237 0 : }
238 :
239 0 : int FuzzedSock::Listen(int) const
240 : {
241 : // Have a permanent error at listen_errnos[0] because when the fuzzed data is exhausted
242 : // SetFuzzedErrNo() will always set the global errno to listen_errnos[0]. We want to
243 : // avoid this method returning -1 and setting errno to a temporary error (like EAGAIN)
244 : // repeatedly because proper code should retry on temporary errors, leading to an
245 : // infinite loop.
246 0 : constexpr std::array listen_errnos{
247 : EADDRINUSE,
248 : EINVAL,
249 : EOPNOTSUPP,
250 : };
251 0 : if (m_fuzzed_data_provider.ConsumeBool()) {
252 0 : SetFuzzedErrNo(m_fuzzed_data_provider, listen_errnos);
253 0 : return -1;
254 : }
255 0 : return 0;
256 0 : }
257 :
258 0 : std::unique_ptr<Sock> FuzzedSock::Accept(sockaddr* addr, socklen_t* addr_len) const
259 : {
260 0 : constexpr std::array accept_errnos{
261 : ECONNABORTED,
262 : EINTR,
263 : ENOMEM,
264 : };
265 0 : if (m_fuzzed_data_provider.ConsumeBool()) {
266 0 : SetFuzzedErrNo(m_fuzzed_data_provider, accept_errnos);
267 0 : return std::unique_ptr<FuzzedSock>();
268 : }
269 0 : return std::make_unique<FuzzedSock>(m_fuzzed_data_provider);
270 0 : }
271 :
272 0 : int FuzzedSock::GetSockOpt(int level, int opt_name, void* opt_val, socklen_t* opt_len) const
273 : {
274 0 : constexpr std::array getsockopt_errnos{
275 : ENOMEM,
276 : ENOBUFS,
277 : };
278 0 : if (m_fuzzed_data_provider.ConsumeBool()) {
279 0 : SetFuzzedErrNo(m_fuzzed_data_provider, getsockopt_errnos);
280 0 : return -1;
281 : }
282 0 : if (opt_val == nullptr) {
283 0 : return 0;
284 : }
285 0 : std::memcpy(opt_val,
286 0 : ConsumeFixedLengthByteVector(m_fuzzed_data_provider, *opt_len).data(),
287 0 : *opt_len);
288 0 : return 0;
289 0 : }
290 :
291 0 : int FuzzedSock::SetSockOpt(int, int, const void*, socklen_t) const
292 : {
293 0 : constexpr std::array setsockopt_errnos{
294 : ENOMEM,
295 : ENOBUFS,
296 : };
297 0 : if (m_fuzzed_data_provider.ConsumeBool()) {
298 0 : SetFuzzedErrNo(m_fuzzed_data_provider, setsockopt_errnos);
299 0 : return -1;
300 : }
301 0 : return 0;
302 0 : }
303 :
304 0 : int FuzzedSock::GetSockName(sockaddr* name, socklen_t* name_len) const
305 : {
306 0 : constexpr std::array getsockname_errnos{
307 : ECONNRESET,
308 : ENOBUFS,
309 : };
310 0 : if (m_fuzzed_data_provider.ConsumeBool()) {
311 0 : SetFuzzedErrNo(m_fuzzed_data_provider, getsockname_errnos);
312 0 : return -1;
313 : }
314 0 : *name_len = m_fuzzed_data_provider.ConsumeData(name, *name_len);
315 0 : return 0;
316 0 : }
317 :
318 0 : bool FuzzedSock::SetNonBlocking() const
319 : {
320 0 : constexpr std::array setnonblocking_errnos{
321 : EBADF,
322 : EPERM,
323 : };
324 0 : if (m_fuzzed_data_provider.ConsumeBool()) {
325 0 : SetFuzzedErrNo(m_fuzzed_data_provider, setnonblocking_errnos);
326 0 : return false;
327 : }
328 0 : return true;
329 0 : }
330 :
331 0 : bool FuzzedSock::IsSelectable() const
332 : {
333 0 : return m_selectable;
334 : }
335 :
336 0 : bool FuzzedSock::Wait(std::chrono::milliseconds timeout, Event requested, Event* occurred) const
337 : {
338 0 : constexpr std::array wait_errnos{
339 : EBADF,
340 : EINTR,
341 : EINVAL,
342 : };
343 0 : if (m_fuzzed_data_provider.ConsumeBool()) {
344 0 : SetFuzzedErrNo(m_fuzzed_data_provider, wait_errnos);
345 0 : return false;
346 : }
347 0 : if (occurred != nullptr) {
348 0 : *occurred = m_fuzzed_data_provider.ConsumeBool() ? requested : 0;
349 0 : }
350 0 : return true;
351 0 : }
352 :
353 0 : bool FuzzedSock::WaitMany(std::chrono::milliseconds timeout, EventsPerSock& events_per_sock) const
354 : {
355 0 : for (auto& [sock, events] : events_per_sock) {
356 : (void)sock;
357 0 : events.occurred = m_fuzzed_data_provider.ConsumeBool() ? events.requested : 0;
358 : }
359 0 : return true;
360 : }
361 :
362 0 : bool FuzzedSock::IsConnected(std::string& errmsg) const
363 : {
364 0 : if (m_fuzzed_data_provider.ConsumeBool()) {
365 0 : return true;
366 : }
367 0 : errmsg = "disconnected at random by the fuzzer";
368 0 : return false;
369 0 : }
370 :
371 0 : void FillNode(FuzzedDataProvider& fuzzed_data_provider, ConnmanTestMsg& connman, CNode& node) noexcept
372 : {
373 0 : connman.Handshake(node,
374 0 : /*successfully_connected=*/fuzzed_data_provider.ConsumeBool(),
375 0 : /*remote_services=*/ConsumeWeakEnum(fuzzed_data_provider, ALL_SERVICE_FLAGS),
376 0 : /*local_services=*/ConsumeWeakEnum(fuzzed_data_provider, ALL_SERVICE_FLAGS),
377 0 : /*version=*/fuzzed_data_provider.ConsumeIntegralInRange<int32_t>(MIN_PEER_PROTO_VERSION, std::numeric_limits<int32_t>::max()),
378 0 : /*relay_txs=*/fuzzed_data_provider.ConsumeBool());
379 0 : }
|
