A Cluster-Based Secure Synchronization Protocol for Underwater Wireless Sensor Networks

Abstract

Secure time synchronization is one of the key concerns for Underwater Wireless Sensor Networks (UWSNs). This paper presents a CLUster-based Secure Synchronization (CLUSS) protocol that ensures the security of synchronization under harsh underwater environments against various attacks, including Sybil attack, replay attack, message manipulation attack, and delay attack. The time synchronization process of CLUSS is divided into three phases: authentication phase, intercluster synchronization phase, and intracluster synchronization phase. During the authentication phase, cluster heads are authenticated to beacons and ordinary nodes are authenticated to cluster heads. During the process of intercluster and intracluster synchronization phases, CLUSS distinguishes the propagation delay of downlink from that of uplink caused by node movement in order to improve time synchronization accuracy. Moreover, part of these two phases can be executed concurrently for reducing the number of messages generated in synchronization. We demonstrate through simulations that CLUSS can reduce synchronization errors as well as energy consumption compared to traditional protocols in various circumstances.

1. Introduction

Underwater Wireless Sensor Networks (UWSNs) have a lot of potential application areas such as oceanographic data collection, disaster prevention, pollution monitoring, offshore exploration, and military surveillance [1–3]. UWSN is a new area of wireless sensor network in underwater environments which has challenges to be overcome such as long propagation delay, severely limited bandwidth, and unpredictable node movement [4–6]. All the above distinct features of UWSNs give birth to new challenging areas for every level of the network protocol suite. Among them, providing clock synchronization is a well-known fundamental issue due to the unique characteristics of UWSNs [7, 8]. A number of important network functionalities require that nodes have a common notion of time, including time stamping of events, distributed data aggregation, MAC, and localization. Meanwhile, numerous time synchronization protocols have been proposed for terrestrial wireless sensor networks, such as RBS [9], TPSN [10], and FSTP [11]. However, they cannot be directly applied to UWSNs, because most of them assume negligible propagation delay among sensor nodes, which is not true in UWSNs. On the other hand, as UWSNs are often deployed in an inaccessible and hostile environment, those unattended sensor nodes are likely to incur many critical security attacks, including Sybil attack, replay attack, message manipulation attack, and delay attack [12, 13]. Therefore, time synchronization must resist modification attempts by attackers, especially in applications such as military surveillance and oceanographic data collection.

Time synchronization attacks have great effects on a set of sensor network applications and services since they heavily rely on accurate time synchronization to perform their respective functions. All attacks on time synchronization protocols of UWSNs aim to deceive some nodes that their neighbor's clocks are at a different time than they actually are. In Sybil attack, a malicious node pretends to have multiple identities. In some cases, an attacker can simply create fabricated identities. If the name space is intentionally limited to prevent attackers from fabricating identities, they can also destroy or temporarily disable the impersonated nodes and assign stolen identities to malicious nodes. In replay attack, a valid data transmission is maliciously or fraudulently repeated. An attacker can take part in distributing timing messages among its neighbor nodes. As a result, old timing messages could be deceitfully issued as legitimate messages to its neighbor nodes for disrupting the timing synchronization process. In message manipulation attack, an attacker may drop, modify, or even forge the exchanged timing messages to interrupt the process of time synchronization. In a delay attack, an attacker intentionally delays some of the time messages in order to disrupt the time synchronization process and cause it to fail. If this attack infiltrates into the system, it cannot be prevented using traditional cryptographic techniques.

In this paper, we propose a novel CLUster-based Secure Synchronization (CLUSS) protocol that concerns security as well as accuracy in synchronization. Before time synchronization, CLUSS needs to execute the process of cluster formation securely by means of cluster consistency checking. After that, CLUSS performs the process of time synchronization, which can be divided into three phases: authentication phase, intercluster synchronization phase, and intracluster synchronization phase. During the authentication phase, all sensor nodes need to be authenticated to each other and the identified malicious nodes will be removed from the network. During the intercluster synchronization phase, cluster heads synchronize themselves with beacons in sender-receiver mode. And then, ordinary nodes synchronize themselves with cluster heads in receiver-receiver mode during the intracluster synchronization phase. Part of intercluster synchronization phase and intracluster synchronization phase can be executed concurrently in order to reduce the number of messages generated in synchronization. In order to improve time synchronization accuracy, CLUSS detects abnormal end-to-end delay data and identifies malicious nodes. Additionally, CLUSS also distinguishes the propagation delay of downlink from that of uplink caused by node movement during the process of calculating clock skew and offset. Numerical simulations confirm the suitability of our protocol compared with the current schemes.

The remainder of the paper is organized as follows: Section 2 presents a brief overview of related work. Section 3 presents the technical details of our time synchronization protocol. Performance evaluation is described in Section 4. Finally, we conclude the paper in Section 5.

2. Related Work

In the literature, there are various time synchronization protocols for distributed systems like terrestrial radio sensor networks. RBS (Reference Broadcast Synchronization) [9] is a well-known receiver-receiver synchronization protocol that synchronizes a set of receivers with one another by periodically sending beacon messages to their neighbors. Recipients use the message's arrival time as a point of reference for comparing their clocks. However, RBS requires extra message exchange to communicate the local timestamps between any two nodes which intend to become synchronized. TPSN (Timing-sync Protocol for Sensor Networks) [10] is based on the sender-receiver time synchronization, which employs a two-way message exchange for synchronization. Although TPSN takes care of propagation delays, it does not take the clock skew into account during synchronization period. FTSP (Flooding Time Synchronization Protocol) [11] supports network topology changes including mobile nodes. The applied flood-based communication protocol provides a very robust network, but it is not applicable to underwater sensor network mainly because it also assumes instant reception of messages. TSHL (Time Synchronization for High Latency) [14] is the first time synchronization algorithm designed for high latency networks specifically. It uses one-way communication to estimate the clock skew and two-way communication to estimate the clock offset. TSHL assumes that underwater sensor networks are static and therefore suffers from sensor nodes mobility, especially when nodes move fast. D-Sync [15] provides an indication of the relative motion between nodes. In D-Sync, Doppler shift is used in order to infer the propagation delay and an ordinary least square estimator is applied to provide an estimate for both clock skew and offset. However, in deriving the estimators, communication channel variability is not taken into account, which reduces the accuracy of synchronization. MU-Sync [16] runs two times of linear regression to estimate the clock skew and clock offset for cluster based UWSNs. MU-Sync assumes that the one-way propagation delay can be estimated as the average round trip time, which causes extra errors and has relative high message overhead. Moreover, none of these protocols take security as one of their goals. Consequently, an adversary can easily attack any of these time synchronization protocols by capturing a fraction of the nodes and have them distribute faulty time synchronization messages. In effect, the nodes in the entire network will be out-of-sync with each other. WATERSync [17] is a correlation-based time synchronization protocol specifically for shallow underwater sensor networks. WATERSync integrates the time synchronization procedure with the tree-like network routing topology in vertical direction (the surface station is the tree root), which consists of Gradual Depth Timing (GDT) phase and Level 1 (i.e., between the surface station and first depth nodes) Skew Compensation (LSC) phase. To make the time synchronization dependable, WATERSync adopts a correlation-based security model to detect outlier timestamp data and identify malicious nodes. However, horizontal direction is neglected during the process of time synchronization, which results in high offset errors.

