Deep Auto-Encoder Based Intelligent and Secure Time Synchronization Protocol (iSTSP) for Security-Critical Time-Sensitive WSNs

1  Introduction

WSNs have transformed the way we collect and handle data in a variety of disciplines, from environmental monitoring to industrial automation. These networks are made up of little, resource-constrained sensor nodes dispersed across a certain area, cooperating to gather and transmit data to a central sink or gateway [1]. Time synchronization, which requires the nodes to maintain a consistent sense of time to successfully coordinate their operations, is one of the fundamental conditions for the accurate operation of WSNs.

Time synchronization is essential in WSNs for a number of reasons. It is essential to many applications, including target tracking, event detection, and data aggregation. It also makes it possible to combine accurate data in an energy-efficient manner. Many time synchronization techniques have been developed and implemented in WSNs with the goal of achieving a balance between synchronization accuracy and resource efficiency [2]. Time synchronization protocols allow sensor nodes to align their internal clocks, promoting data coherence and efficient network administration. The inherent characteristics of WSNs make them vulnerable to security attacks. These characteristics include [3]:

1.   Limited resources: The processing speed, memory, and energy of sensor nodes are all finite. This makes elaborate security methods harder to implement.

2.   Exposed and hostile environments: WSNs are frequently deployed in open and dangerous locations, such as battlefields or disaster zones. As a result, they are subject to physical attacks and eavesdropping.

3.   Absence of central security control: The security management in WSNs is not centralized. As a result, it is challenging to implement security regulations and to recognize and stop attacks.

One of the most important security threats in the WSN network is the spoofing of time synchronization protocols. By manipulating the message timestamps, an attacker can disrupt the normal operation of the network, such as by injecting fake data, delaying the message, or replaying old messages. To secure the time synchronization protocols in WSN, some studies [4–7] have suggested various techniques to combat attacks, such as:

1.   Using cryptography to secure communications between sensor nodes.

2.   Applying algorithms to validate the authenticity of sensor nodes in a sensor field.

3.   Implementing secure detection and routing to prevent attackers from injecting malicious messages into the network.

To address these challenges, we propose the Intelligent and Secure Time Synchronization Protocol (iSTSP), a novel solution that integrates deep learning-based anomaly detection with adaptive control theory in a structured four-stage defense pipeline. iSTSP’s architecture systematically mitigates threats while maintaining high synchronization accuracy:

1.   Trust Preprocessing—Filters out untrusted nodes before synchronization begins using dynamic trust scoring, reducing the attack surface by 63%.

2.   Anomaly Isolation—Detects and excludes compromised nodes in real time using an autoencoder-based model, achieving 92% Sybil attack detection within a single synchronization round.

3.   Reliability-Weighted Consensus—Prioritizes high-trust nodes during time aggregation, limiting malicious influence by 7.2× compared to unweighted methods.

4.   Convergence-Optimized Synchronization—Dynamically adjusts synchronization parameters using a closed-form convergence time model, reducing synchronization error by 38% under attack conditions.

Our key contributions include:

1.   A four-stage defense pipeline that sequentially filters, isolates, weights, and optimizes synchronization for robustness.

2.   Rigorous theoretical analysis, including stability proofs, asymptotic error bounds, and a closed-form convergence time expression.

3.   Real-world validation on a 16-node testbed, demonstrating iSTSP’s superiority over existing protocols (AvgPISync, SE-FTSP, and MMAR-CTS) in attack resilience, convergence speed, and energy efficiency.

This work establishes the feasibility and core benefits of the iSTSP approach through rigorous theoretical analysis and validation on a controlled 16-node laboratory testbed using MICAz motes. While the protocol design is general, the experimental evaluation focuses on demonstrating its effectiveness under specific adversarial conditions manageable within this testbed scope. It bridges the gap between theoretical security guarantees and practical deployment, offering a scalable solution for mission-critical WSN applications in adversarial environments.

The rest of the paper is organized as follows: Section 2 discusses related works in terms of secure clock syncronization in WSNs. Section 3 formulates the WSN system model to lay the foundation for the design of secure time synchronization protocol. Section 4 presents the suggested synchronization framework. Section 5 conducts the theoretical convergence analysis of synchronization. Section 6 presents the design of the iSTSP protocol that performs secure multi-hop global synchronization of WSN nodes. In Section 7, a thorough performance evaluation of the protocol using both simulations and real-time synchronization is presented. Lastly, Section 8 concludes the paper.

2  Related Works

Many techniques have been proposed to solve the problem of security in addressing clock synchronization problem. Traditional protocols such as the Flooding Time Synchronization Protocol (FTSP), and Timing-sync Protocol for Sensor Networks (TPSN) [8] introduced a hierarchical mechanisms involving level discovery and pairwise synchronization using a two-way message exchange. TPSN for example achieves sub-microsecond accuracy in ideal conditions, but it assumes a benign environment and is highly susceptible to adversarial delay injection and replay attacks, as it lacks any built-in authentication or anomaly detection mechanisms.

To enhance resilience, cryptographic extensions have been proposed. The Secure Flooding Time Synchronization Protocol (SE-FTSP) enhances the original FTSP by integrating message authentication codes (MACs) into synchronization packets [9]. SE-FTSP prevents simple spoofing and replay attacks by ensuring that only authenticated messages contribute to clock updates. While this approach secures the protocol against unauthorized time sources, it does not mitigate subtle timing manipulations or insider threats, and it introduces overhead due to cryptographic operations.

In [10], the authors investigated the large-scale Internet of Things’ safe time synchronization and presented a secure clock model that can identify hostile nodes and avoid the use of malicious timestamps to prevent external attacks. A secure time synchronization protocol was developed to prevent fake timestamps. The model was evaluated using NS2 and compared to previous protocols TPSN and STETS, demonstrating its effectiveness in preventing malicious nodes attacks.

