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