3. Proposed Scheme

3.1. Network Topology and Cluster Formation

We consider that a UWSN is composed of a large number of nodes uniformly scattered in monitoring fields and represented by $G = (V, E)$ , where V denotes the set of vertexes (nodes) and E is the set of communication links. We assume that the set of n safe nodes is represented as a set $V_{s}$ and the set of m malicious nodes is represented as a set $V_{m}$ , where $V = V_{s} \cup V_{m}$ . Each node only knows about its direct neighboring nodes and communicates with them when necessary without any advanced knowledge about whether they are safe nodes or malicious nodes. All sensor nodes are assumed to be static, or they have low mobility with respect to signal propagation speed. Every sensor node has the same transmission range and is able to communicate with other sensor nodes within its range. We also assume that each node is assigned with a triplet of coordinate $(x, y, z)$ , where each coordinate represents the hop distance of the node from one anchor. All sensor nodes have the same communication range of r, which is represented as a sphere volume of radius r in a UWSN.

Definition 1.

The function $δ (u, v)$ defines the distance between two nodes $n_{u}$ and $n_{v}$ in a 3D Euclidean space as

\begin{matrix} δ : N \times N ⟶ Γ : δ (u, v), \\ δ (u, v) = \sqrt{{(u_{x} - v_{x})}^{2} + {(u_{y} - v_{y})}^{2} + {(u_{z} - v_{z})}^{2}} . \end{matrix}

(1)

Two nodes $n_{u}$ and $n_{v}$ are neighbors and connected by a link if $δ (u, v) < r$ and the link between $n_{u}$ and $n_{v}$ is denoted by $e (u, v)$ . The node degree of $n_{u}$ is the number of links incident to $n_{u}$ , which is denoted by $D_{u}$ . We construct the network topology with RNG (Relative Neighborhood Graph) [18], and then two nodes become neighbor nodes if and only if for any arbitrary node $n_{p}$ , $δ (u, v) \leq \max {δ (p, u), δ (p, v)}$ . For a three-dimensional Euler space embedded, if the arcuate area formed by the intersection of two spheres centered at $n_{u}$ and $n_{v}$ (with radius $δ (u, v)$ ) is empty, then $n_{u}$ and $n_{v}$ are adjacent nodes. RNG algorithm is simple and is easily built in a distributed way. There is no crossing edges in a RNG because at least one edge in any pair of crossing edges must be removed according to their definitions and the time complexity is $O (n^{3})$ . While constructing from a Delaunay Triangulation Graph structure, its complexity of lower bound is $O (n \log (n))$ [19]. In addition, a computational method with the complexity of $O (n^{2})$ for the RNG in a three-dimensional space is given in [20]. As underwater sensors float with currents, their movements are constrained in different horizontal planes and they are likely to maintain a steady position relative to each other. The construction of RNG does not require that the exact positions of nodes and their neighbors are known. For each node, only the corresponding mutual distances to its neighbors are required. Therefore, RNG is expected to be more suitable in modeling UWSN, which achieves more accurate results and behaves more consistently than other models. In fact, we model a UWSN with a RNG, not form a RNG overlay on top of a random geometric graph. The deployment of a UWSN is deemed to be sparser than that of a terrestrial sensor network due to the cost involved and to the challenges associated to the deployment itself in the underwater environment. Therefore, modeling a UWSN with a random geometric graph is not suitable for selection in view of the connectivity especially when sensor nodes are not evenly distributed.

CLUSS is a CLUster-based Secure Synchronization protocol. Given a UWSN, the whole network is composed of three types of nodes: beacons, cluster heads, and ordinary nodes. Beacons have unlimited energy resources and perfect timing information. For example, they can synchronize to UTC (Universal Time Coordinated) time constantly using GPS services without recalibrating their atomic clocks or performing any synchronization algorithms. In this regard, they provide the time reference for the sensors positioned underwater. If there are two or more beacons, they can communicate with each other through radio frequency (RF) links. Beacons communicate with cluster heads and ordinary nodes through acoustic links. Each cluster has and only has one cluster head. All ordinary nodes connect to their cluster head via single hop. The cluster heads of different clusters connect to a beacon through multiple hops. Figure 1 shows the topology of a UWSN with 8 sensor nodes and one beacon. The beacon is placed on the water surface and is equipped with GPS to obtain UTC time. Each sensor node is assigned a unique identifier (ID). The sensor nodes make autonomous decision about cluster formation without any centralized control.

Figure 1

The topology of a UWSN with 8 sensor nodes.

Definition 2.

Suppose that the cluster for node $n_{u}$ is denoted as $C_{u}$ ; then for each node, $n_{v} \in C_{u}$ ; if $C_{v} = C_{u}$ , then cluster consistency is satisfied; else if there exists a node $n_{w} \in C_{u}$ such that $C_{w} \neq C_{u}$ , then it is called cluster inconsistency.

Definition 2 gives the meanings of cluster consistency and cluster inconsistency. According to Definition 2, each sensor node belongs to one and only one cluster. Different clusters cannot share any common sensor nodes. It is important for sensor nodes to perform cluster consistency checking during the process of cluster formation.

The process of cluster formation for a UWSN is described as in the following step-by-step instructions.

Step 1. All sensor nodes with 1-hop distance to a beacon are set to cluster heads.

Step 2. Each cluster head will try to add its neighboring nodes as ordinary nodes that belong to its cluster in order of their degrees from high to low. If a sensor node happens to be the neighboring node of multiple cluster heads, it will be assigned to the cluster head with the smallest ID as an ordinary of that cluster.

