Byzantine Algorithms in Wireless Sensors
Ryszard Klempous
Faculty of Electrical Engineering
Wroclaw University of Technology
Wroclaw, Poland
ryszard.klempousgpwr.wroc.pl
Lukasz Radosz
Faculty of Electrical Engineering
Wroclaw University of Technology
Wroclaw, Poland
lukasz.radoszgpwr.wroc.pl
Abstract- In this paper we discuss classic concepts of
Byzantine Failure Tolerance that can be applied in fault-tolerant
system design. Through replication of services (algorithmic
computations) in a Wireless Sensors Network, the system can
operate in a reasonably correct manner even in presence of
errors (e.g. faults). In distributed systems similar to Wireless
Sensors Networks - local disturbances or distortion problems can
be resolved locally without involving the whole infrastructure.
Our proposition is to demonstrate suitability of variants of
Byzantine Algorithms based on additional information flow for
solving such problems locally. By using Byzantine Algorithms we
can ensure reduction of disturbances and fake or invalid alarms
in a sensors field as well limit their range to a minimum. Whole
problem is presented using a simulator that shows this algorithms
during operation.
Keywords-component, formatting, style, styling, insert (key
words)
I. INTRODUCTION
Over the past few years distributed wireless sensor
networks (WSN) have been the focus of considerable research
for both civil and military applications. Sensors are generally
constrained in on-board energy supply therefore efficient
management of the network is crucial to extend the life of the
system. Failures and disturbance are inevitable in sensor
networks executing in hostile environments and due to their
unattended deployment [1]. Faulty sensors or data distortion
can cause network infrastructure to needlessly transfer
erroneous or even totally false information through the entire
system. Such events usually cost additional power consumption
of key elements of WSN (e.g. Cluster Heads). The main aim of
this project is to explore and propose innovative computational
algorithmic solutions that can produce agreeable results in
presence of uncertainties thus reducing influence of sensors
that work incorrectly or sensors which capture fake events due
to disturbance or other environmental factors [8][3]. The
explored algorithms are based on general concepts used in the
Byzantine Fault Tolerance. Locally, a Wireless Sensors
Network can be treated like a set of replicas; hence it is
1-4244-0555-6/06/$20.00 (©2006 IEEE Page 319
Network
Jan Nikodem
Faculty of Electrical Engineering
Wroclaw University of Technology
Wroclaw, Poland
jan.nikodem gpwr.wroc.pl
Norbert Raus
Faculty of Electrical Engineering
Wroclaw University of Technology
Wroclaw, Poland
norbert.rausgstudent.pwr.wroc.pl
possible to apply such algorithms to reduce influence of faulty
sensors or disturbances only to a small group of sensor. It is
possible that using the Byzantine algorithms may cause greater
power consumption and hardware usage, however in this work
we aim to propose efficient algorithms that can manage these
disadvantages and offer more reliable solutions for WSN based
systems.
The research presented in this paper does not correspond to
any safety features or fault tolerance of a single sensor. We
tried to focus on using the Byzantine Algorithms to solve local
distortion problems (detecting fake or false events). In our
future work however we intend to extend our field of interests
to other system-wide issues..
II. BYZANTINE GENERALS PROBLEM
Lamport, Shostak and Pease first introduced the concept of
the Byzantine Failure or the Byzantine Generals Problem in
1982 in their "The Byzantine Generals Problem" research work
[6][8].
Figure 1. Byzantine Generals Problem
Generai 1
General 2
|3 Genral 3
In a fault-tolerant distributed computing system, a
Byzantine failure is defined as an arbitrary fault that occurs
during the execution of an algorithm by a distributed system. It
encompasses classes of faults that are commonly referred to as
"crash failures" or/and "send and omission failures." When a
Byzantine failure occurs, the element of a system may respond
ICIA 2006
in any unpredictable way and can spread fake (invalid)
information. The adjective Byzantine refers to the Byzantine
Generals' Problem, an agreement problem in which generals of
the Byzantine Empire's army must decide unanimously
whether or not to attack a certain army of an enemy as depicted
in Figurel. The problem is complicated by the fact of
geographic separation of the generals, who have to
communicate by sending messengers to each other, and by the
presence of traitors amongst the generals. These traitors can act
arbitrarily in order to achieve the following aims: trick some
generals into attacking; force a decision that is not consistent
with the generals' desires, e.g. forcing an attack when no
general wished to attack; or so confusing some generals that
they could never make up their minds. If traitors actually
succeed in any of these goals, any resulting attack is likely to
be doomed, as only a concerted effort can result in a victory. In
their seminal work Shostak, Lamport and Pease introduced
algorithms that can tolerate Byzantine Failures. Those
innovative algorithms are based on additional information flow
and can be generally described following the below presented
scenario.
Byzantine Generals Problem
A commanding general must send an order to his n- 1
lieutenant generals such that:
IC1. All loyal lieutenants obey the same order,
IC2. If the commanding general is loyal, then every loyal
lieutenant obeys the order he sends.
Conditions IC 1 and IC2 are called the interactive
consistency conditions. Note, that if the commander is loyal,
then IC1 follows from IC2. However, the commander need not
be loyal. To solve our original problem, the i-th general sends
his value of v(i) by using a solution to the Byzantine Generals
Problem to send the order "use v (i) as my value", with the
other generals acting as the lieutenants. The algorithm to solve
this problem can be defined as follows:
Require default value vdef if traitorous commander does not
send a message (e.g.RETREAT)
Define function majority(v1,...,v11l) = v if a majority of the
values vi = v.
Algorithm UM(n,O) # no traitors case
(1) The Commander sends v to every lieutenant.
(2) Each lieutentent uses the value received from
the commander or vdef if he receives no value.
Algorithm UM(n,m) # m-traitors case
(3) The Commander sends v to every lieutenant.
(4) For each Lieutenant.,
let vi = value received from commander or vdef if no
value received.
send vi to n-2 other lieutenants using UM(n- l,m- 1)
(5) For each i & each j # i,
Page 320
let vj = value Lieutenant, received from Lieutenantj in
step (4) or vdef if no value received.
Lieutenant, uses the value majority(v1,...,v.-j)
In Byzantine General Problem Shostak, Lamport and Pease
proposed similar algorithms (e.g. signed messages algorithm)
however in our work we consider a solution with "oral
messages" only [6]. In general, discussed algorithms are based
on original solutions proposed to solve Byzantine Generals
Problem that we call the Byzantine Algorithms. The main idea
that we propose is to add an additional information layer to
message passing protocol in Wireless Sensor Network in order
to decrease influence of disturbances that cause detection of
fake events.
III. BYZANTINE ALGORITHMS IN WSN
Why should one add Byzantine algorithms to the Wireless
Sensors Network? Trying to explain this question - let us
imagine a situation in which we have large area covered by
sensors network, the network is divided into clusters, and
whole routing is established. In such a wireless sensors network
some elements spread fake information through our network.
There could be many reasons why such a situations may occur
for example: a low battery level, environmental influences or
some electro-magnetic disturbances could have a detrimental
effect to quality of information [1]. The process of spreading
fake information through the network causes additional power
consumption of key elements of the network (e.g. cluster
heads) that are crucial for proper communication in WSN. To
reduce or even eliminate influence of such faulty sensors the
Byzantine Algorithms can be applied.
Worth noting is the fact that due to a hard environmental
factors and high density of sensors' deployment wireless
sensors networks usually use redundancy to ensure system's
robustness and availability of data. Hence, in WSN every part
of a given field area is covered by sensing range of several
sensors. If that is not the case we can intentionally deploy
sensors to gain greater sensors' density and required a
redundancy level, as the cost of sensors is comparatively low.
Locally some sensors can by treated as a set of replicas and it is
feasible to add algorithms tolerating Byzantine Failures to
solve problem presented above.
In normal distributed wireless sensors network when an
event occurs all sensors that detect this event send information
to cluster head and then further to the base station through
cluster heads using some routing rules. After adding the
Byzantine Algorithms properties the sensors may decide not to
send information about certain events further into the network.
 zEm063g-F'W4ext1;H>jwNM.,5i!ECr&D@zIev6-B;l3*N
Sending information to HQ Sending information to HO
(let's call it the Agreement Range - Ar ) as depicted in Figure
4.
Sending information to CH

Sending information to CH I?

Byzantine Algorithms

Detection of an event Detection of an evernt

Figure 2. Standard WSN vs. WSN with

Byzantine Algorithms
Figure 3. Detection of an event
In order to decide if to send information, a set of nearby
sensors should possess capability to communicate with one
another. Potentially, there could be a problem occurring with
selecting only sensors in neighborhood, which can be solved by
using radio communication at a required transmission power
level. Using these properties we can adjust radius of
communication to a desired range. Summing up, the proposed
wireless sensors network should fulfill the following
requirements:
X Every part of sensor field should by covered by
several sensors (redundancy).
X Sensors should be able to communicate with one
another in a flexible manner (ad-hoc communication) Figure 4. Sending information to nearby sensors

X A sensor in a network should be able to find other In the following step sensor waits some time T for answer
sensors in same given radius from other sensor and gathers received information in some
Adding Byzantine Algorithms to Wireless Sensors Network table (lets call it agreement matrix AM), if there is no answer -

should provide a local tolerance for disturbances, distortions
and false alarms. This requirement is essential in distributed
systems, as it enables to reduce spread of fake or invalid
information through the entire network. Since decisions are
made locally then only small part of network actively take part
in communication. Our rime objective is to solve problems
with local disturbances and thus increase the system reliability
at the local level. Additionally, by addressing local issues at the
local level, without involving global mechanisms that usually
require usage of additional resources we are able to generate
significant savings.
from a sensor it means there is no detection of an object or
event. A sensor also has knowledge about quantity of sensors
in his Agreement Range (Ar) so after using a majority function
it can decide what to do. If a majority of sensors detects an
event then information will be send to the cluster head and then
to the base. If this is not the case then no information will be
send through the network. In our model, we introduce an
additional requirement that only sensors with highest energy
level can send information to cluster head (see Figure 5). This
allows reduction of the communication load.
.....
6'i3 i'8

So how does it work? i

3
i'
i''

.,,,. W "' '","'i .,jB .,,.0

At first to simplify our algorithm it is assumed that sensors

detect only presence of an event, and they send only
information about detection of an object (information about ?
,,,
" '6 ?
t
1,w,
,, 6 .. T.

localization or similar data can be skipped). Sending more

information about a given event is not a problem, but it is ,_E, ,, BS,

necessary to use more complex function to decide upon

common consensus.
i h (
Worth nothings is the fact that in a case with sensor
Figure 5. Sending information to Cluster Head after Byzantine Agreement
detecting fake event can be parallel to a case with traitorous
commander described in chapter 2 and a case when a sensor is
detecting true event and is parallel to a case when we deal with
a loyal commander. In our version of the algorithm a sensor
detects an event, fake or true (see Figure 3) and then sends
information to other sensors in a given communication range

Page 321
 IV. DESCRIPTION OF THE ALGORITHM
The algorithm that we that we have used to perform
simulation in Matlab environment can described as follows:
1) Wait for: sensor detected an event or received information --

If (detected an event ) go to step 2 ---------- --------------------- ...........

else go to step 4
2) Find sensors in Agreement Range Ar, go to step 3
3) For each sensor found in step 2: send an information
about an event and about power level; go to step 4
4) While (timeout < T) receive information from other
sensors and put them to Agreement matrix Ama; go to step
5
5) Majority(Ama); go to step 6 //decide if an event has
occurr ed using basic majority function
6) Find sensor in Am with highest energy level, if sensor's
ID ==current ID send information to Cluster Head
Figure 6. Main simulator's window

