# Blockchain Communication Vulnerabilities

Crypto.world

> Prior blockchain attack studies are usually custom-built for one protocol, so nobody has compared how different blockchains' communication layers hold up under the same adversarial conditions.

**arXiv**: 2603.02661

**Published**: 2026-03-03

**Authors**: Andrei Lebedev, Vincent Gramoli

## AI summary

## Overview

**Research area:** Blockchain security, specifically the peer-to-peer communication protocols that nodes use to disseminate transactions, blocks and consensus messages.

**Technical level:** Intermediate. Readers need some familiarity with consensus, gossip/overlay topologies and transport protocols (TCP vs QUIC), but the paper's argument is empirical rather than mathematical.

**Scope (one sentence):** The paper empirically compares how five in-production blockchains (Algorand, Aptos, Avalanche, Redbelly and Solana) behave under five protocol-agnostic network attacks, using a common 25-VM testbed and a common 200 TPS workload.

## What This Paper Is About

Prior blockchain attack studies are usually custom-built for one protocol, so nobody has compared how different blockchains' communication layers hold up under the same adversarial conditions. The authors take five modern blockchains — chosen because they claim to tolerate partial synchrony or message delays, unlike Bitcoin and Ethereum — and subject each to the same five attacks: targeted load, transient failure, packet loss, stopping, and leader isolation. The goal is to identify which specific communication design choices (transport protocol, topology, throttling, leader selection) create which specific vulnerabilities.

## Key Contributions

1. **A protocol-agnostic attack suite.** Five attacks derived from previously blockchain-specific literature, applied uniformly to any blockchain: targeted load (inspired by DoS attacks), transient failure (inspired by churn), packet loss (inspired by balance attacks), stopping (inspired by majority attacks) and leader isolation (inspired by eclipse attacks).
2. **A fair, side-by-side empirical comparison.** A single testbed configuration — 25 Ubuntu 24.04.1 LTS VMs on a Proxmox cluster with 4 vCPUs and 8 GB memory each, 5 benchmark nodes plus 20 blockchain nodes, up to 20 clients, and the open-source Diablo benchmark — used identically for Algorand v3.27.0, Aptos v1.25.1, Avalanche C-Chain v1.12.1, Redbelly v0.36.2 and Solana Agave v2.0.20.
3. **Attack-injection and measurement tooling.** A `tc`/`netem`-based transient packet-loss injector, an `inotify`-based log monitor that detects leader transitions and automatically applies packet loss (e.g. 75%) only while a node is leader, and an `iptables`-based per-peer bandwidth accounting system.
4. **A vulnerability matrix (Table 1)** mapping each blockchain's fault-tolerance threshold (Algorand n/5, Aptos n/3, Avalanche n/5, Redbelly n/3, Solana n/3) and communication type (gossip, hierarchical, throttled, rate limited, hierarchical) to the attacks it fails under, with responsible disclosure made to all five teams; Anza confirmed that Solana experiences vulnerabilities.

## Main Findings