Step 3. Each ordinary node will try to find its neighboring nodes with 2-hop distance to the cluster head of its current cluster for the purpose of forming new clusters. If there is such a sensor node, the ordinary node will update itself to be the cluster head of a new cluster and add other neighboring nodes with 2-hop distance to its former cluster head into the new cluster as ordinary nodes.

Step 4. Repeat Step 2 and Step 3 until all sensor nodes have identities of either cluster heads or ordinary nodes.

Step 5. Each sensor node performs cluster consistency checking. If it identifies malicious nodes, it removes them from the network and restarts the cluster formation process from Step 1.

Figure 2 shows the process of cluster formation for a UWSN with 8 sensor nodes. Each circle denotes an ordinary node and each concentric circle denotes a cluster head in the UWSN. The concrete steps are given as follows.

Figure 2

The process of cluster formation for a UWSN with 8 sensor nodes.

Step 1. Node 000 and node 001 are set to cluster heads as they are 1-hop distance to the beacon as shown in Figure 2(a).

Step 2. Node 000 tries to add its neighbors as ordinary nodes of its cluster in order of their degrees from high to low, that is, node 011 ( $D_{011} = 5$ ), node 101 ( $D_{101} = 4$ ), and node 010 ( $D_{010} = 3$ ). Likewise, node 001 tries to add its neighbors as ordinary nodes of its cluster in order of node 011 ( $D_{011} = 5$ ), node 110 ( $D_{110} = 4$ ), and node 100 ( $D_{100} = 2$ ). As the ID of node 000 is smaller than that of node 001, node 011 will become an ordinary node in the cluster of node 000 as shown in Figure 2(b).

Step 3. The ordinary node 101 in the cluster of node 000 finds that its neighboring node 111 is located 2-hop away from the cluster head node 000. In the same way, the ordinary node 110 in the cluster of node 001 also finds node 111 with 2-hop distance to the cluster head node 001. Since the ID of node 101 is smaller than that of node 110, node 101 will update itself as the cluster head of a new cluster and add node 111 into its cluster as shown in Figure 2(c).

Hereafter, all sensor nodes are assigned identities of either cluster heads or ordinary nodes. After cluster consistency checking, the process of cluster formation is completed.

An attacker may participate in the process of cluster formation using malicious nodes. These malicious nodes can launch different attacks in order to introduce cluster inconsistency. However, as each sensor node has a unique ID, all unicast messages exchanged between nodes can be authenticated with unique pair-wise keys shared with other nodes and broadcast messages can be authenticated with public key based digital signatures. By such means, the process of cluster formation can be executed securely.

3.2. Time Synchronization Protocol

The time synchronization of CLUSS can be divided into three phases: authentication phase, intercluster synchronization phase, and intracluster synchronization phase. During the authentication phase, all sensor nodes need to be authenticated to each other. Cluster heads are authenticated to beacons and ordinary nodes are authenticated to cluster heads. During the intercluster synchronization phase, cluster heads synchronize themselves with beacons in sender-receiver mode. During the intracluster synchronization phase, ordinary nodes synchronize themselves with cluster heads in receiver-receiver mode. In order to reduce the number of messages generated in synchronization, part of intercluster synchronization phase and intracluster synchronization phase can be executed concurrently. Although many existing sender-receiver and receiver-receiver based clock synchronization protocols can be interpreted by common statistical signal processing methods, it is still too early to say that these techniques can get rid of cluster or tree structure especially in those wireless sensor networks with characteristics of long propagation delay and high mobility. The basic idea of our synchronization protocol is simple but effective in realizing time synchronization even when the network is attacked by malicious nodes. To the best of our knowledge, this is the first work that describes secure synchronization protocol for underwater wireless sensor networks.

3.2.1. Authentication between Nodes

We adopt the following notations throughout the description of the protocol as shown in Notations Section.

After the process of cluster formation, all sensor nodes know ID and nonce information of their neighboring nodes. The compromised nodes may attempt to provide falsified clock values, which in turn make the clock adjustment deviate from its desired value. Therefore, each sensor node must authenticate the trustworthiness of synchronization messages it receives from its neighboring nodes before using them for synchronization. In order to realize authentication in the whole network, beacons play an important role during the whole process of authentication. Firstly, cluster heads will be authenticated to beacons. Suppose that C is a cluster head with 1-hop distance to a beacon B. For the purpose of authentication with the beacon B, the cluster head C generates its secret key $S K_{C}$ and signs its nonce $N_{C}$ with $S K_{C}$ , which then becomes $S K_{C} (N_{C})$ . Moreover, the cluster head C also generates a hash value $H_{C B 0} = H 〈 {ID}_{C}, {ID}_{B}, N_{C} 〉$ and signs $H_{C B 0}$ with $S K_{C}$ , which then becomes SIG_ $S K_{C} (H 〈 {ID}_{C}, {ID}_{B}, N_{C} 〉)$ . Both $S K_{C} (N_{C})$ and SIG_ $S K_{C} (H 〈 {ID}_{C}, {ID}_{B}, N_{C} 〉)$ are sent to the beacon B. On the other hand, the beacon B attempts to decrypt $S K_{C} (N_{C})$ using C's public key ${PK}_{C}$ and get the original $N_{C}$ . Furthermore, the beacon B also attempts to decrypt SIG_ $S K_{C} (H 〈 {ID}_{C}, {ID}_{B}, N_{C} 〉)$ using C's public key $P K_{C}$ and get the original $H_{C B 0}$ . After that, the beacon B generates a hash value $H_{C B 1} = H 〈 {ID}_{C}, {ID}_{B}, N_{C} 〉$ and compares $H_{C B 1}$ with $H_{C B 0}$ . If $H_{C B 1}$ matches $H_{C B 0}$ , then the beacon B generates another hash value $H_{B C 0} = H 〈 {ID}_{B}, {ID}_{C}, N_{B}, N_{C} 〉$ and signs $H_{B C 0}$ with its secret key $S K_{B}$ , which then becomes SIG_ $S K_{B} (H 〈 {ID}_{B}, {ID}_{C}, N_{B}, N_{C} 〉)$ . In addition, the beacon B also signs its nonce $N_{B}$ with $S K_{B}$ , which then becomes $S K_{B}$ ( $N_{B}$ ). In turn, the beacon B sends $S K_{B}$ ( $N_{B}$ ) and SIG_ $S K_{B} (H 〈 {ID}_{B}, {ID}_{C}, N_{B}, N_{C} 〉)$ to the cluster head C. After receiving $S K_{B} (N_{B})$ and SIG_ $S K_{B} (H 〈 {ID}_{B}, {ID}_{C}, N_{B}, N_{C} 〉)$ , the cluster head C decrypts them using B's public key ${PK}_{B}$ and get the original $H_{B C 0}$ and $N_{B}$ . Moreover, the cluster head C generates a hash value $H_{B C 1} = H 〈 {ID}_{B}, {ID}_{C}, N_{B}, N_{C} 〉$ and compares $H_{B C 1}$ with $H_{B C 0}$ . If $H_{B C 1}$ matches $H_{B C 0}$ , then the authentication is successful; otherwise, the authentication is failed. Likewise, ordinary nodes can be authenticated to cluster heads. After the execution of authentication phase, all neighboring nodes are authenticated with each other and they can communicate with each other securely.

