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 : : #include <test/fuzz/util/net.h>
6 : :
7 : : #include <compat/compat.h>
8 : : #include <netaddress.h>
9 : : #include <node/protocol_version.h>
10 : : #include <protocol.h>
11 : : #include <test/fuzz/FuzzedDataProvider.h>
12 : : #include <test/fuzz/util.h>
13 : : #include <test/util/net.h>
14 : : #include <util/sock.h>
15 : : #include <util/time.h>
16 : :
17 : : #include <array>
18 : : #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 : 10918292 : CNetAddr ConsumeNetAddr(FuzzedDataProvider& fuzzed_data_provider, FastRandomContext* rand) noexcept
29 : : {
30 : 10918292 : struct NetAux {
31 : : Network net;
32 : : CNetAddr::BIP155Network bip155;
33 : : size_t len;
34 : : };
35 : :
36 : 10918292 : static constexpr std::array<NetAux, 6> nets{
37 : : NetAux{.net = Network::NET_IPV4, .bip155 = CNetAddr::BIP155Network::IPV4, .len = ADDR_IPV4_SIZE},
38 : : NetAux{.net = Network::NET_IPV6, .bip155 = CNetAddr::BIP155Network::IPV6, .len = ADDR_IPV6_SIZE},
39 : : NetAux{.net = Network::NET_ONION, .bip155 = CNetAddr::BIP155Network::TORV3, .len = ADDR_TORV3_SIZE},
40 : : NetAux{.net = Network::NET_I2P, .bip155 = CNetAddr::BIP155Network::I2P, .len = ADDR_I2P_SIZE},
41 : : NetAux{.net = Network::NET_CJDNS, .bip155 = CNetAddr::BIP155Network::CJDNS, .len = ADDR_CJDNS_SIZE},
42 : : NetAux{.net = Network::NET_INTERNAL, .bip155 = CNetAddr::BIP155Network{0}, .len = 0},
43 : : };
44 : :
45 : 10918292 : const size_t nets_index{rand == nullptr
46 [ + + ]: 10918292 : ? fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, nets.size() - 1)
47 : 7410907 : : static_cast<size_t>(rand->randrange(nets.size()))};
48 : :
49 : 10918292 : const auto& aux = nets[nets_index];
50 : :
51 : 10918292 : CNetAddr addr;
52 : :
53 [ + + ]: 10918292 : if (aux.net == Network::NET_INTERNAL) {
54 [ + + ]: 1431640 : if (rand == nullptr) {
55 : 198575 : addr.SetInternal(fuzzed_data_provider.ConsumeBytesAsString(32));
56 : : } else {
57 : 1233065 : const auto v = rand->randbytes(32);
58 : 1233065 : addr.SetInternal(std::string{v.begin(), v.end()});
59 : 1233065 : }
60 : : return addr;
61 : : }
62 : :
63 : 9486652 : DataStream s;
64 : :
65 : 9486652 : s << static_cast<uint8_t>(aux.bip155);
66 : :
67 : 9486652 : std::vector<uint8_t> addr_bytes;
68 [ + + ]: 9486652 : if (rand == nullptr) {
69 : 3308810 : addr_bytes = fuzzed_data_provider.ConsumeBytes<uint8_t>(aux.len);
70 : 3308810 : addr_bytes.resize(aux.len);
71 : : } else {
72 : 6177842 : addr_bytes = rand->randbytes(aux.len);
73 : : }
74 [ + + + + ]: 9486652 : if (aux.net == NET_IPV6 && addr_bytes[0] == CJDNS_PREFIX) { // Avoid generating IPv6 addresses that look like CJDNS.
75 : 11500 : addr_bytes[0] = 0x55; // Just an arbitrary number, anything != CJDNS_PREFIX would do.
76 : : }
77 [ + + ]: 9486652 : if (aux.net == NET_CJDNS) { // Avoid generating CJDNS addresses that don't start with CJDNS_PREFIX because those are !IsValid().
78 : 1254672 : addr_bytes[0] = CJDNS_PREFIX;
79 : : }
80 : 9486652 : s << addr_bytes;
81 : :
82 : 9486652 : s >> CAddress::V2_NETWORK(addr);
83 : :
84 : 9486652 : return addr;
85 : 9486652 : }
86 : :
87 : 1804112 : CAddress ConsumeAddress(FuzzedDataProvider& fuzzed_data_provider) noexcept
88 : : {
89 : 1804112 : return {ConsumeService(fuzzed_data_provider), ConsumeWeakEnum(fuzzed_data_provider, ALL_SERVICE_FLAGS), NodeSeconds{std::chrono::seconds{fuzzed_data_provider.ConsumeIntegral<uint32_t>()}}};
90 : : }
91 : :
92 : : template <typename P>
93 : 1432 : P ConsumeDeserializationParams(FuzzedDataProvider& fuzzed_data_provider) noexcept
94 : : {
95 : 1432 : constexpr std::array ADDR_ENCODINGS{
96 : : CNetAddr::Encoding::V1,
97 : : CNetAddr::Encoding::V2,
98 : : };
99 : 1432 : constexpr std::array ADDR_FORMATS{
100 : : CAddress::Format::Disk,
101 : : CAddress::Format::Network,
102 : : };
103 : : if constexpr (std::is_same_v<P, CNetAddr::SerParams>) {
104 : 1188 : return P{PickValue(fuzzed_data_provider, ADDR_ENCODINGS)};
105 : : }
106 : : if constexpr (std::is_same_v<P, CAddress::SerParams>) {
107 : 244 : return P{{PickValue(fuzzed_data_provider, ADDR_ENCODINGS)}, PickValue(fuzzed_data_provider, ADDR_FORMATS)};
108 : : }
109 : : }
110 : : template CNetAddr::SerParams ConsumeDeserializationParams(FuzzedDataProvider&) noexcept;
111 : : template CAddress::SerParams ConsumeDeserializationParams(FuzzedDataProvider&) noexcept;
112 : :
113 : 26167 : FuzzedSock::FuzzedSock(FuzzedDataProvider& fuzzed_data_provider)
114 : : : Sock{fuzzed_data_provider.ConsumeIntegralInRange<SOCKET>(INVALID_SOCKET - 1, INVALID_SOCKET)},
115 : 26167 : m_fuzzed_data_provider{fuzzed_data_provider},
116 : 26167 : m_selectable{fuzzed_data_provider.ConsumeBool()},
117 : 26167 : m_time{MockableSteadyClock::INITIAL_MOCK_TIME}
118 : : {
119 [ + - ]: 26167 : ElapseTime(std::chrono::seconds(0)); // start mocking the steady clock.
120 : 26167 : }
121 : :
122 : 28179 : FuzzedSock::~FuzzedSock()
123 : : {
124 : : // Sock::~Sock() will be called after FuzzedSock::~FuzzedSock() and it will call
125 : : // close(m_socket) if m_socket is not INVALID_SOCKET.
126 : : // Avoid closing an arbitrary file descriptor (m_socket is just a random very high number which
127 : : // theoretically may concide with a real opened file descriptor).
128 : 26167 : m_socket = INVALID_SOCKET;
129 : 28179 : }
130 : :
131 : 34185 : void FuzzedSock::ElapseTime(std::chrono::milliseconds duration) const
132 : : {
133 : 34185 : m_time += duration;
134 : 34185 : MockableSteadyClock::SetMockTime(m_time);
135 : 34185 : }
136 : :
137 : 0 : FuzzedSock& FuzzedSock::operator=(Sock&& other)
138 : : {
139 : 0 : assert(false && "Move of Sock into FuzzedSock not allowed.");
140 : : return *this;
141 : : }
142 : :
143 : 50797 : ssize_t FuzzedSock::Send(const void* data, size_t len, int flags) const
144 : : {
145 : 50797 : constexpr std::array send_errnos{
146 : : EACCES,
147 : : EAGAIN,
148 : : EALREADY,
149 : : EBADF,
150 : : ECONNRESET,
151 : : EDESTADDRREQ,
152 : : EFAULT,
153 : : EINTR,
154 : : EINVAL,
155 : : EISCONN,
156 : : EMSGSIZE,
157 : : ENOBUFS,
158 : : ENOMEM,
159 : : ENOTCONN,
160 : : ENOTSOCK,
161 : : EOPNOTSUPP,
162 : : EPIPE,
163 : : EWOULDBLOCK,
164 : : };
165 [ + + ]: 50797 : if (m_fuzzed_data_provider.ConsumeBool()) {
166 : 41962 : return len;
167 : : }
168 : 8835 : const ssize_t r = m_fuzzed_data_provider.ConsumeIntegralInRange<ssize_t>(-1, len);
169 [ + + ]: 8835 : if (r == -1) {
170 : 2052 : SetFuzzedErrNo(m_fuzzed_data_provider, send_errnos);
171 : : }
172 : : return r;
173 : : }
174 : :
175 : 12716 : ssize_t FuzzedSock::Recv(void* buf, size_t len, int flags) const
176 : : {
177 : : // Have a permanent error at recv_errnos[0] because when the fuzzed data is exhausted
178 : : // SetFuzzedErrNo() will always return the first element and we want to avoid Recv()
179 : : // returning -1 and setting errno to EAGAIN repeatedly.
180 : 12716 : constexpr std::array recv_errnos{
181 : : ECONNREFUSED,
182 : : EAGAIN,
183 : : EBADF,
184 : : EFAULT,
185 : : EINTR,
186 : : EINVAL,
187 : : ENOMEM,
188 : : ENOTCONN,
189 : : ENOTSOCK,
190 : : EWOULDBLOCK,
191 : : };
192 [ - + - - ]: 12716 : assert(buf != nullptr || len == 0);
193 : :
194 : : // Do the latency before any of the "return" statements.
195 [ + + - + ]: 12716 : if (m_fuzzed_data_provider.ConsumeBool() && std::getenv("FUZZED_SOCKET_FAKE_LATENCY") != nullptr) {
196 : 0 : std::this_thread::sleep_for(std::chrono::milliseconds{2});
197 : : }
198 : :
199 [ + - + + ]: 12716 : if (len == 0 || m_fuzzed_data_provider.ConsumeBool()) {
200 [ + + ]: 166 : const ssize_t r = m_fuzzed_data_provider.ConsumeBool() ? 0 : -1;
201 : 105 : if (r == -1) {
202 : 105 : SetFuzzedErrNo(m_fuzzed_data_provider, recv_errnos);
203 : : }
204 : 166 : return r;
205 : : }
206 : :
207 : 12550 : size_t copied_so_far{0};
208 : :
209 [ + + ]: 12550 : if (!m_peek_data.empty()) {
210 : : // `MSG_PEEK` was used in the preceding `Recv()` call, copy the first bytes from `m_peek_data`.
211 [ - + + + ]: 6339 : const size_t copy_len{std::min(len, m_peek_data.size())};
212 [ + + ]: 6339 : std::memcpy(buf, m_peek_data.data(), copy_len);
213 : 6339 : copied_so_far += copy_len;
214 [ + + ]: 6339 : if ((flags & MSG_PEEK) == 0) {
215 : 6085 : m_peek_data.erase(m_peek_data.begin(), m_peek_data.begin() + copy_len);
216 : : }
217 : : }
218 : :
219 [ + + ]: 12550 : if (copied_so_far == len) {
220 : 4093 : return copied_so_far;
221 : : }
222 : :
223 : 8457 : auto new_data = ConsumeRandomLengthByteVector(m_fuzzed_data_provider, len - copied_so_far);
224 [ + + ]: 8457 : if (new_data.empty()) return copied_so_far;
225 : :
226 [ - + - + ]: 8340 : std::memcpy(reinterpret_cast<uint8_t*>(buf) + copied_so_far, new_data.data(), new_data.size());
227 [ - + ]: 8340 : copied_so_far += new_data.size();
228 : :
229 [ + + ]: 8340 : if ((flags & MSG_PEEK) != 0) {
230 [ + - ]: 6100 : m_peek_data.insert(m_peek_data.end(), new_data.begin(), new_data.end());
231 : : }
232 : :
233 [ + + + + ]: 8340 : if (copied_so_far == len || m_fuzzed_data_provider.ConsumeBool()) {
234 : 4170 : return copied_so_far;
235 : : }
236 : :
237 : : // Pad to len bytes.
238 : 4170 : std::memset(reinterpret_cast<uint8_t*>(buf) + copied_so_far, 0x0, len - copied_so_far);
239 : :
240 : 4170 : return len;
241 : 8457 : }
242 : :
243 : 796 : int FuzzedSock::Connect(const sockaddr*, socklen_t) const
244 : : {
245 : : // Have a permanent error at connect_errnos[0] because when the fuzzed data is exhausted
246 : : // SetFuzzedErrNo() will always return the first element and we want to avoid Connect()
247 : : // returning -1 and setting errno to EAGAIN repeatedly.
248 : 796 : constexpr std::array connect_errnos{
249 : : ECONNREFUSED,
250 : : EAGAIN,
251 : : ECONNRESET,
252 : : EHOSTUNREACH,
253 : : EINPROGRESS,
254 : : EINTR,
255 : : ENETUNREACH,
256 : : ETIMEDOUT,
257 : : };
258 [ + + ]: 796 : if (m_fuzzed_data_provider.ConsumeBool()) {
259 : 62 : SetFuzzedErrNo(m_fuzzed_data_provider, connect_errnos);
260 : 62 : return -1;
261 : : }
262 : : return 0;
263 : : }
264 : :
265 : 148 : int FuzzedSock::Bind(const sockaddr*, socklen_t) const
266 : : {
267 : : // Have a permanent error at bind_errnos[0] because when the fuzzed data is exhausted
268 : : // SetFuzzedErrNo() will always set the global errno to bind_errnos[0]. We want to
269 : : // avoid this method returning -1 and setting errno to a temporary error (like EAGAIN)
270 : : // repeatedly because proper code should retry on temporary errors, leading to an
271 : : // infinite loop.
272 : 148 : constexpr std::array bind_errnos{
273 : : EACCES,
274 : : EADDRINUSE,
275 : : EADDRNOTAVAIL,
276 : : EAGAIN,
277 : : };
278 [ + + ]: 148 : if (m_fuzzed_data_provider.ConsumeBool()) {
279 : 7 : SetFuzzedErrNo(m_fuzzed_data_provider, bind_errnos);
280 : 7 : return -1;
281 : : }
282 : : return 0;
283 : : }
284 : :
285 : 23 : int FuzzedSock::Listen(int) const
286 : : {
287 : : // Have a permanent error at listen_errnos[0] because when the fuzzed data is exhausted
288 : : // SetFuzzedErrNo() will always set the global errno to listen_errnos[0]. We want to
289 : : // avoid this method returning -1 and setting errno to a temporary error (like EAGAIN)
290 : : // repeatedly because proper code should retry on temporary errors, leading to an
291 : : // infinite loop.
292 : 23 : constexpr std::array listen_errnos{
293 : : EADDRINUSE,
294 : : EINVAL,
295 : : EOPNOTSUPP,
296 : : };
297 [ - + ]: 23 : if (m_fuzzed_data_provider.ConsumeBool()) {
298 : 0 : SetFuzzedErrNo(m_fuzzed_data_provider, listen_errnos);
299 : 0 : return -1;
300 : : }
301 : : return 0;
302 : : }
303 : :
304 : 0 : std::unique_ptr<Sock> FuzzedSock::Accept(sockaddr* addr, socklen_t* addr_len) const
305 : : {
306 : 0 : constexpr std::array accept_errnos{
307 : : ECONNABORTED,
308 : : EINTR,
309 : : ENOMEM,
310 : : };
311 [ # # ]: 0 : if (m_fuzzed_data_provider.ConsumeBool()) {
312 : 0 : SetFuzzedErrNo(m_fuzzed_data_provider, accept_errnos);
313 : 0 : return std::unique_ptr<FuzzedSock>();
314 : : }
315 [ # # ]: 0 : if (addr != nullptr) {
316 : : // Set a fuzzed address in the output argument addr.
317 : 0 : memset(addr, 0x00, *addr_len);
318 [ # # ]: 0 : if (m_fuzzed_data_provider.ConsumeBool()) {
319 : : // IPv4
320 : 0 : const socklen_t write_len = static_cast<socklen_t>(sizeof(sockaddr_in));
321 [ # # ]: 0 : if (*addr_len >= write_len) {
322 : 0 : *addr_len = write_len;
323 : 0 : auto addr4 = reinterpret_cast<sockaddr_in*>(addr);
324 : 0 : addr4->sin_family = AF_INET;
325 : 0 : const auto sin_addr_bytes = m_fuzzed_data_provider.ConsumeBytes<uint8_t>(sizeof(addr4->sin_addr));
326 [ # # ]: 0 : memcpy(&addr4->sin_addr, sin_addr_bytes.data(), sin_addr_bytes.size());
327 : 0 : addr4->sin_port = m_fuzzed_data_provider.ConsumeIntegralInRange<uint16_t>(1, 65535);
328 : 0 : }
329 : : } else {
330 : : // IPv6
331 : 0 : const socklen_t write_len = static_cast<socklen_t>(sizeof(sockaddr_in6));
332 [ # # ]: 0 : if (*addr_len >= write_len) {
333 : 0 : *addr_len = write_len;
334 : 0 : auto addr6 = reinterpret_cast<sockaddr_in6*>(addr);
335 : 0 : addr6->sin6_family = AF_INET6;
336 : 0 : const auto sin_addr_bytes = m_fuzzed_data_provider.ConsumeBytes<uint8_t>(sizeof(addr6->sin6_addr));
337 [ # # ]: 0 : memcpy(&addr6->sin6_addr, sin_addr_bytes.data(), sin_addr_bytes.size());
338 : 0 : addr6->sin6_port = m_fuzzed_data_provider.ConsumeIntegralInRange<uint16_t>(1, 65535);
339 : 0 : }
340 : : }
341 : : }
342 : 0 : return std::make_unique<FuzzedSock>(m_fuzzed_data_provider);
343 : : }
344 : :
345 : 20 : int FuzzedSock::GetSockOpt(int level, int opt_name, void* opt_val, socklen_t* opt_len) const
346 : : {
347 : 20 : constexpr std::array getsockopt_errnos{
348 : : ENOMEM,
349 : : ENOBUFS,
350 : : };
351 [ + + ]: 20 : if (m_fuzzed_data_provider.ConsumeBool()) {
352 : 5 : SetFuzzedErrNo(m_fuzzed_data_provider, getsockopt_errnos);
353 : 5 : return -1;
354 : : }
355 [ + - ]: 15 : if (opt_val == nullptr) {
356 : : return 0;
357 : : }
358 : 15 : std::memcpy(opt_val,
359 : 15 : ConsumeFixedLengthByteVector(m_fuzzed_data_provider, *opt_len).data(),
360 : 15 : *opt_len);
361 : 15 : return 0;
362 : : }
363 : :
364 : 1120 : int FuzzedSock::SetSockOpt(int, int, const void*, socklen_t) const
365 : : {
366 : 1120 : constexpr std::array setsockopt_errnos{
367 : : ENOMEM,
368 : : ENOBUFS,
369 : : };
370 [ + + ]: 1120 : if (m_fuzzed_data_provider.ConsumeBool()) {
371 : 1043 : SetFuzzedErrNo(m_fuzzed_data_provider, setsockopt_errnos);
372 : 1043 : return -1;
373 : : }
374 : : return 0;
375 : : }
376 : :
377 : 184 : int FuzzedSock::GetSockName(sockaddr* name, socklen_t* name_len) const
378 : : {
379 : 184 : constexpr std::array getsockname_errnos{
380 : : ECONNRESET,
381 : : ENOBUFS,
382 : : };
383 [ + + ]: 184 : if (m_fuzzed_data_provider.ConsumeBool()) {
384 : 4 : SetFuzzedErrNo(m_fuzzed_data_provider, getsockname_errnos);
385 : 4 : return -1;
386 : : }
387 [ - + ]: 180 : assert(name_len);
388 : 180 : const auto bytes{ConsumeRandomLengthByteVector(m_fuzzed_data_provider, *name_len)};
389 [ - + + + ]: 180 : if (bytes.size() < (int)sizeof(sockaddr)) return -1;
390 [ - + ]: 138 : std::memcpy(name, bytes.data(), bytes.size());
391 [ - + ]: 138 : *name_len = bytes.size();
392 : 138 : return 0;
393 : 180 : }
394 : :
395 : 0 : bool FuzzedSock::SetNonBlocking() const
396 : : {
397 : 0 : constexpr std::array setnonblocking_errnos{
398 : : EBADF,
399 : : EPERM,
400 : : };
401 [ # # ]: 0 : if (m_fuzzed_data_provider.ConsumeBool()) {
402 : 0 : SetFuzzedErrNo(m_fuzzed_data_provider, setnonblocking_errnos);
403 : 0 : return false;
404 : : }
405 : : return true;
406 : : }
407 : :
408 : 1182 : bool FuzzedSock::IsSelectable() const
409 : : {
410 : 1182 : return m_selectable;
411 : : }
412 : :
413 : 7904 : bool FuzzedSock::Wait(std::chrono::milliseconds timeout, Event requested, Event* occurred) const
414 : : {
415 : 7904 : constexpr std::array wait_errnos{
416 : : EBADF,
417 : : EINTR,
418 : : EINVAL,
419 : : };
420 [ + + ]: 7904 : if (m_fuzzed_data_provider.ConsumeBool()) {
421 : 77 : SetFuzzedErrNo(m_fuzzed_data_provider, wait_errnos);
422 : 77 : return false;
423 : : }
424 [ + + ]: 7827 : if (occurred != nullptr) {
425 : : // We simulate the requested event as occurred when ConsumeBool()
426 : : // returns false. This avoids simulating endless waiting if the
427 : : // FuzzedDataProvider runs out of data.
428 [ + + ]: 843 : *occurred = m_fuzzed_data_provider.ConsumeBool() ? 0 : requested;
429 : : }
430 : 7827 : ElapseTime(timeout);
431 : 7827 : return true;
432 : : }
433 : :
434 : 191 : bool FuzzedSock::WaitMany(std::chrono::milliseconds timeout, EventsPerSock& events_per_sock) const
435 : : {
436 [ + + ]: 438 : for (auto& [sock, events] : events_per_sock) {
437 : 247 : (void)sock;
438 : : // We simulate the requested event as occurred when ConsumeBool()
439 : : // returns false. This avoids simulating endless waiting if the
440 : : // FuzzedDataProvider runs out of data.
441 : 494 : events.occurred = m_fuzzed_data_provider.ConsumeBool() ? 0 : events.requested;
442 : : }
443 : 191 : ElapseTime(timeout);
444 : 191 : return true;
445 : : }
446 : :
447 : 53 : bool FuzzedSock::IsConnected(std::string& errmsg) const
448 : : {
449 [ + + ]: 53 : if (m_fuzzed_data_provider.ConsumeBool()) {
450 : : return true;
451 : : }
452 : 46 : errmsg = "disconnected at random by the fuzzer";
453 : 46 : return false;
454 : : }
455 : :
456 : 7107 : void FillNode(FuzzedDataProvider& fuzzed_data_provider, ConnmanTestMsg& connman, CNode& node) noexcept
457 : : {
458 : 7107 : auto successfully_connected = fuzzed_data_provider.ConsumeBool();
459 : 7107 : auto remote_services = ConsumeWeakEnum(fuzzed_data_provider, ALL_SERVICE_FLAGS);
460 : 7107 : auto local_services = ConsumeWeakEnum(fuzzed_data_provider, ALL_SERVICE_FLAGS);
461 : 7107 : auto version = fuzzed_data_provider.ConsumeIntegralInRange<int32_t>(MIN_PEER_PROTO_VERSION, std::numeric_limits<int32_t>::max());
462 : 7107 : auto relay_txs = fuzzed_data_provider.ConsumeBool();
463 : 7107 : connman.Handshake(node, successfully_connected, remote_services, local_services, version, relay_txs);
464 : 7107 : }
|
