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