In UWSNs, sensor nodes are usually equipped with crystal oscillators for providing local times. Due to aging and environmental factors (such as temperature, pressure, and vibration), these oscillators will gradually exhibit deviations as shown in Figure 3.

Figure 3

Two real clocks with linear and nonlinear deviations from ideal UTC time (initial offset equal to 0).

Assuming the existence of clock skew and drift, the clock value $T_{A} (t)$ can be defined as the following Taylor series [21]:

\begin{matrix} T_{A} (t) = α_{a} t + β_{a} + γ_{a} t^{2} + \dots, \end{matrix}

(2)

where

T_{A} (t)

stands for the measured time of the sensor node A; t is the reference time (UTC time); the linear parameter

α_{a}

denotes the clock skew; the coefficient

β_{a}

can be associated with the initial offset of clock; and the quadratic parameter

γ_{a}

represents nonlinear deviation from the reference time. However, a nonlinear quadratic model will lead to high computational complexity, which is not suitable for resource constrained UWSNs. Therefore, most synchronization protocols rely on linear model that only needs to estimate the clock skew and offset. In underwater environments, the effect of drift could be ignored if frequency fluctuation has less effect on the accuracy of clock than that of long propagation latency. As a practical matter, CLUSS simplifies the clock model in linear regression estimation as

\begin{matrix} T_{A} (t) = α_{a} t + β_{a} . \end{matrix}

(3)

The basic idea of time synchronization is that the unsynchronized nodes exchange messages with the reference node (already synchronized) in order to estimate clock skews and offsets in local clocks, so that they can correct their local times with that of UTC time and maintain time synchronization by periodical updating their local clocks.

Figure 4 illustrates the process of intercluster and intracluster synchronization in CLUSS.

Figure 4

The process of intercluster and intracluster synchronization in CLUSS.

At first, the cluster head C generates a synchronization request packet Sync-Req, which consists of destination address, source address, identifier, hops, and the number of iterations. After that, the cluster head C creates a synchronization request message $M_{1}$ containing its identifier ${ID}_{C}$ , nonce $N_{C}$ , timestamp $T_{C}$ ( $t_{1}$ ), Sync-Req, and a signature SIG_ ${SK}_{C}$ over the hash of ID_C, $N_{C}$ , $T_{C}$ ( $t_{1}$ ), and Sync-Req, which then becomes $M_{1} = ({ID}_{C}, N_{C}, T_{C} (t_{1})$ , Sync-Req, SIG_ ${SK}_{C} (H 〈 {ID}_{C}, N_{C}, T_{C} (t_{1}), S y n c - R e q 〉))$ . The timestamp $T_{C}$ ( $t_{1}$ ) consists of two 32 bits unsigned integers. One of them denotes second, and the other represents nanosecond. Both of them are required from the MAC layer of local sensor node. And then, the cluster head C broadcasts $M_{1}$ to the beacon B and all ordinary nodes in its cluster, such as the node A.

The ordinary node A is not need to reply the synchronization request message $M_{1}$ . After receiving $M_{1}$ , the beacon B records its arrival time $t_{2}$ and attempts to authenticate it using C's public key ${PK}_{C}$ . If the authentication fails, the synchronization message $M_{1}$ will be dropped. Otherwise, the beacon B will generate a synchronization acknowledgement packet (Sync-Ack). The Sync-Ack packet consists of destination address, source address, identifier, hops, and the number of iterations. Moreover, the beacon B creates a synchronization acknowledgement message $M_{2}$ containing its identifier ${ID}_{B}$ , nonce $N_{B}$ , timestamp $T_{C}$ ( $t_{1}$ ), timestamp $t_{2}$ , timestamp $t_{3}$ , Sync-Ack, and a signature SIG_ ${SK}_{B}$ over the hash of $M_{2}$ , which then becomes $M_{2} = ({ID}_{B}, N_{B}$ , $T_{C} (t_{1}), t_{2}, t_{3}$ , Sync-Ack, SIG_ ${SK}_{B} (H 〈 {ID}_{B}, N_{B}, T_{C} (t_{1}), t_{2}, t_{3}, S y n c - A c k 〉))$ . In turn, the beacon B sends the synchronization acknowledgement message $M_{2}$ to the cluster head C.

On receiving the synchronization acknowledgement message $M_{2}$ , the cluster head C records its arrival time $T_{C}$ ( $t_{4}$ ) and verifies its authenticity using B's public key ${PK}_{B}$ . If the verification is positive, the cluster head C also needs to calculate the message end-to-end delay. Let $d_{C B}$ be the deterministic part of the message end-to-end delay between the cluster head C and the beacon B. It can be precomputed in the deployment phase of the network or estimated via an extra message exchange between the cluster head C and the beacon B. There are many existing techniques that can also estimate the deterministic delay while estimating the clock skew and offset [22].

3.2.2. Abnormal End-to-End Delay Detection

In order to detect abnormal end-to-end delay data and identify malicious nodes, we consider centered hyperellipsoidal support vector machine (CESVM) [23] as an appropriate scheme for outlier detection in a distributed manner. The basic idea of CESVM is to map the data vectors in the input space to a higher dimensional space, which are centered by means of a kernel function. A hyperellipsoid centered at the origin with minimal effective radius is fitted around the majority of the data vectors in the higher dimensional space. The vectors that fall on or inside the hyperellipsoid are classified as normal and those falling outside the hyperellipsoid are classified as outlier values.

Consider a data set $X = {x_{i} : i = 1, \dots, n}$ of p variant data vectors $x_{i} = {x_{i 1}, x_{i 2}, \dots, x_{i p}}, i = 1, \dots, n$ , in the input space which is mapped into a feature space $ℜ^{f}$ using some nonlinear function $ϕ (\cdot) : ℜ^{p} \to ℜ^{f}$ , resulting in a set $X_{ϕ} = {ϕ (x_{i}) : i = 1, \dots, n}$ . The aim is to enclose the majority of mapped data vectors in the feature space by fitting a hyperellipsoid centered at the origin with a minimum effective radius R(>0), Thus, the optimization problem in CESVM classifier is represented as

