LCOV - code coverage report
Current view: top level - src/test/fuzz/util - net.cpp (source / functions) Hit Total Coverage
Test: fuzz_coverage.info Lines: 0 191 0.0 %
Date: 2024-01-03 14:57:27 Functions: 0 23 0.0 %
Branches: 0 156 0.0 %

           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                 :          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                 :          0 : 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 : }

Generated by: LCOV version 1.14