A secure time synchronization protocol based on node identification was also presented by Wang et al. [11] after they researched the design and analysis of secure time synchronization algorithms for resource-constrained industrial WSNs under the Sybil attack. Instead of isolating suspicious nodes, the main concept is to use the timestamp correlation between various nodes and the distinctiveness of the node clock offset to detect erroneous information.

In order to reduce external attacks and react to changes in topology, Fan et al. suggested a blockchain-based solution [12]. This approach primarily employed a closed blockchain to record and broadcast the clock information of nodes. The scheme uses POS consensus for efficient time synchronization, achieving high efficiency and reduced communication costs, according to the analysis results.

The authors in [13] studied the clock synchronization security problem and suggested methods that takes into account malicious attacks in sensor networks and proposed a technique based on detect and compensate for attacks using maximum consensus protocol. Techniques for detecting binary attacks variable in their method was based on the removing received malicious node clocks in the synchronization process.

Jha et al. [14] analyzed and evaluated the behavior of consensus-based time synchronization (CTS) algorithms under message manipulation attacks using simulation-based analysis. Their simulation results showed that the proposed Message Manipulation Attack Resilient CTS (MMAR-CTS) algorithm outperforms other candidate algorithms in terms of convergence speed and synchronization error. MMAR-CTS (Multi-Model Adversarial Resilient Clock-Time Sync) uses statistical residual analysis to detect and isolate malicious nodes based on deviations from expected timing patterns [15]. By combining multiple prediction models and applying statistical hypothesis testing, MMAR-CTS detects manipulation and Sybil attacks with moderate detection latency. However, this method requires fine-tuning of residual thresholds and incurs significant computational cost for multi-model evaluations.

Using dynamic control theory, Xuan et al. [16] examined the viability of the Kalman filter based on resolving the error brought on by CPU interrupt and other factors. The Kalman filter-optimized precise time synchronization protocol outperforms the protocol without the filter in terms of accuracy and stability in estimation error of clock offset and clock skew rate. This approach is particularly effective for single-hop and multi-hop synchronization, with significant advantages for larger observation noise. The Kalman filter effectively filters out synchronization noise and suppresses transmission of synchronization errors, thereby enhancing the network’s expansion.

Another recent work by Jha et al. in [17] suggested a novel sybil resilient consensus time synchronization protocol (SRCTS) for WSNs to detect and filter sybil messages. The protocol uses a graph-theoretic approach and a connected component strategy to detect sybil messages at the message level. Simulation results show that SRCTS has a higher sybil message detection rate compared to existing protocols, the robust and secure Time Synchronization Protocol (RTSP) and the node-identification-based secure time synchronization protocols (NiSTS), with a 6% improvement compared to RTSP and a 14% improvement compared to NiSTS. The SRCTS algorithm is also shown to be more effective and efficient in terms of convergence rate compared to NiSTS and RTSP.

Recently, reference [18] proposes an improved version of intrusion detection systems (IDSs) called multipath intrusion detection system (MIDS) to limit the hostile impact of packet-dropping attacks in a Low Energy Adaptive Clustering Hierarchy (LEACH) environment. The system integrates IDs with ad hoc on-demand Multipath Distance Vector (AOMDV) protocol, calculating intrusion ratio (IR) to mitigate sinkhole attacks and round trip time (RTT) to mitigate wormhole attacks. The proposed MIDS algorithm shows efficiency in terms of energy consumption, lifetime, and network throughput.

To the best of authors’ knowledge, previous works show that there is no single solution available to completely secure time synchronization protocols in the WSN. Each of them covers multiple targeted applications with different adaptive time synchronization strategies. The best approach employed by most of previous works was to use a combination of security mechanisms to reduce the risk of attacks on the time synchronization protocol or introduce these mechanisms in the protocol itself. The work presented in this paper also utilized hybrid approach for securing time synchronization protocol, but different from previous works. We first utilize the trust based authetication technique between nodes, we detect malicious node using an artificial intellgence based approach, and lastly we propose a dynamic weighted time synchronization approach for optimal syncronization accross network’s node.

While this work focuses on time-delay based Sybil attacks where a single malicious node injects variable timestamp delays to multiple identities full identity-forging Sybil attacks (i.e. virtual-identity injection) are orthogonal to our synchronization-accuracy threat model. Techniques such as robust identity management or certificate-based node authentication can be layered on top of iSTSP. We leave the integration of such schemes as future work.

3  WSN System Model

Time synchronization is a crucial need in WSNs, ensuring that sensor nodes maintain constant and accurate clocks to enable coordinated data gathering, processing, and transfer. However, achieving accurate time synchronization in the face of clock errors, network topological restrictions, transmission delays, and possible threats presents formidable difficulties [19].

3.1 Network Model

The sensor nodes in the WSN are linked together by wireless communication lines. Since nodes can join or leave the network and communication links might have varying degrees of availability and quality, the network topology is by its very nature dynamic [20]. In the network model, nodes that are within communication range of one another are referred to as neighbors. Gateway nodes also act as hubs for data gathering and coordination, which is essential for time synchronization [12]. The hardware clock of the gateway node, Tg, acts as a source in the absence of an external clock source and is tracked for synchronization by all other sensor nodes, as shown in Fig. 1. In this paradigm, nodes i and j are 1-hop neighbors of the gateway node, g, and communicate clock values to their 1-hop neighbors as well as occasionally receiving clock values from the gateway, Tg. Each node uses a synchronization algorithm to update its clock value utilizing the current clock value and received neighborhood clock values after a predetermined number of packet exchanges after which global network synchronization is expected within acceptable error margins [21].

Figure 1: Model network for clock synchronization: where the synchronization of each node’s clock to the clock of a gateway node is accomplished through the exchange of neighborhood clock information between nodes, Tg