\begin{array}{l} \min_{R \in ℜ^{+}, ξ \in ℜ^{n}} R^{2} + \frac{1}{v n} \sum_{i = 1}^{n} ξ_{i} \\ subject to: ϕ (x_{i}) Σ^{- 1} ϕ {(x_{i})}^{T} \leq R^{2} + ξ_{i}, \\ ξ_{i} \geq 0, i = 1, \dots, n, \end{array}

(4)

where

{ξ_{i} : i = 1, \dots, n}

are the slack variables that allow some of the data vectors to lie outside the hyperellipsoid. The parameter

v \in (0,1]

is used to control the fraction of data vectors that can be outliers.

Σ^{- 1}

is the inverse of the sample covariance matrix Σ of mapped data vectors

X_{ϕ}

, which is calculated as follows:

\begin{matrix} Σ = \frac{1}{n} \sum_{i = 1}^{n} {(ϕ (x_{i}) - μ)}^{T} (ϕ (x_{i}) - μ), \\ u = \frac{1}{n} \sum_{i = 1}^{n} ϕ (x_{i}), \end{matrix}

(5)

where is the sample mean of

X_{ϕ}

. Using Mercer Kernels [24], the inner products of mapped data vectors in the feature space can be computed in the input data space without knowledge of the nonlinear function ϕ(·) [25]. Each sensor node

u_{i}

models its own CESVM for n sequential end-to-end delay values and then calculates the effective radius

R_{i}

as well as the corresponding parameters of the median and the covariance matrix of centered data. Then the local outliers at each sensor node

u_{i}

can be determined in real time by comparing the distances between new arriving end-to-end delay values and the origin using (4).

3.2.3. Clock Skew and Offset Estimation

In CLUSS, the random delays in uplink and downlink are modeled as independent and identically distributed zero mean Gaussian random variables $X_{C B}$ and $Y_{C B}$ , respectively, with common variance equal to $σ^{2}$ . The UTC time $t_{2}$ can be calculated as

\begin{matrix} t_{2} = t_{1} + d_{C B} + X_{C B} . \end{matrix}

(6)

The timestamp of cluster head C at UTC time $t_{1}$ can be calculated as

\begin{matrix} T_{C} (t_{1}) = α_{c} (t_{2} - d_{C B} - X_{C B}) + β_{c} . \end{matrix}

(7)

Similarly, the UTC time $t_{4}$ can be calculated accordingly as

\begin{matrix} t_{4} = t_{3} + d_{C B} + Y_{C B} . \end{matrix}

(8)

Moreover, the timestamp of cluster head C at UTC time $t_{4}$ can be calculated as

\begin{matrix} T_{C} (t_{4}) = α_{c} (t_{3} + d_{C B} + Y_{C B}) + β_{c} . \end{matrix}

(9)

Assuming that $t_{3} = t_{2} + ε, z_{c} = [(T_{C} (t_{1}) - t_{2}) + (T_{C} (t_{1}) - t_{3})] / 2$ , then we get

\begin{matrix} z_{c} = α_{c} [t_{2} + \frac{ε}{2} + \frac{Y_{C B} - X_{C B}}{2}] + β_{c} + \frac{Y_{C B} - X_{C B}}{2} . \end{matrix}

(10)

Let $w_{c} = (Y_{C B} - X_{C B}) / 2$ , as $t_{2} ≫ ε / 2 + (Y_{C B} - X_{C B}) / 2$ ; then we get

\begin{matrix} z_{c} \approx α_{c} t_{2} + β_{c} + w_{c}, \end{matrix}

(11)

where

w_{c}

obeys Gaussian distribution of

N (0, σ^{2} / 2)

After k iterations of (11) with MAC timestamps, cluster head C's clock skew and offset can be estimated.

And then, cluster head C generates a Sync-Ack packet and broadcasts the synchronization acknowledgement message $M_{3}$ to all ordinary nodes in its local cluster. After receiving and verification of the authenticity $M_{3}$ , these ordinary nodes can synchronize themselves with cluster head C. For example, the ordinary node A in the cluster of C can calculate its estimated time $t_{1}$ as

\begin{matrix} {\hat{t}}_{1} = \frac{T_{C} (t_{1}) - {\hat{β}}_{C}}{1 + {\hat{α}}_{C}} . \end{matrix}

(12)

Let $d_{A C}$ denote the deterministic part of the message end-to-end delay between ordinary node A and cluster head C. Also, let the random portion of the downlink delay $X_{A C}$ be a zero mean Gaussian random variable with variance $σ^{2}$ ; then the estimated UTC time $t_{1}$ of ordinary node A can be calculated as

\begin{matrix} {\hat{t}}_{2} = {\hat{t}}_{1} + d_{A C} + X_{A C} . \end{matrix}

(13)

The timestamp of ordinary node A at UTC time $t_{2}$ can be calculated as

\begin{matrix} T_{A} (t_{2}) = α_{a} {\hat{t}}_{2} + β_{a} . \end{matrix}

(14)

Applying (12) to (13), we can get

\begin{matrix} T_{A} (t_{2}) = α_{a} ({\hat{t}}_{1} + d_{A C} + X_{A C}) + β_{a} . \end{matrix}

(15)

Applying (12) to (15), we can get

\begin{matrix} T_{A} (t_{2}) = α_{a} (\frac{T_{C} (t_{1}) - {\hat{β}}_{c}}{1 + {\hat{α}}_{c}} + d_{A C} + X_{A C}) + β_{a} . \end{matrix}

(16)

Similarly, we can also get the linear model of $T_{A}$ ( $t_{6}$ ) and $T_{C}$ ( $t_{5}$ ), which can be used to calculate ordinary node A's clock skew and offset together with (16).

In the same way, cluster head C's neighboring clusters can synchronize their clock times by treating cluster head C as their reference node. This process is repeated until all sensor nodes in the network are synchronized.

3.3. Security Analysis

In this section we discuss how different attacks are prevented by the proposed protocol. We assume that beacons cannot be captured by an attacker as they are physically protected.

