Catalog My learning Blog
Raft and Paxos Explained: Consensus, ZooKeeper and etcd · Phase 1 · Lesson 4 · 10 min read

Crash Faults vs Byzantine Faults

On this page
  1. Learning Objective
  2. Concept Explanation
  3. Worked Example: The Same Equivocation Attack Against CFT and BFT
  4. Real-World Examples
  5. Review Questions & Answers

Learning Objective

Distinguish the crash-fault and Byzantine-fault models, explain why Byzantine tolerance needs 3f plus 1 nodes rather than 2f plus 1, and justify why almost all internal infrastructure correctly chooses crash-fault tolerance while blockchains and some aerospace systems do not.

Concept Explanation

A fault model is a precise statement of how a component is permitted to misbehave, and it determines which algorithms are even applicable. The crash-fault model, also called fail-stop, says a faulty process simply stops: it halts, sends no further messages, and never sends anything incorrect. It may restart later and rejoin, but while faulty it is silent rather than deceptive. The Byzantine-fault model, named after Lamport, Shostak, and Pease's 1982 Byzantine Generals Problem paper, permits arbitrary behaviour: a faulty process may send contradictory messages to different peers, forge values, claim to have received things it did not, collude with other faulty processes, and do all of this while appearing perfectly healthy to any observer.

The gap between these models is enormous in cost. Crash-fault tolerance needs 2f plus 1 nodes to tolerate f faults, which is the majority quorum from the previous lesson. Byzantine fault tolerance needs 3f plus 1: tolerating one Byzantine node requires four nodes, tolerating two requires seven. The reason is worth understanding rather than memorising. With N equal to 3f plus 1, a quorum of 2f plus 1 is used, and any two such quorums intersect in at least f plus 1 nodes, which guarantees at least one honest node in the intersection even if all f faulty nodes are in it. Crash tolerance only needs any intersection at all, because a crashed node cannot lie about what it saw; Byzantine tolerance needs an intersection large enough to contain a truth-teller, because a faulty node in the intersection will simply say whatever is most damaging.

Byzantine protocols also pay heavily in message complexity and cryptography. Practical Byzantine Fault Tolerance, introduced by Castro and Liskov in 1999 and the first BFT protocol fast enough to be considered practical at all, uses a three-phase commit - pre-prepare, prepare, commit - with all-to-all broadcast in the prepare and commit phases, giving message complexity that grows with the square of the cluster size rather than linearly as in Raft. Every message must be authenticated, since the whole point is that a participant might forge one, so cryptographic signing or MACs sit on the critical path of every round. Modern designs like HotStuff, which underpins several blockchain systems, reduce this to linear message complexity per view by routing through a leader and using threshold signatures, but the cryptographic cost and the larger node count remain.

So which model do you actually have? For a cluster of machines you own, running software you deployed, inside a network you control, with mutual TLS between nodes, the honest answer is crash faults. The threats that make Byzantine tolerance necessary - a participant deliberately lying to gain advantage - are not present when every participant is your own process on your own hardware. If an attacker has compromised one of your etcd nodes deeply enough to make it send forged consensus messages, they almost certainly have credentials that let them attack the others too, and a BFT protocol would not save you. The realistic non-crash faults in a datacentre are things like silent disk corruption and memory bit flips, and those are addressed far more cheaply with checksums, ECC memory, and CRCs on the log than by tripling the node count.

Byzantine tolerance earns its cost in exactly two situations. The first is an open, permissionless system where participants are mutually distrusting and have direct financial incentive to cheat, which is the entire premise of public blockchains: Tendermint and HotStuff-derived protocols exist because in that setting a participant lying is the expected case rather than a remote possibility. The second is safety-critical systems where the fault mode genuinely includes arbitrary output rather than clean stopping, notably avionics: the Boeing 777 and 787 flight control systems and the SAFEbus standard use Byzantine-tolerant designs because a sensor or processor producing plausible-looking wrong values, rather than failing silently, is a real and studied failure mode with catastrophic consequences.