Assume a WSN has symmetric links and hence can be represented by an undirected graph 𝒢=(𝒱,ℰ) where the sensor nodes of the network as the vertex set, 𝒱=vi|i=1,2,…,N, where N=|𝒱| is the cardinality of 𝒱 and the connectivity between these nodes as an edge set, ℰsuch that(ℰi,ℰj)∈ℰ if nodes i and j can send information to each other. Such nodes that directly communicate with node i are referred to as the neighbors of i and represented by the set, 𝒩i=(vj|ℰi,j∈ℰ) of cardinality Ni=|𝒩i|.

3.2 Clock Model

The consequences of clock inaccuracies are significant because nodes with inaccurate clocks may induce synchronization issues, leading to misalignment and inconsistent temporal coordination in the network. In a WSN, each node is equipped with a hardware clock, T which is designed using a crystal oscillator. Since the nominal operating frequency of these oscillators vary due to changes in temperature, and aging, the hardware clocks exhibit drifts. We adopt the definition of a hardware clock given in [2], where the hardware clock value, Ti of an arbitrary WSN node i at time t>t0 is modeled in terms of an initial clock value, Ti(t0) and the oscillator frequency, f(φ)∈[f^−fmax, f^+fmax] as

Ti(tk)=Ti(t0)+∫t0tkf(φ)dφ(1)

where fmin and fmax are, respectively, the lower and upper bounds of the nominal frequency of the oscillator, f^ and the drift dynamics of the clock is modeled as

f(tk)=f^+n(tk)(2)

where n(tk) is uniformly distributed between −fmax and +fmax.

Since the physical clock parameters of a node cannot be modified, each node maintains a logical clock Ci(tk) that is a function, H(.) of the initial physical and logical clock values, current physical clock value Ti(tk) and a logical clock rate Ri(tk):

Ci(tk)=H(Ci(t0),Ri(tk),[Ti(tk)−Ti(t0)])(3)

The logical clock speed Ri(tk) depends on the relative frequency estimate f^fi(tk). The clocks can be kept synchronized by recursively updating the logical clock offset Ci(tk) and rate Ri(tk) using an adaptive approach.

We assume the gateway’s clock ticks with perfect regularity. This means it advances by a ticking rate R(tk) with each tick. The clock value of the gateway, Tg at time t at any given tick can then be expressed as:

Tg(tk)=k×R(tk)(4)

where k is a non-negative integer representing the tick count. The corresponding gateway clock frequency fg of this perfect clock is defined as the inverse of the time interval between ticks:

fg(tk)=1R(tk)(5)

3.3 Malicious Node Attack Models

The potential existence of hostile nodes that purposefully interfere with synchronization operations causes security flaws in time synchronization. In this section we present the two attack models considered in our protocol design. The models are the malicious node mode and the delay attack models.

3.3.1 Delay Attack Model

Wireless communication is prone to transmission delays, which can have a big impact on time synchronization. The propagation, queueing, and processing delays that occur during message transmission between nodes are included in the delay model [22]. These delays impair the precise alignment of clocks by introducing uncertainty and asynchronicity into message exchange. Let Dij(tk) denote the transmission delay between nodes i and j at time t. The delay model captures the temporal offset introduced by delays:

Dij(tk)=Δtprop+Δtqueue+Δtproc(6)

where Δtprop represents propagation delay, Δtqueue is queuing delay, and Δtproc represents processing delay.

In order to induce faults and inconsistencies, malicious nodes stray from the recommended synchronization technique. These nodes may broadcast erroneous synchronization messages, alter message timings, or make an effort to desynchronize nearby nodes. The dynamics of a malicious node Mi(tk) can be modeled as:

Mi(tk)=Ci(tk)+εi(tk)(7)

where εi(tk) represents the malicious deviation from the true logical clock which can be modeled as white noise.

This attack can also be based on artificial delaying message transmission by adding εi(tk) to delay, Dij between node i and its neighbors aimed at preventing synchronization. These attacks may cause incorrect synchronization assumptions between nearby nodes, resulting in misalignment and undermining of the correctness of the overall synchronization. The malicious deviation, εi(tk) can be modeled as white or colored stochastic noise which is characterized by flat power spectral frequencies across all frequencies and can introduce widespread random disruptions on clock signals in the form of erratic jitters and deviations in clock values and frequency making it challenging to predict and counteract.

3.3.2 Sybil Attack Model

A Sybil attacker introduces a set of fake identities 𝒮=s1,s2,…,sm into the network such that 𝒮∩𝒱=∅. These identities falsely appear as legitimate nodes to neighbors and participate in clock synchronization exchanges with manipulated timing data.

Let node i∈𝒱 be a legitimate sensor node with a neighbor j∈𝒩i. Suppose that j is a Sybil node or influenced by a Sybil attacker. The goal of the Sybil attacker is to disrupt the time synchronization process by injecting inconsistent or misleading timing information.

Each Sybil identity sk∈𝒮 reports a forged clock value at time tk, denoted as:

Csk(tk)=Tg(tk)+θk(tk)(8)

where θk(tk) is an arbitrary deviation from the true gateway clock value Tg(tk), possibly designed to disrupt consensus. The attacker may adapt θk(tk) to bias synchronization depending on the synchronization algorithm used.

Node i typically uses information from its neighborhood 𝒩i to update its local clock. The update rule (e.g., averaging or weighted consensus) can then be expressed as:

Ci(tk+1)=Ci(tk)+α∑j∈𝒩iwij(Cj(tk)−Ci(tk))(9)

where:

α is a step size,

wij is a weight assigned to neighbor j (typically based on trust, distance, or static topology),

Cj(tk) is the clock value by neighbor j at time tk.

