4
$\begingroup$

PBFT and most consensus algorithms are more complicated than a simple voting scheme. By simple voting I mean the following: we require all nodes to sign their local copy of the state and send this signed message to all other nodes. Each node then collects messages from all other nodes, and accepts the state if more than t < n nodes agree on the same state.

There are many ways to achieve the scheme above (e.g., each node individually signs, or using threshold signatures), which seems much simpler than other protocols such as PBFT (which among other things, requires designating a leader).

Therefore, I'm left to assume that voting can't directly produce a secure BFT protocol, but my question is - why is this the case? Where does consensus by voting break?

$\endgroup$
3
$\begingroup$

The purpose of a BFT is to achieve Byzantine Fault Tolerance rather than to be cryptographically secure. In fact, some BFT papers have no cryptography in them at all. You could devise a secure voting scheme but that doesn't automatically make it tolerant to byzantine failures.

Generally these algorithms seek to achieve liveness (eventual consistency of the data) and safety up to a certain number of faults, neither of these premises are present in your voting example. If you can guarantee through your protocol that even in the presence of a certain number of byzantine nodes (t < n) the protocol reaches consensus on a consistent state, then you have just created a BFT protocol.

$\endgroup$
1
$\begingroup$

Without a leader, who decides what to vote on? If everyone agrees on what is the question, then all is left is to sign the answer and count the votes. What pBFT achieves is sequencing the transactions - not only agreeing that the transactions occurred, but also on the order at which they occurred. Once the leader is known (and what ever he says next is the next transaction), still three rounds of voting are required to make sure everyone is inline with him. Actually two rounds are enough, but the third is needed to make sure the process ended before a new leader was elected.

$\endgroup$
0
$\begingroup$

The algorithm you describe is accurate and was essentially described in the original Byzantine Generals Problem paper as the SM protocol - signed messages. One of the assumptions in the SM protocol (and in fact the entire paper) is that messages must be delivered, in other words, if a node chooses not to answer, that is detectible. This is only possible in a synchronous network. Assuming the network is synchronous, it's possible for the system to correctly broadcast a command (Byzantine Broadcast) if there are only 2 honest nodes (that is the result from the paper). And for Byzantine Agreement to occur with N = 2f + 1. See these two papers.

https://eprint.iacr.org/2018/1028.pdf

https://pdfs.semanticscholar.org/38c8/30bf6192d9e83cf6793d01c54032b63bb8f8.pdf?_ga=2.146872127.901652623.1562362596-376969731.1562362596

The problem that the PBFT algorithm solves is consensus in a partially synchronous network, rather than a synchronous one. The basic intuition is that if 1/3 of the honest nodes are delayed, and 1/3 are malicious, the remaining 1/3 honest nodes can't figure out what the rest of the system is going to do since they can only hear from the 1/3 dishonest nodes, creating a 50/50 tie. That's why you need 1 extra honest node - hence 2/3 + 1.

PBFT Paper:

Excerpt from original PBFT Paper by Castro and Liskov

$\endgroup$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.