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 : memcpy(v6_addr.s6_addr, fuzzed_data_provider.ConsumeBytes<uint8_t>(16).data(), 16);
40 [ # # ][ # # ]: 0 : net_addr = CNetAddr{v6_addr, fuzzed_data_provider.ConsumeIntegral<uint32_t>()};
41 : 0 : }
42 [ # # ]: 0 : } else if (network == Network::NET_INTERNAL) {
43 [ # # ][ # # ]: 0 : net_addr.SetInternal(fuzzed_data_provider.ConsumeBytesAsString(32));
44 [ # # ]: 0 : } else if (network == Network::NET_ONION) {
45 [ # # ]: 0 : auto pub_key{fuzzed_data_provider.ConsumeBytes<uint8_t>(ADDR_TORV3_SIZE)};
46 [ # # ]: 0 : pub_key.resize(ADDR_TORV3_SIZE);
47 [ # # ][ # # ]: 0 : const bool ok{net_addr.SetSpecial(OnionToString(pub_key))};
[ # # ]
48 [ # # ]: 0 : assert(ok);
49 : 0 : }
50 : 0 : return net_addr;
51 [ # # ]: 0 : }
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 : : }
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 [ + - ]: 2 : }
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 : }
|