However, if Sybil nodes are present in 𝒩i, the update becomes:

Ci(tk+1)=Ci(tk)+α(∑j∈𝒩ilegitwij(Cj(tk)−Ci(tk))+∑s∈𝒩isybilwis(Cs(tk)−Ci(tk)))(10)

here: 𝒩ilegit⊂𝒩i is the set of legitimate neighbors, 𝒩isybil=𝒩i∩𝒮 is the set of Sybil identities within i’s neighborhood.

If the sum of weights of Sybil neighbors is large or if the θk(tk) values are skewed, node i’s clock update may drift significantly from the true time.

We can quantify the clock skew induced by Sybil influence at node i over time as:

ξi(tk+1)=|Ci(tk+1)−Tg(tk+1)|(11)

A rapid increase in ξi(tk) or a consistently high value suggests possible Sybil interference.

3.4 Problem Formulation

Examining the clock model, network topology, delay model, and various attack scenarios is necessary for formalizing the difficulties of secure time synchronization. The problem formulation aims to establish accurate and secure time synchronization by accounting for clock errors, communication delays, and adversarial behaviors. This requires developing synchronization techniques that reduce the impact of clock variances, make use of network topology, and guard against malicious behavior.

WSNs need an integrated method for secure and intelligent time synchronization due to the combined effects of clock imperfections, network topology, communication delays, and potential assaults.

We propose a thorough system that handles these issues in the subsequent chapters, combining trust-based authentication, malicious node identification, adaptive clock updates, and selective synchronization techniques. Our suggested framework attempts to establish robust and secure time synchronization framework in WSNs by combining these methods in an optimized manner.

Our protocol operates under the practical assumption that:

1.   The system is partially synchronous (i.e., bounded delay assumptions hold in real WSNs).

2.   Trust-based authentication allows nodes to selectively synchronize with more reliable peers, mitigating the effects of attacks.

4  Suggested Framework for Intelligent Secure Synchronization

Achieving secure time synchronization in WSNs necessitates a comprehensive solution that covers both dependability and resistance against hostile behaviors. The proposed system combines cutting-edge methods for adaptive clock updates, malicious node identification, trust-based neighborhood authentication, and selective clock update to build a solid framework for precise and secure synchronization between sensor nodes.

4.1 Trust Based Neighborhood Authentication

Establishing trust among neighboring nodes is critical for dependable time synchronization. Trust-based neighborhood authentication allows nodes to work successfully and maintain correct time synchronization collectively. A trust score can be calculated by analyzing the synchronization behavior of surrounding nodes, which reflects the level of confidence in a node’s synchronization dependability. The trust-based neighborhood authentication mechanism involves the following steps:

1.   Observation and Logging: Each node keeps track of its neighbors’ synchronization patterns over time through observation and logging. This involves keeping an eye on synchronization patterns, transmission delays, and clock offsets.

2.   Trust Score Computation: Each neighboring node receives a trust score based on the observed synchronization behavior. The node’s reliability, precision, and adherence to the synchronization protocol are reflected in the trust score.

3.   Threshold-based Trust Decision: Nodes assess the computed trust scores against a predetermined cutoff. Nodes over the threshold are regarded as reliable, whereas nodes below the threshold should be handled carefully.

The trust score Li(tk) for node i at time t is calculated using the observed synchronization behavior of nearby nodes 𝒩i, and it depends on transmission delays and offset values:

Li(tk+1)=F(Li(tk),ΔTij(tk),Dij(tk) for j∈𝒩i)(12)

where F is a trust score computation function that captures the dynamics of synchronization behavior, ΔTij(tk) and Dij(tk) are the clock offset value and transmission delay between nodes i and j at time t, respectively. The trust score Li(tk+1) is updated over time to reflect the evolving trustworthiness of neighboring nodes. Three candidate functions are considered for secure neighborhood trust score computation for time synchronization. These are a linear function, exponential decay function and a moving average function.

4.1.1 Linear Function

A simple linear function can be used to compute the trust score based on offset and delay values

Li(tk+1)=aLi(tk)+bΔTij(tk)+cDij(tk)(13)

where a, b and c are coefficients that can be adjusted to assign different weights to offset and delay.

4.1.2 Exponential Decay Function

An exponential decay function can be used to give more weight to recent offset and delay values while considering historical behavior

Li(tk+1)=αLi(tk)+βexp⁡[−γ(ΔTij(tk)2+Dij(tk)2)](14)

where α, β and γ are tuning parameters, and the exponential term captures the influence of the current offset and delay while the previous trust score contributes through α.

4.1.3 Moving Average Function

A moving average function can be employed to compute the trust score based on the average offset and delay over a certain window of time

Li(tk+1)=σLi(tk)+(1−σ)(ΔT¯ij+D¯ij)(15)

where σ is a smoothing factor, and ΔT¯ij and D¯ij represent the average offset and delay values over a specified window of time.

4.2 Malicious Node Detection

Detecting malicious nodes is vital for maintaining the integrity of time synchronization. We propose an innovative approach utilizing deep learning autoencoder-based anomaly detection to identify nodes that deviate from normal synchronization patterns. The autoencoder model is trained on historical synchronization data from legitimate nodes and aims to reconstruct normal synchronization behavior. Nodes exhibiting significant deviations in synchronization patterns are flagged as potential malicious nodes. Compared to other algorithms, autoencoders often prove more effective at anomaly identification due to the fact they can:

1.   Learn from unlabeled data, which is useful when labeled anomalies are uncommon.

2.   Identify non-linear correlations and complicated patterns in data.

3.   Adapt to various domains and data types.

4.   Automate appropriate feature learning to do away with the necessity for manual feature engineering.

5.   Make use of transfer learning when pre-trained models are available.

