1. Data Consistency in Sensor Networks: Secure Agreement Fatemeh Borran Supervised by: Panos Papadimitratos, Marcin Poturalski Prof. Jean-Pierre Hubaux IC-29 Self-Organised Wireless and Sensor Networks

2. Outline Introduction Problem Statement Assumptions System Model Algorithms Results Conclusion March 6, 20072

3. Introduction Classical Sensor Networks –centralized and reliable base station –one-to-many association Distributed Sensor Networks –decentralized architecture –every node could be faulty or malicious –many-to-many association March 6, 20073

4. 4 Problem Statement Environment produces single actual value α Each sensor node measures the noisy environment Measurement error is bounded by ε All sensor nodes don’t behave correctly incorrect measurement or malicious behavior Problem: value of single sensor node is not reliable Goal: ensure data consistency among sensor nodes Approach: agreement on actual value α

5. March 6, 20075 Fault Model Correct Sensor: behave according to the protocol specification measurement error is bounded by ε Faulty Sensor: measurement error is not bounded follow assigned protocol Byzantine Sensor: under control of a unique adversary behave arbitrary (crash-failure, omission-failure,…) |F|≤ k |B|≤ t |C|≥ n-k-t

6. March 6, 20076 System Model System Synchronous: transmission delay and process speed are bounded and known Asynchronous: slow process is not detectable Authentication Unique identity and signature A modified message is detectable Communication Channels Integrity: every received message was previously sent No-duplication: each message is received at most once Reliability: messages sent by a correct node are received by all nodes and are not modified.

7. March 6, 20077 Secure Agreement Problem Properties: Validity: if s i decides v, then |v-v i |≤ε and v i is initial value of some non-Byzantine node Strong Validity: if s i decides v, then |v-α|≤ε Agreement: if s i decides v i and s j decides v j then |v i -v j |≤Φ Termination: every non-Byzantine node eventually decides Primitives: broadcast( v i ) decide( v )

8. March 6, 20078 Algorithm I: Synchronous One-hop V p := r := 1 while r < t+1 do broadcast(V p ) to all nodes V p := V p U {V q | V q is received from q} r := r + 1 end while T := all duplicated values in V p V p := V p - T decide(f(V p )) f : trimming and averaging function W p := reduce(V p,k+t-|T|/2) f(V p ) := mean(W p ) r ≤ 1

9. March 6, 20079 Theorem I Theorem I: Algorithm I solves secure agreement for one-hop synchronous sensor networks with authenticated messages. Lemma I: After t+1 rounds, all nodes have the same set. Lemma II: All nodes apply the same deterministic function: f. Communication complexity: O ((t+1)n 2 ) S PQ x Round 1 S PQ x Round 2 S PQ x Round 1 S PQ x Round 2 y y S is Byzantine

10. March 6, 200710 Algorithm II: Synchronous One-hop r := 1 while true do broadcast(x p ) to all nodes V p := U { | x q is received from q} W p := reduce(V p,t+k) x p := median(W p ) if (δ(W p ) < Φ) then decide(x p ) end if r := r + 1 end while Φ = ε => one round is required Φ two rounds are required δ(W p ):= max(W p ) – min(W p )

11. March 6, 200711 Theorem II Theorem II: Algorithm II solves secure agreement for one- hop synchronous sensor networks with authenticated messages. Lemma I: W p contains only the values from correct nodes. Lemma II: Every faulty node corrects its value after first round. Communication complexity: O (n) Question: Is it possible to achieve O (c) complexity?

12. March 6, 200712 Algorithm III: Synchronous One-hop r := 1 S := arbitrary set of 2t+2k+1 nodes while true do if p in S then broadcast(x p ) to all nodes end if … // same as Algorithm II r := r + 1 end while Communication complexity: O (2t+2k+1)

13. March 6, 200713 Modified Algorithm II: Asynchronous One-hop r := 1 while true do broadcast(x p ) to all nodes V p := U { | x q is received from q} if (|V p | ≥ n-t) then W p := reduce(V p,t+k) x p := median(W p ) if (δ(W p ) < Φ) then decide(x p ) end if r := r + 1 end while |V|: cardinality of V Φ = ε => one round is required in best case Φ t rounds are required in best case