In Sybil attack, an attacker tries to create multiple fabricated identities. In our protocol, all sensor nodes along the communication path are authenticated using Elliptic Curve Cryptography (ECC) public-key algorithm, which is feasible for low-end underwater sensors [26]. The sender signs the hash of a synchronization message with its secret key and broadcasts the signature along with the message. The receivers verify the correctness of the signature by using the sender's public key. As a result, an attacker cannot disguise as a legitimate node and cannot exchange any false information between legitimate nodes.

Replay attack is prevented by using a random nonce, which is updated every time the synchronization message which is broadcasted. Thus, an attacker cannot pass the authentication phase even if a malicious node makes a copy of the previous synchronization message.

In order to perform message manipulation attack, an intruder tries to drop, modify, or even forge the exchanged messages to interrupt the process of synchronization. In the proposed protocol, all unicast messages exchanged between nodes can be authenticated with unique pair-wise keys shared with other nodes and broadcast messages can be authenticated with public key based digital signatures. Thus, message manipulation attack is not effective with this protocol.

In a delay attack, an attacker intentionally delays some of the timing messages in order to disrupt the synchronization process and cause it to fail. Our protocol exploits centered hyperellipsoidal support vector machine (CESVM) in order to detect abnormal end-to-end delay data and identify malicious nodes in a distributed manner. All detected abnormal end-to-end delay data will be aborted without using in computation of clock skew and offset. Thus, this attack cannot take place if the proposed protocol is in use.

Of course, obtaining absolutely secure and labeled data for training a classifier could be an impossible task. That is the reason that we consider CESVM as an appropriate scheme for detecting abnormal end-to-end delay data. CESVM belongs to one-class SVM that can model the normal profile of the monitored data while automatically ignoring the errors or anomalies present in the data using unsupervised anomaly detection techniques.

3.4. Complexity Analysis

In order to execute time synchronization protocol completely, each sensor node consumes a certain amount of memory space for storing the information of its neighboring nodes and propagates a finite number of timing messages for synchronization. Moreover, each sensor node should also calculate its clock skew and offset, which will incur nonignorable computational cost. Let $| V |$ denote the total number of sensor nodes in the network. $D_{\max}$ and $D_{avg}$ denote the maximum degree and the average degree of the nodes in the network, respectively. Then the computational complexity is proportional to the square of the maximum degree of the node according to the definition of Breadth-First Search, which can be represented as $O (D_{\max}^{2})$ . The number of clusters in the network is calculated as $| V | / D_{avg}$ . Suppose that the number of messages generated in synchronization is M; then the communication complexity is calculated as $O (M \cdot {| V |}^{2} / D_{avg})$ . As a distributed time synchronization protocol, each sensor node only stores the information of its neighboring nodes within 1-hop distance in CLUSS. Therefore, the memory complexity is $O (D_{\max})$ for each sensor node and $O (| V | \cdot D_{\max})$ for the whole network in the worst case.

4. Performance Evaluation

4.1. Simulation Settings

We use Aqua-Sim [27] as simulation framework to evaluate our approach. The data packets are also generated by the simulator. Aqua-Sim is an ns-2 based underwater sensor network simulator developed by underwater sensor network lab at University of Connecticut. Aqua-Sim can simulate the attenuation and propagation of acoustic signals. It can also simulate packet collision in underwater sensor networks.

In simulations, we assume that beacons own UTC time and have unlimited energy resources. Other sensor nodes have their own internal clocks and the errors for processing and exchanging of messages among sensor nodes obey Gaussian distribution [28]. The R-MAC [27] protocol is used as the underlying MAC protocol in order to avoid data packet collision and produce timestamp during the process of simulation. The sensor nodes follow the random-walk mobility pattern, which randomly select a direction and move to the new position with a speed between 1 m/s and 5 m/s. Other simulation parameters and their default values are listed in Table 1.

Table 1

Simulation parameters and their default values.

Simulation parameters	Default values
Number of beacons	3
Number of sensor nodes	50
The size of region	1 km × 1 km × 1 km
Average node degree	4.6
Average node speed	1 m/s
Initial clock skew	50 ppm
Initial clock offset	80 ppm
Time granularity	1 μs
Jitters in receivers	10 μs
Time interval of messages	1 s

CESVM is less sensitive to the choice of parameter values than other SVMs. For example, CESVM can achieve an AUC (Area Under roc Curve) in excess of 0.8 for a wide range of kernel parameter values which vary from 0.08 to 41943.04 [22]. Moreover, the effective radius for the CESVM is computed either using any border support vector or using the mean of the support vectors if such border support vector not exists. Therefore, we do not individually discuss the effect of parameters for CESVM on the final results in this paper.

We compared the performance of CLUster-based Secure Synchronization (CLUSS) protocol with that of MU-Sync [16] and WATERSync [17]. Without loss of generality, every data point is obtained as the average of 1000 simulation runs.

4.2. Simulation Results

In the first set of simulations, we compared the errors with time elapsed since synchronization in different synchronization protocols without malicious nodes. The number of sensor nodes is set to 50. As shown in Figure 5, the errors of three synchronization protocols are proportional to the time after synchronization. CLUSS achieves lower errors than that of MU-Sync and WATERSync in the same circumstances. The average error of CLUSS is only 42.4% of MU-Sync and 28.8% of WATERSync after synchronization of 10⁵ seconds. The lowest precision of WATERSync is caused by its high offset errors as it neglects horizontal direction during the process of time synchronization. MU-Sync applies half of the round trip time to compute one way propagation delay, which involves significant errors if sensor nodes move fast or experience long response times. Although the time point MU-Sync used in the second linear regression has decreased propagation delay, the local clock deviation is still large because of the large propagation delay estimation error.

Figure 5

Errors versus time after synchronization without malicious nodes.

Next, we compared the errors with time elapsed since synchronization in different synchronization protocols with 10% malicious nodes. The number of sensor nodes is set to 50 as default (i.e., 45 safe nodes and 5 malicious nodes). As shown in Figure 6, the errors of three synchronization protocols are proportional to the time after synchronization. CLUSS achieves lower errors than that of MU-Sync and WATERSync in the same circumstances. The average error of CLUSS is only 15.4% of MU-Sync and 24.1% of WATERSync after synchronization of 10⁵ seconds. Moreover, compared with Figure 5, the errors of all three protocols increase to some extent. The curve of MU-Sync rises sharply because it has no prevention measures against malicious nodes. As a result, the precision of WATERSync overtakes that of MU-Sync as WATERSync can detect outlier timestamp data and identify some attacks generating by malicious nodes.

Figure 6

Errors versus time after synchronization with 10% malicious nodes.

