What peer messages mean

3251    const CBlockIndex *pindexLast = nullptr;
3252
3253    // We'll set already_validated_work to true if these headers are
3254    // successfully processed as part of a low-work headers sync in progress
3255    // (either in PRESYNC or REDOWNLOAD phase).
3256    // If true, this will mean that any headers returned to us (ie during
3257    // REDOWNLOAD) can be validated without further anti-DoS checks.
3258    bool already_validated_work = false;
3259
3260    // If we're in the middle of headers sync, let it do its magic.
3261    bool have_headers_sync = false;
3262    {
3263        LOCK(peer.m_headers_sync_mutex);
3264
3265        already_validated_work = IsContinuationOfLowWorkHeadersSync(peer, pfrom, headers);
3266
3267        // The headers we passed in may have been:
3268        // - untouched, perhaps if no headers-sync was in progress, or some
3269        //   failure occurred
3270        // - erased, such as if the headers were successfully processed and no
3271        //   additional headers processing needs to take place (such as if we
3272        //   are still in PRESYNC)
3273        // - replaced with headers that are now ready for validation, such as
3274        //   during the REDOWNLOAD phase of a low-work headers sync.
3275        // So just check whether we still have headers that we need to process,
3276        // or not.
3277        if (headers.empty()) {
3278            return;
3279        }
3280
3281        have_headers_sync = !!peer.m_headers_sync;
3282    }
3283
3284    // Do these headers connect to something in our block index?
3285    const CBlockIndex *chain_start_header{WITH_LOCK(::cs_main, return m_chainman.m_blockman.LookupBlockIndex(headers[0].hashPrevBlock))};
3286    bool headers_connect_blockindex{chain_start_header != nullptr};
3287
3288    if (!headers_connect_blockindex) {
3289        // This could be a BIP 130 block announcement, use
3290        // special logic for handling headers that don't connect, as this
3291        // could be benign.
3292        HandleUnconnectingHeaders(pfrom, peer, headers);
3293        return;
3294    }
3295
3296    // If headers connect, assume that this is in response to any outstanding getheaders
3297    // request we may have sent, and clear out the time of our last request. Non-connecting
3298    // headers cannot be a response to a getheaders request.
3299    peer.m_last_getheaders_timestamp = {};
3300
3301    // If the headers we received are already in memory and an ancestor of
3302    // m_best_header or our tip, skip anti-DoS checks. These headers will not
3303    // use any more memory (and we are not leaking information that could be
3304    // used to fingerprint us).
3305    const CBlockIndex *last_received_header{nullptr};
3306    {
3307        LOCK(cs_main);
3308        last_received_header = m_chainman.m_blockman.LookupBlockIndex(headers.back().GetHash());
3309        already_validated_work = already_validated_work || IsAncestorOfBestHeaderOrTip(last_received_header);
3310    }
3311
3312    // If our peer has NetPermissionFlags::NoBan privileges, then bypass our
3313    // anti-DoS logic (this saves bandwidth when we connect to a trusted peer
3314    // on startup).
3315    if (pfrom.HasPermission(NetPermissionFlags::NoBan)) {
3316        already_validated_work = true;
3317    }
3318
3319    // At this point, the headers connect to something in our block index.
3320    // Do anti-DoS checks to determine if we should process or store for later
3321    // processing.
3322    if (!already_validated_work && TryLowWorkHeadersSync(peer, pfrom,
3323                                                         *chain_start_header, headers)) {
3324        // If we successfully started a low-work headers sync, then there
3325        // should be no headers to process any further.
3326        Assume(headers.empty());
3327        return;
3328    }
3329
3330    // At this point, we have a set of headers with sufficient work on them
3331    // which can be processed.
3332
3333    // If we don't have the last header, then this peer will have given us
3334    // something new (if these headers are valid).
3335    bool received_new_header{last_received_header == nullptr};
3336
3337    // Now process all the headers.
3338    BlockValidationState state;
3339    const bool processed{m_chainman.ProcessNewBlockHeaders(headers,
3340                                                           /*min_pow_checked=*/true,
3341                                                           state, &pindexLast)};
3342    if (!processed) {
3343        if (state.IsInvalid()) {
3344            if (!pfrom.IsInboundConn() && state.GetResult() == BlockValidationResult::BLOCK_CACHED_INVALID) {
3345                // Warn user if outgoing peers send us headers of blocks that we previously marked as invalid.
3346                LogWarning("%s (received from peer=%i). "
3347                           "If this happens with all peers, consider database corruption (that -reindex may fix) "
3348                           "or a potential consensus incompatibility.",
3349                           state.GetDebugMessage(), pfrom.GetId());
3350            }
3351            MaybePunishNodeForBlock(pfrom.GetId(), state, via_compact_block, "invalid header received");
3352            return;
3353        }
3354    }
3355    assert(pindexLast);
3356
3357    if (processed && received_new_header) {
3358        LogBlockHeader(*pindexLast, pfrom, /*via_compact_block=*/false);
3359    }
3360
3361    // Consider fetching more headers if we are not using our headers-sync mechanism.
3362    if (nCount == m_opts.max_headers_result && !have_headers_sync) {
3363        // Headers message had its maximum size; the peer may have more headers.
3364        if (MaybeSendGetHeaders(pfrom, GetLocator(pindexLast), peer)) {
3365            LogDebug(BCLog::NET, "more getheaders (%d) to end to peer=%d", pindexLast->nHeight, pfrom.GetId());
3366        }
3367    }
3368
3369    UpdatePeerStateForReceivedHeaders(pfrom, *pindexLast, received_new_header, nCount == m_opts.max_headers_result);
3370
3371    // Consider immediately downloading blocks.
3372    HeadersDirectFetchBlocks(pfrom, peer, *pindexLast);
3373
3374    return;
3375}
3376
3377std::optional<node::PackageToValidate> PeerManagerImpl::ProcessInvalidTx(NodeId nodeid, const CTransactionRef& ptx, const TxValidationState& state,
3378                                       bool first_time_failure)
3379{
3380    AssertLockNotHeld(m_peer_mutex);
3381    AssertLockHeld(g_msgproc_mutex);
3382    AssertLockHeld(m_tx_download_mutex);
3383
3384    PeerRef peer{GetPeerRef(nodeid)};
3385
3386    LogDebug(BCLog::MEMPOOLREJ, "%s (wtxid=%s) from peer=%d was not accepted: %s\n",
3387        ptx->GetHash().ToString(),
3388        ptx->GetWitnessHash().ToString(),
3389        nodeid,
3390        state.ToString());
3391
3392    const auto& [add_extra_compact_tx, unique_parents, package_to_validate] = m_txdownloadman.MempoolRejectedTx(ptx, state, nodeid, first_time_failure);
3393
3394    if (add_extra_compact_tx && RecursiveDynamicUsage(*ptx) < 100000) {
3395        AddToCompactExtraTransactions(ptx);
3396    }
3397    for (const Txid& parent_txid : unique_parents) {
3398        if (peer) AddKnownTx(*peer, parent_txid.ToUint256());
3399    }
3400
3401    return package_to_validate;
3402}
3403
3404void PeerManagerImpl::ProcessValidTx(NodeId nodeid, const CTransactionRef& tx, const std::list<CTransactionRef>& replaced_transactions)
3405{
3406    AssertLockNotHeld(m_peer_mutex);
3407    AssertLockHeld(g_msgproc_mutex);
3408    AssertLockHeld(m_tx_download_mutex);
3409
3410    m_txdownloadman.MempoolAcceptedTx(tx);
3411
3412    LogDebug(BCLog::MEMPOOL, "AcceptToMemoryPool: peer=%d: accepted %s (wtxid=%s) (poolsz %u txn, %u kB)\n",
3413             nodeid,
3414             tx->GetHash().ToString(),
3415             tx->GetWitnessHash().ToString(),
3416             m_mempool.size(), m_mempool.DynamicMemoryUsage() / 1000);
3417
3418    InitiateTxBroadcastToAll(tx->GetWitnessHash());
3419
3420    for (const CTransactionRef& removedTx : replaced_transactions) {
3421        AddToCompactExtraTransactions(removedTx);
3422    }
3423}
3424
3425void PeerManagerImpl::ProcessPackageResult(const node::PackageToValidate& package_to_validate, const PackageMempoolAcceptResult& package_result)
3426{
3427    AssertLockNotHeld(m_peer_mutex);
3428    AssertLockHeld(g_msgproc_mutex);
3429    AssertLockHeld(m_tx_download_mutex);
3430
3431    const auto& package = package_to_validate.m_txns;
3432    const auto& senders = package_to_validate.m_senders;
3433
3434    if (package_result.m_state.IsInvalid()) {
3435        m_txdownloadman.MempoolRejectedPackage(package);
3436    }
3437    // We currently only expect to process 1-parent-1-child packages. Remove if this changes.
3438    if (!Assume(package.size() == 2)) return;
3439
3440    // Iterate backwards to erase in-package descendants from the orphanage before they become
3441    // relevant in AddChildrenToWorkSet.
3442    auto package_iter = package.rbegin();
3443    auto senders_iter = senders.rbegin();
3444    while (package_iter != package.rend()) {
3445        const auto& tx = *package_iter;
3446        const NodeId nodeid = *senders_iter;
3447        const auto it_result{package_result.m_tx_results.find(tx->GetWitnessHash())};
3448
3449        // It is not guaranteed that a result exists for every transaction.
3450        if (it_result != package_result.m_tx_results.end()) {
3451            const auto& tx_result = it_result->second;
3452            switch (tx_result.m_result_type) {
3453                case MempoolAcceptResult::ResultType::VALID:
3454                {
3455                    ProcessValidTx(nodeid, tx, tx_result.m_replaced_transactions);
3456                    break;
3457                }
3458                case MempoolAcceptResult::ResultType::INVALID:
3459                case MempoolAcceptResult::ResultType::DIFFERENT_WITNESS:
3460                {
3461                    // Don't add to vExtraTxnForCompact, as these transactions should have already been
3462                    // added there when added to the orphanage or rejected for TX_RECONSIDERABLE.
3463                    // This should be updated if package submission is ever used for transactions
3464                    // that haven't already been validated before.
3465                    ProcessInvalidTx(nodeid, tx, tx_result.m_state, /*first_time_failure=*/false);
3466                    break;
3467                }
3468                case MempoolAcceptResult::ResultType::MEMPOOL_ENTRY:
3469                {
3470                    // AlreadyHaveTx() should be catching transactions that are already in mempool.
3471                    Assume(false);
3472                    break;
3473                }
3474            }
3475        }
3476        package_iter++;
3477        senders_iter++;
3478    }
3479}
3480
3481// NOTE: the orphan processing used to be uninterruptible and quadratic, which could allow a peer to stall the node for
3482// hours with specially crafted transactions. See https://bitcoincore.org/en/2024/07/03/disclose-orphan-dos.
3483bool PeerManagerImpl::ProcessOrphanTx(Peer& peer)
3484{
3485    AssertLockHeld(g_msgproc_mutex);
3486    LOCK2(::cs_main, m_tx_download_mutex);
3487
3488    while (CTransactionRef porphanTx = m_txdownloadman.GetTxToReconsider(peer.m_id)) {
3489        const MempoolAcceptResult result = m_chainman.ProcessTransaction(porphanTx);
3490        const TxValidationState& state = result.m_state;
3491        const Txid& orphanHash = porphanTx->GetHash();
3492        const Wtxid& orphan_wtxid = porphanTx->GetWitnessHash();
3493
3494        if (result.m_result_type == MempoolAcceptResult::ResultType::VALID) {
3495            LogDebug(BCLog::TXPACKAGES, "   accepted orphan tx %s (wtxid=%s)\n", orphanHash.ToString(), orphan_wtxid.ToString());
3496            ProcessValidTx(peer.m_id, porphanTx, result.m_replaced_transactions);
3497            return true;
3498        } else if (state.GetResult() != TxValidationResult::TX_MISSING_INPUTS) {
3499            LogDebug(BCLog::TXPACKAGES, "   invalid orphan tx %s (wtxid=%s) from peer=%d. %s\n",
3500                orphanHash.ToString(),