Inside Bitcoin

1251     *  (only after ReceiveKey). Decoys are skipped. Optional associated authenticated data (AAD) is
1252     *  expected in the first received packet, no matter if that is a decoy or not. */
1253    std::vector<uint8_t> ReceivePacket(std::span<const std::byte> aad = {})
1254    {
1255        std::vector<uint8_t> contents;
1256        // Loop as long as there are ignored packets that are to be skipped.
1257        while (true) {
1258            // When processing a packet, at least enough bytes for its length descriptor must be received.
1259            BOOST_REQUIRE(m_received.size() >= BIP324Cipher::LENGTH_LEN);
1260            // Decrypt the content length.
1261            size_t size = m_cipher.DecryptLength(MakeByteSpan(std::span{m_received}.first(BIP324Cipher::LENGTH_LEN)));
1262            // Check that the full packet is in the receive buffer.
1263            BOOST_REQUIRE(m_received.size() >= size + BIP324Cipher::EXPANSION);
1264            // Decrypt the packet contents.
1265            contents.resize(size);
1266            bool ignore{false};
1267            bool ret = m_cipher.Decrypt(
1268                /*input=*/MakeByteSpan(
1269                    std::span{m_received}.first(size + BIP324Cipher::EXPANSION).subspan(BIP324Cipher::LENGTH_LEN)),
1270                /*aad=*/aad,
1271                /*ignore=*/ignore,
1272                /*contents=*/MakeWritableByteSpan(contents));
1273            BOOST_CHECK(ret);
1274            // Don't expect AAD in further packets.
1275            aad = {};
1276            // Strip the processed packet's bytes off the front of the receive buffer.
1277            m_received.erase(m_received.begin(), m_received.begin() + size + BIP324Cipher::EXPANSION);
1278            // Stop if the ignore bit is not set on this packet.
1279            if (!ignore) break;
1280        }
1281        return contents;
1282    }
1283
1284    /** Expect garbage and garbage terminator to have been received, and process them (only after
1285     *  ReceiveKey). */
1286    void ReceiveGarbage()
1287    {
1288        // Figure out the garbage length.
1289        size_t garblen;
1290        for (garblen = 0; garblen <= V2Transport::MAX_GARBAGE_LEN; ++garblen) {
1291            BOOST_REQUIRE(m_received.size() >= garblen + BIP324Cipher::GARBAGE_TERMINATOR_LEN);
1292            auto term_span = MakeByteSpan(std::span{m_received}.subspan(garblen, BIP324Cipher::GARBAGE_TERMINATOR_LEN));
1293            if (std::ranges::equal(term_span, m_cipher.GetReceiveGarbageTerminator())) break;
1294        }
1295        // Copy the garbage to a buffer.
1296        m_recv_garbage.assign(m_received.begin(), m_received.begin() + garblen);
1297        // Strip garbage + garbage terminator off the front of the receive buffer.
1298        m_received.erase(m_received.begin(), m_received.begin() + garblen + BIP324Cipher::GARBAGE_TERMINATOR_LEN);
1299    }
1300
1301    /** Expect version packet to have been received, and process it (only after ReceiveKey). */
1302    void ReceiveVersion()
1303    {
1304        auto contents = ReceivePacket(/*aad=*/MakeByteSpan(m_recv_garbage));
1305        // Version packets from real BIP324 peers are expected to be empty, despite the fact that
1306        // this class supports *sending* non-empty version packets (to test that BIP324 peers
1307        // correctly ignore version packet contents).
1308        BOOST_CHECK(contents.empty());
1309    }
1310
1311    /** Expect application packet to have been received, with specified short id and payload.
1312     *  (only after ReceiveKey). */
1313    void ReceiveMessage(uint8_t short_id, std::span<const uint8_t> payload)
1314    {
1315        auto ret = ReceivePacket();
1316        BOOST_CHECK(ret.size() == payload.size() + 1);
1317        BOOST_CHECK(ret[0] == short_id);
1318        BOOST_CHECK(std::ranges::equal(std::span{ret}.subspan(1), payload));
1319    }
1320
1321    /** Expect application packet to have been received, with specified 12-char message type and
1322     *  payload (only after ReceiveKey). */
1323    void ReceiveMessage(const std::string& m_type, std::span<const uint8_t> payload)
1324    {
1325        auto ret = ReceivePacket();
1326        BOOST_REQUIRE(ret.size() == payload.size() + 1 + CMessageHeader::MESSAGE_TYPE_SIZE);
1327        BOOST_CHECK(ret[0] == 0);
1328        for (unsigned i = 0; i < 12; ++i) {
1329            if (i < m_type.size()) {
1330                BOOST_CHECK(ret[1 + i] == m_type[i]);
1331            } else {
1332                BOOST_CHECK(ret[1 + i] == 0);
1333            }
1334        }
1335        BOOST_CHECK(std::ranges::equal(std::span{ret}.subspan(1 + CMessageHeader::MESSAGE_TYPE_SIZE), payload));
1336    }
1337
1338    /** Schedule an encrypted packet with specified message type and payload to be sent to
1339     *  transport (only after ReceiveKey). */
1340    void SendMessage(std::string mtype, std::span<const uint8_t> payload)
1341    {
1342        // Construct contents consisting of 0x00 + 12-byte message type + payload.
1343        std::vector<uint8_t> contents(1 + CMessageHeader::MESSAGE_TYPE_SIZE + payload.size());
1344        std::copy(mtype.begin(), mtype.end(), contents.begin() + 1);
1345        std::copy(payload.begin(), payload.end(), contents.begin() + 1 + CMessageHeader::MESSAGE_TYPE_SIZE);
1346        // Send a packet with that as contents.
1347        SendPacket(contents);
1348    }
1349
1350    /** Schedule an encrypted packet with specified short message id and payload to be sent to
1351     *  transport (only after ReceiveKey). */
1352    void SendMessage(uint8_t short_id, std::span<const uint8_t> payload)
1353    {
1354        // Construct contents consisting of short_id + payload.
1355        std::vector<uint8_t> contents(1 + payload.size());
1356        contents[0] = short_id;
1357        std::copy(payload.begin(), payload.end(), contents.begin() + 1);
1358        // Send a packet with that as contents.
1359        SendPacket(contents);
1360    }
1361
1362    /** Test whether the transport's session ID matches the session ID we expect. */
1363    void CompareSessionIDs() const
1364    {
1365        auto info = m_transport.GetInfo();
1366        BOOST_CHECK(info.session_id);
1367        BOOST_CHECK(uint256(MakeUCharSpan(m_cipher.GetSessionID())) == *info.session_id);
1368    }
1369
1370    /** Introduce a bit error in the data scheduled to be sent. */
1371    void Damage()
1372    {
1373        m_to_send[m_rng.randrange(m_to_send.size())] ^= (uint8_t{1} << m_rng.randrange(8));
1374    }
1375};
1376
1377} // namespace
1378
1379BOOST_AUTO_TEST_CASE(v2transport_test)
1380{
1381    // A mostly normal scenario, testing a transport in initiator mode.
1382    for (int i = 0; i < 10; ++i) {
1383        V2TransportTester tester(m_rng, true);
1384        auto ret = tester.Interact();
1385        BOOST_REQUIRE(ret);
1386        BOOST_REQUIRE(ret->empty());
1387        tester.SendKey();
1388        tester.SendGarbage();
1389        tester.ReceiveKey();
1390        tester.SendGarbageTerm();
1391        tester.SendVersion();
1392        ret = tester.Interact();
1393        BOOST_REQUIRE(ret);
1394        BOOST_REQUIRE(ret->empty());
1395        tester.ReceiveGarbage();
1396        tester.ReceiveVersion();
1397        tester.CompareSessionIDs();
1398        auto msg_data_1 = m_rng.randbytes<uint8_t>(m_rng.randrange(100000));
1399        auto msg_data_2 = m_rng.randbytes<uint8_t>(m_rng.randrange(1000));
1400        tester.SendMessage(uint8_t(4), msg_data_1); // cmpctblock short id
1401        tester.SendMessage(0, {}); // Invalidly encoded message
1402        tester.SendMessage("tx", msg_data_2); // 12-character encoded message type
1403        // Message type containing 0x7F (DEL): outside the printable-ASCII range
1404        // accepted by the v1 transport, so must be rejected here as well.
1405        tester.SendMessage(std::string{"t\x7f"}, msg_data_2);
1406        // Message type containing 0x7E ('~'): at the boundary, still valid.
1407        tester.SendMessage("t~", msg_data_2);
1408        ret = tester.Interact();
1409        BOOST_REQUIRE(ret);
1410        BOOST_REQUIRE(ret->size() == 5);
1411        BOOST_REQUIRE((*ret)[0]);
1412        BOOST_CHECK((*ret)[0]->m_type == "cmpctblock");
1413        BOOST_CHECK(std::ranges::equal((*ret)[0]->m_recv, MakeByteSpan(msg_data_1)));
1414        BOOST_CHECK(!(*ret)[1]);
1415        BOOST_REQUIRE((*ret)[2]);
1416        BOOST_CHECK((*ret)[2]->m_type == "tx");
1417        BOOST_CHECK(std::ranges::equal((*ret)[2]->m_recv, MakeByteSpan(msg_data_2)));
1418        BOOST_CHECK(!(*ret)[3]);
1419        BOOST_REQUIRE((*ret)[4]);
1420        BOOST_CHECK((*ret)[4]->m_type == "t~");
1421        BOOST_CHECK(std::ranges::equal((*ret)[4]->m_recv, MakeByteSpan(msg_data_2)));
1422
1423        // Then send a message with a bit error, expecting failure. It's possible this failure does
1424        // not occur immediately (when the length descriptor was modified), but it should come
1425        // eventually, and no messages can be delivered anymore.
1426        tester.SendMessage("bad", msg_data_1);
1427        tester.Damage();
1428        while (true) {
1429            ret = tester.Interact();
1430            if (!ret) break; // failure
1431            BOOST_CHECK(ret->size() == 0); // no message can be delivered
1432            // Send another message.
1433            auto msg_data_3 = m_rng.randbytes<uint8_t>(m_rng.randrange(10000));
1434            tester.SendMessage(uint8_t(12), msg_data_3); // getheaders short id
1435        }
1436    }
1437
1438    // Normal scenario, with a transport in responder node.
1439    for (int i = 0; i < 10; ++i) {
1440        V2TransportTester tester(m_rng, false);
1441        tester.SendKey();
1442        tester.SendGarbage();
1443        auto ret = tester.Interact();
1444        BOOST_REQUIRE(ret);
1445        BOOST_REQUIRE(ret->empty());
1446        tester.ReceiveKey();
1447        tester.SendGarbageTerm();
1448        tester.SendVersion();
1449        ret = tester.Interact();
1450        BOOST_REQUIRE(ret);
1451        BOOST_REQUIRE(ret->empty());
1452        tester.ReceiveGarbage();
1453        tester.ReceiveVersion();
1454        tester.CompareSessionIDs();
1455        auto msg_data_1 = m_rng.randbytes<uint8_t>(m_rng.randrange(100000));
1456        auto msg_data_2 = m_rng.randbytes<uint8_t>(m_rng.randrange(1000));
1457        tester.SendMessage(uint8_t(14), msg_data_1); // inv short id
1458        tester.SendMessage(uint8_t(19), msg_data_2); // pong short id
1459        ret = tester.Interact();
1460        BOOST_REQUIRE(ret);
1461        BOOST_REQUIRE(ret->size() == 2);
1462        BOOST_REQUIRE((*ret)[0]);
1463        BOOST_CHECK((*ret)[0]->m_type == "inv");
1464        BOOST_CHECK(std::ranges::equal((*ret)[0]->m_recv, MakeByteSpan(msg_data_1)));
1465        BOOST_REQUIRE((*ret)[1]);
1466        BOOST_CHECK((*ret)[1]->m_type == "pong");
1467        BOOST_CHECK(std::ranges::equal((*ret)[1]->m_recv, MakeByteSpan(msg_data_2)));
1468
1469        // Then send a too-large message.
1470        auto msg_data_3 = m_rng.randbytes<uint8_t>(4005000);
1471        tester.SendMessage(uint8_t(11), msg_data_3); // getdata short id
1472        ret = tester.Interact();
1473        BOOST_CHECK(!ret);
1474    }
1475
1476    // Various valid but unusual scenarios.
1477    for (int i = 0; i < 50; ++i) {
1478        /** Whether an initiator or responder is being tested. */
1479        bool initiator = m_rng.randbool();
1480        /** Use either 0 bytes or the maximum possible (4095 bytes) garbage length. */
1481        size_t garb_len = m_rng.randbool() ? 0 : V2Transport::MAX_GARBAGE_LEN;
1482        /** How many decoy packets to send before the version packet. */
1483        unsigned num_ignore_version = m_rng.randrange(10);
1484        /** What data to send in the version packet (ignored by BIP324 peers, but reserved for future extensions). */
1485        auto ver_data = m_rng.randbytes<uint8_t>(m_rng.randbool() ? 0 : m_rng.randrange(1000));
1486        /** Whether to immediately send key and garbage out (required for responders, optional otherwise). */
1487        bool send_immediately = !initiator || m_rng.randbool();
1488        /** How many decoy packets to send before the first and second real message. */
1489        unsigned num_decoys_1 = m_rng.randrange(1000), num_decoys_2 = m_rng.randrange(1000);
1490        V2TransportTester tester(m_rng, initiator);
1491        if (send_immediately) {
1492            tester.SendKey();
1493            tester.SendGarbage(garb_len);
1494        }
1495        auto ret = tester.Interact();
1496        BOOST_REQUIRE(ret);
1497        BOOST_REQUIRE(ret->empty());
1498        if (!send_immediately) {
1499            tester.SendKey();
1500            tester.SendGarbage(garb_len);