Byzantine Consensus under Local Broadcast Model: Tight Sufficient Condition

01/12/2019 ∙ by Muhammad Samir Khan, et al. ∙ Georgetown University University of Illinois at Urbana-Champaign 0

In this work we consider Byzantine Consensus on undirected communication graphs under the local broadcast model. In the classical point-to-point communication model the messages exchanged between two nodes u, v on an edge uv of G are private. This allows a faulty node to send conflicting information to its different neighbours, a property called equivocation. In contrast, in the local broadcast communication model considered here, a message sent by node u is received identically by all of its neighbours. This restriction to broadcast messages provides non-equivocation even for faulty nodes. In prior results NaqviMaster, NaqviBroadcast it was shown that in the local broadcast model the communication graph must be (3f/2+1)-connected and have degree at least 2f to achieve Byzantine Consensus. In this work we show that this network condition is tight.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

In this work we consider Byzantine Consensus on undirected communication graphs under the local broadcast model. nodes with binary input communicate with their neighbours in the communication graph via message passing to reach consensus on a binary output. In addition, up to nodes are byzantine faulty where they may exhibit arbitrary behaviour. Non-faulty nodes must achieve consensus in finite time and must agree on an input of some non-faulty node.

In the classical point-to-point communication model the messages exchanged between two nodes on an edge of are private. This allows a faulty node to send conflicting information to its different neighbours, a property called equivocation. In contrast, in the local broadcast communication model considered here, a message sent by node is received identically by all of its neighbours. This restriction to broadcast messages provides non-equivocation even for faulty nodes. This communication model is motivated by wireless broadcast networks where messages sent by an entity are received identically by those in its vicinity.

For point-to-point communication model in undirected graphs a -connectivity and are together necessary and sufficient [3, 4]. In contrast, prior work [10, 11] has established that for local broadcast a -connectivity and a minimum degree of is necessary. It was also shown [10, 11] that -connectivity is sufficient with local broadcast. In this work we close this gap by presenting an algorithm for undirected graphs with -connectivity and minimum degree of .

The rest of the paper is organized as follows. In Section 2 we discuss related work. Section 3 formalizes the system model and introduces notation for the setting. We present our main result in Section 4.

2 Related Work

The Byzantine Consensus problem was introduced by Lamport, Shostak, and Pease [8, 13] who proved that is a tight condition for complete graphs. Subsequent work [3, 4] identified necessary and sufficient conditions for arbitrary undirected graphs. For undirected graphs it is well known that reliable communication between nodes is both necessary and sufficient for consensus. For directed graphs Tseng and Vaidya [18] gave necessary and sufficient conditions where reliable communication between all nodes is not provided. All of these works considered point-to-point communication links.

Prior work [1, 7, 12, 14, 17] has looked at the local broadcast model. However, they were interested in achieving Byzantine Broadcast as opposed to Byzantine Consensus, the aim of this paper. In contrast with the point-to-point communication, the network requirements are different for the two problems with local broadcast. Zhang and Sundaram [20] gave necessary and sufficient conditions for approximate real valued Byzantine Consensus using an iterative algorithm with local broadcast. In this work we look at exact binary valued consensus.

The ability of faulty nodes to send conflicting information to its different neighbours is called “equivocation” in the literature. Many works have looked at the effects of restricting equivocation for faulty nodes. Rabin and Ben-Or [15] considered a global broadcast model, which is the same as our model on complete graphs, and showed that is both sufficient and necessary for any multiparty protocol using synchronous communication. Clement et. al. [2] looked at non-equivocation in complete graphs for asynchronous communication. Different works [5, 6, 9, 16] investigate the impact of limiting equivocation via partial broadcast channels modeled as broadcast over hyperedges.

3 System Model and Notation

We consider nodes in an undirected communication graph . Two nodes and are neighbors if is an edge of . The degree of a node is the number of ’s neighbors or, equivalently, the number of edges incident to . Every node knows the topology of the communication graph . The communication in the network is synchronous, allowing nodes to make progress in synchronous rounds. We consider a local broadcast model of communication where a message sent by is received identically and correctly by all neighbors of . In contrast, the classical point-to-point model allows a node to target a specific neighbor for each message sent. This allows a bad node to possibly sent conflicting information to its different neighbors. We also assume that when a node receives a message, it can correctly determine the neighbor that transmitted the message.