14. Multi-hop Communication Connectivity: there is a path between each pair of non- Byzantine nodes in the network. t-connectivity: there are no t nodes whose removal disconnects the network March 6, 200714 Correct node Faulty node Byzantine node Communication range unconnected network

15. Multi-hop Communication Connectivity: there is a path between each pair of non- Byzantine nodes in the network. t-connectivity: there are no t nodes whose removal disconnects the network March 6, 200715 Correct node Faulty node Byzantine node Communication range unconnected network

16. Multi-hop Communication Connectivity: there is a path between each pair of non- Byzantine nodes in the network. t-connectivity: there are no t nodes whose removal disconnects the network March 6, 200716 connected network Correct node Faulty node Byzantine node Communication range

17. March 6, 200717 Modified Algorithm I: Synchronous Multi-hop V p := r := 1 while r < t+d+1 do broadcast(V p ) to all nodes V p := V p U {V q | V q is received from q} r := r + 1 end while T := all duplicated values in V p V p := V p – T decide(f(V p )) f : trimming and averaging function W p := reduce(V p,k+t-|T|/2) f(V p ) := mean(W p ) d: network diameter r < d+1

18. March 6, 200718 Theorem III Theorem III: Algorithm I solves secure agreement for multi-hop synchronous sensor networks with authenticated messages. Lemma I: After t+d+1 rounds, all nodes have the same set. Lemma II: All nodes apply the same deterministic function: f. Lemma III: t-connectivity ensures agreement and termination. Communication complexity: O ((t+d+1)n 2 )

19. March 6, 200719 Algorithm IV: Asynchronous Multi-hop V p := r := 1 while true do broadcast(V p ) to all nodes V p := V p U {V q | V q is received from q} if (|V p | > 2(t+k)) then W p := reduce(V p,t+k) x p := median(W p ) if (δ(W p ) < Φ) then decide(x p ) end if V p := r := r + 1 end while Φ = ε => one round is required in best case Φ n-2t-2k rounds are required in best case

20. March 6, 200720 Theorem IV Theorem IV: Algorithm IV solves secure agreement for multi-hop asynchronous sensor networks with authenticated messages. Lemma I: Within 2(t+k)+1 values, t+k+1 values are correct. Lemma II: All nodes apply the same deterministic function: f. Lemma III: t-connectivity ensures termination. Communication complexity: O (2(t+k)n)

21. Results: One-hop March 6, 200721 AlgorithmSystemAssumptionCommunication complexity Algorithm ISynchronousn > 2t+2kO(n 2 ) Algorithm IISynchronousn > 2t+2kO(n) Algorithm IIISynchronousn > 2t+2kO(2(t+k)) Algorithm II’Asynchronousn > 3t+2kO(n) * Table I: Secure Agreement with Strong Validity * best case results

22. Results: One-hop March 6, 200722 AlgorithmSystemAssumptionCommunication complexity Algorithm ISynchronousn > 2tO(tn 2 ) Algorithm IISynchronousn > 2tO(tn) Algorithm IIISynchronousn > 2tO(2t(t+k)) Algorithm II’Asynchronousn > 3tO(tn) * Table II: Secure Agreement with Validity * best case results

23. Results: Multi-hop March 6, 200723 AlgorithmSystemAssumptionCommunication complexity Algorithm I’Synchronousn > 2t+2kO(dn 2 ) Algorithm IVAsynchronousn > 2t+2kO(2(t+k)n) * Table III: Secure Agreement with Strong Validity * best case results

24. Results: Multi-hop March 6, 200724 AlgorithmSystemAssumptionCommunication complexity Algorithm I’Synchronousn > 2tO((t+d+1)n 2 ) Algorithm IVAsynchronousn > 2tO(2(t+k)(n-2t-2k)n)* Table IV: Secure Agreement with Validity * best case results

25. March 6, 200725 Conclusion Distributed sensor networks vs. Classical sensor networks. save communication bandwidth provide redundancy eliminate single-point of failure use broadcast instead of unicast inform quickly and easily the end-user Data consistency as agreement problem. New variant of agreement problem: secure agreement. Φ can be chosen arbitrarily small to get as close to consensus as desired. t-connectivity is not required to be held in every round.

26. March 6, 200726 Future works Strong validity requires n>2(t+k) Impossibility results with n≤2(t+k) ? Asynchronous algorithm with constant communication complexity? Analyse communication complexity of worst case in asynchronous algorithms? Simulation results