DimensionCrash-Fault Tolerant (CFT)Byzantine-Fault Tolerant (BFT)
Fault assumptionProcesses halt; they never send incorrect messagesProcesses may lie, forge, equivocate, and collude arbitrarily
Nodes needed for f faults2f + 1 (3 nodes tolerate 1)3f + 1 (4 nodes tolerate 1)
Message complexityLinear in cluster size per commitQuadratic for classic PBFT; linear per view for HotStuff-style designs
Cryptography on the hot pathOptional; TLS for transport is typically enoughRequired; every consensus message must be authenticated
Representative protocolsPaxos, Raft, ZAB, Viewstamped ReplicationPBFT, Tendermint, HotStuff, SBFT
Where it belongsInternal infrastructure: etcd, ZooKeeper, Consul, CockroachDB, TiKVPermissionless blockchains, mutually distrusting consortia, avionics

Worked Example: The Same Equivocation Attack Against CFT and BFT

The concrete difference between the models is best seen by running one specific misbehaviour - a node telling two different stories to two different peers - against each and watching what happens.

Code
# A node sends CONTRADICTORY messages to different peers (equivocation).
# This is the defining Byzantine behaviour: not silence, but inconsistency.

# --- Against a 3-node Raft cluster (CFT: assumes this cannot happen) ---
Nodes: A (compromised), B, C.  Quorum = 2.

A -> B : AppendEntries(term=5, index=10, value="x=1")
A -> C : AppendEntries(term=5, index=10, value="x=999")

B stores x=1  at index 10 and acknowledges.
C stores x=999 at index 10 and acknowledges.
A counts 2 acknowledgements, declares index 10 committed, and tells
clients the write succeeded.

# Result: B and C have permanently divergent state at the same log index
# and each believes it is correct. Raft's safety argument assumed A would
# never send two different values for one index. Once that assumption is
# violated, the algorithm offers no protection whatsoever - and this is
# not a Raft bug, it is Raft being used outside its stated fault model.

# --- Against a 4-node PBFT cluster (BFT: expects exactly this) ---
Nodes: A (compromised primary), B, C, D.  N=4, f=1, quorum = 2f+1 = 3.

A -> B : PRE-PREPARE(seq=10, "x=1")
A -> C : PRE-PREPARE(seq=10, "x=999")
A -> D : PRE-PREPARE(seq=10, "x=1")

# PBFT's PREPARE phase is all-to-all, so replicas compare notes directly
# rather than trusting the primary:
B -> C,D : PREPARE(seq=10, digest("x=1"))
C -> B,D : PREPARE(seq=10, digest("x=999"))
D -> B,C : PREPARE(seq=10, digest("x=1"))

# Each replica now needs 2f = 2 matching PREPAREs plus its own:
#   B sees its own + D's for digest("x=1")   -> prepared
#   D sees its own + B's for digest("x=1")   -> prepared
#   C sees only its own for digest("x=999")  -> NOT prepared
# C detects the conflict, cannot reach a prepared certificate, and
# triggers a VIEW CHANGE to replace the equivocating primary.
#
# Safety holds: no two honest replicas ever commit different values at
# seq=10. The cost of that guarantee is the extra node (4 not 3), the
# all-to-all round, and a signature on every message.
One equivocating node sending two different values to two peers, and what each fault model does about it: a crash-fault-tolerant cluster silently diverges because the behaviour is outside its assumptions, while a Byzantine-tolerant cluster cross-checks between replicas, detects the conflict, and replaces the faulty leader.
One equivocating node sending two different values to two peers, and what each fault model does about it: a crash-fault-tolerant cluster silently diverges because the behaviour is outside its assumptions, while a Byzantine-tolerant cluster cross-checks between replicas, detects the conflict, and replaces the faulty leader.