And then, we compared the errors with average node speed in different synchronization protocols with 10% malicious nodes. The synchronization time is set to 10 seconds. As shown in Figure 7, the errors of three synchronization protocols are proportional to the average node speed. MU-Sync obtains the highest synchronization error among the three synchronization protocols when their average node speeds are same. Moreover, with the increase of average node speed, the curve of MU-Sync shows a rapid rising compared with other synchronization protocols. The curve of WATERSync indicates that the error is approximately linear with the average node speed. The error of CLUSS is obviously lower than that of MU-Sync and WATERSync. Furthermore, with the increase of average node speed, the accumulated errors of CLUSS display a mild growth. On average, the error of CLUSS is only 25.6% of MU-Sync and 57.6% of WATERSync.

Figure 7

Errors versus average node speed.

After that, we compared the errors with the number of nodes in different synchronization protocols with 10% malicious nodes. The synchronization time is also set to 10 seconds. As shown in Figure 8, the errors of three synchronization protocols are proportional to the number of nodes. CLUSS achieves the lowest errors among the three protocols in the same circumstances. The average error of CLUSS is only 34.3% of MU-Sync and 72.5% of WATERSync.

Figure 8

Errors versus number of nodes.

In addition, we also compared the errors with the rate of malicious nodes in different synchronization protocols. The number of sensor nodes is set to 50 and the average node speed is set to 1 m/s as default. As shown in Figure 9, the errors of three synchronization protocols are proportional to the rate of malicious nodes. CLUSS achieves lower errors than that of MU-Sync and WATERSync in the same circumstances. The curve of CLUSS is also gentler than that of MU-Sync and WATERSync. When the rate of malicious nodes is not above 6%, the error of MU-Sync is slightly lower than that of WATERSync. When the rate of malicious nodes is not less than 10%, the error of MU-Sync becomes higher than that of WATERSync. Overall, the average error of CLUSS is only 34.4% of MU-Sync and 62.3% of WATERSync.

Figure 9

Errors versus rate of malicious nodes.

In the second set of simulations, we compared the number of messages with time elapsed since synchronization in different synchronization protocols with 10% malicious nodes. The synchronization time is set to 10 seconds. As shown in Figure 10, the number of messages is proportional to the time elapsed since synchronization. CLUSS produces the minimum number of messages, while WATERSync generates the maximum number of messages. Moreover, the curve of CLUSS indicates gentler slope compared with that of MU-Sync and WATERSync. Overall, CLUSS decreases 7.1% of the number of messages than that of MU-Sync and 32.7% of the number of messages than that of WATERSync on average after time synchronization. This is because part of intercluster synchronization phase and intracluster synchronization phase in CLUSS can be executed concurrently, which in turn reduces the number of messages generated in synchronization.

Figure 10

Number of messages versus time after synchronization.

After that, we compared the number of messages with the number of nodes in different synchronization protocols with 10% malicious nodes. As shown in Figure 11, the number of messages is proportional to the number of nodes in three synchronization protocols. CLUSS produces fewer messages than that of MU-Sync and WATERSync with the same number of nodes. Moreover, the slope of the curve in CLUSS is gentler than that of MU-Sync and WATERSync. Overall, CLUSS decreases 14.9% of the number of messages than that of MU-Sync and 35.4% of the number of messages than that of WATERSync on average.

Figure 11

Number of messages versus number of nodes.

In the last set of simulations, we compared the number of iterations with error tolerance in different synchronization protocols as shown in Figure 12. The amount of energy consumed by resynchronization is represented by the number of iterations over a period of 10⁵ seconds of operating time for various values of error tolerance. The number of iterations is inversely proportional to error tolerance in three synchronization protocols. Under the same condition, CLUSS outperforms MU-Sync and WATERSync due to its ability to estimate skew more accurately. On average, CLUSS only needs 46.5% of iterations compared to MU-Sync and 22.1% of iterations compared to WATERSync.

Figure 12

Number of iterations versus error tolerance.

4.3. Discussion

When an existing sensor node leaves the network due to battery outage, if this sensor node is not the cluster head of any cluster, then there is nothing to do. If this sensor node is a cluster head, then the system will execute the process of cluster formation and assign new cluster heads for the newly formed clusters. When a new sensor node joins the network, the system will execute the process of cluster formation and assign new cluster heads for the newly formed clusters if needed. Furthermore, the new sensor node should also synchronize its clock with the whole network. Therefore, the cost for cluster maintenance cannot be neglected in highly dynamic and unstable networks where nodes frequently join and leave. However, in a UWSN, each sensor node is attached to a surface buoy by a wire that can be adjusted for proper and suitable length or anchored to the ocean bottom using weights. Moreover, the network battery life is sufficiently long to avoid recharging or replacing node batteries frequently in harsh underwater environments. Hence, the topology of the network does not change frequently after initial deployment and the cost for cluster maintenance only has a trifling impact on the proposed method in a UWSN.

5. Conclusion

This paper proposed a CLUster-based Secure Synchronization (CLUSS) protocol that ensures the security of synchronization under harsh underwater environments against various attacks, including Sybil attack, replay attack, message manipulation attack, and delay attack. The time synchronization process of CLUSS is divided into three phases: authentication phase, intercluster synchronization phase, and intracluster synchronization phase. During the authentication phase, cluster heads are authenticated to beacons and ordinary nodes are authenticated to cluster heads. During the process of intercluster and intracluster synchronization phases, CLUSS distinguishes the propagation delay of downlink from that of uplink caused by node movement in order to improve time synchronization accuracy. Moreover, part of these two phases can be executed concurrently for reducing the number of messages generated in synchronization. We demonstrate through simulations that CLUSS can reduce synchronization errors as well as the number of synchronization messages than traditional protocols even when the network is attacked by malicious nodes. In future work, we will investigate the influence of MAC layer activities to the performance of time synchronization protocols, such as packet loss and retransmission. Moreover, we will analysis the adaptability of our protocol and evaluate its performance through real ocean experiments.

Footnotes

Notations

Conflict of Interests

The authors declare that there is no conflict of interests regarding the publication of this paper.

Acknowledgments

This work was sponsored by the National Nature Science Foundation of China (61202370, 51279099), the Innovation Program of Shanghai Municipal Education Commission (14YZ110), the Shanghai Pujiang Program from Science and Technology Commission of Shanghai Municipality (11PJ1404300), and the Open Program of Shanghai Key Laboratory of Intelligent Information Processing (IIPL-2011-008).

References

Manjula

R. B.

Sunilkumar

S. M.