- **Aptos is vulnerable to targeted load attacks.** With a single client sending 200 TPS to one node, Aptos needed 4 minutes and 15 seconds to commit all transactions, versus under 3 seconds for Avalanche (base fee disabled) and Redbelly, 10 seconds for Algorand and 27 seconds for Solana; Aptos's median (p50) latency exceeded 2 minutes and 30 seconds. The node under attack generated 25.7% of total outgoing traffic, and only that node logged the `ProofOfStoreInit`/`ProofOfStoreReady` events of the `ProofCoordinator` module.
- **Aptos's bottleneck comes from Quorum Store.** Removing the leader bottleneck creates a validator bottleneck: one node must process all transactions, form all batches, send them to all validators and collect ⌊2n/3⌋+1 signatures per batch. Logs showed the receiving node alone initiated and finalised the proof-of-store process.
- **Spreading the load does not fix Aptos.** Latency was lowest (median 2.27 seconds) when 30% of validators received traffic, but Aptos loses transactions when load is balanced across 60% to 100% of validators; with clients sending to all nodes only 50% of submitted transactions were committed, and with 70% of nodes loaded 90% were committed. The authors conjecture this is due to per-node signature verification cost at one extreme and a quadratic, Ω(n²) total signature count when many nodes each build distinct batches.
- **Avalanche is vulnerable to transient failure attacks, amplified by throttling.** Crashing 10% of nodes from 133s to 266s caused Avalanche to permanently lose approximately 60% of transactions (only 40% committed), even long after recovery. Repeating the experiment with throttling disabled let Avalanche commit 100% of transactions. The cause is unproductive traffic to failed proposers being misread by throttling as malicious overload, after which throttling suppresses legitimate traffic.
- **Avalanche degrades as failures increase.** With 2 failures only 36% of transactions were committed, and with 5 failures only 22%. Roughly 26,600 transactions could be submitted during the attack window (200 TPS × 133 s) while Avalanche's transaction pool holds only 6,144 transactions, so rejections cascade into higher-nonce rejections with `ErrUnderpriced`. At 30% transient failures throughput drops sharply and does not recover after restart.
- **Aptos is more resilient than Avalanche to transient failures but still lossy.** Under a harsher 35% failure scenario (133s to 266s) Aptos eventually committed 89% of transactions, losing 11%, and required over 600 seconds to process the workload. Algorand and Redbelly showed no observed impact.
- **TCP-based blockchains collapse under packet loss; Solana does not.** From the bandwidth table, during a 50% packet loss attack average peer TX rate fell 95.5% for Algorand (1,480 to 67 KiB/s), 95.6% for Redbelly (547 to 24 KiB/s), 84.2% for Avalanche (152 to 24 KiB/s) and 83.8% for Aptos (112 to 18 KiB/s), while Solana stayed at 840 KiB/s (0.0% change) with RX falling 31.8% (872 to 595 KiB/s).
- **Algorand is specifically vulnerable to packet loss.** Even 25% loss causes significant p90/p99 latency rises. The authors cite three causes: a broadcast queue that fills and drops messages (`HTTP 400: "message":"broadcast queue full"`), a need for an additional 99 seconds to resume transaction processing after connectivity is restored, and a `TxSyncer` Bloom filter whose false positives can leave transactions unrequested ("stuck").
- **Avalanche latency data disappears at high loss.** At 50% and 75% packet loss, p50, p90 and p99 values are missing for Avalanche; Aptos and Redbelly also show sharp latency increases at these levels.
- **Solana's packet-loss resilience is multi-layered:** QUIC instead of TCP (avoiding head-of-line blocking), Turbine block propagation with erasure coding into "shreds", and stake-weighted QoS.
- **Solana is vulnerable to stopping attacks.** If sufficiently many nodes experience a transient outage, the system can get stuck even after those nodes recover; large-scale attacks cause Solana to halt indefinitely, while Avalanche enters a near-halt state. Solana also depends on 30 subsequent blocks (at least 12.4 s) for commitment and uses a lockout period that doubles with each successive vote on the same branch, which can stall liveness.
- **Aptos and Solana are vulnerable to leader isolation.** Aptos's reputation-based leader selection and Solana's leader schedule are deterministic, letting an attacker predict and target successive leaders; targeting one node translates into a global slowdown.
- **Avalanche has a load-induced fee vulnerability.** The 200 TPS rate triggered base-fee escalation in Avalanche's dynamic fee mechanism until transaction processing halted; the authors disabled fee escalation in the genesis configuration for all Avalanche experiments to isolate the communication protocol.

## Methodology in Plain English

The researchers built one small but realistic network — 25 virtual machines on a Proxmox cluster, each with 4 vCPUs and 8 GB RAM, deliberately below what some of these projects recommend so that all five chains run under identical hardware — and deployed each blockchain on it in turn, alongside the Diablo benchmark, which acts as an independent client per node. Every experiment ran a steady 200 transactions per second of native transfers, a rate chosen because Avalanche's measured capacity is 357 TPS (2-second block period, 15M gas limit).

