Sensor Systems and Software · 2014. 11. 4. · 123 Marco Zuniga Gianluca Dini (Eds.) Sensor Systems and Software 4th International ICST Conference, S-Cube 2013 Lucca, Italy, June

123

Marco ZunigaGianluca Dini (Eds.)

Sensor Systemsand Software4th International ICST Conference, S-Cube 2013Lucca, Italy, June 2013Revised Selected Papers

122

Lecture Notes of the Institutefor Computer Sciences, Social Informaticsand Telecommunications Engineering 122

Editorial Board

Ozgur AkanMiddle East Technical University, Ankara, Turkey

Paolo BellavistaUniversity of Bologna, Italy

Jiannong CaoHong Kong Polytechnic University, Hong Kong

Falko DresslerUniversity of Erlangen, Germany

Domenico FerrariUniversità Cattolica Piacenza, Italy

Mario GerlaUCLA, USA

Hisashi KobayashiPrinceton University, USA

Sergio PalazzoUniversity of Catania, Italy

Sartaj SahniUniversity of Florida, USA

Xuemin (Sherman) ShenUniversity of Waterloo, Canada

Mircea StanUniversity of Virginia, USA

Jia XiaohuaCity University of Hong Kong, Hong Kong

Albert ZomayaUniversity of Sydney, Australia

Geoffrey CoulsonLancaster University, UK

Marco Zuniga Gianluca Dini (Eds.)

Sensor Systemsand Software4th International ICST Conference, S-Cube 2013Lucca, Italy, June 11-12, 2013Revised Selected Papers

13

Volume Editors

Marco ZunigaDelft University of Technology, The NetherlandsE-mail: [email protected]

Gianluca DiniUniversity of Pisa, ItalyE-mail: [email protected]

ISSN 1867-8211 e-ISSN 1867-822XISBN 978-3-319-04165-0 e-ISBN 978-3-319-04166-7DOI 10.1007/978-3-319-04166-7Springer Cham Heidelberg New York Dordrecht London

Library of Congress Control Number: 2013956548

CR Subject Classification (1998): C.2, C.3, K.6, J.2, J.3, H.2.8, C.4

© ICST Institute for Computer Sciences, Social Informatics and Telecommunications Engineering 2013

This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part ofthe material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation,broadcasting, reproduction on microfilms or in any other physical way, and transmission or informationstorage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodologynow known or hereafter developed. Exempted from this legal reservation are brief excerpts in connectionwith reviews or scholarly analysis or material supplied specifically for the purpose of being entered andexecuted on a computer system, for exclusive use by the purchaser of the work. Duplication of this publicationor parts thereof is permitted only under the provisions of the Copyright Law of the Publisher’s location,in ist current version, and permission for use must always be obtained from Springer. Permissions for usemay be obtained through RightsLink at the Copyright Clearance Center. Violations are liable to prosecutionunder the respective Copyright Law.The use of general descriptive names, registered names, trademarks, service marks, etc. in this publicationdoes not imply, even in the absence of a specific statement, that such names are exempt from the relevantprotective laws and regulations and therefore free for general use.While the advice and information in this book are believed to be true and accurate at the date of publication,neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors oromissions that may be made. The publisher makes no warranty, express or implied, with respect to thematerial contained herein.

Typesetting: Camera-ready by author, data conversion by Scientific Publishing Services, Chennai, India

Printed on acid-free paper

Springer is part of Springer Science+Business Media (www.springer.com)

Preface

The 4th International ICST Conference on Sensor Systems and Software (S-CUBE 2013) was held during June 11–12, in Lucca, Italy. The conference aimsto promote discussion and dissemination of state-of-the-art work in the areas ofsystem development and software support for wireless sensor networks. Thesenetworks are made of spatially distributed ubiquitous devices that combine com-munication, computation, and sensing. They are currently used to experimentwith the development of innovative applications for precision agriculture, smarthomes/smart cities, and advanced healthcare. Novel analysis techniques, tools,and programming paradigms are needed to handle the complexity of wireless sen-sor networks. This requires contributions from several fields, including embed-ded systems, distributed systems, software engineering, Semantic Web, real-timedata acquisition and data fusion, wireless protocols, and system security.

This year’s technical program included two keynote speakers: Luca Mottola(Politecnico di Milano, Italy, and Swedish Institute of Computer Science), andRamiro Martinez De Dios (University of Seville, Spain). Eight regular paperswere peer-reviewed and accepted at the conference; two further regular paperswere invited and presented at the conference. The papers made diverse contri-butions on different technologies for wireless sensor networks, including: securityprotocols, middleware, analysis tools and frameworks.

The social program included a dinner at ”Ristorante Puccini” in the heart ofLucca, a small medieval town in Tuscany, central Italy.

Organization

Steering Committee

Imrich Chlamtac Create-Net, ItalySabrina Sicari Università degli studi dell’Insubria, ItalyStephen Hailes University College of London, UK

Organizing Committee

Conference General Chair

Gianluca Dini University of Pisa, Italy

TPC Chair

Marco Zuniga Delft University of Technology,The Netherlands

Web Chair

Angelica Lo Duca National Research Council, Italy

Local Arrangements Chair

Cinzia Bernardeschi University of Pisa, Italy

Conference Coordinator

Elisa Mendini EAI

Publication Chair

Paolo Masci Queen Mary University of London, UK

Publicity Co-chair

Annarita Giani Los Alamos National Lab, USAChia-Yen Shih University of Duisburg-Essen, Germany

VIII Organization

Technical Program Committee

Mario Alves ISEP, PortugalD.K. Arvind The University of Edinburgh, UKKarthik Dantu Harvard, USASimon Duquennoy SICS, SwedenCem Ersoy Bogazici University, TurkeyVlado Handzisky TU Berlin, GermanySalil Kanhere UNSW, AustraliaManfred Hauswirth Digital Enterprise Research Institute, IrelandOlaf Landsiedel Chalmers, SwedenMirco Musolesi University of Birmingham, UKMelek Onen EUROCOM, FranceAnimesh Pathak Inria, FranceChiara Petrioli Università di Roma La Sapienza, ItalyDaniele Puccinelli SUPSI, SwitzerlandOlga Saukh ETHZ, SwitzerlandCormac Sreenan University College Cork, IrelandGoce Trajcevski Northwestern University, USAAndrea Vitaletti Università di Roma La Sapienza, ItalyAndreas Willig University of Canterbury, New Zealand

Table of Contents

Improving Key Negotiation in Transitory Master Key Schemes forWireless Sensor Networks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

Cesare Celozzi, Filippo Gandino, and Maurizio Rebaudengo

REsilient Double WEighted TruST Based (REDWEST) WSN UsingSAX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

Aline S. Siranossian and Hoda W. Maalouf

Overpotential-Based Battery End-of-Life Indication in WSN Nodes . . . . . 34Thomas Menzel and Adam Wolisz

Definition and Development of a Topology-Based CryptographicScheme for Wireless Sensor Networks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

Stefano Marchesani, Luigi Pomante, Marco Pugliese, andFortunato Santucci

Smart Fence: Decentralized Sequential Hypothesis Testing for PerimeterSecurity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

Fabien Chraim and Kristofer Pister

Underwater Sensor Networks with Mobile Agents: Experience from theField . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

Andrea Caiti, Vincenzo Calabrò, and Andrea Munafò

IRIS: A Flexible and Extensible Experiment Management and DataAnalysis Tool for Wireless Sensor Networks . . . . . . . . . . . . . . . . . . . . . . . . . 94

Richard Figura, Chia-Yen Shih, Songwei Fu, Roberta Daidone,Sascha Jungen, and Pedro José Marrón

Enabling High-Level Application Development in the Internetof Things . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

Pankesh Patel, Animesh Pathak, Damien Cassou, andValérie Issarny

X Table of Contents

Comparative LCA Evaluations between Conventional Interventionsand Building Automation Systems for Energetic RequalificationActivities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127

Alessandra Pierucci and Guido R. Dell‘Osso

RAISE: RAIlway Infrastructure Health Monitoring Using WirelessSEnsor Networks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

Jaime Chen, Manuel Dı́az, Bartolomé Rubio, and José M. Troya

Author Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159

Improving Key Negotiation in Transitory Master

Key Schemes for Wireless Sensor Networks

Cesare Celozzi, Filippo Gandino, and Maurizio Rebaudengo

Polytechnic of Turin, Department of Automation and Information Technology,Corso Duca degli Abruzzi, 24, 10129 Turin, Italy

{cesare.celozzi,filippo.gandino,maurizio.rebaudengo}@polito.it

Abstract. In recent years, wireless sensor networks have been adoptedin various areas of daily life, and this exposes the network data and hard-ware to a number of security threats. Many key management schemeshave been proposed to secure the communications among nodes, for in-stance the popular LEAP+ protocol. This paper proposes an enhancedvariant of the LEAP+ protocol that decreases the key setup time throughthe reduction of the number of packets exchanged. This improves the se-curity of communications. The results obtained by network simulationafter extensive testing are compared to the corresponding data derivedfrom the LEAP+ protocol to quantify the improvements.

