Simulating Practical Byzantine Fault Tolerance (PBFT) with Asyncio and Latency Analysis

A Coding Implementation to Simulate Practical Byzantine Fault Tolerance with Asyncio, Malicious Nodes, and Latency Analysis

The PBFT simulator models a distributed network with asynchronous message passing and configurable delays. It explicitly implements pre-prepare, prepare, and commit phases to achieve consensus while respecting the theoretical 3f+1 node bound.

Why This Matters

In distributed systems, theoretical guarantees like the 3f+1 bound often encounter real-world friction from network latency and non-deterministic message delivery. This simulation demonstrates that once Byzantine nodes exceed the tolerated threshold, the system’s safety and liveness break down, highlighting the critical importance of quorum thresholds in modern blockchain and trust systems.

Key Insights

• PBFT requires a minimum of 3f+1 nodes to tolerate f malicious actors, ensuring consensus safety through multi-phase voting.
• Asynchronous network modeling in the simulator uses random delays (5ms to 40ms) to mimic real-world congestion and reordering.
• The consensus process relies on three distinct phases: Pre-prepare (primary proposal), Prepare (quorum verification), and Commit (finalization).
• Byzantine nodes can perform equivocation by sending conflicting digests to different peers, a behavior modeled to test system robustness.
• Latency analysis reveals that consensus time increases and success rates drop sharply as the number of malicious nodes approaches the 1/3 threshold.

Working Examples

Core PBFT message structures and asynchronous network layer implementation.

import asyncio\nimport random\nimport time\nimport hashlib\nfrom dataclasses import dataclass, field\nfrom typing import Dict, Set, Tuple, Optional, List\n\nPREPREPARE = "PREPREPARE"\nPREPARE = "PREPARE"\nCOMMIT = "COMMIT"\n\n@dataclass(frozen=True)\nclass Msg:\n    typ: str\n    view: int\n    seq: int\n    digest: str\n    sender: int\n\nclass Network:\n    def __init__(self, cfg: NetConfig):\n        self.cfg = cfg\n        self.nodes: Dict[int, "Node"] = {}\n    async def send(self, dst: int, msg: Msg):\n        if random.random() < self.cfg.drop_prob: return\n        d = random.uniform(self.cfg.min_delay_ms, self.cfg.max_delay_ms) / 1000.0\n        await asyncio.sleep(d)\n        await self.nodes[dst].inbox.put(msg)\n    async def broadcast(self, src: int, msg: Msg):\n        tasks = [asyncio.create_task(self.send(nid, msg)) for nid in self.nodes.keys()]\n        await asyncio.gather(*tasks)

Practical Applications

• Blockchain Protocol Design: Testing leader rotation and view changes under adversarial pressure; failure to account for network partitions often leads to liveness failure.
• Distributed Trust Systems: Implementing authenticated messaging to prevent node impersonation; neglecting digest validation allows malicious nodes to inject forged transactions.

References:

• https://www.marktechpost.com/2026/02/24/a-coding-implementation-to-simulate-practical-byzantine-fault-tolerance-with-asyncio-malicious-nodes-and-latency-analysis/