They then played the role of an adversary in five ways. For targeted load, one client hammers one node. For transient failure, they crash a percentage of nodes at 133 seconds and restart them at 266 seconds. For packet loss, they use Linux `tc`/`netem` to drop 25% to 75% of packets between a group of ⌊f+1⌋ nodes and the rest of the network, disabling hardware offloads first and re-enabling them afterwards so the effect is temporary. For leader isolation, a log-watching daemon detects when a node becomes leader and automatically applies 75% packet loss until it stops being leader. For stopping attacks, they crash a large fraction of the network.

To see *why* things break, they measured more than throughput: per-peer transmit and receive rates via `iptables` accounting chains, traffic share per node, and node logs (e.g. which node ran the proof-of-store process). They report median (p50) latency with p90/p99 shaded bands.

## Why This Matters

**Impact on research.** The paper moves blockchain security evaluation from bespoke, one-off attacks toward a shared, open-source, cross-protocol benchmark. Its most transferable insight is that a defence mechanism (Avalanche's throttling) can itself be the amplifier of a failure, and that the transport protocol choice (TCP vs QUIC plus erasure coding) predicts packet-loss tolerance more strongly than the consensus algorithm does. It also reframes "leader bottleneck" work such as Aptos's Quorum Store as relocating a bottleneck rather than removing one.

**Real-world applications (as the paper frames them):**

- Validator operators and node operators deciding how much hardware headroom and what network configuration to provision, given that a single overloaded or isolated node can degrade a whole chain.
- Protocol teams designing rate limiting and throttling, who must distinguish "failed peer" traffic from genuine attack traffic before suppressing queues.
- Leader-selection designers in leader-based chains, who need unpredictability to prevent single-node targeting.
- Mempool and nonce-management designers, since a small pool (Avalanche's 6,144 transactions) turns brief outages into permanent transaction loss.

**Industry relevance.** All five projects were notified before publication, and Anza confirmed that Solana experiences vulnerabilities — meaning the findings feed directly into production engineering. The disclosure process also covers Ava Labs, Aptos, Algorand and Redbelly.

## Future Directions

- **Throttling that survives failures.** Avalanche recovered fully with throttling disabled, so the open question is how to rate-limit without mistaking traffic to crashed peers for an attack — for example by weighting or discounting samples directed at unresponsive nodes.
- **Nonce- and mempool-aware recovery.** Avalanche's cascade of `ErrUnderpriced` rejections when its 6,144-transaction pool fills suggests a need for admission policies that do not permanently discard transactions during transient outages.
- **Unpredictable leader selection.** Since Aptos and Solana were both isolated by predicting leaders, randomised or VRF-style scheduling (as Algorand already uses) is the obvious line of defence to evaluate.
- **Generalising beyond 25 VMs.** The comparison used a small network on a single Proxmox cluster; whether the rankings hold on wide-area, geographically distributed deployments with realistic latency, and for other chains, is not reported and remains open. The paper's later sections on leader isolation (Section 8), the two critical issues in Avalanche and Solana and their countermeasures (Section 9), and its formal conclusions (Section 11) are outside the truncated content provided here.

## Target Audience

Protocol and core engineers working on consensus or networking layers; security researchers who need a reusable adversarial test harness; validators and infrastructure operators sizing hardware and network paths; and graduate students or advanced undergraduates studying distributed systems who want a concrete, empirical picture of why synchrony assumptions and transport choices matter in deployed blockchains. Readers looking for formal proofs or cryptographic analysis will not find them here — the contribution is measurement.

## Authors’ abstract

Blockchains are diverse in the way they handle communications between their nodes to disseminate information, mitigate attacks, and agree on the next block. While security vulnerabilities have been identified, they rely on an attack custom-made for a specific blockchain communication protocol. To our knowledge, the vulnerabilities of multiple blockchain communication protocols to adversarial conditions have never been compared. In this paper, we compare empirically the…

[The full abstract on arXiv](https://arxiv.org/abs/2603.02661)

[Read the original paper](https://arxiv.org/abs/2603.02661)

---

Canonical: https://crypto.world/paper/blockchain-communication-vulnerabilities-2603.02661