The most important thing in this algorithm is to set optimal
value of Agreement Range and optimal majority function. The
majority function depends on several factors like density of
deployment of sensors, type of information send by sensors,
detection range of sensors.
Setting an Agreement range is a great deal, if it is to large
there will be too much additional communication and too many
sensors will be taking part in an agreement. If it is too small it
is possible that sensors will not find any nearby sensors. Our
proposition is to set this value to a half of detecting sensors'
range, but the density of deployment of sensor should by
enough.
We should also add that this algorithm does not depend on
routing and clustering, it is based on a different layer of
abstraction. Working of Byzantine Algorithms is transparent
for clustering and routing algorithms. There is no problem if
sensors that are taking part in Byzantine Agreement belong to
different clusters.
V. SIMULATION
A. About the Simulator
In this chapter an simulation results are shown. Simulator
was written using Matlab environiment. The main simulator
window is presented.
As it is seen on the figure 6, simulator has numerous
B. Simulation Results
The main problem and risk is situation in which an true
event will by recognized as fake. In our simulation we tried to
set parameters in such a value that will guaranty that real event
will be corr ectly detected. During simulation using some fixed
value of Agreement and Sensor's Range there was no situation
in which true event was incorr ectly recognized. We suggest
that ratio of Agreement and Sensor's Range should be about
0,5-0,6. That guaranties proper work of sensors without high
increase of additional communication. During test using such
settings we noticed that:
11 Non of the true events were recognized incorrectly
11 Only about lOOo of fake events ware treated as true
events and spread across the network.
Below we presented some of simulation results. The bigger
circle shows the detection range (Sensors Range) of Sensors,
and the smaller one shows an Agreement Range. The chart
below an picture of simulation show an decision process for
chosen sensor.
An fake event has been recognized correctly
---------------------------------