We consider the Byzantine model of faults where a faulty node can exhibit arbitrary behavior, including an adversary with complete knowledge of the current system state to coordinate actions among all faulty nodes. A maximum of nodes in can be faulty. In the Byzantine Consensus Problem, each node has a binary input and the goal is for each node to output a binary value, satisfying the following conditions, in the presence of at most faulty nodes.

  1. [label=0),topsep=0pt,labelindent=0pt]

  2. Agreement: All non-faulty nodes must output the same value.

  3. Validity: The output of each non-faulty node must be an input of some non-faulty node.

  4. Termination: All non-faulty nodes must decide on their output in finite time.

For two nodes and , a -path is a path from to . is the source node of and is the terminal node of . Every other node in is an internal node of . -paths are node disjoint if they do not have any common internal nodes. For a set and node , a -path is a -path for some node . -paths are node disjoint if they do not have any common source or internal nodes. A -path or a -path is said to exclude a set of nodes if no internal node of the path belongs to . Note that the source and terminal nodes can still be from . A -path or a -path is fault-free if it does not have any faulty internal node, i.e. excludes the set of faulty nodes. Note that we allow a fault-free path to have a faulty source and/or terminal node.

A graph is -connected if and removal of any nodes does not disconnect . By Menger’s Theorem [19] a graph is -connected if and only if for any two nodes there exist node disjoint -paths. Another standard result [19] for -connected graphs is that if is -connected, then for any node and a set of at least nodes there exist node disjoint -paths.

4 Our Result

Our main result is that if is -connected and each node has degree at least , then this is sufficient for Byzantine Consensus under the local broadcast model.

Theorem 4.1.

Under the local broadcast model, Byzantine Consensus with at most faults is achievable if is -connected and every node in has degree at least .

In contrast the point-to-point communication model requires that must be -connected and must have at least nodes [3, 4]. Prior work [10, 11] has identified the graph condition in Theorem 4.1 to be necessary under local broadcast, so the result in this paper implies that the condition is tight. We prove Theorem 4.1 constructively by providing an algorithm that solves Byzantine Consensus under these assumptions and an accompanying proof of correctness.

4.1 Algorithm

In this section we describe an algorithm to solve consensus on a graph such that it is -connected and each node has degree at least . Every communication in the algorithm is a message where is a label, is a binary valued message body, and is a path where the source node indicates the node where the message originated and the remaining nodes indicate how the message has travelled so far.

A node communicates with the rest of the graph via “flooding” where sends a message to the entire network with a unique label corresponding to each iteration of flooding. When a node receives a message from one of its neighbors such that , then forwards to its neighbors, if does not contain nodes already. Since communication is synchronous, can wait for synchronous rounds to ensure that the message has propagated to the entire network. If a faulty node chooses to stay silent when a message is expected, then the non-faulty neighbors of replace silence with a default message so that we can assume that a message is always sent when expected, even though it may be tampered. Similarly if a faulty node sends a message with a label when a label is expected, then the non-faulty neighbors of replace the label in the message with when forwarding the message. If a faulty node sends a message of the form where path does not exist, then its non-faulty neighbors ignore it, so that we can assume that messages are always sent along actual paths that exist. To achieve this, all nodes know the topology of the graph .

In the local broadcast model we can ensure that even a faulty node can only flood a single value with any given label, which is in contrast with the point-to-point communication model where a faulty node can send different conflicting values to its neighbors. If a faulty node attempts to flood two different values with a given label, then its non-faulty neighbors simply chose to forward first such value, ignoring the rest. In general, for any label and path , a non-faulty node will forward only the first message of the form it receives from a neighbor , ignoring the rest.

Each node has binary input and maintains a binary state .
Initially, .
For every candidate faulty set such that  do
  1. [label=Step (),topsep=0pt,labelindent=12pt,leftmargin=!]

  2.  

    Flood with label . In the remaining steps of the iteration, values received