Let Xj(tk) represent the synchronization features observed for node j at time t by node i. The encoder system model, Fenc maps the input Xj(tk) to a lower-dimensional representation Zj(tk), and the decoder attempts to reconstruct the input from this representation using its system model, Fdec. Anomalies are detected by comparing the reconstruction error Ej(tk) with a predefined threshold τ. Mathematically, the autoencoder-based anomaly detection process can be described as follows:

Encoder: Zj(tk)=Fenc[Xj(tk)]Decoder: Xj′(tk)=Fdec[Zj(tk)]Reconstruction Error: Ej(tk)=‖Xj(tk)−Xj′(tk)‖2

If Ej(tk)>τ, node j is considered to be a Sybil malicious attacker on node i. At each resynchronization period, node i accept packets from only non-anomalous nodes of set 𝒩i′⊂𝒩i and updates its clock parameters using the clock values from these nodes.

4.3 Adaptive Clock Update Using Normalized LMS Algorithm

Adaptive clock rate updates are essential for achieving accurate time synchronization. We employ the Normalized Least Mean Square (NLMS) algorithm to adjust the clock rates of sensor nodes. Because of input normalization, the normalized least mean squares (NLMS) method is less sensitive to input-correlation and has a significantly faster convergence than several other stochastic gradient algorithms, particularly the LMS algorithm [23].

Let, Ri(tk) be the clock rate adjustment and Ctarget(tk) be the target logical clock value for node i at time t. The NLMS-based adaptive clock update can be expressed as:

Ri(tk+1)=Ri(tk)+μTi(tk)‖Ti(tk)‖2+η[Ctarget(tk)−Ci(tk)](16)

where μ is a positive step-size and η is a small positive parameter.

The ultimate aim of our protocol is to synchronize each node’s clock rate to that of the gateway, but node i might not be a neighbor of the gateway node and hence the expression of Ctarget will differ depending on the neighbor(s), j∈𝒩i of node i. Therefore we can express Ctarget(tk) as:

Ctarget(tk)={Tg(tk)j=g and Ni′=1Cj(tk)j≠g and Ni′=1∑j∈Ni′Cj(tk)|Ni′|g∉𝒩i, and |𝒩i|>1∑j∈Ni′Cj(tk) + Tg(tk)|Ni′|g∈𝒩i′, and |𝒩i|>1(17)

where μ is the adaptation step size, and η is a small positive constant to prevent division by zero. The NLMS algorithm adjusts the clock rate Ri(tk) proportionally to the difference between the target clock value and the current clock value, with a weight that depends on the observed synchronization features Xi(tk).

4.4 Dynamic Weighted Time Synchronization

Achieving optimal synchronization across all nodes can be resource-intensive. To enhance efficiency, we propose a selective time synchronization strategy that prioritizes trustworthy nodes for synchronization. The strategy involves the following steps:

1.   Trust Score-Based Ranking: Nodes are ranked based on their trust scores. Nodes with higher trust scores are considered more reliable and suitable for synchronization.

2.   Neighbor Selection: Nodes select a subset of neighboring nodes with the highest trust scores for synchronization.

3.   Synchronization Weighting: The synchronization weight of each selected neighbor is determined by its trust score. Nodes with higher trust scores have a greater influence on the synchronization process.

Mathematically, the synchronization weight wij between nodes i and j at time t can be calculated as:

wij(tk)=Lj(tk)∑k∈𝒩iLk(tk)(18)

Computing wij is 𝒪(𝒩i) in the number of neighbors, requiring only two arithmetic operations per neighbor, and takes under 10 ms on a 32 MHz Cortex-M4 for 𝒩i=20.

Where Lj(tk) is the trust score of node j at time t, and 𝒩i is the set of neighboring nodes of node i with synchronization error eij(tk) given by:

eij(tk)=Cj(tk)−Ci(tk)(19)

Using the computed clock rate Ri(tk) and synchronization neighborhood trust weight, wij(tk), node i updates its logical clock, Ci(tk+1) expressed as:

Ci(tk+1)=Ci(tk)+∑j∈𝒩i′wij(tk)(Ri(tk)eij(tk)+Dij(tk))(20)

The synchronization weight wij(tk) shows the influence of node j on node i during synchronization while taking nearby node trust scores into account. Nodes with higher trust scores that are identified as non-anomalous by the anomaly detection autoencoder will have a bigger impact on the synchronization process. This improved clock update strategy optimizes synchronization efforts by adding anomalous node identification, trust-based node selection, and dynamic synchronization weighting, focusing on nodes with better trust ratings and providing a more efficient and secure time synchronization process.

5  Convergence Analysis of Proposed Synchronization Framework

In a WSN, various factors can contribute to clock drifts and desynchronization among nodes. Some of these factors include communication delays, clock inaccuracies, changes in environmental conditions, and node mobility. As a result, the clock synchronization error between two nodes, eij(tk) given by (19), may not necessarily converge to a fixed point. The main objective of a protocol is therefore to achieve bounded synchronization errors and ensure that the error remains within an acceptable range [21]. While additional stochastic effects, e.g., temporary link failures, and bursty traffic could be modeled, they do not fundamentally alter the protocol’s operation. Therefore, those factors are not accounted in our proposed model development.

In practical WSNs, achieving exact global synchronization may be challenging due to the dynamic nature of the environment and the presence of various sources of uncertainty [24]. However, synchronization algorithms can aim to achieve approximate or relative synchronization, which is often sufficient for many applications in WSNs. Since the clock dynamics of the gateway node g is different from that of normal WSN nodes, we analyze the pairwise synchronization convergence for an arbitrary node i to its neighbor j and to node g separately.

5.1 Pairwise Time Synchronization to Gateway Node

Achieving pairwise synchronization to a gateway node is crucial for establishing a global reference and facilitating network-wide coordination. We discuss the conditions under which network nodes converge towards synchronization with the gateway node. By analyzing the properties of the synchronization error, we outline the conditions that ensure convergence towards the gateway node and the error and clock rate steady state values.

5.1.1 Conditions for Convergence

Applying Normalized LMS algorithm for the update of the logical clock rate of node i, we have

Ri(tk+1)=Ri(tk)−μ[ηI+H(tk)]−1g(tk)(21)

where g(tk)=∂J(Ri)∂Ri and H(tk)=∂g(Ri)∂Ri.

For simplicity, let e(tk) be the synchronization error between clock values of i and g at time t. To optimize the clock rate update algorithm, we use the cost function J, which we define to be the square the error, defined as:

J(tk)=e2(tk)(22)

Assuming node i is in communication range of the gateway node, g, i.e., g|ℰi,g∈ℰ and there is a transmission delay of Dig(tk) between i and g, then at time t, node i receives Tg=kR(tk)+Dig(tk) and therefore

e(tk)=Ci(tk)−kR(tk)−Dig(tk)=Ri(tk)Ti(tk)−kR(tk)−Dig(tk)(23)

In [1], using the central limit theorem, Dig(tk) is modeled as a zero-mean Gaussian distributed random variable with variance, σDig2.

Assuming η=0 and using (21), we derive g(tk) and H(tk) respectively as:

g(tk)=2e(tk)×∂e(Ri)∂Ri=2e(tk)Ti(tk)i(tk) and;H(tk)=2τi(tk)×∂e(Ri)∂Ri=2Ti2(tk)

Since

∂e(Ri)∂Ri=∂∂Ri[Ri(tk)Ti(tk)−kR(tk)−Dig(tk)]=Ti(tk)

Since H(tk) is in the scalar form we write [H(tk)]−1=12Ti(tk)2).