Keywords: key management, wireless sensor networks, transitory mas-ter key.

1 Introduction

Wireless sensor networks (WSNs) have obtained worldwide attention in recentyears due to the diffusion of Micro-Electro-Mechanical Systems technology whichhas led to the manufacture of smart sensors. These sensors are smaller and moreaffordable than the older generation sensors and can measure and collect informa-tion from the environment, transmit this data through wireless communicationlinks and process them in order to take decisions. However, these sensor nodeshave limited computing resources and can only perform complex tasks in largeregions if organized in an interlinked network.

Nowadays this pervasive technology is exploited in various applications rang-ing from infrastructure monitoring [1] to HVAC (heating, ventilation, and airconditioning) for buildings [2]. WSNs have also been applied to military pur-poses [3] due to the low costs and high scalability. In each of these contextscommunications security is crucial. In particular, WSNs must be protected fromthreats that could compromise the integrity and confidentiality of the data or al-ter the behavior of the nodes. Since WSNs are often deployed in unsafe or hostileareas they are exposed to various security threats like eavesdropping, hardwaretampering or injection of malicious requests. Therefore, in order to protect theintegrity, confidentiality and reliability of WSNs an effective security scheme isrequired.

M. Zuniga and G. Dini (Eds): S-Cube 2013, LNICST 122, pp. 1–16, 2013.c© Institute for Computer Sciences, Social Informatics and Telecommunications Engineering 2013

2 C. Celozzi, F. Gandino, and M. Rebaudengo

The key aspect of the security in WSNs is the protection of the communi-cations between pairs of sensor nodes. In principle, the network links can beprotected through asymmetric cryptography techniques which allow the keydistribution to be managed efficiently. However, given the low computationalresources of the sensor nodes and the limited power supply [4], [5], symmet-ric cryptography has been largely exploited in the majority of recent securityschemes. Symmetric cryptography can be used to satisfy the main security re-quirements, such as authenticity and confidentiality. The adoption of a symmet-ric encryption scheme implies that each pair of nodes of the WSNs shares a secretkey. The negotiation of these cryptographic keys (key management [6][7]) is in-dependent of the employed encryption method and heavily affects the security,the computational load and power consumption of the WSN.

Various approaches based on symmetric cryptography have been proposed inthe context of key management [8], [9], [10]. In transitory master key techniquesall nodes share a master key which is deleted after a certain amount of time (keysetup time). This is estimated to be the time required by the WSN to negotiatea pairwise key for each pair of nodes. The security assumption is that the keysetup time is shorter than the time required by an attacker to extract the masterkey from a compromised node.

Among the above mentioned approaches, LEAP/LEAP+ protocol and itsvariants [11], [9], [12] have emerged as effective transitory master key protocolsfor pairwise key negotiation in static WSNs which allow node addition. LEAP+protocol relies on the difficulty in accessing the memory of a deployed nodecontaining the master key before its deletion which occurs few seconds after thedeployment. The secrecy of the master key is crucial for the security of linkssince all the pairwise keys are derived from a pseudo-random function indexedby the master key and applied to the IDs of the node. Therefore, a shorterkey setup time implies lower probability of key theft and higher security of thecommunication links.

This paper proposes a modified version of the pairwise key negotiation proto-col of the LEAP+ to reduce the key setup time. This goal is achieved througha set of variations of the pairwise key negotiation handshake which decreasesthe number of packets exchanged in the wireless channel reducing the numberof collisions and thus the handshake time. The reduction of the handshake timeallows the adoption of a shorter key setup time, keeping the percentage of nego-tiated pairwise keys constant. The data extracted from network simulations ofthe LEAP+ protocol and of the proposed enhanced variant have been illustratedand compared in order to quantify the benefits of the modifications.

The remainder of the paper is organized as follows: in Section 2 the LEAP+protocol together with an overview of the main security issues is described.Section 3 presents the proposed modification of the handshake. Finally, in Section4, the proposed approach is evaluated and compared with the original protocol,and in Section 5 some conclusions are drawn.

Improving Key Negotiation in Transitory Master Key Schemes for WSN 3

2 Overview of LEAP+ Protocol

The LEAP+ protocol is based on a transitory master key technique and on theassumption that a newly deployed node cannot be compromised within a shortperiod of time (denoted by TMIN ). This is the time required for neighbor dis-covery and pairwise key negotiation. Therefore, TMIN represents the maximumamount of time available to an attacker to access and copy the memory of asensor node. The security scheme presented in [9] proposes the adoption of fourkinds of key to manage different levels of communication among the nodes (in-cluding the Base Station). This work is focused on the pairwise key negotiationwhich is the most crucial security aspect of the LEAP+ protocol. In order toincrease the security level, the pairwise keys of each pair of nodes are negotiatedafter the deployment, exploiting the transitory master key secrecy. In this wayeach pair of nodes will have a different shared secret and the compromise of onepairwise key will not affect the security of the other links of the network.

The pairwise key negotiation procedure is composed of 4 phases, as shown inFig. 1, where:

- a −→ ∗ : node a broadcasts a packet;- a −→ b : node a unicasts a packet to node b;- {m}K : message m cyphered with key K;- MAC(m)K : Message Authentication Code of the message m indexed bythe key K;

- a|b|c : concatenation of a, b, c.

Before the deployment of the network an offline setup procedure (Phase 0 ) iscarried out. During this phase the central controller generates and loads the sametransitory master key on each node of the network. From the transitory masterkey each node derives its own private master key Ku = fKIN (u), where f(·) isa pseudo-random function indexed by the key KIN . At the time of deploymenteach node starts a timer which measures the lifetime of the master key. Whenthe timer elapses the master key is deleted from the memory. In this way thenode will no longer be able to start a handshake procedure for the negotiationof a pairwise key since it is no longer capable of verifying the authenticity of theACK1 answer. However a node which is no longer in possession of the master keycan still answer to any HELLO message received from other nodes. Therefore,this mechanism allows the addition of new nodes to a network that has alreadycompleted the deployment phase.

After key initialization the nodes are ready for deployment. When a nodeis activated and deployed it starts to exchange messages with its neighbors tonegotiate the pairwise keys. In order to start the handshake, a generic node uperiodically broadcasts a packet called HELLO. This packet contains the iden-tification code IDu of the sender. Through this packet the node communicatesits presence to the neighbors (Phase 1 ). The frequency of the HELLO packets(1/THELLO) has great impact on the performance of the handshake. In fact,the transmission of a high number of messages increases the probability that


Phase 0, Key initialization

Phase 1, Send HELLO:u −→ ∗ : IDu

Phase 2, Send ACK1:v −→ u : IDv,MAC(IDu|IDv)Kv

Phase 3, Send ACK2:u −→ v : IDu,MAC(IDv)Kv

Fig. 1. Handshake for pairwise key negotiation in LEAP+ protocol

every neighbor will receive the HELLO message but also increases the numberof collisions on the wireless channel. Therefore, sending HELLO packets withhigh frequency degrades the overall performance of the system. The choice of aproper THELLO must be made taking into account the average node degree ofthe network.

A generic node v which receives the HELLO message will reply with an ac-knowledgment message ACK1 (Phase 2 ). This message is unicast to the senderof the HELLO message and contains the IDv and a MAC indexed by the privatemaster key Kv. In order to avoid collisions the ACK1 packets are sent after thebackoff time which is a random time extracted from a uniform distribution withrange (0, TBACKOFF ). At the same time the node starts a timer that will elapseafter an interval of time during which the node waits for an answers (ACK2)from the HELLO sender (node u). If the node does not receive the ACK2 mes-sage after the timer elapses, it retransmits the ACK1 message. This retransmis-sion is scheduled in the interval of time (TBACKOFF+1s, 2·TBACKOFF+1s).

When the node u receives back the ACK1 message it verifies the integrity andauthenticity of the message computing the MAC and comparing it to the oneattached to the received message. In positive cases it generates and stores thepairwise key and sends a response called ACK2 (Phase 3 ). The ACK2 containsthe IDu of the HELLO sender and the MAC for authentication. When the nodev receives the ACK2 and verifies the integrity and authenticity of the messagethe handshake is completed and both nodes share the same pairwise key forfurther secure communications.

2.1 Security Issue

From a security point of view the main weak point of LEAP+ protocol is thatthe compromise of the transitory master key during the deployment phase maydisrupt the security of the whole network. In fact, an attacker in possessionof the master key may decipher eavesdropped traffic and even fabricate newnodes able to initiate the handshake for pairwise key negotiation. The thresholdTMIN represents the interval of time during which it can be assumed that it


is not physically possible to compromise the memory of a node. However, theexperiment realized in 2005 by [10] showed that it is possible to obtain a copyof the memory of a node in tens of seconds. This study also showed that the keysetup time may last minutes depending on the average node degree and on thenumber of messages exchanged. Since TMIN must not be longer than the timeestimated by [10] (which future technologies will lower), the reduction of TMINis a critical aspect for ensuring the security of the key management scheme. Thiswork focuses on this security issue and proposes a variation of the LEAP+ thatdramatically lowers the value of TMIN required by LEAP+ for networks withsame average node degree.

