751        return nCopy;
752
753    // deserialize to CMessageHeader
754    try {
755        hdrbuf >> hdr;
756    }
757    catch (const std::exception&) {
758        LogDebug(BCLog::NET, "Header error: Unable to deserialize, peer=%d\n", m_node_id);
759        return -1;
760    }
761
762    // Check start string, network magic
763    if (hdr.pchMessageStart != m_magic_bytes) {
764        LogDebug(BCLog::NET, "Header error: Wrong MessageStart %s received, peer=%d\n", HexStr(hdr.pchMessageStart), m_node_id);
765        return -1;
766    }
767
768    // reject messages larger than MAX_SIZE or MAX_PROTOCOL_MESSAGE_LENGTH
769    // NOTE: failing to perform this check previously allowed a malicious peer to make us allocate 32MiB of memory per
770    // connection. See https://bitcoincore.org/en/2024/07/03/disclose_receive_buffer_oom.
771    if (hdr.nMessageSize > MAX_SIZE || hdr.nMessageSize > MAX_PROTOCOL_MESSAGE_LENGTH) {
772        LogDebug(BCLog::NET, "Header error: Size too large (%s, %u bytes), peer=%d\n", SanitizeString(hdr.GetMessageType()), hdr.nMessageSize, m_node_id);
773        return -1;
774    }
775
776    // switch state to reading message data
777    in_data = true;
778
779    return nCopy;
780}
781
782int V1Transport::readData(std::span<const uint8_t> msg_bytes)
783{
784    AssertLockHeld(m_recv_mutex);
785    unsigned int nRemaining = hdr.nMessageSize - nDataPos;
786    unsigned int nCopy = std::min<unsigned int>(nRemaining, msg_bytes.size());
787
788    if (vRecv.size() < nDataPos + nCopy) {
789        // Allocate up to 256 KiB ahead, but never more than the total message size.
790        vRecv.resize(std::min(hdr.nMessageSize, nDataPos + nCopy + 256 * 1024));
791    }
792
793    hasher.Write(msg_bytes.first(nCopy));
794    memcpy(&vRecv[nDataPos], msg_bytes.data(), nCopy);
795    nDataPos += nCopy;
796
797    return nCopy;
798}
799
800const uint256& V1Transport::GetMessageHash() const
801{
802    AssertLockHeld(m_recv_mutex);
803    assert(CompleteInternal());
804    if (data_hash.IsNull())
805        hasher.Finalize(data_hash);
806    return data_hash;
807}
808
809CNetMessage V1Transport::GetReceivedMessage(NodeClock::time_point time, bool& reject_message)
810{
811    AssertLockNotHeld(m_recv_mutex);
812    // Initialize out parameter
813    reject_message = false;
814    // decompose a single CNetMessage from the TransportDeserializer
815    LOCK(m_recv_mutex);
816    CNetMessage msg(std::move(vRecv));
817
818    // store message type string, time, and sizes
819    msg.m_type = hdr.GetMessageType();
820    msg.m_time = time;
821    msg.m_message_size = hdr.nMessageSize;
822    msg.m_raw_message_size = hdr.nMessageSize + CMessageHeader::HEADER_SIZE;
823
824    uint256 hash = GetMessageHash();
825
826    // We just received a message off the wire, harvest entropy from the time (and the message checksum)
827    RandAddEvent(ReadLE32(hash.begin()));
828
829    // Check checksum and header message type string
830    if (memcmp(hash.begin(), hdr.pchChecksum, CMessageHeader::CHECKSUM_SIZE) != 0) {
831        LogDebug(BCLog::NET, "Header error: Wrong checksum (%s, %u bytes), expected %s was %s, peer=%d\n",
832                 SanitizeString(msg.m_type), msg.m_message_size,
833                 HexStr(std::span{hash}.first(CMessageHeader::CHECKSUM_SIZE)),
834                 HexStr(hdr.pchChecksum),
835                 m_node_id);
836        reject_message = true;
837    } else if (!hdr.IsMessageTypeValid()) {
838        LogDebug(BCLog::NET, "Header error: Invalid message type (%s, %u bytes), peer=%d\n",
839                 SanitizeString(hdr.GetMessageType()), msg.m_message_size, m_node_id);
840        reject_message = true;
841    }
842
843    // Always reset the network deserializer (prepare for the next message)
844    Reset();
845    return msg;
846}
847
848bool V1Transport::SetMessageToSend(CSerializedNetMsg& msg) noexcept
849{
850    AssertLockNotHeld(m_send_mutex);
851    // Determine whether a new message can be set.
852    LOCK(m_send_mutex);
853    if (m_sending_header || m_bytes_sent < m_message_to_send.data.size()) return false;
854
855    // create dbl-sha256 checksum
856    uint256 hash = Hash(msg.data);
857
858    // create header
859    CMessageHeader hdr(m_magic_bytes, msg.m_type.c_str(), msg.data.size());
860    memcpy(hdr.pchChecksum, hash.begin(), CMessageHeader::CHECKSUM_SIZE);
861
862    // serialize header
863    m_header_to_send.clear();
864    VectorWriter{m_header_to_send, 0, hdr};
865
866    // update state
867    m_message_to_send = std::move(msg);
868    m_sending_header = true;
869    m_bytes_sent = 0;
870    return true;
871}
872
873Transport::BytesToSend V1Transport::GetBytesToSend(bool have_next_message) const noexcept
874{
875    AssertLockNotHeld(m_send_mutex);
876    LOCK(m_send_mutex);
877    if (m_sending_header) {
878        return {std::span{m_header_to_send}.subspan(m_bytes_sent),
879                // We have more to send after the header if the message has payload, or if there
880                // is a next message after that.
881                have_next_message || !m_message_to_send.data.empty(),
882                m_message_to_send.m_type
883               };
884    } else {
885        return {std::span{m_message_to_send.data}.subspan(m_bytes_sent),
886                // We only have more to send after this message's payload if there is another
887                // message.
888                have_next_message,
889                m_message_to_send.m_type
890               };
891    }
892}
893
894void V1Transport::MarkBytesSent(size_t bytes_sent) noexcept
895{
896    AssertLockNotHeld(m_send_mutex);
897    LOCK(m_send_mutex);
898    m_bytes_sent += bytes_sent;
899    if (m_sending_header && m_bytes_sent == m_header_to_send.size()) {
900        // We're done sending a message's header. Switch to sending its data bytes.
901        m_sending_header = false;
902        m_bytes_sent = 0;
903    } else if (!m_sending_header && m_bytes_sent == m_message_to_send.data.size()) {
904        // We're done sending a message's data. Wipe the data vector to reduce memory consumption.
905        ClearShrink(m_message_to_send.data);
906        m_bytes_sent = 0;
907    }
908}
909
910size_t V1Transport::GetSendMemoryUsage() const noexcept
911{
912    AssertLockNotHeld(m_send_mutex);
913    LOCK(m_send_mutex);
914    // Don't count sending-side fields besides m_message_to_send, as they're all small and bounded.
915    return m_message_to_send.GetMemoryUsage();
916}
917
918namespace {
919
920/** List of short messages as defined in BIP324, in order.
921 *
922 * Only message types that are actually implemented in this codebase need to be listed, as other
923 * messages get ignored anyway - whether we know how to decode them or not.
924 */
925const std::array<std::string, BIP324_SHORTIDS_IMPLEMENTED> V2_MESSAGE_IDS = {
926    "", // 12 bytes follow encoding the message type like in V1
927    NetMsgType::ADDR,
928    NetMsgType::BLOCK,
929    NetMsgType::BLOCKTXN,
930    NetMsgType::CMPCTBLOCK,
931    NetMsgType::FEEFILTER,
932    NetMsgType::FILTERADD,
933    NetMsgType::FILTERCLEAR,
934    NetMsgType::FILTERLOAD,
935    NetMsgType::GETBLOCKS,
936    NetMsgType::GETBLOCKTXN,
937    NetMsgType::GETDATA,
938    NetMsgType::GETHEADERS,
939    NetMsgType::HEADERS,
940    NetMsgType::INV,
941    NetMsgType::MEMPOOL,
942    NetMsgType::MERKLEBLOCK,
943    NetMsgType::NOTFOUND,
944    NetMsgType::PING,
945    NetMsgType::PONG,
946    NetMsgType::SENDCMPCT,
947    NetMsgType::TX,
948    NetMsgType::GETCFILTERS,
949    NetMsgType::CFILTER,
950    NetMsgType::GETCFHEADERS,
951    NetMsgType::CFHEADERS,
952    NetMsgType::GETCFCHECKPT,
953    NetMsgType::CFCHECKPT,
954    NetMsgType::ADDRV2,
955    "", "", "", // Unimplemented message types 29-31
956    "", "", "", "", // Unimplemented message types 32-35
957    "",  // Unimplemented message type 36
958    NetMsgType::FEATURE,
959};
960
961class V2MessageMap
962{
963    std::unordered_map<std::string, uint8_t> m_map;
964
965public:
966    V2MessageMap() noexcept
967    {
968        for (size_t i = 1; i < std::size(V2_MESSAGE_IDS); ++i) {
969            m_map.emplace(V2_MESSAGE_IDS[i], i);
970        }
971    }
972
973    std::optional<uint8_t> operator()(const std::string& message_name) const noexcept
974    {
975        auto it = m_map.find(message_name);
976        if (it == m_map.end()) return std::nullopt;
977        return it->second;
978    }
979};
980
981const V2MessageMap V2_MESSAGE_MAP;
982
983std::vector<uint8_t> GenerateRandomGarbage() noexcept
984{
985    std::vector<uint8_t> ret;
986    FastRandomContext rng;
987    ret.resize(rng.randrange(V2Transport::MAX_GARBAGE_LEN + 1));
988    rng.fillrand(MakeWritableByteSpan(ret));
989    return ret;
990}
991
992} // namespace
993
994void V2Transport::StartSendingHandshake() noexcept
995{
996    AssertLockHeld(m_send_mutex);
997    Assume(m_send_state == SendState::AWAITING_KEY);
998    Assume(m_send_buffer.empty());
999    // Initialize the send buffer with ellswift pubkey + provided garbage.
1000    m_send_buffer.resize(EllSwiftPubKey::size() + m_send_garbage.size());