Real-World Examples

  • Every mainstream infrastructure consensus system - etcd, ZooKeeper, Consul, CockroachDB, TiKV, and Kafka's KRaft mode - is crash-fault tolerant only, and this is a deliberate, documented choice rather than an oversight. The operators of these systems own every node, authenticate peers with mutual TLS, and treat a node capable of forging consensus messages as a compromise that BFT would not meaningfully contain anyway, so they spend the node budget on more replicas and better durability instead of on tripling the cluster to defend against a threat model they do not face.
  • Public blockchain systems invert that calculus completely. Tendermint, used by the Cosmos network, and HotStuff-derived protocols such as the one built for Diem, are Byzantine fault tolerant because participants are anonymous, mutually distrusting, and directly financially motivated to cheat, making equivocation the expected behaviour rather than a remote possibility. Both accept the 3f plus 1 node requirement and per-message cryptographic authentication as the unavoidable price of operating without any trusted party.
Best PracticeChoose the fault model that matches your actual adversary. For nodes you own, inside a network you control, with authenticated peers, crash-fault tolerance is correct and Byzantine tolerance is a tripling of cost against a threat you do not have. Silent data corruption is a real non-crash fault in datacentres, but the right answer to it is checksums, CRCs on log entries, and ECC memory, not a BFT protocol.

Review Questions & Answers

Crash tolerance only needs any two quorums to intersect at all, because a crashed node cannot misreport what it saw, so a single shared node reliably carries forward the previous decision. Byzantine tolerance needs the intersection to be large enough to contain at least one honest node even in the worst case where all f faulty nodes are inside it. With N equal to 3f plus 1 and quorums of 2f plus 1, any two quorums intersect in at least f plus 1 nodes, guaranteeing at least one honest participant in the overlap whose account can be trusted. The extra f nodes exist purely to outnumber the liars in every intersection.

No. Byzantine tolerance defends against participants that deliberately lie, which requires an adversary who controls a node deeply enough to make it forge authenticated consensus messages. In this environment, an attacker with that level of access to one node has almost certainly obtained credentials and access paths that work against the others, so BFT would not contain the compromise it is supposedly defending against. The costs are concrete: at least seven nodes instead of five to tolerate two faults, cryptographic verification on every consensus message, and far more complex software. That budget is far better spent on more replicas, better backups, and checksums against silent corruption.

Raft offers no protection at all: a node that sends different values for the same log index to different followers can cause those followers to commit permanently divergent state while every node believes it behaved correctly. This is not a bug because Raft's published safety proof is explicitly conditional on the crash-fault model, in which processes halt rather than misbehave. An algorithm cannot be faulted for failing outside its stated assumptions; the design error, if any, belongs to whoever deployed a CFT protocol in a setting with a Byzantine adversary.

Technically it is a non-crash fault, since the node now holds and may serve incorrect data rather than having cleanly stopped, so it falls outside the strict crash-fault model. But the appropriate defence is not a BFT protocol, because the corruption is random rather than adversarial and is not coordinated with other failures. Checksums or CRCs on every log entry and snapshot detect it directly and cheaply, at which point the node can be failed deliberately and re-seeded from a healthy peer, converting an unmodelled fault into a modelled crash fault. ECC memory addresses the same class of problem in RAM. This is why real CFT implementations checksum aggressively despite claiming only crash-fault tolerance.

The difference is entirely about who runs the nodes and what they gain by cheating. A public blockchain admits anonymous, unvetted participants who profit directly from equivocating about transaction history, so lying is the expected behaviour and the protocol must remain safe when a minority does it. An internal service registry runs on nodes a single organisation owns, deploys, and authenticates, where a lying node indicates a full compromise that BFT does not solve. The fault model should be chosen from the actual adversary, not from a general preference for stronger guarantees, because each additional f of Byzantine tolerance costs three nodes rather than two plus cryptography on every message.