3 Proposed Approach

From the analysis presented in the previous section it can be noticed that inspecific cases, especially those with high average node degree, the LEAP+ pro-tocol does not allow the negotiation of all the keys actually available in thesystem because TMIN is too short. The major cause of this behavior is the highnumber of collisions generated by the large quantity of messages exchanged ina small time interval during the negotiation phase. A possible solution for thisproblem is the adoption of TMIN intervals with longer duration. However, thissolution increases the probability of compromising a node that is still in posses-sion of the master key, thus allowing an attacker to break all network commu-nications. Conversely, the violation of a node which is in possession of the soleprivate master key only allows the violation of the communications that involvethe compromised node. Therefore, to increase the security of the network thetime interval TMIN should be minimized. To achieve this goal the handshake(HELLO−→ACK1−→ACK2) should be as efficient as possible to maximizethe number of keys negotiated during the TMIN interval. In fact, if a node is notable to negotiate a pairwise key with a neighbor node, it cannot communicatedirectly with it and this may imply an increase of energy consumption derivingfrom the resulting use of multi-hop communication.

Starting from the solutions adopted by LEAP+ a new handshake has beenproposed to reduce the number of packets exchanged and the duration of thekey negotiation phase.

3.1 Hello Flag

As discussed above, the pairwise key negotiation of the LEAP+ protocol [9]is composed of various phases (Fig. 1) but starts with the HELLO messagebroadcast. The HELLO message is sent periodically during the time intervalTMIN .

When the nodes of the network are activated, a large amount of traffic dueto the broadcast of the HELLO messages and to the subsequent ACKs isgenerated. For instance, in a network with n = 50 nodes, TMIN= 30s andTHELLO= 3s, the protocol generates n · (TMIN/THELLO) = 500 HELLO pack-ets. For eachHELLO message each node answers with an ACK1 message which


is received by all other nodes that are in the communication range. The com-munication modules of the receiving nodes must perform the basic operationsto identify if they are recipients of the ACK1 message, regardless of whetherthe communication is unicast or broadcast. This may be exploited to reduce thenumber of HELLO messages in the network by simply interpreting a genericACK1 message with a destination address that is different from the receiveraddress as a HELLO message. A HELLO flag was added to the header of theACK1 packet in order to enable or disable this feature. The HELLO flag isnecessary when a node is no longer in possession of the master key. In this casethe node is not able to initiate a handshake procedure since it cannot verify theauthenticity of the ACK1 replies. Therefore, the HELLO flag must be set tofalse. Since the simulation experiments have shown that the variation of thequantity and frequency of the HELLO messages have a significant impact onperformance in terms of time required for the negotiation of the keys, a periodTHELLO= 0.33·TMIN was also applied to the ACK1 messages that have theHELLO flag set to true.

When a node is deployed and the LEAP+ protocol starts the handshake, aHELLO message is scheduled in the interval of time 0÷THELLO. If the nodereceives a HELLO message from another node before sending its own HELLOmessage it answers with an ACK1 message in which the HELLO flag is setto true. The HELLO message which has been replaced by the ACK1 with theHELLO flag set to true is rescheduled by a time equal to THELLO. Furthermore,a proximity threshold was introduced to discard and replace a HELLO message,which was scheduled for an instant of time that falls within the threshold, withan ACK1 message. This threshold makes it possible to anticipate the beginningof the handshake through the dispatch of an ACK1 message that must be sentin any case. The implementation of this mechanism requires the capability todisable the incoming packets filter which discard packets that are not meantfor the node. In the experimental phase a proximity threshold of 0.1·THELLOwas adopted. Tests showed that this mechanism reduces the number of HELLOmessage produced by the protocol.

3.2 Composite ACK1

The security of LEAP+ protocol is based on the assumption that only the pos-sessors of the master key can authenticate the ACK1 through the computationof MAC(IDu|IDv)Kv . The presence of IDu in the MAC argument is criticalfrom the security point of view because it prevents potential reply attacks. Sinceeach node performs this computation for each HELLO message received, thenumber of packets in the network during the handshake and the power consump-tion depend on the node degree distribution of the network. In networks withhigh average node degree the performance of the handshake may suffer from ahigh number of collisions and from resulting retransmissions.

Starting from these considerations a new typology of ACK1 packet calledcomposite ACK1 (ACK1C for brevity) was proposed. The ACK1C packet isa special ACK1 packet that contains the IDu of every node from which the


sender received a HELLO message, with the corresponding MAC. The ACK1Censures the same security features of the ACK1 packet but is able to manage allthe pending handshake initiation requests with a single message. Only a node inpossession of the master key can generate the ACK1C message and the recipi-ents can verify the authenticity of such a packet through the same mechanismsadopted for the ACK1 message. Each ACK1C packet can carry a maximumnumber S of node IDs for which S slots are reserved IDu1 . . . IDuS |IDv. In thisway the maximum dimension of the packet is constant.

The adoption of the ACK1C packet reduces the total number of messagesrequired for key negotiation. Theoretically, the reduction of ACK1 messages isequal to 1/S. This reduction also lowers the workload and the memory occupa-tion required for the generation of the corresponding MAC. On the other hand,there is a limited increase in the size of the message which does not significantlyaffect the processing time for the computation of the MAC. The ACK1C pack-ets are broadcast in the network as a response to multiple HELLO messagereceived by a node. Each node that receives an ACK1C packet verifies whetherits own IDu is contained in one of the slots of the packet and decides to dropit or further develop the handshake protocol. If the HELLO flag is set to trueand if the receivers have not yet exchanged a pairwise key with the sender, theACK1C packet is interpreted as a HELLO message. Otherwise the receiververifies the authenticity of the message and continues the handshake describedin the LEAP+ protocol.

When a node receive a HELLO message or an ACK1C with the HELLO flagset to true and no ACK1C is in the outgoing queue, it schedules a new ACK1Cpacket and randomly chooses a backoff time from the interval 0÷TBACKOFF .If the node receives further HELLOs from other nodes it adds new IDu in thefree slots of the scheduled ACK1C packet until there are no more free slots orthe backoff timer elapse. After sending the message, for each node whose IDuhas been added to the ACK1C packet the node awaits the ACK2 replies fora certain amount of time. If some of the replies are missing, the free slots ofthe next ACK1C scheduled in the outgoing queue are filled with the IDu ofthe nodes associated to the missing replies and with the IDu of the HELLOsreceived in the meanwhile. In order to maximize the number of useful slots ofthe scheduled ACK1C , the IDs of the nodes with missing ACK2 replies near tothe expiration threshold are also added in the free slots of the ACK1C message.

3.3 Modified Handshake Protocol

Since ACK1C packets have the same security features of ACK2 packets butallow multiple destinations, they can replace them. This led to a new version ofthe handshake protocol: HELLO−→ACK1C−→ACK1C . With this handshakeit is possible to obtain improved performance especially in case of high-densitynetworks and short key setup time TMIN . These improvements cover the caseshighlighted as critical by the security analysis presented in the previous section.In order to discriminate between ACK1C packets that require authenticationfrom nodes in possession of the master key and ACK1C packets which replace


HELLO

ACK2

ACK1M

ACK1M

(a) LEAP+

ACK2

ACK1M

ACK1M

ACK1/2

HELLO FLAG=true

(b) Proposed approach

Fig. 2. ACK1 retransmission in the handshake protocol

ACK2 packets, an additional flag was introduced in the ACK1C packet for eachslot (ACK2 flag). This modified handshake still guarantees that the nodes thatterminate the key negotiation are authorized nodes in possession of the masterkey.

Since one ACK2 flag is associated to each slot, both ACK1 and ACK2acknowledgment messages can coexist in the same ACK1C packet. Therefore,when a node receive an ACK1C packet it verifies if its IDu is present in one ofthe slots and then checks the status of the corresponding ACK2 flag and of theHELLO flag in order to correctly interpret the message. In the case of ACK1Cpacket interpreted as ACK2 the node generates the appropriate pairwise key andthe handshake terminates. Otherwise, after the generation of the pairwise keythe node dispatches an ACK2-like packet (ACK1C with ACK2 flag or ACK2).

Summing up, there are different handshake configurations in which each nodemay be involved. The negotiation procedure starts with a HELLO packet orwith an ACK1C packet with the HELLO flag set to true. After the first step,the receiving nodes reply with an ACK1C packet. Then, the handshake is ter-minated with an ACK2 packet in case the sender no longer has the master key.Otherwise, the handshake is terminated with an ACK1C packet which improvesthe efficiency of the protocol. If a node does not receive an ACK2-like packet itmust retransmit the ACK1C packet (Fig. 2). In Fig. 3 the possible handshakeconfigurations are summarized. The proposed handshake requires three differentpackets: HELLO, ACK1C and ACK2. These packets contain the fields shownin Tab. 1.

4 Comparison between LEAP+ and the ProposedApproach