Issues in underwater acoustic sensor networks

International Journal of Computer and Electrical Engineering 2011 3 1 1793 8163

Chen

Y. G.

X. M.

Zhang

Design of RC-LDPC codes and its application for shallow water acoustic communications

Journal of Convergence Information Technology 2012 7 12 177 185

Shen

Sun

Cheng

Zhang

SNR estimation algorithm based on pilot symbols for DFT-spread OFDM systems over underwater acoustic channels

Journal of Convergence Information Technology 2011 6 2 191 196

2-s2.0-79952414027

10.4156/jcit.vol6.issue2.20

Basagni

Petrioli

Petroccia

Stojanovic

Optimized packet size selection in underwater wireless sensor network communications

IEEE Journal of Oceanic Engineering 2012 37 3 321 337

10.1109/JOE.2012.2197271

Jornet

J. M.

Stojanovic

Zorzi

On joint frequency and power allocation in a cross-layer protocol for underwater acoustic networks

IEEE Journal of Oceanic Engineering 2010 35 4 936 947

2-s2.0-78649754510

10.1109/JOE.2010.2080410

Detweiler

Doniec

Vasilescu

Rus

Autonomous depth adjustment for underwater sensor networks: design and applications

IEEE/ASME Transactions on Mechatronics 2012 17 1 16 24

2-s2.0-84855922893

10.1109/TMECH.2011.2175003

Akyildiz

I. F.

Pompili

Melodia

Underwater acoustic sensor networks: research challenges

Ad Hoc Networks 2005 3 3 257 279

2-s2.0-13944252629

10.1016/j.adhoc.2005.01.004

Liu

Zhou

Peng

Cui

J.-H.

Mobi-sync: efficient time synchronization for mobile underwater sensor networks

Proceedings of the 4th ACM international Workshop on Underwater Networks

2009

1 5

Elson

Girod

Estrin

Fine-grained network time synchronization using reference broadcasts

Proceedings of the 5th Symposium on Operating Systems Design and Implementation

2002

147 163

10.

Ganeriwal

Kumar

Srivastava

M. B.

Timing-sync protocol for sensor networks

Proceedings of the 1st International Conference on Embedded Networked Sensor Systems (SenSys '03)

November 2003

138 149

2-s2.0-11244272924

11.

Maróti

Kusy

Simon

Lédeczi

Á.

The flooding time synchronization protocol

Proceedings of the 2nd International Conference on Embedded Networked Sensor Systems (SenSys ′04)

November 2004

39 49

2-s2.0-27644533289

12.

Uluagac

A. S.

Beyah

R. A.

Copeland

J. A.

Secure source-based loose synchronization (SOBAS) for wireless sensor networks

IEEE Transactions on Parallel and Distributed Systems 2013 24 4 803 813

10.1109/TPDS.2012.170

13.

Liu

Guizani

Lightweight secure global time synchronization for wireless sensor networks

Proceedings of the IEEE Wireless Communications and Networking Conference: Mobile and Wireless Networks

2012

2312 2317

14.

Syed

A. A.

Heidemann

Time synchronization for high latency acoustic networks

Proceedings of the 25th IEEE International Conference on Computer Communications (INFOCOM ′06)

April 2006

1 6

2-s2.0-39049102879

10.1109/INFOCOM.2006.161

15.

Mirza

Schurgers

D-Sync: doppler-based time synchronization for mobile underwater sensor networks

Proceedings of the 5th ACM International Workshop on UnderWater Networks (WUWNet ′10)

October 2010

1 8

2-s2.0-78650139691

10.1145/1868812.1868815

16.

Chirdchoo

Soh

W.-S.

Chua

K. C.

MU-Sync: a time synchronization protocol for underwater mobile networks

Proceedings of the 3rd ACM International Workshop on Underwater Networks (WUWNet ′08)

September 2008

35 42

2-s2.0-70549108000

17.

Wilson

Xiao

Correlation-based security in time synchronization of sensor networks

Proceedings of the IEEE Wireless Communications and Networking Conference (WCNC ′08)

April 2008

2525 2530

2-s2.0-51649120386

18.

Toussaint

G. T.

The relative neighbourhood graph of a finite planar set

Pattern Recognition 1980 12 4 261 268

2-s2.0-0019213414

19.

Bose

Devroye

Evans

Kirkpatrick

On the spanning ratio of gabriel graphs and β-skeletons

SIAM Journal on Discrete Mathematics 2006 20 2 412 427

2-s2.0-34249008092

10.1137/S0895480197318088

20.

Supowit

K. J.

The relative neighborhood graph with an application to minimum spanning trees

Journal of Association for Computing Machinery 1983 30 3 428 448

2-s2.0-0020783496

10.1145/2402.322386

21.

Fernandez

J. A.

Ortega

J. M.

Hernando

A. G.

Performance analysis of time synchronization protocols in wireless sensor networks with regular topologies

International Journal on Advances in Security 2010 3 1-2 13 26

22.

Cao

Yang

Gan

Joint estimation of clock skew and offset in pairwise broadcast synchronization mechanism

IEEE Transactions on Communications 2013 61 6 2508 2521

23.

Rajasegarar

Leckie

Bezdek

J. C.

Palaniswami

Centered hyperspherical and hyperellipsoidal one-class support vector machines for anomaly detection in sensor networks

IEEE Transactions on Information Forensics and Security 2010 5 3 518 533

2-s2.0-77955684744

10.1109/TIFS.2010.2051543

24.

Vapnik

V. N.

Statistical Learning Theory 1998

John Wiley & Sons

25.

Vapnik

V. N.

An overview of statistical learning theory

IEEE Transactions on Neural Networks 1999 10 5 988 999

2-s2.0-0032594959

10.1109/72.788640

26.

Yan

Shi

Z. J.

Fei

Efficient implementation of elliptic curve cryptography on DSP for underwater sensor networks

Proceedings of the 7th Workshop on Optimizations for DSP and Embedded Systems

2009

7 15

27.

Xie

Zhou

Peng

Yan

Cui

J.-H.

Shi

Fei

Zhou

Aqua-sim: an NS-2 based simulator for underwater sensor networks

Proceedings of the MTS/IEEE Marine Technology for Our Future: Global and Local Challenges (OCEANS ′09)

October 2009

Biloxi, Miss, USA

1 7

2-s2.0-77951595933

28.

Elson

Girod

Estrin

Fine-grained network time synchronization using reference broadcasts

Proceedings of the 5th Symposium on Operating Systems Design and Implementation

2002

147 163