options to set. An amount of deployed sensor and size of filed

can be set. Also a sensors' fault and communication err ors ratio - -

is settable. It is possible to adjust an Agreement and Sensor's

Range. - - - -

----------- -------------------
--------- ---------

Figure 7. A fake event simulation

Page 322
 Incorrect recognition of a fake event.
a) An event
a) recognized
Co as tru e
(U ----------------------------

a)
0
U1) An event --------- --------- -------------------

Co recognized as
fake
a)
(I)
-------------

U)

L--------- L---- L--------- L

01 60 ------------------

Sensors that haven't detected an event ------------------------------ ---------

Figure 8. A fake event simulation

A true event has been recognized coff ectly:
'0I

---------------------------------------------------------- An event
a)
recognized
---------------------------- U1) as true

--------- --------- --------

An event
-------------------

recognized as
a)
-------------------

U1)
fake
a)
----------------------------

- --

0 1A
------------------- --------- --------- -----------------------------------------
Sensors that haven't detected an event

Figure 10. A fake event simulation

,o,'z.
An event CONCLUSIONS
VI.
-a. recognized Our work is to add an algorithm that could help us to
a) as true
a) reduce influence of a single disturbance or false alarms in field
co
of sensors. This task should be made locally not globally.
An event Problems of reliability of detection can be only solved locally
cu
-a recognized as using proposed Byzantine Algorithms. This idea can be
U1)
a)
fake compared to a society that locally copes with problems using
basics of democracy. To perform this task we used an
algorithm's known form false tolerance commonly named the
Byzantine False Tolerance. Despite of a rather high cost of
additional communication we attempted to add these properties
to Wireless Sensors Networks, Our intuitive approaches and
PI positive results of our initial simulation gives us a certain level
0
A