In this session the performance of LEAP+ and of the proposed handshake havebeen analyzed and compared for different network configurations. The NS2 net-work simulation software has been adopted to collect large quantity of data. Thissoftware has been integrated with specific libraries for the analysis of WirelessSensor Networks. The network parameters that was taken into account for theconfiguration of the simulator are:

– Nodes: number of active nodes in the network;


HELLO

ID=u1

ACK1M

msg={

IDs={u2,

,u3

,u4

,u1

,u5

}

ACK2 FLAGS={f,t,f,true,f}

Tmin FLAG=true

...

}

MAC={Kv,msg}

ACK1M

msg={

IDs={u2,

,u3

,u4

,u1

,u5

}

ACK2 FLAGS={f,t,f,false,f}

Tmin FLAG=true

...

}

MAC={Kv,msg}

(a)

ACK1M

msg={

IDs={u2,

,u3

,u4

,u1

,u5

}


Tmin FLAG=true

...

}

MAC={Kv,msg}

ACK1M

msg={

IDs={u2,

,u3

,u4

,u1

,u5

}

ACK2 FLAGS={f,f,t,false,f}

Tmin FLAG=true

...

}

MAC={Kv,msg}

ACK1/2

HELLO FLAG=true

(b)

HELLO

ID=u1

ACK1M

msg={

IDs={u2,

,u3

,u4

,u1

,u5

}


TminFlag=false

...

}

MAC={Kv,msg}

ACK2

msg={

ID={u1

,v}

}

MAC={Kuv,msg}

(c)

ACK1/2

HELLO FLAG=true

ACK2

msg={

ID={u1

,v}

}

MAC={Kuv,msg}

ACK1M

msg={

IDs={u2,

,u3

,u4

,u1

,u5

}


TminFlag=false

...

}

MAC={Kv,msg}

(d)

Fig. 3. Possible handshake configurations for pairwise key negotiation

– Average node degree: average number of nodes in the wireless commu-nication range of each node;

– X,Y: dimension of the deployment area (X · Y m2 with X = Y );– TMIN : lifetime of the master key; after TMIN elapses the node erase the

master key and all the keys derived from it except its own private masterkey;

– Deploy interval: maximum time interval between the deployment and theactivation of a node;

– THELLO: time interval between two consecutive HELLO messages;– TBACKOFF : maximum time interval between the reception of a HELLO

message and the forwarding of the ACK1 reply.


Table 1. Fields contained in the packets

Packet Field Description Size (bits)

HELLO NodeID ID of the sender 16

ACK1C

NodeID ID of the sender 16

NodeIDslots IDs of the recipients 16 · SNodeIDR ID of the recipient 16

Hello Flag If true the message can be interpreted as HELLO 1

TMIN Flag If true the sender has the master key and can stillreceive ACK1C messages as acknowledgment toACK1C messages

1

Ack2 Flags If set to true the node with ID equal to the onecontained on the corresponding slot will not sendan ACK2 message since the ACK1C terminatesthe handshake

16 · S

Mac Message Authentication Code obtained with themaster key of the node

256

ACK2

NodeIDS ID of the sender 16

NodeIDR ID of the recipient 16

Hello Flag If set to true the message can be interpreted asHELLO

1

Mac Message Authentication Code obtained with theprivate master key of the recipient node

256

4.1 Key Setup Time Analysis

The goal of the proposed approach is to lower the time TMIN so that the periodof vulnerability of the nodes is reduced. In order to evaluate the performanceof the modified handshake, the number of negotiated pairwise keys have beenestimated for different values of TMIN . A completion percentage equal to 100%corresponds to the negotiation of all the pairwise keys. The minimum valuesof TMIN which guarantee a completion percentage of 99% have been shown inFig. 4 for different values of the average node degree. It can be noticed that theadoption of the proposed handshake significantly reduces the time TMIN by afactor that depends on the network configuration and on the protocol parameters(i.e.: the number of slots in the ACK1C packet, etc...). For the configurationshown in Tab. 2 the reduction of TMIN is greater than 30% respect to LEAP+.

Data collected through the simulations showed the better scalability of theproposed approach due to the reduction of packets exchanged during the hand-shake. This parameter may be further reduced determining an adequate numberof available slots in the ACK1C packet, thus acting on the trade-off between thepacket overhead and the performance. Furthermore, a detailed analysis on therelationship between average node degree and TMIN has been performed. Fromresults presented in Fig. 5 it can be noticed that for low values of TMIN and high


0

2

4

6

8

10

12

5 10 15 20 25 30

T min

(s)