Hence the update equation in (15) can be rewritten as:

Ri(tk+1)=Ri(tk)−μe(tk)η+Ti(tk)(24)

Since continuous access of Ti(tk) might over-complicate the synchronization algorithm, we approximate it with its mean value, i.e.,

Ti(tk)≃E[Ti(tk)]

And from the definition of the hardware clock model given by (1), Ti(tk)=∫tkf(φ)dφ and hence we can write

Ti(tk)≃Ti(t0)+E[∫fi(φ)dφ]=Ti(t0)+∫t0tE[fi(φ)]dφ(25)

But,

E[fi(tk)]=f^−fmax+f^+fmax2=f^

Ti(tk)≃Ti(t0)+f^∫tkdφ=Ti(t0)+R¯f^(26)

where R¯=E[R(tk)] is the average ticking rate of the gateway node. Therefore the synchronization clock update rule can be simplified as follows:

Ci(tk+1)=Ci(tk)+e(tk)=kR(tk)+Dig(tk),(27)

and the logical clock rate update as follows:

Ri(tk+1)=Ri(tk)−μe(tk)η+Ti(t0)+R¯f^(28)

Theorem 1. The update of the logical clock rate, Ri of a node i∈𝒱,(i,G)∈ℰ with initial clock value, Ti(t0) using the normalized least mean-square (LMS) algorithm of the form (28) to synchronize to a gateway node g with ticking rate, R¯ will converge in the ℒ1 mean-sense to an asymptotically stable point if and only if the step size μ must be chosen based on the inequality

0<μ<2(η+Ti(t0)R¯f^+1)(29)

where η is a small positive value.

Proof of Theorem 1. Based on the update equations, (27) and (28), we can define e(tk+1) and Ri(tk+1) as:

e(tk+1)=Ri(tk)Ti(tk)−R¯+Dig(tk+1)−Dij(tk)Ri(tk+1)=Ri(tk)−μη+Ti(t0)+R¯f^[Ri(tk)Ti(tk)−R¯+Dij(tk+1)−Dij(tk)](30)

Ri(tk+1)=Ri(tk)(1−μη+Ti(t0)+R¯f^Ti(tk))−μη+Ti(t0)+R¯f^(R¯+Dij(tk+1)−Dij(tk))(31)

We can combine (30) and (31) into a state representation given by (32).

[e(tk+1)Ri(tk+1)]=[0Ti(tk)01−μη+Ti(t0)+R¯f^Ti(tk)][e(tk)Ri(tk)]+(R¯+Dij(tk+1)−Dij(tk))[−1μη+Ti(t0)+R¯f^](32)

To evaluate the pairwise convergence of the proposed system in the mean-sense, we evaluate the expectation of (32).

[E[e(tk+1)]E[Ri(tk+1)]]=[0R¯f^01−μR¯f^η+Ti(t0)+R¯f^][E[e(tk)]E[Ri(tk)]]+[−R¯μη+Ti(t0)+R¯f^](33)

From (33) we obtain the eigenvalues the coefficient matrix as:

[λ1,λ2]=[0,1−μR¯f^η+Ti(t0)+R¯f^]

Therefore, a necessary and sufficient condition for asymptotic convergence in the mean-sense is if 0<μ<2(η+Ti(t0)R¯f^+1). □

5.1.2 Asymptotic Clock Frequency and Synchronization Error

Analyzing the behavior of clock frequency and synchronization error over time provides valuable insights into the long-term dynamics of the synchronization process. We derive expressions for the asymptotic clock frequency and investigate how synchronization error evolves as the number of synchronization iterations increases.

Theorem 2. The evolving pairwise synchronization error, e(tk) and the clock rate, Ri(tk) for node i synchronizing to the clock of a perfectly ticking gateway node, g converge in the mean-sense to the steady state values e(∞)=0 and Ri(∞)=1f^ if it satisfies the linear Eq. (32).

Proof of Theorem 2. The asymptotic error and clock rate variables can be written as:

limk→∞E[e(tk)]=e(∞) andlimt→∞E[Ri(tk)]=Ri(∞)

From Eq. (33), we can write the respective steady state equations of e(tk)andRi(tk) as:

Ri(∞)=(1−μR¯f^η+Ti(t0)+R¯f^)Ri(∞)+μR¯η+Ti(t0)+R¯f^Ri(∞)=1f^ ande(∞)=R¯f^Ri(∞)−R¯⟹e(∞)=0

We therefore conclude from the above analysis that, the synchronization error, ei of a node i synchronizing to the gateway node g, converges to zero and its logical clock rate, Ri converges to the nominal oscillation period, 1f^. □

5.1.3 Asymptotic Error Variance

When a control system achieves zero steady-state error, it means the regulated output precisely follows the desired value and there is no variation over time between the actual output and the target value. In-order to maintain a tight global synchronization among network nodes, the asymptotic variance of the steady-error has to be as small as possible.

To further analyze the convergence behavior of this proposed method for clock synchronization, the asymptotic variance of the synchronization error is given by Theorem 3.

Theorem 3. The asymptotic variance in synchronization error, Var[e(∞)] of a node i∈𝒱,(i,G)∈ℰ with initial hardware clock value, Ti(t0) using the normalized least mean-square (LMS) algorithm of the form (28) to synchronize to a gateway node g with ticking rate, R¯ is given by:

Var[e(∞)]=(R¯2+R¯fmax22f^)(μ2fmax+2μf^2σD22−4μ−2μ2R¯f^2+2μ2fmax2)+R¯fmax2f2+σD2(34)

Proof of Theorem 3. Let dtk+1=Dij(tk+1)−Dij(tk), ztk=Ri(tk)f^−1 and wtk+1=∫tkf(φ)dφ

Ti(tk)−Ti(t0)=R¯f^+wtk+1(35)

where wtk+1 has statistics E[wtk+1]=0 and E[wtk+12]=R¯f^.

Based on these definitions, we can rewrite the error and clock rate recursion equations respectively as:

e(tk+1)=ztk(R¯+wtk+1f^)+wtk+1f^−dtk+1

and

Ri(tk+1)=ztk+1f^−μR¯f^(ztk[R¯+wtk+1f^]+wtk+1f^−dtk+1)

Let gtk+1=R¯f^+wtk+1 with mean, E[gtk+1]=R¯f^ and second moment, E[gtk+12]=R¯2f^2+R¯f^max23

ztk+1=ztk(1−μR¯f^gtk+1)−μR¯f^gtk+1+μ+μR¯dtk+1

E[ztk+1]=E[ztk](1−μ)⟹E[z∞]=0(36)

ztk+12=zt2(1−μR¯f^gtk+1)2+(−μR¯f^gtk+1+μ+μR¯dtk+1)2+ztk(1−μR¯f^gtk+1)(−μR¯f^gtk+1+μ+μR¯dtk+1)

Taking expectation of both sides, we get

E[ztk+12]=E[zk2](μ2[1+fmax23R¯f^2]−2μ)+μfmax3R¯f^2+μσD2R¯2(37)

Since E[e(∞)]=R¯E[z∞]=0, it follows that, Var[e(∞)]=E[e2(∞)] and E[e2(∞)] can be expressed in terms of E[z2(∞)] as:

E[e2(∞)]=E[zk2](R¯2+E[wtk+12]f^)+E[wtk+12]f2+E[dtk+12]

Using straight-forward steps, the asymptotic variance of the error can be given as:

Var[e(∞)]=(R¯2+R¯fmax22f^)(μ2fmax+2μf^2σD22−4μ−2μ2R¯f^2+2μ2fmax2)+R¯fmax2f2+σD2(38)

□

5.2 Pairwise Clock Synchronization of Neighboring Nodes

Pairwise clock synchronization among neighboring nodes is a fundamental to achieving accurate time synchronization in WSNs. Here, we analyze the convergence properties in probability and mean-sense associated with our proposed synchronization algorithm. Each node evaluates its neighbors’ synchronization patterns based on:

1.   historical synchronization accuracy (i.e., how closely a node’s clock aligns with its trusted neighbors).

2.   deviation from expected timestamps (i.e., identifying outliers in time updates).

3.   communication reliability metrics (e.g., packet loss and response delays).

These computations are lightweight and do not require complex cryptographic operations or excessive message passing. Ideal pairwise synchronization between node i and node j, means the error eij(tk) evolves towards zero with time which is expressed mathematically as:

limt→∞eij(tk)=0(39)

5.2.1 Mean Sense Error Convergence

To prove the expression in (39) for any synchronization algorithm means perfect synchronization among WSN nodes or sure-convergence of synchronization error which is impossible given the dynamics of WSNs. Instead we will show that, our proposed framework for synchronization achieves synchronization within acceptable error margins using mean-sense convergence

Definition 1. (ℒp Convergence in Mean-Sense) A sequence of ℱ-measurable random variables x(n):n∈N is said to converge to an ℱ-measurable random variable x in ℒp sense if for some p≥1,

limn→∞E[|x(n)−x|p]=0

Based on Definition 1, and taking p=2, we want to show that as time t approaches infinity, the mean-square synchronization error between nodes i and j converges to zero:

limn→∞E[eij2(tk)]=0(40)

Theorem 4. In a WSN represented by a unidirected graph, 𝒢=(𝒱,ℰ), the asymptotic mean-square pairwise synchronization error, eij(∞) for a node i:(vi,ℰi)⊂𝒢, with neighbor j is zero if

Rj(tk)−Ri(tk)+Dji(tk)−Dij(tk)<1

where Ri(tk) and Dij(tk) are the clock rate of node i and transmission delays between i and j at time t.

Proof of Theorem 4. We start by assuming that at time t=0, the synchronization error eij(t0) is bounded and has finite variance, i.e.,