with label are considered implicitly.
  • For each node , identify a single -path that excludes . Set

  •  

    Define and as follows.

    1. [label=Case 0:,topsep=0pt,labelindent=0pt]

    2. and . Set and .

    3. and . Set and .

    4. and . Set and .

    5. and . Set and .

    If , then stays unchanged. If , then identify node disjoint -paths that exclude . If received identically (resp. ) along these

  •        paths in step (a), then set to be (resp. ); otherwise stays unchanged.
    end
    Output .
    Algorithm 1 Algorithm for Byzantine Consensus under local broadcast model. All steps are performed by a node .

    The formal procedure is presented as Algorithm 1 and we give a formal proof of correctness in Section 4.2. The algorithm is inspired by the Byzantine Consensus algorithm for directed graphs by Tseng and Vaidya [18]. Here we describe the algorithm informally. Each node starts with a binary input and maintains a binary state which is initially set to its input. The algorithm has one loop and in each iteration we select a set such that . We call the candidate faulty set of the iteration. As a first step, each node floods its state . Note that this requires to 1) locally broadcast to its neighbors and 2) assist other nodes to flood their states by forwarding messages received from its neighbors, as described earlier.

    Let be the set of nodes that flooded in the first step and let be the set of nodes that flooded . Note that and partition the node set . In step (b), each non-faulty node

    finds its own estimate

    and of and respectively, using as the candidate faulty set. This is done by selecting, for each node , a single path that excludes . Such a path must exist since is -connected. Observe that if , then is the single node path consisting of exactly . If receives along , then puts in and if receives along this path, then puts in . Note that if there exists a faulty node in , then and may not be the same as and . It is also possible that, for a node , and . However, and partition the node set .

    In step (c), using as the candidate faulty set, either nodes in change their state to or nodes in change their state to . Since each non-faulty node ’s estimates and may vary when faulty nodes exist in , non-faulty nodes may disagree on which nodes must retain their state and which nodes must switch. The four cases in Algorithm 1 step (c) select sets and so that, from ’s perspective, nodes in retain their state and nodes in switch. and are selected so that each node in has at least node disjoint -paths excluding (Lemma 4.4). This ensures that 1) when contains faulty nodes, then non-faulty nodes do not switch to a state of a faulty node (Lemma 4.5) and 2) when contains all the faulty nodes, then non-faulty nodes in do switch their states correctly to achieve agreement (Lemma 4.6).

    At the end, each node outputs its state as its decision.

    4.2 Proof of Correctness

    We assume in the proof. Theorem 4.1 is trivially true for . At a high level, our objective is two folds. Firstly, we want to show that regardless of the choice of the candidate faulty set , a non-faulty node will only change its state in step (c) of the iteration to match a state of some non-faulty node at the beginning of the iteration (Lemma 4.5). By a simple induction, it follows that the final state of is an input of some non-faulty node. Secondly, we want to show that when contains the actual set of faulty nodes in a given execution, then all non-faulty nodes reach agreement in that iteration (Lemma 4.6). Since all non-faulty nodes now have the same state, by Lemma 4.5 it follows that in the future iterations all non-faulty nodes will maintain this state.

    We start by observing that if a message is received along a fault-free path, then the exact same message was indeed sent. Recall that even a faulty node can only flood a single value in step (a) of the algorithm.

    Observation 4.2.

    For any iteration of the loop in Algorithm 1, in step (a) for any two nodes (possibly faulty), receives along a fault-free -path if and only if flooded .

    A priori, it is not clear if the paths identified in the algorithm always exist. For paths in step (b) the existence is relatively straightforward to prove.

    Lemma 4.3.

    For any two nodes and any iteration of the loop in Algorithm 1 with a candidate faulty set , there exists a -path that excludes .

    Proof:   Let . Since and is -connected, we have that is a connected graph and so there exists a -path in which is a -path in that excludes .

    The next lemma shows that the choice of sets and ensures that paths in step (c) also exist.

    Lemma 4.4.

    For any non-faulty node and any iteration of the loop in Algorithm 1 with a candidate faulty set , in step (c) if , then there exist node disjoint -paths that exclude .

    Proof:   Fix an iteration in the algorithm and the candidate faulty set . Consider an arbitrary non-faulty node such that in step (c). There are 4 cases to consider, corresponding to the 4 cases in step (c).

    1. [label=Case 0:,topsep=0pt,labelindent=0pt]

    2. and . Then and . Therefore there exist at least nodes in . Node selects nodes from by choosing all nodes from and the rest arbitrarily from . By choice of , we have that has at most nodes. Since is -connected, so there exist node disjoint -paths in that exclude . Furthermore, since all the nodes in are the source nodes in these paths and , we have that these paths exclude 111recall that a path that excludes does not have nodes from as internal nodes; however, nodes from may be the source or terminal nodes..

    3. and . Then and . Since the degree of is at least and there are at most nodes in (including ), we have that has at least neighbors in . There are therefore node disjoint -paths that have no internal nodes and hence exclude .

    4. and . Then and . We have that

      So this case is the same as Case 1 with the roles of and swapped.

    5. and . Then and . From the analysis in Case 3, we have that . So this case is the same as Case 2 with the roles of and swapped.

    In all four cases we have that there do exist node disjoint -paths that exclude .

    We now show that in any iteration, the state of a non-faulty node at the end of the iteration equals the state of some non-faulty node at the beginning of the iteration.

    Lemma 4.5.

    For any non-faulty node and any iteration of the loop in Algorithm 1, the state of at the end of the iteration is equal to a state of some non-faulty node at the beginning of the iteration.

    Proof:   Fix an iteration in the algorithm and the candidate faulty set . For any node , we denote the state at the beginning of the iteration by and the state at the end of the iteration by . Consider an arbitrary non-faulty node and the sets and in step (c). Let be the node disjoint -paths identified by in step (c). If , then the claim is trivially true. So suppose and receives identical values along in step (a). Since the number of faulty nodes is at most , thus at least one of these paths is both fault-free and has a non-faulty source node, say . By Observation 4.2, it follows that whatever value is received by along this path in step (a) is the value flooded by . Therefore , where is a non-faulty node, as required.

    Next, we show that when the candidate faulty set is properly selected, all non-faulty nodes reach agreement in that iteration.

    Lemma 4.6.

    Consider an iteration of the loop in Algorithm 1 such that all faulty nodes are contained in the candidate faulty set . Then for any two non-faulty nodes , we have that and have the same state at the end of the iteration.

    Proof:   Fix an iteration of the algorithm and the candidate faulty set such that all faulty nodes are contained in . Let be the set of nodes that flooded in step (a) of the iteration and let be the set of nodes that flooded in step (a). We first show that for any non-faulty node , and . Consider an arbitrary node that flooded (resp. ) in step (a) of the iteration so that (resp. ). Observe that identified in step (b) of the iteration excludes and is fault-free. Therefore, by Observation 4.2 receives (resp. ) along and correctly sets (resp. ), as required.

    It follows that for any two non-faulty nodes and , we have that and . Thus and . Let and . Now all nodes in flooded identical value in step (a), say . If , then ’s state is at the beginning of the iteration and stays unchanged in step (c). Therefore, at the end of the iteration . If , then observe that the node disjoint -paths identified by in step (c) are all fault-free. By Observation 4.2, it follows that receives identically along these paths and so, at the end of the iteration, . Similarly for , we have that , as required.

    We now have all the necessary ingredients to prove Theorem 4.1.

    Proof of Theorem 4.1:   The algorithm terminates in finite time at every node. This satisfies the termination property. Validity follows from Lemma 4.5 via a simple induction. For agreement, observe that there exists at least one iteration of the loop in Algorithm 1 where all faulty nodes are contained in the candidate faulty set , namely when is exactly the set of faulty nodes. From Lemma 4.6 we have that all non-faulty nodes have the same state at the end of this iteration. From Lemma 4.5, it follows that non-faulty nodes do not change their states in subsequent iterations. Therefore, all non-faulty nodes output the same state at the end of the algorithm.

    5 Discussion

    In this work, we have presented a constructive proof that it is sufficient for the communication graph to be -connected and have degree at least for Byzantine Consensus under local broadcast. The results in this paper along with prior results in [10, 11] show that the condition that must be -connected and have degree at least is tight. The algorithm provided in this paper is not polynomial. In [10, 11] we gave an efficient algorithm when is -connected. We leave finding an efficient algorithm for the tight condition for future work.

    References

    • [1] V. Bhandari and N. H. Vaidya. On reliable broadcast in a radio network. In Proceedings of the Twenty-fourth Annual ACM Symposium on Principles of Distributed Computing, PODC ’05, pages 138–147, New York, NY, USA, 2005. ACM.
    • [2] A. Clement, F. Junqueira, A. Kate, and R. Rodrigues. On the (limited) power of non-equivocation. In Proceedings of the 2012 ACM Symposium on Principles of Distributed Computing, PODC ’12, pages 301–308, New York, NY, USA, 2012. ACM.
    • [3] D. Dolev. The byzantine generals strike again. Journal of Algorithms, 3(1):14 – 30, 1982.
    • [4] M. J. Fischer, N. A. Lynch, and M. Merritt. Easy impossibility proofs for distributed consensus problems. Distributed Computing, 1(1):26–39, Mar 1986.
    • [5] M. Fitzi and U. Maurer. From partial consistency to global broadcast. In

      Proceedings of the Thirty-second Annual ACM Symposium on Theory of Computing

      , STOC ’00, pages 494–503, New York, NY, USA, 2000. ACM.
    • [6] A. Jaffe, T. Moscibroda, and S. Sen. On the price of equivocation in byzantine agreement. In Proceedings of the 2012 ACM Symposium on Principles of Distributed Computing, PODC ’12, pages 309–318, New York, NY, USA, 2012. ACM.
    • [7] C.-Y. Koo, V. Bhandari, J. Katz, and N. H. Vaidya. Reliable broadcast in radio networks: The bounded collision case. In Proceedings of the Twenty-fifth Annual ACM Symposium on Principles of Distributed Computing, PODC ’06, pages 258–264, New York, NY, USA, 2006. ACM.
    • [8] L. Lamport, R. Shostak, and M. Pease. The byzantine generals problem. ACM Trans. Program. Lang. Syst., 4(3):382–401, July 1982.
    • [9] C. Li, M. Hurfin, Y. Wang, and L. Yu. Towards a restrained use of non-equivocation for achieving iterative approximate byzantine consensus. In 2016 IEEE International Parallel and Distributed Processing Symposium (IPDPS), pages 710–719, May 2016.
    • [10] S. S. Naqvi. Exact Byzantine consensus under local-broadcast channels (Advisor: Nitin Vaidya). Master’s thesis, University of Illinois at Urbana-Champaign, 2018.
    • [11] S. S. Naqvi, M. S. Khan, and N. H. Vaidya. Exact byzantine consensus under local-broadcast model. CoRR, abs/1811.08535, 2018.
    • [12] A. Pagourtzis, G. Panagiotakos, and D. Sakavalas. Reliable broadcast with respect to topology knowledge. Distributed Computing, 30(2):87–102, Apr 2017.
    • [13] M. Pease, R. Shostak, and L. Lamport. Reaching agreement in the presence of faults. J. ACM, 27(2):228–234, Apr. 1980.
    • [14] A. Pelc and D. Peleg. Broadcasting with locally bounded byzantine faults. Inf. Process. Lett., 93(3):109–115, Feb. 2005.
    • [15] T. Rabin and M. Ben-Or. Verifiable secret sharing and multiparty protocols with honest majority. In Proceedings of the Twenty-first Annual ACM Symposium on Theory of Computing, STOC ’89, pages 73–85, New York, NY, USA, 1989. ACM.
    • [16] D. V. S. Ravikant, V. Muthuramakrishnan, V. Srikanth, K. Srinathan, and C. P. Rangan. On byzantine agreement over (2,3)-uniform hypergraphs. In R. Guerraoui, editor, Distributed Computing, pages 450–464, Berlin, Heidelberg, 2004. Springer Berlin Heidelberg.
    • [17] L. Tseng, N. Vaidya, and V. Bhandari. Broadcast using certified propagation algorithm in presence of byzantine faults. Information Processing Letters, 115(4):512 – 514, 2015.
    • [18] L. Tseng and N. H. Vaidya. Exact byzantine consensus in directed graphs. CoRR, abs/1208.5075, 2012.
    • [19] D. B. West et al. Introduction to graph theory, volume 2. Prentice hall, 2001.
    • [20] H. Zhang and S. Sundaram. Robustness of information diffusion algorithms to locally bounded adversaries. In 2012 American Control Conference (ACC), pages 5855–5861, June 2012.