Ezra N. Hoch

Fast self-stabilizing byzantine tolerant digital clock synchronization

Consider a distributed network in which up to a third of the nodes may be Byzantine, and in which the non-faulty nodes may be subject to transient faults that alter their memory in an arbitrary fashion. Within the context of this model, we are interested in the digital clock synchronization problem; which consists of agreeing on bounded integer counters, and increasing these counters regularly. It has been postulated in the past that synchronization cannot be solved in a Byzantine tolerant and self-stabilizing manner. The first solution to this problem had an expected exponential convergence time. Later, a deterministic solution was published with linear convergence time, which is optimal for deterministic solutions. In the current paper we achieve an expected constant convergence time. We thus obtain the optimal probabilistic solution, both in terms of convergence time and in terms of resilience to Byzantine adversaries.

Self-stabilizing and Byzantine-tolerant overlay network

Network overlays have been the subject of intensive research in recent years. The paper presents an overlay structure, S-Fireflies, that is self-stabilizing and is robust against permanent Byzantine faults. The overlay structure has a logarithmic diameter with high probability, which matches the diameter of less robust overlays. The overlay can withstand high churn without affecting the ability of active and correct members to disseminate their messages. The construction uses a randomized technique to choose the neighbors of each member, while limiting the ability of Byzantine members to affect the randomization or to disturb the construction. The basic ideas generalize the original Fireflies construction that withstands Byzantine failures but was not self-stabilizing.

OCD: obsessive consensus disorder (or repetitive consensus)

Consider a distributed system S of sensors, where the goal is to continuously output an agreed reading. The input readings of non-faulty sensors may change over time; and some of the sensors may be faulty (Byzantine). Thus, the system is required to repeatedly perform consensus on the input values. This paper investigates the following question: assuming the input values of all the non-faulty sensors remain unchanged for a long period of time, what can be said about the agreed-upon output reading of the entire system? We prove that no systems output is stable, i.e. the faulty sensors can force a change of the output value at least once. We show that any system with binary input values can avoid changing its output more than once, thus matching the lower bound. For systems with multi-value inputs, we show that the output may change at most twice; when n=3f+1 this solution is shown to be tight. Moreover, the solutions we present are self-stabilizing.

Constant-Space Localized Byzantine Consensus

Adding Byzantintolerance to large scale distributed systems is considered non-practical. The time, message and space requirements are very high. Recently, researches have investigated the broadcast problemin the presence of a f l -local Byzantinadversary. The local adversary cannot control more than f l neighbors of any given node. This paper proves sufficient conditions as to when the synchronous Byzantinconsensus problemcan be solved in the presence of a f l -local adversary. Moreover, we show that for a family of graphs, the Byzantinconsensus problem can be solved using a relatively small number of messages, and with time complexity proportional to the diameter of the network. Specifically, for a family of bounded-degree graphs with logarithmic diameter, O(logn) time and O(nlogn) messages. Furthermore, our proposed solution requires constant memory space at each node.

Brief anouncement: simple gradecast based algorithms

Gradecast is a simple three-round algorithm presented by Feldman and Micali [4]. The current work presents two very simple algorithms that utilize Gradecast to achieve Byzantine agreement and to solve the Approximate agreement problem [2].

A fault-resistant asynchronous clock function

Consider an asynchronous network in a shared-memory environment consisting of n nodes. Assume that up to f of the nodes might be Byzantine (n > 12f), where the adversary is full-information and dynamic (sometimes called adaptive). In addition, the non-Byzantine nodes may undergo transient failures. Nodes advance in atomic steps, which consist of reading all registers, performing some calculation and writing to all registers. The three main contributions of the paper are: first, the clock-function problem is defined, which is a generalization of the clock synchronization problem. This generalization encapsulates previous clock synchronization problem definitions while extending them to the current papers model. Second, a randomized asynchronous self-stabilizing Byzantine tolerant clock synchronization algorithm is presented. In the construction of the clock synchronization algorithm, a building block that ensures different nodes advance at similar rates is developed. This feature is the third contribution of the paper. It is self-stabilizing and Byzantine tolerant and can be used as a building block for different algorithms that operate in an asynchronous self-stabilizing Byzantine model. The convergence time of the presented algorithm is exponential. Observe that in the asynchronous setting the best known full-information dynamic Byzantine agreement also has an expected exponential convergence time.

Self-stabilizing Numerical Iterative Computation

Many challenging tasks in sensor networks, including sensor calibration, ranking of nodes, monitoring, event region detection, collaborative filtering, collaborative signal processing, etc. , can be formulated as a problem of solving a linear system of equations. Several recent works propose different distributed algorithms for solving these problems, usually by using linear iterative numerical methods. In this work, we extend the settings of the above approaches, by adding another dimension to the problem. Specifically, we are interested in self-stabilizing algorithms, that continuously run and converge to a solution from any initial state. This aspect of the problem is highly important due to the dynamic nature of the network and the frequent changes in the measured environment. In this paper, we link together algorithms from two different domains. On the one hand, we use the rich linear algebra literature of linear iterative methods for solving systems of linear equations, which are naturally distributed with rapid convergence properties. On the other hand, we are interested in self-stabilizing algorithms, where the input to the computation is constantly changing, and we would like the algorithms to converge from any initial state. We propose a simple novel method called SS-Iterative as a self-stabilizing variant of the linear iterative methods. We prove that under mild conditions the self-stabilizing algorithm converges to a desired result. We further extend these results to handle the asynchronous case. As a case study, we discuss the sensor calibration problem and provide simulation results to support the applicability of our approach.