Inside Bitcoin

1001    BOOST_CHECK(GetLocalAddress(*peer_ipv6_tunnel) == addr_ipv4);
1002    BOOST_CHECK(GetLocalAddress(*peer_teredo) == addr_ipv4);
1003    BOOST_CHECK(GetLocalAddress(*peer_cjdns) == addr_ipv4);
1004    BOOST_CHECK(!GetLocalAddress(*peer_onion).IsValid());
1005    BOOST_CHECK(!GetLocalAddress(*peer_i2p).IsValid());
1006    RemoveLocal(addr_ipv4);
1007
1008    // local privacy addresses - don't advertise to clearnet peers
1009    AddLocal(addr_onion);
1010    AddLocal(addr_i2p);
1011    BOOST_CHECK(!GetLocalAddress(*peer_ipv4).IsValid());
1012    BOOST_CHECK(!GetLocalAddress(*peer_ipv6).IsValid());
1013    BOOST_CHECK(!GetLocalAddress(*peer_ipv6_tunnel).IsValid());
1014    BOOST_CHECK(!GetLocalAddress(*peer_teredo).IsValid());
1015    BOOST_CHECK(!GetLocalAddress(*peer_cjdns).IsValid());
1016    BOOST_CHECK(GetLocalAddress(*peer_onion) == addr_onion);
1017    BOOST_CHECK(GetLocalAddress(*peer_i2p) == addr_i2p);
1018    RemoveLocal(addr_onion);
1019    RemoveLocal(addr_i2p);
1020
1021    // local addresses from all networks
1022    AddLocal(addr_ipv4);
1023    AddLocal(addr_ipv6);
1024    AddLocal(addr_ipv6_tunnel);
1025    AddLocal(addr_teredo);
1026    AddLocal(addr_onion);
1027    AddLocal(addr_i2p);
1028    AddLocal(addr_cjdns);
1029    BOOST_CHECK(GetLocalAddress(*peer_ipv4) == addr_ipv4);
1030    BOOST_CHECK(GetLocalAddress(*peer_ipv6) == addr_ipv6);
1031    BOOST_CHECK(GetLocalAddress(*peer_ipv6_tunnel) == addr_ipv6);
1032    BOOST_CHECK(GetLocalAddress(*peer_teredo) == addr_ipv4);
1033    BOOST_CHECK(GetLocalAddress(*peer_onion) == addr_onion);
1034    BOOST_CHECK(GetLocalAddress(*peer_i2p) == addr_i2p);
1035    BOOST_CHECK(GetLocalAddress(*peer_cjdns) == addr_cjdns);
1036    RemoveLocal(addr_ipv4);
1037    RemoveLocal(addr_ipv6);
1038    RemoveLocal(addr_ipv6_tunnel);
1039    RemoveLocal(addr_teredo);
1040    RemoveLocal(addr_onion);
1041    RemoveLocal(addr_i2p);
1042    RemoveLocal(addr_cjdns);
1043}
1044
1045namespace {
1046
1047CKey GenerateRandomTestKey(FastRandomContext& rng) noexcept
1048{
1049    CKey key;
1050    uint256 key_data = rng.rand256();
1051    key.Set(key_data.begin(), key_data.end(), true);
1052    return key;
1053}
1054
1055/** A class for scenario-based tests of V2Transport
1056 *
1057 * Each V2TransportTester encapsulates a V2Transport (the one being tested), and can be told to
1058 * interact with it. To do so, it also encapsulates a BIP324Cipher to act as the other side. A
1059 * second V2Transport is not used, as doing so would not permit scenarios that involve sending
1060 * invalid data, or ones using BIP324 features that are not implemented on the sending
1061 * side (like decoy packets).
1062 */
1063class V2TransportTester
1064{
1065    FastRandomContext& m_rng;
1066    V2Transport m_transport; //!< V2Transport being tested
1067    BIP324Cipher m_cipher; //!< Cipher to help with the other side
1068    bool m_test_initiator; //!< Whether m_transport is the initiator (true) or responder (false)
1069
1070    std::vector<uint8_t> m_sent_garbage; //!< The garbage we've sent to m_transport.
1071    std::vector<uint8_t> m_recv_garbage; //!< The garbage we've received from m_transport.
1072    std::vector<uint8_t> m_to_send; //!< Bytes we have queued up to send to m_transport.
1073    std::vector<uint8_t> m_received; //!< Bytes we have received from m_transport.
1074    std::deque<CSerializedNetMsg> m_msg_to_send; //!< Messages to be sent *by* m_transport to us.
1075    bool m_sent_aad{false};
1076
1077public:
1078    /** Construct a tester object. test_initiator: whether the tested transport is initiator. */
1079    explicit V2TransportTester(FastRandomContext& rng, bool test_initiator)
1080        : m_rng{rng},
1081          m_transport{0, test_initiator},
1082          m_cipher{GenerateRandomTestKey(m_rng), MakeByteSpan(m_rng.rand256())},
1083          m_test_initiator(test_initiator) {}
1084
1085    /** Data type returned by Interact:
1086     *
1087     * - std::nullopt: transport error occurred
1088     * - otherwise: a vector of
1089     *   - std::nullopt: invalid message received
1090     *   - otherwise: a CNetMessage retrieved
1091     */
1092    using InteractResult = std::optional<std::vector<std::optional<CNetMessage>>>;
1093
1094    /** Send/receive scheduled/available bytes and messages.
1095     *
1096     * This is the only function that interacts with the transport being tested; everything else is
1097     * scheduling things done by Interact(), or processing things learned by it.
1098     */
1099    InteractResult Interact()
1100    {
1101        std::vector<std::optional<CNetMessage>> ret;
1102        while (true) {
1103            bool progress{false};
1104            // Send bytes from m_to_send to the transport.
1105            if (!m_to_send.empty()) {
1106                std::span<const uint8_t> to_send = std::span{m_to_send}.first(1 + m_rng.randrange(m_to_send.size()));
1107                size_t old_len = to_send.size();
1108                if (!m_transport.ReceivedBytes(to_send)) {
1109                    return std::nullopt; // transport error occurred
1110                }
1111                if (old_len != to_send.size()) {
1112                    progress = true;
1113                    m_to_send.erase(m_to_send.begin(), m_to_send.begin() + (old_len - to_send.size()));
1114                }
1115            }
1116            // Retrieve messages received by the transport.
1117            if (m_transport.ReceivedMessageComplete() && (!progress || m_rng.randbool())) {
1118                bool reject{false};
1119                auto msg = m_transport.GetReceivedMessage({}, reject);
1120                if (reject) {
1121                    ret.emplace_back(std::nullopt);
1122                } else {
1123                    ret.emplace_back(std::move(msg));
1124                }
1125                progress = true;
1126            }
1127            // Enqueue a message to be sent by the transport to us.
1128            if (!m_msg_to_send.empty() && (!progress || m_rng.randbool())) {
1129                if (m_transport.SetMessageToSend(m_msg_to_send.front())) {
1130                    m_msg_to_send.pop_front();
1131                    progress = true;
1132                }
1133            }
1134            // Receive bytes from the transport.
1135            const auto& [recv_bytes, _more, _msg_type] = m_transport.GetBytesToSend(!m_msg_to_send.empty());
1136            if (!recv_bytes.empty() && (!progress || m_rng.randbool())) {
1137                size_t to_receive = 1 + m_rng.randrange(recv_bytes.size());
1138                m_received.insert(m_received.end(), recv_bytes.begin(), recv_bytes.begin() + to_receive);
1139                progress = true;
1140                m_transport.MarkBytesSent(to_receive);
1141            }
1142            if (!progress) break;
1143        }
1144        return ret;
1145    }
1146
1147    /** Expose the cipher. */
1148    BIP324Cipher& GetCipher() { return m_cipher; }
1149
1150    /** Schedule bytes to be sent to the transport. */
1151    void Send(std::span<const uint8_t> data)
1152    {
1153        m_to_send.insert(m_to_send.end(), data.begin(), data.end());
1154    }
1155
1156    /** Send V1 version message header to the transport. */
1157    void SendV1Version(const MessageStartChars& magic)
1158    {
1159        CMessageHeader hdr(magic, "version", 126 + m_rng.randrange(11));
1160        DataStream ser{};
1161        ser << hdr;
1162        m_to_send.insert(m_to_send.end(), UCharCast(ser.data()), UCharCast(ser.data() + ser.size()));
1163    }
1164
1165    /** Schedule bytes to be sent to the transport. */
1166    void Send(std::span<const std::byte> data) { Send(MakeUCharSpan(data)); }
1167
1168    /** Schedule our ellswift key to be sent to the transport. */
1169    void SendKey() { Send(m_cipher.GetOurPubKey()); }
1170
1171    /** Schedule specified garbage to be sent to the transport. */
1172    void SendGarbage(std::span<const uint8_t> garbage)
1173    {
1174        // Remember the specified garbage (so we can use it as AAD).
1175        m_sent_garbage.assign(garbage.begin(), garbage.end());
1176        // Schedule it for sending.
1177        Send(m_sent_garbage);
1178    }
1179
1180    /** Schedule garbage (of specified length) to be sent to the transport. */
1181    void SendGarbage(size_t garbage_len)
1182    {
1183        // Generate random garbage and send it.
1184        SendGarbage(m_rng.randbytes<uint8_t>(garbage_len));
1185    }
1186
1187    /** Schedule garbage (with valid random length) to be sent to the transport. */
1188    void SendGarbage()
1189    {
1190         SendGarbage(m_rng.randrange(V2Transport::MAX_GARBAGE_LEN + 1));
1191    }
1192
1193    /** Schedule a message to be sent to us by the transport. */
1194    void AddMessage(std::string m_type, std::vector<uint8_t> payload)
1195    {
1196        CSerializedNetMsg msg;
1197        msg.m_type = std::move(m_type);
1198        msg.data = std::move(payload);
1199        m_msg_to_send.push_back(std::move(msg));
1200    }
1201
1202    /** Expect ellswift key to have been received from transport and process it.
1203     *
1204     * Many other V2TransportTester functions cannot be called until after ReceiveKey() has been
1205     * called, as no encryption keys are set up before that point.
1206     */
1207    void ReceiveKey()
1208    {
1209        // When processing a key, enough bytes need to have been received already.
1210        BOOST_REQUIRE(m_received.size() >= EllSwiftPubKey::size());
1211        // Initialize the cipher using it (acting as the opposite side of the tested transport).
1212        m_cipher.Initialize(MakeByteSpan(m_received).first(EllSwiftPubKey::size()), !m_test_initiator);
1213        // Strip the processed bytes off the front of the receive buffer.
1214        m_received.erase(m_received.begin(), m_received.begin() + EllSwiftPubKey::size());
1215    }
1216
1217    /** Schedule an encrypted packet with specified content/aad/ignore to be sent to transport
1218     *  (only after ReceiveKey). */
1219    void SendPacket(std::span<const uint8_t> content, std::span<const uint8_t> aad = {}, bool ignore = false)
1220    {
1221        // Use cipher to construct ciphertext.
1222        std::vector<std::byte> ciphertext;
1223        ciphertext.resize(content.size() + BIP324Cipher::EXPANSION);
1224        m_cipher.Encrypt(
1225            /*contents=*/MakeByteSpan(content),
1226            /*aad=*/MakeByteSpan(aad),
1227            /*ignore=*/ignore,
1228            /*output=*/ciphertext);
1229        // Schedule it for sending.
1230        Send(ciphertext);
1231    }
1232
1233    /** Schedule garbage terminator to be sent to the transport (only after ReceiveKey). */
1234    void SendGarbageTerm()
1235    {
1236        // Schedule the garbage terminator to be sent.
1237        Send(m_cipher.GetSendGarbageTerminator());
1238    }
1239
1240    /** Schedule version packet to be sent to the transport (only after ReceiveKey). */
1241    void SendVersion(std::span<const uint8_t> version_data = {}, bool vers_ignore = false)
1242    {
1243        std::span<const std::uint8_t> aad;
1244        // Set AAD to garbage only for first packet.
1245        if (!m_sent_aad) aad = m_sent_garbage;
1246        SendPacket(/*content=*/version_data, /*aad=*/aad, /*ignore=*/vers_ignore);
1247        m_sent_aad = true;
1248    }
1249
1250    /** Expect a packet to have been received from transport, process it, and return its contents