Average node degree (# nodes)

Proposed solution

Tmin associated to a completion percentage of 99%

LEAP+

Fig. 4. TMIN in the case of completion threshold equal to 99%

Table 2. Network configuration

Network parameters

Nodes 30 Average node degree 5-30

X=Y 200-900 m TMIN 1-12 s

Deploy interval 0 s THELLO interval Tmin · 0.33TBACKOFF THELLO Number of slots S 5

values of average node degrees the percentages of completion are lower. However,the proposed approach improves these percentages in each critical configuration(see Fig. 5). For instance, in the case of TMIN = 4s the completion percentageof LEAP+ original handshake is about 70% whereas the completion percentageof the proposed handshake is about 100%.

From the charts shown in Fig. 5 it can be highlighted that very short TMINintervals do not allow the negotiation of all the pairwise keys. Adopting thenetwork parameters of Tab. 2 the LEAP+ handshake allows a completion per-centage of 95% with TMIN = 6s while the proposed approach performs better,allowing the same completion percentage with TMIN = 3s.

4.2 Deployment Time Analysis

In order to carry out a detailed analysis of the proposed handshake for differentvalues of the deploy interval, a network configuration with high average nodedegree has been adopted (Tab. 3). In fact, in networks with high average nodedegree the activation of a large number of neighbor nodes causes the generationof a large number of packets in a limited time interval. In this context, thehigh number of collisions in the communication channel dramatically increases


510

1520

2530

24

68

1012

0

20

40

60

80

100

Completion percentage

Com

plet

ion

perc

enta

ge (%

)


min (s)T

0102030405060708090100

(a) LEAP+

510

1520

2530

24

68

1012

0

20

40

60

80

100


Com

plet

ion

perc

enta

ge (%

)


min (s)T

2030405060708090100


Fig. 5. Completion percentage as a function of TMIN and of the average node degree

the number of resent packets, thus stretching the negotiation time. Therefore,this condition amplifies the differences between the two handshakes and allowsan effective comparison. As shown in Fig. 6, both LEAP+ and the proposedapproach present weak performance for low values of the deploy interval.

However, the adoption of ACK1C packets and of the modified handshakeHELLO−→ACK1C−→ACK1C makes it possible to increase considerably thepercentage of keys negotiated in the network, keeping the deploy interval con-stant. This statement is also endorsed by the study of the average number ofpackets received and sent by each node. In fact, the proposed handshake allows


0

20

40

60

80

100

0 20 40 60 80 100 120 140

Com

plet

ion

perc

enta

ge (%

)

Deploy time (s)


Proposed solutionLEAP+

Fig. 6. Completion percentage as a function of the deploy time. Network with highaverage node degree.

Table 3. Network configuration

Network parameters

Nodes 70 Average node degree 70

X=Y 140-160 m TMIN 12 s

Deploy interval 0-140 s THELLO interval Tmin · 0.33TBACKOFF THELLO Number of slots S 5

the reduction of the number of sent packet for each deploy interval, as shown inFig. 7.

From the analysis of Fig. 7(a) it can be noticed that the high number of re-transmissions is due to the loss of ACK2 packets. The number of retransmissionsand collisions decreases as the deploy interval increases. However, the averagenumber of received packets per node increases in the new implementation (seeFig. 8) since the ACK1C packets introduced in the proposed handshake arebroadcast and potentially received by S nodes.

It is worth noting that the quantities of packets sent and received as a functionof the deploy interval, shown in the previous histograms, refer to different com-pletion percentages (data shown in Fig. 6). As highlighted in Fig. 7(a), a highnumber of sent packets does not necessarily implies a high number of negotiatedkeys. This is due to the increment in the number of collisions that occurs whenthe number of packets exchanged in the communication channel increases.


0

20

40

60

80

100

120

0 10 20 30 40 50 60 70 80 90 100 110 120 130 140

Ave

rage

num

ber o

f sen

t pac

kets

Deploy interval (s)

Sent packetsHELLO

ACK1DELAYED ACK1

ACK2

(a) LEAP+

0

20

40

60

80

10

30

50

0 20 40 60 80 10 30 50 70 90 200 220 240 260 280

Ave

rage

num

ber o

f sen

t pac

kets

Deploy interval (s)

Sent packetsHELLO

ACK2DELAYED ACK2

ACK4


Fig. 7. Average number of packets sent by a node

5 Conclusion

This paper presented an enhanced version of the LEAP+ protocol which im-proves the security of the handshake for pairwise key negotiation. The improve-ment consists in the reduction of the vulnerability time during which an attackermay stole the master key that is critical for the security of all the pairwise keycommunications. The results, obtained through a network simulator, showed sig-nificant improvements of performance in terms of reduction of the key setup timeand of number of packets exchanged for the key negotiation. The improvementswere more evident in the most critical contexts for the LEAP+ protocol such


0

20

40

60

80

100

120

0 10 20 30 40 50 60 70 80 90 100 110 120 130 140

Num

bero

frec

eive

dpa

cket

s

Deploy interval (s)

Received packetsHELLO

ACK1ACK2

(a) LEAP+

0 2468135792Num63bero

f o

co

i o

vo

doo

df o

dco

di o

o do f o po co ao i o ko vo t o doo ddo df o dpo dco

sDl

y2N8

N2n

25u2

(4m

n)29

e

R2n25u2( 4mn) 29eHELLO

ACKdACKf


Fig. 8. Average number of packets received by a node

as high density networks with low activation time. The higher efficiency in thepairwise key negotiation made it possible to shorten the interval of vulnerabilityof the nodes thus increasing the security of the entire network. The study carriedout showed the importance of the selection of proper network configuration pa-rameters and algorithms parameter. The evaluation of optimal values for theseparameters as a function of specific constraints of the network will be the subjectof future research.


Acknowledgment. This work was supported in part by grant “Nano-materialsand -technologies for intelligent monitoring of safety, quality and traceability inconfectionery products (NAMATECH)” from Regione Piemonte, Italy.

References

1. Hu, X., Wang, B., Ji, H.: A wireless sensor network-based structural health mon-itoring system for highway bridges. Computer-Aided Civil and Infrastructure En-gineering 28(3), 193–209 (2013)

2. Sultan, S., Khan, T., Khatoon, S.: Implementation of hvac system through wirelesssensor network. In: Proceedings of the 2010 Second International Conference onCommunication Software and Networks, ICCSN 2010, pp. 52–56. IEEE ComputerSociety, Washington, DC (2010)

3. Bekmezci, I.: Wireless Sensor Networks: A Military Monitoring Application. VDMVerlag, Saarbrücken (2009)

4. Gura, N., Patel, A., Eberle, A.W.H., Shantz, S.C.: Comparing elliptic curve cryp-tography and rsa on 8-bit cpus. In: Workshop on Cryptographic Hardware andEmbedded Systems 2004, pp. 119–132 (2004)

5. Piotrowski, K., Langendoerfer, P., Peter, S.: How public key cryptography influ-ences wireless sensor node lifetime. In: Proceedings of the Fourth ACM Workshopon Security of Ad Hoc and Sensor Networks, SASN 2006, pp. 169–176. ACM, NewYork (2006)

6. Zhang, J., Varadharajan, V.: Review: Wireless sensor network key managementsurvey and taxonomy. J. Netw. Comput. Appl. 33(2), 63–75 (2010)

7. Stelle, S., Manulis, M., Hollick, M.: Topology-driven secure initialization in wirelesssensor networks: A tool-assisted approach. In: Proceedings of the 2012 SeventhInternational Conference on Availability, Reliability and Security, ARES 2012, pp.28–37. IEEE Computer Society, Washington, DC (2012)

8. Eschenauer, L., Gligor, V.D.: A key-management scheme for distributed sensornetworks. In: Proceedings of the 9th ACM Conference on Computer and Commu-nications Security, CCS 2002, pp. 41–47. ACM, New York (2002)

9. Zhu, S., Setia, S., Jajodia, S.: Leap+: Efficient security mechanisms for large-scaledistributed sensor networks. ACM Trans. Sen. Netw. 2(4), 500–528 (2006)

10. Deng, J., Hartung, C., Han, R., Mishra, S.: A practical study of transitory mas-ter key establishment forwireless sensor networks. In: Proceedings of the FirstInternational Conference on Security and Privacy for Emerging Areas in Commu-nications Networks, SECURECOMM 2005, pp. 289–302. IEEE Computer Society,Washington, DC (2005)

11. Zhu, S., Setia, S., Jajodia, S.: Leap: efficient security mechanisms for large-scaledistributed sensor networks. In: Proceedings of the 10th ACM Conference on Com-puter and Communications Security, CCS 2003, pp. 62–72. ACM, New York (2003)

12. Lim, C.: Leap++: A robust key establishment scheme for wireless sensor networks.In: 28th International Conference on Distributed Computing Systems Workshops,ICDCS 2008, pp. 376–381. IEEE (2008)

M. Zuniga and G. Dini (Eds): S-Cube 2013, LNICST 122, pp. 17–33, 2013. © Institute for Computer Sciences, Social Informatics and Telecommunications Engineering 2013

REsilient Double WEighted TruST Based (REDWEST) WSN Using SAX

Aline S. Siranossian and Hoda W. Maalouf

Notre Dame University Louaize, Zouk Mosbeh, Lebanon {asiranossian,hmaalouf}@ndu.edu.lb

Abstract. Wireless Sensor Networks (WSNs) are becoming the most widely used applications in monitoring environment and military operations. However, in such applications sensors are deployed in harsh environments and sometimes are inaccessible once deployed making them vulnerable to both physical and software attacks. Malicious nodes can send misleading data to the controller affecting monitoring results. Sophisticated security applications cannot be used to overcome this problem due to the limited power of the sensors. A new mechanism is needed which first identifies malicious nodes in an accurate manner and offers indispensible characteristics namely, resiliency and reliability to the WSN. In this paper, we develop a malicious and malfunctioning node detection scheme using a resilient double weighted trust evaluation technique in a hierarchical sensor network. Our system evaluates all sensor nodes, increases and decreases trust value accordingly and excludes nodes having under threshold trust values. The simulation results show that our approach is very efficient even in harsh environments.

Keywords: Wireless sensor networks, malicious node detection, weighted trust, resiliency.

1 Introduction

The field of Wireless Sensor Networks (WSNs) is now in a stage where serious applications of societal and economical importance are in reach. Examples such as landslide, forest fire and underground mines advocate the use of wireless sensing technology as a new scientific instrument for environmental monitoring under extreme conditions. In such applications, reliability, availability, and maintainability are indispensible characteristics.

When an environment needs to be monitored, a large number of sensor nodes are usually deployed in a random fashion. The main purpose of the sensor nodes in this case is to take measurements and to forward this data to the sink node where it is processed and necessary action is taken.

Being used in very critical applications, data has to be transmitted accurately. However, WSNs have limited capacity and energy resources and hence are likely to be influenced by unpredictable failures occurring in the harsh sensor field. So the system requires a routing protocol to deliver event packets from source nodes to sink

18 A.S. Siranossian and H.W. Maalouf

nodes in a fault-tolerant and energy efficient way regardless of node failures and attacks such as, HELLO flooding attacks, sink hole attacks, black hole attacks, worm hole attacks, or DDoS attacks [1]. Sybil attacks are when a malicious node behaves as if it were a large number of nodes. In the worst case scenario, an attacker may generate an arbitrary number of node identities using only one identity [15]. In application layer, attackers may take control over nodes and make them send false data in a very intelligent manner to fool data aggregators and hence lead to an incorrect decision, facing a byzantine problem [14]. This is one of the worst attacks, which when solved can also solve many types of WSN node problems. Some solutions depending on trust value of the sensor are reported to detect these attacks so that the influence of the malicious node is minimized and finally removed from the network. However, all of these approaches assume that only sensor nodes that are placed at the lowest level in the hierarchical network are prone to attacks and failure. Forwarding nodes and access points are assumed to be trustful and won’t be compromised. In reality, all sensor nodes have similar properties since they are situated in the same environment making them all equally prone to attacks and failures.

Since sensors have very limited resources (memory, storage and power) therefore, dimensionality reduction, code and task minimization are other indispensable factors to be considered. In fact, a sensor is a tiny device with only a small amount of memory and storage space for the code, so the overall code for detection, aggregation and security has to be small. Furthermore, the power consumption needed for transmission dominates processing energy consumption. Hence, communication should be minimized as much as possible. To meet these stringent bandwidth and power constraints, especially when considering real-time data monitoring, the high-dimensional sensor observation should be converted into low-dimensional data by carrying out local data dimensionality reduction.

Several techniques like, Discrete Wavelet Transform (DWT) and Discrete Fourier Transform (DFT) were used for dimensionality reduction. However, most of these techniques require lots of storage space. Recently, Lin and Keogh et al. [13] proposed the Symbolic Aggregate approximation (SAX), the first symbolic representation for time series that allows for dimensionality reduction and indexing with a lower-bounding distance measure, based on Piecewise Aggregate Approximation (PAA) and assumes normality of the resulting aggregated values. When using SAX, the data is first transformed into the PAA representation and then symbolized into a sequence of discrete strings. The symbolization region is determined by looking up in statistical tables since the time series represent a Gaussian distribution. Breakpoints are represented as a sorted list of numbers such that the area under a Gaussian curve from

to . These breakpoints are determined by statistical tables. All PAA

coefficients that are below the smallest breakpoint are mapped to the symbol “a”, all coefficients greater than or equal to the smallest and less than the second smallest breakpoint are mapped to the symbol “b”, etc.[13].

In this paper, we will be using SAX with some modifications for data dimensionality, code and task reduction. Furthermore, by considering the real case of all nodes being prone to attack, we propose in this paper a dual weighted trust scheme

REsilient Double WEighted TruST Based (REDWEST) WSN Using SAX 19

for detecting and removing compromised nodes. Whenever a controller node is detected as malicious, the network will perform modifications by assigning a new controller so that the system will not be affected and continue to provide valid reports even under harsh environmental conditions.

The rest of the paper is organized as follows: Section two summarizes previous work related to fault detection schemes. Section 3 explains the proposed dimensionality reduction scheme. Section 4 describes the network topology to be used throughout the paper. Our resilient double trust based scheme is presented in section 5 and the experimental tests and results are shown in section 6. Finally, section 7 concludes the paper.

2 Related Work

The goal of fault detection is to verify that the services being provided are functioning properly, and in some cases to predict if they will continue to function properly in the near future. Fault detection techniques are classified as: self-diagnosis where the node itself can identify faults in its components, group- detection where several nodes monitor the behavior of another node, and hierarchical detection. The approach used in [3] which performs diagnosis based on accelerometers to determine if the node suffers from an impact that could lead to hardware malfunctions, the approaches used in [4], [5] and [12] which use voltage and signal strength anomaly and the approach used by [10] which use localization anomaly are all self-diagnosis techniques. Some of the drawbacks of these techniques are the incapability of sudden crash failures and the reliability on single node in decision making which can be already compromised.

The approaches used by Iyengar in [7] and Cheng et al. in [6], which are based on the idea that sensors from the same region should have similar values unless a node is at the boundary to calculate the probability of the node being faulty, and the approach used by Loureiro et al. in [11] which is based on nodes reading sensors signal strength measured by neighboring nodes and comparing its compatibility with the node's geographical position to detect malfunction are group-detection techniques. Group detection schemes are applicable. However, they have several drawbacks. They require large overhead needed for transmitting data which is a problem both for sending and processing, they are not energy efficient and the use of encryption is often impracticable, since this would hamper other nodes observing the contents of messages [8].

Hierarchical detection techniques use data aggregation techniques in their scheme. In [9], the authors proposed mechanism which uses a hierarchical network topology where cluster heads monitor ordinary nodes, and the base station monitors the cluster heads. To perform the monitoring, the base station and the cluster heads constantly ping those nodes that still have battery power left and that are under their direct supervision. If a node does not respond, it is marked as a failure. Lately a special type of attack where the compromised nodes behave normally but report false readings to lead to an incorrect decision has been investigated by Atakli. Et al. [1] this is a straightforward hierarchical detection approach and incurs less overhead since there is


no expensive calculation involved. They proposed the scheme of weighted trust evaluation (WTE) to detect malicious nodes. The weights of nodes are updated after each cycle by reflecting the ratio of the number of incorrectly reporting nodes to the total number of nodes. However, as explained by [2] the aggregated result of their scheme, calculated by the forwarding node cannot reflect the real situation, and the update of weight value cannot reflect change of credibility of the node itself. So they proposed a weighted-trust application (WTA) scheme. The weight of each sensor node in this scheme is updated based on the behavior of the node itself, making the node’s weight value more accurate and misdetection ratio distinctly lower. OH et al. in [14] found that both schemes proposed by Atakeli et al’s and Ju et al, are likely to detect malicious nodes by sacrificing some normal nodes. The loss of normal nodes might be problematic due to the resulting lack of network connectivity and sensing coverage. In addition, faults are only partially taken into account in detecting malicious nodes. They proposed a dual weighted trust evaluation scheme (DWE) in an environment where noise, natural faults and malicious nodes coexist. Each sensor node is assigned two trust values. The trust values are increased or decreased depending on the reading and aggregation result at the forwarding node. An efficient updating policy is used to keep mis-detection rate low while achieving high malicious node detection rate [14].

3 Dimensionality Reduction

Depending on the application, each sensor node will be equipped with a special type of sensor. In general, the sensor data can be divided into three categories: normal (sensor is unharmed and the condition is normal, e.g. no fire), critical (sensor is unharmed while the condition is critical, e.g. fire) and abnormal (sensor is compromised, malfunctioned or dead). Even though the data is divided into three regions, each region may include a large number of data points. It is assumed that each sensor node knows its location, which will be sent to the parent node each time a symbol is sent. We will first normalize these data points making the normal value assigned equal to zero. In addition to dimensionality reduction purpose, we will be using the symbols from SAX to determine the deviation of a sensor from the normal. So, we proposed a new symbol conversion scheme by performing some modifications on SAX’s look up table. SAX considers only positive values. However, in our case sensor readings can deviate from the normal from both sides (higher or lower) and should be penalized in the same manner. We have proposed a new look up table to perform the needed task. Table 1 is our proposed generalized look up table where the user is able to specify the complexity of the calculation. Increasing the number of breakpoints increases the number of levels (symbols). Although this would increase the accuracy of the system but it will increase the required discretization time.

For example, if we consider three regions in the table 1, the normalized sensor readings between [-0.43 and 0.43] will be converted to symbol “b” and the rest to symbol “a”. However, if SAX is used in this scenario, then the symbols would be “a” if the value is less than -0.43, “b” from [-0.43 and 0.43] and “c” if greater than 0.43.


Table 1. Digit to symbol conversion table

4 Network Topology

Our proposed system will have a four-layer architectural design, consisting of four types of sensor nodes: Simple Sensor Nodes (SS), Cluster Nodes (CL), Base Station (BS) nodes and the Sink Node (SN). SS nodes communicate directly with their CL nodes which in turn send their data to their BS parents, which finally send their data to the sink node. We shall assume that the SN has no limitations and is not vulnerable to any attacks. It receives the obtained readings, saves them for future use and takes the appropriate action in severe cases.

Fig. 1. Architecture of REDWEST

Sink Node(SN)layer

BaSe(BS)nodes layer

CLuster (CL)nodes layer

SimpleSensor (SS)nodes layer


Based on the four-layered architecture, the deployed sensors must be divided into these types depending on their positions. At launch, sensor nodes are randomly distributed on a given terrain which is divided into a predefined grid by the user. Each grid will have one CL node. Several neighboring nodes (depending on the grid dimension) will have one common BS node. So at first all sensors are assumed to be SS nodes. In order to select the CL and BS nodes, the system accomplishes the following steps:

1. Determines the nearest sensor node to the intersection of the neighboring grids and

designates it as BS. Each sensor node designated as BS will use its higher transmission capabilities to be able to communicate with all its children. This process is performed by the SN.

2. Determines the nearest sensor node from the center of the grid and designates it as a CL node. Each sensor node designated as CL will also use its higher transmission capabilities as well. This process is performed by the BSs.

It is assumed that this process is only performed using security measures. In this

way, the location of BS and CL children is provided securely. This is important so that parent nodes can detect Sybil attacks by the number of children they have and the mismatch in the position information sent by each sensor when transmitting its data.

Whenever a CL or a BS node has consumed its power, or is detected as malicious, Redwest will be able to find that due to its ability to find malicious and malfunctioning sensors and replace it by using the above conditions.

5 REDWEST

5.1 Proposed Algorithm

• Simple Sensor (SS) Node Layer: Sensor nodes (SSs), will read the data sensed by the sensor, perform the conversion from digit to symbol using our proposed SAX algorithm and send the data and its position through its antenna.

• Cluster Control (CL) Node Layer: After receiving the data from its children SS nodes, the CL node will validate the position information and find the letter which has the maximum occurrence and designate it as the normal value. Then, it will calculate the deviation of each node from the normal and penalize those nodes by decreasing their weight. In addition to deviation from normal, REDWEST considers the performance system as another important factor in the evaluation process. If an SS node sends five consecutive correct values with respect to the normal, the CL node will increase the weight of that SS node. Having the weight of each sensor, data aggregation will be performed by multiplying the data sent by their weight and finding the average. In this way, sensors being suspected as malicious will have less impact on the system and sensors that were giving wrong results in one occasion will have the chance to be considered as an important factor in the system. After aggregating the data, the CL node will send the result to the BS node.


• Base Station (BS) Node Layer: As we go up in the hierarchy, the number of children decreases, meaning that the received data will be reduced making the impact of a single node higher since the influence caused by an erroneous sensor will be higher. So we proposed to take firmer actions by performing two types of weight calculation schemes. In the first scheme, the algorithm adopted by the CLs utilizes harsher conditions: the tolerance of accepting wrong readings will be changed. In the second scheme, BSs will compare the average of data of sensors CLx1 found at a certain distance from the edge with its neighboring CLx2. Since the data sensed at the adjacent edges should be the same, then wrong results sent by two adjacent CLs would cause further decrease or increase in their weight.

5.2 Simulation Program and Adopted Formulas

The Symbol representations of each sensor in addition to its own reading will be collected by the CL node. If an SS node fails to send an accredited symbol or simply does not send any data due to battery failure or physical/software damage, the CL will consider its letter grade to be the last letter in the range. With the number of readings matching the number of children and the location sent by the sensor matching the one in its table, the CL node will determine the total count of each letter and designate the letter having the highest count as the normal value in the grid. In Table 2 the list of the used symbolic notations are given and explained.

Table 2. Symbolic Notations

Symbol

Meaning

E Aggregation result SS sensor node’s output. E.g. temperature reading Symbol value of SS sensor node’s output. E.g. “a”

Indicates if SS node’s reading matches the average value Sletter Count of sensors (with penalty) reading the value “letter” Wn Weight value of SS sensor n, which ranges from 0 to 1 Vn Weight value of CL sensor n, which ranges from 0 to 1 Dn Deviation of the sensor value from “letter” value S Number of regions selected by user Fn Number of “m” consecutive correct readings out of “n” Rn Number of wrong readings sent by a single SS node n M The most common letter (of all sensors in one grid) in a single round Mx1 The most common letter (of sensors on the right of grid) in a single round Mx2 The most common letter (of sensors on the left of grid) in a single round My1 The most common letter (of sensors on the top of grid) in a single round My2 The most common letter (of sensors on the bottom of grid) in a single round θ Positive penalty coefficient γ Negative penalty coefficient


In this paper, counting the number of occurrences of each letter is not performed using a primitive manner. Here also the idea of trust is used. This is performed to solve the Byzantine problem. Sensors which are detected as malicious (even if they are giving correct values on purpose) will not have influence on the counting phenomena. The count of sensors reading the “symbol” value is given by Sletter .Where Sletter represents, the sum of sensors whose quantized ( ) value of its output ( ) matches the normal symbol value “letter” multiplied by the weight of the sensor. Sletter can be obtained using the following formula: S ∑ WN where, 1 " "0 (1)

Consequently, if “a” and “b” are the two symbols used, then, S will give the number of sensors reading the symbol “a” and S will give the number of sensors reading symbol “b” taking into account their weight value. Having these values, CL will find the symbol having the highest S value and designate it as the most common letter M.

The CL node will now find out how much each sensor is deviated from the most common (normal) value, calculate the extent of irregularity, the number of consecutive successes and accordingly penalize each sensor. The updated penalty will be used in the next round.

We proposed to calculate the deviation from the normal value using the following formula: | 2 | (2)

Where dn is the deviation of each sensor in a single round and “s” is steps (region from table 1) selected by the user.

The main purpose behind this convention is adding the factor of error deviation to the penalty formula (eq.3) meaning that a sensor making a deviation δ from the normal will be penalized less than the sensor making an error (δ+λ).

This factor was not considered in previous work; however, we believe that sensors should be penalized depending on how much they are deviated from the average. A sensor that is slightly deviated due to a disaster in its area should not be penalized as much as a sensor giving a value with high deviation due to malfunction or intrusion. E.g. a fire can start near a sensor, so that sensor will read values slightly higher than neighboring sensors at round one. If this is the case, and a large penalty is given to that sensor then it will be considered as a faulty node where in fact it is not. In our system, the node will be penalized with a small factor and will be rewarded in the next round, since the average will tend to be that of a disaster state if fire spreads making more sensors to detect the phenomena.

The number of wrong readings (Rn) the sensor has made, is another factor to be considered in finding the penalty weight. This issue was considered in previous body of work. However, we believe that the number of wrong readings ought to have an


exponential impact on the weight factor. In fact, we selected the 1 factor since it gives the desired performance. The system will not tolerate a sensor giving more than 5 wrong readings and will give harsh penalties to sensors making more than 2 consecutive wrong readings.

We also proposed upgrading the weight value whenever the sensor has been affected by a natural noise. This scheme was recently used by Oh et al. in [14]. However, we think that the increase should not be done directly every time the sensor output matches the normal value. We propose to increase the weight if the sensor was able to send a certain number of consecutive correct readings out of a predefined number ( ). Selection of the parameter has an effect on the detection accuracy. By default, it is set to five out of ten. Hence, each five consecutive readings within the ten readings will increase by 1. After the ten consecutive readings, the number is reset. For stricter conditions, this value can be set to a firmer range such as eight correct readings out of ten.

Having the number of wrong readings ( ), the deviation from average ( ) and the number of five consecutive correct sensor readings obtained ( ), the CL node will calculate the weight value of each sensor in a single round. The weight can be increased or decreased depending on the behavior of a single node. The weight value represents the sensor node’s dependability. That is, the readings of a sensor node with a higher weight are more trustworthy and thus its readings will have higher influence in the aggregation process. Updating the values is important to reflect the correctness of the current readings in the future decision making process.

Updating the weights has two purposes. First, if a sensor node is compromised and is frequently sending its faulty readings that are inconsistent with the final decision, its weight is likely to be decreased. Second, if an abnormal reading was sent by the sensor on one occasion and later by resolving its problem became consistent, then the weight value has to be increased. This is reasonable since sensors with incorrect reading should have smaller impact on the final decision than those with correct readings.

Hence, summing up we propose the following equation to calculate the weight, where j indicates the present round:

1 1 (3) Where, 0 1.

In equation 3, the number of wrong readings ( ), with the selected exponential factor is deducted from the sensor’s previous weight. This means that, our formula is also based on the behavior of the sensor node itself. This was selected so that the penalty can depend on the number of mistaken reports which will increase the penalty exponentially. To add the ability to do fine adjustments, we have included the negative penalty coefficient (γ). Increasing this coefficient value will decrease the weight more rapidly. The value of γ can vary between 0.1 and 1.


On the other hand, the number of consecutive readings multiplied by the positive penalty coefficient θ is added to the previous sensor weight. The larger the value of θ is, the faster the increase of the weight value is when consecutive successes are achieved. The value of γ can vary between 0.1 and 1.

Finding the optimal values of θ and γ is essential in our mechanism since these parameters affect the detection time and accuracy of our proposed algorithm.

In (eq. 3), we notice that sensors having higher deviation will be penalized more. Based on updated weights, the CL node is able to detect a node as a malicious node if its weight is lower or equal to zero. Sensors indicated as malicious will be taken out of the system.

Moreover we have used in (eq. 3) the factor H to detect intruder nodes as well as Sybil and replication attacks, another factor H is added to (eq. 3), which is the validation factor. If the position of the sensor is not validated by its parent, a value of 1 will be assigned to H, otherwise H will be zero. Subtracting 1 in (eq. 3) leads to the removal of the sensor from the system directly. We assumed here that the probability of finding the exact position of a sensor by a malicious node is low, sensors do not have the ability of finding the position of their neighboring sensors and that the position information is forwarded to the BS and CL nodes in a secure way.

Next, the CL node will aggregate two values to be sent to the BS node. The normal value aggregated from all sensors of the grid and the normal side sensor’s values aggregated from the sensors having a minimum distance (defined by the user) from the sides.

To get the aggregation of the side sensors, the CL will use the same equations as above but instead of considering all sensors in the grid, it will consider the sensors which are positioned at the edge of the grid. This step will generate the values of the most common letter in the different sides of the grid, namely Mx1 on the right side, Mx2 on the left side, My1 on the top side and My2 on the bottom side.

Now, if we need to have the exact reading values and not just the letter characters then the aggregation equation will become:

(4)

Where E is the aggregation result, Wn is the weight ranging from 0 to 1 and Un the sensor reading.

After receiving the most common letters M, Mx1, Mx2,My1, My2, values from its children CLs, the BS node performs Aggregation based on the M values where each BS node will collect the data received from the four corners. Similarly, a BS node will find the most common letter Nn based on the weight Vn and the different Nn using previous formulas but with firmer conditions. Figure 2 summarizes the weight based aggregation system.


Fig. 2. Weight based aggregation of the hierarchical network REDWEST

The above steps are repeated whenever new information is to be reported to the sink node. The weight of each sensor is updated based on the correctness of the information. If the weight value of a sensor becomes less or equal to zero, it will be considered out of the system. If it happens to be a CL or a BS node, the system will designate that job to another sensor that has the necessary requirements by performing the steps explained earlier.

Sensor nodes whose weight value is less or equal to zero are excluded from the system; however, these nodes can join the aggregation process again if their weights increase to 1 by the user depending on the application.

6 Simulation Results

Several simulation experiments using Matlab[16] were conducted to evaluate the effectiveness and performance of REDWEST. In these simulations, we considered that a total of 900 temperature sensors were deployed in a forest which was divided to a 3 3 grid. The number of letters chosen was 5. Faults (dead, malicious, and malfunctioning sensors) and critical situations were introduced. In the case of dead sensors, it was assumed that these sensors would remain dead during the selected 100 runs, where a run is the process of all sensor readings being sent to SN node. Malicious nodes were picked randomly with a probability of an occurrence set by the user. To make the simulation as close to reality as possible, we assumed that the probability of an already selected node to be picked again as malicious was higher in the next round. In the performed tests we have evaluated the effectiveness of our proposed formulas with respect to previously used similar schemes. Also, resiliency, endurance, performance and dynamism tests were performed as functions of different factors such as: the number of sensors deployed, the number of runs performed (endurance test), the number of malicious nodes deployed, the number of permanent faults deployed, positive penalty coefficient θ, negative penalty coefficient γ, the 1 , H and factors.

To begin with, we considered θ = 0.2 and γ = 0.8 since we have to be strict with sensors making mistakes and on the other hand not tolerant with the sensors giving

Sink Node

SS node2 SS node3 SS node4

CL node1

SS node1

CL node2 CL node3 CL node4

BS node1 BS node2

SS node6 SS node7 SS node8SS node5

U'5

M4, Mxy4M3, Mxy3M2, Mxy2M1, Mxy1

U'6 U'8U'7U'1 U'2 U'3 U'4

N1 N2

V1 V2 V3 V4

Z2Z1

W2W1 W3 W4W5 W6W7 W8


correct values after incorrect readings. Endurance of the system was measured by varying the number of reading instances (runs) from 100 to 1000 runs.

Two probability factors were generated: possibility of sensors to be damaged, malfunctioning and out of power denoted by Pdead , and possibility of sensor to be malicious, reading incorrect readings and under the influence of attack denoted by Pproblematic . To consider very harsh environment, we took extreme bad conditions where the probability of dead sensors Pdead =0.10 and then the probability of problematic (damaged, having dead battery, created due to Sybil and malicious attacks) was increased. The system functioned error free until Pproblematic = 0.6.

From the first subplot (a) in Figure 3, it can be noticed that even with 10% dead sensor leading to 90 sensors in each grid with 60% of it not normal (malicious or

Fig. 3. General Outcome

(a)

(b) (c)

(d) (e)


malfunctioned), the system in the 100 runs gave only one mistaken output with a deviation of two letter grades. However, if we look at the remaining subplots, we can see that at that instance no unharmed sensors exist (d), less than 5 sensors were giving correct results (b), all sensors were penalized (c) and less than 20 sensors were alive (e). Moreover, even after the incorrect reading reported, the system was able to overcome this harsh situation due to our two way grading system. So we can say that the system is consistent, resilient, and was able to overcome our endurance test.

Fig. 4. Averages for every 5 run

Figure 4 magnifies what we previously noticed in figure 3. Here, instead of reading the result after each run, the average of every five runs was considered. We can see that after the 6th 5-Run step there are no remaining unharmed sensors, so all sensors on the terrain were malicious, dead or suspicious. It can also be noticed that in spite of having the number of correct readings most of the time less than half of the live sensors, the system was still able to give correct results (meaning correct temperature values). Furthermore, the system was able to revive itself by adding the non- malicious nodes to the system after they were temporarily removed due to erroneous readings. These come to substantiate what we previously already concluded previously.

Next, a comparison between our system and previous works that could be applied to our system is performed. Ju et al’s system WTA was considered, since it is an improved version of WTE. Figure 5 presents:

• The average reading of all sensor nodes in the grid considering dead and malicious sensor nodes denoted by Averages. It should be noted that sensors


giving no values will be read as 2 (i.e. the value of “2” is considered as an infinite reading).

• The average reading of all sensor nodes in the grid using Ju et al’s system, denoted by WTA averages.

• The average reading of all sensor nodes in the grid using our proposed system, denoted by REDWEST averages.

• The average reading of only sensor nodes in the grid which are giving correct values, denoted by Perfect Averages.

Fig. 5. Comparison Test

In comparison to Ju et al’s system WTA, it can be noticed that REDWEST has passed the endurance test by at least 100 Runs while WTA was able to last until the 60th round. Moreover, if we further continue this comparison, we notice that REDWEST was too close to the perfect results, while WTA was more sensitive to errors.

Survival rate is an equally important factor especially when the system is adopted in battlefields or harsh environmental conditions. We have also tested the system with high rate of attacks for longer periods of time. Figure 6, shows that although the system was under high rate of malicious attacks, it was able to overcome it and gave correct answers.

Numerically speaking if 60% of the 90 sensors are malicious at every run then the system will collapse after eight runs at extreme conditions. REDWEST on the other hand is functioning perfectly until the 120th run even when all the sensors are damaged. The output was wrong only when none of the sensors were giving correct results, which is very normal. If we compare it with WTA, we can notice how REDWEST’s lifetime and endurance is high. In fact, it gave near perfect results except in situations where none of the sensors were functioning correctly, while WTA stopped functioning after 60 Runs. Finally, in order to find the optimal values of the positive penalty coefficient (θ) and the negative penalty coefficient (γ) we considered ratio ∂.

Redwest Perfect Averages

Averages WTA


Fig. 6. System’s performance under long term stress

∂ system correctnessmean correctlive sensors (5) After considering different combinations of θ and γ, the simulation results showed

that θ= 0.2 γ=0.8 combination gives the best results. By taking γ=0.8 we are decreasing the weight of a wrong sensor rapidly. However, taking θ=0.2 means that we are increasing the weight of the correct sensor smoothly. In this way the system will have enough time to decide whether the sensor was malicious or was under the effect of thermal noise.

7 Conclusion

In this paper, we proposed a novel dual weighted trust evaluation based scheme to detect compromised or misbehaved nodes in hierarchical WSNs. Trust values of sensor nodes are used as weights decided by the parent node to reflect the correctness of a sensor node’s reports in decision-making procedures. The weights are updated in such a way that normal nodes with weights equal to 1 will retain their values, while those with weights less than one will be put in testing phase. If five consecutive correct values are recorded, then the trust value is increased. On the other hand, malicious nodes behaving differently from normal nodes gradually lose their weights and nodes having weight value equal to zero are excluded from the system.

Redwest

Averages WTA

Perfect Averages


In this paper, a modified SAX was used in order to minimize the transmitted data and to increase the system accuracy. Several equations were also proposed to test and calculate the different coefficients of the proposed algorithm.

As possible future work, we propose to add energy level to our weight formula hence solving the problems caused directly by selfish nodes. In this way, sensors having high power will be more trusted especially in the case of CL and BS nodes. Furthermore, additional aspects can be added to detect any source of replication leading to Sybil attacks; and to minimize extra security procedures used by security measures which consume several resources like energy and storage.

References

1. Atakli, I.M., Hu, H., Chen, Y., Ku, W.-S., Su, Z.: Malicious Node Detection in Wireless Sensor Networks using Weighted Trust Evaluation. In: The Symposium on Simulation of Systems Security (SSSS 2008), Ottawa, Canada, April 14-17 (2008)

2. Ju, L., Li, H., Liu, Y., Xue, W., Li, K., Chi, Z.: An Improved Intrusion Detection Scheme based on Weighted Trust Evaluation. In: The IEEE 2010 Proceedings of the 5th International Conference on Ubiquitous Information Technologies and Applications, CUTE (2010)

3. Harte, S., Rahman., A.: Fault Tolerance in Sensor Networks Using Self-Diagnosing Sensor Nodes. In: The IEE International Workshop on Intelligent Environment, pp. 7–12 (June 2005)

4. Benini, L., Castelli, G., Macii, A., Macii, E., Poncino, M., Scarsi, R.: A Discrete-Time Battery Model for High-Level Power Estimation. In: Proceeding of the Design, Automation and Test in Europe Conference and Exhibition 2000, pp. 35–39 (2000)

5. Rakhmatov, D., Vrudhula, S.B.: Time-to-Failure Estimation for Batteries in Portable Electronic Systems. In: Proceedings of the 2001 International Symposium on Low Power Electronics and Design, pp. 88–91 (2001)

6. Ding, M., Chen, D., Xing, K., Cheng, X.: Localized fault-tolerant event boundary detection in sensor networks. In: INFOCOM (2005)

7. Krishnamachari, B., Iyengar, S.: Distributed Bayesian Algorithms for Fault-Tolerant Event Region Detection in Wireless Sensor Networks. IEEE Transactions on Computers 53, 241–250 (2004)

8. Marti, S., Giuli, T.J., Lai, K., Baker, M.: Mitigating Routing Misbehavior in Mobile Ad hoc Networks. In: Proceedings of the 6th Annual International Conference on Mobile Computing and Networking, pp. 255–265 (2000)

9. Ruiz, L.B., Wong, H.C., Siqueira, I.G., Marcos, J., Nogueira, S., Loureiro, A.A.F.: Fault Management in Event-driven Wireless Sensor Networks. In: Proceedings of the 7th ACM International Symposium on Modeling, Analysis and Simulation of Wireless and Mobile Systems, pp. 149–156 (June 2004)

10. Du, W., Fang, L., Ning, P.: LAD: Localization Anomaly Detection for Wireless Sensor Networks. In: 19th International Parallel and Distributed Processing Symposium (IPDPS 2005), Denver, Colorado, USA, April 3-8 (2005)

11. Junior, W., Figueriredo, T., Wong, H.-C., Loureiro, A.: Malicious Node Detection in Wireless Sensor Networks. In: 18th International Parallel and Distributed Processing Symposium (IPDPS 2004), Santa Fe, New Mexico, USA, April 26-30 (2004)

Sensor Systems and Software · 2014. 11. 4. · 123 Marco Zuniga Gianluca Dini (Eds.) Sensor Systems and Software 4th International ICST Conference, S-Cube 2013 Lucca, Italy, June

Documents