Sensors that haven't detected an event of confidence that we are on a right track however further real-
life experiments are requires. In our future work we are
Figure 9. Detection of true event thinking about adding some additional requirements for our

Page 323
algorithmic solutions. For example, by passing some additional
infornation about information reliability i.e. confidence levels
of intelligence or by building reliability maps of sensors. We
are continuously working on reducing of additional
communication and power consumption levels.
VII. REFERENCES
[1] Z. Chaczko,F. Ahmad, "Wireless Sensor Network Based System for Fire
Endangered Areas", ICITA 2005, Sydney, July 2005.
[2] Z. Chaczko, S. Sinha, "SAFE Model Approach to Construction of
Intelligent Security Systems", ICITA 2005, Sydney, July 2005.
[3] S.C. Wang K.Q. Yan H.C. Hsieh, "The Byzantine Agreement under
Mobile Network", International Conference on Networking, Sensing &
Control ,Taipei. Taiwan. March 2004
Page 324
[4] B. Liskov, R. Rodrigues, "Tolerating Byzantine Faulty Clients in a
Quorum System", ICDCS'06, Lisbon, 2006
[5] V. Drabkin, R. Friedman, Marc Segal, "Efficient Byzantine Broadcast in
Wireless Ad-Hoc Networks", DSN'05, Israel, 2005
[6] L. Lamport, R. Shostak, M. Pease, "The Byzantine Generals Problem."
ACM Transactions on Programming Languages and Systems, 1982.
[7] C. Liskov, "Practical Byzantine Fault Tolerance". In OSDI: Symposium
on Operating Systems Design and Implementation (1999), USENIX
Association, Co-sponsored by IEEE TCOS and ACM SIGOPS.
[8] M. Pease, R Shostak, and L. Lamport,"Reaching Agreement in Presence
of Faults," JACM, vol. 27, no. 2, pp. 228234, April 1980.