Branch data     Line data    Source code

       1                 :            : // Copyright (c) 2011-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                 :            : // Unit tests for denial-of-service detection/prevention code
       6                 :            : 
       7                 :            : #include <banman.h>
       8                 :            : #include <chainparams.h>
       9                 :            : #include <common/args.h>
      10                 :            : #include <net.h>
      11                 :            : #include <net_processing.h>
      12                 :            : #include <pubkey.h>
      13                 :            : #include <script/sign.h>
      14                 :            : #include <script/signingprovider.h>
      15                 :            : #include <serialize.h>
      16                 :            : #include <test/util/net.h>
      17                 :          0 : #include <test/util/random.h>
      18                 :          0 : #include <test/util/setup_common.h>
      19                 :            : #include <timedata.h>
      20                 :            : #include <util/string.h>
      21                 :            : #include <util/time.h>
      22                 :            : #include <validation.h>
      23                 :            : 
      24                 :            : #include <array>
      25                 :            : #include <stdint.h>
      26                 :            : 
      27                 :            : #include <boost/test/unit_test.hpp>
      28                 :            : 
      29                 :          0 : static CService ip(uint32_t i)
      30                 :            : {
      31                 :            :     struct in_addr s;
      32                 :          0 :     s.s_addr = i;
      33                 :          0 :     return CService(CNetAddr(s), Params().GetDefaultPort());
      34                 :          0 : }
      35                 :            : 
      36                 :          0 : BOOST_FIXTURE_TEST_SUITE(denialofservice_tests, TestingSetup)
      37                 :            : 
      38                 :            : // Test eviction of an outbound peer whose chain never advances
      39                 :            : // Mock a node connection, and use mocktime to simulate a peer
      40                 :            : // which never sends any headers messages.  PeerLogic should
      41                 :            : // decide to evict that outbound peer, after the appropriate timeouts.
      42                 :            : // Note that we protect 4 outbound nodes from being subject to
      43                 :            : // this logic; this test takes advantage of that protection only
      44                 :            : // being applied to nodes which send headers with sufficient
      45                 :            : // work.
      46                 :          0 : BOOST_AUTO_TEST_CASE(outbound_slow_chain_eviction)
      47                 :            : {
      48                 :          0 :     LOCK(NetEventsInterface::g_msgproc_mutex);
      49                 :            : 
      50                 :          0 :     ConnmanTestMsg& connman = static_cast<ConnmanTestMsg&>(*m_node.connman);
      51                 :            :     // Disable inactivity checks for this test to avoid interference
      52                 :          0 :     connman.SetPeerConnectTimeout(99999s);
      53                 :          0 :     PeerManager& peerman = *m_node.peerman;
      54                 :            : 
      55                 :            :     // Mock an outbound peer
      56                 :          0 :     CAddress addr1(ip(0xa0b0c001), NODE_NONE);
      57                 :          0 :     NodeId id{0};
      58                 :          0 :     CNode dummyNode1{id++,
      59                 :          0 :                      /*sock=*/nullptr,
      60                 :            :                      addr1,
      61                 :            :                      /*nKeyedNetGroupIn=*/0,
      62                 :            :                      /*nLocalHostNonceIn=*/0,
      63                 :          0 :                      CAddress(),
      64                 :          0 :                      /*addrNameIn=*/"",
      65                 :            :                      ConnectionType::OUTBOUND_FULL_RELAY,
      66                 :            :                      /*inbound_onion=*/false};
      67                 :            : 
      68                 :          0 :     connman.Handshake(
      69                 :            :         /*node=*/dummyNode1,
      70                 :            :         /*successfully_connected=*/true,
      71                 :            :         /*remote_services=*/ServiceFlags(NODE_NETWORK | NODE_WITNESS),
      72                 :            :         /*local_services=*/ServiceFlags(NODE_NETWORK | NODE_WITNESS),
      73                 :            :         /*version=*/PROTOCOL_VERSION,
      74                 :          0 :         /*relay_txs=*/true);
      75                 :          0 :     TestOnlyResetTimeData();
      76                 :            : 
      77                 :            :     // This test requires that we have a chain with non-zero work.
      78                 :            :     {
      79                 :          0 :         LOCK(cs_main);
      80                 :          0 :         BOOST_CHECK(m_node.chainman->ActiveChain().Tip() != nullptr);
      81                 :          0 :         BOOST_CHECK(m_node.chainman->ActiveChain().Tip()->nChainWork > 0);
      82                 :          0 :     }
      83                 :          0 : 
      84                 :            :     // Test starts here
      85                 :          0 :     BOOST_CHECK(peerman.SendMessages(&dummyNode1)); // should result in getheaders
      86                 :            : 
      87                 :            :     {
      88                 :          0 :         LOCK(dummyNode1.cs_vSend);
      89                 :          0 :         const auto& [to_send, _more, _msg_type] = dummyNode1.m_transport->GetBytesToSend(false);
      90                 :          0 :         BOOST_CHECK(!to_send.empty());
      91                 :          0 :     }
      92                 :          0 :     connman.FlushSendBuffer(dummyNode1);
      93                 :            : 
      94                 :          0 :     int64_t nStartTime = GetTime();
      95                 :            :     // Wait 21 minutes
      96                 :          0 :     SetMockTime(nStartTime+21*60);
      97                 :          0 :     BOOST_CHECK(peerman.SendMessages(&dummyNode1)); // should result in getheaders
      98                 :            :     {
      99                 :          0 :         LOCK(dummyNode1.cs_vSend);
     100                 :          0 :         const auto& [to_send, _more, _msg_type] = dummyNode1.m_transport->GetBytesToSend(false);
     101                 :          0 :         BOOST_CHECK(!to_send.empty());
     102                 :          0 :     }
     103                 :            :     // Wait 3 more minutes
     104                 :          0 :     SetMockTime(nStartTime+24*60);
     105                 :          0 :     BOOST_CHECK(peerman.SendMessages(&dummyNode1)); // should result in disconnect
     106                 :          0 :     BOOST_CHECK(dummyNode1.fDisconnect == true);
     107                 :            : 
     108                 :          0 :     peerman.FinalizeNode(dummyNode1);
     109                 :          0 : }
     110                 :            : 
     111                 :          0 : static void AddRandomOutboundPeer(NodeId& id, std::vector<CNode*>& vNodes, PeerManager& peerLogic, ConnmanTestMsg& connman, ConnectionType connType, bool onion_peer = false)
     112                 :            : {
     113                 :          0 :     CAddress addr;
     114                 :            : 
     115                 :          0 :     if (onion_peer) {
     116                 :          0 :         auto tor_addr{g_insecure_rand_ctx.randbytes(ADDR_TORV3_SIZE)};
     117                 :          0 :         BOOST_REQUIRE(addr.SetSpecial(OnionToString(tor_addr)));
     118                 :          0 :     }
     119                 :            : 
     120                 :          0 :     while (!addr.IsRoutable()) {
     121                 :          0 :         addr = CAddress(ip(g_insecure_rand_ctx.randbits(32)), NODE_NONE);
     122                 :            :     }
     123                 :            : 
     124                 :          0 :     vNodes.emplace_back(new CNode{id++,
     125                 :          0 :                                   /*sock=*/nullptr,
     126                 :            :                                   addr,
     127                 :            :                                   /*nKeyedNetGroupIn=*/0,
     128                 :            :                                   /*nLocalHostNonceIn=*/0,
     129                 :          0 :                                   CAddress(),
     130                 :          0 :                                   /*addrNameIn=*/"",
     131                 :          0 :                                   connType,
     132                 :            :                                   /*inbound_onion=*/false});
     133                 :          0 :     CNode &node = *vNodes.back();
     134                 :          0 :     node.SetCommonVersion(PROTOCOL_VERSION);
     135                 :            : 
     136                 :          0 :     peerLogic.InitializeNode(node, ServiceFlags(NODE_NETWORK | NODE_WITNESS));
     137                 :          0 :     node.fSuccessfullyConnected = true;
     138                 :            : 
     139                 :          0 :     connman.AddTestNode(node);
     140                 :          0 : }
     141                 :            : 
     142                 :          0 : BOOST_AUTO_TEST_CASE(stale_tip_peer_management)
     143                 :            : {
     144                 :          0 :     NodeId id{0};
     145                 :          0 :     auto connman = std::make_unique<ConnmanTestMsg>(0x1337, 0x1337, *m_node.addrman, *m_node.netgroupman, Params());
     146                 :          0 :     auto peerLogic = PeerManager::make(*connman, *m_node.addrman, nullptr, *m_node.chainman, *m_node.mempool, {});
     147                 :            : 
     148                 :          0 :     constexpr int max_outbound_full_relay = MAX_OUTBOUND_FULL_RELAY_CONNECTIONS;
     149                 :          0 :     CConnman::Options options;
     150                 :          0 :     options.nMaxConnections = DEFAULT_MAX_PEER_CONNECTIONS;
     151                 :          0 :     options.m_max_outbound_full_relay = max_outbound_full_relay;
     152                 :          0 :     options.nMaxFeeler = MAX_FEELER_CONNECTIONS;
     153                 :            : 
     154                 :          0 :     const auto time_init{GetTime<std::chrono::seconds>()};
     155                 :          0 :     SetMockTime(time_init);
     156                 :          0 :     const auto time_later{time_init + 3 * std::chrono::seconds{m_node.chainman->GetConsensus().nPowTargetSpacing} + 1s};
     157                 :          0 :     connman->Init(options);
     158                 :          0 :     std::vector<CNode *> vNodes;
     159                 :            : 
     160                 :            :     // Mock some outbound peers
     161                 :          0 :     for (int i = 0; i < max_outbound_full_relay; ++i) {
     162                 :          0 :         AddRandomOutboundPeer(id, vNodes, *peerLogic, *connman, ConnectionType::OUTBOUND_FULL_RELAY);
     163                 :          0 :     }
     164                 :            : 
     165                 :          0 :     peerLogic->CheckForStaleTipAndEvictPeers();
     166                 :            : 
     167                 :            :     // No nodes should be marked for disconnection while we have no extra peers
     168                 :          0 :     for (const CNode *node : vNodes) {
     169                 :          0 :         BOOST_CHECK(node->fDisconnect == false);
     170                 :            :     }
     171                 :            : 
     172                 :          0 :     SetMockTime(time_later);
     173                 :            : 
     174                 :            :     // Now tip should definitely be stale, and we should look for an extra
     175                 :            :     // outbound peer
     176                 :          0 :     peerLogic->CheckForStaleTipAndEvictPeers();
     177                 :          0 :     BOOST_CHECK(connman->GetTryNewOutboundPeer());
     178                 :            : 
     179                 :            :     // Still no peers should be marked for disconnection
     180                 :          0 :     for (const CNode *node : vNodes) {
     181                 :          0 :         BOOST_CHECK(node->fDisconnect == false);
     182                 :            :     }
     183                 :            : 
     184                 :            :     // If we add one more peer, something should get marked for eviction
     185                 :            :     // on the next check (since we're mocking the time to be in the future, the
     186                 :            :     // required time connected check should be satisfied).
     187                 :          0 :     SetMockTime(time_init);
     188                 :          0 :     AddRandomOutboundPeer(id, vNodes, *peerLogic, *connman, ConnectionType::OUTBOUND_FULL_RELAY);
     189                 :          0 :     SetMockTime(time_later);
     190                 :            : 
     191                 :          0 :     peerLogic->CheckForStaleTipAndEvictPeers();
     192                 :          0 :     for (int i = 0; i < max_outbound_full_relay; ++i) {
     193                 :          0 :         BOOST_CHECK(vNodes[i]->fDisconnect == false);
     194                 :          0 :     }
     195                 :            :     // Last added node should get marked for eviction
     196                 :          0 :     BOOST_CHECK(vNodes.back()->fDisconnect == true);
     197                 :            : 
     198                 :          0 :     vNodes.back()->fDisconnect = false;
     199                 :            : 
     200                 :            :     // Update the last announced block time for the last
     201                 :            :     // peer, and check that the next newest node gets evicted.
     202                 :          0 :     peerLogic->UpdateLastBlockAnnounceTime(vNodes.back()->GetId(), GetTime());
     203                 :            : 
     204                 :          0 :     peerLogic->CheckForStaleTipAndEvictPeers();
     205                 :          0 :     for (int i = 0; i < max_outbound_full_relay - 1; ++i) {
     206                 :          0 :         BOOST_CHECK(vNodes[i]->fDisconnect == false);
     207                 :          0 :     }
     208                 :          0 :     BOOST_CHECK(vNodes[max_outbound_full_relay-1]->fDisconnect == true);
     209                 :          0 :     BOOST_CHECK(vNodes.back()->fDisconnect == false);
     210                 :            : 
     211                 :          0 :     vNodes[max_outbound_full_relay - 1]->fDisconnect = false;
     212                 :            : 
     213                 :            :     // Add an onion peer, that will be protected because it is the only one for
     214                 :            :     // its network, so another peer gets disconnected instead.
     215                 :          0 :     SetMockTime(time_init);
     216                 :          0 :     AddRandomOutboundPeer(id, vNodes, *peerLogic, *connman, ConnectionType::OUTBOUND_FULL_RELAY, /*onion_peer=*/true);
     217                 :          0 :     SetMockTime(time_later);
     218                 :          0 :     peerLogic->CheckForStaleTipAndEvictPeers();
     219                 :            : 
     220                 :          0 :     for (int i = 0; i < max_outbound_full_relay - 2; ++i) {
     221                 :          0 :         BOOST_CHECK(vNodes[i]->fDisconnect == false);
     222                 :          0 :     }
     223                 :          0 :     BOOST_CHECK(vNodes[max_outbound_full_relay - 2]->fDisconnect == false);
     224                 :          0 :     BOOST_CHECK(vNodes[max_outbound_full_relay - 1]->fDisconnect == true);
     225                 :          0 :     BOOST_CHECK(vNodes[max_outbound_full_relay]->fDisconnect == false);
     226                 :            : 
     227                 :          0 :     // Add a second onion peer which won't be protected
     228                 :          0 :     SetMockTime(time_init);
     229                 :          0 :     AddRandomOutboundPeer(id, vNodes, *peerLogic, *connman, ConnectionType::OUTBOUND_FULL_RELAY, /*onion_peer=*/true);
     230                 :          0 :     SetMockTime(time_later);
     231                 :          0 :     peerLogic->CheckForStaleTipAndEvictPeers();
     232                 :            : 
     233                 :          0 :     BOOST_CHECK(vNodes.back()->fDisconnect == true);
     234                 :            : 
     235                 :          0 :     for (const CNode *node : vNodes) {
     236                 :          0 :         peerLogic->FinalizeNode(*node);
     237                 :            :     }
     238                 :            : 
     239                 :          0 :     connman->ClearTestNodes();
     240                 :          0 : }
     241                 :            : 
     242                 :          0 : BOOST_AUTO_TEST_CASE(block_relay_only_eviction)
     243                 :            : {
     244                 :          0 :     NodeId id{0};
     245                 :          0 :     auto connman = std::make_unique<ConnmanTestMsg>(0x1337, 0x1337, *m_node.addrman, *m_node.netgroupman, Params());
     246                 :          0 :     auto peerLogic = PeerManager::make(*connman, *m_node.addrman, nullptr, *m_node.chainman, *m_node.mempool, {});
     247                 :            : 
     248                 :          0 :     constexpr int max_outbound_block_relay{MAX_BLOCK_RELAY_ONLY_CONNECTIONS};
     249                 :          0 :     constexpr int64_t MINIMUM_CONNECT_TIME{30};
     250                 :          0 :     CConnman::Options options;
     251                 :          0 :     options.nMaxConnections = DEFAULT_MAX_PEER_CONNECTIONS;
     252                 :          0 :     options.m_max_outbound_full_relay = MAX_OUTBOUND_FULL_RELAY_CONNECTIONS;
     253                 :          0 :     options.m_max_outbound_block_relay = max_outbound_block_relay;
     254                 :            : 
     255                 :          0 :     connman->Init(options);
     256                 :          0 :     std::vector<CNode*> vNodes;
     257                 :            : 
     258                 :            :     // Add block-relay-only peers up to the limit
     259                 :          0 :     for (int i = 0; i < max_outbound_block_relay; ++i) {
     260                 :          0 :         AddRandomOutboundPeer(id, vNodes, *peerLogic, *connman, ConnectionType::BLOCK_RELAY);
     261                 :          0 :     }
     262                 :          0 :     peerLogic->CheckForStaleTipAndEvictPeers();
     263                 :            : 
     264                 :          0 :     for (int i = 0; i < max_outbound_block_relay; ++i) {
     265                 :          0 :         BOOST_CHECK(vNodes[i]->fDisconnect == false);
     266                 :          0 :     }
     267                 :            : 
     268                 :            :     // Add an extra block-relay-only peer breaking the limit (mocks logic in ThreadOpenConnections)
     269                 :          0 :     AddRandomOutboundPeer(id, vNodes, *peerLogic, *connman, ConnectionType::BLOCK_RELAY);
     270                 :          0 :     peerLogic->CheckForStaleTipAndEvictPeers();
     271                 :            : 
     272                 :            :     // The extra peer should only get marked for eviction after MINIMUM_CONNECT_TIME
     273                 :          0 :     for (int i = 0; i < max_outbound_block_relay; ++i) {
     274                 :          0 :         BOOST_CHECK(vNodes[i]->fDisconnect == false);
     275                 :          0 :     }
     276                 :          0 :     BOOST_CHECK(vNodes.back()->fDisconnect == false);
     277                 :            : 
     278                 :          0 :     SetMockTime(GetTime() + MINIMUM_CONNECT_TIME + 1);
     279                 :          0 :     peerLogic->CheckForStaleTipAndEvictPeers();
     280                 :          0 :     for (int i = 0; i < max_outbound_block_relay; ++i) {
     281                 :          0 :         BOOST_CHECK(vNodes[i]->fDisconnect == false);
     282                 :          0 :     }
     283                 :          0 :     BOOST_CHECK(vNodes.back()->fDisconnect == true);
     284                 :            : 
     285                 :            :     // Update the last block time for the extra peer,
     286                 :            :     // and check that the next youngest peer gets evicted.
     287                 :          0 :     vNodes.back()->fDisconnect = false;
     288                 :          0 :     vNodes.back()->m_last_block_time = GetTime<std::chrono::seconds>();
     289                 :            : 
     290                 :          0 :     peerLogic->CheckForStaleTipAndEvictPeers();
     291                 :          0 :     for (int i = 0; i < max_outbound_block_relay - 1; ++i) {
     292                 :          0 :         BOOST_CHECK(vNodes[i]->fDisconnect == false);
     293                 :          0 :     }
     294                 :          0 :     BOOST_CHECK(vNodes[max_outbound_block_relay - 1]->fDisconnect == true);
     295                 :          0 :     BOOST_CHECK(vNodes.back()->fDisconnect == false);
     296                 :            : 
     297                 :          0 :     for (const CNode* node : vNodes) {
     298                 :          0 :         peerLogic->FinalizeNode(*node);
     299                 :            :     }
     300                 :          0 :     connman->ClearTestNodes();
     301                 :          0 : }
     302                 :            : 
     303                 :          0 : BOOST_AUTO_TEST_CASE(peer_discouragement)
     304                 :            : {
     305                 :          0 :     LOCK(NetEventsInterface::g_msgproc_mutex);
     306                 :            : 
     307                 :          0 :     auto banman = std::make_unique<BanMan>(m_args.GetDataDirBase() / "banlist", nullptr, DEFAULT_MISBEHAVING_BANTIME);
     308                 :          0 :     auto connman = std::make_unique<ConnmanTestMsg>(0x1337, 0x1337, *m_node.addrman, *m_node.netgroupman, Params());
     309                 :          0 :     auto peerLogic = PeerManager::make(*connman, *m_node.addrman, banman.get(), *m_node.chainman, *m_node.mempool, {});
     310                 :            : 
     311                 :          0 :     CNetAddr tor_netaddr;
     312                 :          0 :     BOOST_REQUIRE(
     313                 :            :         tor_netaddr.SetSpecial("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion"));
     314                 :          0 :     const CService tor_service{tor_netaddr, Params().GetDefaultPort()};
     315                 :            : 
     316                 :          0 :     const std::array<CAddress, 3> addr{CAddress{ip(0xa0b0c001), NODE_NONE},
     317                 :          0 :                                        CAddress{ip(0xa0b0c002), NODE_NONE},
     318                 :          0 :                                        CAddress{tor_service, NODE_NONE}};
     319                 :            : 
     320                 :          0 :     const CNetAddr other_addr{ip(0xa0b0ff01)}; // Not any of addr[].
     321                 :            : 
     322                 :            :     std::array<CNode*, 3> nodes;
     323                 :            : 
     324                 :          0 :     banman->ClearBanned();
     325                 :          0 :     NodeId id{0};
     326                 :          0 :     nodes[0] = new CNode{id++,
     327                 :          0 :                          /*sock=*/nullptr,
     328                 :          0 :                          addr[0],
     329                 :            :                          /*nKeyedNetGroupIn=*/0,
     330                 :            :                          /*nLocalHostNonceIn=*/0,
     331                 :          0 :                          CAddress(),
     332                 :          0 :                          /*addrNameIn=*/"",
     333                 :            :                          ConnectionType::INBOUND,
     334                 :            :                          /*inbound_onion=*/false};
     335                 :          0 :     nodes[0]->SetCommonVersion(PROTOCOL_VERSION);
     336                 :          0 :     peerLogic->InitializeNode(*nodes[0], NODE_NETWORK);
     337                 :          0 :     nodes[0]->fSuccessfullyConnected = true;
     338                 :          0 :     connman->AddTestNode(*nodes[0]);
     339                 :          0 :     peerLogic->UnitTestMisbehaving(nodes[0]->GetId(), DISCOURAGEMENT_THRESHOLD); // Should be discouraged
     340                 :          0 :     BOOST_CHECK(peerLogic->SendMessages(nodes[0]));
     341                 :            : 
     342                 :          0 :     BOOST_CHECK(banman->IsDiscouraged(addr[0]));
     343                 :          0 :     BOOST_CHECK(nodes[0]->fDisconnect);
     344                 :          0 :     BOOST_CHECK(!banman->IsDiscouraged(other_addr)); // Different address, not discouraged
     345                 :            : 
     346                 :          0 :     nodes[1] = new CNode{id++,
     347                 :          0 :                          /*sock=*/nullptr,
     348                 :          0 :                          addr[1],
     349                 :            :                          /*nKeyedNetGroupIn=*/1,
     350                 :            :                          /*nLocalHostNonceIn=*/1,
     351                 :          0 :                          CAddress(),
     352                 :          0 :                          /*addrNameIn=*/"",
     353                 :            :                          ConnectionType::INBOUND,
     354                 :            :                          /*inbound_onion=*/false};
     355                 :          0 :     nodes[1]->SetCommonVersion(PROTOCOL_VERSION);
     356                 :          0 :     peerLogic->InitializeNode(*nodes[1], NODE_NETWORK);
     357                 :          0 :     nodes[1]->fSuccessfullyConnected = true;
     358                 :          0 :     connman->AddTestNode(*nodes[1]);
     359                 :          0 :     peerLogic->UnitTestMisbehaving(nodes[1]->GetId(), DISCOURAGEMENT_THRESHOLD - 1);
     360                 :          0 :     BOOST_CHECK(peerLogic->SendMessages(nodes[1]));
     361                 :            :     // [0] is still discouraged/disconnected.
     362                 :          0 :     BOOST_CHECK(banman->IsDiscouraged(addr[0]));
     363                 :          0 :     BOOST_CHECK(nodes[0]->fDisconnect);
     364                 :            :     // [1] is not discouraged/disconnected yet.
     365                 :          0 :     BOOST_CHECK(!banman->IsDiscouraged(addr[1]));
     366                 :          0 :     BOOST_CHECK(!nodes[1]->fDisconnect);
     367                 :          0 :     peerLogic->UnitTestMisbehaving(nodes[1]->GetId(), 1); // [1] reaches discouragement threshold
     368                 :          0 :     BOOST_CHECK(peerLogic->SendMessages(nodes[1]));
     369                 :            :     // Expect both [0] and [1] to be discouraged/disconnected now.
     370                 :          0 :     BOOST_CHECK(banman->IsDiscouraged(addr[0]));
     371                 :          0 :     BOOST_CHECK(nodes[0]->fDisconnect);
     372                 :          0 :     BOOST_CHECK(banman->IsDiscouraged(addr[1]));
     373                 :          0 :     BOOST_CHECK(nodes[1]->fDisconnect);
     374                 :            : 
     375                 :            :     // Make sure non-IP peers are discouraged and disconnected properly.
     376                 :            : 
     377                 :          0 :     nodes[2] = new CNode{id++,
     378                 :          0 :                          /*sock=*/nullptr,
     379                 :          0 :                          addr[2],
     380                 :            :                          /*nKeyedNetGroupIn=*/1,
     381                 :            :                          /*nLocalHostNonceIn=*/1,
     382                 :          0 :                          CAddress(),
     383                 :          0 :                          /*addrNameIn=*/"",
     384                 :            :                          ConnectionType::OUTBOUND_FULL_RELAY,
     385                 :            :                          /*inbound_onion=*/false};
     386                 :          0 :     nodes[2]->SetCommonVersion(PROTOCOL_VERSION);
     387                 :          0 :     peerLogic->InitializeNode(*nodes[2], NODE_NETWORK);
     388                 :          0 :     nodes[2]->fSuccessfullyConnected = true;
     389                 :          0 :     connman->AddTestNode(*nodes[2]);
     390                 :          0 :     peerLogic->UnitTestMisbehaving(nodes[2]->GetId(), DISCOURAGEMENT_THRESHOLD);
     391                 :          0 :     BOOST_CHECK(peerLogic->SendMessages(nodes[2]));
     392                 :          0 :     BOOST_CHECK(banman->IsDiscouraged(addr[0]));
     393                 :          0 :     BOOST_CHECK(banman->IsDiscouraged(addr[1]));
     394                 :          0 :     BOOST_CHECK(banman->IsDiscouraged(addr[2]));
     395                 :          0 :     BOOST_CHECK(nodes[0]->fDisconnect);
     396                 :          0 :     BOOST_CHECK(nodes[1]->fDisconnect);
     397                 :          0 :     BOOST_CHECK(nodes[2]->fDisconnect);
     398                 :            : 
     399                 :          0 :     for (CNode* node : nodes) {
     400                 :          0 :         peerLogic->FinalizeNode(*node);
     401                 :            :     }
     402                 :          0 :     connman->ClearTestNodes();
     403                 :          0 : }
     404                 :            : 
     405                 :          0 : BOOST_AUTO_TEST_CASE(DoS_bantime)
     406                 :            : {
     407                 :          0 :     LOCK(NetEventsInterface::g_msgproc_mutex);
     408                 :            : 
     409                 :          0 :     auto banman = std::make_unique<BanMan>(m_args.GetDataDirBase() / "banlist", nullptr, DEFAULT_MISBEHAVING_BANTIME);
     410                 :          0 :     auto connman = std::make_unique<CConnman>(0x1337, 0x1337, *m_node.addrman, *m_node.netgroupman, Params());
     411                 :          0 :     auto peerLogic = PeerManager::make(*connman, *m_node.addrman, banman.get(), *m_node.chainman, *m_node.mempool, {});
     412                 :            : 
     413                 :          0 :     banman->ClearBanned();
     414                 :          0 :     int64_t nStartTime = GetTime();
     415                 :          0 :     SetMockTime(nStartTime); // Overrides future calls to GetTime()
     416                 :            : 
     417                 :          0 :     CAddress addr(ip(0xa0b0c001), NODE_NONE);
     418                 :          0 :     NodeId id{0};
     419                 :          0 :     CNode dummyNode{id++,
     420                 :          0 :                     /*sock=*/nullptr,
     421                 :            :                     addr,
     422                 :            :                     /*nKeyedNetGroupIn=*/4,
     423                 :            :                     /*nLocalHostNonceIn=*/4,
     424                 :          0 :                     CAddress(),
     425                 :          0 :                     /*addrNameIn=*/"",
     426                 :            :                     ConnectionType::INBOUND,
     427                 :            :                     /*inbound_onion=*/false};
     428                 :          0 :     dummyNode.SetCommonVersion(PROTOCOL_VERSION);
     429                 :          0 :     peerLogic->InitializeNode(dummyNode, NODE_NETWORK);
     430                 :          0 :     dummyNode.fSuccessfullyConnected = true;
     431                 :            : 
     432                 :          0 :     peerLogic->UnitTestMisbehaving(dummyNode.GetId(), DISCOURAGEMENT_THRESHOLD);
     433                 :          0 :     BOOST_CHECK(peerLogic->SendMessages(&dummyNode));
     434                 :          0 :     BOOST_CHECK(banman->IsDiscouraged(addr));
     435                 :            : 
     436                 :          0 :     peerLogic->FinalizeNode(dummyNode);
     437                 :          0 : }
     438                 :            : 
     439                 :          0 : BOOST_AUTO_TEST_SUITE_END()