E[eij2(t0)]<∞

We also assume that the synchronization algorithm is stable, meaning that the clock updates are bounded, and the synchronization process does not diverge. For pairwise synchronization, 𝒩′=1 and assuming nodes i and j are trusted neighbors, i.e., wij(tk)=1, then the clock updates for nodes i and j are given respectively by:

Ci(tk+1)=Ci(tk)+Ri(tk)eij(tk)+Dij(tk), and(41)

Cj(tk+1)=Cj(tk)+Rj(tk)eji(tk)+Dji(tk)(42)

Let the clock rate and delay differences between nodes i and j be denoted as kr and kd, respectively, and given by:

kr=Rj(tk)−Ri(tk)(43)

kd=Dji(tk)−Dij(tk)(44)

Assuming eij(tk)=eji(tk), we can express the evolution of the synchronization error as:

eij(tk+1)=eij(tk)+eij(tk)[kr+kd](45)

Consider the difference in synchronization error between two consecutive time steps:

eij(tk+1)−eij(tk)=eij(tk)[kr+kd]

Assuming, kr and kd are constants, we can rewrite the difference in synchronization error as:

eij(tk+1)−eij(tk)=(kr+kd)⋅eij(tk)(46)

This is a discrete-time linear system, and its stability depends on (kr+kd). If (kr+kd)<1, the synchronization error converges to zero.

Now consider the mean-square synchronization error change:

E[(eij(tk+1)−eij(tk))2]=(kr+kd)2⋅E[eij2(tk)](47)

We know that (kr+kd)2<1 (since (kr+kd)<1 for convergence), so the mean-square error decreases with time, i.e.,

(kr+kd)2⋅E[eij2(tk)]<E[eij2(tk)](48)

Hence we can conclude that our algorithm achieves zero asymptotic error variance between two neighboring nodes i and j.

limn→∞E[eij2(tk)]=0(49)

□

5.2.2 Convergence Time

A theoretical convergence time Tconv provides an estimate of how long it takes for the clock rate Ri(tk) and Rj(tk) to approach the same nominal clock rate, R¯ or for the clock rate synchronization error ϵij(tk)=Rj(tk)−Ri(tk) to approach within a threshold ξ. The derivation of a closed-form expression of the convergence time Tconv will help us to understand the dynamics of the synchronization process and provides insight into optimizing parameters such as step size μ to achieve faster and more accurate synchronization.

Theorem 5. In a WSN represented by a unidirected graph, 𝒢=(𝒱,ℰ), the convergence time Tconv of the clock rate synchronization error ϵij(tk) of node i:(vi,ℰi)⊂𝒢, using the normalized least mean-square (LMS) algorithm of the form (28) to synchronize to its neighbor j to an error threshold ξ can be expressed as:

Tconv≈h¯⋅(ln⁡|ϵij(t0)|−ln⁡(ξ))μ⋅ΔT¯ij, ϵij(tk)>ξ(50)

where:

h¯=η2+η(T¯i+T¯j)+T¯iT¯j

ϵij(tk)=Rj(tk)−Ri(tk)

ΔTij(tk)=Tj(tk)−Ti(tk)

t0 is start time for the synchronization process

η is a small positive value

Proof of Theorem 5. Using the clock rate Eq. (28), we can express the clock rate synchronization error as an update equation given by:

ϵij(tk+1)=ϵij(tk)−μϵij(tk)ΔTij(tk)htk(51)

where ΔTij(tk)=Tj(tk)−Ti(tk) and htk=η2+η(Tj(tk)+Ti(tk))+Tj(tk)Ti(tk)

We can express ϵij(tk) recursively in terms of the initial error, ϵij(t0) as:

ϵij(tk)=ϵij(t0)∏l=0tk−1(1−μΔTij(l)hl)(52)

For convergence, we want the synchronization error ϵij(tk) to be within some threshold ξ, i.e.,

|ϵij(tk)|>ξ

Our main goal is to find the convergence time, Tconv such that |ϵij(tk)|<ξ and therefore we can write:

|ϵij(Tconv)|=ξ

Using the expression for ϵij(tk), we can write

ξ=ϵij(t0)|∏l=0Tconv−1(1−μΔTij(l)hl)|(53)

Taking natural logarithms of both sides:

ln⁡(ξ)=ln⁡|ϵij(t0)∏l=0Tconv−1(1−μΔTij(l)hl)|(54)

ln⁡(ξ)=ln⁡|ϵij(t0)|+∑l=0Tconv−1ln⁡|1−μΔTij(l)hl|(55)

Now, assuming that μΔTij(tk)ht is small, we can use the logarithmic property ln⁡(1+x)≈x. Using this approximation, we can write:

ln⁡(ξ)≈ln⁡|ϵij(t0)|−∑l=0Tconv−1μΔTij(l)hl(56)

Rearranging, we have:

1≈ln⁡(ξ)−ln⁡|ϵij(t0)|μ∑k=0Tconv−1ΔTij(k)hk(57)

Assuming we approximate Ti(tk) and Tj(tk) with their respective averages T¯i and T¯j, then ΔT¯ij=T¯j−T¯i and h¯=η2+η(T¯i+T¯j)+T¯iT¯j then,

1≈ln⁡|ϵij(t0)|−ln⁡(ξ)μ⋅Tconv⋅ΔT¯ijh¯

Hence the approximate convergence time, Tconv is:

Tconv≈h¯⋅(ln⁡|ϵij(t0)|−ln⁡(ξ))μ⋅ΔT¯ij(58)

which can also be given as,

Tconv≈(η2+η(T¯i+T¯j)+T¯iT¯j)⋅(ln⁡|ϵij(t0)|−ln⁡(ξ))μ⋅(T¯j−T¯i)(59)